diff --git a/dist/main.cjs b/dist/main.cjs new file mode 100644 index 0000000..c1b3622 --- /dev/null +++ b/dist/main.cjs @@ -0,0 +1,39939 @@ +"use strict"; +Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" }); +const viem = require("viem"); +const tryCatch$1 = require("./try-catch-CAXuSatr.cjs"); +var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {}; +function getAugmentedNamespace(n) { + if (Object.prototype.hasOwnProperty.call(n, "__esModule")) return n; + var f = n.default; + if (typeof f == "function") { + var a = function a2() { + var isInstance = false; + try { + isInstance = this instanceof a2; + } catch { + } + if (isInstance) { + return Reflect.construct(f, arguments, this.constructor); + } + return f.apply(this, arguments); + }; + a.prototype = f.prototype; + } else a = {}; + Object.defineProperty(a, "__esModule", { value: true }); + Object.keys(n).forEach(function(k) { + var d = Object.getOwnPropertyDescriptor(n, k); + Object.defineProperty(a, k, d.get ? d : { + enumerable: true, + get: function() { + return n[k]; + } + }); + }); + return a; +} +function getDefaultExportFromCjs(x) { + return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x; +} +var browser$d = { exports: {} }; +var process = browser$d.exports = {}; +var cachedSetTimeout; +var cachedClearTimeout; +function defaultSetTimout() { + throw new Error("setTimeout has not been defined"); +} +function defaultClearTimeout() { + throw new Error("clearTimeout has not been defined"); +} +(function() { + try { + if (typeof setTimeout === "function") { + cachedSetTimeout = setTimeout; + } else { + cachedSetTimeout = defaultSetTimout; + } + } catch (e) { + cachedSetTimeout = defaultSetTimout; + } + try { + if (typeof clearTimeout === "function") { + cachedClearTimeout = clearTimeout; + } else { + cachedClearTimeout = defaultClearTimeout; + } + } catch (e) { + cachedClearTimeout = defaultClearTimeout; + } +})(); +function runTimeout(fun) { + if (cachedSetTimeout === setTimeout) { + return setTimeout(fun, 0); + } + if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) { + cachedSetTimeout = setTimeout; + return setTimeout(fun, 0); + } + try { + return cachedSetTimeout(fun, 0); + } catch (e) { + try { + return cachedSetTimeout.call(null, fun, 0); + } catch (e2) { + return cachedSetTimeout.call(this, fun, 0); + } + } +} +function runClearTimeout(marker) { + if (cachedClearTimeout === clearTimeout) { + return clearTimeout(marker); + } + if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) { + cachedClearTimeout = clearTimeout; + return clearTimeout(marker); + } + try { + return cachedClearTimeout(marker); + } catch (e) { + try { + return cachedClearTimeout.call(null, marker); + } catch (e2) { + return cachedClearTimeout.call(this, marker); + } + } +} +var queue = []; +var draining = false; +var currentQueue; +var queueIndex = -1; +function cleanUpNextTick() { + if (!draining || !currentQueue) { + return; + } + draining = false; + if (currentQueue.length) { + queue = currentQueue.concat(queue); + } else { + queueIndex = -1; + } + if (queue.length) { + drainQueue(); + } +} +function drainQueue() { + if (draining) { + return; + } + var timeout = runTimeout(cleanUpNextTick); + draining = true; + var len2 = queue.length; + while (len2) { + currentQueue = queue; + queue = []; + while (++queueIndex < len2) { + if (currentQueue) { + currentQueue[queueIndex].run(); + } + } + queueIndex = -1; + len2 = queue.length; + } + currentQueue = null; + draining = false; + runClearTimeout(timeout); +} +process.nextTick = function(fun) { + var args = new Array(arguments.length - 1); + if (arguments.length > 1) { + for (var i2 = 1; i2 < arguments.length; i2++) { + args[i2 - 1] = arguments[i2]; + } + } + queue.push(new Item(fun, args)); + if (queue.length === 1 && !draining) { + runTimeout(drainQueue); + } +}; +function Item(fun, array) { + this.fun = fun; + this.array = array; +} +Item.prototype.run = function() { + this.fun.apply(null, this.array); +}; +process.title = "browser"; +process.browser = true; +process.env = {}; +process.argv = []; +process.version = ""; +process.versions = {}; +function noop() { +} +process.on = noop; +process.addListener = noop; +process.once = noop; +process.off = noop; +process.removeListener = noop; +process.removeAllListeners = noop; +process.emit = noop; +process.prependListener = noop; +process.prependOnceListener = noop; +process.listeners = function(name) { + return []; +}; +process.binding = function(name) { + throw new Error("process.binding is not supported"); +}; +process.cwd = function() { + return "/"; +}; +process.chdir = function(dir) { + throw new Error("process.chdir is not supported"); +}; +process.umask = function() { + return 0; +}; +var browserExports = browser$d.exports; +const process$1 = /* @__PURE__ */ getDefaultExportFromCjs(browserExports); +var config = {}; +var buffer$1 = {}; +var base64Js = {}; +base64Js.byteLength = byteLength; +base64Js.toByteArray = toByteArray; +base64Js.fromByteArray = fromByteArray; +var lookup = []; +var revLookup = []; +var Arr = typeof Uint8Array !== "undefined" ? Uint8Array : Array; +var code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; +for (var i = 0, len = code.length; i < len; ++i) { + lookup[i] = code[i]; + revLookup[code.charCodeAt(i)] = i; +} +revLookup["-".charCodeAt(0)] = 62; +revLookup["_".charCodeAt(0)] = 63; +function getLens(b64) { + var len2 = b64.length; + if (len2 % 4 > 0) { + throw new Error("Invalid string. Length must be a multiple of 4"); + } + var validLen = b64.indexOf("="); + if (validLen === -1) validLen = len2; + var placeHoldersLen = validLen === len2 ? 0 : 4 - validLen % 4; + return [validLen, placeHoldersLen]; +} +function byteLength(b64) { + var lens = getLens(b64); + var validLen = lens[0]; + var placeHoldersLen = lens[1]; + return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen; +} +function _byteLength(b64, validLen, placeHoldersLen) { + return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen; +} +function toByteArray(b64) { + var tmp; + var lens = getLens(b64); + var validLen = lens[0]; + var placeHoldersLen = lens[1]; + var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen)); + var curByte = 0; + var len2 = placeHoldersLen > 0 ? validLen - 4 : validLen; + var 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; + var 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; + var len2 = uint8.length; + var extraBytes = len2 % 3; + var parts = []; + var 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(""); +} +var ieee754 = {}; +/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh */ +ieee754.read = function(buffer2, offset, isLE, mLen, nBytes) { + var e, m; + var eLen = nBytes * 8 - mLen - 1; + var eMax = (1 << eLen) - 1; + var eBias = eMax >> 1; + var nBits = -7; + var i2 = isLE ? nBytes - 1 : 0; + var d = isLE ? -1 : 1; + var s = buffer2[offset + i2]; + i2 += d; + e = s & (1 << -nBits) - 1; + s >>= -nBits; + nBits += eLen; + for (; nBits > 0; e = e * 256 + buffer2[offset + i2], i2 += d, nBits -= 8) { + } + m = e & (1 << -nBits) - 1; + e >>= -nBits; + nBits += mLen; + for (; nBits > 0; m = m * 256 + buffer2[offset + i2], i2 += d, nBits -= 8) { + } + if (e === 0) { + e = 1 - eBias; + } else if (e === eMax) { + return m ? NaN : (s ? -1 : 1) * Infinity; + } else { + m = m + Math.pow(2, mLen); + e = e - eBias; + } + return (s ? -1 : 1) * m * Math.pow(2, e - mLen); +}; +ieee754.write = function(buffer2, value, offset, isLE, mLen, nBytes) { + var e, m, c; + var eLen = nBytes * 8 - mLen - 1; + var eMax = (1 << eLen) - 1; + var eBias = eMax >> 1; + var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0; + var i2 = isLE ? 0 : nBytes - 1; + var d = isLE ? 1 : -1; + var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0; + value = Math.abs(value); + if (isNaN(value) || value === Infinity) { + m = isNaN(value) ? 1 : 0; + e = eMax; + } else { + e = Math.floor(Math.log(value) / Math.LN2); + if (value * (c = Math.pow(2, -e)) < 1) { + e--; + c *= 2; + } + if (e + eBias >= 1) { + value += rt / c; + } else { + value += rt * Math.pow(2, 1 - eBias); + } + if (value * c >= 2) { + e++; + c /= 2; + } + if (e + eBias >= eMax) { + m = 0; + e = eMax; + } else if (e + eBias >= 1) { + m = (value * c - 1) * Math.pow(2, mLen); + e = e + eBias; + } else { + m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen); + e = 0; + } + } + for (; mLen >= 8; buffer2[offset + i2] = m & 255, i2 += d, m /= 256, mLen -= 8) { + } + e = e << mLen | m; + eLen += mLen; + for (; eLen > 0; buffer2[offset + i2] = e & 255, i2 += d, e /= 256, eLen -= 8) { + } + buffer2[offset + i2 - d] |= s * 128; +}; +/*! + * The buffer module from node.js, for the browser. + * + * @author Feross Aboukhadijeh + * @license MIT + */ +(function(exports2) { + const base64 = base64Js; + const ieee754$1 = ieee754; + const customInspectSymbol = typeof Symbol === "function" && typeof Symbol["for"] === "function" ? Symbol["for"]("nodejs.util.inspect.custom") : null; + exports2.Buffer = Buffer2; + exports2.SlowBuffer = SlowBuffer; + exports2.INSPECT_MAX_BYTES = 50; + const K_MAX_LENGTH = 2147483647; + exports2.kMaxLength = K_MAX_LENGTH; + const { Uint8Array: GlobalUint8Array, ArrayBuffer: GlobalArrayBuffer, SharedArrayBuffer: GlobalSharedArrayBuffer } = globalThis; + Buffer2.TYPED_ARRAY_SUPPORT = typedArraySupport(); + if (!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 { + const arr = new GlobalUint8Array(1); + const proto = { foo: function() { + return 42; + } }; + Object.setPrototypeOf(proto, GlobalUint8Array.prototype); + Object.setPrototypeOf(arr, proto); + return arr.foo() === 42; + } catch (e) { + return false; + } + } + Object.defineProperty(Buffer2.prototype, "parent", { + enumerable: true, + get: function() { + if (!Buffer2.isBuffer(this)) return void 0; + return this.buffer; + } + }); + Object.defineProperty(Buffer2.prototype, "offset", { + enumerable: true, + get: function() { + if (!Buffer2.isBuffer(this)) return void 0; + return this.byteOffset; + } + }); + function createBuffer(length) { + if (length > K_MAX_LENGTH) { + throw new RangeError('The value "' + length + '" is invalid for option "size"'); + } + const buf = new GlobalUint8Array(length); + Object.setPrototypeOf(buf, Buffer2.prototype); + return 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 (GlobalArrayBuffer.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, GlobalArrayBuffer) || value && isInstance(value.buffer, GlobalArrayBuffer)) { + return fromArrayBuffer(value, encodingOrOffset, length); + } + if (typeof GlobalSharedArrayBuffer !== "undefined" && (isInstance(value, GlobalSharedArrayBuffer) || value && isInstance(value.buffer, GlobalSharedArrayBuffer))) { + return fromArrayBuffer(value, encodingOrOffset, length); + } + if (typeof value === "number") { + throw new TypeError( + 'The "value" argument must not be of type number. Received type number' + ); + } + const valueOf = value.valueOf && value.valueOf(); + if (valueOf != null && valueOf !== value) { + return Buffer2.from(valueOf, encodingOrOffset, length); + } + const 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, GlobalUint8Array.prototype); + Object.setPrototypeOf(Buffer2, GlobalUint8Array); + function assertSize(size) { + if (typeof size !== "number") { + throw new TypeError('"size" argument must be of type number'); + } else if (size < 0) { + throw new RangeError('The value "' + size + '" is invalid for option "size"'); + } + } + function alloc(size, fill, encoding) { + assertSize(size); + if (size <= 0) { + return createBuffer(size); + } + if (fill !== void 0) { + return typeof encoding === "string" ? createBuffer(size).fill(fill, encoding) : createBuffer(size).fill(fill); + } + return createBuffer(size); + } + Buffer2.alloc = function(size, fill, encoding) { + return alloc(size, fill, encoding); + }; + function allocUnsafe(size) { + assertSize(size); + return 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"; + } + if (!Buffer2.isEncoding(encoding)) { + throw new TypeError("Unknown encoding: " + encoding); + } + const length = byteLength2(string, encoding) | 0; + let buf = createBuffer(length); + const actual = buf.write(string, encoding); + if (actual !== length) { + buf = buf.slice(0, actual); + } + return buf; + } + function fromArrayLike(array) { + const length = array.length < 0 ? 0 : checked(array.length) | 0; + const buf = createBuffer(length); + for (let i2 = 0; i2 < length; i2 += 1) { + buf[i2] = array[i2] & 255; + } + return buf; + } + function fromArrayView(arrayView) { + if (isInstance(arrayView, GlobalUint8Array)) { + const copy = new GlobalUint8Array(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; + if (byteOffset === void 0 && length === void 0) { + buf = new GlobalUint8Array(array); + } else if (length === void 0) { + buf = new GlobalUint8Array(array, byteOffset); + } else { + buf = new GlobalUint8Array(array, byteOffset, length); + } + Object.setPrototypeOf(buf, Buffer2.prototype); + return buf; + } + function fromObject(obj) { + if (Buffer2.isBuffer(obj)) { + const len2 = checked(obj.length) | 0; + const buf = createBuffer(len2); + if (buf.length === 0) { + return buf; + } + obj.copy(buf, 0, 0, len2); + return buf; + } + if (obj.length !== void 0) { + if (typeof obj.length !== "number" || numberIsNaN(obj.length)) { + return createBuffer(0); + } + return fromArrayLike(obj); + } + if (obj.type === "Buffer" && Array.isArray(obj.data)) { + return fromArrayLike(obj.data); + } + } + function checked(length) { + if (length >= K_MAX_LENGTH) { + throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + K_MAX_LENGTH.toString(16) + " bytes"); + } + return length | 0; + } + function SlowBuffer(length) { + if (+length != length) { + length = 0; + } + return Buffer2.alloc(+length); + } + Buffer2.isBuffer = function isBuffer(b) { + return b != null && b._isBuffer === true && b !== Buffer2.prototype; + }; + Buffer2.compare = function compare(a, b) { + if (isInstance(a, GlobalUint8Array)) a = Buffer2.from(a, a.offset, a.byteLength); + if (isInstance(b, GlobalUint8Array)) b = Buffer2.from(b, b.offset, b.byteLength); + if (!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; + let 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 isEncoding(encoding) { + switch (String(encoding).toLowerCase()) { + case "hex": + case "utf8": + case "utf-8": + case "ascii": + case "latin1": + case "binary": + case "base64": + case "ucs2": + case "ucs-2": + case "utf16le": + case "utf-16le": + return true; + default: + return false; + } + }; + Buffer2.concat = function concat(list, length) { + if (!Array.isArray(list)) { + throw new TypeError('"list" argument must be an Array of Buffers'); + } + if (list.length === 0) { + return Buffer2.alloc(0); + } + let i2; + if (length === void 0) { + length = 0; + for (i2 = 0; i2 < list.length; ++i2) { + length += list[i2].length; + } + } + const buffer2 = Buffer2.allocUnsafe(length); + let pos = 0; + for (i2 = 0; i2 < list.length; ++i2) { + let buf = list[i2]; + if (isInstance(buf, GlobalUint8Array)) { + if (pos + buf.length > buffer2.length) { + if (!Buffer2.isBuffer(buf)) buf = Buffer2.from(buf); + buf.copy(buffer2, pos); + } else { + GlobalUint8Array.prototype.set.call( + buffer2, + buf, + pos + ); + } + } else if (!Buffer2.isBuffer(buf)) { + throw new TypeError('"list" argument must be an Array of Buffers'); + } else { + buf.copy(buffer2, pos); + } + pos += buf.length; + } + return buffer2; + }; + function byteLength2(string, encoding) { + if (Buffer2.isBuffer(string)) { + return string.length; + } + if (GlobalArrayBuffer.isView(string) || isInstance(string, GlobalArrayBuffer)) { + 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 + ); + } + const len2 = string.length; + const 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; + } + } + } + Buffer2.byteLength = byteLength2; + function slowToString(encoding, start, end) { + let loweredCase = false; + if (start === void 0 || start < 0) { + start = 0; + } + if (start > this.length) { + return ""; + } + if (end === void 0 || end > this.length) { + end = this.length; + } + if (end <= 0) { + return ""; + } + end >>>= 0; + start >>>= 0; + if (end <= start) { + return ""; + } + if (!encoding) encoding = "utf8"; + while (true) { + switch (encoding) { + case "hex": + return hexSlice(this, start, end); + case "utf8": + case "utf-8": + return utf8Slice(this, start, end); + case "ascii": + return asciiSlice(this, start, end); + case "latin1": + case "binary": + return latin1Slice(this, start, end); + case "base64": + return base64Slice(this, start, end); + case "ucs2": + case "ucs-2": + case "utf16le": + case "utf-16le": + return utf16leSlice(this, start, end); + default: + if (loweredCase) throw new TypeError("Unknown encoding: " + encoding); + encoding = (encoding + "").toLowerCase(); + loweredCase = true; + } + } + } + Buffer2.prototype._isBuffer = true; + function swap(b, n, m) { + const i2 = b[n]; + b[n] = b[m]; + b[m] = i2; + } + Buffer2.prototype.swap16 = function swap16() { + const len2 = this.length; + if (len2 % 2 !== 0) { + throw new 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 swap32() { + const len2 = this.length; + if (len2 % 4 !== 0) { + throw new 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 swap64() { + const len2 = this.length; + if (len2 % 8 !== 0) { + throw new 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 toString() { + const 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 equals(b) { + if (!Buffer2.isBuffer(b)) throw new TypeError("Argument must be a Buffer"); + if (this === b) return true; + return Buffer2.compare(this, b) === 0; + }; + Buffer2.prototype.inspect = function inspect2() { + let str = ""; + const max = exports2.INSPECT_MAX_BYTES; + str = this.toString("hex", 0, max).replace(/(.{2})/g, "$1 ").trim(); + if (this.length > max) str += " ... "; + return ""; + }; + if (customInspectSymbol) { + Buffer2.prototype[customInspectSymbol] = Buffer2.prototype.inspect; + } + Buffer2.prototype.compare = function compare(target, start, end, thisStart, thisEnd) { + if (isInstance(target, GlobalUint8Array)) { + target = Buffer2.from(target, target.offset, target.byteLength); + } + if (!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; + } + if (end === void 0) { + end = target ? target.length : 0; + } + if (thisStart === void 0) { + thisStart = 0; + } + if (thisEnd === void 0) { + thisEnd = this.length; + } + if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) { + throw new RangeError("out of range index"); + } + if (thisStart >= thisEnd && start >= end) { + return 0; + } + if (thisStart >= thisEnd) { + return -1; + } + if (start >= end) { + return 1; + } + start >>>= 0; + end >>>= 0; + thisStart >>>= 0; + thisEnd >>>= 0; + if (this === target) return 0; + let x = thisEnd - thisStart; + let y = end - start; + const len2 = Math.min(x, y); + const thisCopy = this.slice(thisStart, thisEnd); + const 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; + }; + function bidirectionalIndexOf(buffer2, val, byteOffset, encoding, dir) { + if (buffer2.length === 0) return -1; + if (typeof byteOffset === "string") { + encoding = byteOffset; + byteOffset = 0; + } else if (byteOffset > 2147483647) { + byteOffset = 2147483647; + } else if (byteOffset < -2147483648) { + byteOffset = -2147483648; + } + byteOffset = +byteOffset; + if (numberIsNaN(byteOffset)) { + byteOffset = dir ? 0 : buffer2.length - 1; + } + if (byteOffset < 0) byteOffset = buffer2.length + byteOffset; + if (byteOffset >= buffer2.length) { + if (dir) return -1; + else byteOffset = buffer2.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(buffer2, val, byteOffset, encoding, dir); + } else if (typeof val === "number") { + val = val & 255; + if (typeof GlobalUint8Array.prototype.indexOf === "function") { + if (dir) { + return GlobalUint8Array.prototype.indexOf.call(buffer2, val, byteOffset); + } else { + return GlobalUint8Array.prototype.lastIndexOf.call(buffer2, val, byteOffset); + } + } + return arrayIndexOf(buffer2, [val], byteOffset, encoding, dir); + } + throw new TypeError("val must be string, number or Buffer"); + } + function arrayIndexOf(arr, val, byteOffset, encoding, dir) { + let indexSize = 1; + let arrLength = arr.length; + let valLength = val.length; + if (encoding !== void 0) { + encoding = String(encoding).toLowerCase(); + if (encoding === "ucs2" || encoding === "ucs-2" || encoding === "utf16le" || encoding === "utf-16le") { + if (arr.length < 2 || val.length < 2) { + return -1; + } + indexSize = 2; + arrLength /= 2; + valLength /= 2; + byteOffset /= 2; + } + } + function read(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 (read(arr, i2) === read(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 (read(arr, i2 + j) !== read(val, j)) { + found = false; + break; + } + } + if (found) return i2; + } + } + return -1; + } + Buffer2.prototype.includes = function includes(val, byteOffset, encoding) { + return this.indexOf(val, byteOffset, encoding) !== -1; + }; + Buffer2.prototype.indexOf = function indexOf2(val, byteOffset, encoding) { + return bidirectionalIndexOf(this, val, byteOffset, encoding, true); + }; + Buffer2.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) { + return bidirectionalIndexOf(this, val, byteOffset, encoding, false); + }; + function hexWrite(buf, string, offset, length) { + offset = Number(offset) || 0; + const remaining = buf.length - offset; + if (!length) { + length = remaining; + } else { + length = Number(length); + if (length > remaining) { + length = remaining; + } + } + const strLen = string.length; + if (length > strLen / 2) { + length = strLen / 2; + } + let i2; + for (i2 = 0; i2 < length; ++i2) { + const parsed = parseInt(string.substr(i2 * 2, 2), 16); + if (numberIsNaN(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); + } + Buffer2.prototype.write = function write(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; + if (isFinite(length)) { + length = length >>> 0; + if (encoding === void 0) encoding = "utf8"; + } else { + encoding = length; + length = void 0; + } + } else { + throw new Error( + "Buffer.write(string, encoding, offset[, length]) is no longer supported" + ); + } + const remaining = this.length - offset; + if (length === void 0 || length > remaining) length = remaining; + if (string.length > 0 && (length < 0 || offset < 0) || offset > this.length) { + throw new RangeError("Attempt to write outside buffer bounds"); + } + if (!encoding) encoding = "utf8"; + 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 new TypeError("Unknown encoding: " + encoding); + encoding = ("" + encoding).toLowerCase(); + loweredCase = true; + } + } + }; + Buffer2.prototype.toJSON = function toJSON() { + return { + type: "Buffer", + data: Array.prototype.slice.call(this._arr || this, 0) + }; + }; + function base64Slice(buf, start, end) { + if (start === 0 && end === buf.length) { + return base64.fromByteArray(buf); + } else { + return base64.fromByteArray(buf.slice(start, end)); + } + } + function utf8Slice(buf, start, end) { + end = Math.min(buf.length, end); + const res = []; + let i2 = start; + while (i2 < end) { + const firstByte = buf[i2]; + let codePoint = null; + let 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: + secondByte = buf[i2 + 1]; + if ((secondByte & 192) === 128) { + tempCodePoint = (firstByte & 31) << 6 | secondByte & 63; + if (tempCodePoint > 127) { + codePoint = tempCodePoint; + } + } + break; + case 3: + secondByte = buf[i2 + 1]; + thirdByte = buf[i2 + 2]; + if ((secondByte & 192) === 128 && (thirdByte & 192) === 128) { + tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63; + if (tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343)) { + codePoint = tempCodePoint; + } + } + break; + case 4: + secondByte = buf[i2 + 1]; + thirdByte = buf[i2 + 2]; + fourthByte = buf[i2 + 3]; + if ((secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128) { + tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63; + if (tempCodePoint > 65535 && tempCodePoint < 1114112) { + codePoint = tempCodePoint; + } + } + } + } + if (codePoint === null) { + codePoint = 65533; + bytesPerSequence = 1; + } else if (codePoint > 65535) { + codePoint -= 65536; + res.push(codePoint >>> 10 & 1023 | 55296); + codePoint = 56320 | codePoint & 1023; + } + res.push(codePoint); + i2 += bytesPerSequence; + } + return decodeCodePointsArray(res); + } + const MAX_ARGUMENTS_LENGTH = 4096; + function decodeCodePointsArray(codePoints) { + const len2 = codePoints.length; + if (len2 <= MAX_ARGUMENTS_LENGTH) { + return String.fromCharCode.apply(String, codePoints); + } + let res = ""; + let 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) { + const 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) { + const bytes = buf.slice(start, end); + let res = ""; + for (let i2 = 0; i2 < bytes.length - 1; i2 += 2) { + res += String.fromCharCode(bytes[i2] + bytes[i2 + 1] * 256); + } + return res; + } + Buffer2.prototype.slice = function slice(start, end) { + const len2 = this.length; + start = ~~start; + end = end === void 0 ? len2 : ~~end; + if (start < 0) { + start += len2; + if (start < 0) start = 0; + } else if (start > len2) { + start = len2; + } + if (end < 0) { + end += len2; + if (end < 0) end = 0; + } else if (end > len2) { + end = len2; + } + if (end < start) end = start; + const newBuf = this.subarray(start, end); + Object.setPrototypeOf(newBuf, Buffer2.prototype); + return 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 readUIntLE(offset, byteLength3, noAssert) { + offset = offset >>> 0; + byteLength3 = byteLength3 >>> 0; + if (!noAssert) checkOffset(offset, byteLength3, this.length); + let val = this[offset]; + let mul = 1; + let i2 = 0; + while (++i2 < byteLength3 && (mul *= 256)) { + val += this[offset + i2] * mul; + } + return val; + }; + Buffer2.prototype.readUintBE = Buffer2.prototype.readUIntBE = function readUIntBE(offset, byteLength3, noAssert) { + offset = offset >>> 0; + byteLength3 = byteLength3 >>> 0; + if (!noAssert) { + checkOffset(offset, byteLength3, this.length); + } + let val = this[offset + --byteLength3]; + let mul = 1; + while (byteLength3 > 0 && (mul *= 256)) { + val += this[offset + --byteLength3] * mul; + } + return val; + }; + Buffer2.prototype.readUint8 = Buffer2.prototype.readUInt8 = function readUInt8(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) checkOffset(offset, 1, this.length); + return this[offset]; + }; + Buffer2.prototype.readUint16LE = Buffer2.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) checkOffset(offset, 2, this.length); + return this[offset] | this[offset + 1] << 8; + }; + Buffer2.prototype.readUint16BE = Buffer2.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) checkOffset(offset, 2, this.length); + return this[offset] << 8 | this[offset + 1]; + }; + Buffer2.prototype.readUint32LE = Buffer2.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) checkOffset(offset, 4, this.length); + return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 16777216; + }; + Buffer2.prototype.readUint32BE = Buffer2.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) checkOffset(offset, 4, this.length); + return this[offset] * 16777216 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]); + }; + Buffer2.prototype.readBigUInt64LE = defineBigIntMethod(function readBigUInt64LE(offset) { + offset = offset >>> 0; + validateNumber(offset, "offset"); + const first = this[offset]; + const last = this[offset + 7]; + if (first === void 0 || last === void 0) { + boundsError(offset, this.length - 8); + } + const lo = first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24; + const hi = this[++offset] + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + last * 2 ** 24; + return BigInt(lo) + (BigInt(hi) << BigInt(32)); + }); + Buffer2.prototype.readBigUInt64BE = defineBigIntMethod(function readBigUInt64BE(offset) { + offset = offset >>> 0; + validateNumber(offset, "offset"); + const first = this[offset]; + const last = this[offset + 7]; + if (first === void 0 || last === void 0) { + boundsError(offset, this.length - 8); + } + const hi = first * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset]; + const lo = this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last; + return (BigInt(hi) << BigInt(32)) + BigInt(lo); + }); + Buffer2.prototype.readIntLE = function readIntLE(offset, byteLength3, noAssert) { + offset = offset >>> 0; + byteLength3 = byteLength3 >>> 0; + if (!noAssert) checkOffset(offset, byteLength3, this.length); + let val = this[offset]; + let mul = 1; + let i2 = 0; + while (++i2 < byteLength3 && (mul *= 256)) { + val += this[offset + i2] * mul; + } + mul *= 128; + if (val >= mul) val -= Math.pow(2, 8 * byteLength3); + return val; + }; + Buffer2.prototype.readIntBE = function readIntBE(offset, byteLength3, noAssert) { + offset = offset >>> 0; + byteLength3 = byteLength3 >>> 0; + if (!noAssert) checkOffset(offset, byteLength3, this.length); + let i2 = byteLength3; + let mul = 1; + let val = this[offset + --i2]; + while (i2 > 0 && (mul *= 256)) { + val += this[offset + --i2] * mul; + } + mul *= 128; + if (val >= mul) val -= Math.pow(2, 8 * byteLength3); + return val; + }; + Buffer2.prototype.readInt8 = function readInt8(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) checkOffset(offset, 1, this.length); + if (!(this[offset] & 128)) return this[offset]; + return (255 - this[offset] + 1) * -1; + }; + Buffer2.prototype.readInt16LE = function readInt16LE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) checkOffset(offset, 2, this.length); + const val = this[offset] | this[offset + 1] << 8; + return val & 32768 ? val | 4294901760 : val; + }; + Buffer2.prototype.readInt16BE = function readInt16BE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) checkOffset(offset, 2, this.length); + const val = this[offset + 1] | this[offset] << 8; + return val & 32768 ? val | 4294901760 : val; + }; + Buffer2.prototype.readInt32LE = function readInt32LE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) checkOffset(offset, 4, this.length); + return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24; + }; + Buffer2.prototype.readInt32BE = function readInt32BE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) checkOffset(offset, 4, this.length); + return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]; + }; + Buffer2.prototype.readBigInt64LE = defineBigIntMethod(function readBigInt64LE(offset) { + offset = offset >>> 0; + validateNumber(offset, "offset"); + const first = this[offset]; + const last = this[offset + 7]; + if (first === void 0 || last === void 0) { + boundsError(offset, this.length - 8); + } + const val = this[offset + 4] + this[offset + 5] * 2 ** 8 + this[offset + 6] * 2 ** 16 + (last << 24); + return (BigInt(val) << BigInt(32)) + BigInt(first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24); + }); + Buffer2.prototype.readBigInt64BE = defineBigIntMethod(function readBigInt64BE(offset) { + offset = offset >>> 0; + validateNumber(offset, "offset"); + const first = this[offset]; + const last = this[offset + 7]; + if (first === void 0 || last === void 0) { + boundsError(offset, this.length - 8); + } + const val = (first << 24) + // Overflow + 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 readFloatLE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) checkOffset(offset, 4, this.length); + return ieee754$1.read(this, offset, true, 23, 4); + }; + Buffer2.prototype.readFloatBE = function readFloatBE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) checkOffset(offset, 4, this.length); + return ieee754$1.read(this, offset, false, 23, 4); + }; + Buffer2.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) checkOffset(offset, 8, this.length); + return ieee754$1.read(this, offset, true, 52, 8); + }; + Buffer2.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) checkOffset(offset, 8, this.length); + return ieee754$1.read(this, offset, false, 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 writeUIntLE(value, offset, byteLength3, noAssert) { + value = +value; + offset = offset >>> 0; + byteLength3 = byteLength3 >>> 0; + if (!noAssert) { + const maxBytes = Math.pow(2, 8 * byteLength3) - 1; + checkInt(this, value, offset, byteLength3, maxBytes, 0); + } + let mul = 1; + let i2 = 0; + this[offset] = value & 255; + while (++i2 < byteLength3 && (mul *= 256)) { + this[offset + i2] = value / mul & 255; + } + return offset + byteLength3; + }; + Buffer2.prototype.writeUintBE = Buffer2.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength3, noAssert) { + value = +value; + offset = offset >>> 0; + byteLength3 = byteLength3 >>> 0; + if (!noAssert) { + const maxBytes = Math.pow(2, 8 * byteLength3) - 1; + checkInt(this, value, offset, byteLength3, maxBytes, 0); + } + let i2 = byteLength3 - 1; + let mul = 1; + this[offset + i2] = value & 255; + while (--i2 >= 0 && (mul *= 256)) { + this[offset + i2] = value / mul & 255; + } + return offset + byteLength3; + }; + Buffer2.prototype.writeUint8 = Buffer2.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) checkInt(this, value, offset, 1, 255, 0); + this[offset] = value & 255; + return offset + 1; + }; + Buffer2.prototype.writeUint16LE = Buffer2.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) checkInt(this, value, offset, 2, 65535, 0); + this[offset] = value & 255; + this[offset + 1] = value >>> 8; + return offset + 2; + }; + Buffer2.prototype.writeUint16BE = Buffer2.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) checkInt(this, value, offset, 2, 65535, 0); + this[offset] = value >>> 8; + this[offset + 1] = value & 255; + return offset + 2; + }; + Buffer2.prototype.writeUint32LE = Buffer2.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0); + this[offset + 3] = value >>> 24; + this[offset + 2] = value >>> 16; + this[offset + 1] = value >>> 8; + this[offset] = value & 255; + return offset + 4; + }; + Buffer2.prototype.writeUint32BE = Buffer2.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0); + this[offset] = value >>> 24; + this[offset + 1] = value >>> 16; + this[offset + 2] = value >>> 8; + this[offset + 3] = value & 255; + return offset + 4; + }; + function wrtBigUInt64LE(buf, value, offset, min, max) { + checkIntBI(value, min, max, buf, offset, 7); + let lo = Number(value & BigInt(4294967295)); + buf[offset++] = lo; + lo = lo >> 8; + buf[offset++] = lo; + lo = lo >> 8; + buf[offset++] = lo; + lo = lo >> 8; + buf[offset++] = lo; + let hi = Number(value >> BigInt(32) & BigInt(4294967295)); + buf[offset++] = hi; + hi = hi >> 8; + buf[offset++] = hi; + hi = hi >> 8; + buf[offset++] = hi; + hi = hi >> 8; + buf[offset++] = hi; + return offset; + } + function wrtBigUInt64BE(buf, value, offset, min, max) { + checkIntBI(value, min, max, buf, offset, 7); + let lo = Number(value & BigInt(4294967295)); + buf[offset + 7] = lo; + lo = lo >> 8; + buf[offset + 6] = lo; + lo = lo >> 8; + buf[offset + 5] = lo; + lo = lo >> 8; + buf[offset + 4] = lo; + let hi = Number(value >> BigInt(32) & BigInt(4294967295)); + buf[offset + 3] = hi; + hi = hi >> 8; + buf[offset + 2] = hi; + hi = hi >> 8; + buf[offset + 1] = hi; + hi = hi >> 8; + buf[offset] = hi; + return offset + 8; + } + Buffer2.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE(value, offset = 0) { + return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff")); + }); + Buffer2.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE(value, offset = 0) { + return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff")); + }); + Buffer2.prototype.writeIntLE = function writeIntLE(value, offset, byteLength3, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) { + const limit = Math.pow(2, 8 * byteLength3 - 1); + checkInt(this, value, offset, byteLength3, limit - 1, -limit); + } + let i2 = 0; + let mul = 1; + let sub = 0; + this[offset] = value & 255; + while (++i2 < byteLength3 && (mul *= 256)) { + if (value < 0 && sub === 0 && this[offset + i2 - 1] !== 0) { + sub = 1; + } + this[offset + i2] = (value / mul >> 0) - sub & 255; + } + return offset + byteLength3; + }; + Buffer2.prototype.writeIntBE = function writeIntBE(value, offset, byteLength3, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) { + const limit = Math.pow(2, 8 * byteLength3 - 1); + checkInt(this, value, offset, byteLength3, limit - 1, -limit); + } + let i2 = byteLength3 - 1; + let mul = 1; + let sub = 0; + this[offset + i2] = value & 255; + while (--i2 >= 0 && (mul *= 256)) { + if (value < 0 && sub === 0 && this[offset + i2 + 1] !== 0) { + sub = 1; + } + this[offset + i2] = (value / mul >> 0) - sub & 255; + } + return offset + byteLength3; + }; + Buffer2.prototype.writeInt8 = function writeInt8(value, offset, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) checkInt(this, value, offset, 1, 127, -128); + if (value < 0) value = 255 + value + 1; + this[offset] = value & 255; + return offset + 1; + }; + Buffer2.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) checkInt(this, value, offset, 2, 32767, -32768); + this[offset] = value & 255; + this[offset + 1] = value >>> 8; + return offset + 2; + }; + Buffer2.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) checkInt(this, value, offset, 2, 32767, -32768); + this[offset] = value >>> 8; + this[offset + 1] = value & 255; + return offset + 2; + }; + Buffer2.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) checkInt(this, value, offset, 4, 2147483647, -2147483648); + this[offset] = value & 255; + this[offset + 1] = value >>> 8; + this[offset + 2] = value >>> 16; + this[offset + 3] = value >>> 24; + return offset + 4; + }; + Buffer2.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) checkInt(this, value, offset, 4, 2147483647, -2147483648); + if (value < 0) value = 4294967295 + value + 1; + this[offset] = value >>> 24; + this[offset + 1] = value >>> 16; + this[offset + 2] = value >>> 8; + this[offset + 3] = value & 255; + return offset + 4; + }; + Buffer2.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE(value, offset = 0) { + return wrtBigUInt64LE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff")); + }); + Buffer2.prototype.writeBigInt64BE = defineBigIntMethod(function writeBigInt64BE(value, offset = 0) { + return wrtBigUInt64BE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff")); + }); + function checkIEEE754(buf, value, offset, ext, max, min) { + if (offset + ext > buf.length) throw new RangeError("Index out of range"); + if (offset < 0) throw new RangeError("Index out of range"); + } + function writeFloat(buf, value, offset, littleEndian, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) { + checkIEEE754(buf, value, offset, 4); + } + ieee754$1.write(buf, value, offset, littleEndian, 23, 4); + return offset + 4; + } + Buffer2.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) { + return writeFloat(this, value, offset, true, noAssert); + }; + Buffer2.prototype.writeFloatBE = function writeFloatBE(value, offset, noAssert) { + return writeFloat(this, value, offset, false, noAssert); + }; + function writeDouble(buf, value, offset, littleEndian, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) { + checkIEEE754(buf, value, offset, 8); + } + ieee754$1.write(buf, value, offset, littleEndian, 52, 8); + return offset + 8; + } + Buffer2.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) { + return writeDouble(this, value, offset, true, noAssert); + }; + Buffer2.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) { + return writeDouble(this, value, offset, false, noAssert); + }; + Buffer2.prototype.copy = function copy(target, targetStart, start, end) { + if (!Buffer2.isBuffer(target)) throw new TypeError("argument should be a Buffer"); + if (!start) start = 0; + if (!end && end !== 0) end = this.length; + if (targetStart >= target.length) targetStart = target.length; + if (!targetStart) targetStart = 0; + if (end > 0 && end < start) end = start; + if (end === start) return 0; + if (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"); + if (end > this.length) end = this.length; + if (target.length - targetStart < end - start) { + end = target.length - targetStart + start; + } + const len2 = end - start; + if (this === target && typeof GlobalUint8Array.prototype.copyWithin === "function") { + this.copyWithin(targetStart, start, end); + } else { + GlobalUint8Array.prototype.set.call( + target, + this.subarray(start, end), + targetStart + ); + } + return len2; + }; + Buffer2.prototype.fill = function fill(val, start, end, encoding) { + if (typeof val === "string") { + if (typeof start === "string") { + encoding = start; + start = 0; + end = this.length; + } else if (typeof end === "string") { + encoding = end; + end = this.length; + } + if (encoding !== 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) { + const code2 = val.charCodeAt(0); + if (encoding === "utf8" && code2 < 128 || encoding === "latin1") { + val = code2; + } + } + } else if (typeof val === "number") { + val = val & 255; + } else if (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; + if (!val) val = 0; + let i2; + if (typeof val === "number") { + for (i2 = start; i2 < end; ++i2) { + this[i2] = val; + } + } else { + const bytes = Buffer2.isBuffer(val) ? val : Buffer2.from(val, encoding); + const len2 = bytes.length; + if (len2 === 0) { + throw new TypeError('The value "' + val + '" is invalid for argument "value"'); + } + for (i2 = 0; i2 < end - start; ++i2) { + this[i2 + start] = bytes[i2 % len2]; + } + } + return this; + }; + const errors = {}; + function E(sym, getMessage, Base) { + errors[sym] = class NodeError extends Base { + constructor() { + super(); + Object.defineProperty(this, "message", { + value: getMessage.apply(this, arguments), + writable: true, + configurable: true + }); + this.name = `${this.name} [${sym}]`; + this.stack; + delete this.name; + } + get code() { + return sym; + } + set code(value) { + Object.defineProperty(this, "code", { + configurable: true, + enumerable: true, + value, + writable: true + }); + } + toString() { + return `${this.name} [${sym}]: ${this.message}`; + } + }; + } + E( + "ERR_BUFFER_OUT_OF_BOUNDS", + function(name) { + if (name) { + return `${name} is outside of buffer bounds`; + } + return "Attempt to access memory outside buffer bounds"; + }, + RangeError + ); + E( + "ERR_INVALID_ARG_TYPE", + function(name, actual) { + return `The "${name}" argument must be of type number. Received type ${typeof actual}`; + }, + TypeError + ); + E( + "ERR_OUT_OF_RANGE", + function(str, range2, input) { + let msg = `The value of "${str}" is out of range.`; + let received = input; + if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) { + received = addNumericalSeparator(String(input)); + } else if (typeof input === "bigint") { + received = String(input); + if (input > BigInt(2) ** BigInt(32) || input < -(BigInt(2) ** BigInt(32))) { + received = addNumericalSeparator(received); + } + received += "n"; + } + msg += ` It must be ${range2}. Received ${received}`; + return msg; + }, + RangeError + ); + function addNumericalSeparator(val) { + let res = ""; + let i2 = val.length; + const 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, byteLength3) { + validateNumber(offset, "offset"); + if (buf[offset] === void 0 || buf[offset + byteLength3] === void 0) { + boundsError(offset, buf.length - (byteLength3 + 1)); + } + } + function checkIntBI(value, min, max, buf, offset, byteLength3) { + if (value > max || value < min) { + const n = typeof min === "bigint" ? "n" : ""; + let range2; + { + if (min === 0 || min === BigInt(0)) { + range2 = `>= 0${n} and < 2${n} ** ${(byteLength3 + 1) * 8}${n}`; + } else { + range2 = `>= -(2${n} ** ${(byteLength3 + 1) * 8 - 1}${n}) and < 2 ** ${(byteLength3 + 1) * 8 - 1}${n}`; + } + } + throw new errors.ERR_OUT_OF_RANGE("value", range2, value); + } + checkBounds(buf, offset, byteLength3); + } + function validateNumber(value, name) { + if (typeof value !== "number") { + throw new errors.ERR_INVALID_ARG_TYPE(name, "number", value); + } + } + function boundsError(value, length, type2) { + if (Math.floor(value) !== value) { + validateNumber(value, type2); + throw new errors.ERR_OUT_OF_RANGE("offset", "an integer", value); + } + if (length < 0) { + throw new errors.ERR_BUFFER_OUT_OF_BOUNDS(); + } + throw new errors.ERR_OUT_OF_RANGE( + "offset", + `>= ${0} and <= ${length}`, + value + ); + } + const INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g; + function base64clean(str) { + str = str.split("=")[0]; + str = str.trim().replace(INVALID_BASE64_RE, ""); + if (str.length < 2) return ""; + while (str.length % 4 !== 0) { + str = str + "="; + } + return str; + } + function utf8ToBytes(string, units) { + units = units || Infinity; + let codePoint; + const length = string.length; + let leadSurrogate = null; + const bytes = []; + for (let i2 = 0; i2 < length; ++i2) { + codePoint = string.charCodeAt(i2); + if (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); + } + leadSurrogate = null; + if (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) { + const 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; + const 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 base64.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, type2) { + return obj instanceof type2 || obj != null && obj.constructor != null && obj.constructor.name != null && obj.constructor.name === type2.name; + } + function numberIsNaN(obj) { + return obj !== obj; + } + const hexSliceLookupTable = function() { + const alphabet = "0123456789abcdef"; + const table = new Array(256); + for (let i2 = 0; i2 < 16; ++i2) { + const i16 = i2 * 16; + for (let j = 0; j < 16; ++j) { + table[i16 + j] = alphabet[i2] + alphabet[j]; + } + } + return table; + }(); + function defineBigIntMethod(fn) { + return typeof BigInt === "undefined" ? BufferBigIntNotDefined : fn; + } + function BufferBigIntNotDefined() { + throw new Error("BigInt not supported"); + } +})(buffer$1); +const Buffer = buffer$1.Buffer; +var main = { exports: {} }; +var empty = null; +const empty$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ + __proto__: null, + default: empty +}, Symbol.toStringTag, { value: "Module" })); +const require$$0$1 = /* @__PURE__ */ getAugmentedNamespace(empty$1); +var pathBrowserify; +var hasRequiredPathBrowserify; +function requirePathBrowserify() { + if (hasRequiredPathBrowserify) return pathBrowserify; + hasRequiredPathBrowserify = 1; + function assertPath(path) { + if (typeof path !== "string") { + throw new TypeError("Path must be a string. Received " + JSON.stringify(path)); + } + } + function normalizeStringPosix(path, allowAboveRoot) { + var res = ""; + var lastSegmentLength = 0; + var lastSlash = -1; + var dots = 0; + var code2; + for (var i2 = 0; i2 <= path.length; ++i2) { + if (i2 < path.length) + code2 = path.charCodeAt(i2); + else if (code2 === 47) + break; + else + code2 = 47; + if (code2 === 47) { + if (lastSlash === i2 - 1 || dots === 1) ; + else if (lastSlash !== i2 - 1 && dots === 2) { + if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 || res.charCodeAt(res.length - 2) !== 46) { + if (res.length > 2) { + var lastSlashIndex = res.lastIndexOf("/"); + if (lastSlashIndex !== res.length - 1) { + if (lastSlashIndex === -1) { + res = ""; + lastSegmentLength = 0; + } else { + res = res.slice(0, lastSlashIndex); + lastSegmentLength = res.length - 1 - res.lastIndexOf("/"); + } + lastSlash = i2; + dots = 0; + continue; + } + } else if (res.length === 2 || res.length === 1) { + res = ""; + lastSegmentLength = 0; + lastSlash = i2; + dots = 0; + continue; + } + } + if (allowAboveRoot) { + if (res.length > 0) + res += "/.."; + else + res = ".."; + lastSegmentLength = 2; + } + } else { + if (res.length > 0) + res += "/" + path.slice(lastSlash + 1, i2); + else + res = path.slice(lastSlash + 1, i2); + lastSegmentLength = i2 - lastSlash - 1; + } + lastSlash = i2; + dots = 0; + } else if (code2 === 46 && dots !== -1) { + ++dots; + } else { + dots = -1; + } + } + return res; + } + function _format(sep, pathObject) { + var dir = pathObject.dir || pathObject.root; + var base2 = pathObject.base || (pathObject.name || "") + (pathObject.ext || ""); + if (!dir) { + return base2; + } + if (dir === pathObject.root) { + return dir + base2; + } + return dir + sep + base2; + } + var posix = { + // path.resolve([from ...], to) + resolve: function resolve() { + var resolvedPath = ""; + var resolvedAbsolute = false; + var cwd; + for (var i2 = arguments.length - 1; i2 >= -1 && !resolvedAbsolute; i2--) { + var path; + if (i2 >= 0) + path = arguments[i2]; + else { + if (cwd === void 0) + cwd = process$1.cwd(); + path = cwd; + } + assertPath(path); + if (path.length === 0) { + continue; + } + resolvedPath = path + "/" + resolvedPath; + resolvedAbsolute = path.charCodeAt(0) === 47; + } + resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute); + if (resolvedAbsolute) { + if (resolvedPath.length > 0) + return "/" + resolvedPath; + else + return "/"; + } else if (resolvedPath.length > 0) { + return resolvedPath; + } else { + return "."; + } + }, + normalize: function normalize2(path) { + assertPath(path); + if (path.length === 0) return "."; + var isAbsolute = path.charCodeAt(0) === 47; + var trailingSeparator = path.charCodeAt(path.length - 1) === 47; + path = normalizeStringPosix(path, !isAbsolute); + if (path.length === 0 && !isAbsolute) path = "."; + if (path.length > 0 && trailingSeparator) path += "/"; + if (isAbsolute) return "/" + path; + return path; + }, + isAbsolute: function isAbsolute(path) { + assertPath(path); + return path.length > 0 && path.charCodeAt(0) === 47; + }, + join: function join2() { + if (arguments.length === 0) + return "."; + var joined; + for (var i2 = 0; i2 < arguments.length; ++i2) { + var arg = arguments[i2]; + assertPath(arg); + if (arg.length > 0) { + if (joined === void 0) + joined = arg; + else + joined += "/" + arg; + } + } + if (joined === void 0) + return "."; + return posix.normalize(joined); + }, + relative: function relative(from, to) { + assertPath(from); + assertPath(to); + if (from === to) return ""; + from = posix.resolve(from); + to = posix.resolve(to); + if (from === to) return ""; + var fromStart = 1; + for (; fromStart < from.length; ++fromStart) { + if (from.charCodeAt(fromStart) !== 47) + break; + } + var fromEnd = from.length; + var fromLen = fromEnd - fromStart; + var toStart = 1; + for (; toStart < to.length; ++toStart) { + if (to.charCodeAt(toStart) !== 47) + break; + } + var toEnd = to.length; + var toLen = toEnd - toStart; + var length = fromLen < toLen ? fromLen : toLen; + var lastCommonSep = -1; + var i2 = 0; + for (; i2 <= length; ++i2) { + if (i2 === length) { + if (toLen > length) { + if (to.charCodeAt(toStart + i2) === 47) { + return to.slice(toStart + i2 + 1); + } else if (i2 === 0) { + return to.slice(toStart + i2); + } + } else if (fromLen > length) { + if (from.charCodeAt(fromStart + i2) === 47) { + lastCommonSep = i2; + } else if (i2 === 0) { + lastCommonSep = 0; + } + } + break; + } + var fromCode = from.charCodeAt(fromStart + i2); + var toCode = to.charCodeAt(toStart + i2); + if (fromCode !== toCode) + break; + else if (fromCode === 47) + lastCommonSep = i2; + } + var out = ""; + for (i2 = fromStart + lastCommonSep + 1; i2 <= fromEnd; ++i2) { + if (i2 === fromEnd || from.charCodeAt(i2) === 47) { + if (out.length === 0) + out += ".."; + else + out += "/.."; + } + } + if (out.length > 0) + return out + to.slice(toStart + lastCommonSep); + else { + toStart += lastCommonSep; + if (to.charCodeAt(toStart) === 47) + ++toStart; + return to.slice(toStart); + } + }, + _makeLong: function _makeLong(path) { + return path; + }, + dirname: function dirname(path) { + assertPath(path); + if (path.length === 0) return "."; + var code2 = path.charCodeAt(0); + var hasRoot = code2 === 47; + var end = -1; + var matchedSlash = true; + for (var i2 = path.length - 1; i2 >= 1; --i2) { + code2 = path.charCodeAt(i2); + if (code2 === 47) { + if (!matchedSlash) { + end = i2; + break; + } + } else { + matchedSlash = false; + } + } + if (end === -1) return hasRoot ? "/" : "."; + if (hasRoot && end === 1) return "//"; + return path.slice(0, end); + }, + basename: function basename(path, ext) { + if (ext !== void 0 && typeof ext !== "string") throw new TypeError('"ext" argument must be a string'); + assertPath(path); + var start = 0; + var end = -1; + var matchedSlash = true; + var i2; + if (ext !== void 0 && ext.length > 0 && ext.length <= path.length) { + if (ext.length === path.length && ext === path) return ""; + var extIdx = ext.length - 1; + var firstNonSlashEnd = -1; + for (i2 = path.length - 1; i2 >= 0; --i2) { + var code2 = path.charCodeAt(i2); + if (code2 === 47) { + if (!matchedSlash) { + start = i2 + 1; + break; + } + } else { + if (firstNonSlashEnd === -1) { + matchedSlash = false; + firstNonSlashEnd = i2 + 1; + } + if (extIdx >= 0) { + if (code2 === ext.charCodeAt(extIdx)) { + if (--extIdx === -1) { + end = i2; + } + } else { + extIdx = -1; + end = firstNonSlashEnd; + } + } + } + } + if (start === end) end = firstNonSlashEnd; + else if (end === -1) end = path.length; + return path.slice(start, end); + } else { + for (i2 = path.length - 1; i2 >= 0; --i2) { + if (path.charCodeAt(i2) === 47) { + if (!matchedSlash) { + start = i2 + 1; + break; + } + } else if (end === -1) { + matchedSlash = false; + end = i2 + 1; + } + } + if (end === -1) return ""; + return path.slice(start, end); + } + }, + extname: function extname(path) { + assertPath(path); + var startDot = -1; + var startPart = 0; + var end = -1; + var matchedSlash = true; + var preDotState = 0; + for (var i2 = path.length - 1; i2 >= 0; --i2) { + var code2 = path.charCodeAt(i2); + if (code2 === 47) { + if (!matchedSlash) { + startPart = i2 + 1; + break; + } + continue; + } + if (end === -1) { + matchedSlash = false; + end = i2 + 1; + } + if (code2 === 46) { + if (startDot === -1) + startDot = i2; + else if (preDotState !== 1) + preDotState = 1; + } else if (startDot !== -1) { + preDotState = -1; + } + } + if (startDot === -1 || end === -1 || // We saw a non-dot character immediately before the dot + preDotState === 0 || // The (right-most) trimmed path component is exactly '..' + preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) { + return ""; + } + return path.slice(startDot, end); + }, + format: function format(pathObject) { + if (pathObject === null || typeof pathObject !== "object") { + throw new TypeError('The "pathObject" argument must be of type Object. Received type ' + typeof pathObject); + } + return _format("/", pathObject); + }, + parse: function parse2(path) { + assertPath(path); + var ret = { root: "", dir: "", base: "", ext: "", name: "" }; + if (path.length === 0) return ret; + var code2 = path.charCodeAt(0); + var isAbsolute = code2 === 47; + var start; + if (isAbsolute) { + ret.root = "/"; + start = 1; + } else { + start = 0; + } + var startDot = -1; + var startPart = 0; + var end = -1; + var matchedSlash = true; + var i2 = path.length - 1; + var preDotState = 0; + for (; i2 >= start; --i2) { + code2 = path.charCodeAt(i2); + if (code2 === 47) { + if (!matchedSlash) { + startPart = i2 + 1; + break; + } + continue; + } + if (end === -1) { + matchedSlash = false; + end = i2 + 1; + } + if (code2 === 46) { + if (startDot === -1) startDot = i2; + else if (preDotState !== 1) preDotState = 1; + } else if (startDot !== -1) { + preDotState = -1; + } + } + if (startDot === -1 || end === -1 || // We saw a non-dot character immediately before the dot + preDotState === 0 || // The (right-most) trimmed path component is exactly '..' + preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) { + if (end !== -1) { + if (startPart === 0 && isAbsolute) ret.base = ret.name = path.slice(1, end); + else ret.base = ret.name = path.slice(startPart, end); + } + } else { + if (startPart === 0 && isAbsolute) { + ret.name = path.slice(1, startDot); + ret.base = path.slice(1, end); + } else { + ret.name = path.slice(startPart, startDot); + ret.base = path.slice(startPart, end); + } + ret.ext = path.slice(startDot, end); + } + if (startPart > 0) ret.dir = path.slice(0, startPart - 1); + else if (isAbsolute) ret.dir = "/"; + return ret; + }, + sep: "/", + delimiter: ":", + win32: null, + posix: null + }; + posix.posix = posix; + pathBrowserify = posix; + return pathBrowserify; +} +var browser$c = {}; +var hasRequiredBrowser$c; +function requireBrowser$c() { + if (hasRequiredBrowser$c) return browser$c; + hasRequiredBrowser$c = 1; + browser$c.endianness = function() { + return "LE"; + }; + browser$c.hostname = function() { + if (typeof location !== "undefined") { + return location.hostname; + } else return ""; + }; + browser$c.loadavg = function() { + return []; + }; + browser$c.uptime = function() { + return 0; + }; + browser$c.freemem = function() { + return Number.MAX_VALUE; + }; + browser$c.totalmem = function() { + return Number.MAX_VALUE; + }; + browser$c.cpus = function() { + return []; + }; + browser$c.type = function() { + return "Browser"; + }; + browser$c.release = function() { + if (typeof navigator !== "undefined") { + return navigator.appVersion; + } + return ""; + }; + browser$c.networkInterfaces = browser$c.getNetworkInterfaces = function() { + return {}; + }; + browser$c.arch = function() { + return "javascript"; + }; + browser$c.platform = function() { + return "browser"; + }; + browser$c.tmpdir = browser$c.tmpDir = function() { + return "/tmp"; + }; + browser$c.EOL = "\n"; + browser$c.homedir = function() { + return "/"; + }; + return browser$c; +} +var cryptoBrowserify = {}; +var browser$b = { exports: {} }; +var safeBuffer$1 = { exports: {} }; +var dist = {}; +var hasRequiredDist; +function requireDist() { + if (hasRequiredDist) return dist; + hasRequiredDist = 1; + (function(exports2) { + Object.defineProperties(exports2, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } }); + var buffer2 = {}; + var base64Js2 = {}; + base64Js2.byteLength = byteLength2; + base64Js2.toByteArray = toByteArray2; + base64Js2.fromByteArray = fromByteArray2; + var lookup2 = []; + var revLookup2 = []; + var Arr2 = typeof Uint8Array !== "undefined" ? Uint8Array : Array; + var code2 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + for (var i2 = 0, len2 = code2.length; i2 < len2; ++i2) { + lookup2[i2] = code2[i2]; + revLookup2[code2.charCodeAt(i2)] = i2; + } + revLookup2["-".charCodeAt(0)] = 62; + revLookup2["_".charCodeAt(0)] = 63; + function getLens2(b64) { + var len3 = b64.length; + if (len3 % 4 > 0) { + throw new Error("Invalid string. Length must be a multiple of 4"); + } + var validLen = b64.indexOf("="); + if (validLen === -1) validLen = len3; + var placeHoldersLen = validLen === len3 ? 0 : 4 - validLen % 4; + return [validLen, placeHoldersLen]; + } + function byteLength2(b64) { + var lens = getLens2(b64); + var validLen = lens[0]; + var placeHoldersLen = lens[1]; + return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen; + } + function _byteLength2(b64, validLen, placeHoldersLen) { + return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen; + } + function toByteArray2(b64) { + var tmp; + var lens = getLens2(b64); + var validLen = lens[0]; + var placeHoldersLen = lens[1]; + var arr = new Arr2(_byteLength2(b64, validLen, placeHoldersLen)); + var curByte = 0; + var len3 = placeHoldersLen > 0 ? validLen - 4 : validLen; + var i3; + for (i3 = 0; i3 < len3; i3 += 4) { + tmp = revLookup2[b64.charCodeAt(i3)] << 18 | revLookup2[b64.charCodeAt(i3 + 1)] << 12 | revLookup2[b64.charCodeAt(i3 + 2)] << 6 | revLookup2[b64.charCodeAt(i3 + 3)]; + arr[curByte++] = tmp >> 16 & 255; + arr[curByte++] = tmp >> 8 & 255; + arr[curByte++] = tmp & 255; + } + if (placeHoldersLen === 2) { + tmp = revLookup2[b64.charCodeAt(i3)] << 2 | revLookup2[b64.charCodeAt(i3 + 1)] >> 4; + arr[curByte++] = tmp & 255; + } + if (placeHoldersLen === 1) { + tmp = revLookup2[b64.charCodeAt(i3)] << 10 | revLookup2[b64.charCodeAt(i3 + 1)] << 4 | revLookup2[b64.charCodeAt(i3 + 2)] >> 2; + arr[curByte++] = tmp >> 8 & 255; + arr[curByte++] = tmp & 255; + } + return arr; + } + function tripletToBase642(num) { + return lookup2[num >> 18 & 63] + lookup2[num >> 12 & 63] + lookup2[num >> 6 & 63] + lookup2[num & 63]; + } + function encodeChunk2(uint8, start, end) { + var tmp; + var output = []; + for (var i3 = start; i3 < end; i3 += 3) { + tmp = (uint8[i3] << 16 & 16711680) + (uint8[i3 + 1] << 8 & 65280) + (uint8[i3 + 2] & 255); + output.push(tripletToBase642(tmp)); + } + return output.join(""); + } + function fromByteArray2(uint8) { + var tmp; + var len3 = uint8.length; + var extraBytes = len3 % 3; + var parts = []; + var maxChunkLength = 16383; + for (var i3 = 0, len22 = len3 - extraBytes; i3 < len22; i3 += maxChunkLength) { + parts.push(encodeChunk2(uint8, i3, i3 + maxChunkLength > len22 ? len22 : i3 + maxChunkLength)); + } + if (extraBytes === 1) { + tmp = uint8[len3 - 1]; + parts.push( + lookup2[tmp >> 2] + lookup2[tmp << 4 & 63] + "==" + ); + } else if (extraBytes === 2) { + tmp = (uint8[len3 - 2] << 8) + uint8[len3 - 1]; + parts.push( + lookup2[tmp >> 10] + lookup2[tmp >> 4 & 63] + lookup2[tmp << 2 & 63] + "=" + ); + } + return parts.join(""); + } + var ieee7542 = {}; + /*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh */ + ieee7542.read = function(buffer3, offset, isLE, mLen, nBytes) { + var e, m; + var eLen = nBytes * 8 - mLen - 1; + var eMax = (1 << eLen) - 1; + var eBias = eMax >> 1; + var nBits = -7; + var i3 = isLE ? nBytes - 1 : 0; + var d = isLE ? -1 : 1; + var s = buffer3[offset + i3]; + i3 += d; + e = s & (1 << -nBits) - 1; + s >>= -nBits; + nBits += eLen; + for (; nBits > 0; e = e * 256 + buffer3[offset + i3], i3 += d, nBits -= 8) { + } + m = e & (1 << -nBits) - 1; + e >>= -nBits; + nBits += mLen; + for (; nBits > 0; m = m * 256 + buffer3[offset + i3], i3 += d, nBits -= 8) { + } + if (e === 0) { + e = 1 - eBias; + } else if (e === eMax) { + return m ? NaN : (s ? -1 : 1) * Infinity; + } else { + m = m + Math.pow(2, mLen); + e = e - eBias; + } + return (s ? -1 : 1) * m * Math.pow(2, e - mLen); + }; + ieee7542.write = function(buffer3, value, offset, isLE, mLen, nBytes) { + var e, m, c; + var eLen = nBytes * 8 - mLen - 1; + var eMax = (1 << eLen) - 1; + var eBias = eMax >> 1; + var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0; + var i3 = isLE ? 0 : nBytes - 1; + var d = isLE ? 1 : -1; + var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0; + value = Math.abs(value); + if (isNaN(value) || value === Infinity) { + m = isNaN(value) ? 1 : 0; + e = eMax; + } else { + e = Math.floor(Math.log(value) / Math.LN2); + if (value * (c = Math.pow(2, -e)) < 1) { + e--; + c *= 2; + } + if (e + eBias >= 1) { + value += rt / c; + } else { + value += rt * Math.pow(2, 1 - eBias); + } + if (value * c >= 2) { + e++; + c /= 2; + } + if (e + eBias >= eMax) { + m = 0; + e = eMax; + } else if (e + eBias >= 1) { + m = (value * c - 1) * Math.pow(2, mLen); + e = e + eBias; + } else { + m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen); + e = 0; + } + } + for (; mLen >= 8; buffer3[offset + i3] = m & 255, i3 += d, m /= 256, mLen -= 8) { + } + e = e << mLen | m; + eLen += mLen; + for (; eLen > 0; buffer3[offset + i3] = e & 255, i3 += d, e /= 256, eLen -= 8) { + } + buffer3[offset + i3 - d] |= s * 128; + }; + /*! + * The buffer module from node.js, for the browser. + * + * @author Feross Aboukhadijeh + * @license MIT + */ + (function(exports3) { + const base64 = base64Js2; + const ieee754$1 = ieee7542; + const customInspectSymbol = typeof Symbol === "function" && typeof Symbol["for"] === "function" ? Symbol["for"]("nodejs.util.inspect.custom") : null; + exports3.Buffer = Buffer3; + exports3.SlowBuffer = SlowBuffer; + exports3.INSPECT_MAX_BYTES = 50; + const K_MAX_LENGTH = 2147483647; + exports3.kMaxLength = K_MAX_LENGTH; + const { Uint8Array: GlobalUint8Array, ArrayBuffer: GlobalArrayBuffer, SharedArrayBuffer: GlobalSharedArrayBuffer } = globalThis; + Buffer3.TYPED_ARRAY_SUPPORT = typedArraySupport(); + if (!Buffer3.TYPED_ARRAY_SUPPORT && typeof console !== "undefined" && typeof console.error === "function") { + console.error( + "This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support." + ); + } + function typedArraySupport() { + try { + const arr = new GlobalUint8Array(1); + const proto = { foo: function() { + return 42; + } }; + Object.setPrototypeOf(proto, GlobalUint8Array.prototype); + Object.setPrototypeOf(arr, proto); + return arr.foo() === 42; + } catch (e) { + return false; + } + } + Object.defineProperty(Buffer3.prototype, "parent", { + enumerable: true, + get: function() { + if (!Buffer3.isBuffer(this)) return void 0; + return this.buffer; + } + }); + Object.defineProperty(Buffer3.prototype, "offset", { + enumerable: true, + get: function() { + if (!Buffer3.isBuffer(this)) return void 0; + return this.byteOffset; + } + }); + function createBuffer(length) { + if (length > K_MAX_LENGTH) { + throw new RangeError('The value "' + length + '" is invalid for option "size"'); + } + const buf = new GlobalUint8Array(length); + Object.setPrototypeOf(buf, Buffer3.prototype); + return buf; + } + function Buffer3(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); + } + Buffer3.poolSize = 8192; + function from(value, encodingOrOffset, length) { + if (typeof value === "string") { + return fromString(value, encodingOrOffset); + } + if (GlobalArrayBuffer.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, GlobalArrayBuffer) || value && isInstance(value.buffer, GlobalArrayBuffer)) { + return fromArrayBuffer(value, encodingOrOffset, length); + } + if (typeof GlobalSharedArrayBuffer !== "undefined" && (isInstance(value, GlobalSharedArrayBuffer) || value && isInstance(value.buffer, GlobalSharedArrayBuffer))) { + return fromArrayBuffer(value, encodingOrOffset, length); + } + if (typeof value === "number") { + throw new TypeError( + 'The "value" argument must not be of type number. Received type number' + ); + } + const valueOf = value.valueOf && value.valueOf(); + if (valueOf != null && valueOf !== value) { + return Buffer3.from(valueOf, encodingOrOffset, length); + } + const b = fromObject(value); + if (b) return b; + if (typeof Symbol !== "undefined" && Symbol.toPrimitive != null && typeof value[Symbol.toPrimitive] === "function") { + return Buffer3.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 + ); + } + Buffer3.from = function(value, encodingOrOffset, length) { + return from(value, encodingOrOffset, length); + }; + Object.setPrototypeOf(Buffer3.prototype, GlobalUint8Array.prototype); + Object.setPrototypeOf(Buffer3, GlobalUint8Array); + function assertSize(size) { + if (typeof size !== "number") { + throw new TypeError('"size" argument must be of type number'); + } else if (size < 0) { + throw new RangeError('The value "' + size + '" is invalid for option "size"'); + } + } + function alloc(size, fill, encoding) { + assertSize(size); + if (size <= 0) { + return createBuffer(size); + } + if (fill !== void 0) { + return typeof encoding === "string" ? createBuffer(size).fill(fill, encoding) : createBuffer(size).fill(fill); + } + return createBuffer(size); + } + Buffer3.alloc = function(size, fill, encoding) { + return alloc(size, fill, encoding); + }; + function allocUnsafe(size) { + assertSize(size); + return createBuffer(size < 0 ? 0 : checked(size) | 0); + } + Buffer3.allocUnsafe = function(size) { + return allocUnsafe(size); + }; + Buffer3.allocUnsafeSlow = function(size) { + return allocUnsafe(size); + }; + function fromString(string, encoding) { + if (typeof encoding !== "string" || encoding === "") { + encoding = "utf8"; + } + if (!Buffer3.isEncoding(encoding)) { + throw new TypeError("Unknown encoding: " + encoding); + } + const length = byteLength3(string, encoding) | 0; + let buf = createBuffer(length); + const actual = buf.write(string, encoding); + if (actual !== length) { + buf = buf.slice(0, actual); + } + return buf; + } + function fromArrayLike(array) { + const length = array.length < 0 ? 0 : checked(array.length) | 0; + const buf = createBuffer(length); + for (let i3 = 0; i3 < length; i3 += 1) { + buf[i3] = array[i3] & 255; + } + return buf; + } + function fromArrayView(arrayView) { + if (isInstance(arrayView, GlobalUint8Array)) { + const copy = new GlobalUint8Array(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; + if (byteOffset === void 0 && length === void 0) { + buf = new GlobalUint8Array(array); + } else if (length === void 0) { + buf = new GlobalUint8Array(array, byteOffset); + } else { + buf = new GlobalUint8Array(array, byteOffset, length); + } + Object.setPrototypeOf(buf, Buffer3.prototype); + return buf; + } + function fromObject(obj) { + if (Buffer3.isBuffer(obj)) { + const len3 = checked(obj.length) | 0; + const buf = createBuffer(len3); + if (buf.length === 0) { + return buf; + } + obj.copy(buf, 0, 0, len3); + return buf; + } + if (obj.length !== void 0) { + if (typeof obj.length !== "number" || numberIsNaN(obj.length)) { + return createBuffer(0); + } + return fromArrayLike(obj); + } + if (obj.type === "Buffer" && Array.isArray(obj.data)) { + return fromArrayLike(obj.data); + } + } + function checked(length) { + if (length >= K_MAX_LENGTH) { + throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + K_MAX_LENGTH.toString(16) + " bytes"); + } + return length | 0; + } + function SlowBuffer(length) { + if (+length != length) { + length = 0; + } + return Buffer3.alloc(+length); + } + Buffer3.isBuffer = function isBuffer(b) { + return b != null && b._isBuffer === true && b !== Buffer3.prototype; + }; + Buffer3.compare = function compare(a, b) { + if (isInstance(a, GlobalUint8Array)) a = Buffer3.from(a, a.offset, a.byteLength); + if (isInstance(b, GlobalUint8Array)) b = Buffer3.from(b, b.offset, b.byteLength); + if (!Buffer3.isBuffer(a) || !Buffer3.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; + let y = b.length; + for (let i3 = 0, len3 = Math.min(x, y); i3 < len3; ++i3) { + if (a[i3] !== b[i3]) { + x = a[i3]; + y = b[i3]; + break; + } + } + if (x < y) return -1; + if (y < x) return 1; + return 0; + }; + Buffer3.isEncoding = function isEncoding(encoding) { + switch (String(encoding).toLowerCase()) { + case "hex": + case "utf8": + case "utf-8": + case "ascii": + case "latin1": + case "binary": + case "base64": + case "ucs2": + case "ucs-2": + case "utf16le": + case "utf-16le": + return true; + default: + return false; + } + }; + Buffer3.concat = function concat(list, length) { + if (!Array.isArray(list)) { + throw new TypeError('"list" argument must be an Array of Buffers'); + } + if (list.length === 0) { + return Buffer3.alloc(0); + } + let i3; + if (length === void 0) { + length = 0; + for (i3 = 0; i3 < list.length; ++i3) { + length += list[i3].length; + } + } + const buffer3 = Buffer3.allocUnsafe(length); + let pos = 0; + for (i3 = 0; i3 < list.length; ++i3) { + let buf = list[i3]; + if (isInstance(buf, GlobalUint8Array)) { + if (pos + buf.length > buffer3.length) { + if (!Buffer3.isBuffer(buf)) buf = Buffer3.from(buf); + buf.copy(buffer3, pos); + } else { + GlobalUint8Array.prototype.set.call( + buffer3, + buf, + pos + ); + } + } else if (!Buffer3.isBuffer(buf)) { + throw new TypeError('"list" argument must be an Array of Buffers'); + } else { + buf.copy(buffer3, pos); + } + pos += buf.length; + } + return buffer3; + }; + function byteLength3(string, encoding) { + if (Buffer3.isBuffer(string)) { + return string.length; + } + if (GlobalArrayBuffer.isView(string) || isInstance(string, GlobalArrayBuffer)) { + 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 + ); + } + const len3 = string.length; + const mustMatch = arguments.length > 2 && arguments[2] === true; + if (!mustMatch && len3 === 0) return 0; + let loweredCase = false; + for (; ; ) { + switch (encoding) { + case "ascii": + case "latin1": + case "binary": + return len3; + case "utf8": + case "utf-8": + return utf8ToBytes(string).length; + case "ucs2": + case "ucs-2": + case "utf16le": + case "utf-16le": + return len3 * 2; + case "hex": + return len3 >>> 1; + case "base64": + return base64ToBytes(string).length; + default: + if (loweredCase) { + return mustMatch ? -1 : utf8ToBytes(string).length; + } + encoding = ("" + encoding).toLowerCase(); + loweredCase = true; + } + } + } + Buffer3.byteLength = byteLength3; + function slowToString(encoding, start, end) { + let loweredCase = false; + if (start === void 0 || start < 0) { + start = 0; + } + if (start > this.length) { + return ""; + } + if (end === void 0 || end > this.length) { + end = this.length; + } + if (end <= 0) { + return ""; + } + end >>>= 0; + start >>>= 0; + if (end <= start) { + return ""; + } + if (!encoding) encoding = "utf8"; + while (true) { + switch (encoding) { + case "hex": + return hexSlice(this, start, end); + case "utf8": + case "utf-8": + return utf8Slice(this, start, end); + case "ascii": + return asciiSlice(this, start, end); + case "latin1": + case "binary": + return latin1Slice(this, start, end); + case "base64": + return base64Slice(this, start, end); + case "ucs2": + case "ucs-2": + case "utf16le": + case "utf-16le": + return utf16leSlice(this, start, end); + default: + if (loweredCase) throw new TypeError("Unknown encoding: " + encoding); + encoding = (encoding + "").toLowerCase(); + loweredCase = true; + } + } + } + Buffer3.prototype._isBuffer = true; + function swap(b, n, m) { + const i3 = b[n]; + b[n] = b[m]; + b[m] = i3; + } + Buffer3.prototype.swap16 = function swap16() { + const len3 = this.length; + if (len3 % 2 !== 0) { + throw new RangeError("Buffer size must be a multiple of 16-bits"); + } + for (let i3 = 0; i3 < len3; i3 += 2) { + swap(this, i3, i3 + 1); + } + return this; + }; + Buffer3.prototype.swap32 = function swap32() { + const len3 = this.length; + if (len3 % 4 !== 0) { + throw new RangeError("Buffer size must be a multiple of 32-bits"); + } + for (let i3 = 0; i3 < len3; i3 += 4) { + swap(this, i3, i3 + 3); + swap(this, i3 + 1, i3 + 2); + } + return this; + }; + Buffer3.prototype.swap64 = function swap64() { + const len3 = this.length; + if (len3 % 8 !== 0) { + throw new RangeError("Buffer size must be a multiple of 64-bits"); + } + for (let i3 = 0; i3 < len3; i3 += 8) { + swap(this, i3, i3 + 7); + swap(this, i3 + 1, i3 + 6); + swap(this, i3 + 2, i3 + 5); + swap(this, i3 + 3, i3 + 4); + } + return this; + }; + Buffer3.prototype.toString = function toString() { + const length = this.length; + if (length === 0) return ""; + if (arguments.length === 0) return utf8Slice(this, 0, length); + return slowToString.apply(this, arguments); + }; + Buffer3.prototype.toLocaleString = Buffer3.prototype.toString; + Buffer3.prototype.equals = function equals(b) { + if (!Buffer3.isBuffer(b)) throw new TypeError("Argument must be a Buffer"); + if (this === b) return true; + return Buffer3.compare(this, b) === 0; + }; + Buffer3.prototype.inspect = function inspect2() { + let str = ""; + const max = exports3.INSPECT_MAX_BYTES; + str = this.toString("hex", 0, max).replace(/(.{2})/g, "$1 ").trim(); + if (this.length > max) str += " ... "; + return ""; + }; + if (customInspectSymbol) { + Buffer3.prototype[customInspectSymbol] = Buffer3.prototype.inspect; + } + Buffer3.prototype.compare = function compare(target, start, end, thisStart, thisEnd) { + if (isInstance(target, GlobalUint8Array)) { + target = Buffer3.from(target, target.offset, target.byteLength); + } + if (!Buffer3.isBuffer(target)) { + throw new TypeError( + 'The "target" argument must be one of type Buffer or Uint8Array. Received type ' + typeof target + ); + } + if (start === void 0) { + start = 0; + } + if (end === void 0) { + end = target ? target.length : 0; + } + if (thisStart === void 0) { + thisStart = 0; + } + if (thisEnd === void 0) { + thisEnd = this.length; + } + if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) { + throw new RangeError("out of range index"); + } + if (thisStart >= thisEnd && start >= end) { + return 0; + } + if (thisStart >= thisEnd) { + return -1; + } + if (start >= end) { + return 1; + } + start >>>= 0; + end >>>= 0; + thisStart >>>= 0; + thisEnd >>>= 0; + if (this === target) return 0; + let x = thisEnd - thisStart; + let y = end - start; + const len3 = Math.min(x, y); + const thisCopy = this.slice(thisStart, thisEnd); + const targetCopy = target.slice(start, end); + for (let i3 = 0; i3 < len3; ++i3) { + if (thisCopy[i3] !== targetCopy[i3]) { + x = thisCopy[i3]; + y = targetCopy[i3]; + break; + } + } + if (x < y) return -1; + if (y < x) return 1; + return 0; + }; + function bidirectionalIndexOf(buffer3, val, byteOffset, encoding, dir) { + if (buffer3.length === 0) return -1; + if (typeof byteOffset === "string") { + encoding = byteOffset; + byteOffset = 0; + } else if (byteOffset > 2147483647) { + byteOffset = 2147483647; + } else if (byteOffset < -2147483648) { + byteOffset = -2147483648; + } + byteOffset = +byteOffset; + if (numberIsNaN(byteOffset)) { + byteOffset = dir ? 0 : buffer3.length - 1; + } + if (byteOffset < 0) byteOffset = buffer3.length + byteOffset; + if (byteOffset >= buffer3.length) { + if (dir) return -1; + else byteOffset = buffer3.length - 1; + } else if (byteOffset < 0) { + if (dir) byteOffset = 0; + else return -1; + } + if (typeof val === "string") { + val = Buffer3.from(val, encoding); + } + if (Buffer3.isBuffer(val)) { + if (val.length === 0) { + return -1; + } + return arrayIndexOf(buffer3, val, byteOffset, encoding, dir); + } else if (typeof val === "number") { + val = val & 255; + if (typeof GlobalUint8Array.prototype.indexOf === "function") { + if (dir) { + return GlobalUint8Array.prototype.indexOf.call(buffer3, val, byteOffset); + } else { + return GlobalUint8Array.prototype.lastIndexOf.call(buffer3, val, byteOffset); + } + } + return arrayIndexOf(buffer3, [val], byteOffset, encoding, dir); + } + throw new TypeError("val must be string, number or Buffer"); + } + function arrayIndexOf(arr, val, byteOffset, encoding, dir) { + let indexSize = 1; + let arrLength = arr.length; + let valLength = val.length; + if (encoding !== void 0) { + encoding = String(encoding).toLowerCase(); + if (encoding === "ucs2" || encoding === "ucs-2" || encoding === "utf16le" || encoding === "utf-16le") { + if (arr.length < 2 || val.length < 2) { + return -1; + } + indexSize = 2; + arrLength /= 2; + valLength /= 2; + byteOffset /= 2; + } + } + function read(buf, i4) { + if (indexSize === 1) { + return buf[i4]; + } else { + return buf.readUInt16BE(i4 * indexSize); + } + } + let i3; + if (dir) { + let foundIndex = -1; + for (i3 = byteOffset; i3 < arrLength; i3++) { + if (read(arr, i3) === read(val, foundIndex === -1 ? 0 : i3 - foundIndex)) { + if (foundIndex === -1) foundIndex = i3; + if (i3 - foundIndex + 1 === valLength) return foundIndex * indexSize; + } else { + if (foundIndex !== -1) i3 -= i3 - foundIndex; + foundIndex = -1; + } + } + } else { + if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength; + for (i3 = byteOffset; i3 >= 0; i3--) { + let found = true; + for (let j = 0; j < valLength; j++) { + if (read(arr, i3 + j) !== read(val, j)) { + found = false; + break; + } + } + if (found) return i3; + } + } + return -1; + } + Buffer3.prototype.includes = function includes(val, byteOffset, encoding) { + return this.indexOf(val, byteOffset, encoding) !== -1; + }; + Buffer3.prototype.indexOf = function indexOf2(val, byteOffset, encoding) { + return bidirectionalIndexOf(this, val, byteOffset, encoding, true); + }; + Buffer3.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) { + return bidirectionalIndexOf(this, val, byteOffset, encoding, false); + }; + function hexWrite(buf, string, offset, length) { + offset = Number(offset) || 0; + const remaining = buf.length - offset; + if (!length) { + length = remaining; + } else { + length = Number(length); + if (length > remaining) { + length = remaining; + } + } + const strLen = string.length; + if (length > strLen / 2) { + length = strLen / 2; + } + let i3; + for (i3 = 0; i3 < length; ++i3) { + const parsed = parseInt(string.substr(i3 * 2, 2), 16); + if (numberIsNaN(parsed)) return i3; + buf[offset + i3] = parsed; + } + return i3; + } + 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); + } + Buffer3.prototype.write = function write(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; + if (isFinite(length)) { + length = length >>> 0; + if (encoding === void 0) encoding = "utf8"; + } else { + encoding = length; + length = void 0; + } + } else { + throw new Error( + "Buffer.write(string, encoding, offset[, length]) is no longer supported" + ); + } + const remaining = this.length - offset; + if (length === void 0 || length > remaining) length = remaining; + if (string.length > 0 && (length < 0 || offset < 0) || offset > this.length) { + throw new RangeError("Attempt to write outside buffer bounds"); + } + if (!encoding) encoding = "utf8"; + 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 new TypeError("Unknown encoding: " + encoding); + encoding = ("" + encoding).toLowerCase(); + loweredCase = true; + } + } + }; + Buffer3.prototype.toJSON = function toJSON() { + return { + type: "Buffer", + data: Array.prototype.slice.call(this._arr || this, 0) + }; + }; + function base64Slice(buf, start, end) { + if (start === 0 && end === buf.length) { + return base64.fromByteArray(buf); + } else { + return base64.fromByteArray(buf.slice(start, end)); + } + } + function utf8Slice(buf, start, end) { + end = Math.min(buf.length, end); + const res = []; + let i3 = start; + while (i3 < end) { + const firstByte = buf[i3]; + let codePoint = null; + let bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1; + if (i3 + bytesPerSequence <= end) { + let secondByte, thirdByte, fourthByte, tempCodePoint; + switch (bytesPerSequence) { + case 1: + if (firstByte < 128) { + codePoint = firstByte; + } + break; + case 2: + secondByte = buf[i3 + 1]; + if ((secondByte & 192) === 128) { + tempCodePoint = (firstByte & 31) << 6 | secondByte & 63; + if (tempCodePoint > 127) { + codePoint = tempCodePoint; + } + } + break; + case 3: + secondByte = buf[i3 + 1]; + thirdByte = buf[i3 + 2]; + if ((secondByte & 192) === 128 && (thirdByte & 192) === 128) { + tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63; + if (tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343)) { + codePoint = tempCodePoint; + } + } + break; + case 4: + secondByte = buf[i3 + 1]; + thirdByte = buf[i3 + 2]; + fourthByte = buf[i3 + 3]; + if ((secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128) { + tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63; + if (tempCodePoint > 65535 && tempCodePoint < 1114112) { + codePoint = tempCodePoint; + } + } + } + } + if (codePoint === null) { + codePoint = 65533; + bytesPerSequence = 1; + } else if (codePoint > 65535) { + codePoint -= 65536; + res.push(codePoint >>> 10 & 1023 | 55296); + codePoint = 56320 | codePoint & 1023; + } + res.push(codePoint); + i3 += bytesPerSequence; + } + return decodeCodePointsArray(res); + } + const MAX_ARGUMENTS_LENGTH = 4096; + function decodeCodePointsArray(codePoints) { + const len3 = codePoints.length; + if (len3 <= MAX_ARGUMENTS_LENGTH) { + return String.fromCharCode.apply(String, codePoints); + } + let res = ""; + let i3 = 0; + while (i3 < len3) { + res += String.fromCharCode.apply( + String, + codePoints.slice(i3, i3 += MAX_ARGUMENTS_LENGTH) + ); + } + return res; + } + function asciiSlice(buf, start, end) { + let ret = ""; + end = Math.min(buf.length, end); + for (let i3 = start; i3 < end; ++i3) { + ret += String.fromCharCode(buf[i3] & 127); + } + return ret; + } + function latin1Slice(buf, start, end) { + let ret = ""; + end = Math.min(buf.length, end); + for (let i3 = start; i3 < end; ++i3) { + ret += String.fromCharCode(buf[i3]); + } + return ret; + } + function hexSlice(buf, start, end) { + const len3 = buf.length; + if (!start || start < 0) start = 0; + if (!end || end < 0 || end > len3) end = len3; + let out = ""; + for (let i3 = start; i3 < end; ++i3) { + out += hexSliceLookupTable[buf[i3]]; + } + return out; + } + function utf16leSlice(buf, start, end) { + const bytes = buf.slice(start, end); + let res = ""; + for (let i3 = 0; i3 < bytes.length - 1; i3 += 2) { + res += String.fromCharCode(bytes[i3] + bytes[i3 + 1] * 256); + } + return res; + } + Buffer3.prototype.slice = function slice(start, end) { + const len3 = this.length; + start = ~~start; + end = end === void 0 ? len3 : ~~end; + if (start < 0) { + start += len3; + if (start < 0) start = 0; + } else if (start > len3) { + start = len3; + } + if (end < 0) { + end += len3; + if (end < 0) end = 0; + } else if (end > len3) { + end = len3; + } + if (end < start) end = start; + const newBuf = this.subarray(start, end); + Object.setPrototypeOf(newBuf, Buffer3.prototype); + return 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"); + } + Buffer3.prototype.readUintLE = Buffer3.prototype.readUIntLE = function readUIntLE(offset, byteLength4, noAssert) { + offset = offset >>> 0; + byteLength4 = byteLength4 >>> 0; + if (!noAssert) checkOffset(offset, byteLength4, this.length); + let val = this[offset]; + let mul = 1; + let i3 = 0; + while (++i3 < byteLength4 && (mul *= 256)) { + val += this[offset + i3] * mul; + } + return val; + }; + Buffer3.prototype.readUintBE = Buffer3.prototype.readUIntBE = function readUIntBE(offset, byteLength4, noAssert) { + offset = offset >>> 0; + byteLength4 = byteLength4 >>> 0; + if (!noAssert) { + checkOffset(offset, byteLength4, this.length); + } + let val = this[offset + --byteLength4]; + let mul = 1; + while (byteLength4 > 0 && (mul *= 256)) { + val += this[offset + --byteLength4] * mul; + } + return val; + }; + Buffer3.prototype.readUint8 = Buffer3.prototype.readUInt8 = function readUInt8(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) checkOffset(offset, 1, this.length); + return this[offset]; + }; + Buffer3.prototype.readUint16LE = Buffer3.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) checkOffset(offset, 2, this.length); + return this[offset] | this[offset + 1] << 8; + }; + Buffer3.prototype.readUint16BE = Buffer3.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) checkOffset(offset, 2, this.length); + return this[offset] << 8 | this[offset + 1]; + }; + Buffer3.prototype.readUint32LE = Buffer3.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) checkOffset(offset, 4, this.length); + return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 16777216; + }; + Buffer3.prototype.readUint32BE = Buffer3.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) checkOffset(offset, 4, this.length); + return this[offset] * 16777216 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]); + }; + Buffer3.prototype.readBigUInt64LE = defineBigIntMethod(function readBigUInt64LE(offset) { + offset = offset >>> 0; + validateNumber(offset, "offset"); + const first = this[offset]; + const last = this[offset + 7]; + if (first === void 0 || last === void 0) { + boundsError(offset, this.length - 8); + } + const lo = first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24; + const hi = this[++offset] + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + last * 2 ** 24; + return BigInt(lo) + (BigInt(hi) << BigInt(32)); + }); + Buffer3.prototype.readBigUInt64BE = defineBigIntMethod(function readBigUInt64BE(offset) { + offset = offset >>> 0; + validateNumber(offset, "offset"); + const first = this[offset]; + const last = this[offset + 7]; + if (first === void 0 || last === void 0) { + boundsError(offset, this.length - 8); + } + const hi = first * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset]; + const lo = this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last; + return (BigInt(hi) << BigInt(32)) + BigInt(lo); + }); + Buffer3.prototype.readIntLE = function readIntLE(offset, byteLength4, noAssert) { + offset = offset >>> 0; + byteLength4 = byteLength4 >>> 0; + if (!noAssert) checkOffset(offset, byteLength4, this.length); + let val = this[offset]; + let mul = 1; + let i3 = 0; + while (++i3 < byteLength4 && (mul *= 256)) { + val += this[offset + i3] * mul; + } + mul *= 128; + if (val >= mul) val -= Math.pow(2, 8 * byteLength4); + return val; + }; + Buffer3.prototype.readIntBE = function readIntBE(offset, byteLength4, noAssert) { + offset = offset >>> 0; + byteLength4 = byteLength4 >>> 0; + if (!noAssert) checkOffset(offset, byteLength4, this.length); + let i3 = byteLength4; + let mul = 1; + let val = this[offset + --i3]; + while (i3 > 0 && (mul *= 256)) { + val += this[offset + --i3] * mul; + } + mul *= 128; + if (val >= mul) val -= Math.pow(2, 8 * byteLength4); + return val; + }; + Buffer3.prototype.readInt8 = function readInt8(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) checkOffset(offset, 1, this.length); + if (!(this[offset] & 128)) return this[offset]; + return (255 - this[offset] + 1) * -1; + }; + Buffer3.prototype.readInt16LE = function readInt16LE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) checkOffset(offset, 2, this.length); + const val = this[offset] | this[offset + 1] << 8; + return val & 32768 ? val | 4294901760 : val; + }; + Buffer3.prototype.readInt16BE = function readInt16BE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) checkOffset(offset, 2, this.length); + const val = this[offset + 1] | this[offset] << 8; + return val & 32768 ? val | 4294901760 : val; + }; + Buffer3.prototype.readInt32LE = function readInt32LE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) checkOffset(offset, 4, this.length); + return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24; + }; + Buffer3.prototype.readInt32BE = function readInt32BE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) checkOffset(offset, 4, this.length); + return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]; + }; + Buffer3.prototype.readBigInt64LE = defineBigIntMethod(function readBigInt64LE(offset) { + offset = offset >>> 0; + validateNumber(offset, "offset"); + const first = this[offset]; + const last = this[offset + 7]; + if (first === void 0 || last === void 0) { + boundsError(offset, this.length - 8); + } + const val = this[offset + 4] + this[offset + 5] * 2 ** 8 + this[offset + 6] * 2 ** 16 + (last << 24); + return (BigInt(val) << BigInt(32)) + BigInt(first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24); + }); + Buffer3.prototype.readBigInt64BE = defineBigIntMethod(function readBigInt64BE(offset) { + offset = offset >>> 0; + validateNumber(offset, "offset"); + const first = this[offset]; + const last = this[offset + 7]; + if (first === void 0 || last === void 0) { + boundsError(offset, this.length - 8); + } + const val = (first << 24) + // Overflow + 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); + }); + Buffer3.prototype.readFloatLE = function readFloatLE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) checkOffset(offset, 4, this.length); + return ieee754$1.read(this, offset, true, 23, 4); + }; + Buffer3.prototype.readFloatBE = function readFloatBE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) checkOffset(offset, 4, this.length); + return ieee754$1.read(this, offset, false, 23, 4); + }; + Buffer3.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) checkOffset(offset, 8, this.length); + return ieee754$1.read(this, offset, true, 52, 8); + }; + Buffer3.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) checkOffset(offset, 8, this.length); + return ieee754$1.read(this, offset, false, 52, 8); + }; + function checkInt(buf, value, offset, ext, max, min) { + if (!Buffer3.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"); + } + Buffer3.prototype.writeUintLE = Buffer3.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength4, noAssert) { + value = +value; + offset = offset >>> 0; + byteLength4 = byteLength4 >>> 0; + if (!noAssert) { + const maxBytes = Math.pow(2, 8 * byteLength4) - 1; + checkInt(this, value, offset, byteLength4, maxBytes, 0); + } + let mul = 1; + let i3 = 0; + this[offset] = value & 255; + while (++i3 < byteLength4 && (mul *= 256)) { + this[offset + i3] = value / mul & 255; + } + return offset + byteLength4; + }; + Buffer3.prototype.writeUintBE = Buffer3.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength4, noAssert) { + value = +value; + offset = offset >>> 0; + byteLength4 = byteLength4 >>> 0; + if (!noAssert) { + const maxBytes = Math.pow(2, 8 * byteLength4) - 1; + checkInt(this, value, offset, byteLength4, maxBytes, 0); + } + let i3 = byteLength4 - 1; + let mul = 1; + this[offset + i3] = value & 255; + while (--i3 >= 0 && (mul *= 256)) { + this[offset + i3] = value / mul & 255; + } + return offset + byteLength4; + }; + Buffer3.prototype.writeUint8 = Buffer3.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) checkInt(this, value, offset, 1, 255, 0); + this[offset] = value & 255; + return offset + 1; + }; + Buffer3.prototype.writeUint16LE = Buffer3.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) checkInt(this, value, offset, 2, 65535, 0); + this[offset] = value & 255; + this[offset + 1] = value >>> 8; + return offset + 2; + }; + Buffer3.prototype.writeUint16BE = Buffer3.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) checkInt(this, value, offset, 2, 65535, 0); + this[offset] = value >>> 8; + this[offset + 1] = value & 255; + return offset + 2; + }; + Buffer3.prototype.writeUint32LE = Buffer3.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0); + this[offset + 3] = value >>> 24; + this[offset + 2] = value >>> 16; + this[offset + 1] = value >>> 8; + this[offset] = value & 255; + return offset + 4; + }; + Buffer3.prototype.writeUint32BE = Buffer3.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0); + this[offset] = value >>> 24; + this[offset + 1] = value >>> 16; + this[offset + 2] = value >>> 8; + this[offset + 3] = value & 255; + return offset + 4; + }; + function wrtBigUInt64LE(buf, value, offset, min, max) { + checkIntBI(value, min, max, buf, offset, 7); + let lo = Number(value & BigInt(4294967295)); + buf[offset++] = lo; + lo = lo >> 8; + buf[offset++] = lo; + lo = lo >> 8; + buf[offset++] = lo; + lo = lo >> 8; + buf[offset++] = lo; + let hi = Number(value >> BigInt(32) & BigInt(4294967295)); + buf[offset++] = hi; + hi = hi >> 8; + buf[offset++] = hi; + hi = hi >> 8; + buf[offset++] = hi; + hi = hi >> 8; + buf[offset++] = hi; + return offset; + } + function wrtBigUInt64BE(buf, value, offset, min, max) { + checkIntBI(value, min, max, buf, offset, 7); + let lo = Number(value & BigInt(4294967295)); + buf[offset + 7] = lo; + lo = lo >> 8; + buf[offset + 6] = lo; + lo = lo >> 8; + buf[offset + 5] = lo; + lo = lo >> 8; + buf[offset + 4] = lo; + let hi = Number(value >> BigInt(32) & BigInt(4294967295)); + buf[offset + 3] = hi; + hi = hi >> 8; + buf[offset + 2] = hi; + hi = hi >> 8; + buf[offset + 1] = hi; + hi = hi >> 8; + buf[offset] = hi; + return offset + 8; + } + Buffer3.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE(value, offset = 0) { + return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff")); + }); + Buffer3.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE(value, offset = 0) { + return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff")); + }); + Buffer3.prototype.writeIntLE = function writeIntLE(value, offset, byteLength4, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) { + const limit = Math.pow(2, 8 * byteLength4 - 1); + checkInt(this, value, offset, byteLength4, limit - 1, -limit); + } + let i3 = 0; + let mul = 1; + let sub = 0; + this[offset] = value & 255; + while (++i3 < byteLength4 && (mul *= 256)) { + if (value < 0 && sub === 0 && this[offset + i3 - 1] !== 0) { + sub = 1; + } + this[offset + i3] = (value / mul >> 0) - sub & 255; + } + return offset + byteLength4; + }; + Buffer3.prototype.writeIntBE = function writeIntBE(value, offset, byteLength4, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) { + const limit = Math.pow(2, 8 * byteLength4 - 1); + checkInt(this, value, offset, byteLength4, limit - 1, -limit); + } + let i3 = byteLength4 - 1; + let mul = 1; + let sub = 0; + this[offset + i3] = value & 255; + while (--i3 >= 0 && (mul *= 256)) { + if (value < 0 && sub === 0 && this[offset + i3 + 1] !== 0) { + sub = 1; + } + this[offset + i3] = (value / mul >> 0) - sub & 255; + } + return offset + byteLength4; + }; + Buffer3.prototype.writeInt8 = function writeInt8(value, offset, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) checkInt(this, value, offset, 1, 127, -128); + if (value < 0) value = 255 + value + 1; + this[offset] = value & 255; + return offset + 1; + }; + Buffer3.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) checkInt(this, value, offset, 2, 32767, -32768); + this[offset] = value & 255; + this[offset + 1] = value >>> 8; + return offset + 2; + }; + Buffer3.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) checkInt(this, value, offset, 2, 32767, -32768); + this[offset] = value >>> 8; + this[offset + 1] = value & 255; + return offset + 2; + }; + Buffer3.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) checkInt(this, value, offset, 4, 2147483647, -2147483648); + this[offset] = value & 255; + this[offset + 1] = value >>> 8; + this[offset + 2] = value >>> 16; + this[offset + 3] = value >>> 24; + return offset + 4; + }; + Buffer3.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) checkInt(this, value, offset, 4, 2147483647, -2147483648); + if (value < 0) value = 4294967295 + value + 1; + this[offset] = value >>> 24; + this[offset + 1] = value >>> 16; + this[offset + 2] = value >>> 8; + this[offset + 3] = value & 255; + return offset + 4; + }; + Buffer3.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE(value, offset = 0) { + return wrtBigUInt64LE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff")); + }); + Buffer3.prototype.writeBigInt64BE = defineBigIntMethod(function writeBigInt64BE(value, offset = 0) { + return wrtBigUInt64BE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff")); + }); + function checkIEEE754(buf, value, offset, ext, max, min) { + if (offset + ext > buf.length) throw new RangeError("Index out of range"); + if (offset < 0) throw new RangeError("Index out of range"); + } + function writeFloat(buf, value, offset, littleEndian, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) { + checkIEEE754(buf, value, offset, 4); + } + ieee754$1.write(buf, value, offset, littleEndian, 23, 4); + return offset + 4; + } + Buffer3.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) { + return writeFloat(this, value, offset, true, noAssert); + }; + Buffer3.prototype.writeFloatBE = function writeFloatBE(value, offset, noAssert) { + return writeFloat(this, value, offset, false, noAssert); + }; + function writeDouble(buf, value, offset, littleEndian, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) { + checkIEEE754(buf, value, offset, 8); + } + ieee754$1.write(buf, value, offset, littleEndian, 52, 8); + return offset + 8; + } + Buffer3.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) { + return writeDouble(this, value, offset, true, noAssert); + }; + Buffer3.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) { + return writeDouble(this, value, offset, false, noAssert); + }; + Buffer3.prototype.copy = function copy(target, targetStart, start, end) { + if (!Buffer3.isBuffer(target)) throw new TypeError("argument should be a Buffer"); + if (!start) start = 0; + if (!end && end !== 0) end = this.length; + if (targetStart >= target.length) targetStart = target.length; + if (!targetStart) targetStart = 0; + if (end > 0 && end < start) end = start; + if (end === start) return 0; + if (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"); + if (end > this.length) end = this.length; + if (target.length - targetStart < end - start) { + end = target.length - targetStart + start; + } + const len3 = end - start; + if (this === target && typeof GlobalUint8Array.prototype.copyWithin === "function") { + this.copyWithin(targetStart, start, end); + } else { + GlobalUint8Array.prototype.set.call( + target, + this.subarray(start, end), + targetStart + ); + } + return len3; + }; + Buffer3.prototype.fill = function fill(val, start, end, encoding) { + if (typeof val === "string") { + if (typeof start === "string") { + encoding = start; + start = 0; + end = this.length; + } else if (typeof end === "string") { + encoding = end; + end = this.length; + } + if (encoding !== void 0 && typeof encoding !== "string") { + throw new TypeError("encoding must be a string"); + } + if (typeof encoding === "string" && !Buffer3.isEncoding(encoding)) { + throw new TypeError("Unknown encoding: " + encoding); + } + if (val.length === 1) { + const code3 = val.charCodeAt(0); + if (encoding === "utf8" && code3 < 128 || encoding === "latin1") { + val = code3; + } + } + } else if (typeof val === "number") { + val = val & 255; + } else if (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; + if (!val) val = 0; + let i3; + if (typeof val === "number") { + for (i3 = start; i3 < end; ++i3) { + this[i3] = val; + } + } else { + const bytes = Buffer3.isBuffer(val) ? val : Buffer3.from(val, encoding); + const len3 = bytes.length; + if (len3 === 0) { + throw new TypeError('The value "' + val + '" is invalid for argument "value"'); + } + for (i3 = 0; i3 < end - start; ++i3) { + this[i3 + start] = bytes[i3 % len3]; + } + } + return this; + }; + const errors = {}; + function E(sym, getMessage, Base) { + errors[sym] = class NodeError extends Base { + constructor() { + super(); + Object.defineProperty(this, "message", { + value: getMessage.apply(this, arguments), + writable: true, + configurable: true + }); + this.name = `${this.name} [${sym}]`; + this.stack; + delete this.name; + } + get code() { + return sym; + } + set code(value) { + Object.defineProperty(this, "code", { + configurable: true, + enumerable: true, + value, + writable: true + }); + } + toString() { + return `${this.name} [${sym}]: ${this.message}`; + } + }; + } + E( + "ERR_BUFFER_OUT_OF_BOUNDS", + function(name) { + if (name) { + return `${name} is outside of buffer bounds`; + } + return "Attempt to access memory outside buffer bounds"; + }, + RangeError + ); + E( + "ERR_INVALID_ARG_TYPE", + function(name, actual) { + return `The "${name}" argument must be of type number. Received type ${typeof actual}`; + }, + TypeError + ); + E( + "ERR_OUT_OF_RANGE", + function(str, range2, input) { + let msg = `The value of "${str}" is out of range.`; + let received = input; + if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) { + received = addNumericalSeparator(String(input)); + } else if (typeof input === "bigint") { + received = String(input); + if (input > BigInt(2) ** BigInt(32) || input < -(BigInt(2) ** BigInt(32))) { + received = addNumericalSeparator(received); + } + received += "n"; + } + msg += ` It must be ${range2}. Received ${received}`; + return msg; + }, + RangeError + ); + function addNumericalSeparator(val) { + let res = ""; + let i3 = val.length; + const start = val[0] === "-" ? 1 : 0; + for (; i3 >= start + 4; i3 -= 3) { + res = `_${val.slice(i3 - 3, i3)}${res}`; + } + return `${val.slice(0, i3)}${res}`; + } + function checkBounds(buf, offset, byteLength4) { + validateNumber(offset, "offset"); + if (buf[offset] === void 0 || buf[offset + byteLength4] === void 0) { + boundsError(offset, buf.length - (byteLength4 + 1)); + } + } + function checkIntBI(value, min, max, buf, offset, byteLength4) { + if (value > max || value < min) { + const n = typeof min === "bigint" ? "n" : ""; + let range2; + { + if (min === 0 || min === BigInt(0)) { + range2 = `>= 0${n} and < 2${n} ** ${(byteLength4 + 1) * 8}${n}`; + } else { + range2 = `>= -(2${n} ** ${(byteLength4 + 1) * 8 - 1}${n}) and < 2 ** ${(byteLength4 + 1) * 8 - 1}${n}`; + } + } + throw new errors.ERR_OUT_OF_RANGE("value", range2, value); + } + checkBounds(buf, offset, byteLength4); + } + function validateNumber(value, name) { + if (typeof value !== "number") { + throw new errors.ERR_INVALID_ARG_TYPE(name, "number", value); + } + } + function boundsError(value, length, type2) { + if (Math.floor(value) !== value) { + validateNumber(value, type2); + throw new errors.ERR_OUT_OF_RANGE("offset", "an integer", value); + } + if (length < 0) { + throw new errors.ERR_BUFFER_OUT_OF_BOUNDS(); + } + throw new errors.ERR_OUT_OF_RANGE( + "offset", + `>= ${0} and <= ${length}`, + value + ); + } + const INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g; + function base64clean(str) { + str = str.split("=")[0]; + str = str.trim().replace(INVALID_BASE64_RE, ""); + if (str.length < 2) return ""; + while (str.length % 4 !== 0) { + str = str + "="; + } + return str; + } + function utf8ToBytes(string, units) { + units = units || Infinity; + let codePoint; + const length = string.length; + let leadSurrogate = null; + const bytes = []; + for (let i3 = 0; i3 < length; ++i3) { + codePoint = string.charCodeAt(i3); + if (codePoint > 55295 && codePoint < 57344) { + if (!leadSurrogate) { + if (codePoint > 56319) { + if ((units -= 3) > -1) bytes.push(239, 191, 189); + continue; + } else if (i3 + 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); + } + leadSurrogate = null; + if (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) { + const byteArray = []; + for (let i3 = 0; i3 < str.length; ++i3) { + byteArray.push(str.charCodeAt(i3) & 255); + } + return byteArray; + } + function utf16leToBytes(str, units) { + let c, hi, lo; + const byteArray = []; + for (let i3 = 0; i3 < str.length; ++i3) { + if ((units -= 2) < 0) break; + c = str.charCodeAt(i3); + 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 i3; + for (i3 = 0; i3 < length; ++i3) { + if (i3 + offset >= dst.length || i3 >= src.length) break; + dst[i3 + offset] = src[i3]; + } + return i3; + } + function isInstance(obj, type2) { + return obj instanceof type2 || obj != null && obj.constructor != null && obj.constructor.name != null && obj.constructor.name === type2.name; + } + function numberIsNaN(obj) { + return obj !== obj; + } + const hexSliceLookupTable = function() { + const alphabet = "0123456789abcdef"; + const table = new Array(256); + for (let i3 = 0; i3 < 16; ++i3) { + const i16 = i3 * 16; + for (let j = 0; j < 16; ++j) { + table[i16 + j] = alphabet[i3] + alphabet[j]; + } + } + return table; + }(); + function defineBigIntMethod(fn) { + return typeof BigInt === "undefined" ? BufferBigIntNotDefined : fn; + } + function BufferBigIntNotDefined() { + throw new Error("BigInt not supported"); + } + })(buffer2); + const Buffer2 = buffer2.Buffer; + exports2.Blob = buffer2.Blob; + exports2.BlobOptions = buffer2.BlobOptions; + exports2.Buffer = buffer2.Buffer; + exports2.File = buffer2.File; + exports2.FileOptions = buffer2.FileOptions; + exports2.INSPECT_MAX_BYTES = buffer2.INSPECT_MAX_BYTES; + exports2.SlowBuffer = buffer2.SlowBuffer; + exports2.TranscodeEncoding = buffer2.TranscodeEncoding; + exports2.atob = buffer2.atob; + exports2.btoa = buffer2.btoa; + exports2.constants = buffer2.constants; + exports2.default = Buffer2; + exports2.isAscii = buffer2.isAscii; + exports2.isUtf8 = buffer2.isUtf8; + exports2.kMaxLength = buffer2.kMaxLength; + exports2.kStringMaxLength = buffer2.kStringMaxLength; + exports2.resolveObjectURL = buffer2.resolveObjectURL; + exports2.transcode = buffer2.transcode; + })(dist); + return dist; +} +/*! safe-buffer. MIT License. Feross Aboukhadijeh */ +var hasRequiredSafeBuffer$1; +function requireSafeBuffer$1() { + if (hasRequiredSafeBuffer$1) return safeBuffer$1.exports; + hasRequiredSafeBuffer$1 = 1; + (function(module2, exports2) { + var buffer2 = requireDist(); + var Buffer2 = buffer2.Buffer; + function copyProps(src, dst) { + for (var key2 in src) { + dst[key2] = src[key2]; + } + } + if (Buffer2.from && Buffer2.alloc && Buffer2.allocUnsafe && Buffer2.allocUnsafeSlow) { + module2.exports = buffer2; + } else { + copyProps(buffer2, exports2); + exports2.Buffer = SafeBuffer; + } + function SafeBuffer(arg, encodingOrOffset, length) { + return Buffer2(arg, encodingOrOffset, length); + } + SafeBuffer.prototype = Object.create(Buffer2.prototype); + copyProps(Buffer2, SafeBuffer); + SafeBuffer.from = function(arg, encodingOrOffset, length) { + if (typeof arg === "number") { + throw new TypeError("Argument must not be a number"); + } + return Buffer2(arg, encodingOrOffset, length); + }; + SafeBuffer.alloc = function(size, fill, encoding) { + if (typeof size !== "number") { + throw new TypeError("Argument must be a number"); + } + var buf = Buffer2(size); + if (fill !== void 0) { + if (typeof encoding === "string") { + buf.fill(fill, encoding); + } else { + buf.fill(fill); + } + } else { + buf.fill(0); + } + return buf; + }; + SafeBuffer.allocUnsafe = function(size) { + if (typeof size !== "number") { + throw new TypeError("Argument must be a number"); + } + return Buffer2(size); + }; + SafeBuffer.allocUnsafeSlow = function(size) { + if (typeof size !== "number") { + throw new TypeError("Argument must be a number"); + } + return buffer2.SlowBuffer(size); + }; + })(safeBuffer$1, safeBuffer$1.exports); + return safeBuffer$1.exports; +} +var hasRequiredBrowser$b; +function requireBrowser$b() { + if (hasRequiredBrowser$b) return browser$b.exports; + hasRequiredBrowser$b = 1; + var MAX_BYTES = 65536; + var MAX_UINT32 = 4294967295; + function oldBrowser() { + throw new Error("Secure random number generation is not supported by this browser.\nUse Chrome, Firefox or Internet Explorer 11"); + } + var Buffer2 = requireSafeBuffer$1().Buffer; + var crypto = commonjsGlobal.crypto || commonjsGlobal.msCrypto; + if (crypto && crypto.getRandomValues) { + browser$b.exports = randomBytes; + } else { + browser$b.exports = oldBrowser; + } + function randomBytes(size, cb) { + if (size > MAX_UINT32) throw new RangeError("requested too many random bytes"); + var bytes = Buffer2.allocUnsafe(size); + if (size > 0) { + if (size > MAX_BYTES) { + for (var generated = 0; generated < size; generated += MAX_BYTES) { + crypto.getRandomValues(bytes.slice(generated, generated + MAX_BYTES)); + } + } else { + crypto.getRandomValues(bytes); + } + } + if (typeof cb === "function") { + return process$1.nextTick(function() { + cb(null, bytes); + }); + } + return bytes; + } + return browser$b.exports; +} +var inherits_browser = { exports: {} }; +var hasRequiredInherits_browser; +function requireInherits_browser() { + if (hasRequiredInherits_browser) return inherits_browser.exports; + hasRequiredInherits_browser = 1; + if (typeof Object.create === "function") { + inherits_browser.exports = function inherits(ctor, superCtor) { + if (superCtor) { + ctor.super_ = superCtor; + ctor.prototype = Object.create(superCtor.prototype, { + constructor: { + value: ctor, + enumerable: false, + writable: true, + configurable: true + } + }); + } + }; + } else { + inherits_browser.exports = function inherits(ctor, superCtor) { + if (superCtor) { + ctor.super_ = superCtor; + var TempCtor = function() { + }; + TempCtor.prototype = superCtor.prototype; + ctor.prototype = new TempCtor(); + ctor.prototype.constructor = ctor; + } + }; + } + return inherits_browser.exports; +} +var readableBrowser$1 = { exports: {} }; +var events = { exports: {} }; +var hasRequiredEvents; +function requireEvents() { + if (hasRequiredEvents) return events.exports; + hasRequiredEvents = 1; + var R = typeof Reflect === "object" ? Reflect : null; + var ReflectApply = R && typeof R.apply === "function" ? R.apply : function ReflectApply2(target, receiver, args) { + return Function.prototype.apply.call(target, receiver, args); + }; + var ReflectOwnKeys; + if (R && typeof R.ownKeys === "function") { + ReflectOwnKeys = R.ownKeys; + } else if (Object.getOwnPropertySymbols) { + ReflectOwnKeys = function ReflectOwnKeys2(target) { + return Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target)); + }; + } else { + ReflectOwnKeys = function ReflectOwnKeys2(target) { + return Object.getOwnPropertyNames(target); + }; + } + function ProcessEmitWarning(warning) { + if (console && console.warn) console.warn(warning); + } + var NumberIsNaN = Number.isNaN || function NumberIsNaN2(value) { + return value !== value; + }; + function EventEmitter() { + EventEmitter.init.call(this); + } + events.exports = EventEmitter; + events.exports.once = once; + EventEmitter.EventEmitter = EventEmitter; + EventEmitter.prototype._events = void 0; + EventEmitter.prototype._eventsCount = 0; + EventEmitter.prototype._maxListeners = void 0; + var defaultMaxListeners = 10; + function checkListener(listener) { + if (typeof listener !== "function") { + throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener); + } + } + Object.defineProperty(EventEmitter, "defaultMaxListeners", { + enumerable: true, + get: function() { + return defaultMaxListeners; + }, + set: function(arg) { + if (typeof arg !== "number" || arg < 0 || NumberIsNaN(arg)) { + throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + "."); + } + defaultMaxListeners = arg; + } + }); + EventEmitter.init = function() { + if (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) { + this._events = /* @__PURE__ */ Object.create(null); + this._eventsCount = 0; + } + this._maxListeners = this._maxListeners || void 0; + }; + EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) { + if (typeof n !== "number" || n < 0 || NumberIsNaN(n)) { + throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + "."); + } + this._maxListeners = n; + return this; + }; + function _getMaxListeners(that) { + if (that._maxListeners === void 0) + return EventEmitter.defaultMaxListeners; + return that._maxListeners; + } + EventEmitter.prototype.getMaxListeners = function getMaxListeners() { + return _getMaxListeners(this); + }; + EventEmitter.prototype.emit = function emit(type2) { + var args = []; + for (var i2 = 1; i2 < arguments.length; i2++) args.push(arguments[i2]); + var doError = type2 === "error"; + var events2 = this._events; + if (events2 !== void 0) + doError = doError && events2.error === void 0; + else if (!doError) + return false; + if (doError) { + var er; + if (args.length > 0) + er = args[0]; + if (er instanceof Error) { + throw er; + } + var err = new Error("Unhandled error." + (er ? " (" + er.message + ")" : "")); + err.context = er; + throw err; + } + var handler = events2[type2]; + if (handler === void 0) + return false; + if (typeof handler === "function") { + ReflectApply(handler, this, args); + } else { + var len2 = handler.length; + var listeners = arrayClone(handler, len2); + for (var i2 = 0; i2 < len2; ++i2) + ReflectApply(listeners[i2], this, args); + } + return true; + }; + function _addListener(target, type2, listener, prepend) { + var m; + var events2; + var existing; + checkListener(listener); + events2 = target._events; + if (events2 === void 0) { + events2 = target._events = /* @__PURE__ */ Object.create(null); + target._eventsCount = 0; + } else { + if (events2.newListener !== void 0) { + target.emit( + "newListener", + type2, + listener.listener ? listener.listener : listener + ); + events2 = target._events; + } + existing = events2[type2]; + } + if (existing === void 0) { + existing = events2[type2] = listener; + ++target._eventsCount; + } else { + if (typeof existing === "function") { + existing = events2[type2] = prepend ? [listener, existing] : [existing, listener]; + } else if (prepend) { + existing.unshift(listener); + } else { + existing.push(listener); + } + m = _getMaxListeners(target); + if (m > 0 && existing.length > m && !existing.warned) { + existing.warned = true; + var w = new Error("Possible EventEmitter memory leak detected. " + existing.length + " " + String(type2) + " listeners added. Use emitter.setMaxListeners() to increase limit"); + w.name = "MaxListenersExceededWarning"; + w.emitter = target; + w.type = type2; + w.count = existing.length; + ProcessEmitWarning(w); + } + } + return target; + } + EventEmitter.prototype.addListener = function addListener(type2, listener) { + return _addListener(this, type2, listener, false); + }; + EventEmitter.prototype.on = EventEmitter.prototype.addListener; + EventEmitter.prototype.prependListener = function prependListener(type2, listener) { + return _addListener(this, type2, listener, true); + }; + function onceWrapper() { + if (!this.fired) { + this.target.removeListener(this.type, this.wrapFn); + this.fired = true; + if (arguments.length === 0) + return this.listener.call(this.target); + return this.listener.apply(this.target, arguments); + } + } + function _onceWrap(target, type2, listener) { + var state2 = { fired: false, wrapFn: void 0, target, type: type2, listener }; + var wrapped = onceWrapper.bind(state2); + wrapped.listener = listener; + state2.wrapFn = wrapped; + return wrapped; + } + EventEmitter.prototype.once = function once2(type2, listener) { + checkListener(listener); + this.on(type2, _onceWrap(this, type2, listener)); + return this; + }; + EventEmitter.prototype.prependOnceListener = function prependOnceListener(type2, listener) { + checkListener(listener); + this.prependListener(type2, _onceWrap(this, type2, listener)); + return this; + }; + EventEmitter.prototype.removeListener = function removeListener(type2, listener) { + var list, events2, position, i2, originalListener; + checkListener(listener); + events2 = this._events; + if (events2 === void 0) + return this; + list = events2[type2]; + if (list === void 0) + return this; + if (list === listener || list.listener === listener) { + if (--this._eventsCount === 0) + this._events = /* @__PURE__ */ Object.create(null); + else { + delete events2[type2]; + if (events2.removeListener) + this.emit("removeListener", type2, list.listener || listener); + } + } else if (typeof list !== "function") { + position = -1; + for (i2 = list.length - 1; i2 >= 0; i2--) { + if (list[i2] === listener || list[i2].listener === listener) { + originalListener = list[i2].listener; + position = i2; + break; + } + } + if (position < 0) + return this; + if (position === 0) + list.shift(); + else { + spliceOne(list, position); + } + if (list.length === 1) + events2[type2] = list[0]; + if (events2.removeListener !== void 0) + this.emit("removeListener", type2, originalListener || listener); + } + return this; + }; + EventEmitter.prototype.off = EventEmitter.prototype.removeListener; + EventEmitter.prototype.removeAllListeners = function removeAllListeners(type2) { + var listeners, events2, i2; + events2 = this._events; + if (events2 === void 0) + return this; + if (events2.removeListener === void 0) { + if (arguments.length === 0) { + this._events = /* @__PURE__ */ Object.create(null); + this._eventsCount = 0; + } else if (events2[type2] !== void 0) { + if (--this._eventsCount === 0) + this._events = /* @__PURE__ */ Object.create(null); + else + delete events2[type2]; + } + return this; + } + if (arguments.length === 0) { + var keys = Object.keys(events2); + var key2; + for (i2 = 0; i2 < keys.length; ++i2) { + key2 = keys[i2]; + if (key2 === "removeListener") continue; + this.removeAllListeners(key2); + } + this.removeAllListeners("removeListener"); + this._events = /* @__PURE__ */ Object.create(null); + this._eventsCount = 0; + return this; + } + listeners = events2[type2]; + if (typeof listeners === "function") { + this.removeListener(type2, listeners); + } else if (listeners !== void 0) { + for (i2 = listeners.length - 1; i2 >= 0; i2--) { + this.removeListener(type2, listeners[i2]); + } + } + return this; + }; + function _listeners(target, type2, unwrap) { + var events2 = target._events; + if (events2 === void 0) + return []; + var evlistener = events2[type2]; + if (evlistener === void 0) + return []; + if (typeof evlistener === "function") + return unwrap ? [evlistener.listener || evlistener] : [evlistener]; + return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length); + } + EventEmitter.prototype.listeners = function listeners(type2) { + return _listeners(this, type2, true); + }; + EventEmitter.prototype.rawListeners = function rawListeners(type2) { + return _listeners(this, type2, false); + }; + EventEmitter.listenerCount = function(emitter, type2) { + if (typeof emitter.listenerCount === "function") { + return emitter.listenerCount(type2); + } else { + return listenerCount.call(emitter, type2); + } + }; + EventEmitter.prototype.listenerCount = listenerCount; + function listenerCount(type2) { + var events2 = this._events; + if (events2 !== void 0) { + var evlistener = events2[type2]; + if (typeof evlistener === "function") { + return 1; + } else if (evlistener !== void 0) { + return evlistener.length; + } + } + return 0; + } + EventEmitter.prototype.eventNames = function eventNames() { + return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : []; + }; + function arrayClone(arr, n) { + var copy = new Array(n); + for (var i2 = 0; i2 < n; ++i2) + copy[i2] = arr[i2]; + return copy; + } + function spliceOne(list, index) { + for (; index + 1 < list.length; index++) + list[index] = list[index + 1]; + list.pop(); + } + function unwrapListeners(arr) { + var ret = new Array(arr.length); + for (var i2 = 0; i2 < ret.length; ++i2) { + ret[i2] = arr[i2].listener || arr[i2]; + } + return ret; + } + function once(emitter, name) { + return new Promise(function(resolve, reject) { + function errorListener(err) { + emitter.removeListener(name, resolver); + reject(err); + } + function resolver() { + if (typeof emitter.removeListener === "function") { + emitter.removeListener("error", errorListener); + } + resolve([].slice.call(arguments)); + } + eventTargetAgnosticAddListener(emitter, name, resolver, { once: true }); + if (name !== "error") { + addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true }); + } + }); + } + function addErrorHandlerIfEventEmitter(emitter, handler, flags) { + if (typeof emitter.on === "function") { + eventTargetAgnosticAddListener(emitter, "error", handler, flags); + } + } + function eventTargetAgnosticAddListener(emitter, name, listener, flags) { + if (typeof emitter.on === "function") { + if (flags.once) { + emitter.once(name, listener); + } else { + emitter.on(name, listener); + } + } else if (typeof emitter.addEventListener === "function") { + emitter.addEventListener(name, function wrapListener(arg) { + if (flags.once) { + emitter.removeEventListener(name, wrapListener); + } + listener(arg); + }); + } else { + throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter); + } + } + return events.exports; +} +var streamBrowser$1; +var hasRequiredStreamBrowser$1; +function requireStreamBrowser$1() { + if (hasRequiredStreamBrowser$1) return streamBrowser$1; + hasRequiredStreamBrowser$1 = 1; + streamBrowser$1 = requireEvents().EventEmitter; + return streamBrowser$1; +} +var util$1 = {}; +var types = {}; +var shams$1; +var hasRequiredShams$1; +function requireShams$1() { + if (hasRequiredShams$1) return shams$1; + hasRequiredShams$1 = 1; + shams$1 = function hasSymbols2() { + if (typeof Symbol !== "function" || typeof Object.getOwnPropertySymbols !== "function") { + return false; + } + if (typeof Symbol.iterator === "symbol") { + return true; + } + var obj = {}; + var sym = Symbol("test"); + var symObj = Object(sym); + if (typeof sym === "string") { + return false; + } + if (Object.prototype.toString.call(sym) !== "[object Symbol]") { + return false; + } + if (Object.prototype.toString.call(symObj) !== "[object Symbol]") { + return false; + } + var symVal = 42; + obj[sym] = symVal; + for (sym in obj) { + return false; + } + if (typeof Object.keys === "function" && Object.keys(obj).length !== 0) { + return false; + } + if (typeof Object.getOwnPropertyNames === "function" && Object.getOwnPropertyNames(obj).length !== 0) { + return false; + } + var syms = Object.getOwnPropertySymbols(obj); + if (syms.length !== 1 || syms[0] !== sym) { + return false; + } + if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) { + return false; + } + if (typeof Object.getOwnPropertyDescriptor === "function") { + var descriptor = Object.getOwnPropertyDescriptor(obj, sym); + if (descriptor.value !== symVal || descriptor.enumerable !== true) { + return false; + } + } + return true; + }; + return shams$1; +} +var shams; +var hasRequiredShams; +function requireShams() { + if (hasRequiredShams) return shams; + hasRequiredShams = 1; + var hasSymbols2 = requireShams$1(); + shams = function hasToStringTagShams() { + return hasSymbols2() && !!Symbol.toStringTag; + }; + return shams; +} +var esErrors; +var hasRequiredEsErrors; +function requireEsErrors() { + if (hasRequiredEsErrors) return esErrors; + hasRequiredEsErrors = 1; + esErrors = Error; + return esErrors; +} +var _eval; +var hasRequired_eval; +function require_eval() { + if (hasRequired_eval) return _eval; + hasRequired_eval = 1; + _eval = EvalError; + return _eval; +} +var range; +var hasRequiredRange; +function requireRange() { + if (hasRequiredRange) return range; + hasRequiredRange = 1; + range = RangeError; + return range; +} +var ref; +var hasRequiredRef; +function requireRef() { + if (hasRequiredRef) return ref; + hasRequiredRef = 1; + ref = ReferenceError; + return ref; +} +var syntax; +var hasRequiredSyntax; +function requireSyntax() { + if (hasRequiredSyntax) return syntax; + hasRequiredSyntax = 1; + syntax = SyntaxError; + return syntax; +} +var type; +var hasRequiredType; +function requireType() { + if (hasRequiredType) return type; + hasRequiredType = 1; + type = TypeError; + return type; +} +var uri; +var hasRequiredUri; +function requireUri() { + if (hasRequiredUri) return uri; + hasRequiredUri = 1; + uri = URIError; + return uri; +} +var hasSymbols; +var hasRequiredHasSymbols; +function requireHasSymbols() { + if (hasRequiredHasSymbols) return hasSymbols; + hasRequiredHasSymbols = 1; + var origSymbol = typeof Symbol !== "undefined" && Symbol; + var hasSymbolSham = requireShams$1(); + hasSymbols = function hasNativeSymbols() { + if (typeof origSymbol !== "function") { + return false; + } + if (typeof Symbol !== "function") { + return false; + } + if (typeof origSymbol("foo") !== "symbol") { + return false; + } + if (typeof Symbol("bar") !== "symbol") { + return false; + } + return hasSymbolSham(); + }; + return hasSymbols; +} +var hasProto; +var hasRequiredHasProto; +function requireHasProto() { + if (hasRequiredHasProto) return hasProto; + hasRequiredHasProto = 1; + var test = { + __proto__: null, + foo: {} + }; + var $Object = Object; + hasProto = function hasProto2() { + return { __proto__: test }.foo === test.foo && !(test instanceof $Object); + }; + return hasProto; +} +var implementation; +var hasRequiredImplementation; +function requireImplementation() { + if (hasRequiredImplementation) return implementation; + hasRequiredImplementation = 1; + var ERROR_MESSAGE = "Function.prototype.bind called on incompatible "; + var toStr = Object.prototype.toString; + var max = Math.max; + var funcType = "[object Function]"; + var concatty = function concatty2(a, b) { + var arr = []; + for (var i2 = 0; i2 < a.length; i2 += 1) { + arr[i2] = a[i2]; + } + for (var j = 0; j < b.length; j += 1) { + arr[j + a.length] = b[j]; + } + return arr; + }; + var slicy = function slicy2(arrLike, offset) { + var arr = []; + for (var i2 = offset, j = 0; i2 < arrLike.length; i2 += 1, j += 1) { + arr[j] = arrLike[i2]; + } + return arr; + }; + var joiny = function(arr, joiner) { + var str = ""; + for (var i2 = 0; i2 < arr.length; i2 += 1) { + str += arr[i2]; + if (i2 + 1 < arr.length) { + str += joiner; + } + } + return str; + }; + implementation = function bind(that) { + var target = this; + if (typeof target !== "function" || toStr.apply(target) !== funcType) { + throw new TypeError(ERROR_MESSAGE + target); + } + var args = slicy(arguments, 1); + var bound; + var binder = function() { + if (this instanceof bound) { + var result = target.apply( + this, + concatty(args, arguments) + ); + if (Object(result) === result) { + return result; + } + return this; + } + return target.apply( + that, + concatty(args, arguments) + ); + }; + var boundLength = max(0, target.length - args.length); + var boundArgs = []; + for (var i2 = 0; i2 < boundLength; i2++) { + boundArgs[i2] = "$" + i2; + } + bound = Function("binder", "return function (" + joiny(boundArgs, ",") + "){ return binder.apply(this,arguments); }")(binder); + if (target.prototype) { + var Empty = function Empty2() { + }; + Empty.prototype = target.prototype; + bound.prototype = new Empty(); + Empty.prototype = null; + } + return bound; + }; + return implementation; +} +var functionBind; +var hasRequiredFunctionBind; +function requireFunctionBind() { + if (hasRequiredFunctionBind) return functionBind; + hasRequiredFunctionBind = 1; + var implementation2 = requireImplementation(); + functionBind = Function.prototype.bind || implementation2; + return functionBind; +} +var hasown; +var hasRequiredHasown; +function requireHasown() { + if (hasRequiredHasown) return hasown; + hasRequiredHasown = 1; + var call = Function.prototype.call; + var $hasOwn = Object.prototype.hasOwnProperty; + var bind = requireFunctionBind(); + hasown = bind.call(call, $hasOwn); + return hasown; +} +var getIntrinsic; +var hasRequiredGetIntrinsic; +function requireGetIntrinsic() { + if (hasRequiredGetIntrinsic) return getIntrinsic; + hasRequiredGetIntrinsic = 1; + var undefined$1; + var $Error = /* @__PURE__ */ requireEsErrors(); + var $EvalError = /* @__PURE__ */ require_eval(); + var $RangeError = /* @__PURE__ */ requireRange(); + var $ReferenceError = /* @__PURE__ */ requireRef(); + var $SyntaxError = /* @__PURE__ */ requireSyntax(); + var $TypeError = /* @__PURE__ */ requireType(); + var $URIError = /* @__PURE__ */ requireUri(); + var $Function = Function; + var getEvalledConstructor = function(expressionSyntax) { + try { + return $Function('"use strict"; return (' + expressionSyntax + ").constructor;")(); + } catch (e) { + } + }; + var $gOPD = Object.getOwnPropertyDescriptor; + if ($gOPD) { + try { + $gOPD({}, ""); + } catch (e) { + $gOPD = null; + } + } + var throwTypeError = function() { + throw new $TypeError(); + }; + var ThrowTypeError = $gOPD ? function() { + try { + arguments.callee; + return throwTypeError; + } catch (calleeThrows) { + try { + return $gOPD(arguments, "callee").get; + } catch (gOPDthrows) { + return throwTypeError; + } + } + }() : throwTypeError; + var hasSymbols2 = requireHasSymbols()(); + var hasProto2 = /* @__PURE__ */ requireHasProto()(); + var getProto = Object.getPrototypeOf || (hasProto2 ? function(x) { + return x.__proto__; + } : null); + var needsEval = {}; + var TypedArray = typeof Uint8Array === "undefined" || !getProto ? undefined$1 : getProto(Uint8Array); + var INTRINSICS = { + __proto__: null, + "%AggregateError%": typeof AggregateError === "undefined" ? undefined$1 : AggregateError, + "%Array%": Array, + "%ArrayBuffer%": typeof ArrayBuffer === "undefined" ? undefined$1 : ArrayBuffer, + "%ArrayIteratorPrototype%": hasSymbols2 && getProto ? getProto([][Symbol.iterator]()) : undefined$1, + "%AsyncFromSyncIteratorPrototype%": undefined$1, + "%AsyncFunction%": needsEval, + "%AsyncGenerator%": needsEval, + "%AsyncGeneratorFunction%": needsEval, + "%AsyncIteratorPrototype%": needsEval, + "%Atomics%": typeof Atomics === "undefined" ? undefined$1 : Atomics, + "%BigInt%": typeof BigInt === "undefined" ? undefined$1 : BigInt, + "%BigInt64Array%": typeof BigInt64Array === "undefined" ? undefined$1 : BigInt64Array, + "%BigUint64Array%": typeof BigUint64Array === "undefined" ? undefined$1 : BigUint64Array, + "%Boolean%": Boolean, + "%DataView%": typeof DataView === "undefined" ? undefined$1 : DataView, + "%Date%": Date, + "%decodeURI%": decodeURI, + "%decodeURIComponent%": decodeURIComponent, + "%encodeURI%": encodeURI, + "%encodeURIComponent%": encodeURIComponent, + "%Error%": $Error, + "%eval%": eval, + // eslint-disable-line no-eval + "%EvalError%": $EvalError, + "%Float32Array%": typeof Float32Array === "undefined" ? undefined$1 : Float32Array, + "%Float64Array%": typeof Float64Array === "undefined" ? undefined$1 : Float64Array, + "%FinalizationRegistry%": typeof FinalizationRegistry === "undefined" ? undefined$1 : FinalizationRegistry, + "%Function%": $Function, + "%GeneratorFunction%": needsEval, + "%Int8Array%": typeof Int8Array === "undefined" ? undefined$1 : Int8Array, + "%Int16Array%": typeof Int16Array === "undefined" ? undefined$1 : Int16Array, + "%Int32Array%": typeof Int32Array === "undefined" ? undefined$1 : Int32Array, + "%isFinite%": isFinite, + "%isNaN%": isNaN, + "%IteratorPrototype%": hasSymbols2 && getProto ? getProto(getProto([][Symbol.iterator]())) : undefined$1, + "%JSON%": typeof JSON === "object" ? JSON : undefined$1, + "%Map%": typeof Map === "undefined" ? undefined$1 : Map, + "%MapIteratorPrototype%": typeof Map === "undefined" || !hasSymbols2 || !getProto ? undefined$1 : getProto((/* @__PURE__ */ new Map())[Symbol.iterator]()), + "%Math%": Math, + "%Number%": Number, + "%Object%": Object, + "%parseFloat%": parseFloat, + "%parseInt%": parseInt, + "%Promise%": typeof Promise === "undefined" ? undefined$1 : Promise, + "%Proxy%": typeof Proxy === "undefined" ? undefined$1 : Proxy, + "%RangeError%": $RangeError, + "%ReferenceError%": $ReferenceError, + "%Reflect%": typeof Reflect === "undefined" ? undefined$1 : Reflect, + "%RegExp%": RegExp, + "%Set%": typeof Set === "undefined" ? undefined$1 : Set, + "%SetIteratorPrototype%": typeof Set === "undefined" || !hasSymbols2 || !getProto ? undefined$1 : getProto((/* @__PURE__ */ new Set())[Symbol.iterator]()), + "%SharedArrayBuffer%": typeof SharedArrayBuffer === "undefined" ? undefined$1 : SharedArrayBuffer, + "%String%": String, + "%StringIteratorPrototype%": hasSymbols2 && getProto ? getProto(""[Symbol.iterator]()) : undefined$1, + "%Symbol%": hasSymbols2 ? Symbol : undefined$1, + "%SyntaxError%": $SyntaxError, + "%ThrowTypeError%": ThrowTypeError, + "%TypedArray%": TypedArray, + "%TypeError%": $TypeError, + "%Uint8Array%": typeof Uint8Array === "undefined" ? undefined$1 : Uint8Array, + "%Uint8ClampedArray%": typeof Uint8ClampedArray === "undefined" ? undefined$1 : Uint8ClampedArray, + "%Uint16Array%": typeof Uint16Array === "undefined" ? undefined$1 : Uint16Array, + "%Uint32Array%": typeof Uint32Array === "undefined" ? undefined$1 : Uint32Array, + "%URIError%": $URIError, + "%WeakMap%": typeof WeakMap === "undefined" ? undefined$1 : WeakMap, + "%WeakRef%": typeof WeakRef === "undefined" ? undefined$1 : WeakRef, + "%WeakSet%": typeof WeakSet === "undefined" ? undefined$1 : WeakSet + }; + if (getProto) { + try { + null.error; + } catch (e) { + var errorProto = getProto(getProto(e)); + INTRINSICS["%Error.prototype%"] = errorProto; + } + } + var doEval = function doEval2(name) { + var value; + if (name === "%AsyncFunction%") { + value = getEvalledConstructor("async function () {}"); + } else if (name === "%GeneratorFunction%") { + value = getEvalledConstructor("function* () {}"); + } else if (name === "%AsyncGeneratorFunction%") { + value = getEvalledConstructor("async function* () {}"); + } else if (name === "%AsyncGenerator%") { + var fn = doEval2("%AsyncGeneratorFunction%"); + if (fn) { + value = fn.prototype; + } + } else if (name === "%AsyncIteratorPrototype%") { + var gen = doEval2("%AsyncGenerator%"); + if (gen && getProto) { + value = getProto(gen.prototype); + } + } + INTRINSICS[name] = value; + return value; + }; + var LEGACY_ALIASES = { + __proto__: null, + "%ArrayBufferPrototype%": ["ArrayBuffer", "prototype"], + "%ArrayPrototype%": ["Array", "prototype"], + "%ArrayProto_entries%": ["Array", "prototype", "entries"], + "%ArrayProto_forEach%": ["Array", "prototype", "forEach"], + "%ArrayProto_keys%": ["Array", "prototype", "keys"], + "%ArrayProto_values%": ["Array", "prototype", "values"], + "%AsyncFunctionPrototype%": ["AsyncFunction", "prototype"], + "%AsyncGenerator%": ["AsyncGeneratorFunction", "prototype"], + "%AsyncGeneratorPrototype%": ["AsyncGeneratorFunction", "prototype", "prototype"], + "%BooleanPrototype%": ["Boolean", "prototype"], + "%DataViewPrototype%": ["DataView", "prototype"], + "%DatePrototype%": ["Date", "prototype"], + "%ErrorPrototype%": ["Error", "prototype"], + "%EvalErrorPrototype%": ["EvalError", "prototype"], + "%Float32ArrayPrototype%": ["Float32Array", "prototype"], + "%Float64ArrayPrototype%": ["Float64Array", "prototype"], + "%FunctionPrototype%": ["Function", "prototype"], + "%Generator%": ["GeneratorFunction", "prototype"], + "%GeneratorPrototype%": ["GeneratorFunction", "prototype", "prototype"], + "%Int8ArrayPrototype%": ["Int8Array", "prototype"], + "%Int16ArrayPrototype%": ["Int16Array", "prototype"], + "%Int32ArrayPrototype%": ["Int32Array", "prototype"], + "%JSONParse%": ["JSON", "parse"], + "%JSONStringify%": ["JSON", "stringify"], + "%MapPrototype%": ["Map", "prototype"], + "%NumberPrototype%": ["Number", "prototype"], + "%ObjectPrototype%": ["Object", "prototype"], + "%ObjProto_toString%": ["Object", "prototype", "toString"], + "%ObjProto_valueOf%": ["Object", "prototype", "valueOf"], + "%PromisePrototype%": ["Promise", "prototype"], + "%PromiseProto_then%": ["Promise", "prototype", "then"], + "%Promise_all%": ["Promise", "all"], + "%Promise_reject%": ["Promise", "reject"], + "%Promise_resolve%": ["Promise", "resolve"], + "%RangeErrorPrototype%": ["RangeError", "prototype"], + "%ReferenceErrorPrototype%": ["ReferenceError", "prototype"], + "%RegExpPrototype%": ["RegExp", "prototype"], + "%SetPrototype%": ["Set", "prototype"], + "%SharedArrayBufferPrototype%": ["SharedArrayBuffer", "prototype"], + "%StringPrototype%": ["String", "prototype"], + "%SymbolPrototype%": ["Symbol", "prototype"], + "%SyntaxErrorPrototype%": ["SyntaxError", "prototype"], + "%TypedArrayPrototype%": ["TypedArray", "prototype"], + "%TypeErrorPrototype%": ["TypeError", "prototype"], + "%Uint8ArrayPrototype%": ["Uint8Array", "prototype"], + "%Uint8ClampedArrayPrototype%": ["Uint8ClampedArray", "prototype"], + "%Uint16ArrayPrototype%": ["Uint16Array", "prototype"], + "%Uint32ArrayPrototype%": ["Uint32Array", "prototype"], + "%URIErrorPrototype%": ["URIError", "prototype"], + "%WeakMapPrototype%": ["WeakMap", "prototype"], + "%WeakSetPrototype%": ["WeakSet", "prototype"] + }; + var bind = requireFunctionBind(); + var hasOwn = /* @__PURE__ */ requireHasown(); + var $concat = bind.call(Function.call, Array.prototype.concat); + var $spliceApply = bind.call(Function.apply, Array.prototype.splice); + var $replace = bind.call(Function.call, String.prototype.replace); + var $strSlice = bind.call(Function.call, String.prototype.slice); + var $exec = bind.call(Function.call, RegExp.prototype.exec); + var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g; + var reEscapeChar = /\\(\\)?/g; + var stringToPath = function stringToPath2(string) { + var first = $strSlice(string, 0, 1); + var last = $strSlice(string, -1); + if (first === "%" && last !== "%") { + throw new $SyntaxError("invalid intrinsic syntax, expected closing `%`"); + } else if (last === "%" && first !== "%") { + throw new $SyntaxError("invalid intrinsic syntax, expected opening `%`"); + } + var result = []; + $replace(string, rePropName, function(match, number, quote, subString) { + result[result.length] = quote ? $replace(subString, reEscapeChar, "$1") : number || match; + }); + return result; + }; + var getBaseIntrinsic = function getBaseIntrinsic2(name, allowMissing) { + var intrinsicName = name; + var alias; + if (hasOwn(LEGACY_ALIASES, intrinsicName)) { + alias = LEGACY_ALIASES[intrinsicName]; + intrinsicName = "%" + alias[0] + "%"; + } + if (hasOwn(INTRINSICS, intrinsicName)) { + var value = INTRINSICS[intrinsicName]; + if (value === needsEval) { + value = doEval(intrinsicName); + } + if (typeof value === "undefined" && !allowMissing) { + throw new $TypeError("intrinsic " + name + " exists, but is not available. Please file an issue!"); + } + return { + alias, + name: intrinsicName, + value + }; + } + throw new $SyntaxError("intrinsic " + name + " does not exist!"); + }; + getIntrinsic = function GetIntrinsic(name, allowMissing) { + if (typeof name !== "string" || name.length === 0) { + throw new $TypeError("intrinsic name must be a non-empty string"); + } + if (arguments.length > 1 && typeof allowMissing !== "boolean") { + throw new $TypeError('"allowMissing" argument must be a boolean'); + } + if ($exec(/^%?[^%]*%?$/, name) === null) { + throw new $SyntaxError("`%` may not be present anywhere but at the beginning and end of the intrinsic name"); + } + var parts = stringToPath(name); + var intrinsicBaseName = parts.length > 0 ? parts[0] : ""; + var intrinsic = getBaseIntrinsic("%" + intrinsicBaseName + "%", allowMissing); + var intrinsicRealName = intrinsic.name; + var value = intrinsic.value; + var skipFurtherCaching = false; + var alias = intrinsic.alias; + if (alias) { + intrinsicBaseName = alias[0]; + $spliceApply(parts, $concat([0, 1], alias)); + } + for (var i2 = 1, isOwn = true; i2 < parts.length; i2 += 1) { + var part = parts[i2]; + var first = $strSlice(part, 0, 1); + var last = $strSlice(part, -1); + if ((first === '"' || first === "'" || first === "`" || (last === '"' || last === "'" || last === "`")) && first !== last) { + throw new $SyntaxError("property names with quotes must have matching quotes"); + } + if (part === "constructor" || !isOwn) { + skipFurtherCaching = true; + } + intrinsicBaseName += "." + part; + intrinsicRealName = "%" + intrinsicBaseName + "%"; + if (hasOwn(INTRINSICS, intrinsicRealName)) { + value = INTRINSICS[intrinsicRealName]; + } else if (value != null) { + if (!(part in value)) { + if (!allowMissing) { + throw new $TypeError("base intrinsic for " + name + " exists, but the property is not available."); + } + return void undefined$1; + } + if ($gOPD && i2 + 1 >= parts.length) { + var desc = $gOPD(value, part); + isOwn = !!desc; + if (isOwn && "get" in desc && !("originalValue" in desc.get)) { + value = desc.get; + } else { + value = value[part]; + } + } else { + isOwn = hasOwn(value, part); + value = value[part]; + } + if (isOwn && !skipFurtherCaching) { + INTRINSICS[intrinsicRealName] = value; + } + } + } + return value; + }; + return getIntrinsic; +} +var callBind = { exports: {} }; +var esDefineProperty; +var hasRequiredEsDefineProperty; +function requireEsDefineProperty() { + if (hasRequiredEsDefineProperty) return esDefineProperty; + hasRequiredEsDefineProperty = 1; + var GetIntrinsic = /* @__PURE__ */ requireGetIntrinsic(); + var $defineProperty = GetIntrinsic("%Object.defineProperty%", true) || false; + if ($defineProperty) { + try { + $defineProperty({}, "a", { value: 1 }); + } catch (e) { + $defineProperty = false; + } + } + esDefineProperty = $defineProperty; + return esDefineProperty; +} +var gopd; +var hasRequiredGopd; +function requireGopd() { + if (hasRequiredGopd) return gopd; + hasRequiredGopd = 1; + var GetIntrinsic = /* @__PURE__ */ requireGetIntrinsic(); + var $gOPD = GetIntrinsic("%Object.getOwnPropertyDescriptor%", true); + if ($gOPD) { + try { + $gOPD([], "length"); + } catch (e) { + $gOPD = null; + } + } + gopd = $gOPD; + return gopd; +} +var defineDataProperty; +var hasRequiredDefineDataProperty; +function requireDefineDataProperty() { + if (hasRequiredDefineDataProperty) return defineDataProperty; + hasRequiredDefineDataProperty = 1; + var $defineProperty = /* @__PURE__ */ requireEsDefineProperty(); + var $SyntaxError = /* @__PURE__ */ requireSyntax(); + var $TypeError = /* @__PURE__ */ requireType(); + var gopd2 = /* @__PURE__ */ requireGopd(); + defineDataProperty = function defineDataProperty2(obj, property, value) { + if (!obj || typeof obj !== "object" && typeof obj !== "function") { + throw new $TypeError("`obj` must be an object or a function`"); + } + if (typeof property !== "string" && typeof property !== "symbol") { + throw new $TypeError("`property` must be a string or a symbol`"); + } + if (arguments.length > 3 && typeof arguments[3] !== "boolean" && arguments[3] !== null) { + throw new $TypeError("`nonEnumerable`, if provided, must be a boolean or null"); + } + if (arguments.length > 4 && typeof arguments[4] !== "boolean" && arguments[4] !== null) { + throw new $TypeError("`nonWritable`, if provided, must be a boolean or null"); + } + if (arguments.length > 5 && typeof arguments[5] !== "boolean" && arguments[5] !== null) { + throw new $TypeError("`nonConfigurable`, if provided, must be a boolean or null"); + } + if (arguments.length > 6 && typeof arguments[6] !== "boolean") { + throw new $TypeError("`loose`, if provided, must be a boolean"); + } + var nonEnumerable = arguments.length > 3 ? arguments[3] : null; + var nonWritable = arguments.length > 4 ? arguments[4] : null; + var nonConfigurable = arguments.length > 5 ? arguments[5] : null; + var loose = arguments.length > 6 ? arguments[6] : false; + var desc = !!gopd2 && gopd2(obj, property); + if ($defineProperty) { + $defineProperty(obj, property, { + configurable: nonConfigurable === null && desc ? desc.configurable : !nonConfigurable, + enumerable: nonEnumerable === null && desc ? desc.enumerable : !nonEnumerable, + value, + writable: nonWritable === null && desc ? desc.writable : !nonWritable + }); + } else if (loose || !nonEnumerable && !nonWritable && !nonConfigurable) { + obj[property] = value; + } else { + throw new $SyntaxError("This environment does not support defining a property as non-configurable, non-writable, or non-enumerable."); + } + }; + return defineDataProperty; +} +var hasPropertyDescriptors_1; +var hasRequiredHasPropertyDescriptors; +function requireHasPropertyDescriptors() { + if (hasRequiredHasPropertyDescriptors) return hasPropertyDescriptors_1; + hasRequiredHasPropertyDescriptors = 1; + var $defineProperty = /* @__PURE__ */ requireEsDefineProperty(); + var hasPropertyDescriptors = function hasPropertyDescriptors2() { + return !!$defineProperty; + }; + hasPropertyDescriptors.hasArrayLengthDefineBug = function hasArrayLengthDefineBug() { + if (!$defineProperty) { + return null; + } + try { + return $defineProperty([], "length", { value: 1 }).length !== 1; + } catch (e) { + return true; + } + }; + hasPropertyDescriptors_1 = hasPropertyDescriptors; + return hasPropertyDescriptors_1; +} +var setFunctionLength; +var hasRequiredSetFunctionLength; +function requireSetFunctionLength() { + if (hasRequiredSetFunctionLength) return setFunctionLength; + hasRequiredSetFunctionLength = 1; + var GetIntrinsic = /* @__PURE__ */ requireGetIntrinsic(); + var define = /* @__PURE__ */ requireDefineDataProperty(); + var hasDescriptors = /* @__PURE__ */ requireHasPropertyDescriptors()(); + var gOPD = /* @__PURE__ */ requireGopd(); + var $TypeError = /* @__PURE__ */ requireType(); + var $floor = GetIntrinsic("%Math.floor%"); + setFunctionLength = function setFunctionLength2(fn, length) { + if (typeof fn !== "function") { + throw new $TypeError("`fn` is not a function"); + } + if (typeof length !== "number" || length < 0 || length > 4294967295 || $floor(length) !== length) { + throw new $TypeError("`length` must be a positive 32-bit integer"); + } + var loose = arguments.length > 2 && !!arguments[2]; + var functionLengthIsConfigurable = true; + var functionLengthIsWritable = true; + if ("length" in fn && gOPD) { + var desc = gOPD(fn, "length"); + if (desc && !desc.configurable) { + functionLengthIsConfigurable = false; + } + if (desc && !desc.writable) { + functionLengthIsWritable = false; + } + } + if (functionLengthIsConfigurable || functionLengthIsWritable || !loose) { + if (hasDescriptors) { + define( + /** @type {Parameters[0]} */ + fn, + "length", + length, + true, + true + ); + } else { + define( + /** @type {Parameters[0]} */ + fn, + "length", + length + ); + } + } + return fn; + }; + return setFunctionLength; +} +var hasRequiredCallBind; +function requireCallBind() { + if (hasRequiredCallBind) return callBind.exports; + hasRequiredCallBind = 1; + (function(module2) { + var bind = requireFunctionBind(); + var GetIntrinsic = /* @__PURE__ */ requireGetIntrinsic(); + var setFunctionLength2 = /* @__PURE__ */ requireSetFunctionLength(); + var $TypeError = /* @__PURE__ */ requireType(); + var $apply = GetIntrinsic("%Function.prototype.apply%"); + var $call = GetIntrinsic("%Function.prototype.call%"); + var $reflectApply = GetIntrinsic("%Reflect.apply%", true) || bind.call($call, $apply); + var $defineProperty = /* @__PURE__ */ requireEsDefineProperty(); + var $max = GetIntrinsic("%Math.max%"); + module2.exports = function callBind2(originalFunction) { + if (typeof originalFunction !== "function") { + throw new $TypeError("a function is required"); + } + var func = $reflectApply(bind, $call, arguments); + return setFunctionLength2( + func, + 1 + $max(0, originalFunction.length - (arguments.length - 1)), + true + ); + }; + var applyBind = function applyBind2() { + return $reflectApply(bind, $apply, arguments); + }; + if ($defineProperty) { + $defineProperty(module2.exports, "apply", { value: applyBind }); + } else { + module2.exports.apply = applyBind; + } + })(callBind); + return callBind.exports; +} +var callBound; +var hasRequiredCallBound; +function requireCallBound() { + if (hasRequiredCallBound) return callBound; + hasRequiredCallBound = 1; + var GetIntrinsic = /* @__PURE__ */ requireGetIntrinsic(); + var callBind2 = requireCallBind(); + var $indexOf = callBind2(GetIntrinsic("String.prototype.indexOf")); + callBound = function callBoundIntrinsic(name, allowMissing) { + var intrinsic = GetIntrinsic(name, !!allowMissing); + if (typeof intrinsic === "function" && $indexOf(name, ".prototype.") > -1) { + return callBind2(intrinsic); + } + return intrinsic; + }; + return callBound; +} +var isArguments; +var hasRequiredIsArguments; +function requireIsArguments() { + if (hasRequiredIsArguments) return isArguments; + hasRequiredIsArguments = 1; + var hasToStringTag = requireShams()(); + var callBound2 = requireCallBound(); + var $toString = callBound2("Object.prototype.toString"); + var isStandardArguments = function isArguments2(value) { + if (hasToStringTag && value && typeof value === "object" && Symbol.toStringTag in value) { + return false; + } + return $toString(value) === "[object Arguments]"; + }; + var isLegacyArguments = function isArguments2(value) { + if (isStandardArguments(value)) { + return true; + } + return value !== null && typeof value === "object" && typeof value.length === "number" && value.length >= 0 && $toString(value) !== "[object Array]" && $toString(value.callee) === "[object Function]"; + }; + var supportsStandardArguments = function() { + return isStandardArguments(arguments); + }(); + isStandardArguments.isLegacyArguments = isLegacyArguments; + isArguments = supportsStandardArguments ? isStandardArguments : isLegacyArguments; + return isArguments; +} +var isGeneratorFunction; +var hasRequiredIsGeneratorFunction; +function requireIsGeneratorFunction() { + if (hasRequiredIsGeneratorFunction) return isGeneratorFunction; + hasRequiredIsGeneratorFunction = 1; + var toStr = Object.prototype.toString; + var fnToStr = Function.prototype.toString; + var isFnRegex = /^\s*(?:function)?\*/; + var hasToStringTag = requireShams()(); + var getProto = Object.getPrototypeOf; + var getGeneratorFunc = function() { + if (!hasToStringTag) { + return false; + } + try { + return Function("return function*() {}")(); + } catch (e) { + } + }; + var GeneratorFunction; + isGeneratorFunction = function isGeneratorFunction2(fn) { + if (typeof fn !== "function") { + return false; + } + if (isFnRegex.test(fnToStr.call(fn))) { + return true; + } + if (!hasToStringTag) { + var str = toStr.call(fn); + return str === "[object GeneratorFunction]"; + } + if (!getProto) { + return false; + } + if (typeof GeneratorFunction === "undefined") { + var generatorFunc = getGeneratorFunc(); + GeneratorFunction = generatorFunc ? getProto(generatorFunc) : false; + } + return getProto(fn) === GeneratorFunction; + }; + return isGeneratorFunction; +} +var isCallable; +var hasRequiredIsCallable; +function requireIsCallable() { + if (hasRequiredIsCallable) return isCallable; + hasRequiredIsCallable = 1; + var fnToStr = Function.prototype.toString; + var reflectApply = typeof Reflect === "object" && Reflect !== null && Reflect.apply; + var badArrayLike; + var isCallableMarker; + if (typeof reflectApply === "function" && typeof Object.defineProperty === "function") { + try { + badArrayLike = Object.defineProperty({}, "length", { + get: function() { + throw isCallableMarker; + } + }); + isCallableMarker = {}; + reflectApply(function() { + throw 42; + }, null, badArrayLike); + } catch (_) { + if (_ !== isCallableMarker) { + reflectApply = null; + } + } + } else { + reflectApply = null; + } + var constructorRegex = /^\s*class\b/; + var isES6ClassFn = function isES6ClassFunction(value) { + try { + var fnStr = fnToStr.call(value); + return constructorRegex.test(fnStr); + } catch (e) { + return false; + } + }; + var tryFunctionObject = function tryFunctionToStr(value) { + try { + if (isES6ClassFn(value)) { + return false; + } + fnToStr.call(value); + return true; + } catch (e) { + return false; + } + }; + var toStr = Object.prototype.toString; + var objectClass = "[object Object]"; + var fnClass = "[object Function]"; + var genClass = "[object GeneratorFunction]"; + var ddaClass = "[object HTMLAllCollection]"; + var ddaClass2 = "[object HTML document.all class]"; + var ddaClass3 = "[object HTMLCollection]"; + var hasToStringTag = typeof Symbol === "function" && !!Symbol.toStringTag; + var isIE68 = !(0 in [,]); + var isDDA = function isDocumentDotAll() { + return false; + }; + if (typeof document === "object") { + var all = document.all; + if (toStr.call(all) === toStr.call(document.all)) { + isDDA = function isDocumentDotAll(value) { + if ((isIE68 || !value) && (typeof value === "undefined" || typeof value === "object")) { + try { + var str = toStr.call(value); + return (str === ddaClass || str === ddaClass2 || str === ddaClass3 || str === objectClass) && value("") == null; + } catch (e) { + } + } + return false; + }; + } + } + isCallable = reflectApply ? function isCallable2(value) { + if (isDDA(value)) { + return true; + } + if (!value) { + return false; + } + if (typeof value !== "function" && typeof value !== "object") { + return false; + } + try { + reflectApply(value, null, badArrayLike); + } catch (e) { + if (e !== isCallableMarker) { + return false; + } + } + return !isES6ClassFn(value) && tryFunctionObject(value); + } : function isCallable2(value) { + if (isDDA(value)) { + return true; + } + if (!value) { + return false; + } + if (typeof value !== "function" && typeof value !== "object") { + return false; + } + if (hasToStringTag) { + return tryFunctionObject(value); + } + if (isES6ClassFn(value)) { + return false; + } + var strClass = toStr.call(value); + if (strClass !== fnClass && strClass !== genClass && !/^\[object HTML/.test(strClass)) { + return false; + } + return tryFunctionObject(value); + }; + return isCallable; +} +var forEach_1; +var hasRequiredForEach; +function requireForEach() { + if (hasRequiredForEach) return forEach_1; + hasRequiredForEach = 1; + var isCallable2 = requireIsCallable(); + var toStr = Object.prototype.toString; + var hasOwnProperty = Object.prototype.hasOwnProperty; + var forEachArray = function forEachArray2(array, iterator, receiver) { + for (var i2 = 0, len2 = array.length; i2 < len2; i2++) { + if (hasOwnProperty.call(array, i2)) { + if (receiver == null) { + iterator(array[i2], i2, array); + } else { + iterator.call(receiver, array[i2], i2, array); + } + } + } + }; + var forEachString = function forEachString2(string, iterator, receiver) { + for (var i2 = 0, len2 = string.length; i2 < len2; i2++) { + if (receiver == null) { + iterator(string.charAt(i2), i2, string); + } else { + iterator.call(receiver, string.charAt(i2), i2, string); + } + } + }; + var forEachObject = function forEachObject2(object, iterator, receiver) { + for (var k in object) { + if (hasOwnProperty.call(object, k)) { + if (receiver == null) { + iterator(object[k], k, object); + } else { + iterator.call(receiver, object[k], k, object); + } + } + } + }; + var forEach2 = function forEach3(list, iterator, thisArg) { + if (!isCallable2(iterator)) { + throw new TypeError("iterator must be a function"); + } + var receiver; + if (arguments.length >= 3) { + receiver = thisArg; + } + if (toStr.call(list) === "[object Array]") { + forEachArray(list, iterator, receiver); + } else if (typeof list === "string") { + forEachString(list, iterator, receiver); + } else { + forEachObject(list, iterator, receiver); + } + }; + forEach_1 = forEach2; + return forEach_1; +} +var possibleTypedArrayNames; +var hasRequiredPossibleTypedArrayNames; +function requirePossibleTypedArrayNames() { + if (hasRequiredPossibleTypedArrayNames) return possibleTypedArrayNames; + hasRequiredPossibleTypedArrayNames = 1; + possibleTypedArrayNames = [ + "Float32Array", + "Float64Array", + "Int8Array", + "Int16Array", + "Int32Array", + "Uint8Array", + "Uint8ClampedArray", + "Uint16Array", + "Uint32Array", + "BigInt64Array", + "BigUint64Array" + ]; + return possibleTypedArrayNames; +} +var availableTypedArrays; +var hasRequiredAvailableTypedArrays; +function requireAvailableTypedArrays() { + if (hasRequiredAvailableTypedArrays) return availableTypedArrays; + hasRequiredAvailableTypedArrays = 1; + var possibleNames = /* @__PURE__ */ requirePossibleTypedArrayNames(); + var g = typeof globalThis === "undefined" ? commonjsGlobal : globalThis; + availableTypedArrays = function availableTypedArrays2() { + var out = []; + for (var i2 = 0; i2 < possibleNames.length; i2++) { + if (typeof g[possibleNames[i2]] === "function") { + out[out.length] = possibleNames[i2]; + } + } + return out; + }; + return availableTypedArrays; +} +var whichTypedArray; +var hasRequiredWhichTypedArray; +function requireWhichTypedArray() { + if (hasRequiredWhichTypedArray) return whichTypedArray; + hasRequiredWhichTypedArray = 1; + var forEach2 = requireForEach(); + var availableTypedArrays2 = /* @__PURE__ */ requireAvailableTypedArrays(); + var callBind2 = requireCallBind(); + var callBound2 = requireCallBound(); + var gOPD = /* @__PURE__ */ requireGopd(); + var $toString = callBound2("Object.prototype.toString"); + var hasToStringTag = requireShams()(); + var g = typeof globalThis === "undefined" ? commonjsGlobal : globalThis; + var typedArrays = availableTypedArrays2(); + var $slice = callBound2("String.prototype.slice"); + var getPrototypeOf = Object.getPrototypeOf; + var $indexOf = callBound2("Array.prototype.indexOf", true) || function indexOf2(array, value) { + for (var i2 = 0; i2 < array.length; i2 += 1) { + if (array[i2] === value) { + return i2; + } + } + return -1; + }; + var cache = { __proto__: null }; + if (hasToStringTag && gOPD && getPrototypeOf) { + forEach2(typedArrays, function(typedArray) { + var arr = new g[typedArray](); + if (Symbol.toStringTag in arr) { + var proto = getPrototypeOf(arr); + var descriptor = gOPD(proto, Symbol.toStringTag); + if (!descriptor) { + var superProto = getPrototypeOf(proto); + descriptor = gOPD(superProto, Symbol.toStringTag); + } + cache["$" + typedArray] = callBind2(descriptor.get); + } + }); + } else { + forEach2(typedArrays, function(typedArray) { + var arr = new g[typedArray](); + var fn = arr.slice || arr.set; + if (fn) { + cache["$" + typedArray] = callBind2(fn); + } + }); + } + var tryTypedArrays = function tryAllTypedArrays(value) { + var found = false; + forEach2( + // eslint-disable-next-line no-extra-parens + /** @type {Record<`\$${TypedArrayName}`, Getter>} */ + /** @type {any} */ + cache, + /** @type {(getter: Getter, name: `\$${import('.').TypedArrayName}`) => void} */ + function(getter, typedArray) { + if (!found) { + try { + if ("$" + getter(value) === typedArray) { + found = $slice(typedArray, 1); + } + } catch (e) { + } + } + } + ); + return found; + }; + var trySlices = function tryAllSlices(value) { + var found = false; + forEach2( + // eslint-disable-next-line no-extra-parens + /** @type {Record<`\$${TypedArrayName}`, Getter>} */ + /** @type {any} */ + cache, + /** @type {(getter: typeof cache, name: `\$${import('.').TypedArrayName}`) => void} */ + function(getter, name) { + if (!found) { + try { + getter(value); + found = $slice(name, 1); + } catch (e) { + } + } + } + ); + return found; + }; + whichTypedArray = function whichTypedArray2(value) { + if (!value || typeof value !== "object") { + return false; + } + if (!hasToStringTag) { + var tag = $slice($toString(value), 8, -1); + if ($indexOf(typedArrays, tag) > -1) { + return tag; + } + if (tag !== "Object") { + return false; + } + return trySlices(value); + } + if (!gOPD) { + return null; + } + return tryTypedArrays(value); + }; + return whichTypedArray; +} +var isTypedArray; +var hasRequiredIsTypedArray; +function requireIsTypedArray() { + if (hasRequiredIsTypedArray) return isTypedArray; + hasRequiredIsTypedArray = 1; + var whichTypedArray2 = /* @__PURE__ */ requireWhichTypedArray(); + isTypedArray = function isTypedArray2(value) { + return !!whichTypedArray2(value); + }; + return isTypedArray; +} +var hasRequiredTypes; +function requireTypes() { + if (hasRequiredTypes) return types; + hasRequiredTypes = 1; + (function(exports2) { + var isArgumentsObject = requireIsArguments(); + var isGeneratorFunction2 = requireIsGeneratorFunction(); + var whichTypedArray2 = /* @__PURE__ */ requireWhichTypedArray(); + var isTypedArray2 = /* @__PURE__ */ requireIsTypedArray(); + function uncurryThis(f) { + return f.call.bind(f); + } + var BigIntSupported = typeof BigInt !== "undefined"; + var SymbolSupported = typeof Symbol !== "undefined"; + var ObjectToString = uncurryThis(Object.prototype.toString); + var numberValue = uncurryThis(Number.prototype.valueOf); + var stringValue = uncurryThis(String.prototype.valueOf); + var booleanValue = uncurryThis(Boolean.prototype.valueOf); + if (BigIntSupported) { + var bigIntValue = uncurryThis(BigInt.prototype.valueOf); + } + if (SymbolSupported) { + var symbolValue = uncurryThis(Symbol.prototype.valueOf); + } + function checkBoxedPrimitive(value, prototypeValueOf) { + if (typeof value !== "object") { + return false; + } + try { + prototypeValueOf(value); + return true; + } catch (e) { + return false; + } + } + exports2.isArgumentsObject = isArgumentsObject; + exports2.isGeneratorFunction = isGeneratorFunction2; + exports2.isTypedArray = isTypedArray2; + function isPromise(input) { + return typeof Promise !== "undefined" && input instanceof Promise || input !== null && typeof input === "object" && typeof input.then === "function" && typeof input.catch === "function"; + } + exports2.isPromise = isPromise; + function isArrayBufferView(value) { + if (typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView) { + return ArrayBuffer.isView(value); + } + return isTypedArray2(value) || isDataView(value); + } + exports2.isArrayBufferView = isArrayBufferView; + function isUint8Array(value) { + return whichTypedArray2(value) === "Uint8Array"; + } + exports2.isUint8Array = isUint8Array; + function isUint8ClampedArray(value) { + return whichTypedArray2(value) === "Uint8ClampedArray"; + } + exports2.isUint8ClampedArray = isUint8ClampedArray; + function isUint16Array(value) { + return whichTypedArray2(value) === "Uint16Array"; + } + exports2.isUint16Array = isUint16Array; + function isUint32Array(value) { + return whichTypedArray2(value) === "Uint32Array"; + } + exports2.isUint32Array = isUint32Array; + function isInt8Array(value) { + return whichTypedArray2(value) === "Int8Array"; + } + exports2.isInt8Array = isInt8Array; + function isInt16Array(value) { + return whichTypedArray2(value) === "Int16Array"; + } + exports2.isInt16Array = isInt16Array; + function isInt32Array(value) { + return whichTypedArray2(value) === "Int32Array"; + } + exports2.isInt32Array = isInt32Array; + function isFloat32Array(value) { + return whichTypedArray2(value) === "Float32Array"; + } + exports2.isFloat32Array = isFloat32Array; + function isFloat64Array(value) { + return whichTypedArray2(value) === "Float64Array"; + } + exports2.isFloat64Array = isFloat64Array; + function isBigInt64Array(value) { + return whichTypedArray2(value) === "BigInt64Array"; + } + exports2.isBigInt64Array = isBigInt64Array; + function isBigUint64Array(value) { + return whichTypedArray2(value) === "BigUint64Array"; + } + exports2.isBigUint64Array = isBigUint64Array; + function isMapToString(value) { + return ObjectToString(value) === "[object Map]"; + } + isMapToString.working = typeof Map !== "undefined" && isMapToString(/* @__PURE__ */ new Map()); + function isMap(value) { + if (typeof Map === "undefined") { + return false; + } + return isMapToString.working ? isMapToString(value) : value instanceof Map; + } + exports2.isMap = isMap; + function isSetToString(value) { + return ObjectToString(value) === "[object Set]"; + } + isSetToString.working = typeof Set !== "undefined" && isSetToString(/* @__PURE__ */ new Set()); + function isSet(value) { + if (typeof Set === "undefined") { + return false; + } + return isSetToString.working ? isSetToString(value) : value instanceof Set; + } + exports2.isSet = isSet; + function isWeakMapToString(value) { + return ObjectToString(value) === "[object WeakMap]"; + } + isWeakMapToString.working = typeof WeakMap !== "undefined" && isWeakMapToString(/* @__PURE__ */ new WeakMap()); + function isWeakMap(value) { + if (typeof WeakMap === "undefined") { + return false; + } + return isWeakMapToString.working ? isWeakMapToString(value) : value instanceof WeakMap; + } + exports2.isWeakMap = isWeakMap; + function isWeakSetToString(value) { + return ObjectToString(value) === "[object WeakSet]"; + } + isWeakSetToString.working = typeof WeakSet !== "undefined" && isWeakSetToString(/* @__PURE__ */ new WeakSet()); + function isWeakSet(value) { + return isWeakSetToString(value); + } + exports2.isWeakSet = isWeakSet; + function isArrayBufferToString(value) { + return ObjectToString(value) === "[object ArrayBuffer]"; + } + isArrayBufferToString.working = typeof ArrayBuffer !== "undefined" && isArrayBufferToString(new ArrayBuffer()); + function isArrayBuffer(value) { + if (typeof ArrayBuffer === "undefined") { + return false; + } + return isArrayBufferToString.working ? isArrayBufferToString(value) : value instanceof ArrayBuffer; + } + exports2.isArrayBuffer = isArrayBuffer; + function isDataViewToString(value) { + return ObjectToString(value) === "[object DataView]"; + } + isDataViewToString.working = typeof ArrayBuffer !== "undefined" && typeof DataView !== "undefined" && isDataViewToString(new DataView(new ArrayBuffer(1), 0, 1)); + function isDataView(value) { + if (typeof DataView === "undefined") { + return false; + } + return isDataViewToString.working ? isDataViewToString(value) : value instanceof DataView; + } + exports2.isDataView = isDataView; + var SharedArrayBufferCopy = typeof SharedArrayBuffer !== "undefined" ? SharedArrayBuffer : void 0; + function isSharedArrayBufferToString(value) { + return ObjectToString(value) === "[object SharedArrayBuffer]"; + } + function isSharedArrayBuffer(value) { + if (typeof SharedArrayBufferCopy === "undefined") { + return false; + } + if (typeof isSharedArrayBufferToString.working === "undefined") { + isSharedArrayBufferToString.working = isSharedArrayBufferToString(new SharedArrayBufferCopy()); + } + return isSharedArrayBufferToString.working ? isSharedArrayBufferToString(value) : value instanceof SharedArrayBufferCopy; + } + exports2.isSharedArrayBuffer = isSharedArrayBuffer; + function isAsyncFunction(value) { + return ObjectToString(value) === "[object AsyncFunction]"; + } + exports2.isAsyncFunction = isAsyncFunction; + function isMapIterator(value) { + return ObjectToString(value) === "[object Map Iterator]"; + } + exports2.isMapIterator = isMapIterator; + function isSetIterator(value) { + return ObjectToString(value) === "[object Set Iterator]"; + } + exports2.isSetIterator = isSetIterator; + function isGeneratorObject(value) { + return ObjectToString(value) === "[object Generator]"; + } + exports2.isGeneratorObject = isGeneratorObject; + function isWebAssemblyCompiledModule(value) { + return ObjectToString(value) === "[object WebAssembly.Module]"; + } + exports2.isWebAssemblyCompiledModule = isWebAssemblyCompiledModule; + function isNumberObject(value) { + return checkBoxedPrimitive(value, numberValue); + } + exports2.isNumberObject = isNumberObject; + function isStringObject(value) { + return checkBoxedPrimitive(value, stringValue); + } + exports2.isStringObject = isStringObject; + function isBooleanObject(value) { + return checkBoxedPrimitive(value, booleanValue); + } + exports2.isBooleanObject = isBooleanObject; + function isBigIntObject(value) { + return BigIntSupported && checkBoxedPrimitive(value, bigIntValue); + } + exports2.isBigIntObject = isBigIntObject; + function isSymbolObject(value) { + return SymbolSupported && checkBoxedPrimitive(value, symbolValue); + } + exports2.isSymbolObject = isSymbolObject; + function isBoxedPrimitive(value) { + return isNumberObject(value) || isStringObject(value) || isBooleanObject(value) || isBigIntObject(value) || isSymbolObject(value); + } + exports2.isBoxedPrimitive = isBoxedPrimitive; + function isAnyArrayBuffer(value) { + return typeof Uint8Array !== "undefined" && (isArrayBuffer(value) || isSharedArrayBuffer(value)); + } + exports2.isAnyArrayBuffer = isAnyArrayBuffer; + ["isProxy", "isExternal", "isModuleNamespaceObject"].forEach(function(method) { + Object.defineProperty(exports2, method, { + enumerable: false, + value: function() { + throw new Error(method + " is not supported in userland"); + } + }); + }); + })(types); + return types; +} +var isBufferBrowser; +var hasRequiredIsBufferBrowser; +function requireIsBufferBrowser() { + if (hasRequiredIsBufferBrowser) return isBufferBrowser; + hasRequiredIsBufferBrowser = 1; + isBufferBrowser = function isBuffer(arg) { + return arg && typeof arg === "object" && typeof arg.copy === "function" && typeof arg.fill === "function" && typeof arg.readUInt8 === "function"; + }; + return isBufferBrowser; +} +var hasRequiredUtil$1; +function requireUtil$1() { + if (hasRequiredUtil$1) return util$1; + hasRequiredUtil$1 = 1; + (function(exports2) { + var getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors || function getOwnPropertyDescriptors2(obj) { + var keys = Object.keys(obj); + var descriptors = {}; + for (var i2 = 0; i2 < keys.length; i2++) { + descriptors[keys[i2]] = Object.getOwnPropertyDescriptor(obj, keys[i2]); + } + return descriptors; + }; + var formatRegExp = /%[sdj%]/g; + exports2.format = function(f) { + if (!isString(f)) { + var objects = []; + for (var i2 = 0; i2 < arguments.length; i2++) { + objects.push(inspect2(arguments[i2])); + } + return objects.join(" "); + } + var i2 = 1; + var args = arguments; + var len2 = args.length; + var str = String(f).replace(formatRegExp, function(x2) { + if (x2 === "%%") return "%"; + if (i2 >= len2) return x2; + switch (x2) { + case "%s": + return String(args[i2++]); + case "%d": + return Number(args[i2++]); + case "%j": + try { + return JSON.stringify(args[i2++]); + } catch (_) { + return "[Circular]"; + } + default: + return x2; + } + }); + for (var x = args[i2]; i2 < len2; x = args[++i2]) { + if (isNull(x) || !isObject(x)) { + str += " " + x; + } else { + str += " " + inspect2(x); + } + } + return str; + }; + exports2.deprecate = function(fn, msg) { + if (typeof process$1 !== "undefined" && process$1.noDeprecation === true) { + return fn; + } + if (typeof process$1 === "undefined") { + return function() { + return exports2.deprecate(fn, msg).apply(this, arguments); + }; + } + var warned = false; + function deprecated() { + if (!warned) { + if (process$1.throwDeprecation) { + throw new Error(msg); + } else if (process$1.traceDeprecation) { + console.trace(msg); + } else { + console.error(msg); + } + warned = true; + } + return fn.apply(this, arguments); + } + return deprecated; + }; + var debugs = {}; + var debugEnvRegex = /^$/; + if (process$1.env.NODE_DEBUG) { + var debugEnv = process$1.env.NODE_DEBUG; + debugEnv = debugEnv.replace(/[|\\{}()[\]^$+?.]/g, "\\$&").replace(/\*/g, ".*").replace(/,/g, "$|^").toUpperCase(); + debugEnvRegex = new RegExp("^" + debugEnv + "$", "i"); + } + exports2.debuglog = function(set) { + set = set.toUpperCase(); + if (!debugs[set]) { + if (debugEnvRegex.test(set)) { + var pid = process$1.pid; + debugs[set] = function() { + var msg = exports2.format.apply(exports2, arguments); + console.error("%s %d: %s", set, pid, msg); + }; + } else { + debugs[set] = function() { + }; + } + } + return debugs[set]; + }; + function inspect2(obj, opts) { + var ctx = { + seen: [], + stylize: stylizeNoColor + }; + if (arguments.length >= 3) ctx.depth = arguments[2]; + if (arguments.length >= 4) ctx.colors = arguments[3]; + if (isBoolean(opts)) { + ctx.showHidden = opts; + } else if (opts) { + exports2._extend(ctx, opts); + } + if (isUndefined(ctx.showHidden)) ctx.showHidden = false; + if (isUndefined(ctx.depth)) ctx.depth = 2; + if (isUndefined(ctx.colors)) ctx.colors = false; + if (isUndefined(ctx.customInspect)) ctx.customInspect = true; + if (ctx.colors) ctx.stylize = stylizeWithColor; + return formatValue2(ctx, obj, ctx.depth); + } + exports2.inspect = inspect2; + inspect2.colors = { + "bold": [1, 22], + "italic": [3, 23], + "underline": [4, 24], + "inverse": [7, 27], + "white": [37, 39], + "grey": [90, 39], + "black": [30, 39], + "blue": [34, 39], + "cyan": [36, 39], + "green": [32, 39], + "magenta": [35, 39], + "red": [31, 39], + "yellow": [33, 39] + }; + inspect2.styles = { + "special": "cyan", + "number": "yellow", + "boolean": "yellow", + "undefined": "grey", + "null": "bold", + "string": "green", + "date": "magenta", + // "name": intentionally not styling + "regexp": "red" + }; + function stylizeWithColor(str, styleType) { + var style = inspect2.styles[styleType]; + if (style) { + return "\x1B[" + inspect2.colors[style][0] + "m" + str + "\x1B[" + inspect2.colors[style][1] + "m"; + } else { + return str; + } + } + function stylizeNoColor(str, styleType) { + return str; + } + function arrayToHash(array) { + var hash2 = {}; + array.forEach(function(val, idx) { + hash2[val] = true; + }); + return hash2; + } + function formatValue2(ctx, value, recurseTimes) { + if (ctx.customInspect && value && isFunction(value.inspect) && // Filter out the util module, it's inspect function is special + value.inspect !== exports2.inspect && // Also filter out any prototype objects using the circular check. + !(value.constructor && value.constructor.prototype === value)) { + var ret = value.inspect(recurseTimes, ctx); + if (!isString(ret)) { + ret = formatValue2(ctx, ret, recurseTimes); + } + return ret; + } + var primitive = formatPrimitive(ctx, value); + if (primitive) { + return primitive; + } + var keys = Object.keys(value); + var visibleKeys = arrayToHash(keys); + if (ctx.showHidden) { + keys = Object.getOwnPropertyNames(value); + } + if (isError(value) && (keys.indexOf("message") >= 0 || keys.indexOf("description") >= 0)) { + return formatError(value); + } + if (keys.length === 0) { + if (isFunction(value)) { + var name = value.name ? ": " + value.name : ""; + return ctx.stylize("[Function" + name + "]", "special"); + } + if (isRegExp(value)) { + return ctx.stylize(RegExp.prototype.toString.call(value), "regexp"); + } + if (isDate(value)) { + return ctx.stylize(Date.prototype.toString.call(value), "date"); + } + if (isError(value)) { + return formatError(value); + } + } + var base2 = "", array = false, braces = ["{", "}"]; + if (isArray(value)) { + array = true; + braces = ["[", "]"]; + } + if (isFunction(value)) { + var n = value.name ? ": " + value.name : ""; + base2 = " [Function" + n + "]"; + } + if (isRegExp(value)) { + base2 = " " + RegExp.prototype.toString.call(value); + } + if (isDate(value)) { + base2 = " " + Date.prototype.toUTCString.call(value); + } + if (isError(value)) { + base2 = " " + formatError(value); + } + if (keys.length === 0 && (!array || value.length == 0)) { + return braces[0] + base2 + braces[1]; + } + if (recurseTimes < 0) { + if (isRegExp(value)) { + return ctx.stylize(RegExp.prototype.toString.call(value), "regexp"); + } else { + return ctx.stylize("[Object]", "special"); + } + } + ctx.seen.push(value); + var output; + if (array) { + output = formatArray2(ctx, value, recurseTimes, visibleKeys, keys); + } else { + output = keys.map(function(key2) { + return formatProperty(ctx, value, recurseTimes, visibleKeys, key2, array); + }); + } + ctx.seen.pop(); + return reduceToSingleString(output, base2, braces); + } + function formatPrimitive(ctx, value) { + if (isUndefined(value)) + return ctx.stylize("undefined", "undefined"); + if (isString(value)) { + var simple = "'" + JSON.stringify(value).replace(/^"|"$/g, "").replace(/'/g, "\\'").replace(/\\"/g, '"') + "'"; + return ctx.stylize(simple, "string"); + } + if (isNumber(value)) + return ctx.stylize("" + value, "number"); + if (isBoolean(value)) + return ctx.stylize("" + value, "boolean"); + if (isNull(value)) + return ctx.stylize("null", "null"); + } + function formatError(value) { + return "[" + Error.prototype.toString.call(value) + "]"; + } + function formatArray2(ctx, value, recurseTimes, visibleKeys, keys) { + var output = []; + for (var i2 = 0, l = value.length; i2 < l; ++i2) { + if (hasOwnProperty(value, String(i2))) { + output.push(formatProperty( + ctx, + value, + recurseTimes, + visibleKeys, + String(i2), + true + )); + } else { + output.push(""); + } + } + keys.forEach(function(key2) { + if (!key2.match(/^\d+$/)) { + output.push(formatProperty( + ctx, + value, + recurseTimes, + visibleKeys, + key2, + true + )); + } + }); + return output; + } + function formatProperty(ctx, value, recurseTimes, visibleKeys, key2, array) { + var name, str, desc; + desc = Object.getOwnPropertyDescriptor(value, key2) || { value: value[key2] }; + if (desc.get) { + if (desc.set) { + str = ctx.stylize("[Getter/Setter]", "special"); + } else { + str = ctx.stylize("[Getter]", "special"); + } + } else { + if (desc.set) { + str = ctx.stylize("[Setter]", "special"); + } + } + if (!hasOwnProperty(visibleKeys, key2)) { + name = "[" + key2 + "]"; + } + if (!str) { + if (ctx.seen.indexOf(desc.value) < 0) { + if (isNull(recurseTimes)) { + str = formatValue2(ctx, desc.value, null); + } else { + str = formatValue2(ctx, desc.value, recurseTimes - 1); + } + if (str.indexOf("\n") > -1) { + if (array) { + str = str.split("\n").map(function(line) { + return " " + line; + }).join("\n").slice(2); + } else { + str = "\n" + str.split("\n").map(function(line) { + return " " + line; + }).join("\n"); + } + } + } else { + str = ctx.stylize("[Circular]", "special"); + } + } + if (isUndefined(name)) { + if (array && key2.match(/^\d+$/)) { + return str; + } + name = JSON.stringify("" + key2); + if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) { + name = name.slice(1, -1); + name = ctx.stylize(name, "name"); + } else { + name = name.replace(/'/g, "\\'").replace(/\\"/g, '"').replace(/(^"|"$)/g, "'"); + name = ctx.stylize(name, "string"); + } + } + return name + ": " + str; + } + function reduceToSingleString(output, base2, braces) { + var length = output.reduce(function(prev, cur) { + if (cur.indexOf("\n") >= 0) ; + return prev + cur.replace(/\u001b\[\d\d?m/g, "").length + 1; + }, 0); + if (length > 60) { + return braces[0] + (base2 === "" ? "" : base2 + "\n ") + " " + output.join(",\n ") + " " + braces[1]; + } + return braces[0] + base2 + " " + output.join(", ") + " " + braces[1]; + } + exports2.types = requireTypes(); + function isArray(ar) { + return Array.isArray(ar); + } + exports2.isArray = isArray; + function isBoolean(arg) { + return typeof arg === "boolean"; + } + exports2.isBoolean = isBoolean; + function isNull(arg) { + return arg === null; + } + exports2.isNull = isNull; + function isNullOrUndefined(arg) { + return arg == null; + } + exports2.isNullOrUndefined = isNullOrUndefined; + function isNumber(arg) { + return typeof arg === "number"; + } + exports2.isNumber = isNumber; + function isString(arg) { + return typeof arg === "string"; + } + exports2.isString = isString; + function isSymbol2(arg) { + return typeof arg === "symbol"; + } + exports2.isSymbol = isSymbol2; + function isUndefined(arg) { + return arg === void 0; + } + exports2.isUndefined = isUndefined; + function isRegExp(re) { + return isObject(re) && objectToString(re) === "[object RegExp]"; + } + exports2.isRegExp = isRegExp; + exports2.types.isRegExp = isRegExp; + function isObject(arg) { + return typeof arg === "object" && arg !== null; + } + exports2.isObject = isObject; + function isDate(d) { + return isObject(d) && objectToString(d) === "[object Date]"; + } + exports2.isDate = isDate; + exports2.types.isDate = isDate; + function isError(e) { + return isObject(e) && (objectToString(e) === "[object Error]" || e instanceof Error); + } + exports2.isError = isError; + exports2.types.isNativeError = isError; + function isFunction(arg) { + return typeof arg === "function"; + } + exports2.isFunction = isFunction; + function isPrimitive(arg) { + return arg === null || typeof arg === "boolean" || typeof arg === "number" || typeof arg === "string" || typeof arg === "symbol" || // ES6 symbol + typeof arg === "undefined"; + } + exports2.isPrimitive = isPrimitive; + exports2.isBuffer = requireIsBufferBrowser(); + function objectToString(o) { + return Object.prototype.toString.call(o); + } + function pad(n) { + return n < 10 ? "0" + n.toString(10) : n.toString(10); + } + var months = [ + "Jan", + "Feb", + "Mar", + "Apr", + "May", + "Jun", + "Jul", + "Aug", + "Sep", + "Oct", + "Nov", + "Dec" + ]; + function timestamp() { + var d = /* @__PURE__ */ new Date(); + var time = [ + pad(d.getHours()), + pad(d.getMinutes()), + pad(d.getSeconds()) + ].join(":"); + return [d.getDate(), months[d.getMonth()], time].join(" "); + } + exports2.log = function() { + console.log("%s - %s", timestamp(), exports2.format.apply(exports2, arguments)); + }; + exports2.inherits = requireInherits_browser(); + exports2._extend = function(origin, add) { + if (!add || !isObject(add)) return origin; + var keys = Object.keys(add); + var i2 = keys.length; + while (i2--) { + origin[keys[i2]] = add[keys[i2]]; + } + return origin; + }; + function hasOwnProperty(obj, prop) { + return Object.prototype.hasOwnProperty.call(obj, prop); + } + var kCustomPromisifiedSymbol = typeof Symbol !== "undefined" ? Symbol("util.promisify.custom") : void 0; + exports2.promisify = function promisify(original) { + if (typeof original !== "function") + throw new TypeError('The "original" argument must be of type Function'); + if (kCustomPromisifiedSymbol && original[kCustomPromisifiedSymbol]) { + var fn = original[kCustomPromisifiedSymbol]; + if (typeof fn !== "function") { + throw new TypeError('The "util.promisify.custom" argument must be of type Function'); + } + Object.defineProperty(fn, kCustomPromisifiedSymbol, { + value: fn, + enumerable: false, + writable: false, + configurable: true + }); + return fn; + } + function fn() { + var promiseResolve, promiseReject; + var promise = new Promise(function(resolve, reject) { + promiseResolve = resolve; + promiseReject = reject; + }); + var args = []; + for (var i2 = 0; i2 < arguments.length; i2++) { + args.push(arguments[i2]); + } + args.push(function(err, value) { + if (err) { + promiseReject(err); + } else { + promiseResolve(value); + } + }); + try { + original.apply(this, args); + } catch (err) { + promiseReject(err); + } + return promise; + } + Object.setPrototypeOf(fn, Object.getPrototypeOf(original)); + if (kCustomPromisifiedSymbol) Object.defineProperty(fn, kCustomPromisifiedSymbol, { + value: fn, + enumerable: false, + writable: false, + configurable: true + }); + return Object.defineProperties( + fn, + getOwnPropertyDescriptors(original) + ); + }; + exports2.promisify.custom = kCustomPromisifiedSymbol; + function callbackifyOnRejected(reason, cb) { + if (!reason) { + var newReason = new Error("Promise was rejected with a falsy value"); + newReason.reason = reason; + reason = newReason; + } + return cb(reason); + } + function callbackify(original) { + if (typeof original !== "function") { + throw new TypeError('The "original" argument must be of type Function'); + } + function callbackified() { + var args = []; + for (var i2 = 0; i2 < arguments.length; i2++) { + args.push(arguments[i2]); + } + var maybeCb = args.pop(); + if (typeof maybeCb !== "function") { + throw new TypeError("The last argument must be of type Function"); + } + var self2 = this; + var cb = function() { + return maybeCb.apply(self2, arguments); + }; + original.apply(this, args).then( + function(ret) { + process$1.nextTick(cb.bind(null, null, ret)); + }, + function(rej) { + process$1.nextTick(callbackifyOnRejected.bind(null, rej, cb)); + } + ); + } + Object.setPrototypeOf(callbackified, Object.getPrototypeOf(original)); + Object.defineProperties( + callbackified, + getOwnPropertyDescriptors(original) + ); + return callbackified; + } + exports2.callbackify = callbackify; + })(util$1); + return util$1; +} +var buffer_list; +var hasRequiredBuffer_list; +function requireBuffer_list() { + if (hasRequiredBuffer_list) return buffer_list; + hasRequiredBuffer_list = 1; + function ownKeys(object, enumerableOnly) { + var keys = Object.keys(object); + if (Object.getOwnPropertySymbols) { + var symbols = Object.getOwnPropertySymbols(object); + enumerableOnly && (symbols = symbols.filter(function(sym) { + return Object.getOwnPropertyDescriptor(object, sym).enumerable; + })), keys.push.apply(keys, symbols); + } + return keys; + } + function _objectSpread(target) { + for (var i2 = 1; i2 < arguments.length; i2++) { + var source = null != arguments[i2] ? arguments[i2] : {}; + i2 % 2 ? ownKeys(Object(source), true).forEach(function(key2) { + _defineProperty(target, key2, source[key2]); + }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function(key2) { + Object.defineProperty(target, key2, Object.getOwnPropertyDescriptor(source, key2)); + }); + } + return target; + } + function _defineProperty(obj, key2, value) { + key2 = _toPropertyKey(key2); + if (key2 in obj) { + Object.defineProperty(obj, key2, { value, enumerable: true, configurable: true, writable: true }); + } else { + obj[key2] = value; + } + return obj; + } + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + } + function _defineProperties(target, props) { + for (var i2 = 0; i2 < props.length; i2++) { + var descriptor = props[i2]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); + } + } + function _createClass(Constructor, protoProps, staticProps) { + if (protoProps) _defineProperties(Constructor.prototype, protoProps); + Object.defineProperty(Constructor, "prototype", { writable: false }); + return Constructor; + } + function _toPropertyKey(arg) { + var key2 = _toPrimitive(arg, "string"); + return typeof key2 === "symbol" ? key2 : String(key2); + } + function _toPrimitive(input, hint) { + if (typeof input !== "object" || input === null) return input; + var prim = input[Symbol.toPrimitive]; + if (prim !== void 0) { + var res = prim.call(input, hint); + if (typeof res !== "object") return res; + throw new TypeError("@@toPrimitive must return a primitive value."); + } + return String(input); + } + var _require = requireDist(), Buffer2 = _require.Buffer; + var _require2 = requireUtil$1(), inspect2 = _require2.inspect; + var custom = inspect2 && inspect2.custom || "inspect"; + function copyBuffer(src, target, offset) { + Buffer2.prototype.copy.call(src, target, offset); + } + buffer_list = /* @__PURE__ */ function() { + function BufferList2() { + _classCallCheck(this, BufferList2); + this.head = null; + this.tail = null; + this.length = 0; + } + _createClass(BufferList2, [{ + key: "push", + value: function push(v) { + var entry = { + data: v, + next: null + }; + if (this.length > 0) this.tail.next = entry; + else this.head = entry; + this.tail = entry; + ++this.length; + } + }, { + key: "unshift", + value: function unshift(v) { + var entry = { + data: v, + next: this.head + }; + if (this.length === 0) this.tail = entry; + this.head = entry; + ++this.length; + } + }, { + key: "shift", + value: function shift() { + if (this.length === 0) return; + var ret = this.head.data; + if (this.length === 1) this.head = this.tail = null; + else this.head = this.head.next; + --this.length; + return ret; + } + }, { + key: "clear", + value: function clear() { + this.head = this.tail = null; + this.length = 0; + } + }, { + key: "join", + value: function join2(s) { + if (this.length === 0) return ""; + var p = this.head; + var ret = "" + p.data; + while (p = p.next) ret += s + p.data; + return ret; + } + }, { + key: "concat", + value: function concat(n) { + if (this.length === 0) return Buffer2.alloc(0); + var ret = Buffer2.allocUnsafe(n >>> 0); + var p = this.head; + var i2 = 0; + while (p) { + copyBuffer(p.data, ret, i2); + i2 += p.data.length; + p = p.next; + } + return ret; + } + // Consumes a specified amount of bytes or characters from the buffered data. + }, { + key: "consume", + value: function consume(n, hasStrings) { + var ret; + if (n < this.head.data.length) { + ret = this.head.data.slice(0, n); + this.head.data = this.head.data.slice(n); + } else if (n === this.head.data.length) { + ret = this.shift(); + } else { + ret = hasStrings ? this._getString(n) : this._getBuffer(n); + } + return ret; + } + }, { + key: "first", + value: function first() { + return this.head.data; + } + // Consumes a specified amount of characters from the buffered data. + }, { + key: "_getString", + value: function _getString(n) { + var p = this.head; + var c = 1; + var ret = p.data; + n -= ret.length; + while (p = p.next) { + var str = p.data; + var nb = n > str.length ? str.length : n; + if (nb === str.length) ret += str; + else ret += str.slice(0, n); + n -= nb; + if (n === 0) { + if (nb === str.length) { + ++c; + if (p.next) this.head = p.next; + else this.head = this.tail = null; + } else { + this.head = p; + p.data = str.slice(nb); + } + break; + } + ++c; + } + this.length -= c; + return ret; + } + // Consumes a specified amount of bytes from the buffered data. + }, { + key: "_getBuffer", + value: function _getBuffer(n) { + var ret = Buffer2.allocUnsafe(n); + var p = this.head; + var c = 1; + p.data.copy(ret); + n -= p.data.length; + while (p = p.next) { + var buf = p.data; + var nb = n > buf.length ? buf.length : n; + buf.copy(ret, ret.length - n, 0, nb); + n -= nb; + if (n === 0) { + if (nb === buf.length) { + ++c; + if (p.next) this.head = p.next; + else this.head = this.tail = null; + } else { + this.head = p; + p.data = buf.slice(nb); + } + break; + } + ++c; + } + this.length -= c; + return ret; + } + // Make sure the linked list only shows the minimal necessary information. + }, { + key: custom, + value: function value(_, options) { + return inspect2(this, _objectSpread(_objectSpread({}, options), {}, { + // Only inspect one level. + depth: 0, + // It should not recurse. + customInspect: false + })); + } + }]); + return BufferList2; + }(); + return buffer_list; +} +var destroy_1$1; +var hasRequiredDestroy$1; +function requireDestroy$1() { + if (hasRequiredDestroy$1) return destroy_1$1; + hasRequiredDestroy$1 = 1; + function destroy(err, cb) { + var _this = this; + var readableDestroyed = this._readableState && this._readableState.destroyed; + var writableDestroyed = this._writableState && this._writableState.destroyed; + if (readableDestroyed || writableDestroyed) { + if (cb) { + cb(err); + } else if (err) { + if (!this._writableState) { + process$1.nextTick(emitErrorNT, this, err); + } else if (!this._writableState.errorEmitted) { + this._writableState.errorEmitted = true; + process$1.nextTick(emitErrorNT, this, err); + } + } + return this; + } + if (this._readableState) { + this._readableState.destroyed = true; + } + if (this._writableState) { + this._writableState.destroyed = true; + } + this._destroy(err || null, function(err2) { + if (!cb && err2) { + if (!_this._writableState) { + process$1.nextTick(emitErrorAndCloseNT, _this, err2); + } else if (!_this._writableState.errorEmitted) { + _this._writableState.errorEmitted = true; + process$1.nextTick(emitErrorAndCloseNT, _this, err2); + } else { + process$1.nextTick(emitCloseNT, _this); + } + } else if (cb) { + process$1.nextTick(emitCloseNT, _this); + cb(err2); + } else { + process$1.nextTick(emitCloseNT, _this); + } + }); + return this; + } + function emitErrorAndCloseNT(self2, err) { + emitErrorNT(self2, err); + emitCloseNT(self2); + } + function emitCloseNT(self2) { + if (self2._writableState && !self2._writableState.emitClose) return; + if (self2._readableState && !self2._readableState.emitClose) return; + self2.emit("close"); + } + function undestroy() { + if (this._readableState) { + this._readableState.destroyed = false; + this._readableState.reading = false; + this._readableState.ended = false; + this._readableState.endEmitted = false; + } + if (this._writableState) { + this._writableState.destroyed = false; + this._writableState.ended = false; + this._writableState.ending = false; + this._writableState.finalCalled = false; + this._writableState.prefinished = false; + this._writableState.finished = false; + this._writableState.errorEmitted = false; + } + } + function emitErrorNT(self2, err) { + self2.emit("error", err); + } + function errorOrDestroy(stream, err) { + var rState = stream._readableState; + var wState = stream._writableState; + if (rState && rState.autoDestroy || wState && wState.autoDestroy) stream.destroy(err); + else stream.emit("error", err); + } + destroy_1$1 = { + destroy, + undestroy, + errorOrDestroy + }; + return destroy_1$1; +} +var errorsBrowser = {}; +var hasRequiredErrorsBrowser; +function requireErrorsBrowser() { + if (hasRequiredErrorsBrowser) return errorsBrowser; + hasRequiredErrorsBrowser = 1; + function _inheritsLoose(subClass, superClass) { + subClass.prototype = Object.create(superClass.prototype); + subClass.prototype.constructor = subClass; + subClass.__proto__ = superClass; + } + var codes = {}; + function createErrorType(code2, message, Base) { + if (!Base) { + Base = Error; + } + function getMessage(arg1, arg2, arg3) { + if (typeof message === "string") { + return message; + } else { + return message(arg1, arg2, arg3); + } + } + var NodeError = /* @__PURE__ */ function(_Base) { + _inheritsLoose(NodeError2, _Base); + function NodeError2(arg1, arg2, arg3) { + return _Base.call(this, getMessage(arg1, arg2, arg3)) || this; + } + return NodeError2; + }(Base); + NodeError.prototype.name = Base.name; + NodeError.prototype.code = code2; + codes[code2] = NodeError; + } + function oneOf(expected, thing) { + if (Array.isArray(expected)) { + var len2 = expected.length; + expected = expected.map(function(i2) { + return String(i2); + }); + if (len2 > 2) { + return "one of ".concat(thing, " ").concat(expected.slice(0, len2 - 1).join(", "), ", or ") + expected[len2 - 1]; + } else if (len2 === 2) { + return "one of ".concat(thing, " ").concat(expected[0], " or ").concat(expected[1]); + } else { + return "of ".concat(thing, " ").concat(expected[0]); + } + } else { + return "of ".concat(thing, " ").concat(String(expected)); + } + } + function startsWith(str, search, pos) { + return str.substr(0, search.length) === search; + } + function endsWith(str, search, this_len) { + if (this_len === void 0 || this_len > str.length) { + this_len = str.length; + } + return str.substring(this_len - search.length, this_len) === search; + } + function includes(str, search, start) { + if (typeof start !== "number") { + start = 0; + } + if (start + search.length > str.length) { + return false; + } else { + return str.indexOf(search, start) !== -1; + } + } + createErrorType("ERR_INVALID_OPT_VALUE", function(name, value) { + return 'The value "' + value + '" is invalid for option "' + name + '"'; + }, TypeError); + createErrorType("ERR_INVALID_ARG_TYPE", function(name, expected, actual) { + var determiner; + if (typeof expected === "string" && startsWith(expected, "not ")) { + determiner = "must not be"; + expected = expected.replace(/^not /, ""); + } else { + determiner = "must be"; + } + var msg; + if (endsWith(name, " argument")) { + msg = "The ".concat(name, " ").concat(determiner, " ").concat(oneOf(expected, "type")); + } else { + var type2 = includes(name, ".") ? "property" : "argument"; + msg = 'The "'.concat(name, '" ').concat(type2, " ").concat(determiner, " ").concat(oneOf(expected, "type")); + } + msg += ". Received type ".concat(typeof actual); + return msg; + }, TypeError); + createErrorType("ERR_STREAM_PUSH_AFTER_EOF", "stream.push() after EOF"); + createErrorType("ERR_METHOD_NOT_IMPLEMENTED", function(name) { + return "The " + name + " method is not implemented"; + }); + createErrorType("ERR_STREAM_PREMATURE_CLOSE", "Premature close"); + createErrorType("ERR_STREAM_DESTROYED", function(name) { + return "Cannot call " + name + " after a stream was destroyed"; + }); + createErrorType("ERR_MULTIPLE_CALLBACK", "Callback called multiple times"); + createErrorType("ERR_STREAM_CANNOT_PIPE", "Cannot pipe, not readable"); + createErrorType("ERR_STREAM_WRITE_AFTER_END", "write after end"); + createErrorType("ERR_STREAM_NULL_VALUES", "May not write null values to stream", TypeError); + createErrorType("ERR_UNKNOWN_ENCODING", function(arg) { + return "Unknown encoding: " + arg; + }, TypeError); + createErrorType("ERR_STREAM_UNSHIFT_AFTER_END_EVENT", "stream.unshift() after end event"); + errorsBrowser.codes = codes; + return errorsBrowser; +} +var state; +var hasRequiredState; +function requireState() { + if (hasRequiredState) return state; + hasRequiredState = 1; + var ERR_INVALID_OPT_VALUE = requireErrorsBrowser().codes.ERR_INVALID_OPT_VALUE; + function highWaterMarkFrom(options, isDuplex, duplexKey) { + return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null; + } + function getHighWaterMark(state2, options, duplexKey, isDuplex) { + var hwm = highWaterMarkFrom(options, isDuplex, duplexKey); + if (hwm != null) { + if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) { + var name = isDuplex ? duplexKey : "highWaterMark"; + throw new ERR_INVALID_OPT_VALUE(name, hwm); + } + return Math.floor(hwm); + } + return state2.objectMode ? 16 : 16 * 1024; + } + state = { + getHighWaterMark + }; + return state; +} +var browser$a; +var hasRequiredBrowser$a; +function requireBrowser$a() { + if (hasRequiredBrowser$a) return browser$a; + hasRequiredBrowser$a = 1; + browser$a = deprecate; + function deprecate(fn, msg) { + if (config2("noDeprecation")) { + return fn; + } + var warned = false; + function deprecated() { + if (!warned) { + if (config2("throwDeprecation")) { + throw new Error(msg); + } else if (config2("traceDeprecation")) { + console.trace(msg); + } else { + console.warn(msg); + } + warned = true; + } + return fn.apply(this, arguments); + } + return deprecated; + } + function config2(name) { + try { + if (!commonjsGlobal.localStorage) return false; + } catch (_) { + return false; + } + var val = commonjsGlobal.localStorage[name]; + if (null == val) return false; + return String(val).toLowerCase() === "true"; + } + return browser$a; +} +var _stream_writable$1; +var hasRequired_stream_writable$1; +function require_stream_writable$1() { + if (hasRequired_stream_writable$1) return _stream_writable$1; + hasRequired_stream_writable$1 = 1; + _stream_writable$1 = Writable; + function CorkedRequest(state2) { + var _this = this; + this.next = null; + this.entry = null; + this.finish = function() { + onCorkedFinish(_this, state2); + }; + } + var Duplex; + Writable.WritableState = WritableState; + var internalUtil = { + deprecate: requireBrowser$a() + }; + var Stream = requireStreamBrowser$1(); + var Buffer2 = requireDist().Buffer; + var OurUint8Array = (typeof commonjsGlobal !== "undefined" ? commonjsGlobal : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : {}).Uint8Array || function() { + }; + function _uint8ArrayToBuffer(chunk2) { + return Buffer2.from(chunk2); + } + function _isUint8Array(obj) { + return Buffer2.isBuffer(obj) || obj instanceof OurUint8Array; + } + var destroyImpl = requireDestroy$1(); + var _require = requireState(), getHighWaterMark = _require.getHighWaterMark; + var _require$codes = requireErrorsBrowser().codes, ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE, ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED, ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK, ERR_STREAM_CANNOT_PIPE = _require$codes.ERR_STREAM_CANNOT_PIPE, ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED, ERR_STREAM_NULL_VALUES = _require$codes.ERR_STREAM_NULL_VALUES, ERR_STREAM_WRITE_AFTER_END = _require$codes.ERR_STREAM_WRITE_AFTER_END, ERR_UNKNOWN_ENCODING = _require$codes.ERR_UNKNOWN_ENCODING; + var errorOrDestroy = destroyImpl.errorOrDestroy; + requireInherits_browser()(Writable, Stream); + function nop() { + } + function WritableState(options, stream, isDuplex) { + Duplex = Duplex || require_stream_duplex$1(); + options = options || {}; + if (typeof isDuplex !== "boolean") isDuplex = stream instanceof Duplex; + this.objectMode = !!options.objectMode; + if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode; + this.highWaterMark = getHighWaterMark(this, options, "writableHighWaterMark", isDuplex); + this.finalCalled = false; + this.needDrain = false; + this.ending = false; + this.ended = false; + this.finished = false; + this.destroyed = false; + var noDecode = options.decodeStrings === false; + this.decodeStrings = !noDecode; + this.defaultEncoding = options.defaultEncoding || "utf8"; + this.length = 0; + this.writing = false; + this.corked = 0; + this.sync = true; + this.bufferProcessing = false; + this.onwrite = function(er) { + onwrite(stream, er); + }; + this.writecb = null; + this.writelen = 0; + this.bufferedRequest = null; + this.lastBufferedRequest = null; + this.pendingcb = 0; + this.prefinished = false; + this.errorEmitted = false; + this.emitClose = options.emitClose !== false; + this.autoDestroy = !!options.autoDestroy; + this.bufferedRequestCount = 0; + this.corkedRequestsFree = new CorkedRequest(this); + } + WritableState.prototype.getBuffer = function getBuffer() { + var current = this.bufferedRequest; + var out = []; + while (current) { + out.push(current); + current = current.next; + } + return out; + }; + (function() { + try { + Object.defineProperty(WritableState.prototype, "buffer", { + get: internalUtil.deprecate(function writableStateBufferGetter() { + return this.getBuffer(); + }, "_writableState.buffer is deprecated. Use _writableState.getBuffer instead.", "DEP0003") + }); + } catch (_) { + } + })(); + var realHasInstance; + if (typeof Symbol === "function" && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === "function") { + realHasInstance = Function.prototype[Symbol.hasInstance]; + Object.defineProperty(Writable, Symbol.hasInstance, { + value: function value(object) { + if (realHasInstance.call(this, object)) return true; + if (this !== Writable) return false; + return object && object._writableState instanceof WritableState; + } + }); + } else { + realHasInstance = function realHasInstance2(object) { + return object instanceof this; + }; + } + function Writable(options) { + Duplex = Duplex || require_stream_duplex$1(); + var isDuplex = this instanceof Duplex; + if (!isDuplex && !realHasInstance.call(Writable, this)) return new Writable(options); + this._writableState = new WritableState(options, this, isDuplex); + this.writable = true; + if (options) { + if (typeof options.write === "function") this._write = options.write; + if (typeof options.writev === "function") this._writev = options.writev; + if (typeof options.destroy === "function") this._destroy = options.destroy; + if (typeof options.final === "function") this._final = options.final; + } + Stream.call(this); + } + Writable.prototype.pipe = function() { + errorOrDestroy(this, new ERR_STREAM_CANNOT_PIPE()); + }; + function writeAfterEnd(stream, cb) { + var er = new ERR_STREAM_WRITE_AFTER_END(); + errorOrDestroy(stream, er); + process$1.nextTick(cb, er); + } + function validChunk(stream, state2, chunk2, cb) { + var er; + if (chunk2 === null) { + er = new ERR_STREAM_NULL_VALUES(); + } else if (typeof chunk2 !== "string" && !state2.objectMode) { + er = new ERR_INVALID_ARG_TYPE("chunk", ["string", "Buffer"], chunk2); + } + if (er) { + errorOrDestroy(stream, er); + process$1.nextTick(cb, er); + return false; + } + return true; + } + Writable.prototype.write = function(chunk2, encoding, cb) { + var state2 = this._writableState; + var ret = false; + var isBuf = !state2.objectMode && _isUint8Array(chunk2); + if (isBuf && !Buffer2.isBuffer(chunk2)) { + chunk2 = _uint8ArrayToBuffer(chunk2); + } + if (typeof encoding === "function") { + cb = encoding; + encoding = null; + } + if (isBuf) encoding = "buffer"; + else if (!encoding) encoding = state2.defaultEncoding; + if (typeof cb !== "function") cb = nop; + if (state2.ending) writeAfterEnd(this, cb); + else if (isBuf || validChunk(this, state2, chunk2, cb)) { + state2.pendingcb++; + ret = writeOrBuffer(this, state2, isBuf, chunk2, encoding, cb); + } + return ret; + }; + Writable.prototype.cork = function() { + this._writableState.corked++; + }; + Writable.prototype.uncork = function() { + var state2 = this._writableState; + if (state2.corked) { + state2.corked--; + if (!state2.writing && !state2.corked && !state2.bufferProcessing && state2.bufferedRequest) clearBuffer(this, state2); + } + }; + Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) { + if (typeof encoding === "string") encoding = encoding.toLowerCase(); + if (!(["hex", "utf8", "utf-8", "ascii", "binary", "base64", "ucs2", "ucs-2", "utf16le", "utf-16le", "raw"].indexOf((encoding + "").toLowerCase()) > -1)) throw new ERR_UNKNOWN_ENCODING(encoding); + this._writableState.defaultEncoding = encoding; + return this; + }; + Object.defineProperty(Writable.prototype, "writableBuffer", { + // making it explicit this property is not enumerable + // because otherwise some prototype manipulation in + // userland will fail + enumerable: false, + get: function get() { + return this._writableState && this._writableState.getBuffer(); + } + }); + function decodeChunk(state2, chunk2, encoding) { + if (!state2.objectMode && state2.decodeStrings !== false && typeof chunk2 === "string") { + chunk2 = Buffer2.from(chunk2, encoding); + } + return chunk2; + } + Object.defineProperty(Writable.prototype, "writableHighWaterMark", { + // making it explicit this property is not enumerable + // because otherwise some prototype manipulation in + // userland will fail + enumerable: false, + get: function get() { + return this._writableState.highWaterMark; + } + }); + function writeOrBuffer(stream, state2, isBuf, chunk2, encoding, cb) { + if (!isBuf) { + var newChunk = decodeChunk(state2, chunk2, encoding); + if (chunk2 !== newChunk) { + isBuf = true; + encoding = "buffer"; + chunk2 = newChunk; + } + } + var len2 = state2.objectMode ? 1 : chunk2.length; + state2.length += len2; + var ret = state2.length < state2.highWaterMark; + if (!ret) state2.needDrain = true; + if (state2.writing || state2.corked) { + var last = state2.lastBufferedRequest; + state2.lastBufferedRequest = { + chunk: chunk2, + encoding, + isBuf, + callback: cb, + next: null + }; + if (last) { + last.next = state2.lastBufferedRequest; + } else { + state2.bufferedRequest = state2.lastBufferedRequest; + } + state2.bufferedRequestCount += 1; + } else { + doWrite(stream, state2, false, len2, chunk2, encoding, cb); + } + return ret; + } + function doWrite(stream, state2, writev, len2, chunk2, encoding, cb) { + state2.writelen = len2; + state2.writecb = cb; + state2.writing = true; + state2.sync = true; + if (state2.destroyed) state2.onwrite(new ERR_STREAM_DESTROYED("write")); + else if (writev) stream._writev(chunk2, state2.onwrite); + else stream._write(chunk2, encoding, state2.onwrite); + state2.sync = false; + } + function onwriteError(stream, state2, sync, er, cb) { + --state2.pendingcb; + if (sync) { + process$1.nextTick(cb, er); + process$1.nextTick(finishMaybe, stream, state2); + stream._writableState.errorEmitted = true; + errorOrDestroy(stream, er); + } else { + cb(er); + stream._writableState.errorEmitted = true; + errorOrDestroy(stream, er); + finishMaybe(stream, state2); + } + } + function onwriteStateUpdate(state2) { + state2.writing = false; + state2.writecb = null; + state2.length -= state2.writelen; + state2.writelen = 0; + } + function onwrite(stream, er) { + var state2 = stream._writableState; + var sync = state2.sync; + var cb = state2.writecb; + if (typeof cb !== "function") throw new ERR_MULTIPLE_CALLBACK(); + onwriteStateUpdate(state2); + if (er) onwriteError(stream, state2, sync, er, cb); + else { + var finished = needFinish(state2) || stream.destroyed; + if (!finished && !state2.corked && !state2.bufferProcessing && state2.bufferedRequest) { + clearBuffer(stream, state2); + } + if (sync) { + process$1.nextTick(afterWrite, stream, state2, finished, cb); + } else { + afterWrite(stream, state2, finished, cb); + } + } + } + function afterWrite(stream, state2, finished, cb) { + if (!finished) onwriteDrain(stream, state2); + state2.pendingcb--; + cb(); + finishMaybe(stream, state2); + } + function onwriteDrain(stream, state2) { + if (state2.length === 0 && state2.needDrain) { + state2.needDrain = false; + stream.emit("drain"); + } + } + function clearBuffer(stream, state2) { + state2.bufferProcessing = true; + var entry = state2.bufferedRequest; + if (stream._writev && entry && entry.next) { + var l = state2.bufferedRequestCount; + var buffer2 = new Array(l); + var holder = state2.corkedRequestsFree; + holder.entry = entry; + var count = 0; + var allBuffers = true; + while (entry) { + buffer2[count] = entry; + if (!entry.isBuf) allBuffers = false; + entry = entry.next; + count += 1; + } + buffer2.allBuffers = allBuffers; + doWrite(stream, state2, true, state2.length, buffer2, "", holder.finish); + state2.pendingcb++; + state2.lastBufferedRequest = null; + if (holder.next) { + state2.corkedRequestsFree = holder.next; + holder.next = null; + } else { + state2.corkedRequestsFree = new CorkedRequest(state2); + } + state2.bufferedRequestCount = 0; + } else { + while (entry) { + var chunk2 = entry.chunk; + var encoding = entry.encoding; + var cb = entry.callback; + var len2 = state2.objectMode ? 1 : chunk2.length; + doWrite(stream, state2, false, len2, chunk2, encoding, cb); + entry = entry.next; + state2.bufferedRequestCount--; + if (state2.writing) { + break; + } + } + if (entry === null) state2.lastBufferedRequest = null; + } + state2.bufferedRequest = entry; + state2.bufferProcessing = false; + } + Writable.prototype._write = function(chunk2, encoding, cb) { + cb(new ERR_METHOD_NOT_IMPLEMENTED("_write()")); + }; + Writable.prototype._writev = null; + Writable.prototype.end = function(chunk2, encoding, cb) { + var state2 = this._writableState; + if (typeof chunk2 === "function") { + cb = chunk2; + chunk2 = null; + encoding = null; + } else if (typeof encoding === "function") { + cb = encoding; + encoding = null; + } + if (chunk2 !== null && chunk2 !== void 0) this.write(chunk2, encoding); + if (state2.corked) { + state2.corked = 1; + this.uncork(); + } + if (!state2.ending) endWritable(this, state2, cb); + return this; + }; + Object.defineProperty(Writable.prototype, "writableLength", { + // making it explicit this property is not enumerable + // because otherwise some prototype manipulation in + // userland will fail + enumerable: false, + get: function get() { + return this._writableState.length; + } + }); + function needFinish(state2) { + return state2.ending && state2.length === 0 && state2.bufferedRequest === null && !state2.finished && !state2.writing; + } + function callFinal(stream, state2) { + stream._final(function(err) { + state2.pendingcb--; + if (err) { + errorOrDestroy(stream, err); + } + state2.prefinished = true; + stream.emit("prefinish"); + finishMaybe(stream, state2); + }); + } + function prefinish(stream, state2) { + if (!state2.prefinished && !state2.finalCalled) { + if (typeof stream._final === "function" && !state2.destroyed) { + state2.pendingcb++; + state2.finalCalled = true; + process$1.nextTick(callFinal, stream, state2); + } else { + state2.prefinished = true; + stream.emit("prefinish"); + } + } + } + function finishMaybe(stream, state2) { + var need = needFinish(state2); + if (need) { + prefinish(stream, state2); + if (state2.pendingcb === 0) { + state2.finished = true; + stream.emit("finish"); + if (state2.autoDestroy) { + var rState = stream._readableState; + if (!rState || rState.autoDestroy && rState.endEmitted) { + stream.destroy(); + } + } + } + } + return need; + } + function endWritable(stream, state2, cb) { + state2.ending = true; + finishMaybe(stream, state2); + if (cb) { + if (state2.finished) process$1.nextTick(cb); + else stream.once("finish", cb); + } + state2.ended = true; + stream.writable = false; + } + function onCorkedFinish(corkReq, state2, err) { + var entry = corkReq.entry; + corkReq.entry = null; + while (entry) { + var cb = entry.callback; + state2.pendingcb--; + cb(err); + entry = entry.next; + } + state2.corkedRequestsFree.next = corkReq; + } + Object.defineProperty(Writable.prototype, "destroyed", { + // making it explicit this property is not enumerable + // because otherwise some prototype manipulation in + // userland will fail + enumerable: false, + get: function get() { + if (this._writableState === void 0) { + return false; + } + return this._writableState.destroyed; + }, + set: function set(value) { + if (!this._writableState) { + return; + } + this._writableState.destroyed = value; + } + }); + Writable.prototype.destroy = destroyImpl.destroy; + Writable.prototype._undestroy = destroyImpl.undestroy; + Writable.prototype._destroy = function(err, cb) { + cb(err); + }; + return _stream_writable$1; +} +var _stream_duplex$1; +var hasRequired_stream_duplex$1; +function require_stream_duplex$1() { + if (hasRequired_stream_duplex$1) return _stream_duplex$1; + hasRequired_stream_duplex$1 = 1; + var objectKeys = Object.keys || function(obj) { + var keys2 = []; + for (var key2 in obj) keys2.push(key2); + return keys2; + }; + _stream_duplex$1 = Duplex; + var Readable = require_stream_readable$1(); + var Writable = require_stream_writable$1(); + requireInherits_browser()(Duplex, Readable); + { + var keys = objectKeys(Writable.prototype); + for (var v = 0; v < keys.length; v++) { + var method = keys[v]; + if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method]; + } + } + function Duplex(options) { + if (!(this instanceof Duplex)) return new Duplex(options); + Readable.call(this, options); + Writable.call(this, options); + this.allowHalfOpen = true; + if (options) { + if (options.readable === false) this.readable = false; + if (options.writable === false) this.writable = false; + if (options.allowHalfOpen === false) { + this.allowHalfOpen = false; + this.once("end", onend); + } + } + } + Object.defineProperty(Duplex.prototype, "writableHighWaterMark", { + // making it explicit this property is not enumerable + // because otherwise some prototype manipulation in + // userland will fail + enumerable: false, + get: function get() { + return this._writableState.highWaterMark; + } + }); + Object.defineProperty(Duplex.prototype, "writableBuffer", { + // making it explicit this property is not enumerable + // because otherwise some prototype manipulation in + // userland will fail + enumerable: false, + get: function get() { + return this._writableState && this._writableState.getBuffer(); + } + }); + Object.defineProperty(Duplex.prototype, "writableLength", { + // making it explicit this property is not enumerable + // because otherwise some prototype manipulation in + // userland will fail + enumerable: false, + get: function get() { + return this._writableState.length; + } + }); + function onend() { + if (this._writableState.ended) return; + process$1.nextTick(onEndNT, this); + } + function onEndNT(self2) { + self2.end(); + } + Object.defineProperty(Duplex.prototype, "destroyed", { + // making it explicit this property is not enumerable + // because otherwise some prototype manipulation in + // userland will fail + enumerable: false, + get: function get() { + if (this._readableState === void 0 || this._writableState === void 0) { + return false; + } + return this._readableState.destroyed && this._writableState.destroyed; + }, + set: function set(value) { + if (this._readableState === void 0 || this._writableState === void 0) { + return; + } + this._readableState.destroyed = value; + this._writableState.destroyed = value; + } + }); + return _stream_duplex$1; +} +var string_decoder = {}; +var hasRequiredString_decoder; +function requireString_decoder() { + if (hasRequiredString_decoder) return string_decoder; + hasRequiredString_decoder = 1; + var Buffer2 = requireSafeBuffer$1().Buffer; + var isEncoding = Buffer2.isEncoding || function(encoding) { + encoding = "" + encoding; + switch (encoding && encoding.toLowerCase()) { + case "hex": + case "utf8": + case "utf-8": + case "ascii": + case "binary": + case "base64": + case "ucs2": + case "ucs-2": + case "utf16le": + case "utf-16le": + case "raw": + return true; + default: + return false; + } + }; + function _normalizeEncoding(enc) { + if (!enc) return "utf8"; + var retried; + while (true) { + switch (enc) { + case "utf8": + case "utf-8": + return "utf8"; + case "ucs2": + case "ucs-2": + case "utf16le": + case "utf-16le": + return "utf16le"; + case "latin1": + case "binary": + return "latin1"; + case "base64": + case "ascii": + case "hex": + return enc; + default: + if (retried) return; + enc = ("" + enc).toLowerCase(); + retried = true; + } + } + } + function normalizeEncoding(enc) { + var nenc = _normalizeEncoding(enc); + if (typeof nenc !== "string" && (Buffer2.isEncoding === isEncoding || !isEncoding(enc))) throw new Error("Unknown encoding: " + enc); + return nenc || enc; + } + string_decoder.StringDecoder = StringDecoder; + function StringDecoder(encoding) { + this.encoding = normalizeEncoding(encoding); + var nb; + switch (this.encoding) { + case "utf16le": + this.text = utf16Text; + this.end = utf16End; + nb = 4; + break; + case "utf8": + this.fillLast = utf8FillLast; + nb = 4; + break; + case "base64": + this.text = base64Text; + this.end = base64End; + nb = 3; + break; + default: + this.write = simpleWrite; + this.end = simpleEnd; + return; + } + this.lastNeed = 0; + this.lastTotal = 0; + this.lastChar = Buffer2.allocUnsafe(nb); + } + StringDecoder.prototype.write = function(buf) { + if (buf.length === 0) return ""; + var r; + var i2; + if (this.lastNeed) { + r = this.fillLast(buf); + if (r === void 0) return ""; + i2 = this.lastNeed; + this.lastNeed = 0; + } else { + i2 = 0; + } + if (i2 < buf.length) return r ? r + this.text(buf, i2) : this.text(buf, i2); + return r || ""; + }; + StringDecoder.prototype.end = utf8End; + StringDecoder.prototype.text = utf8Text; + StringDecoder.prototype.fillLast = function(buf) { + if (this.lastNeed <= buf.length) { + buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed); + return this.lastChar.toString(this.encoding, 0, this.lastTotal); + } + buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length); + this.lastNeed -= buf.length; + }; + function utf8CheckByte(byte) { + if (byte <= 127) return 0; + else if (byte >> 5 === 6) return 2; + else if (byte >> 4 === 14) return 3; + else if (byte >> 3 === 30) return 4; + return byte >> 6 === 2 ? -1 : -2; + } + function utf8CheckIncomplete(self2, buf, i2) { + var j = buf.length - 1; + if (j < i2) return 0; + var nb = utf8CheckByte(buf[j]); + if (nb >= 0) { + if (nb > 0) self2.lastNeed = nb - 1; + return nb; + } + if (--j < i2 || nb === -2) return 0; + nb = utf8CheckByte(buf[j]); + if (nb >= 0) { + if (nb > 0) self2.lastNeed = nb - 2; + return nb; + } + if (--j < i2 || nb === -2) return 0; + nb = utf8CheckByte(buf[j]); + if (nb >= 0) { + if (nb > 0) { + if (nb === 2) nb = 0; + else self2.lastNeed = nb - 3; + } + return nb; + } + return 0; + } + function utf8CheckExtraBytes(self2, buf, p) { + if ((buf[0] & 192) !== 128) { + self2.lastNeed = 0; + return "�"; + } + if (self2.lastNeed > 1 && buf.length > 1) { + if ((buf[1] & 192) !== 128) { + self2.lastNeed = 1; + return "�"; + } + if (self2.lastNeed > 2 && buf.length > 2) { + if ((buf[2] & 192) !== 128) { + self2.lastNeed = 2; + return "�"; + } + } + } + } + function utf8FillLast(buf) { + var p = this.lastTotal - this.lastNeed; + var r = utf8CheckExtraBytes(this, buf); + if (r !== void 0) return r; + if (this.lastNeed <= buf.length) { + buf.copy(this.lastChar, p, 0, this.lastNeed); + return this.lastChar.toString(this.encoding, 0, this.lastTotal); + } + buf.copy(this.lastChar, p, 0, buf.length); + this.lastNeed -= buf.length; + } + function utf8Text(buf, i2) { + var total = utf8CheckIncomplete(this, buf, i2); + if (!this.lastNeed) return buf.toString("utf8", i2); + this.lastTotal = total; + var end = buf.length - (total - this.lastNeed); + buf.copy(this.lastChar, 0, end); + return buf.toString("utf8", i2, end); + } + function utf8End(buf) { + var r = buf && buf.length ? this.write(buf) : ""; + if (this.lastNeed) return r + "�"; + return r; + } + function utf16Text(buf, i2) { + if ((buf.length - i2) % 2 === 0) { + var r = buf.toString("utf16le", i2); + if (r) { + var c = r.charCodeAt(r.length - 1); + if (c >= 55296 && c <= 56319) { + this.lastNeed = 2; + this.lastTotal = 4; + this.lastChar[0] = buf[buf.length - 2]; + this.lastChar[1] = buf[buf.length - 1]; + return r.slice(0, -1); + } + } + return r; + } + this.lastNeed = 1; + this.lastTotal = 2; + this.lastChar[0] = buf[buf.length - 1]; + return buf.toString("utf16le", i2, buf.length - 1); + } + function utf16End(buf) { + var r = buf && buf.length ? this.write(buf) : ""; + if (this.lastNeed) { + var end = this.lastTotal - this.lastNeed; + return r + this.lastChar.toString("utf16le", 0, end); + } + return r; + } + function base64Text(buf, i2) { + var n = (buf.length - i2) % 3; + if (n === 0) return buf.toString("base64", i2); + this.lastNeed = 3 - n; + this.lastTotal = 3; + if (n === 1) { + this.lastChar[0] = buf[buf.length - 1]; + } else { + this.lastChar[0] = buf[buf.length - 2]; + this.lastChar[1] = buf[buf.length - 1]; + } + return buf.toString("base64", i2, buf.length - n); + } + function base64End(buf) { + var r = buf && buf.length ? this.write(buf) : ""; + if (this.lastNeed) return r + this.lastChar.toString("base64", 0, 3 - this.lastNeed); + return r; + } + function simpleWrite(buf) { + return buf.toString(this.encoding); + } + function simpleEnd(buf) { + return buf && buf.length ? this.write(buf) : ""; + } + return string_decoder; +} +var endOfStream; +var hasRequiredEndOfStream; +function requireEndOfStream() { + if (hasRequiredEndOfStream) return endOfStream; + hasRequiredEndOfStream = 1; + var ERR_STREAM_PREMATURE_CLOSE = requireErrorsBrowser().codes.ERR_STREAM_PREMATURE_CLOSE; + function once(callback) { + var called = false; + return function() { + if (called) return; + called = true; + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + callback.apply(this, args); + }; + } + function noop2() { + } + function isRequest(stream) { + return stream.setHeader && typeof stream.abort === "function"; + } + function eos(stream, opts, callback) { + if (typeof opts === "function") return eos(stream, null, opts); + if (!opts) opts = {}; + callback = once(callback || noop2); + var readable = opts.readable || opts.readable !== false && stream.readable; + var writable = opts.writable || opts.writable !== false && stream.writable; + var onlegacyfinish = function onlegacyfinish2() { + if (!stream.writable) onfinish(); + }; + var writableEnded = stream._writableState && stream._writableState.finished; + var onfinish = function onfinish2() { + writable = false; + writableEnded = true; + if (!readable) callback.call(stream); + }; + var readableEnded = stream._readableState && stream._readableState.endEmitted; + var onend = function onend2() { + readable = false; + readableEnded = true; + if (!writable) callback.call(stream); + }; + var onerror = function onerror2(err) { + callback.call(stream, err); + }; + var onclose = function onclose2() { + var err; + if (readable && !readableEnded) { + if (!stream._readableState || !stream._readableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE(); + return callback.call(stream, err); + } + if (writable && !writableEnded) { + if (!stream._writableState || !stream._writableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE(); + return callback.call(stream, err); + } + }; + var onrequest = function onrequest2() { + stream.req.on("finish", onfinish); + }; + if (isRequest(stream)) { + stream.on("complete", onfinish); + stream.on("abort", onclose); + if (stream.req) onrequest(); + else stream.on("request", onrequest); + } else if (writable && !stream._writableState) { + stream.on("end", onlegacyfinish); + stream.on("close", onlegacyfinish); + } + stream.on("end", onend); + stream.on("finish", onfinish); + if (opts.error !== false) stream.on("error", onerror); + stream.on("close", onclose); + return function() { + stream.removeListener("complete", onfinish); + stream.removeListener("abort", onclose); + stream.removeListener("request", onrequest); + if (stream.req) stream.req.removeListener("finish", onfinish); + stream.removeListener("end", onlegacyfinish); + stream.removeListener("close", onlegacyfinish); + stream.removeListener("finish", onfinish); + stream.removeListener("end", onend); + stream.removeListener("error", onerror); + stream.removeListener("close", onclose); + }; + } + endOfStream = eos; + return endOfStream; +} +var async_iterator; +var hasRequiredAsync_iterator; +function requireAsync_iterator() { + if (hasRequiredAsync_iterator) return async_iterator; + hasRequiredAsync_iterator = 1; + var _Object$setPrototypeO; + function _defineProperty(obj, key2, value) { + key2 = _toPropertyKey(key2); + if (key2 in obj) { + Object.defineProperty(obj, key2, { value, enumerable: true, configurable: true, writable: true }); + } else { + obj[key2] = value; + } + return obj; + } + function _toPropertyKey(arg) { + var key2 = _toPrimitive(arg, "string"); + return typeof key2 === "symbol" ? key2 : String(key2); + } + function _toPrimitive(input, hint) { + if (typeof input !== "object" || input === null) return input; + var prim = input[Symbol.toPrimitive]; + if (prim !== void 0) { + var res = prim.call(input, hint); + if (typeof res !== "object") return res; + throw new TypeError("@@toPrimitive must return a primitive value."); + } + return (hint === "string" ? String : Number)(input); + } + var finished = requireEndOfStream(); + var kLastResolve = Symbol("lastResolve"); + var kLastReject = Symbol("lastReject"); + var kError = Symbol("error"); + var kEnded = Symbol("ended"); + var kLastPromise = Symbol("lastPromise"); + var kHandlePromise = Symbol("handlePromise"); + var kStream = Symbol("stream"); + function createIterResult(value, done) { + return { + value, + done + }; + } + function readAndResolve(iter) { + var resolve = iter[kLastResolve]; + if (resolve !== null) { + var data = iter[kStream].read(); + if (data !== null) { + iter[kLastPromise] = null; + iter[kLastResolve] = null; + iter[kLastReject] = null; + resolve(createIterResult(data, false)); + } + } + } + function onReadable(iter) { + process$1.nextTick(readAndResolve, iter); + } + function wrapForNext(lastPromise, iter) { + return function(resolve, reject) { + lastPromise.then(function() { + if (iter[kEnded]) { + resolve(createIterResult(void 0, true)); + return; + } + iter[kHandlePromise](resolve, reject); + }, reject); + }; + } + var AsyncIteratorPrototype = Object.getPrototypeOf(function() { + }); + var ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPrototypeO = { + get stream() { + return this[kStream]; + }, + next: function next() { + var _this = this; + var error = this[kError]; + if (error !== null) { + return Promise.reject(error); + } + if (this[kEnded]) { + return Promise.resolve(createIterResult(void 0, true)); + } + if (this[kStream].destroyed) { + return new Promise(function(resolve, reject) { + process$1.nextTick(function() { + if (_this[kError]) { + reject(_this[kError]); + } else { + resolve(createIterResult(void 0, true)); + } + }); + }); + } + var lastPromise = this[kLastPromise]; + var promise; + if (lastPromise) { + promise = new Promise(wrapForNext(lastPromise, this)); + } else { + var data = this[kStream].read(); + if (data !== null) { + return Promise.resolve(createIterResult(data, false)); + } + promise = new Promise(this[kHandlePromise]); + } + this[kLastPromise] = promise; + return promise; + } + }, _defineProperty(_Object$setPrototypeO, Symbol.asyncIterator, function() { + return this; + }), _defineProperty(_Object$setPrototypeO, "return", function _return() { + var _this2 = this; + return new Promise(function(resolve, reject) { + _this2[kStream].destroy(null, function(err) { + if (err) { + reject(err); + return; + } + resolve(createIterResult(void 0, true)); + }); + }); + }), _Object$setPrototypeO), AsyncIteratorPrototype); + var createReadableStreamAsyncIterator = function createReadableStreamAsyncIterator2(stream) { + var _Object$create; + var iterator = Object.create(ReadableStreamAsyncIteratorPrototype, (_Object$create = {}, _defineProperty(_Object$create, kStream, { + value: stream, + writable: true + }), _defineProperty(_Object$create, kLastResolve, { + value: null, + writable: true + }), _defineProperty(_Object$create, kLastReject, { + value: null, + writable: true + }), _defineProperty(_Object$create, kError, { + value: null, + writable: true + }), _defineProperty(_Object$create, kEnded, { + value: stream._readableState.endEmitted, + writable: true + }), _defineProperty(_Object$create, kHandlePromise, { + value: function value(resolve, reject) { + var data = iterator[kStream].read(); + if (data) { + iterator[kLastPromise] = null; + iterator[kLastResolve] = null; + iterator[kLastReject] = null; + resolve(createIterResult(data, false)); + } else { + iterator[kLastResolve] = resolve; + iterator[kLastReject] = reject; + } + }, + writable: true + }), _Object$create)); + iterator[kLastPromise] = null; + finished(stream, function(err) { + if (err && err.code !== "ERR_STREAM_PREMATURE_CLOSE") { + var reject = iterator[kLastReject]; + if (reject !== null) { + iterator[kLastPromise] = null; + iterator[kLastResolve] = null; + iterator[kLastReject] = null; + reject(err); + } + iterator[kError] = err; + return; + } + var resolve = iterator[kLastResolve]; + if (resolve !== null) { + iterator[kLastPromise] = null; + iterator[kLastResolve] = null; + iterator[kLastReject] = null; + resolve(createIterResult(void 0, true)); + } + iterator[kEnded] = true; + }); + stream.on("readable", onReadable.bind(null, iterator)); + return iterator; + }; + async_iterator = createReadableStreamAsyncIterator; + return async_iterator; +} +var fromBrowser; +var hasRequiredFromBrowser; +function requireFromBrowser() { + if (hasRequiredFromBrowser) return fromBrowser; + hasRequiredFromBrowser = 1; + fromBrowser = function() { + throw new Error("Readable.from is not available in the browser"); + }; + return fromBrowser; +} +var _stream_readable$1; +var hasRequired_stream_readable$1; +function require_stream_readable$1() { + if (hasRequired_stream_readable$1) return _stream_readable$1; + hasRequired_stream_readable$1 = 1; + _stream_readable$1 = Readable; + var Duplex; + Readable.ReadableState = ReadableState; + requireEvents().EventEmitter; + var EElistenerCount = function EElistenerCount2(emitter, type2) { + return emitter.listeners(type2).length; + }; + var Stream = requireStreamBrowser$1(); + var Buffer2 = requireDist().Buffer; + var OurUint8Array = (typeof commonjsGlobal !== "undefined" ? commonjsGlobal : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : {}).Uint8Array || function() { + }; + function _uint8ArrayToBuffer(chunk2) { + return Buffer2.from(chunk2); + } + function _isUint8Array(obj) { + return Buffer2.isBuffer(obj) || obj instanceof OurUint8Array; + } + var debugUtil = requireUtil$1(); + var debug; + if (debugUtil && debugUtil.debuglog) { + debug = debugUtil.debuglog("stream"); + } else { + debug = function debug2() { + }; + } + var BufferList2 = requireBuffer_list(); + var destroyImpl = requireDestroy$1(); + var _require = requireState(), getHighWaterMark = _require.getHighWaterMark; + var _require$codes = requireErrorsBrowser().codes, ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE, ERR_STREAM_PUSH_AFTER_EOF = _require$codes.ERR_STREAM_PUSH_AFTER_EOF, ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED, ERR_STREAM_UNSHIFT_AFTER_END_EVENT = _require$codes.ERR_STREAM_UNSHIFT_AFTER_END_EVENT; + var StringDecoder; + var createReadableStreamAsyncIterator; + var from; + requireInherits_browser()(Readable, Stream); + var errorOrDestroy = destroyImpl.errorOrDestroy; + var kProxyEvents = ["error", "close", "destroy", "pause", "resume"]; + function prependListener(emitter, event, fn) { + if (typeof emitter.prependListener === "function") return emitter.prependListener(event, fn); + if (!emitter._events || !emitter._events[event]) emitter.on(event, fn); + else if (Array.isArray(emitter._events[event])) emitter._events[event].unshift(fn); + else emitter._events[event] = [fn, emitter._events[event]]; + } + function ReadableState(options, stream, isDuplex) { + Duplex = Duplex || require_stream_duplex$1(); + options = options || {}; + if (typeof isDuplex !== "boolean") isDuplex = stream instanceof Duplex; + this.objectMode = !!options.objectMode; + if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode; + this.highWaterMark = getHighWaterMark(this, options, "readableHighWaterMark", isDuplex); + this.buffer = new BufferList2(); + this.length = 0; + this.pipes = null; + this.pipesCount = 0; + this.flowing = null; + this.ended = false; + this.endEmitted = false; + this.reading = false; + this.sync = true; + this.needReadable = false; + this.emittedReadable = false; + this.readableListening = false; + this.resumeScheduled = false; + this.paused = true; + this.emitClose = options.emitClose !== false; + this.autoDestroy = !!options.autoDestroy; + this.destroyed = false; + this.defaultEncoding = options.defaultEncoding || "utf8"; + this.awaitDrain = 0; + this.readingMore = false; + this.decoder = null; + this.encoding = null; + if (options.encoding) { + if (!StringDecoder) StringDecoder = requireString_decoder().StringDecoder; + this.decoder = new StringDecoder(options.encoding); + this.encoding = options.encoding; + } + } + function Readable(options) { + Duplex = Duplex || require_stream_duplex$1(); + if (!(this instanceof Readable)) return new Readable(options); + var isDuplex = this instanceof Duplex; + this._readableState = new ReadableState(options, this, isDuplex); + this.readable = true; + if (options) { + if (typeof options.read === "function") this._read = options.read; + if (typeof options.destroy === "function") this._destroy = options.destroy; + } + Stream.call(this); + } + Object.defineProperty(Readable.prototype, "destroyed", { + // making it explicit this property is not enumerable + // because otherwise some prototype manipulation in + // userland will fail + enumerable: false, + get: function get() { + if (this._readableState === void 0) { + return false; + } + return this._readableState.destroyed; + }, + set: function set(value) { + if (!this._readableState) { + return; + } + this._readableState.destroyed = value; + } + }); + Readable.prototype.destroy = destroyImpl.destroy; + Readable.prototype._undestroy = destroyImpl.undestroy; + Readable.prototype._destroy = function(err, cb) { + cb(err); + }; + Readable.prototype.push = function(chunk2, encoding) { + var state2 = this._readableState; + var skipChunkCheck; + if (!state2.objectMode) { + if (typeof chunk2 === "string") { + encoding = encoding || state2.defaultEncoding; + if (encoding !== state2.encoding) { + chunk2 = Buffer2.from(chunk2, encoding); + encoding = ""; + } + skipChunkCheck = true; + } + } else { + skipChunkCheck = true; + } + return readableAddChunk(this, chunk2, encoding, false, skipChunkCheck); + }; + Readable.prototype.unshift = function(chunk2) { + return readableAddChunk(this, chunk2, null, true, false); + }; + function readableAddChunk(stream, chunk2, encoding, addToFront, skipChunkCheck) { + debug("readableAddChunk", chunk2); + var state2 = stream._readableState; + if (chunk2 === null) { + state2.reading = false; + onEofChunk(stream, state2); + } else { + var er; + if (!skipChunkCheck) er = chunkInvalid(state2, chunk2); + if (er) { + errorOrDestroy(stream, er); + } else if (state2.objectMode || chunk2 && chunk2.length > 0) { + if (typeof chunk2 !== "string" && !state2.objectMode && Object.getPrototypeOf(chunk2) !== Buffer2.prototype) { + chunk2 = _uint8ArrayToBuffer(chunk2); + } + if (addToFront) { + if (state2.endEmitted) errorOrDestroy(stream, new ERR_STREAM_UNSHIFT_AFTER_END_EVENT()); + else addChunk(stream, state2, chunk2, true); + } else if (state2.ended) { + errorOrDestroy(stream, new ERR_STREAM_PUSH_AFTER_EOF()); + } else if (state2.destroyed) { + return false; + } else { + state2.reading = false; + if (state2.decoder && !encoding) { + chunk2 = state2.decoder.write(chunk2); + if (state2.objectMode || chunk2.length !== 0) addChunk(stream, state2, chunk2, false); + else maybeReadMore(stream, state2); + } else { + addChunk(stream, state2, chunk2, false); + } + } + } else if (!addToFront) { + state2.reading = false; + maybeReadMore(stream, state2); + } + } + return !state2.ended && (state2.length < state2.highWaterMark || state2.length === 0); + } + function addChunk(stream, state2, chunk2, addToFront) { + if (state2.flowing && state2.length === 0 && !state2.sync) { + state2.awaitDrain = 0; + stream.emit("data", chunk2); + } else { + state2.length += state2.objectMode ? 1 : chunk2.length; + if (addToFront) state2.buffer.unshift(chunk2); + else state2.buffer.push(chunk2); + if (state2.needReadable) emitReadable(stream); + } + maybeReadMore(stream, state2); + } + function chunkInvalid(state2, chunk2) { + var er; + if (!_isUint8Array(chunk2) && typeof chunk2 !== "string" && chunk2 !== void 0 && !state2.objectMode) { + er = new ERR_INVALID_ARG_TYPE("chunk", ["string", "Buffer", "Uint8Array"], chunk2); + } + return er; + } + Readable.prototype.isPaused = function() { + return this._readableState.flowing === false; + }; + Readable.prototype.setEncoding = function(enc) { + if (!StringDecoder) StringDecoder = requireString_decoder().StringDecoder; + var decoder = new StringDecoder(enc); + this._readableState.decoder = decoder; + this._readableState.encoding = this._readableState.decoder.encoding; + var p = this._readableState.buffer.head; + var content = ""; + while (p !== null) { + content += decoder.write(p.data); + p = p.next; + } + this._readableState.buffer.clear(); + if (content !== "") this._readableState.buffer.push(content); + this._readableState.length = content.length; + return this; + }; + var MAX_HWM = 1073741824; + function computeNewHighWaterMark(n) { + if (n >= MAX_HWM) { + n = MAX_HWM; + } else { + n--; + n |= n >>> 1; + n |= n >>> 2; + n |= n >>> 4; + n |= n >>> 8; + n |= n >>> 16; + n++; + } + return n; + } + function howMuchToRead(n, state2) { + if (n <= 0 || state2.length === 0 && state2.ended) return 0; + if (state2.objectMode) return 1; + if (n !== n) { + if (state2.flowing && state2.length) return state2.buffer.head.data.length; + else return state2.length; + } + if (n > state2.highWaterMark) state2.highWaterMark = computeNewHighWaterMark(n); + if (n <= state2.length) return n; + if (!state2.ended) { + state2.needReadable = true; + return 0; + } + return state2.length; + } + Readable.prototype.read = function(n) { + debug("read", n); + n = parseInt(n, 10); + var state2 = this._readableState; + var nOrig = n; + if (n !== 0) state2.emittedReadable = false; + if (n === 0 && state2.needReadable && ((state2.highWaterMark !== 0 ? state2.length >= state2.highWaterMark : state2.length > 0) || state2.ended)) { + debug("read: emitReadable", state2.length, state2.ended); + if (state2.length === 0 && state2.ended) endReadable(this); + else emitReadable(this); + return null; + } + n = howMuchToRead(n, state2); + if (n === 0 && state2.ended) { + if (state2.length === 0) endReadable(this); + return null; + } + var doRead = state2.needReadable; + debug("need readable", doRead); + if (state2.length === 0 || state2.length - n < state2.highWaterMark) { + doRead = true; + debug("length less than watermark", doRead); + } + if (state2.ended || state2.reading) { + doRead = false; + debug("reading or ended", doRead); + } else if (doRead) { + debug("do read"); + state2.reading = true; + state2.sync = true; + if (state2.length === 0) state2.needReadable = true; + this._read(state2.highWaterMark); + state2.sync = false; + if (!state2.reading) n = howMuchToRead(nOrig, state2); + } + var ret; + if (n > 0) ret = fromList(n, state2); + else ret = null; + if (ret === null) { + state2.needReadable = state2.length <= state2.highWaterMark; + n = 0; + } else { + state2.length -= n; + state2.awaitDrain = 0; + } + if (state2.length === 0) { + if (!state2.ended) state2.needReadable = true; + if (nOrig !== n && state2.ended) endReadable(this); + } + if (ret !== null) this.emit("data", ret); + return ret; + }; + function onEofChunk(stream, state2) { + debug("onEofChunk"); + if (state2.ended) return; + if (state2.decoder) { + var chunk2 = state2.decoder.end(); + if (chunk2 && chunk2.length) { + state2.buffer.push(chunk2); + state2.length += state2.objectMode ? 1 : chunk2.length; + } + } + state2.ended = true; + if (state2.sync) { + emitReadable(stream); + } else { + state2.needReadable = false; + if (!state2.emittedReadable) { + state2.emittedReadable = true; + emitReadable_(stream); + } + } + } + function emitReadable(stream) { + var state2 = stream._readableState; + debug("emitReadable", state2.needReadable, state2.emittedReadable); + state2.needReadable = false; + if (!state2.emittedReadable) { + debug("emitReadable", state2.flowing); + state2.emittedReadable = true; + process$1.nextTick(emitReadable_, stream); + } + } + function emitReadable_(stream) { + var state2 = stream._readableState; + debug("emitReadable_", state2.destroyed, state2.length, state2.ended); + if (!state2.destroyed && (state2.length || state2.ended)) { + stream.emit("readable"); + state2.emittedReadable = false; + } + state2.needReadable = !state2.flowing && !state2.ended && state2.length <= state2.highWaterMark; + flow(stream); + } + function maybeReadMore(stream, state2) { + if (!state2.readingMore) { + state2.readingMore = true; + process$1.nextTick(maybeReadMore_, stream, state2); + } + } + function maybeReadMore_(stream, state2) { + while (!state2.reading && !state2.ended && (state2.length < state2.highWaterMark || state2.flowing && state2.length === 0)) { + var len2 = state2.length; + debug("maybeReadMore read 0"); + stream.read(0); + if (len2 === state2.length) + break; + } + state2.readingMore = false; + } + Readable.prototype._read = function(n) { + errorOrDestroy(this, new ERR_METHOD_NOT_IMPLEMENTED("_read()")); + }; + Readable.prototype.pipe = function(dest, pipeOpts) { + var src = this; + var state2 = this._readableState; + switch (state2.pipesCount) { + case 0: + state2.pipes = dest; + break; + case 1: + state2.pipes = [state2.pipes, dest]; + break; + default: + state2.pipes.push(dest); + break; + } + state2.pipesCount += 1; + debug("pipe count=%d opts=%j", state2.pipesCount, pipeOpts); + var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process$1.stdout && dest !== process$1.stderr; + var endFn = doEnd ? onend : unpipe; + if (state2.endEmitted) process$1.nextTick(endFn); + else src.once("end", endFn); + dest.on("unpipe", onunpipe); + function onunpipe(readable, unpipeInfo) { + debug("onunpipe"); + if (readable === src) { + if (unpipeInfo && unpipeInfo.hasUnpiped === false) { + unpipeInfo.hasUnpiped = true; + cleanup(); + } + } + } + function onend() { + debug("onend"); + dest.end(); + } + var ondrain = pipeOnDrain(src); + dest.on("drain", ondrain); + var cleanedUp = false; + function cleanup() { + debug("cleanup"); + dest.removeListener("close", onclose); + dest.removeListener("finish", onfinish); + dest.removeListener("drain", ondrain); + dest.removeListener("error", onerror); + dest.removeListener("unpipe", onunpipe); + src.removeListener("end", onend); + src.removeListener("end", unpipe); + src.removeListener("data", ondata); + cleanedUp = true; + if (state2.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain(); + } + src.on("data", ondata); + function ondata(chunk2) { + debug("ondata"); + var ret = dest.write(chunk2); + debug("dest.write", ret); + if (ret === false) { + if ((state2.pipesCount === 1 && state2.pipes === dest || state2.pipesCount > 1 && indexOf2(state2.pipes, dest) !== -1) && !cleanedUp) { + debug("false write response, pause", state2.awaitDrain); + state2.awaitDrain++; + } + src.pause(); + } + } + function onerror(er) { + debug("onerror", er); + unpipe(); + dest.removeListener("error", onerror); + if (EElistenerCount(dest, "error") === 0) errorOrDestroy(dest, er); + } + prependListener(dest, "error", onerror); + function onclose() { + dest.removeListener("finish", onfinish); + unpipe(); + } + dest.once("close", onclose); + function onfinish() { + debug("onfinish"); + dest.removeListener("close", onclose); + unpipe(); + } + dest.once("finish", onfinish); + function unpipe() { + debug("unpipe"); + src.unpipe(dest); + } + dest.emit("pipe", src); + if (!state2.flowing) { + debug("pipe resume"); + src.resume(); + } + return dest; + }; + function pipeOnDrain(src) { + return function pipeOnDrainFunctionResult() { + var state2 = src._readableState; + debug("pipeOnDrain", state2.awaitDrain); + if (state2.awaitDrain) state2.awaitDrain--; + if (state2.awaitDrain === 0 && EElistenerCount(src, "data")) { + state2.flowing = true; + flow(src); + } + }; + } + Readable.prototype.unpipe = function(dest) { + var state2 = this._readableState; + var unpipeInfo = { + hasUnpiped: false + }; + if (state2.pipesCount === 0) return this; + if (state2.pipesCount === 1) { + if (dest && dest !== state2.pipes) return this; + if (!dest) dest = state2.pipes; + state2.pipes = null; + state2.pipesCount = 0; + state2.flowing = false; + if (dest) dest.emit("unpipe", this, unpipeInfo); + return this; + } + if (!dest) { + var dests = state2.pipes; + var len2 = state2.pipesCount; + state2.pipes = null; + state2.pipesCount = 0; + state2.flowing = false; + for (var i2 = 0; i2 < len2; i2++) dests[i2].emit("unpipe", this, { + hasUnpiped: false + }); + return this; + } + var index = indexOf2(state2.pipes, dest); + if (index === -1) return this; + state2.pipes.splice(index, 1); + state2.pipesCount -= 1; + if (state2.pipesCount === 1) state2.pipes = state2.pipes[0]; + dest.emit("unpipe", this, unpipeInfo); + return this; + }; + Readable.prototype.on = function(ev, fn) { + var res = Stream.prototype.on.call(this, ev, fn); + var state2 = this._readableState; + if (ev === "data") { + state2.readableListening = this.listenerCount("readable") > 0; + if (state2.flowing !== false) this.resume(); + } else if (ev === "readable") { + if (!state2.endEmitted && !state2.readableListening) { + state2.readableListening = state2.needReadable = true; + state2.flowing = false; + state2.emittedReadable = false; + debug("on readable", state2.length, state2.reading); + if (state2.length) { + emitReadable(this); + } else if (!state2.reading) { + process$1.nextTick(nReadingNextTick, this); + } + } + } + return res; + }; + Readable.prototype.addListener = Readable.prototype.on; + Readable.prototype.removeListener = function(ev, fn) { + var res = Stream.prototype.removeListener.call(this, ev, fn); + if (ev === "readable") { + process$1.nextTick(updateReadableListening, this); + } + return res; + }; + Readable.prototype.removeAllListeners = function(ev) { + var res = Stream.prototype.removeAllListeners.apply(this, arguments); + if (ev === "readable" || ev === void 0) { + process$1.nextTick(updateReadableListening, this); + } + return res; + }; + function updateReadableListening(self2) { + var state2 = self2._readableState; + state2.readableListening = self2.listenerCount("readable") > 0; + if (state2.resumeScheduled && !state2.paused) { + state2.flowing = true; + } else if (self2.listenerCount("data") > 0) { + self2.resume(); + } + } + function nReadingNextTick(self2) { + debug("readable nexttick read 0"); + self2.read(0); + } + Readable.prototype.resume = function() { + var state2 = this._readableState; + if (!state2.flowing) { + debug("resume"); + state2.flowing = !state2.readableListening; + resume(this, state2); + } + state2.paused = false; + return this; + }; + function resume(stream, state2) { + if (!state2.resumeScheduled) { + state2.resumeScheduled = true; + process$1.nextTick(resume_, stream, state2); + } + } + function resume_(stream, state2) { + debug("resume", state2.reading); + if (!state2.reading) { + stream.read(0); + } + state2.resumeScheduled = false; + stream.emit("resume"); + flow(stream); + if (state2.flowing && !state2.reading) stream.read(0); + } + Readable.prototype.pause = function() { + debug("call pause flowing=%j", this._readableState.flowing); + if (this._readableState.flowing !== false) { + debug("pause"); + this._readableState.flowing = false; + this.emit("pause"); + } + this._readableState.paused = true; + return this; + }; + function flow(stream) { + var state2 = stream._readableState; + debug("flow", state2.flowing); + while (state2.flowing && stream.read() !== null) ; + } + Readable.prototype.wrap = function(stream) { + var _this = this; + var state2 = this._readableState; + var paused = false; + stream.on("end", function() { + debug("wrapped end"); + if (state2.decoder && !state2.ended) { + var chunk2 = state2.decoder.end(); + if (chunk2 && chunk2.length) _this.push(chunk2); + } + _this.push(null); + }); + stream.on("data", function(chunk2) { + debug("wrapped data"); + if (state2.decoder) chunk2 = state2.decoder.write(chunk2); + if (state2.objectMode && (chunk2 === null || chunk2 === void 0)) return; + else if (!state2.objectMode && (!chunk2 || !chunk2.length)) return; + var ret = _this.push(chunk2); + if (!ret) { + paused = true; + stream.pause(); + } + }); + for (var i2 in stream) { + if (this[i2] === void 0 && typeof stream[i2] === "function") { + this[i2] = /* @__PURE__ */ function methodWrap(method) { + return function methodWrapReturnFunction() { + return stream[method].apply(stream, arguments); + }; + }(i2); + } + } + for (var n = 0; n < kProxyEvents.length; n++) { + stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n])); + } + this._read = function(n2) { + debug("wrapped _read", n2); + if (paused) { + paused = false; + stream.resume(); + } + }; + return this; + }; + if (typeof Symbol === "function") { + Readable.prototype[Symbol.asyncIterator] = function() { + if (createReadableStreamAsyncIterator === void 0) { + createReadableStreamAsyncIterator = requireAsync_iterator(); + } + return createReadableStreamAsyncIterator(this); + }; + } + Object.defineProperty(Readable.prototype, "readableHighWaterMark", { + // making it explicit this property is not enumerable + // because otherwise some prototype manipulation in + // userland will fail + enumerable: false, + get: function get() { + return this._readableState.highWaterMark; + } + }); + Object.defineProperty(Readable.prototype, "readableBuffer", { + // making it explicit this property is not enumerable + // because otherwise some prototype manipulation in + // userland will fail + enumerable: false, + get: function get() { + return this._readableState && this._readableState.buffer; + } + }); + Object.defineProperty(Readable.prototype, "readableFlowing", { + // making it explicit this property is not enumerable + // because otherwise some prototype manipulation in + // userland will fail + enumerable: false, + get: function get() { + return this._readableState.flowing; + }, + set: function set(state2) { + if (this._readableState) { + this._readableState.flowing = state2; + } + } + }); + Readable._fromList = fromList; + Object.defineProperty(Readable.prototype, "readableLength", { + // making it explicit this property is not enumerable + // because otherwise some prototype manipulation in + // userland will fail + enumerable: false, + get: function get() { + return this._readableState.length; + } + }); + function fromList(n, state2) { + if (state2.length === 0) return null; + var ret; + if (state2.objectMode) ret = state2.buffer.shift(); + else if (!n || n >= state2.length) { + if (state2.decoder) ret = state2.buffer.join(""); + else if (state2.buffer.length === 1) ret = state2.buffer.first(); + else ret = state2.buffer.concat(state2.length); + state2.buffer.clear(); + } else { + ret = state2.buffer.consume(n, state2.decoder); + } + return ret; + } + function endReadable(stream) { + var state2 = stream._readableState; + debug("endReadable", state2.endEmitted); + if (!state2.endEmitted) { + state2.ended = true; + process$1.nextTick(endReadableNT, state2, stream); + } + } + function endReadableNT(state2, stream) { + debug("endReadableNT", state2.endEmitted, state2.length); + if (!state2.endEmitted && state2.length === 0) { + state2.endEmitted = true; + stream.readable = false; + stream.emit("end"); + if (state2.autoDestroy) { + var wState = stream._writableState; + if (!wState || wState.autoDestroy && wState.finished) { + stream.destroy(); + } + } + } + } + if (typeof Symbol === "function") { + Readable.from = function(iterable, opts) { + if (from === void 0) { + from = requireFromBrowser(); + } + return from(Readable, iterable, opts); + }; + } + function indexOf2(xs, x) { + for (var i2 = 0, l = xs.length; i2 < l; i2++) { + if (xs[i2] === x) return i2; + } + return -1; + } + return _stream_readable$1; +} +var _stream_transform$1; +var hasRequired_stream_transform$1; +function require_stream_transform$1() { + if (hasRequired_stream_transform$1) return _stream_transform$1; + hasRequired_stream_transform$1 = 1; + _stream_transform$1 = Transform; + var _require$codes = requireErrorsBrowser().codes, ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED, ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK, ERR_TRANSFORM_ALREADY_TRANSFORMING = _require$codes.ERR_TRANSFORM_ALREADY_TRANSFORMING, ERR_TRANSFORM_WITH_LENGTH_0 = _require$codes.ERR_TRANSFORM_WITH_LENGTH_0; + var Duplex = require_stream_duplex$1(); + requireInherits_browser()(Transform, Duplex); + function afterTransform(er, data) { + var ts = this._transformState; + ts.transforming = false; + var cb = ts.writecb; + if (cb === null) { + return this.emit("error", new ERR_MULTIPLE_CALLBACK()); + } + ts.writechunk = null; + ts.writecb = null; + if (data != null) + this.push(data); + cb(er); + var rs = this._readableState; + rs.reading = false; + if (rs.needReadable || rs.length < rs.highWaterMark) { + this._read(rs.highWaterMark); + } + } + function Transform(options) { + if (!(this instanceof Transform)) return new Transform(options); + Duplex.call(this, options); + this._transformState = { + afterTransform: afterTransform.bind(this), + needTransform: false, + transforming: false, + writecb: null, + writechunk: null, + writeencoding: null + }; + this._readableState.needReadable = true; + this._readableState.sync = false; + if (options) { + if (typeof options.transform === "function") this._transform = options.transform; + if (typeof options.flush === "function") this._flush = options.flush; + } + this.on("prefinish", prefinish); + } + function prefinish() { + var _this = this; + if (typeof this._flush === "function" && !this._readableState.destroyed) { + this._flush(function(er, data) { + done(_this, er, data); + }); + } else { + done(this, null, null); + } + } + Transform.prototype.push = function(chunk2, encoding) { + this._transformState.needTransform = false; + return Duplex.prototype.push.call(this, chunk2, encoding); + }; + Transform.prototype._transform = function(chunk2, encoding, cb) { + cb(new ERR_METHOD_NOT_IMPLEMENTED("_transform()")); + }; + Transform.prototype._write = function(chunk2, encoding, cb) { + var ts = this._transformState; + ts.writecb = cb; + ts.writechunk = chunk2; + ts.writeencoding = encoding; + if (!ts.transforming) { + var rs = this._readableState; + if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark); + } + }; + Transform.prototype._read = function(n) { + var ts = this._transformState; + if (ts.writechunk !== null && !ts.transforming) { + ts.transforming = true; + this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform); + } else { + ts.needTransform = true; + } + }; + Transform.prototype._destroy = function(err, cb) { + Duplex.prototype._destroy.call(this, err, function(err2) { + cb(err2); + }); + }; + function done(stream, er, data) { + if (er) return stream.emit("error", er); + if (data != null) + stream.push(data); + if (stream._writableState.length) throw new ERR_TRANSFORM_WITH_LENGTH_0(); + if (stream._transformState.transforming) throw new ERR_TRANSFORM_ALREADY_TRANSFORMING(); + return stream.push(null); + } + return _stream_transform$1; +} +var _stream_passthrough$1; +var hasRequired_stream_passthrough$1; +function require_stream_passthrough$1() { + if (hasRequired_stream_passthrough$1) return _stream_passthrough$1; + hasRequired_stream_passthrough$1 = 1; + _stream_passthrough$1 = PassThrough; + var Transform = require_stream_transform$1(); + requireInherits_browser()(PassThrough, Transform); + function PassThrough(options) { + if (!(this instanceof PassThrough)) return new PassThrough(options); + Transform.call(this, options); + } + PassThrough.prototype._transform = function(chunk2, encoding, cb) { + cb(null, chunk2); + }; + return _stream_passthrough$1; +} +var pipeline_1; +var hasRequiredPipeline; +function requirePipeline() { + if (hasRequiredPipeline) return pipeline_1; + hasRequiredPipeline = 1; + var eos; + function once(callback) { + var called = false; + return function() { + if (called) return; + called = true; + callback.apply(void 0, arguments); + }; + } + var _require$codes = requireErrorsBrowser().codes, ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS, ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED; + function noop2(err) { + if (err) throw err; + } + function isRequest(stream) { + return stream.setHeader && typeof stream.abort === "function"; + } + function destroyer(stream, reading, writing, callback) { + callback = once(callback); + var closed = false; + stream.on("close", function() { + closed = true; + }); + if (eos === void 0) eos = requireEndOfStream(); + eos(stream, { + readable: reading, + writable: writing + }, function(err) { + if (err) return callback(err); + closed = true; + callback(); + }); + var destroyed = false; + return function(err) { + if (closed) return; + if (destroyed) return; + destroyed = true; + if (isRequest(stream)) return stream.abort(); + if (typeof stream.destroy === "function") return stream.destroy(); + callback(err || new ERR_STREAM_DESTROYED("pipe")); + }; + } + function call(fn) { + fn(); + } + function pipe(from, to) { + return from.pipe(to); + } + function popCallback(streams) { + if (!streams.length) return noop2; + if (typeof streams[streams.length - 1] !== "function") return noop2; + return streams.pop(); + } + function pipeline() { + for (var _len = arguments.length, streams = new Array(_len), _key = 0; _key < _len; _key++) { + streams[_key] = arguments[_key]; + } + var callback = popCallback(streams); + if (Array.isArray(streams[0])) streams = streams[0]; + if (streams.length < 2) { + throw new ERR_MISSING_ARGS("streams"); + } + var error; + var destroys = streams.map(function(stream, i2) { + var reading = i2 < streams.length - 1; + var writing = i2 > 0; + return destroyer(stream, reading, writing, function(err) { + if (!error) error = err; + if (err) destroys.forEach(call); + if (reading) return; + destroys.forEach(call); + callback(error); + }); + }); + return streams.reduce(pipe); + } + pipeline_1 = pipeline; + return pipeline_1; +} +var hasRequiredReadableBrowser$1; +function requireReadableBrowser$1() { + if (hasRequiredReadableBrowser$1) return readableBrowser$1.exports; + hasRequiredReadableBrowser$1 = 1; + (function(module2, exports2) { + exports2 = module2.exports = require_stream_readable$1(); + exports2.Stream = exports2; + exports2.Readable = exports2; + exports2.Writable = require_stream_writable$1(); + exports2.Duplex = require_stream_duplex$1(); + exports2.Transform = require_stream_transform$1(); + exports2.PassThrough = require_stream_passthrough$1(); + exports2.finished = requireEndOfStream(); + exports2.pipeline = requirePipeline(); + })(readableBrowser$1, readableBrowser$1.exports); + return readableBrowser$1.exports; +} +var hashBase; +var hasRequiredHashBase; +function requireHashBase() { + if (hasRequiredHashBase) return hashBase; + hasRequiredHashBase = 1; + var Buffer2 = requireSafeBuffer$1().Buffer; + var Transform = requireReadableBrowser$1().Transform; + var inherits = requireInherits_browser(); + function throwIfNotStringOrBuffer(val, prefix) { + if (!Buffer2.isBuffer(val) && typeof val !== "string") { + throw new TypeError(prefix + " must be a string or a buffer"); + } + } + function HashBase(blockSize) { + Transform.call(this); + this._block = Buffer2.allocUnsafe(blockSize); + this._blockSize = blockSize; + this._blockOffset = 0; + this._length = [0, 0, 0, 0]; + this._finalized = false; + } + inherits(HashBase, Transform); + HashBase.prototype._transform = function(chunk2, encoding, callback) { + var error = null; + try { + this.update(chunk2, encoding); + } catch (err) { + error = err; + } + callback(error); + }; + HashBase.prototype._flush = function(callback) { + var error = null; + try { + this.push(this.digest()); + } catch (err) { + error = err; + } + callback(error); + }; + HashBase.prototype.update = function(data, encoding) { + throwIfNotStringOrBuffer(data, "Data"); + if (this._finalized) throw new Error("Digest already called"); + if (!Buffer2.isBuffer(data)) data = Buffer2.from(data, encoding); + var block2 = this._block; + var offset = 0; + while (this._blockOffset + data.length - offset >= this._blockSize) { + for (var i2 = this._blockOffset; i2 < this._blockSize; ) block2[i2++] = data[offset++]; + this._update(); + this._blockOffset = 0; + } + while (offset < data.length) block2[this._blockOffset++] = data[offset++]; + for (var j = 0, carry = data.length * 8; carry > 0; ++j) { + this._length[j] += carry; + carry = this._length[j] / 4294967296 | 0; + if (carry > 0) this._length[j] -= 4294967296 * carry; + } + return this; + }; + HashBase.prototype._update = function() { + throw new Error("_update is not implemented"); + }; + HashBase.prototype.digest = function(encoding) { + if (this._finalized) throw new Error("Digest already called"); + this._finalized = true; + var digest = this._digest(); + if (encoding !== void 0) digest = digest.toString(encoding); + this._block.fill(0); + this._blockOffset = 0; + for (var i2 = 0; i2 < 4; ++i2) this._length[i2] = 0; + return digest; + }; + HashBase.prototype._digest = function() { + throw new Error("_digest is not implemented"); + }; + hashBase = HashBase; + return hashBase; +} +var md5_js; +var hasRequiredMd5_js; +function requireMd5_js() { + if (hasRequiredMd5_js) return md5_js; + hasRequiredMd5_js = 1; + var inherits = requireInherits_browser(); + var HashBase = requireHashBase(); + var Buffer2 = requireSafeBuffer$1().Buffer; + var ARRAY16 = new Array(16); + function MD5() { + HashBase.call(this, 64); + this._a = 1732584193; + this._b = 4023233417; + this._c = 2562383102; + this._d = 271733878; + } + inherits(MD5, HashBase); + MD5.prototype._update = function() { + var M = ARRAY16; + for (var i2 = 0; i2 < 16; ++i2) M[i2] = this._block.readInt32LE(i2 * 4); + var a = this._a; + var b = this._b; + var c = this._c; + var d = this._d; + a = fnF(a, b, c, d, M[0], 3614090360, 7); + d = fnF(d, a, b, c, M[1], 3905402710, 12); + c = fnF(c, d, a, b, M[2], 606105819, 17); + b = fnF(b, c, d, a, M[3], 3250441966, 22); + a = fnF(a, b, c, d, M[4], 4118548399, 7); + d = fnF(d, a, b, c, M[5], 1200080426, 12); + c = fnF(c, d, a, b, M[6], 2821735955, 17); + b = fnF(b, c, d, a, M[7], 4249261313, 22); + a = fnF(a, b, c, d, M[8], 1770035416, 7); + d = fnF(d, a, b, c, M[9], 2336552879, 12); + c = fnF(c, d, a, b, M[10], 4294925233, 17); + b = fnF(b, c, d, a, M[11], 2304563134, 22); + a = fnF(a, b, c, d, M[12], 1804603682, 7); + d = fnF(d, a, b, c, M[13], 4254626195, 12); + c = fnF(c, d, a, b, M[14], 2792965006, 17); + b = fnF(b, c, d, a, M[15], 1236535329, 22); + a = fnG(a, b, c, d, M[1], 4129170786, 5); + d = fnG(d, a, b, c, M[6], 3225465664, 9); + c = fnG(c, d, a, b, M[11], 643717713, 14); + b = fnG(b, c, d, a, M[0], 3921069994, 20); + a = fnG(a, b, c, d, M[5], 3593408605, 5); + d = fnG(d, a, b, c, M[10], 38016083, 9); + c = fnG(c, d, a, b, M[15], 3634488961, 14); + b = fnG(b, c, d, a, M[4], 3889429448, 20); + a = fnG(a, b, c, d, M[9], 568446438, 5); + d = fnG(d, a, b, c, M[14], 3275163606, 9); + c = fnG(c, d, a, b, M[3], 4107603335, 14); + b = fnG(b, c, d, a, M[8], 1163531501, 20); + a = fnG(a, b, c, d, M[13], 2850285829, 5); + d = fnG(d, a, b, c, M[2], 4243563512, 9); + c = fnG(c, d, a, b, M[7], 1735328473, 14); + b = fnG(b, c, d, a, M[12], 2368359562, 20); + a = fnH(a, b, c, d, M[5], 4294588738, 4); + d = fnH(d, a, b, c, M[8], 2272392833, 11); + c = fnH(c, d, a, b, M[11], 1839030562, 16); + b = fnH(b, c, d, a, M[14], 4259657740, 23); + a = fnH(a, b, c, d, M[1], 2763975236, 4); + d = fnH(d, a, b, c, M[4], 1272893353, 11); + c = fnH(c, d, a, b, M[7], 4139469664, 16); + b = fnH(b, c, d, a, M[10], 3200236656, 23); + a = fnH(a, b, c, d, M[13], 681279174, 4); + d = fnH(d, a, b, c, M[0], 3936430074, 11); + c = fnH(c, d, a, b, M[3], 3572445317, 16); + b = fnH(b, c, d, a, M[6], 76029189, 23); + a = fnH(a, b, c, d, M[9], 3654602809, 4); + d = fnH(d, a, b, c, M[12], 3873151461, 11); + c = fnH(c, d, a, b, M[15], 530742520, 16); + b = fnH(b, c, d, a, M[2], 3299628645, 23); + a = fnI(a, b, c, d, M[0], 4096336452, 6); + d = fnI(d, a, b, c, M[7], 1126891415, 10); + c = fnI(c, d, a, b, M[14], 2878612391, 15); + b = fnI(b, c, d, a, M[5], 4237533241, 21); + a = fnI(a, b, c, d, M[12], 1700485571, 6); + d = fnI(d, a, b, c, M[3], 2399980690, 10); + c = fnI(c, d, a, b, M[10], 4293915773, 15); + b = fnI(b, c, d, a, M[1], 2240044497, 21); + a = fnI(a, b, c, d, M[8], 1873313359, 6); + d = fnI(d, a, b, c, M[15], 4264355552, 10); + c = fnI(c, d, a, b, M[6], 2734768916, 15); + b = fnI(b, c, d, a, M[13], 1309151649, 21); + a = fnI(a, b, c, d, M[4], 4149444226, 6); + d = fnI(d, a, b, c, M[11], 3174756917, 10); + c = fnI(c, d, a, b, M[2], 718787259, 15); + b = fnI(b, c, d, a, M[9], 3951481745, 21); + this._a = this._a + a | 0; + this._b = this._b + b | 0; + this._c = this._c + c | 0; + this._d = this._d + d | 0; + }; + MD5.prototype._digest = function() { + this._block[this._blockOffset++] = 128; + if (this._blockOffset > 56) { + this._block.fill(0, this._blockOffset, 64); + this._update(); + this._blockOffset = 0; + } + this._block.fill(0, this._blockOffset, 56); + this._block.writeUInt32LE(this._length[0], 56); + this._block.writeUInt32LE(this._length[1], 60); + this._update(); + var buffer2 = Buffer2.allocUnsafe(16); + buffer2.writeInt32LE(this._a, 0); + buffer2.writeInt32LE(this._b, 4); + buffer2.writeInt32LE(this._c, 8); + buffer2.writeInt32LE(this._d, 12); + return buffer2; + }; + function rotl(x, n) { + return x << n | x >>> 32 - n; + } + function fnF(a, b, c, d, m, k, s) { + return rotl(a + (b & c | ~b & d) + m + k | 0, s) + b | 0; + } + function fnG(a, b, c, d, m, k, s) { + return rotl(a + (b & d | c & ~d) + m + k | 0, s) + b | 0; + } + function fnH(a, b, c, d, m, k, s) { + return rotl(a + (b ^ c ^ d) + m + k | 0, s) + b | 0; + } + function fnI(a, b, c, d, m, k, s) { + return rotl(a + (c ^ (b | ~d)) + m + k | 0, s) + b | 0; + } + md5_js = MD5; + return md5_js; +} +var ripemd160; +var hasRequiredRipemd160; +function requireRipemd160() { + if (hasRequiredRipemd160) return ripemd160; + hasRequiredRipemd160 = 1; + var Buffer2 = requireDist().Buffer; + var inherits = requireInherits_browser(); + var HashBase = requireHashBase(); + var ARRAY16 = new Array(16); + var zl = [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 7, + 4, + 13, + 1, + 10, + 6, + 15, + 3, + 12, + 0, + 9, + 5, + 2, + 14, + 11, + 8, + 3, + 10, + 14, + 4, + 9, + 15, + 8, + 1, + 2, + 7, + 0, + 6, + 13, + 11, + 5, + 12, + 1, + 9, + 11, + 10, + 0, + 8, + 12, + 4, + 13, + 3, + 7, + 15, + 14, + 5, + 6, + 2, + 4, + 0, + 5, + 9, + 7, + 12, + 2, + 10, + 14, + 1, + 3, + 8, + 11, + 6, + 15, + 13 + ]; + var zr = [ + 5, + 14, + 7, + 0, + 9, + 2, + 11, + 4, + 13, + 6, + 15, + 8, + 1, + 10, + 3, + 12, + 6, + 11, + 3, + 7, + 0, + 13, + 5, + 10, + 14, + 15, + 8, + 12, + 4, + 9, + 1, + 2, + 15, + 5, + 1, + 3, + 7, + 14, + 6, + 9, + 11, + 8, + 12, + 2, + 10, + 0, + 4, + 13, + 8, + 6, + 4, + 1, + 3, + 11, + 15, + 0, + 5, + 12, + 2, + 13, + 9, + 7, + 10, + 14, + 12, + 15, + 10, + 4, + 1, + 5, + 8, + 7, + 6, + 2, + 13, + 14, + 0, + 3, + 9, + 11 + ]; + var sl = [ + 11, + 14, + 15, + 12, + 5, + 8, + 7, + 9, + 11, + 13, + 14, + 15, + 6, + 7, + 9, + 8, + 7, + 6, + 8, + 13, + 11, + 9, + 7, + 15, + 7, + 12, + 15, + 9, + 11, + 7, + 13, + 12, + 11, + 13, + 6, + 7, + 14, + 9, + 13, + 15, + 14, + 8, + 13, + 6, + 5, + 12, + 7, + 5, + 11, + 12, + 14, + 15, + 14, + 15, + 9, + 8, + 9, + 14, + 5, + 6, + 8, + 6, + 5, + 12, + 9, + 15, + 5, + 11, + 6, + 8, + 13, + 12, + 5, + 12, + 13, + 14, + 11, + 8, + 5, + 6 + ]; + var sr = [ + 8, + 9, + 9, + 11, + 13, + 15, + 15, + 5, + 7, + 7, + 8, + 11, + 14, + 14, + 12, + 6, + 9, + 13, + 15, + 7, + 12, + 8, + 9, + 11, + 7, + 7, + 12, + 7, + 6, + 15, + 13, + 11, + 9, + 7, + 15, + 11, + 8, + 6, + 6, + 14, + 12, + 13, + 5, + 14, + 13, + 13, + 7, + 5, + 15, + 5, + 8, + 11, + 14, + 14, + 6, + 14, + 6, + 9, + 12, + 9, + 12, + 5, + 15, + 8, + 8, + 5, + 12, + 9, + 12, + 5, + 14, + 6, + 8, + 13, + 6, + 5, + 15, + 13, + 11, + 11 + ]; + var hl = [0, 1518500249, 1859775393, 2400959708, 2840853838]; + var hr = [1352829926, 1548603684, 1836072691, 2053994217, 0]; + function RIPEMD160() { + HashBase.call(this, 64); + this._a = 1732584193; + this._b = 4023233417; + this._c = 2562383102; + this._d = 271733878; + this._e = 3285377520; + } + inherits(RIPEMD160, HashBase); + RIPEMD160.prototype._update = function() { + var words = ARRAY16; + for (var j = 0; j < 16; ++j) words[j] = this._block.readInt32LE(j * 4); + var al = this._a | 0; + var bl = this._b | 0; + var cl = this._c | 0; + var dl = this._d | 0; + var el = this._e | 0; + var ar = this._a | 0; + var br = this._b | 0; + var cr = this._c | 0; + var dr = this._d | 0; + var er = this._e | 0; + for (var i2 = 0; i2 < 80; i2 += 1) { + var tl; + var tr; + if (i2 < 16) { + tl = fn1(al, bl, cl, dl, el, words[zl[i2]], hl[0], sl[i2]); + tr = fn5(ar, br, cr, dr, er, words[zr[i2]], hr[0], sr[i2]); + } else if (i2 < 32) { + tl = fn2(al, bl, cl, dl, el, words[zl[i2]], hl[1], sl[i2]); + tr = fn4(ar, br, cr, dr, er, words[zr[i2]], hr[1], sr[i2]); + } else if (i2 < 48) { + tl = fn3(al, bl, cl, dl, el, words[zl[i2]], hl[2], sl[i2]); + tr = fn3(ar, br, cr, dr, er, words[zr[i2]], hr[2], sr[i2]); + } else if (i2 < 64) { + tl = fn4(al, bl, cl, dl, el, words[zl[i2]], hl[3], sl[i2]); + tr = fn2(ar, br, cr, dr, er, words[zr[i2]], hr[3], sr[i2]); + } else { + tl = fn5(al, bl, cl, dl, el, words[zl[i2]], hl[4], sl[i2]); + tr = fn1(ar, br, cr, dr, er, words[zr[i2]], hr[4], sr[i2]); + } + al = el; + el = dl; + dl = rotl(cl, 10); + cl = bl; + bl = tl; + ar = er; + er = dr; + dr = rotl(cr, 10); + cr = br; + br = tr; + } + var t = this._b + cl + dr | 0; + this._b = this._c + dl + er | 0; + this._c = this._d + el + ar | 0; + this._d = this._e + al + br | 0; + this._e = this._a + bl + cr | 0; + this._a = t; + }; + RIPEMD160.prototype._digest = function() { + this._block[this._blockOffset++] = 128; + if (this._blockOffset > 56) { + this._block.fill(0, this._blockOffset, 64); + this._update(); + this._blockOffset = 0; + } + this._block.fill(0, this._blockOffset, 56); + this._block.writeUInt32LE(this._length[0], 56); + this._block.writeUInt32LE(this._length[1], 60); + this._update(); + var buffer2 = Buffer2.alloc ? Buffer2.alloc(20) : new Buffer2(20); + buffer2.writeInt32LE(this._a, 0); + buffer2.writeInt32LE(this._b, 4); + buffer2.writeInt32LE(this._c, 8); + buffer2.writeInt32LE(this._d, 12); + buffer2.writeInt32LE(this._e, 16); + return buffer2; + }; + function rotl(x, n) { + return x << n | x >>> 32 - n; + } + function fn1(a, b, c, d, e, m, k, s) { + return rotl(a + (b ^ c ^ d) + m + k | 0, s) + e | 0; + } + function fn2(a, b, c, d, e, m, k, s) { + return rotl(a + (b & c | ~b & d) + m + k | 0, s) + e | 0; + } + function fn3(a, b, c, d, e, m, k, s) { + return rotl(a + ((b | ~c) ^ d) + m + k | 0, s) + e | 0; + } + function fn4(a, b, c, d, e, m, k, s) { + return rotl(a + (b & d | c & ~d) + m + k | 0, s) + e | 0; + } + function fn5(a, b, c, d, e, m, k, s) { + return rotl(a + (b ^ (c | ~d)) + m + k | 0, s) + e | 0; + } + ripemd160 = RIPEMD160; + return ripemd160; +} +var sha_js = { exports: {} }; +var hash$1; +var hasRequiredHash$1; +function requireHash$1() { + if (hasRequiredHash$1) return hash$1; + hasRequiredHash$1 = 1; + var Buffer2 = requireSafeBuffer$1().Buffer; + function Hash(blockSize, finalSize) { + this._block = Buffer2.alloc(blockSize); + this._finalSize = finalSize; + this._blockSize = blockSize; + this._len = 0; + } + Hash.prototype.update = function(data, enc) { + if (typeof data === "string") { + enc = enc || "utf8"; + data = Buffer2.from(data, enc); + } + var block2 = this._block; + var blockSize = this._blockSize; + var length = data.length; + var accum = this._len; + for (var offset = 0; offset < length; ) { + var assigned = accum % blockSize; + var remainder = Math.min(length - offset, blockSize - assigned); + for (var i2 = 0; i2 < remainder; i2++) { + block2[assigned + i2] = data[offset + i2]; + } + accum += remainder; + offset += remainder; + if (accum % blockSize === 0) { + this._update(block2); + } + } + this._len += length; + return this; + }; + Hash.prototype.digest = function(enc) { + var rem = this._len % this._blockSize; + this._block[rem] = 128; + this._block.fill(0, rem + 1); + if (rem >= this._finalSize) { + this._update(this._block); + this._block.fill(0); + } + var bits = this._len * 8; + if (bits <= 4294967295) { + this._block.writeUInt32BE(bits, this._blockSize - 4); + } else { + var lowBits = (bits & 4294967295) >>> 0; + var highBits = (bits - lowBits) / 4294967296; + this._block.writeUInt32BE(highBits, this._blockSize - 8); + this._block.writeUInt32BE(lowBits, this._blockSize - 4); + } + this._update(this._block); + var hash2 = this._hash(); + return enc ? hash2.toString(enc) : hash2; + }; + Hash.prototype._update = function() { + throw new Error("_update must be implemented by subclass"); + }; + hash$1 = Hash; + return hash$1; +} +var sha$1; +var hasRequiredSha$1; +function requireSha$1() { + if (hasRequiredSha$1) return sha$1; + hasRequiredSha$1 = 1; + var inherits = requireInherits_browser(); + var Hash = requireHash$1(); + var Buffer2 = requireSafeBuffer$1().Buffer; + var K = [ + 1518500249, + 1859775393, + 2400959708 | 0, + 3395469782 | 0 + ]; + var W = new Array(80); + function Sha() { + this.init(); + this._w = W; + Hash.call(this, 64, 56); + } + inherits(Sha, Hash); + Sha.prototype.init = function() { + this._a = 1732584193; + this._b = 4023233417; + this._c = 2562383102; + this._d = 271733878; + this._e = 3285377520; + return this; + }; + function rotl5(num) { + return num << 5 | num >>> 27; + } + function rotl30(num) { + return num << 30 | num >>> 2; + } + function ft(s, b, c, d) { + if (s === 0) return b & c | ~b & d; + if (s === 2) return b & c | b & d | c & d; + return b ^ c ^ d; + } + Sha.prototype._update = function(M) { + var W2 = this._w; + var a = this._a | 0; + var b = this._b | 0; + var c = this._c | 0; + var d = this._d | 0; + var e = this._e | 0; + for (var i2 = 0; i2 < 16; ++i2) W2[i2] = M.readInt32BE(i2 * 4); + for (; i2 < 80; ++i2) W2[i2] = W2[i2 - 3] ^ W2[i2 - 8] ^ W2[i2 - 14] ^ W2[i2 - 16]; + for (var j = 0; j < 80; ++j) { + var s = ~~(j / 20); + var t = rotl5(a) + ft(s, b, c, d) + e + W2[j] + K[s] | 0; + e = d; + d = c; + c = rotl30(b); + b = a; + a = t; + } + this._a = a + this._a | 0; + this._b = b + this._b | 0; + this._c = c + this._c | 0; + this._d = d + this._d | 0; + this._e = e + this._e | 0; + }; + Sha.prototype._hash = function() { + var H = Buffer2.allocUnsafe(20); + H.writeInt32BE(this._a | 0, 0); + H.writeInt32BE(this._b | 0, 4); + H.writeInt32BE(this._c | 0, 8); + H.writeInt32BE(this._d | 0, 12); + H.writeInt32BE(this._e | 0, 16); + return H; + }; + sha$1 = Sha; + return sha$1; +} +var sha1; +var hasRequiredSha1; +function requireSha1() { + if (hasRequiredSha1) return sha1; + hasRequiredSha1 = 1; + var inherits = requireInherits_browser(); + var Hash = requireHash$1(); + var Buffer2 = requireSafeBuffer$1().Buffer; + var K = [ + 1518500249, + 1859775393, + 2400959708 | 0, + 3395469782 | 0 + ]; + var W = new Array(80); + function Sha1() { + this.init(); + this._w = W; + Hash.call(this, 64, 56); + } + inherits(Sha1, Hash); + Sha1.prototype.init = function() { + this._a = 1732584193; + this._b = 4023233417; + this._c = 2562383102; + this._d = 271733878; + this._e = 3285377520; + return this; + }; + function rotl1(num) { + return num << 1 | num >>> 31; + } + function rotl5(num) { + return num << 5 | num >>> 27; + } + function rotl30(num) { + return num << 30 | num >>> 2; + } + function ft(s, b, c, d) { + if (s === 0) return b & c | ~b & d; + if (s === 2) return b & c | b & d | c & d; + return b ^ c ^ d; + } + Sha1.prototype._update = function(M) { + var W2 = this._w; + var a = this._a | 0; + var b = this._b | 0; + var c = this._c | 0; + var d = this._d | 0; + var e = this._e | 0; + for (var i2 = 0; i2 < 16; ++i2) W2[i2] = M.readInt32BE(i2 * 4); + for (; i2 < 80; ++i2) W2[i2] = rotl1(W2[i2 - 3] ^ W2[i2 - 8] ^ W2[i2 - 14] ^ W2[i2 - 16]); + for (var j = 0; j < 80; ++j) { + var s = ~~(j / 20); + var t = rotl5(a) + ft(s, b, c, d) + e + W2[j] + K[s] | 0; + e = d; + d = c; + c = rotl30(b); + b = a; + a = t; + } + this._a = a + this._a | 0; + this._b = b + this._b | 0; + this._c = c + this._c | 0; + this._d = d + this._d | 0; + this._e = e + this._e | 0; + }; + Sha1.prototype._hash = function() { + var H = Buffer2.allocUnsafe(20); + H.writeInt32BE(this._a | 0, 0); + H.writeInt32BE(this._b | 0, 4); + H.writeInt32BE(this._c | 0, 8); + H.writeInt32BE(this._d | 0, 12); + H.writeInt32BE(this._e | 0, 16); + return H; + }; + sha1 = Sha1; + return sha1; +} +var sha256$1; +var hasRequiredSha256; +function requireSha256() { + if (hasRequiredSha256) return sha256$1; + hasRequiredSha256 = 1; + var inherits = requireInherits_browser(); + var Hash = requireHash$1(); + var Buffer2 = requireSafeBuffer$1().Buffer; + var K = [ + 1116352408, + 1899447441, + 3049323471, + 3921009573, + 961987163, + 1508970993, + 2453635748, + 2870763221, + 3624381080, + 310598401, + 607225278, + 1426881987, + 1925078388, + 2162078206, + 2614888103, + 3248222580, + 3835390401, + 4022224774, + 264347078, + 604807628, + 770255983, + 1249150122, + 1555081692, + 1996064986, + 2554220882, + 2821834349, + 2952996808, + 3210313671, + 3336571891, + 3584528711, + 113926993, + 338241895, + 666307205, + 773529912, + 1294757372, + 1396182291, + 1695183700, + 1986661051, + 2177026350, + 2456956037, + 2730485921, + 2820302411, + 3259730800, + 3345764771, + 3516065817, + 3600352804, + 4094571909, + 275423344, + 430227734, + 506948616, + 659060556, + 883997877, + 958139571, + 1322822218, + 1537002063, + 1747873779, + 1955562222, + 2024104815, + 2227730452, + 2361852424, + 2428436474, + 2756734187, + 3204031479, + 3329325298 + ]; + var W = new Array(64); + function Sha256() { + this.init(); + this._w = W; + Hash.call(this, 64, 56); + } + inherits(Sha256, Hash); + Sha256.prototype.init = function() { + this._a = 1779033703; + this._b = 3144134277; + this._c = 1013904242; + this._d = 2773480762; + this._e = 1359893119; + this._f = 2600822924; + this._g = 528734635; + this._h = 1541459225; + return this; + }; + function ch(x, y, z) { + return z ^ x & (y ^ z); + } + function maj(x, y, z) { + return x & y | z & (x | y); + } + function sigma0(x) { + return (x >>> 2 | x << 30) ^ (x >>> 13 | x << 19) ^ (x >>> 22 | x << 10); + } + function sigma1(x) { + return (x >>> 6 | x << 26) ^ (x >>> 11 | x << 21) ^ (x >>> 25 | x << 7); + } + function gamma0(x) { + return (x >>> 7 | x << 25) ^ (x >>> 18 | x << 14) ^ x >>> 3; + } + function gamma1(x) { + return (x >>> 17 | x << 15) ^ (x >>> 19 | x << 13) ^ x >>> 10; + } + Sha256.prototype._update = function(M) { + var W2 = this._w; + var a = this._a | 0; + var b = this._b | 0; + var c = this._c | 0; + var d = this._d | 0; + var e = this._e | 0; + var f = this._f | 0; + var g = this._g | 0; + var h = this._h | 0; + for (var i2 = 0; i2 < 16; ++i2) W2[i2] = M.readInt32BE(i2 * 4); + for (; i2 < 64; ++i2) W2[i2] = gamma1(W2[i2 - 2]) + W2[i2 - 7] + gamma0(W2[i2 - 15]) + W2[i2 - 16] | 0; + for (var j = 0; j < 64; ++j) { + var T1 = h + sigma1(e) + ch(e, f, g) + K[j] + W2[j] | 0; + var T2 = sigma0(a) + maj(a, b, c) | 0; + h = g; + g = f; + f = e; + e = d + T1 | 0; + d = c; + c = b; + b = a; + a = T1 + T2 | 0; + } + this._a = a + this._a | 0; + this._b = b + this._b | 0; + this._c = c + this._c | 0; + this._d = d + this._d | 0; + this._e = e + this._e | 0; + this._f = f + this._f | 0; + this._g = g + this._g | 0; + this._h = h + this._h | 0; + }; + Sha256.prototype._hash = function() { + var H = Buffer2.allocUnsafe(32); + H.writeInt32BE(this._a, 0); + H.writeInt32BE(this._b, 4); + H.writeInt32BE(this._c, 8); + H.writeInt32BE(this._d, 12); + H.writeInt32BE(this._e, 16); + H.writeInt32BE(this._f, 20); + H.writeInt32BE(this._g, 24); + H.writeInt32BE(this._h, 28); + return H; + }; + sha256$1 = Sha256; + return sha256$1; +} +var sha224$1; +var hasRequiredSha224; +function requireSha224() { + if (hasRequiredSha224) return sha224$1; + hasRequiredSha224 = 1; + var inherits = requireInherits_browser(); + var Sha256 = requireSha256(); + var Hash = requireHash$1(); + var Buffer2 = requireSafeBuffer$1().Buffer; + var W = new Array(64); + function Sha224() { + this.init(); + this._w = W; + Hash.call(this, 64, 56); + } + inherits(Sha224, Sha256); + Sha224.prototype.init = function() { + this._a = 3238371032; + this._b = 914150663; + this._c = 812702999; + this._d = 4144912697; + this._e = 4290775857; + this._f = 1750603025; + this._g = 1694076839; + this._h = 3204075428; + return this; + }; + Sha224.prototype._hash = function() { + var H = Buffer2.allocUnsafe(28); + H.writeInt32BE(this._a, 0); + H.writeInt32BE(this._b, 4); + H.writeInt32BE(this._c, 8); + H.writeInt32BE(this._d, 12); + H.writeInt32BE(this._e, 16); + H.writeInt32BE(this._f, 20); + H.writeInt32BE(this._g, 24); + return H; + }; + sha224$1 = Sha224; + return sha224$1; +} +var sha512$1; +var hasRequiredSha512; +function requireSha512() { + if (hasRequiredSha512) return sha512$1; + hasRequiredSha512 = 1; + var inherits = requireInherits_browser(); + var Hash = requireHash$1(); + var Buffer2 = requireSafeBuffer$1().Buffer; + var K = [ + 1116352408, + 3609767458, + 1899447441, + 602891725, + 3049323471, + 3964484399, + 3921009573, + 2173295548, + 961987163, + 4081628472, + 1508970993, + 3053834265, + 2453635748, + 2937671579, + 2870763221, + 3664609560, + 3624381080, + 2734883394, + 310598401, + 1164996542, + 607225278, + 1323610764, + 1426881987, + 3590304994, + 1925078388, + 4068182383, + 2162078206, + 991336113, + 2614888103, + 633803317, + 3248222580, + 3479774868, + 3835390401, + 2666613458, + 4022224774, + 944711139, + 264347078, + 2341262773, + 604807628, + 2007800933, + 770255983, + 1495990901, + 1249150122, + 1856431235, + 1555081692, + 3175218132, + 1996064986, + 2198950837, + 2554220882, + 3999719339, + 2821834349, + 766784016, + 2952996808, + 2566594879, + 3210313671, + 3203337956, + 3336571891, + 1034457026, + 3584528711, + 2466948901, + 113926993, + 3758326383, + 338241895, + 168717936, + 666307205, + 1188179964, + 773529912, + 1546045734, + 1294757372, + 1522805485, + 1396182291, + 2643833823, + 1695183700, + 2343527390, + 1986661051, + 1014477480, + 2177026350, + 1206759142, + 2456956037, + 344077627, + 2730485921, + 1290863460, + 2820302411, + 3158454273, + 3259730800, + 3505952657, + 3345764771, + 106217008, + 3516065817, + 3606008344, + 3600352804, + 1432725776, + 4094571909, + 1467031594, + 275423344, + 851169720, + 430227734, + 3100823752, + 506948616, + 1363258195, + 659060556, + 3750685593, + 883997877, + 3785050280, + 958139571, + 3318307427, + 1322822218, + 3812723403, + 1537002063, + 2003034995, + 1747873779, + 3602036899, + 1955562222, + 1575990012, + 2024104815, + 1125592928, + 2227730452, + 2716904306, + 2361852424, + 442776044, + 2428436474, + 593698344, + 2756734187, + 3733110249, + 3204031479, + 2999351573, + 3329325298, + 3815920427, + 3391569614, + 3928383900, + 3515267271, + 566280711, + 3940187606, + 3454069534, + 4118630271, + 4000239992, + 116418474, + 1914138554, + 174292421, + 2731055270, + 289380356, + 3203993006, + 460393269, + 320620315, + 685471733, + 587496836, + 852142971, + 1086792851, + 1017036298, + 365543100, + 1126000580, + 2618297676, + 1288033470, + 3409855158, + 1501505948, + 4234509866, + 1607167915, + 987167468, + 1816402316, + 1246189591 + ]; + var W = new Array(160); + function Sha512() { + this.init(); + this._w = W; + Hash.call(this, 128, 112); + } + inherits(Sha512, Hash); + Sha512.prototype.init = function() { + this._ah = 1779033703; + this._bh = 3144134277; + this._ch = 1013904242; + this._dh = 2773480762; + this._eh = 1359893119; + this._fh = 2600822924; + this._gh = 528734635; + this._hh = 1541459225; + this._al = 4089235720; + this._bl = 2227873595; + this._cl = 4271175723; + this._dl = 1595750129; + this._el = 2917565137; + this._fl = 725511199; + this._gl = 4215389547; + this._hl = 327033209; + return this; + }; + function Ch(x, y, z) { + return z ^ x & (y ^ z); + } + function maj(x, y, z) { + return x & y | z & (x | y); + } + function sigma0(x, xl) { + return (x >>> 28 | xl << 4) ^ (xl >>> 2 | x << 30) ^ (xl >>> 7 | x << 25); + } + function sigma1(x, xl) { + return (x >>> 14 | xl << 18) ^ (x >>> 18 | xl << 14) ^ (xl >>> 9 | x << 23); + } + function Gamma0(x, xl) { + return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ x >>> 7; + } + function Gamma0l(x, xl) { + return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ (x >>> 7 | xl << 25); + } + function Gamma1(x, xl) { + return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ x >>> 6; + } + function Gamma1l(x, xl) { + return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ (x >>> 6 | xl << 26); + } + function getCarry(a, b) { + return a >>> 0 < b >>> 0 ? 1 : 0; + } + Sha512.prototype._update = function(M) { + var W2 = this._w; + var ah = this._ah | 0; + var bh = this._bh | 0; + var ch = this._ch | 0; + var dh2 = this._dh | 0; + var eh = this._eh | 0; + var fh = this._fh | 0; + var gh = this._gh | 0; + var hh = this._hh | 0; + var al = this._al | 0; + var bl = this._bl | 0; + var cl = this._cl | 0; + var dl = this._dl | 0; + var el = this._el | 0; + var fl = this._fl | 0; + var gl = this._gl | 0; + var hl = this._hl | 0; + for (var i2 = 0; i2 < 32; i2 += 2) { + W2[i2] = M.readInt32BE(i2 * 4); + W2[i2 + 1] = M.readInt32BE(i2 * 4 + 4); + } + for (; i2 < 160; i2 += 2) { + var xh = W2[i2 - 15 * 2]; + var xl = W2[i2 - 15 * 2 + 1]; + var gamma0 = Gamma0(xh, xl); + var gamma0l = Gamma0l(xl, xh); + xh = W2[i2 - 2 * 2]; + xl = W2[i2 - 2 * 2 + 1]; + var gamma1 = Gamma1(xh, xl); + var gamma1l = Gamma1l(xl, xh); + var Wi7h = W2[i2 - 7 * 2]; + var Wi7l = W2[i2 - 7 * 2 + 1]; + var Wi16h = W2[i2 - 16 * 2]; + var Wi16l = W2[i2 - 16 * 2 + 1]; + var Wil = gamma0l + Wi7l | 0; + var Wih = gamma0 + Wi7h + getCarry(Wil, gamma0l) | 0; + Wil = Wil + gamma1l | 0; + Wih = Wih + gamma1 + getCarry(Wil, gamma1l) | 0; + Wil = Wil + Wi16l | 0; + Wih = Wih + Wi16h + getCarry(Wil, Wi16l) | 0; + W2[i2] = Wih; + W2[i2 + 1] = Wil; + } + for (var j = 0; j < 160; j += 2) { + Wih = W2[j]; + Wil = W2[j + 1]; + var majh = maj(ah, bh, ch); + var majl = maj(al, bl, cl); + var sigma0h = sigma0(ah, al); + var sigma0l = sigma0(al, ah); + var sigma1h = sigma1(eh, el); + var sigma1l = sigma1(el, eh); + var Kih = K[j]; + var Kil = K[j + 1]; + var chh = Ch(eh, fh, gh); + var chl = Ch(el, fl, gl); + var t1l = hl + sigma1l | 0; + var t1h = hh + sigma1h + getCarry(t1l, hl) | 0; + t1l = t1l + chl | 0; + t1h = t1h + chh + getCarry(t1l, chl) | 0; + t1l = t1l + Kil | 0; + t1h = t1h + Kih + getCarry(t1l, Kil) | 0; + t1l = t1l + Wil | 0; + t1h = t1h + Wih + getCarry(t1l, Wil) | 0; + var t2l = sigma0l + majl | 0; + var t2h = sigma0h + majh + getCarry(t2l, sigma0l) | 0; + hh = gh; + hl = gl; + gh = fh; + gl = fl; + fh = eh; + fl = el; + el = dl + t1l | 0; + eh = dh2 + t1h + getCarry(el, dl) | 0; + dh2 = ch; + dl = cl; + ch = bh; + cl = bl; + bh = ah; + bl = al; + al = t1l + t2l | 0; + ah = t1h + t2h + getCarry(al, t1l) | 0; + } + this._al = this._al + al | 0; + this._bl = this._bl + bl | 0; + this._cl = this._cl + cl | 0; + this._dl = this._dl + dl | 0; + this._el = this._el + el | 0; + this._fl = this._fl + fl | 0; + this._gl = this._gl + gl | 0; + this._hl = this._hl + hl | 0; + this._ah = this._ah + ah + getCarry(this._al, al) | 0; + this._bh = this._bh + bh + getCarry(this._bl, bl) | 0; + this._ch = this._ch + ch + getCarry(this._cl, cl) | 0; + this._dh = this._dh + dh2 + getCarry(this._dl, dl) | 0; + this._eh = this._eh + eh + getCarry(this._el, el) | 0; + this._fh = this._fh + fh + getCarry(this._fl, fl) | 0; + this._gh = this._gh + gh + getCarry(this._gl, gl) | 0; + this._hh = this._hh + hh + getCarry(this._hl, hl) | 0; + }; + Sha512.prototype._hash = function() { + var H = Buffer2.allocUnsafe(64); + function writeInt64BE(h, l, offset) { + H.writeInt32BE(h, offset); + H.writeInt32BE(l, offset + 4); + } + writeInt64BE(this._ah, this._al, 0); + writeInt64BE(this._bh, this._bl, 8); + writeInt64BE(this._ch, this._cl, 16); + writeInt64BE(this._dh, this._dl, 24); + writeInt64BE(this._eh, this._el, 32); + writeInt64BE(this._fh, this._fl, 40); + writeInt64BE(this._gh, this._gl, 48); + writeInt64BE(this._hh, this._hl, 56); + return H; + }; + sha512$1 = Sha512; + return sha512$1; +} +var sha384$1; +var hasRequiredSha384; +function requireSha384() { + if (hasRequiredSha384) return sha384$1; + hasRequiredSha384 = 1; + var inherits = requireInherits_browser(); + var SHA512 = requireSha512(); + var Hash = requireHash$1(); + var Buffer2 = requireSafeBuffer$1().Buffer; + var W = new Array(160); + function Sha384() { + this.init(); + this._w = W; + Hash.call(this, 128, 112); + } + inherits(Sha384, SHA512); + Sha384.prototype.init = function() { + this._ah = 3418070365; + this._bh = 1654270250; + this._ch = 2438529370; + this._dh = 355462360; + this._eh = 1731405415; + this._fh = 2394180231; + this._gh = 3675008525; + this._hh = 1203062813; + this._al = 3238371032; + this._bl = 914150663; + this._cl = 812702999; + this._dl = 4144912697; + this._el = 4290775857; + this._fl = 1750603025; + this._gl = 1694076839; + this._hl = 3204075428; + return this; + }; + Sha384.prototype._hash = function() { + var H = Buffer2.allocUnsafe(48); + function writeInt64BE(h, l, offset) { + H.writeInt32BE(h, offset); + H.writeInt32BE(l, offset + 4); + } + writeInt64BE(this._ah, this._al, 0); + writeInt64BE(this._bh, this._bl, 8); + writeInt64BE(this._ch, this._cl, 16); + writeInt64BE(this._dh, this._dl, 24); + writeInt64BE(this._eh, this._el, 32); + writeInt64BE(this._fh, this._fl, 40); + return H; + }; + sha384$1 = Sha384; + return sha384$1; +} +var hasRequiredSha_js; +function requireSha_js() { + if (hasRequiredSha_js) return sha_js.exports; + hasRequiredSha_js = 1; + var exports2 = sha_js.exports = function SHA(algorithm) { + algorithm = algorithm.toLowerCase(); + var Algorithm = exports2[algorithm]; + if (!Algorithm) throw new Error(algorithm + " is not supported (we accept pull requests)"); + return new Algorithm(); + }; + exports2.sha = requireSha$1(); + exports2.sha1 = requireSha1(); + exports2.sha224 = requireSha224(); + exports2.sha256 = requireSha256(); + exports2.sha384 = requireSha384(); + exports2.sha512 = requireSha512(); + return sha_js.exports; +} +var streamBrowserify; +var hasRequiredStreamBrowserify; +function requireStreamBrowserify() { + if (hasRequiredStreamBrowserify) return streamBrowserify; + hasRequiredStreamBrowserify = 1; + streamBrowserify = Stream; + var EE = requireEvents().EventEmitter; + var inherits = requireInherits_browser(); + inherits(Stream, EE); + Stream.Readable = require_stream_readable$1(); + Stream.Writable = require_stream_writable$1(); + Stream.Duplex = require_stream_duplex$1(); + Stream.Transform = require_stream_transform$1(); + Stream.PassThrough = require_stream_passthrough$1(); + Stream.finished = requireEndOfStream(); + Stream.pipeline = requirePipeline(); + Stream.Stream = Stream; + function Stream() { + EE.call(this); + } + Stream.prototype.pipe = function(dest, options) { + var source = this; + function ondata(chunk2) { + if (dest.writable) { + if (false === dest.write(chunk2) && source.pause) { + source.pause(); + } + } + } + source.on("data", ondata); + function ondrain() { + if (source.readable && source.resume) { + source.resume(); + } + } + dest.on("drain", ondrain); + if (!dest._isStdio && (!options || options.end !== false)) { + source.on("end", onend); + source.on("close", onclose); + } + var didOnEnd = false; + function onend() { + if (didOnEnd) return; + didOnEnd = true; + dest.end(); + } + function onclose() { + if (didOnEnd) return; + didOnEnd = true; + if (typeof dest.destroy === "function") dest.destroy(); + } + function onerror(er) { + cleanup(); + if (EE.listenerCount(this, "error") === 0) { + throw er; + } + } + source.on("error", onerror); + dest.on("error", onerror); + function cleanup() { + source.removeListener("data", ondata); + dest.removeListener("drain", ondrain); + source.removeListener("end", onend); + source.removeListener("close", onclose); + source.removeListener("error", onerror); + dest.removeListener("error", onerror); + source.removeListener("end", cleanup); + source.removeListener("close", cleanup); + dest.removeListener("close", cleanup); + } + source.on("end", cleanup); + source.on("close", cleanup); + dest.on("close", cleanup); + dest.emit("pipe", source); + return dest; + }; + return streamBrowserify; +} +var cipherBase; +var hasRequiredCipherBase; +function requireCipherBase() { + if (hasRequiredCipherBase) return cipherBase; + hasRequiredCipherBase = 1; + var Buffer2 = requireSafeBuffer$1().Buffer; + var Transform = requireStreamBrowserify().Transform; + var StringDecoder = requireString_decoder().StringDecoder; + var inherits = requireInherits_browser(); + function CipherBase(hashMode) { + Transform.call(this); + this.hashMode = typeof hashMode === "string"; + if (this.hashMode) { + this[hashMode] = this._finalOrDigest; + } else { + this.final = this._finalOrDigest; + } + if (this._final) { + this.__final = this._final; + this._final = null; + } + this._decoder = null; + this._encoding = null; + } + inherits(CipherBase, Transform); + CipherBase.prototype.update = function(data, inputEnc, outputEnc) { + if (typeof data === "string") { + data = Buffer2.from(data, inputEnc); + } + var outData = this._update(data); + if (this.hashMode) return this; + if (outputEnc) { + outData = this._toString(outData, outputEnc); + } + return outData; + }; + CipherBase.prototype.setAutoPadding = function() { + }; + CipherBase.prototype.getAuthTag = function() { + throw new Error("trying to get auth tag in unsupported state"); + }; + CipherBase.prototype.setAuthTag = function() { + throw new Error("trying to set auth tag in unsupported state"); + }; + CipherBase.prototype.setAAD = function() { + throw new Error("trying to set aad in unsupported state"); + }; + CipherBase.prototype._transform = function(data, _, next) { + var err; + try { + if (this.hashMode) { + this._update(data); + } else { + this.push(this._update(data)); + } + } catch (e) { + err = e; + } finally { + next(err); + } + }; + CipherBase.prototype._flush = function(done) { + var err; + try { + this.push(this.__final()); + } catch (e) { + err = e; + } + done(err); + }; + CipherBase.prototype._finalOrDigest = function(outputEnc) { + var outData = this.__final() || Buffer2.alloc(0); + if (outputEnc) { + outData = this._toString(outData, outputEnc, true); + } + return outData; + }; + CipherBase.prototype._toString = function(value, enc, fin) { + if (!this._decoder) { + this._decoder = new StringDecoder(enc); + this._encoding = enc; + } + if (this._encoding !== enc) throw new Error("can't switch encodings"); + var out = this._decoder.write(value); + if (fin) { + out += this._decoder.end(); + } + return out; + }; + cipherBase = CipherBase; + return cipherBase; +} +var browser$9; +var hasRequiredBrowser$9; +function requireBrowser$9() { + if (hasRequiredBrowser$9) return browser$9; + hasRequiredBrowser$9 = 1; + var inherits = requireInherits_browser(); + var MD5 = requireMd5_js(); + var RIPEMD160 = requireRipemd160(); + var sha2 = requireSha_js(); + var Base = requireCipherBase(); + function Hash(hash2) { + Base.call(this, "digest"); + this._hash = hash2; + } + inherits(Hash, Base); + Hash.prototype._update = function(data) { + this._hash.update(data); + }; + Hash.prototype._final = function() { + return this._hash.digest(); + }; + browser$9 = function createHash(alg) { + alg = alg.toLowerCase(); + if (alg === "md5") return new MD5(); + if (alg === "rmd160" || alg === "ripemd160") return new RIPEMD160(); + return new Hash(sha2(alg)); + }; + return browser$9; +} +var legacy; +var hasRequiredLegacy; +function requireLegacy() { + if (hasRequiredLegacy) return legacy; + hasRequiredLegacy = 1; + var inherits = requireInherits_browser(); + var Buffer2 = requireSafeBuffer$1().Buffer; + var Base = requireCipherBase(); + var ZEROS = Buffer2.alloc(128); + var blocksize = 64; + function Hmac(alg, key2) { + Base.call(this, "digest"); + if (typeof key2 === "string") { + key2 = Buffer2.from(key2); + } + this._alg = alg; + this._key = key2; + if (key2.length > blocksize) { + key2 = alg(key2); + } else if (key2.length < blocksize) { + key2 = Buffer2.concat([key2, ZEROS], blocksize); + } + var ipad = this._ipad = Buffer2.allocUnsafe(blocksize); + var opad = this._opad = Buffer2.allocUnsafe(blocksize); + for (var i2 = 0; i2 < blocksize; i2++) { + ipad[i2] = key2[i2] ^ 54; + opad[i2] = key2[i2] ^ 92; + } + this._hash = [ipad]; + } + inherits(Hmac, Base); + Hmac.prototype._update = function(data) { + this._hash.push(data); + }; + Hmac.prototype._final = function() { + var h = this._alg(Buffer2.concat(this._hash)); + return this._alg(Buffer2.concat([this._opad, h])); + }; + legacy = Hmac; + return legacy; +} +var md5; +var hasRequiredMd5; +function requireMd5() { + if (hasRequiredMd5) return md5; + hasRequiredMd5 = 1; + var MD5 = requireMd5_js(); + md5 = function(buffer2) { + return new MD5().update(buffer2).digest(); + }; + return md5; +} +var browser$8; +var hasRequiredBrowser$8; +function requireBrowser$8() { + if (hasRequiredBrowser$8) return browser$8; + hasRequiredBrowser$8 = 1; + var inherits = requireInherits_browser(); + var Legacy = requireLegacy(); + var Base = requireCipherBase(); + var Buffer2 = requireSafeBuffer$1().Buffer; + var md52 = requireMd5(); + var RIPEMD160 = requireRipemd160(); + var sha2 = requireSha_js(); + var ZEROS = Buffer2.alloc(128); + function Hmac(alg, key2) { + Base.call(this, "digest"); + if (typeof key2 === "string") { + key2 = Buffer2.from(key2); + } + var blocksize = alg === "sha512" || alg === "sha384" ? 128 : 64; + this._alg = alg; + this._key = key2; + if (key2.length > blocksize) { + var hash2 = alg === "rmd160" ? new RIPEMD160() : sha2(alg); + key2 = hash2.update(key2).digest(); + } else if (key2.length < blocksize) { + key2 = Buffer2.concat([key2, ZEROS], blocksize); + } + var ipad = this._ipad = Buffer2.allocUnsafe(blocksize); + var opad = this._opad = Buffer2.allocUnsafe(blocksize); + for (var i2 = 0; i2 < blocksize; i2++) { + ipad[i2] = key2[i2] ^ 54; + opad[i2] = key2[i2] ^ 92; + } + this._hash = alg === "rmd160" ? new RIPEMD160() : sha2(alg); + this._hash.update(ipad); + } + inherits(Hmac, Base); + Hmac.prototype._update = function(data) { + this._hash.update(data); + }; + Hmac.prototype._final = function() { + var h = this._hash.digest(); + var hash2 = this._alg === "rmd160" ? new RIPEMD160() : sha2(this._alg); + return hash2.update(this._opad).update(h).digest(); + }; + browser$8 = function createHmac(alg, key2) { + alg = alg.toLowerCase(); + if (alg === "rmd160" || alg === "ripemd160") { + return new Hmac("rmd160", key2); + } + if (alg === "md5") { + return new Legacy(md52, key2); + } + return new Hmac(alg, key2); + }; + return browser$8; +} +const sha224WithRSAEncryption = { "sign": "rsa", "hash": "sha224", "id": "302d300d06096086480165030402040500041c" }; +const sha256WithRSAEncryption = { "sign": "rsa", "hash": "sha256", "id": "3031300d060960864801650304020105000420" }; +const sha384WithRSAEncryption = { "sign": "rsa", "hash": "sha384", "id": "3041300d060960864801650304020205000430" }; +const sha512WithRSAEncryption = { "sign": "rsa", "hash": "sha512", "id": "3051300d060960864801650304020305000440" }; +const sha256 = { "sign": "ecdsa", "hash": "sha256", "id": "" }; +const sha224 = { "sign": "ecdsa", "hash": "sha224", "id": "" }; +const sha384 = { "sign": "ecdsa", "hash": "sha384", "id": "" }; +const sha512 = { "sign": "ecdsa", "hash": "sha512", "id": "" }; +const DSA = { "sign": "dsa", "hash": "sha1", "id": "" }; +const ripemd160WithRSA = { "sign": "rsa", "hash": "rmd160", "id": "3021300906052b2403020105000414" }; +const md5WithRSAEncryption = { "sign": "rsa", "hash": "md5", "id": "3020300c06082a864886f70d020505000410" }; +const require$$6 = { + sha224WithRSAEncryption, + "RSA-SHA224": { "sign": "ecdsa/rsa", "hash": "sha224", "id": "302d300d06096086480165030402040500041c" }, + sha256WithRSAEncryption, + "RSA-SHA256": { "sign": "ecdsa/rsa", "hash": "sha256", "id": "3031300d060960864801650304020105000420" }, + sha384WithRSAEncryption, + "RSA-SHA384": { "sign": "ecdsa/rsa", "hash": "sha384", "id": "3041300d060960864801650304020205000430" }, + sha512WithRSAEncryption, + "RSA-SHA512": { "sign": "ecdsa/rsa", "hash": "sha512", "id": "3051300d060960864801650304020305000440" }, + "RSA-SHA1": { "sign": "rsa", "hash": "sha1", "id": "3021300906052b0e03021a05000414" }, + "ecdsa-with-SHA1": { "sign": "ecdsa", "hash": "sha1", "id": "" }, + sha256, + sha224, + sha384, + sha512, + "DSA-SHA": { "sign": "dsa", "hash": "sha1", "id": "" }, + "DSA-SHA1": { "sign": "dsa", "hash": "sha1", "id": "" }, + DSA, + "DSA-WITH-SHA224": { "sign": "dsa", "hash": "sha224", "id": "" }, + "DSA-SHA224": { "sign": "dsa", "hash": "sha224", "id": "" }, + "DSA-WITH-SHA256": { "sign": "dsa", "hash": "sha256", "id": "" }, + "DSA-SHA256": { "sign": "dsa", "hash": "sha256", "id": "" }, + "DSA-WITH-SHA384": { "sign": "dsa", "hash": "sha384", "id": "" }, + "DSA-SHA384": { "sign": "dsa", "hash": "sha384", "id": "" }, + "DSA-WITH-SHA512": { "sign": "dsa", "hash": "sha512", "id": "" }, + "DSA-SHA512": { "sign": "dsa", "hash": "sha512", "id": "" }, + "DSA-RIPEMD160": { "sign": "dsa", "hash": "rmd160", "id": "" }, + ripemd160WithRSA, + "RSA-RIPEMD160": { "sign": "rsa", "hash": "rmd160", "id": "3021300906052b2403020105000414" }, + md5WithRSAEncryption, + "RSA-MD5": { "sign": "rsa", "hash": "md5", "id": "3020300c06082a864886f70d020505000410" } +}; +var algos; +var hasRequiredAlgos; +function requireAlgos() { + if (hasRequiredAlgos) return algos; + hasRequiredAlgos = 1; + algos = require$$6; + return algos; +} +var browser$7 = {}; +var precondition; +var hasRequiredPrecondition; +function requirePrecondition() { + if (hasRequiredPrecondition) return precondition; + hasRequiredPrecondition = 1; + var MAX_ALLOC = Math.pow(2, 30) - 1; + precondition = function(iterations, keylen) { + if (typeof iterations !== "number") { + throw new TypeError("Iterations not a number"); + } + if (iterations < 0) { + throw new TypeError("Bad iterations"); + } + if (typeof keylen !== "number") { + throw new TypeError("Key length not a number"); + } + if (keylen < 0 || keylen > MAX_ALLOC || keylen !== keylen) { + throw new TypeError("Bad key length"); + } + }; + return precondition; +} +var defaultEncoding_1; +var hasRequiredDefaultEncoding; +function requireDefaultEncoding() { + if (hasRequiredDefaultEncoding) return defaultEncoding_1; + hasRequiredDefaultEncoding = 1; + var defaultEncoding; + if (commonjsGlobal.process && commonjsGlobal.process.browser) { + defaultEncoding = "utf-8"; + } else if (commonjsGlobal.process && commonjsGlobal.process.version) { + var pVersionMajor = parseInt(process$1.version.split(".")[0].slice(1), 10); + defaultEncoding = pVersionMajor >= 6 ? "utf-8" : "binary"; + } else { + defaultEncoding = "utf-8"; + } + defaultEncoding_1 = defaultEncoding; + return defaultEncoding_1; +} +var toBuffer; +var hasRequiredToBuffer; +function requireToBuffer() { + if (hasRequiredToBuffer) return toBuffer; + hasRequiredToBuffer = 1; + var Buffer2 = requireSafeBuffer$1().Buffer; + toBuffer = function(thing, encoding, name) { + if (Buffer2.isBuffer(thing)) { + return thing; + } else if (typeof thing === "string") { + return Buffer2.from(thing, encoding); + } else if (ArrayBuffer.isView(thing)) { + return Buffer2.from(thing.buffer); + } else { + throw new TypeError(name + " must be a string, a Buffer, a typed array or a DataView"); + } + }; + return toBuffer; +} +var syncBrowser; +var hasRequiredSyncBrowser; +function requireSyncBrowser() { + if (hasRequiredSyncBrowser) return syncBrowser; + hasRequiredSyncBrowser = 1; + var md52 = requireMd5(); + var RIPEMD160 = requireRipemd160(); + var sha2 = requireSha_js(); + var Buffer2 = requireSafeBuffer$1().Buffer; + var checkParameters = requirePrecondition(); + var defaultEncoding = requireDefaultEncoding(); + var toBuffer2 = requireToBuffer(); + var ZEROS = Buffer2.alloc(128); + var sizes = { + md5: 16, + sha1: 20, + sha224: 28, + sha256: 32, + sha384: 48, + sha512: 64, + rmd160: 20, + ripemd160: 20 + }; + function Hmac(alg, key2, saltLen) { + var hash2 = getDigest(alg); + var blocksize = alg === "sha512" || alg === "sha384" ? 128 : 64; + if (key2.length > blocksize) { + key2 = hash2(key2); + } else if (key2.length < blocksize) { + key2 = Buffer2.concat([key2, ZEROS], blocksize); + } + var ipad = Buffer2.allocUnsafe(blocksize + sizes[alg]); + var opad = Buffer2.allocUnsafe(blocksize + sizes[alg]); + for (var i2 = 0; i2 < blocksize; i2++) { + ipad[i2] = key2[i2] ^ 54; + opad[i2] = key2[i2] ^ 92; + } + var ipad1 = Buffer2.allocUnsafe(blocksize + saltLen + 4); + ipad.copy(ipad1, 0, 0, blocksize); + this.ipad1 = ipad1; + this.ipad2 = ipad; + this.opad = opad; + this.alg = alg; + this.blocksize = blocksize; + this.hash = hash2; + this.size = sizes[alg]; + } + Hmac.prototype.run = function(data, ipad) { + data.copy(ipad, this.blocksize); + var h = this.hash(ipad); + h.copy(this.opad, this.blocksize); + return this.hash(this.opad); + }; + function getDigest(alg) { + function shaFunc(data) { + return sha2(alg).update(data).digest(); + } + function rmd160Func(data) { + return new RIPEMD160().update(data).digest(); + } + if (alg === "rmd160" || alg === "ripemd160") return rmd160Func; + if (alg === "md5") return md52; + return shaFunc; + } + function pbkdf2(password, salt, iterations, keylen, digest) { + checkParameters(iterations, keylen); + password = toBuffer2(password, defaultEncoding, "Password"); + salt = toBuffer2(salt, defaultEncoding, "Salt"); + digest = digest || "sha1"; + var hmac2 = new Hmac(digest, password, salt.length); + var DK = Buffer2.allocUnsafe(keylen); + var block1 = Buffer2.allocUnsafe(salt.length + 4); + salt.copy(block1, 0, 0, salt.length); + var destPos = 0; + var hLen = sizes[digest]; + var l = Math.ceil(keylen / hLen); + for (var i2 = 1; i2 <= l; i2++) { + block1.writeUInt32BE(i2, salt.length); + var T = hmac2.run(block1, hmac2.ipad1); + var U = T; + for (var j = 1; j < iterations; j++) { + U = hmac2.run(U, hmac2.ipad2); + for (var k = 0; k < hLen; k++) T[k] ^= U[k]; + } + T.copy(DK, destPos); + destPos += hLen; + } + return DK; + } + syncBrowser = pbkdf2; + return syncBrowser; +} +var async; +var hasRequiredAsync; +function requireAsync() { + if (hasRequiredAsync) return async; + hasRequiredAsync = 1; + var Buffer2 = requireSafeBuffer$1().Buffer; + var checkParameters = requirePrecondition(); + var defaultEncoding = requireDefaultEncoding(); + var sync = requireSyncBrowser(); + var toBuffer2 = requireToBuffer(); + var ZERO_BUF; + var subtle = commonjsGlobal.crypto && commonjsGlobal.crypto.subtle; + var toBrowser = { + sha: "SHA-1", + "sha-1": "SHA-1", + sha1: "SHA-1", + sha256: "SHA-256", + "sha-256": "SHA-256", + sha384: "SHA-384", + "sha-384": "SHA-384", + "sha-512": "SHA-512", + sha512: "SHA-512" + }; + var checks = []; + function checkNative(algo) { + if (commonjsGlobal.process && !commonjsGlobal.process.browser) { + return Promise.resolve(false); + } + if (!subtle || !subtle.importKey || !subtle.deriveBits) { + return Promise.resolve(false); + } + if (checks[algo] !== void 0) { + return checks[algo]; + } + ZERO_BUF = ZERO_BUF || Buffer2.alloc(8); + var prom = browserPbkdf2(ZERO_BUF, ZERO_BUF, 10, 128, algo).then(function() { + return true; + }).catch(function() { + return false; + }); + checks[algo] = prom; + return prom; + } + var nextTick; + function getNextTick() { + if (nextTick) { + return nextTick; + } + if (commonjsGlobal.process && commonjsGlobal.process.nextTick) { + nextTick = commonjsGlobal.process.nextTick; + } else if (commonjsGlobal.queueMicrotask) { + nextTick = commonjsGlobal.queueMicrotask; + } else if (commonjsGlobal.setImmediate) { + nextTick = commonjsGlobal.setImmediate; + } else { + nextTick = commonjsGlobal.setTimeout; + } + return nextTick; + } + function browserPbkdf2(password, salt, iterations, length, algo) { + return subtle.importKey( + "raw", + password, + { name: "PBKDF2" }, + false, + ["deriveBits"] + ).then(function(key2) { + return subtle.deriveBits({ + name: "PBKDF2", + salt, + iterations, + hash: { + name: algo + } + }, key2, length << 3); + }).then(function(res) { + return Buffer2.from(res); + }); + } + function resolvePromise(promise, callback) { + promise.then(function(out) { + getNextTick()(function() { + callback(null, out); + }); + }, function(e) { + getNextTick()(function() { + callback(e); + }); + }); + } + async = function(password, salt, iterations, keylen, digest, callback) { + if (typeof digest === "function") { + callback = digest; + digest = void 0; + } + digest = digest || "sha1"; + var algo = toBrowser[digest.toLowerCase()]; + if (!algo || typeof commonjsGlobal.Promise !== "function") { + getNextTick()(function() { + var out; + try { + out = sync(password, salt, iterations, keylen, digest); + } catch (e) { + return callback(e); + } + callback(null, out); + }); + return; + } + checkParameters(iterations, keylen); + password = toBuffer2(password, defaultEncoding, "Password"); + salt = toBuffer2(salt, defaultEncoding, "Salt"); + if (typeof callback !== "function") throw new Error("No callback provided to pbkdf2"); + resolvePromise(checkNative(algo).then(function(resp) { + if (resp) return browserPbkdf2(password, salt, iterations, keylen, algo); + return sync(password, salt, iterations, keylen, digest); + }), callback); + }; + return async; +} +var hasRequiredBrowser$7; +function requireBrowser$7() { + if (hasRequiredBrowser$7) return browser$7; + hasRequiredBrowser$7 = 1; + browser$7.pbkdf2 = requireAsync(); + browser$7.pbkdf2Sync = requireSyncBrowser(); + return browser$7; +} +var browser$6 = {}; +var des$1 = {}; +var utils$4 = {}; +var hasRequiredUtils$3; +function requireUtils$3() { + if (hasRequiredUtils$3) return utils$4; + hasRequiredUtils$3 = 1; + utils$4.readUInt32BE = function readUInt32BE(bytes, off) { + var res = bytes[0 + off] << 24 | bytes[1 + off] << 16 | bytes[2 + off] << 8 | bytes[3 + off]; + return res >>> 0; + }; + utils$4.writeUInt32BE = function writeUInt32BE(bytes, value, off) { + bytes[0 + off] = value >>> 24; + bytes[1 + off] = value >>> 16 & 255; + bytes[2 + off] = value >>> 8 & 255; + bytes[3 + off] = value & 255; + }; + utils$4.ip = function ip(inL, inR, out, off) { + var outL = 0; + var outR = 0; + for (var i2 = 6; i2 >= 0; i2 -= 2) { + for (var j = 0; j <= 24; j += 8) { + outL <<= 1; + outL |= inR >>> j + i2 & 1; + } + for (var j = 0; j <= 24; j += 8) { + outL <<= 1; + outL |= inL >>> j + i2 & 1; + } + } + for (var i2 = 6; i2 >= 0; i2 -= 2) { + for (var j = 1; j <= 25; j += 8) { + outR <<= 1; + outR |= inR >>> j + i2 & 1; + } + for (var j = 1; j <= 25; j += 8) { + outR <<= 1; + outR |= inL >>> j + i2 & 1; + } + } + out[off + 0] = outL >>> 0; + out[off + 1] = outR >>> 0; + }; + utils$4.rip = function rip(inL, inR, out, off) { + var outL = 0; + var outR = 0; + for (var i2 = 0; i2 < 4; i2++) { + for (var j = 24; j >= 0; j -= 8) { + outL <<= 1; + outL |= inR >>> j + i2 & 1; + outL <<= 1; + outL |= inL >>> j + i2 & 1; + } + } + for (var i2 = 4; i2 < 8; i2++) { + for (var j = 24; j >= 0; j -= 8) { + outR <<= 1; + outR |= inR >>> j + i2 & 1; + outR <<= 1; + outR |= inL >>> j + i2 & 1; + } + } + out[off + 0] = outL >>> 0; + out[off + 1] = outR >>> 0; + }; + utils$4.pc1 = function pc1(inL, inR, out, off) { + var outL = 0; + var outR = 0; + for (var i2 = 7; i2 >= 5; i2--) { + for (var j = 0; j <= 24; j += 8) { + outL <<= 1; + outL |= inR >> j + i2 & 1; + } + for (var j = 0; j <= 24; j += 8) { + outL <<= 1; + outL |= inL >> j + i2 & 1; + } + } + for (var j = 0; j <= 24; j += 8) { + outL <<= 1; + outL |= inR >> j + i2 & 1; + } + for (var i2 = 1; i2 <= 3; i2++) { + for (var j = 0; j <= 24; j += 8) { + outR <<= 1; + outR |= inR >> j + i2 & 1; + } + for (var j = 0; j <= 24; j += 8) { + outR <<= 1; + outR |= inL >> j + i2 & 1; + } + } + for (var j = 0; j <= 24; j += 8) { + outR <<= 1; + outR |= inL >> j + i2 & 1; + } + out[off + 0] = outL >>> 0; + out[off + 1] = outR >>> 0; + }; + utils$4.r28shl = function r28shl(num, shift) { + return num << shift & 268435455 | num >>> 28 - shift; + }; + var pc2table = [ + // inL => outL + 14, + 11, + 17, + 4, + 27, + 23, + 25, + 0, + 13, + 22, + 7, + 18, + 5, + 9, + 16, + 24, + 2, + 20, + 12, + 21, + 1, + 8, + 15, + 26, + // inR => outR + 15, + 4, + 25, + 19, + 9, + 1, + 26, + 16, + 5, + 11, + 23, + 8, + 12, + 7, + 17, + 0, + 22, + 3, + 10, + 14, + 6, + 20, + 27, + 24 + ]; + utils$4.pc2 = function pc2(inL, inR, out, off) { + var outL = 0; + var outR = 0; + var len2 = pc2table.length >>> 1; + for (var i2 = 0; i2 < len2; i2++) { + outL <<= 1; + outL |= inL >>> pc2table[i2] & 1; + } + for (var i2 = len2; i2 < pc2table.length; i2++) { + outR <<= 1; + outR |= inR >>> pc2table[i2] & 1; + } + out[off + 0] = outL >>> 0; + out[off + 1] = outR >>> 0; + }; + utils$4.expand = function expand(r, out, off) { + var outL = 0; + var outR = 0; + outL = (r & 1) << 5 | r >>> 27; + for (var i2 = 23; i2 >= 15; i2 -= 4) { + outL <<= 6; + outL |= r >>> i2 & 63; + } + for (var i2 = 11; i2 >= 3; i2 -= 4) { + outR |= r >>> i2 & 63; + outR <<= 6; + } + outR |= (r & 31) << 1 | r >>> 31; + out[off + 0] = outL >>> 0; + out[off + 1] = outR >>> 0; + }; + var sTable = [ + 14, + 0, + 4, + 15, + 13, + 7, + 1, + 4, + 2, + 14, + 15, + 2, + 11, + 13, + 8, + 1, + 3, + 10, + 10, + 6, + 6, + 12, + 12, + 11, + 5, + 9, + 9, + 5, + 0, + 3, + 7, + 8, + 4, + 15, + 1, + 12, + 14, + 8, + 8, + 2, + 13, + 4, + 6, + 9, + 2, + 1, + 11, + 7, + 15, + 5, + 12, + 11, + 9, + 3, + 7, + 14, + 3, + 10, + 10, + 0, + 5, + 6, + 0, + 13, + 15, + 3, + 1, + 13, + 8, + 4, + 14, + 7, + 6, + 15, + 11, + 2, + 3, + 8, + 4, + 14, + 9, + 12, + 7, + 0, + 2, + 1, + 13, + 10, + 12, + 6, + 0, + 9, + 5, + 11, + 10, + 5, + 0, + 13, + 14, + 8, + 7, + 10, + 11, + 1, + 10, + 3, + 4, + 15, + 13, + 4, + 1, + 2, + 5, + 11, + 8, + 6, + 12, + 7, + 6, + 12, + 9, + 0, + 3, + 5, + 2, + 14, + 15, + 9, + 10, + 13, + 0, + 7, + 9, + 0, + 14, + 9, + 6, + 3, + 3, + 4, + 15, + 6, + 5, + 10, + 1, + 2, + 13, + 8, + 12, + 5, + 7, + 14, + 11, + 12, + 4, + 11, + 2, + 15, + 8, + 1, + 13, + 1, + 6, + 10, + 4, + 13, + 9, + 0, + 8, + 6, + 15, + 9, + 3, + 8, + 0, + 7, + 11, + 4, + 1, + 15, + 2, + 14, + 12, + 3, + 5, + 11, + 10, + 5, + 14, + 2, + 7, + 12, + 7, + 13, + 13, + 8, + 14, + 11, + 3, + 5, + 0, + 6, + 6, + 15, + 9, + 0, + 10, + 3, + 1, + 4, + 2, + 7, + 8, + 2, + 5, + 12, + 11, + 1, + 12, + 10, + 4, + 14, + 15, + 9, + 10, + 3, + 6, + 15, + 9, + 0, + 0, + 6, + 12, + 10, + 11, + 1, + 7, + 13, + 13, + 8, + 15, + 9, + 1, + 4, + 3, + 5, + 14, + 11, + 5, + 12, + 2, + 7, + 8, + 2, + 4, + 14, + 2, + 14, + 12, + 11, + 4, + 2, + 1, + 12, + 7, + 4, + 10, + 7, + 11, + 13, + 6, + 1, + 8, + 5, + 5, + 0, + 3, + 15, + 15, + 10, + 13, + 3, + 0, + 9, + 14, + 8, + 9, + 6, + 4, + 11, + 2, + 8, + 1, + 12, + 11, + 7, + 10, + 1, + 13, + 14, + 7, + 2, + 8, + 13, + 15, + 6, + 9, + 15, + 12, + 0, + 5, + 9, + 6, + 10, + 3, + 4, + 0, + 5, + 14, + 3, + 12, + 10, + 1, + 15, + 10, + 4, + 15, + 2, + 9, + 7, + 2, + 12, + 6, + 9, + 8, + 5, + 0, + 6, + 13, + 1, + 3, + 13, + 4, + 14, + 14, + 0, + 7, + 11, + 5, + 3, + 11, + 8, + 9, + 4, + 14, + 3, + 15, + 2, + 5, + 12, + 2, + 9, + 8, + 5, + 12, + 15, + 3, + 10, + 7, + 11, + 0, + 14, + 4, + 1, + 10, + 7, + 1, + 6, + 13, + 0, + 11, + 8, + 6, + 13, + 4, + 13, + 11, + 0, + 2, + 11, + 14, + 7, + 15, + 4, + 0, + 9, + 8, + 1, + 13, + 10, + 3, + 14, + 12, + 3, + 9, + 5, + 7, + 12, + 5, + 2, + 10, + 15, + 6, + 8, + 1, + 6, + 1, + 6, + 4, + 11, + 11, + 13, + 13, + 8, + 12, + 1, + 3, + 4, + 7, + 10, + 14, + 7, + 10, + 9, + 15, + 5, + 6, + 0, + 8, + 15, + 0, + 14, + 5, + 2, + 9, + 3, + 2, + 12, + 13, + 1, + 2, + 15, + 8, + 13, + 4, + 8, + 6, + 10, + 15, + 3, + 11, + 7, + 1, + 4, + 10, + 12, + 9, + 5, + 3, + 6, + 14, + 11, + 5, + 0, + 0, + 14, + 12, + 9, + 7, + 2, + 7, + 2, + 11, + 1, + 4, + 14, + 1, + 7, + 9, + 4, + 12, + 10, + 14, + 8, + 2, + 13, + 0, + 15, + 6, + 12, + 10, + 9, + 13, + 0, + 15, + 3, + 3, + 5, + 5, + 6, + 8, + 11 + ]; + utils$4.substitute = function substitute(inL, inR) { + var out = 0; + for (var i2 = 0; i2 < 4; i2++) { + var b = inL >>> 18 - i2 * 6 & 63; + var sb = sTable[i2 * 64 + b]; + out <<= 4; + out |= sb; + } + for (var i2 = 0; i2 < 4; i2++) { + var b = inR >>> 18 - i2 * 6 & 63; + var sb = sTable[4 * 64 + i2 * 64 + b]; + out <<= 4; + out |= sb; + } + return out >>> 0; + }; + var permuteTable = [ + 16, + 25, + 12, + 11, + 3, + 20, + 4, + 15, + 31, + 17, + 9, + 6, + 27, + 14, + 1, + 22, + 30, + 24, + 8, + 18, + 0, + 5, + 29, + 23, + 13, + 19, + 2, + 26, + 10, + 21, + 28, + 7 + ]; + utils$4.permute = function permute(num) { + var out = 0; + for (var i2 = 0; i2 < permuteTable.length; i2++) { + out <<= 1; + out |= num >>> permuteTable[i2] & 1; + } + return out >>> 0; + }; + utils$4.padSplit = function padSplit(num, size, group) { + var str = num.toString(2); + while (str.length < size) + str = "0" + str; + var out = []; + for (var i2 = 0; i2 < size; i2 += group) + out.push(str.slice(i2, i2 + group)); + return out.join(" "); + }; + return utils$4; +} +var minimalisticAssert; +var hasRequiredMinimalisticAssert; +function requireMinimalisticAssert() { + if (hasRequiredMinimalisticAssert) return minimalisticAssert; + hasRequiredMinimalisticAssert = 1; + minimalisticAssert = assert; + function assert(val, msg) { + if (!val) + throw new Error(msg || "Assertion failed"); + } + assert.equal = function assertEqual(l, r, msg) { + if (l != r) + throw new Error(msg || "Assertion failed: " + l + " != " + r); + }; + return minimalisticAssert; +} +var cipher; +var hasRequiredCipher; +function requireCipher() { + if (hasRequiredCipher) return cipher; + hasRequiredCipher = 1; + var assert = requireMinimalisticAssert(); + function Cipher(options) { + this.options = options; + this.type = this.options.type; + this.blockSize = 8; + this._init(); + this.buffer = new Array(this.blockSize); + this.bufferOff = 0; + this.padding = options.padding !== false; + } + cipher = Cipher; + Cipher.prototype._init = function _init() { + }; + Cipher.prototype.update = function update(data) { + if (data.length === 0) + return []; + if (this.type === "decrypt") + return this._updateDecrypt(data); + else + return this._updateEncrypt(data); + }; + Cipher.prototype._buffer = function _buffer(data, off) { + var min = Math.min(this.buffer.length - this.bufferOff, data.length - off); + for (var i2 = 0; i2 < min; i2++) + this.buffer[this.bufferOff + i2] = data[off + i2]; + this.bufferOff += min; + return min; + }; + Cipher.prototype._flushBuffer = function _flushBuffer(out, off) { + this._update(this.buffer, 0, out, off); + this.bufferOff = 0; + return this.blockSize; + }; + Cipher.prototype._updateEncrypt = function _updateEncrypt(data) { + var inputOff = 0; + var outputOff = 0; + var count = (this.bufferOff + data.length) / this.blockSize | 0; + var out = new Array(count * this.blockSize); + if (this.bufferOff !== 0) { + inputOff += this._buffer(data, inputOff); + if (this.bufferOff === this.buffer.length) + outputOff += this._flushBuffer(out, outputOff); + } + var max = data.length - (data.length - inputOff) % this.blockSize; + for (; inputOff < max; inputOff += this.blockSize) { + this._update(data, inputOff, out, outputOff); + outputOff += this.blockSize; + } + for (; inputOff < data.length; inputOff++, this.bufferOff++) + this.buffer[this.bufferOff] = data[inputOff]; + return out; + }; + Cipher.prototype._updateDecrypt = function _updateDecrypt(data) { + var inputOff = 0; + var outputOff = 0; + var count = Math.ceil((this.bufferOff + data.length) / this.blockSize) - 1; + var out = new Array(count * this.blockSize); + for (; count > 0; count--) { + inputOff += this._buffer(data, inputOff); + outputOff += this._flushBuffer(out, outputOff); + } + inputOff += this._buffer(data, inputOff); + return out; + }; + Cipher.prototype.final = function final(buffer2) { + var first; + if (buffer2) + first = this.update(buffer2); + var last; + if (this.type === "encrypt") + last = this._finalEncrypt(); + else + last = this._finalDecrypt(); + if (first) + return first.concat(last); + else + return last; + }; + Cipher.prototype._pad = function _pad(buffer2, off) { + if (off === 0) + return false; + while (off < buffer2.length) + buffer2[off++] = 0; + return true; + }; + Cipher.prototype._finalEncrypt = function _finalEncrypt() { + if (!this._pad(this.buffer, this.bufferOff)) + return []; + var out = new Array(this.blockSize); + this._update(this.buffer, 0, out, 0); + return out; + }; + Cipher.prototype._unpad = function _unpad(buffer2) { + return buffer2; + }; + Cipher.prototype._finalDecrypt = function _finalDecrypt() { + assert.equal(this.bufferOff, this.blockSize, "Not enough data to decrypt"); + var out = new Array(this.blockSize); + this._flushBuffer(out, 0); + return this._unpad(out); + }; + return cipher; +} +var des; +var hasRequiredDes$1; +function requireDes$1() { + if (hasRequiredDes$1) return des; + hasRequiredDes$1 = 1; + var assert = requireMinimalisticAssert(); + var inherits = requireInherits_browser(); + var utils2 = requireUtils$3(); + var Cipher = requireCipher(); + function DESState() { + this.tmp = new Array(2); + this.keys = null; + } + function DES(options) { + Cipher.call(this, options); + var state2 = new DESState(); + this._desState = state2; + this.deriveKeys(state2, options.key); + } + inherits(DES, Cipher); + des = DES; + DES.create = function create(options) { + return new DES(options); + }; + var shiftTable = [ + 1, + 1, + 2, + 2, + 2, + 2, + 2, + 2, + 1, + 2, + 2, + 2, + 2, + 2, + 2, + 1 + ]; + DES.prototype.deriveKeys = function deriveKeys(state2, key2) { + state2.keys = new Array(16 * 2); + assert.equal(key2.length, this.blockSize, "Invalid key length"); + var kL = utils2.readUInt32BE(key2, 0); + var kR = utils2.readUInt32BE(key2, 4); + utils2.pc1(kL, kR, state2.tmp, 0); + kL = state2.tmp[0]; + kR = state2.tmp[1]; + for (var i2 = 0; i2 < state2.keys.length; i2 += 2) { + var shift = shiftTable[i2 >>> 1]; + kL = utils2.r28shl(kL, shift); + kR = utils2.r28shl(kR, shift); + utils2.pc2(kL, kR, state2.keys, i2); + } + }; + DES.prototype._update = function _update(inp, inOff, out, outOff) { + var state2 = this._desState; + var l = utils2.readUInt32BE(inp, inOff); + var r = utils2.readUInt32BE(inp, inOff + 4); + utils2.ip(l, r, state2.tmp, 0); + l = state2.tmp[0]; + r = state2.tmp[1]; + if (this.type === "encrypt") + this._encrypt(state2, l, r, state2.tmp, 0); + else + this._decrypt(state2, l, r, state2.tmp, 0); + l = state2.tmp[0]; + r = state2.tmp[1]; + utils2.writeUInt32BE(out, l, outOff); + utils2.writeUInt32BE(out, r, outOff + 4); + }; + DES.prototype._pad = function _pad(buffer2, off) { + if (this.padding === false) { + return false; + } + var value = buffer2.length - off; + for (var i2 = off; i2 < buffer2.length; i2++) + buffer2[i2] = value; + return true; + }; + DES.prototype._unpad = function _unpad(buffer2) { + if (this.padding === false) { + return buffer2; + } + var pad = buffer2[buffer2.length - 1]; + for (var i2 = buffer2.length - pad; i2 < buffer2.length; i2++) + assert.equal(buffer2[i2], pad); + return buffer2.slice(0, buffer2.length - pad); + }; + DES.prototype._encrypt = function _encrypt(state2, lStart, rStart, out, off) { + var l = lStart; + var r = rStart; + for (var i2 = 0; i2 < state2.keys.length; i2 += 2) { + var keyL = state2.keys[i2]; + var keyR = state2.keys[i2 + 1]; + utils2.expand(r, state2.tmp, 0); + keyL ^= state2.tmp[0]; + keyR ^= state2.tmp[1]; + var s = utils2.substitute(keyL, keyR); + var f = utils2.permute(s); + var t = r; + r = (l ^ f) >>> 0; + l = t; + } + utils2.rip(r, l, out, off); + }; + DES.prototype._decrypt = function _decrypt(state2, lStart, rStart, out, off) { + var l = rStart; + var r = lStart; + for (var i2 = state2.keys.length - 2; i2 >= 0; i2 -= 2) { + var keyL = state2.keys[i2]; + var keyR = state2.keys[i2 + 1]; + utils2.expand(l, state2.tmp, 0); + keyL ^= state2.tmp[0]; + keyR ^= state2.tmp[1]; + var s = utils2.substitute(keyL, keyR); + var f = utils2.permute(s); + var t = l; + l = (r ^ f) >>> 0; + r = t; + } + utils2.rip(l, r, out, off); + }; + return des; +} +var cbc$1 = {}; +var hasRequiredCbc$1; +function requireCbc$1() { + if (hasRequiredCbc$1) return cbc$1; + hasRequiredCbc$1 = 1; + var assert = requireMinimalisticAssert(); + var inherits = requireInherits_browser(); + var proto = {}; + function CBCState(iv) { + assert.equal(iv.length, 8, "Invalid IV length"); + this.iv = new Array(8); + for (var i2 = 0; i2 < this.iv.length; i2++) + this.iv[i2] = iv[i2]; + } + function instantiate(Base) { + function CBC(options) { + Base.call(this, options); + this._cbcInit(); + } + inherits(CBC, Base); + var keys = Object.keys(proto); + for (var i2 = 0; i2 < keys.length; i2++) { + var key2 = keys[i2]; + CBC.prototype[key2] = proto[key2]; + } + CBC.create = function create(options) { + return new CBC(options); + }; + return CBC; + } + cbc$1.instantiate = instantiate; + proto._cbcInit = function _cbcInit() { + var state2 = new CBCState(this.options.iv); + this._cbcState = state2; + }; + proto._update = function _update(inp, inOff, out, outOff) { + var state2 = this._cbcState; + var superProto = this.constructor.super_.prototype; + var iv = state2.iv; + if (this.type === "encrypt") { + for (var i2 = 0; i2 < this.blockSize; i2++) + iv[i2] ^= inp[inOff + i2]; + superProto._update.call(this, iv, 0, out, outOff); + for (var i2 = 0; i2 < this.blockSize; i2++) + iv[i2] = out[outOff + i2]; + } else { + superProto._update.call(this, inp, inOff, out, outOff); + for (var i2 = 0; i2 < this.blockSize; i2++) + out[outOff + i2] ^= iv[i2]; + for (var i2 = 0; i2 < this.blockSize; i2++) + iv[i2] = inp[inOff + i2]; + } + }; + return cbc$1; +} +var ede; +var hasRequiredEde; +function requireEde() { + if (hasRequiredEde) return ede; + hasRequiredEde = 1; + var assert = requireMinimalisticAssert(); + var inherits = requireInherits_browser(); + var Cipher = requireCipher(); + var DES = requireDes$1(); + function EDEState(type2, key2) { + assert.equal(key2.length, 24, "Invalid key length"); + var k1 = key2.slice(0, 8); + var k2 = key2.slice(8, 16); + var k3 = key2.slice(16, 24); + if (type2 === "encrypt") { + this.ciphers = [ + DES.create({ type: "encrypt", key: k1 }), + DES.create({ type: "decrypt", key: k2 }), + DES.create({ type: "encrypt", key: k3 }) + ]; + } else { + this.ciphers = [ + DES.create({ type: "decrypt", key: k3 }), + DES.create({ type: "encrypt", key: k2 }), + DES.create({ type: "decrypt", key: k1 }) + ]; + } + } + function EDE(options) { + Cipher.call(this, options); + var state2 = new EDEState(this.type, this.options.key); + this._edeState = state2; + } + inherits(EDE, Cipher); + ede = EDE; + EDE.create = function create(options) { + return new EDE(options); + }; + EDE.prototype._update = function _update(inp, inOff, out, outOff) { + var state2 = this._edeState; + state2.ciphers[0]._update(inp, inOff, out, outOff); + state2.ciphers[1]._update(out, outOff, out, outOff); + state2.ciphers[2]._update(out, outOff, out, outOff); + }; + EDE.prototype._pad = DES.prototype._pad; + EDE.prototype._unpad = DES.prototype._unpad; + return ede; +} +var hasRequiredDes; +function requireDes() { + if (hasRequiredDes) return des$1; + hasRequiredDes = 1; + des$1.utils = requireUtils$3(); + des$1.Cipher = requireCipher(); + des$1.DES = requireDes$1(); + des$1.CBC = requireCbc$1(); + des$1.EDE = requireEde(); + return des$1; +} +var browserifyDes; +var hasRequiredBrowserifyDes; +function requireBrowserifyDes() { + if (hasRequiredBrowserifyDes) return browserifyDes; + hasRequiredBrowserifyDes = 1; + var CipherBase = requireCipherBase(); + var des2 = requireDes(); + var inherits = requireInherits_browser(); + var Buffer2 = requireSafeBuffer$1().Buffer; + var modes2 = { + "des-ede3-cbc": des2.CBC.instantiate(des2.EDE), + "des-ede3": des2.EDE, + "des-ede-cbc": des2.CBC.instantiate(des2.EDE), + "des-ede": des2.EDE, + "des-cbc": des2.CBC.instantiate(des2.DES), + "des-ecb": des2.DES + }; + modes2.des = modes2["des-cbc"]; + modes2.des3 = modes2["des-ede3-cbc"]; + browserifyDes = DES; + inherits(DES, CipherBase); + function DES(opts) { + CipherBase.call(this); + var modeName = opts.mode.toLowerCase(); + var mode = modes2[modeName]; + var type2; + if (opts.decrypt) { + type2 = "decrypt"; + } else { + type2 = "encrypt"; + } + var key2 = opts.key; + if (!Buffer2.isBuffer(key2)) { + key2 = Buffer2.from(key2); + } + if (modeName === "des-ede" || modeName === "des-ede-cbc") { + key2 = Buffer2.concat([key2, key2.slice(0, 8)]); + } + var iv = opts.iv; + if (!Buffer2.isBuffer(iv)) { + iv = Buffer2.from(iv); + } + this._des = mode.create({ + key: key2, + iv, + type: type2 + }); + } + DES.prototype._update = function(data) { + return Buffer2.from(this._des.update(data)); + }; + DES.prototype._final = function() { + return Buffer2.from(this._des.final()); + }; + return browserifyDes; +} +var browser$5 = {}; +var encrypter = {}; +var ecb = {}; +var hasRequiredEcb; +function requireEcb() { + if (hasRequiredEcb) return ecb; + hasRequiredEcb = 1; + ecb.encrypt = function(self2, block2) { + return self2._cipher.encryptBlock(block2); + }; + ecb.decrypt = function(self2, block2) { + return self2._cipher.decryptBlock(block2); + }; + return ecb; +} +var cbc = {}; +var bufferXor; +var hasRequiredBufferXor; +function requireBufferXor() { + if (hasRequiredBufferXor) return bufferXor; + hasRequiredBufferXor = 1; + bufferXor = function xor2(a, b) { + var length = Math.min(a.length, b.length); + var buffer2 = new Buffer(length); + for (var i2 = 0; i2 < length; ++i2) { + buffer2[i2] = a[i2] ^ b[i2]; + } + return buffer2; + }; + return bufferXor; +} +var hasRequiredCbc; +function requireCbc() { + if (hasRequiredCbc) return cbc; + hasRequiredCbc = 1; + var xor2 = requireBufferXor(); + cbc.encrypt = function(self2, block2) { + var data = xor2(block2, self2._prev); + self2._prev = self2._cipher.encryptBlock(data); + return self2._prev; + }; + cbc.decrypt = function(self2, block2) { + var pad = self2._prev; + self2._prev = block2; + var out = self2._cipher.decryptBlock(block2); + return xor2(out, pad); + }; + return cbc; +} +var cfb = {}; +var hasRequiredCfb; +function requireCfb() { + if (hasRequiredCfb) return cfb; + hasRequiredCfb = 1; + var Buffer2 = requireSafeBuffer$1().Buffer; + var xor2 = requireBufferXor(); + function encryptStart(self2, data, decrypt) { + var len2 = data.length; + var out = xor2(data, self2._cache); + self2._cache = self2._cache.slice(len2); + self2._prev = Buffer2.concat([self2._prev, decrypt ? data : out]); + return out; + } + cfb.encrypt = function(self2, data, decrypt) { + var out = Buffer2.allocUnsafe(0); + var len2; + while (data.length) { + if (self2._cache.length === 0) { + self2._cache = self2._cipher.encryptBlock(self2._prev); + self2._prev = Buffer2.allocUnsafe(0); + } + if (self2._cache.length <= data.length) { + len2 = self2._cache.length; + out = Buffer2.concat([out, encryptStart(self2, data.slice(0, len2), decrypt)]); + data = data.slice(len2); + } else { + out = Buffer2.concat([out, encryptStart(self2, data, decrypt)]); + break; + } + } + return out; + }; + return cfb; +} +var cfb8 = {}; +var hasRequiredCfb8; +function requireCfb8() { + if (hasRequiredCfb8) return cfb8; + hasRequiredCfb8 = 1; + var Buffer2 = requireSafeBuffer$1().Buffer; + function encryptByte(self2, byteParam, decrypt) { + var pad = self2._cipher.encryptBlock(self2._prev); + var out = pad[0] ^ byteParam; + self2._prev = Buffer2.concat([ + self2._prev.slice(1), + Buffer2.from([decrypt ? byteParam : out]) + ]); + return out; + } + cfb8.encrypt = function(self2, chunk2, decrypt) { + var len2 = chunk2.length; + var out = Buffer2.allocUnsafe(len2); + var i2 = -1; + while (++i2 < len2) { + out[i2] = encryptByte(self2, chunk2[i2], decrypt); + } + return out; + }; + return cfb8; +} +var cfb1 = {}; +var hasRequiredCfb1; +function requireCfb1() { + if (hasRequiredCfb1) return cfb1; + hasRequiredCfb1 = 1; + var Buffer2 = requireSafeBuffer$1().Buffer; + function encryptByte(self2, byteParam, decrypt) { + var pad; + var i2 = -1; + var len2 = 8; + var out = 0; + var bit, value; + while (++i2 < len2) { + pad = self2._cipher.encryptBlock(self2._prev); + bit = byteParam & 1 << 7 - i2 ? 128 : 0; + value = pad[0] ^ bit; + out += (value & 128) >> i2 % 8; + self2._prev = shiftIn(self2._prev, decrypt ? bit : value); + } + return out; + } + function shiftIn(buffer2, value) { + var len2 = buffer2.length; + var i2 = -1; + var out = Buffer2.allocUnsafe(buffer2.length); + buffer2 = Buffer2.concat([buffer2, Buffer2.from([value])]); + while (++i2 < len2) { + out[i2] = buffer2[i2] << 1 | buffer2[i2 + 1] >> 7; + } + return out; + } + cfb1.encrypt = function(self2, chunk2, decrypt) { + var len2 = chunk2.length; + var out = Buffer2.allocUnsafe(len2); + var i2 = -1; + while (++i2 < len2) { + out[i2] = encryptByte(self2, chunk2[i2], decrypt); + } + return out; + }; + return cfb1; +} +var ofb = {}; +var hasRequiredOfb; +function requireOfb() { + if (hasRequiredOfb) return ofb; + hasRequiredOfb = 1; + var xor2 = requireBufferXor(); + function getBlock(self2) { + self2._prev = self2._cipher.encryptBlock(self2._prev); + return self2._prev; + } + ofb.encrypt = function(self2, chunk2) { + while (self2._cache.length < chunk2.length) { + self2._cache = Buffer.concat([self2._cache, getBlock(self2)]); + } + var pad = self2._cache.slice(0, chunk2.length); + self2._cache = self2._cache.slice(chunk2.length); + return xor2(chunk2, pad); + }; + return ofb; +} +var ctr = {}; +var incr32_1; +var hasRequiredIncr32; +function requireIncr32() { + if (hasRequiredIncr32) return incr32_1; + hasRequiredIncr32 = 1; + function incr32(iv) { + var len2 = iv.length; + var item; + while (len2--) { + item = iv.readUInt8(len2); + if (item === 255) { + iv.writeUInt8(0, len2); + } else { + item++; + iv.writeUInt8(item, len2); + break; + } + } + } + incr32_1 = incr32; + return incr32_1; +} +var hasRequiredCtr; +function requireCtr() { + if (hasRequiredCtr) return ctr; + hasRequiredCtr = 1; + var xor2 = requireBufferXor(); + var Buffer2 = requireSafeBuffer$1().Buffer; + var incr32 = requireIncr32(); + function getBlock(self2) { + var out = self2._cipher.encryptBlockRaw(self2._prev); + incr32(self2._prev); + return out; + } + var blockSize = 16; + ctr.encrypt = function(self2, chunk2) { + var chunkNum = Math.ceil(chunk2.length / blockSize); + var start = self2._cache.length; + self2._cache = Buffer2.concat([ + self2._cache, + Buffer2.allocUnsafe(chunkNum * blockSize) + ]); + for (var i2 = 0; i2 < chunkNum; i2++) { + var out = getBlock(self2); + var offset = start + i2 * blockSize; + self2._cache.writeUInt32BE(out[0], offset + 0); + self2._cache.writeUInt32BE(out[1], offset + 4); + self2._cache.writeUInt32BE(out[2], offset + 8); + self2._cache.writeUInt32BE(out[3], offset + 12); + } + var pad = self2._cache.slice(0, chunk2.length); + self2._cache = self2._cache.slice(chunk2.length); + return xor2(chunk2, pad); + }; + return ctr; +} +const aes128 = { "cipher": "AES", "key": 128, "iv": 16, "mode": "CBC", "type": "block" }; +const aes192 = { "cipher": "AES", "key": 192, "iv": 16, "mode": "CBC", "type": "block" }; +const aes256 = { "cipher": "AES", "key": 256, "iv": 16, "mode": "CBC", "type": "block" }; +const require$$2 = { + "aes-128-ecb": { "cipher": "AES", "key": 128, "iv": 0, "mode": "ECB", "type": "block" }, + "aes-192-ecb": { "cipher": "AES", "key": 192, "iv": 0, "mode": "ECB", "type": "block" }, + "aes-256-ecb": { "cipher": "AES", "key": 256, "iv": 0, "mode": "ECB", "type": "block" }, + "aes-128-cbc": { "cipher": "AES", "key": 128, "iv": 16, "mode": "CBC", "type": "block" }, + "aes-192-cbc": { "cipher": "AES", "key": 192, "iv": 16, "mode": "CBC", "type": "block" }, + "aes-256-cbc": { "cipher": "AES", "key": 256, "iv": 16, "mode": "CBC", "type": "block" }, + aes128, + aes192, + aes256, + "aes-128-cfb": { "cipher": "AES", "key": 128, "iv": 16, "mode": "CFB", "type": "stream" }, + "aes-192-cfb": { "cipher": "AES", "key": 192, "iv": 16, "mode": "CFB", "type": "stream" }, + "aes-256-cfb": { "cipher": "AES", "key": 256, "iv": 16, "mode": "CFB", "type": "stream" }, + "aes-128-cfb8": { "cipher": "AES", "key": 128, "iv": 16, "mode": "CFB8", "type": "stream" }, + "aes-192-cfb8": { "cipher": "AES", "key": 192, "iv": 16, "mode": "CFB8", "type": "stream" }, + "aes-256-cfb8": { "cipher": "AES", "key": 256, "iv": 16, "mode": "CFB8", "type": "stream" }, + "aes-128-cfb1": { "cipher": "AES", "key": 128, "iv": 16, "mode": "CFB1", "type": "stream" }, + "aes-192-cfb1": { "cipher": "AES", "key": 192, "iv": 16, "mode": "CFB1", "type": "stream" }, + "aes-256-cfb1": { "cipher": "AES", "key": 256, "iv": 16, "mode": "CFB1", "type": "stream" }, + "aes-128-ofb": { "cipher": "AES", "key": 128, "iv": 16, "mode": "OFB", "type": "stream" }, + "aes-192-ofb": { "cipher": "AES", "key": 192, "iv": 16, "mode": "OFB", "type": "stream" }, + "aes-256-ofb": { "cipher": "AES", "key": 256, "iv": 16, "mode": "OFB", "type": "stream" }, + "aes-128-ctr": { "cipher": "AES", "key": 128, "iv": 16, "mode": "CTR", "type": "stream" }, + "aes-192-ctr": { "cipher": "AES", "key": 192, "iv": 16, "mode": "CTR", "type": "stream" }, + "aes-256-ctr": { "cipher": "AES", "key": 256, "iv": 16, "mode": "CTR", "type": "stream" }, + "aes-128-gcm": { "cipher": "AES", "key": 128, "iv": 12, "mode": "GCM", "type": "auth" }, + "aes-192-gcm": { "cipher": "AES", "key": 192, "iv": 12, "mode": "GCM", "type": "auth" }, + "aes-256-gcm": { "cipher": "AES", "key": 256, "iv": 12, "mode": "GCM", "type": "auth" } +}; +var modes_1; +var hasRequiredModes$1; +function requireModes$1() { + if (hasRequiredModes$1) return modes_1; + hasRequiredModes$1 = 1; + var modeModules = { + ECB: requireEcb(), + CBC: requireCbc(), + CFB: requireCfb(), + CFB8: requireCfb8(), + CFB1: requireCfb1(), + OFB: requireOfb(), + CTR: requireCtr(), + GCM: requireCtr() + }; + var modes2 = require$$2; + for (var key2 in modes2) { + modes2[key2].module = modeModules[modes2[key2].mode]; + } + modes_1 = modes2; + return modes_1; +} +var aes = {}; +var hasRequiredAes; +function requireAes() { + if (hasRequiredAes) return aes; + hasRequiredAes = 1; + var Buffer2 = requireSafeBuffer$1().Buffer; + function asUInt32Array(buf) { + if (!Buffer2.isBuffer(buf)) buf = Buffer2.from(buf); + var len2 = buf.length / 4 | 0; + var out = new Array(len2); + for (var i2 = 0; i2 < len2; i2++) { + out[i2] = buf.readUInt32BE(i2 * 4); + } + return out; + } + function scrubVec(v) { + for (var i2 = 0; i2 < v.length; v++) { + v[i2] = 0; + } + } + function cryptBlock(M, keySchedule, SUB_MIX, SBOX, nRounds) { + var SUB_MIX0 = SUB_MIX[0]; + var SUB_MIX1 = SUB_MIX[1]; + var SUB_MIX2 = SUB_MIX[2]; + var SUB_MIX3 = SUB_MIX[3]; + var s0 = M[0] ^ keySchedule[0]; + var s1 = M[1] ^ keySchedule[1]; + var s2 = M[2] ^ keySchedule[2]; + var s3 = M[3] ^ keySchedule[3]; + var t0, t1, t2, t3; + var ksRow = 4; + for (var round = 1; round < nRounds; round++) { + t0 = SUB_MIX0[s0 >>> 24] ^ SUB_MIX1[s1 >>> 16 & 255] ^ SUB_MIX2[s2 >>> 8 & 255] ^ SUB_MIX3[s3 & 255] ^ keySchedule[ksRow++]; + t1 = SUB_MIX0[s1 >>> 24] ^ SUB_MIX1[s2 >>> 16 & 255] ^ SUB_MIX2[s3 >>> 8 & 255] ^ SUB_MIX3[s0 & 255] ^ keySchedule[ksRow++]; + t2 = SUB_MIX0[s2 >>> 24] ^ SUB_MIX1[s3 >>> 16 & 255] ^ SUB_MIX2[s0 >>> 8 & 255] ^ SUB_MIX3[s1 & 255] ^ keySchedule[ksRow++]; + t3 = SUB_MIX0[s3 >>> 24] ^ SUB_MIX1[s0 >>> 16 & 255] ^ SUB_MIX2[s1 >>> 8 & 255] ^ SUB_MIX3[s2 & 255] ^ keySchedule[ksRow++]; + s0 = t0; + s1 = t1; + s2 = t2; + s3 = t3; + } + t0 = (SBOX[s0 >>> 24] << 24 | SBOX[s1 >>> 16 & 255] << 16 | SBOX[s2 >>> 8 & 255] << 8 | SBOX[s3 & 255]) ^ keySchedule[ksRow++]; + t1 = (SBOX[s1 >>> 24] << 24 | SBOX[s2 >>> 16 & 255] << 16 | SBOX[s3 >>> 8 & 255] << 8 | SBOX[s0 & 255]) ^ keySchedule[ksRow++]; + t2 = (SBOX[s2 >>> 24] << 24 | SBOX[s3 >>> 16 & 255] << 16 | SBOX[s0 >>> 8 & 255] << 8 | SBOX[s1 & 255]) ^ keySchedule[ksRow++]; + t3 = (SBOX[s3 >>> 24] << 24 | SBOX[s0 >>> 16 & 255] << 16 | SBOX[s1 >>> 8 & 255] << 8 | SBOX[s2 & 255]) ^ keySchedule[ksRow++]; + t0 = t0 >>> 0; + t1 = t1 >>> 0; + t2 = t2 >>> 0; + t3 = t3 >>> 0; + return [t0, t1, t2, t3]; + } + var RCON = [0, 1, 2, 4, 8, 16, 32, 64, 128, 27, 54]; + var G = function() { + var d = new Array(256); + for (var j = 0; j < 256; j++) { + if (j < 128) { + d[j] = j << 1; + } else { + d[j] = j << 1 ^ 283; + } + } + var SBOX = []; + var INV_SBOX = []; + var SUB_MIX = [[], [], [], []]; + var INV_SUB_MIX = [[], [], [], []]; + var x = 0; + var xi = 0; + for (var i2 = 0; i2 < 256; ++i2) { + var sx = xi ^ xi << 1 ^ xi << 2 ^ xi << 3 ^ xi << 4; + sx = sx >>> 8 ^ sx & 255 ^ 99; + SBOX[x] = sx; + INV_SBOX[sx] = x; + var x2 = d[x]; + var x4 = d[x2]; + var x8 = d[x4]; + var t = d[sx] * 257 ^ sx * 16843008; + SUB_MIX[0][x] = t << 24 | t >>> 8; + SUB_MIX[1][x] = t << 16 | t >>> 16; + SUB_MIX[2][x] = t << 8 | t >>> 24; + SUB_MIX[3][x] = t; + t = x8 * 16843009 ^ x4 * 65537 ^ x2 * 257 ^ x * 16843008; + INV_SUB_MIX[0][sx] = t << 24 | t >>> 8; + INV_SUB_MIX[1][sx] = t << 16 | t >>> 16; + INV_SUB_MIX[2][sx] = t << 8 | t >>> 24; + INV_SUB_MIX[3][sx] = t; + if (x === 0) { + x = xi = 1; + } else { + x = x2 ^ d[d[d[x8 ^ x2]]]; + xi ^= d[d[xi]]; + } + } + return { + SBOX, + INV_SBOX, + SUB_MIX, + INV_SUB_MIX + }; + }(); + function AES(key2) { + this._key = asUInt32Array(key2); + this._reset(); + } + AES.blockSize = 4 * 4; + AES.keySize = 256 / 8; + AES.prototype.blockSize = AES.blockSize; + AES.prototype.keySize = AES.keySize; + AES.prototype._reset = function() { + var keyWords = this._key; + var keySize = keyWords.length; + var nRounds = keySize + 6; + var ksRows = (nRounds + 1) * 4; + var keySchedule = []; + for (var k = 0; k < keySize; k++) { + keySchedule[k] = keyWords[k]; + } + for (k = keySize; k < ksRows; k++) { + var t = keySchedule[k - 1]; + if (k % keySize === 0) { + t = t << 8 | t >>> 24; + t = G.SBOX[t >>> 24] << 24 | G.SBOX[t >>> 16 & 255] << 16 | G.SBOX[t >>> 8 & 255] << 8 | G.SBOX[t & 255]; + t ^= RCON[k / keySize | 0] << 24; + } else if (keySize > 6 && k % keySize === 4) { + t = G.SBOX[t >>> 24] << 24 | G.SBOX[t >>> 16 & 255] << 16 | G.SBOX[t >>> 8 & 255] << 8 | G.SBOX[t & 255]; + } + keySchedule[k] = keySchedule[k - keySize] ^ t; + } + var invKeySchedule = []; + for (var ik = 0; ik < ksRows; ik++) { + var ksR = ksRows - ik; + var tt = keySchedule[ksR - (ik % 4 ? 0 : 4)]; + if (ik < 4 || ksR <= 4) { + invKeySchedule[ik] = tt; + } else { + invKeySchedule[ik] = G.INV_SUB_MIX[0][G.SBOX[tt >>> 24]] ^ G.INV_SUB_MIX[1][G.SBOX[tt >>> 16 & 255]] ^ G.INV_SUB_MIX[2][G.SBOX[tt >>> 8 & 255]] ^ G.INV_SUB_MIX[3][G.SBOX[tt & 255]]; + } + } + this._nRounds = nRounds; + this._keySchedule = keySchedule; + this._invKeySchedule = invKeySchedule; + }; + AES.prototype.encryptBlockRaw = function(M) { + M = asUInt32Array(M); + return cryptBlock(M, this._keySchedule, G.SUB_MIX, G.SBOX, this._nRounds); + }; + AES.prototype.encryptBlock = function(M) { + var out = this.encryptBlockRaw(M); + var buf = Buffer2.allocUnsafe(16); + buf.writeUInt32BE(out[0], 0); + buf.writeUInt32BE(out[1], 4); + buf.writeUInt32BE(out[2], 8); + buf.writeUInt32BE(out[3], 12); + return buf; + }; + AES.prototype.decryptBlock = function(M) { + M = asUInt32Array(M); + var m1 = M[1]; + M[1] = M[3]; + M[3] = m1; + var out = cryptBlock(M, this._invKeySchedule, G.INV_SUB_MIX, G.INV_SBOX, this._nRounds); + var buf = Buffer2.allocUnsafe(16); + buf.writeUInt32BE(out[0], 0); + buf.writeUInt32BE(out[3], 4); + buf.writeUInt32BE(out[2], 8); + buf.writeUInt32BE(out[1], 12); + return buf; + }; + AES.prototype.scrub = function() { + scrubVec(this._keySchedule); + scrubVec(this._invKeySchedule); + scrubVec(this._key); + }; + aes.AES = AES; + return aes; +} +var ghash; +var hasRequiredGhash; +function requireGhash() { + if (hasRequiredGhash) return ghash; + hasRequiredGhash = 1; + var Buffer2 = requireSafeBuffer$1().Buffer; + var ZEROES = Buffer2.alloc(16, 0); + function toArray(buf) { + return [ + buf.readUInt32BE(0), + buf.readUInt32BE(4), + buf.readUInt32BE(8), + buf.readUInt32BE(12) + ]; + } + function fromArray(out) { + var buf = Buffer2.allocUnsafe(16); + buf.writeUInt32BE(out[0] >>> 0, 0); + buf.writeUInt32BE(out[1] >>> 0, 4); + buf.writeUInt32BE(out[2] >>> 0, 8); + buf.writeUInt32BE(out[3] >>> 0, 12); + return buf; + } + function GHASH(key2) { + this.h = key2; + this.state = Buffer2.alloc(16, 0); + this.cache = Buffer2.allocUnsafe(0); + } + GHASH.prototype.ghash = function(block2) { + var i2 = -1; + while (++i2 < block2.length) { + this.state[i2] ^= block2[i2]; + } + this._multiply(); + }; + GHASH.prototype._multiply = function() { + var Vi = toArray(this.h); + var Zi = [0, 0, 0, 0]; + var j, xi, lsbVi; + var i2 = -1; + while (++i2 < 128) { + xi = (this.state[~~(i2 / 8)] & 1 << 7 - i2 % 8) !== 0; + if (xi) { + Zi[0] ^= Vi[0]; + Zi[1] ^= Vi[1]; + Zi[2] ^= Vi[2]; + Zi[3] ^= Vi[3]; + } + lsbVi = (Vi[3] & 1) !== 0; + for (j = 3; j > 0; j--) { + Vi[j] = Vi[j] >>> 1 | (Vi[j - 1] & 1) << 31; + } + Vi[0] = Vi[0] >>> 1; + if (lsbVi) { + Vi[0] = Vi[0] ^ 225 << 24; + } + } + this.state = fromArray(Zi); + }; + GHASH.prototype.update = function(buf) { + this.cache = Buffer2.concat([this.cache, buf]); + var chunk2; + while (this.cache.length >= 16) { + chunk2 = this.cache.slice(0, 16); + this.cache = this.cache.slice(16); + this.ghash(chunk2); + } + }; + GHASH.prototype.final = function(abl, bl) { + if (this.cache.length) { + this.ghash(Buffer2.concat([this.cache, ZEROES], 16)); + } + this.ghash(fromArray([0, abl, 0, bl])); + return this.state; + }; + ghash = GHASH; + return ghash; +} +var authCipher; +var hasRequiredAuthCipher; +function requireAuthCipher() { + if (hasRequiredAuthCipher) return authCipher; + hasRequiredAuthCipher = 1; + var aes2 = requireAes(); + var Buffer2 = requireSafeBuffer$1().Buffer; + var Transform = requireCipherBase(); + var inherits = requireInherits_browser(); + var GHASH = requireGhash(); + var xor2 = requireBufferXor(); + var incr32 = requireIncr32(); + function xorTest(a, b) { + var out = 0; + if (a.length !== b.length) out++; + var len2 = Math.min(a.length, b.length); + for (var i2 = 0; i2 < len2; ++i2) { + out += a[i2] ^ b[i2]; + } + return out; + } + function calcIv(self2, iv, ck) { + if (iv.length === 12) { + self2._finID = Buffer2.concat([iv, Buffer2.from([0, 0, 0, 1])]); + return Buffer2.concat([iv, Buffer2.from([0, 0, 0, 2])]); + } + var ghash2 = new GHASH(ck); + var len2 = iv.length; + var toPad = len2 % 16; + ghash2.update(iv); + if (toPad) { + toPad = 16 - toPad; + ghash2.update(Buffer2.alloc(toPad, 0)); + } + ghash2.update(Buffer2.alloc(8, 0)); + var ivBits = len2 * 8; + var tail = Buffer2.alloc(8); + tail.writeUIntBE(ivBits, 0, 8); + ghash2.update(tail); + self2._finID = ghash2.state; + var out = Buffer2.from(self2._finID); + incr32(out); + return out; + } + function StreamCipher(mode, key2, iv, decrypt) { + Transform.call(this); + var h = Buffer2.alloc(4, 0); + this._cipher = new aes2.AES(key2); + var ck = this._cipher.encryptBlock(h); + this._ghash = new GHASH(ck); + iv = calcIv(this, iv, ck); + this._prev = Buffer2.from(iv); + this._cache = Buffer2.allocUnsafe(0); + this._secCache = Buffer2.allocUnsafe(0); + this._decrypt = decrypt; + this._alen = 0; + this._len = 0; + this._mode = mode; + this._authTag = null; + this._called = false; + } + inherits(StreamCipher, Transform); + StreamCipher.prototype._update = function(chunk2) { + if (!this._called && this._alen) { + var rump = 16 - this._alen % 16; + if (rump < 16) { + rump = Buffer2.alloc(rump, 0); + this._ghash.update(rump); + } + } + this._called = true; + var out = this._mode.encrypt(this, chunk2); + if (this._decrypt) { + this._ghash.update(chunk2); + } else { + this._ghash.update(out); + } + this._len += chunk2.length; + return out; + }; + StreamCipher.prototype._final = function() { + if (this._decrypt && !this._authTag) throw new Error("Unsupported state or unable to authenticate data"); + var tag = xor2(this._ghash.final(this._alen * 8, this._len * 8), this._cipher.encryptBlock(this._finID)); + if (this._decrypt && xorTest(tag, this._authTag)) throw new Error("Unsupported state or unable to authenticate data"); + this._authTag = tag; + this._cipher.scrub(); + }; + StreamCipher.prototype.getAuthTag = function getAuthTag() { + if (this._decrypt || !Buffer2.isBuffer(this._authTag)) throw new Error("Attempting to get auth tag in unsupported state"); + return this._authTag; + }; + StreamCipher.prototype.setAuthTag = function setAuthTag(tag) { + if (!this._decrypt) throw new Error("Attempting to set auth tag in unsupported state"); + this._authTag = tag; + }; + StreamCipher.prototype.setAAD = function setAAD(buf) { + if (this._called) throw new Error("Attempting to set AAD in unsupported state"); + this._ghash.update(buf); + this._alen += buf.length; + }; + authCipher = StreamCipher; + return authCipher; +} +var streamCipher; +var hasRequiredStreamCipher; +function requireStreamCipher() { + if (hasRequiredStreamCipher) return streamCipher; + hasRequiredStreamCipher = 1; + var aes2 = requireAes(); + var Buffer2 = requireSafeBuffer$1().Buffer; + var Transform = requireCipherBase(); + var inherits = requireInherits_browser(); + function StreamCipher(mode, key2, iv, decrypt) { + Transform.call(this); + this._cipher = new aes2.AES(key2); + this._prev = Buffer2.from(iv); + this._cache = Buffer2.allocUnsafe(0); + this._secCache = Buffer2.allocUnsafe(0); + this._decrypt = decrypt; + this._mode = mode; + } + inherits(StreamCipher, Transform); + StreamCipher.prototype._update = function(chunk2) { + return this._mode.encrypt(this, chunk2, this._decrypt); + }; + StreamCipher.prototype._final = function() { + this._cipher.scrub(); + }; + streamCipher = StreamCipher; + return streamCipher; +} +var evp_bytestokey; +var hasRequiredEvp_bytestokey; +function requireEvp_bytestokey() { + if (hasRequiredEvp_bytestokey) return evp_bytestokey; + hasRequiredEvp_bytestokey = 1; + var Buffer2 = requireSafeBuffer$1().Buffer; + var MD5 = requireMd5_js(); + function EVP_BytesToKey(password, salt, keyBits, ivLen) { + if (!Buffer2.isBuffer(password)) password = Buffer2.from(password, "binary"); + if (salt) { + if (!Buffer2.isBuffer(salt)) salt = Buffer2.from(salt, "binary"); + if (salt.length !== 8) throw new RangeError("salt should be Buffer with 8 byte length"); + } + var keyLen = keyBits / 8; + var key2 = Buffer2.alloc(keyLen); + var iv = Buffer2.alloc(ivLen || 0); + var tmp = Buffer2.alloc(0); + while (keyLen > 0 || ivLen > 0) { + var hash2 = new MD5(); + hash2.update(tmp); + hash2.update(password); + if (salt) hash2.update(salt); + tmp = hash2.digest(); + var used = 0; + if (keyLen > 0) { + var keyStart = key2.length - keyLen; + used = Math.min(keyLen, tmp.length); + tmp.copy(key2, keyStart, 0, used); + keyLen -= used; + } + if (used < tmp.length && ivLen > 0) { + var ivStart = iv.length - ivLen; + var length = Math.min(ivLen, tmp.length - used); + tmp.copy(iv, ivStart, used, used + length); + ivLen -= length; + } + } + tmp.fill(0); + return { key: key2, iv }; + } + evp_bytestokey = EVP_BytesToKey; + return evp_bytestokey; +} +var hasRequiredEncrypter; +function requireEncrypter() { + if (hasRequiredEncrypter) return encrypter; + hasRequiredEncrypter = 1; + var MODES = requireModes$1(); + var AuthCipher = requireAuthCipher(); + var Buffer2 = requireSafeBuffer$1().Buffer; + var StreamCipher = requireStreamCipher(); + var Transform = requireCipherBase(); + var aes2 = requireAes(); + var ebtk = requireEvp_bytestokey(); + var inherits = requireInherits_browser(); + function Cipher(mode, key2, iv) { + Transform.call(this); + this._cache = new Splitter(); + this._cipher = new aes2.AES(key2); + this._prev = Buffer2.from(iv); + this._mode = mode; + this._autopadding = true; + } + inherits(Cipher, Transform); + Cipher.prototype._update = function(data) { + this._cache.add(data); + var chunk2; + var thing; + var out = []; + while (chunk2 = this._cache.get()) { + thing = this._mode.encrypt(this, chunk2); + out.push(thing); + } + return Buffer2.concat(out); + }; + var PADDING = Buffer2.alloc(16, 16); + Cipher.prototype._final = function() { + var chunk2 = this._cache.flush(); + if (this._autopadding) { + chunk2 = this._mode.encrypt(this, chunk2); + this._cipher.scrub(); + return chunk2; + } + if (!chunk2.equals(PADDING)) { + this._cipher.scrub(); + throw new Error("data not multiple of block length"); + } + }; + Cipher.prototype.setAutoPadding = function(setTo) { + this._autopadding = !!setTo; + return this; + }; + function Splitter() { + this.cache = Buffer2.allocUnsafe(0); + } + Splitter.prototype.add = function(data) { + this.cache = Buffer2.concat([this.cache, data]); + }; + Splitter.prototype.get = function() { + if (this.cache.length > 15) { + var out = this.cache.slice(0, 16); + this.cache = this.cache.slice(16); + return out; + } + return null; + }; + Splitter.prototype.flush = function() { + var len2 = 16 - this.cache.length; + var padBuff = Buffer2.allocUnsafe(len2); + var i2 = -1; + while (++i2 < len2) { + padBuff.writeUInt8(len2, i2); + } + return Buffer2.concat([this.cache, padBuff]); + }; + function createCipheriv(suite, password, iv) { + var config2 = MODES[suite.toLowerCase()]; + if (!config2) throw new TypeError("invalid suite type"); + if (typeof password === "string") password = Buffer2.from(password); + if (password.length !== config2.key / 8) throw new TypeError("invalid key length " + password.length); + if (typeof iv === "string") iv = Buffer2.from(iv); + if (config2.mode !== "GCM" && iv.length !== config2.iv) throw new TypeError("invalid iv length " + iv.length); + if (config2.type === "stream") { + return new StreamCipher(config2.module, password, iv); + } else if (config2.type === "auth") { + return new AuthCipher(config2.module, password, iv); + } + return new Cipher(config2.module, password, iv); + } + function createCipher(suite, password) { + var config2 = MODES[suite.toLowerCase()]; + if (!config2) throw new TypeError("invalid suite type"); + var keys = ebtk(password, false, config2.key, config2.iv); + return createCipheriv(suite, keys.key, keys.iv); + } + encrypter.createCipheriv = createCipheriv; + encrypter.createCipher = createCipher; + return encrypter; +} +var decrypter = {}; +var hasRequiredDecrypter; +function requireDecrypter() { + if (hasRequiredDecrypter) return decrypter; + hasRequiredDecrypter = 1; + var AuthCipher = requireAuthCipher(); + var Buffer2 = requireSafeBuffer$1().Buffer; + var MODES = requireModes$1(); + var StreamCipher = requireStreamCipher(); + var Transform = requireCipherBase(); + var aes2 = requireAes(); + var ebtk = requireEvp_bytestokey(); + var inherits = requireInherits_browser(); + function Decipher(mode, key2, iv) { + Transform.call(this); + this._cache = new Splitter(); + this._last = void 0; + this._cipher = new aes2.AES(key2); + this._prev = Buffer2.from(iv); + this._mode = mode; + this._autopadding = true; + } + inherits(Decipher, Transform); + Decipher.prototype._update = function(data) { + this._cache.add(data); + var chunk2; + var thing; + var out = []; + while (chunk2 = this._cache.get(this._autopadding)) { + thing = this._mode.decrypt(this, chunk2); + out.push(thing); + } + return Buffer2.concat(out); + }; + Decipher.prototype._final = function() { + var chunk2 = this._cache.flush(); + if (this._autopadding) { + return unpad(this._mode.decrypt(this, chunk2)); + } else if (chunk2) { + throw new Error("data not multiple of block length"); + } + }; + Decipher.prototype.setAutoPadding = function(setTo) { + this._autopadding = !!setTo; + return this; + }; + function Splitter() { + this.cache = Buffer2.allocUnsafe(0); + } + Splitter.prototype.add = function(data) { + this.cache = Buffer2.concat([this.cache, data]); + }; + Splitter.prototype.get = function(autoPadding) { + var out; + if (autoPadding) { + if (this.cache.length > 16) { + out = this.cache.slice(0, 16); + this.cache = this.cache.slice(16); + return out; + } + } else { + if (this.cache.length >= 16) { + out = this.cache.slice(0, 16); + this.cache = this.cache.slice(16); + return out; + } + } + return null; + }; + Splitter.prototype.flush = function() { + if (this.cache.length) return this.cache; + }; + function unpad(last) { + var padded = last[15]; + if (padded < 1 || padded > 16) { + throw new Error("unable to decrypt data"); + } + var i2 = -1; + while (++i2 < padded) { + if (last[i2 + (16 - padded)] !== padded) { + throw new Error("unable to decrypt data"); + } + } + if (padded === 16) return; + return last.slice(0, 16 - padded); + } + function createDecipheriv(suite, password, iv) { + var config2 = MODES[suite.toLowerCase()]; + if (!config2) throw new TypeError("invalid suite type"); + if (typeof iv === "string") iv = Buffer2.from(iv); + if (config2.mode !== "GCM" && iv.length !== config2.iv) throw new TypeError("invalid iv length " + iv.length); + if (typeof password === "string") password = Buffer2.from(password); + if (password.length !== config2.key / 8) throw new TypeError("invalid key length " + password.length); + if (config2.type === "stream") { + return new StreamCipher(config2.module, password, iv, true); + } else if (config2.type === "auth") { + return new AuthCipher(config2.module, password, iv, true); + } + return new Decipher(config2.module, password, iv); + } + function createDecipher(suite, password) { + var config2 = MODES[suite.toLowerCase()]; + if (!config2) throw new TypeError("invalid suite type"); + var keys = ebtk(password, false, config2.key, config2.iv); + return createDecipheriv(suite, keys.key, keys.iv); + } + decrypter.createDecipher = createDecipher; + decrypter.createDecipheriv = createDecipheriv; + return decrypter; +} +var hasRequiredBrowser$6; +function requireBrowser$6() { + if (hasRequiredBrowser$6) return browser$5; + hasRequiredBrowser$6 = 1; + var ciphers = requireEncrypter(); + var deciphers = requireDecrypter(); + var modes2 = require$$2; + function getCiphers() { + return Object.keys(modes2); + } + browser$5.createCipher = browser$5.Cipher = ciphers.createCipher; + browser$5.createCipheriv = browser$5.Cipheriv = ciphers.createCipheriv; + browser$5.createDecipher = browser$5.Decipher = deciphers.createDecipher; + browser$5.createDecipheriv = browser$5.Decipheriv = deciphers.createDecipheriv; + browser$5.listCiphers = browser$5.getCiphers = getCiphers; + return browser$5; +} +var modes = {}; +var hasRequiredModes; +function requireModes() { + if (hasRequiredModes) return modes; + hasRequiredModes = 1; + (function(exports2) { + exports2["des-ecb"] = { + key: 8, + iv: 0 + }; + exports2["des-cbc"] = exports2.des = { + key: 8, + iv: 8 + }; + exports2["des-ede3-cbc"] = exports2.des3 = { + key: 24, + iv: 8 + }; + exports2["des-ede3"] = { + key: 24, + iv: 0 + }; + exports2["des-ede-cbc"] = { + key: 16, + iv: 8 + }; + exports2["des-ede"] = { + key: 16, + iv: 0 + }; + })(modes); + return modes; +} +var hasRequiredBrowser$5; +function requireBrowser$5() { + if (hasRequiredBrowser$5) return browser$6; + hasRequiredBrowser$5 = 1; + var DES = requireBrowserifyDes(); + var aes2 = requireBrowser$6(); + var aesModes = requireModes$1(); + var desModes = requireModes(); + var ebtk = requireEvp_bytestokey(); + function createCipher(suite, password) { + suite = suite.toLowerCase(); + var keyLen, ivLen; + if (aesModes[suite]) { + keyLen = aesModes[suite].key; + ivLen = aesModes[suite].iv; + } else if (desModes[suite]) { + keyLen = desModes[suite].key * 8; + ivLen = desModes[suite].iv; + } else { + throw new TypeError("invalid suite type"); + } + var keys = ebtk(password, false, keyLen, ivLen); + return createCipheriv(suite, keys.key, keys.iv); + } + function createDecipher(suite, password) { + suite = suite.toLowerCase(); + var keyLen, ivLen; + if (aesModes[suite]) { + keyLen = aesModes[suite].key; + ivLen = aesModes[suite].iv; + } else if (desModes[suite]) { + keyLen = desModes[suite].key * 8; + ivLen = desModes[suite].iv; + } else { + throw new TypeError("invalid suite type"); + } + var keys = ebtk(password, false, keyLen, ivLen); + return createDecipheriv(suite, keys.key, keys.iv); + } + function createCipheriv(suite, key2, iv) { + suite = suite.toLowerCase(); + if (aesModes[suite]) return aes2.createCipheriv(suite, key2, iv); + if (desModes[suite]) return new DES({ key: key2, iv, mode: suite }); + throw new TypeError("invalid suite type"); + } + function createDecipheriv(suite, key2, iv) { + suite = suite.toLowerCase(); + if (aesModes[suite]) return aes2.createDecipheriv(suite, key2, iv); + if (desModes[suite]) return new DES({ key: key2, iv, mode: suite, decrypt: true }); + throw new TypeError("invalid suite type"); + } + function getCiphers() { + return Object.keys(desModes).concat(aes2.getCiphers()); + } + browser$6.createCipher = browser$6.Cipher = createCipher; + browser$6.createCipheriv = browser$6.Cipheriv = createCipheriv; + browser$6.createDecipher = browser$6.Decipher = createDecipher; + browser$6.createDecipheriv = browser$6.Decipheriv = createDecipheriv; + browser$6.listCiphers = browser$6.getCiphers = getCiphers; + return browser$6; +} +var browser$4 = {}; +var bn$3 = { exports: {} }; +var bn$2 = bn$3.exports; +var hasRequiredBn$1; +function requireBn$1() { + if (hasRequiredBn$1) return bn$3.exports; + hasRequiredBn$1 = 1; + (function(module2) { + (function(module3, exports2) { + function assert(val, msg) { + if (!val) throw new Error(msg || "Assertion failed"); + } + function inherits(ctor, superCtor) { + ctor.super_ = superCtor; + var TempCtor = function() { + }; + TempCtor.prototype = superCtor.prototype; + ctor.prototype = new TempCtor(); + ctor.prototype.constructor = ctor; + } + function BN(number, base2, endian) { + if (BN.isBN(number)) { + return number; + } + this.negative = 0; + this.words = null; + this.length = 0; + this.red = null; + if (number !== null) { + if (base2 === "le" || base2 === "be") { + endian = base2; + base2 = 10; + } + this._init(number || 0, base2 || 10, endian || "be"); + } + } + if (typeof module3 === "object") { + module3.exports = BN; + } else { + exports2.BN = BN; + } + BN.BN = BN; + BN.wordSize = 26; + var Buffer2; + try { + if (typeof window !== "undefined" && typeof window.Buffer !== "undefined") { + Buffer2 = window.Buffer; + } else { + Buffer2 = requireDist().Buffer; + } + } catch (e) { + } + BN.isBN = function isBN(num) { + if (num instanceof BN) { + return true; + } + return num !== null && typeof num === "object" && num.constructor.wordSize === BN.wordSize && Array.isArray(num.words); + }; + BN.max = function max(left, right) { + if (left.cmp(right) > 0) return left; + return right; + }; + BN.min = function min(left, right) { + if (left.cmp(right) < 0) return left; + return right; + }; + BN.prototype._init = function init(number, base2, endian) { + if (typeof number === "number") { + return this._initNumber(number, base2, endian); + } + if (typeof number === "object") { + return this._initArray(number, base2, endian); + } + if (base2 === "hex") { + base2 = 16; + } + assert(base2 === (base2 | 0) && base2 >= 2 && base2 <= 36); + number = number.toString().replace(/\s+/g, ""); + var start = 0; + if (number[0] === "-") { + start++; + this.negative = 1; + } + if (start < number.length) { + if (base2 === 16) { + this._parseHex(number, start, endian); + } else { + this._parseBase(number, base2, start); + if (endian === "le") { + this._initArray(this.toArray(), base2, endian); + } + } + } + }; + BN.prototype._initNumber = function _initNumber(number, base2, endian) { + if (number < 0) { + this.negative = 1; + number = -number; + } + if (number < 67108864) { + this.words = [number & 67108863]; + this.length = 1; + } else if (number < 4503599627370496) { + this.words = [ + number & 67108863, + number / 67108864 & 67108863 + ]; + this.length = 2; + } else { + assert(number < 9007199254740992); + this.words = [ + number & 67108863, + number / 67108864 & 67108863, + 1 + ]; + this.length = 3; + } + if (endian !== "le") return; + this._initArray(this.toArray(), base2, endian); + }; + BN.prototype._initArray = function _initArray(number, base2, endian) { + assert(typeof number.length === "number"); + if (number.length <= 0) { + this.words = [0]; + this.length = 1; + return this; + } + this.length = Math.ceil(number.length / 3); + this.words = new Array(this.length); + for (var i2 = 0; i2 < this.length; i2++) { + this.words[i2] = 0; + } + var j, w; + var off = 0; + if (endian === "be") { + for (i2 = number.length - 1, j = 0; i2 >= 0; i2 -= 3) { + w = number[i2] | number[i2 - 1] << 8 | number[i2 - 2] << 16; + this.words[j] |= w << off & 67108863; + this.words[j + 1] = w >>> 26 - off & 67108863; + off += 24; + if (off >= 26) { + off -= 26; + j++; + } + } + } else if (endian === "le") { + for (i2 = 0, j = 0; i2 < number.length; i2 += 3) { + w = number[i2] | number[i2 + 1] << 8 | number[i2 + 2] << 16; + this.words[j] |= w << off & 67108863; + this.words[j + 1] = w >>> 26 - off & 67108863; + off += 24; + if (off >= 26) { + off -= 26; + j++; + } + } + } + return this.strip(); + }; + function parseHex4Bits(string, index) { + var c = string.charCodeAt(index); + if (c >= 65 && c <= 70) { + return c - 55; + } else if (c >= 97 && c <= 102) { + return c - 87; + } else { + return c - 48 & 15; + } + } + function parseHexByte(string, lowerBound, index) { + var r = parseHex4Bits(string, index); + if (index - 1 >= lowerBound) { + r |= parseHex4Bits(string, index - 1) << 4; + } + return r; + } + BN.prototype._parseHex = function _parseHex(number, start, endian) { + this.length = Math.ceil((number.length - start) / 6); + this.words = new Array(this.length); + for (var i2 = 0; i2 < this.length; i2++) { + this.words[i2] = 0; + } + var off = 0; + var j = 0; + var w; + if (endian === "be") { + for (i2 = number.length - 1; i2 >= start; i2 -= 2) { + w = parseHexByte(number, start, i2) << off; + this.words[j] |= w & 67108863; + if (off >= 18) { + off -= 18; + j += 1; + this.words[j] |= w >>> 26; + } else { + off += 8; + } + } + } else { + var parseLength = number.length - start; + for (i2 = parseLength % 2 === 0 ? start + 1 : start; i2 < number.length; i2 += 2) { + w = parseHexByte(number, start, i2) << off; + this.words[j] |= w & 67108863; + if (off >= 18) { + off -= 18; + j += 1; + this.words[j] |= w >>> 26; + } else { + off += 8; + } + } + } + this.strip(); + }; + function parseBase(str, start, end, mul) { + var r = 0; + var len2 = Math.min(str.length, end); + for (var i2 = start; i2 < len2; i2++) { + var c = str.charCodeAt(i2) - 48; + r *= mul; + if (c >= 49) { + r += c - 49 + 10; + } else if (c >= 17) { + r += c - 17 + 10; + } else { + r += c; + } + } + return r; + } + BN.prototype._parseBase = function _parseBase(number, base2, start) { + this.words = [0]; + this.length = 1; + for (var limbLen = 0, limbPow = 1; limbPow <= 67108863; limbPow *= base2) { + limbLen++; + } + limbLen--; + limbPow = limbPow / base2 | 0; + var total = number.length - start; + var mod = total % limbLen; + var end = Math.min(total, total - mod) + start; + var word = 0; + for (var i2 = start; i2 < end; i2 += limbLen) { + word = parseBase(number, i2, i2 + limbLen, base2); + this.imuln(limbPow); + if (this.words[0] + word < 67108864) { + this.words[0] += word; + } else { + this._iaddn(word); + } + } + if (mod !== 0) { + var pow = 1; + word = parseBase(number, i2, number.length, base2); + for (i2 = 0; i2 < mod; i2++) { + pow *= base2; + } + this.imuln(pow); + if (this.words[0] + word < 67108864) { + this.words[0] += word; + } else { + this._iaddn(word); + } + } + this.strip(); + }; + BN.prototype.copy = function copy(dest) { + dest.words = new Array(this.length); + for (var i2 = 0; i2 < this.length; i2++) { + dest.words[i2] = this.words[i2]; + } + dest.length = this.length; + dest.negative = this.negative; + dest.red = this.red; + }; + BN.prototype.clone = function clone() { + var r = new BN(null); + this.copy(r); + return r; + }; + BN.prototype._expand = function _expand(size) { + while (this.length < size) { + this.words[this.length++] = 0; + } + return this; + }; + BN.prototype.strip = function strip() { + while (this.length > 1 && this.words[this.length - 1] === 0) { + this.length--; + } + return this._normSign(); + }; + BN.prototype._normSign = function _normSign() { + if (this.length === 1 && this.words[0] === 0) { + this.negative = 0; + } + return this; + }; + BN.prototype.inspect = function inspect2() { + return (this.red ? ""; + }; + var zeros = [ + "", + "0", + "00", + "000", + "0000", + "00000", + "000000", + "0000000", + "00000000", + "000000000", + "0000000000", + "00000000000", + "000000000000", + "0000000000000", + "00000000000000", + "000000000000000", + "0000000000000000", + "00000000000000000", + "000000000000000000", + "0000000000000000000", + "00000000000000000000", + "000000000000000000000", + "0000000000000000000000", + "00000000000000000000000", + "000000000000000000000000", + "0000000000000000000000000" + ]; + var groupSizes = [ + 0, + 0, + 25, + 16, + 12, + 11, + 10, + 9, + 8, + 8, + 7, + 7, + 7, + 7, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5 + ]; + var groupBases = [ + 0, + 0, + 33554432, + 43046721, + 16777216, + 48828125, + 60466176, + 40353607, + 16777216, + 43046721, + 1e7, + 19487171, + 35831808, + 62748517, + 7529536, + 11390625, + 16777216, + 24137569, + 34012224, + 47045881, + 64e6, + 4084101, + 5153632, + 6436343, + 7962624, + 9765625, + 11881376, + 14348907, + 17210368, + 20511149, + 243e5, + 28629151, + 33554432, + 39135393, + 45435424, + 52521875, + 60466176 + ]; + BN.prototype.toString = function toString(base2, padding) { + base2 = base2 || 10; + padding = padding | 0 || 1; + var out; + if (base2 === 16 || base2 === "hex") { + out = ""; + var off = 0; + var carry = 0; + for (var i2 = 0; i2 < this.length; i2++) { + var w = this.words[i2]; + var word = ((w << off | carry) & 16777215).toString(16); + carry = w >>> 24 - off & 16777215; + if (carry !== 0 || i2 !== this.length - 1) { + out = zeros[6 - word.length] + word + out; + } else { + out = word + out; + } + off += 2; + if (off >= 26) { + off -= 26; + i2--; + } + } + if (carry !== 0) { + out = carry.toString(16) + out; + } + while (out.length % padding !== 0) { + out = "0" + out; + } + if (this.negative !== 0) { + out = "-" + out; + } + return out; + } + if (base2 === (base2 | 0) && base2 >= 2 && base2 <= 36) { + var groupSize = groupSizes[base2]; + var groupBase = groupBases[base2]; + out = ""; + var c = this.clone(); + c.negative = 0; + while (!c.isZero()) { + var r = c.modn(groupBase).toString(base2); + c = c.idivn(groupBase); + if (!c.isZero()) { + out = zeros[groupSize - r.length] + r + out; + } else { + out = r + out; + } + } + if (this.isZero()) { + out = "0" + out; + } + while (out.length % padding !== 0) { + out = "0" + out; + } + if (this.negative !== 0) { + out = "-" + out; + } + return out; + } + assert(false, "Base should be between 2 and 36"); + }; + BN.prototype.toNumber = function toNumber2() { + var ret = this.words[0]; + if (this.length === 2) { + ret += this.words[1] * 67108864; + } else if (this.length === 3 && this.words[2] === 1) { + ret += 4503599627370496 + this.words[1] * 67108864; + } else if (this.length > 2) { + assert(false, "Number can only safely store up to 53 bits"); + } + return this.negative !== 0 ? -ret : ret; + }; + BN.prototype.toJSON = function toJSON() { + return this.toString(16); + }; + BN.prototype.toBuffer = function toBuffer2(endian, length) { + assert(typeof Buffer2 !== "undefined"); + return this.toArrayLike(Buffer2, endian, length); + }; + BN.prototype.toArray = function toArray(endian, length) { + return this.toArrayLike(Array, endian, length); + }; + BN.prototype.toArrayLike = function toArrayLike(ArrayType, endian, length) { + var byteLength2 = this.byteLength(); + var reqLength = length || Math.max(1, byteLength2); + assert(byteLength2 <= reqLength, "byte array longer than desired length"); + assert(reqLength > 0, "Requested array length <= 0"); + this.strip(); + var littleEndian = endian === "le"; + var res = new ArrayType(reqLength); + var b, i2; + var q = this.clone(); + if (!littleEndian) { + for (i2 = 0; i2 < reqLength - byteLength2; i2++) { + res[i2] = 0; + } + for (i2 = 0; !q.isZero(); i2++) { + b = q.andln(255); + q.iushrn(8); + res[reqLength - i2 - 1] = b; + } + } else { + for (i2 = 0; !q.isZero(); i2++) { + b = q.andln(255); + q.iushrn(8); + res[i2] = b; + } + for (; i2 < reqLength; i2++) { + res[i2] = 0; + } + } + return res; + }; + if (Math.clz32) { + BN.prototype._countBits = function _countBits(w) { + return 32 - Math.clz32(w); + }; + } else { + BN.prototype._countBits = function _countBits(w) { + var t = w; + var r = 0; + if (t >= 4096) { + r += 13; + t >>>= 13; + } + if (t >= 64) { + r += 7; + t >>>= 7; + } + if (t >= 8) { + r += 4; + t >>>= 4; + } + if (t >= 2) { + r += 2; + t >>>= 2; + } + return r + t; + }; + } + BN.prototype._zeroBits = function _zeroBits(w) { + if (w === 0) return 26; + var t = w; + var r = 0; + if ((t & 8191) === 0) { + r += 13; + t >>>= 13; + } + if ((t & 127) === 0) { + r += 7; + t >>>= 7; + } + if ((t & 15) === 0) { + r += 4; + t >>>= 4; + } + if ((t & 3) === 0) { + r += 2; + t >>>= 2; + } + if ((t & 1) === 0) { + r++; + } + return r; + }; + BN.prototype.bitLength = function bitLength() { + var w = this.words[this.length - 1]; + var hi = this._countBits(w); + return (this.length - 1) * 26 + hi; + }; + function toBitArray(num) { + var w = new Array(num.bitLength()); + for (var bit = 0; bit < w.length; bit++) { + var off = bit / 26 | 0; + var wbit = bit % 26; + w[bit] = (num.words[off] & 1 << wbit) >>> wbit; + } + return w; + } + BN.prototype.zeroBits = function zeroBits() { + if (this.isZero()) return 0; + var r = 0; + for (var i2 = 0; i2 < this.length; i2++) { + var b = this._zeroBits(this.words[i2]); + r += b; + if (b !== 26) break; + } + return r; + }; + BN.prototype.byteLength = function byteLength2() { + return Math.ceil(this.bitLength() / 8); + }; + BN.prototype.toTwos = function toTwos(width) { + if (this.negative !== 0) { + return this.abs().inotn(width).iaddn(1); + } + return this.clone(); + }; + BN.prototype.fromTwos = function fromTwos(width) { + if (this.testn(width - 1)) { + return this.notn(width).iaddn(1).ineg(); + } + return this.clone(); + }; + BN.prototype.isNeg = function isNeg() { + return this.negative !== 0; + }; + BN.prototype.neg = function neg() { + return this.clone().ineg(); + }; + BN.prototype.ineg = function ineg() { + if (!this.isZero()) { + this.negative ^= 1; + } + return this; + }; + BN.prototype.iuor = function iuor(num) { + while (this.length < num.length) { + this.words[this.length++] = 0; + } + for (var i2 = 0; i2 < num.length; i2++) { + this.words[i2] = this.words[i2] | num.words[i2]; + } + return this.strip(); + }; + BN.prototype.ior = function ior(num) { + assert((this.negative | num.negative) === 0); + return this.iuor(num); + }; + BN.prototype.or = function or(num) { + if (this.length > num.length) return this.clone().ior(num); + return num.clone().ior(this); + }; + BN.prototype.uor = function uor(num) { + if (this.length > num.length) return this.clone().iuor(num); + return num.clone().iuor(this); + }; + BN.prototype.iuand = function iuand(num) { + var b; + if (this.length > num.length) { + b = num; + } else { + b = this; + } + for (var i2 = 0; i2 < b.length; i2++) { + this.words[i2] = this.words[i2] & num.words[i2]; + } + this.length = b.length; + return this.strip(); + }; + BN.prototype.iand = function iand(num) { + assert((this.negative | num.negative) === 0); + return this.iuand(num); + }; + BN.prototype.and = function and(num) { + if (this.length > num.length) return this.clone().iand(num); + return num.clone().iand(this); + }; + BN.prototype.uand = function uand(num) { + if (this.length > num.length) return this.clone().iuand(num); + return num.clone().iuand(this); + }; + BN.prototype.iuxor = function iuxor(num) { + var a; + var b; + if (this.length > num.length) { + a = this; + b = num; + } else { + a = num; + b = this; + } + for (var i2 = 0; i2 < b.length; i2++) { + this.words[i2] = a.words[i2] ^ b.words[i2]; + } + if (this !== a) { + for (; i2 < a.length; i2++) { + this.words[i2] = a.words[i2]; + } + } + this.length = a.length; + return this.strip(); + }; + BN.prototype.ixor = function ixor(num) { + assert((this.negative | num.negative) === 0); + return this.iuxor(num); + }; + BN.prototype.xor = function xor2(num) { + if (this.length > num.length) return this.clone().ixor(num); + return num.clone().ixor(this); + }; + BN.prototype.uxor = function uxor(num) { + if (this.length > num.length) return this.clone().iuxor(num); + return num.clone().iuxor(this); + }; + BN.prototype.inotn = function inotn(width) { + assert(typeof width === "number" && width >= 0); + var bytesNeeded = Math.ceil(width / 26) | 0; + var bitsLeft = width % 26; + this._expand(bytesNeeded); + if (bitsLeft > 0) { + bytesNeeded--; + } + for (var i2 = 0; i2 < bytesNeeded; i2++) { + this.words[i2] = ~this.words[i2] & 67108863; + } + if (bitsLeft > 0) { + this.words[i2] = ~this.words[i2] & 67108863 >> 26 - bitsLeft; + } + return this.strip(); + }; + BN.prototype.notn = function notn(width) { + return this.clone().inotn(width); + }; + BN.prototype.setn = function setn(bit, val) { + assert(typeof bit === "number" && bit >= 0); + var off = bit / 26 | 0; + var wbit = bit % 26; + this._expand(off + 1); + if (val) { + this.words[off] = this.words[off] | 1 << wbit; + } else { + this.words[off] = this.words[off] & ~(1 << wbit); + } + return this.strip(); + }; + BN.prototype.iadd = function iadd(num) { + var r; + if (this.negative !== 0 && num.negative === 0) { + this.negative = 0; + r = this.isub(num); + this.negative ^= 1; + return this._normSign(); + } else if (this.negative === 0 && num.negative !== 0) { + num.negative = 0; + r = this.isub(num); + num.negative = 1; + return r._normSign(); + } + var a, b; + if (this.length > num.length) { + a = this; + b = num; + } else { + a = num; + b = this; + } + var carry = 0; + for (var i2 = 0; i2 < b.length; i2++) { + r = (a.words[i2] | 0) + (b.words[i2] | 0) + carry; + this.words[i2] = r & 67108863; + carry = r >>> 26; + } + for (; carry !== 0 && i2 < a.length; i2++) { + r = (a.words[i2] | 0) + carry; + this.words[i2] = r & 67108863; + carry = r >>> 26; + } + this.length = a.length; + if (carry !== 0) { + this.words[this.length] = carry; + this.length++; + } else if (a !== this) { + for (; i2 < a.length; i2++) { + this.words[i2] = a.words[i2]; + } + } + return this; + }; + BN.prototype.add = function add(num) { + var res; + if (num.negative !== 0 && this.negative === 0) { + num.negative = 0; + res = this.sub(num); + num.negative ^= 1; + return res; + } else if (num.negative === 0 && this.negative !== 0) { + this.negative = 0; + res = num.sub(this); + this.negative = 1; + return res; + } + if (this.length > num.length) return this.clone().iadd(num); + return num.clone().iadd(this); + }; + BN.prototype.isub = function isub(num) { + if (num.negative !== 0) { + num.negative = 0; + var r = this.iadd(num); + num.negative = 1; + return r._normSign(); + } else if (this.negative !== 0) { + this.negative = 0; + this.iadd(num); + this.negative = 1; + return this._normSign(); + } + var cmp = this.cmp(num); + if (cmp === 0) { + this.negative = 0; + this.length = 1; + this.words[0] = 0; + return this; + } + var a, b; + if (cmp > 0) { + a = this; + b = num; + } else { + a = num; + b = this; + } + var carry = 0; + for (var i2 = 0; i2 < b.length; i2++) { + r = (a.words[i2] | 0) - (b.words[i2] | 0) + carry; + carry = r >> 26; + this.words[i2] = r & 67108863; + } + for (; carry !== 0 && i2 < a.length; i2++) { + r = (a.words[i2] | 0) + carry; + carry = r >> 26; + this.words[i2] = r & 67108863; + } + if (carry === 0 && i2 < a.length && a !== this) { + for (; i2 < a.length; i2++) { + this.words[i2] = a.words[i2]; + } + } + this.length = Math.max(this.length, i2); + if (a !== this) { + this.negative = 1; + } + return this.strip(); + }; + BN.prototype.sub = function sub(num) { + return this.clone().isub(num); + }; + function smallMulTo(self2, num, out) { + out.negative = num.negative ^ self2.negative; + var len2 = self2.length + num.length | 0; + out.length = len2; + len2 = len2 - 1 | 0; + var a = self2.words[0] | 0; + var b = num.words[0] | 0; + var r = a * b; + var lo = r & 67108863; + var carry = r / 67108864 | 0; + out.words[0] = lo; + for (var k = 1; k < len2; k++) { + var ncarry = carry >>> 26; + var rword = carry & 67108863; + var maxJ = Math.min(k, num.length - 1); + for (var j = Math.max(0, k - self2.length + 1); j <= maxJ; j++) { + var i2 = k - j | 0; + a = self2.words[i2] | 0; + b = num.words[j] | 0; + r = a * b + rword; + ncarry += r / 67108864 | 0; + rword = r & 67108863; + } + out.words[k] = rword | 0; + carry = ncarry | 0; + } + if (carry !== 0) { + out.words[k] = carry | 0; + } else { + out.length--; + } + return out.strip(); + } + var comb10MulTo = function comb10MulTo2(self2, num, out) { + var a = self2.words; + var b = num.words; + var o = out.words; + var c = 0; + var lo; + var mid; + var hi; + var a0 = a[0] | 0; + var al0 = a0 & 8191; + var ah0 = a0 >>> 13; + var a1 = a[1] | 0; + var al1 = a1 & 8191; + var ah1 = a1 >>> 13; + var a2 = a[2] | 0; + var al2 = a2 & 8191; + var ah2 = a2 >>> 13; + var a3 = a[3] | 0; + var al3 = a3 & 8191; + var ah3 = a3 >>> 13; + var a4 = a[4] | 0; + var al4 = a4 & 8191; + var ah4 = a4 >>> 13; + var a5 = a[5] | 0; + var al5 = a5 & 8191; + var ah5 = a5 >>> 13; + var a6 = a[6] | 0; + var al6 = a6 & 8191; + var ah6 = a6 >>> 13; + var a7 = a[7] | 0; + var al7 = a7 & 8191; + var ah7 = a7 >>> 13; + var a8 = a[8] | 0; + var al8 = a8 & 8191; + var ah8 = a8 >>> 13; + var a9 = a[9] | 0; + var al9 = a9 & 8191; + var ah9 = a9 >>> 13; + var b0 = b[0] | 0; + var bl0 = b0 & 8191; + var bh0 = b0 >>> 13; + var b1 = b[1] | 0; + var bl1 = b1 & 8191; + var bh1 = b1 >>> 13; + var b2 = b[2] | 0; + var bl2 = b2 & 8191; + var bh2 = b2 >>> 13; + var b3 = b[3] | 0; + var bl3 = b3 & 8191; + var bh3 = b3 >>> 13; + var b4 = b[4] | 0; + var bl4 = b4 & 8191; + var bh4 = b4 >>> 13; + var b5 = b[5] | 0; + var bl5 = b5 & 8191; + var bh5 = b5 >>> 13; + var b6 = b[6] | 0; + var bl6 = b6 & 8191; + var bh6 = b6 >>> 13; + var b7 = b[7] | 0; + var bl7 = b7 & 8191; + var bh7 = b7 >>> 13; + var b8 = b[8] | 0; + var bl8 = b8 & 8191; + var bh8 = b8 >>> 13; + var b9 = b[9] | 0; + var bl9 = b9 & 8191; + var bh9 = b9 >>> 13; + out.negative = self2.negative ^ num.negative; + out.length = 19; + lo = Math.imul(al0, bl0); + mid = Math.imul(al0, bh0); + mid = mid + Math.imul(ah0, bl0) | 0; + hi = Math.imul(ah0, bh0); + var w0 = (c + lo | 0) + ((mid & 8191) << 13) | 0; + c = (hi + (mid >>> 13) | 0) + (w0 >>> 26) | 0; + w0 &= 67108863; + lo = Math.imul(al1, bl0); + mid = Math.imul(al1, bh0); + mid = mid + Math.imul(ah1, bl0) | 0; + hi = Math.imul(ah1, bh0); + lo = lo + Math.imul(al0, bl1) | 0; + mid = mid + Math.imul(al0, bh1) | 0; + mid = mid + Math.imul(ah0, bl1) | 0; + hi = hi + Math.imul(ah0, bh1) | 0; + var w1 = (c + lo | 0) + ((mid & 8191) << 13) | 0; + c = (hi + (mid >>> 13) | 0) + (w1 >>> 26) | 0; + w1 &= 67108863; + lo = Math.imul(al2, bl0); + mid = Math.imul(al2, bh0); + mid = mid + Math.imul(ah2, bl0) | 0; + hi = Math.imul(ah2, bh0); + lo = lo + Math.imul(al1, bl1) | 0; + mid = mid + Math.imul(al1, bh1) | 0; + mid = mid + Math.imul(ah1, bl1) | 0; + hi = hi + Math.imul(ah1, bh1) | 0; + lo = lo + Math.imul(al0, bl2) | 0; + mid = mid + Math.imul(al0, bh2) | 0; + mid = mid + Math.imul(ah0, bl2) | 0; + hi = hi + Math.imul(ah0, bh2) | 0; + var w2 = (c + lo | 0) + ((mid & 8191) << 13) | 0; + c = (hi + (mid >>> 13) | 0) + (w2 >>> 26) | 0; + w2 &= 67108863; + lo = Math.imul(al3, bl0); + mid = Math.imul(al3, bh0); + mid = mid + Math.imul(ah3, bl0) | 0; + hi = Math.imul(ah3, bh0); + lo = lo + Math.imul(al2, bl1) | 0; + mid = mid + Math.imul(al2, bh1) | 0; + mid = mid + Math.imul(ah2, bl1) | 0; + hi = hi + Math.imul(ah2, bh1) | 0; + lo = lo + Math.imul(al1, bl2) | 0; + mid = mid + Math.imul(al1, bh2) | 0; + mid = mid + Math.imul(ah1, bl2) | 0; + hi = hi + Math.imul(ah1, bh2) | 0; + lo = lo + Math.imul(al0, bl3) | 0; + mid = mid + Math.imul(al0, bh3) | 0; + mid = mid + Math.imul(ah0, bl3) | 0; + hi = hi + Math.imul(ah0, bh3) | 0; + var w3 = (c + lo | 0) + ((mid & 8191) << 13) | 0; + c = (hi + (mid >>> 13) | 0) + (w3 >>> 26) | 0; + w3 &= 67108863; + lo = Math.imul(al4, bl0); + mid = Math.imul(al4, bh0); + mid = mid + Math.imul(ah4, bl0) | 0; + hi = Math.imul(ah4, bh0); + lo = lo + Math.imul(al3, bl1) | 0; + mid = mid + Math.imul(al3, bh1) | 0; + mid = mid + Math.imul(ah3, bl1) | 0; + hi = hi + Math.imul(ah3, bh1) | 0; + lo = lo + Math.imul(al2, bl2) | 0; + mid = mid + Math.imul(al2, bh2) | 0; + mid = mid + Math.imul(ah2, bl2) | 0; + hi = hi + Math.imul(ah2, bh2) | 0; + lo = lo + Math.imul(al1, bl3) | 0; + mid = mid + Math.imul(al1, bh3) | 0; + mid = mid + Math.imul(ah1, bl3) | 0; + hi = hi + Math.imul(ah1, bh3) | 0; + lo = lo + Math.imul(al0, bl4) | 0; + mid = mid + Math.imul(al0, bh4) | 0; + mid = mid + Math.imul(ah0, bl4) | 0; + hi = hi + Math.imul(ah0, bh4) | 0; + var w4 = (c + lo | 0) + ((mid & 8191) << 13) | 0; + c = (hi + (mid >>> 13) | 0) + (w4 >>> 26) | 0; + w4 &= 67108863; + lo = Math.imul(al5, bl0); + mid = Math.imul(al5, bh0); + mid = mid + Math.imul(ah5, bl0) | 0; + hi = Math.imul(ah5, bh0); + lo = lo + Math.imul(al4, bl1) | 0; + mid = mid + Math.imul(al4, bh1) | 0; + mid = mid + Math.imul(ah4, bl1) | 0; + hi = hi + Math.imul(ah4, bh1) | 0; + lo = lo + Math.imul(al3, bl2) | 0; + mid = mid + Math.imul(al3, bh2) | 0; + mid = mid + Math.imul(ah3, bl2) | 0; + hi = hi + Math.imul(ah3, bh2) | 0; + lo = lo + Math.imul(al2, bl3) | 0; + mid = mid + Math.imul(al2, bh3) | 0; + mid = mid + Math.imul(ah2, bl3) | 0; + hi = hi + Math.imul(ah2, bh3) | 0; + lo = lo + Math.imul(al1, bl4) | 0; + mid = mid + Math.imul(al1, bh4) | 0; + mid = mid + Math.imul(ah1, bl4) | 0; + hi = hi + Math.imul(ah1, bh4) | 0; + lo = lo + Math.imul(al0, bl5) | 0; + mid = mid + Math.imul(al0, bh5) | 0; + mid = mid + Math.imul(ah0, bl5) | 0; + hi = hi + Math.imul(ah0, bh5) | 0; + var w5 = (c + lo | 0) + ((mid & 8191) << 13) | 0; + c = (hi + (mid >>> 13) | 0) + (w5 >>> 26) | 0; + w5 &= 67108863; + lo = Math.imul(al6, bl0); + mid = Math.imul(al6, bh0); + mid = mid + Math.imul(ah6, bl0) | 0; + hi = Math.imul(ah6, bh0); + lo = lo + Math.imul(al5, bl1) | 0; + mid = mid + Math.imul(al5, bh1) | 0; + mid = mid + Math.imul(ah5, bl1) | 0; + hi = hi + Math.imul(ah5, bh1) | 0; + lo = lo + Math.imul(al4, bl2) | 0; + mid = mid + Math.imul(al4, bh2) | 0; + mid = mid + Math.imul(ah4, bl2) | 0; + hi = hi + Math.imul(ah4, bh2) | 0; + lo = lo + Math.imul(al3, bl3) | 0; + mid = mid + Math.imul(al3, bh3) | 0; + mid = mid + Math.imul(ah3, bl3) | 0; + hi = hi + Math.imul(ah3, bh3) | 0; + lo = lo + Math.imul(al2, bl4) | 0; + mid = mid + Math.imul(al2, bh4) | 0; + mid = mid + Math.imul(ah2, bl4) | 0; + hi = hi + Math.imul(ah2, bh4) | 0; + lo = lo + Math.imul(al1, bl5) | 0; + mid = mid + Math.imul(al1, bh5) | 0; + mid = mid + Math.imul(ah1, bl5) | 0; + hi = hi + Math.imul(ah1, bh5) | 0; + lo = lo + Math.imul(al0, bl6) | 0; + mid = mid + Math.imul(al0, bh6) | 0; + mid = mid + Math.imul(ah0, bl6) | 0; + hi = hi + Math.imul(ah0, bh6) | 0; + var w6 = (c + lo | 0) + ((mid & 8191) << 13) | 0; + c = (hi + (mid >>> 13) | 0) + (w6 >>> 26) | 0; + w6 &= 67108863; + lo = Math.imul(al7, bl0); + mid = Math.imul(al7, bh0); + mid = mid + Math.imul(ah7, bl0) | 0; + hi = Math.imul(ah7, bh0); + lo = lo + Math.imul(al6, bl1) | 0; + mid = mid + Math.imul(al6, bh1) | 0; + mid = mid + Math.imul(ah6, bl1) | 0; + hi = hi + Math.imul(ah6, bh1) | 0; + lo = lo + Math.imul(al5, bl2) | 0; + mid = mid + Math.imul(al5, bh2) | 0; + mid = mid + Math.imul(ah5, bl2) | 0; + hi = hi + Math.imul(ah5, bh2) | 0; + lo = lo + Math.imul(al4, bl3) | 0; + mid = mid + Math.imul(al4, bh3) | 0; + mid = mid + Math.imul(ah4, bl3) | 0; + hi = hi + Math.imul(ah4, bh3) | 0; + lo = lo + Math.imul(al3, bl4) | 0; + mid = mid + Math.imul(al3, bh4) | 0; + mid = mid + Math.imul(ah3, bl4) | 0; + hi = hi + Math.imul(ah3, bh4) | 0; + lo = lo + Math.imul(al2, bl5) | 0; + mid = mid + Math.imul(al2, bh5) | 0; + mid = mid + Math.imul(ah2, bl5) | 0; + hi = hi + Math.imul(ah2, bh5) | 0; + lo = lo + Math.imul(al1, bl6) | 0; + mid = mid + Math.imul(al1, bh6) | 0; + mid = mid + Math.imul(ah1, bl6) | 0; + hi = hi + Math.imul(ah1, bh6) | 0; + lo = lo + Math.imul(al0, bl7) | 0; + mid = mid + Math.imul(al0, bh7) | 0; + mid = mid + Math.imul(ah0, bl7) | 0; + hi = hi + Math.imul(ah0, bh7) | 0; + var w7 = (c + lo | 0) + ((mid & 8191) << 13) | 0; + c = (hi + (mid >>> 13) | 0) + (w7 >>> 26) | 0; + w7 &= 67108863; + lo = Math.imul(al8, bl0); + mid = Math.imul(al8, bh0); + mid = mid + Math.imul(ah8, bl0) | 0; + hi = Math.imul(ah8, bh0); + lo = lo + Math.imul(al7, bl1) | 0; + mid = mid + Math.imul(al7, bh1) | 0; + mid = mid + Math.imul(ah7, bl1) | 0; + hi = hi + Math.imul(ah7, bh1) | 0; + lo = lo + Math.imul(al6, bl2) | 0; + mid = mid + Math.imul(al6, bh2) | 0; + mid = mid + Math.imul(ah6, bl2) | 0; + hi = hi + Math.imul(ah6, bh2) | 0; + lo = lo + Math.imul(al5, bl3) | 0; + mid = mid + Math.imul(al5, bh3) | 0; + mid = mid + Math.imul(ah5, bl3) | 0; + hi = hi + Math.imul(ah5, bh3) | 0; + lo = lo + Math.imul(al4, bl4) | 0; + mid = mid + Math.imul(al4, bh4) | 0; + mid = mid + Math.imul(ah4, bl4) | 0; + hi = hi + Math.imul(ah4, bh4) | 0; + lo = lo + Math.imul(al3, bl5) | 0; + mid = mid + Math.imul(al3, bh5) | 0; + mid = mid + Math.imul(ah3, bl5) | 0; + hi = hi + Math.imul(ah3, bh5) | 0; + lo = lo + Math.imul(al2, bl6) | 0; + mid = mid + Math.imul(al2, bh6) | 0; + mid = mid + Math.imul(ah2, bl6) | 0; + hi = hi + Math.imul(ah2, bh6) | 0; + lo = lo + Math.imul(al1, bl7) | 0; + mid = mid + Math.imul(al1, bh7) | 0; + mid = mid + Math.imul(ah1, bl7) | 0; + hi = hi + Math.imul(ah1, bh7) | 0; + lo = lo + Math.imul(al0, bl8) | 0; + mid = mid + Math.imul(al0, bh8) | 0; + mid = mid + Math.imul(ah0, bl8) | 0; + hi = hi + Math.imul(ah0, bh8) | 0; + var w8 = (c + lo | 0) + ((mid & 8191) << 13) | 0; + c = (hi + (mid >>> 13) | 0) + (w8 >>> 26) | 0; + w8 &= 67108863; + lo = Math.imul(al9, bl0); + mid = Math.imul(al9, bh0); + mid = mid + Math.imul(ah9, bl0) | 0; + hi = Math.imul(ah9, bh0); + lo = lo + Math.imul(al8, bl1) | 0; + mid = mid + Math.imul(al8, bh1) | 0; + mid = mid + Math.imul(ah8, bl1) | 0; + hi = hi + Math.imul(ah8, bh1) | 0; + lo = lo + Math.imul(al7, bl2) | 0; + mid = mid + Math.imul(al7, bh2) | 0; + mid = mid + Math.imul(ah7, bl2) | 0; + hi = hi + Math.imul(ah7, bh2) | 0; + lo = lo + Math.imul(al6, bl3) | 0; + mid = mid + Math.imul(al6, bh3) | 0; + mid = mid + Math.imul(ah6, bl3) | 0; + hi = hi + Math.imul(ah6, bh3) | 0; + lo = lo + Math.imul(al5, bl4) | 0; + mid = mid + Math.imul(al5, bh4) | 0; + mid = mid + Math.imul(ah5, bl4) | 0; + hi = hi + Math.imul(ah5, bh4) | 0; + lo = lo + Math.imul(al4, bl5) | 0; + mid = mid + Math.imul(al4, bh5) | 0; + mid = mid + Math.imul(ah4, bl5) | 0; + hi = hi + Math.imul(ah4, bh5) | 0; + lo = lo + Math.imul(al3, bl6) | 0; + mid = mid + Math.imul(al3, bh6) | 0; + mid = mid + Math.imul(ah3, bl6) | 0; + hi = hi + Math.imul(ah3, bh6) | 0; + lo = lo + Math.imul(al2, bl7) | 0; + mid = mid + Math.imul(al2, bh7) | 0; + mid = mid + Math.imul(ah2, bl7) | 0; + hi = hi + Math.imul(ah2, bh7) | 0; + lo = lo + Math.imul(al1, bl8) | 0; + mid = mid + Math.imul(al1, bh8) | 0; + mid = mid + Math.imul(ah1, bl8) | 0; + hi = hi + Math.imul(ah1, bh8) | 0; + lo = lo + Math.imul(al0, bl9) | 0; + mid = mid + Math.imul(al0, bh9) | 0; + mid = mid + Math.imul(ah0, bl9) | 0; + hi = hi + Math.imul(ah0, bh9) | 0; + var w9 = (c + lo | 0) + ((mid & 8191) << 13) | 0; + c = (hi + (mid >>> 13) | 0) + (w9 >>> 26) | 0; + w9 &= 67108863; + lo = Math.imul(al9, bl1); + mid = Math.imul(al9, bh1); + mid = mid + Math.imul(ah9, bl1) | 0; + hi = Math.imul(ah9, bh1); + lo = lo + Math.imul(al8, bl2) | 0; + mid = mid + Math.imul(al8, bh2) | 0; + mid = mid + Math.imul(ah8, bl2) | 0; + hi = hi + Math.imul(ah8, bh2) | 0; + lo = lo + Math.imul(al7, bl3) | 0; + mid = mid + Math.imul(al7, bh3) | 0; + mid = mid + Math.imul(ah7, bl3) | 0; + hi = hi + Math.imul(ah7, bh3) | 0; + lo = lo + Math.imul(al6, bl4) | 0; + mid = mid + Math.imul(al6, bh4) | 0; + mid = mid + Math.imul(ah6, bl4) | 0; + hi = hi + Math.imul(ah6, bh4) | 0; + lo = lo + Math.imul(al5, bl5) | 0; + mid = mid + Math.imul(al5, bh5) | 0; + mid = mid + Math.imul(ah5, bl5) | 0; + hi = hi + Math.imul(ah5, bh5) | 0; + lo = lo + Math.imul(al4, bl6) | 0; + mid = mid + Math.imul(al4, bh6) | 0; + mid = mid + Math.imul(ah4, bl6) | 0; + hi = hi + Math.imul(ah4, bh6) | 0; + lo = lo + Math.imul(al3, bl7) | 0; + mid = mid + Math.imul(al3, bh7) | 0; + mid = mid + Math.imul(ah3, bl7) | 0; + hi = hi + Math.imul(ah3, bh7) | 0; + lo = lo + Math.imul(al2, bl8) | 0; + mid = mid + Math.imul(al2, bh8) | 0; + mid = mid + Math.imul(ah2, bl8) | 0; + hi = hi + Math.imul(ah2, bh8) | 0; + lo = lo + Math.imul(al1, bl9) | 0; + mid = mid + Math.imul(al1, bh9) | 0; + mid = mid + Math.imul(ah1, bl9) | 0; + hi = hi + Math.imul(ah1, bh9) | 0; + var w10 = (c + lo | 0) + ((mid & 8191) << 13) | 0; + c = (hi + (mid >>> 13) | 0) + (w10 >>> 26) | 0; + w10 &= 67108863; + lo = Math.imul(al9, bl2); + mid = Math.imul(al9, bh2); + mid = mid + Math.imul(ah9, bl2) | 0; + hi = Math.imul(ah9, bh2); + lo = lo + Math.imul(al8, bl3) | 0; + mid = mid + Math.imul(al8, bh3) | 0; + mid = mid + Math.imul(ah8, bl3) | 0; + hi = hi + Math.imul(ah8, bh3) | 0; + lo = lo + Math.imul(al7, bl4) | 0; + mid = mid + Math.imul(al7, bh4) | 0; + mid = mid + Math.imul(ah7, bl4) | 0; + hi = hi + Math.imul(ah7, bh4) | 0; + lo = lo + Math.imul(al6, bl5) | 0; + mid = mid + Math.imul(al6, bh5) | 0; + mid = mid + Math.imul(ah6, bl5) | 0; + hi = hi + Math.imul(ah6, bh5) | 0; + lo = lo + Math.imul(al5, bl6) | 0; + mid = mid + Math.imul(al5, bh6) | 0; + mid = mid + Math.imul(ah5, bl6) | 0; + hi = hi + Math.imul(ah5, bh6) | 0; + lo = lo + Math.imul(al4, bl7) | 0; + mid = mid + Math.imul(al4, bh7) | 0; + mid = mid + Math.imul(ah4, bl7) | 0; + hi = hi + Math.imul(ah4, bh7) | 0; + lo = lo + Math.imul(al3, bl8) | 0; + mid = mid + Math.imul(al3, bh8) | 0; + mid = mid + Math.imul(ah3, bl8) | 0; + hi = hi + Math.imul(ah3, bh8) | 0; + lo = lo + Math.imul(al2, bl9) | 0; + mid = mid + Math.imul(al2, bh9) | 0; + mid = mid + Math.imul(ah2, bl9) | 0; + hi = hi + Math.imul(ah2, bh9) | 0; + var w11 = (c + lo | 0) + ((mid & 8191) << 13) | 0; + c = (hi + (mid >>> 13) | 0) + (w11 >>> 26) | 0; + w11 &= 67108863; + lo = Math.imul(al9, bl3); + mid = Math.imul(al9, bh3); + mid = mid + Math.imul(ah9, bl3) | 0; + hi = Math.imul(ah9, bh3); + lo = lo + Math.imul(al8, bl4) | 0; + mid = mid + Math.imul(al8, bh4) | 0; + mid = mid + Math.imul(ah8, bl4) | 0; + hi = hi + Math.imul(ah8, bh4) | 0; + lo = lo + Math.imul(al7, bl5) | 0; + mid = mid + Math.imul(al7, bh5) | 0; + mid = mid + Math.imul(ah7, bl5) | 0; + hi = hi + Math.imul(ah7, bh5) | 0; + lo = lo + Math.imul(al6, bl6) | 0; + mid = mid + Math.imul(al6, bh6) | 0; + mid = mid + Math.imul(ah6, bl6) | 0; + hi = hi + Math.imul(ah6, bh6) | 0; + lo = lo + Math.imul(al5, bl7) | 0; + mid = mid + Math.imul(al5, bh7) | 0; + mid = mid + Math.imul(ah5, bl7) | 0; + hi = hi + Math.imul(ah5, bh7) | 0; + lo = lo + Math.imul(al4, bl8) | 0; + mid = mid + Math.imul(al4, bh8) | 0; + mid = mid + Math.imul(ah4, bl8) | 0; + hi = hi + Math.imul(ah4, bh8) | 0; + lo = lo + Math.imul(al3, bl9) | 0; + mid = mid + Math.imul(al3, bh9) | 0; + mid = mid + Math.imul(ah3, bl9) | 0; + hi = hi + Math.imul(ah3, bh9) | 0; + var w12 = (c + lo | 0) + ((mid & 8191) << 13) | 0; + c = (hi + (mid >>> 13) | 0) + (w12 >>> 26) | 0; + w12 &= 67108863; + lo = Math.imul(al9, bl4); + mid = Math.imul(al9, bh4); + mid = mid + Math.imul(ah9, bl4) | 0; + hi = Math.imul(ah9, bh4); + lo = lo + Math.imul(al8, bl5) | 0; + mid = mid + Math.imul(al8, bh5) | 0; + mid = mid + Math.imul(ah8, bl5) | 0; + hi = hi + Math.imul(ah8, bh5) | 0; + lo = lo + Math.imul(al7, bl6) | 0; + mid = mid + Math.imul(al7, bh6) | 0; + mid = mid + Math.imul(ah7, bl6) | 0; + hi = hi + Math.imul(ah7, bh6) | 0; + lo = lo + Math.imul(al6, bl7) | 0; + mid = mid + Math.imul(al6, bh7) | 0; + mid = mid + Math.imul(ah6, bl7) | 0; + hi = hi + Math.imul(ah6, bh7) | 0; + lo = lo + Math.imul(al5, bl8) | 0; + mid = mid + Math.imul(al5, bh8) | 0; + mid = mid + Math.imul(ah5, bl8) | 0; + hi = hi + Math.imul(ah5, bh8) | 0; + lo = lo + Math.imul(al4, bl9) | 0; + mid = mid + Math.imul(al4, bh9) | 0; + mid = mid + Math.imul(ah4, bl9) | 0; + hi = hi + Math.imul(ah4, bh9) | 0; + var w13 = (c + lo | 0) + ((mid & 8191) << 13) | 0; + c = (hi + (mid >>> 13) | 0) + (w13 >>> 26) | 0; + w13 &= 67108863; + lo = Math.imul(al9, bl5); + mid = Math.imul(al9, bh5); + mid = mid + Math.imul(ah9, bl5) | 0; + hi = Math.imul(ah9, bh5); + lo = lo + Math.imul(al8, bl6) | 0; + mid = mid + Math.imul(al8, bh6) | 0; + mid = mid + Math.imul(ah8, bl6) | 0; + hi = hi + Math.imul(ah8, bh6) | 0; + lo = lo + Math.imul(al7, bl7) | 0; + mid = mid + Math.imul(al7, bh7) | 0; + mid = mid + Math.imul(ah7, bl7) | 0; + hi = hi + Math.imul(ah7, bh7) | 0; + lo = lo + Math.imul(al6, bl8) | 0; + mid = mid + Math.imul(al6, bh8) | 0; + mid = mid + Math.imul(ah6, bl8) | 0; + hi = hi + Math.imul(ah6, bh8) | 0; + lo = lo + Math.imul(al5, bl9) | 0; + mid = mid + Math.imul(al5, bh9) | 0; + mid = mid + Math.imul(ah5, bl9) | 0; + hi = hi + Math.imul(ah5, bh9) | 0; + var w14 = (c + lo | 0) + ((mid & 8191) << 13) | 0; + c = (hi + (mid >>> 13) | 0) + (w14 >>> 26) | 0; + w14 &= 67108863; + lo = Math.imul(al9, bl6); + mid = Math.imul(al9, bh6); + mid = mid + Math.imul(ah9, bl6) | 0; + hi = Math.imul(ah9, bh6); + lo = lo + Math.imul(al8, bl7) | 0; + mid = mid + Math.imul(al8, bh7) | 0; + mid = mid + Math.imul(ah8, bl7) | 0; + hi = hi + Math.imul(ah8, bh7) | 0; + lo = lo + Math.imul(al7, bl8) | 0; + mid = mid + Math.imul(al7, bh8) | 0; + mid = mid + Math.imul(ah7, bl8) | 0; + hi = hi + Math.imul(ah7, bh8) | 0; + lo = lo + Math.imul(al6, bl9) | 0; + mid = mid + Math.imul(al6, bh9) | 0; + mid = mid + Math.imul(ah6, bl9) | 0; + hi = hi + Math.imul(ah6, bh9) | 0; + var w15 = (c + lo | 0) + ((mid & 8191) << 13) | 0; + c = (hi + (mid >>> 13) | 0) + (w15 >>> 26) | 0; + w15 &= 67108863; + lo = Math.imul(al9, bl7); + mid = Math.imul(al9, bh7); + mid = mid + Math.imul(ah9, bl7) | 0; + hi = Math.imul(ah9, bh7); + lo = lo + Math.imul(al8, bl8) | 0; + mid = mid + Math.imul(al8, bh8) | 0; + mid = mid + Math.imul(ah8, bl8) | 0; + hi = hi + Math.imul(ah8, bh8) | 0; + lo = lo + Math.imul(al7, bl9) | 0; + mid = mid + Math.imul(al7, bh9) | 0; + mid = mid + Math.imul(ah7, bl9) | 0; + hi = hi + Math.imul(ah7, bh9) | 0; + var w16 = (c + lo | 0) + ((mid & 8191) << 13) | 0; + c = (hi + (mid >>> 13) | 0) + (w16 >>> 26) | 0; + w16 &= 67108863; + lo = Math.imul(al9, bl8); + mid = Math.imul(al9, bh8); + mid = mid + Math.imul(ah9, bl8) | 0; + hi = Math.imul(ah9, bh8); + lo = lo + Math.imul(al8, bl9) | 0; + mid = mid + Math.imul(al8, bh9) | 0; + mid = mid + Math.imul(ah8, bl9) | 0; + hi = hi + Math.imul(ah8, bh9) | 0; + var w17 = (c + lo | 0) + ((mid & 8191) << 13) | 0; + c = (hi + (mid >>> 13) | 0) + (w17 >>> 26) | 0; + w17 &= 67108863; + lo = Math.imul(al9, bl9); + mid = Math.imul(al9, bh9); + mid = mid + Math.imul(ah9, bl9) | 0; + hi = Math.imul(ah9, bh9); + var w18 = (c + lo | 0) + ((mid & 8191) << 13) | 0; + c = (hi + (mid >>> 13) | 0) + (w18 >>> 26) | 0; + w18 &= 67108863; + o[0] = w0; + o[1] = w1; + o[2] = w2; + o[3] = w3; + o[4] = w4; + o[5] = w5; + o[6] = w6; + o[7] = w7; + o[8] = w8; + o[9] = w9; + o[10] = w10; + o[11] = w11; + o[12] = w12; + o[13] = w13; + o[14] = w14; + o[15] = w15; + o[16] = w16; + o[17] = w17; + o[18] = w18; + if (c !== 0) { + o[19] = c; + out.length++; + } + return out; + }; + if (!Math.imul) { + comb10MulTo = smallMulTo; + } + function bigMulTo(self2, num, out) { + out.negative = num.negative ^ self2.negative; + out.length = self2.length + num.length; + var carry = 0; + var hncarry = 0; + for (var k = 0; k < out.length - 1; k++) { + var ncarry = hncarry; + hncarry = 0; + var rword = carry & 67108863; + var maxJ = Math.min(k, num.length - 1); + for (var j = Math.max(0, k - self2.length + 1); j <= maxJ; j++) { + var i2 = k - j; + var a = self2.words[i2] | 0; + var b = num.words[j] | 0; + var r = a * b; + var lo = r & 67108863; + ncarry = ncarry + (r / 67108864 | 0) | 0; + lo = lo + rword | 0; + rword = lo & 67108863; + ncarry = ncarry + (lo >>> 26) | 0; + hncarry += ncarry >>> 26; + ncarry &= 67108863; + } + out.words[k] = rword; + carry = ncarry; + ncarry = hncarry; + } + if (carry !== 0) { + out.words[k] = carry; + } else { + out.length--; + } + return out.strip(); + } + function jumboMulTo(self2, num, out) { + var fftm = new FFTM(); + return fftm.mulp(self2, num, out); + } + BN.prototype.mulTo = function mulTo(num, out) { + var res; + var len2 = this.length + num.length; + if (this.length === 10 && num.length === 10) { + res = comb10MulTo(this, num, out); + } else if (len2 < 63) { + res = smallMulTo(this, num, out); + } else if (len2 < 1024) { + res = bigMulTo(this, num, out); + } else { + res = jumboMulTo(this, num, out); + } + return res; + }; + function FFTM(x, y) { + this.x = x; + this.y = y; + } + FFTM.prototype.makeRBT = function makeRBT(N) { + var t = new Array(N); + var l = BN.prototype._countBits(N) - 1; + for (var i2 = 0; i2 < N; i2++) { + t[i2] = this.revBin(i2, l, N); + } + return t; + }; + FFTM.prototype.revBin = function revBin(x, l, N) { + if (x === 0 || x === N - 1) return x; + var rb = 0; + for (var i2 = 0; i2 < l; i2++) { + rb |= (x & 1) << l - i2 - 1; + x >>= 1; + } + return rb; + }; + FFTM.prototype.permute = function permute(rbt, rws, iws, rtws, itws, N) { + for (var i2 = 0; i2 < N; i2++) { + rtws[i2] = rws[rbt[i2]]; + itws[i2] = iws[rbt[i2]]; + } + }; + FFTM.prototype.transform = function transform(rws, iws, rtws, itws, N, rbt) { + this.permute(rbt, rws, iws, rtws, itws, N); + for (var s = 1; s < N; s <<= 1) { + var l = s << 1; + var rtwdf = Math.cos(2 * Math.PI / l); + var itwdf = Math.sin(2 * Math.PI / l); + for (var p = 0; p < N; p += l) { + var rtwdf_ = rtwdf; + var itwdf_ = itwdf; + for (var j = 0; j < s; j++) { + var re = rtws[p + j]; + var ie = itws[p + j]; + var ro = rtws[p + j + s]; + var io = itws[p + j + s]; + var rx = rtwdf_ * ro - itwdf_ * io; + io = rtwdf_ * io + itwdf_ * ro; + ro = rx; + rtws[p + j] = re + ro; + itws[p + j] = ie + io; + rtws[p + j + s] = re - ro; + itws[p + j + s] = ie - io; + if (j !== l) { + rx = rtwdf * rtwdf_ - itwdf * itwdf_; + itwdf_ = rtwdf * itwdf_ + itwdf * rtwdf_; + rtwdf_ = rx; + } + } + } + } + }; + FFTM.prototype.guessLen13b = function guessLen13b(n, m) { + var N = Math.max(m, n) | 1; + var odd = N & 1; + var i2 = 0; + for (N = N / 2 | 0; N; N = N >>> 1) { + i2++; + } + return 1 << i2 + 1 + odd; + }; + FFTM.prototype.conjugate = function conjugate(rws, iws, N) { + if (N <= 1) return; + for (var i2 = 0; i2 < N / 2; i2++) { + var t = rws[i2]; + rws[i2] = rws[N - i2 - 1]; + rws[N - i2 - 1] = t; + t = iws[i2]; + iws[i2] = -iws[N - i2 - 1]; + iws[N - i2 - 1] = -t; + } + }; + FFTM.prototype.normalize13b = function normalize13b(ws, N) { + var carry = 0; + for (var i2 = 0; i2 < N / 2; i2++) { + var w = Math.round(ws[2 * i2 + 1] / N) * 8192 + Math.round(ws[2 * i2] / N) + carry; + ws[i2] = w & 67108863; + if (w < 67108864) { + carry = 0; + } else { + carry = w / 67108864 | 0; + } + } + return ws; + }; + FFTM.prototype.convert13b = function convert13b(ws, len2, rws, N) { + var carry = 0; + for (var i2 = 0; i2 < len2; i2++) { + carry = carry + (ws[i2] | 0); + rws[2 * i2] = carry & 8191; + carry = carry >>> 13; + rws[2 * i2 + 1] = carry & 8191; + carry = carry >>> 13; + } + for (i2 = 2 * len2; i2 < N; ++i2) { + rws[i2] = 0; + } + assert(carry === 0); + assert((carry & -8192) === 0); + }; + FFTM.prototype.stub = function stub(N) { + var ph = new Array(N); + for (var i2 = 0; i2 < N; i2++) { + ph[i2] = 0; + } + return ph; + }; + FFTM.prototype.mulp = function mulp(x, y, out) { + var N = 2 * this.guessLen13b(x.length, y.length); + var rbt = this.makeRBT(N); + var _ = this.stub(N); + var rws = new Array(N); + var rwst = new Array(N); + var iwst = new Array(N); + var nrws = new Array(N); + var nrwst = new Array(N); + var niwst = new Array(N); + var rmws = out.words; + rmws.length = N; + this.convert13b(x.words, x.length, rws, N); + this.convert13b(y.words, y.length, nrws, N); + this.transform(rws, _, rwst, iwst, N, rbt); + this.transform(nrws, _, nrwst, niwst, N, rbt); + for (var i2 = 0; i2 < N; i2++) { + var rx = rwst[i2] * nrwst[i2] - iwst[i2] * niwst[i2]; + iwst[i2] = rwst[i2] * niwst[i2] + iwst[i2] * nrwst[i2]; + rwst[i2] = rx; + } + this.conjugate(rwst, iwst, N); + this.transform(rwst, iwst, rmws, _, N, rbt); + this.conjugate(rmws, _, N); + this.normalize13b(rmws, N); + out.negative = x.negative ^ y.negative; + out.length = x.length + y.length; + return out.strip(); + }; + BN.prototype.mul = function mul(num) { + var out = new BN(null); + out.words = new Array(this.length + num.length); + return this.mulTo(num, out); + }; + BN.prototype.mulf = function mulf(num) { + var out = new BN(null); + out.words = new Array(this.length + num.length); + return jumboMulTo(this, num, out); + }; + BN.prototype.imul = function imul(num) { + return this.clone().mulTo(num, this); + }; + BN.prototype.imuln = function imuln(num) { + assert(typeof num === "number"); + assert(num < 67108864); + var carry = 0; + for (var i2 = 0; i2 < this.length; i2++) { + var w = (this.words[i2] | 0) * num; + var lo = (w & 67108863) + (carry & 67108863); + carry >>= 26; + carry += w / 67108864 | 0; + carry += lo >>> 26; + this.words[i2] = lo & 67108863; + } + if (carry !== 0) { + this.words[i2] = carry; + this.length++; + } + return this; + }; + BN.prototype.muln = function muln(num) { + return this.clone().imuln(num); + }; + BN.prototype.sqr = function sqr() { + return this.mul(this); + }; + BN.prototype.isqr = function isqr() { + return this.imul(this.clone()); + }; + BN.prototype.pow = function pow(num) { + var w = toBitArray(num); + if (w.length === 0) return new BN(1); + var res = this; + for (var i2 = 0; i2 < w.length; i2++, res = res.sqr()) { + if (w[i2] !== 0) break; + } + if (++i2 < w.length) { + for (var q = res.sqr(); i2 < w.length; i2++, q = q.sqr()) { + if (w[i2] === 0) continue; + res = res.mul(q); + } + } + return res; + }; + BN.prototype.iushln = function iushln(bits) { + assert(typeof bits === "number" && bits >= 0); + var r = bits % 26; + var s = (bits - r) / 26; + var carryMask = 67108863 >>> 26 - r << 26 - r; + var i2; + if (r !== 0) { + var carry = 0; + for (i2 = 0; i2 < this.length; i2++) { + var newCarry = this.words[i2] & carryMask; + var c = (this.words[i2] | 0) - newCarry << r; + this.words[i2] = c | carry; + carry = newCarry >>> 26 - r; + } + if (carry) { + this.words[i2] = carry; + this.length++; + } + } + if (s !== 0) { + for (i2 = this.length - 1; i2 >= 0; i2--) { + this.words[i2 + s] = this.words[i2]; + } + for (i2 = 0; i2 < s; i2++) { + this.words[i2] = 0; + } + this.length += s; + } + return this.strip(); + }; + BN.prototype.ishln = function ishln(bits) { + assert(this.negative === 0); + return this.iushln(bits); + }; + BN.prototype.iushrn = function iushrn(bits, hint, extended) { + assert(typeof bits === "number" && bits >= 0); + var h; + if (hint) { + h = (hint - hint % 26) / 26; + } else { + h = 0; + } + var r = bits % 26; + var s = Math.min((bits - r) / 26, this.length); + var mask = 67108863 ^ 67108863 >>> r << r; + var maskedWords = extended; + h -= s; + h = Math.max(0, h); + if (maskedWords) { + for (var i2 = 0; i2 < s; i2++) { + maskedWords.words[i2] = this.words[i2]; + } + maskedWords.length = s; + } + if (s === 0) ; + else if (this.length > s) { + this.length -= s; + for (i2 = 0; i2 < this.length; i2++) { + this.words[i2] = this.words[i2 + s]; + } + } else { + this.words[0] = 0; + this.length = 1; + } + var carry = 0; + for (i2 = this.length - 1; i2 >= 0 && (carry !== 0 || i2 >= h); i2--) { + var word = this.words[i2] | 0; + this.words[i2] = carry << 26 - r | word >>> r; + carry = word & mask; + } + if (maskedWords && carry !== 0) { + maskedWords.words[maskedWords.length++] = carry; + } + if (this.length === 0) { + this.words[0] = 0; + this.length = 1; + } + return this.strip(); + }; + BN.prototype.ishrn = function ishrn(bits, hint, extended) { + assert(this.negative === 0); + return this.iushrn(bits, hint, extended); + }; + BN.prototype.shln = function shln(bits) { + return this.clone().ishln(bits); + }; + BN.prototype.ushln = function ushln(bits) { + return this.clone().iushln(bits); + }; + BN.prototype.shrn = function shrn(bits) { + return this.clone().ishrn(bits); + }; + BN.prototype.ushrn = function ushrn(bits) { + return this.clone().iushrn(bits); + }; + BN.prototype.testn = function testn(bit) { + assert(typeof bit === "number" && bit >= 0); + var r = bit % 26; + var s = (bit - r) / 26; + var q = 1 << r; + if (this.length <= s) return false; + var w = this.words[s]; + return !!(w & q); + }; + BN.prototype.imaskn = function imaskn(bits) { + assert(typeof bits === "number" && bits >= 0); + var r = bits % 26; + var s = (bits - r) / 26; + assert(this.negative === 0, "imaskn works only with positive numbers"); + if (this.length <= s) { + return this; + } + if (r !== 0) { + s++; + } + this.length = Math.min(s, this.length); + if (r !== 0) { + var mask = 67108863 ^ 67108863 >>> r << r; + this.words[this.length - 1] &= mask; + } + return this.strip(); + }; + BN.prototype.maskn = function maskn(bits) { + return this.clone().imaskn(bits); + }; + BN.prototype.iaddn = function iaddn(num) { + assert(typeof num === "number"); + assert(num < 67108864); + if (num < 0) return this.isubn(-num); + if (this.negative !== 0) { + if (this.length === 1 && (this.words[0] | 0) < num) { + this.words[0] = num - (this.words[0] | 0); + this.negative = 0; + return this; + } + this.negative = 0; + this.isubn(num); + this.negative = 1; + return this; + } + return this._iaddn(num); + }; + BN.prototype._iaddn = function _iaddn(num) { + this.words[0] += num; + for (var i2 = 0; i2 < this.length && this.words[i2] >= 67108864; i2++) { + this.words[i2] -= 67108864; + if (i2 === this.length - 1) { + this.words[i2 + 1] = 1; + } else { + this.words[i2 + 1]++; + } + } + this.length = Math.max(this.length, i2 + 1); + return this; + }; + BN.prototype.isubn = function isubn(num) { + assert(typeof num === "number"); + assert(num < 67108864); + if (num < 0) return this.iaddn(-num); + if (this.negative !== 0) { + this.negative = 0; + this.iaddn(num); + this.negative = 1; + return this; + } + this.words[0] -= num; + if (this.length === 1 && this.words[0] < 0) { + this.words[0] = -this.words[0]; + this.negative = 1; + } else { + for (var i2 = 0; i2 < this.length && this.words[i2] < 0; i2++) { + this.words[i2] += 67108864; + this.words[i2 + 1] -= 1; + } + } + return this.strip(); + }; + BN.prototype.addn = function addn(num) { + return this.clone().iaddn(num); + }; + BN.prototype.subn = function subn(num) { + return this.clone().isubn(num); + }; + BN.prototype.iabs = function iabs() { + this.negative = 0; + return this; + }; + BN.prototype.abs = function abs() { + return this.clone().iabs(); + }; + BN.prototype._ishlnsubmul = function _ishlnsubmul(num, mul, shift) { + var len2 = num.length + shift; + var i2; + this._expand(len2); + var w; + var carry = 0; + for (i2 = 0; i2 < num.length; i2++) { + w = (this.words[i2 + shift] | 0) + carry; + var right = (num.words[i2] | 0) * mul; + w -= right & 67108863; + carry = (w >> 26) - (right / 67108864 | 0); + this.words[i2 + shift] = w & 67108863; + } + for (; i2 < this.length - shift; i2++) { + w = (this.words[i2 + shift] | 0) + carry; + carry = w >> 26; + this.words[i2 + shift] = w & 67108863; + } + if (carry === 0) return this.strip(); + assert(carry === -1); + carry = 0; + for (i2 = 0; i2 < this.length; i2++) { + w = -(this.words[i2] | 0) + carry; + carry = w >> 26; + this.words[i2] = w & 67108863; + } + this.negative = 1; + return this.strip(); + }; + BN.prototype._wordDiv = function _wordDiv(num, mode) { + var shift = this.length - num.length; + var a = this.clone(); + var b = num; + var bhi = b.words[b.length - 1] | 0; + var bhiBits = this._countBits(bhi); + shift = 26 - bhiBits; + if (shift !== 0) { + b = b.ushln(shift); + a.iushln(shift); + bhi = b.words[b.length - 1] | 0; + } + var m = a.length - b.length; + var q; + if (mode !== "mod") { + q = new BN(null); + q.length = m + 1; + q.words = new Array(q.length); + for (var i2 = 0; i2 < q.length; i2++) { + q.words[i2] = 0; + } + } + var diff = a.clone()._ishlnsubmul(b, 1, m); + if (diff.negative === 0) { + a = diff; + if (q) { + q.words[m] = 1; + } + } + for (var j = m - 1; j >= 0; j--) { + var qj = (a.words[b.length + j] | 0) * 67108864 + (a.words[b.length + j - 1] | 0); + qj = Math.min(qj / bhi | 0, 67108863); + a._ishlnsubmul(b, qj, j); + while (a.negative !== 0) { + qj--; + a.negative = 0; + a._ishlnsubmul(b, 1, j); + if (!a.isZero()) { + a.negative ^= 1; + } + } + if (q) { + q.words[j] = qj; + } + } + if (q) { + q.strip(); + } + a.strip(); + if (mode !== "div" && shift !== 0) { + a.iushrn(shift); + } + return { + div: q || null, + mod: a + }; + }; + BN.prototype.divmod = function divmod(num, mode, positive) { + assert(!num.isZero()); + if (this.isZero()) { + return { + div: new BN(0), + mod: new BN(0) + }; + } + var div, mod, res; + if (this.negative !== 0 && num.negative === 0) { + res = this.neg().divmod(num, mode); + if (mode !== "mod") { + div = res.div.neg(); + } + if (mode !== "div") { + mod = res.mod.neg(); + if (positive && mod.negative !== 0) { + mod.iadd(num); + } + } + return { + div, + mod + }; + } + if (this.negative === 0 && num.negative !== 0) { + res = this.divmod(num.neg(), mode); + if (mode !== "mod") { + div = res.div.neg(); + } + return { + div, + mod: res.mod + }; + } + if ((this.negative & num.negative) !== 0) { + res = this.neg().divmod(num.neg(), mode); + if (mode !== "div") { + mod = res.mod.neg(); + if (positive && mod.negative !== 0) { + mod.isub(num); + } + } + return { + div: res.div, + mod + }; + } + if (num.length > this.length || this.cmp(num) < 0) { + return { + div: new BN(0), + mod: this + }; + } + if (num.length === 1) { + if (mode === "div") { + return { + div: this.divn(num.words[0]), + mod: null + }; + } + if (mode === "mod") { + return { + div: null, + mod: new BN(this.modn(num.words[0])) + }; + } + return { + div: this.divn(num.words[0]), + mod: new BN(this.modn(num.words[0])) + }; + } + return this._wordDiv(num, mode); + }; + BN.prototype.div = function div(num) { + return this.divmod(num, "div", false).div; + }; + BN.prototype.mod = function mod(num) { + return this.divmod(num, "mod", false).mod; + }; + BN.prototype.umod = function umod(num) { + return this.divmod(num, "mod", true).mod; + }; + BN.prototype.divRound = function divRound(num) { + var dm = this.divmod(num); + if (dm.mod.isZero()) return dm.div; + var mod = dm.div.negative !== 0 ? dm.mod.isub(num) : dm.mod; + var half = num.ushrn(1); + var r2 = num.andln(1); + var cmp = mod.cmp(half); + if (cmp < 0 || r2 === 1 && cmp === 0) return dm.div; + return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1); + }; + BN.prototype.modn = function modn(num) { + assert(num <= 67108863); + var p = (1 << 26) % num; + var acc = 0; + for (var i2 = this.length - 1; i2 >= 0; i2--) { + acc = (p * acc + (this.words[i2] | 0)) % num; + } + return acc; + }; + BN.prototype.idivn = function idivn(num) { + assert(num <= 67108863); + var carry = 0; + for (var i2 = this.length - 1; i2 >= 0; i2--) { + var w = (this.words[i2] | 0) + carry * 67108864; + this.words[i2] = w / num | 0; + carry = w % num; + } + return this.strip(); + }; + BN.prototype.divn = function divn(num) { + return this.clone().idivn(num); + }; + BN.prototype.egcd = function egcd(p) { + assert(p.negative === 0); + assert(!p.isZero()); + var x = this; + var y = p.clone(); + if (x.negative !== 0) { + x = x.umod(p); + } else { + x = x.clone(); + } + var A = new BN(1); + var B = new BN(0); + var C = new BN(0); + var D = new BN(1); + var g = 0; + while (x.isEven() && y.isEven()) { + x.iushrn(1); + y.iushrn(1); + ++g; + } + var yp = y.clone(); + var xp = x.clone(); + while (!x.isZero()) { + for (var i2 = 0, im = 1; (x.words[0] & im) === 0 && i2 < 26; ++i2, im <<= 1) ; + if (i2 > 0) { + x.iushrn(i2); + while (i2-- > 0) { + if (A.isOdd() || B.isOdd()) { + A.iadd(yp); + B.isub(xp); + } + A.iushrn(1); + B.iushrn(1); + } + } + for (var j = 0, jm = 1; (y.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1) ; + if (j > 0) { + y.iushrn(j); + while (j-- > 0) { + if (C.isOdd() || D.isOdd()) { + C.iadd(yp); + D.isub(xp); + } + C.iushrn(1); + D.iushrn(1); + } + } + if (x.cmp(y) >= 0) { + x.isub(y); + A.isub(C); + B.isub(D); + } else { + y.isub(x); + C.isub(A); + D.isub(B); + } + } + return { + a: C, + b: D, + gcd: y.iushln(g) + }; + }; + BN.prototype._invmp = function _invmp(p) { + assert(p.negative === 0); + assert(!p.isZero()); + var a = this; + var b = p.clone(); + if (a.negative !== 0) { + a = a.umod(p); + } else { + a = a.clone(); + } + var x1 = new BN(1); + var x2 = new BN(0); + var delta = b.clone(); + while (a.cmpn(1) > 0 && b.cmpn(1) > 0) { + for (var i2 = 0, im = 1; (a.words[0] & im) === 0 && i2 < 26; ++i2, im <<= 1) ; + if (i2 > 0) { + a.iushrn(i2); + while (i2-- > 0) { + if (x1.isOdd()) { + x1.iadd(delta); + } + x1.iushrn(1); + } + } + for (var j = 0, jm = 1; (b.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1) ; + if (j > 0) { + b.iushrn(j); + while (j-- > 0) { + if (x2.isOdd()) { + x2.iadd(delta); + } + x2.iushrn(1); + } + } + if (a.cmp(b) >= 0) { + a.isub(b); + x1.isub(x2); + } else { + b.isub(a); + x2.isub(x1); + } + } + var res; + if (a.cmpn(1) === 0) { + res = x1; + } else { + res = x2; + } + if (res.cmpn(0) < 0) { + res.iadd(p); + } + return res; + }; + BN.prototype.gcd = function gcd(num) { + if (this.isZero()) return num.abs(); + if (num.isZero()) return this.abs(); + var a = this.clone(); + var b = num.clone(); + a.negative = 0; + b.negative = 0; + for (var shift = 0; a.isEven() && b.isEven(); shift++) { + a.iushrn(1); + b.iushrn(1); + } + do { + while (a.isEven()) { + a.iushrn(1); + } + while (b.isEven()) { + b.iushrn(1); + } + var r = a.cmp(b); + if (r < 0) { + var t = a; + a = b; + b = t; + } else if (r === 0 || b.cmpn(1) === 0) { + break; + } + a.isub(b); + } while (true); + return b.iushln(shift); + }; + BN.prototype.invm = function invm(num) { + return this.egcd(num).a.umod(num); + }; + BN.prototype.isEven = function isEven() { + return (this.words[0] & 1) === 0; + }; + BN.prototype.isOdd = function isOdd() { + return (this.words[0] & 1) === 1; + }; + BN.prototype.andln = function andln(num) { + return this.words[0] & num; + }; + BN.prototype.bincn = function bincn(bit) { + assert(typeof bit === "number"); + var r = bit % 26; + var s = (bit - r) / 26; + var q = 1 << r; + if (this.length <= s) { + this._expand(s + 1); + this.words[s] |= q; + return this; + } + var carry = q; + for (var i2 = s; carry !== 0 && i2 < this.length; i2++) { + var w = this.words[i2] | 0; + w += carry; + carry = w >>> 26; + w &= 67108863; + this.words[i2] = w; + } + if (carry !== 0) { + this.words[i2] = carry; + this.length++; + } + return this; + }; + BN.prototype.isZero = function isZero() { + return this.length === 1 && this.words[0] === 0; + }; + BN.prototype.cmpn = function cmpn(num) { + var negative = num < 0; + if (this.negative !== 0 && !negative) return -1; + if (this.negative === 0 && negative) return 1; + this.strip(); + var res; + if (this.length > 1) { + res = 1; + } else { + if (negative) { + num = -num; + } + assert(num <= 67108863, "Number is too big"); + var w = this.words[0] | 0; + res = w === num ? 0 : w < num ? -1 : 1; + } + if (this.negative !== 0) return -res | 0; + return res; + }; + BN.prototype.cmp = function cmp(num) { + if (this.negative !== 0 && num.negative === 0) return -1; + if (this.negative === 0 && num.negative !== 0) return 1; + var res = this.ucmp(num); + if (this.negative !== 0) return -res | 0; + return res; + }; + BN.prototype.ucmp = function ucmp(num) { + if (this.length > num.length) return 1; + if (this.length < num.length) return -1; + var res = 0; + for (var i2 = this.length - 1; i2 >= 0; i2--) { + var a = this.words[i2] | 0; + var b = num.words[i2] | 0; + if (a === b) continue; + if (a < b) { + res = -1; + } else if (a > b) { + res = 1; + } + break; + } + return res; + }; + BN.prototype.gtn = function gtn(num) { + return this.cmpn(num) === 1; + }; + BN.prototype.gt = function gt(num) { + return this.cmp(num) === 1; + }; + BN.prototype.gten = function gten(num) { + return this.cmpn(num) >= 0; + }; + BN.prototype.gte = function gte(num) { + return this.cmp(num) >= 0; + }; + BN.prototype.ltn = function ltn(num) { + return this.cmpn(num) === -1; + }; + BN.prototype.lt = function lt(num) { + return this.cmp(num) === -1; + }; + BN.prototype.lten = function lten(num) { + return this.cmpn(num) <= 0; + }; + BN.prototype.lte = function lte(num) { + return this.cmp(num) <= 0; + }; + BN.prototype.eqn = function eqn(num) { + return this.cmpn(num) === 0; + }; + BN.prototype.eq = function eq(num) { + return this.cmp(num) === 0; + }; + BN.red = function red(num) { + return new Red(num); + }; + BN.prototype.toRed = function toRed(ctx) { + assert(!this.red, "Already a number in reduction context"); + assert(this.negative === 0, "red works only with positives"); + return ctx.convertTo(this)._forceRed(ctx); + }; + BN.prototype.fromRed = function fromRed() { + assert(this.red, "fromRed works only with numbers in reduction context"); + return this.red.convertFrom(this); + }; + BN.prototype._forceRed = function _forceRed(ctx) { + this.red = ctx; + return this; + }; + BN.prototype.forceRed = function forceRed(ctx) { + assert(!this.red, "Already a number in reduction context"); + return this._forceRed(ctx); + }; + BN.prototype.redAdd = function redAdd(num) { + assert(this.red, "redAdd works only with red numbers"); + return this.red.add(this, num); + }; + BN.prototype.redIAdd = function redIAdd(num) { + assert(this.red, "redIAdd works only with red numbers"); + return this.red.iadd(this, num); + }; + BN.prototype.redSub = function redSub(num) { + assert(this.red, "redSub works only with red numbers"); + return this.red.sub(this, num); + }; + BN.prototype.redISub = function redISub(num) { + assert(this.red, "redISub works only with red numbers"); + return this.red.isub(this, num); + }; + BN.prototype.redShl = function redShl(num) { + assert(this.red, "redShl works only with red numbers"); + return this.red.shl(this, num); + }; + BN.prototype.redMul = function redMul(num) { + assert(this.red, "redMul works only with red numbers"); + this.red._verify2(this, num); + return this.red.mul(this, num); + }; + BN.prototype.redIMul = function redIMul(num) { + assert(this.red, "redMul works only with red numbers"); + this.red._verify2(this, num); + return this.red.imul(this, num); + }; + BN.prototype.redSqr = function redSqr() { + assert(this.red, "redSqr works only with red numbers"); + this.red._verify1(this); + return this.red.sqr(this); + }; + BN.prototype.redISqr = function redISqr() { + assert(this.red, "redISqr works only with red numbers"); + this.red._verify1(this); + return this.red.isqr(this); + }; + BN.prototype.redSqrt = function redSqrt() { + assert(this.red, "redSqrt works only with red numbers"); + this.red._verify1(this); + return this.red.sqrt(this); + }; + BN.prototype.redInvm = function redInvm() { + assert(this.red, "redInvm works only with red numbers"); + this.red._verify1(this); + return this.red.invm(this); + }; + BN.prototype.redNeg = function redNeg() { + assert(this.red, "redNeg works only with red numbers"); + this.red._verify1(this); + return this.red.neg(this); + }; + BN.prototype.redPow = function redPow(num) { + assert(this.red && !num.red, "redPow(normalNum)"); + this.red._verify1(this); + return this.red.pow(this, num); + }; + var primes = { + k256: null, + p224: null, + p192: null, + p25519: null + }; + function MPrime(name, p) { + this.name = name; + this.p = new BN(p, 16); + this.n = this.p.bitLength(); + this.k = new BN(1).iushln(this.n).isub(this.p); + this.tmp = this._tmp(); + } + MPrime.prototype._tmp = function _tmp() { + var tmp = new BN(null); + tmp.words = new Array(Math.ceil(this.n / 13)); + return tmp; + }; + MPrime.prototype.ireduce = function ireduce(num) { + var r = num; + var rlen; + do { + this.split(r, this.tmp); + r = this.imulK(r); + r = r.iadd(this.tmp); + rlen = r.bitLength(); + } while (rlen > this.n); + var cmp = rlen < this.n ? -1 : r.ucmp(this.p); + if (cmp === 0) { + r.words[0] = 0; + r.length = 1; + } else if (cmp > 0) { + r.isub(this.p); + } else { + if (r.strip !== void 0) { + r.strip(); + } else { + r._strip(); + } + } + return r; + }; + MPrime.prototype.split = function split(input, out) { + input.iushrn(this.n, 0, out); + }; + MPrime.prototype.imulK = function imulK(num) { + return num.imul(this.k); + }; + function K256() { + MPrime.call( + this, + "k256", + "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f" + ); + } + inherits(K256, MPrime); + K256.prototype.split = function split(input, output) { + var mask = 4194303; + var outLen = Math.min(input.length, 9); + for (var i2 = 0; i2 < outLen; i2++) { + output.words[i2] = input.words[i2]; + } + output.length = outLen; + if (input.length <= 9) { + input.words[0] = 0; + input.length = 1; + return; + } + var prev = input.words[9]; + output.words[output.length++] = prev & mask; + for (i2 = 10; i2 < input.length; i2++) { + var next = input.words[i2] | 0; + input.words[i2 - 10] = (next & mask) << 4 | prev >>> 22; + prev = next; + } + prev >>>= 22; + input.words[i2 - 10] = prev; + if (prev === 0 && input.length > 10) { + input.length -= 10; + } else { + input.length -= 9; + } + }; + K256.prototype.imulK = function imulK(num) { + num.words[num.length] = 0; + num.words[num.length + 1] = 0; + num.length += 2; + var lo = 0; + for (var i2 = 0; i2 < num.length; i2++) { + var w = num.words[i2] | 0; + lo += w * 977; + num.words[i2] = lo & 67108863; + lo = w * 64 + (lo / 67108864 | 0); + } + if (num.words[num.length - 1] === 0) { + num.length--; + if (num.words[num.length - 1] === 0) { + num.length--; + } + } + return num; + }; + function P224() { + MPrime.call( + this, + "p224", + "ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001" + ); + } + inherits(P224, MPrime); + function P192() { + MPrime.call( + this, + "p192", + "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff" + ); + } + inherits(P192, MPrime); + function P25519() { + MPrime.call( + this, + "25519", + "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed" + ); + } + inherits(P25519, MPrime); + P25519.prototype.imulK = function imulK(num) { + var carry = 0; + for (var i2 = 0; i2 < num.length; i2++) { + var hi = (num.words[i2] | 0) * 19 + carry; + var lo = hi & 67108863; + hi >>>= 26; + num.words[i2] = lo; + carry = hi; + } + if (carry !== 0) { + num.words[num.length++] = carry; + } + return num; + }; + BN._prime = function prime(name) { + if (primes[name]) return primes[name]; + var prime2; + if (name === "k256") { + prime2 = new K256(); + } else if (name === "p224") { + prime2 = new P224(); + } else if (name === "p192") { + prime2 = new P192(); + } else if (name === "p25519") { + prime2 = new P25519(); + } else { + throw new Error("Unknown prime " + name); + } + primes[name] = prime2; + return prime2; + }; + function Red(m) { + if (typeof m === "string") { + var prime = BN._prime(m); + this.m = prime.p; + this.prime = prime; + } else { + assert(m.gtn(1), "modulus must be greater than 1"); + this.m = m; + this.prime = null; + } + } + Red.prototype._verify1 = function _verify1(a) { + assert(a.negative === 0, "red works only with positives"); + assert(a.red, "red works only with red numbers"); + }; + Red.prototype._verify2 = function _verify2(a, b) { + assert((a.negative | b.negative) === 0, "red works only with positives"); + assert( + a.red && a.red === b.red, + "red works only with red numbers" + ); + }; + Red.prototype.imod = function imod(a) { + if (this.prime) return this.prime.ireduce(a)._forceRed(this); + return a.umod(this.m)._forceRed(this); + }; + Red.prototype.neg = function neg(a) { + if (a.isZero()) { + return a.clone(); + } + return this.m.sub(a)._forceRed(this); + }; + Red.prototype.add = function add(a, b) { + this._verify2(a, b); + var res = a.add(b); + if (res.cmp(this.m) >= 0) { + res.isub(this.m); + } + return res._forceRed(this); + }; + Red.prototype.iadd = function iadd(a, b) { + this._verify2(a, b); + var res = a.iadd(b); + if (res.cmp(this.m) >= 0) { + res.isub(this.m); + } + return res; + }; + Red.prototype.sub = function sub(a, b) { + this._verify2(a, b); + var res = a.sub(b); + if (res.cmpn(0) < 0) { + res.iadd(this.m); + } + return res._forceRed(this); + }; + Red.prototype.isub = function isub(a, b) { + this._verify2(a, b); + var res = a.isub(b); + if (res.cmpn(0) < 0) { + res.iadd(this.m); + } + return res; + }; + Red.prototype.shl = function shl(a, num) { + this._verify1(a); + return this.imod(a.ushln(num)); + }; + Red.prototype.imul = function imul(a, b) { + this._verify2(a, b); + return this.imod(a.imul(b)); + }; + Red.prototype.mul = function mul(a, b) { + this._verify2(a, b); + return this.imod(a.mul(b)); + }; + Red.prototype.isqr = function isqr(a) { + return this.imul(a, a.clone()); + }; + Red.prototype.sqr = function sqr(a) { + return this.mul(a, a); + }; + Red.prototype.sqrt = function sqrt(a) { + if (a.isZero()) return a.clone(); + var mod3 = this.m.andln(3); + assert(mod3 % 2 === 1); + if (mod3 === 3) { + var pow = this.m.add(new BN(1)).iushrn(2); + return this.pow(a, pow); + } + var q = this.m.subn(1); + var s = 0; + while (!q.isZero() && q.andln(1) === 0) { + s++; + q.iushrn(1); + } + assert(!q.isZero()); + var one = new BN(1).toRed(this); + var nOne = one.redNeg(); + var lpow = this.m.subn(1).iushrn(1); + var z = this.m.bitLength(); + z = new BN(2 * z * z).toRed(this); + while (this.pow(z, lpow).cmp(nOne) !== 0) { + z.redIAdd(nOne); + } + var c = this.pow(z, q); + var r = this.pow(a, q.addn(1).iushrn(1)); + var t = this.pow(a, q); + var m = s; + while (t.cmp(one) !== 0) { + var tmp = t; + for (var i2 = 0; tmp.cmp(one) !== 0; i2++) { + tmp = tmp.redSqr(); + } + assert(i2 < m); + var b = this.pow(c, new BN(1).iushln(m - i2 - 1)); + r = r.redMul(b); + c = b.redSqr(); + t = t.redMul(c); + m = i2; + } + return r; + }; + Red.prototype.invm = function invm(a) { + var inv = a._invmp(this.m); + if (inv.negative !== 0) { + inv.negative = 0; + return this.imod(inv).redNeg(); + } else { + return this.imod(inv); + } + }; + Red.prototype.pow = function pow(a, num) { + if (num.isZero()) return new BN(1).toRed(this); + if (num.cmpn(1) === 0) return a.clone(); + var windowSize = 4; + var wnd = new Array(1 << windowSize); + wnd[0] = new BN(1).toRed(this); + wnd[1] = a; + for (var i2 = 2; i2 < wnd.length; i2++) { + wnd[i2] = this.mul(wnd[i2 - 1], a); + } + var res = wnd[0]; + var current = 0; + var currentLen = 0; + var start = num.bitLength() % 26; + if (start === 0) { + start = 26; + } + for (i2 = num.length - 1; i2 >= 0; i2--) { + var word = num.words[i2]; + for (var j = start - 1; j >= 0; j--) { + var bit = word >> j & 1; + if (res !== wnd[0]) { + res = this.sqr(res); + } + if (bit === 0 && current === 0) { + currentLen = 0; + continue; + } + current <<= 1; + current |= bit; + currentLen++; + if (currentLen !== windowSize && (i2 !== 0 || j !== 0)) continue; + res = this.mul(res, wnd[current]); + currentLen = 0; + current = 0; + } + start = 26; + } + return res; + }; + Red.prototype.convertTo = function convertTo(num) { + var r = num.umod(this.m); + return r === num ? r.clone() : r; + }; + Red.prototype.convertFrom = function convertFrom(num) { + var res = num.clone(); + res.red = null; + return res; + }; + BN.mont = function mont2(num) { + return new Mont(num); + }; + function Mont(m) { + Red.call(this, m); + this.shift = this.m.bitLength(); + if (this.shift % 26 !== 0) { + this.shift += 26 - this.shift % 26; + } + this.r = new BN(1).iushln(this.shift); + this.r2 = this.imod(this.r.sqr()); + this.rinv = this.r._invmp(this.m); + this.minv = this.rinv.mul(this.r).isubn(1).div(this.m); + this.minv = this.minv.umod(this.r); + this.minv = this.r.sub(this.minv); + } + inherits(Mont, Red); + Mont.prototype.convertTo = function convertTo(num) { + return this.imod(num.ushln(this.shift)); + }; + Mont.prototype.convertFrom = function convertFrom(num) { + var r = this.imod(num.mul(this.rinv)); + r.red = null; + return r; + }; + Mont.prototype.imul = function imul(a, b) { + if (a.isZero() || b.isZero()) { + a.words[0] = 0; + a.length = 1; + return a; + } + var t = a.imul(b); + var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m); + var u = t.isub(c).iushrn(this.shift); + var res = u; + if (u.cmp(this.m) >= 0) { + res = u.isub(this.m); + } else if (u.cmpn(0) < 0) { + res = u.iadd(this.m); + } + return res._forceRed(this); + }; + Mont.prototype.mul = function mul(a, b) { + if (a.isZero() || b.isZero()) return new BN(0)._forceRed(this); + var t = a.mul(b); + var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m); + var u = t.isub(c).iushrn(this.shift); + var res = u; + if (u.cmp(this.m) >= 0) { + res = u.isub(this.m); + } else if (u.cmpn(0) < 0) { + res = u.iadd(this.m); + } + return res._forceRed(this); + }; + Mont.prototype.invm = function invm(a) { + var res = this.imod(a._invmp(this.m).mul(this.r2)); + return res._forceRed(this); + }; + })(module2, bn$2); + })(bn$3); + return bn$3.exports; +} +var brorand = { exports: {} }; +var hasRequiredBrorand; +function requireBrorand() { + if (hasRequiredBrorand) return brorand.exports; + hasRequiredBrorand = 1; + var r; + brorand.exports = function rand(len2) { + if (!r) + r = new Rand(null); + return r.generate(len2); + }; + function Rand(rand) { + this.rand = rand; + } + brorand.exports.Rand = Rand; + Rand.prototype.generate = function generate(len2) { + return this._rand(len2); + }; + Rand.prototype._rand = function _rand(n) { + if (this.rand.getBytes) + return this.rand.getBytes(n); + var res = new Uint8Array(n); + for (var i2 = 0; i2 < res.length; i2++) + res[i2] = this.rand.getByte(); + return res; + }; + if (typeof self === "object") { + if (self.crypto && self.crypto.getRandomValues) { + Rand.prototype._rand = function _rand(n) { + var arr = new Uint8Array(n); + self.crypto.getRandomValues(arr); + return arr; + }; + } else if (self.msCrypto && self.msCrypto.getRandomValues) { + Rand.prototype._rand = function _rand(n) { + var arr = new Uint8Array(n); + self.msCrypto.getRandomValues(arr); + return arr; + }; + } else if (typeof window === "object") { + Rand.prototype._rand = function() { + throw new Error("Not implemented yet"); + }; + } + } else { + try { + var crypto = requireCryptoBrowserify(); + if (typeof crypto.randomBytes !== "function") + throw new Error("Not supported"); + Rand.prototype._rand = function _rand(n) { + return crypto.randomBytes(n); + }; + } catch (e) { + } + } + return brorand.exports; +} +var mr; +var hasRequiredMr; +function requireMr() { + if (hasRequiredMr) return mr; + hasRequiredMr = 1; + var bn2 = requireBn$1(); + var brorand2 = requireBrorand(); + function MillerRabin(rand) { + this.rand = rand || new brorand2.Rand(); + } + mr = MillerRabin; + MillerRabin.create = function create(rand) { + return new MillerRabin(rand); + }; + MillerRabin.prototype._randbelow = function _randbelow(n) { + var len2 = n.bitLength(); + var min_bytes = Math.ceil(len2 / 8); + do + var a = new bn2(this.rand.generate(min_bytes)); + while (a.cmp(n) >= 0); + return a; + }; + MillerRabin.prototype._randrange = function _randrange(start, stop) { + var size = stop.sub(start); + return start.add(this._randbelow(size)); + }; + MillerRabin.prototype.test = function test(n, k, cb) { + var len2 = n.bitLength(); + var red = bn2.mont(n); + var rone = new bn2(1).toRed(red); + if (!k) + k = Math.max(1, len2 / 48 | 0); + var n1 = n.subn(1); + for (var s = 0; !n1.testn(s); s++) { + } + var d = n.shrn(s); + var rn1 = n1.toRed(red); + var prime = true; + for (; k > 0; k--) { + var a = this._randrange(new bn2(2), n1); + if (cb) + cb(a); + var x = a.toRed(red).redPow(d); + if (x.cmp(rone) === 0 || x.cmp(rn1) === 0) + continue; + for (var i2 = 1; i2 < s; i2++) { + x = x.redSqr(); + if (x.cmp(rone) === 0) + return false; + if (x.cmp(rn1) === 0) + break; + } + if (i2 === s) + return false; + } + return prime; + }; + MillerRabin.prototype.getDivisor = function getDivisor(n, k) { + var len2 = n.bitLength(); + var red = bn2.mont(n); + var rone = new bn2(1).toRed(red); + if (!k) + k = Math.max(1, len2 / 48 | 0); + var n1 = n.subn(1); + for (var s = 0; !n1.testn(s); s++) { + } + var d = n.shrn(s); + var rn1 = n1.toRed(red); + for (; k > 0; k--) { + var a = this._randrange(new bn2(2), n1); + var g = n.gcd(a); + if (g.cmpn(1) !== 0) + return g; + var x = a.toRed(red).redPow(d); + if (x.cmp(rone) === 0 || x.cmp(rn1) === 0) + continue; + for (var i2 = 1; i2 < s; i2++) { + x = x.redSqr(); + if (x.cmp(rone) === 0) + return x.fromRed().subn(1).gcd(n); + if (x.cmp(rn1) === 0) + break; + } + if (i2 === s) { + x = x.redSqr(); + return x.fromRed().subn(1).gcd(n); + } + } + return false; + }; + return mr; +} +var generatePrime; +var hasRequiredGeneratePrime; +function requireGeneratePrime() { + if (hasRequiredGeneratePrime) return generatePrime; + hasRequiredGeneratePrime = 1; + var randomBytes = requireBrowser$b(); + generatePrime = findPrime; + findPrime.simpleSieve = simpleSieve; + findPrime.fermatTest = fermatTest; + var BN = requireBn$1(); + var TWENTYFOUR = new BN(24); + var MillerRabin = requireMr(); + var millerRabin = new MillerRabin(); + var ONE = new BN(1); + var TWO = new BN(2); + var FIVE = new BN(5); + new BN(16); + new BN(8); + var TEN = new BN(10); + var THREE = new BN(3); + new BN(7); + var ELEVEN = new BN(11); + var FOUR = new BN(4); + new BN(12); + var primes = null; + function _getPrimes() { + if (primes !== null) + return primes; + var limit = 1048576; + var res = []; + res[0] = 2; + for (var i2 = 1, k = 3; k < limit; k += 2) { + var sqrt = Math.ceil(Math.sqrt(k)); + for (var j = 0; j < i2 && res[j] <= sqrt; j++) + if (k % res[j] === 0) + break; + if (i2 !== j && res[j] <= sqrt) + continue; + res[i2++] = k; + } + primes = res; + return res; + } + function simpleSieve(p) { + var primes2 = _getPrimes(); + for (var i2 = 0; i2 < primes2.length; i2++) + if (p.modn(primes2[i2]) === 0) { + if (p.cmpn(primes2[i2]) === 0) { + return true; + } else { + return false; + } + } + return true; + } + function fermatTest(p) { + var red = BN.mont(p); + return TWO.toRed(red).redPow(p.subn(1)).fromRed().cmpn(1) === 0; + } + function findPrime(bits, gen) { + if (bits < 16) { + if (gen === 2 || gen === 5) { + return new BN([140, 123]); + } else { + return new BN([140, 39]); + } + } + gen = new BN(gen); + var num, n2; + while (true) { + num = new BN(randomBytes(Math.ceil(bits / 8))); + while (num.bitLength() > bits) { + num.ishrn(1); + } + if (num.isEven()) { + num.iadd(ONE); + } + if (!num.testn(1)) { + num.iadd(TWO); + } + if (!gen.cmp(TWO)) { + while (num.mod(TWENTYFOUR).cmp(ELEVEN)) { + num.iadd(FOUR); + } + } else if (!gen.cmp(FIVE)) { + while (num.mod(TEN).cmp(THREE)) { + num.iadd(FOUR); + } + } + n2 = num.shrn(1); + if (simpleSieve(n2) && simpleSieve(num) && fermatTest(n2) && fermatTest(num) && millerRabin.test(n2) && millerRabin.test(num)) { + return num; + } + } + } + return generatePrime; +} +const modp1 = { "gen": "02", "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a63a3620ffffffffffffffff" }; +const modp2 = { "gen": "02", "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece65381ffffffffffffffff" }; +const modp5 = { "gen": "02", "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca237327ffffffffffffffff" }; +const modp14 = { "gen": "02", "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aacaa68ffffffffffffffff" }; +const modp15 = { "gen": "02", "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a93ad2caffffffffffffffff" }; +const modp16 = { "gen": "02", "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a92108011a723c12a787e6d788719a10bdba5b2699c327186af4e23c1a946834b6150bda2583e9ca2ad44ce8dbbbc2db04de8ef92e8efc141fbecaa6287c59474e6bc05d99b2964fa090c3a2233ba186515be7ed1f612970cee2d7afb81bdd762170481cd0069127d5b05aa993b4ea988d8fddc186ffb7dc90a6c08f4df435c934063199ffffffffffffffff" }; +const modp17 = { "gen": "02", "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a92108011a723c12a787e6d788719a10bdba5b2699c327186af4e23c1a946834b6150bda2583e9ca2ad44ce8dbbbc2db04de8ef92e8efc141fbecaa6287c59474e6bc05d99b2964fa090c3a2233ba186515be7ed1f612970cee2d7afb81bdd762170481cd0069127d5b05aa993b4ea988d8fddc186ffb7dc90a6c08f4df435c93402849236c3fab4d27c7026c1d4dcb2602646dec9751e763dba37bdf8ff9406ad9e530ee5db382f413001aeb06a53ed9027d831179727b0865a8918da3edbebcf9b14ed44ce6cbaced4bb1bdb7f1447e6cc254b332051512bd7af426fb8f401378cd2bf5983ca01c64b92ecf032ea15d1721d03f482d7ce6e74fef6d55e702f46980c82b5a84031900b1c9e59e7c97fbec7e8f323a97a7e36cc88be0f1d45b7ff585ac54bd407b22b4154aacc8f6d7ebf48e1d814cc5ed20f8037e0a79715eef29be32806a1d58bb7c5da76f550aa3d8a1fbff0eb19ccb1a313d55cda56c9ec2ef29632387fe8d76e3c0468043e8f663f4860ee12bf2d5b0b7474d6e694f91e6dcc4024ffffffffffffffff" }; +const modp18 = { "gen": "02", "prime": "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" }; +const require$$1$1 = { + modp1, + modp2, + modp5, + modp14, + modp15, + modp16, + modp17, + modp18 +}; +var dh; +var hasRequiredDh; +function requireDh() { + if (hasRequiredDh) return dh; + hasRequiredDh = 1; + var BN = requireBn$1(); + var MillerRabin = requireMr(); + var millerRabin = new MillerRabin(); + var TWENTYFOUR = new BN(24); + var ELEVEN = new BN(11); + var TEN = new BN(10); + var THREE = new BN(3); + var SEVEN = new BN(7); + var primes = requireGeneratePrime(); + var randomBytes = requireBrowser$b(); + dh = DH; + function setPublicKey(pub, enc) { + enc = enc || "utf8"; + if (!Buffer.isBuffer(pub)) { + pub = new Buffer(pub, enc); + } + this._pub = new BN(pub); + return this; + } + function setPrivateKey(priv, enc) { + enc = enc || "utf8"; + if (!Buffer.isBuffer(priv)) { + priv = new Buffer(priv, enc); + } + this._priv = new BN(priv); + return this; + } + var primeCache = {}; + function checkPrime(prime, generator) { + var gen = generator.toString("hex"); + var hex = [gen, prime.toString(16)].join("_"); + if (hex in primeCache) { + return primeCache[hex]; + } + var error = 0; + if (prime.isEven() || !primes.simpleSieve || !primes.fermatTest(prime) || !millerRabin.test(prime)) { + error += 1; + if (gen === "02" || gen === "05") { + error += 8; + } else { + error += 4; + } + primeCache[hex] = error; + return error; + } + if (!millerRabin.test(prime.shrn(1))) { + error += 2; + } + var rem; + switch (gen) { + case "02": + if (prime.mod(TWENTYFOUR).cmp(ELEVEN)) { + error += 8; + } + break; + case "05": + rem = prime.mod(TEN); + if (rem.cmp(THREE) && rem.cmp(SEVEN)) { + error += 8; + } + break; + default: + error += 4; + } + primeCache[hex] = error; + return error; + } + function DH(prime, generator, malleable) { + this.setGenerator(generator); + this.__prime = new BN(prime); + this._prime = BN.mont(this.__prime); + this._primeLen = prime.length; + this._pub = void 0; + this._priv = void 0; + this._primeCode = void 0; + if (malleable) { + this.setPublicKey = setPublicKey; + this.setPrivateKey = setPrivateKey; + } else { + this._primeCode = 8; + } + } + Object.defineProperty(DH.prototype, "verifyError", { + enumerable: true, + get: function() { + if (typeof this._primeCode !== "number") { + this._primeCode = checkPrime(this.__prime, this.__gen); + } + return this._primeCode; + } + }); + DH.prototype.generateKeys = function() { + if (!this._priv) { + this._priv = new BN(randomBytes(this._primeLen)); + } + this._pub = this._gen.toRed(this._prime).redPow(this._priv).fromRed(); + return this.getPublicKey(); + }; + DH.prototype.computeSecret = function(other) { + other = new BN(other); + other = other.toRed(this._prime); + var secret = other.redPow(this._priv).fromRed(); + var out = new Buffer(secret.toArray()); + var prime = this.getPrime(); + if (out.length < prime.length) { + var front = new Buffer(prime.length - out.length); + front.fill(0); + out = Buffer.concat([front, out]); + } + return out; + }; + DH.prototype.getPublicKey = function getPublicKey(enc) { + return formatReturnValue(this._pub, enc); + }; + DH.prototype.getPrivateKey = function getPrivateKey(enc) { + return formatReturnValue(this._priv, enc); + }; + DH.prototype.getPrime = function(enc) { + return formatReturnValue(this.__prime, enc); + }; + DH.prototype.getGenerator = function(enc) { + return formatReturnValue(this._gen, enc); + }; + DH.prototype.setGenerator = function(gen, enc) { + enc = enc || "utf8"; + if (!Buffer.isBuffer(gen)) { + gen = new Buffer(gen, enc); + } + this.__gen = gen; + this._gen = new BN(gen); + return this; + }; + function formatReturnValue(bn2, enc) { + var buf = new Buffer(bn2.toArray()); + if (!enc) { + return buf; + } else { + return buf.toString(enc); + } + } + return dh; +} +var hasRequiredBrowser$4; +function requireBrowser$4() { + if (hasRequiredBrowser$4) return browser$4; + hasRequiredBrowser$4 = 1; + var generatePrime2 = requireGeneratePrime(); + var primes = require$$1$1; + var DH = requireDh(); + function getDiffieHellman(mod) { + var prime = new Buffer(primes[mod].prime, "hex"); + var gen = new Buffer(primes[mod].gen, "hex"); + return new DH(prime, gen); + } + var ENCODINGS = { + "binary": true, + "hex": true, + "base64": true + }; + function createDiffieHellman(prime, enc, generator, genc) { + if (Buffer.isBuffer(enc) || ENCODINGS[enc] === void 0) { + return createDiffieHellman(prime, "binary", enc, generator); + } + enc = enc || "binary"; + genc = genc || "binary"; + generator = generator || new Buffer([2]); + if (!Buffer.isBuffer(generator)) { + generator = new Buffer(generator, genc); + } + if (typeof prime === "number") { + return new DH(generatePrime2(prime, generator), generator, true); + } + if (!Buffer.isBuffer(prime)) { + prime = new Buffer(prime, enc); + } + return new DH(prime, generator, true); + } + browser$4.DiffieHellmanGroup = browser$4.createDiffieHellmanGroup = browser$4.getDiffieHellman = getDiffieHellman; + browser$4.createDiffieHellman = browser$4.DiffieHellman = createDiffieHellman; + return browser$4; +} +var readableBrowser = { exports: {} }; +var processNextickArgs = { exports: {} }; +var hasRequiredProcessNextickArgs; +function requireProcessNextickArgs() { + if (hasRequiredProcessNextickArgs) return processNextickArgs.exports; + hasRequiredProcessNextickArgs = 1; + if (typeof process$1 === "undefined" || !process$1.version || process$1.version.indexOf("v0.") === 0 || process$1.version.indexOf("v1.") === 0 && process$1.version.indexOf("v1.8.") !== 0) { + processNextickArgs.exports = { nextTick }; + } else { + processNextickArgs.exports = process$1; + } + function nextTick(fn, arg1, arg2, arg3) { + if (typeof fn !== "function") { + throw new TypeError('"callback" argument must be a function'); + } + var len2 = arguments.length; + var args, i2; + switch (len2) { + case 0: + case 1: + return process$1.nextTick(fn); + case 2: + return process$1.nextTick(function afterTickOne() { + fn.call(null, arg1); + }); + case 3: + return process$1.nextTick(function afterTickTwo() { + fn.call(null, arg1, arg2); + }); + case 4: + return process$1.nextTick(function afterTickThree() { + fn.call(null, arg1, arg2, arg3); + }); + default: + args = new Array(len2 - 1); + i2 = 0; + while (i2 < args.length) { + args[i2++] = arguments[i2]; + } + return process$1.nextTick(function afterTick() { + fn.apply(null, args); + }); + } + } + return processNextickArgs.exports; +} +var isarray; +var hasRequiredIsarray; +function requireIsarray() { + if (hasRequiredIsarray) return isarray; + hasRequiredIsarray = 1; + var toString = {}.toString; + isarray = Array.isArray || function(arr) { + return toString.call(arr) == "[object Array]"; + }; + return isarray; +} +var streamBrowser; +var hasRequiredStreamBrowser; +function requireStreamBrowser() { + if (hasRequiredStreamBrowser) return streamBrowser; + hasRequiredStreamBrowser = 1; + streamBrowser = requireEvents().EventEmitter; + return streamBrowser; +} +var safeBuffer = { exports: {} }; +var hasRequiredSafeBuffer; +function requireSafeBuffer() { + if (hasRequiredSafeBuffer) return safeBuffer.exports; + hasRequiredSafeBuffer = 1; + (function(module2, exports2) { + var buffer2 = requireDist(); + var Buffer2 = buffer2.Buffer; + function copyProps(src, dst) { + for (var key2 in src) { + dst[key2] = src[key2]; + } + } + if (Buffer2.from && Buffer2.alloc && Buffer2.allocUnsafe && Buffer2.allocUnsafeSlow) { + module2.exports = buffer2; + } else { + copyProps(buffer2, exports2); + exports2.Buffer = SafeBuffer; + } + function SafeBuffer(arg, encodingOrOffset, length) { + return Buffer2(arg, encodingOrOffset, length); + } + copyProps(Buffer2, SafeBuffer); + SafeBuffer.from = function(arg, encodingOrOffset, length) { + if (typeof arg === "number") { + throw new TypeError("Argument must not be a number"); + } + return Buffer2(arg, encodingOrOffset, length); + }; + SafeBuffer.alloc = function(size, fill, encoding) { + if (typeof size !== "number") { + throw new TypeError("Argument must be a number"); + } + var buf = Buffer2(size); + if (fill !== void 0) { + if (typeof encoding === "string") { + buf.fill(fill, encoding); + } else { + buf.fill(fill); + } + } else { + buf.fill(0); + } + return buf; + }; + SafeBuffer.allocUnsafe = function(size) { + if (typeof size !== "number") { + throw new TypeError("Argument must be a number"); + } + return Buffer2(size); + }; + SafeBuffer.allocUnsafeSlow = function(size) { + if (typeof size !== "number") { + throw new TypeError("Argument must be a number"); + } + return buffer2.SlowBuffer(size); + }; + })(safeBuffer, safeBuffer.exports); + return safeBuffer.exports; +} +var util = {}; +var hasRequiredUtil; +function requireUtil() { + if (hasRequiredUtil) return util; + hasRequiredUtil = 1; + function isArray(arg) { + if (Array.isArray) { + return Array.isArray(arg); + } + return objectToString(arg) === "[object Array]"; + } + util.isArray = isArray; + function isBoolean(arg) { + return typeof arg === "boolean"; + } + util.isBoolean = isBoolean; + function isNull(arg) { + return arg === null; + } + util.isNull = isNull; + function isNullOrUndefined(arg) { + return arg == null; + } + util.isNullOrUndefined = isNullOrUndefined; + function isNumber(arg) { + return typeof arg === "number"; + } + util.isNumber = isNumber; + function isString(arg) { + return typeof arg === "string"; + } + util.isString = isString; + function isSymbol2(arg) { + return typeof arg === "symbol"; + } + util.isSymbol = isSymbol2; + function isUndefined(arg) { + return arg === void 0; + } + util.isUndefined = isUndefined; + function isRegExp(re) { + return objectToString(re) === "[object RegExp]"; + } + util.isRegExp = isRegExp; + function isObject(arg) { + return typeof arg === "object" && arg !== null; + } + util.isObject = isObject; + function isDate(d) { + return objectToString(d) === "[object Date]"; + } + util.isDate = isDate; + function isError(e) { + return objectToString(e) === "[object Error]" || e instanceof Error; + } + util.isError = isError; + function isFunction(arg) { + return typeof arg === "function"; + } + util.isFunction = isFunction; + function isPrimitive(arg) { + return arg === null || typeof arg === "boolean" || typeof arg === "number" || typeof arg === "string" || typeof arg === "symbol" || // ES6 symbol + typeof arg === "undefined"; + } + util.isPrimitive = isPrimitive; + util.isBuffer = requireDist().Buffer.isBuffer; + function objectToString(o) { + return Object.prototype.toString.call(o); + } + return util; +} +var BufferList = { exports: {} }; +var hasRequiredBufferList; +function requireBufferList() { + if (hasRequiredBufferList) return BufferList.exports; + hasRequiredBufferList = 1; + (function(module2) { + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + } + var Buffer2 = requireSafeBuffer().Buffer; + var util2 = requireUtil$1(); + function copyBuffer(src, target, offset) { + src.copy(target, offset); + } + module2.exports = function() { + function BufferList2() { + _classCallCheck(this, BufferList2); + this.head = null; + this.tail = null; + this.length = 0; + } + BufferList2.prototype.push = function push(v) { + var entry = { data: v, next: null }; + if (this.length > 0) this.tail.next = entry; + else this.head = entry; + this.tail = entry; + ++this.length; + }; + BufferList2.prototype.unshift = function unshift(v) { + var entry = { data: v, next: this.head }; + if (this.length === 0) this.tail = entry; + this.head = entry; + ++this.length; + }; + BufferList2.prototype.shift = function shift() { + if (this.length === 0) return; + var ret = this.head.data; + if (this.length === 1) this.head = this.tail = null; + else this.head = this.head.next; + --this.length; + return ret; + }; + BufferList2.prototype.clear = function clear() { + this.head = this.tail = null; + this.length = 0; + }; + BufferList2.prototype.join = function join2(s) { + if (this.length === 0) return ""; + var p = this.head; + var ret = "" + p.data; + while (p = p.next) { + ret += s + p.data; + } + return ret; + }; + BufferList2.prototype.concat = function concat(n) { + if (this.length === 0) return Buffer2.alloc(0); + var ret = Buffer2.allocUnsafe(n >>> 0); + var p = this.head; + var i2 = 0; + while (p) { + copyBuffer(p.data, ret, i2); + i2 += p.data.length; + p = p.next; + } + return ret; + }; + return BufferList2; + }(); + if (util2 && util2.inspect && util2.inspect.custom) { + module2.exports.prototype[util2.inspect.custom] = function() { + var obj = util2.inspect({ length: this.length }); + return this.constructor.name + " " + obj; + }; + } + })(BufferList); + return BufferList.exports; +} +var destroy_1; +var hasRequiredDestroy; +function requireDestroy() { + if (hasRequiredDestroy) return destroy_1; + hasRequiredDestroy = 1; + var pna = requireProcessNextickArgs(); + function destroy(err, cb) { + var _this = this; + var readableDestroyed = this._readableState && this._readableState.destroyed; + var writableDestroyed = this._writableState && this._writableState.destroyed; + if (readableDestroyed || writableDestroyed) { + if (cb) { + cb(err); + } else if (err) { + if (!this._writableState) { + pna.nextTick(emitErrorNT, this, err); + } else if (!this._writableState.errorEmitted) { + this._writableState.errorEmitted = true; + pna.nextTick(emitErrorNT, this, err); + } + } + return this; + } + if (this._readableState) { + this._readableState.destroyed = true; + } + if (this._writableState) { + this._writableState.destroyed = true; + } + this._destroy(err || null, function(err2) { + if (!cb && err2) { + if (!_this._writableState) { + pna.nextTick(emitErrorNT, _this, err2); + } else if (!_this._writableState.errorEmitted) { + _this._writableState.errorEmitted = true; + pna.nextTick(emitErrorNT, _this, err2); + } + } else if (cb) { + cb(err2); + } + }); + return this; + } + function undestroy() { + if (this._readableState) { + this._readableState.destroyed = false; + this._readableState.reading = false; + this._readableState.ended = false; + this._readableState.endEmitted = false; + } + if (this._writableState) { + this._writableState.destroyed = false; + this._writableState.ended = false; + this._writableState.ending = false; + this._writableState.finalCalled = false; + this._writableState.prefinished = false; + this._writableState.finished = false; + this._writableState.errorEmitted = false; + } + } + function emitErrorNT(self2, err) { + self2.emit("error", err); + } + destroy_1 = { + destroy, + undestroy + }; + return destroy_1; +} +var _stream_writable; +var hasRequired_stream_writable; +function require_stream_writable() { + if (hasRequired_stream_writable) return _stream_writable; + hasRequired_stream_writable = 1; + var pna = requireProcessNextickArgs(); + _stream_writable = Writable; + function CorkedRequest(state2) { + var _this = this; + this.next = null; + this.entry = null; + this.finish = function() { + onCorkedFinish(_this, state2); + }; + } + var asyncWrite = !process$1.browser && ["v0.10", "v0.9."].indexOf(process$1.version.slice(0, 5)) > -1 ? setImmediate : pna.nextTick; + var Duplex; + Writable.WritableState = WritableState; + var util2 = Object.create(requireUtil()); + util2.inherits = requireInherits_browser(); + var internalUtil = { + deprecate: requireBrowser$a() + }; + var Stream = requireStreamBrowser(); + var Buffer2 = requireSafeBuffer().Buffer; + var OurUint8Array = (typeof commonjsGlobal !== "undefined" ? commonjsGlobal : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : {}).Uint8Array || function() { + }; + function _uint8ArrayToBuffer(chunk2) { + return Buffer2.from(chunk2); + } + function _isUint8Array(obj) { + return Buffer2.isBuffer(obj) || obj instanceof OurUint8Array; + } + var destroyImpl = requireDestroy(); + util2.inherits(Writable, Stream); + function nop() { + } + function WritableState(options, stream) { + Duplex = Duplex || require_stream_duplex(); + options = options || {}; + var isDuplex = stream instanceof Duplex; + this.objectMode = !!options.objectMode; + if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode; + var hwm = options.highWaterMark; + var writableHwm = options.writableHighWaterMark; + var defaultHwm = this.objectMode ? 16 : 16 * 1024; + if (hwm || hwm === 0) this.highWaterMark = hwm; + else if (isDuplex && (writableHwm || writableHwm === 0)) this.highWaterMark = writableHwm; + else this.highWaterMark = defaultHwm; + this.highWaterMark = Math.floor(this.highWaterMark); + this.finalCalled = false; + this.needDrain = false; + this.ending = false; + this.ended = false; + this.finished = false; + this.destroyed = false; + var noDecode = options.decodeStrings === false; + this.decodeStrings = !noDecode; + this.defaultEncoding = options.defaultEncoding || "utf8"; + this.length = 0; + this.writing = false; + this.corked = 0; + this.sync = true; + this.bufferProcessing = false; + this.onwrite = function(er) { + onwrite(stream, er); + }; + this.writecb = null; + this.writelen = 0; + this.bufferedRequest = null; + this.lastBufferedRequest = null; + this.pendingcb = 0; + this.prefinished = false; + this.errorEmitted = false; + this.bufferedRequestCount = 0; + this.corkedRequestsFree = new CorkedRequest(this); + } + WritableState.prototype.getBuffer = function getBuffer() { + var current = this.bufferedRequest; + var out = []; + while (current) { + out.push(current); + current = current.next; + } + return out; + }; + (function() { + try { + Object.defineProperty(WritableState.prototype, "buffer", { + get: internalUtil.deprecate(function() { + return this.getBuffer(); + }, "_writableState.buffer is deprecated. Use _writableState.getBuffer instead.", "DEP0003") + }); + } catch (_) { + } + })(); + var realHasInstance; + if (typeof Symbol === "function" && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === "function") { + realHasInstance = Function.prototype[Symbol.hasInstance]; + Object.defineProperty(Writable, Symbol.hasInstance, { + value: function(object) { + if (realHasInstance.call(this, object)) return true; + if (this !== Writable) return false; + return object && object._writableState instanceof WritableState; + } + }); + } else { + realHasInstance = function(object) { + return object instanceof this; + }; + } + function Writable(options) { + Duplex = Duplex || require_stream_duplex(); + if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) { + return new Writable(options); + } + this._writableState = new WritableState(options, this); + this.writable = true; + if (options) { + if (typeof options.write === "function") this._write = options.write; + if (typeof options.writev === "function") this._writev = options.writev; + if (typeof options.destroy === "function") this._destroy = options.destroy; + if (typeof options.final === "function") this._final = options.final; + } + Stream.call(this); + } + Writable.prototype.pipe = function() { + this.emit("error", new Error("Cannot pipe, not readable")); + }; + function writeAfterEnd(stream, cb) { + var er = new Error("write after end"); + stream.emit("error", er); + pna.nextTick(cb, er); + } + function validChunk(stream, state2, chunk2, cb) { + var valid = true; + var er = false; + if (chunk2 === null) { + er = new TypeError("May not write null values to stream"); + } else if (typeof chunk2 !== "string" && chunk2 !== void 0 && !state2.objectMode) { + er = new TypeError("Invalid non-string/buffer chunk"); + } + if (er) { + stream.emit("error", er); + pna.nextTick(cb, er); + valid = false; + } + return valid; + } + Writable.prototype.write = function(chunk2, encoding, cb) { + var state2 = this._writableState; + var ret = false; + var isBuf = !state2.objectMode && _isUint8Array(chunk2); + if (isBuf && !Buffer2.isBuffer(chunk2)) { + chunk2 = _uint8ArrayToBuffer(chunk2); + } + if (typeof encoding === "function") { + cb = encoding; + encoding = null; + } + if (isBuf) encoding = "buffer"; + else if (!encoding) encoding = state2.defaultEncoding; + if (typeof cb !== "function") cb = nop; + if (state2.ended) writeAfterEnd(this, cb); + else if (isBuf || validChunk(this, state2, chunk2, cb)) { + state2.pendingcb++; + ret = writeOrBuffer(this, state2, isBuf, chunk2, encoding, cb); + } + return ret; + }; + Writable.prototype.cork = function() { + var state2 = this._writableState; + state2.corked++; + }; + Writable.prototype.uncork = function() { + var state2 = this._writableState; + if (state2.corked) { + state2.corked--; + if (!state2.writing && !state2.corked && !state2.bufferProcessing && state2.bufferedRequest) clearBuffer(this, state2); + } + }; + Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) { + if (typeof encoding === "string") encoding = encoding.toLowerCase(); + if (!(["hex", "utf8", "utf-8", "ascii", "binary", "base64", "ucs2", "ucs-2", "utf16le", "utf-16le", "raw"].indexOf((encoding + "").toLowerCase()) > -1)) throw new TypeError("Unknown encoding: " + encoding); + this._writableState.defaultEncoding = encoding; + return this; + }; + function decodeChunk(state2, chunk2, encoding) { + if (!state2.objectMode && state2.decodeStrings !== false && typeof chunk2 === "string") { + chunk2 = Buffer2.from(chunk2, encoding); + } + return chunk2; + } + Object.defineProperty(Writable.prototype, "writableHighWaterMark", { + // making it explicit this property is not enumerable + // because otherwise some prototype manipulation in + // userland will fail + enumerable: false, + get: function() { + return this._writableState.highWaterMark; + } + }); + function writeOrBuffer(stream, state2, isBuf, chunk2, encoding, cb) { + if (!isBuf) { + var newChunk = decodeChunk(state2, chunk2, encoding); + if (chunk2 !== newChunk) { + isBuf = true; + encoding = "buffer"; + chunk2 = newChunk; + } + } + var len2 = state2.objectMode ? 1 : chunk2.length; + state2.length += len2; + var ret = state2.length < state2.highWaterMark; + if (!ret) state2.needDrain = true; + if (state2.writing || state2.corked) { + var last = state2.lastBufferedRequest; + state2.lastBufferedRequest = { + chunk: chunk2, + encoding, + isBuf, + callback: cb, + next: null + }; + if (last) { + last.next = state2.lastBufferedRequest; + } else { + state2.bufferedRequest = state2.lastBufferedRequest; + } + state2.bufferedRequestCount += 1; + } else { + doWrite(stream, state2, false, len2, chunk2, encoding, cb); + } + return ret; + } + function doWrite(stream, state2, writev, len2, chunk2, encoding, cb) { + state2.writelen = len2; + state2.writecb = cb; + state2.writing = true; + state2.sync = true; + if (writev) stream._writev(chunk2, state2.onwrite); + else stream._write(chunk2, encoding, state2.onwrite); + state2.sync = false; + } + function onwriteError(stream, state2, sync, er, cb) { + --state2.pendingcb; + if (sync) { + pna.nextTick(cb, er); + pna.nextTick(finishMaybe, stream, state2); + stream._writableState.errorEmitted = true; + stream.emit("error", er); + } else { + cb(er); + stream._writableState.errorEmitted = true; + stream.emit("error", er); + finishMaybe(stream, state2); + } + } + function onwriteStateUpdate(state2) { + state2.writing = false; + state2.writecb = null; + state2.length -= state2.writelen; + state2.writelen = 0; + } + function onwrite(stream, er) { + var state2 = stream._writableState; + var sync = state2.sync; + var cb = state2.writecb; + onwriteStateUpdate(state2); + if (er) onwriteError(stream, state2, sync, er, cb); + else { + var finished = needFinish(state2); + if (!finished && !state2.corked && !state2.bufferProcessing && state2.bufferedRequest) { + clearBuffer(stream, state2); + } + if (sync) { + asyncWrite(afterWrite, stream, state2, finished, cb); + } else { + afterWrite(stream, state2, finished, cb); + } + } + } + function afterWrite(stream, state2, finished, cb) { + if (!finished) onwriteDrain(stream, state2); + state2.pendingcb--; + cb(); + finishMaybe(stream, state2); + } + function onwriteDrain(stream, state2) { + if (state2.length === 0 && state2.needDrain) { + state2.needDrain = false; + stream.emit("drain"); + } + } + function clearBuffer(stream, state2) { + state2.bufferProcessing = true; + var entry = state2.bufferedRequest; + if (stream._writev && entry && entry.next) { + var l = state2.bufferedRequestCount; + var buffer2 = new Array(l); + var holder = state2.corkedRequestsFree; + holder.entry = entry; + var count = 0; + var allBuffers = true; + while (entry) { + buffer2[count] = entry; + if (!entry.isBuf) allBuffers = false; + entry = entry.next; + count += 1; + } + buffer2.allBuffers = allBuffers; + doWrite(stream, state2, true, state2.length, buffer2, "", holder.finish); + state2.pendingcb++; + state2.lastBufferedRequest = null; + if (holder.next) { + state2.corkedRequestsFree = holder.next; + holder.next = null; + } else { + state2.corkedRequestsFree = new CorkedRequest(state2); + } + state2.bufferedRequestCount = 0; + } else { + while (entry) { + var chunk2 = entry.chunk; + var encoding = entry.encoding; + var cb = entry.callback; + var len2 = state2.objectMode ? 1 : chunk2.length; + doWrite(stream, state2, false, len2, chunk2, encoding, cb); + entry = entry.next; + state2.bufferedRequestCount--; + if (state2.writing) { + break; + } + } + if (entry === null) state2.lastBufferedRequest = null; + } + state2.bufferedRequest = entry; + state2.bufferProcessing = false; + } + Writable.prototype._write = function(chunk2, encoding, cb) { + cb(new Error("_write() is not implemented")); + }; + Writable.prototype._writev = null; + Writable.prototype.end = function(chunk2, encoding, cb) { + var state2 = this._writableState; + if (typeof chunk2 === "function") { + cb = chunk2; + chunk2 = null; + encoding = null; + } else if (typeof encoding === "function") { + cb = encoding; + encoding = null; + } + if (chunk2 !== null && chunk2 !== void 0) this.write(chunk2, encoding); + if (state2.corked) { + state2.corked = 1; + this.uncork(); + } + if (!state2.ending) endWritable(this, state2, cb); + }; + function needFinish(state2) { + return state2.ending && state2.length === 0 && state2.bufferedRequest === null && !state2.finished && !state2.writing; + } + function callFinal(stream, state2) { + stream._final(function(err) { + state2.pendingcb--; + if (err) { + stream.emit("error", err); + } + state2.prefinished = true; + stream.emit("prefinish"); + finishMaybe(stream, state2); + }); + } + function prefinish(stream, state2) { + if (!state2.prefinished && !state2.finalCalled) { + if (typeof stream._final === "function") { + state2.pendingcb++; + state2.finalCalled = true; + pna.nextTick(callFinal, stream, state2); + } else { + state2.prefinished = true; + stream.emit("prefinish"); + } + } + } + function finishMaybe(stream, state2) { + var need = needFinish(state2); + if (need) { + prefinish(stream, state2); + if (state2.pendingcb === 0) { + state2.finished = true; + stream.emit("finish"); + } + } + return need; + } + function endWritable(stream, state2, cb) { + state2.ending = true; + finishMaybe(stream, state2); + if (cb) { + if (state2.finished) pna.nextTick(cb); + else stream.once("finish", cb); + } + state2.ended = true; + stream.writable = false; + } + function onCorkedFinish(corkReq, state2, err) { + var entry = corkReq.entry; + corkReq.entry = null; + while (entry) { + var cb = entry.callback; + state2.pendingcb--; + cb(err); + entry = entry.next; + } + state2.corkedRequestsFree.next = corkReq; + } + Object.defineProperty(Writable.prototype, "destroyed", { + get: function() { + if (this._writableState === void 0) { + return false; + } + return this._writableState.destroyed; + }, + set: function(value) { + if (!this._writableState) { + return; + } + this._writableState.destroyed = value; + } + }); + Writable.prototype.destroy = destroyImpl.destroy; + Writable.prototype._undestroy = destroyImpl.undestroy; + Writable.prototype._destroy = function(err, cb) { + this.end(); + cb(err); + }; + return _stream_writable; +} +var _stream_duplex; +var hasRequired_stream_duplex; +function require_stream_duplex() { + if (hasRequired_stream_duplex) return _stream_duplex; + hasRequired_stream_duplex = 1; + var pna = requireProcessNextickArgs(); + var objectKeys = Object.keys || function(obj) { + var keys2 = []; + for (var key2 in obj) { + keys2.push(key2); + } + return keys2; + }; + _stream_duplex = Duplex; + var util2 = Object.create(requireUtil()); + util2.inherits = requireInherits_browser(); + var Readable = require_stream_readable(); + var Writable = require_stream_writable(); + util2.inherits(Duplex, Readable); + { + var keys = objectKeys(Writable.prototype); + for (var v = 0; v < keys.length; v++) { + var method = keys[v]; + if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method]; + } + } + function Duplex(options) { + if (!(this instanceof Duplex)) return new Duplex(options); + Readable.call(this, options); + Writable.call(this, options); + if (options && options.readable === false) this.readable = false; + if (options && options.writable === false) this.writable = false; + this.allowHalfOpen = true; + if (options && options.allowHalfOpen === false) this.allowHalfOpen = false; + this.once("end", onend); + } + Object.defineProperty(Duplex.prototype, "writableHighWaterMark", { + // making it explicit this property is not enumerable + // because otherwise some prototype manipulation in + // userland will fail + enumerable: false, + get: function() { + return this._writableState.highWaterMark; + } + }); + function onend() { + if (this.allowHalfOpen || this._writableState.ended) return; + pna.nextTick(onEndNT, this); + } + function onEndNT(self2) { + self2.end(); + } + Object.defineProperty(Duplex.prototype, "destroyed", { + get: function() { + if (this._readableState === void 0 || this._writableState === void 0) { + return false; + } + return this._readableState.destroyed && this._writableState.destroyed; + }, + set: function(value) { + if (this._readableState === void 0 || this._writableState === void 0) { + return; + } + this._readableState.destroyed = value; + this._writableState.destroyed = value; + } + }); + Duplex.prototype._destroy = function(err, cb) { + this.push(null); + this.end(); + pna.nextTick(cb, err); + }; + return _stream_duplex; +} +var _stream_readable; +var hasRequired_stream_readable; +function require_stream_readable() { + if (hasRequired_stream_readable) return _stream_readable; + hasRequired_stream_readable = 1; + var pna = requireProcessNextickArgs(); + _stream_readable = Readable; + var isArray = requireIsarray(); + var Duplex; + Readable.ReadableState = ReadableState; + requireEvents().EventEmitter; + var EElistenerCount = function(emitter, type2) { + return emitter.listeners(type2).length; + }; + var Stream = requireStreamBrowser(); + var Buffer2 = requireSafeBuffer().Buffer; + var OurUint8Array = (typeof commonjsGlobal !== "undefined" ? commonjsGlobal : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : {}).Uint8Array || function() { + }; + function _uint8ArrayToBuffer(chunk2) { + return Buffer2.from(chunk2); + } + function _isUint8Array(obj) { + return Buffer2.isBuffer(obj) || obj instanceof OurUint8Array; + } + var util2 = Object.create(requireUtil()); + util2.inherits = requireInherits_browser(); + var debugUtil = requireUtil$1(); + var debug = void 0; + if (debugUtil && debugUtil.debuglog) { + debug = debugUtil.debuglog("stream"); + } else { + debug = function() { + }; + } + var BufferList2 = requireBufferList(); + var destroyImpl = requireDestroy(); + var StringDecoder; + util2.inherits(Readable, Stream); + var kProxyEvents = ["error", "close", "destroy", "pause", "resume"]; + function prependListener(emitter, event, fn) { + if (typeof emitter.prependListener === "function") return emitter.prependListener(event, fn); + if (!emitter._events || !emitter._events[event]) emitter.on(event, fn); + else if (isArray(emitter._events[event])) emitter._events[event].unshift(fn); + else emitter._events[event] = [fn, emitter._events[event]]; + } + function ReadableState(options, stream) { + Duplex = Duplex || require_stream_duplex(); + options = options || {}; + var isDuplex = stream instanceof Duplex; + this.objectMode = !!options.objectMode; + if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode; + var hwm = options.highWaterMark; + var readableHwm = options.readableHighWaterMark; + var defaultHwm = this.objectMode ? 16 : 16 * 1024; + if (hwm || hwm === 0) this.highWaterMark = hwm; + else if (isDuplex && (readableHwm || readableHwm === 0)) this.highWaterMark = readableHwm; + else this.highWaterMark = defaultHwm; + this.highWaterMark = Math.floor(this.highWaterMark); + this.buffer = new BufferList2(); + this.length = 0; + this.pipes = null; + this.pipesCount = 0; + this.flowing = null; + this.ended = false; + this.endEmitted = false; + this.reading = false; + this.sync = true; + this.needReadable = false; + this.emittedReadable = false; + this.readableListening = false; + this.resumeScheduled = false; + this.destroyed = false; + this.defaultEncoding = options.defaultEncoding || "utf8"; + this.awaitDrain = 0; + this.readingMore = false; + this.decoder = null; + this.encoding = null; + if (options.encoding) { + if (!StringDecoder) StringDecoder = requireString_decoder().StringDecoder; + this.decoder = new StringDecoder(options.encoding); + this.encoding = options.encoding; + } + } + function Readable(options) { + Duplex = Duplex || require_stream_duplex(); + if (!(this instanceof Readable)) return new Readable(options); + this._readableState = new ReadableState(options, this); + this.readable = true; + if (options) { + if (typeof options.read === "function") this._read = options.read; + if (typeof options.destroy === "function") this._destroy = options.destroy; + } + Stream.call(this); + } + Object.defineProperty(Readable.prototype, "destroyed", { + get: function() { + if (this._readableState === void 0) { + return false; + } + return this._readableState.destroyed; + }, + set: function(value) { + if (!this._readableState) { + return; + } + this._readableState.destroyed = value; + } + }); + Readable.prototype.destroy = destroyImpl.destroy; + Readable.prototype._undestroy = destroyImpl.undestroy; + Readable.prototype._destroy = function(err, cb) { + this.push(null); + cb(err); + }; + Readable.prototype.push = function(chunk2, encoding) { + var state2 = this._readableState; + var skipChunkCheck; + if (!state2.objectMode) { + if (typeof chunk2 === "string") { + encoding = encoding || state2.defaultEncoding; + if (encoding !== state2.encoding) { + chunk2 = Buffer2.from(chunk2, encoding); + encoding = ""; + } + skipChunkCheck = true; + } + } else { + skipChunkCheck = true; + } + return readableAddChunk(this, chunk2, encoding, false, skipChunkCheck); + }; + Readable.prototype.unshift = function(chunk2) { + return readableAddChunk(this, chunk2, null, true, false); + }; + function readableAddChunk(stream, chunk2, encoding, addToFront, skipChunkCheck) { + var state2 = stream._readableState; + if (chunk2 === null) { + state2.reading = false; + onEofChunk(stream, state2); + } else { + var er; + if (!skipChunkCheck) er = chunkInvalid(state2, chunk2); + if (er) { + stream.emit("error", er); + } else if (state2.objectMode || chunk2 && chunk2.length > 0) { + if (typeof chunk2 !== "string" && !state2.objectMode && Object.getPrototypeOf(chunk2) !== Buffer2.prototype) { + chunk2 = _uint8ArrayToBuffer(chunk2); + } + if (addToFront) { + if (state2.endEmitted) stream.emit("error", new Error("stream.unshift() after end event")); + else addChunk(stream, state2, chunk2, true); + } else if (state2.ended) { + stream.emit("error", new Error("stream.push() after EOF")); + } else { + state2.reading = false; + if (state2.decoder && !encoding) { + chunk2 = state2.decoder.write(chunk2); + if (state2.objectMode || chunk2.length !== 0) addChunk(stream, state2, chunk2, false); + else maybeReadMore(stream, state2); + } else { + addChunk(stream, state2, chunk2, false); + } + } + } else if (!addToFront) { + state2.reading = false; + } + } + return needMoreData(state2); + } + function addChunk(stream, state2, chunk2, addToFront) { + if (state2.flowing && state2.length === 0 && !state2.sync) { + stream.emit("data", chunk2); + stream.read(0); + } else { + state2.length += state2.objectMode ? 1 : chunk2.length; + if (addToFront) state2.buffer.unshift(chunk2); + else state2.buffer.push(chunk2); + if (state2.needReadable) emitReadable(stream); + } + maybeReadMore(stream, state2); + } + function chunkInvalid(state2, chunk2) { + var er; + if (!_isUint8Array(chunk2) && typeof chunk2 !== "string" && chunk2 !== void 0 && !state2.objectMode) { + er = new TypeError("Invalid non-string/buffer chunk"); + } + return er; + } + function needMoreData(state2) { + return !state2.ended && (state2.needReadable || state2.length < state2.highWaterMark || state2.length === 0); + } + Readable.prototype.isPaused = function() { + return this._readableState.flowing === false; + }; + Readable.prototype.setEncoding = function(enc) { + if (!StringDecoder) StringDecoder = requireString_decoder().StringDecoder; + this._readableState.decoder = new StringDecoder(enc); + this._readableState.encoding = enc; + return this; + }; + var MAX_HWM = 8388608; + function computeNewHighWaterMark(n) { + if (n >= MAX_HWM) { + n = MAX_HWM; + } else { + n--; + n |= n >>> 1; + n |= n >>> 2; + n |= n >>> 4; + n |= n >>> 8; + n |= n >>> 16; + n++; + } + return n; + } + function howMuchToRead(n, state2) { + if (n <= 0 || state2.length === 0 && state2.ended) return 0; + if (state2.objectMode) return 1; + if (n !== n) { + if (state2.flowing && state2.length) return state2.buffer.head.data.length; + else return state2.length; + } + if (n > state2.highWaterMark) state2.highWaterMark = computeNewHighWaterMark(n); + if (n <= state2.length) return n; + if (!state2.ended) { + state2.needReadable = true; + return 0; + } + return state2.length; + } + Readable.prototype.read = function(n) { + debug("read", n); + n = parseInt(n, 10); + var state2 = this._readableState; + var nOrig = n; + if (n !== 0) state2.emittedReadable = false; + if (n === 0 && state2.needReadable && (state2.length >= state2.highWaterMark || state2.ended)) { + debug("read: emitReadable", state2.length, state2.ended); + if (state2.length === 0 && state2.ended) endReadable(this); + else emitReadable(this); + return null; + } + n = howMuchToRead(n, state2); + if (n === 0 && state2.ended) { + if (state2.length === 0) endReadable(this); + return null; + } + var doRead = state2.needReadable; + debug("need readable", doRead); + if (state2.length === 0 || state2.length - n < state2.highWaterMark) { + doRead = true; + debug("length less than watermark", doRead); + } + if (state2.ended || state2.reading) { + doRead = false; + debug("reading or ended", doRead); + } else if (doRead) { + debug("do read"); + state2.reading = true; + state2.sync = true; + if (state2.length === 0) state2.needReadable = true; + this._read(state2.highWaterMark); + state2.sync = false; + if (!state2.reading) n = howMuchToRead(nOrig, state2); + } + var ret; + if (n > 0) ret = fromList(n, state2); + else ret = null; + if (ret === null) { + state2.needReadable = true; + n = 0; + } else { + state2.length -= n; + } + if (state2.length === 0) { + if (!state2.ended) state2.needReadable = true; + if (nOrig !== n && state2.ended) endReadable(this); + } + if (ret !== null) this.emit("data", ret); + return ret; + }; + function onEofChunk(stream, state2) { + if (state2.ended) return; + if (state2.decoder) { + var chunk2 = state2.decoder.end(); + if (chunk2 && chunk2.length) { + state2.buffer.push(chunk2); + state2.length += state2.objectMode ? 1 : chunk2.length; + } + } + state2.ended = true; + emitReadable(stream); + } + function emitReadable(stream) { + var state2 = stream._readableState; + state2.needReadable = false; + if (!state2.emittedReadable) { + debug("emitReadable", state2.flowing); + state2.emittedReadable = true; + if (state2.sync) pna.nextTick(emitReadable_, stream); + else emitReadable_(stream); + } + } + function emitReadable_(stream) { + debug("emit readable"); + stream.emit("readable"); + flow(stream); + } + function maybeReadMore(stream, state2) { + if (!state2.readingMore) { + state2.readingMore = true; + pna.nextTick(maybeReadMore_, stream, state2); + } + } + function maybeReadMore_(stream, state2) { + var len2 = state2.length; + while (!state2.reading && !state2.flowing && !state2.ended && state2.length < state2.highWaterMark) { + debug("maybeReadMore read 0"); + stream.read(0); + if (len2 === state2.length) + break; + else len2 = state2.length; + } + state2.readingMore = false; + } + Readable.prototype._read = function(n) { + this.emit("error", new Error("_read() is not implemented")); + }; + Readable.prototype.pipe = function(dest, pipeOpts) { + var src = this; + var state2 = this._readableState; + switch (state2.pipesCount) { + case 0: + state2.pipes = dest; + break; + case 1: + state2.pipes = [state2.pipes, dest]; + break; + default: + state2.pipes.push(dest); + break; + } + state2.pipesCount += 1; + debug("pipe count=%d opts=%j", state2.pipesCount, pipeOpts); + var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process$1.stdout && dest !== process$1.stderr; + var endFn = doEnd ? onend : unpipe; + if (state2.endEmitted) pna.nextTick(endFn); + else src.once("end", endFn); + dest.on("unpipe", onunpipe); + function onunpipe(readable, unpipeInfo) { + debug("onunpipe"); + if (readable === src) { + if (unpipeInfo && unpipeInfo.hasUnpiped === false) { + unpipeInfo.hasUnpiped = true; + cleanup(); + } + } + } + function onend() { + debug("onend"); + dest.end(); + } + var ondrain = pipeOnDrain(src); + dest.on("drain", ondrain); + var cleanedUp = false; + function cleanup() { + debug("cleanup"); + dest.removeListener("close", onclose); + dest.removeListener("finish", onfinish); + dest.removeListener("drain", ondrain); + dest.removeListener("error", onerror); + dest.removeListener("unpipe", onunpipe); + src.removeListener("end", onend); + src.removeListener("end", unpipe); + src.removeListener("data", ondata); + cleanedUp = true; + if (state2.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain(); + } + var increasedAwaitDrain = false; + src.on("data", ondata); + function ondata(chunk2) { + debug("ondata"); + increasedAwaitDrain = false; + var ret = dest.write(chunk2); + if (false === ret && !increasedAwaitDrain) { + if ((state2.pipesCount === 1 && state2.pipes === dest || state2.pipesCount > 1 && indexOf2(state2.pipes, dest) !== -1) && !cleanedUp) { + debug("false write response, pause", state2.awaitDrain); + state2.awaitDrain++; + increasedAwaitDrain = true; + } + src.pause(); + } + } + function onerror(er) { + debug("onerror", er); + unpipe(); + dest.removeListener("error", onerror); + if (EElistenerCount(dest, "error") === 0) dest.emit("error", er); + } + prependListener(dest, "error", onerror); + function onclose() { + dest.removeListener("finish", onfinish); + unpipe(); + } + dest.once("close", onclose); + function onfinish() { + debug("onfinish"); + dest.removeListener("close", onclose); + unpipe(); + } + dest.once("finish", onfinish); + function unpipe() { + debug("unpipe"); + src.unpipe(dest); + } + dest.emit("pipe", src); + if (!state2.flowing) { + debug("pipe resume"); + src.resume(); + } + return dest; + }; + function pipeOnDrain(src) { + return function() { + var state2 = src._readableState; + debug("pipeOnDrain", state2.awaitDrain); + if (state2.awaitDrain) state2.awaitDrain--; + if (state2.awaitDrain === 0 && EElistenerCount(src, "data")) { + state2.flowing = true; + flow(src); + } + }; + } + Readable.prototype.unpipe = function(dest) { + var state2 = this._readableState; + var unpipeInfo = { hasUnpiped: false }; + if (state2.pipesCount === 0) return this; + if (state2.pipesCount === 1) { + if (dest && dest !== state2.pipes) return this; + if (!dest) dest = state2.pipes; + state2.pipes = null; + state2.pipesCount = 0; + state2.flowing = false; + if (dest) dest.emit("unpipe", this, unpipeInfo); + return this; + } + if (!dest) { + var dests = state2.pipes; + var len2 = state2.pipesCount; + state2.pipes = null; + state2.pipesCount = 0; + state2.flowing = false; + for (var i2 = 0; i2 < len2; i2++) { + dests[i2].emit("unpipe", this, { hasUnpiped: false }); + } + return this; + } + var index = indexOf2(state2.pipes, dest); + if (index === -1) return this; + state2.pipes.splice(index, 1); + state2.pipesCount -= 1; + if (state2.pipesCount === 1) state2.pipes = state2.pipes[0]; + dest.emit("unpipe", this, unpipeInfo); + return this; + }; + Readable.prototype.on = function(ev, fn) { + var res = Stream.prototype.on.call(this, ev, fn); + if (ev === "data") { + if (this._readableState.flowing !== false) this.resume(); + } else if (ev === "readable") { + var state2 = this._readableState; + if (!state2.endEmitted && !state2.readableListening) { + state2.readableListening = state2.needReadable = true; + state2.emittedReadable = false; + if (!state2.reading) { + pna.nextTick(nReadingNextTick, this); + } else if (state2.length) { + emitReadable(this); + } + } + } + return res; + }; + Readable.prototype.addListener = Readable.prototype.on; + function nReadingNextTick(self2) { + debug("readable nexttick read 0"); + self2.read(0); + } + Readable.prototype.resume = function() { + var state2 = this._readableState; + if (!state2.flowing) { + debug("resume"); + state2.flowing = true; + resume(this, state2); + } + return this; + }; + function resume(stream, state2) { + if (!state2.resumeScheduled) { + state2.resumeScheduled = true; + pna.nextTick(resume_, stream, state2); + } + } + function resume_(stream, state2) { + if (!state2.reading) { + debug("resume read 0"); + stream.read(0); + } + state2.resumeScheduled = false; + state2.awaitDrain = 0; + stream.emit("resume"); + flow(stream); + if (state2.flowing && !state2.reading) stream.read(0); + } + Readable.prototype.pause = function() { + debug("call pause flowing=%j", this._readableState.flowing); + if (false !== this._readableState.flowing) { + debug("pause"); + this._readableState.flowing = false; + this.emit("pause"); + } + return this; + }; + function flow(stream) { + var state2 = stream._readableState; + debug("flow", state2.flowing); + while (state2.flowing && stream.read() !== null) { + } + } + Readable.prototype.wrap = function(stream) { + var _this = this; + var state2 = this._readableState; + var paused = false; + stream.on("end", function() { + debug("wrapped end"); + if (state2.decoder && !state2.ended) { + var chunk2 = state2.decoder.end(); + if (chunk2 && chunk2.length) _this.push(chunk2); + } + _this.push(null); + }); + stream.on("data", function(chunk2) { + debug("wrapped data"); + if (state2.decoder) chunk2 = state2.decoder.write(chunk2); + if (state2.objectMode && (chunk2 === null || chunk2 === void 0)) return; + else if (!state2.objectMode && (!chunk2 || !chunk2.length)) return; + var ret = _this.push(chunk2); + if (!ret) { + paused = true; + stream.pause(); + } + }); + for (var i2 in stream) { + if (this[i2] === void 0 && typeof stream[i2] === "function") { + this[i2] = /* @__PURE__ */ function(method) { + return function() { + return stream[method].apply(stream, arguments); + }; + }(i2); + } + } + for (var n = 0; n < kProxyEvents.length; n++) { + stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n])); + } + this._read = function(n2) { + debug("wrapped _read", n2); + if (paused) { + paused = false; + stream.resume(); + } + }; + return this; + }; + Object.defineProperty(Readable.prototype, "readableHighWaterMark", { + // making it explicit this property is not enumerable + // because otherwise some prototype manipulation in + // userland will fail + enumerable: false, + get: function() { + return this._readableState.highWaterMark; + } + }); + Readable._fromList = fromList; + function fromList(n, state2) { + if (state2.length === 0) return null; + var ret; + if (state2.objectMode) ret = state2.buffer.shift(); + else if (!n || n >= state2.length) { + if (state2.decoder) ret = state2.buffer.join(""); + else if (state2.buffer.length === 1) ret = state2.buffer.head.data; + else ret = state2.buffer.concat(state2.length); + state2.buffer.clear(); + } else { + ret = fromListPartial(n, state2.buffer, state2.decoder); + } + return ret; + } + function fromListPartial(n, list, hasStrings) { + var ret; + if (n < list.head.data.length) { + ret = list.head.data.slice(0, n); + list.head.data = list.head.data.slice(n); + } else if (n === list.head.data.length) { + ret = list.shift(); + } else { + ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list); + } + return ret; + } + function copyFromBufferString(n, list) { + var p = list.head; + var c = 1; + var ret = p.data; + n -= ret.length; + while (p = p.next) { + var str = p.data; + var nb = n > str.length ? str.length : n; + if (nb === str.length) ret += str; + else ret += str.slice(0, n); + n -= nb; + if (n === 0) { + if (nb === str.length) { + ++c; + if (p.next) list.head = p.next; + else list.head = list.tail = null; + } else { + list.head = p; + p.data = str.slice(nb); + } + break; + } + ++c; + } + list.length -= c; + return ret; + } + function copyFromBuffer(n, list) { + var ret = Buffer2.allocUnsafe(n); + var p = list.head; + var c = 1; + p.data.copy(ret); + n -= p.data.length; + while (p = p.next) { + var buf = p.data; + var nb = n > buf.length ? buf.length : n; + buf.copy(ret, ret.length - n, 0, nb); + n -= nb; + if (n === 0) { + if (nb === buf.length) { + ++c; + if (p.next) list.head = p.next; + else list.head = list.tail = null; + } else { + list.head = p; + p.data = buf.slice(nb); + } + break; + } + ++c; + } + list.length -= c; + return ret; + } + function endReadable(stream) { + var state2 = stream._readableState; + if (state2.length > 0) throw new Error('"endReadable()" called on non-empty stream'); + if (!state2.endEmitted) { + state2.ended = true; + pna.nextTick(endReadableNT, state2, stream); + } + } + function endReadableNT(state2, stream) { + if (!state2.endEmitted && state2.length === 0) { + state2.endEmitted = true; + stream.readable = false; + stream.emit("end"); + } + } + function indexOf2(xs, x) { + for (var i2 = 0, l = xs.length; i2 < l; i2++) { + if (xs[i2] === x) return i2; + } + return -1; + } + return _stream_readable; +} +var _stream_transform; +var hasRequired_stream_transform; +function require_stream_transform() { + if (hasRequired_stream_transform) return _stream_transform; + hasRequired_stream_transform = 1; + _stream_transform = Transform; + var Duplex = require_stream_duplex(); + var util2 = Object.create(requireUtil()); + util2.inherits = requireInherits_browser(); + util2.inherits(Transform, Duplex); + function afterTransform(er, data) { + var ts = this._transformState; + ts.transforming = false; + var cb = ts.writecb; + if (!cb) { + return this.emit("error", new Error("write callback called multiple times")); + } + ts.writechunk = null; + ts.writecb = null; + if (data != null) + this.push(data); + cb(er); + var rs = this._readableState; + rs.reading = false; + if (rs.needReadable || rs.length < rs.highWaterMark) { + this._read(rs.highWaterMark); + } + } + function Transform(options) { + if (!(this instanceof Transform)) return new Transform(options); + Duplex.call(this, options); + this._transformState = { + afterTransform: afterTransform.bind(this), + needTransform: false, + transforming: false, + writecb: null, + writechunk: null, + writeencoding: null + }; + this._readableState.needReadable = true; + this._readableState.sync = false; + if (options) { + if (typeof options.transform === "function") this._transform = options.transform; + if (typeof options.flush === "function") this._flush = options.flush; + } + this.on("prefinish", prefinish); + } + function prefinish() { + var _this = this; + if (typeof this._flush === "function") { + this._flush(function(er, data) { + done(_this, er, data); + }); + } else { + done(this, null, null); + } + } + Transform.prototype.push = function(chunk2, encoding) { + this._transformState.needTransform = false; + return Duplex.prototype.push.call(this, chunk2, encoding); + }; + Transform.prototype._transform = function(chunk2, encoding, cb) { + throw new Error("_transform() is not implemented"); + }; + Transform.prototype._write = function(chunk2, encoding, cb) { + var ts = this._transformState; + ts.writecb = cb; + ts.writechunk = chunk2; + ts.writeencoding = encoding; + if (!ts.transforming) { + var rs = this._readableState; + if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark); + } + }; + Transform.prototype._read = function(n) { + var ts = this._transformState; + if (ts.writechunk !== null && ts.writecb && !ts.transforming) { + ts.transforming = true; + this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform); + } else { + ts.needTransform = true; + } + }; + Transform.prototype._destroy = function(err, cb) { + var _this2 = this; + Duplex.prototype._destroy.call(this, err, function(err2) { + cb(err2); + _this2.emit("close"); + }); + }; + function done(stream, er, data) { + if (er) return stream.emit("error", er); + if (data != null) + stream.push(data); + if (stream._writableState.length) throw new Error("Calling transform done when ws.length != 0"); + if (stream._transformState.transforming) throw new Error("Calling transform done when still transforming"); + return stream.push(null); + } + return _stream_transform; +} +var _stream_passthrough; +var hasRequired_stream_passthrough; +function require_stream_passthrough() { + if (hasRequired_stream_passthrough) return _stream_passthrough; + hasRequired_stream_passthrough = 1; + _stream_passthrough = PassThrough; + var Transform = require_stream_transform(); + var util2 = Object.create(requireUtil()); + util2.inherits = requireInherits_browser(); + util2.inherits(PassThrough, Transform); + function PassThrough(options) { + if (!(this instanceof PassThrough)) return new PassThrough(options); + Transform.call(this, options); + } + PassThrough.prototype._transform = function(chunk2, encoding, cb) { + cb(null, chunk2); + }; + return _stream_passthrough; +} +var hasRequiredReadableBrowser; +function requireReadableBrowser() { + if (hasRequiredReadableBrowser) return readableBrowser.exports; + hasRequiredReadableBrowser = 1; + (function(module2, exports2) { + exports2 = module2.exports = require_stream_readable(); + exports2.Stream = exports2; + exports2.Readable = exports2; + exports2.Writable = require_stream_writable(); + exports2.Duplex = require_stream_duplex(); + exports2.Transform = require_stream_transform(); + exports2.PassThrough = require_stream_passthrough(); + })(readableBrowser, readableBrowser.exports); + return readableBrowser.exports; +} +var sign = { exports: {} }; +var bn$1 = { exports: {} }; +var bn = bn$1.exports; +var hasRequiredBn; +function requireBn() { + if (hasRequiredBn) return bn$1.exports; + hasRequiredBn = 1; + (function(module2) { + (function(module3, exports2) { + function assert(val, msg) { + if (!val) throw new Error(msg || "Assertion failed"); + } + function inherits(ctor, superCtor) { + ctor.super_ = superCtor; + var TempCtor = function() { + }; + TempCtor.prototype = superCtor.prototype; + ctor.prototype = new TempCtor(); + ctor.prototype.constructor = ctor; + } + function BN(number, base2, endian) { + if (BN.isBN(number)) { + return number; + } + this.negative = 0; + this.words = null; + this.length = 0; + this.red = null; + if (number !== null) { + if (base2 === "le" || base2 === "be") { + endian = base2; + base2 = 10; + } + this._init(number || 0, base2 || 10, endian || "be"); + } + } + if (typeof module3 === "object") { + module3.exports = BN; + } else { + exports2.BN = BN; + } + BN.BN = BN; + BN.wordSize = 26; + var Buffer2; + try { + if (typeof window !== "undefined" && typeof window.Buffer !== "undefined") { + Buffer2 = window.Buffer; + } else { + Buffer2 = requireDist().Buffer; + } + } catch (e) { + } + BN.isBN = function isBN(num) { + if (num instanceof BN) { + return true; + } + return num !== null && typeof num === "object" && num.constructor.wordSize === BN.wordSize && Array.isArray(num.words); + }; + BN.max = function max(left, right) { + if (left.cmp(right) > 0) return left; + return right; + }; + BN.min = function min(left, right) { + if (left.cmp(right) < 0) return left; + return right; + }; + BN.prototype._init = function init(number, base2, endian) { + if (typeof number === "number") { + return this._initNumber(number, base2, endian); + } + if (typeof number === "object") { + return this._initArray(number, base2, endian); + } + if (base2 === "hex") { + base2 = 16; + } + assert(base2 === (base2 | 0) && base2 >= 2 && base2 <= 36); + number = number.toString().replace(/\s+/g, ""); + var start = 0; + if (number[0] === "-") { + start++; + this.negative = 1; + } + if (start < number.length) { + if (base2 === 16) { + this._parseHex(number, start, endian); + } else { + this._parseBase(number, base2, start); + if (endian === "le") { + this._initArray(this.toArray(), base2, endian); + } + } + } + }; + BN.prototype._initNumber = function _initNumber(number, base2, endian) { + if (number < 0) { + this.negative = 1; + number = -number; + } + if (number < 67108864) { + this.words = [number & 67108863]; + this.length = 1; + } else if (number < 4503599627370496) { + this.words = [ + number & 67108863, + number / 67108864 & 67108863 + ]; + this.length = 2; + } else { + assert(number < 9007199254740992); + this.words = [ + number & 67108863, + number / 67108864 & 67108863, + 1 + ]; + this.length = 3; + } + if (endian !== "le") return; + this._initArray(this.toArray(), base2, endian); + }; + BN.prototype._initArray = function _initArray(number, base2, endian) { + assert(typeof number.length === "number"); + if (number.length <= 0) { + this.words = [0]; + this.length = 1; + return this; + } + this.length = Math.ceil(number.length / 3); + this.words = new Array(this.length); + for (var i2 = 0; i2 < this.length; i2++) { + this.words[i2] = 0; + } + var j, w; + var off = 0; + if (endian === "be") { + for (i2 = number.length - 1, j = 0; i2 >= 0; i2 -= 3) { + w = number[i2] | number[i2 - 1] << 8 | number[i2 - 2] << 16; + this.words[j] |= w << off & 67108863; + this.words[j + 1] = w >>> 26 - off & 67108863; + off += 24; + if (off >= 26) { + off -= 26; + j++; + } + } + } else if (endian === "le") { + for (i2 = 0, j = 0; i2 < number.length; i2 += 3) { + w = number[i2] | number[i2 + 1] << 8 | number[i2 + 2] << 16; + this.words[j] |= w << off & 67108863; + this.words[j + 1] = w >>> 26 - off & 67108863; + off += 24; + if (off >= 26) { + off -= 26; + j++; + } + } + } + return this._strip(); + }; + function parseHex4Bits(string, index) { + var c = string.charCodeAt(index); + if (c >= 48 && c <= 57) { + return c - 48; + } else if (c >= 65 && c <= 70) { + return c - 55; + } else if (c >= 97 && c <= 102) { + return c - 87; + } else { + assert(false, "Invalid character in " + string); + } + } + function parseHexByte(string, lowerBound, index) { + var r = parseHex4Bits(string, index); + if (index - 1 >= lowerBound) { + r |= parseHex4Bits(string, index - 1) << 4; + } + return r; + } + BN.prototype._parseHex = function _parseHex(number, start, endian) { + this.length = Math.ceil((number.length - start) / 6); + this.words = new Array(this.length); + for (var i2 = 0; i2 < this.length; i2++) { + this.words[i2] = 0; + } + var off = 0; + var j = 0; + var w; + if (endian === "be") { + for (i2 = number.length - 1; i2 >= start; i2 -= 2) { + w = parseHexByte(number, start, i2) << off; + this.words[j] |= w & 67108863; + if (off >= 18) { + off -= 18; + j += 1; + this.words[j] |= w >>> 26; + } else { + off += 8; + } + } + } else { + var parseLength = number.length - start; + for (i2 = parseLength % 2 === 0 ? start + 1 : start; i2 < number.length; i2 += 2) { + w = parseHexByte(number, start, i2) << off; + this.words[j] |= w & 67108863; + if (off >= 18) { + off -= 18; + j += 1; + this.words[j] |= w >>> 26; + } else { + off += 8; + } + } + } + this._strip(); + }; + function parseBase(str, start, end, mul) { + var r = 0; + var b = 0; + var len2 = Math.min(str.length, end); + for (var i2 = start; i2 < len2; i2++) { + var c = str.charCodeAt(i2) - 48; + r *= mul; + if (c >= 49) { + b = c - 49 + 10; + } else if (c >= 17) { + b = c - 17 + 10; + } else { + b = c; + } + assert(c >= 0 && b < mul, "Invalid character"); + r += b; + } + return r; + } + BN.prototype._parseBase = function _parseBase(number, base2, start) { + this.words = [0]; + this.length = 1; + for (var limbLen = 0, limbPow = 1; limbPow <= 67108863; limbPow *= base2) { + limbLen++; + } + limbLen--; + limbPow = limbPow / base2 | 0; + var total = number.length - start; + var mod = total % limbLen; + var end = Math.min(total, total - mod) + start; + var word = 0; + for (var i2 = start; i2 < end; i2 += limbLen) { + word = parseBase(number, i2, i2 + limbLen, base2); + this.imuln(limbPow); + if (this.words[0] + word < 67108864) { + this.words[0] += word; + } else { + this._iaddn(word); + } + } + if (mod !== 0) { + var pow = 1; + word = parseBase(number, i2, number.length, base2); + for (i2 = 0; i2 < mod; i2++) { + pow *= base2; + } + this.imuln(pow); + if (this.words[0] + word < 67108864) { + this.words[0] += word; + } else { + this._iaddn(word); + } + } + this._strip(); + }; + BN.prototype.copy = function copy(dest) { + dest.words = new Array(this.length); + for (var i2 = 0; i2 < this.length; i2++) { + dest.words[i2] = this.words[i2]; + } + dest.length = this.length; + dest.negative = this.negative; + dest.red = this.red; + }; + function move(dest, src) { + dest.words = src.words; + dest.length = src.length; + dest.negative = src.negative; + dest.red = src.red; + } + BN.prototype._move = function _move(dest) { + move(dest, this); + }; + BN.prototype.clone = function clone() { + var r = new BN(null); + this.copy(r); + return r; + }; + BN.prototype._expand = function _expand(size) { + while (this.length < size) { + this.words[this.length++] = 0; + } + return this; + }; + BN.prototype._strip = function strip() { + while (this.length > 1 && this.words[this.length - 1] === 0) { + this.length--; + } + return this._normSign(); + }; + BN.prototype._normSign = function _normSign() { + if (this.length === 1 && this.words[0] === 0) { + this.negative = 0; + } + return this; + }; + if (typeof Symbol !== "undefined" && typeof Symbol.for === "function") { + try { + BN.prototype[Symbol.for("nodejs.util.inspect.custom")] = inspect2; + } catch (e) { + BN.prototype.inspect = inspect2; + } + } else { + BN.prototype.inspect = inspect2; + } + function inspect2() { + return (this.red ? ""; + } + var zeros = [ + "", + "0", + "00", + "000", + "0000", + "00000", + "000000", + "0000000", + "00000000", + "000000000", + "0000000000", + "00000000000", + "000000000000", + "0000000000000", + "00000000000000", + "000000000000000", + "0000000000000000", + "00000000000000000", + "000000000000000000", + "0000000000000000000", + "00000000000000000000", + "000000000000000000000", + "0000000000000000000000", + "00000000000000000000000", + "000000000000000000000000", + "0000000000000000000000000" + ]; + var groupSizes = [ + 0, + 0, + 25, + 16, + 12, + 11, + 10, + 9, + 8, + 8, + 7, + 7, + 7, + 7, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5 + ]; + var groupBases = [ + 0, + 0, + 33554432, + 43046721, + 16777216, + 48828125, + 60466176, + 40353607, + 16777216, + 43046721, + 1e7, + 19487171, + 35831808, + 62748517, + 7529536, + 11390625, + 16777216, + 24137569, + 34012224, + 47045881, + 64e6, + 4084101, + 5153632, + 6436343, + 7962624, + 9765625, + 11881376, + 14348907, + 17210368, + 20511149, + 243e5, + 28629151, + 33554432, + 39135393, + 45435424, + 52521875, + 60466176 + ]; + BN.prototype.toString = function toString(base2, padding) { + base2 = base2 || 10; + padding = padding | 0 || 1; + var out; + if (base2 === 16 || base2 === "hex") { + out = ""; + var off = 0; + var carry = 0; + for (var i2 = 0; i2 < this.length; i2++) { + var w = this.words[i2]; + var word = ((w << off | carry) & 16777215).toString(16); + carry = w >>> 24 - off & 16777215; + off += 2; + if (off >= 26) { + off -= 26; + i2--; + } + if (carry !== 0 || i2 !== this.length - 1) { + out = zeros[6 - word.length] + word + out; + } else { + out = word + out; + } + } + if (carry !== 0) { + out = carry.toString(16) + out; + } + while (out.length % padding !== 0) { + out = "0" + out; + } + if (this.negative !== 0) { + out = "-" + out; + } + return out; + } + if (base2 === (base2 | 0) && base2 >= 2 && base2 <= 36) { + var groupSize = groupSizes[base2]; + var groupBase = groupBases[base2]; + out = ""; + var c = this.clone(); + c.negative = 0; + while (!c.isZero()) { + var r = c.modrn(groupBase).toString(base2); + c = c.idivn(groupBase); + if (!c.isZero()) { + out = zeros[groupSize - r.length] + r + out; + } else { + out = r + out; + } + } + if (this.isZero()) { + out = "0" + out; + } + while (out.length % padding !== 0) { + out = "0" + out; + } + if (this.negative !== 0) { + out = "-" + out; + } + return out; + } + assert(false, "Base should be between 2 and 36"); + }; + BN.prototype.toNumber = function toNumber2() { + var ret = this.words[0]; + if (this.length === 2) { + ret += this.words[1] * 67108864; + } else if (this.length === 3 && this.words[2] === 1) { + ret += 4503599627370496 + this.words[1] * 67108864; + } else if (this.length > 2) { + assert(false, "Number can only safely store up to 53 bits"); + } + return this.negative !== 0 ? -ret : ret; + }; + BN.prototype.toJSON = function toJSON() { + return this.toString(16, 2); + }; + if (Buffer2) { + BN.prototype.toBuffer = function toBuffer2(endian, length) { + return this.toArrayLike(Buffer2, endian, length); + }; + } + BN.prototype.toArray = function toArray(endian, length) { + return this.toArrayLike(Array, endian, length); + }; + var allocate = function allocate2(ArrayType, size) { + if (ArrayType.allocUnsafe) { + return ArrayType.allocUnsafe(size); + } + return new ArrayType(size); + }; + BN.prototype.toArrayLike = function toArrayLike(ArrayType, endian, length) { + this._strip(); + var byteLength2 = this.byteLength(); + var reqLength = length || Math.max(1, byteLength2); + assert(byteLength2 <= reqLength, "byte array longer than desired length"); + assert(reqLength > 0, "Requested array length <= 0"); + var res = allocate(ArrayType, reqLength); + var postfix = endian === "le" ? "LE" : "BE"; + this["_toArrayLike" + postfix](res, byteLength2); + return res; + }; + BN.prototype._toArrayLikeLE = function _toArrayLikeLE(res, byteLength2) { + var position = 0; + var carry = 0; + for (var i2 = 0, shift = 0; i2 < this.length; i2++) { + var word = this.words[i2] << shift | carry; + res[position++] = word & 255; + if (position < res.length) { + res[position++] = word >> 8 & 255; + } + if (position < res.length) { + res[position++] = word >> 16 & 255; + } + if (shift === 6) { + if (position < res.length) { + res[position++] = word >> 24 & 255; + } + carry = 0; + shift = 0; + } else { + carry = word >>> 24; + shift += 2; + } + } + if (position < res.length) { + res[position++] = carry; + while (position < res.length) { + res[position++] = 0; + } + } + }; + BN.prototype._toArrayLikeBE = function _toArrayLikeBE(res, byteLength2) { + var position = res.length - 1; + var carry = 0; + for (var i2 = 0, shift = 0; i2 < this.length; i2++) { + var word = this.words[i2] << shift | carry; + res[position--] = word & 255; + if (position >= 0) { + res[position--] = word >> 8 & 255; + } + if (position >= 0) { + res[position--] = word >> 16 & 255; + } + if (shift === 6) { + if (position >= 0) { + res[position--] = word >> 24 & 255; + } + carry = 0; + shift = 0; + } else { + carry = word >>> 24; + shift += 2; + } + } + if (position >= 0) { + res[position--] = carry; + while (position >= 0) { + res[position--] = 0; + } + } + }; + if (Math.clz32) { + BN.prototype._countBits = function _countBits(w) { + return 32 - Math.clz32(w); + }; + } else { + BN.prototype._countBits = function _countBits(w) { + var t = w; + var r = 0; + if (t >= 4096) { + r += 13; + t >>>= 13; + } + if (t >= 64) { + r += 7; + t >>>= 7; + } + if (t >= 8) { + r += 4; + t >>>= 4; + } + if (t >= 2) { + r += 2; + t >>>= 2; + } + return r + t; + }; + } + BN.prototype._zeroBits = function _zeroBits(w) { + if (w === 0) return 26; + var t = w; + var r = 0; + if ((t & 8191) === 0) { + r += 13; + t >>>= 13; + } + if ((t & 127) === 0) { + r += 7; + t >>>= 7; + } + if ((t & 15) === 0) { + r += 4; + t >>>= 4; + } + if ((t & 3) === 0) { + r += 2; + t >>>= 2; + } + if ((t & 1) === 0) { + r++; + } + return r; + }; + BN.prototype.bitLength = function bitLength() { + var w = this.words[this.length - 1]; + var hi = this._countBits(w); + return (this.length - 1) * 26 + hi; + }; + function toBitArray(num) { + var w = new Array(num.bitLength()); + for (var bit = 0; bit < w.length; bit++) { + var off = bit / 26 | 0; + var wbit = bit % 26; + w[bit] = num.words[off] >>> wbit & 1; + } + return w; + } + BN.prototype.zeroBits = function zeroBits() { + if (this.isZero()) return 0; + var r = 0; + for (var i2 = 0; i2 < this.length; i2++) { + var b = this._zeroBits(this.words[i2]); + r += b; + if (b !== 26) break; + } + return r; + }; + BN.prototype.byteLength = function byteLength2() { + return Math.ceil(this.bitLength() / 8); + }; + BN.prototype.toTwos = function toTwos(width) { + if (this.negative !== 0) { + return this.abs().inotn(width).iaddn(1); + } + return this.clone(); + }; + BN.prototype.fromTwos = function fromTwos(width) { + if (this.testn(width - 1)) { + return this.notn(width).iaddn(1).ineg(); + } + return this.clone(); + }; + BN.prototype.isNeg = function isNeg() { + return this.negative !== 0; + }; + BN.prototype.neg = function neg() { + return this.clone().ineg(); + }; + BN.prototype.ineg = function ineg() { + if (!this.isZero()) { + this.negative ^= 1; + } + return this; + }; + BN.prototype.iuor = function iuor(num) { + while (this.length < num.length) { + this.words[this.length++] = 0; + } + for (var i2 = 0; i2 < num.length; i2++) { + this.words[i2] = this.words[i2] | num.words[i2]; + } + return this._strip(); + }; + BN.prototype.ior = function ior(num) { + assert((this.negative | num.negative) === 0); + return this.iuor(num); + }; + BN.prototype.or = function or(num) { + if (this.length > num.length) return this.clone().ior(num); + return num.clone().ior(this); + }; + BN.prototype.uor = function uor(num) { + if (this.length > num.length) return this.clone().iuor(num); + return num.clone().iuor(this); + }; + BN.prototype.iuand = function iuand(num) { + var b; + if (this.length > num.length) { + b = num; + } else { + b = this; + } + for (var i2 = 0; i2 < b.length; i2++) { + this.words[i2] = this.words[i2] & num.words[i2]; + } + this.length = b.length; + return this._strip(); + }; + BN.prototype.iand = function iand(num) { + assert((this.negative | num.negative) === 0); + return this.iuand(num); + }; + BN.prototype.and = function and(num) { + if (this.length > num.length) return this.clone().iand(num); + return num.clone().iand(this); + }; + BN.prototype.uand = function uand(num) { + if (this.length > num.length) return this.clone().iuand(num); + return num.clone().iuand(this); + }; + BN.prototype.iuxor = function iuxor(num) { + var a; + var b; + if (this.length > num.length) { + a = this; + b = num; + } else { + a = num; + b = this; + } + for (var i2 = 0; i2 < b.length; i2++) { + this.words[i2] = a.words[i2] ^ b.words[i2]; + } + if (this !== a) { + for (; i2 < a.length; i2++) { + this.words[i2] = a.words[i2]; + } + } + this.length = a.length; + return this._strip(); + }; + BN.prototype.ixor = function ixor(num) { + assert((this.negative | num.negative) === 0); + return this.iuxor(num); + }; + BN.prototype.xor = function xor2(num) { + if (this.length > num.length) return this.clone().ixor(num); + return num.clone().ixor(this); + }; + BN.prototype.uxor = function uxor(num) { + if (this.length > num.length) return this.clone().iuxor(num); + return num.clone().iuxor(this); + }; + BN.prototype.inotn = function inotn(width) { + assert(typeof width === "number" && width >= 0); + var bytesNeeded = Math.ceil(width / 26) | 0; + var bitsLeft = width % 26; + this._expand(bytesNeeded); + if (bitsLeft > 0) { + bytesNeeded--; + } + for (var i2 = 0; i2 < bytesNeeded; i2++) { + this.words[i2] = ~this.words[i2] & 67108863; + } + if (bitsLeft > 0) { + this.words[i2] = ~this.words[i2] & 67108863 >> 26 - bitsLeft; + } + return this._strip(); + }; + BN.prototype.notn = function notn(width) { + return this.clone().inotn(width); + }; + BN.prototype.setn = function setn(bit, val) { + assert(typeof bit === "number" && bit >= 0); + var off = bit / 26 | 0; + var wbit = bit % 26; + this._expand(off + 1); + if (val) { + this.words[off] = this.words[off] | 1 << wbit; + } else { + this.words[off] = this.words[off] & ~(1 << wbit); + } + return this._strip(); + }; + BN.prototype.iadd = function iadd(num) { + var r; + if (this.negative !== 0 && num.negative === 0) { + this.negative = 0; + r = this.isub(num); + this.negative ^= 1; + return this._normSign(); + } else if (this.negative === 0 && num.negative !== 0) { + num.negative = 0; + r = this.isub(num); + num.negative = 1; + return r._normSign(); + } + var a, b; + if (this.length > num.length) { + a = this; + b = num; + } else { + a = num; + b = this; + } + var carry = 0; + for (var i2 = 0; i2 < b.length; i2++) { + r = (a.words[i2] | 0) + (b.words[i2] | 0) + carry; + this.words[i2] = r & 67108863; + carry = r >>> 26; + } + for (; carry !== 0 && i2 < a.length; i2++) { + r = (a.words[i2] | 0) + carry; + this.words[i2] = r & 67108863; + carry = r >>> 26; + } + this.length = a.length; + if (carry !== 0) { + this.words[this.length] = carry; + this.length++; + } else if (a !== this) { + for (; i2 < a.length; i2++) { + this.words[i2] = a.words[i2]; + } + } + return this; + }; + BN.prototype.add = function add(num) { + var res; + if (num.negative !== 0 && this.negative === 0) { + num.negative = 0; + res = this.sub(num); + num.negative ^= 1; + return res; + } else if (num.negative === 0 && this.negative !== 0) { + this.negative = 0; + res = num.sub(this); + this.negative = 1; + return res; + } + if (this.length > num.length) return this.clone().iadd(num); + return num.clone().iadd(this); + }; + BN.prototype.isub = function isub(num) { + if (num.negative !== 0) { + num.negative = 0; + var r = this.iadd(num); + num.negative = 1; + return r._normSign(); + } else if (this.negative !== 0) { + this.negative = 0; + this.iadd(num); + this.negative = 1; + return this._normSign(); + } + var cmp = this.cmp(num); + if (cmp === 0) { + this.negative = 0; + this.length = 1; + this.words[0] = 0; + return this; + } + var a, b; + if (cmp > 0) { + a = this; + b = num; + } else { + a = num; + b = this; + } + var carry = 0; + for (var i2 = 0; i2 < b.length; i2++) { + r = (a.words[i2] | 0) - (b.words[i2] | 0) + carry; + carry = r >> 26; + this.words[i2] = r & 67108863; + } + for (; carry !== 0 && i2 < a.length; i2++) { + r = (a.words[i2] | 0) + carry; + carry = r >> 26; + this.words[i2] = r & 67108863; + } + if (carry === 0 && i2 < a.length && a !== this) { + for (; i2 < a.length; i2++) { + this.words[i2] = a.words[i2]; + } + } + this.length = Math.max(this.length, i2); + if (a !== this) { + this.negative = 1; + } + return this._strip(); + }; + BN.prototype.sub = function sub(num) { + return this.clone().isub(num); + }; + function smallMulTo(self2, num, out) { + out.negative = num.negative ^ self2.negative; + var len2 = self2.length + num.length | 0; + out.length = len2; + len2 = len2 - 1 | 0; + var a = self2.words[0] | 0; + var b = num.words[0] | 0; + var r = a * b; + var lo = r & 67108863; + var carry = r / 67108864 | 0; + out.words[0] = lo; + for (var k = 1; k < len2; k++) { + var ncarry = carry >>> 26; + var rword = carry & 67108863; + var maxJ = Math.min(k, num.length - 1); + for (var j = Math.max(0, k - self2.length + 1); j <= maxJ; j++) { + var i2 = k - j | 0; + a = self2.words[i2] | 0; + b = num.words[j] | 0; + r = a * b + rword; + ncarry += r / 67108864 | 0; + rword = r & 67108863; + } + out.words[k] = rword | 0; + carry = ncarry | 0; + } + if (carry !== 0) { + out.words[k] = carry | 0; + } else { + out.length--; + } + return out._strip(); + } + var comb10MulTo = function comb10MulTo2(self2, num, out) { + var a = self2.words; + var b = num.words; + var o = out.words; + var c = 0; + var lo; + var mid; + var hi; + var a0 = a[0] | 0; + var al0 = a0 & 8191; + var ah0 = a0 >>> 13; + var a1 = a[1] | 0; + var al1 = a1 & 8191; + var ah1 = a1 >>> 13; + var a2 = a[2] | 0; + var al2 = a2 & 8191; + var ah2 = a2 >>> 13; + var a3 = a[3] | 0; + var al3 = a3 & 8191; + var ah3 = a3 >>> 13; + var a4 = a[4] | 0; + var al4 = a4 & 8191; + var ah4 = a4 >>> 13; + var a5 = a[5] | 0; + var al5 = a5 & 8191; + var ah5 = a5 >>> 13; + var a6 = a[6] | 0; + var al6 = a6 & 8191; + var ah6 = a6 >>> 13; + var a7 = a[7] | 0; + var al7 = a7 & 8191; + var ah7 = a7 >>> 13; + var a8 = a[8] | 0; + var al8 = a8 & 8191; + var ah8 = a8 >>> 13; + var a9 = a[9] | 0; + var al9 = a9 & 8191; + var ah9 = a9 >>> 13; + var b0 = b[0] | 0; + var bl0 = b0 & 8191; + var bh0 = b0 >>> 13; + var b1 = b[1] | 0; + var bl1 = b1 & 8191; + var bh1 = b1 >>> 13; + var b2 = b[2] | 0; + var bl2 = b2 & 8191; + var bh2 = b2 >>> 13; + var b3 = b[3] | 0; + var bl3 = b3 & 8191; + var bh3 = b3 >>> 13; + var b4 = b[4] | 0; + var bl4 = b4 & 8191; + var bh4 = b4 >>> 13; + var b5 = b[5] | 0; + var bl5 = b5 & 8191; + var bh5 = b5 >>> 13; + var b6 = b[6] | 0; + var bl6 = b6 & 8191; + var bh6 = b6 >>> 13; + var b7 = b[7] | 0; + var bl7 = b7 & 8191; + var bh7 = b7 >>> 13; + var b8 = b[8] | 0; + var bl8 = b8 & 8191; + var bh8 = b8 >>> 13; + var b9 = b[9] | 0; + var bl9 = b9 & 8191; + var bh9 = b9 >>> 13; + out.negative = self2.negative ^ num.negative; + out.length = 19; + lo = Math.imul(al0, bl0); + mid = Math.imul(al0, bh0); + mid = mid + Math.imul(ah0, bl0) | 0; + hi = Math.imul(ah0, bh0); + var w0 = (c + lo | 0) + ((mid & 8191) << 13) | 0; + c = (hi + (mid >>> 13) | 0) + (w0 >>> 26) | 0; + w0 &= 67108863; + lo = Math.imul(al1, bl0); + mid = Math.imul(al1, bh0); + mid = mid + Math.imul(ah1, bl0) | 0; + hi = Math.imul(ah1, bh0); + lo = lo + Math.imul(al0, bl1) | 0; + mid = mid + Math.imul(al0, bh1) | 0; + mid = mid + Math.imul(ah0, bl1) | 0; + hi = hi + Math.imul(ah0, bh1) | 0; + var w1 = (c + lo | 0) + ((mid & 8191) << 13) | 0; + c = (hi + (mid >>> 13) | 0) + (w1 >>> 26) | 0; + w1 &= 67108863; + lo = Math.imul(al2, bl0); + mid = Math.imul(al2, bh0); + mid = mid + Math.imul(ah2, bl0) | 0; + hi = Math.imul(ah2, bh0); + lo = lo + Math.imul(al1, bl1) | 0; + mid = mid + Math.imul(al1, bh1) | 0; + mid = mid + Math.imul(ah1, bl1) | 0; + hi = hi + Math.imul(ah1, bh1) | 0; + lo = lo + Math.imul(al0, bl2) | 0; + mid = mid + Math.imul(al0, bh2) | 0; + mid = mid + Math.imul(ah0, bl2) | 0; + hi = hi + Math.imul(ah0, bh2) | 0; + var w2 = (c + lo | 0) + ((mid & 8191) << 13) | 0; + c = (hi + (mid >>> 13) | 0) + (w2 >>> 26) | 0; + w2 &= 67108863; + lo = Math.imul(al3, bl0); + mid = Math.imul(al3, bh0); + mid = mid + Math.imul(ah3, bl0) | 0; + hi = Math.imul(ah3, bh0); + lo = lo + Math.imul(al2, bl1) | 0; + mid = mid + Math.imul(al2, bh1) | 0; + mid = mid + Math.imul(ah2, bl1) | 0; + hi = hi + Math.imul(ah2, bh1) | 0; + lo = lo + Math.imul(al1, bl2) | 0; + mid = mid + Math.imul(al1, bh2) | 0; + mid = mid + Math.imul(ah1, bl2) | 0; + hi = hi + Math.imul(ah1, bh2) | 0; + lo = lo + Math.imul(al0, bl3) | 0; + mid = mid + Math.imul(al0, bh3) | 0; + mid = mid + Math.imul(ah0, bl3) | 0; + hi = hi + Math.imul(ah0, bh3) | 0; + var w3 = (c + lo | 0) + ((mid & 8191) << 13) | 0; + c = (hi + (mid >>> 13) | 0) + (w3 >>> 26) | 0; + w3 &= 67108863; + lo = Math.imul(al4, bl0); + mid = Math.imul(al4, bh0); + mid = mid + Math.imul(ah4, bl0) | 0; + hi = Math.imul(ah4, bh0); + lo = lo + Math.imul(al3, bl1) | 0; + mid = mid + Math.imul(al3, bh1) | 0; + mid = mid + Math.imul(ah3, bl1) | 0; + hi = hi + Math.imul(ah3, bh1) | 0; + lo = lo + Math.imul(al2, bl2) | 0; + mid = mid + Math.imul(al2, bh2) | 0; + mid = mid + Math.imul(ah2, bl2) | 0; + hi = hi + Math.imul(ah2, bh2) | 0; + lo = lo + Math.imul(al1, bl3) | 0; + mid = mid + Math.imul(al1, bh3) | 0; + mid = mid + Math.imul(ah1, bl3) | 0; + hi = hi + Math.imul(ah1, bh3) | 0; + lo = lo + Math.imul(al0, bl4) | 0; + mid = mid + Math.imul(al0, bh4) | 0; + mid = mid + Math.imul(ah0, bl4) | 0; + hi = hi + Math.imul(ah0, bh4) | 0; + var w4 = (c + lo | 0) + ((mid & 8191) << 13) | 0; + c = (hi + (mid >>> 13) | 0) + (w4 >>> 26) | 0; + w4 &= 67108863; + lo = Math.imul(al5, bl0); + mid = Math.imul(al5, bh0); + mid = mid + Math.imul(ah5, bl0) | 0; + hi = Math.imul(ah5, bh0); + lo = lo + Math.imul(al4, bl1) | 0; + mid = mid + Math.imul(al4, bh1) | 0; + mid = mid + Math.imul(ah4, bl1) | 0; + hi = hi + Math.imul(ah4, bh1) | 0; + lo = lo + Math.imul(al3, bl2) | 0; + mid = mid + Math.imul(al3, bh2) | 0; + mid = mid + Math.imul(ah3, bl2) | 0; + hi = hi + Math.imul(ah3, bh2) | 0; + lo = lo + Math.imul(al2, bl3) | 0; + mid = mid + Math.imul(al2, bh3) | 0; + mid = mid + Math.imul(ah2, bl3) | 0; + hi = hi + Math.imul(ah2, bh3) | 0; + lo = lo + Math.imul(al1, bl4) | 0; + mid = mid + Math.imul(al1, bh4) | 0; + mid = mid + Math.imul(ah1, bl4) | 0; + hi = hi + Math.imul(ah1, bh4) | 0; + lo = lo + Math.imul(al0, bl5) | 0; + mid = mid + Math.imul(al0, bh5) | 0; + mid = mid + Math.imul(ah0, bl5) | 0; + hi = hi + Math.imul(ah0, bh5) | 0; + var w5 = (c + lo | 0) + ((mid & 8191) << 13) | 0; + c = (hi + (mid >>> 13) | 0) + (w5 >>> 26) | 0; + w5 &= 67108863; + lo = Math.imul(al6, bl0); + mid = Math.imul(al6, bh0); + mid = mid + Math.imul(ah6, bl0) | 0; + hi = Math.imul(ah6, bh0); + lo = lo + Math.imul(al5, bl1) | 0; + mid = mid + Math.imul(al5, bh1) | 0; + mid = mid + Math.imul(ah5, bl1) | 0; + hi = hi + Math.imul(ah5, bh1) | 0; + lo = lo + Math.imul(al4, bl2) | 0; + mid = mid + Math.imul(al4, bh2) | 0; + mid = mid + Math.imul(ah4, bl2) | 0; + hi = hi + Math.imul(ah4, bh2) | 0; + lo = lo + Math.imul(al3, bl3) | 0; + mid = mid + Math.imul(al3, bh3) | 0; + mid = mid + Math.imul(ah3, bl3) | 0; + hi = hi + Math.imul(ah3, bh3) | 0; + lo = lo + Math.imul(al2, bl4) | 0; + mid = mid + Math.imul(al2, bh4) | 0; + mid = mid + Math.imul(ah2, bl4) | 0; + hi = hi + Math.imul(ah2, bh4) | 0; + lo = lo + Math.imul(al1, bl5) | 0; + mid = mid + Math.imul(al1, bh5) | 0; + mid = mid + Math.imul(ah1, bl5) | 0; + hi = hi + Math.imul(ah1, bh5) | 0; + lo = lo + Math.imul(al0, bl6) | 0; + mid = mid + Math.imul(al0, bh6) | 0; + mid = mid + Math.imul(ah0, bl6) | 0; + hi = hi + Math.imul(ah0, bh6) | 0; + var w6 = (c + lo | 0) + ((mid & 8191) << 13) | 0; + c = (hi + (mid >>> 13) | 0) + (w6 >>> 26) | 0; + w6 &= 67108863; + lo = Math.imul(al7, bl0); + mid = Math.imul(al7, bh0); + mid = mid + Math.imul(ah7, bl0) | 0; + hi = Math.imul(ah7, bh0); + lo = lo + Math.imul(al6, bl1) | 0; + mid = mid + Math.imul(al6, bh1) | 0; + mid = mid + Math.imul(ah6, bl1) | 0; + hi = hi + Math.imul(ah6, bh1) | 0; + lo = lo + Math.imul(al5, bl2) | 0; + mid = mid + Math.imul(al5, bh2) | 0; + mid = mid + Math.imul(ah5, bl2) | 0; + hi = hi + Math.imul(ah5, bh2) | 0; + lo = lo + Math.imul(al4, bl3) | 0; + mid = mid + Math.imul(al4, bh3) | 0; + mid = mid + Math.imul(ah4, bl3) | 0; + hi = hi + Math.imul(ah4, bh3) | 0; + lo = lo + Math.imul(al3, bl4) | 0; + mid = mid + Math.imul(al3, bh4) | 0; + mid = mid + Math.imul(ah3, bl4) | 0; + hi = hi + Math.imul(ah3, bh4) | 0; + lo = lo + Math.imul(al2, bl5) | 0; + mid = mid + Math.imul(al2, bh5) | 0; + mid = mid + Math.imul(ah2, bl5) | 0; + hi = hi + Math.imul(ah2, bh5) | 0; + lo = lo + Math.imul(al1, bl6) | 0; + mid = mid + Math.imul(al1, bh6) | 0; + mid = mid + Math.imul(ah1, bl6) | 0; + hi = hi + Math.imul(ah1, bh6) | 0; + lo = lo + Math.imul(al0, bl7) | 0; + mid = mid + Math.imul(al0, bh7) | 0; + mid = mid + Math.imul(ah0, bl7) | 0; + hi = hi + Math.imul(ah0, bh7) | 0; + var w7 = (c + lo | 0) + ((mid & 8191) << 13) | 0; + c = (hi + (mid >>> 13) | 0) + (w7 >>> 26) | 0; + w7 &= 67108863; + lo = Math.imul(al8, bl0); + mid = Math.imul(al8, bh0); + mid = mid + Math.imul(ah8, bl0) | 0; + hi = Math.imul(ah8, bh0); + lo = lo + Math.imul(al7, bl1) | 0; + mid = mid + Math.imul(al7, bh1) | 0; + mid = mid + Math.imul(ah7, bl1) | 0; + hi = hi + Math.imul(ah7, bh1) | 0; + lo = lo + Math.imul(al6, bl2) | 0; + mid = mid + Math.imul(al6, bh2) | 0; + mid = mid + Math.imul(ah6, bl2) | 0; + hi = hi + Math.imul(ah6, bh2) | 0; + lo = lo + Math.imul(al5, bl3) | 0; + mid = mid + Math.imul(al5, bh3) | 0; + mid = mid + Math.imul(ah5, bl3) | 0; + hi = hi + Math.imul(ah5, bh3) | 0; + lo = lo + Math.imul(al4, bl4) | 0; + mid = mid + Math.imul(al4, bh4) | 0; + mid = mid + Math.imul(ah4, bl4) | 0; + hi = hi + Math.imul(ah4, bh4) | 0; + lo = lo + Math.imul(al3, bl5) | 0; + mid = mid + Math.imul(al3, bh5) | 0; + mid = mid + Math.imul(ah3, bl5) | 0; + hi = hi + Math.imul(ah3, bh5) | 0; + lo = lo + Math.imul(al2, bl6) | 0; + mid = mid + Math.imul(al2, bh6) | 0; + mid = mid + Math.imul(ah2, bl6) | 0; + hi = hi + Math.imul(ah2, bh6) | 0; + lo = lo + Math.imul(al1, bl7) | 0; + mid = mid + Math.imul(al1, bh7) | 0; + mid = mid + Math.imul(ah1, bl7) | 0; + hi = hi + Math.imul(ah1, bh7) | 0; + lo = lo + Math.imul(al0, bl8) | 0; + mid = mid + Math.imul(al0, bh8) | 0; + mid = mid + Math.imul(ah0, bl8) | 0; + hi = hi + Math.imul(ah0, bh8) | 0; + var w8 = (c + lo | 0) + ((mid & 8191) << 13) | 0; + c = (hi + (mid >>> 13) | 0) + (w8 >>> 26) | 0; + w8 &= 67108863; + lo = Math.imul(al9, bl0); + mid = Math.imul(al9, bh0); + mid = mid + Math.imul(ah9, bl0) | 0; + hi = Math.imul(ah9, bh0); + lo = lo + Math.imul(al8, bl1) | 0; + mid = mid + Math.imul(al8, bh1) | 0; + mid = mid + Math.imul(ah8, bl1) | 0; + hi = hi + Math.imul(ah8, bh1) | 0; + lo = lo + Math.imul(al7, bl2) | 0; + mid = mid + Math.imul(al7, bh2) | 0; + mid = mid + Math.imul(ah7, bl2) | 0; + hi = hi + Math.imul(ah7, bh2) | 0; + lo = lo + Math.imul(al6, bl3) | 0; + mid = mid + Math.imul(al6, bh3) | 0; + mid = mid + Math.imul(ah6, bl3) | 0; + hi = hi + Math.imul(ah6, bh3) | 0; + lo = lo + Math.imul(al5, bl4) | 0; + mid = mid + Math.imul(al5, bh4) | 0; + mid = mid + Math.imul(ah5, bl4) | 0; + hi = hi + Math.imul(ah5, bh4) | 0; + lo = lo + Math.imul(al4, bl5) | 0; + mid = mid + Math.imul(al4, bh5) | 0; + mid = mid + Math.imul(ah4, bl5) | 0; + hi = hi + Math.imul(ah4, bh5) | 0; + lo = lo + Math.imul(al3, bl6) | 0; + mid = mid + Math.imul(al3, bh6) | 0; + mid = mid + Math.imul(ah3, bl6) | 0; + hi = hi + Math.imul(ah3, bh6) | 0; + lo = lo + Math.imul(al2, bl7) | 0; + mid = mid + Math.imul(al2, bh7) | 0; + mid = mid + Math.imul(ah2, bl7) | 0; + hi = hi + Math.imul(ah2, bh7) | 0; + lo = lo + Math.imul(al1, bl8) | 0; + mid = mid + Math.imul(al1, bh8) | 0; + mid = mid + Math.imul(ah1, bl8) | 0; + hi = hi + Math.imul(ah1, bh8) | 0; + lo = lo + Math.imul(al0, bl9) | 0; + mid = mid + Math.imul(al0, bh9) | 0; + mid = mid + Math.imul(ah0, bl9) | 0; + hi = hi + Math.imul(ah0, bh9) | 0; + var w9 = (c + lo | 0) + ((mid & 8191) << 13) | 0; + c = (hi + (mid >>> 13) | 0) + (w9 >>> 26) | 0; + w9 &= 67108863; + lo = Math.imul(al9, bl1); + mid = Math.imul(al9, bh1); + mid = mid + Math.imul(ah9, bl1) | 0; + hi = Math.imul(ah9, bh1); + lo = lo + Math.imul(al8, bl2) | 0; + mid = mid + Math.imul(al8, bh2) | 0; + mid = mid + Math.imul(ah8, bl2) | 0; + hi = hi + Math.imul(ah8, bh2) | 0; + lo = lo + Math.imul(al7, bl3) | 0; + mid = mid + Math.imul(al7, bh3) | 0; + mid = mid + Math.imul(ah7, bl3) | 0; + hi = hi + Math.imul(ah7, bh3) | 0; + lo = lo + Math.imul(al6, bl4) | 0; + mid = mid + Math.imul(al6, bh4) | 0; + mid = mid + Math.imul(ah6, bl4) | 0; + hi = hi + Math.imul(ah6, bh4) | 0; + lo = lo + Math.imul(al5, bl5) | 0; + mid = mid + Math.imul(al5, bh5) | 0; + mid = mid + Math.imul(ah5, bl5) | 0; + hi = hi + Math.imul(ah5, bh5) | 0; + lo = lo + Math.imul(al4, bl6) | 0; + mid = mid + Math.imul(al4, bh6) | 0; + mid = mid + Math.imul(ah4, bl6) | 0; + hi = hi + Math.imul(ah4, bh6) | 0; + lo = lo + Math.imul(al3, bl7) | 0; + mid = mid + Math.imul(al3, bh7) | 0; + mid = mid + Math.imul(ah3, bl7) | 0; + hi = hi + Math.imul(ah3, bh7) | 0; + lo = lo + Math.imul(al2, bl8) | 0; + mid = mid + Math.imul(al2, bh8) | 0; + mid = mid + Math.imul(ah2, bl8) | 0; + hi = hi + Math.imul(ah2, bh8) | 0; + lo = lo + Math.imul(al1, bl9) | 0; + mid = mid + Math.imul(al1, bh9) | 0; + mid = mid + Math.imul(ah1, bl9) | 0; + hi = hi + Math.imul(ah1, bh9) | 0; + var w10 = (c + lo | 0) + ((mid & 8191) << 13) | 0; + c = (hi + (mid >>> 13) | 0) + (w10 >>> 26) | 0; + w10 &= 67108863; + lo = Math.imul(al9, bl2); + mid = Math.imul(al9, bh2); + mid = mid + Math.imul(ah9, bl2) | 0; + hi = Math.imul(ah9, bh2); + lo = lo + Math.imul(al8, bl3) | 0; + mid = mid + Math.imul(al8, bh3) | 0; + mid = mid + Math.imul(ah8, bl3) | 0; + hi = hi + Math.imul(ah8, bh3) | 0; + lo = lo + Math.imul(al7, bl4) | 0; + mid = mid + Math.imul(al7, bh4) | 0; + mid = mid + Math.imul(ah7, bl4) | 0; + hi = hi + Math.imul(ah7, bh4) | 0; + lo = lo + Math.imul(al6, bl5) | 0; + mid = mid + Math.imul(al6, bh5) | 0; + mid = mid + Math.imul(ah6, bl5) | 0; + hi = hi + Math.imul(ah6, bh5) | 0; + lo = lo + Math.imul(al5, bl6) | 0; + mid = mid + Math.imul(al5, bh6) | 0; + mid = mid + Math.imul(ah5, bl6) | 0; + hi = hi + Math.imul(ah5, bh6) | 0; + lo = lo + Math.imul(al4, bl7) | 0; + mid = mid + Math.imul(al4, bh7) | 0; + mid = mid + Math.imul(ah4, bl7) | 0; + hi = hi + Math.imul(ah4, bh7) | 0; + lo = lo + Math.imul(al3, bl8) | 0; + mid = mid + Math.imul(al3, bh8) | 0; + mid = mid + Math.imul(ah3, bl8) | 0; + hi = hi + Math.imul(ah3, bh8) | 0; + lo = lo + Math.imul(al2, bl9) | 0; + mid = mid + Math.imul(al2, bh9) | 0; + mid = mid + Math.imul(ah2, bl9) | 0; + hi = hi + Math.imul(ah2, bh9) | 0; + var w11 = (c + lo | 0) + ((mid & 8191) << 13) | 0; + c = (hi + (mid >>> 13) | 0) + (w11 >>> 26) | 0; + w11 &= 67108863; + lo = Math.imul(al9, bl3); + mid = Math.imul(al9, bh3); + mid = mid + Math.imul(ah9, bl3) | 0; + hi = Math.imul(ah9, bh3); + lo = lo + Math.imul(al8, bl4) | 0; + mid = mid + Math.imul(al8, bh4) | 0; + mid = mid + Math.imul(ah8, bl4) | 0; + hi = hi + Math.imul(ah8, bh4) | 0; + lo = lo + Math.imul(al7, bl5) | 0; + mid = mid + Math.imul(al7, bh5) | 0; + mid = mid + Math.imul(ah7, bl5) | 0; + hi = hi + Math.imul(ah7, bh5) | 0; + lo = lo + Math.imul(al6, bl6) | 0; + mid = mid + Math.imul(al6, bh6) | 0; + mid = mid + Math.imul(ah6, bl6) | 0; + hi = hi + Math.imul(ah6, bh6) | 0; + lo = lo + Math.imul(al5, bl7) | 0; + mid = mid + Math.imul(al5, bh7) | 0; + mid = mid + Math.imul(ah5, bl7) | 0; + hi = hi + Math.imul(ah5, bh7) | 0; + lo = lo + Math.imul(al4, bl8) | 0; + mid = mid + Math.imul(al4, bh8) | 0; + mid = mid + Math.imul(ah4, bl8) | 0; + hi = hi + Math.imul(ah4, bh8) | 0; + lo = lo + Math.imul(al3, bl9) | 0; + mid = mid + Math.imul(al3, bh9) | 0; + mid = mid + Math.imul(ah3, bl9) | 0; + hi = hi + Math.imul(ah3, bh9) | 0; + var w12 = (c + lo | 0) + ((mid & 8191) << 13) | 0; + c = (hi + (mid >>> 13) | 0) + (w12 >>> 26) | 0; + w12 &= 67108863; + lo = Math.imul(al9, bl4); + mid = Math.imul(al9, bh4); + mid = mid + Math.imul(ah9, bl4) | 0; + hi = Math.imul(ah9, bh4); + lo = lo + Math.imul(al8, bl5) | 0; + mid = mid + Math.imul(al8, bh5) | 0; + mid = mid + Math.imul(ah8, bl5) | 0; + hi = hi + Math.imul(ah8, bh5) | 0; + lo = lo + Math.imul(al7, bl6) | 0; + mid = mid + Math.imul(al7, bh6) | 0; + mid = mid + Math.imul(ah7, bl6) | 0; + hi = hi + Math.imul(ah7, bh6) | 0; + lo = lo + Math.imul(al6, bl7) | 0; + mid = mid + Math.imul(al6, bh7) | 0; + mid = mid + Math.imul(ah6, bl7) | 0; + hi = hi + Math.imul(ah6, bh7) | 0; + lo = lo + Math.imul(al5, bl8) | 0; + mid = mid + Math.imul(al5, bh8) | 0; + mid = mid + Math.imul(ah5, bl8) | 0; + hi = hi + Math.imul(ah5, bh8) | 0; + lo = lo + Math.imul(al4, bl9) | 0; + mid = mid + Math.imul(al4, bh9) | 0; + mid = mid + Math.imul(ah4, bl9) | 0; + hi = hi + Math.imul(ah4, bh9) | 0; + var w13 = (c + lo | 0) + ((mid & 8191) << 13) | 0; + c = (hi + (mid >>> 13) | 0) + (w13 >>> 26) | 0; + w13 &= 67108863; + lo = Math.imul(al9, bl5); + mid = Math.imul(al9, bh5); + mid = mid + Math.imul(ah9, bl5) | 0; + hi = Math.imul(ah9, bh5); + lo = lo + Math.imul(al8, bl6) | 0; + mid = mid + Math.imul(al8, bh6) | 0; + mid = mid + Math.imul(ah8, bl6) | 0; + hi = hi + Math.imul(ah8, bh6) | 0; + lo = lo + Math.imul(al7, bl7) | 0; + mid = mid + Math.imul(al7, bh7) | 0; + mid = mid + Math.imul(ah7, bl7) | 0; + hi = hi + Math.imul(ah7, bh7) | 0; + lo = lo + Math.imul(al6, bl8) | 0; + mid = mid + Math.imul(al6, bh8) | 0; + mid = mid + Math.imul(ah6, bl8) | 0; + hi = hi + Math.imul(ah6, bh8) | 0; + lo = lo + Math.imul(al5, bl9) | 0; + mid = mid + Math.imul(al5, bh9) | 0; + mid = mid + Math.imul(ah5, bl9) | 0; + hi = hi + Math.imul(ah5, bh9) | 0; + var w14 = (c + lo | 0) + ((mid & 8191) << 13) | 0; + c = (hi + (mid >>> 13) | 0) + (w14 >>> 26) | 0; + w14 &= 67108863; + lo = Math.imul(al9, bl6); + mid = Math.imul(al9, bh6); + mid = mid + Math.imul(ah9, bl6) | 0; + hi = Math.imul(ah9, bh6); + lo = lo + Math.imul(al8, bl7) | 0; + mid = mid + Math.imul(al8, bh7) | 0; + mid = mid + Math.imul(ah8, bl7) | 0; + hi = hi + Math.imul(ah8, bh7) | 0; + lo = lo + Math.imul(al7, bl8) | 0; + mid = mid + Math.imul(al7, bh8) | 0; + mid = mid + Math.imul(ah7, bl8) | 0; + hi = hi + Math.imul(ah7, bh8) | 0; + lo = lo + Math.imul(al6, bl9) | 0; + mid = mid + Math.imul(al6, bh9) | 0; + mid = mid + Math.imul(ah6, bl9) | 0; + hi = hi + Math.imul(ah6, bh9) | 0; + var w15 = (c + lo | 0) + ((mid & 8191) << 13) | 0; + c = (hi + (mid >>> 13) | 0) + (w15 >>> 26) | 0; + w15 &= 67108863; + lo = Math.imul(al9, bl7); + mid = Math.imul(al9, bh7); + mid = mid + Math.imul(ah9, bl7) | 0; + hi = Math.imul(ah9, bh7); + lo = lo + Math.imul(al8, bl8) | 0; + mid = mid + Math.imul(al8, bh8) | 0; + mid = mid + Math.imul(ah8, bl8) | 0; + hi = hi + Math.imul(ah8, bh8) | 0; + lo = lo + Math.imul(al7, bl9) | 0; + mid = mid + Math.imul(al7, bh9) | 0; + mid = mid + Math.imul(ah7, bl9) | 0; + hi = hi + Math.imul(ah7, bh9) | 0; + var w16 = (c + lo | 0) + ((mid & 8191) << 13) | 0; + c = (hi + (mid >>> 13) | 0) + (w16 >>> 26) | 0; + w16 &= 67108863; + lo = Math.imul(al9, bl8); + mid = Math.imul(al9, bh8); + mid = mid + Math.imul(ah9, bl8) | 0; + hi = Math.imul(ah9, bh8); + lo = lo + Math.imul(al8, bl9) | 0; + mid = mid + Math.imul(al8, bh9) | 0; + mid = mid + Math.imul(ah8, bl9) | 0; + hi = hi + Math.imul(ah8, bh9) | 0; + var w17 = (c + lo | 0) + ((mid & 8191) << 13) | 0; + c = (hi + (mid >>> 13) | 0) + (w17 >>> 26) | 0; + w17 &= 67108863; + lo = Math.imul(al9, bl9); + mid = Math.imul(al9, bh9); + mid = mid + Math.imul(ah9, bl9) | 0; + hi = Math.imul(ah9, bh9); + var w18 = (c + lo | 0) + ((mid & 8191) << 13) | 0; + c = (hi + (mid >>> 13) | 0) + (w18 >>> 26) | 0; + w18 &= 67108863; + o[0] = w0; + o[1] = w1; + o[2] = w2; + o[3] = w3; + o[4] = w4; + o[5] = w5; + o[6] = w6; + o[7] = w7; + o[8] = w8; + o[9] = w9; + o[10] = w10; + o[11] = w11; + o[12] = w12; + o[13] = w13; + o[14] = w14; + o[15] = w15; + o[16] = w16; + o[17] = w17; + o[18] = w18; + if (c !== 0) { + o[19] = c; + out.length++; + } + return out; + }; + if (!Math.imul) { + comb10MulTo = smallMulTo; + } + function bigMulTo(self2, num, out) { + out.negative = num.negative ^ self2.negative; + out.length = self2.length + num.length; + var carry = 0; + var hncarry = 0; + for (var k = 0; k < out.length - 1; k++) { + var ncarry = hncarry; + hncarry = 0; + var rword = carry & 67108863; + var maxJ = Math.min(k, num.length - 1); + for (var j = Math.max(0, k - self2.length + 1); j <= maxJ; j++) { + var i2 = k - j; + var a = self2.words[i2] | 0; + var b = num.words[j] | 0; + var r = a * b; + var lo = r & 67108863; + ncarry = ncarry + (r / 67108864 | 0) | 0; + lo = lo + rword | 0; + rword = lo & 67108863; + ncarry = ncarry + (lo >>> 26) | 0; + hncarry += ncarry >>> 26; + ncarry &= 67108863; + } + out.words[k] = rword; + carry = ncarry; + ncarry = hncarry; + } + if (carry !== 0) { + out.words[k] = carry; + } else { + out.length--; + } + return out._strip(); + } + function jumboMulTo(self2, num, out) { + return bigMulTo(self2, num, out); + } + BN.prototype.mulTo = function mulTo(num, out) { + var res; + var len2 = this.length + num.length; + if (this.length === 10 && num.length === 10) { + res = comb10MulTo(this, num, out); + } else if (len2 < 63) { + res = smallMulTo(this, num, out); + } else if (len2 < 1024) { + res = bigMulTo(this, num, out); + } else { + res = jumboMulTo(this, num, out); + } + return res; + }; + BN.prototype.mul = function mul(num) { + var out = new BN(null); + out.words = new Array(this.length + num.length); + return this.mulTo(num, out); + }; + BN.prototype.mulf = function mulf(num) { + var out = new BN(null); + out.words = new Array(this.length + num.length); + return jumboMulTo(this, num, out); + }; + BN.prototype.imul = function imul(num) { + return this.clone().mulTo(num, this); + }; + BN.prototype.imuln = function imuln(num) { + var isNegNum = num < 0; + if (isNegNum) num = -num; + assert(typeof num === "number"); + assert(num < 67108864); + var carry = 0; + for (var i2 = 0; i2 < this.length; i2++) { + var w = (this.words[i2] | 0) * num; + var lo = (w & 67108863) + (carry & 67108863); + carry >>= 26; + carry += w / 67108864 | 0; + carry += lo >>> 26; + this.words[i2] = lo & 67108863; + } + if (carry !== 0) { + this.words[i2] = carry; + this.length++; + } + return isNegNum ? this.ineg() : this; + }; + BN.prototype.muln = function muln(num) { + return this.clone().imuln(num); + }; + BN.prototype.sqr = function sqr() { + return this.mul(this); + }; + BN.prototype.isqr = function isqr() { + return this.imul(this.clone()); + }; + BN.prototype.pow = function pow(num) { + var w = toBitArray(num); + if (w.length === 0) return new BN(1); + var res = this; + for (var i2 = 0; i2 < w.length; i2++, res = res.sqr()) { + if (w[i2] !== 0) break; + } + if (++i2 < w.length) { + for (var q = res.sqr(); i2 < w.length; i2++, q = q.sqr()) { + if (w[i2] === 0) continue; + res = res.mul(q); + } + } + return res; + }; + BN.prototype.iushln = function iushln(bits) { + assert(typeof bits === "number" && bits >= 0); + var r = bits % 26; + var s = (bits - r) / 26; + var carryMask = 67108863 >>> 26 - r << 26 - r; + var i2; + if (r !== 0) { + var carry = 0; + for (i2 = 0; i2 < this.length; i2++) { + var newCarry = this.words[i2] & carryMask; + var c = (this.words[i2] | 0) - newCarry << r; + this.words[i2] = c | carry; + carry = newCarry >>> 26 - r; + } + if (carry) { + this.words[i2] = carry; + this.length++; + } + } + if (s !== 0) { + for (i2 = this.length - 1; i2 >= 0; i2--) { + this.words[i2 + s] = this.words[i2]; + } + for (i2 = 0; i2 < s; i2++) { + this.words[i2] = 0; + } + this.length += s; + } + return this._strip(); + }; + BN.prototype.ishln = function ishln(bits) { + assert(this.negative === 0); + return this.iushln(bits); + }; + BN.prototype.iushrn = function iushrn(bits, hint, extended) { + assert(typeof bits === "number" && bits >= 0); + var h; + if (hint) { + h = (hint - hint % 26) / 26; + } else { + h = 0; + } + var r = bits % 26; + var s = Math.min((bits - r) / 26, this.length); + var mask = 67108863 ^ 67108863 >>> r << r; + var maskedWords = extended; + h -= s; + h = Math.max(0, h); + if (maskedWords) { + for (var i2 = 0; i2 < s; i2++) { + maskedWords.words[i2] = this.words[i2]; + } + maskedWords.length = s; + } + if (s === 0) ; + else if (this.length > s) { + this.length -= s; + for (i2 = 0; i2 < this.length; i2++) { + this.words[i2] = this.words[i2 + s]; + } + } else { + this.words[0] = 0; + this.length = 1; + } + var carry = 0; + for (i2 = this.length - 1; i2 >= 0 && (carry !== 0 || i2 >= h); i2--) { + var word = this.words[i2] | 0; + this.words[i2] = carry << 26 - r | word >>> r; + carry = word & mask; + } + if (maskedWords && carry !== 0) { + maskedWords.words[maskedWords.length++] = carry; + } + if (this.length === 0) { + this.words[0] = 0; + this.length = 1; + } + return this._strip(); + }; + BN.prototype.ishrn = function ishrn(bits, hint, extended) { + assert(this.negative === 0); + return this.iushrn(bits, hint, extended); + }; + BN.prototype.shln = function shln(bits) { + return this.clone().ishln(bits); + }; + BN.prototype.ushln = function ushln(bits) { + return this.clone().iushln(bits); + }; + BN.prototype.shrn = function shrn(bits) { + return this.clone().ishrn(bits); + }; + BN.prototype.ushrn = function ushrn(bits) { + return this.clone().iushrn(bits); + }; + BN.prototype.testn = function testn(bit) { + assert(typeof bit === "number" && bit >= 0); + var r = bit % 26; + var s = (bit - r) / 26; + var q = 1 << r; + if (this.length <= s) return false; + var w = this.words[s]; + return !!(w & q); + }; + BN.prototype.imaskn = function imaskn(bits) { + assert(typeof bits === "number" && bits >= 0); + var r = bits % 26; + var s = (bits - r) / 26; + assert(this.negative === 0, "imaskn works only with positive numbers"); + if (this.length <= s) { + return this; + } + if (r !== 0) { + s++; + } + this.length = Math.min(s, this.length); + if (r !== 0) { + var mask = 67108863 ^ 67108863 >>> r << r; + this.words[this.length - 1] &= mask; + } + return this._strip(); + }; + BN.prototype.maskn = function maskn(bits) { + return this.clone().imaskn(bits); + }; + BN.prototype.iaddn = function iaddn(num) { + assert(typeof num === "number"); + assert(num < 67108864); + if (num < 0) return this.isubn(-num); + if (this.negative !== 0) { + if (this.length === 1 && (this.words[0] | 0) <= num) { + this.words[0] = num - (this.words[0] | 0); + this.negative = 0; + return this; + } + this.negative = 0; + this.isubn(num); + this.negative = 1; + return this; + } + return this._iaddn(num); + }; + BN.prototype._iaddn = function _iaddn(num) { + this.words[0] += num; + for (var i2 = 0; i2 < this.length && this.words[i2] >= 67108864; i2++) { + this.words[i2] -= 67108864; + if (i2 === this.length - 1) { + this.words[i2 + 1] = 1; + } else { + this.words[i2 + 1]++; + } + } + this.length = Math.max(this.length, i2 + 1); + return this; + }; + BN.prototype.isubn = function isubn(num) { + assert(typeof num === "number"); + assert(num < 67108864); + if (num < 0) return this.iaddn(-num); + if (this.negative !== 0) { + this.negative = 0; + this.iaddn(num); + this.negative = 1; + return this; + } + this.words[0] -= num; + if (this.length === 1 && this.words[0] < 0) { + this.words[0] = -this.words[0]; + this.negative = 1; + } else { + for (var i2 = 0; i2 < this.length && this.words[i2] < 0; i2++) { + this.words[i2] += 67108864; + this.words[i2 + 1] -= 1; + } + } + return this._strip(); + }; + BN.prototype.addn = function addn(num) { + return this.clone().iaddn(num); + }; + BN.prototype.subn = function subn(num) { + return this.clone().isubn(num); + }; + BN.prototype.iabs = function iabs() { + this.negative = 0; + return this; + }; + BN.prototype.abs = function abs() { + return this.clone().iabs(); + }; + BN.prototype._ishlnsubmul = function _ishlnsubmul(num, mul, shift) { + var len2 = num.length + shift; + var i2; + this._expand(len2); + var w; + var carry = 0; + for (i2 = 0; i2 < num.length; i2++) { + w = (this.words[i2 + shift] | 0) + carry; + var right = (num.words[i2] | 0) * mul; + w -= right & 67108863; + carry = (w >> 26) - (right / 67108864 | 0); + this.words[i2 + shift] = w & 67108863; + } + for (; i2 < this.length - shift; i2++) { + w = (this.words[i2 + shift] | 0) + carry; + carry = w >> 26; + this.words[i2 + shift] = w & 67108863; + } + if (carry === 0) return this._strip(); + assert(carry === -1); + carry = 0; + for (i2 = 0; i2 < this.length; i2++) { + w = -(this.words[i2] | 0) + carry; + carry = w >> 26; + this.words[i2] = w & 67108863; + } + this.negative = 1; + return this._strip(); + }; + BN.prototype._wordDiv = function _wordDiv(num, mode) { + var shift = this.length - num.length; + var a = this.clone(); + var b = num; + var bhi = b.words[b.length - 1] | 0; + var bhiBits = this._countBits(bhi); + shift = 26 - bhiBits; + if (shift !== 0) { + b = b.ushln(shift); + a.iushln(shift); + bhi = b.words[b.length - 1] | 0; + } + var m = a.length - b.length; + var q; + if (mode !== "mod") { + q = new BN(null); + q.length = m + 1; + q.words = new Array(q.length); + for (var i2 = 0; i2 < q.length; i2++) { + q.words[i2] = 0; + } + } + var diff = a.clone()._ishlnsubmul(b, 1, m); + if (diff.negative === 0) { + a = diff; + if (q) { + q.words[m] = 1; + } + } + for (var j = m - 1; j >= 0; j--) { + var qj = (a.words[b.length + j] | 0) * 67108864 + (a.words[b.length + j - 1] | 0); + qj = Math.min(qj / bhi | 0, 67108863); + a._ishlnsubmul(b, qj, j); + while (a.negative !== 0) { + qj--; + a.negative = 0; + a._ishlnsubmul(b, 1, j); + if (!a.isZero()) { + a.negative ^= 1; + } + } + if (q) { + q.words[j] = qj; + } + } + if (q) { + q._strip(); + } + a._strip(); + if (mode !== "div" && shift !== 0) { + a.iushrn(shift); + } + return { + div: q || null, + mod: a + }; + }; + BN.prototype.divmod = function divmod(num, mode, positive) { + assert(!num.isZero()); + if (this.isZero()) { + return { + div: new BN(0), + mod: new BN(0) + }; + } + var div, mod, res; + if (this.negative !== 0 && num.negative === 0) { + res = this.neg().divmod(num, mode); + if (mode !== "mod") { + div = res.div.neg(); + } + if (mode !== "div") { + mod = res.mod.neg(); + if (positive && mod.negative !== 0) { + mod.iadd(num); + } + } + return { + div, + mod + }; + } + if (this.negative === 0 && num.negative !== 0) { + res = this.divmod(num.neg(), mode); + if (mode !== "mod") { + div = res.div.neg(); + } + return { + div, + mod: res.mod + }; + } + if ((this.negative & num.negative) !== 0) { + res = this.neg().divmod(num.neg(), mode); + if (mode !== "div") { + mod = res.mod.neg(); + if (positive && mod.negative !== 0) { + mod.isub(num); + } + } + return { + div: res.div, + mod + }; + } + if (num.length > this.length || this.cmp(num) < 0) { + return { + div: new BN(0), + mod: this + }; + } + if (num.length === 1) { + if (mode === "div") { + return { + div: this.divn(num.words[0]), + mod: null + }; + } + if (mode === "mod") { + return { + div: null, + mod: new BN(this.modrn(num.words[0])) + }; + } + return { + div: this.divn(num.words[0]), + mod: new BN(this.modrn(num.words[0])) + }; + } + return this._wordDiv(num, mode); + }; + BN.prototype.div = function div(num) { + return this.divmod(num, "div", false).div; + }; + BN.prototype.mod = function mod(num) { + return this.divmod(num, "mod", false).mod; + }; + BN.prototype.umod = function umod(num) { + return this.divmod(num, "mod", true).mod; + }; + BN.prototype.divRound = function divRound(num) { + var dm = this.divmod(num); + if (dm.mod.isZero()) return dm.div; + var mod = dm.div.negative !== 0 ? dm.mod.isub(num) : dm.mod; + var half = num.ushrn(1); + var r2 = num.andln(1); + var cmp = mod.cmp(half); + if (cmp < 0 || r2 === 1 && cmp === 0) return dm.div; + return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1); + }; + BN.prototype.modrn = function modrn(num) { + var isNegNum = num < 0; + if (isNegNum) num = -num; + assert(num <= 67108863); + var p = (1 << 26) % num; + var acc = 0; + for (var i2 = this.length - 1; i2 >= 0; i2--) { + acc = (p * acc + (this.words[i2] | 0)) % num; + } + return isNegNum ? -acc : acc; + }; + BN.prototype.modn = function modn(num) { + return this.modrn(num); + }; + BN.prototype.idivn = function idivn(num) { + var isNegNum = num < 0; + if (isNegNum) num = -num; + assert(num <= 67108863); + var carry = 0; + for (var i2 = this.length - 1; i2 >= 0; i2--) { + var w = (this.words[i2] | 0) + carry * 67108864; + this.words[i2] = w / num | 0; + carry = w % num; + } + this._strip(); + return isNegNum ? this.ineg() : this; + }; + BN.prototype.divn = function divn(num) { + return this.clone().idivn(num); + }; + BN.prototype.egcd = function egcd(p) { + assert(p.negative === 0); + assert(!p.isZero()); + var x = this; + var y = p.clone(); + if (x.negative !== 0) { + x = x.umod(p); + } else { + x = x.clone(); + } + var A = new BN(1); + var B = new BN(0); + var C = new BN(0); + var D = new BN(1); + var g = 0; + while (x.isEven() && y.isEven()) { + x.iushrn(1); + y.iushrn(1); + ++g; + } + var yp = y.clone(); + var xp = x.clone(); + while (!x.isZero()) { + for (var i2 = 0, im = 1; (x.words[0] & im) === 0 && i2 < 26; ++i2, im <<= 1) ; + if (i2 > 0) { + x.iushrn(i2); + while (i2-- > 0) { + if (A.isOdd() || B.isOdd()) { + A.iadd(yp); + B.isub(xp); + } + A.iushrn(1); + B.iushrn(1); + } + } + for (var j = 0, jm = 1; (y.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1) ; + if (j > 0) { + y.iushrn(j); + while (j-- > 0) { + if (C.isOdd() || D.isOdd()) { + C.iadd(yp); + D.isub(xp); + } + C.iushrn(1); + D.iushrn(1); + } + } + if (x.cmp(y) >= 0) { + x.isub(y); + A.isub(C); + B.isub(D); + } else { + y.isub(x); + C.isub(A); + D.isub(B); + } + } + return { + a: C, + b: D, + gcd: y.iushln(g) + }; + }; + BN.prototype._invmp = function _invmp(p) { + assert(p.negative === 0); + assert(!p.isZero()); + var a = this; + var b = p.clone(); + if (a.negative !== 0) { + a = a.umod(p); + } else { + a = a.clone(); + } + var x1 = new BN(1); + var x2 = new BN(0); + var delta = b.clone(); + while (a.cmpn(1) > 0 && b.cmpn(1) > 0) { + for (var i2 = 0, im = 1; (a.words[0] & im) === 0 && i2 < 26; ++i2, im <<= 1) ; + if (i2 > 0) { + a.iushrn(i2); + while (i2-- > 0) { + if (x1.isOdd()) { + x1.iadd(delta); + } + x1.iushrn(1); + } + } + for (var j = 0, jm = 1; (b.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1) ; + if (j > 0) { + b.iushrn(j); + while (j-- > 0) { + if (x2.isOdd()) { + x2.iadd(delta); + } + x2.iushrn(1); + } + } + if (a.cmp(b) >= 0) { + a.isub(b); + x1.isub(x2); + } else { + b.isub(a); + x2.isub(x1); + } + } + var res; + if (a.cmpn(1) === 0) { + res = x1; + } else { + res = x2; + } + if (res.cmpn(0) < 0) { + res.iadd(p); + } + return res; + }; + BN.prototype.gcd = function gcd(num) { + if (this.isZero()) return num.abs(); + if (num.isZero()) return this.abs(); + var a = this.clone(); + var b = num.clone(); + a.negative = 0; + b.negative = 0; + for (var shift = 0; a.isEven() && b.isEven(); shift++) { + a.iushrn(1); + b.iushrn(1); + } + do { + while (a.isEven()) { + a.iushrn(1); + } + while (b.isEven()) { + b.iushrn(1); + } + var r = a.cmp(b); + if (r < 0) { + var t = a; + a = b; + b = t; + } else if (r === 0 || b.cmpn(1) === 0) { + break; + } + a.isub(b); + } while (true); + return b.iushln(shift); + }; + BN.prototype.invm = function invm(num) { + return this.egcd(num).a.umod(num); + }; + BN.prototype.isEven = function isEven() { + return (this.words[0] & 1) === 0; + }; + BN.prototype.isOdd = function isOdd() { + return (this.words[0] & 1) === 1; + }; + BN.prototype.andln = function andln(num) { + return this.words[0] & num; + }; + BN.prototype.bincn = function bincn(bit) { + assert(typeof bit === "number"); + var r = bit % 26; + var s = (bit - r) / 26; + var q = 1 << r; + if (this.length <= s) { + this._expand(s + 1); + this.words[s] |= q; + return this; + } + var carry = q; + for (var i2 = s; carry !== 0 && i2 < this.length; i2++) { + var w = this.words[i2] | 0; + w += carry; + carry = w >>> 26; + w &= 67108863; + this.words[i2] = w; + } + if (carry !== 0) { + this.words[i2] = carry; + this.length++; + } + return this; + }; + BN.prototype.isZero = function isZero() { + return this.length === 1 && this.words[0] === 0; + }; + BN.prototype.cmpn = function cmpn(num) { + var negative = num < 0; + if (this.negative !== 0 && !negative) return -1; + if (this.negative === 0 && negative) return 1; + this._strip(); + var res; + if (this.length > 1) { + res = 1; + } else { + if (negative) { + num = -num; + } + assert(num <= 67108863, "Number is too big"); + var w = this.words[0] | 0; + res = w === num ? 0 : w < num ? -1 : 1; + } + if (this.negative !== 0) return -res | 0; + return res; + }; + BN.prototype.cmp = function cmp(num) { + if (this.negative !== 0 && num.negative === 0) return -1; + if (this.negative === 0 && num.negative !== 0) return 1; + var res = this.ucmp(num); + if (this.negative !== 0) return -res | 0; + return res; + }; + BN.prototype.ucmp = function ucmp(num) { + if (this.length > num.length) return 1; + if (this.length < num.length) return -1; + var res = 0; + for (var i2 = this.length - 1; i2 >= 0; i2--) { + var a = this.words[i2] | 0; + var b = num.words[i2] | 0; + if (a === b) continue; + if (a < b) { + res = -1; + } else if (a > b) { + res = 1; + } + break; + } + return res; + }; + BN.prototype.gtn = function gtn(num) { + return this.cmpn(num) === 1; + }; + BN.prototype.gt = function gt(num) { + return this.cmp(num) === 1; + }; + BN.prototype.gten = function gten(num) { + return this.cmpn(num) >= 0; + }; + BN.prototype.gte = function gte(num) { + return this.cmp(num) >= 0; + }; + BN.prototype.ltn = function ltn(num) { + return this.cmpn(num) === -1; + }; + BN.prototype.lt = function lt(num) { + return this.cmp(num) === -1; + }; + BN.prototype.lten = function lten(num) { + return this.cmpn(num) <= 0; + }; + BN.prototype.lte = function lte(num) { + return this.cmp(num) <= 0; + }; + BN.prototype.eqn = function eqn(num) { + return this.cmpn(num) === 0; + }; + BN.prototype.eq = function eq(num) { + return this.cmp(num) === 0; + }; + BN.red = function red(num) { + return new Red(num); + }; + BN.prototype.toRed = function toRed(ctx) { + assert(!this.red, "Already a number in reduction context"); + assert(this.negative === 0, "red works only with positives"); + return ctx.convertTo(this)._forceRed(ctx); + }; + BN.prototype.fromRed = function fromRed() { + assert(this.red, "fromRed works only with numbers in reduction context"); + return this.red.convertFrom(this); + }; + BN.prototype._forceRed = function _forceRed(ctx) { + this.red = ctx; + return this; + }; + BN.prototype.forceRed = function forceRed(ctx) { + assert(!this.red, "Already a number in reduction context"); + return this._forceRed(ctx); + }; + BN.prototype.redAdd = function redAdd(num) { + assert(this.red, "redAdd works only with red numbers"); + return this.red.add(this, num); + }; + BN.prototype.redIAdd = function redIAdd(num) { + assert(this.red, "redIAdd works only with red numbers"); + return this.red.iadd(this, num); + }; + BN.prototype.redSub = function redSub(num) { + assert(this.red, "redSub works only with red numbers"); + return this.red.sub(this, num); + }; + BN.prototype.redISub = function redISub(num) { + assert(this.red, "redISub works only with red numbers"); + return this.red.isub(this, num); + }; + BN.prototype.redShl = function redShl(num) { + assert(this.red, "redShl works only with red numbers"); + return this.red.shl(this, num); + }; + BN.prototype.redMul = function redMul(num) { + assert(this.red, "redMul works only with red numbers"); + this.red._verify2(this, num); + return this.red.mul(this, num); + }; + BN.prototype.redIMul = function redIMul(num) { + assert(this.red, "redMul works only with red numbers"); + this.red._verify2(this, num); + return this.red.imul(this, num); + }; + BN.prototype.redSqr = function redSqr() { + assert(this.red, "redSqr works only with red numbers"); + this.red._verify1(this); + return this.red.sqr(this); + }; + BN.prototype.redISqr = function redISqr() { + assert(this.red, "redISqr works only with red numbers"); + this.red._verify1(this); + return this.red.isqr(this); + }; + BN.prototype.redSqrt = function redSqrt() { + assert(this.red, "redSqrt works only with red numbers"); + this.red._verify1(this); + return this.red.sqrt(this); + }; + BN.prototype.redInvm = function redInvm() { + assert(this.red, "redInvm works only with red numbers"); + this.red._verify1(this); + return this.red.invm(this); + }; + BN.prototype.redNeg = function redNeg() { + assert(this.red, "redNeg works only with red numbers"); + this.red._verify1(this); + return this.red.neg(this); + }; + BN.prototype.redPow = function redPow(num) { + assert(this.red && !num.red, "redPow(normalNum)"); + this.red._verify1(this); + return this.red.pow(this, num); + }; + var primes = { + k256: null, + p224: null, + p192: null, + p25519: null + }; + function MPrime(name, p) { + this.name = name; + this.p = new BN(p, 16); + this.n = this.p.bitLength(); + this.k = new BN(1).iushln(this.n).isub(this.p); + this.tmp = this._tmp(); + } + MPrime.prototype._tmp = function _tmp() { + var tmp = new BN(null); + tmp.words = new Array(Math.ceil(this.n / 13)); + return tmp; + }; + MPrime.prototype.ireduce = function ireduce(num) { + var r = num; + var rlen; + do { + this.split(r, this.tmp); + r = this.imulK(r); + r = r.iadd(this.tmp); + rlen = r.bitLength(); + } while (rlen > this.n); + var cmp = rlen < this.n ? -1 : r.ucmp(this.p); + if (cmp === 0) { + r.words[0] = 0; + r.length = 1; + } else if (cmp > 0) { + r.isub(this.p); + } else { + if (r.strip !== void 0) { + r.strip(); + } else { + r._strip(); + } + } + return r; + }; + MPrime.prototype.split = function split(input, out) { + input.iushrn(this.n, 0, out); + }; + MPrime.prototype.imulK = function imulK(num) { + return num.imul(this.k); + }; + function K256() { + MPrime.call( + this, + "k256", + "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f" + ); + } + inherits(K256, MPrime); + K256.prototype.split = function split(input, output) { + var mask = 4194303; + var outLen = Math.min(input.length, 9); + for (var i2 = 0; i2 < outLen; i2++) { + output.words[i2] = input.words[i2]; + } + output.length = outLen; + if (input.length <= 9) { + input.words[0] = 0; + input.length = 1; + return; + } + var prev = input.words[9]; + output.words[output.length++] = prev & mask; + for (i2 = 10; i2 < input.length; i2++) { + var next = input.words[i2] | 0; + input.words[i2 - 10] = (next & mask) << 4 | prev >>> 22; + prev = next; + } + prev >>>= 22; + input.words[i2 - 10] = prev; + if (prev === 0 && input.length > 10) { + input.length -= 10; + } else { + input.length -= 9; + } + }; + K256.prototype.imulK = function imulK(num) { + num.words[num.length] = 0; + num.words[num.length + 1] = 0; + num.length += 2; + var lo = 0; + for (var i2 = 0; i2 < num.length; i2++) { + var w = num.words[i2] | 0; + lo += w * 977; + num.words[i2] = lo & 67108863; + lo = w * 64 + (lo / 67108864 | 0); + } + if (num.words[num.length - 1] === 0) { + num.length--; + if (num.words[num.length - 1] === 0) { + num.length--; + } + } + return num; + }; + function P224() { + MPrime.call( + this, + "p224", + "ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001" + ); + } + inherits(P224, MPrime); + function P192() { + MPrime.call( + this, + "p192", + "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff" + ); + } + inherits(P192, MPrime); + function P25519() { + MPrime.call( + this, + "25519", + "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed" + ); + } + inherits(P25519, MPrime); + P25519.prototype.imulK = function imulK(num) { + var carry = 0; + for (var i2 = 0; i2 < num.length; i2++) { + var hi = (num.words[i2] | 0) * 19 + carry; + var lo = hi & 67108863; + hi >>>= 26; + num.words[i2] = lo; + carry = hi; + } + if (carry !== 0) { + num.words[num.length++] = carry; + } + return num; + }; + BN._prime = function prime(name) { + if (primes[name]) return primes[name]; + var prime2; + if (name === "k256") { + prime2 = new K256(); + } else if (name === "p224") { + prime2 = new P224(); + } else if (name === "p192") { + prime2 = new P192(); + } else if (name === "p25519") { + prime2 = new P25519(); + } else { + throw new Error("Unknown prime " + name); + } + primes[name] = prime2; + return prime2; + }; + function Red(m) { + if (typeof m === "string") { + var prime = BN._prime(m); + this.m = prime.p; + this.prime = prime; + } else { + assert(m.gtn(1), "modulus must be greater than 1"); + this.m = m; + this.prime = null; + } + } + Red.prototype._verify1 = function _verify1(a) { + assert(a.negative === 0, "red works only with positives"); + assert(a.red, "red works only with red numbers"); + }; + Red.prototype._verify2 = function _verify2(a, b) { + assert((a.negative | b.negative) === 0, "red works only with positives"); + assert( + a.red && a.red === b.red, + "red works only with red numbers" + ); + }; + Red.prototype.imod = function imod(a) { + if (this.prime) return this.prime.ireduce(a)._forceRed(this); + move(a, a.umod(this.m)._forceRed(this)); + return a; + }; + Red.prototype.neg = function neg(a) { + if (a.isZero()) { + return a.clone(); + } + return this.m.sub(a)._forceRed(this); + }; + Red.prototype.add = function add(a, b) { + this._verify2(a, b); + var res = a.add(b); + if (res.cmp(this.m) >= 0) { + res.isub(this.m); + } + return res._forceRed(this); + }; + Red.prototype.iadd = function iadd(a, b) { + this._verify2(a, b); + var res = a.iadd(b); + if (res.cmp(this.m) >= 0) { + res.isub(this.m); + } + return res; + }; + Red.prototype.sub = function sub(a, b) { + this._verify2(a, b); + var res = a.sub(b); + if (res.cmpn(0) < 0) { + res.iadd(this.m); + } + return res._forceRed(this); + }; + Red.prototype.isub = function isub(a, b) { + this._verify2(a, b); + var res = a.isub(b); + if (res.cmpn(0) < 0) { + res.iadd(this.m); + } + return res; + }; + Red.prototype.shl = function shl(a, num) { + this._verify1(a); + return this.imod(a.ushln(num)); + }; + Red.prototype.imul = function imul(a, b) { + this._verify2(a, b); + return this.imod(a.imul(b)); + }; + Red.prototype.mul = function mul(a, b) { + this._verify2(a, b); + return this.imod(a.mul(b)); + }; + Red.prototype.isqr = function isqr(a) { + return this.imul(a, a.clone()); + }; + Red.prototype.sqr = function sqr(a) { + return this.mul(a, a); + }; + Red.prototype.sqrt = function sqrt(a) { + if (a.isZero()) return a.clone(); + var mod3 = this.m.andln(3); + assert(mod3 % 2 === 1); + if (mod3 === 3) { + var pow = this.m.add(new BN(1)).iushrn(2); + return this.pow(a, pow); + } + var q = this.m.subn(1); + var s = 0; + while (!q.isZero() && q.andln(1) === 0) { + s++; + q.iushrn(1); + } + assert(!q.isZero()); + var one = new BN(1).toRed(this); + var nOne = one.redNeg(); + var lpow = this.m.subn(1).iushrn(1); + var z = this.m.bitLength(); + z = new BN(2 * z * z).toRed(this); + while (this.pow(z, lpow).cmp(nOne) !== 0) { + z.redIAdd(nOne); + } + var c = this.pow(z, q); + var r = this.pow(a, q.addn(1).iushrn(1)); + var t = this.pow(a, q); + var m = s; + while (t.cmp(one) !== 0) { + var tmp = t; + for (var i2 = 0; tmp.cmp(one) !== 0; i2++) { + tmp = tmp.redSqr(); + } + assert(i2 < m); + var b = this.pow(c, new BN(1).iushln(m - i2 - 1)); + r = r.redMul(b); + c = b.redSqr(); + t = t.redMul(c); + m = i2; + } + return r; + }; + Red.prototype.invm = function invm(a) { + var inv = a._invmp(this.m); + if (inv.negative !== 0) { + inv.negative = 0; + return this.imod(inv).redNeg(); + } else { + return this.imod(inv); + } + }; + Red.prototype.pow = function pow(a, num) { + if (num.isZero()) return new BN(1).toRed(this); + if (num.cmpn(1) === 0) return a.clone(); + var windowSize = 4; + var wnd = new Array(1 << windowSize); + wnd[0] = new BN(1).toRed(this); + wnd[1] = a; + for (var i2 = 2; i2 < wnd.length; i2++) { + wnd[i2] = this.mul(wnd[i2 - 1], a); + } + var res = wnd[0]; + var current = 0; + var currentLen = 0; + var start = num.bitLength() % 26; + if (start === 0) { + start = 26; + } + for (i2 = num.length - 1; i2 >= 0; i2--) { + var word = num.words[i2]; + for (var j = start - 1; j >= 0; j--) { + var bit = word >> j & 1; + if (res !== wnd[0]) { + res = this.sqr(res); + } + if (bit === 0 && current === 0) { + currentLen = 0; + continue; + } + current <<= 1; + current |= bit; + currentLen++; + if (currentLen !== windowSize && (i2 !== 0 || j !== 0)) continue; + res = this.mul(res, wnd[current]); + currentLen = 0; + current = 0; + } + start = 26; + } + return res; + }; + Red.prototype.convertTo = function convertTo(num) { + var r = num.umod(this.m); + return r === num ? r.clone() : r; + }; + Red.prototype.convertFrom = function convertFrom(num) { + var res = num.clone(); + res.red = null; + return res; + }; + BN.mont = function mont2(num) { + return new Mont(num); + }; + function Mont(m) { + Red.call(this, m); + this.shift = this.m.bitLength(); + if (this.shift % 26 !== 0) { + this.shift += 26 - this.shift % 26; + } + this.r = new BN(1).iushln(this.shift); + this.r2 = this.imod(this.r.sqr()); + this.rinv = this.r._invmp(this.m); + this.minv = this.rinv.mul(this.r).isubn(1).div(this.m); + this.minv = this.minv.umod(this.r); + this.minv = this.r.sub(this.minv); + } + inherits(Mont, Red); + Mont.prototype.convertTo = function convertTo(num) { + return this.imod(num.ushln(this.shift)); + }; + Mont.prototype.convertFrom = function convertFrom(num) { + var r = this.imod(num.mul(this.rinv)); + r.red = null; + return r; + }; + Mont.prototype.imul = function imul(a, b) { + if (a.isZero() || b.isZero()) { + a.words[0] = 0; + a.length = 1; + return a; + } + var t = a.imul(b); + var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m); + var u = t.isub(c).iushrn(this.shift); + var res = u; + if (u.cmp(this.m) >= 0) { + res = u.isub(this.m); + } else if (u.cmpn(0) < 0) { + res = u.iadd(this.m); + } + return res._forceRed(this); + }; + Mont.prototype.mul = function mul(a, b) { + if (a.isZero() || b.isZero()) return new BN(0)._forceRed(this); + var t = a.mul(b); + var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m); + var u = t.isub(c).iushrn(this.shift); + var res = u; + if (u.cmp(this.m) >= 0) { + res = u.isub(this.m); + } else if (u.cmpn(0) < 0) { + res = u.iadd(this.m); + } + return res._forceRed(this); + }; + Mont.prototype.invm = function invm(a) { + var res = this.imod(a._invmp(this.m).mul(this.r2)); + return res._forceRed(this); + }; + })(module2, bn); + })(bn$1); + return bn$1.exports; +} +var browserifyRsa; +var hasRequiredBrowserifyRsa; +function requireBrowserifyRsa() { + if (hasRequiredBrowserifyRsa) return browserifyRsa; + hasRequiredBrowserifyRsa = 1; + var BN = requireBn(); + var randomBytes = requireBrowser$b(); + var Buffer2 = requireSafeBuffer$1().Buffer; + function getr(priv) { + var len2 = priv.modulus.byteLength(); + var r; + do { + r = new BN(randomBytes(len2)); + } while (r.cmp(priv.modulus) >= 0 || !r.umod(priv.prime1) || !r.umod(priv.prime2)); + return r; + } + function blind(priv) { + var r = getr(priv); + var blinder = r.toRed(BN.mont(priv.modulus)).redPow(new BN(priv.publicExponent)).fromRed(); + return { blinder, unblinder: r.invm(priv.modulus) }; + } + function crt(msg, priv) { + var blinds = blind(priv); + var len2 = priv.modulus.byteLength(); + var blinded = new BN(msg).mul(blinds.blinder).umod(priv.modulus); + var c1 = blinded.toRed(BN.mont(priv.prime1)); + var c2 = blinded.toRed(BN.mont(priv.prime2)); + var qinv = priv.coefficient; + var p = priv.prime1; + var q = priv.prime2; + var m1 = c1.redPow(priv.exponent1).fromRed(); + var m2 = c2.redPow(priv.exponent2).fromRed(); + var h = m1.isub(m2).imul(qinv).umod(p).imul(q); + return m2.iadd(h).imul(blinds.unblinder).umod(priv.modulus).toArrayLike(Buffer2, "be", len2); + } + crt.getr = getr; + browserifyRsa = crt; + return browserifyRsa; +} +var elliptic = {}; +const version$1 = "6.5.7"; +const require$$0 = { + version: version$1 +}; +var utils$3 = {}; +var utils$2 = {}; +var hasRequiredUtils$2; +function requireUtils$2() { + if (hasRequiredUtils$2) return utils$2; + hasRequiredUtils$2 = 1; + (function(exports2) { + var utils2 = exports2; + function toArray(msg, enc) { + if (Array.isArray(msg)) + return msg.slice(); + if (!msg) + return []; + var res = []; + if (typeof msg !== "string") { + for (var i2 = 0; i2 < msg.length; i2++) + res[i2] = msg[i2] | 0; + return res; + } + if (enc === "hex") { + msg = msg.replace(/[^a-z0-9]+/ig, ""); + if (msg.length % 2 !== 0) + msg = "0" + msg; + for (var i2 = 0; i2 < msg.length; i2 += 2) + res.push(parseInt(msg[i2] + msg[i2 + 1], 16)); + } else { + for (var i2 = 0; i2 < msg.length; i2++) { + var c = msg.charCodeAt(i2); + var hi = c >> 8; + var lo = c & 255; + if (hi) + res.push(hi, lo); + else + res.push(lo); + } + } + return res; + } + utils2.toArray = toArray; + function zero2(word) { + if (word.length === 1) + return "0" + word; + else + return word; + } + utils2.zero2 = zero2; + function toHex(msg) { + var res = ""; + for (var i2 = 0; i2 < msg.length; i2++) + res += zero2(msg[i2].toString(16)); + return res; + } + utils2.toHex = toHex; + utils2.encode = function encode(arr, enc) { + if (enc === "hex") + return toHex(arr); + else + return arr; + }; + })(utils$2); + return utils$2; +} +var hasRequiredUtils$1; +function requireUtils$1() { + if (hasRequiredUtils$1) return utils$3; + hasRequiredUtils$1 = 1; + (function(exports2) { + var utils2 = exports2; + var BN = requireBn$1(); + var minAssert = requireMinimalisticAssert(); + var minUtils = requireUtils$2(); + utils2.assert = minAssert; + utils2.toArray = minUtils.toArray; + utils2.zero2 = minUtils.zero2; + utils2.toHex = minUtils.toHex; + utils2.encode = minUtils.encode; + function getNAF(num, w, bits) { + var naf = new Array(Math.max(num.bitLength(), bits) + 1); + var i2; + for (i2 = 0; i2 < naf.length; i2 += 1) { + naf[i2] = 0; + } + var ws = 1 << w + 1; + var k = num.clone(); + for (i2 = 0; i2 < naf.length; i2++) { + var z; + var mod = k.andln(ws - 1); + if (k.isOdd()) { + if (mod > (ws >> 1) - 1) + z = (ws >> 1) - mod; + else + z = mod; + k.isubn(z); + } else { + z = 0; + } + naf[i2] = z; + k.iushrn(1); + } + return naf; + } + utils2.getNAF = getNAF; + function getJSF(k1, k2) { + var jsf = [ + [], + [] + ]; + k1 = k1.clone(); + k2 = k2.clone(); + var d1 = 0; + var d2 = 0; + var m8; + while (k1.cmpn(-d1) > 0 || k2.cmpn(-d2) > 0) { + var m14 = k1.andln(3) + d1 & 3; + var m24 = k2.andln(3) + d2 & 3; + if (m14 === 3) + m14 = -1; + if (m24 === 3) + m24 = -1; + var u1; + if ((m14 & 1) === 0) { + u1 = 0; + } else { + m8 = k1.andln(7) + d1 & 7; + if ((m8 === 3 || m8 === 5) && m24 === 2) + u1 = -m14; + else + u1 = m14; + } + jsf[0].push(u1); + var u2; + if ((m24 & 1) === 0) { + u2 = 0; + } else { + m8 = k2.andln(7) + d2 & 7; + if ((m8 === 3 || m8 === 5) && m14 === 2) + u2 = -m24; + else + u2 = m24; + } + jsf[1].push(u2); + if (2 * d1 === u1 + 1) + d1 = 1 - d1; + if (2 * d2 === u2 + 1) + d2 = 1 - d2; + k1.iushrn(1); + k2.iushrn(1); + } + return jsf; + } + utils2.getJSF = getJSF; + function cachedProperty(obj, name, computer) { + var key2 = "_" + name; + obj.prototype[name] = function cachedProperty2() { + return this[key2] !== void 0 ? this[key2] : this[key2] = computer.call(this); + }; + } + utils2.cachedProperty = cachedProperty; + function parseBytes(bytes) { + return typeof bytes === "string" ? utils2.toArray(bytes, "hex") : bytes; + } + utils2.parseBytes = parseBytes; + function intFromLE(bytes) { + return new BN(bytes, "hex", "le"); + } + utils2.intFromLE = intFromLE; + })(utils$3); + return utils$3; +} +var curve = {}; +var base$1; +var hasRequiredBase$1; +function requireBase$1() { + if (hasRequiredBase$1) return base$1; + hasRequiredBase$1 = 1; + var BN = requireBn$1(); + var utils2 = requireUtils$1(); + var getNAF = utils2.getNAF; + var getJSF = utils2.getJSF; + var assert = utils2.assert; + function BaseCurve(type2, conf) { + this.type = type2; + this.p = new BN(conf.p, 16); + this.red = conf.prime ? BN.red(conf.prime) : BN.mont(this.p); + this.zero = new BN(0).toRed(this.red); + this.one = new BN(1).toRed(this.red); + this.two = new BN(2).toRed(this.red); + this.n = conf.n && new BN(conf.n, 16); + this.g = conf.g && this.pointFromJSON(conf.g, conf.gRed); + this._wnafT1 = new Array(4); + this._wnafT2 = new Array(4); + this._wnafT3 = new Array(4); + this._wnafT4 = new Array(4); + this._bitLength = this.n ? this.n.bitLength() : 0; + var adjustCount = this.n && this.p.div(this.n); + if (!adjustCount || adjustCount.cmpn(100) > 0) { + this.redN = null; + } else { + this._maxwellTrick = true; + this.redN = this.n.toRed(this.red); + } + } + base$1 = BaseCurve; + BaseCurve.prototype.point = function point() { + throw new Error("Not implemented"); + }; + BaseCurve.prototype.validate = function validate() { + throw new Error("Not implemented"); + }; + BaseCurve.prototype._fixedNafMul = function _fixedNafMul(p, k) { + assert(p.precomputed); + var doubles = p._getDoubles(); + var naf = getNAF(k, 1, this._bitLength); + var I = (1 << doubles.step + 1) - (doubles.step % 2 === 0 ? 2 : 1); + I /= 3; + var repr = []; + var j; + var nafW; + for (j = 0; j < naf.length; j += doubles.step) { + nafW = 0; + for (var l = j + doubles.step - 1; l >= j; l--) + nafW = (nafW << 1) + naf[l]; + repr.push(nafW); + } + var a = this.jpoint(null, null, null); + var b = this.jpoint(null, null, null); + for (var i2 = I; i2 > 0; i2--) { + for (j = 0; j < repr.length; j++) { + nafW = repr[j]; + if (nafW === i2) + b = b.mixedAdd(doubles.points[j]); + else if (nafW === -i2) + b = b.mixedAdd(doubles.points[j].neg()); + } + a = a.add(b); + } + return a.toP(); + }; + BaseCurve.prototype._wnafMul = function _wnafMul(p, k) { + var w = 4; + var nafPoints = p._getNAFPoints(w); + w = nafPoints.wnd; + var wnd = nafPoints.points; + var naf = getNAF(k, w, this._bitLength); + var acc = this.jpoint(null, null, null); + for (var i2 = naf.length - 1; i2 >= 0; i2--) { + for (var l = 0; i2 >= 0 && naf[i2] === 0; i2--) + l++; + if (i2 >= 0) + l++; + acc = acc.dblp(l); + if (i2 < 0) + break; + var z = naf[i2]; + assert(z !== 0); + if (p.type === "affine") { + if (z > 0) + acc = acc.mixedAdd(wnd[z - 1 >> 1]); + else + acc = acc.mixedAdd(wnd[-z - 1 >> 1].neg()); + } else { + if (z > 0) + acc = acc.add(wnd[z - 1 >> 1]); + else + acc = acc.add(wnd[-z - 1 >> 1].neg()); + } + } + return p.type === "affine" ? acc.toP() : acc; + }; + BaseCurve.prototype._wnafMulAdd = function _wnafMulAdd(defW, points, coeffs, len2, jacobianResult) { + var wndWidth = this._wnafT1; + var wnd = this._wnafT2; + var naf = this._wnafT3; + var max = 0; + var i2; + var j; + var p; + for (i2 = 0; i2 < len2; i2++) { + p = points[i2]; + var nafPoints = p._getNAFPoints(defW); + wndWidth[i2] = nafPoints.wnd; + wnd[i2] = nafPoints.points; + } + for (i2 = len2 - 1; i2 >= 1; i2 -= 2) { + var a = i2 - 1; + var b = i2; + if (wndWidth[a] !== 1 || wndWidth[b] !== 1) { + naf[a] = getNAF(coeffs[a], wndWidth[a], this._bitLength); + naf[b] = getNAF(coeffs[b], wndWidth[b], this._bitLength); + max = Math.max(naf[a].length, max); + max = Math.max(naf[b].length, max); + continue; + } + var comb = [ + points[a], + /* 1 */ + null, + /* 3 */ + null, + /* 5 */ + points[b] + /* 7 */ + ]; + if (points[a].y.cmp(points[b].y) === 0) { + comb[1] = points[a].add(points[b]); + comb[2] = points[a].toJ().mixedAdd(points[b].neg()); + } else if (points[a].y.cmp(points[b].y.redNeg()) === 0) { + comb[1] = points[a].toJ().mixedAdd(points[b]); + comb[2] = points[a].add(points[b].neg()); + } else { + comb[1] = points[a].toJ().mixedAdd(points[b]); + comb[2] = points[a].toJ().mixedAdd(points[b].neg()); + } + var index = [ + -3, + /* -1 -1 */ + -1, + /* -1 0 */ + -5, + /* -1 1 */ + -7, + /* 0 -1 */ + 0, + /* 0 0 */ + 7, + /* 0 1 */ + 5, + /* 1 -1 */ + 1, + /* 1 0 */ + 3 + /* 1 1 */ + ]; + var jsf = getJSF(coeffs[a], coeffs[b]); + max = Math.max(jsf[0].length, max); + naf[a] = new Array(max); + naf[b] = new Array(max); + for (j = 0; j < max; j++) { + var ja = jsf[0][j] | 0; + var jb = jsf[1][j] | 0; + naf[a][j] = index[(ja + 1) * 3 + (jb + 1)]; + naf[b][j] = 0; + wnd[a] = comb; + } + } + var acc = this.jpoint(null, null, null); + var tmp = this._wnafT4; + for (i2 = max; i2 >= 0; i2--) { + var k = 0; + while (i2 >= 0) { + var zero = true; + for (j = 0; j < len2; j++) { + tmp[j] = naf[j][i2] | 0; + if (tmp[j] !== 0) + zero = false; + } + if (!zero) + break; + k++; + i2--; + } + if (i2 >= 0) + k++; + acc = acc.dblp(k); + if (i2 < 0) + break; + for (j = 0; j < len2; j++) { + var z = tmp[j]; + if (z === 0) + continue; + else if (z > 0) + p = wnd[j][z - 1 >> 1]; + else if (z < 0) + p = wnd[j][-z - 1 >> 1].neg(); + if (p.type === "affine") + acc = acc.mixedAdd(p); + else + acc = acc.add(p); + } + } + for (i2 = 0; i2 < len2; i2++) + wnd[i2] = null; + if (jacobianResult) + return acc; + else + return acc.toP(); + }; + function BasePoint(curve2, type2) { + this.curve = curve2; + this.type = type2; + this.precomputed = null; + } + BaseCurve.BasePoint = BasePoint; + BasePoint.prototype.eq = function eq() { + throw new Error("Not implemented"); + }; + BasePoint.prototype.validate = function validate() { + return this.curve.validate(this); + }; + BaseCurve.prototype.decodePoint = function decodePoint(bytes, enc) { + bytes = utils2.toArray(bytes, enc); + var len2 = this.p.byteLength(); + if ((bytes[0] === 4 || bytes[0] === 6 || bytes[0] === 7) && bytes.length - 1 === 2 * len2) { + if (bytes[0] === 6) + assert(bytes[bytes.length - 1] % 2 === 0); + else if (bytes[0] === 7) + assert(bytes[bytes.length - 1] % 2 === 1); + var res = this.point( + bytes.slice(1, 1 + len2), + bytes.slice(1 + len2, 1 + 2 * len2) + ); + return res; + } else if ((bytes[0] === 2 || bytes[0] === 3) && bytes.length - 1 === len2) { + return this.pointFromX(bytes.slice(1, 1 + len2), bytes[0] === 3); + } + throw new Error("Unknown point format"); + }; + BasePoint.prototype.encodeCompressed = function encodeCompressed(enc) { + return this.encode(enc, true); + }; + BasePoint.prototype._encode = function _encode(compact) { + var len2 = this.curve.p.byteLength(); + var x = this.getX().toArray("be", len2); + if (compact) + return [this.getY().isEven() ? 2 : 3].concat(x); + return [4].concat(x, this.getY().toArray("be", len2)); + }; + BasePoint.prototype.encode = function encode(enc, compact) { + return utils2.encode(this._encode(compact), enc); + }; + BasePoint.prototype.precompute = function precompute(power) { + if (this.precomputed) + return this; + var precomputed = { + doubles: null, + naf: null, + beta: null + }; + precomputed.naf = this._getNAFPoints(8); + precomputed.doubles = this._getDoubles(4, power); + precomputed.beta = this._getBeta(); + this.precomputed = precomputed; + return this; + }; + BasePoint.prototype._hasDoubles = function _hasDoubles(k) { + if (!this.precomputed) + return false; + var doubles = this.precomputed.doubles; + if (!doubles) + return false; + return doubles.points.length >= Math.ceil((k.bitLength() + 1) / doubles.step); + }; + BasePoint.prototype._getDoubles = function _getDoubles(step, power) { + if (this.precomputed && this.precomputed.doubles) + return this.precomputed.doubles; + var doubles = [this]; + var acc = this; + for (var i2 = 0; i2 < power; i2 += step) { + for (var j = 0; j < step; j++) + acc = acc.dbl(); + doubles.push(acc); + } + return { + step, + points: doubles + }; + }; + BasePoint.prototype._getNAFPoints = function _getNAFPoints(wnd) { + if (this.precomputed && this.precomputed.naf) + return this.precomputed.naf; + var res = [this]; + var max = (1 << wnd) - 1; + var dbl = max === 1 ? null : this.dbl(); + for (var i2 = 1; i2 < max; i2++) + res[i2] = res[i2 - 1].add(dbl); + return { + wnd, + points: res + }; + }; + BasePoint.prototype._getBeta = function _getBeta() { + return null; + }; + BasePoint.prototype.dblp = function dblp(k) { + var r = this; + for (var i2 = 0; i2 < k; i2++) + r = r.dbl(); + return r; + }; + return base$1; +} +var short; +var hasRequiredShort; +function requireShort() { + if (hasRequiredShort) return short; + hasRequiredShort = 1; + var utils2 = requireUtils$1(); + var BN = requireBn$1(); + var inherits = requireInherits_browser(); + var Base = requireBase$1(); + var assert = utils2.assert; + function ShortCurve(conf) { + Base.call(this, "short", conf); + this.a = new BN(conf.a, 16).toRed(this.red); + this.b = new BN(conf.b, 16).toRed(this.red); + this.tinv = this.two.redInvm(); + this.zeroA = this.a.fromRed().cmpn(0) === 0; + this.threeA = this.a.fromRed().sub(this.p).cmpn(-3) === 0; + this.endo = this._getEndomorphism(conf); + this._endoWnafT1 = new Array(4); + this._endoWnafT2 = new Array(4); + } + inherits(ShortCurve, Base); + short = ShortCurve; + ShortCurve.prototype._getEndomorphism = function _getEndomorphism(conf) { + if (!this.zeroA || !this.g || !this.n || this.p.modn(3) !== 1) + return; + var beta; + var lambda; + if (conf.beta) { + beta = new BN(conf.beta, 16).toRed(this.red); + } else { + var betas = this._getEndoRoots(this.p); + beta = betas[0].cmp(betas[1]) < 0 ? betas[0] : betas[1]; + beta = beta.toRed(this.red); + } + if (conf.lambda) { + lambda = new BN(conf.lambda, 16); + } else { + var lambdas = this._getEndoRoots(this.n); + if (this.g.mul(lambdas[0]).x.cmp(this.g.x.redMul(beta)) === 0) { + lambda = lambdas[0]; + } else { + lambda = lambdas[1]; + assert(this.g.mul(lambda).x.cmp(this.g.x.redMul(beta)) === 0); + } + } + var basis; + if (conf.basis) { + basis = conf.basis.map(function(vec) { + return { + a: new BN(vec.a, 16), + b: new BN(vec.b, 16) + }; + }); + } else { + basis = this._getEndoBasis(lambda); + } + return { + beta, + lambda, + basis + }; + }; + ShortCurve.prototype._getEndoRoots = function _getEndoRoots(num) { + var red = num === this.p ? this.red : BN.mont(num); + var tinv = new BN(2).toRed(red).redInvm(); + var ntinv = tinv.redNeg(); + var s = new BN(3).toRed(red).redNeg().redSqrt().redMul(tinv); + var l1 = ntinv.redAdd(s).fromRed(); + var l2 = ntinv.redSub(s).fromRed(); + return [l1, l2]; + }; + ShortCurve.prototype._getEndoBasis = function _getEndoBasis(lambda) { + var aprxSqrt = this.n.ushrn(Math.floor(this.n.bitLength() / 2)); + var u = lambda; + var v = this.n.clone(); + var x1 = new BN(1); + var y1 = new BN(0); + var x2 = new BN(0); + var y2 = new BN(1); + var a0; + var b0; + var a1; + var b1; + var a2; + var b2; + var prevR; + var i2 = 0; + var r; + var x; + while (u.cmpn(0) !== 0) { + var q = v.div(u); + r = v.sub(q.mul(u)); + x = x2.sub(q.mul(x1)); + var y = y2.sub(q.mul(y1)); + if (!a1 && r.cmp(aprxSqrt) < 0) { + a0 = prevR.neg(); + b0 = x1; + a1 = r.neg(); + b1 = x; + } else if (a1 && ++i2 === 2) { + break; + } + prevR = r; + v = u; + u = r; + x2 = x1; + x1 = x; + y2 = y1; + y1 = y; + } + a2 = r.neg(); + b2 = x; + var len1 = a1.sqr().add(b1.sqr()); + var len2 = a2.sqr().add(b2.sqr()); + if (len2.cmp(len1) >= 0) { + a2 = a0; + b2 = b0; + } + if (a1.negative) { + a1 = a1.neg(); + b1 = b1.neg(); + } + if (a2.negative) { + a2 = a2.neg(); + b2 = b2.neg(); + } + return [ + { a: a1, b: b1 }, + { a: a2, b: b2 } + ]; + }; + ShortCurve.prototype._endoSplit = function _endoSplit(k) { + var basis = this.endo.basis; + var v1 = basis[0]; + var v2 = basis[1]; + var c1 = v2.b.mul(k).divRound(this.n); + var c2 = v1.b.neg().mul(k).divRound(this.n); + var p1 = c1.mul(v1.a); + var p2 = c2.mul(v2.a); + var q1 = c1.mul(v1.b); + var q2 = c2.mul(v2.b); + var k1 = k.sub(p1).sub(p2); + var k2 = q1.add(q2).neg(); + return { k1, k2 }; + }; + ShortCurve.prototype.pointFromX = function pointFromX(x, odd) { + x = new BN(x, 16); + if (!x.red) + x = x.toRed(this.red); + var y2 = x.redSqr().redMul(x).redIAdd(x.redMul(this.a)).redIAdd(this.b); + var y = y2.redSqrt(); + if (y.redSqr().redSub(y2).cmp(this.zero) !== 0) + throw new Error("invalid point"); + var isOdd = y.fromRed().isOdd(); + if (odd && !isOdd || !odd && isOdd) + y = y.redNeg(); + return this.point(x, y); + }; + ShortCurve.prototype.validate = function validate(point) { + if (point.inf) + return true; + var x = point.x; + var y = point.y; + var ax = this.a.redMul(x); + var rhs = x.redSqr().redMul(x).redIAdd(ax).redIAdd(this.b); + return y.redSqr().redISub(rhs).cmpn(0) === 0; + }; + ShortCurve.prototype._endoWnafMulAdd = function _endoWnafMulAdd(points, coeffs, jacobianResult) { + var npoints = this._endoWnafT1; + var ncoeffs = this._endoWnafT2; + for (var i2 = 0; i2 < points.length; i2++) { + var split = this._endoSplit(coeffs[i2]); + var p = points[i2]; + var beta = p._getBeta(); + if (split.k1.negative) { + split.k1.ineg(); + p = p.neg(true); + } + if (split.k2.negative) { + split.k2.ineg(); + beta = beta.neg(true); + } + npoints[i2 * 2] = p; + npoints[i2 * 2 + 1] = beta; + ncoeffs[i2 * 2] = split.k1; + ncoeffs[i2 * 2 + 1] = split.k2; + } + var res = this._wnafMulAdd(1, npoints, ncoeffs, i2 * 2, jacobianResult); + for (var j = 0; j < i2 * 2; j++) { + npoints[j] = null; + ncoeffs[j] = null; + } + return res; + }; + function Point(curve2, x, y, isRed) { + Base.BasePoint.call(this, curve2, "affine"); + if (x === null && y === null) { + this.x = null; + this.y = null; + this.inf = true; + } else { + this.x = new BN(x, 16); + this.y = new BN(y, 16); + if (isRed) { + this.x.forceRed(this.curve.red); + this.y.forceRed(this.curve.red); + } + if (!this.x.red) + this.x = this.x.toRed(this.curve.red); + if (!this.y.red) + this.y = this.y.toRed(this.curve.red); + this.inf = false; + } + } + inherits(Point, Base.BasePoint); + ShortCurve.prototype.point = function point(x, y, isRed) { + return new Point(this, x, y, isRed); + }; + ShortCurve.prototype.pointFromJSON = function pointFromJSON(obj, red) { + return Point.fromJSON(this, obj, red); + }; + Point.prototype._getBeta = function _getBeta() { + if (!this.curve.endo) + return; + var pre = this.precomputed; + if (pre && pre.beta) + return pre.beta; + var beta = this.curve.point(this.x.redMul(this.curve.endo.beta), this.y); + if (pre) { + var curve2 = this.curve; + var endoMul = function(p) { + return curve2.point(p.x.redMul(curve2.endo.beta), p.y); + }; + pre.beta = beta; + beta.precomputed = { + beta: null, + naf: pre.naf && { + wnd: pre.naf.wnd, + points: pre.naf.points.map(endoMul) + }, + doubles: pre.doubles && { + step: pre.doubles.step, + points: pre.doubles.points.map(endoMul) + } + }; + } + return beta; + }; + Point.prototype.toJSON = function toJSON() { + if (!this.precomputed) + return [this.x, this.y]; + return [this.x, this.y, this.precomputed && { + doubles: this.precomputed.doubles && { + step: this.precomputed.doubles.step, + points: this.precomputed.doubles.points.slice(1) + }, + naf: this.precomputed.naf && { + wnd: this.precomputed.naf.wnd, + points: this.precomputed.naf.points.slice(1) + } + }]; + }; + Point.fromJSON = function fromJSON(curve2, obj, red) { + if (typeof obj === "string") + obj = JSON.parse(obj); + var res = curve2.point(obj[0], obj[1], red); + if (!obj[2]) + return res; + function obj2point(obj2) { + return curve2.point(obj2[0], obj2[1], red); + } + var pre = obj[2]; + res.precomputed = { + beta: null, + doubles: pre.doubles && { + step: pre.doubles.step, + points: [res].concat(pre.doubles.points.map(obj2point)) + }, + naf: pre.naf && { + wnd: pre.naf.wnd, + points: [res].concat(pre.naf.points.map(obj2point)) + } + }; + return res; + }; + Point.prototype.inspect = function inspect2() { + if (this.isInfinity()) + return ""; + return ""; + }; + Point.prototype.isInfinity = function isInfinity() { + return this.inf; + }; + Point.prototype.add = function add(p) { + if (this.inf) + return p; + if (p.inf) + return this; + if (this.eq(p)) + return this.dbl(); + if (this.neg().eq(p)) + return this.curve.point(null, null); + if (this.x.cmp(p.x) === 0) + return this.curve.point(null, null); + var c = this.y.redSub(p.y); + if (c.cmpn(0) !== 0) + c = c.redMul(this.x.redSub(p.x).redInvm()); + var nx = c.redSqr().redISub(this.x).redISub(p.x); + var ny = c.redMul(this.x.redSub(nx)).redISub(this.y); + return this.curve.point(nx, ny); + }; + Point.prototype.dbl = function dbl() { + if (this.inf) + return this; + var ys1 = this.y.redAdd(this.y); + if (ys1.cmpn(0) === 0) + return this.curve.point(null, null); + var a = this.curve.a; + var x2 = this.x.redSqr(); + var dyinv = ys1.redInvm(); + var c = x2.redAdd(x2).redIAdd(x2).redIAdd(a).redMul(dyinv); + var nx = c.redSqr().redISub(this.x.redAdd(this.x)); + var ny = c.redMul(this.x.redSub(nx)).redISub(this.y); + return this.curve.point(nx, ny); + }; + Point.prototype.getX = function getX() { + return this.x.fromRed(); + }; + Point.prototype.getY = function getY() { + return this.y.fromRed(); + }; + Point.prototype.mul = function mul(k) { + k = new BN(k, 16); + if (this.isInfinity()) + return this; + else if (this._hasDoubles(k)) + return this.curve._fixedNafMul(this, k); + else if (this.curve.endo) + return this.curve._endoWnafMulAdd([this], [k]); + else + return this.curve._wnafMul(this, k); + }; + Point.prototype.mulAdd = function mulAdd(k1, p2, k2) { + var points = [this, p2]; + var coeffs = [k1, k2]; + if (this.curve.endo) + return this.curve._endoWnafMulAdd(points, coeffs); + else + return this.curve._wnafMulAdd(1, points, coeffs, 2); + }; + Point.prototype.jmulAdd = function jmulAdd(k1, p2, k2) { + var points = [this, p2]; + var coeffs = [k1, k2]; + if (this.curve.endo) + return this.curve._endoWnafMulAdd(points, coeffs, true); + else + return this.curve._wnafMulAdd(1, points, coeffs, 2, true); + }; + Point.prototype.eq = function eq(p) { + return this === p || this.inf === p.inf && (this.inf || this.x.cmp(p.x) === 0 && this.y.cmp(p.y) === 0); + }; + Point.prototype.neg = function neg(_precompute) { + if (this.inf) + return this; + var res = this.curve.point(this.x, this.y.redNeg()); + if (_precompute && this.precomputed) { + var pre = this.precomputed; + var negate = function(p) { + return p.neg(); + }; + res.precomputed = { + naf: pre.naf && { + wnd: pre.naf.wnd, + points: pre.naf.points.map(negate) + }, + doubles: pre.doubles && { + step: pre.doubles.step, + points: pre.doubles.points.map(negate) + } + }; + } + return res; + }; + Point.prototype.toJ = function toJ() { + if (this.inf) + return this.curve.jpoint(null, null, null); + var res = this.curve.jpoint(this.x, this.y, this.curve.one); + return res; + }; + function JPoint(curve2, x, y, z) { + Base.BasePoint.call(this, curve2, "jacobian"); + if (x === null && y === null && z === null) { + this.x = this.curve.one; + this.y = this.curve.one; + this.z = new BN(0); + } else { + this.x = new BN(x, 16); + this.y = new BN(y, 16); + this.z = new BN(z, 16); + } + if (!this.x.red) + this.x = this.x.toRed(this.curve.red); + if (!this.y.red) + this.y = this.y.toRed(this.curve.red); + if (!this.z.red) + this.z = this.z.toRed(this.curve.red); + this.zOne = this.z === this.curve.one; + } + inherits(JPoint, Base.BasePoint); + ShortCurve.prototype.jpoint = function jpoint(x, y, z) { + return new JPoint(this, x, y, z); + }; + JPoint.prototype.toP = function toP() { + if (this.isInfinity()) + return this.curve.point(null, null); + var zinv = this.z.redInvm(); + var zinv2 = zinv.redSqr(); + var ax = this.x.redMul(zinv2); + var ay = this.y.redMul(zinv2).redMul(zinv); + return this.curve.point(ax, ay); + }; + JPoint.prototype.neg = function neg() { + return this.curve.jpoint(this.x, this.y.redNeg(), this.z); + }; + JPoint.prototype.add = function add(p) { + if (this.isInfinity()) + return p; + if (p.isInfinity()) + return this; + var pz2 = p.z.redSqr(); + var z2 = this.z.redSqr(); + var u1 = this.x.redMul(pz2); + var u2 = p.x.redMul(z2); + var s1 = this.y.redMul(pz2.redMul(p.z)); + var s2 = p.y.redMul(z2.redMul(this.z)); + var h = u1.redSub(u2); + var r = s1.redSub(s2); + if (h.cmpn(0) === 0) { + if (r.cmpn(0) !== 0) + return this.curve.jpoint(null, null, null); + else + return this.dbl(); + } + var h2 = h.redSqr(); + var h3 = h2.redMul(h); + var v = u1.redMul(h2); + var nx = r.redSqr().redIAdd(h3).redISub(v).redISub(v); + var ny = r.redMul(v.redISub(nx)).redISub(s1.redMul(h3)); + var nz = this.z.redMul(p.z).redMul(h); + return this.curve.jpoint(nx, ny, nz); + }; + JPoint.prototype.mixedAdd = function mixedAdd(p) { + if (this.isInfinity()) + return p.toJ(); + if (p.isInfinity()) + return this; + var z2 = this.z.redSqr(); + var u1 = this.x; + var u2 = p.x.redMul(z2); + var s1 = this.y; + var s2 = p.y.redMul(z2).redMul(this.z); + var h = u1.redSub(u2); + var r = s1.redSub(s2); + if (h.cmpn(0) === 0) { + if (r.cmpn(0) !== 0) + return this.curve.jpoint(null, null, null); + else + return this.dbl(); + } + var h2 = h.redSqr(); + var h3 = h2.redMul(h); + var v = u1.redMul(h2); + var nx = r.redSqr().redIAdd(h3).redISub(v).redISub(v); + var ny = r.redMul(v.redISub(nx)).redISub(s1.redMul(h3)); + var nz = this.z.redMul(h); + return this.curve.jpoint(nx, ny, nz); + }; + JPoint.prototype.dblp = function dblp(pow) { + if (pow === 0) + return this; + if (this.isInfinity()) + return this; + if (!pow) + return this.dbl(); + var i2; + if (this.curve.zeroA || this.curve.threeA) { + var r = this; + for (i2 = 0; i2 < pow; i2++) + r = r.dbl(); + return r; + } + var a = this.curve.a; + var tinv = this.curve.tinv; + var jx = this.x; + var jy = this.y; + var jz = this.z; + var jz4 = jz.redSqr().redSqr(); + var jyd = jy.redAdd(jy); + for (i2 = 0; i2 < pow; i2++) { + var jx2 = jx.redSqr(); + var jyd2 = jyd.redSqr(); + var jyd4 = jyd2.redSqr(); + var c = jx2.redAdd(jx2).redIAdd(jx2).redIAdd(a.redMul(jz4)); + var t1 = jx.redMul(jyd2); + var nx = c.redSqr().redISub(t1.redAdd(t1)); + var t2 = t1.redISub(nx); + var dny = c.redMul(t2); + dny = dny.redIAdd(dny).redISub(jyd4); + var nz = jyd.redMul(jz); + if (i2 + 1 < pow) + jz4 = jz4.redMul(jyd4); + jx = nx; + jz = nz; + jyd = dny; + } + return this.curve.jpoint(jx, jyd.redMul(tinv), jz); + }; + JPoint.prototype.dbl = function dbl() { + if (this.isInfinity()) + return this; + if (this.curve.zeroA) + return this._zeroDbl(); + else if (this.curve.threeA) + return this._threeDbl(); + else + return this._dbl(); + }; + JPoint.prototype._zeroDbl = function _zeroDbl() { + var nx; + var ny; + var nz; + if (this.zOne) { + var xx = this.x.redSqr(); + var yy = this.y.redSqr(); + var yyyy = yy.redSqr(); + var s = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy); + s = s.redIAdd(s); + var m = xx.redAdd(xx).redIAdd(xx); + var t = m.redSqr().redISub(s).redISub(s); + var yyyy8 = yyyy.redIAdd(yyyy); + yyyy8 = yyyy8.redIAdd(yyyy8); + yyyy8 = yyyy8.redIAdd(yyyy8); + nx = t; + ny = m.redMul(s.redISub(t)).redISub(yyyy8); + nz = this.y.redAdd(this.y); + } else { + var a = this.x.redSqr(); + var b = this.y.redSqr(); + var c = b.redSqr(); + var d = this.x.redAdd(b).redSqr().redISub(a).redISub(c); + d = d.redIAdd(d); + var e = a.redAdd(a).redIAdd(a); + var f = e.redSqr(); + var c8 = c.redIAdd(c); + c8 = c8.redIAdd(c8); + c8 = c8.redIAdd(c8); + nx = f.redISub(d).redISub(d); + ny = e.redMul(d.redISub(nx)).redISub(c8); + nz = this.y.redMul(this.z); + nz = nz.redIAdd(nz); + } + return this.curve.jpoint(nx, ny, nz); + }; + JPoint.prototype._threeDbl = function _threeDbl() { + var nx; + var ny; + var nz; + if (this.zOne) { + var xx = this.x.redSqr(); + var yy = this.y.redSqr(); + var yyyy = yy.redSqr(); + var s = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy); + s = s.redIAdd(s); + var m = xx.redAdd(xx).redIAdd(xx).redIAdd(this.curve.a); + var t = m.redSqr().redISub(s).redISub(s); + nx = t; + var yyyy8 = yyyy.redIAdd(yyyy); + yyyy8 = yyyy8.redIAdd(yyyy8); + yyyy8 = yyyy8.redIAdd(yyyy8); + ny = m.redMul(s.redISub(t)).redISub(yyyy8); + nz = this.y.redAdd(this.y); + } else { + var delta = this.z.redSqr(); + var gamma = this.y.redSqr(); + var beta = this.x.redMul(gamma); + var alpha = this.x.redSub(delta).redMul(this.x.redAdd(delta)); + alpha = alpha.redAdd(alpha).redIAdd(alpha); + var beta4 = beta.redIAdd(beta); + beta4 = beta4.redIAdd(beta4); + var beta8 = beta4.redAdd(beta4); + nx = alpha.redSqr().redISub(beta8); + nz = this.y.redAdd(this.z).redSqr().redISub(gamma).redISub(delta); + var ggamma8 = gamma.redSqr(); + ggamma8 = ggamma8.redIAdd(ggamma8); + ggamma8 = ggamma8.redIAdd(ggamma8); + ggamma8 = ggamma8.redIAdd(ggamma8); + ny = alpha.redMul(beta4.redISub(nx)).redISub(ggamma8); + } + return this.curve.jpoint(nx, ny, nz); + }; + JPoint.prototype._dbl = function _dbl() { + var a = this.curve.a; + var jx = this.x; + var jy = this.y; + var jz = this.z; + var jz4 = jz.redSqr().redSqr(); + var jx2 = jx.redSqr(); + var jy2 = jy.redSqr(); + var c = jx2.redAdd(jx2).redIAdd(jx2).redIAdd(a.redMul(jz4)); + var jxd4 = jx.redAdd(jx); + jxd4 = jxd4.redIAdd(jxd4); + var t1 = jxd4.redMul(jy2); + var nx = c.redSqr().redISub(t1.redAdd(t1)); + var t2 = t1.redISub(nx); + var jyd8 = jy2.redSqr(); + jyd8 = jyd8.redIAdd(jyd8); + jyd8 = jyd8.redIAdd(jyd8); + jyd8 = jyd8.redIAdd(jyd8); + var ny = c.redMul(t2).redISub(jyd8); + var nz = jy.redAdd(jy).redMul(jz); + return this.curve.jpoint(nx, ny, nz); + }; + JPoint.prototype.trpl = function trpl() { + if (!this.curve.zeroA) + return this.dbl().add(this); + var xx = this.x.redSqr(); + var yy = this.y.redSqr(); + var zz = this.z.redSqr(); + var yyyy = yy.redSqr(); + var m = xx.redAdd(xx).redIAdd(xx); + var mm = m.redSqr(); + var e = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy); + e = e.redIAdd(e); + e = e.redAdd(e).redIAdd(e); + e = e.redISub(mm); + var ee = e.redSqr(); + var t = yyyy.redIAdd(yyyy); + t = t.redIAdd(t); + t = t.redIAdd(t); + t = t.redIAdd(t); + var u = m.redIAdd(e).redSqr().redISub(mm).redISub(ee).redISub(t); + var yyu4 = yy.redMul(u); + yyu4 = yyu4.redIAdd(yyu4); + yyu4 = yyu4.redIAdd(yyu4); + var nx = this.x.redMul(ee).redISub(yyu4); + nx = nx.redIAdd(nx); + nx = nx.redIAdd(nx); + var ny = this.y.redMul(u.redMul(t.redISub(u)).redISub(e.redMul(ee))); + ny = ny.redIAdd(ny); + ny = ny.redIAdd(ny); + ny = ny.redIAdd(ny); + var nz = this.z.redAdd(e).redSqr().redISub(zz).redISub(ee); + return this.curve.jpoint(nx, ny, nz); + }; + JPoint.prototype.mul = function mul(k, kbase) { + k = new BN(k, kbase); + return this.curve._wnafMul(this, k); + }; + JPoint.prototype.eq = function eq(p) { + if (p.type === "affine") + return this.eq(p.toJ()); + if (this === p) + return true; + var z2 = this.z.redSqr(); + var pz2 = p.z.redSqr(); + if (this.x.redMul(pz2).redISub(p.x.redMul(z2)).cmpn(0) !== 0) + return false; + var z3 = z2.redMul(this.z); + var pz3 = pz2.redMul(p.z); + return this.y.redMul(pz3).redISub(p.y.redMul(z3)).cmpn(0) === 0; + }; + JPoint.prototype.eqXToP = function eqXToP(x) { + var zs = this.z.redSqr(); + var rx = x.toRed(this.curve.red).redMul(zs); + if (this.x.cmp(rx) === 0) + return true; + var xc = x.clone(); + var t = this.curve.redN.redMul(zs); + for (; ; ) { + xc.iadd(this.curve.n); + if (xc.cmp(this.curve.p) >= 0) + return false; + rx.redIAdd(t); + if (this.x.cmp(rx) === 0) + return true; + } + }; + JPoint.prototype.inspect = function inspect2() { + if (this.isInfinity()) + return ""; + return ""; + }; + JPoint.prototype.isInfinity = function isInfinity() { + return this.z.cmpn(0) === 0; + }; + return short; +} +var mont; +var hasRequiredMont; +function requireMont() { + if (hasRequiredMont) return mont; + hasRequiredMont = 1; + var BN = requireBn$1(); + var inherits = requireInherits_browser(); + var Base = requireBase$1(); + var utils2 = requireUtils$1(); + function MontCurve(conf) { + Base.call(this, "mont", conf); + this.a = new BN(conf.a, 16).toRed(this.red); + this.b = new BN(conf.b, 16).toRed(this.red); + this.i4 = new BN(4).toRed(this.red).redInvm(); + this.two = new BN(2).toRed(this.red); + this.a24 = this.i4.redMul(this.a.redAdd(this.two)); + } + inherits(MontCurve, Base); + mont = MontCurve; + MontCurve.prototype.validate = function validate(point) { + var x = point.normalize().x; + var x2 = x.redSqr(); + var rhs = x2.redMul(x).redAdd(x2.redMul(this.a)).redAdd(x); + var y = rhs.redSqrt(); + return y.redSqr().cmp(rhs) === 0; + }; + function Point(curve2, x, z) { + Base.BasePoint.call(this, curve2, "projective"); + if (x === null && z === null) { + this.x = this.curve.one; + this.z = this.curve.zero; + } else { + this.x = new BN(x, 16); + this.z = new BN(z, 16); + if (!this.x.red) + this.x = this.x.toRed(this.curve.red); + if (!this.z.red) + this.z = this.z.toRed(this.curve.red); + } + } + inherits(Point, Base.BasePoint); + MontCurve.prototype.decodePoint = function decodePoint(bytes, enc) { + return this.point(utils2.toArray(bytes, enc), 1); + }; + MontCurve.prototype.point = function point(x, z) { + return new Point(this, x, z); + }; + MontCurve.prototype.pointFromJSON = function pointFromJSON(obj) { + return Point.fromJSON(this, obj); + }; + Point.prototype.precompute = function precompute() { + }; + Point.prototype._encode = function _encode() { + return this.getX().toArray("be", this.curve.p.byteLength()); + }; + Point.fromJSON = function fromJSON(curve2, obj) { + return new Point(curve2, obj[0], obj[1] || curve2.one); + }; + Point.prototype.inspect = function inspect2() { + if (this.isInfinity()) + return ""; + return ""; + }; + Point.prototype.isInfinity = function isInfinity() { + return this.z.cmpn(0) === 0; + }; + Point.prototype.dbl = function dbl() { + var a = this.x.redAdd(this.z); + var aa = a.redSqr(); + var b = this.x.redSub(this.z); + var bb = b.redSqr(); + var c = aa.redSub(bb); + var nx = aa.redMul(bb); + var nz = c.redMul(bb.redAdd(this.curve.a24.redMul(c))); + return this.curve.point(nx, nz); + }; + Point.prototype.add = function add() { + throw new Error("Not supported on Montgomery curve"); + }; + Point.prototype.diffAdd = function diffAdd(p, diff) { + var a = this.x.redAdd(this.z); + var b = this.x.redSub(this.z); + var c = p.x.redAdd(p.z); + var d = p.x.redSub(p.z); + var da = d.redMul(a); + var cb = c.redMul(b); + var nx = diff.z.redMul(da.redAdd(cb).redSqr()); + var nz = diff.x.redMul(da.redISub(cb).redSqr()); + return this.curve.point(nx, nz); + }; + Point.prototype.mul = function mul(k) { + var t = k.clone(); + var a = this; + var b = this.curve.point(null, null); + var c = this; + for (var bits = []; t.cmpn(0) !== 0; t.iushrn(1)) + bits.push(t.andln(1)); + for (var i2 = bits.length - 1; i2 >= 0; i2--) { + if (bits[i2] === 0) { + a = a.diffAdd(b, c); + b = b.dbl(); + } else { + b = a.diffAdd(b, c); + a = a.dbl(); + } + } + return b; + }; + Point.prototype.mulAdd = function mulAdd() { + throw new Error("Not supported on Montgomery curve"); + }; + Point.prototype.jumlAdd = function jumlAdd() { + throw new Error("Not supported on Montgomery curve"); + }; + Point.prototype.eq = function eq(other) { + return this.getX().cmp(other.getX()) === 0; + }; + Point.prototype.normalize = function normalize2() { + this.x = this.x.redMul(this.z.redInvm()); + this.z = this.curve.one; + return this; + }; + Point.prototype.getX = function getX() { + this.normalize(); + return this.x.fromRed(); + }; + return mont; +} +var edwards; +var hasRequiredEdwards; +function requireEdwards() { + if (hasRequiredEdwards) return edwards; + hasRequiredEdwards = 1; + var utils2 = requireUtils$1(); + var BN = requireBn$1(); + var inherits = requireInherits_browser(); + var Base = requireBase$1(); + var assert = utils2.assert; + function EdwardsCurve(conf) { + this.twisted = (conf.a | 0) !== 1; + this.mOneA = this.twisted && (conf.a | 0) === -1; + this.extended = this.mOneA; + Base.call(this, "edwards", conf); + this.a = new BN(conf.a, 16).umod(this.red.m); + this.a = this.a.toRed(this.red); + this.c = new BN(conf.c, 16).toRed(this.red); + this.c2 = this.c.redSqr(); + this.d = new BN(conf.d, 16).toRed(this.red); + this.dd = this.d.redAdd(this.d); + assert(!this.twisted || this.c.fromRed().cmpn(1) === 0); + this.oneC = (conf.c | 0) === 1; + } + inherits(EdwardsCurve, Base); + edwards = EdwardsCurve; + EdwardsCurve.prototype._mulA = function _mulA(num) { + if (this.mOneA) + return num.redNeg(); + else + return this.a.redMul(num); + }; + EdwardsCurve.prototype._mulC = function _mulC(num) { + if (this.oneC) + return num; + else + return this.c.redMul(num); + }; + EdwardsCurve.prototype.jpoint = function jpoint(x, y, z, t) { + return this.point(x, y, z, t); + }; + EdwardsCurve.prototype.pointFromX = function pointFromX(x, odd) { + x = new BN(x, 16); + if (!x.red) + x = x.toRed(this.red); + var x2 = x.redSqr(); + var rhs = this.c2.redSub(this.a.redMul(x2)); + var lhs = this.one.redSub(this.c2.redMul(this.d).redMul(x2)); + var y2 = rhs.redMul(lhs.redInvm()); + var y = y2.redSqrt(); + if (y.redSqr().redSub(y2).cmp(this.zero) !== 0) + throw new Error("invalid point"); + var isOdd = y.fromRed().isOdd(); + if (odd && !isOdd || !odd && isOdd) + y = y.redNeg(); + return this.point(x, y); + }; + EdwardsCurve.prototype.pointFromY = function pointFromY(y, odd) { + y = new BN(y, 16); + if (!y.red) + y = y.toRed(this.red); + var y2 = y.redSqr(); + var lhs = y2.redSub(this.c2); + var rhs = y2.redMul(this.d).redMul(this.c2).redSub(this.a); + var x2 = lhs.redMul(rhs.redInvm()); + if (x2.cmp(this.zero) === 0) { + if (odd) + throw new Error("invalid point"); + else + return this.point(this.zero, y); + } + var x = x2.redSqrt(); + if (x.redSqr().redSub(x2).cmp(this.zero) !== 0) + throw new Error("invalid point"); + if (x.fromRed().isOdd() !== odd) + x = x.redNeg(); + return this.point(x, y); + }; + EdwardsCurve.prototype.validate = function validate(point) { + if (point.isInfinity()) + return true; + point.normalize(); + var x2 = point.x.redSqr(); + var y2 = point.y.redSqr(); + var lhs = x2.redMul(this.a).redAdd(y2); + var rhs = this.c2.redMul(this.one.redAdd(this.d.redMul(x2).redMul(y2))); + return lhs.cmp(rhs) === 0; + }; + function Point(curve2, x, y, z, t) { + Base.BasePoint.call(this, curve2, "projective"); + if (x === null && y === null && z === null) { + this.x = this.curve.zero; + this.y = this.curve.one; + this.z = this.curve.one; + this.t = this.curve.zero; + this.zOne = true; + } else { + this.x = new BN(x, 16); + this.y = new BN(y, 16); + this.z = z ? new BN(z, 16) : this.curve.one; + this.t = t && new BN(t, 16); + if (!this.x.red) + this.x = this.x.toRed(this.curve.red); + if (!this.y.red) + this.y = this.y.toRed(this.curve.red); + if (!this.z.red) + this.z = this.z.toRed(this.curve.red); + if (this.t && !this.t.red) + this.t = this.t.toRed(this.curve.red); + this.zOne = this.z === this.curve.one; + if (this.curve.extended && !this.t) { + this.t = this.x.redMul(this.y); + if (!this.zOne) + this.t = this.t.redMul(this.z.redInvm()); + } + } + } + inherits(Point, Base.BasePoint); + EdwardsCurve.prototype.pointFromJSON = function pointFromJSON(obj) { + return Point.fromJSON(this, obj); + }; + EdwardsCurve.prototype.point = function point(x, y, z, t) { + return new Point(this, x, y, z, t); + }; + Point.fromJSON = function fromJSON(curve2, obj) { + return new Point(curve2, obj[0], obj[1], obj[2]); + }; + Point.prototype.inspect = function inspect2() { + if (this.isInfinity()) + return ""; + return ""; + }; + Point.prototype.isInfinity = function isInfinity() { + return this.x.cmpn(0) === 0 && (this.y.cmp(this.z) === 0 || this.zOne && this.y.cmp(this.curve.c) === 0); + }; + Point.prototype._extDbl = function _extDbl() { + var a = this.x.redSqr(); + var b = this.y.redSqr(); + var c = this.z.redSqr(); + c = c.redIAdd(c); + var d = this.curve._mulA(a); + var e = this.x.redAdd(this.y).redSqr().redISub(a).redISub(b); + var g = d.redAdd(b); + var f = g.redSub(c); + var h = d.redSub(b); + var nx = e.redMul(f); + var ny = g.redMul(h); + var nt = e.redMul(h); + var nz = f.redMul(g); + return this.curve.point(nx, ny, nz, nt); + }; + Point.prototype._projDbl = function _projDbl() { + var b = this.x.redAdd(this.y).redSqr(); + var c = this.x.redSqr(); + var d = this.y.redSqr(); + var nx; + var ny; + var nz; + var e; + var h; + var j; + if (this.curve.twisted) { + e = this.curve._mulA(c); + var f = e.redAdd(d); + if (this.zOne) { + nx = b.redSub(c).redSub(d).redMul(f.redSub(this.curve.two)); + ny = f.redMul(e.redSub(d)); + nz = f.redSqr().redSub(f).redSub(f); + } else { + h = this.z.redSqr(); + j = f.redSub(h).redISub(h); + nx = b.redSub(c).redISub(d).redMul(j); + ny = f.redMul(e.redSub(d)); + nz = f.redMul(j); + } + } else { + e = c.redAdd(d); + h = this.curve._mulC(this.z).redSqr(); + j = e.redSub(h).redSub(h); + nx = this.curve._mulC(b.redISub(e)).redMul(j); + ny = this.curve._mulC(e).redMul(c.redISub(d)); + nz = e.redMul(j); + } + return this.curve.point(nx, ny, nz); + }; + Point.prototype.dbl = function dbl() { + if (this.isInfinity()) + return this; + if (this.curve.extended) + return this._extDbl(); + else + return this._projDbl(); + }; + Point.prototype._extAdd = function _extAdd(p) { + var a = this.y.redSub(this.x).redMul(p.y.redSub(p.x)); + var b = this.y.redAdd(this.x).redMul(p.y.redAdd(p.x)); + var c = this.t.redMul(this.curve.dd).redMul(p.t); + var d = this.z.redMul(p.z.redAdd(p.z)); + var e = b.redSub(a); + var f = d.redSub(c); + var g = d.redAdd(c); + var h = b.redAdd(a); + var nx = e.redMul(f); + var ny = g.redMul(h); + var nt = e.redMul(h); + var nz = f.redMul(g); + return this.curve.point(nx, ny, nz, nt); + }; + Point.prototype._projAdd = function _projAdd(p) { + var a = this.z.redMul(p.z); + var b = a.redSqr(); + var c = this.x.redMul(p.x); + var d = this.y.redMul(p.y); + var e = this.curve.d.redMul(c).redMul(d); + var f = b.redSub(e); + var g = b.redAdd(e); + var tmp = this.x.redAdd(this.y).redMul(p.x.redAdd(p.y)).redISub(c).redISub(d); + var nx = a.redMul(f).redMul(tmp); + var ny; + var nz; + if (this.curve.twisted) { + ny = a.redMul(g).redMul(d.redSub(this.curve._mulA(c))); + nz = f.redMul(g); + } else { + ny = a.redMul(g).redMul(d.redSub(c)); + nz = this.curve._mulC(f).redMul(g); + } + return this.curve.point(nx, ny, nz); + }; + Point.prototype.add = function add(p) { + if (this.isInfinity()) + return p; + if (p.isInfinity()) + return this; + if (this.curve.extended) + return this._extAdd(p); + else + return this._projAdd(p); + }; + Point.prototype.mul = function mul(k) { + if (this._hasDoubles(k)) + return this.curve._fixedNafMul(this, k); + else + return this.curve._wnafMul(this, k); + }; + Point.prototype.mulAdd = function mulAdd(k1, p, k2) { + return this.curve._wnafMulAdd(1, [this, p], [k1, k2], 2, false); + }; + Point.prototype.jmulAdd = function jmulAdd(k1, p, k2) { + return this.curve._wnafMulAdd(1, [this, p], [k1, k2], 2, true); + }; + Point.prototype.normalize = function normalize2() { + if (this.zOne) + return this; + var zi = this.z.redInvm(); + this.x = this.x.redMul(zi); + this.y = this.y.redMul(zi); + if (this.t) + this.t = this.t.redMul(zi); + this.z = this.curve.one; + this.zOne = true; + return this; + }; + Point.prototype.neg = function neg() { + return this.curve.point( + this.x.redNeg(), + this.y, + this.z, + this.t && this.t.redNeg() + ); + }; + Point.prototype.getX = function getX() { + this.normalize(); + return this.x.fromRed(); + }; + Point.prototype.getY = function getY() { + this.normalize(); + return this.y.fromRed(); + }; + Point.prototype.eq = function eq(other) { + return this === other || this.getX().cmp(other.getX()) === 0 && this.getY().cmp(other.getY()) === 0; + }; + Point.prototype.eqXToP = function eqXToP(x) { + var rx = x.toRed(this.curve.red).redMul(this.z); + if (this.x.cmp(rx) === 0) + return true; + var xc = x.clone(); + var t = this.curve.redN.redMul(this.z); + for (; ; ) { + xc.iadd(this.curve.n); + if (xc.cmp(this.curve.p) >= 0) + return false; + rx.redIAdd(t); + if (this.x.cmp(rx) === 0) + return true; + } + }; + Point.prototype.toP = Point.prototype.normalize; + Point.prototype.mixedAdd = Point.prototype.add; + return edwards; +} +var hasRequiredCurve; +function requireCurve() { + if (hasRequiredCurve) return curve; + hasRequiredCurve = 1; + (function(exports2) { + var curve2 = exports2; + curve2.base = requireBase$1(); + curve2.short = requireShort(); + curve2.mont = requireMont(); + curve2.edwards = requireEdwards(); + })(curve); + return curve; +} +var curves = {}; +var hash = {}; +var utils$1 = {}; +var hasRequiredUtils; +function requireUtils() { + if (hasRequiredUtils) return utils$1; + hasRequiredUtils = 1; + var assert = requireMinimalisticAssert(); + var inherits = requireInherits_browser(); + utils$1.inherits = inherits; + function isSurrogatePair(msg, i2) { + if ((msg.charCodeAt(i2) & 64512) !== 55296) { + return false; + } + if (i2 < 0 || i2 + 1 >= msg.length) { + return false; + } + return (msg.charCodeAt(i2 + 1) & 64512) === 56320; + } + function toArray(msg, enc) { + if (Array.isArray(msg)) + return msg.slice(); + if (!msg) + return []; + var res = []; + if (typeof msg === "string") { + if (!enc) { + var p = 0; + for (var i2 = 0; i2 < msg.length; i2++) { + var c = msg.charCodeAt(i2); + if (c < 128) { + res[p++] = c; + } else if (c < 2048) { + res[p++] = c >> 6 | 192; + res[p++] = c & 63 | 128; + } else if (isSurrogatePair(msg, i2)) { + c = 65536 + ((c & 1023) << 10) + (msg.charCodeAt(++i2) & 1023); + res[p++] = c >> 18 | 240; + res[p++] = c >> 12 & 63 | 128; + res[p++] = c >> 6 & 63 | 128; + res[p++] = c & 63 | 128; + } else { + res[p++] = c >> 12 | 224; + res[p++] = c >> 6 & 63 | 128; + res[p++] = c & 63 | 128; + } + } + } else if (enc === "hex") { + msg = msg.replace(/[^a-z0-9]+/ig, ""); + if (msg.length % 2 !== 0) + msg = "0" + msg; + for (i2 = 0; i2 < msg.length; i2 += 2) + res.push(parseInt(msg[i2] + msg[i2 + 1], 16)); + } + } else { + for (i2 = 0; i2 < msg.length; i2++) + res[i2] = msg[i2] | 0; + } + return res; + } + utils$1.toArray = toArray; + function toHex(msg) { + var res = ""; + for (var i2 = 0; i2 < msg.length; i2++) + res += zero2(msg[i2].toString(16)); + return res; + } + utils$1.toHex = toHex; + function htonl(w) { + var res = w >>> 24 | w >>> 8 & 65280 | w << 8 & 16711680 | (w & 255) << 24; + return res >>> 0; + } + utils$1.htonl = htonl; + function toHex32(msg, endian) { + var res = ""; + for (var i2 = 0; i2 < msg.length; i2++) { + var w = msg[i2]; + if (endian === "little") + w = htonl(w); + res += zero8(w.toString(16)); + } + return res; + } + utils$1.toHex32 = toHex32; + function zero2(word) { + if (word.length === 1) + return "0" + word; + else + return word; + } + utils$1.zero2 = zero2; + function zero8(word) { + if (word.length === 7) + return "0" + word; + else if (word.length === 6) + return "00" + word; + else if (word.length === 5) + return "000" + word; + else if (word.length === 4) + return "0000" + word; + else if (word.length === 3) + return "00000" + word; + else if (word.length === 2) + return "000000" + word; + else if (word.length === 1) + return "0000000" + word; + else + return word; + } + utils$1.zero8 = zero8; + function join32(msg, start, end, endian) { + var len2 = end - start; + assert(len2 % 4 === 0); + var res = new Array(len2 / 4); + for (var i2 = 0, k = start; i2 < res.length; i2++, k += 4) { + var w; + if (endian === "big") + w = msg[k] << 24 | msg[k + 1] << 16 | msg[k + 2] << 8 | msg[k + 3]; + else + w = msg[k + 3] << 24 | msg[k + 2] << 16 | msg[k + 1] << 8 | msg[k]; + res[i2] = w >>> 0; + } + return res; + } + utils$1.join32 = join32; + function split32(msg, endian) { + var res = new Array(msg.length * 4); + for (var i2 = 0, k = 0; i2 < msg.length; i2++, k += 4) { + var m = msg[i2]; + if (endian === "big") { + res[k] = m >>> 24; + res[k + 1] = m >>> 16 & 255; + res[k + 2] = m >>> 8 & 255; + res[k + 3] = m & 255; + } else { + res[k + 3] = m >>> 24; + res[k + 2] = m >>> 16 & 255; + res[k + 1] = m >>> 8 & 255; + res[k] = m & 255; + } + } + return res; + } + utils$1.split32 = split32; + function rotr32(w, b) { + return w >>> b | w << 32 - b; + } + utils$1.rotr32 = rotr32; + function rotl32(w, b) { + return w << b | w >>> 32 - b; + } + utils$1.rotl32 = rotl32; + function sum32(a, b) { + return a + b >>> 0; + } + utils$1.sum32 = sum32; + function sum32_3(a, b, c) { + return a + b + c >>> 0; + } + utils$1.sum32_3 = sum32_3; + function sum32_4(a, b, c, d) { + return a + b + c + d >>> 0; + } + utils$1.sum32_4 = sum32_4; + function sum32_5(a, b, c, d, e) { + return a + b + c + d + e >>> 0; + } + utils$1.sum32_5 = sum32_5; + function sum64(buf, pos, ah, al) { + var bh = buf[pos]; + var bl = buf[pos + 1]; + var lo = al + bl >>> 0; + var hi = (lo < al ? 1 : 0) + ah + bh; + buf[pos] = hi >>> 0; + buf[pos + 1] = lo; + } + utils$1.sum64 = sum64; + function sum64_hi(ah, al, bh, bl) { + var lo = al + bl >>> 0; + var hi = (lo < al ? 1 : 0) + ah + bh; + return hi >>> 0; + } + utils$1.sum64_hi = sum64_hi; + function sum64_lo(ah, al, bh, bl) { + var lo = al + bl; + return lo >>> 0; + } + utils$1.sum64_lo = sum64_lo; + function sum64_4_hi(ah, al, bh, bl, ch, cl, dh2, dl) { + var carry = 0; + var lo = al; + lo = lo + bl >>> 0; + carry += lo < al ? 1 : 0; + lo = lo + cl >>> 0; + carry += lo < cl ? 1 : 0; + lo = lo + dl >>> 0; + carry += lo < dl ? 1 : 0; + var hi = ah + bh + ch + dh2 + carry; + return hi >>> 0; + } + utils$1.sum64_4_hi = sum64_4_hi; + function sum64_4_lo(ah, al, bh, bl, ch, cl, dh2, dl) { + var lo = al + bl + cl + dl; + return lo >>> 0; + } + utils$1.sum64_4_lo = sum64_4_lo; + function sum64_5_hi(ah, al, bh, bl, ch, cl, dh2, dl, eh, el) { + var carry = 0; + var lo = al; + lo = lo + bl >>> 0; + carry += lo < al ? 1 : 0; + lo = lo + cl >>> 0; + carry += lo < cl ? 1 : 0; + lo = lo + dl >>> 0; + carry += lo < dl ? 1 : 0; + lo = lo + el >>> 0; + carry += lo < el ? 1 : 0; + var hi = ah + bh + ch + dh2 + eh + carry; + return hi >>> 0; + } + utils$1.sum64_5_hi = sum64_5_hi; + function sum64_5_lo(ah, al, bh, bl, ch, cl, dh2, dl, eh, el) { + var lo = al + bl + cl + dl + el; + return lo >>> 0; + } + utils$1.sum64_5_lo = sum64_5_lo; + function rotr64_hi(ah, al, num) { + var r = al << 32 - num | ah >>> num; + return r >>> 0; + } + utils$1.rotr64_hi = rotr64_hi; + function rotr64_lo(ah, al, num) { + var r = ah << 32 - num | al >>> num; + return r >>> 0; + } + utils$1.rotr64_lo = rotr64_lo; + function shr64_hi(ah, al, num) { + return ah >>> num; + } + utils$1.shr64_hi = shr64_hi; + function shr64_lo(ah, al, num) { + var r = ah << 32 - num | al >>> num; + return r >>> 0; + } + utils$1.shr64_lo = shr64_lo; + return utils$1; +} +var common$1 = {}; +var hasRequiredCommon$1; +function requireCommon$1() { + if (hasRequiredCommon$1) return common$1; + hasRequiredCommon$1 = 1; + var utils2 = requireUtils(); + var assert = requireMinimalisticAssert(); + function BlockHash() { + this.pending = null; + this.pendingTotal = 0; + this.blockSize = this.constructor.blockSize; + this.outSize = this.constructor.outSize; + this.hmacStrength = this.constructor.hmacStrength; + this.padLength = this.constructor.padLength / 8; + this.endian = "big"; + this._delta8 = this.blockSize / 8; + this._delta32 = this.blockSize / 32; + } + common$1.BlockHash = BlockHash; + BlockHash.prototype.update = function update(msg, enc) { + msg = utils2.toArray(msg, enc); + if (!this.pending) + this.pending = msg; + else + this.pending = this.pending.concat(msg); + this.pendingTotal += msg.length; + if (this.pending.length >= this._delta8) { + msg = this.pending; + var r = msg.length % this._delta8; + this.pending = msg.slice(msg.length - r, msg.length); + if (this.pending.length === 0) + this.pending = null; + msg = utils2.join32(msg, 0, msg.length - r, this.endian); + for (var i2 = 0; i2 < msg.length; i2 += this._delta32) + this._update(msg, i2, i2 + this._delta32); + } + return this; + }; + BlockHash.prototype.digest = function digest(enc) { + this.update(this._pad()); + assert(this.pending === null); + return this._digest(enc); + }; + BlockHash.prototype._pad = function pad() { + var len2 = this.pendingTotal; + var bytes = this._delta8; + var k = bytes - (len2 + this.padLength) % bytes; + var res = new Array(k + this.padLength); + res[0] = 128; + for (var i2 = 1; i2 < k; i2++) + res[i2] = 0; + len2 <<= 3; + if (this.endian === "big") { + for (var t = 8; t < this.padLength; t++) + res[i2++] = 0; + res[i2++] = 0; + res[i2++] = 0; + res[i2++] = 0; + res[i2++] = 0; + res[i2++] = len2 >>> 24 & 255; + res[i2++] = len2 >>> 16 & 255; + res[i2++] = len2 >>> 8 & 255; + res[i2++] = len2 & 255; + } else { + res[i2++] = len2 & 255; + res[i2++] = len2 >>> 8 & 255; + res[i2++] = len2 >>> 16 & 255; + res[i2++] = len2 >>> 24 & 255; + res[i2++] = 0; + res[i2++] = 0; + res[i2++] = 0; + res[i2++] = 0; + for (t = 8; t < this.padLength; t++) + res[i2++] = 0; + } + return res; + }; + return common$1; +} +var sha = {}; +var common = {}; +var hasRequiredCommon; +function requireCommon() { + if (hasRequiredCommon) return common; + hasRequiredCommon = 1; + var utils2 = requireUtils(); + var rotr32 = utils2.rotr32; + function ft_1(s, x, y, z) { + if (s === 0) + return ch32(x, y, z); + if (s === 1 || s === 3) + return p32(x, y, z); + if (s === 2) + return maj32(x, y, z); + } + common.ft_1 = ft_1; + function ch32(x, y, z) { + return x & y ^ ~x & z; + } + common.ch32 = ch32; + function maj32(x, y, z) { + return x & y ^ x & z ^ y & z; + } + common.maj32 = maj32; + function p32(x, y, z) { + return x ^ y ^ z; + } + common.p32 = p32; + function s0_256(x) { + return rotr32(x, 2) ^ rotr32(x, 13) ^ rotr32(x, 22); + } + common.s0_256 = s0_256; + function s1_256(x) { + return rotr32(x, 6) ^ rotr32(x, 11) ^ rotr32(x, 25); + } + common.s1_256 = s1_256; + function g0_256(x) { + return rotr32(x, 7) ^ rotr32(x, 18) ^ x >>> 3; + } + common.g0_256 = g0_256; + function g1_256(x) { + return rotr32(x, 17) ^ rotr32(x, 19) ^ x >>> 10; + } + common.g1_256 = g1_256; + return common; +} +var _1; +var hasRequired_1; +function require_1() { + if (hasRequired_1) return _1; + hasRequired_1 = 1; + var utils2 = requireUtils(); + var common2 = requireCommon$1(); + var shaCommon = requireCommon(); + var rotl32 = utils2.rotl32; + var sum32 = utils2.sum32; + var sum32_5 = utils2.sum32_5; + var ft_1 = shaCommon.ft_1; + var BlockHash = common2.BlockHash; + var sha1_K = [ + 1518500249, + 1859775393, + 2400959708, + 3395469782 + ]; + function SHA1() { + if (!(this instanceof SHA1)) + return new SHA1(); + BlockHash.call(this); + this.h = [ + 1732584193, + 4023233417, + 2562383102, + 271733878, + 3285377520 + ]; + this.W = new Array(80); + } + utils2.inherits(SHA1, BlockHash); + _1 = SHA1; + SHA1.blockSize = 512; + SHA1.outSize = 160; + SHA1.hmacStrength = 80; + SHA1.padLength = 64; + SHA1.prototype._update = function _update(msg, start) { + var W = this.W; + for (var i2 = 0; i2 < 16; i2++) + W[i2] = msg[start + i2]; + for (; i2 < W.length; i2++) + W[i2] = rotl32(W[i2 - 3] ^ W[i2 - 8] ^ W[i2 - 14] ^ W[i2 - 16], 1); + var a = this.h[0]; + var b = this.h[1]; + var c = this.h[2]; + var d = this.h[3]; + var e = this.h[4]; + for (i2 = 0; i2 < W.length; i2++) { + var s = ~~(i2 / 20); + var t = sum32_5(rotl32(a, 5), ft_1(s, b, c, d), e, W[i2], sha1_K[s]); + e = d; + d = c; + c = rotl32(b, 30); + b = a; + a = t; + } + this.h[0] = sum32(this.h[0], a); + this.h[1] = sum32(this.h[1], b); + this.h[2] = sum32(this.h[2], c); + this.h[3] = sum32(this.h[3], d); + this.h[4] = sum32(this.h[4], e); + }; + SHA1.prototype._digest = function digest(enc) { + if (enc === "hex") + return utils2.toHex32(this.h, "big"); + else + return utils2.split32(this.h, "big"); + }; + return _1; +} +var _256; +var hasRequired_256; +function require_256() { + if (hasRequired_256) return _256; + hasRequired_256 = 1; + var utils2 = requireUtils(); + var common2 = requireCommon$1(); + var shaCommon = requireCommon(); + var assert = requireMinimalisticAssert(); + var sum32 = utils2.sum32; + var sum32_4 = utils2.sum32_4; + var sum32_5 = utils2.sum32_5; + var ch32 = shaCommon.ch32; + var maj32 = shaCommon.maj32; + var s0_256 = shaCommon.s0_256; + var s1_256 = shaCommon.s1_256; + var g0_256 = shaCommon.g0_256; + var g1_256 = shaCommon.g1_256; + var BlockHash = common2.BlockHash; + var sha256_K = [ + 1116352408, + 1899447441, + 3049323471, + 3921009573, + 961987163, + 1508970993, + 2453635748, + 2870763221, + 3624381080, + 310598401, + 607225278, + 1426881987, + 1925078388, + 2162078206, + 2614888103, + 3248222580, + 3835390401, + 4022224774, + 264347078, + 604807628, + 770255983, + 1249150122, + 1555081692, + 1996064986, + 2554220882, + 2821834349, + 2952996808, + 3210313671, + 3336571891, + 3584528711, + 113926993, + 338241895, + 666307205, + 773529912, + 1294757372, + 1396182291, + 1695183700, + 1986661051, + 2177026350, + 2456956037, + 2730485921, + 2820302411, + 3259730800, + 3345764771, + 3516065817, + 3600352804, + 4094571909, + 275423344, + 430227734, + 506948616, + 659060556, + 883997877, + 958139571, + 1322822218, + 1537002063, + 1747873779, + 1955562222, + 2024104815, + 2227730452, + 2361852424, + 2428436474, + 2756734187, + 3204031479, + 3329325298 + ]; + function SHA256() { + if (!(this instanceof SHA256)) + return new SHA256(); + BlockHash.call(this); + this.h = [ + 1779033703, + 3144134277, + 1013904242, + 2773480762, + 1359893119, + 2600822924, + 528734635, + 1541459225 + ]; + this.k = sha256_K; + this.W = new Array(64); + } + utils2.inherits(SHA256, BlockHash); + _256 = SHA256; + SHA256.blockSize = 512; + SHA256.outSize = 256; + SHA256.hmacStrength = 192; + SHA256.padLength = 64; + SHA256.prototype._update = function _update(msg, start) { + var W = this.W; + for (var i2 = 0; i2 < 16; i2++) + W[i2] = msg[start + i2]; + for (; i2 < W.length; i2++) + W[i2] = sum32_4(g1_256(W[i2 - 2]), W[i2 - 7], g0_256(W[i2 - 15]), W[i2 - 16]); + var a = this.h[0]; + var b = this.h[1]; + var c = this.h[2]; + var d = this.h[3]; + var e = this.h[4]; + var f = this.h[5]; + var g = this.h[6]; + var h = this.h[7]; + assert(this.k.length === W.length); + for (i2 = 0; i2 < W.length; i2++) { + var T1 = sum32_5(h, s1_256(e), ch32(e, f, g), this.k[i2], W[i2]); + var T2 = sum32(s0_256(a), maj32(a, b, c)); + h = g; + g = f; + f = e; + e = sum32(d, T1); + d = c; + c = b; + b = a; + a = sum32(T1, T2); + } + this.h[0] = sum32(this.h[0], a); + this.h[1] = sum32(this.h[1], b); + this.h[2] = sum32(this.h[2], c); + this.h[3] = sum32(this.h[3], d); + this.h[4] = sum32(this.h[4], e); + this.h[5] = sum32(this.h[5], f); + this.h[6] = sum32(this.h[6], g); + this.h[7] = sum32(this.h[7], h); + }; + SHA256.prototype._digest = function digest(enc) { + if (enc === "hex") + return utils2.toHex32(this.h, "big"); + else + return utils2.split32(this.h, "big"); + }; + return _256; +} +var _224; +var hasRequired_224; +function require_224() { + if (hasRequired_224) return _224; + hasRequired_224 = 1; + var utils2 = requireUtils(); + var SHA256 = require_256(); + function SHA224() { + if (!(this instanceof SHA224)) + return new SHA224(); + SHA256.call(this); + this.h = [ + 3238371032, + 914150663, + 812702999, + 4144912697, + 4290775857, + 1750603025, + 1694076839, + 3204075428 + ]; + } + utils2.inherits(SHA224, SHA256); + _224 = SHA224; + SHA224.blockSize = 512; + SHA224.outSize = 224; + SHA224.hmacStrength = 192; + SHA224.padLength = 64; + SHA224.prototype._digest = function digest(enc) { + if (enc === "hex") + return utils2.toHex32(this.h.slice(0, 7), "big"); + else + return utils2.split32(this.h.slice(0, 7), "big"); + }; + return _224; +} +var _512; +var hasRequired_512; +function require_512() { + if (hasRequired_512) return _512; + hasRequired_512 = 1; + var utils2 = requireUtils(); + var common2 = requireCommon$1(); + var assert = requireMinimalisticAssert(); + var rotr64_hi = utils2.rotr64_hi; + var rotr64_lo = utils2.rotr64_lo; + var shr64_hi = utils2.shr64_hi; + var shr64_lo = utils2.shr64_lo; + var sum64 = utils2.sum64; + var sum64_hi = utils2.sum64_hi; + var sum64_lo = utils2.sum64_lo; + var sum64_4_hi = utils2.sum64_4_hi; + var sum64_4_lo = utils2.sum64_4_lo; + var sum64_5_hi = utils2.sum64_5_hi; + var sum64_5_lo = utils2.sum64_5_lo; + var BlockHash = common2.BlockHash; + var sha512_K = [ + 1116352408, + 3609767458, + 1899447441, + 602891725, + 3049323471, + 3964484399, + 3921009573, + 2173295548, + 961987163, + 4081628472, + 1508970993, + 3053834265, + 2453635748, + 2937671579, + 2870763221, + 3664609560, + 3624381080, + 2734883394, + 310598401, + 1164996542, + 607225278, + 1323610764, + 1426881987, + 3590304994, + 1925078388, + 4068182383, + 2162078206, + 991336113, + 2614888103, + 633803317, + 3248222580, + 3479774868, + 3835390401, + 2666613458, + 4022224774, + 944711139, + 264347078, + 2341262773, + 604807628, + 2007800933, + 770255983, + 1495990901, + 1249150122, + 1856431235, + 1555081692, + 3175218132, + 1996064986, + 2198950837, + 2554220882, + 3999719339, + 2821834349, + 766784016, + 2952996808, + 2566594879, + 3210313671, + 3203337956, + 3336571891, + 1034457026, + 3584528711, + 2466948901, + 113926993, + 3758326383, + 338241895, + 168717936, + 666307205, + 1188179964, + 773529912, + 1546045734, + 1294757372, + 1522805485, + 1396182291, + 2643833823, + 1695183700, + 2343527390, + 1986661051, + 1014477480, + 2177026350, + 1206759142, + 2456956037, + 344077627, + 2730485921, + 1290863460, + 2820302411, + 3158454273, + 3259730800, + 3505952657, + 3345764771, + 106217008, + 3516065817, + 3606008344, + 3600352804, + 1432725776, + 4094571909, + 1467031594, + 275423344, + 851169720, + 430227734, + 3100823752, + 506948616, + 1363258195, + 659060556, + 3750685593, + 883997877, + 3785050280, + 958139571, + 3318307427, + 1322822218, + 3812723403, + 1537002063, + 2003034995, + 1747873779, + 3602036899, + 1955562222, + 1575990012, + 2024104815, + 1125592928, + 2227730452, + 2716904306, + 2361852424, + 442776044, + 2428436474, + 593698344, + 2756734187, + 3733110249, + 3204031479, + 2999351573, + 3329325298, + 3815920427, + 3391569614, + 3928383900, + 3515267271, + 566280711, + 3940187606, + 3454069534, + 4118630271, + 4000239992, + 116418474, + 1914138554, + 174292421, + 2731055270, + 289380356, + 3203993006, + 460393269, + 320620315, + 685471733, + 587496836, + 852142971, + 1086792851, + 1017036298, + 365543100, + 1126000580, + 2618297676, + 1288033470, + 3409855158, + 1501505948, + 4234509866, + 1607167915, + 987167468, + 1816402316, + 1246189591 + ]; + function SHA512() { + if (!(this instanceof SHA512)) + return new SHA512(); + BlockHash.call(this); + this.h = [ + 1779033703, + 4089235720, + 3144134277, + 2227873595, + 1013904242, + 4271175723, + 2773480762, + 1595750129, + 1359893119, + 2917565137, + 2600822924, + 725511199, + 528734635, + 4215389547, + 1541459225, + 327033209 + ]; + this.k = sha512_K; + this.W = new Array(160); + } + utils2.inherits(SHA512, BlockHash); + _512 = SHA512; + SHA512.blockSize = 1024; + SHA512.outSize = 512; + SHA512.hmacStrength = 192; + SHA512.padLength = 128; + SHA512.prototype._prepareBlock = function _prepareBlock(msg, start) { + var W = this.W; + for (var i2 = 0; i2 < 32; i2++) + W[i2] = msg[start + i2]; + for (; i2 < W.length; i2 += 2) { + var c0_hi = g1_512_hi(W[i2 - 4], W[i2 - 3]); + var c0_lo = g1_512_lo(W[i2 - 4], W[i2 - 3]); + var c1_hi = W[i2 - 14]; + var c1_lo = W[i2 - 13]; + var c2_hi = g0_512_hi(W[i2 - 30], W[i2 - 29]); + var c2_lo = g0_512_lo(W[i2 - 30], W[i2 - 29]); + var c3_hi = W[i2 - 32]; + var c3_lo = W[i2 - 31]; + W[i2] = sum64_4_hi( + c0_hi, + c0_lo, + c1_hi, + c1_lo, + c2_hi, + c2_lo, + c3_hi, + c3_lo + ); + W[i2 + 1] = sum64_4_lo( + c0_hi, + c0_lo, + c1_hi, + c1_lo, + c2_hi, + c2_lo, + c3_hi, + c3_lo + ); + } + }; + SHA512.prototype._update = function _update(msg, start) { + this._prepareBlock(msg, start); + var W = this.W; + var ah = this.h[0]; + var al = this.h[1]; + var bh = this.h[2]; + var bl = this.h[3]; + var ch = this.h[4]; + var cl = this.h[5]; + var dh2 = this.h[6]; + var dl = this.h[7]; + var eh = this.h[8]; + var el = this.h[9]; + var fh = this.h[10]; + var fl = this.h[11]; + var gh = this.h[12]; + var gl = this.h[13]; + var hh = this.h[14]; + var hl = this.h[15]; + assert(this.k.length === W.length); + for (var i2 = 0; i2 < W.length; i2 += 2) { + var c0_hi = hh; + var c0_lo = hl; + var c1_hi = s1_512_hi(eh, el); + var c1_lo = s1_512_lo(eh, el); + var c2_hi = ch64_hi(eh, el, fh, fl, gh); + var c2_lo = ch64_lo(eh, el, fh, fl, gh, gl); + var c3_hi = this.k[i2]; + var c3_lo = this.k[i2 + 1]; + var c4_hi = W[i2]; + var c4_lo = W[i2 + 1]; + var T1_hi = sum64_5_hi( + c0_hi, + c0_lo, + c1_hi, + c1_lo, + c2_hi, + c2_lo, + c3_hi, + c3_lo, + c4_hi, + c4_lo + ); + var T1_lo = sum64_5_lo( + c0_hi, + c0_lo, + c1_hi, + c1_lo, + c2_hi, + c2_lo, + c3_hi, + c3_lo, + c4_hi, + c4_lo + ); + c0_hi = s0_512_hi(ah, al); + c0_lo = s0_512_lo(ah, al); + c1_hi = maj64_hi(ah, al, bh, bl, ch); + c1_lo = maj64_lo(ah, al, bh, bl, ch, cl); + var T2_hi = sum64_hi(c0_hi, c0_lo, c1_hi, c1_lo); + var T2_lo = sum64_lo(c0_hi, c0_lo, c1_hi, c1_lo); + hh = gh; + hl = gl; + gh = fh; + gl = fl; + fh = eh; + fl = el; + eh = sum64_hi(dh2, dl, T1_hi, T1_lo); + el = sum64_lo(dl, dl, T1_hi, T1_lo); + dh2 = ch; + dl = cl; + ch = bh; + cl = bl; + bh = ah; + bl = al; + ah = sum64_hi(T1_hi, T1_lo, T2_hi, T2_lo); + al = sum64_lo(T1_hi, T1_lo, T2_hi, T2_lo); + } + sum64(this.h, 0, ah, al); + sum64(this.h, 2, bh, bl); + sum64(this.h, 4, ch, cl); + sum64(this.h, 6, dh2, dl); + sum64(this.h, 8, eh, el); + sum64(this.h, 10, fh, fl); + sum64(this.h, 12, gh, gl); + sum64(this.h, 14, hh, hl); + }; + SHA512.prototype._digest = function digest(enc) { + if (enc === "hex") + return utils2.toHex32(this.h, "big"); + else + return utils2.split32(this.h, "big"); + }; + function ch64_hi(xh, xl, yh, yl, zh) { + var r = xh & yh ^ ~xh & zh; + if (r < 0) + r += 4294967296; + return r; + } + function ch64_lo(xh, xl, yh, yl, zh, zl) { + var r = xl & yl ^ ~xl & zl; + if (r < 0) + r += 4294967296; + return r; + } + function maj64_hi(xh, xl, yh, yl, zh) { + var r = xh & yh ^ xh & zh ^ yh & zh; + if (r < 0) + r += 4294967296; + return r; + } + function maj64_lo(xh, xl, yh, yl, zh, zl) { + var r = xl & yl ^ xl & zl ^ yl & zl; + if (r < 0) + r += 4294967296; + return r; + } + function s0_512_hi(xh, xl) { + var c0_hi = rotr64_hi(xh, xl, 28); + var c1_hi = rotr64_hi(xl, xh, 2); + var c2_hi = rotr64_hi(xl, xh, 7); + var r = c0_hi ^ c1_hi ^ c2_hi; + if (r < 0) + r += 4294967296; + return r; + } + function s0_512_lo(xh, xl) { + var c0_lo = rotr64_lo(xh, xl, 28); + var c1_lo = rotr64_lo(xl, xh, 2); + var c2_lo = rotr64_lo(xl, xh, 7); + var r = c0_lo ^ c1_lo ^ c2_lo; + if (r < 0) + r += 4294967296; + return r; + } + function s1_512_hi(xh, xl) { + var c0_hi = rotr64_hi(xh, xl, 14); + var c1_hi = rotr64_hi(xh, xl, 18); + var c2_hi = rotr64_hi(xl, xh, 9); + var r = c0_hi ^ c1_hi ^ c2_hi; + if (r < 0) + r += 4294967296; + return r; + } + function s1_512_lo(xh, xl) { + var c0_lo = rotr64_lo(xh, xl, 14); + var c1_lo = rotr64_lo(xh, xl, 18); + var c2_lo = rotr64_lo(xl, xh, 9); + var r = c0_lo ^ c1_lo ^ c2_lo; + if (r < 0) + r += 4294967296; + return r; + } + function g0_512_hi(xh, xl) { + var c0_hi = rotr64_hi(xh, xl, 1); + var c1_hi = rotr64_hi(xh, xl, 8); + var c2_hi = shr64_hi(xh, xl, 7); + var r = c0_hi ^ c1_hi ^ c2_hi; + if (r < 0) + r += 4294967296; + return r; + } + function g0_512_lo(xh, xl) { + var c0_lo = rotr64_lo(xh, xl, 1); + var c1_lo = rotr64_lo(xh, xl, 8); + var c2_lo = shr64_lo(xh, xl, 7); + var r = c0_lo ^ c1_lo ^ c2_lo; + if (r < 0) + r += 4294967296; + return r; + } + function g1_512_hi(xh, xl) { + var c0_hi = rotr64_hi(xh, xl, 19); + var c1_hi = rotr64_hi(xl, xh, 29); + var c2_hi = shr64_hi(xh, xl, 6); + var r = c0_hi ^ c1_hi ^ c2_hi; + if (r < 0) + r += 4294967296; + return r; + } + function g1_512_lo(xh, xl) { + var c0_lo = rotr64_lo(xh, xl, 19); + var c1_lo = rotr64_lo(xl, xh, 29); + var c2_lo = shr64_lo(xh, xl, 6); + var r = c0_lo ^ c1_lo ^ c2_lo; + if (r < 0) + r += 4294967296; + return r; + } + return _512; +} +var _384; +var hasRequired_384; +function require_384() { + if (hasRequired_384) return _384; + hasRequired_384 = 1; + var utils2 = requireUtils(); + var SHA512 = require_512(); + function SHA384() { + if (!(this instanceof SHA384)) + return new SHA384(); + SHA512.call(this); + this.h = [ + 3418070365, + 3238371032, + 1654270250, + 914150663, + 2438529370, + 812702999, + 355462360, + 4144912697, + 1731405415, + 4290775857, + 2394180231, + 1750603025, + 3675008525, + 1694076839, + 1203062813, + 3204075428 + ]; + } + utils2.inherits(SHA384, SHA512); + _384 = SHA384; + SHA384.blockSize = 1024; + SHA384.outSize = 384; + SHA384.hmacStrength = 192; + SHA384.padLength = 128; + SHA384.prototype._digest = function digest(enc) { + if (enc === "hex") + return utils2.toHex32(this.h.slice(0, 12), "big"); + else + return utils2.split32(this.h.slice(0, 12), "big"); + }; + return _384; +} +var hasRequiredSha; +function requireSha() { + if (hasRequiredSha) return sha; + hasRequiredSha = 1; + sha.sha1 = require_1(); + sha.sha224 = require_224(); + sha.sha256 = require_256(); + sha.sha384 = require_384(); + sha.sha512 = require_512(); + return sha; +} +var ripemd = {}; +var hasRequiredRipemd; +function requireRipemd() { + if (hasRequiredRipemd) return ripemd; + hasRequiredRipemd = 1; + var utils2 = requireUtils(); + var common2 = requireCommon$1(); + var rotl32 = utils2.rotl32; + var sum32 = utils2.sum32; + var sum32_3 = utils2.sum32_3; + var sum32_4 = utils2.sum32_4; + var BlockHash = common2.BlockHash; + function RIPEMD160() { + if (!(this instanceof RIPEMD160)) + return new RIPEMD160(); + BlockHash.call(this); + this.h = [1732584193, 4023233417, 2562383102, 271733878, 3285377520]; + this.endian = "little"; + } + utils2.inherits(RIPEMD160, BlockHash); + ripemd.ripemd160 = RIPEMD160; + RIPEMD160.blockSize = 512; + RIPEMD160.outSize = 160; + RIPEMD160.hmacStrength = 192; + RIPEMD160.padLength = 64; + RIPEMD160.prototype._update = function update(msg, start) { + var A = this.h[0]; + var B = this.h[1]; + var C = this.h[2]; + var D = this.h[3]; + var E = this.h[4]; + var Ah = A; + var Bh = B; + var Ch = C; + var Dh = D; + var Eh = E; + for (var j = 0; j < 80; j++) { + var T = sum32( + rotl32( + sum32_4(A, f(j, B, C, D), msg[r[j] + start], K(j)), + s[j] + ), + E + ); + A = E; + E = D; + D = rotl32(C, 10); + C = B; + B = T; + T = sum32( + rotl32( + sum32_4(Ah, f(79 - j, Bh, Ch, Dh), msg[rh[j] + start], Kh(j)), + sh[j] + ), + Eh + ); + Ah = Eh; + Eh = Dh; + Dh = rotl32(Ch, 10); + Ch = Bh; + Bh = T; + } + T = sum32_3(this.h[1], C, Dh); + this.h[1] = sum32_3(this.h[2], D, Eh); + this.h[2] = sum32_3(this.h[3], E, Ah); + this.h[3] = sum32_3(this.h[4], A, Bh); + this.h[4] = sum32_3(this.h[0], B, Ch); + this.h[0] = T; + }; + RIPEMD160.prototype._digest = function digest(enc) { + if (enc === "hex") + return utils2.toHex32(this.h, "little"); + else + return utils2.split32(this.h, "little"); + }; + function f(j, x, y, z) { + if (j <= 15) + return x ^ y ^ z; + else if (j <= 31) + return x & y | ~x & z; + else if (j <= 47) + return (x | ~y) ^ z; + else if (j <= 63) + return x & z | y & ~z; + else + return x ^ (y | ~z); + } + function K(j) { + if (j <= 15) + return 0; + else if (j <= 31) + return 1518500249; + else if (j <= 47) + return 1859775393; + else if (j <= 63) + return 2400959708; + else + return 2840853838; + } + function Kh(j) { + if (j <= 15) + return 1352829926; + else if (j <= 31) + return 1548603684; + else if (j <= 47) + return 1836072691; + else if (j <= 63) + return 2053994217; + else + return 0; + } + var r = [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 7, + 4, + 13, + 1, + 10, + 6, + 15, + 3, + 12, + 0, + 9, + 5, + 2, + 14, + 11, + 8, + 3, + 10, + 14, + 4, + 9, + 15, + 8, + 1, + 2, + 7, + 0, + 6, + 13, + 11, + 5, + 12, + 1, + 9, + 11, + 10, + 0, + 8, + 12, + 4, + 13, + 3, + 7, + 15, + 14, + 5, + 6, + 2, + 4, + 0, + 5, + 9, + 7, + 12, + 2, + 10, + 14, + 1, + 3, + 8, + 11, + 6, + 15, + 13 + ]; + var rh = [ + 5, + 14, + 7, + 0, + 9, + 2, + 11, + 4, + 13, + 6, + 15, + 8, + 1, + 10, + 3, + 12, + 6, + 11, + 3, + 7, + 0, + 13, + 5, + 10, + 14, + 15, + 8, + 12, + 4, + 9, + 1, + 2, + 15, + 5, + 1, + 3, + 7, + 14, + 6, + 9, + 11, + 8, + 12, + 2, + 10, + 0, + 4, + 13, + 8, + 6, + 4, + 1, + 3, + 11, + 15, + 0, + 5, + 12, + 2, + 13, + 9, + 7, + 10, + 14, + 12, + 15, + 10, + 4, + 1, + 5, + 8, + 7, + 6, + 2, + 13, + 14, + 0, + 3, + 9, + 11 + ]; + var s = [ + 11, + 14, + 15, + 12, + 5, + 8, + 7, + 9, + 11, + 13, + 14, + 15, + 6, + 7, + 9, + 8, + 7, + 6, + 8, + 13, + 11, + 9, + 7, + 15, + 7, + 12, + 15, + 9, + 11, + 7, + 13, + 12, + 11, + 13, + 6, + 7, + 14, + 9, + 13, + 15, + 14, + 8, + 13, + 6, + 5, + 12, + 7, + 5, + 11, + 12, + 14, + 15, + 14, + 15, + 9, + 8, + 9, + 14, + 5, + 6, + 8, + 6, + 5, + 12, + 9, + 15, + 5, + 11, + 6, + 8, + 13, + 12, + 5, + 12, + 13, + 14, + 11, + 8, + 5, + 6 + ]; + var sh = [ + 8, + 9, + 9, + 11, + 13, + 15, + 15, + 5, + 7, + 7, + 8, + 11, + 14, + 14, + 12, + 6, + 9, + 13, + 15, + 7, + 12, + 8, + 9, + 11, + 7, + 7, + 12, + 7, + 6, + 15, + 13, + 11, + 9, + 7, + 15, + 11, + 8, + 6, + 6, + 14, + 12, + 13, + 5, + 14, + 13, + 13, + 7, + 5, + 15, + 5, + 8, + 11, + 14, + 14, + 6, + 14, + 6, + 9, + 12, + 9, + 12, + 5, + 15, + 8, + 8, + 5, + 12, + 9, + 12, + 5, + 14, + 6, + 8, + 13, + 6, + 5, + 15, + 13, + 11, + 11 + ]; + return ripemd; +} +var hmac; +var hasRequiredHmac; +function requireHmac() { + if (hasRequiredHmac) return hmac; + hasRequiredHmac = 1; + var utils2 = requireUtils(); + var assert = requireMinimalisticAssert(); + function Hmac(hash2, key2, enc) { + if (!(this instanceof Hmac)) + return new Hmac(hash2, key2, enc); + this.Hash = hash2; + this.blockSize = hash2.blockSize / 8; + this.outSize = hash2.outSize / 8; + this.inner = null; + this.outer = null; + this._init(utils2.toArray(key2, enc)); + } + hmac = Hmac; + Hmac.prototype._init = function init(key2) { + if (key2.length > this.blockSize) + key2 = new this.Hash().update(key2).digest(); + assert(key2.length <= this.blockSize); + for (var i2 = key2.length; i2 < this.blockSize; i2++) + key2.push(0); + for (i2 = 0; i2 < key2.length; i2++) + key2[i2] ^= 54; + this.inner = new this.Hash().update(key2); + for (i2 = 0; i2 < key2.length; i2++) + key2[i2] ^= 106; + this.outer = new this.Hash().update(key2); + }; + Hmac.prototype.update = function update(msg, enc) { + this.inner.update(msg, enc); + return this; + }; + Hmac.prototype.digest = function digest(enc) { + this.outer.update(this.inner.digest()); + return this.outer.digest(enc); + }; + return hmac; +} +var hasRequiredHash; +function requireHash() { + if (hasRequiredHash) return hash; + hasRequiredHash = 1; + (function(exports2) { + var hash2 = exports2; + hash2.utils = requireUtils(); + hash2.common = requireCommon$1(); + hash2.sha = requireSha(); + hash2.ripemd = requireRipemd(); + hash2.hmac = requireHmac(); + hash2.sha1 = hash2.sha.sha1; + hash2.sha256 = hash2.sha.sha256; + hash2.sha224 = hash2.sha.sha224; + hash2.sha384 = hash2.sha.sha384; + hash2.sha512 = hash2.sha.sha512; + hash2.ripemd160 = hash2.ripemd.ripemd160; + })(hash); + return hash; +} +var secp256k1; +var hasRequiredSecp256k1; +function requireSecp256k1() { + if (hasRequiredSecp256k1) return secp256k1; + hasRequiredSecp256k1 = 1; + secp256k1 = { + doubles: { + step: 4, + points: [ + [ + "e60fce93b59e9ec53011aabc21c23e97b2a31369b87a5ae9c44ee89e2a6dec0a", + "f7e3507399e595929db99f34f57937101296891e44d23f0be1f32cce69616821" + ], + [ + "8282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508", + "11f8a8098557dfe45e8256e830b60ace62d613ac2f7b17bed31b6eaff6e26caf" + ], + [ + "175e159f728b865a72f99cc6c6fc846de0b93833fd2222ed73fce5b551e5b739", + "d3506e0d9e3c79eba4ef97a51ff71f5eacb5955add24345c6efa6ffee9fed695" + ], + [ + "363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640", + "4e273adfc732221953b445397f3363145b9a89008199ecb62003c7f3bee9de9" + ], + [ + "8b4b5f165df3c2be8c6244b5b745638843e4a781a15bcd1b69f79a55dffdf80c", + "4aad0a6f68d308b4b3fbd7813ab0da04f9e336546162ee56b3eff0c65fd4fd36" + ], + [ + "723cbaa6e5db996d6bf771c00bd548c7b700dbffa6c0e77bcb6115925232fcda", + "96e867b5595cc498a921137488824d6e2660a0653779494801dc069d9eb39f5f" + ], + [ + "eebfa4d493bebf98ba5feec812c2d3b50947961237a919839a533eca0e7dd7fa", + "5d9a8ca3970ef0f269ee7edaf178089d9ae4cdc3a711f712ddfd4fdae1de8999" + ], + [ + "100f44da696e71672791d0a09b7bde459f1215a29b3c03bfefd7835b39a48db0", + "cdd9e13192a00b772ec8f3300c090666b7ff4a18ff5195ac0fbd5cd62bc65a09" + ], + [ + "e1031be262c7ed1b1dc9227a4a04c017a77f8d4464f3b3852c8acde6e534fd2d", + "9d7061928940405e6bb6a4176597535af292dd419e1ced79a44f18f29456a00d" + ], + [ + "feea6cae46d55b530ac2839f143bd7ec5cf8b266a41d6af52d5e688d9094696d", + "e57c6b6c97dce1bab06e4e12bf3ecd5c981c8957cc41442d3155debf18090088" + ], + [ + "da67a91d91049cdcb367be4be6ffca3cfeed657d808583de33fa978bc1ec6cb1", + "9bacaa35481642bc41f463f7ec9780e5dec7adc508f740a17e9ea8e27a68be1d" + ], + [ + "53904faa0b334cdda6e000935ef22151ec08d0f7bb11069f57545ccc1a37b7c0", + "5bc087d0bc80106d88c9eccac20d3c1c13999981e14434699dcb096b022771c8" + ], + [ + "8e7bcd0bd35983a7719cca7764ca906779b53a043a9b8bcaeff959f43ad86047", + "10b7770b2a3da4b3940310420ca9514579e88e2e47fd68b3ea10047e8460372a" + ], + [ + "385eed34c1cdff21e6d0818689b81bde71a7f4f18397e6690a841e1599c43862", + "283bebc3e8ea23f56701de19e9ebf4576b304eec2086dc8cc0458fe5542e5453" + ], + [ + "6f9d9b803ecf191637c73a4413dfa180fddf84a5947fbc9c606ed86c3fac3a7", + "7c80c68e603059ba69b8e2a30e45c4d47ea4dd2f5c281002d86890603a842160" + ], + [ + "3322d401243c4e2582a2147c104d6ecbf774d163db0f5e5313b7e0e742d0e6bd", + "56e70797e9664ef5bfb019bc4ddaf9b72805f63ea2873af624f3a2e96c28b2a0" + ], + [ + "85672c7d2de0b7da2bd1770d89665868741b3f9af7643397721d74d28134ab83", + "7c481b9b5b43b2eb6374049bfa62c2e5e77f17fcc5298f44c8e3094f790313a6" + ], + [ + "948bf809b1988a46b06c9f1919413b10f9226c60f668832ffd959af60c82a0a", + "53a562856dcb6646dc6b74c5d1c3418c6d4dff08c97cd2bed4cb7f88d8c8e589" + ], + [ + "6260ce7f461801c34f067ce0f02873a8f1b0e44dfc69752accecd819f38fd8e8", + "bc2da82b6fa5b571a7f09049776a1ef7ecd292238051c198c1a84e95b2b4ae17" + ], + [ + "e5037de0afc1d8d43d8348414bbf4103043ec8f575bfdc432953cc8d2037fa2d", + "4571534baa94d3b5f9f98d09fb990bddbd5f5b03ec481f10e0e5dc841d755bda" + ], + [ + "e06372b0f4a207adf5ea905e8f1771b4e7e8dbd1c6a6c5b725866a0ae4fce725", + "7a908974bce18cfe12a27bb2ad5a488cd7484a7787104870b27034f94eee31dd" + ], + [ + "213c7a715cd5d45358d0bbf9dc0ce02204b10bdde2a3f58540ad6908d0559754", + "4b6dad0b5ae462507013ad06245ba190bb4850f5f36a7eeddff2c27534b458f2" + ], + [ + "4e7c272a7af4b34e8dbb9352a5419a87e2838c70adc62cddf0cc3a3b08fbd53c", + "17749c766c9d0b18e16fd09f6def681b530b9614bff7dd33e0b3941817dcaae6" + ], + [ + "fea74e3dbe778b1b10f238ad61686aa5c76e3db2be43057632427e2840fb27b6", + "6e0568db9b0b13297cf674deccb6af93126b596b973f7b77701d3db7f23cb96f" + ], + [ + "76e64113f677cf0e10a2570d599968d31544e179b760432952c02a4417bdde39", + "c90ddf8dee4e95cf577066d70681f0d35e2a33d2b56d2032b4b1752d1901ac01" + ], + [ + "c738c56b03b2abe1e8281baa743f8f9a8f7cc643df26cbee3ab150242bcbb891", + "893fb578951ad2537f718f2eacbfbbbb82314eef7880cfe917e735d9699a84c3" + ], + [ + "d895626548b65b81e264c7637c972877d1d72e5f3a925014372e9f6588f6c14b", + "febfaa38f2bc7eae728ec60818c340eb03428d632bb067e179363ed75d7d991f" + ], + [ + "b8da94032a957518eb0f6433571e8761ceffc73693e84edd49150a564f676e03", + "2804dfa44805a1e4d7c99cc9762808b092cc584d95ff3b511488e4e74efdf6e7" + ], + [ + "e80fea14441fb33a7d8adab9475d7fab2019effb5156a792f1a11778e3c0df5d", + "eed1de7f638e00771e89768ca3ca94472d155e80af322ea9fcb4291b6ac9ec78" + ], + [ + "a301697bdfcd704313ba48e51d567543f2a182031efd6915ddc07bbcc4e16070", + "7370f91cfb67e4f5081809fa25d40f9b1735dbf7c0a11a130c0d1a041e177ea1" + ], + [ + "90ad85b389d6b936463f9d0512678de208cc330b11307fffab7ac63e3fb04ed4", + "e507a3620a38261affdcbd9427222b839aefabe1582894d991d4d48cb6ef150" + ], + [ + "8f68b9d2f63b5f339239c1ad981f162ee88c5678723ea3351b7b444c9ec4c0da", + "662a9f2dba063986de1d90c2b6be215dbbea2cfe95510bfdf23cbf79501fff82" + ], + [ + "e4f3fb0176af85d65ff99ff9198c36091f48e86503681e3e6686fd5053231e11", + "1e63633ad0ef4f1c1661a6d0ea02b7286cc7e74ec951d1c9822c38576feb73bc" + ], + [ + "8c00fa9b18ebf331eb961537a45a4266c7034f2f0d4e1d0716fb6eae20eae29e", + "efa47267fea521a1a9dc343a3736c974c2fadafa81e36c54e7d2a4c66702414b" + ], + [ + "e7a26ce69dd4829f3e10cec0a9e98ed3143d084f308b92c0997fddfc60cb3e41", + "2a758e300fa7984b471b006a1aafbb18d0a6b2c0420e83e20e8a9421cf2cfd51" + ], + [ + "b6459e0ee3662ec8d23540c223bcbdc571cbcb967d79424f3cf29eb3de6b80ef", + "67c876d06f3e06de1dadf16e5661db3c4b3ae6d48e35b2ff30bf0b61a71ba45" + ], + [ + "d68a80c8280bb840793234aa118f06231d6f1fc67e73c5a5deda0f5b496943e8", + "db8ba9fff4b586d00c4b1f9177b0e28b5b0e7b8f7845295a294c84266b133120" + ], + [ + "324aed7df65c804252dc0270907a30b09612aeb973449cea4095980fc28d3d5d", + "648a365774b61f2ff130c0c35aec1f4f19213b0c7e332843967224af96ab7c84" + ], + [ + "4df9c14919cde61f6d51dfdbe5fee5dceec4143ba8d1ca888e8bd373fd054c96", + "35ec51092d8728050974c23a1d85d4b5d506cdc288490192ebac06cad10d5d" + ], + [ + "9c3919a84a474870faed8a9c1cc66021523489054d7f0308cbfc99c8ac1f98cd", + "ddb84f0f4a4ddd57584f044bf260e641905326f76c64c8e6be7e5e03d4fc599d" + ], + [ + "6057170b1dd12fdf8de05f281d8e06bb91e1493a8b91d4cc5a21382120a959e5", + "9a1af0b26a6a4807add9a2daf71df262465152bc3ee24c65e899be932385a2a8" + ], + [ + "a576df8e23a08411421439a4518da31880cef0fba7d4df12b1a6973eecb94266", + "40a6bf20e76640b2c92b97afe58cd82c432e10a7f514d9f3ee8be11ae1b28ec8" + ], + [ + "7778a78c28dec3e30a05fe9629de8c38bb30d1f5cf9a3a208f763889be58ad71", + "34626d9ab5a5b22ff7098e12f2ff580087b38411ff24ac563b513fc1fd9f43ac" + ], + [ + "928955ee637a84463729fd30e7afd2ed5f96274e5ad7e5cb09eda9c06d903ac", + "c25621003d3f42a827b78a13093a95eeac3d26efa8a8d83fc5180e935bcd091f" + ], + [ + "85d0fef3ec6db109399064f3a0e3b2855645b4a907ad354527aae75163d82751", + "1f03648413a38c0be29d496e582cf5663e8751e96877331582c237a24eb1f962" + ], + [ + "ff2b0dce97eece97c1c9b6041798b85dfdfb6d8882da20308f5404824526087e", + "493d13fef524ba188af4c4dc54d07936c7b7ed6fb90e2ceb2c951e01f0c29907" + ], + [ + "827fbbe4b1e880ea9ed2b2e6301b212b57f1ee148cd6dd28780e5e2cf856e241", + "c60f9c923c727b0b71bef2c67d1d12687ff7a63186903166d605b68baec293ec" + ], + [ + "eaa649f21f51bdbae7be4ae34ce6e5217a58fdce7f47f9aa7f3b58fa2120e2b3", + "be3279ed5bbbb03ac69a80f89879aa5a01a6b965f13f7e59d47a5305ba5ad93d" + ], + [ + "e4a42d43c5cf169d9391df6decf42ee541b6d8f0c9a137401e23632dda34d24f", + "4d9f92e716d1c73526fc99ccfb8ad34ce886eedfa8d8e4f13a7f7131deba9414" + ], + [ + "1ec80fef360cbdd954160fadab352b6b92b53576a88fea4947173b9d4300bf19", + "aeefe93756b5340d2f3a4958a7abbf5e0146e77f6295a07b671cdc1cc107cefd" + ], + [ + "146a778c04670c2f91b00af4680dfa8bce3490717d58ba889ddb5928366642be", + "b318e0ec3354028add669827f9d4b2870aaa971d2f7e5ed1d0b297483d83efd0" + ], + [ + "fa50c0f61d22e5f07e3acebb1aa07b128d0012209a28b9776d76a8793180eef9", + "6b84c6922397eba9b72cd2872281a68a5e683293a57a213b38cd8d7d3f4f2811" + ], + [ + "da1d61d0ca721a11b1a5bf6b7d88e8421a288ab5d5bba5220e53d32b5f067ec2", + "8157f55a7c99306c79c0766161c91e2966a73899d279b48a655fba0f1ad836f1" + ], + [ + "a8e282ff0c9706907215ff98e8fd416615311de0446f1e062a73b0610d064e13", + "7f97355b8db81c09abfb7f3c5b2515888b679a3e50dd6bd6cef7c73111f4cc0c" + ], + [ + "174a53b9c9a285872d39e56e6913cab15d59b1fa512508c022f382de8319497c", + "ccc9dc37abfc9c1657b4155f2c47f9e6646b3a1d8cb9854383da13ac079afa73" + ], + [ + "959396981943785c3d3e57edf5018cdbe039e730e4918b3d884fdff09475b7ba", + "2e7e552888c331dd8ba0386a4b9cd6849c653f64c8709385e9b8abf87524f2fd" + ], + [ + "d2a63a50ae401e56d645a1153b109a8fcca0a43d561fba2dbb51340c9d82b151", + "e82d86fb6443fcb7565aee58b2948220a70f750af484ca52d4142174dcf89405" + ], + [ + "64587e2335471eb890ee7896d7cfdc866bacbdbd3839317b3436f9b45617e073", + "d99fcdd5bf6902e2ae96dd6447c299a185b90a39133aeab358299e5e9faf6589" + ], + [ + "8481bde0e4e4d885b3a546d3e549de042f0aa6cea250e7fd358d6c86dd45e458", + "38ee7b8cba5404dd84a25bf39cecb2ca900a79c42b262e556d64b1b59779057e" + ], + [ + "13464a57a78102aa62b6979ae817f4637ffcfed3c4b1ce30bcd6303f6caf666b", + "69be159004614580ef7e433453ccb0ca48f300a81d0942e13f495a907f6ecc27" + ], + [ + "bc4a9df5b713fe2e9aef430bcc1dc97a0cd9ccede2f28588cada3a0d2d83f366", + "d3a81ca6e785c06383937adf4b798caa6e8a9fbfa547b16d758d666581f33c1" + ], + [ + "8c28a97bf8298bc0d23d8c749452a32e694b65e30a9472a3954ab30fe5324caa", + "40a30463a3305193378fedf31f7cc0eb7ae784f0451cb9459e71dc73cbef9482" + ], + [ + "8ea9666139527a8c1dd94ce4f071fd23c8b350c5a4bb33748c4ba111faccae0", + "620efabbc8ee2782e24e7c0cfb95c5d735b783be9cf0f8e955af34a30e62b945" + ], + [ + "dd3625faef5ba06074669716bbd3788d89bdde815959968092f76cc4eb9a9787", + "7a188fa3520e30d461da2501045731ca941461982883395937f68d00c644a573" + ], + [ + "f710d79d9eb962297e4f6232b40e8f7feb2bc63814614d692c12de752408221e", + "ea98e67232d3b3295d3b535532115ccac8612c721851617526ae47a9c77bfc82" + ] + ] + }, + naf: { + wnd: 7, + points: [ + [ + "f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9", + "388f7b0f632de8140fe337e62a37f3566500a99934c2231b6cb9fd7584b8e672" + ], + [ + "2f8bde4d1a07209355b4a7250a5c5128e88b84bddc619ab7cba8d569b240efe4", + "d8ac222636e5e3d6d4dba9dda6c9c426f788271bab0d6840dca87d3aa6ac62d6" + ], + [ + "5cbdf0646e5db4eaa398f365f2ea7a0e3d419b7e0330e39ce92bddedcac4f9bc", + "6aebca40ba255960a3178d6d861a54dba813d0b813fde7b5a5082628087264da" + ], + [ + "acd484e2f0c7f65309ad178a9f559abde09796974c57e714c35f110dfc27ccbe", + "cc338921b0a7d9fd64380971763b61e9add888a4375f8e0f05cc262ac64f9c37" + ], + [ + "774ae7f858a9411e5ef4246b70c65aac5649980be5c17891bbec17895da008cb", + "d984a032eb6b5e190243dd56d7b7b365372db1e2dff9d6a8301d74c9c953c61b" + ], + [ + "f28773c2d975288bc7d1d205c3748651b075fbc6610e58cddeeddf8f19405aa8", + "ab0902e8d880a89758212eb65cdaf473a1a06da521fa91f29b5cb52db03ed81" + ], + [ + "d7924d4f7d43ea965a465ae3095ff41131e5946f3c85f79e44adbcf8e27e080e", + "581e2872a86c72a683842ec228cc6defea40af2bd896d3a5c504dc9ff6a26b58" + ], + [ + "defdea4cdb677750a420fee807eacf21eb9898ae79b9768766e4faa04a2d4a34", + "4211ab0694635168e997b0ead2a93daeced1f4a04a95c0f6cfb199f69e56eb77" + ], + [ + "2b4ea0a797a443d293ef5cff444f4979f06acfebd7e86d277475656138385b6c", + "85e89bc037945d93b343083b5a1c86131a01f60c50269763b570c854e5c09b7a" + ], + [ + "352bbf4a4cdd12564f93fa332ce333301d9ad40271f8107181340aef25be59d5", + "321eb4075348f534d59c18259dda3e1f4a1b3b2e71b1039c67bd3d8bcf81998c" + ], + [ + "2fa2104d6b38d11b0230010559879124e42ab8dfeff5ff29dc9cdadd4ecacc3f", + "2de1068295dd865b64569335bd5dd80181d70ecfc882648423ba76b532b7d67" + ], + [ + "9248279b09b4d68dab21a9b066edda83263c3d84e09572e269ca0cd7f5453714", + "73016f7bf234aade5d1aa71bdea2b1ff3fc0de2a887912ffe54a32ce97cb3402" + ], + [ + "daed4f2be3a8bf278e70132fb0beb7522f570e144bf615c07e996d443dee8729", + "a69dce4a7d6c98e8d4a1aca87ef8d7003f83c230f3afa726ab40e52290be1c55" + ], + [ + "c44d12c7065d812e8acf28d7cbb19f9011ecd9e9fdf281b0e6a3b5e87d22e7db", + "2119a460ce326cdc76c45926c982fdac0e106e861edf61c5a039063f0e0e6482" + ], + [ + "6a245bf6dc698504c89a20cfded60853152b695336c28063b61c65cbd269e6b4", + "e022cf42c2bd4a708b3f5126f16a24ad8b33ba48d0423b6efd5e6348100d8a82" + ], + [ + "1697ffa6fd9de627c077e3d2fe541084ce13300b0bec1146f95ae57f0d0bd6a5", + "b9c398f186806f5d27561506e4557433a2cf15009e498ae7adee9d63d01b2396" + ], + [ + "605bdb019981718b986d0f07e834cb0d9deb8360ffb7f61df982345ef27a7479", + "2972d2de4f8d20681a78d93ec96fe23c26bfae84fb14db43b01e1e9056b8c49" + ], + [ + "62d14dab4150bf497402fdc45a215e10dcb01c354959b10cfe31c7e9d87ff33d", + "80fc06bd8cc5b01098088a1950eed0db01aa132967ab472235f5642483b25eaf" + ], + [ + "80c60ad0040f27dade5b4b06c408e56b2c50e9f56b9b8b425e555c2f86308b6f", + "1c38303f1cc5c30f26e66bad7fe72f70a65eed4cbe7024eb1aa01f56430bd57a" + ], + [ + "7a9375ad6167ad54aa74c6348cc54d344cc5dc9487d847049d5eabb0fa03c8fb", + "d0e3fa9eca8726909559e0d79269046bdc59ea10c70ce2b02d499ec224dc7f7" + ], + [ + "d528ecd9b696b54c907a9ed045447a79bb408ec39b68df504bb51f459bc3ffc9", + "eecf41253136e5f99966f21881fd656ebc4345405c520dbc063465b521409933" + ], + [ + "49370a4b5f43412ea25f514e8ecdad05266115e4a7ecb1387231808f8b45963", + "758f3f41afd6ed428b3081b0512fd62a54c3f3afbb5b6764b653052a12949c9a" + ], + [ + "77f230936ee88cbbd73df930d64702ef881d811e0e1498e2f1c13eb1fc345d74", + "958ef42a7886b6400a08266e9ba1b37896c95330d97077cbbe8eb3c7671c60d6" + ], + [ + "f2dac991cc4ce4b9ea44887e5c7c0bce58c80074ab9d4dbaeb28531b7739f530", + "e0dedc9b3b2f8dad4da1f32dec2531df9eb5fbeb0598e4fd1a117dba703a3c37" + ], + [ + "463b3d9f662621fb1b4be8fbbe2520125a216cdfc9dae3debcba4850c690d45b", + "5ed430d78c296c3543114306dd8622d7c622e27c970a1de31cb377b01af7307e" + ], + [ + "f16f804244e46e2a09232d4aff3b59976b98fac14328a2d1a32496b49998f247", + "cedabd9b82203f7e13d206fcdf4e33d92a6c53c26e5cce26d6579962c4e31df6" + ], + [ + "caf754272dc84563b0352b7a14311af55d245315ace27c65369e15f7151d41d1", + "cb474660ef35f5f2a41b643fa5e460575f4fa9b7962232a5c32f908318a04476" + ], + [ + "2600ca4b282cb986f85d0f1709979d8b44a09c07cb86d7c124497bc86f082120", + "4119b88753c15bd6a693b03fcddbb45d5ac6be74ab5f0ef44b0be9475a7e4b40" + ], + [ + "7635ca72d7e8432c338ec53cd12220bc01c48685e24f7dc8c602a7746998e435", + "91b649609489d613d1d5e590f78e6d74ecfc061d57048bad9e76f302c5b9c61" + ], + [ + "754e3239f325570cdbbf4a87deee8a66b7f2b33479d468fbc1a50743bf56cc18", + "673fb86e5bda30fb3cd0ed304ea49a023ee33d0197a695d0c5d98093c536683" + ], + [ + "e3e6bd1071a1e96aff57859c82d570f0330800661d1c952f9fe2694691d9b9e8", + "59c9e0bba394e76f40c0aa58379a3cb6a5a2283993e90c4167002af4920e37f5" + ], + [ + "186b483d056a033826ae73d88f732985c4ccb1f32ba35f4b4cc47fdcf04aa6eb", + "3b952d32c67cf77e2e17446e204180ab21fb8090895138b4a4a797f86e80888b" + ], + [ + "df9d70a6b9876ce544c98561f4be4f725442e6d2b737d9c91a8321724ce0963f", + "55eb2dafd84d6ccd5f862b785dc39d4ab157222720ef9da217b8c45cf2ba2417" + ], + [ + "5edd5cc23c51e87a497ca815d5dce0f8ab52554f849ed8995de64c5f34ce7143", + "efae9c8dbc14130661e8cec030c89ad0c13c66c0d17a2905cdc706ab7399a868" + ], + [ + "290798c2b6476830da12fe02287e9e777aa3fba1c355b17a722d362f84614fba", + "e38da76dcd440621988d00bcf79af25d5b29c094db2a23146d003afd41943e7a" + ], + [ + "af3c423a95d9f5b3054754efa150ac39cd29552fe360257362dfdecef4053b45", + "f98a3fd831eb2b749a93b0e6f35cfb40c8cd5aa667a15581bc2feded498fd9c6" + ], + [ + "766dbb24d134e745cccaa28c99bf274906bb66b26dcf98df8d2fed50d884249a", + "744b1152eacbe5e38dcc887980da38b897584a65fa06cedd2c924f97cbac5996" + ], + [ + "59dbf46f8c94759ba21277c33784f41645f7b44f6c596a58ce92e666191abe3e", + "c534ad44175fbc300f4ea6ce648309a042ce739a7919798cd85e216c4a307f6e" + ], + [ + "f13ada95103c4537305e691e74e9a4a8dd647e711a95e73cb62dc6018cfd87b8", + "e13817b44ee14de663bf4bc808341f326949e21a6a75c2570778419bdaf5733d" + ], + [ + "7754b4fa0e8aced06d4167a2c59cca4cda1869c06ebadfb6488550015a88522c", + "30e93e864e669d82224b967c3020b8fa8d1e4e350b6cbcc537a48b57841163a2" + ], + [ + "948dcadf5990e048aa3874d46abef9d701858f95de8041d2a6828c99e2262519", + "e491a42537f6e597d5d28a3224b1bc25df9154efbd2ef1d2cbba2cae5347d57e" + ], + [ + "7962414450c76c1689c7b48f8202ec37fb224cf5ac0bfa1570328a8a3d7c77ab", + "100b610ec4ffb4760d5c1fc133ef6f6b12507a051f04ac5760afa5b29db83437" + ], + [ + "3514087834964b54b15b160644d915485a16977225b8847bb0dd085137ec47ca", + "ef0afbb2056205448e1652c48e8127fc6039e77c15c2378b7e7d15a0de293311" + ], + [ + "d3cc30ad6b483e4bc79ce2c9dd8bc54993e947eb8df787b442943d3f7b527eaf", + "8b378a22d827278d89c5e9be8f9508ae3c2ad46290358630afb34db04eede0a4" + ], + [ + "1624d84780732860ce1c78fcbfefe08b2b29823db913f6493975ba0ff4847610", + "68651cf9b6da903e0914448c6cd9d4ca896878f5282be4c8cc06e2a404078575" + ], + [ + "733ce80da955a8a26902c95633e62a985192474b5af207da6df7b4fd5fc61cd4", + "f5435a2bd2badf7d485a4d8b8db9fcce3e1ef8e0201e4578c54673bc1dc5ea1d" + ], + [ + "15d9441254945064cf1a1c33bbd3b49f8966c5092171e699ef258dfab81c045c", + "d56eb30b69463e7234f5137b73b84177434800bacebfc685fc37bbe9efe4070d" + ], + [ + "a1d0fcf2ec9de675b612136e5ce70d271c21417c9d2b8aaaac138599d0717940", + "edd77f50bcb5a3cab2e90737309667f2641462a54070f3d519212d39c197a629" + ], + [ + "e22fbe15c0af8ccc5780c0735f84dbe9a790badee8245c06c7ca37331cb36980", + "a855babad5cd60c88b430a69f53a1a7a38289154964799be43d06d77d31da06" + ], + [ + "311091dd9860e8e20ee13473c1155f5f69635e394704eaa74009452246cfa9b3", + "66db656f87d1f04fffd1f04788c06830871ec5a64feee685bd80f0b1286d8374" + ], + [ + "34c1fd04d301be89b31c0442d3e6ac24883928b45a9340781867d4232ec2dbdf", + "9414685e97b1b5954bd46f730174136d57f1ceeb487443dc5321857ba73abee" + ], + [ + "f219ea5d6b54701c1c14de5b557eb42a8d13f3abbcd08affcc2a5e6b049b8d63", + "4cb95957e83d40b0f73af4544cccf6b1f4b08d3c07b27fb8d8c2962a400766d1" + ], + [ + "d7b8740f74a8fbaab1f683db8f45de26543a5490bca627087236912469a0b448", + "fa77968128d9c92ee1010f337ad4717eff15db5ed3c049b3411e0315eaa4593b" + ], + [ + "32d31c222f8f6f0ef86f7c98d3a3335ead5bcd32abdd94289fe4d3091aa824bf", + "5f3032f5892156e39ccd3d7915b9e1da2e6dac9e6f26e961118d14b8462e1661" + ], + [ + "7461f371914ab32671045a155d9831ea8793d77cd59592c4340f86cbc18347b5", + "8ec0ba238b96bec0cbdddcae0aa442542eee1ff50c986ea6b39847b3cc092ff6" + ], + [ + "ee079adb1df1860074356a25aa38206a6d716b2c3e67453d287698bad7b2b2d6", + "8dc2412aafe3be5c4c5f37e0ecc5f9f6a446989af04c4e25ebaac479ec1c8c1e" + ], + [ + "16ec93e447ec83f0467b18302ee620f7e65de331874c9dc72bfd8616ba9da6b5", + "5e4631150e62fb40d0e8c2a7ca5804a39d58186a50e497139626778e25b0674d" + ], + [ + "eaa5f980c245f6f038978290afa70b6bd8855897f98b6aa485b96065d537bd99", + "f65f5d3e292c2e0819a528391c994624d784869d7e6ea67fb18041024edc07dc" + ], + [ + "78c9407544ac132692ee1910a02439958ae04877151342ea96c4b6b35a49f51", + "f3e0319169eb9b85d5404795539a5e68fa1fbd583c064d2462b675f194a3ddb4" + ], + [ + "494f4be219a1a77016dcd838431aea0001cdc8ae7a6fc688726578d9702857a5", + "42242a969283a5f339ba7f075e36ba2af925ce30d767ed6e55f4b031880d562c" + ], + [ + "a598a8030da6d86c6bc7f2f5144ea549d28211ea58faa70ebf4c1e665c1fe9b5", + "204b5d6f84822c307e4b4a7140737aec23fc63b65b35f86a10026dbd2d864e6b" + ], + [ + "c41916365abb2b5d09192f5f2dbeafec208f020f12570a184dbadc3e58595997", + "4f14351d0087efa49d245b328984989d5caf9450f34bfc0ed16e96b58fa9913" + ], + [ + "841d6063a586fa475a724604da03bc5b92a2e0d2e0a36acfe4c73a5514742881", + "73867f59c0659e81904f9a1c7543698e62562d6744c169ce7a36de01a8d6154" + ], + [ + "5e95bb399a6971d376026947f89bde2f282b33810928be4ded112ac4d70e20d5", + "39f23f366809085beebfc71181313775a99c9aed7d8ba38b161384c746012865" + ], + [ + "36e4641a53948fd476c39f8a99fd974e5ec07564b5315d8bf99471bca0ef2f66", + "d2424b1b1abe4eb8164227b085c9aa9456ea13493fd563e06fd51cf5694c78fc" + ], + [ + "336581ea7bfbbb290c191a2f507a41cf5643842170e914faeab27c2c579f726", + "ead12168595fe1be99252129b6e56b3391f7ab1410cd1e0ef3dcdcabd2fda224" + ], + [ + "8ab89816dadfd6b6a1f2634fcf00ec8403781025ed6890c4849742706bd43ede", + "6fdcef09f2f6d0a044e654aef624136f503d459c3e89845858a47a9129cdd24e" + ], + [ + "1e33f1a746c9c5778133344d9299fcaa20b0938e8acff2544bb40284b8c5fb94", + "60660257dd11b3aa9c8ed618d24edff2306d320f1d03010e33a7d2057f3b3b6" + ], + [ + "85b7c1dcb3cec1b7ee7f30ded79dd20a0ed1f4cc18cbcfcfa410361fd8f08f31", + "3d98a9cdd026dd43f39048f25a8847f4fcafad1895d7a633c6fed3c35e999511" + ], + [ + "29df9fbd8d9e46509275f4b125d6d45d7fbe9a3b878a7af872a2800661ac5f51", + "b4c4fe99c775a606e2d8862179139ffda61dc861c019e55cd2876eb2a27d84b" + ], + [ + "a0b1cae06b0a847a3fea6e671aaf8adfdfe58ca2f768105c8082b2e449fce252", + "ae434102edde0958ec4b19d917a6a28e6b72da1834aff0e650f049503a296cf2" + ], + [ + "4e8ceafb9b3e9a136dc7ff67e840295b499dfb3b2133e4ba113f2e4c0e121e5", + "cf2174118c8b6d7a4b48f6d534ce5c79422c086a63460502b827ce62a326683c" + ], + [ + "d24a44e047e19b6f5afb81c7ca2f69080a5076689a010919f42725c2b789a33b", + "6fb8d5591b466f8fc63db50f1c0f1c69013f996887b8244d2cdec417afea8fa3" + ], + [ + "ea01606a7a6c9cdd249fdfcfacb99584001edd28abbab77b5104e98e8e3b35d4", + "322af4908c7312b0cfbfe369f7a7b3cdb7d4494bc2823700cfd652188a3ea98d" + ], + [ + "af8addbf2b661c8a6c6328655eb96651252007d8c5ea31be4ad196de8ce2131f", + "6749e67c029b85f52a034eafd096836b2520818680e26ac8f3dfbcdb71749700" + ], + [ + "e3ae1974566ca06cc516d47e0fb165a674a3dabcfca15e722f0e3450f45889", + "2aeabe7e4531510116217f07bf4d07300de97e4874f81f533420a72eeb0bd6a4" + ], + [ + "591ee355313d99721cf6993ffed1e3e301993ff3ed258802075ea8ced397e246", + "b0ea558a113c30bea60fc4775460c7901ff0b053d25ca2bdeee98f1a4be5d196" + ], + [ + "11396d55fda54c49f19aa97318d8da61fa8584e47b084945077cf03255b52984", + "998c74a8cd45ac01289d5833a7beb4744ff536b01b257be4c5767bea93ea57a4" + ], + [ + "3c5d2a1ba39c5a1790000738c9e0c40b8dcdfd5468754b6405540157e017aa7a", + "b2284279995a34e2f9d4de7396fc18b80f9b8b9fdd270f6661f79ca4c81bd257" + ], + [ + "cc8704b8a60a0defa3a99a7299f2e9c3fbc395afb04ac078425ef8a1793cc030", + "bdd46039feed17881d1e0862db347f8cf395b74fc4bcdc4e940b74e3ac1f1b13" + ], + [ + "c533e4f7ea8555aacd9777ac5cad29b97dd4defccc53ee7ea204119b2889b197", + "6f0a256bc5efdf429a2fb6242f1a43a2d9b925bb4a4b3a26bb8e0f45eb596096" + ], + [ + "c14f8f2ccb27d6f109f6d08d03cc96a69ba8c34eec07bbcf566d48e33da6593", + "c359d6923bb398f7fd4473e16fe1c28475b740dd098075e6c0e8649113dc3a38" + ], + [ + "a6cbc3046bc6a450bac24789fa17115a4c9739ed75f8f21ce441f72e0b90e6ef", + "21ae7f4680e889bb130619e2c0f95a360ceb573c70603139862afd617fa9b9f" + ], + [ + "347d6d9a02c48927ebfb86c1359b1caf130a3c0267d11ce6344b39f99d43cc38", + "60ea7f61a353524d1c987f6ecec92f086d565ab687870cb12689ff1e31c74448" + ], + [ + "da6545d2181db8d983f7dcb375ef5866d47c67b1bf31c8cf855ef7437b72656a", + "49b96715ab6878a79e78f07ce5680c5d6673051b4935bd897fea824b77dc208a" + ], + [ + "c40747cc9d012cb1a13b8148309c6de7ec25d6945d657146b9d5994b8feb1111", + "5ca560753be2a12fc6de6caf2cb489565db936156b9514e1bb5e83037e0fa2d4" + ], + [ + "4e42c8ec82c99798ccf3a610be870e78338c7f713348bd34c8203ef4037f3502", + "7571d74ee5e0fb92a7a8b33a07783341a5492144cc54bcc40a94473693606437" + ], + [ + "3775ab7089bc6af823aba2e1af70b236d251cadb0c86743287522a1b3b0dedea", + "be52d107bcfa09d8bcb9736a828cfa7fac8db17bf7a76a2c42ad961409018cf7" + ], + [ + "cee31cbf7e34ec379d94fb814d3d775ad954595d1314ba8846959e3e82f74e26", + "8fd64a14c06b589c26b947ae2bcf6bfa0149ef0be14ed4d80f448a01c43b1c6d" + ], + [ + "b4f9eaea09b6917619f6ea6a4eb5464efddb58fd45b1ebefcdc1a01d08b47986", + "39e5c9925b5a54b07433a4f18c61726f8bb131c012ca542eb24a8ac07200682a" + ], + [ + "d4263dfc3d2df923a0179a48966d30ce84e2515afc3dccc1b77907792ebcc60e", + "62dfaf07a0f78feb30e30d6295853ce189e127760ad6cf7fae164e122a208d54" + ], + [ + "48457524820fa65a4f8d35eb6930857c0032acc0a4a2de422233eeda897612c4", + "25a748ab367979d98733c38a1fa1c2e7dc6cc07db2d60a9ae7a76aaa49bd0f77" + ], + [ + "dfeeef1881101f2cb11644f3a2afdfc2045e19919152923f367a1767c11cceda", + "ecfb7056cf1de042f9420bab396793c0c390bde74b4bbdff16a83ae09a9a7517" + ], + [ + "6d7ef6b17543f8373c573f44e1f389835d89bcbc6062ced36c82df83b8fae859", + "cd450ec335438986dfefa10c57fea9bcc521a0959b2d80bbf74b190dca712d10" + ], + [ + "e75605d59102a5a2684500d3b991f2e3f3c88b93225547035af25af66e04541f", + "f5c54754a8f71ee540b9b48728473e314f729ac5308b06938360990e2bfad125" + ], + [ + "eb98660f4c4dfaa06a2be453d5020bc99a0c2e60abe388457dd43fefb1ed620c", + "6cb9a8876d9cb8520609af3add26cd20a0a7cd8a9411131ce85f44100099223e" + ], + [ + "13e87b027d8514d35939f2e6892b19922154596941888336dc3563e3b8dba942", + "fef5a3c68059a6dec5d624114bf1e91aac2b9da568d6abeb2570d55646b8adf1" + ], + [ + "ee163026e9fd6fe017c38f06a5be6fc125424b371ce2708e7bf4491691e5764a", + "1acb250f255dd61c43d94ccc670d0f58f49ae3fa15b96623e5430da0ad6c62b2" + ], + [ + "b268f5ef9ad51e4d78de3a750c2dc89b1e626d43505867999932e5db33af3d80", + "5f310d4b3c99b9ebb19f77d41c1dee018cf0d34fd4191614003e945a1216e423" + ], + [ + "ff07f3118a9df035e9fad85eb6c7bfe42b02f01ca99ceea3bf7ffdba93c4750d", + "438136d603e858a3a5c440c38eccbaddc1d2942114e2eddd4740d098ced1f0d8" + ], + [ + "8d8b9855c7c052a34146fd20ffb658bea4b9f69e0d825ebec16e8c3ce2b526a1", + "cdb559eedc2d79f926baf44fb84ea4d44bcf50fee51d7ceb30e2e7f463036758" + ], + [ + "52db0b5384dfbf05bfa9d472d7ae26dfe4b851ceca91b1eba54263180da32b63", + "c3b997d050ee5d423ebaf66a6db9f57b3180c902875679de924b69d84a7b375" + ], + [ + "e62f9490d3d51da6395efd24e80919cc7d0f29c3f3fa48c6fff543becbd43352", + "6d89ad7ba4876b0b22c2ca280c682862f342c8591f1daf5170e07bfd9ccafa7d" + ], + [ + "7f30ea2476b399b4957509c88f77d0191afa2ff5cb7b14fd6d8e7d65aaab1193", + "ca5ef7d4b231c94c3b15389a5f6311e9daff7bb67b103e9880ef4bff637acaec" + ], + [ + "5098ff1e1d9f14fb46a210fada6c903fef0fb7b4a1dd1d9ac60a0361800b7a00", + "9731141d81fc8f8084d37c6e7542006b3ee1b40d60dfe5362a5b132fd17ddc0" + ], + [ + "32b78c7de9ee512a72895be6b9cbefa6e2f3c4ccce445c96b9f2c81e2778ad58", + "ee1849f513df71e32efc3896ee28260c73bb80547ae2275ba497237794c8753c" + ], + [ + "e2cb74fddc8e9fbcd076eef2a7c72b0ce37d50f08269dfc074b581550547a4f7", + "d3aa2ed71c9dd2247a62df062736eb0baddea9e36122d2be8641abcb005cc4a4" + ], + [ + "8438447566d4d7bedadc299496ab357426009a35f235cb141be0d99cd10ae3a8", + "c4e1020916980a4da5d01ac5e6ad330734ef0d7906631c4f2390426b2edd791f" + ], + [ + "4162d488b89402039b584c6fc6c308870587d9c46f660b878ab65c82c711d67e", + "67163e903236289f776f22c25fb8a3afc1732f2b84b4e95dbda47ae5a0852649" + ], + [ + "3fad3fa84caf0f34f0f89bfd2dcf54fc175d767aec3e50684f3ba4a4bf5f683d", + "cd1bc7cb6cc407bb2f0ca647c718a730cf71872e7d0d2a53fa20efcdfe61826" + ], + [ + "674f2600a3007a00568c1a7ce05d0816c1fb84bf1370798f1c69532faeb1a86b", + "299d21f9413f33b3edf43b257004580b70db57da0b182259e09eecc69e0d38a5" + ], + [ + "d32f4da54ade74abb81b815ad1fb3b263d82d6c692714bcff87d29bd5ee9f08f", + "f9429e738b8e53b968e99016c059707782e14f4535359d582fc416910b3eea87" + ], + [ + "30e4e670435385556e593657135845d36fbb6931f72b08cb1ed954f1e3ce3ff6", + "462f9bce619898638499350113bbc9b10a878d35da70740dc695a559eb88db7b" + ], + [ + "be2062003c51cc3004682904330e4dee7f3dcd10b01e580bf1971b04d4cad297", + "62188bc49d61e5428573d48a74e1c655b1c61090905682a0d5558ed72dccb9bc" + ], + [ + "93144423ace3451ed29e0fb9ac2af211cb6e84a601df5993c419859fff5df04a", + "7c10dfb164c3425f5c71a3f9d7992038f1065224f72bb9d1d902a6d13037b47c" + ], + [ + "b015f8044f5fcbdcf21ca26d6c34fb8197829205c7b7d2a7cb66418c157b112c", + "ab8c1e086d04e813744a655b2df8d5f83b3cdc6faa3088c1d3aea1454e3a1d5f" + ], + [ + "d5e9e1da649d97d89e4868117a465a3a4f8a18de57a140d36b3f2af341a21b52", + "4cb04437f391ed73111a13cc1d4dd0db1693465c2240480d8955e8592f27447a" + ], + [ + "d3ae41047dd7ca065dbf8ed77b992439983005cd72e16d6f996a5316d36966bb", + "bd1aeb21ad22ebb22a10f0303417c6d964f8cdd7df0aca614b10dc14d125ac46" + ], + [ + "463e2763d885f958fc66cdd22800f0a487197d0a82e377b49f80af87c897b065", + "bfefacdb0e5d0fd7df3a311a94de062b26b80c61fbc97508b79992671ef7ca7f" + ], + [ + "7985fdfd127c0567c6f53ec1bb63ec3158e597c40bfe747c83cddfc910641917", + "603c12daf3d9862ef2b25fe1de289aed24ed291e0ec6708703a5bd567f32ed03" + ], + [ + "74a1ad6b5f76e39db2dd249410eac7f99e74c59cb83d2d0ed5ff1543da7703e9", + "cc6157ef18c9c63cd6193d83631bbea0093e0968942e8c33d5737fd790e0db08" + ], + [ + "30682a50703375f602d416664ba19b7fc9bab42c72747463a71d0896b22f6da3", + "553e04f6b018b4fa6c8f39e7f311d3176290d0e0f19ca73f17714d9977a22ff8" + ], + [ + "9e2158f0d7c0d5f26c3791efefa79597654e7a2b2464f52b1ee6c1347769ef57", + "712fcdd1b9053f09003a3481fa7762e9ffd7c8ef35a38509e2fbf2629008373" + ], + [ + "176e26989a43c9cfeba4029c202538c28172e566e3c4fce7322857f3be327d66", + "ed8cc9d04b29eb877d270b4878dc43c19aefd31f4eee09ee7b47834c1fa4b1c3" + ], + [ + "75d46efea3771e6e68abb89a13ad747ecf1892393dfc4f1b7004788c50374da8", + "9852390a99507679fd0b86fd2b39a868d7efc22151346e1a3ca4726586a6bed8" + ], + [ + "809a20c67d64900ffb698c4c825f6d5f2310fb0451c869345b7319f645605721", + "9e994980d9917e22b76b061927fa04143d096ccc54963e6a5ebfa5f3f8e286c1" + ], + [ + "1b38903a43f7f114ed4500b4eac7083fdefece1cf29c63528d563446f972c180", + "4036edc931a60ae889353f77fd53de4a2708b26b6f5da72ad3394119daf408f9" + ] + ] + } + }; + return secp256k1; +} +var hasRequiredCurves; +function requireCurves() { + if (hasRequiredCurves) return curves; + hasRequiredCurves = 1; + (function(exports2) { + var curves2 = exports2; + var hash2 = requireHash(); + var curve2 = requireCurve(); + var utils2 = requireUtils$1(); + var assert = utils2.assert; + function PresetCurve(options) { + if (options.type === "short") + this.curve = new curve2.short(options); + else if (options.type === "edwards") + this.curve = new curve2.edwards(options); + else + this.curve = new curve2.mont(options); + this.g = this.curve.g; + this.n = this.curve.n; + this.hash = options.hash; + assert(this.g.validate(), "Invalid curve"); + assert(this.g.mul(this.n).isInfinity(), "Invalid curve, G*N != O"); + } + curves2.PresetCurve = PresetCurve; + function defineCurve(name, options) { + Object.defineProperty(curves2, name, { + configurable: true, + enumerable: true, + get: function() { + var curve3 = new PresetCurve(options); + Object.defineProperty(curves2, name, { + configurable: true, + enumerable: true, + value: curve3 + }); + return curve3; + } + }); + } + defineCurve("p192", { + type: "short", + prime: "p192", + p: "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff", + a: "ffffffff ffffffff ffffffff fffffffe ffffffff fffffffc", + b: "64210519 e59c80e7 0fa7e9ab 72243049 feb8deec c146b9b1", + n: "ffffffff ffffffff ffffffff 99def836 146bc9b1 b4d22831", + hash: hash2.sha256, + gRed: false, + g: [ + "188da80e b03090f6 7cbf20eb 43a18800 f4ff0afd 82ff1012", + "07192b95 ffc8da78 631011ed 6b24cdd5 73f977a1 1e794811" + ] + }); + defineCurve("p224", { + type: "short", + prime: "p224", + p: "ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001", + a: "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff fffffffe", + b: "b4050a85 0c04b3ab f5413256 5044b0b7 d7bfd8ba 270b3943 2355ffb4", + n: "ffffffff ffffffff ffffffff ffff16a2 e0b8f03e 13dd2945 5c5c2a3d", + hash: hash2.sha256, + gRed: false, + g: [ + "b70e0cbd 6bb4bf7f 321390b9 4a03c1d3 56c21122 343280d6 115c1d21", + "bd376388 b5f723fb 4c22dfe6 cd4375a0 5a074764 44d58199 85007e34" + ] + }); + defineCurve("p256", { + type: "short", + prime: null, + p: "ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff ffffffff", + a: "ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff fffffffc", + b: "5ac635d8 aa3a93e7 b3ebbd55 769886bc 651d06b0 cc53b0f6 3bce3c3e 27d2604b", + n: "ffffffff 00000000 ffffffff ffffffff bce6faad a7179e84 f3b9cac2 fc632551", + hash: hash2.sha256, + gRed: false, + g: [ + "6b17d1f2 e12c4247 f8bce6e5 63a440f2 77037d81 2deb33a0 f4a13945 d898c296", + "4fe342e2 fe1a7f9b 8ee7eb4a 7c0f9e16 2bce3357 6b315ece cbb64068 37bf51f5" + ] + }); + defineCurve("p384", { + type: "short", + prime: null, + p: "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe ffffffff 00000000 00000000 ffffffff", + a: "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe ffffffff 00000000 00000000 fffffffc", + b: "b3312fa7 e23ee7e4 988e056b e3f82d19 181d9c6e fe814112 0314088f 5013875a c656398d 8a2ed19d 2a85c8ed d3ec2aef", + n: "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff c7634d81 f4372ddf 581a0db2 48b0a77a ecec196a ccc52973", + hash: hash2.sha384, + gRed: false, + g: [ + "aa87ca22 be8b0537 8eb1c71e f320ad74 6e1d3b62 8ba79b98 59f741e0 82542a38 5502f25d bf55296c 3a545e38 72760ab7", + "3617de4a 96262c6f 5d9e98bf 9292dc29 f8f41dbd 289a147c e9da3113 b5f0b8c0 0a60b1ce 1d7e819d 7a431d7c 90ea0e5f" + ] + }); + defineCurve("p521", { + type: "short", + prime: null, + p: "000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff", + a: "000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffc", + b: "00000051 953eb961 8e1c9a1f 929a21a0 b68540ee a2da725b 99b315f3 b8b48991 8ef109e1 56193951 ec7e937b 1652c0bd 3bb1bf07 3573df88 3d2c34f1 ef451fd4 6b503f00", + n: "000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffa 51868783 bf2f966b 7fcc0148 f709a5d0 3bb5c9b8 899c47ae bb6fb71e 91386409", + hash: hash2.sha512, + gRed: false, + g: [ + "000000c6 858e06b7 0404e9cd 9e3ecb66 2395b442 9c648139 053fb521 f828af60 6b4d3dba a14b5e77 efe75928 fe1dc127 a2ffa8de 3348b3c1 856a429b f97e7e31 c2e5bd66", + "00000118 39296a78 9a3bc004 5c8a5fb4 2c7d1bd9 98f54449 579b4468 17afbd17 273e662c 97ee7299 5ef42640 c550b901 3fad0761 353c7086 a272c240 88be9476 9fd16650" + ] + }); + defineCurve("curve25519", { + type: "mont", + prime: "p25519", + p: "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed", + a: "76d06", + b: "1", + n: "1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed", + hash: hash2.sha256, + gRed: false, + g: [ + "9" + ] + }); + defineCurve("ed25519", { + type: "edwards", + prime: "p25519", + p: "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed", + a: "-1", + c: "1", + // -121665 * (121666^(-1)) (mod P) + d: "52036cee2b6ffe73 8cc740797779e898 00700a4d4141d8ab 75eb4dca135978a3", + n: "1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed", + hash: hash2.sha256, + gRed: false, + g: [ + "216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51a", + // 4/5 + "6666666666666666666666666666666666666666666666666666666666666658" + ] + }); + var pre; + try { + pre = requireSecp256k1(); + } catch (e) { + pre = void 0; + } + defineCurve("secp256k1", { + type: "short", + prime: "k256", + p: "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f", + a: "0", + b: "7", + n: "ffffffff ffffffff ffffffff fffffffe baaedce6 af48a03b bfd25e8c d0364141", + h: "1", + hash: hash2.sha256, + // Precomputed endomorphism + beta: "7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee", + lambda: "5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72", + basis: [ + { + a: "3086d221a7d46bcde86c90e49284eb15", + b: "-e4437ed6010e88286f547fa90abfe4c3" + }, + { + a: "114ca50f7a8e2f3f657c1108d9d44cfd8", + b: "3086d221a7d46bcde86c90e49284eb15" + } + ], + gRed: false, + g: [ + "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798", + "483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8", + pre + ] + }); + })(curves); + return curves; +} +var hmacDrbg; +var hasRequiredHmacDrbg; +function requireHmacDrbg() { + if (hasRequiredHmacDrbg) return hmacDrbg; + hasRequiredHmacDrbg = 1; + var hash2 = requireHash(); + var utils2 = requireUtils$2(); + var assert = requireMinimalisticAssert(); + function HmacDRBG(options) { + if (!(this instanceof HmacDRBG)) + return new HmacDRBG(options); + this.hash = options.hash; + this.predResist = !!options.predResist; + this.outLen = this.hash.outSize; + this.minEntropy = options.minEntropy || this.hash.hmacStrength; + this._reseed = null; + this.reseedInterval = null; + this.K = null; + this.V = null; + var entropy = utils2.toArray(options.entropy, options.entropyEnc || "hex"); + var nonce = utils2.toArray(options.nonce, options.nonceEnc || "hex"); + var pers = utils2.toArray(options.pers, options.persEnc || "hex"); + assert( + entropy.length >= this.minEntropy / 8, + "Not enough entropy. Minimum is: " + this.minEntropy + " bits" + ); + this._init(entropy, nonce, pers); + } + hmacDrbg = HmacDRBG; + HmacDRBG.prototype._init = function init(entropy, nonce, pers) { + var seed = entropy.concat(nonce).concat(pers); + this.K = new Array(this.outLen / 8); + this.V = new Array(this.outLen / 8); + for (var i2 = 0; i2 < this.V.length; i2++) { + this.K[i2] = 0; + this.V[i2] = 1; + } + this._update(seed); + this._reseed = 1; + this.reseedInterval = 281474976710656; + }; + HmacDRBG.prototype._hmac = function hmac2() { + return new hash2.hmac(this.hash, this.K); + }; + HmacDRBG.prototype._update = function update(seed) { + var kmac = this._hmac().update(this.V).update([0]); + if (seed) + kmac = kmac.update(seed); + this.K = kmac.digest(); + this.V = this._hmac().update(this.V).digest(); + if (!seed) + return; + this.K = this._hmac().update(this.V).update([1]).update(seed).digest(); + this.V = this._hmac().update(this.V).digest(); + }; + HmacDRBG.prototype.reseed = function reseed(entropy, entropyEnc, add, addEnc) { + if (typeof entropyEnc !== "string") { + addEnc = add; + add = entropyEnc; + entropyEnc = null; + } + entropy = utils2.toArray(entropy, entropyEnc); + add = utils2.toArray(add, addEnc); + assert( + entropy.length >= this.minEntropy / 8, + "Not enough entropy. Minimum is: " + this.minEntropy + " bits" + ); + this._update(entropy.concat(add || [])); + this._reseed = 1; + }; + HmacDRBG.prototype.generate = function generate(len2, enc, add, addEnc) { + if (this._reseed > this.reseedInterval) + throw new Error("Reseed is required"); + if (typeof enc !== "string") { + addEnc = add; + add = enc; + enc = null; + } + if (add) { + add = utils2.toArray(add, addEnc || "hex"); + this._update(add); + } + var temp = []; + while (temp.length < len2) { + this.V = this._hmac().update(this.V).digest(); + temp = temp.concat(this.V); + } + var res = temp.slice(0, len2); + this._update(add); + this._reseed++; + return utils2.encode(res, enc); + }; + return hmacDrbg; +} +var key$1; +var hasRequiredKey$1; +function requireKey$1() { + if (hasRequiredKey$1) return key$1; + hasRequiredKey$1 = 1; + var BN = requireBn$1(); + var utils2 = requireUtils$1(); + var assert = utils2.assert; + function KeyPair(ec2, options) { + this.ec = ec2; + this.priv = null; + this.pub = null; + if (options.priv) + this._importPrivate(options.priv, options.privEnc); + if (options.pub) + this._importPublic(options.pub, options.pubEnc); + } + key$1 = KeyPair; + KeyPair.fromPublic = function fromPublic(ec2, pub, enc) { + if (pub instanceof KeyPair) + return pub; + return new KeyPair(ec2, { + pub, + pubEnc: enc + }); + }; + KeyPair.fromPrivate = function fromPrivate(ec2, priv, enc) { + if (priv instanceof KeyPair) + return priv; + return new KeyPair(ec2, { + priv, + privEnc: enc + }); + }; + KeyPair.prototype.validate = function validate() { + var pub = this.getPublic(); + if (pub.isInfinity()) + return { result: false, reason: "Invalid public key" }; + if (!pub.validate()) + return { result: false, reason: "Public key is not a point" }; + if (!pub.mul(this.ec.curve.n).isInfinity()) + return { result: false, reason: "Public key * N != O" }; + return { result: true, reason: null }; + }; + KeyPair.prototype.getPublic = function getPublic(compact, enc) { + if (typeof compact === "string") { + enc = compact; + compact = null; + } + if (!this.pub) + this.pub = this.ec.g.mul(this.priv); + if (!enc) + return this.pub; + return this.pub.encode(enc, compact); + }; + KeyPair.prototype.getPrivate = function getPrivate(enc) { + if (enc === "hex") + return this.priv.toString(16, 2); + else + return this.priv; + }; + KeyPair.prototype._importPrivate = function _importPrivate(key2, enc) { + this.priv = new BN(key2, enc || 16); + this.priv = this.priv.umod(this.ec.curve.n); + }; + KeyPair.prototype._importPublic = function _importPublic(key2, enc) { + if (key2.x || key2.y) { + if (this.ec.curve.type === "mont") { + assert(key2.x, "Need x coordinate"); + } else if (this.ec.curve.type === "short" || this.ec.curve.type === "edwards") { + assert(key2.x && key2.y, "Need both x and y coordinate"); + } + this.pub = this.ec.curve.point(key2.x, key2.y); + return; + } + this.pub = this.ec.curve.decodePoint(key2, enc); + }; + KeyPair.prototype.derive = function derive(pub) { + if (!pub.validate()) { + assert(pub.validate(), "public point not validated"); + } + return pub.mul(this.priv).getX(); + }; + KeyPair.prototype.sign = function sign2(msg, enc, options) { + return this.ec.sign(msg, this, enc, options); + }; + KeyPair.prototype.verify = function verify(msg, signature2) { + return this.ec.verify(msg, signature2, this); + }; + KeyPair.prototype.inspect = function inspect2() { + return ""; + }; + return key$1; +} +var signature$1; +var hasRequiredSignature$1; +function requireSignature$1() { + if (hasRequiredSignature$1) return signature$1; + hasRequiredSignature$1 = 1; + var BN = requireBn$1(); + var utils2 = requireUtils$1(); + var assert = utils2.assert; + function Signature(options, enc) { + if (options instanceof Signature) + return options; + if (this._importDER(options, enc)) + return; + assert(options.r && options.s, "Signature without r or s"); + this.r = new BN(options.r, 16); + this.s = new BN(options.s, 16); + if (options.recoveryParam === void 0) + this.recoveryParam = null; + else + this.recoveryParam = options.recoveryParam; + } + signature$1 = Signature; + function Position() { + this.place = 0; + } + function getLength(buf, p) { + var initial = buf[p.place++]; + if (!(initial & 128)) { + return initial; + } + var octetLen = initial & 15; + if (octetLen === 0 || octetLen > 4) { + return false; + } + if (buf[p.place] === 0) { + return false; + } + var val = 0; + for (var i2 = 0, off = p.place; i2 < octetLen; i2++, off++) { + val <<= 8; + val |= buf[off]; + val >>>= 0; + } + if (val <= 127) { + return false; + } + p.place = off; + return val; + } + function rmPadding(buf) { + var i2 = 0; + var len2 = buf.length - 1; + while (!buf[i2] && !(buf[i2 + 1] & 128) && i2 < len2) { + i2++; + } + if (i2 === 0) { + return buf; + } + return buf.slice(i2); + } + Signature.prototype._importDER = function _importDER(data, enc) { + data = utils2.toArray(data, enc); + var p = new Position(); + if (data[p.place++] !== 48) { + return false; + } + var len2 = getLength(data, p); + if (len2 === false) { + return false; + } + if (len2 + p.place !== data.length) { + return false; + } + if (data[p.place++] !== 2) { + return false; + } + var rlen = getLength(data, p); + if (rlen === false) { + return false; + } + if ((data[p.place] & 128) !== 0) { + return false; + } + var r = data.slice(p.place, rlen + p.place); + p.place += rlen; + if (data[p.place++] !== 2) { + return false; + } + var slen = getLength(data, p); + if (slen === false) { + return false; + } + if (data.length !== slen + p.place) { + return false; + } + if ((data[p.place] & 128) !== 0) { + return false; + } + var s = data.slice(p.place, slen + p.place); + if (r[0] === 0) { + if (r[1] & 128) { + r = r.slice(1); + } else { + return false; + } + } + if (s[0] === 0) { + if (s[1] & 128) { + s = s.slice(1); + } else { + return false; + } + } + this.r = new BN(r); + this.s = new BN(s); + this.recoveryParam = null; + return true; + }; + function constructLength(arr, len2) { + if (len2 < 128) { + arr.push(len2); + return; + } + var octets = 1 + (Math.log(len2) / Math.LN2 >>> 3); + arr.push(octets | 128); + while (--octets) { + arr.push(len2 >>> (octets << 3) & 255); + } + arr.push(len2); + } + Signature.prototype.toDER = function toDER(enc) { + var r = this.r.toArray(); + var s = this.s.toArray(); + if (r[0] & 128) + r = [0].concat(r); + if (s[0] & 128) + s = [0].concat(s); + r = rmPadding(r); + s = rmPadding(s); + while (!s[0] && !(s[1] & 128)) { + s = s.slice(1); + } + var arr = [2]; + constructLength(arr, r.length); + arr = arr.concat(r); + arr.push(2); + constructLength(arr, s.length); + var backHalf = arr.concat(s); + var res = [48]; + constructLength(res, backHalf.length); + res = res.concat(backHalf); + return utils2.encode(res, enc); + }; + return signature$1; +} +var ec; +var hasRequiredEc; +function requireEc() { + if (hasRequiredEc) return ec; + hasRequiredEc = 1; + var BN = requireBn$1(); + var HmacDRBG = requireHmacDrbg(); + var utils2 = requireUtils$1(); + var curves2 = requireCurves(); + var rand = requireBrorand(); + var assert = utils2.assert; + var KeyPair = requireKey$1(); + var Signature = requireSignature$1(); + function EC(options) { + if (!(this instanceof EC)) + return new EC(options); + if (typeof options === "string") { + assert( + Object.prototype.hasOwnProperty.call(curves2, options), + "Unknown curve " + options + ); + options = curves2[options]; + } + if (options instanceof curves2.PresetCurve) + options = { curve: options }; + this.curve = options.curve.curve; + this.n = this.curve.n; + this.nh = this.n.ushrn(1); + this.g = this.curve.g; + this.g = options.curve.g; + this.g.precompute(options.curve.n.bitLength() + 1); + this.hash = options.hash || options.curve.hash; + } + ec = EC; + EC.prototype.keyPair = function keyPair(options) { + return new KeyPair(this, options); + }; + EC.prototype.keyFromPrivate = function keyFromPrivate(priv, enc) { + return KeyPair.fromPrivate(this, priv, enc); + }; + EC.prototype.keyFromPublic = function keyFromPublic(pub, enc) { + return KeyPair.fromPublic(this, pub, enc); + }; + EC.prototype.genKeyPair = function genKeyPair(options) { + if (!options) + options = {}; + var drbg = new HmacDRBG({ + hash: this.hash, + pers: options.pers, + persEnc: options.persEnc || "utf8", + entropy: options.entropy || rand(this.hash.hmacStrength), + entropyEnc: options.entropy && options.entropyEnc || "utf8", + nonce: this.n.toArray() + }); + var bytes = this.n.byteLength(); + var ns2 = this.n.sub(new BN(2)); + for (; ; ) { + var priv = new BN(drbg.generate(bytes)); + if (priv.cmp(ns2) > 0) + continue; + priv.iaddn(1); + return this.keyFromPrivate(priv); + } + }; + EC.prototype._truncateToN = function _truncateToN(msg, truncOnly) { + var delta = msg.byteLength() * 8 - this.n.bitLength(); + if (delta > 0) + msg = msg.ushrn(delta); + if (!truncOnly && msg.cmp(this.n) >= 0) + return msg.sub(this.n); + else + return msg; + }; + EC.prototype.sign = function sign2(msg, key2, enc, options) { + if (typeof enc === "object") { + options = enc; + enc = null; + } + if (!options) + options = {}; + key2 = this.keyFromPrivate(key2, enc); + msg = this._truncateToN(new BN(msg, 16)); + var bytes = this.n.byteLength(); + var bkey = key2.getPrivate().toArray("be", bytes); + var nonce = msg.toArray("be", bytes); + var drbg = new HmacDRBG({ + hash: this.hash, + entropy: bkey, + nonce, + pers: options.pers, + persEnc: options.persEnc || "utf8" + }); + var ns1 = this.n.sub(new BN(1)); + for (var iter = 0; ; iter++) { + var k = options.k ? options.k(iter) : new BN(drbg.generate(this.n.byteLength())); + k = this._truncateToN(k, true); + if (k.cmpn(1) <= 0 || k.cmp(ns1) >= 0) + continue; + var kp = this.g.mul(k); + if (kp.isInfinity()) + continue; + var kpX = kp.getX(); + var r = kpX.umod(this.n); + if (r.cmpn(0) === 0) + continue; + var s = k.invm(this.n).mul(r.mul(key2.getPrivate()).iadd(msg)); + s = s.umod(this.n); + if (s.cmpn(0) === 0) + continue; + var recoveryParam = (kp.getY().isOdd() ? 1 : 0) | (kpX.cmp(r) !== 0 ? 2 : 0); + if (options.canonical && s.cmp(this.nh) > 0) { + s = this.n.sub(s); + recoveryParam ^= 1; + } + return new Signature({ r, s, recoveryParam }); + } + }; + EC.prototype.verify = function verify(msg, signature2, key2, enc) { + msg = this._truncateToN(new BN(msg, 16)); + key2 = this.keyFromPublic(key2, enc); + signature2 = new Signature(signature2, "hex"); + var r = signature2.r; + var s = signature2.s; + if (r.cmpn(1) < 0 || r.cmp(this.n) >= 0) + return false; + if (s.cmpn(1) < 0 || s.cmp(this.n) >= 0) + return false; + var sinv = s.invm(this.n); + var u1 = sinv.mul(msg).umod(this.n); + var u2 = sinv.mul(r).umod(this.n); + var p; + if (!this.curve._maxwellTrick) { + p = this.g.mulAdd(u1, key2.getPublic(), u2); + if (p.isInfinity()) + return false; + return p.getX().umod(this.n).cmp(r) === 0; + } + p = this.g.jmulAdd(u1, key2.getPublic(), u2); + if (p.isInfinity()) + return false; + return p.eqXToP(r); + }; + EC.prototype.recoverPubKey = function(msg, signature2, j, enc) { + assert((3 & j) === j, "The recovery param is more than two bits"); + signature2 = new Signature(signature2, enc); + var n = this.n; + var e = new BN(msg); + var r = signature2.r; + var s = signature2.s; + var isYOdd = j & 1; + var isSecondKey = j >> 1; + if (r.cmp(this.curve.p.umod(this.curve.n)) >= 0 && isSecondKey) + throw new Error("Unable to find sencond key candinate"); + if (isSecondKey) + r = this.curve.pointFromX(r.add(this.curve.n), isYOdd); + else + r = this.curve.pointFromX(r, isYOdd); + var rInv = signature2.r.invm(n); + var s1 = n.sub(e).mul(rInv).umod(n); + var s2 = s.mul(rInv).umod(n); + return this.g.mulAdd(s1, r, s2); + }; + EC.prototype.getKeyRecoveryParam = function(e, signature2, Q, enc) { + signature2 = new Signature(signature2, enc); + if (signature2.recoveryParam !== null) + return signature2.recoveryParam; + for (var i2 = 0; i2 < 4; i2++) { + var Qprime; + try { + Qprime = this.recoverPubKey(e, signature2, i2); + } catch (e2) { + continue; + } + if (Qprime.eq(Q)) + return i2; + } + throw new Error("Unable to find valid recovery factor"); + }; + return ec; +} +var key; +var hasRequiredKey; +function requireKey() { + if (hasRequiredKey) return key; + hasRequiredKey = 1; + var utils2 = requireUtils$1(); + var assert = utils2.assert; + var parseBytes = utils2.parseBytes; + var cachedProperty = utils2.cachedProperty; + function KeyPair(eddsa2, params) { + this.eddsa = eddsa2; + this._secret = parseBytes(params.secret); + if (eddsa2.isPoint(params.pub)) + this._pub = params.pub; + else + this._pubBytes = parseBytes(params.pub); + } + KeyPair.fromPublic = function fromPublic(eddsa2, pub) { + if (pub instanceof KeyPair) + return pub; + return new KeyPair(eddsa2, { pub }); + }; + KeyPair.fromSecret = function fromSecret(eddsa2, secret) { + if (secret instanceof KeyPair) + return secret; + return new KeyPair(eddsa2, { secret }); + }; + KeyPair.prototype.secret = function secret() { + return this._secret; + }; + cachedProperty(KeyPair, "pubBytes", function pubBytes() { + return this.eddsa.encodePoint(this.pub()); + }); + cachedProperty(KeyPair, "pub", function pub() { + if (this._pubBytes) + return this.eddsa.decodePoint(this._pubBytes); + return this.eddsa.g.mul(this.priv()); + }); + cachedProperty(KeyPair, "privBytes", function privBytes() { + var eddsa2 = this.eddsa; + var hash2 = this.hash(); + var lastIx = eddsa2.encodingLength - 1; + var a = hash2.slice(0, eddsa2.encodingLength); + a[0] &= 248; + a[lastIx] &= 127; + a[lastIx] |= 64; + return a; + }); + cachedProperty(KeyPair, "priv", function priv() { + return this.eddsa.decodeInt(this.privBytes()); + }); + cachedProperty(KeyPair, "hash", function hash2() { + return this.eddsa.hash().update(this.secret()).digest(); + }); + cachedProperty(KeyPair, "messagePrefix", function messagePrefix() { + return this.hash().slice(this.eddsa.encodingLength); + }); + KeyPair.prototype.sign = function sign2(message) { + assert(this._secret, "KeyPair can only verify"); + return this.eddsa.sign(message, this); + }; + KeyPair.prototype.verify = function verify(message, sig) { + return this.eddsa.verify(message, sig, this); + }; + KeyPair.prototype.getSecret = function getSecret(enc) { + assert(this._secret, "KeyPair is public only"); + return utils2.encode(this.secret(), enc); + }; + KeyPair.prototype.getPublic = function getPublic(enc) { + return utils2.encode(this.pubBytes(), enc); + }; + key = KeyPair; + return key; +} +var signature; +var hasRequiredSignature; +function requireSignature() { + if (hasRequiredSignature) return signature; + hasRequiredSignature = 1; + var BN = requireBn$1(); + var utils2 = requireUtils$1(); + var assert = utils2.assert; + var cachedProperty = utils2.cachedProperty; + var parseBytes = utils2.parseBytes; + function Signature(eddsa2, sig) { + this.eddsa = eddsa2; + if (typeof sig !== "object") + sig = parseBytes(sig); + if (Array.isArray(sig)) { + assert(sig.length === eddsa2.encodingLength * 2, "Signature has invalid size"); + sig = { + R: sig.slice(0, eddsa2.encodingLength), + S: sig.slice(eddsa2.encodingLength) + }; + } + assert(sig.R && sig.S, "Signature without R or S"); + if (eddsa2.isPoint(sig.R)) + this._R = sig.R; + if (sig.S instanceof BN) + this._S = sig.S; + this._Rencoded = Array.isArray(sig.R) ? sig.R : sig.Rencoded; + this._Sencoded = Array.isArray(sig.S) ? sig.S : sig.Sencoded; + } + cachedProperty(Signature, "S", function S() { + return this.eddsa.decodeInt(this.Sencoded()); + }); + cachedProperty(Signature, "R", function R() { + return this.eddsa.decodePoint(this.Rencoded()); + }); + cachedProperty(Signature, "Rencoded", function Rencoded() { + return this.eddsa.encodePoint(this.R()); + }); + cachedProperty(Signature, "Sencoded", function Sencoded() { + return this.eddsa.encodeInt(this.S()); + }); + Signature.prototype.toBytes = function toBytes() { + return this.Rencoded().concat(this.Sencoded()); + }; + Signature.prototype.toHex = function toHex() { + return utils2.encode(this.toBytes(), "hex").toUpperCase(); + }; + signature = Signature; + return signature; +} +var eddsa; +var hasRequiredEddsa; +function requireEddsa() { + if (hasRequiredEddsa) return eddsa; + hasRequiredEddsa = 1; + var hash2 = requireHash(); + var curves2 = requireCurves(); + var utils2 = requireUtils$1(); + var assert = utils2.assert; + var parseBytes = utils2.parseBytes; + var KeyPair = requireKey(); + var Signature = requireSignature(); + function EDDSA(curve2) { + assert(curve2 === "ed25519", "only tested with ed25519 so far"); + if (!(this instanceof EDDSA)) + return new EDDSA(curve2); + curve2 = curves2[curve2].curve; + this.curve = curve2; + this.g = curve2.g; + this.g.precompute(curve2.n.bitLength() + 1); + this.pointClass = curve2.point().constructor; + this.encodingLength = Math.ceil(curve2.n.bitLength() / 8); + this.hash = hash2.sha512; + } + eddsa = EDDSA; + EDDSA.prototype.sign = function sign2(message, secret) { + message = parseBytes(message); + var key2 = this.keyFromSecret(secret); + var r = this.hashInt(key2.messagePrefix(), message); + var R = this.g.mul(r); + var Rencoded = this.encodePoint(R); + var s_ = this.hashInt(Rencoded, key2.pubBytes(), message).mul(key2.priv()); + var S = r.add(s_).umod(this.curve.n); + return this.makeSignature({ R, S, Rencoded }); + }; + EDDSA.prototype.verify = function verify(message, sig, pub) { + message = parseBytes(message); + sig = this.makeSignature(sig); + if (sig.S().gte(sig.eddsa.curve.n) || sig.S().isNeg()) { + return false; + } + var key2 = this.keyFromPublic(pub); + var h = this.hashInt(sig.Rencoded(), key2.pubBytes(), message); + var SG = this.g.mul(sig.S()); + var RplusAh = sig.R().add(key2.pub().mul(h)); + return RplusAh.eq(SG); + }; + EDDSA.prototype.hashInt = function hashInt() { + var hash3 = this.hash(); + for (var i2 = 0; i2 < arguments.length; i2++) + hash3.update(arguments[i2]); + return utils2.intFromLE(hash3.digest()).umod(this.curve.n); + }; + EDDSA.prototype.keyFromPublic = function keyFromPublic(pub) { + return KeyPair.fromPublic(this, pub); + }; + EDDSA.prototype.keyFromSecret = function keyFromSecret(secret) { + return KeyPair.fromSecret(this, secret); + }; + EDDSA.prototype.makeSignature = function makeSignature(sig) { + if (sig instanceof Signature) + return sig; + return new Signature(this, sig); + }; + EDDSA.prototype.encodePoint = function encodePoint(point) { + var enc = point.getY().toArray("le", this.encodingLength); + enc[this.encodingLength - 1] |= point.getX().isOdd() ? 128 : 0; + return enc; + }; + EDDSA.prototype.decodePoint = function decodePoint(bytes) { + bytes = utils2.parseBytes(bytes); + var lastIx = bytes.length - 1; + var normed = bytes.slice(0, lastIx).concat(bytes[lastIx] & -129); + var xIsOdd = (bytes[lastIx] & 128) !== 0; + var y = utils2.intFromLE(normed); + return this.curve.pointFromY(y, xIsOdd); + }; + EDDSA.prototype.encodeInt = function encodeInt(num) { + return num.toArray("le", this.encodingLength); + }; + EDDSA.prototype.decodeInt = function decodeInt(bytes) { + return utils2.intFromLE(bytes); + }; + EDDSA.prototype.isPoint = function isPoint(val) { + return val instanceof this.pointClass; + }; + return eddsa; +} +var hasRequiredElliptic; +function requireElliptic() { + if (hasRequiredElliptic) return elliptic; + hasRequiredElliptic = 1; + (function(exports2) { + var elliptic2 = exports2; + elliptic2.version = require$$0.version; + elliptic2.utils = requireUtils$1(); + elliptic2.rand = requireBrorand(); + elliptic2.curve = requireCurve(); + elliptic2.curves = requireCurves(); + elliptic2.ec = requireEc(); + elliptic2.eddsa = requireEddsa(); + })(elliptic); + return elliptic; +} +var asn1$1 = {}; +var asn1 = {}; +var api = {}; +var vmBrowserify = {}; +var hasRequiredVmBrowserify; +function requireVmBrowserify() { + if (hasRequiredVmBrowserify) return vmBrowserify; + hasRequiredVmBrowserify = 1; + (function(exports) { + var indexOf = function(xs, item) { + if (xs.indexOf) return xs.indexOf(item); + else for (var i2 = 0; i2 < xs.length; i2++) { + if (xs[i2] === item) return i2; + } + return -1; + }; + var Object_keys = function(obj) { + if (Object.keys) return Object.keys(obj); + else { + var res = []; + for (var key2 in obj) res.push(key2); + return res; + } + }; + var forEach = function(xs, fn) { + if (xs.forEach) return xs.forEach(fn); + else for (var i2 = 0; i2 < xs.length; i2++) { + fn(xs[i2], i2, xs); + } + }; + var defineProp = function() { + try { + Object.defineProperty({}, "_", {}); + return function(obj, name, value) { + Object.defineProperty(obj, name, { + writable: true, + enumerable: false, + configurable: true, + value + }); + }; + } catch (e) { + return function(obj, name, value) { + obj[name] = value; + }; + } + }(); + var globals = [ + "Array", + "Boolean", + "Date", + "Error", + "EvalError", + "Function", + "Infinity", + "JSON", + "Math", + "NaN", + "Number", + "Object", + "RangeError", + "ReferenceError", + "RegExp", + "String", + "SyntaxError", + "TypeError", + "URIError", + "decodeURI", + "decodeURIComponent", + "encodeURI", + "encodeURIComponent", + "escape", + "eval", + "isFinite", + "isNaN", + "parseFloat", + "parseInt", + "undefined", + "unescape" + ]; + function Context() { + } + Context.prototype = {}; + var Script = exports.Script = function NodeScript(code2) { + if (!(this instanceof Script)) return new Script(code2); + this.code = code2; + }; + Script.prototype.runInContext = function(context) { + if (!(context instanceof Context)) { + throw new TypeError("needs a 'context' argument."); + } + var iframe = document.createElement("iframe"); + if (!iframe.style) iframe.style = {}; + iframe.style.display = "none"; + document.body.appendChild(iframe); + var win = iframe.contentWindow; + var wEval = win.eval, wExecScript = win.execScript; + if (!wEval && wExecScript) { + wExecScript.call(win, "null"); + wEval = win.eval; + } + forEach(Object_keys(context), function(key2) { + win[key2] = context[key2]; + }); + forEach(globals, function(key2) { + if (context[key2]) { + win[key2] = context[key2]; + } + }); + var winKeys = Object_keys(win); + var res = wEval.call(win, this.code); + forEach(Object_keys(win), function(key2) { + if (key2 in context || indexOf(winKeys, key2) === -1) { + context[key2] = win[key2]; + } + }); + forEach(globals, function(key2) { + if (!(key2 in context)) { + defineProp(context, key2, win[key2]); + } + }); + document.body.removeChild(iframe); + return res; + }; + Script.prototype.runInThisContext = function() { + return eval(this.code); + }; + Script.prototype.runInNewContext = function(context) { + var ctx = Script.createContext(context); + var res = this.runInContext(ctx); + if (context) { + forEach(Object_keys(ctx), function(key2) { + context[key2] = ctx[key2]; + }); + } + return res; + }; + forEach(Object_keys(Script.prototype), function(name) { + exports[name] = Script[name] = function(code2) { + var s = Script(code2); + return s[name].apply(s, [].slice.call(arguments, 1)); + }; + }); + exports.isContext = function(context) { + return context instanceof Context; + }; + exports.createScript = function(code2) { + return exports.Script(code2); + }; + exports.createContext = Script.createContext = function(context) { + var copy = new Context(); + if (typeof context === "object") { + forEach(Object_keys(context), function(key2) { + copy[key2] = context[key2]; + }); + } + return copy; + }; + })(vmBrowserify); + return vmBrowserify; +} +var hasRequiredApi; +function requireApi() { + if (hasRequiredApi) return api; + hasRequiredApi = 1; + (function(exports2) { + var asn12 = requireAsn1$1(); + var inherits = requireInherits_browser(); + var api2 = exports2; + api2.define = function define(name, body) { + return new Entity(name, body); + }; + function Entity(name, body) { + this.name = name; + this.body = body; + this.decoders = {}; + this.encoders = {}; + } + Entity.prototype._createNamed = function createNamed(base2) { + var named; + try { + named = requireVmBrowserify().runInThisContext( + "(function " + this.name + "(entity) {\n this._initNamed(entity);\n})" + ); + } catch (e) { + named = function(entity) { + this._initNamed(entity); + }; + } + inherits(named, base2); + named.prototype._initNamed = function initnamed(entity) { + base2.call(this, entity); + }; + return new named(this); + }; + Entity.prototype._getDecoder = function _getDecoder(enc) { + enc = enc || "der"; + if (!this.decoders.hasOwnProperty(enc)) + this.decoders[enc] = this._createNamed(asn12.decoders[enc]); + return this.decoders[enc]; + }; + Entity.prototype.decode = function decode(data, enc, options) { + return this._getDecoder(enc).decode(data, options); + }; + Entity.prototype._getEncoder = function _getEncoder(enc) { + enc = enc || "der"; + if (!this.encoders.hasOwnProperty(enc)) + this.encoders[enc] = this._createNamed(asn12.encoders[enc]); + return this.encoders[enc]; + }; + Entity.prototype.encode = function encode(data, enc, reporter2) { + return this._getEncoder(enc).encode(data, reporter2); + }; + })(api); + return api; +} +var base = {}; +var reporter = {}; +var hasRequiredReporter; +function requireReporter() { + if (hasRequiredReporter) return reporter; + hasRequiredReporter = 1; + var inherits = requireInherits_browser(); + function Reporter(options) { + this._reporterState = { + obj: null, + path: [], + options: options || {}, + errors: [] + }; + } + reporter.Reporter = Reporter; + Reporter.prototype.isError = function isError(obj) { + return obj instanceof ReporterError; + }; + Reporter.prototype.save = function save() { + var state2 = this._reporterState; + return { obj: state2.obj, pathLen: state2.path.length }; + }; + Reporter.prototype.restore = function restore(data) { + var state2 = this._reporterState; + state2.obj = data.obj; + state2.path = state2.path.slice(0, data.pathLen); + }; + Reporter.prototype.enterKey = function enterKey(key2) { + return this._reporterState.path.push(key2); + }; + Reporter.prototype.exitKey = function exitKey(index) { + var state2 = this._reporterState; + state2.path = state2.path.slice(0, index - 1); + }; + Reporter.prototype.leaveKey = function leaveKey(index, key2, value) { + var state2 = this._reporterState; + this.exitKey(index); + if (state2.obj !== null) + state2.obj[key2] = value; + }; + Reporter.prototype.path = function path() { + return this._reporterState.path.join("/"); + }; + Reporter.prototype.enterObject = function enterObject() { + var state2 = this._reporterState; + var prev = state2.obj; + state2.obj = {}; + return prev; + }; + Reporter.prototype.leaveObject = function leaveObject(prev) { + var state2 = this._reporterState; + var now = state2.obj; + state2.obj = prev; + return now; + }; + Reporter.prototype.error = function error(msg) { + var err; + var state2 = this._reporterState; + var inherited = msg instanceof ReporterError; + if (inherited) { + err = msg; + } else { + err = new ReporterError(state2.path.map(function(elem) { + return "[" + JSON.stringify(elem) + "]"; + }).join(""), msg.message || msg, msg.stack); + } + if (!state2.options.partial) + throw err; + if (!inherited) + state2.errors.push(err); + return err; + }; + Reporter.prototype.wrapResult = function wrapResult(result) { + var state2 = this._reporterState; + if (!state2.options.partial) + return result; + return { + result: this.isError(result) ? null : result, + errors: state2.errors + }; + }; + function ReporterError(path, msg) { + this.path = path; + this.rethrow(msg); + } + inherits(ReporterError, Error); + ReporterError.prototype.rethrow = function rethrow(msg) { + this.message = msg + " at: " + (this.path || "(shallow)"); + if (Error.captureStackTrace) + Error.captureStackTrace(this, ReporterError); + if (!this.stack) { + try { + throw new Error(this.message); + } catch (e) { + this.stack = e.stack; + } + } + return this; + }; + return reporter; +} +var buffer = {}; +var hasRequiredBuffer; +function requireBuffer() { + if (hasRequiredBuffer) return buffer; + hasRequiredBuffer = 1; + var inherits = requireInherits_browser(); + var Reporter = requireBase().Reporter; + var Buffer2 = requireDist().Buffer; + function DecoderBuffer(base2, options) { + Reporter.call(this, options); + if (!Buffer2.isBuffer(base2)) { + this.error("Input not Buffer"); + return; + } + this.base = base2; + this.offset = 0; + this.length = base2.length; + } + inherits(DecoderBuffer, Reporter); + buffer.DecoderBuffer = DecoderBuffer; + DecoderBuffer.prototype.save = function save() { + return { offset: this.offset, reporter: Reporter.prototype.save.call(this) }; + }; + DecoderBuffer.prototype.restore = function restore(save) { + var res = new DecoderBuffer(this.base); + res.offset = save.offset; + res.length = this.offset; + this.offset = save.offset; + Reporter.prototype.restore.call(this, save.reporter); + return res; + }; + DecoderBuffer.prototype.isEmpty = function isEmpty() { + return this.offset === this.length; + }; + DecoderBuffer.prototype.readUInt8 = function readUInt8(fail) { + if (this.offset + 1 <= this.length) + return this.base.readUInt8(this.offset++, true); + else + return this.error(fail || "DecoderBuffer overrun"); + }; + DecoderBuffer.prototype.skip = function skip(bytes, fail) { + if (!(this.offset + bytes <= this.length)) + return this.error(fail || "DecoderBuffer overrun"); + var res = new DecoderBuffer(this.base); + res._reporterState = this._reporterState; + res.offset = this.offset; + res.length = this.offset + bytes; + this.offset += bytes; + return res; + }; + DecoderBuffer.prototype.raw = function raw(save) { + return this.base.slice(save ? save.offset : this.offset, this.length); + }; + function EncoderBuffer(value, reporter2) { + if (Array.isArray(value)) { + this.length = 0; + this.value = value.map(function(item) { + if (!(item instanceof EncoderBuffer)) + item = new EncoderBuffer(item, reporter2); + this.length += item.length; + return item; + }, this); + } else if (typeof value === "number") { + if (!(0 <= value && value <= 255)) + return reporter2.error("non-byte EncoderBuffer value"); + this.value = value; + this.length = 1; + } else if (typeof value === "string") { + this.value = value; + this.length = Buffer2.byteLength(value); + } else if (Buffer2.isBuffer(value)) { + this.value = value; + this.length = value.length; + } else { + return reporter2.error("Unsupported type: " + typeof value); + } + } + buffer.EncoderBuffer = EncoderBuffer; + EncoderBuffer.prototype.join = function join2(out, offset) { + if (!out) + out = new Buffer2(this.length); + if (!offset) + offset = 0; + if (this.length === 0) + return out; + if (Array.isArray(this.value)) { + this.value.forEach(function(item) { + item.join(out, offset); + offset += item.length; + }); + } else { + if (typeof this.value === "number") + out[offset] = this.value; + else if (typeof this.value === "string") + out.write(this.value, offset); + else if (Buffer2.isBuffer(this.value)) + this.value.copy(out, offset); + offset += this.length; + } + return out; + }; + return buffer; +} +var node; +var hasRequiredNode; +function requireNode() { + if (hasRequiredNode) return node; + hasRequiredNode = 1; + var Reporter = requireBase().Reporter; + var EncoderBuffer = requireBase().EncoderBuffer; + var DecoderBuffer = requireBase().DecoderBuffer; + var assert = requireMinimalisticAssert(); + var tags = [ + "seq", + "seqof", + "set", + "setof", + "objid", + "bool", + "gentime", + "utctime", + "null_", + "enum", + "int", + "objDesc", + "bitstr", + "bmpstr", + "charstr", + "genstr", + "graphstr", + "ia5str", + "iso646str", + "numstr", + "octstr", + "printstr", + "t61str", + "unistr", + "utf8str", + "videostr" + ]; + var methods = [ + "key", + "obj", + "use", + "optional", + "explicit", + "implicit", + "def", + "choice", + "any", + "contains" + ].concat(tags); + var overrided = [ + "_peekTag", + "_decodeTag", + "_use", + "_decodeStr", + "_decodeObjid", + "_decodeTime", + "_decodeNull", + "_decodeInt", + "_decodeBool", + "_decodeList", + "_encodeComposite", + "_encodeStr", + "_encodeObjid", + "_encodeTime", + "_encodeNull", + "_encodeInt", + "_encodeBool" + ]; + function Node(enc, parent) { + var state2 = {}; + this._baseState = state2; + state2.enc = enc; + state2.parent = parent || null; + state2.children = null; + state2.tag = null; + state2.args = null; + state2.reverseArgs = null; + state2.choice = null; + state2.optional = false; + state2.any = false; + state2.obj = false; + state2.use = null; + state2.useDecoder = null; + state2.key = null; + state2["default"] = null; + state2.explicit = null; + state2.implicit = null; + state2.contains = null; + if (!state2.parent) { + state2.children = []; + this._wrap(); + } + } + node = Node; + var stateProps = [ + "enc", + "parent", + "children", + "tag", + "args", + "reverseArgs", + "choice", + "optional", + "any", + "obj", + "use", + "alteredUse", + "key", + "default", + "explicit", + "implicit", + "contains" + ]; + Node.prototype.clone = function clone() { + var state2 = this._baseState; + var cstate = {}; + stateProps.forEach(function(prop) { + cstate[prop] = state2[prop]; + }); + var res = new this.constructor(cstate.parent); + res._baseState = cstate; + return res; + }; + Node.prototype._wrap = function wrap2() { + var state2 = this._baseState; + methods.forEach(function(method) { + this[method] = function _wrappedMethod() { + var clone = new this.constructor(this); + state2.children.push(clone); + return clone[method].apply(clone, arguments); + }; + }, this); + }; + Node.prototype._init = function init(body) { + var state2 = this._baseState; + assert(state2.parent === null); + body.call(this); + state2.children = state2.children.filter(function(child) { + return child._baseState.parent === this; + }, this); + assert.equal(state2.children.length, 1, "Root node can have only one child"); + }; + Node.prototype._useArgs = function useArgs(args) { + var state2 = this._baseState; + var children = args.filter(function(arg) { + return arg instanceof this.constructor; + }, this); + args = args.filter(function(arg) { + return !(arg instanceof this.constructor); + }, this); + if (children.length !== 0) { + assert(state2.children === null); + state2.children = children; + children.forEach(function(child) { + child._baseState.parent = this; + }, this); + } + if (args.length !== 0) { + assert(state2.args === null); + state2.args = args; + state2.reverseArgs = args.map(function(arg) { + if (typeof arg !== "object" || arg.constructor !== Object) + return arg; + var res = {}; + Object.keys(arg).forEach(function(key2) { + if (key2 == (key2 | 0)) + key2 |= 0; + var value = arg[key2]; + res[value] = key2; + }); + return res; + }); + } + }; + overrided.forEach(function(method) { + Node.prototype[method] = function _overrided() { + var state2 = this._baseState; + throw new Error(method + " not implemented for encoding: " + state2.enc); + }; + }); + tags.forEach(function(tag) { + Node.prototype[tag] = function _tagMethod() { + var state2 = this._baseState; + var args = Array.prototype.slice.call(arguments); + assert(state2.tag === null); + state2.tag = tag; + this._useArgs(args); + return this; + }; + }); + Node.prototype.use = function use(item) { + assert(item); + var state2 = this._baseState; + assert(state2.use === null); + state2.use = item; + return this; + }; + Node.prototype.optional = function optional() { + var state2 = this._baseState; + state2.optional = true; + return this; + }; + Node.prototype.def = function def(val) { + var state2 = this._baseState; + assert(state2["default"] === null); + state2["default"] = val; + state2.optional = true; + return this; + }; + Node.prototype.explicit = function explicit(num) { + var state2 = this._baseState; + assert(state2.explicit === null && state2.implicit === null); + state2.explicit = num; + return this; + }; + Node.prototype.implicit = function implicit(num) { + var state2 = this._baseState; + assert(state2.explicit === null && state2.implicit === null); + state2.implicit = num; + return this; + }; + Node.prototype.obj = function obj() { + var state2 = this._baseState; + var args = Array.prototype.slice.call(arguments); + state2.obj = true; + if (args.length !== 0) + this._useArgs(args); + return this; + }; + Node.prototype.key = function key2(newKey) { + var state2 = this._baseState; + assert(state2.key === null); + state2.key = newKey; + return this; + }; + Node.prototype.any = function any() { + var state2 = this._baseState; + state2.any = true; + return this; + }; + Node.prototype.choice = function choice(obj) { + var state2 = this._baseState; + assert(state2.choice === null); + state2.choice = obj; + this._useArgs(Object.keys(obj).map(function(key2) { + return obj[key2]; + })); + return this; + }; + Node.prototype.contains = function contains(item) { + var state2 = this._baseState; + assert(state2.use === null); + state2.contains = item; + return this; + }; + Node.prototype._decode = function decode(input, options) { + var state2 = this._baseState; + if (state2.parent === null) + return input.wrapResult(state2.children[0]._decode(input, options)); + var result = state2["default"]; + var present = true; + var prevKey = null; + if (state2.key !== null) + prevKey = input.enterKey(state2.key); + if (state2.optional) { + var tag = null; + if (state2.explicit !== null) + tag = state2.explicit; + else if (state2.implicit !== null) + tag = state2.implicit; + else if (state2.tag !== null) + tag = state2.tag; + if (tag === null && !state2.any) { + var save = input.save(); + try { + if (state2.choice === null) + this._decodeGeneric(state2.tag, input, options); + else + this._decodeChoice(input, options); + present = true; + } catch (e) { + present = false; + } + input.restore(save); + } else { + present = this._peekTag(input, tag, state2.any); + if (input.isError(present)) + return present; + } + } + var prevObj; + if (state2.obj && present) + prevObj = input.enterObject(); + if (present) { + if (state2.explicit !== null) { + var explicit = this._decodeTag(input, state2.explicit); + if (input.isError(explicit)) + return explicit; + input = explicit; + } + var start = input.offset; + if (state2.use === null && state2.choice === null) { + if (state2.any) + var save = input.save(); + var body = this._decodeTag( + input, + state2.implicit !== null ? state2.implicit : state2.tag, + state2.any + ); + if (input.isError(body)) + return body; + if (state2.any) + result = input.raw(save); + else + input = body; + } + if (options && options.track && state2.tag !== null) + options.track(input.path(), start, input.length, "tagged"); + if (options && options.track && state2.tag !== null) + options.track(input.path(), input.offset, input.length, "content"); + if (state2.any) + result = result; + else if (state2.choice === null) + result = this._decodeGeneric(state2.tag, input, options); + else + result = this._decodeChoice(input, options); + if (input.isError(result)) + return result; + if (!state2.any && state2.choice === null && state2.children !== null) { + state2.children.forEach(function decodeChildren(child) { + child._decode(input, options); + }); + } + if (state2.contains && (state2.tag === "octstr" || state2.tag === "bitstr")) { + var data = new DecoderBuffer(result); + result = this._getUse(state2.contains, input._reporterState.obj)._decode(data, options); + } + } + if (state2.obj && present) + result = input.leaveObject(prevObj); + if (state2.key !== null && (result !== null || present === true)) + input.leaveKey(prevKey, state2.key, result); + else if (prevKey !== null) + input.exitKey(prevKey); + return result; + }; + Node.prototype._decodeGeneric = function decodeGeneric(tag, input, options) { + var state2 = this._baseState; + if (tag === "seq" || tag === "set") + return null; + if (tag === "seqof" || tag === "setof") + return this._decodeList(input, tag, state2.args[0], options); + else if (/str$/.test(tag)) + return this._decodeStr(input, tag, options); + else if (tag === "objid" && state2.args) + return this._decodeObjid(input, state2.args[0], state2.args[1], options); + else if (tag === "objid") + return this._decodeObjid(input, null, null, options); + else if (tag === "gentime" || tag === "utctime") + return this._decodeTime(input, tag, options); + else if (tag === "null_") + return this._decodeNull(input, options); + else if (tag === "bool") + return this._decodeBool(input, options); + else if (tag === "objDesc") + return this._decodeStr(input, tag, options); + else if (tag === "int" || tag === "enum") + return this._decodeInt(input, state2.args && state2.args[0], options); + if (state2.use !== null) { + return this._getUse(state2.use, input._reporterState.obj)._decode(input, options); + } else { + return input.error("unknown tag: " + tag); + } + }; + Node.prototype._getUse = function _getUse(entity, obj) { + var state2 = this._baseState; + state2.useDecoder = this._use(entity, obj); + assert(state2.useDecoder._baseState.parent === null); + state2.useDecoder = state2.useDecoder._baseState.children[0]; + if (state2.implicit !== state2.useDecoder._baseState.implicit) { + state2.useDecoder = state2.useDecoder.clone(); + state2.useDecoder._baseState.implicit = state2.implicit; + } + return state2.useDecoder; + }; + Node.prototype._decodeChoice = function decodeChoice(input, options) { + var state2 = this._baseState; + var result = null; + var match = false; + Object.keys(state2.choice).some(function(key2) { + var save = input.save(); + var node2 = state2.choice[key2]; + try { + var value = node2._decode(input, options); + if (input.isError(value)) + return false; + result = { type: key2, value }; + match = true; + } catch (e) { + input.restore(save); + return false; + } + return true; + }, this); + if (!match) + return input.error("Choice not matched"); + return result; + }; + Node.prototype._createEncoderBuffer = function createEncoderBuffer(data) { + return new EncoderBuffer(data, this.reporter); + }; + Node.prototype._encode = function encode(data, reporter2, parent) { + var state2 = this._baseState; + if (state2["default"] !== null && state2["default"] === data) + return; + var result = this._encodeValue(data, reporter2, parent); + if (result === void 0) + return; + if (this._skipDefault(result, reporter2, parent)) + return; + return result; + }; + Node.prototype._encodeValue = function encode(data, reporter2, parent) { + var state2 = this._baseState; + if (state2.parent === null) + return state2.children[0]._encode(data, reporter2 || new Reporter()); + var result = null; + this.reporter = reporter2; + if (state2.optional && data === void 0) { + if (state2["default"] !== null) + data = state2["default"]; + else + return; + } + var content = null; + var primitive = false; + if (state2.any) { + result = this._createEncoderBuffer(data); + } else if (state2.choice) { + result = this._encodeChoice(data, reporter2); + } else if (state2.contains) { + content = this._getUse(state2.contains, parent)._encode(data, reporter2); + primitive = true; + } else if (state2.children) { + content = state2.children.map(function(child2) { + if (child2._baseState.tag === "null_") + return child2._encode(null, reporter2, data); + if (child2._baseState.key === null) + return reporter2.error("Child should have a key"); + var prevKey = reporter2.enterKey(child2._baseState.key); + if (typeof data !== "object") + return reporter2.error("Child expected, but input is not object"); + var res = child2._encode(data[child2._baseState.key], reporter2, data); + reporter2.leaveKey(prevKey); + return res; + }, this).filter(function(child2) { + return child2; + }); + content = this._createEncoderBuffer(content); + } else { + if (state2.tag === "seqof" || state2.tag === "setof") { + if (!(state2.args && state2.args.length === 1)) + return reporter2.error("Too many args for : " + state2.tag); + if (!Array.isArray(data)) + return reporter2.error("seqof/setof, but data is not Array"); + var child = this.clone(); + child._baseState.implicit = null; + content = this._createEncoderBuffer(data.map(function(item) { + var state3 = this._baseState; + return this._getUse(state3.args[0], data)._encode(item, reporter2); + }, child)); + } else if (state2.use !== null) { + result = this._getUse(state2.use, parent)._encode(data, reporter2); + } else { + content = this._encodePrimitive(state2.tag, data); + primitive = true; + } + } + var result; + if (!state2.any && state2.choice === null) { + var tag = state2.implicit !== null ? state2.implicit : state2.tag; + var cls = state2.implicit === null ? "universal" : "context"; + if (tag === null) { + if (state2.use === null) + reporter2.error("Tag could be omitted only for .use()"); + } else { + if (state2.use === null) + result = this._encodeComposite(tag, primitive, cls, content); + } + } + if (state2.explicit !== null) + result = this._encodeComposite(state2.explicit, false, "context", result); + return result; + }; + Node.prototype._encodeChoice = function encodeChoice(data, reporter2) { + var state2 = this._baseState; + var node2 = state2.choice[data.type]; + if (!node2) { + assert( + false, + data.type + " not found in " + JSON.stringify(Object.keys(state2.choice)) + ); + } + return node2._encode(data.value, reporter2); + }; + Node.prototype._encodePrimitive = function encodePrimitive(tag, data) { + var state2 = this._baseState; + if (/str$/.test(tag)) + return this._encodeStr(data, tag); + else if (tag === "objid" && state2.args) + return this._encodeObjid(data, state2.reverseArgs[0], state2.args[1]); + else if (tag === "objid") + return this._encodeObjid(data, null, null); + else if (tag === "gentime" || tag === "utctime") + return this._encodeTime(data, tag); + else if (tag === "null_") + return this._encodeNull(); + else if (tag === "int" || tag === "enum") + return this._encodeInt(data, state2.args && state2.reverseArgs[0]); + else if (tag === "bool") + return this._encodeBool(data); + else if (tag === "objDesc") + return this._encodeStr(data, tag); + else + throw new Error("Unsupported tag: " + tag); + }; + Node.prototype._isNumstr = function isNumstr(str) { + return /^[0-9 ]*$/.test(str); + }; + Node.prototype._isPrintstr = function isPrintstr(str) { + return /^[A-Za-z0-9 '\(\)\+,\-\.\/:=\?]*$/.test(str); + }; + return node; +} +var hasRequiredBase; +function requireBase() { + if (hasRequiredBase) return base; + hasRequiredBase = 1; + (function(exports2) { + var base2 = exports2; + base2.Reporter = requireReporter().Reporter; + base2.DecoderBuffer = requireBuffer().DecoderBuffer; + base2.EncoderBuffer = requireBuffer().EncoderBuffer; + base2.Node = requireNode(); + })(base); + return base; +} +var constants = {}; +var der = {}; +var hasRequiredDer$2; +function requireDer$2() { + if (hasRequiredDer$2) return der; + hasRequiredDer$2 = 1; + (function(exports2) { + var constants2 = requireConstants(); + exports2.tagClass = { + 0: "universal", + 1: "application", + 2: "context", + 3: "private" + }; + exports2.tagClassByName = constants2._reverse(exports2.tagClass); + exports2.tag = { + 0: "end", + 1: "bool", + 2: "int", + 3: "bitstr", + 4: "octstr", + 5: "null_", + 6: "objid", + 7: "objDesc", + 8: "external", + 9: "real", + 10: "enum", + 11: "embed", + 12: "utf8str", + 13: "relativeOid", + 16: "seq", + 17: "set", + 18: "numstr", + 19: "printstr", + 20: "t61str", + 21: "videostr", + 22: "ia5str", + 23: "utctime", + 24: "gentime", + 25: "graphstr", + 26: "iso646str", + 27: "genstr", + 28: "unistr", + 29: "charstr", + 30: "bmpstr" + }; + exports2.tagByName = constants2._reverse(exports2.tag); + })(der); + return der; +} +var hasRequiredConstants; +function requireConstants() { + if (hasRequiredConstants) return constants; + hasRequiredConstants = 1; + (function(exports2) { + var constants2 = exports2; + constants2._reverse = function reverse(map) { + var res = {}; + Object.keys(map).forEach(function(key2) { + if ((key2 | 0) == key2) + key2 = key2 | 0; + var value = map[key2]; + res[value] = key2; + }); + return res; + }; + constants2.der = requireDer$2(); + })(constants); + return constants; +} +var decoders = {}; +var der_1$1; +var hasRequiredDer$1; +function requireDer$1() { + if (hasRequiredDer$1) return der_1$1; + hasRequiredDer$1 = 1; + var inherits = requireInherits_browser(); + var asn12 = requireAsn1$1(); + var base2 = asn12.base; + var bignum = asn12.bignum; + var der2 = asn12.constants.der; + function DERDecoder(entity) { + this.enc = "der"; + this.name = entity.name; + this.entity = entity; + this.tree = new DERNode(); + this.tree._init(entity.body); + } + der_1$1 = DERDecoder; + DERDecoder.prototype.decode = function decode(data, options) { + if (!(data instanceof base2.DecoderBuffer)) + data = new base2.DecoderBuffer(data, options); + return this.tree._decode(data, options); + }; + function DERNode(parent) { + base2.Node.call(this, "der", parent); + } + inherits(DERNode, base2.Node); + DERNode.prototype._peekTag = function peekTag(buffer2, tag, any) { + if (buffer2.isEmpty()) + return false; + var state2 = buffer2.save(); + var decodedTag = derDecodeTag(buffer2, 'Failed to peek tag: "' + tag + '"'); + if (buffer2.isError(decodedTag)) + return decodedTag; + buffer2.restore(state2); + return decodedTag.tag === tag || decodedTag.tagStr === tag || decodedTag.tagStr + "of" === tag || any; + }; + DERNode.prototype._decodeTag = function decodeTag(buffer2, tag, any) { + var decodedTag = derDecodeTag( + buffer2, + 'Failed to decode tag of "' + tag + '"' + ); + if (buffer2.isError(decodedTag)) + return decodedTag; + var len2 = derDecodeLen( + buffer2, + decodedTag.primitive, + 'Failed to get length of "' + tag + '"' + ); + if (buffer2.isError(len2)) + return len2; + if (!any && decodedTag.tag !== tag && decodedTag.tagStr !== tag && decodedTag.tagStr + "of" !== tag) { + return buffer2.error('Failed to match tag: "' + tag + '"'); + } + if (decodedTag.primitive || len2 !== null) + return buffer2.skip(len2, 'Failed to match body of: "' + tag + '"'); + var state2 = buffer2.save(); + var res = this._skipUntilEnd( + buffer2, + 'Failed to skip indefinite length body: "' + this.tag + '"' + ); + if (buffer2.isError(res)) + return res; + len2 = buffer2.offset - state2.offset; + buffer2.restore(state2); + return buffer2.skip(len2, 'Failed to match body of: "' + tag + '"'); + }; + DERNode.prototype._skipUntilEnd = function skipUntilEnd(buffer2, fail) { + while (true) { + var tag = derDecodeTag(buffer2, fail); + if (buffer2.isError(tag)) + return tag; + var len2 = derDecodeLen(buffer2, tag.primitive, fail); + if (buffer2.isError(len2)) + return len2; + var res; + if (tag.primitive || len2 !== null) + res = buffer2.skip(len2); + else + res = this._skipUntilEnd(buffer2, fail); + if (buffer2.isError(res)) + return res; + if (tag.tagStr === "end") + break; + } + }; + DERNode.prototype._decodeList = function decodeList(buffer2, tag, decoder, options) { + var result = []; + while (!buffer2.isEmpty()) { + var possibleEnd = this._peekTag(buffer2, "end"); + if (buffer2.isError(possibleEnd)) + return possibleEnd; + var res = decoder.decode(buffer2, "der", options); + if (buffer2.isError(res) && possibleEnd) + break; + result.push(res); + } + return result; + }; + DERNode.prototype._decodeStr = function decodeStr(buffer2, tag) { + if (tag === "bitstr") { + var unused = buffer2.readUInt8(); + if (buffer2.isError(unused)) + return unused; + return { unused, data: buffer2.raw() }; + } else if (tag === "bmpstr") { + var raw = buffer2.raw(); + if (raw.length % 2 === 1) + return buffer2.error("Decoding of string type: bmpstr length mismatch"); + var str = ""; + for (var i2 = 0; i2 < raw.length / 2; i2++) { + str += String.fromCharCode(raw.readUInt16BE(i2 * 2)); + } + return str; + } else if (tag === "numstr") { + var numstr = buffer2.raw().toString("ascii"); + if (!this._isNumstr(numstr)) { + return buffer2.error("Decoding of string type: numstr unsupported characters"); + } + return numstr; + } else if (tag === "octstr") { + return buffer2.raw(); + } else if (tag === "objDesc") { + return buffer2.raw(); + } else if (tag === "printstr") { + var printstr = buffer2.raw().toString("ascii"); + if (!this._isPrintstr(printstr)) { + return buffer2.error("Decoding of string type: printstr unsupported characters"); + } + return printstr; + } else if (/str$/.test(tag)) { + return buffer2.raw().toString(); + } else { + return buffer2.error("Decoding of string type: " + tag + " unsupported"); + } + }; + DERNode.prototype._decodeObjid = function decodeObjid(buffer2, values, relative) { + var result; + var identifiers = []; + var ident = 0; + while (!buffer2.isEmpty()) { + var subident = buffer2.readUInt8(); + ident <<= 7; + ident |= subident & 127; + if ((subident & 128) === 0) { + identifiers.push(ident); + ident = 0; + } + } + if (subident & 128) + identifiers.push(ident); + var first = identifiers[0] / 40 | 0; + var second = identifiers[0] % 40; + if (relative) + result = identifiers; + else + result = [first, second].concat(identifiers.slice(1)); + if (values) { + var tmp = values[result.join(" ")]; + if (tmp === void 0) + tmp = values[result.join(".")]; + if (tmp !== void 0) + result = tmp; + } + return result; + }; + DERNode.prototype._decodeTime = function decodeTime(buffer2, tag) { + var str = buffer2.raw().toString(); + if (tag === "gentime") { + var year = str.slice(0, 4) | 0; + var mon = str.slice(4, 6) | 0; + var day = str.slice(6, 8) | 0; + var hour = str.slice(8, 10) | 0; + var min = str.slice(10, 12) | 0; + var sec = str.slice(12, 14) | 0; + } else if (tag === "utctime") { + var year = str.slice(0, 2) | 0; + var mon = str.slice(2, 4) | 0; + var day = str.slice(4, 6) | 0; + var hour = str.slice(6, 8) | 0; + var min = str.slice(8, 10) | 0; + var sec = str.slice(10, 12) | 0; + if (year < 70) + year = 2e3 + year; + else + year = 1900 + year; + } else { + return buffer2.error("Decoding " + tag + " time is not supported yet"); + } + return Date.UTC(year, mon - 1, day, hour, min, sec, 0); + }; + DERNode.prototype._decodeNull = function decodeNull(buffer2) { + return null; + }; + DERNode.prototype._decodeBool = function decodeBool(buffer2) { + var res = buffer2.readUInt8(); + if (buffer2.isError(res)) + return res; + else + return res !== 0; + }; + DERNode.prototype._decodeInt = function decodeInt(buffer2, values) { + var raw = buffer2.raw(); + var res = new bignum(raw); + if (values) + res = values[res.toString(10)] || res; + return res; + }; + DERNode.prototype._use = function use(entity, obj) { + if (typeof entity === "function") + entity = entity(obj); + return entity._getDecoder("der").tree; + }; + function derDecodeTag(buf, fail) { + var tag = buf.readUInt8(fail); + if (buf.isError(tag)) + return tag; + var cls = der2.tagClass[tag >> 6]; + var primitive = (tag & 32) === 0; + if ((tag & 31) === 31) { + var oct = tag; + tag = 0; + while ((oct & 128) === 128) { + oct = buf.readUInt8(fail); + if (buf.isError(oct)) + return oct; + tag <<= 7; + tag |= oct & 127; + } + } else { + tag &= 31; + } + var tagStr = der2.tag[tag]; + return { + cls, + primitive, + tag, + tagStr + }; + } + function derDecodeLen(buf, primitive, fail) { + var len2 = buf.readUInt8(fail); + if (buf.isError(len2)) + return len2; + if (!primitive && len2 === 128) + return null; + if ((len2 & 128) === 0) { + return len2; + } + var num = len2 & 127; + if (num > 4) + return buf.error("length octect is too long"); + len2 = 0; + for (var i2 = 0; i2 < num; i2++) { + len2 <<= 8; + var j = buf.readUInt8(fail); + if (buf.isError(j)) + return j; + len2 |= j; + } + return len2; + } + return der_1$1; +} +var pem$1; +var hasRequiredPem$1; +function requirePem$1() { + if (hasRequiredPem$1) return pem$1; + hasRequiredPem$1 = 1; + var inherits = requireInherits_browser(); + var Buffer2 = requireDist().Buffer; + var DERDecoder = requireDer$1(); + function PEMDecoder(entity) { + DERDecoder.call(this, entity); + this.enc = "pem"; + } + inherits(PEMDecoder, DERDecoder); + pem$1 = PEMDecoder; + PEMDecoder.prototype.decode = function decode(data, options) { + var lines = data.toString().split(/[\r\n]+/g); + var label = options.label.toUpperCase(); + var re = /^-----(BEGIN|END) ([^-]+)-----$/; + var start = -1; + var end = -1; + for (var i2 = 0; i2 < lines.length; i2++) { + var match = lines[i2].match(re); + if (match === null) + continue; + if (match[2] !== label) + continue; + if (start === -1) { + if (match[1] !== "BEGIN") + break; + start = i2; + } else { + if (match[1] !== "END") + break; + end = i2; + break; + } + } + if (start === -1 || end === -1) + throw new Error("PEM section not found for: " + label); + var base64 = lines.slice(start + 1, end).join(""); + base64.replace(/[^a-z0-9\+\/=]+/gi, ""); + var input = new Buffer2(base64, "base64"); + return DERDecoder.prototype.decode.call(this, input, options); + }; + return pem$1; +} +var hasRequiredDecoders; +function requireDecoders() { + if (hasRequiredDecoders) return decoders; + hasRequiredDecoders = 1; + (function(exports2) { + var decoders2 = exports2; + decoders2.der = requireDer$1(); + decoders2.pem = requirePem$1(); + })(decoders); + return decoders; +} +var encoders = {}; +var der_1; +var hasRequiredDer; +function requireDer() { + if (hasRequiredDer) return der_1; + hasRequiredDer = 1; + var inherits = requireInherits_browser(); + var Buffer2 = requireDist().Buffer; + var asn12 = requireAsn1$1(); + var base2 = asn12.base; + var der2 = asn12.constants.der; + function DEREncoder(entity) { + this.enc = "der"; + this.name = entity.name; + this.entity = entity; + this.tree = new DERNode(); + this.tree._init(entity.body); + } + der_1 = DEREncoder; + DEREncoder.prototype.encode = function encode(data, reporter2) { + return this.tree._encode(data, reporter2).join(); + }; + function DERNode(parent) { + base2.Node.call(this, "der", parent); + } + inherits(DERNode, base2.Node); + DERNode.prototype._encodeComposite = function encodeComposite(tag, primitive, cls, content) { + var encodedTag = encodeTag(tag, primitive, cls, this.reporter); + if (content.length < 128) { + var header = new Buffer2(2); + header[0] = encodedTag; + header[1] = content.length; + return this._createEncoderBuffer([header, content]); + } + var lenOctets = 1; + for (var i2 = content.length; i2 >= 256; i2 >>= 8) + lenOctets++; + var header = new Buffer2(1 + 1 + lenOctets); + header[0] = encodedTag; + header[1] = 128 | lenOctets; + for (var i2 = 1 + lenOctets, j = content.length; j > 0; i2--, j >>= 8) + header[i2] = j & 255; + return this._createEncoderBuffer([header, content]); + }; + DERNode.prototype._encodeStr = function encodeStr(str, tag) { + if (tag === "bitstr") { + return this._createEncoderBuffer([str.unused | 0, str.data]); + } else if (tag === "bmpstr") { + var buf = new Buffer2(str.length * 2); + for (var i2 = 0; i2 < str.length; i2++) { + buf.writeUInt16BE(str.charCodeAt(i2), i2 * 2); + } + return this._createEncoderBuffer(buf); + } else if (tag === "numstr") { + if (!this._isNumstr(str)) { + return this.reporter.error("Encoding of string type: numstr supports only digits and space"); + } + return this._createEncoderBuffer(str); + } else if (tag === "printstr") { + if (!this._isPrintstr(str)) { + return this.reporter.error("Encoding of string type: printstr supports only latin upper and lower case letters, digits, space, apostrophe, left and rigth parenthesis, plus sign, comma, hyphen, dot, slash, colon, equal sign, question mark"); + } + return this._createEncoderBuffer(str); + } else if (/str$/.test(tag)) { + return this._createEncoderBuffer(str); + } else if (tag === "objDesc") { + return this._createEncoderBuffer(str); + } else { + return this.reporter.error("Encoding of string type: " + tag + " unsupported"); + } + }; + DERNode.prototype._encodeObjid = function encodeObjid(id, values, relative) { + if (typeof id === "string") { + if (!values) + return this.reporter.error("string objid given, but no values map found"); + if (!values.hasOwnProperty(id)) + return this.reporter.error("objid not found in values map"); + id = values[id].split(/[\s\.]+/g); + for (var i2 = 0; i2 < id.length; i2++) + id[i2] |= 0; + } else if (Array.isArray(id)) { + id = id.slice(); + for (var i2 = 0; i2 < id.length; i2++) + id[i2] |= 0; + } + if (!Array.isArray(id)) { + return this.reporter.error("objid() should be either array or string, got: " + JSON.stringify(id)); + } + if (!relative) { + if (id[1] >= 40) + return this.reporter.error("Second objid identifier OOB"); + id.splice(0, 2, id[0] * 40 + id[1]); + } + var size = 0; + for (var i2 = 0; i2 < id.length; i2++) { + var ident = id[i2]; + for (size++; ident >= 128; ident >>= 7) + size++; + } + var objid = new Buffer2(size); + var offset = objid.length - 1; + for (var i2 = id.length - 1; i2 >= 0; i2--) { + var ident = id[i2]; + objid[offset--] = ident & 127; + while ((ident >>= 7) > 0) + objid[offset--] = 128 | ident & 127; + } + return this._createEncoderBuffer(objid); + }; + function two(num) { + if (num < 10) + return "0" + num; + else + return num; + } + DERNode.prototype._encodeTime = function encodeTime(time, tag) { + var str; + var date = new Date(time); + if (tag === "gentime") { + str = [ + two(date.getFullYear()), + two(date.getUTCMonth() + 1), + two(date.getUTCDate()), + two(date.getUTCHours()), + two(date.getUTCMinutes()), + two(date.getUTCSeconds()), + "Z" + ].join(""); + } else if (tag === "utctime") { + str = [ + two(date.getFullYear() % 100), + two(date.getUTCMonth() + 1), + two(date.getUTCDate()), + two(date.getUTCHours()), + two(date.getUTCMinutes()), + two(date.getUTCSeconds()), + "Z" + ].join(""); + } else { + this.reporter.error("Encoding " + tag + " time is not supported yet"); + } + return this._encodeStr(str, "octstr"); + }; + DERNode.prototype._encodeNull = function encodeNull() { + return this._createEncoderBuffer(""); + }; + DERNode.prototype._encodeInt = function encodeInt(num, values) { + if (typeof num === "string") { + if (!values) + return this.reporter.error("String int or enum given, but no values map"); + if (!values.hasOwnProperty(num)) { + return this.reporter.error("Values map doesn't contain: " + JSON.stringify(num)); + } + num = values[num]; + } + if (typeof num !== "number" && !Buffer2.isBuffer(num)) { + var numArray = num.toArray(); + if (!num.sign && numArray[0] & 128) { + numArray.unshift(0); + } + num = new Buffer2(numArray); + } + if (Buffer2.isBuffer(num)) { + var size = num.length; + if (num.length === 0) + size++; + var out = new Buffer2(size); + num.copy(out); + if (num.length === 0) + out[0] = 0; + return this._createEncoderBuffer(out); + } + if (num < 128) + return this._createEncoderBuffer(num); + if (num < 256) + return this._createEncoderBuffer([0, num]); + var size = 1; + for (var i2 = num; i2 >= 256; i2 >>= 8) + size++; + var out = new Array(size); + for (var i2 = out.length - 1; i2 >= 0; i2--) { + out[i2] = num & 255; + num >>= 8; + } + if (out[0] & 128) { + out.unshift(0); + } + return this._createEncoderBuffer(new Buffer2(out)); + }; + DERNode.prototype._encodeBool = function encodeBool(value) { + return this._createEncoderBuffer(value ? 255 : 0); + }; + DERNode.prototype._use = function use(entity, obj) { + if (typeof entity === "function") + entity = entity(obj); + return entity._getEncoder("der").tree; + }; + DERNode.prototype._skipDefault = function skipDefault(dataBuffer, reporter2, parent) { + var state2 = this._baseState; + var i2; + if (state2["default"] === null) + return false; + var data = dataBuffer.join(); + if (state2.defaultBuffer === void 0) + state2.defaultBuffer = this._encodeValue(state2["default"], reporter2, parent).join(); + if (data.length !== state2.defaultBuffer.length) + return false; + for (i2 = 0; i2 < data.length; i2++) + if (data[i2] !== state2.defaultBuffer[i2]) + return false; + return true; + }; + function encodeTag(tag, primitive, cls, reporter2) { + var res; + if (tag === "seqof") + tag = "seq"; + else if (tag === "setof") + tag = "set"; + if (der2.tagByName.hasOwnProperty(tag)) + res = der2.tagByName[tag]; + else if (typeof tag === "number" && (tag | 0) === tag) + res = tag; + else + return reporter2.error("Unknown tag: " + tag); + if (res >= 31) + return reporter2.error("Multi-octet tag encoding unsupported"); + if (!primitive) + res |= 32; + res |= der2.tagClassByName[cls || "universal"] << 6; + return res; + } + return der_1; +} +var pem; +var hasRequiredPem; +function requirePem() { + if (hasRequiredPem) return pem; + hasRequiredPem = 1; + var inherits = requireInherits_browser(); + var DEREncoder = requireDer(); + function PEMEncoder(entity) { + DEREncoder.call(this, entity); + this.enc = "pem"; + } + inherits(PEMEncoder, DEREncoder); + pem = PEMEncoder; + PEMEncoder.prototype.encode = function encode(data, options) { + var buf = DEREncoder.prototype.encode.call(this, data); + var p = buf.toString("base64"); + var out = ["-----BEGIN " + options.label + "-----"]; + for (var i2 = 0; i2 < p.length; i2 += 64) + out.push(p.slice(i2, i2 + 64)); + out.push("-----END " + options.label + "-----"); + return out.join("\n"); + }; + return pem; +} +var hasRequiredEncoders; +function requireEncoders() { + if (hasRequiredEncoders) return encoders; + hasRequiredEncoders = 1; + (function(exports2) { + var encoders2 = exports2; + encoders2.der = requireDer(); + encoders2.pem = requirePem(); + })(encoders); + return encoders; +} +var hasRequiredAsn1$1; +function requireAsn1$1() { + if (hasRequiredAsn1$1) return asn1; + hasRequiredAsn1$1 = 1; + (function(exports2) { + var asn12 = exports2; + asn12.bignum = requireBn$1(); + asn12.define = requireApi().define; + asn12.base = requireBase(); + asn12.constants = requireConstants(); + asn12.decoders = requireDecoders(); + asn12.encoders = requireEncoders(); + })(asn1); + return asn1; +} +var certificate; +var hasRequiredCertificate; +function requireCertificate() { + if (hasRequiredCertificate) return certificate; + hasRequiredCertificate = 1; + var asn = requireAsn1$1(); + var Time = asn.define("Time", function() { + this.choice({ + utcTime: this.utctime(), + generalTime: this.gentime() + }); + }); + var AttributeTypeValue = asn.define("AttributeTypeValue", function() { + this.seq().obj( + this.key("type").objid(), + this.key("value").any() + ); + }); + var AlgorithmIdentifier = asn.define("AlgorithmIdentifier", function() { + this.seq().obj( + this.key("algorithm").objid(), + this.key("parameters").optional(), + this.key("curve").objid().optional() + ); + }); + var SubjectPublicKeyInfo = asn.define("SubjectPublicKeyInfo", function() { + this.seq().obj( + this.key("algorithm").use(AlgorithmIdentifier), + this.key("subjectPublicKey").bitstr() + ); + }); + var RelativeDistinguishedName = asn.define("RelativeDistinguishedName", function() { + this.setof(AttributeTypeValue); + }); + var RDNSequence = asn.define("RDNSequence", function() { + this.seqof(RelativeDistinguishedName); + }); + var Name = asn.define("Name", function() { + this.choice({ + rdnSequence: this.use(RDNSequence) + }); + }); + var Validity = asn.define("Validity", function() { + this.seq().obj( + this.key("notBefore").use(Time), + this.key("notAfter").use(Time) + ); + }); + var Extension = asn.define("Extension", function() { + this.seq().obj( + this.key("extnID").objid(), + this.key("critical").bool().def(false), + this.key("extnValue").octstr() + ); + }); + var TBSCertificate = asn.define("TBSCertificate", function() { + this.seq().obj( + this.key("version").explicit(0)["int"]().optional(), + this.key("serialNumber")["int"](), + this.key("signature").use(AlgorithmIdentifier), + this.key("issuer").use(Name), + this.key("validity").use(Validity), + this.key("subject").use(Name), + this.key("subjectPublicKeyInfo").use(SubjectPublicKeyInfo), + this.key("issuerUniqueID").implicit(1).bitstr().optional(), + this.key("subjectUniqueID").implicit(2).bitstr().optional(), + this.key("extensions").explicit(3).seqof(Extension).optional() + ); + }); + var X509Certificate = asn.define("X509Certificate", function() { + this.seq().obj( + this.key("tbsCertificate").use(TBSCertificate), + this.key("signatureAlgorithm").use(AlgorithmIdentifier), + this.key("signatureValue").bitstr() + ); + }); + certificate = X509Certificate; + return certificate; +} +var hasRequiredAsn1; +function requireAsn1() { + if (hasRequiredAsn1) return asn1$1; + hasRequiredAsn1 = 1; + var asn12 = requireAsn1$1(); + asn1$1.certificate = requireCertificate(); + var RSAPrivateKey = asn12.define("RSAPrivateKey", function() { + this.seq().obj( + this.key("version")["int"](), + this.key("modulus")["int"](), + this.key("publicExponent")["int"](), + this.key("privateExponent")["int"](), + this.key("prime1")["int"](), + this.key("prime2")["int"](), + this.key("exponent1")["int"](), + this.key("exponent2")["int"](), + this.key("coefficient")["int"]() + ); + }); + asn1$1.RSAPrivateKey = RSAPrivateKey; + var RSAPublicKey = asn12.define("RSAPublicKey", function() { + this.seq().obj( + this.key("modulus")["int"](), + this.key("publicExponent")["int"]() + ); + }); + asn1$1.RSAPublicKey = RSAPublicKey; + var AlgorithmIdentifier = asn12.define("AlgorithmIdentifier", function() { + this.seq().obj( + this.key("algorithm").objid(), + this.key("none").null_().optional(), + this.key("curve").objid().optional(), + this.key("params").seq().obj( + this.key("p")["int"](), + this.key("q")["int"](), + this.key("g")["int"]() + ).optional() + ); + }); + var PublicKey = asn12.define("SubjectPublicKeyInfo", function() { + this.seq().obj( + this.key("algorithm").use(AlgorithmIdentifier), + this.key("subjectPublicKey").bitstr() + ); + }); + asn1$1.PublicKey = PublicKey; + var PrivateKeyInfo = asn12.define("PrivateKeyInfo", function() { + this.seq().obj( + this.key("version")["int"](), + this.key("algorithm").use(AlgorithmIdentifier), + this.key("subjectPrivateKey").octstr() + ); + }); + asn1$1.PrivateKey = PrivateKeyInfo; + var EncryptedPrivateKeyInfo = asn12.define("EncryptedPrivateKeyInfo", function() { + this.seq().obj( + this.key("algorithm").seq().obj( + this.key("id").objid(), + this.key("decrypt").seq().obj( + this.key("kde").seq().obj( + this.key("id").objid(), + this.key("kdeparams").seq().obj( + this.key("salt").octstr(), + this.key("iters")["int"]() + ) + ), + this.key("cipher").seq().obj( + this.key("algo").objid(), + this.key("iv").octstr() + ) + ) + ), + this.key("subjectPrivateKey").octstr() + ); + }); + asn1$1.EncryptedPrivateKey = EncryptedPrivateKeyInfo; + var DSAPrivateKey = asn12.define("DSAPrivateKey", function() { + this.seq().obj( + this.key("version")["int"](), + this.key("p")["int"](), + this.key("q")["int"](), + this.key("g")["int"](), + this.key("pub_key")["int"](), + this.key("priv_key")["int"]() + ); + }); + asn1$1.DSAPrivateKey = DSAPrivateKey; + asn1$1.DSAparam = asn12.define("DSAparam", function() { + this["int"](); + }); + var ECParameters = asn12.define("ECParameters", function() { + this.choice({ + namedCurve: this.objid() + }); + }); + var ECPrivateKey = asn12.define("ECPrivateKey", function() { + this.seq().obj( + this.key("version")["int"](), + this.key("privateKey").octstr(), + this.key("parameters").optional().explicit(0).use(ECParameters), + this.key("publicKey").optional().explicit(1).bitstr() + ); + }); + asn1$1.ECPrivateKey = ECPrivateKey; + asn1$1.signature = asn12.define("signature", function() { + this.seq().obj( + this.key("r")["int"](), + this.key("s")["int"]() + ); + }); + return asn1$1; +} +const require$$1 = { + "2.16.840.1.101.3.4.1.1": "aes-128-ecb", + "2.16.840.1.101.3.4.1.2": "aes-128-cbc", + "2.16.840.1.101.3.4.1.3": "aes-128-ofb", + "2.16.840.1.101.3.4.1.4": "aes-128-cfb", + "2.16.840.1.101.3.4.1.21": "aes-192-ecb", + "2.16.840.1.101.3.4.1.22": "aes-192-cbc", + "2.16.840.1.101.3.4.1.23": "aes-192-ofb", + "2.16.840.1.101.3.4.1.24": "aes-192-cfb", + "2.16.840.1.101.3.4.1.41": "aes-256-ecb", + "2.16.840.1.101.3.4.1.42": "aes-256-cbc", + "2.16.840.1.101.3.4.1.43": "aes-256-ofb", + "2.16.840.1.101.3.4.1.44": "aes-256-cfb" +}; +var fixProc; +var hasRequiredFixProc; +function requireFixProc() { + if (hasRequiredFixProc) return fixProc; + hasRequiredFixProc = 1; + var findProc = /Proc-Type: 4,ENCRYPTED[\n\r]+DEK-Info: AES-((?:128)|(?:192)|(?:256))-CBC,([0-9A-H]+)[\n\r]+([0-9A-z\n\r+/=]+)[\n\r]+/m; + var startRegex = /^-----BEGIN ((?:.*? KEY)|CERTIFICATE)-----/m; + var fullRegex = /^-----BEGIN ((?:.*? KEY)|CERTIFICATE)-----([0-9A-z\n\r+/=]+)-----END \1-----$/m; + var evp = requireEvp_bytestokey(); + var ciphers = requireBrowser$6(); + var Buffer2 = requireSafeBuffer$1().Buffer; + fixProc = function(okey, password) { + var key2 = okey.toString(); + var match = key2.match(findProc); + var decrypted; + if (!match) { + var match2 = key2.match(fullRegex); + decrypted = Buffer2.from(match2[2].replace(/[\r\n]/g, ""), "base64"); + } else { + var suite = "aes" + match[1]; + var iv = Buffer2.from(match[2], "hex"); + var cipherText = Buffer2.from(match[3].replace(/[\r\n]/g, ""), "base64"); + var cipherKey = evp(password, iv.slice(0, 8), parseInt(match[1], 10)).key; + var out = []; + var cipher2 = ciphers.createDecipheriv(suite, cipherKey, iv); + out.push(cipher2.update(cipherText)); + out.push(cipher2["final"]()); + decrypted = Buffer2.concat(out); + } + var tag = key2.match(startRegex)[1]; + return { + tag, + data: decrypted + }; + }; + return fixProc; +} +var parseAsn1; +var hasRequiredParseAsn1; +function requireParseAsn1() { + if (hasRequiredParseAsn1) return parseAsn1; + hasRequiredParseAsn1 = 1; + var asn12 = requireAsn1(); + var aesid = require$$1; + var fixProc2 = requireFixProc(); + var ciphers = requireBrowser$6(); + var compat = requireBrowser$7(); + var Buffer2 = requireSafeBuffer$1().Buffer; + function decrypt(data, password) { + var salt = data.algorithm.decrypt.kde.kdeparams.salt; + var iters = parseInt(data.algorithm.decrypt.kde.kdeparams.iters.toString(), 10); + var algo = aesid[data.algorithm.decrypt.cipher.algo.join(".")]; + var iv = data.algorithm.decrypt.cipher.iv; + var cipherText = data.subjectPrivateKey; + var keylen = parseInt(algo.split("-")[1], 10) / 8; + var key2 = compat.pbkdf2Sync(password, salt, iters, keylen, "sha1"); + var cipher2 = ciphers.createDecipheriv(algo, key2, iv); + var out = []; + out.push(cipher2.update(cipherText)); + out.push(cipher2["final"]()); + return Buffer2.concat(out); + } + function parseKeys(buffer2) { + var password; + if (typeof buffer2 === "object" && !Buffer2.isBuffer(buffer2)) { + password = buffer2.passphrase; + buffer2 = buffer2.key; + } + if (typeof buffer2 === "string") { + buffer2 = Buffer2.from(buffer2); + } + var stripped = fixProc2(buffer2, password); + var type2 = stripped.tag; + var data = stripped.data; + var subtype, ndata; + switch (type2) { + case "CERTIFICATE": + ndata = asn12.certificate.decode(data, "der").tbsCertificate.subjectPublicKeyInfo; + // falls through + case "PUBLIC KEY": + if (!ndata) { + ndata = asn12.PublicKey.decode(data, "der"); + } + subtype = ndata.algorithm.algorithm.join("."); + switch (subtype) { + case "1.2.840.113549.1.1.1": + return asn12.RSAPublicKey.decode(ndata.subjectPublicKey.data, "der"); + case "1.2.840.10045.2.1": + ndata.subjectPrivateKey = ndata.subjectPublicKey; + return { + type: "ec", + data: ndata + }; + case "1.2.840.10040.4.1": + ndata.algorithm.params.pub_key = asn12.DSAparam.decode(ndata.subjectPublicKey.data, "der"); + return { + type: "dsa", + data: ndata.algorithm.params + }; + default: + throw new Error("unknown key id " + subtype); + } + // throw new Error('unknown key type ' + type) + case "ENCRYPTED PRIVATE KEY": + data = asn12.EncryptedPrivateKey.decode(data, "der"); + data = decrypt(data, password); + // falls through + case "PRIVATE KEY": + ndata = asn12.PrivateKey.decode(data, "der"); + subtype = ndata.algorithm.algorithm.join("."); + switch (subtype) { + case "1.2.840.113549.1.1.1": + return asn12.RSAPrivateKey.decode(ndata.subjectPrivateKey, "der"); + case "1.2.840.10045.2.1": + return { + curve: ndata.algorithm.curve, + privateKey: asn12.ECPrivateKey.decode(ndata.subjectPrivateKey, "der").privateKey + }; + case "1.2.840.10040.4.1": + ndata.algorithm.params.priv_key = asn12.DSAparam.decode(ndata.subjectPrivateKey, "der"); + return { + type: "dsa", + params: ndata.algorithm.params + }; + default: + throw new Error("unknown key id " + subtype); + } + // throw new Error('unknown key type ' + type) + case "RSA PUBLIC KEY": + return asn12.RSAPublicKey.decode(data, "der"); + case "RSA PRIVATE KEY": + return asn12.RSAPrivateKey.decode(data, "der"); + case "DSA PRIVATE KEY": + return { + type: "dsa", + params: asn12.DSAPrivateKey.decode(data, "der") + }; + case "EC PRIVATE KEY": + data = asn12.ECPrivateKey.decode(data, "der"); + return { + curve: data.parameters.value, + privateKey: data.privateKey + }; + default: + throw new Error("unknown key type " + type2); + } + } + parseKeys.signature = asn12.signature; + parseAsn1 = parseKeys; + return parseAsn1; +} +const require$$4$1 = { + "1.3.132.0.10": "secp256k1", + "1.3.132.0.33": "p224", + "1.2.840.10045.3.1.1": "p192", + "1.2.840.10045.3.1.7": "p256", + "1.3.132.0.34": "p384", + "1.3.132.0.35": "p521" +}; +var hasRequiredSign; +function requireSign() { + if (hasRequiredSign) return sign.exports; + hasRequiredSign = 1; + var Buffer2 = requireSafeBuffer$1().Buffer; + var createHmac = requireBrowser$8(); + var crt = /* @__PURE__ */ requireBrowserifyRsa(); + var EC = requireElliptic().ec; + var BN = requireBn(); + var parseKeys = requireParseAsn1(); + var curves2 = require$$4$1; + var RSA_PKCS1_PADDING = 1; + function sign$1(hash2, key2, hashType, signType, tag) { + var priv = parseKeys(key2); + if (priv.curve) { + if (signType !== "ecdsa" && signType !== "ecdsa/rsa") { + throw new Error("wrong private key type"); + } + return ecSign(hash2, priv); + } else if (priv.type === "dsa") { + if (signType !== "dsa") { + throw new Error("wrong private key type"); + } + return dsaSign(hash2, priv, hashType); + } + if (signType !== "rsa" && signType !== "ecdsa/rsa") { + throw new Error("wrong private key type"); + } + if (key2.padding !== void 0 && key2.padding !== RSA_PKCS1_PADDING) { + throw new Error("illegal or unsupported padding mode"); + } + hash2 = Buffer2.concat([tag, hash2]); + var len2 = priv.modulus.byteLength(); + var pad = [0, 1]; + while (hash2.length + pad.length + 1 < len2) { + pad.push(255); + } + pad.push(0); + var i2 = -1; + while (++i2 < hash2.length) { + pad.push(hash2[i2]); + } + var out = crt(pad, priv); + return out; + } + function ecSign(hash2, priv) { + var curveId = curves2[priv.curve.join(".")]; + if (!curveId) { + throw new Error("unknown curve " + priv.curve.join(".")); + } + var curve2 = new EC(curveId); + var key2 = curve2.keyFromPrivate(priv.privateKey); + var out = key2.sign(hash2); + return Buffer2.from(out.toDER()); + } + function dsaSign(hash2, priv, algo) { + var x = priv.params.priv_key; + var p = priv.params.p; + var q = priv.params.q; + var g = priv.params.g; + var r = new BN(0); + var k; + var H = bits2int(hash2, q).mod(q); + var s = false; + var kv = getKey(x, q, hash2, algo); + while (s === false) { + k = makeKey(q, kv, algo); + r = makeR(g, k, p, q); + s = k.invm(q).imul(H.add(x.mul(r))).mod(q); + if (s.cmpn(0) === 0) { + s = false; + r = new BN(0); + } + } + return toDER(r, s); + } + function toDER(r, s) { + r = r.toArray(); + s = s.toArray(); + if (r[0] & 128) { + r = [0].concat(r); + } + if (s[0] & 128) { + s = [0].concat(s); + } + var total = r.length + s.length + 4; + var res = [ + 48, + total, + 2, + r.length + ]; + res = res.concat(r, [2, s.length], s); + return Buffer2.from(res); + } + function getKey(x, q, hash2, algo) { + x = Buffer2.from(x.toArray()); + if (x.length < q.byteLength()) { + var zeros = Buffer2.alloc(q.byteLength() - x.length); + x = Buffer2.concat([zeros, x]); + } + var hlen = hash2.length; + var hbits = bits2octets(hash2, q); + var v = Buffer2.alloc(hlen); + v.fill(1); + var k = Buffer2.alloc(hlen); + k = createHmac(algo, k).update(v).update(Buffer2.from([0])).update(x).update(hbits).digest(); + v = createHmac(algo, k).update(v).digest(); + k = createHmac(algo, k).update(v).update(Buffer2.from([1])).update(x).update(hbits).digest(); + v = createHmac(algo, k).update(v).digest(); + return { k, v }; + } + function bits2int(obits, q) { + var bits = new BN(obits); + var shift = (obits.length << 3) - q.bitLength(); + if (shift > 0) { + bits.ishrn(shift); + } + return bits; + } + function bits2octets(bits, q) { + bits = bits2int(bits, q); + bits = bits.mod(q); + var out = Buffer2.from(bits.toArray()); + if (out.length < q.byteLength()) { + var zeros = Buffer2.alloc(q.byteLength() - out.length); + out = Buffer2.concat([zeros, out]); + } + return out; + } + function makeKey(q, kv, algo) { + var t; + var k; + do { + t = Buffer2.alloc(0); + while (t.length * 8 < q.bitLength()) { + kv.v = createHmac(algo, kv.k).update(kv.v).digest(); + t = Buffer2.concat([t, kv.v]); + } + k = bits2int(t, q); + kv.k = createHmac(algo, kv.k).update(kv.v).update(Buffer2.from([0])).digest(); + kv.v = createHmac(algo, kv.k).update(kv.v).digest(); + } while (k.cmp(q) !== -1); + return k; + } + function makeR(g, k, p, q) { + return g.toRed(BN.mont(p)).redPow(k).fromRed().mod(q); + } + sign.exports = sign$1; + sign.exports.getKey = getKey; + sign.exports.makeKey = makeKey; + return sign.exports; +} +var verify_1; +var hasRequiredVerify; +function requireVerify() { + if (hasRequiredVerify) return verify_1; + hasRequiredVerify = 1; + var Buffer2 = requireSafeBuffer$1().Buffer; + var BN = requireBn(); + var EC = requireElliptic().ec; + var parseKeys = requireParseAsn1(); + var curves2 = require$$4$1; + function verify(sig, hash2, key2, signType, tag) { + var pub = parseKeys(key2); + if (pub.type === "ec") { + if (signType !== "ecdsa" && signType !== "ecdsa/rsa") { + throw new Error("wrong public key type"); + } + return ecVerify(sig, hash2, pub); + } else if (pub.type === "dsa") { + if (signType !== "dsa") { + throw new Error("wrong public key type"); + } + return dsaVerify(sig, hash2, pub); + } + if (signType !== "rsa" && signType !== "ecdsa/rsa") { + throw new Error("wrong public key type"); + } + hash2 = Buffer2.concat([tag, hash2]); + var len2 = pub.modulus.byteLength(); + var pad = [1]; + var padNum = 0; + while (hash2.length + pad.length + 2 < len2) { + pad.push(255); + padNum += 1; + } + pad.push(0); + var i2 = -1; + while (++i2 < hash2.length) { + pad.push(hash2[i2]); + } + pad = Buffer2.from(pad); + var red = BN.mont(pub.modulus); + sig = new BN(sig).toRed(red); + sig = sig.redPow(new BN(pub.publicExponent)); + sig = Buffer2.from(sig.fromRed().toArray()); + var out = padNum < 8 ? 1 : 0; + len2 = Math.min(sig.length, pad.length); + if (sig.length !== pad.length) { + out = 1; + } + i2 = -1; + while (++i2 < len2) { + out |= sig[i2] ^ pad[i2]; + } + return out === 0; + } + function ecVerify(sig, hash2, pub) { + var curveId = curves2[pub.data.algorithm.curve.join(".")]; + if (!curveId) { + throw new Error("unknown curve " + pub.data.algorithm.curve.join(".")); + } + var curve2 = new EC(curveId); + var pubkey = pub.data.subjectPrivateKey.data; + return curve2.verify(hash2, sig, pubkey); + } + function dsaVerify(sig, hash2, pub) { + var p = pub.data.p; + var q = pub.data.q; + var g = pub.data.g; + var y = pub.data.pub_key; + var unpacked = parseKeys.signature.decode(sig, "der"); + var s = unpacked.s; + var r = unpacked.r; + checkValue(s, q); + checkValue(r, q); + var montp = BN.mont(p); + var w = s.invm(q); + var v = g.toRed(montp).redPow(new BN(hash2).mul(w).mod(q)).fromRed().mul(y.toRed(montp).redPow(r.mul(w).mod(q)).fromRed()).mod(p).mod(q); + return v.cmp(r) === 0; + } + function checkValue(b, q) { + if (b.cmpn(0) <= 0) { + throw new Error("invalid sig"); + } + if (b.cmp(q) >= 0) { + throw new Error("invalid sig"); + } + } + verify_1 = verify; + return verify_1; +} +var browser$3; +var hasRequiredBrowser$3; +function requireBrowser$3() { + if (hasRequiredBrowser$3) return browser$3; + hasRequiredBrowser$3 = 1; + var Buffer2 = requireSafeBuffer$1().Buffer; + var createHash = requireBrowser$9(); + var stream = requireReadableBrowser(); + var inherits = requireInherits_browser(); + var sign2 = requireSign(); + var verify = requireVerify(); + var algorithms = require$$6; + Object.keys(algorithms).forEach(function(key2) { + algorithms[key2].id = Buffer2.from(algorithms[key2].id, "hex"); + algorithms[key2.toLowerCase()] = algorithms[key2]; + }); + function Sign(algorithm) { + stream.Writable.call(this); + var data = algorithms[algorithm]; + if (!data) { + throw new Error("Unknown message digest"); + } + this._hashType = data.hash; + this._hash = createHash(data.hash); + this._tag = data.id; + this._signType = data.sign; + } + inherits(Sign, stream.Writable); + Sign.prototype._write = function _write(data, _, done) { + this._hash.update(data); + done(); + }; + Sign.prototype.update = function update(data, enc) { + this._hash.update(typeof data === "string" ? Buffer2.from(data, enc) : data); + return this; + }; + Sign.prototype.sign = function signMethod(key2, enc) { + this.end(); + var hash2 = this._hash.digest(); + var sig = sign2(hash2, key2, this._hashType, this._signType, this._tag); + return enc ? sig.toString(enc) : sig; + }; + function Verify(algorithm) { + stream.Writable.call(this); + var data = algorithms[algorithm]; + if (!data) { + throw new Error("Unknown message digest"); + } + this._hash = createHash(data.hash); + this._tag = data.id; + this._signType = data.sign; + } + inherits(Verify, stream.Writable); + Verify.prototype._write = function _write(data, _, done) { + this._hash.update(data); + done(); + }; + Verify.prototype.update = function update(data, enc) { + this._hash.update(typeof data === "string" ? Buffer2.from(data, enc) : data); + return this; + }; + Verify.prototype.verify = function verifyMethod(key2, sig, enc) { + var sigBuffer = typeof sig === "string" ? Buffer2.from(sig, enc) : sig; + this.end(); + var hash2 = this._hash.digest(); + return verify(sigBuffer, hash2, key2, this._signType, this._tag); + }; + function createSign(algorithm) { + return new Sign(algorithm); + } + function createVerify(algorithm) { + return new Verify(algorithm); + } + browser$3 = { + Sign: createSign, + Verify: createVerify, + createSign, + createVerify + }; + return browser$3; +} +var browser$2; +var hasRequiredBrowser$2; +function requireBrowser$2() { + if (hasRequiredBrowser$2) return browser$2; + hasRequiredBrowser$2 = 1; + var elliptic2 = requireElliptic(); + var BN = requireBn$1(); + browser$2 = function createECDH(curve2) { + return new ECDH(curve2); + }; + var aliases = { + secp256k1: { + name: "secp256k1", + byteLength: 32 + }, + secp224r1: { + name: "p224", + byteLength: 28 + }, + prime256v1: { + name: "p256", + byteLength: 32 + }, + prime192v1: { + name: "p192", + byteLength: 24 + }, + ed25519: { + name: "ed25519", + byteLength: 32 + }, + secp384r1: { + name: "p384", + byteLength: 48 + }, + secp521r1: { + name: "p521", + byteLength: 66 + } + }; + aliases.p224 = aliases.secp224r1; + aliases.p256 = aliases.secp256r1 = aliases.prime256v1; + aliases.p192 = aliases.secp192r1 = aliases.prime192v1; + aliases.p384 = aliases.secp384r1; + aliases.p521 = aliases.secp521r1; + function ECDH(curve2) { + this.curveType = aliases[curve2]; + if (!this.curveType) { + this.curveType = { + name: curve2 + }; + } + this.curve = new elliptic2.ec(this.curveType.name); + this.keys = void 0; + } + ECDH.prototype.generateKeys = function(enc, format) { + this.keys = this.curve.genKeyPair(); + return this.getPublicKey(enc, format); + }; + ECDH.prototype.computeSecret = function(other, inenc, enc) { + inenc = inenc || "utf8"; + if (!Buffer.isBuffer(other)) { + other = new Buffer(other, inenc); + } + var otherPub = this.curve.keyFromPublic(other).getPublic(); + var out = otherPub.mul(this.keys.getPrivate()).getX(); + return formatReturnValue(out, enc, this.curveType.byteLength); + }; + ECDH.prototype.getPublicKey = function(enc, format) { + var key2 = this.keys.getPublic(format === "compressed", true); + if (format === "hybrid") { + if (key2[key2.length - 1] % 2) { + key2[0] = 7; + } else { + key2[0] = 6; + } + } + return formatReturnValue(key2, enc); + }; + ECDH.prototype.getPrivateKey = function(enc) { + return formatReturnValue(this.keys.getPrivate(), enc); + }; + ECDH.prototype.setPublicKey = function(pub, enc) { + enc = enc || "utf8"; + if (!Buffer.isBuffer(pub)) { + pub = new Buffer(pub, enc); + } + this.keys._importPublic(pub); + return this; + }; + ECDH.prototype.setPrivateKey = function(priv, enc) { + enc = enc || "utf8"; + if (!Buffer.isBuffer(priv)) { + priv = new Buffer(priv, enc); + } + var _priv = new BN(priv); + _priv = _priv.toString(16); + this.keys = this.curve.genKeyPair(); + this.keys._importPrivate(_priv); + return this; + }; + function formatReturnValue(bn2, enc, len2) { + if (!Array.isArray(bn2)) { + bn2 = bn2.toArray(); + } + var buf = new Buffer(bn2); + if (len2 && buf.length < len2) { + var zeros = new Buffer(len2 - buf.length); + zeros.fill(0); + buf = Buffer.concat([zeros, buf]); + } + if (!enc) { + return buf; + } else { + return buf.toString(enc); + } + } + return browser$2; +} +var browser$1 = {}; +var mgf; +var hasRequiredMgf; +function requireMgf() { + if (hasRequiredMgf) return mgf; + hasRequiredMgf = 1; + var createHash = requireBrowser$9(); + var Buffer2 = requireSafeBuffer$1().Buffer; + mgf = function(seed, len2) { + var t = Buffer2.alloc(0); + var i2 = 0; + var c; + while (t.length < len2) { + c = i2ops(i2++); + t = Buffer2.concat([t, createHash("sha1").update(seed).update(c).digest()]); + } + return t.slice(0, len2); + }; + function i2ops(c) { + var out = Buffer2.allocUnsafe(4); + out.writeUInt32BE(c, 0); + return out; + } + return mgf; +} +var xor; +var hasRequiredXor; +function requireXor() { + if (hasRequiredXor) return xor; + hasRequiredXor = 1; + xor = function xor2(a, b) { + var len2 = a.length; + var i2 = -1; + while (++i2 < len2) { + a[i2] ^= b[i2]; + } + return a; + }; + return xor; +} +var withPublic_1; +var hasRequiredWithPublic; +function requireWithPublic() { + if (hasRequiredWithPublic) return withPublic_1; + hasRequiredWithPublic = 1; + var BN = requireBn$1(); + var Buffer2 = requireSafeBuffer$1().Buffer; + function withPublic(paddedMsg, key2) { + return Buffer2.from(paddedMsg.toRed(BN.mont(key2.modulus)).redPow(new BN(key2.publicExponent)).fromRed().toArray()); + } + withPublic_1 = withPublic; + return withPublic_1; +} +var publicEncrypt; +var hasRequiredPublicEncrypt; +function requirePublicEncrypt() { + if (hasRequiredPublicEncrypt) return publicEncrypt; + hasRequiredPublicEncrypt = 1; + var parseKeys = requireParseAsn1(); + var randomBytes = requireBrowser$b(); + var createHash = requireBrowser$9(); + var mgf2 = requireMgf(); + var xor2 = requireXor(); + var BN = requireBn$1(); + var withPublic = requireWithPublic(); + var crt = /* @__PURE__ */ requireBrowserifyRsa(); + var Buffer2 = requireSafeBuffer$1().Buffer; + publicEncrypt = function publicEncrypt2(publicKey, msg, reverse) { + var padding; + if (publicKey.padding) { + padding = publicKey.padding; + } else if (reverse) { + padding = 1; + } else { + padding = 4; + } + var key2 = parseKeys(publicKey); + var paddedMsg; + if (padding === 4) { + paddedMsg = oaep(key2, msg); + } else if (padding === 1) { + paddedMsg = pkcs1(key2, msg, reverse); + } else if (padding === 3) { + paddedMsg = new BN(msg); + if (paddedMsg.cmp(key2.modulus) >= 0) { + throw new Error("data too long for modulus"); + } + } else { + throw new Error("unknown padding"); + } + if (reverse) { + return crt(paddedMsg, key2); + } else { + return withPublic(paddedMsg, key2); + } + }; + function oaep(key2, msg) { + var k = key2.modulus.byteLength(); + var mLen = msg.length; + var iHash = createHash("sha1").update(Buffer2.alloc(0)).digest(); + var hLen = iHash.length; + var hLen2 = 2 * hLen; + if (mLen > k - hLen2 - 2) { + throw new Error("message too long"); + } + var ps = Buffer2.alloc(k - mLen - hLen2 - 2); + var dblen = k - hLen - 1; + var seed = randomBytes(hLen); + var maskedDb = xor2(Buffer2.concat([iHash, ps, Buffer2.alloc(1, 1), msg], dblen), mgf2(seed, dblen)); + var maskedSeed = xor2(seed, mgf2(maskedDb, hLen)); + return new BN(Buffer2.concat([Buffer2.alloc(1), maskedSeed, maskedDb], k)); + } + function pkcs1(key2, msg, reverse) { + var mLen = msg.length; + var k = key2.modulus.byteLength(); + if (mLen > k - 11) { + throw new Error("message too long"); + } + var ps; + if (reverse) { + ps = Buffer2.alloc(k - mLen - 3, 255); + } else { + ps = nonZero(k - mLen - 3); + } + return new BN(Buffer2.concat([Buffer2.from([0, reverse ? 1 : 2]), ps, Buffer2.alloc(1), msg], k)); + } + function nonZero(len2) { + var out = Buffer2.allocUnsafe(len2); + var i2 = 0; + var cache = randomBytes(len2 * 2); + var cur = 0; + var num; + while (i2 < len2) { + if (cur === cache.length) { + cache = randomBytes(len2 * 2); + cur = 0; + } + num = cache[cur++]; + if (num) { + out[i2++] = num; + } + } + return out; + } + return publicEncrypt; +} +var privateDecrypt; +var hasRequiredPrivateDecrypt; +function requirePrivateDecrypt() { + if (hasRequiredPrivateDecrypt) return privateDecrypt; + hasRequiredPrivateDecrypt = 1; + var parseKeys = requireParseAsn1(); + var mgf2 = requireMgf(); + var xor2 = requireXor(); + var BN = requireBn$1(); + var crt = /* @__PURE__ */ requireBrowserifyRsa(); + var createHash = requireBrowser$9(); + var withPublic = requireWithPublic(); + var Buffer2 = requireSafeBuffer$1().Buffer; + privateDecrypt = function privateDecrypt2(privateKey, enc, reverse) { + var padding; + if (privateKey.padding) { + padding = privateKey.padding; + } else if (reverse) { + padding = 1; + } else { + padding = 4; + } + var key2 = parseKeys(privateKey); + var k = key2.modulus.byteLength(); + if (enc.length > k || new BN(enc).cmp(key2.modulus) >= 0) { + throw new Error("decryption error"); + } + var msg; + if (reverse) { + msg = withPublic(new BN(enc), key2); + } else { + msg = crt(enc, key2); + } + var zBuffer = Buffer2.alloc(k - msg.length); + msg = Buffer2.concat([zBuffer, msg], k); + if (padding === 4) { + return oaep(key2, msg); + } else if (padding === 1) { + return pkcs1(key2, msg, reverse); + } else if (padding === 3) { + return msg; + } else { + throw new Error("unknown padding"); + } + }; + function oaep(key2, msg) { + var k = key2.modulus.byteLength(); + var iHash = createHash("sha1").update(Buffer2.alloc(0)).digest(); + var hLen = iHash.length; + if (msg[0] !== 0) { + throw new Error("decryption error"); + } + var maskedSeed = msg.slice(1, hLen + 1); + var maskedDb = msg.slice(hLen + 1); + var seed = xor2(maskedSeed, mgf2(maskedDb, hLen)); + var db = xor2(maskedDb, mgf2(seed, k - hLen - 1)); + if (compare(iHash, db.slice(0, hLen))) { + throw new Error("decryption error"); + } + var i2 = hLen; + while (db[i2] === 0) { + i2++; + } + if (db[i2++] !== 1) { + throw new Error("decryption error"); + } + return db.slice(i2); + } + function pkcs1(key2, msg, reverse) { + var p1 = msg.slice(0, 2); + var i2 = 2; + var status = 0; + while (msg[i2++] !== 0) { + if (i2 >= msg.length) { + status++; + break; + } + } + var ps = msg.slice(2, i2 - 1); + if (p1.toString("hex") !== "0002" && !reverse || p1.toString("hex") !== "0001" && reverse) { + status++; + } + if (ps.length < 8) { + status++; + } + if (status) { + throw new Error("decryption error"); + } + return msg.slice(i2); + } + function compare(a, b) { + a = Buffer2.from(a); + b = Buffer2.from(b); + var dif = 0; + var len2 = a.length; + if (a.length !== b.length) { + dif++; + len2 = Math.min(a.length, b.length); + } + var i2 = -1; + while (++i2 < len2) { + dif += a[i2] ^ b[i2]; + } + return dif; + } + return privateDecrypt; +} +var hasRequiredBrowser$1; +function requireBrowser$1() { + if (hasRequiredBrowser$1) return browser$1; + hasRequiredBrowser$1 = 1; + (function(exports2) { + exports2.publicEncrypt = requirePublicEncrypt(); + exports2.privateDecrypt = requirePrivateDecrypt(); + exports2.privateEncrypt = function privateEncrypt(key2, buf) { + return exports2.publicEncrypt(key2, buf, true); + }; + exports2.publicDecrypt = function publicDecrypt(key2, buf) { + return exports2.privateDecrypt(key2, buf, true); + }; + })(browser$1); + return browser$1; +} +var browser = {}; +var hasRequiredBrowser; +function requireBrowser() { + if (hasRequiredBrowser) return browser; + hasRequiredBrowser = 1; + function oldBrowser() { + throw new Error("secure random number generation not supported by this browser\nuse chrome, FireFox or Internet Explorer 11"); + } + var safeBuffer2 = requireSafeBuffer$1(); + var randombytes = requireBrowser$b(); + var Buffer2 = safeBuffer2.Buffer; + var kBufferMaxLength = safeBuffer2.kMaxLength; + var crypto = commonjsGlobal.crypto || commonjsGlobal.msCrypto; + var kMaxUint32 = Math.pow(2, 32) - 1; + function assertOffset(offset, length) { + if (typeof offset !== "number" || offset !== offset) { + throw new TypeError("offset must be a number"); + } + if (offset > kMaxUint32 || offset < 0) { + throw new TypeError("offset must be a uint32"); + } + if (offset > kBufferMaxLength || offset > length) { + throw new RangeError("offset out of range"); + } + } + function assertSize(size, offset, length) { + if (typeof size !== "number" || size !== size) { + throw new TypeError("size must be a number"); + } + if (size > kMaxUint32 || size < 0) { + throw new TypeError("size must be a uint32"); + } + if (size + offset > length || size > kBufferMaxLength) { + throw new RangeError("buffer too small"); + } + } + if (crypto && crypto.getRandomValues || !process$1.browser) { + browser.randomFill = randomFill; + browser.randomFillSync = randomFillSync; + } else { + browser.randomFill = oldBrowser; + browser.randomFillSync = oldBrowser; + } + function randomFill(buf, offset, size, cb) { + if (!Buffer2.isBuffer(buf) && !(buf instanceof commonjsGlobal.Uint8Array)) { + throw new TypeError('"buf" argument must be a Buffer or Uint8Array'); + } + if (typeof offset === "function") { + cb = offset; + offset = 0; + size = buf.length; + } else if (typeof size === "function") { + cb = size; + size = buf.length - offset; + } else if (typeof cb !== "function") { + throw new TypeError('"cb" argument must be a function'); + } + assertOffset(offset, buf.length); + assertSize(size, offset, buf.length); + return actualFill(buf, offset, size, cb); + } + function actualFill(buf, offset, size, cb) { + if (process$1.browser) { + var ourBuf = buf.buffer; + var uint = new Uint8Array(ourBuf, offset, size); + crypto.getRandomValues(uint); + if (cb) { + process$1.nextTick(function() { + cb(null, buf); + }); + return; + } + return buf; + } + if (cb) { + randombytes(size, function(err, bytes2) { + if (err) { + return cb(err); + } + bytes2.copy(buf, offset); + cb(null, buf); + }); + return; + } + var bytes = randombytes(size); + bytes.copy(buf, offset); + return buf; + } + function randomFillSync(buf, offset, size) { + if (typeof offset === "undefined") { + offset = 0; + } + if (!Buffer2.isBuffer(buf) && !(buf instanceof commonjsGlobal.Uint8Array)) { + throw new TypeError('"buf" argument must be a Buffer or Uint8Array'); + } + assertOffset(offset, buf.length); + if (size === void 0) size = buf.length - offset; + assertSize(size, offset, buf.length); + return actualFill(buf, offset, size); + } + return browser; +} +var hasRequiredCryptoBrowserify; +function requireCryptoBrowserify() { + if (hasRequiredCryptoBrowserify) return cryptoBrowserify; + hasRequiredCryptoBrowserify = 1; + cryptoBrowserify.randomBytes = cryptoBrowserify.rng = cryptoBrowserify.pseudoRandomBytes = cryptoBrowserify.prng = requireBrowser$b(); + cryptoBrowserify.createHash = cryptoBrowserify.Hash = requireBrowser$9(); + cryptoBrowserify.createHmac = cryptoBrowserify.Hmac = requireBrowser$8(); + var algos2 = requireAlgos(); + var algoKeys = Object.keys(algos2); + var hashes = [ + "sha1", + "sha224", + "sha256", + "sha384", + "sha512", + "md5", + "rmd160" + ].concat(algoKeys); + cryptoBrowserify.getHashes = function() { + return hashes; + }; + var p = requireBrowser$7(); + cryptoBrowserify.pbkdf2 = p.pbkdf2; + cryptoBrowserify.pbkdf2Sync = p.pbkdf2Sync; + var aes2 = requireBrowser$5(); + cryptoBrowserify.Cipher = aes2.Cipher; + cryptoBrowserify.createCipher = aes2.createCipher; + cryptoBrowserify.Cipheriv = aes2.Cipheriv; + cryptoBrowserify.createCipheriv = aes2.createCipheriv; + cryptoBrowserify.Decipher = aes2.Decipher; + cryptoBrowserify.createDecipher = aes2.createDecipher; + cryptoBrowserify.Decipheriv = aes2.Decipheriv; + cryptoBrowserify.createDecipheriv = aes2.createDecipheriv; + cryptoBrowserify.getCiphers = aes2.getCiphers; + cryptoBrowserify.listCiphers = aes2.listCiphers; + var dh2 = requireBrowser$4(); + cryptoBrowserify.DiffieHellmanGroup = dh2.DiffieHellmanGroup; + cryptoBrowserify.createDiffieHellmanGroup = dh2.createDiffieHellmanGroup; + cryptoBrowserify.getDiffieHellman = dh2.getDiffieHellman; + cryptoBrowserify.createDiffieHellman = dh2.createDiffieHellman; + cryptoBrowserify.DiffieHellman = dh2.DiffieHellman; + var sign2 = requireBrowser$3(); + cryptoBrowserify.createSign = sign2.createSign; + cryptoBrowserify.Sign = sign2.Sign; + cryptoBrowserify.createVerify = sign2.createVerify; + cryptoBrowserify.Verify = sign2.Verify; + cryptoBrowserify.createECDH = requireBrowser$2(); + var publicEncrypt2 = requireBrowser$1(); + cryptoBrowserify.publicEncrypt = publicEncrypt2.publicEncrypt; + cryptoBrowserify.privateEncrypt = publicEncrypt2.privateEncrypt; + cryptoBrowserify.publicDecrypt = publicEncrypt2.publicDecrypt; + cryptoBrowserify.privateDecrypt = publicEncrypt2.privateDecrypt; + var rf = requireBrowser(); + cryptoBrowserify.randomFill = rf.randomFill; + cryptoBrowserify.randomFillSync = rf.randomFillSync; + cryptoBrowserify.createCredentials = function() { + throw new Error("sorry, createCredentials is not implemented yet\nwe accept pull requests\nhttps://github.com/browserify/crypto-browserify"); + }; + cryptoBrowserify.constants = { + DH_CHECK_P_NOT_SAFE_PRIME: 2, + DH_CHECK_P_NOT_PRIME: 1, + DH_UNABLE_TO_CHECK_GENERATOR: 4, + DH_NOT_SUITABLE_GENERATOR: 8, + NPN_ENABLED: 1, + ALPN_ENABLED: 1, + RSA_PKCS1_PADDING: 1, + RSA_SSLV23_PADDING: 2, + RSA_NO_PADDING: 3, + RSA_PKCS1_OAEP_PADDING: 4, + RSA_X931_PADDING: 5, + RSA_PKCS1_PSS_PADDING: 6, + POINT_CONVERSION_COMPRESSED: 2, + POINT_CONVERSION_UNCOMPRESSED: 4, + POINT_CONVERSION_HYBRID: 6 + }; + return cryptoBrowserify; +} +const version = "17.2.0"; +const require$$4 = { + version +}; +var hasRequiredMain; +function requireMain() { + if (hasRequiredMain) return main.exports; + hasRequiredMain = 1; + const fs = require$$0$1; + const path = requirePathBrowserify(); + const os = requireBrowser$c(); + const crypto = requireCryptoBrowserify(); + const packageJson = require$$4; + const version2 = packageJson.version; + const TIPS = [ + "🔐 encrypt with dotenvx: https://dotenvx.com", + "🔐 prevent committing .env to code: https://dotenvx.com/precommit", + "🔐 prevent building .env in docker: https://dotenvx.com/prebuild", + "🛠️ run anywhere with `dotenvx run -- yourcommand`", + "⚙️ specify custom .env file path with { path: '/custom/path/.env' }", + "⚙️ enable debug logging with { debug: true }", + "⚙️ override existing env vars with { override: true }", + "⚙️ suppress all logs with { quiet: true }", + "⚙️ write to custom object with { processEnv: myObject }", + "⚙️ load multiple .env files with { path: ['.env.local', '.env'] }" + ]; + function _getRandomTip() { + return TIPS[Math.floor(Math.random() * TIPS.length)]; + } + function parseBoolean(value) { + if (typeof value === "string") { + return !["false", "0", "no", "off", ""].includes(value.toLowerCase()); + } + return Boolean(value); + } + function supportsAnsi() { + return process$1.stdout.isTTY; + } + function dim(text) { + return supportsAnsi() ? `\x1B[2m${text}\x1B[0m` : text; + } + const LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg; + function parse2(src) { + const obj = {}; + let lines = src.toString(); + lines = lines.replace(/\r\n?/mg, "\n"); + let match; + while ((match = LINE.exec(lines)) != null) { + const key2 = match[1]; + let value = match[2] || ""; + value = value.trim(); + const maybeQuote = value[0]; + value = value.replace(/^(['"`])([\s\S]*)\1$/mg, "$2"); + if (maybeQuote === '"') { + value = value.replace(/\\n/g, "\n"); + value = value.replace(/\\r/g, "\r"); + } + obj[key2] = value; + } + return obj; + } + function _parseVault(options) { + options = options || {}; + const vaultPath = _vaultPath(options); + options.path = vaultPath; + const result = DotenvModule.configDotenv(options); + if (!result.parsed) { + const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`); + err.code = "MISSING_DATA"; + throw err; + } + const keys = _dotenvKey(options).split(","); + const length = keys.length; + let decrypted; + for (let i2 = 0; i2 < length; i2++) { + try { + const key2 = keys[i2].trim(); + const attrs = _instructions(result, key2); + decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key); + break; + } catch (error) { + if (i2 + 1 >= length) { + throw error; + } + } + } + return DotenvModule.parse(decrypted); + } + function _warn(message) { + console.error(`[dotenv@${version2}][WARN] ${message}`); + } + function _debug(message) { + console.log(`[dotenv@${version2}][DEBUG] ${message}`); + } + function _log(message) { + console.log(`[dotenv@${version2}] ${message}`); + } + function _dotenvKey(options) { + if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) { + return options.DOTENV_KEY; + } + if (process$1.env.DOTENV_KEY && process$1.env.DOTENV_KEY.length > 0) { + return process$1.env.DOTENV_KEY; + } + return ""; + } + function _instructions(result, dotenvKey) { + let uri2; + try { + uri2 = new URL(dotenvKey); + } catch (error) { + if (error.code === "ERR_INVALID_URL") { + const err = new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development"); + err.code = "INVALID_DOTENV_KEY"; + throw err; + } + throw error; + } + const key2 = uri2.password; + if (!key2) { + const err = new Error("INVALID_DOTENV_KEY: Missing key part"); + err.code = "INVALID_DOTENV_KEY"; + throw err; + } + const environment = uri2.searchParams.get("environment"); + if (!environment) { + const err = new Error("INVALID_DOTENV_KEY: Missing environment part"); + err.code = "INVALID_DOTENV_KEY"; + throw err; + } + const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`; + const ciphertext = result.parsed[environmentKey]; + if (!ciphertext) { + const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`); + err.code = "NOT_FOUND_DOTENV_ENVIRONMENT"; + throw err; + } + return { ciphertext, key: key2 }; + } + function _vaultPath(options) { + let possibleVaultPath = null; + if (options && options.path && options.path.length > 0) { + if (Array.isArray(options.path)) { + for (const filepath of options.path) { + if (fs.existsSync(filepath)) { + possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`; + } + } + } else { + possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`; + } + } else { + possibleVaultPath = path.resolve(process$1.cwd(), ".env.vault"); + } + if (fs.existsSync(possibleVaultPath)) { + return possibleVaultPath; + } + return null; + } + function _resolveHome(envPath) { + return envPath[0] === "~" ? path.join(os.homedir(), envPath.slice(1)) : envPath; + } + function _configVault(options) { + const debug = parseBoolean(process$1.env.DOTENV_CONFIG_DEBUG || options && options.debug); + const quiet = parseBoolean(process$1.env.DOTENV_CONFIG_QUIET || options && options.quiet); + if (debug || !quiet) { + _log("Loading env from encrypted .env.vault"); + } + const parsed = DotenvModule._parseVault(options); + let processEnv = process$1.env; + if (options && options.processEnv != null) { + processEnv = options.processEnv; + } + DotenvModule.populate(processEnv, parsed, options); + return { parsed }; + } + function configDotenv(options) { + const dotenvPath = path.resolve(process$1.cwd(), ".env"); + let encoding = "utf8"; + let processEnv = process$1.env; + if (options && options.processEnv != null) { + processEnv = options.processEnv; + } + let debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || options && options.debug); + let quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || options && options.quiet); + if (options && options.encoding) { + encoding = options.encoding; + } else { + if (debug) { + _debug("No encoding is specified. UTF-8 is used by default"); + } + } + let optionPaths = [dotenvPath]; + if (options && options.path) { + if (!Array.isArray(options.path)) { + optionPaths = [_resolveHome(options.path)]; + } else { + optionPaths = []; + for (const filepath of options.path) { + optionPaths.push(_resolveHome(filepath)); + } + } + } + let lastError; + const parsedAll = {}; + for (const path2 of optionPaths) { + try { + const parsed = DotenvModule.parse(fs.readFileSync(path2, { encoding })); + DotenvModule.populate(parsedAll, parsed, options); + } catch (e) { + if (debug) { + _debug(`Failed to load ${path2} ${e.message}`); + } + lastError = e; + } + } + const populated = DotenvModule.populate(processEnv, parsedAll, options); + debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || debug); + quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || quiet); + if (debug || !quiet) { + const keysCount = Object.keys(populated).length; + const shortPaths = []; + for (const filePath of optionPaths) { + try { + const relative = path.relative(process$1.cwd(), filePath); + shortPaths.push(relative); + } catch (e) { + if (debug) { + _debug(`Failed to load ${filePath} ${e.message}`); + } + lastError = e; + } + } + _log(`injecting env (${keysCount}) from ${shortPaths.join(",")} ${dim(`(tip: ${_getRandomTip()})`)}`); + } + if (lastError) { + return { parsed: parsedAll, error: lastError }; + } else { + return { parsed: parsedAll }; + } + } + function config2(options) { + if (_dotenvKey(options).length === 0) { + return DotenvModule.configDotenv(options); + } + const vaultPath = _vaultPath(options); + if (!vaultPath) { + _warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`); + return DotenvModule.configDotenv(options); + } + return DotenvModule._configVault(options); + } + function decrypt(encrypted, keyStr) { + const key2 = Buffer.from(keyStr.slice(-64), "hex"); + let ciphertext = Buffer.from(encrypted, "base64"); + const nonce = ciphertext.subarray(0, 12); + const authTag = ciphertext.subarray(-16); + ciphertext = ciphertext.subarray(12, -16); + try { + const aesgcm = crypto.createDecipheriv("aes-256-gcm", key2, nonce); + aesgcm.setAuthTag(authTag); + return `${aesgcm.update(ciphertext)}${aesgcm.final()}`; + } catch (error) { + const isRange = error instanceof RangeError; + const invalidKeyLength = error.message === "Invalid key length"; + const decryptionFailed = error.message === "Unsupported state or unable to authenticate data"; + if (isRange || invalidKeyLength) { + const err = new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)"); + err.code = "INVALID_DOTENV_KEY"; + throw err; + } else if (decryptionFailed) { + const err = new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY"); + err.code = "DECRYPTION_FAILED"; + throw err; + } else { + throw error; + } + } + } + function populate(processEnv, parsed, options = {}) { + const debug = Boolean(options && options.debug); + const override = Boolean(options && options.override); + const populated = {}; + if (typeof parsed !== "object") { + const err = new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate"); + err.code = "OBJECT_REQUIRED"; + throw err; + } + for (const key2 of Object.keys(parsed)) { + if (Object.prototype.hasOwnProperty.call(processEnv, key2)) { + if (override === true) { + processEnv[key2] = parsed[key2]; + populated[key2] = parsed[key2]; + } + if (debug) { + if (override === true) { + _debug(`"${key2}" is already defined and WAS overwritten`); + } else { + _debug(`"${key2}" is already defined and was NOT overwritten`); + } + } + } else { + processEnv[key2] = parsed[key2]; + populated[key2] = parsed[key2]; + } + } + return populated; + } + const DotenvModule = { + configDotenv, + _configVault, + _parseVault, + config: config2, + decrypt, + parse: parse2, + populate + }; + main.exports.configDotenv = DotenvModule.configDotenv; + main.exports._configVault = DotenvModule._configVault; + main.exports._parseVault = DotenvModule._parseVault; + main.exports.config = DotenvModule.config; + main.exports.decrypt = DotenvModule.decrypt; + main.exports.parse = DotenvModule.parse; + main.exports.populate = DotenvModule.populate; + main.exports = DotenvModule; + return main.exports; +} +var envOptions; +var hasRequiredEnvOptions; +function requireEnvOptions() { + if (hasRequiredEnvOptions) return envOptions; + hasRequiredEnvOptions = 1; + const options = {}; + if (process$1.env.DOTENV_CONFIG_ENCODING != null) { + options.encoding = process$1.env.DOTENV_CONFIG_ENCODING; + } + if (process$1.env.DOTENV_CONFIG_PATH != null) { + options.path = process$1.env.DOTENV_CONFIG_PATH; + } + if (process$1.env.DOTENV_CONFIG_QUIET != null) { + options.quiet = process$1.env.DOTENV_CONFIG_QUIET; + } + if (process$1.env.DOTENV_CONFIG_DEBUG != null) { + options.debug = process$1.env.DOTENV_CONFIG_DEBUG; + } + if (process$1.env.DOTENV_CONFIG_OVERRIDE != null) { + options.override = process$1.env.DOTENV_CONFIG_OVERRIDE; + } + if (process$1.env.DOTENV_CONFIG_DOTENV_KEY != null) { + options.DOTENV_KEY = process$1.env.DOTENV_CONFIG_DOTENV_KEY; + } + envOptions = options; + return envOptions; +} +var cliOptions; +var hasRequiredCliOptions; +function requireCliOptions() { + if (hasRequiredCliOptions) return cliOptions; + hasRequiredCliOptions = 1; + const re = /^dotenv_config_(encoding|path|quiet|debug|override|DOTENV_KEY)=(.+)$/; + cliOptions = function optionMatcher(args) { + const options = args.reduce(function(acc, cur) { + const matches = cur.match(re); + if (matches) { + acc[matches[1]] = matches[2]; + } + return acc; + }, {}); + if (!("quiet" in options)) { + options.quiet = "true"; + } + return options; + }; + return cliOptions; +} +var hasRequiredConfig; +function requireConfig() { + if (hasRequiredConfig) return config; + hasRequiredConfig = 1; + (function() { + requireMain().config( + Object.assign( + {}, + requireEnvOptions(), + requireCliOptions()(process$1.argv) + ) + ); + })(); + return config; +} +requireConfig(); +const hoodi = viem.defineChain({ + id: 560048, + name: "Hoodi", + rpcUrls: { + default: { + http: ["https://rpc.hoodi.ethpandaops.io"] + } + }, + nativeCurrency: { + name: "Hoodi Ether", + symbol: "ETH", + decimals: 18 + }, + testnet: true +}); +const chains = { + hoodi +}; +const chainIds = [hoodi.id]; +const networks = ["hoodi"]; +const bam_graph_endpoints = { + [hoodi.id]: "https://api.studio.thegraph.com/query/71118/ssv-network-hoodi/version/latest/" +}; +const bam_paid_graph_endpoints = { + [hoodi.id]: "https://gateway.thegraph.com/api/subgraphs/id/F4AU5vPCuKfHvnLsusibxJEiTN7ELCoYTvnzg3YHGYbh" +}; +const contracts = { + [hoodi.id]: { + bapp: "0xc7fCFeEc5FB9962bDC2234A7a25dCec739e27f9f" + } +}; +const BAppABI = [ + { inputs: [], stateMutability: "nonpayable", type: "constructor" }, + { + inputs: [{ internalType: "address", name: "target", type: "address" }], + name: "AddressEmptyCode", + type: "error" + }, + { inputs: [], name: "BAppAlreadyOptedIn", type: "error" }, + { inputs: [], name: "BAppAlreadyRegistered", type: "error" }, + { inputs: [], name: "BAppDoesNotSupportInterface", type: "error" }, + { inputs: [], name: "BAppNotOptedIn", type: "error" }, + { inputs: [], name: "BAppNotRegistered", type: "error" }, + { inputs: [], name: "BAppOptInFailed", type: "error" }, + { inputs: [], name: "BAppSlashingFailed", type: "error" }, + { inputs: [], name: "DelegationAlreadyExists", type: "error" }, + { inputs: [], name: "DelegationDoesNotExist", type: "error" }, + { inputs: [], name: "DelegationExistsWithSameValue", type: "error" }, + { + inputs: [{ internalType: "address", name: "implementation", type: "address" }], + name: "ERC1967InvalidImplementation", + type: "error" + }, + { inputs: [], name: "ERC1967NonPayable", type: "error" }, + { inputs: [], name: "ExceedingMaxShares", type: "error" }, + { inputs: [], name: "ExceedingPercentageUpdate", type: "error" }, + { inputs: [], name: "FailedCall", type: "error" }, + { inputs: [], name: "FeeAlreadySet", type: "error" }, + { inputs: [], name: "InsufficientBalance", type: "error" }, + { inputs: [], name: "InsufficientLiquidity", type: "error" }, + { inputs: [], name: "InvalidAccountGeneration", type: "error" }, + { inputs: [], name: "InvalidAmount", type: "error" }, + { + inputs: [ + { internalType: "address", name: "caller", type: "address" }, + { internalType: "address", name: "expectedOwner", type: "address" } + ], + name: "InvalidBAppOwner", + type: "error" + }, + { inputs: [], name: "InvalidInitialization", type: "error" }, + { inputs: [], name: "InvalidMaxFeeIncrement", type: "error" }, + { inputs: [], name: "InvalidPercentageIncrement", type: "error" }, + { inputs: [], name: "InvalidStrategyFee", type: "error" }, + { + inputs: [ + { internalType: "address", name: "caller", type: "address" }, + { internalType: "address", name: "expectedOwner", type: "address" } + ], + name: "InvalidStrategyOwner", + type: "error" + }, + { inputs: [], name: "InvalidToken", type: "error" }, + { inputs: [], name: "NoPendingFeeUpdate", type: "error" }, + { inputs: [], name: "NoPendingObligationUpdate", type: "error" }, + { inputs: [], name: "NoPendingWithdrawal", type: "error" }, + { inputs: [], name: "NotInitializing", type: "error" }, + { inputs: [], name: "ObligationAlreadySet", type: "error" }, + { inputs: [], name: "ObligationHasNotBeenCreated", type: "error" }, + { + inputs: [{ internalType: "address", name: "owner", type: "address" }], + name: "OwnableInvalidOwner", + type: "error" + }, + { + inputs: [{ internalType: "address", name: "account", type: "address" }], + name: "OwnableUnauthorizedAccount", + type: "error" + }, + { inputs: [], name: "RequestTimeExpired", type: "error" }, + { inputs: [], name: "SlashingDisabled", type: "error" }, + { + inputs: [{ internalType: "uint8", name: "moduleId", type: "uint8" }], + name: "TargetModuleDoesNotExist", + type: "error" + }, + { inputs: [], name: "TimelockNotElapsed", type: "error" }, + { + inputs: [{ internalType: "address", name: "token", type: "address" }], + name: "TokenAlreadyAddedToBApp", + type: "error" + }, + { + inputs: [{ internalType: "address", name: "token", type: "address" }], + name: "TokenNotSupportedByBApp", + type: "error" + }, + { inputs: [], name: "UUPSUnauthorizedCallContext", type: "error" }, + { + inputs: [{ internalType: "bytes32", name: "slot", type: "bytes32" }], + name: "UUPSUnsupportedProxiableUUID", + type: "error" + }, + { inputs: [], name: "WithdrawTransferFailed", type: "error" }, + { inputs: [], name: "WithdrawalsDisabled", type: "error" }, + { inputs: [], name: "ZeroAddressNotAllowed", type: "error" }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "account", + type: "address" + }, + { + indexed: false, + internalType: "string", + name: "metadataURI", + type: "string" + } + ], + name: "AccountMetadataURIUpdated", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "bApp", + type: "address" + }, + { + indexed: false, + internalType: "string", + name: "metadataURI", + type: "string" + } + ], + name: "BAppMetadataURIUpdated", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "uint32", + name: "strategyId", + type: "uint32" + }, + { + indexed: true, + internalType: "address", + name: "bApp", + type: "address" + }, + { + indexed: false, + internalType: "bytes", + name: "data", + type: "bytes" + }, + { + indexed: false, + internalType: "address[]", + name: "tokens", + type: "address[]" + }, + { + indexed: false, + internalType: "uint32[]", + name: "obligationPercentages", + type: "uint32[]" + } + ], + name: "BAppOptedInByStrategy", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "bApp", + type: "address" + }, + { + indexed: false, + internalType: "address[]", + name: "tokens", + type: "address[]" + }, + { + indexed: false, + internalType: "uint32[]", + name: "sharedRiskLevel", + type: "uint32[]" + }, + { + indexed: false, + internalType: "string", + name: "metadataURI", + type: "string" + } + ], + name: "BAppRegistered", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "bApp", + type: "address" + }, + { + components: [ + { internalType: "address", name: "token", type: "address" }, + { + internalType: "uint32", + name: "sharedRiskLevel", + type: "uint32" + } + ], + indexed: false, + internalType: "struct ICore.TokenConfig[]", + name: "tokenConfigs", + type: "tuple[]" + } + ], + name: "BAppTokensUpdated", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "delegator", + type: "address" + }, + { + indexed: true, + internalType: "address", + name: "receiver", + type: "address" + }, + { + indexed: false, + internalType: "uint32", + name: "percentage", + type: "uint32" + } + ], + name: "DelegationCreated", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "delegator", + type: "address" + }, + { + indexed: true, + internalType: "address", + name: "receiver", + type: "address" + } + ], + name: "DelegationRemoved", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "delegator", + type: "address" + }, + { + indexed: true, + internalType: "address", + name: "receiver", + type: "address" + }, + { + indexed: false, + internalType: "uint32", + name: "percentage", + type: "uint32" + } + ], + name: "DelegationUpdated", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint32", + name: "disabledFeatures", + type: "uint32" + } + ], + name: "DisabledFeaturesUpdated", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint32", + name: "feeExpireTime", + type: "uint32" + } + ], + name: "FeeExpireTimeUpdated", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint32", + name: "feeTimelockPeriod", + type: "uint32" + } + ], + name: "FeeTimelockPeriodUpdated", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint64", + name: "version", + type: "uint64" + } + ], + name: "Initialized", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint32", + name: "newMaxFeeIncrement", + type: "uint32" + } + ], + name: "MaxFeeIncrementSet", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "enum SSVCoreModules", + name: "moduleId", + type: "uint8" + }, + { + indexed: false, + internalType: "address", + name: "moduleAddress", + type: "address" + } + ], + name: "ModuleUpdated", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "uint32", + name: "strategyId", + type: "uint32" + }, + { + indexed: true, + internalType: "address", + name: "bApp", + type: "address" + }, + { + indexed: false, + internalType: "address", + name: "token", + type: "address" + }, + { + indexed: false, + internalType: "uint32", + name: "percentage", + type: "uint32" + } + ], + name: "ObligationCreated", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint32", + name: "obligationExpireTime", + type: "uint32" + } + ], + name: "ObligationExpireTimeUpdated", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint32", + name: "obligationTimelockPeriod", + type: "uint32" + } + ], + name: "ObligationTimelockPeriodUpdated", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "uint32", + name: "strategyId", + type: "uint32" + }, + { + indexed: true, + internalType: "address", + name: "bApp", + type: "address" + }, + { + indexed: false, + internalType: "address", + name: "token", + type: "address" + }, + { + indexed: false, + internalType: "uint32", + name: "percentage", + type: "uint32" + } + ], + name: "ObligationUpdateProposed", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "uint32", + name: "strategyId", + type: "uint32" + }, + { + indexed: true, + internalType: "address", + name: "bApp", + type: "address" + }, + { + indexed: false, + internalType: "address", + name: "token", + type: "address" + }, + { + indexed: false, + internalType: "uint32", + name: "percentage", + type: "uint32" + } + ], + name: "ObligationUpdated", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "previousOwner", + type: "address" + }, + { + indexed: true, + internalType: "address", + name: "newOwner", + type: "address" + } + ], + name: "OwnershipTransferStarted", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "previousOwner", + type: "address" + }, + { + indexed: true, + internalType: "address", + name: "newOwner", + type: "address" + } + ], + name: "OwnershipTransferred", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "token", + type: "address" + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256" + } + ], + name: "SlashingFundWithdrawn", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "uint32", + name: "strategyId", + type: "uint32" + }, + { + indexed: true, + internalType: "address", + name: "owner", + type: "address" + }, + { + indexed: false, + internalType: "uint32", + name: "fee", + type: "uint32" + }, + { + indexed: false, + internalType: "string", + name: "metadataURI", + type: "string" + } + ], + name: "StrategyCreated", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "uint32", + name: "strategyId", + type: "uint32" + }, + { + indexed: true, + internalType: "address", + name: "account", + type: "address" + }, + { + indexed: false, + internalType: "address", + name: "token", + type: "address" + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256" + } + ], + name: "StrategyDeposit", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "uint32", + name: "strategyId", + type: "uint32" + }, + { + indexed: false, + internalType: "address", + name: "owner", + type: "address" + }, + { + indexed: false, + internalType: "uint32", + name: "proposedFee", + type: "uint32" + } + ], + name: "StrategyFeeUpdateProposed", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "uint32", + name: "strategyId", + type: "uint32" + }, + { + indexed: false, + internalType: "address", + name: "owner", + type: "address" + }, + { + indexed: false, + internalType: "uint32", + name: "newFee", + type: "uint32" + }, + { + indexed: false, + internalType: "bool", + name: "isFast", + type: "bool" + } + ], + name: "StrategyFeeUpdated", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint32", + name: "maxFeeIncrement", + type: "uint32" + } + ], + name: "StrategyMaxFeeIncrementUpdated", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint256", + name: "maxShares", + type: "uint256" + } + ], + name: "StrategyMaxSharesUpdated", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "uint32", + name: "strategyId", + type: "uint32" + }, + { + indexed: false, + internalType: "string", + name: "metadataURI", + type: "string" + } + ], + name: "StrategyMetadataURIUpdated", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "uint32", + name: "strategyId", + type: "uint32" + }, + { + indexed: true, + internalType: "address", + name: "bApp", + type: "address" + }, + { + indexed: false, + internalType: "address", + name: "token", + type: "address" + }, + { + indexed: false, + internalType: "uint32", + name: "percentage", + type: "uint32" + }, + { + indexed: false, + internalType: "address", + name: "receiver", + type: "address" + } + ], + name: "StrategySlashed", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "uint32", + name: "strategyId", + type: "uint32" + }, + { + indexed: true, + internalType: "address", + name: "account", + type: "address" + }, + { + indexed: false, + internalType: "address", + name: "token", + type: "address" + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256" + }, + { + indexed: false, + internalType: "bool", + name: "isFast", + type: "bool" + } + ], + name: "StrategyWithdrawal", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "uint32", + name: "strategyId", + type: "uint32" + }, + { + indexed: true, + internalType: "address", + name: "account", + type: "address" + }, + { + indexed: false, + internalType: "address", + name: "token", + type: "address" + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256" + } + ], + name: "StrategyWithdrawalProposed", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint32", + name: "tokenUpdateTimelockPeriod", + type: "uint32" + } + ], + name: "TokenUpdateTimelockPeriodUpdated", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "implementation", + type: "address" + } + ], + name: "Upgraded", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint32", + name: "withdrawalExpireTime", + type: "uint32" + } + ], + name: "WithdrawalExpireTimeUpdated", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint32", + name: "withdrawalTimelockPeriod", + type: "uint32" + } + ], + name: "WithdrawalTimelockPeriodUpdated", + type: "event" + }, + { + inputs: [], + name: "UPGRADE_INTERFACE_VERSION", + outputs: [{ internalType: "string", name: "", type: "string" }], + stateMutability: "view", + type: "function" + }, + { + inputs: [], + name: "acceptOwnership", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { internalType: "address", name: "account", type: "address" }, + { internalType: "address", name: "bApp", type: "address" } + ], + name: "accountBAppStrategy", + outputs: [{ internalType: "uint32", name: "", type: "uint32" }], + stateMutability: "view", + type: "function" + }, + { + inputs: [ + { internalType: "address", name: "bApp", type: "address" }, + { internalType: "address", name: "token", type: "address" } + ], + name: "bAppTokens", + outputs: [ + { internalType: "uint32", name: "currentValue", type: "uint32" }, + { internalType: "bool", name: "isSet", type: "bool" }, + { internalType: "uint32", name: "pendingValue", type: "uint32" }, + { internalType: "uint32", name: "effectTime", type: "uint32" } + ], + stateMutability: "view", + type: "function" + }, + { + inputs: [ + { internalType: "uint32", name: "strategyId", type: "uint32" }, + { internalType: "address", name: "bApp", type: "address" }, + { internalType: "address", name: "token", type: "address" }, + { + internalType: "uint32", + name: "obligationPercentage", + type: "uint32" + } + ], + name: "createObligation", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { internalType: "uint32", name: "fee", type: "uint32" }, + { internalType: "string", name: "metadataURI", type: "string" } + ], + name: "createStrategy", + outputs: [{ internalType: "uint32", name: "strategyId", type: "uint32" }], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { internalType: "address", name: "receiver", type: "address" }, + { internalType: "uint32", name: "percentage", type: "uint32" } + ], + name: "delegateBalance", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { internalType: "address", name: "account", type: "address" }, + { internalType: "address", name: "receiver", type: "address" } + ], + name: "delegations", + outputs: [{ internalType: "uint32", name: "", type: "uint32" }], + stateMutability: "view", + type: "function" + }, + { + inputs: [ + { internalType: "uint32", name: "strategyId", type: "uint32" }, + { internalType: "contract IERC20", name: "token", type: "address" }, + { internalType: "uint256", name: "amount", type: "uint256" } + ], + name: "depositERC20", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [{ internalType: "uint32", name: "strategyId", type: "uint32" }], + name: "depositETH", + outputs: [], + stateMutability: "payable", + type: "function" + }, + { + inputs: [], + name: "disabledFeatures", + outputs: [{ internalType: "uint32", name: "", type: "uint32" }], + stateMutability: "view", + type: "function" + }, + { + inputs: [], + name: "ethAddress", + outputs: [{ internalType: "address", name: "", type: "address" }], + stateMutability: "pure", + type: "function" + }, + { + inputs: [], + name: "feeExpireTime", + outputs: [{ internalType: "uint32", name: "", type: "uint32" }], + stateMutability: "view", + type: "function" + }, + { + inputs: [], + name: "feeTimelockPeriod", + outputs: [{ internalType: "uint32", name: "", type: "uint32" }], + stateMutability: "view", + type: "function" + }, + { + inputs: [{ internalType: "uint32", name: "strategyId", type: "uint32" }], + name: "feeUpdateRequests", + outputs: [ + { internalType: "uint32", name: "percentage", type: "uint32" }, + { internalType: "uint32", name: "requestTime", type: "uint32" } + ], + stateMutability: "view", + type: "function" + }, + { + inputs: [{ internalType: "uint32", name: "strategyId", type: "uint32" }], + name: "finalizeFeeUpdate", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { internalType: "uint32", name: "strategyId", type: "uint32" }, + { internalType: "address", name: "bApp", type: "address" }, + { internalType: "address", name: "token", type: "address" } + ], + name: "finalizeUpdateObligation", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { internalType: "uint32", name: "strategyId", type: "uint32" }, + { internalType: "contract IERC20", name: "token", type: "address" } + ], + name: "finalizeWithdrawal", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [{ internalType: "uint32", name: "strategyId", type: "uint32" }], + name: "finalizeWithdrawalETH", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "enum SSVCoreModules", + name: "moduleId", + type: "uint8" + } + ], + name: "getModuleAddress", + outputs: [{ internalType: "address", name: "", type: "address" }], + stateMutability: "view", + type: "function" + }, + { + inputs: [ + { internalType: "uint32", name: "strategyId", type: "uint32" }, + { internalType: "address", name: "bApp", type: "address" }, + { internalType: "address", name: "token", type: "address" } + ], + name: "getSlashableBalance", + outputs: [ + { + internalType: "uint256", + name: "slashableBalance", + type: "uint256" + } + ], + stateMutability: "view", + type: "function" + }, + { + inputs: [], + name: "getVersion", + outputs: [{ internalType: "string", name: "", type: "string" }], + stateMutability: "pure", + type: "function" + }, + { + inputs: [ + { internalType: "address", name: "owner_", type: "address" }, + { + internalType: "contract IBasedAppManager", + name: "ssvBasedAppManger_", + type: "address" + }, + { + internalType: "contract IStrategyManager", + name: "ssvStrategyManager_", + type: "address" + }, + { + internalType: "contract IProtocolManager", + name: "protocolManager_", + type: "address" + }, + { + components: [ + { internalType: "uint256", name: "maxShares", type: "uint256" }, + { + internalType: "uint32", + name: "feeTimelockPeriod", + type: "uint32" + }, + { + internalType: "uint32", + name: "feeExpireTime", + type: "uint32" + }, + { + internalType: "uint32", + name: "withdrawalTimelockPeriod", + type: "uint32" + }, + { + internalType: "uint32", + name: "withdrawalExpireTime", + type: "uint32" + }, + { + internalType: "uint32", + name: "obligationTimelockPeriod", + type: "uint32" + }, + { + internalType: "uint32", + name: "obligationExpireTime", + type: "uint32" + }, + { + internalType: "uint32", + name: "tokenUpdateTimelockPeriod", + type: "uint32" + }, + { + internalType: "uint32", + name: "maxFeeIncrement", + type: "uint32" + }, + { + internalType: "uint32", + name: "disabledFeatures", + type: "uint32" + } + ], + internalType: "struct ProtocolStorageLib.Data", + name: "config", + type: "tuple" + } + ], + name: "initialize", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [], + name: "maxFeeIncrement", + outputs: [{ internalType: "uint32", name: "", type: "uint32" }], + stateMutability: "view", + type: "function" + }, + { + inputs: [], + name: "maxPercentage", + outputs: [{ internalType: "uint32", name: "", type: "uint32" }], + stateMutability: "pure", + type: "function" + }, + { + inputs: [], + name: "maxShares", + outputs: [{ internalType: "uint256", name: "", type: "uint256" }], + stateMutability: "view", + type: "function" + }, + { + inputs: [], + name: "obligationExpireTime", + outputs: [{ internalType: "uint32", name: "", type: "uint32" }], + stateMutability: "view", + type: "function" + }, + { + inputs: [ + { internalType: "uint32", name: "strategyId", type: "uint32" }, + { internalType: "address", name: "token", type: "address" }, + { internalType: "address", name: "bApp", type: "address" } + ], + name: "obligationRequests", + outputs: [ + { internalType: "uint32", name: "percentage", type: "uint32" }, + { internalType: "uint32", name: "requestTime", type: "uint32" } + ], + stateMutability: "view", + type: "function" + }, + { + inputs: [], + name: "obligationTimelockPeriod", + outputs: [{ internalType: "uint32", name: "", type: "uint32" }], + stateMutability: "view", + type: "function" + }, + { + inputs: [ + { internalType: "uint32", name: "strategyId", type: "uint32" }, + { internalType: "address", name: "bApp", type: "address" }, + { internalType: "address", name: "token", type: "address" } + ], + name: "obligations", + outputs: [ + { internalType: "uint32", name: "percentage", type: "uint32" }, + { internalType: "bool", name: "isSet", type: "bool" } + ], + stateMutability: "view", + type: "function" + }, + { + inputs: [ + { internalType: "uint32", name: "strategyId", type: "uint32" }, + { internalType: "address", name: "bApp", type: "address" }, + { internalType: "address[]", name: "tokens", type: "address[]" }, + { + internalType: "uint32[]", + name: "obligationPercentages", + type: "uint32[]" + }, + { internalType: "bytes", name: "data", type: "bytes" } + ], + name: "optInToBApp", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [{ internalType: "address", name: "owner", type: "address" }], + name: "ownedStrategies", + outputs: [{ internalType: "uint32[]", name: "strategyIds", type: "uint32[]" }], + stateMutability: "view", + type: "function" + }, + { + inputs: [], + name: "owner", + outputs: [{ internalType: "address", name: "", type: "address" }], + stateMutability: "view", + type: "function" + }, + { + inputs: [], + name: "pendingOwner", + outputs: [{ internalType: "address", name: "", type: "address" }], + stateMutability: "view", + type: "function" + }, + { + inputs: [ + { internalType: "uint32", name: "strategyId", type: "uint32" }, + { internalType: "uint32", name: "proposedFee", type: "uint32" } + ], + name: "proposeFeeUpdate", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { internalType: "uint32", name: "strategyId", type: "uint32" }, + { internalType: "address", name: "bApp", type: "address" }, + { internalType: "address", name: "token", type: "address" }, + { + internalType: "uint32", + name: "obligationPercentage", + type: "uint32" + } + ], + name: "proposeUpdateObligation", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { internalType: "uint32", name: "strategyId", type: "uint32" }, + { internalType: "address", name: "token", type: "address" }, + { internalType: "uint256", name: "amount", type: "uint256" } + ], + name: "proposeWithdrawal", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { internalType: "uint32", name: "strategyId", type: "uint32" }, + { internalType: "uint256", name: "amount", type: "uint256" } + ], + name: "proposeWithdrawalETH", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [], + name: "proxiableUUID", + outputs: [{ internalType: "bytes32", name: "", type: "bytes32" }], + stateMutability: "view", + type: "function" + }, + { + inputs: [ + { internalType: "uint32", name: "strategyId", type: "uint32" }, + { internalType: "uint32", name: "proposedFee", type: "uint32" } + ], + name: "reduceFee", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { internalType: "address[]", name: "tokens", type: "address[]" }, + { + internalType: "uint32[]", + name: "sharedRiskLevels", + type: "uint32[]" + }, + { internalType: "string", name: "metadataURI", type: "string" } + ], + name: "registerBApp", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [{ internalType: "address", name: "bApp", type: "address" }], + name: "registeredBApps", + outputs: [{ internalType: "bool", name: "isRegistered", type: "bool" }], + stateMutability: "view", + type: "function" + }, + { + inputs: [{ internalType: "address", name: "receiver", type: "address" }], + name: "removeDelegatedBalance", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [], + name: "renounceOwnership", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { internalType: "uint32", name: "strategyId", type: "uint32" }, + { internalType: "address", name: "bApp", type: "address" }, + { internalType: "address", name: "token", type: "address" }, + { internalType: "uint32", name: "percentage", type: "uint32" }, + { internalType: "bytes", name: "data", type: "bytes" } + ], + name: "slash", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { internalType: "address", name: "account", type: "address" }, + { internalType: "address", name: "token", type: "address" } + ], + name: "slashingFund", + outputs: [{ internalType: "uint256", name: "", type: "uint256" }], + stateMutability: "view", + type: "function" + }, + { + inputs: [{ internalType: "uint32", name: "strategyId", type: "uint32" }], + name: "strategies", + outputs: [ + { internalType: "address", name: "strategyOwner", type: "address" }, + { internalType: "uint32", name: "fee", type: "uint32" } + ], + stateMutability: "view", + type: "function" + }, + { + inputs: [ + { internalType: "uint32", name: "strategyId", type: "uint32" }, + { internalType: "address", name: "account", type: "address" }, + { internalType: "address", name: "token", type: "address" } + ], + name: "strategyAccountShares", + outputs: [{ internalType: "uint256", name: "", type: "uint256" }], + stateMutability: "view", + type: "function" + }, + { + inputs: [ + { internalType: "uint32", name: "strategyId", type: "uint32" }, + { internalType: "address", name: "token", type: "address" } + ], + name: "strategyGeneration", + outputs: [{ internalType: "uint256", name: "", type: "uint256" }], + stateMutability: "view", + type: "function" + }, + { + inputs: [ + { internalType: "uint32", name: "strategyId", type: "uint32" }, + { internalType: "address", name: "token", type: "address" } + ], + name: "strategyTotalBalance", + outputs: [{ internalType: "uint256", name: "", type: "uint256" }], + stateMutability: "view", + type: "function" + }, + { + inputs: [ + { internalType: "uint32", name: "strategyId", type: "uint32" }, + { internalType: "address", name: "token", type: "address" } + ], + name: "strategyTotalShares", + outputs: [{ internalType: "uint256", name: "", type: "uint256" }], + stateMutability: "view", + type: "function" + }, + { + inputs: [], + name: "tokenUpdateTimelockPeriod", + outputs: [{ internalType: "uint32", name: "", type: "uint32" }], + stateMutability: "view", + type: "function" + }, + { + inputs: [{ internalType: "address", name: "delegator", type: "address" }], + name: "totalDelegatedPercentage", + outputs: [{ internalType: "uint32", name: "", type: "uint32" }], + stateMutability: "view", + type: "function" + }, + { + inputs: [{ internalType: "address", name: "newOwner", type: "address" }], + name: "transferOwnership", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [{ internalType: "string", name: "metadataURI", type: "string" }], + name: "updateAccountMetadataURI", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [{ internalType: "string", name: "metadataURI", type: "string" }], + name: "updateBAppMetadataURI", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + components: [ + { internalType: "address", name: "token", type: "address" }, + { + internalType: "uint32", + name: "sharedRiskLevel", + type: "uint32" + } + ], + internalType: "struct ICore.TokenConfig[]", + name: "tokenConfigs", + type: "tuple[]" + } + ], + name: "updateBAppsTokens", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { internalType: "address", name: "receiver", type: "address" }, + { internalType: "uint32", name: "percentage", type: "uint32" } + ], + name: "updateDelegatedBalance", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [{ internalType: "uint32", name: "disabledFeatures", type: "uint32" }], + name: "updateDisabledFeatures", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [{ internalType: "uint32", name: "value", type: "uint32" }], + name: "updateFeeExpireTime", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [{ internalType: "uint32", name: "value", type: "uint32" }], + name: "updateFeeTimelockPeriod", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [{ internalType: "uint32", name: "value", type: "uint32" }], + name: "updateMaxFeeIncrement", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [{ internalType: "uint256", name: "value", type: "uint256" }], + name: "updateMaxShares", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "enum SSVCoreModules[]", + name: "moduleIds", + type: "uint8[]" + }, + { + internalType: "address[]", + name: "moduleAddresses", + type: "address[]" + } + ], + name: "updateModule", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [{ internalType: "uint32", name: "value", type: "uint32" }], + name: "updateObligationExpireTime", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [{ internalType: "uint32", name: "value", type: "uint32" }], + name: "updateObligationTimelockPeriod", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { internalType: "uint32", name: "strategyId", type: "uint32" }, + { internalType: "string", name: "metadataURI", type: "string" } + ], + name: "updateStrategyMetadataURI", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [{ internalType: "uint32", name: "value", type: "uint32" }], + name: "updateTokenUpdateTimelockPeriod", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [{ internalType: "uint32", name: "value", type: "uint32" }], + name: "updateWithdrawalExpireTime", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [{ internalType: "uint32", name: "value", type: "uint32" }], + name: "updateWithdrawalTimelockPeriod", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "address", + name: "newImplementation", + type: "address" + }, + { internalType: "bytes", name: "data", type: "bytes" } + ], + name: "upgradeToAndCall", + outputs: [], + stateMutability: "payable", + type: "function" + }, + { + inputs: [{ internalType: "uint256", name: "amount", type: "uint256" }], + name: "withdrawETHSlashingFund", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { internalType: "address", name: "token", type: "address" }, + { internalType: "uint256", name: "amount", type: "uint256" } + ], + name: "withdrawSlashingFund", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [], + name: "withdrawalExpireTime", + outputs: [{ internalType: "uint32", name: "", type: "uint32" }], + stateMutability: "view", + type: "function" + }, + { + inputs: [ + { internalType: "uint32", name: "strategyId", type: "uint32" }, + { internalType: "address", name: "account", type: "address" }, + { internalType: "address", name: "token", type: "address" } + ], + name: "withdrawalRequests", + outputs: [ + { internalType: "uint256", name: "shares", type: "uint256" }, + { internalType: "uint32", name: "requestTime", type: "uint32" } + ], + stateMutability: "view", + type: "function" + }, + { + inputs: [], + name: "withdrawalTimelockPeriod", + outputs: [{ internalType: "uint32", name: "", type: "uint32" }], + stateMutability: "view", + type: "function" + } +]; +var symbolTag = "[object Symbol]"; +function isSymbol(value) { + return typeof value == "symbol" || tryCatch$1.isObjectLike(value) && tryCatch$1.baseGetTag(value) == symbolTag; +} +var reWhitespace = /\s/; +function trimmedEndIndex(string) { + var index = string.length; + while (index-- && reWhitespace.test(string.charAt(index))) { + } + return index; +} +var reTrimStart = /^\s+/; +function baseTrim(string) { + return string ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, "") : string; +} +var NAN = 0 / 0; +var reIsBadHex = /^[-+]0x[0-9a-f]+$/i; +var reIsBinary = /^0b[01]+$/i; +var reIsOctal = /^0o[0-7]+$/i; +var freeParseInt = parseInt; +function toNumber(value) { + if (typeof value == "number") { + return value; + } + if (isSymbol(value)) { + return NAN; + } + if (tryCatch$1.isObject(value)) { + var other = typeof value.valueOf == "function" ? value.valueOf() : value; + value = tryCatch$1.isObject(other) ? other + "" : other; + } + if (typeof value != "string") { + return value === 0 ? value : +value; + } + value = baseTrim(value); + var isBinary = reIsBinary.test(value); + return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value; +} +var INFINITY = 1 / 0, MAX_INTEGER = 17976931348623157e292; +function toFinite(value) { + if (!value) { + return value === 0 ? value : 0; + } + value = toNumber(value); + if (value === INFINITY || value === -INFINITY) { + var sign2 = value < 0 ? -1 : 1; + return sign2 * MAX_INTEGER; + } + return value === value ? value : 0; +} +function toInteger(value) { + var result = toFinite(value), remainder = result % 1; + return result === result ? remainder ? result - remainder : result : 0; +} +function baseSlice(array, start, end) { + var index = -1, length = array.length; + if (start < 0) { + start = -start > length ? 0 : length + start; + } + end = end > length ? length : end; + if (end < 0) { + end += length; + } + length = start > end ? 0 : end - start >>> 0; + start >>>= 0; + var result = Array(length); + while (++index < length) { + result[index] = array[index + start]; + } + return result; +} +var nativeCeil = Math.ceil, nativeMax = Math.max; +function chunk(array, size, guard) { + if (size === void 0) { + size = 1; + } else { + size = nativeMax(toInteger(size), 0); + } + var length = array == null ? 0 : array.length; + if (!length || size < 1) { + return []; + } + var index = 0, resIndex = 0, result = Array(nativeCeil(length / size)); + while (index < length) { + result[resIndex++] = baseSlice(array, index, index += size); + } + return result; +} +const getValidatorsBalance = async (apis, args) => { + const validators = await apis.bam.getValidatorsByAccount(args); + if (!validators.length) + return { + account: args.account, + validators: [], + balance: 0n + }; + const chunks = chunk(validators, 500); + const results = await Promise.all( + chunks.map( + (chunk2) => apis.beacon.getValidatorBalances({ + stateId: "head", + validatorIds: chunk2 + }) + ) + ); + const data = results.flatMap((v) => v.data); + const totalBalance = viem.parseGwei( + data.reduce((acc, v) => { + return acc + BigInt(v.balance); + }, 0n).toString() + ); + return { + account: args.account, + validators, + balance: totalBalance + }; +}; +const getParticipantWeights = async (apis, args) => { + const bAppData = await apis.bam.getParticipantWeightInput(args); + if (!bAppData) { + throw new Error("bApp not found"); + } + const strategyWeightsMap = /* @__PURE__ */ new Map(); + const riskByTokenAndStrategy = /* @__PURE__ */ new Map(); + for (const strategyData of bAppData.strategies) { + const strategy = strategyData.strategy; + strategyWeightsMap.set(strategy.id, { + id: strategy.id, + tokenWeights: [] + }); + const tokenRisks = /* @__PURE__ */ new Map(); + for (const obligation of strategyData.obligations) { + const token = obligation.token.toLowerCase(); + const currentRisk = tokenRisks.get(token) ?? 0; + tokenRisks.set(token, currentRisk + Number(obligation.percentage) / 1e4); + } + for (const [token, risk] of tokenRisks) { + if (!riskByTokenAndStrategy.has(token)) { + riskByTokenAndStrategy.set(token, /* @__PURE__ */ new Map()); + } + riskByTokenAndStrategy.get(token).set(strategy.id, risk); + } + } + for (const bAppToken of bAppData.bAppTokens) { + const token = bAppToken.token; + const tokenLower = token.toLowerCase(); + const beta = Number(bAppToken.sharedRiskLevel) / 1e4; + const totalObligatedBalance = BigInt(bAppToken.totalObligatedBalance); + if (totalObligatedBalance === 0n) continue; + let normalizationDenominator = 0; + const tempWeights = []; + for (const strategyData of bAppData.strategies) { + const strategy = strategyData.strategy; + const strategyId = strategy.id; + const obligation = strategyData.obligations.find( + (ob) => ob.token.toLowerCase() === tokenLower + ); + if (!obligation) continue; + const balance = strategy.balances.find((bal) => bal.token.toLowerCase() === tokenLower); + if (!balance) continue; + const obligatedBalance = BigInt(obligation.obligatedBalance); + const risk = Math.max(1, riskByTokenAndStrategy.get(tokenLower)?.get(strategyId) ?? 0); + const exponentialTerm = Math.exp(-beta * risk); + const term = Number(obligatedBalance) / Number(totalObligatedBalance) * exponentialTerm; + normalizationDenominator += term; + tempWeights.push({ + strategyId, + weight: term + }); + } + const cToken = normalizationDenominator === 0 ? 0 : 1 / normalizationDenominator; + for (const { strategyId, weight } of tempWeights) { + const strategyWeight = strategyWeightsMap.get(strategyId); + if (strategyWeight) { + strategyWeight.tokenWeights.push({ + token, + weight: weight * cToken + }); + } + } + } + const delegatedBalances = /* @__PURE__ */ new Map(); + let totalBAppBalance = 0; + for (const strategyData of bAppData.strategies) { + const strategy = strategyData.strategy; + if (!strategy.owner.delegators.length) continue; + const balances = await Promise.all( + strategy.owner.delegators.filter((d) => Number(d.percentage) > 0).map(async (delegator) => { + const response = await getValidatorsBalance(apis, { + account: delegator.delegator.id + }); + return { + delegated: Number(response.balance) * Number(delegator.percentage) / 1e4 + }; + }) + ); + const delegatedBalance = balances.reduce((acc, balance) => acc + balance.delegated, 0); + delegatedBalances.set(strategy.id, delegatedBalance); + totalBAppBalance += delegatedBalance; + } + for (const [strategyId, delegatedBalance] of delegatedBalances.entries()) { + const strategyWeight = strategyWeightsMap.get(strategyId); + if (strategyWeight) { + strategyWeight.validatorBalanceWeight = Number(delegatedBalance) / Number(totalBAppBalance); + } + } + return Array.from(strategyWeightsMap.values()); +}; +const getDelegatedBalances = async (apis, args) => { + const bAppDelegators = await apis.bam.getBAppDelegators(args); + if (!bAppDelegators) + return { + bAppTotalDelegatedBalance: 0n, + bAppTotalDelegatedBalances: [] + }; + const bAppTotalDelegatedBalances = await Promise.all( + bAppDelegators.strategies.map(async (strategy) => { + const delegation = (await Promise.all( + strategy.strategy.owner.delegators.map(async (d) => { + const data = await getValidatorsBalance(apis, { + account: d.delegator.id + }); + return data.balance * BigInt(d.percentage) / 10000n; + }) + )).reduce((acc, balance) => acc + balance, 0n); + return { + strategyId: strategy.strategy.id, + delegation + }; + }) + ); + const bAppTotalDelegatedBalance = bAppTotalDelegatedBalances.reduce( + (acc, balance) => acc + balance.delegation, + 0n + ); + return { + bAppTotalDelegatedBalance, + bAppTotalDelegatedBalances + }; +}; +const getObligatedBalances$1 = async (apis, args) => { + const bAppObligations = await apis.bam.getObligatedBalances(args); + if (!bAppObligations) return []; + return bAppObligations; +}; +const getBasedAppsAPI = (apis) => { + return { + getValidatorsBalance: getValidatorsBalance.bind(null, apis), + getParticipantWeights: getParticipantWeights.bind(null, apis), + getDelegatedBalances: getDelegatedBalances.bind(null, apis), + getObligatedBalances: getObligatedBalances$1.bind(null, apis) + }; +}; +function normalize(strArray) { + const resultArray = []; + if (strArray.length === 0) { + return ""; + } + strArray = strArray.filter((part) => part !== ""); + if (typeof strArray[0] !== "string") { + throw new TypeError("Url must be a string. Received " + strArray[0]); + } + if (strArray[0].match(/^[^/:]+:\/*$/) && strArray.length > 1) { + strArray[0] = strArray.shift() + strArray[0]; + } + if (strArray[0] === "/" && strArray.length > 1) { + strArray[0] = strArray.shift() + strArray[0]; + } + if (strArray[0].match(/^file:\/\/\//)) { + strArray[0] = strArray[0].replace(/^([^/:]+):\/*/, "$1:///"); + } else if (!strArray[0].match(/^\[.*:.*\]/)) { + strArray[0] = strArray[0].replace(/^([^/:]+):\/*/, "$1://"); + } + for (let i2 = 0; i2 < strArray.length; i2++) { + let component = strArray[i2]; + if (typeof component !== "string") { + throw new TypeError("Url must be a string. Received " + component); + } + if (i2 > 0) { + component = component.replace(/^[\/]+/, ""); + } + if (i2 < strArray.length - 1) { + component = component.replace(/[\/]+$/, ""); + } else { + component = component.replace(/[\/]+$/, "/"); + } + if (component === "") { + continue; + } + resultArray.push(component); + } + let str = ""; + for (let i2 = 0; i2 < resultArray.length; i2++) { + const part = resultArray[i2]; + if (i2 === 0) { + str += part; + continue; + } + const prevPart = resultArray[i2 - 1]; + if (prevPart && prevPart.endsWith("?") || prevPart.endsWith("#")) { + str += part; + continue; + } + str += "/" + part; + } + str = str.replace(/\/(\?|&|#[^!])/g, "$1"); + const [beforeHash, afterHash] = str.split("#"); + const parts = beforeHash.split(/(?:\?|&)+/).filter(Boolean); + str = parts.shift() + (parts.length > 0 ? "?" : "") + parts.join("&") + (afterHash && afterHash.length > 0 ? "#" + afterHash : ""); + return str; +} +function urlJoin(...args) { + const parts = Array.from(Array.isArray(args[0]) ? args[0] : args); + return normalize(parts); +} +const getValidatorBalances = (baseApi, args) => { + return fetch(urlJoin(baseApi, `/eth/v1/beacon/states/${args.stateId}/validator_balances`), { + method: "POST", + headers: { + "Content-Type": "application/json" + }, + body: JSON.stringify(args.validatorIds) + }).then((res) => res.json()); +}; +const getBeaconChainAPI = (endpoint) => { + return { + getValidatorBalances: getValidatorBalances.bind(null, endpoint) + }; +}; +const checkOperatorDKGEnabled = (baseApi, dkgAddresses) => { + return fetch(urlJoin(baseApi, `/operators/dkg_health_check`), { + method: "POST", + headers: { + "Content-Type": "application/json" + }, + body: JSON.stringify({ + dkgAddresses + }) + }).then( + (res) => res.json() + ); +}; +const getSSVAPI = (endpoint) => { + return { + checkOperatorDKGEnabled: checkOperatorDKGEnabled.bind(null, endpoint) + }; +}; +const GetStrategyBAppOptInsDocument = { + kind: "Document", + definitions: [ + { + kind: "OperationDefinition", + operation: "query", + name: { kind: "Name", value: "GetStrategyBAppOptIns" }, + variableDefinitions: [ + { + kind: "VariableDefinition", + variable: { kind: "Variable", name: { kind: "Name", value: "bAppId" } }, + type: { + kind: "NonNullType", + type: { kind: "NamedType", name: { kind: "Name", value: "Bytes" } } + } + } + ], + selectionSet: { + kind: "SelectionSet", + selections: [ + { + kind: "Field", + name: { kind: "Name", value: "strategyBAppOptIns" }, + arguments: [ + { + kind: "Argument", + name: { kind: "Name", value: "where" }, + value: { + kind: "ObjectValue", + fields: [ + { + kind: "ObjectField", + name: { kind: "Name", value: "bApp_" }, + value: { + kind: "ObjectValue", + fields: [ + { + kind: "ObjectField", + name: { kind: "Name", value: "id" }, + value: { kind: "Variable", name: { kind: "Name", value: "bAppId" } } + } + ] + } + } + ] + } + } + ], + selectionSet: { + kind: "SelectionSet", + selections: [ + { kind: "Field", name: { kind: "Name", value: "id" } }, + { + kind: "Field", + name: { kind: "Name", value: "strategy" }, + selectionSet: { + kind: "SelectionSet", + selections: [ + { + kind: "Field", + name: { kind: "Name", value: "balances" }, + selectionSet: { + kind: "SelectionSet", + selections: [ + { kind: "Field", name: { kind: "Name", value: "token" } }, + { kind: "Field", name: { kind: "Name", value: "balance" } } + ] + } + } + ] + } + }, + { + kind: "Field", + name: { kind: "Name", value: "obligations" }, + selectionSet: { + kind: "SelectionSet", + selections: [ + { kind: "Field", name: { kind: "Name", value: "token" } }, + { kind: "Field", name: { kind: "Name", value: "percentage" } } + ] + } + } + ] + } + } + ] + } + } + ] +}; +const GetParticipantWeightInputDocument = { + kind: "Document", + definitions: [ + { + kind: "OperationDefinition", + operation: "query", + name: { kind: "Name", value: "GetParticipantWeightInput" }, + variableDefinitions: [ + { + kind: "VariableDefinition", + variable: { kind: "Variable", name: { kind: "Name", value: "bAppId" } }, + type: { + kind: "NonNullType", + type: { kind: "NamedType", name: { kind: "Name", value: "ID" } } + } + } + ], + selectionSet: { + kind: "SelectionSet", + selections: [ + { + kind: "Field", + name: { kind: "Name", value: "bapp" }, + arguments: [ + { + kind: "Argument", + name: { kind: "Name", value: "id" }, + value: { kind: "Variable", name: { kind: "Name", value: "bAppId" } } + } + ], + selectionSet: { + kind: "SelectionSet", + selections: [ + { + kind: "Field", + name: { kind: "Name", value: "bAppTokens" }, + selectionSet: { + kind: "SelectionSet", + selections: [ + { kind: "Field", name: { kind: "Name", value: "token" } }, + { kind: "Field", name: { kind: "Name", value: "sharedRiskLevel" } }, + { kind: "Field", name: { kind: "Name", value: "totalObligatedBalance" } } + ] + } + }, + { + kind: "Field", + name: { kind: "Name", value: "strategies" }, + selectionSet: { + kind: "SelectionSet", + selections: [ + { + kind: "Field", + name: { kind: "Name", value: "obligations" }, + selectionSet: { + kind: "SelectionSet", + selections: [ + { kind: "Field", name: { kind: "Name", value: "obligatedBalance" } }, + { kind: "Field", name: { kind: "Name", value: "token" } }, + { kind: "Field", name: { kind: "Name", value: "percentage" } } + ] + } + }, + { + kind: "Field", + name: { kind: "Name", value: "strategy" }, + selectionSet: { + kind: "SelectionSet", + selections: [ + { kind: "Field", name: { kind: "Name", value: "id" } }, + { + kind: "Field", + name: { kind: "Name", value: "owner" }, + selectionSet: { + kind: "SelectionSet", + selections: [ + { kind: "Field", name: { kind: "Name", value: "id" } }, + { + kind: "Field", + name: { kind: "Name", value: "delegators" }, + selectionSet: { + kind: "SelectionSet", + selections: [ + { + kind: "Field", + name: { kind: "Name", value: "percentage" } + }, + { + kind: "Field", + name: { kind: "Name", value: "delegator" }, + selectionSet: { + kind: "SelectionSet", + selections: [ + { + kind: "Field", + name: { kind: "Name", value: "id" } + } + ] + } + } + ] + } + } + ] + } + }, + { + kind: "Field", + name: { kind: "Name", value: "balances" }, + selectionSet: { + kind: "SelectionSet", + selections: [ + { kind: "Field", name: { kind: "Name", value: "token" } }, + { kind: "Field", name: { kind: "Name", value: "riskValue" } } + ] + } + } + ] + } + } + ] + } + } + ] + } + } + ] + } + } + ] +}; +const GetObligatedBalancesDocument = { + kind: "Document", + definitions: [ + { + kind: "OperationDefinition", + operation: "query", + name: { kind: "Name", value: "GetObligatedBalances" }, + variableDefinitions: [ + { + kind: "VariableDefinition", + variable: { kind: "Variable", name: { kind: "Name", value: "bAppId" } }, + type: { + kind: "NonNullType", + type: { kind: "NamedType", name: { kind: "Name", value: "ID" } } + } + } + ], + selectionSet: { + kind: "SelectionSet", + selections: [ + { + kind: "Field", + name: { kind: "Name", value: "bapp" }, + arguments: [ + { + kind: "Argument", + name: { kind: "Name", value: "id" }, + value: { kind: "Variable", name: { kind: "Name", value: "bAppId" } } + } + ], + selectionSet: { + kind: "SelectionSet", + selections: [ + { + kind: "Field", + name: { kind: "Name", value: "bAppTokens" }, + selectionSet: { + kind: "SelectionSet", + selections: [ + { kind: "Field", name: { kind: "Name", value: "totalObligatedBalance" } }, + { kind: "Field", name: { kind: "Name", value: "token" } } + ] + } + }, + { + kind: "Field", + name: { kind: "Name", value: "strategies" }, + selectionSet: { + kind: "SelectionSet", + selections: [ + { + kind: "Field", + name: { kind: "Name", value: "strategy" }, + selectionSet: { + kind: "SelectionSet", + selections: [{ kind: "Field", name: { kind: "Name", value: "id" } }] + } + }, + { + kind: "Field", + name: { kind: "Name", value: "obligations" }, + selectionSet: { + kind: "SelectionSet", + selections: [ + { kind: "Field", name: { kind: "Name", value: "token" } }, + { kind: "Field", name: { kind: "Name", value: "obligatedBalance" } } + ] + } + } + ] + } + } + ] + } + } + ] + } + } + ] +}; +const GetBAppDelegatorsDocument = { + kind: "Document", + definitions: [ + { + kind: "OperationDefinition", + operation: "query", + name: { kind: "Name", value: "GetBAppDelegators" }, + variableDefinitions: [ + { + kind: "VariableDefinition", + variable: { kind: "Variable", name: { kind: "Name", value: "bAppId" } }, + type: { + kind: "NonNullType", + type: { kind: "NamedType", name: { kind: "Name", value: "ID" } } + } + } + ], + selectionSet: { + kind: "SelectionSet", + selections: [ + { + kind: "Field", + name: { kind: "Name", value: "bapp" }, + arguments: [ + { + kind: "Argument", + name: { kind: "Name", value: "id" }, + value: { kind: "Variable", name: { kind: "Name", value: "bAppId" } } + } + ], + selectionSet: { + kind: "SelectionSet", + selections: [ + { + kind: "Field", + name: { kind: "Name", value: "strategies" }, + selectionSet: { + kind: "SelectionSet", + selections: [ + { + kind: "Field", + name: { kind: "Name", value: "strategy" }, + selectionSet: { + kind: "SelectionSet", + selections: [ + { kind: "Field", name: { kind: "Name", value: "id" } }, + { + kind: "Field", + name: { kind: "Name", value: "owner" }, + selectionSet: { + kind: "SelectionSet", + selections: [ + { + kind: "Field", + name: { kind: "Name", value: "delegators" }, + selectionSet: { + kind: "SelectionSet", + selections: [ + { + kind: "Field", + name: { kind: "Name", value: "percentage" } + }, + { + kind: "Field", + name: { kind: "Name", value: "delegator" }, + selectionSet: { + kind: "SelectionSet", + selections: [ + { + kind: "Field", + name: { kind: "Name", value: "id" } + } + ] + } + } + ] + } + } + ] + } + } + ] + } + } + ] + } + } + ] + } + } + ] + } + } + ] +}; +const GetValidatorsByAccountDocument = { + kind: "Document", + definitions: [ + { + kind: "OperationDefinition", + operation: "query", + name: { kind: "Name", value: "GetValidatorsByAccount" }, + variableDefinitions: [ + { + kind: "VariableDefinition", + variable: { kind: "Variable", name: { kind: "Name", value: "account" } }, + type: { + kind: "NonNullType", + type: { kind: "NamedType", name: { kind: "Name", value: "String" } } + } + } + ], + selectionSet: { + kind: "SelectionSet", + selections: [ + { + kind: "Field", + name: { kind: "Name", value: "validators" }, + arguments: [ + { + kind: "Argument", + name: { kind: "Name", value: "where" }, + value: { + kind: "ObjectValue", + fields: [ + { + kind: "ObjectField", + name: { kind: "Name", value: "owner" }, + value: { kind: "Variable", name: { kind: "Name", value: "account" } } + } + ] + } + } + ], + selectionSet: { + kind: "SelectionSet", + selections: [{ kind: "Field", name: { kind: "Name", value: "id" } }] + } + } + ] + } + } + ] +}; +const GetBappMetadataUriDocument = { + kind: "Document", + definitions: [ + { + kind: "OperationDefinition", + operation: "query", + name: { kind: "Name", value: "GetBappMetadataURI" }, + variableDefinitions: [ + { + kind: "VariableDefinition", + variable: { kind: "Variable", name: { kind: "Name", value: "bAppId" } }, + type: { + kind: "NonNullType", + type: { kind: "NamedType", name: { kind: "Name", value: "ID" } } + } + } + ], + selectionSet: { + kind: "SelectionSet", + selections: [ + { + kind: "Field", + name: { kind: "Name", value: "bapp" }, + arguments: [ + { + kind: "Argument", + name: { kind: "Name", value: "id" }, + value: { kind: "Variable", name: { kind: "Name", value: "bAppId" } } + } + ], + selectionSet: { + kind: "SelectionSet", + selections: [{ kind: "Field", name: { kind: "Name", value: "metadataURI" } }] + } + } + ] + } + } + ] +}; +const GetAllBappsMetadataUrIsDocument = { + kind: "Document", + definitions: [ + { + kind: "OperationDefinition", + operation: "query", + name: { kind: "Name", value: "GetAllBappsMetadataURIs" }, + selectionSet: { + kind: "SelectionSet", + selections: [ + { + kind: "Field", + name: { kind: "Name", value: "bapps" }, + selectionSet: { + kind: "SelectionSet", + selections: [ + { kind: "Field", name: { kind: "Name", value: "id" } }, + { kind: "Field", name: { kind: "Name", value: "metadataURI" } } + ] + } + } + ] + } + } + ] +}; +const GetAllStrategyObligatedBalancesForBappDocument = { + kind: "Document", + definitions: [ + { + kind: "OperationDefinition", + operation: "query", + name: { kind: "Name", value: "GetAllStrategyObligatedBalancesForBapp" }, + variableDefinitions: [ + { + kind: "VariableDefinition", + variable: { kind: "Variable", name: { kind: "Name", value: "bAppId" } }, + type: { + kind: "NonNullType", + type: { kind: "NamedType", name: { kind: "Name", value: "ID" } } + } + } + ], + selectionSet: { + kind: "SelectionSet", + selections: [ + { + kind: "Field", + name: { kind: "Name", value: "bapp" }, + arguments: [ + { + kind: "Argument", + name: { kind: "Name", value: "id" }, + value: { kind: "Variable", name: { kind: "Name", value: "bAppId" } } + } + ], + selectionSet: { + kind: "SelectionSet", + selections: [ + { + kind: "Field", + name: { kind: "Name", value: "strategies" }, + selectionSet: { + kind: "SelectionSet", + selections: [ + { + kind: "Field", + name: { kind: "Name", value: "strategy" }, + selectionSet: { + kind: "SelectionSet", + selections: [ + { + kind: "Field", + name: { kind: "Name", value: "balances" }, + selectionSet: { + kind: "SelectionSet", + selections: [ + { kind: "Field", name: { kind: "Name", value: "balance" } }, + { kind: "Field", name: { kind: "Name", value: "token" } } + ] + } + } + ] + } + } + ] + } + } + ] + } + } + ] + } + } + ] +}; +const GetDepositedBalancesForStrategyDocument = { + kind: "Document", + definitions: [ + { + kind: "OperationDefinition", + operation: "query", + name: { kind: "Name", value: "GetDepositedBalancesForStrategy" }, + variableDefinitions: [ + { + kind: "VariableDefinition", + variable: { kind: "Variable", name: { kind: "Name", value: "strategyId" } }, + type: { + kind: "NonNullType", + type: { kind: "NamedType", name: { kind: "Name", value: "ID" } } + } + } + ], + selectionSet: { + kind: "SelectionSet", + selections: [ + { + kind: "Field", + name: { kind: "Name", value: "strategy" }, + arguments: [ + { + kind: "Argument", + name: { kind: "Name", value: "id" }, + value: { kind: "Variable", name: { kind: "Name", value: "strategyId" } } + } + ], + selectionSet: { + kind: "SelectionSet", + selections: [ + { + kind: "Field", + name: { kind: "Name", value: "deposits" }, + selectionSet: { + kind: "SelectionSet", + selections: [ + { + kind: "Field", + name: { kind: "Name", value: "contributor" }, + selectionSet: { + kind: "SelectionSet", + selections: [{ kind: "Field", name: { kind: "Name", value: "id" } }] + } + }, + { kind: "Field", name: { kind: "Name", value: "depositAmount" } }, + { kind: "Field", name: { kind: "Name", value: "token" } } + ] + } + } + ] + } + } + ] + } + } + ] +}; +const GetAllStrategiesDepositedToDocument = { + kind: "Document", + definitions: [ + { + kind: "OperationDefinition", + operation: "query", + name: { kind: "Name", value: "GetAllStrategiesDepositedTo" }, + variableDefinitions: [ + { + kind: "VariableDefinition", + variable: { kind: "Variable", name: { kind: "Name", value: "accountId" } }, + type: { + kind: "NonNullType", + type: { kind: "NamedType", name: { kind: "Name", value: "ID" } } + } + } + ], + selectionSet: { + kind: "SelectionSet", + selections: [ + { + kind: "Field", + name: { kind: "Name", value: "account" }, + arguments: [ + { + kind: "Argument", + name: { kind: "Name", value: "id" }, + value: { kind: "Variable", name: { kind: "Name", value: "accountId" } } + } + ], + selectionSet: { + kind: "SelectionSet", + selections: [ + { + kind: "Field", + name: { kind: "Name", value: "deposits" }, + selectionSet: { + kind: "SelectionSet", + selections: [ + { + kind: "Field", + name: { kind: "Name", value: "strategy" }, + selectionSet: { + kind: "SelectionSet", + selections: [ + { kind: "Field", name: { kind: "Name", value: "id" } }, + { + kind: "Field", + name: { kind: "Name", value: "balances" }, + selectionSet: { + kind: "SelectionSet", + selections: [ + { kind: "Field", name: { kind: "Name", value: "balance" } }, + { kind: "Field", name: { kind: "Name", value: "token" } } + ] + } + } + ] + } + }, + { kind: "Field", name: { kind: "Name", value: "depositAmount" } }, + { kind: "Field", name: { kind: "Name", value: "token" } } + ] + } + } + ] + } + } + ] + } + } + ] +}; +const GetTotalDelegatedPercentageForAccountDocument = { + kind: "Document", + definitions: [ + { + kind: "OperationDefinition", + operation: "query", + name: { kind: "Name", value: "GetTotalDelegatedPercentageForAccount" }, + variableDefinitions: [ + { + kind: "VariableDefinition", + variable: { kind: "Variable", name: { kind: "Name", value: "accountId" } }, + type: { + kind: "NonNullType", + type: { kind: "NamedType", name: { kind: "Name", value: "ID" } } + } + } + ], + selectionSet: { + kind: "SelectionSet", + selections: [ + { + kind: "Field", + name: { kind: "Name", value: "account" }, + arguments: [ + { + kind: "Argument", + name: { kind: "Name", value: "id" }, + value: { kind: "Variable", name: { kind: "Name", value: "accountId" } } + } + ], + selectionSet: { + kind: "SelectionSet", + selections: [ + { kind: "Field", name: { kind: "Name", value: "totalDelegatedPercentage" } } + ] + } + } + ] + } + } + ] +}; +const GetAllStrategiesForBappDocument = { + kind: "Document", + definitions: [ + { + kind: "OperationDefinition", + operation: "query", + name: { kind: "Name", value: "GetAllStrategiesForBapp" }, + variableDefinitions: [ + { + kind: "VariableDefinition", + variable: { kind: "Variable", name: { kind: "Name", value: "bAppId" } }, + type: { + kind: "NonNullType", + type: { kind: "NamedType", name: { kind: "Name", value: "ID" } } + } + } + ], + selectionSet: { + kind: "SelectionSet", + selections: [ + { + kind: "Field", + name: { kind: "Name", value: "bapp" }, + arguments: [ + { + kind: "Argument", + name: { kind: "Name", value: "id" }, + value: { kind: "Variable", name: { kind: "Name", value: "bAppId" } } + } + ], + selectionSet: { + kind: "SelectionSet", + selections: [ + { + kind: "Field", + name: { kind: "Name", value: "strategies" }, + selectionSet: { + kind: "SelectionSet", + selections: [ + { + kind: "Field", + name: { kind: "Name", value: "strategy" }, + selectionSet: { + kind: "SelectionSet", + selections: [{ kind: "Field", name: { kind: "Name", value: "id" } }] + } + } + ] + } + } + ] + } + } + ] + } + } + ] +}; +const GetAllStrategiesForAccountDocument = { + kind: "Document", + definitions: [ + { + kind: "OperationDefinition", + operation: "query", + name: { kind: "Name", value: "GetAllStrategiesForAccount" }, + variableDefinitions: [ + { + kind: "VariableDefinition", + variable: { kind: "Variable", name: { kind: "Name", value: "accountId" } }, + type: { + kind: "NonNullType", + type: { kind: "NamedType", name: { kind: "Name", value: "ID" } } + } + } + ], + selectionSet: { + kind: "SelectionSet", + selections: [ + { + kind: "Field", + name: { kind: "Name", value: "account" }, + arguments: [ + { + kind: "Argument", + name: { kind: "Name", value: "id" }, + value: { kind: "Variable", name: { kind: "Name", value: "accountId" } } + } + ], + selectionSet: { + kind: "SelectionSet", + selections: [ + { + kind: "Field", + name: { kind: "Name", value: "strategies" }, + selectionSet: { + kind: "SelectionSet", + selections: [ + { kind: "Field", name: { kind: "Name", value: "id" } }, + { + kind: "Field", + name: { kind: "Name", value: "balances" }, + selectionSet: { + kind: "SelectionSet", + selections: [ + { kind: "Field", name: { kind: "Name", value: "balance" } }, + { kind: "Field", name: { kind: "Name", value: "token" } } + ] + } + } + ] + } + } + ] + } + } + ] + } + } + ] +}; +const getStrategyBAppOptIns = (client, args) => client.request(GetStrategyBAppOptInsDocument, args).then((res) => res.strategyBAppOptIns); +const getParticipantWeightInput = (client, args) => client.request(GetParticipantWeightInputDocument, args).then((res) => res.bapp); +const getObligatedBalances = (client, args) => client.request(GetObligatedBalancesDocument, args).then((res) => res.bapp); +const getBAppDelegators = (client, args) => client.request(GetBAppDelegatorsDocument, args).then((res) => res.bapp); +const getValidatorsByAccount = (client, args) => client.request(GetValidatorsByAccountDocument, args).then((res) => res.validators.map((v) => v.id)); +const getBappMetadataURI = (client, args) => client.request(GetBappMetadataUriDocument, args).then((res) => res.bapp); +const getAllBappsMetadataURIs = (client) => client.request(GetAllBappsMetadataUrIsDocument).then((res) => res.bapps); +const getAllStrategyObligatedBalancesForBapp = (client, args) => client.request(GetAllStrategyObligatedBalancesForBappDocument, args).then((res) => res.bapp); +const getDepositedBalancesForStrategy = (client, args) => client.request(GetDepositedBalancesForStrategyDocument, args).then((res) => res.strategy); +const getAllStrategiesDepositedTo = (client, args) => client.request(GetAllStrategiesDepositedToDocument, args).then((res) => res.account); +const getTotalDelegatedPercentageForAccount = (client, args) => client.request(GetTotalDelegatedPercentageForAccountDocument, args).then((res) => res.account?.totalDelegatedPercentage); +const getAllStrategiesForBapp = (client, args) => client.request(GetAllStrategiesForBappDocument, args).then((res) => res.bapp?.strategies.map((strategyInfo) => strategyInfo.strategy.id) || []); +const getAllStrategiesForAccount = (client, args) => client.request(GetAllStrategiesForAccountDocument, args).then((res) => res.account?.strategies || []); +const getBAMQueries = (client) => ({ + getStrategyBAppOptIns: getStrategyBAppOptIns.bind(null, client), + getParticipantWeightInput: getParticipantWeightInput.bind(null, client), + getObligatedBalances: getObligatedBalances.bind(null, client), + getBAppDelegators: getBAppDelegators.bind(null, client), + getValidatorsByAccount: getValidatorsByAccount.bind(null, client), + getBappMetadataURI: getBappMetadataURI.bind(null, client), + getAllBappsMetadataURIs: getAllBappsMetadataURIs.bind(null, client), + getAllStrategyObligatedBalancesForBapp: getAllStrategyObligatedBalancesForBapp.bind( + null, + client + ), + getDepositedBalancesForStrategy: getDepositedBalancesForStrategy.bind( + null, + client + ), + getAllStrategiesDepositedTo: getAllStrategiesDepositedTo.bind(null, client), + getTotalDelegatedPercentageForAccount: getTotalDelegatedPercentageForAccount.bind( + null, + client + ), + getAllStrategiesForBapp: getAllStrategiesForBapp.bind(null, client), + getAllStrategiesForAccount: getAllStrategiesForAccount.bind(null, client) +}); +const createSSVAPI = (endpoint) => { + return getSSVAPI(endpoint); +}; +const createBeaconChainAPI = (endpoint) => { + return getBeaconChainAPI(endpoint); +}; +const createBAMQueries = (graphqlClient) => { + return getBAMQueries(graphqlClient); +}; +const createBasedAppsAPI = (apis) => { + return getBasedAppsAPI(apis); +}; +class ClientError extends Error { + response; + request; + constructor(response, request) { + const message = `${ClientError.extractMessage(response)}: ${JSON.stringify({ + response, + request + })}`; + super(message); + Object.setPrototypeOf(this, ClientError.prototype); + this.response = response; + this.request = request; + if (typeof Error.captureStackTrace === `function`) { + Error.captureStackTrace(this, ClientError); + } + } + static extractMessage(response) { + return response.errors?.[0]?.message ?? `GraphQL Error (Code: ${String(response.status)})`; + } +} +const uppercase = (str) => str.toUpperCase(); +const callOrIdentity = (value) => { + return typeof value === `function` ? value() : value; +}; +const zip = (a, b) => a.map((k, i2) => [k, b[i2]]); +const HeadersInitToPlainObject = (headers) => { + let oHeaders = {}; + if (headers instanceof Headers) { + oHeaders = HeadersInstanceToPlainObject(headers); + } else if (Array.isArray(headers)) { + headers.forEach(([name, value]) => { + if (name && value !== void 0) { + oHeaders[name] = value; + } + }); + } else if (headers) { + oHeaders = headers; + } + return oHeaders; +}; +const HeadersInstanceToPlainObject = (headers) => { + const o = {}; + headers.forEach((v, k) => { + o[k] = v; + }); + return o; +}; +const tryCatch = (fn) => { + try { + const result = fn(); + if (isPromiseLikeValue(result)) { + return result.catch((error) => { + return errorFromMaybeError(error); + }); + } + return result; + } catch (error) { + return errorFromMaybeError(error); + } +}; +const errorFromMaybeError = (maybeError) => { + if (maybeError instanceof Error) + return maybeError; + return new Error(String(maybeError)); +}; +const isPromiseLikeValue = (value) => { + return typeof value === `object` && value !== null && `then` in value && typeof value.then === `function` && `catch` in value && typeof value.catch === `function` && `finally` in value && typeof value.finally === `function`; +}; +const casesExhausted = (value) => { + throw new Error(`Unhandled case: ${String(value)}`); +}; +const isPlainObject = (value) => { + return typeof value === `object` && value !== null && !Array.isArray(value); +}; +const parseBatchRequestArgs = (documentsOrOptions, requestHeaders) => { + return documentsOrOptions.documents ? documentsOrOptions : { + documents: documentsOrOptions, + requestHeaders, + signal: void 0 + }; +}; +const parseRawRequestArgs = (queryOrOptions, variables, requestHeaders) => { + return queryOrOptions.query ? queryOrOptions : { + query: queryOrOptions, + variables, + requestHeaders, + signal: void 0 + }; +}; +function devAssert(condition, message) { + const booleanCondition = Boolean(condition); + if (!booleanCondition) { + throw new Error(message); + } +} +function isObjectLike(value) { + return typeof value == "object" && value !== null; +} +function invariant(condition, message) { + const booleanCondition = Boolean(condition); + if (!booleanCondition) { + throw new Error( + "Unexpected invariant triggered." + ); + } +} +const LineRegExp = /\r\n|[\n\r]/g; +function getLocation(source, position) { + let lastLineStart = 0; + let line = 1; + for (const match of source.body.matchAll(LineRegExp)) { + typeof match.index === "number" || invariant(false); + if (match.index >= position) { + break; + } + lastLineStart = match.index + match[0].length; + line += 1; + } + return { + line, + column: position + 1 - lastLineStart + }; +} +function printLocation(location2) { + return printSourceLocation( + location2.source, + getLocation(location2.source, location2.start) + ); +} +function printSourceLocation(source, sourceLocation) { + const firstLineColumnOffset = source.locationOffset.column - 1; + const body = "".padStart(firstLineColumnOffset) + source.body; + const lineIndex = sourceLocation.line - 1; + const lineOffset = source.locationOffset.line - 1; + const lineNum = sourceLocation.line + lineOffset; + const columnOffset = sourceLocation.line === 1 ? firstLineColumnOffset : 0; + const columnNum = sourceLocation.column + columnOffset; + const locationStr = `${source.name}:${lineNum}:${columnNum} +`; + const lines = body.split(/\r\n|[\n\r]/g); + const locationLine = lines[lineIndex]; + if (locationLine.length > 120) { + const subLineIndex = Math.floor(columnNum / 80); + const subLineColumnNum = columnNum % 80; + const subLines = []; + for (let i2 = 0; i2 < locationLine.length; i2 += 80) { + subLines.push(locationLine.slice(i2, i2 + 80)); + } + return locationStr + printPrefixedLines([ + [`${lineNum} |`, subLines[0]], + ...subLines.slice(1, subLineIndex + 1).map((subLine) => ["|", subLine]), + ["|", "^".padStart(subLineColumnNum)], + ["|", subLines[subLineIndex + 1]] + ]); + } + return locationStr + printPrefixedLines([ + // Lines specified like this: ["prefix", "string"], + [`${lineNum - 1} |`, lines[lineIndex - 1]], + [`${lineNum} |`, locationLine], + ["|", "^".padStart(columnNum)], + [`${lineNum + 1} |`, lines[lineIndex + 1]] + ]); +} +function printPrefixedLines(lines) { + const existingLines = lines.filter(([_, line]) => line !== void 0); + const padLen = Math.max(...existingLines.map(([prefix]) => prefix.length)); + return existingLines.map(([prefix, line]) => prefix.padStart(padLen) + (line ? " " + line : "")).join("\n"); +} +function toNormalizedOptions(args) { + const firstArg = args[0]; + if (firstArg == null || "kind" in firstArg || "length" in firstArg) { + return { + nodes: firstArg, + source: args[1], + positions: args[2], + path: args[3], + originalError: args[4], + extensions: args[5] + }; + } + return firstArg; +} +class GraphQLError extends Error { + /** + * An array of `{ line, column }` locations within the source GraphQL document + * which correspond to this error. + * + * Errors during validation often contain multiple locations, for example to + * point out two things with the same name. Errors during execution include a + * single location, the field which produced the error. + * + * Enumerable, and appears in the result of JSON.stringify(). + */ + /** + * An array describing the JSON-path into the execution response which + * corresponds to this error. Only included for errors during execution. + * + * Enumerable, and appears in the result of JSON.stringify(). + */ + /** + * An array of GraphQL AST Nodes corresponding to this error. + */ + /** + * The source GraphQL document for the first location of this error. + * + * Note that if this Error represents more than one node, the source may not + * represent nodes after the first node. + */ + /** + * An array of character offsets within the source GraphQL document + * which correspond to this error. + */ + /** + * The original error thrown from a field resolver during execution. + */ + /** + * Extension fields to add to the formatted error. + */ + /** + * @deprecated Please use the `GraphQLErrorOptions` constructor overload instead. + */ + constructor(message, ...rawArgs) { + var _this$nodes, _nodeLocations$, _ref; + const { nodes, source, positions, path, originalError, extensions } = toNormalizedOptions(rawArgs); + super(message); + this.name = "GraphQLError"; + this.path = path !== null && path !== void 0 ? path : void 0; + this.originalError = originalError !== null && originalError !== void 0 ? originalError : void 0; + this.nodes = undefinedIfEmpty( + Array.isArray(nodes) ? nodes : nodes ? [nodes] : void 0 + ); + const nodeLocations = undefinedIfEmpty( + (_this$nodes = this.nodes) === null || _this$nodes === void 0 ? void 0 : _this$nodes.map((node2) => node2.loc).filter((loc) => loc != null) + ); + this.source = source !== null && source !== void 0 ? source : nodeLocations === null || nodeLocations === void 0 ? void 0 : (_nodeLocations$ = nodeLocations[0]) === null || _nodeLocations$ === void 0 ? void 0 : _nodeLocations$.source; + this.positions = positions !== null && positions !== void 0 ? positions : nodeLocations === null || nodeLocations === void 0 ? void 0 : nodeLocations.map((loc) => loc.start); + this.locations = positions && source ? positions.map((pos) => getLocation(source, pos)) : nodeLocations === null || nodeLocations === void 0 ? void 0 : nodeLocations.map((loc) => getLocation(loc.source, loc.start)); + const originalExtensions = isObjectLike( + originalError === null || originalError === void 0 ? void 0 : originalError.extensions + ) ? originalError === null || originalError === void 0 ? void 0 : originalError.extensions : void 0; + this.extensions = (_ref = extensions !== null && extensions !== void 0 ? extensions : originalExtensions) !== null && _ref !== void 0 ? _ref : /* @__PURE__ */ Object.create(null); + Object.defineProperties(this, { + message: { + writable: true, + enumerable: true + }, + name: { + enumerable: false + }, + nodes: { + enumerable: false + }, + source: { + enumerable: false + }, + positions: { + enumerable: false + }, + originalError: { + enumerable: false + } + }); + if (originalError !== null && originalError !== void 0 && originalError.stack) { + Object.defineProperty(this, "stack", { + value: originalError.stack, + writable: true, + configurable: true + }); + } else if (Error.captureStackTrace) { + Error.captureStackTrace(this, GraphQLError); + } else { + Object.defineProperty(this, "stack", { + value: Error().stack, + writable: true, + configurable: true + }); + } + } + get [Symbol.toStringTag]() { + return "GraphQLError"; + } + toString() { + let output = this.message; + if (this.nodes) { + for (const node2 of this.nodes) { + if (node2.loc) { + output += "\n\n" + printLocation(node2.loc); + } + } + } else if (this.source && this.locations) { + for (const location2 of this.locations) { + output += "\n\n" + printSourceLocation(this.source, location2); + } + } + return output; + } + toJSON() { + const formattedError = { + message: this.message + }; + if (this.locations != null) { + formattedError.locations = this.locations; + } + if (this.path != null) { + formattedError.path = this.path; + } + if (this.extensions != null && Object.keys(this.extensions).length > 0) { + formattedError.extensions = this.extensions; + } + return formattedError; + } +} +function undefinedIfEmpty(array) { + return array === void 0 || array.length === 0 ? void 0 : array; +} +function syntaxError(source, position, description) { + return new GraphQLError(`Syntax Error: ${description}`, { + source, + positions: [position] + }); +} +class Location { + /** + * The character offset at which this Node begins. + */ + /** + * The character offset at which this Node ends. + */ + /** + * The Token at which this Node begins. + */ + /** + * The Token at which this Node ends. + */ + /** + * The Source document the AST represents. + */ + constructor(startToken, endToken, source) { + this.start = startToken.start; + this.end = endToken.end; + this.startToken = startToken; + this.endToken = endToken; + this.source = source; + } + get [Symbol.toStringTag]() { + return "Location"; + } + toJSON() { + return { + start: this.start, + end: this.end + }; + } +} +class Token { + /** + * The kind of Token. + */ + /** + * The character offset at which this Node begins. + */ + /** + * The character offset at which this Node ends. + */ + /** + * The 1-indexed line number on which this Token appears. + */ + /** + * The 1-indexed column number at which this Token begins. + */ + /** + * For non-punctuation tokens, represents the interpreted value of the token. + * + * Note: is undefined for punctuation tokens, but typed as string for + * convenience in the parser. + */ + /** + * Tokens exist as nodes in a double-linked-list amongst all tokens + * including ignored tokens. is always the first node and + * the last. + */ + constructor(kind, start, end, line, column, value) { + this.kind = kind; + this.start = start; + this.end = end; + this.line = line; + this.column = column; + this.value = value; + this.prev = null; + this.next = null; + } + get [Symbol.toStringTag]() { + return "Token"; + } + toJSON() { + return { + kind: this.kind, + value: this.value, + line: this.line, + column: this.column + }; + } +} +const QueryDocumentKeys = { + Name: [], + Document: ["definitions"], + OperationDefinition: [ + "name", + "variableDefinitions", + "directives", + "selectionSet" + ], + VariableDefinition: ["variable", "type", "defaultValue", "directives"], + Variable: ["name"], + SelectionSet: ["selections"], + Field: ["alias", "name", "arguments", "directives", "selectionSet"], + Argument: ["name", "value"], + FragmentSpread: ["name", "directives"], + InlineFragment: ["typeCondition", "directives", "selectionSet"], + FragmentDefinition: [ + "name", + // Note: fragment variable definitions are deprecated and will removed in v17.0.0 + "variableDefinitions", + "typeCondition", + "directives", + "selectionSet" + ], + IntValue: [], + FloatValue: [], + StringValue: [], + BooleanValue: [], + NullValue: [], + EnumValue: [], + ListValue: ["values"], + ObjectValue: ["fields"], + ObjectField: ["name", "value"], + Directive: ["name", "arguments"], + NamedType: ["name"], + ListType: ["type"], + NonNullType: ["type"], + SchemaDefinition: ["description", "directives", "operationTypes"], + OperationTypeDefinition: ["type"], + ScalarTypeDefinition: ["description", "name", "directives"], + ObjectTypeDefinition: [ + "description", + "name", + "interfaces", + "directives", + "fields" + ], + FieldDefinition: ["description", "name", "arguments", "type", "directives"], + InputValueDefinition: [ + "description", + "name", + "type", + "defaultValue", + "directives" + ], + InterfaceTypeDefinition: [ + "description", + "name", + "interfaces", + "directives", + "fields" + ], + UnionTypeDefinition: ["description", "name", "directives", "types"], + EnumTypeDefinition: ["description", "name", "directives", "values"], + EnumValueDefinition: ["description", "name", "directives"], + InputObjectTypeDefinition: ["description", "name", "directives", "fields"], + DirectiveDefinition: ["description", "name", "arguments", "locations"], + SchemaExtension: ["directives", "operationTypes"], + ScalarTypeExtension: ["name", "directives"], + ObjectTypeExtension: ["name", "interfaces", "directives", "fields"], + InterfaceTypeExtension: ["name", "interfaces", "directives", "fields"], + UnionTypeExtension: ["name", "directives", "types"], + EnumTypeExtension: ["name", "directives", "values"], + InputObjectTypeExtension: ["name", "directives", "fields"] +}; +const kindValues = new Set(Object.keys(QueryDocumentKeys)); +function isNode(maybeNode) { + const maybeKind = maybeNode === null || maybeNode === void 0 ? void 0 : maybeNode.kind; + return typeof maybeKind === "string" && kindValues.has(maybeKind); +} +var OperationTypeNode; +(function(OperationTypeNode2) { + OperationTypeNode2["QUERY"] = "query"; + OperationTypeNode2["MUTATION"] = "mutation"; + OperationTypeNode2["SUBSCRIPTION"] = "subscription"; +})(OperationTypeNode || (OperationTypeNode = {})); +var DirectiveLocation; +(function(DirectiveLocation2) { + DirectiveLocation2["QUERY"] = "QUERY"; + DirectiveLocation2["MUTATION"] = "MUTATION"; + DirectiveLocation2["SUBSCRIPTION"] = "SUBSCRIPTION"; + DirectiveLocation2["FIELD"] = "FIELD"; + DirectiveLocation2["FRAGMENT_DEFINITION"] = "FRAGMENT_DEFINITION"; + DirectiveLocation2["FRAGMENT_SPREAD"] = "FRAGMENT_SPREAD"; + DirectiveLocation2["INLINE_FRAGMENT"] = "INLINE_FRAGMENT"; + DirectiveLocation2["VARIABLE_DEFINITION"] = "VARIABLE_DEFINITION"; + DirectiveLocation2["SCHEMA"] = "SCHEMA"; + DirectiveLocation2["SCALAR"] = "SCALAR"; + DirectiveLocation2["OBJECT"] = "OBJECT"; + DirectiveLocation2["FIELD_DEFINITION"] = "FIELD_DEFINITION"; + DirectiveLocation2["ARGUMENT_DEFINITION"] = "ARGUMENT_DEFINITION"; + DirectiveLocation2["INTERFACE"] = "INTERFACE"; + DirectiveLocation2["UNION"] = "UNION"; + DirectiveLocation2["ENUM"] = "ENUM"; + DirectiveLocation2["ENUM_VALUE"] = "ENUM_VALUE"; + DirectiveLocation2["INPUT_OBJECT"] = "INPUT_OBJECT"; + DirectiveLocation2["INPUT_FIELD_DEFINITION"] = "INPUT_FIELD_DEFINITION"; +})(DirectiveLocation || (DirectiveLocation = {})); +var Kind; +(function(Kind2) { + Kind2["NAME"] = "Name"; + Kind2["DOCUMENT"] = "Document"; + Kind2["OPERATION_DEFINITION"] = "OperationDefinition"; + Kind2["VARIABLE_DEFINITION"] = "VariableDefinition"; + Kind2["SELECTION_SET"] = "SelectionSet"; + Kind2["FIELD"] = "Field"; + Kind2["ARGUMENT"] = "Argument"; + Kind2["FRAGMENT_SPREAD"] = "FragmentSpread"; + Kind2["INLINE_FRAGMENT"] = "InlineFragment"; + Kind2["FRAGMENT_DEFINITION"] = "FragmentDefinition"; + Kind2["VARIABLE"] = "Variable"; + Kind2["INT"] = "IntValue"; + Kind2["FLOAT"] = "FloatValue"; + Kind2["STRING"] = "StringValue"; + Kind2["BOOLEAN"] = "BooleanValue"; + Kind2["NULL"] = "NullValue"; + Kind2["ENUM"] = "EnumValue"; + Kind2["LIST"] = "ListValue"; + Kind2["OBJECT"] = "ObjectValue"; + Kind2["OBJECT_FIELD"] = "ObjectField"; + Kind2["DIRECTIVE"] = "Directive"; + Kind2["NAMED_TYPE"] = "NamedType"; + Kind2["LIST_TYPE"] = "ListType"; + Kind2["NON_NULL_TYPE"] = "NonNullType"; + Kind2["SCHEMA_DEFINITION"] = "SchemaDefinition"; + Kind2["OPERATION_TYPE_DEFINITION"] = "OperationTypeDefinition"; + Kind2["SCALAR_TYPE_DEFINITION"] = "ScalarTypeDefinition"; + Kind2["OBJECT_TYPE_DEFINITION"] = "ObjectTypeDefinition"; + Kind2["FIELD_DEFINITION"] = "FieldDefinition"; + Kind2["INPUT_VALUE_DEFINITION"] = "InputValueDefinition"; + Kind2["INTERFACE_TYPE_DEFINITION"] = "InterfaceTypeDefinition"; + Kind2["UNION_TYPE_DEFINITION"] = "UnionTypeDefinition"; + Kind2["ENUM_TYPE_DEFINITION"] = "EnumTypeDefinition"; + Kind2["ENUM_VALUE_DEFINITION"] = "EnumValueDefinition"; + Kind2["INPUT_OBJECT_TYPE_DEFINITION"] = "InputObjectTypeDefinition"; + Kind2["DIRECTIVE_DEFINITION"] = "DirectiveDefinition"; + Kind2["SCHEMA_EXTENSION"] = "SchemaExtension"; + Kind2["SCALAR_TYPE_EXTENSION"] = "ScalarTypeExtension"; + Kind2["OBJECT_TYPE_EXTENSION"] = "ObjectTypeExtension"; + Kind2["INTERFACE_TYPE_EXTENSION"] = "InterfaceTypeExtension"; + Kind2["UNION_TYPE_EXTENSION"] = "UnionTypeExtension"; + Kind2["ENUM_TYPE_EXTENSION"] = "EnumTypeExtension"; + Kind2["INPUT_OBJECT_TYPE_EXTENSION"] = "InputObjectTypeExtension"; +})(Kind || (Kind = {})); +function isWhiteSpace(code2) { + return code2 === 9 || code2 === 32; +} +function isDigit(code2) { + return code2 >= 48 && code2 <= 57; +} +function isLetter(code2) { + return code2 >= 97 && code2 <= 122 || // A-Z + code2 >= 65 && code2 <= 90; +} +function isNameStart(code2) { + return isLetter(code2) || code2 === 95; +} +function isNameContinue(code2) { + return isLetter(code2) || isDigit(code2) || code2 === 95; +} +function dedentBlockStringLines(lines) { + var _firstNonEmptyLine2; + let commonIndent = Number.MAX_SAFE_INTEGER; + let firstNonEmptyLine = null; + let lastNonEmptyLine = -1; + for (let i2 = 0; i2 < lines.length; ++i2) { + var _firstNonEmptyLine; + const line = lines[i2]; + const indent2 = leadingWhitespace(line); + if (indent2 === line.length) { + continue; + } + firstNonEmptyLine = (_firstNonEmptyLine = firstNonEmptyLine) !== null && _firstNonEmptyLine !== void 0 ? _firstNonEmptyLine : i2; + lastNonEmptyLine = i2; + if (i2 !== 0 && indent2 < commonIndent) { + commonIndent = indent2; + } + } + return lines.map((line, i2) => i2 === 0 ? line : line.slice(commonIndent)).slice( + (_firstNonEmptyLine2 = firstNonEmptyLine) !== null && _firstNonEmptyLine2 !== void 0 ? _firstNonEmptyLine2 : 0, + lastNonEmptyLine + 1 + ); +} +function leadingWhitespace(str) { + let i2 = 0; + while (i2 < str.length && isWhiteSpace(str.charCodeAt(i2))) { + ++i2; + } + return i2; +} +function printBlockString(value, options) { + const escapedValue = value.replace(/"""/g, '\\"""'); + const lines = escapedValue.split(/\r\n|[\n\r]/g); + const isSingleLine = lines.length === 1; + const forceLeadingNewLine = lines.length > 1 && lines.slice(1).every((line) => line.length === 0 || isWhiteSpace(line.charCodeAt(0))); + const hasTrailingTripleQuotes = escapedValue.endsWith('\\"""'); + const hasTrailingQuote = value.endsWith('"') && !hasTrailingTripleQuotes; + const hasTrailingSlash = value.endsWith("\\"); + const forceTrailingNewline = hasTrailingQuote || hasTrailingSlash; + const printAsMultipleLines = ( + // add leading and trailing new lines only if it improves readability + !isSingleLine || value.length > 70 || forceTrailingNewline || forceLeadingNewLine || hasTrailingTripleQuotes + ); + let result = ""; + const skipLeadingNewLine = isSingleLine && isWhiteSpace(value.charCodeAt(0)); + if (printAsMultipleLines && !skipLeadingNewLine || forceLeadingNewLine) { + result += "\n"; + } + result += escapedValue; + if (printAsMultipleLines || forceTrailingNewline) { + result += "\n"; + } + return '"""' + result + '"""'; +} +var TokenKind; +(function(TokenKind2) { + TokenKind2["SOF"] = ""; + TokenKind2["EOF"] = ""; + TokenKind2["BANG"] = "!"; + TokenKind2["DOLLAR"] = "$"; + TokenKind2["AMP"] = "&"; + TokenKind2["PAREN_L"] = "("; + TokenKind2["PAREN_R"] = ")"; + TokenKind2["SPREAD"] = "..."; + TokenKind2["COLON"] = ":"; + TokenKind2["EQUALS"] = "="; + TokenKind2["AT"] = "@"; + TokenKind2["BRACKET_L"] = "["; + TokenKind2["BRACKET_R"] = "]"; + TokenKind2["BRACE_L"] = "{"; + TokenKind2["PIPE"] = "|"; + TokenKind2["BRACE_R"] = "}"; + TokenKind2["NAME"] = "Name"; + TokenKind2["INT"] = "Int"; + TokenKind2["FLOAT"] = "Float"; + TokenKind2["STRING"] = "String"; + TokenKind2["BLOCK_STRING"] = "BlockString"; + TokenKind2["COMMENT"] = "Comment"; +})(TokenKind || (TokenKind = {})); +class Lexer { + /** + * The previously focused non-ignored token. + */ + /** + * The currently focused non-ignored token. + */ + /** + * The (1-indexed) line containing the current token. + */ + /** + * The character offset at which the current line begins. + */ + constructor(source) { + const startOfFileToken = new Token(TokenKind.SOF, 0, 0, 0, 0); + this.source = source; + this.lastToken = startOfFileToken; + this.token = startOfFileToken; + this.line = 1; + this.lineStart = 0; + } + get [Symbol.toStringTag]() { + return "Lexer"; + } + /** + * Advances the token stream to the next non-ignored token. + */ + advance() { + this.lastToken = this.token; + const token = this.token = this.lookahead(); + return token; + } + /** + * Looks ahead and returns the next non-ignored token, but does not change + * the state of Lexer. + */ + lookahead() { + let token = this.token; + if (token.kind !== TokenKind.EOF) { + do { + if (token.next) { + token = token.next; + } else { + const nextToken = readNextToken(this, token.end); + token.next = nextToken; + nextToken.prev = token; + token = nextToken; + } + } while (token.kind === TokenKind.COMMENT); + } + return token; + } +} +function isPunctuatorTokenKind(kind) { + return kind === TokenKind.BANG || kind === TokenKind.DOLLAR || kind === TokenKind.AMP || kind === TokenKind.PAREN_L || kind === TokenKind.PAREN_R || kind === TokenKind.SPREAD || kind === TokenKind.COLON || kind === TokenKind.EQUALS || kind === TokenKind.AT || kind === TokenKind.BRACKET_L || kind === TokenKind.BRACKET_R || kind === TokenKind.BRACE_L || kind === TokenKind.PIPE || kind === TokenKind.BRACE_R; +} +function isUnicodeScalarValue(code2) { + return code2 >= 0 && code2 <= 55295 || code2 >= 57344 && code2 <= 1114111; +} +function isSupplementaryCodePoint(body, location2) { + return isLeadingSurrogate(body.charCodeAt(location2)) && isTrailingSurrogate(body.charCodeAt(location2 + 1)); +} +function isLeadingSurrogate(code2) { + return code2 >= 55296 && code2 <= 56319; +} +function isTrailingSurrogate(code2) { + return code2 >= 56320 && code2 <= 57343; +} +function printCodePointAt(lexer, location2) { + const code2 = lexer.source.body.codePointAt(location2); + if (code2 === void 0) { + return TokenKind.EOF; + } else if (code2 >= 32 && code2 <= 126) { + const char = String.fromCodePoint(code2); + return char === '"' ? `'"'` : `"${char}"`; + } + return "U+" + code2.toString(16).toUpperCase().padStart(4, "0"); +} +function createToken(lexer, kind, start, end, value) { + const line = lexer.line; + const col = 1 + start - lexer.lineStart; + return new Token(kind, start, end, line, col, value); +} +function readNextToken(lexer, start) { + const body = lexer.source.body; + const bodyLength = body.length; + let position = start; + while (position < bodyLength) { + const code2 = body.charCodeAt(position); + switch (code2) { + // Ignored :: + // - UnicodeBOM + // - WhiteSpace + // - LineTerminator + // - Comment + // - Comma + // + // UnicodeBOM :: "Byte Order Mark (U+FEFF)" + // + // WhiteSpace :: + // - "Horizontal Tab (U+0009)" + // - "Space (U+0020)" + // + // Comma :: , + case 65279: + // + case 9: + // \t + case 32: + // + case 44: + ++position; + continue; + // LineTerminator :: + // - "New Line (U+000A)" + // - "Carriage Return (U+000D)" [lookahead != "New Line (U+000A)"] + // - "Carriage Return (U+000D)" "New Line (U+000A)" + case 10: + ++position; + ++lexer.line; + lexer.lineStart = position; + continue; + case 13: + if (body.charCodeAt(position + 1) === 10) { + position += 2; + } else { + ++position; + } + ++lexer.line; + lexer.lineStart = position; + continue; + // Comment + case 35: + return readComment(lexer, position); + // Token :: + // - Punctuator + // - Name + // - IntValue + // - FloatValue + // - StringValue + // + // Punctuator :: one of ! $ & ( ) ... : = @ [ ] { | } + case 33: + return createToken(lexer, TokenKind.BANG, position, position + 1); + case 36: + return createToken(lexer, TokenKind.DOLLAR, position, position + 1); + case 38: + return createToken(lexer, TokenKind.AMP, position, position + 1); + case 40: + return createToken(lexer, TokenKind.PAREN_L, position, position + 1); + case 41: + return createToken(lexer, TokenKind.PAREN_R, position, position + 1); + case 46: + if (body.charCodeAt(position + 1) === 46 && body.charCodeAt(position + 2) === 46) { + return createToken(lexer, TokenKind.SPREAD, position, position + 3); + } + break; + case 58: + return createToken(lexer, TokenKind.COLON, position, position + 1); + case 61: + return createToken(lexer, TokenKind.EQUALS, position, position + 1); + case 64: + return createToken(lexer, TokenKind.AT, position, position + 1); + case 91: + return createToken(lexer, TokenKind.BRACKET_L, position, position + 1); + case 93: + return createToken(lexer, TokenKind.BRACKET_R, position, position + 1); + case 123: + return createToken(lexer, TokenKind.BRACE_L, position, position + 1); + case 124: + return createToken(lexer, TokenKind.PIPE, position, position + 1); + case 125: + return createToken(lexer, TokenKind.BRACE_R, position, position + 1); + // StringValue + case 34: + if (body.charCodeAt(position + 1) === 34 && body.charCodeAt(position + 2) === 34) { + return readBlockString(lexer, position); + } + return readString(lexer, position); + } + if (isDigit(code2) || code2 === 45) { + return readNumber(lexer, position, code2); + } + if (isNameStart(code2)) { + return readName(lexer, position); + } + throw syntaxError( + lexer.source, + position, + code2 === 39 ? `Unexpected single quote character ('), did you mean to use a double quote (")?` : isUnicodeScalarValue(code2) || isSupplementaryCodePoint(body, position) ? `Unexpected character: ${printCodePointAt(lexer, position)}.` : `Invalid character: ${printCodePointAt(lexer, position)}.` + ); + } + return createToken(lexer, TokenKind.EOF, bodyLength, bodyLength); +} +function readComment(lexer, start) { + const body = lexer.source.body; + const bodyLength = body.length; + let position = start + 1; + while (position < bodyLength) { + const code2 = body.charCodeAt(position); + if (code2 === 10 || code2 === 13) { + break; + } + if (isUnicodeScalarValue(code2)) { + ++position; + } else if (isSupplementaryCodePoint(body, position)) { + position += 2; + } else { + break; + } + } + return createToken( + lexer, + TokenKind.COMMENT, + start, + position, + body.slice(start + 1, position) + ); +} +function readNumber(lexer, start, firstCode) { + const body = lexer.source.body; + let position = start; + let code2 = firstCode; + let isFloat = false; + if (code2 === 45) { + code2 = body.charCodeAt(++position); + } + if (code2 === 48) { + code2 = body.charCodeAt(++position); + if (isDigit(code2)) { + throw syntaxError( + lexer.source, + position, + `Invalid number, unexpected digit after 0: ${printCodePointAt( + lexer, + position + )}.` + ); + } + } else { + position = readDigits(lexer, position, code2); + code2 = body.charCodeAt(position); + } + if (code2 === 46) { + isFloat = true; + code2 = body.charCodeAt(++position); + position = readDigits(lexer, position, code2); + code2 = body.charCodeAt(position); + } + if (code2 === 69 || code2 === 101) { + isFloat = true; + code2 = body.charCodeAt(++position); + if (code2 === 43 || code2 === 45) { + code2 = body.charCodeAt(++position); + } + position = readDigits(lexer, position, code2); + code2 = body.charCodeAt(position); + } + if (code2 === 46 || isNameStart(code2)) { + throw syntaxError( + lexer.source, + position, + `Invalid number, expected digit but got: ${printCodePointAt( + lexer, + position + )}.` + ); + } + return createToken( + lexer, + isFloat ? TokenKind.FLOAT : TokenKind.INT, + start, + position, + body.slice(start, position) + ); +} +function readDigits(lexer, start, firstCode) { + if (!isDigit(firstCode)) { + throw syntaxError( + lexer.source, + start, + `Invalid number, expected digit but got: ${printCodePointAt( + lexer, + start + )}.` + ); + } + const body = lexer.source.body; + let position = start + 1; + while (isDigit(body.charCodeAt(position))) { + ++position; + } + return position; +} +function readString(lexer, start) { + const body = lexer.source.body; + const bodyLength = body.length; + let position = start + 1; + let chunkStart = position; + let value = ""; + while (position < bodyLength) { + const code2 = body.charCodeAt(position); + if (code2 === 34) { + value += body.slice(chunkStart, position); + return createToken(lexer, TokenKind.STRING, start, position + 1, value); + } + if (code2 === 92) { + value += body.slice(chunkStart, position); + const escape = body.charCodeAt(position + 1) === 117 ? body.charCodeAt(position + 2) === 123 ? readEscapedUnicodeVariableWidth(lexer, position) : readEscapedUnicodeFixedWidth(lexer, position) : readEscapedCharacter(lexer, position); + value += escape.value; + position += escape.size; + chunkStart = position; + continue; + } + if (code2 === 10 || code2 === 13) { + break; + } + if (isUnicodeScalarValue(code2)) { + ++position; + } else if (isSupplementaryCodePoint(body, position)) { + position += 2; + } else { + throw syntaxError( + lexer.source, + position, + `Invalid character within String: ${printCodePointAt( + lexer, + position + )}.` + ); + } + } + throw syntaxError(lexer.source, position, "Unterminated string."); +} +function readEscapedUnicodeVariableWidth(lexer, position) { + const body = lexer.source.body; + let point = 0; + let size = 3; + while (size < 12) { + const code2 = body.charCodeAt(position + size++); + if (code2 === 125) { + if (size < 5 || !isUnicodeScalarValue(point)) { + break; + } + return { + value: String.fromCodePoint(point), + size + }; + } + point = point << 4 | readHexDigit(code2); + if (point < 0) { + break; + } + } + throw syntaxError( + lexer.source, + position, + `Invalid Unicode escape sequence: "${body.slice( + position, + position + size + )}".` + ); +} +function readEscapedUnicodeFixedWidth(lexer, position) { + const body = lexer.source.body; + const code2 = read16BitHexCode(body, position + 2); + if (isUnicodeScalarValue(code2)) { + return { + value: String.fromCodePoint(code2), + size: 6 + }; + } + if (isLeadingSurrogate(code2)) { + if (body.charCodeAt(position + 6) === 92 && body.charCodeAt(position + 7) === 117) { + const trailingCode = read16BitHexCode(body, position + 8); + if (isTrailingSurrogate(trailingCode)) { + return { + value: String.fromCodePoint(code2, trailingCode), + size: 12 + }; + } + } + } + throw syntaxError( + lexer.source, + position, + `Invalid Unicode escape sequence: "${body.slice(position, position + 6)}".` + ); +} +function read16BitHexCode(body, position) { + return readHexDigit(body.charCodeAt(position)) << 12 | readHexDigit(body.charCodeAt(position + 1)) << 8 | readHexDigit(body.charCodeAt(position + 2)) << 4 | readHexDigit(body.charCodeAt(position + 3)); +} +function readHexDigit(code2) { + return code2 >= 48 && code2 <= 57 ? code2 - 48 : code2 >= 65 && code2 <= 70 ? code2 - 55 : code2 >= 97 && code2 <= 102 ? code2 - 87 : -1; +} +function readEscapedCharacter(lexer, position) { + const body = lexer.source.body; + const code2 = body.charCodeAt(position + 1); + switch (code2) { + case 34: + return { + value: '"', + size: 2 + }; + case 92: + return { + value: "\\", + size: 2 + }; + case 47: + return { + value: "/", + size: 2 + }; + case 98: + return { + value: "\b", + size: 2 + }; + case 102: + return { + value: "\f", + size: 2 + }; + case 110: + return { + value: "\n", + size: 2 + }; + case 114: + return { + value: "\r", + size: 2 + }; + case 116: + return { + value: " ", + size: 2 + }; + } + throw syntaxError( + lexer.source, + position, + `Invalid character escape sequence: "${body.slice( + position, + position + 2 + )}".` + ); +} +function readBlockString(lexer, start) { + const body = lexer.source.body; + const bodyLength = body.length; + let lineStart = lexer.lineStart; + let position = start + 3; + let chunkStart = position; + let currentLine = ""; + const blockLines = []; + while (position < bodyLength) { + const code2 = body.charCodeAt(position); + if (code2 === 34 && body.charCodeAt(position + 1) === 34 && body.charCodeAt(position + 2) === 34) { + currentLine += body.slice(chunkStart, position); + blockLines.push(currentLine); + const token = createToken( + lexer, + TokenKind.BLOCK_STRING, + start, + position + 3, + // Return a string of the lines joined with U+000A. + dedentBlockStringLines(blockLines).join("\n") + ); + lexer.line += blockLines.length - 1; + lexer.lineStart = lineStart; + return token; + } + if (code2 === 92 && body.charCodeAt(position + 1) === 34 && body.charCodeAt(position + 2) === 34 && body.charCodeAt(position + 3) === 34) { + currentLine += body.slice(chunkStart, position); + chunkStart = position + 1; + position += 4; + continue; + } + if (code2 === 10 || code2 === 13) { + currentLine += body.slice(chunkStart, position); + blockLines.push(currentLine); + if (code2 === 13 && body.charCodeAt(position + 1) === 10) { + position += 2; + } else { + ++position; + } + currentLine = ""; + chunkStart = position; + lineStart = position; + continue; + } + if (isUnicodeScalarValue(code2)) { + ++position; + } else if (isSupplementaryCodePoint(body, position)) { + position += 2; + } else { + throw syntaxError( + lexer.source, + position, + `Invalid character within String: ${printCodePointAt( + lexer, + position + )}.` + ); + } + } + throw syntaxError(lexer.source, position, "Unterminated string."); +} +function readName(lexer, start) { + const body = lexer.source.body; + const bodyLength = body.length; + let position = start + 1; + while (position < bodyLength) { + const code2 = body.charCodeAt(position); + if (isNameContinue(code2)) { + ++position; + } else { + break; + } + } + return createToken( + lexer, + TokenKind.NAME, + start, + position, + body.slice(start, position) + ); +} +const MAX_ARRAY_LENGTH = 10; +const MAX_RECURSIVE_DEPTH = 2; +function inspect(value) { + return formatValue(value, []); +} +function formatValue(value, seenValues) { + switch (typeof value) { + case "string": + return JSON.stringify(value); + case "function": + return value.name ? `[function ${value.name}]` : "[function]"; + case "object": + return formatObjectValue(value, seenValues); + default: + return String(value); + } +} +function formatObjectValue(value, previouslySeenValues) { + if (value === null) { + return "null"; + } + if (previouslySeenValues.includes(value)) { + return "[Circular]"; + } + const seenValues = [...previouslySeenValues, value]; + if (isJSONable(value)) { + const jsonValue = value.toJSON(); + if (jsonValue !== value) { + return typeof jsonValue === "string" ? jsonValue : formatValue(jsonValue, seenValues); + } + } else if (Array.isArray(value)) { + return formatArray(value, seenValues); + } + return formatObject(value, seenValues); +} +function isJSONable(value) { + return typeof value.toJSON === "function"; +} +function formatObject(object, seenValues) { + const entries = Object.entries(object); + if (entries.length === 0) { + return "{}"; + } + if (seenValues.length > MAX_RECURSIVE_DEPTH) { + return "[" + getObjectTag(object) + "]"; + } + const properties = entries.map( + ([key2, value]) => key2 + ": " + formatValue(value, seenValues) + ); + return "{ " + properties.join(", ") + " }"; +} +function formatArray(array, seenValues) { + if (array.length === 0) { + return "[]"; + } + if (seenValues.length > MAX_RECURSIVE_DEPTH) { + return "[Array]"; + } + const len2 = Math.min(MAX_ARRAY_LENGTH, array.length); + const remaining = array.length - len2; + const items = []; + for (let i2 = 0; i2 < len2; ++i2) { + items.push(formatValue(array[i2], seenValues)); + } + if (remaining === 1) { + items.push("... 1 more item"); + } else if (remaining > 1) { + items.push(`... ${remaining} more items`); + } + return "[" + items.join(", ") + "]"; +} +function getObjectTag(object) { + const tag = Object.prototype.toString.call(object).replace(/^\[object /, "").replace(/]$/, ""); + if (tag === "Object" && typeof object.constructor === "function") { + const name = object.constructor.name; + if (typeof name === "string" && name !== "") { + return name; + } + } + return tag; +} +const isProduction = globalThis.process && // eslint-disable-next-line no-undef +process$1.env.NODE_ENV === "production"; +const instanceOf = ( + /* c8 ignore next 6 */ + // FIXME: https://github.com/graphql/graphql-js/issues/2317 + isProduction ? function instanceOf2(value, constructor) { + return value instanceof constructor; + } : function instanceOf3(value, constructor) { + if (value instanceof constructor) { + return true; + } + if (typeof value === "object" && value !== null) { + var _value$constructor; + const className = constructor.prototype[Symbol.toStringTag]; + const valueClassName = ( + // We still need to support constructor's name to detect conflicts with older versions of this library. + Symbol.toStringTag in value ? value[Symbol.toStringTag] : (_value$constructor = value.constructor) === null || _value$constructor === void 0 ? void 0 : _value$constructor.name + ); + if (className === valueClassName) { + const stringifiedValue = inspect(value); + throw new Error(`Cannot use ${className} "${stringifiedValue}" from another module or realm. + +Ensure that there is only one instance of "graphql" in the node_modules +directory. If different versions of "graphql" are the dependencies of other +relied on modules, use "resolutions" to ensure only one version is installed. + +https://yarnpkg.com/en/docs/selective-version-resolutions + +Duplicate "graphql" modules cannot be used at the same time since different +versions may have different capabilities and behavior. The data from one +version used in the function from another could produce confusing and +spurious results.`); + } + } + return false; + } +); +class Source { + constructor(body, name = "GraphQL request", locationOffset = { + line: 1, + column: 1 + }) { + typeof body === "string" || devAssert(false, `Body must be a string. Received: ${inspect(body)}.`); + this.body = body; + this.name = name; + this.locationOffset = locationOffset; + this.locationOffset.line > 0 || devAssert( + false, + "line in locationOffset is 1-indexed and must be positive." + ); + this.locationOffset.column > 0 || devAssert( + false, + "column in locationOffset is 1-indexed and must be positive." + ); + } + get [Symbol.toStringTag]() { + return "Source"; + } +} +function isSource(source) { + return instanceOf(source, Source); +} +function parse(source, options) { + const parser = new Parser(source, options); + return parser.parseDocument(); +} +class Parser { + constructor(source, options = {}) { + const sourceObj = isSource(source) ? source : new Source(source); + this._lexer = new Lexer(sourceObj); + this._options = options; + this._tokenCounter = 0; + } + /** + * Converts a name lex token into a name parse node. + */ + parseName() { + const token = this.expectToken(TokenKind.NAME); + return this.node(token, { + kind: Kind.NAME, + value: token.value + }); + } + // Implements the parsing rules in the Document section. + /** + * Document : Definition+ + */ + parseDocument() { + return this.node(this._lexer.token, { + kind: Kind.DOCUMENT, + definitions: this.many( + TokenKind.SOF, + this.parseDefinition, + TokenKind.EOF + ) + }); + } + /** + * Definition : + * - ExecutableDefinition + * - TypeSystemDefinition + * - TypeSystemExtension + * + * ExecutableDefinition : + * - OperationDefinition + * - FragmentDefinition + * + * TypeSystemDefinition : + * - SchemaDefinition + * - TypeDefinition + * - DirectiveDefinition + * + * TypeDefinition : + * - ScalarTypeDefinition + * - ObjectTypeDefinition + * - InterfaceTypeDefinition + * - UnionTypeDefinition + * - EnumTypeDefinition + * - InputObjectTypeDefinition + */ + parseDefinition() { + if (this.peek(TokenKind.BRACE_L)) { + return this.parseOperationDefinition(); + } + const hasDescription = this.peekDescription(); + const keywordToken = hasDescription ? this._lexer.lookahead() : this._lexer.token; + if (keywordToken.kind === TokenKind.NAME) { + switch (keywordToken.value) { + case "schema": + return this.parseSchemaDefinition(); + case "scalar": + return this.parseScalarTypeDefinition(); + case "type": + return this.parseObjectTypeDefinition(); + case "interface": + return this.parseInterfaceTypeDefinition(); + case "union": + return this.parseUnionTypeDefinition(); + case "enum": + return this.parseEnumTypeDefinition(); + case "input": + return this.parseInputObjectTypeDefinition(); + case "directive": + return this.parseDirectiveDefinition(); + } + if (hasDescription) { + throw syntaxError( + this._lexer.source, + this._lexer.token.start, + "Unexpected description, descriptions are supported only on type definitions." + ); + } + switch (keywordToken.value) { + case "query": + case "mutation": + case "subscription": + return this.parseOperationDefinition(); + case "fragment": + return this.parseFragmentDefinition(); + case "extend": + return this.parseTypeSystemExtension(); + } + } + throw this.unexpected(keywordToken); + } + // Implements the parsing rules in the Operations section. + /** + * OperationDefinition : + * - SelectionSet + * - OperationType Name? VariableDefinitions? Directives? SelectionSet + */ + parseOperationDefinition() { + const start = this._lexer.token; + if (this.peek(TokenKind.BRACE_L)) { + return this.node(start, { + kind: Kind.OPERATION_DEFINITION, + operation: OperationTypeNode.QUERY, + name: void 0, + variableDefinitions: [], + directives: [], + selectionSet: this.parseSelectionSet() + }); + } + const operation = this.parseOperationType(); + let name; + if (this.peek(TokenKind.NAME)) { + name = this.parseName(); + } + return this.node(start, { + kind: Kind.OPERATION_DEFINITION, + operation, + name, + variableDefinitions: this.parseVariableDefinitions(), + directives: this.parseDirectives(false), + selectionSet: this.parseSelectionSet() + }); + } + /** + * OperationType : one of query mutation subscription + */ + parseOperationType() { + const operationToken = this.expectToken(TokenKind.NAME); + switch (operationToken.value) { + case "query": + return OperationTypeNode.QUERY; + case "mutation": + return OperationTypeNode.MUTATION; + case "subscription": + return OperationTypeNode.SUBSCRIPTION; + } + throw this.unexpected(operationToken); + } + /** + * VariableDefinitions : ( VariableDefinition+ ) + */ + parseVariableDefinitions() { + return this.optionalMany( + TokenKind.PAREN_L, + this.parseVariableDefinition, + TokenKind.PAREN_R + ); + } + /** + * VariableDefinition : Variable : Type DefaultValue? Directives[Const]? + */ + parseVariableDefinition() { + return this.node(this._lexer.token, { + kind: Kind.VARIABLE_DEFINITION, + variable: this.parseVariable(), + type: (this.expectToken(TokenKind.COLON), this.parseTypeReference()), + defaultValue: this.expectOptionalToken(TokenKind.EQUALS) ? this.parseConstValueLiteral() : void 0, + directives: this.parseConstDirectives() + }); + } + /** + * Variable : $ Name + */ + parseVariable() { + const start = this._lexer.token; + this.expectToken(TokenKind.DOLLAR); + return this.node(start, { + kind: Kind.VARIABLE, + name: this.parseName() + }); + } + /** + * ``` + * SelectionSet : { Selection+ } + * ``` + */ + parseSelectionSet() { + return this.node(this._lexer.token, { + kind: Kind.SELECTION_SET, + selections: this.many( + TokenKind.BRACE_L, + this.parseSelection, + TokenKind.BRACE_R + ) + }); + } + /** + * Selection : + * - Field + * - FragmentSpread + * - InlineFragment + */ + parseSelection() { + return this.peek(TokenKind.SPREAD) ? this.parseFragment() : this.parseField(); + } + /** + * Field : Alias? Name Arguments? Directives? SelectionSet? + * + * Alias : Name : + */ + parseField() { + const start = this._lexer.token; + const nameOrAlias = this.parseName(); + let alias; + let name; + if (this.expectOptionalToken(TokenKind.COLON)) { + alias = nameOrAlias; + name = this.parseName(); + } else { + name = nameOrAlias; + } + return this.node(start, { + kind: Kind.FIELD, + alias, + name, + arguments: this.parseArguments(false), + directives: this.parseDirectives(false), + selectionSet: this.peek(TokenKind.BRACE_L) ? this.parseSelectionSet() : void 0 + }); + } + /** + * Arguments[Const] : ( Argument[?Const]+ ) + */ + parseArguments(isConst) { + const item = isConst ? this.parseConstArgument : this.parseArgument; + return this.optionalMany(TokenKind.PAREN_L, item, TokenKind.PAREN_R); + } + /** + * Argument[Const] : Name : Value[?Const] + */ + parseArgument(isConst = false) { + const start = this._lexer.token; + const name = this.parseName(); + this.expectToken(TokenKind.COLON); + return this.node(start, { + kind: Kind.ARGUMENT, + name, + value: this.parseValueLiteral(isConst) + }); + } + parseConstArgument() { + return this.parseArgument(true); + } + // Implements the parsing rules in the Fragments section. + /** + * Corresponds to both FragmentSpread and InlineFragment in the spec. + * + * FragmentSpread : ... FragmentName Directives? + * + * InlineFragment : ... TypeCondition? Directives? SelectionSet + */ + parseFragment() { + const start = this._lexer.token; + this.expectToken(TokenKind.SPREAD); + const hasTypeCondition = this.expectOptionalKeyword("on"); + if (!hasTypeCondition && this.peek(TokenKind.NAME)) { + return this.node(start, { + kind: Kind.FRAGMENT_SPREAD, + name: this.parseFragmentName(), + directives: this.parseDirectives(false) + }); + } + return this.node(start, { + kind: Kind.INLINE_FRAGMENT, + typeCondition: hasTypeCondition ? this.parseNamedType() : void 0, + directives: this.parseDirectives(false), + selectionSet: this.parseSelectionSet() + }); + } + /** + * FragmentDefinition : + * - fragment FragmentName on TypeCondition Directives? SelectionSet + * + * TypeCondition : NamedType + */ + parseFragmentDefinition() { + const start = this._lexer.token; + this.expectKeyword("fragment"); + if (this._options.allowLegacyFragmentVariables === true) { + return this.node(start, { + kind: Kind.FRAGMENT_DEFINITION, + name: this.parseFragmentName(), + variableDefinitions: this.parseVariableDefinitions(), + typeCondition: (this.expectKeyword("on"), this.parseNamedType()), + directives: this.parseDirectives(false), + selectionSet: this.parseSelectionSet() + }); + } + return this.node(start, { + kind: Kind.FRAGMENT_DEFINITION, + name: this.parseFragmentName(), + typeCondition: (this.expectKeyword("on"), this.parseNamedType()), + directives: this.parseDirectives(false), + selectionSet: this.parseSelectionSet() + }); + } + /** + * FragmentName : Name but not `on` + */ + parseFragmentName() { + if (this._lexer.token.value === "on") { + throw this.unexpected(); + } + return this.parseName(); + } + // Implements the parsing rules in the Values section. + /** + * Value[Const] : + * - [~Const] Variable + * - IntValue + * - FloatValue + * - StringValue + * - BooleanValue + * - NullValue + * - EnumValue + * - ListValue[?Const] + * - ObjectValue[?Const] + * + * BooleanValue : one of `true` `false` + * + * NullValue : `null` + * + * EnumValue : Name but not `true`, `false` or `null` + */ + parseValueLiteral(isConst) { + const token = this._lexer.token; + switch (token.kind) { + case TokenKind.BRACKET_L: + return this.parseList(isConst); + case TokenKind.BRACE_L: + return this.parseObject(isConst); + case TokenKind.INT: + this.advanceLexer(); + return this.node(token, { + kind: Kind.INT, + value: token.value + }); + case TokenKind.FLOAT: + this.advanceLexer(); + return this.node(token, { + kind: Kind.FLOAT, + value: token.value + }); + case TokenKind.STRING: + case TokenKind.BLOCK_STRING: + return this.parseStringLiteral(); + case TokenKind.NAME: + this.advanceLexer(); + switch (token.value) { + case "true": + return this.node(token, { + kind: Kind.BOOLEAN, + value: true + }); + case "false": + return this.node(token, { + kind: Kind.BOOLEAN, + value: false + }); + case "null": + return this.node(token, { + kind: Kind.NULL + }); + default: + return this.node(token, { + kind: Kind.ENUM, + value: token.value + }); + } + case TokenKind.DOLLAR: + if (isConst) { + this.expectToken(TokenKind.DOLLAR); + if (this._lexer.token.kind === TokenKind.NAME) { + const varName = this._lexer.token.value; + throw syntaxError( + this._lexer.source, + token.start, + `Unexpected variable "$${varName}" in constant value.` + ); + } else { + throw this.unexpected(token); + } + } + return this.parseVariable(); + default: + throw this.unexpected(); + } + } + parseConstValueLiteral() { + return this.parseValueLiteral(true); + } + parseStringLiteral() { + const token = this._lexer.token; + this.advanceLexer(); + return this.node(token, { + kind: Kind.STRING, + value: token.value, + block: token.kind === TokenKind.BLOCK_STRING + }); + } + /** + * ListValue[Const] : + * - [ ] + * - [ Value[?Const]+ ] + */ + parseList(isConst) { + const item = () => this.parseValueLiteral(isConst); + return this.node(this._lexer.token, { + kind: Kind.LIST, + values: this.any(TokenKind.BRACKET_L, item, TokenKind.BRACKET_R) + }); + } + /** + * ``` + * ObjectValue[Const] : + * - { } + * - { ObjectField[?Const]+ } + * ``` + */ + parseObject(isConst) { + const item = () => this.parseObjectField(isConst); + return this.node(this._lexer.token, { + kind: Kind.OBJECT, + fields: this.any(TokenKind.BRACE_L, item, TokenKind.BRACE_R) + }); + } + /** + * ObjectField[Const] : Name : Value[?Const] + */ + parseObjectField(isConst) { + const start = this._lexer.token; + const name = this.parseName(); + this.expectToken(TokenKind.COLON); + return this.node(start, { + kind: Kind.OBJECT_FIELD, + name, + value: this.parseValueLiteral(isConst) + }); + } + // Implements the parsing rules in the Directives section. + /** + * Directives[Const] : Directive[?Const]+ + */ + parseDirectives(isConst) { + const directives = []; + while (this.peek(TokenKind.AT)) { + directives.push(this.parseDirective(isConst)); + } + return directives; + } + parseConstDirectives() { + return this.parseDirectives(true); + } + /** + * ``` + * Directive[Const] : @ Name Arguments[?Const]? + * ``` + */ + parseDirective(isConst) { + const start = this._lexer.token; + this.expectToken(TokenKind.AT); + return this.node(start, { + kind: Kind.DIRECTIVE, + name: this.parseName(), + arguments: this.parseArguments(isConst) + }); + } + // Implements the parsing rules in the Types section. + /** + * Type : + * - NamedType + * - ListType + * - NonNullType + */ + parseTypeReference() { + const start = this._lexer.token; + let type2; + if (this.expectOptionalToken(TokenKind.BRACKET_L)) { + const innerType = this.parseTypeReference(); + this.expectToken(TokenKind.BRACKET_R); + type2 = this.node(start, { + kind: Kind.LIST_TYPE, + type: innerType + }); + } else { + type2 = this.parseNamedType(); + } + if (this.expectOptionalToken(TokenKind.BANG)) { + return this.node(start, { + kind: Kind.NON_NULL_TYPE, + type: type2 + }); + } + return type2; + } + /** + * NamedType : Name + */ + parseNamedType() { + return this.node(this._lexer.token, { + kind: Kind.NAMED_TYPE, + name: this.parseName() + }); + } + // Implements the parsing rules in the Type Definition section. + peekDescription() { + return this.peek(TokenKind.STRING) || this.peek(TokenKind.BLOCK_STRING); + } + /** + * Description : StringValue + */ + parseDescription() { + if (this.peekDescription()) { + return this.parseStringLiteral(); + } + } + /** + * ``` + * SchemaDefinition : Description? schema Directives[Const]? { OperationTypeDefinition+ } + * ``` + */ + parseSchemaDefinition() { + const start = this._lexer.token; + const description = this.parseDescription(); + this.expectKeyword("schema"); + const directives = this.parseConstDirectives(); + const operationTypes = this.many( + TokenKind.BRACE_L, + this.parseOperationTypeDefinition, + TokenKind.BRACE_R + ); + return this.node(start, { + kind: Kind.SCHEMA_DEFINITION, + description, + directives, + operationTypes + }); + } + /** + * OperationTypeDefinition : OperationType : NamedType + */ + parseOperationTypeDefinition() { + const start = this._lexer.token; + const operation = this.parseOperationType(); + this.expectToken(TokenKind.COLON); + const type2 = this.parseNamedType(); + return this.node(start, { + kind: Kind.OPERATION_TYPE_DEFINITION, + operation, + type: type2 + }); + } + /** + * ScalarTypeDefinition : Description? scalar Name Directives[Const]? + */ + parseScalarTypeDefinition() { + const start = this._lexer.token; + const description = this.parseDescription(); + this.expectKeyword("scalar"); + const name = this.parseName(); + const directives = this.parseConstDirectives(); + return this.node(start, { + kind: Kind.SCALAR_TYPE_DEFINITION, + description, + name, + directives + }); + } + /** + * ObjectTypeDefinition : + * Description? + * type Name ImplementsInterfaces? Directives[Const]? FieldsDefinition? + */ + parseObjectTypeDefinition() { + const start = this._lexer.token; + const description = this.parseDescription(); + this.expectKeyword("type"); + const name = this.parseName(); + const interfaces = this.parseImplementsInterfaces(); + const directives = this.parseConstDirectives(); + const fields = this.parseFieldsDefinition(); + return this.node(start, { + kind: Kind.OBJECT_TYPE_DEFINITION, + description, + name, + interfaces, + directives, + fields + }); + } + /** + * ImplementsInterfaces : + * - implements `&`? NamedType + * - ImplementsInterfaces & NamedType + */ + parseImplementsInterfaces() { + return this.expectOptionalKeyword("implements") ? this.delimitedMany(TokenKind.AMP, this.parseNamedType) : []; + } + /** + * ``` + * FieldsDefinition : { FieldDefinition+ } + * ``` + */ + parseFieldsDefinition() { + return this.optionalMany( + TokenKind.BRACE_L, + this.parseFieldDefinition, + TokenKind.BRACE_R + ); + } + /** + * FieldDefinition : + * - Description? Name ArgumentsDefinition? : Type Directives[Const]? + */ + parseFieldDefinition() { + const start = this._lexer.token; + const description = this.parseDescription(); + const name = this.parseName(); + const args = this.parseArgumentDefs(); + this.expectToken(TokenKind.COLON); + const type2 = this.parseTypeReference(); + const directives = this.parseConstDirectives(); + return this.node(start, { + kind: Kind.FIELD_DEFINITION, + description, + name, + arguments: args, + type: type2, + directives + }); + } + /** + * ArgumentsDefinition : ( InputValueDefinition+ ) + */ + parseArgumentDefs() { + return this.optionalMany( + TokenKind.PAREN_L, + this.parseInputValueDef, + TokenKind.PAREN_R + ); + } + /** + * InputValueDefinition : + * - Description? Name : Type DefaultValue? Directives[Const]? + */ + parseInputValueDef() { + const start = this._lexer.token; + const description = this.parseDescription(); + const name = this.parseName(); + this.expectToken(TokenKind.COLON); + const type2 = this.parseTypeReference(); + let defaultValue; + if (this.expectOptionalToken(TokenKind.EQUALS)) { + defaultValue = this.parseConstValueLiteral(); + } + const directives = this.parseConstDirectives(); + return this.node(start, { + kind: Kind.INPUT_VALUE_DEFINITION, + description, + name, + type: type2, + defaultValue, + directives + }); + } + /** + * InterfaceTypeDefinition : + * - Description? interface Name Directives[Const]? FieldsDefinition? + */ + parseInterfaceTypeDefinition() { + const start = this._lexer.token; + const description = this.parseDescription(); + this.expectKeyword("interface"); + const name = this.parseName(); + const interfaces = this.parseImplementsInterfaces(); + const directives = this.parseConstDirectives(); + const fields = this.parseFieldsDefinition(); + return this.node(start, { + kind: Kind.INTERFACE_TYPE_DEFINITION, + description, + name, + interfaces, + directives, + fields + }); + } + /** + * UnionTypeDefinition : + * - Description? union Name Directives[Const]? UnionMemberTypes? + */ + parseUnionTypeDefinition() { + const start = this._lexer.token; + const description = this.parseDescription(); + this.expectKeyword("union"); + const name = this.parseName(); + const directives = this.parseConstDirectives(); + const types2 = this.parseUnionMemberTypes(); + return this.node(start, { + kind: Kind.UNION_TYPE_DEFINITION, + description, + name, + directives, + types: types2 + }); + } + /** + * UnionMemberTypes : + * - = `|`? NamedType + * - UnionMemberTypes | NamedType + */ + parseUnionMemberTypes() { + return this.expectOptionalToken(TokenKind.EQUALS) ? this.delimitedMany(TokenKind.PIPE, this.parseNamedType) : []; + } + /** + * EnumTypeDefinition : + * - Description? enum Name Directives[Const]? EnumValuesDefinition? + */ + parseEnumTypeDefinition() { + const start = this._lexer.token; + const description = this.parseDescription(); + this.expectKeyword("enum"); + const name = this.parseName(); + const directives = this.parseConstDirectives(); + const values = this.parseEnumValuesDefinition(); + return this.node(start, { + kind: Kind.ENUM_TYPE_DEFINITION, + description, + name, + directives, + values + }); + } + /** + * ``` + * EnumValuesDefinition : { EnumValueDefinition+ } + * ``` + */ + parseEnumValuesDefinition() { + return this.optionalMany( + TokenKind.BRACE_L, + this.parseEnumValueDefinition, + TokenKind.BRACE_R + ); + } + /** + * EnumValueDefinition : Description? EnumValue Directives[Const]? + */ + parseEnumValueDefinition() { + const start = this._lexer.token; + const description = this.parseDescription(); + const name = this.parseEnumValueName(); + const directives = this.parseConstDirectives(); + return this.node(start, { + kind: Kind.ENUM_VALUE_DEFINITION, + description, + name, + directives + }); + } + /** + * EnumValue : Name but not `true`, `false` or `null` + */ + parseEnumValueName() { + if (this._lexer.token.value === "true" || this._lexer.token.value === "false" || this._lexer.token.value === "null") { + throw syntaxError( + this._lexer.source, + this._lexer.token.start, + `${getTokenDesc( + this._lexer.token + )} is reserved and cannot be used for an enum value.` + ); + } + return this.parseName(); + } + /** + * InputObjectTypeDefinition : + * - Description? input Name Directives[Const]? InputFieldsDefinition? + */ + parseInputObjectTypeDefinition() { + const start = this._lexer.token; + const description = this.parseDescription(); + this.expectKeyword("input"); + const name = this.parseName(); + const directives = this.parseConstDirectives(); + const fields = this.parseInputFieldsDefinition(); + return this.node(start, { + kind: Kind.INPUT_OBJECT_TYPE_DEFINITION, + description, + name, + directives, + fields + }); + } + /** + * ``` + * InputFieldsDefinition : { InputValueDefinition+ } + * ``` + */ + parseInputFieldsDefinition() { + return this.optionalMany( + TokenKind.BRACE_L, + this.parseInputValueDef, + TokenKind.BRACE_R + ); + } + /** + * TypeSystemExtension : + * - SchemaExtension + * - TypeExtension + * + * TypeExtension : + * - ScalarTypeExtension + * - ObjectTypeExtension + * - InterfaceTypeExtension + * - UnionTypeExtension + * - EnumTypeExtension + * - InputObjectTypeDefinition + */ + parseTypeSystemExtension() { + const keywordToken = this._lexer.lookahead(); + if (keywordToken.kind === TokenKind.NAME) { + switch (keywordToken.value) { + case "schema": + return this.parseSchemaExtension(); + case "scalar": + return this.parseScalarTypeExtension(); + case "type": + return this.parseObjectTypeExtension(); + case "interface": + return this.parseInterfaceTypeExtension(); + case "union": + return this.parseUnionTypeExtension(); + case "enum": + return this.parseEnumTypeExtension(); + case "input": + return this.parseInputObjectTypeExtension(); + } + } + throw this.unexpected(keywordToken); + } + /** + * ``` + * SchemaExtension : + * - extend schema Directives[Const]? { OperationTypeDefinition+ } + * - extend schema Directives[Const] + * ``` + */ + parseSchemaExtension() { + const start = this._lexer.token; + this.expectKeyword("extend"); + this.expectKeyword("schema"); + const directives = this.parseConstDirectives(); + const operationTypes = this.optionalMany( + TokenKind.BRACE_L, + this.parseOperationTypeDefinition, + TokenKind.BRACE_R + ); + if (directives.length === 0 && operationTypes.length === 0) { + throw this.unexpected(); + } + return this.node(start, { + kind: Kind.SCHEMA_EXTENSION, + directives, + operationTypes + }); + } + /** + * ScalarTypeExtension : + * - extend scalar Name Directives[Const] + */ + parseScalarTypeExtension() { + const start = this._lexer.token; + this.expectKeyword("extend"); + this.expectKeyword("scalar"); + const name = this.parseName(); + const directives = this.parseConstDirectives(); + if (directives.length === 0) { + throw this.unexpected(); + } + return this.node(start, { + kind: Kind.SCALAR_TYPE_EXTENSION, + name, + directives + }); + } + /** + * ObjectTypeExtension : + * - extend type Name ImplementsInterfaces? Directives[Const]? FieldsDefinition + * - extend type Name ImplementsInterfaces? Directives[Const] + * - extend type Name ImplementsInterfaces + */ + parseObjectTypeExtension() { + const start = this._lexer.token; + this.expectKeyword("extend"); + this.expectKeyword("type"); + const name = this.parseName(); + const interfaces = this.parseImplementsInterfaces(); + const directives = this.parseConstDirectives(); + const fields = this.parseFieldsDefinition(); + if (interfaces.length === 0 && directives.length === 0 && fields.length === 0) { + throw this.unexpected(); + } + return this.node(start, { + kind: Kind.OBJECT_TYPE_EXTENSION, + name, + interfaces, + directives, + fields + }); + } + /** + * InterfaceTypeExtension : + * - extend interface Name ImplementsInterfaces? Directives[Const]? FieldsDefinition + * - extend interface Name ImplementsInterfaces? Directives[Const] + * - extend interface Name ImplementsInterfaces + */ + parseInterfaceTypeExtension() { + const start = this._lexer.token; + this.expectKeyword("extend"); + this.expectKeyword("interface"); + const name = this.parseName(); + const interfaces = this.parseImplementsInterfaces(); + const directives = this.parseConstDirectives(); + const fields = this.parseFieldsDefinition(); + if (interfaces.length === 0 && directives.length === 0 && fields.length === 0) { + throw this.unexpected(); + } + return this.node(start, { + kind: Kind.INTERFACE_TYPE_EXTENSION, + name, + interfaces, + directives, + fields + }); + } + /** + * UnionTypeExtension : + * - extend union Name Directives[Const]? UnionMemberTypes + * - extend union Name Directives[Const] + */ + parseUnionTypeExtension() { + const start = this._lexer.token; + this.expectKeyword("extend"); + this.expectKeyword("union"); + const name = this.parseName(); + const directives = this.parseConstDirectives(); + const types2 = this.parseUnionMemberTypes(); + if (directives.length === 0 && types2.length === 0) { + throw this.unexpected(); + } + return this.node(start, { + kind: Kind.UNION_TYPE_EXTENSION, + name, + directives, + types: types2 + }); + } + /** + * EnumTypeExtension : + * - extend enum Name Directives[Const]? EnumValuesDefinition + * - extend enum Name Directives[Const] + */ + parseEnumTypeExtension() { + const start = this._lexer.token; + this.expectKeyword("extend"); + this.expectKeyword("enum"); + const name = this.parseName(); + const directives = this.parseConstDirectives(); + const values = this.parseEnumValuesDefinition(); + if (directives.length === 0 && values.length === 0) { + throw this.unexpected(); + } + return this.node(start, { + kind: Kind.ENUM_TYPE_EXTENSION, + name, + directives, + values + }); + } + /** + * InputObjectTypeExtension : + * - extend input Name Directives[Const]? InputFieldsDefinition + * - extend input Name Directives[Const] + */ + parseInputObjectTypeExtension() { + const start = this._lexer.token; + this.expectKeyword("extend"); + this.expectKeyword("input"); + const name = this.parseName(); + const directives = this.parseConstDirectives(); + const fields = this.parseInputFieldsDefinition(); + if (directives.length === 0 && fields.length === 0) { + throw this.unexpected(); + } + return this.node(start, { + kind: Kind.INPUT_OBJECT_TYPE_EXTENSION, + name, + directives, + fields + }); + } + /** + * ``` + * DirectiveDefinition : + * - Description? directive @ Name ArgumentsDefinition? `repeatable`? on DirectiveLocations + * ``` + */ + parseDirectiveDefinition() { + const start = this._lexer.token; + const description = this.parseDescription(); + this.expectKeyword("directive"); + this.expectToken(TokenKind.AT); + const name = this.parseName(); + const args = this.parseArgumentDefs(); + const repeatable = this.expectOptionalKeyword("repeatable"); + this.expectKeyword("on"); + const locations = this.parseDirectiveLocations(); + return this.node(start, { + kind: Kind.DIRECTIVE_DEFINITION, + description, + name, + arguments: args, + repeatable, + locations + }); + } + /** + * DirectiveLocations : + * - `|`? DirectiveLocation + * - DirectiveLocations | DirectiveLocation + */ + parseDirectiveLocations() { + return this.delimitedMany(TokenKind.PIPE, this.parseDirectiveLocation); + } + /* + * DirectiveLocation : + * - ExecutableDirectiveLocation + * - TypeSystemDirectiveLocation + * + * ExecutableDirectiveLocation : one of + * `QUERY` + * `MUTATION` + * `SUBSCRIPTION` + * `FIELD` + * `FRAGMENT_DEFINITION` + * `FRAGMENT_SPREAD` + * `INLINE_FRAGMENT` + * + * TypeSystemDirectiveLocation : one of + * `SCHEMA` + * `SCALAR` + * `OBJECT` + * `FIELD_DEFINITION` + * `ARGUMENT_DEFINITION` + * `INTERFACE` + * `UNION` + * `ENUM` + * `ENUM_VALUE` + * `INPUT_OBJECT` + * `INPUT_FIELD_DEFINITION` + */ + parseDirectiveLocation() { + const start = this._lexer.token; + const name = this.parseName(); + if (Object.prototype.hasOwnProperty.call(DirectiveLocation, name.value)) { + return name; + } + throw this.unexpected(start); + } + // Core parsing utility functions + /** + * Returns a node that, if configured to do so, sets a "loc" field as a + * location object, used to identify the place in the source that created a + * given parsed object. + */ + node(startToken, node2) { + if (this._options.noLocation !== true) { + node2.loc = new Location( + startToken, + this._lexer.lastToken, + this._lexer.source + ); + } + return node2; + } + /** + * Determines if the next token is of a given kind + */ + peek(kind) { + return this._lexer.token.kind === kind; + } + /** + * If the next token is of the given kind, return that token after advancing the lexer. + * Otherwise, do not change the parser state and throw an error. + */ + expectToken(kind) { + const token = this._lexer.token; + if (token.kind === kind) { + this.advanceLexer(); + return token; + } + throw syntaxError( + this._lexer.source, + token.start, + `Expected ${getTokenKindDesc(kind)}, found ${getTokenDesc(token)}.` + ); + } + /** + * If the next token is of the given kind, return "true" after advancing the lexer. + * Otherwise, do not change the parser state and return "false". + */ + expectOptionalToken(kind) { + const token = this._lexer.token; + if (token.kind === kind) { + this.advanceLexer(); + return true; + } + return false; + } + /** + * If the next token is a given keyword, advance the lexer. + * Otherwise, do not change the parser state and throw an error. + */ + expectKeyword(value) { + const token = this._lexer.token; + if (token.kind === TokenKind.NAME && token.value === value) { + this.advanceLexer(); + } else { + throw syntaxError( + this._lexer.source, + token.start, + `Expected "${value}", found ${getTokenDesc(token)}.` + ); + } + } + /** + * If the next token is a given keyword, return "true" after advancing the lexer. + * Otherwise, do not change the parser state and return "false". + */ + expectOptionalKeyword(value) { + const token = this._lexer.token; + if (token.kind === TokenKind.NAME && token.value === value) { + this.advanceLexer(); + return true; + } + return false; + } + /** + * Helper function for creating an error when an unexpected lexed token is encountered. + */ + unexpected(atToken) { + const token = atToken !== null && atToken !== void 0 ? atToken : this._lexer.token; + return syntaxError( + this._lexer.source, + token.start, + `Unexpected ${getTokenDesc(token)}.` + ); + } + /** + * Returns a possibly empty list of parse nodes, determined by the parseFn. + * This list begins with a lex token of openKind and ends with a lex token of closeKind. + * Advances the parser to the next lex token after the closing token. + */ + any(openKind, parseFn, closeKind) { + this.expectToken(openKind); + const nodes = []; + while (!this.expectOptionalToken(closeKind)) { + nodes.push(parseFn.call(this)); + } + return nodes; + } + /** + * Returns a list of parse nodes, determined by the parseFn. + * It can be empty only if open token is missing otherwise it will always return non-empty list + * that begins with a lex token of openKind and ends with a lex token of closeKind. + * Advances the parser to the next lex token after the closing token. + */ + optionalMany(openKind, parseFn, closeKind) { + if (this.expectOptionalToken(openKind)) { + const nodes = []; + do { + nodes.push(parseFn.call(this)); + } while (!this.expectOptionalToken(closeKind)); + return nodes; + } + return []; + } + /** + * Returns a non-empty list of parse nodes, determined by the parseFn. + * This list begins with a lex token of openKind and ends with a lex token of closeKind. + * Advances the parser to the next lex token after the closing token. + */ + many(openKind, parseFn, closeKind) { + this.expectToken(openKind); + const nodes = []; + do { + nodes.push(parseFn.call(this)); + } while (!this.expectOptionalToken(closeKind)); + return nodes; + } + /** + * Returns a non-empty list of parse nodes, determined by the parseFn. + * This list may begin with a lex token of delimiterKind followed by items separated by lex tokens of tokenKind. + * Advances the parser to the next lex token after last item in the list. + */ + delimitedMany(delimiterKind, parseFn) { + this.expectOptionalToken(delimiterKind); + const nodes = []; + do { + nodes.push(parseFn.call(this)); + } while (this.expectOptionalToken(delimiterKind)); + return nodes; + } + advanceLexer() { + const { maxTokens } = this._options; + const token = this._lexer.advance(); + if (maxTokens !== void 0 && token.kind !== TokenKind.EOF) { + ++this._tokenCounter; + if (this._tokenCounter > maxTokens) { + throw syntaxError( + this._lexer.source, + token.start, + `Document contains more that ${maxTokens} tokens. Parsing aborted.` + ); + } + } + } +} +function getTokenDesc(token) { + const value = token.value; + return getTokenKindDesc(token.kind) + (value != null ? ` "${value}"` : ""); +} +function getTokenKindDesc(kind) { + return isPunctuatorTokenKind(kind) ? `"${kind}"` : kind; +} +function printString(str) { + return `"${str.replace(escapedRegExp, escapedReplacer)}"`; +} +const escapedRegExp = /[\x00-\x1f\x22\x5c\x7f-\x9f]/g; +function escapedReplacer(str) { + return escapeSequences[str.charCodeAt(0)]; +} +const escapeSequences = [ + "\\u0000", + "\\u0001", + "\\u0002", + "\\u0003", + "\\u0004", + "\\u0005", + "\\u0006", + "\\u0007", + "\\b", + "\\t", + "\\n", + "\\u000B", + "\\f", + "\\r", + "\\u000E", + "\\u000F", + "\\u0010", + "\\u0011", + "\\u0012", + "\\u0013", + "\\u0014", + "\\u0015", + "\\u0016", + "\\u0017", + "\\u0018", + "\\u0019", + "\\u001A", + "\\u001B", + "\\u001C", + "\\u001D", + "\\u001E", + "\\u001F", + "", + "", + '\\"', + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + // 2F + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + // 3F + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + // 4F + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "\\\\", + "", + "", + "", + // 5F + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + // 6F + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "\\u007F", + "\\u0080", + "\\u0081", + "\\u0082", + "\\u0083", + "\\u0084", + "\\u0085", + "\\u0086", + "\\u0087", + "\\u0088", + "\\u0089", + "\\u008A", + "\\u008B", + "\\u008C", + "\\u008D", + "\\u008E", + "\\u008F", + "\\u0090", + "\\u0091", + "\\u0092", + "\\u0093", + "\\u0094", + "\\u0095", + "\\u0096", + "\\u0097", + "\\u0098", + "\\u0099", + "\\u009A", + "\\u009B", + "\\u009C", + "\\u009D", + "\\u009E", + "\\u009F" +]; +const BREAK = Object.freeze({}); +function visit(root, visitor, visitorKeys = QueryDocumentKeys) { + const enterLeaveMap = /* @__PURE__ */ new Map(); + for (const kind of Object.values(Kind)) { + enterLeaveMap.set(kind, getEnterLeaveForKind(visitor, kind)); + } + let stack = void 0; + let inArray = Array.isArray(root); + let keys = [root]; + let index = -1; + let edits = []; + let node2 = root; + let key2 = void 0; + let parent = void 0; + const path = []; + const ancestors = []; + do { + index++; + const isLeaving = index === keys.length; + const isEdited = isLeaving && edits.length !== 0; + if (isLeaving) { + key2 = ancestors.length === 0 ? void 0 : path[path.length - 1]; + node2 = parent; + parent = ancestors.pop(); + if (isEdited) { + if (inArray) { + node2 = node2.slice(); + let editOffset = 0; + for (const [editKey, editValue] of edits) { + const arrayKey = editKey - editOffset; + if (editValue === null) { + node2.splice(arrayKey, 1); + editOffset++; + } else { + node2[arrayKey] = editValue; + } + } + } else { + node2 = Object.defineProperties( + {}, + Object.getOwnPropertyDescriptors(node2) + ); + for (const [editKey, editValue] of edits) { + node2[editKey] = editValue; + } + } + } + index = stack.index; + keys = stack.keys; + edits = stack.edits; + inArray = stack.inArray; + stack = stack.prev; + } else if (parent) { + key2 = inArray ? index : keys[index]; + node2 = parent[key2]; + if (node2 === null || node2 === void 0) { + continue; + } + path.push(key2); + } + let result; + if (!Array.isArray(node2)) { + var _enterLeaveMap$get, _enterLeaveMap$get2; + isNode(node2) || devAssert(false, `Invalid AST Node: ${inspect(node2)}.`); + const visitFn = isLeaving ? (_enterLeaveMap$get = enterLeaveMap.get(node2.kind)) === null || _enterLeaveMap$get === void 0 ? void 0 : _enterLeaveMap$get.leave : (_enterLeaveMap$get2 = enterLeaveMap.get(node2.kind)) === null || _enterLeaveMap$get2 === void 0 ? void 0 : _enterLeaveMap$get2.enter; + result = visitFn === null || visitFn === void 0 ? void 0 : visitFn.call(visitor, node2, key2, parent, path, ancestors); + if (result === BREAK) { + break; + } + if (result === false) { + if (!isLeaving) { + path.pop(); + continue; + } + } else if (result !== void 0) { + edits.push([key2, result]); + if (!isLeaving) { + if (isNode(result)) { + node2 = result; + } else { + path.pop(); + continue; + } + } + } + } + if (result === void 0 && isEdited) { + edits.push([key2, node2]); + } + if (isLeaving) { + path.pop(); + } else { + var _node$kind; + stack = { + inArray, + index, + keys, + edits, + prev: stack + }; + inArray = Array.isArray(node2); + keys = inArray ? node2 : (_node$kind = visitorKeys[node2.kind]) !== null && _node$kind !== void 0 ? _node$kind : []; + index = -1; + edits = []; + if (parent) { + ancestors.push(parent); + } + parent = node2; + } + } while (stack !== void 0); + if (edits.length !== 0) { + return edits[edits.length - 1][1]; + } + return root; +} +function getEnterLeaveForKind(visitor, kind) { + const kindVisitor = visitor[kind]; + if (typeof kindVisitor === "object") { + return kindVisitor; + } else if (typeof kindVisitor === "function") { + return { + enter: kindVisitor, + leave: void 0 + }; + } + return { + enter: visitor.enter, + leave: visitor.leave + }; +} +function print(ast) { + return visit(ast, printDocASTReducer); +} +const MAX_LINE_LENGTH = 80; +const printDocASTReducer = { + Name: { + leave: (node2) => node2.value + }, + Variable: { + leave: (node2) => "$" + node2.name + }, + // Document + Document: { + leave: (node2) => join(node2.definitions, "\n\n") + }, + OperationDefinition: { + leave(node2) { + const varDefs = wrap("(", join(node2.variableDefinitions, ", "), ")"); + const prefix = join( + [ + node2.operation, + join([node2.name, varDefs]), + join(node2.directives, " ") + ], + " " + ); + return (prefix === "query" ? "" : prefix + " ") + node2.selectionSet; + } + }, + VariableDefinition: { + leave: ({ variable, type: type2, defaultValue, directives }) => variable + ": " + type2 + wrap(" = ", defaultValue) + wrap(" ", join(directives, " ")) + }, + SelectionSet: { + leave: ({ selections }) => block(selections) + }, + Field: { + leave({ alias, name, arguments: args, directives, selectionSet }) { + const prefix = wrap("", alias, ": ") + name; + let argsLine = prefix + wrap("(", join(args, ", "), ")"); + if (argsLine.length > MAX_LINE_LENGTH) { + argsLine = prefix + wrap("(\n", indent(join(args, "\n")), "\n)"); + } + return join([argsLine, join(directives, " "), selectionSet], " "); + } + }, + Argument: { + leave: ({ name, value }) => name + ": " + value + }, + // Fragments + FragmentSpread: { + leave: ({ name, directives }) => "..." + name + wrap(" ", join(directives, " ")) + }, + InlineFragment: { + leave: ({ typeCondition, directives, selectionSet }) => join( + [ + "...", + wrap("on ", typeCondition), + join(directives, " "), + selectionSet + ], + " " + ) + }, + FragmentDefinition: { + leave: ({ name, typeCondition, variableDefinitions, directives, selectionSet }) => ( + // or removed in the future. + `fragment ${name}${wrap("(", join(variableDefinitions, ", "), ")")} on ${typeCondition} ${wrap("", join(directives, " "), " ")}` + selectionSet + ) + }, + // Value + IntValue: { + leave: ({ value }) => value + }, + FloatValue: { + leave: ({ value }) => value + }, + StringValue: { + leave: ({ value, block: isBlockString }) => isBlockString ? printBlockString(value) : printString(value) + }, + BooleanValue: { + leave: ({ value }) => value ? "true" : "false" + }, + NullValue: { + leave: () => "null" + }, + EnumValue: { + leave: ({ value }) => value + }, + ListValue: { + leave: ({ values }) => "[" + join(values, ", ") + "]" + }, + ObjectValue: { + leave: ({ fields }) => "{" + join(fields, ", ") + "}" + }, + ObjectField: { + leave: ({ name, value }) => name + ": " + value + }, + // Directive + Directive: { + leave: ({ name, arguments: args }) => "@" + name + wrap("(", join(args, ", "), ")") + }, + // Type + NamedType: { + leave: ({ name }) => name + }, + ListType: { + leave: ({ type: type2 }) => "[" + type2 + "]" + }, + NonNullType: { + leave: ({ type: type2 }) => type2 + "!" + }, + // Type System Definitions + SchemaDefinition: { + leave: ({ description, directives, operationTypes }) => wrap("", description, "\n") + join(["schema", join(directives, " "), block(operationTypes)], " ") + }, + OperationTypeDefinition: { + leave: ({ operation, type: type2 }) => operation + ": " + type2 + }, + ScalarTypeDefinition: { + leave: ({ description, name, directives }) => wrap("", description, "\n") + join(["scalar", name, join(directives, " ")], " ") + }, + ObjectTypeDefinition: { + leave: ({ description, name, interfaces, directives, fields }) => wrap("", description, "\n") + join( + [ + "type", + name, + wrap("implements ", join(interfaces, " & ")), + join(directives, " "), + block(fields) + ], + " " + ) + }, + FieldDefinition: { + leave: ({ description, name, arguments: args, type: type2, directives }) => wrap("", description, "\n") + name + (hasMultilineItems(args) ? wrap("(\n", indent(join(args, "\n")), "\n)") : wrap("(", join(args, ", "), ")")) + ": " + type2 + wrap(" ", join(directives, " ")) + }, + InputValueDefinition: { + leave: ({ description, name, type: type2, defaultValue, directives }) => wrap("", description, "\n") + join( + [name + ": " + type2, wrap("= ", defaultValue), join(directives, " ")], + " " + ) + }, + InterfaceTypeDefinition: { + leave: ({ description, name, interfaces, directives, fields }) => wrap("", description, "\n") + join( + [ + "interface", + name, + wrap("implements ", join(interfaces, " & ")), + join(directives, " "), + block(fields) + ], + " " + ) + }, + UnionTypeDefinition: { + leave: ({ description, name, directives, types: types2 }) => wrap("", description, "\n") + join( + ["union", name, join(directives, " "), wrap("= ", join(types2, " | "))], + " " + ) + }, + EnumTypeDefinition: { + leave: ({ description, name, directives, values }) => wrap("", description, "\n") + join(["enum", name, join(directives, " "), block(values)], " ") + }, + EnumValueDefinition: { + leave: ({ description, name, directives }) => wrap("", description, "\n") + join([name, join(directives, " ")], " ") + }, + InputObjectTypeDefinition: { + leave: ({ description, name, directives, fields }) => wrap("", description, "\n") + join(["input", name, join(directives, " "), block(fields)], " ") + }, + DirectiveDefinition: { + leave: ({ description, name, arguments: args, repeatable, locations }) => wrap("", description, "\n") + "directive @" + name + (hasMultilineItems(args) ? wrap("(\n", indent(join(args, "\n")), "\n)") : wrap("(", join(args, ", "), ")")) + (repeatable ? " repeatable" : "") + " on " + join(locations, " | ") + }, + SchemaExtension: { + leave: ({ directives, operationTypes }) => join( + ["extend schema", join(directives, " "), block(operationTypes)], + " " + ) + }, + ScalarTypeExtension: { + leave: ({ name, directives }) => join(["extend scalar", name, join(directives, " ")], " ") + }, + ObjectTypeExtension: { + leave: ({ name, interfaces, directives, fields }) => join( + [ + "extend type", + name, + wrap("implements ", join(interfaces, " & ")), + join(directives, " "), + block(fields) + ], + " " + ) + }, + InterfaceTypeExtension: { + leave: ({ name, interfaces, directives, fields }) => join( + [ + "extend interface", + name, + wrap("implements ", join(interfaces, " & ")), + join(directives, " "), + block(fields) + ], + " " + ) + }, + UnionTypeExtension: { + leave: ({ name, directives, types: types2 }) => join( + [ + "extend union", + name, + join(directives, " "), + wrap("= ", join(types2, " | ")) + ], + " " + ) + }, + EnumTypeExtension: { + leave: ({ name, directives, values }) => join(["extend enum", name, join(directives, " "), block(values)], " ") + }, + InputObjectTypeExtension: { + leave: ({ name, directives, fields }) => join(["extend input", name, join(directives, " "), block(fields)], " ") + } +}; +function join(maybeArray, separator = "") { + var _maybeArray$filter$jo; + return (_maybeArray$filter$jo = maybeArray === null || maybeArray === void 0 ? void 0 : maybeArray.filter((x) => x).join(separator)) !== null && _maybeArray$filter$jo !== void 0 ? _maybeArray$filter$jo : ""; +} +function block(array) { + return wrap("{\n", indent(join(array, "\n")), "\n}"); +} +function wrap(start, maybeString, end = "") { + return maybeString != null && maybeString !== "" ? start + maybeString + end : ""; +} +function indent(str) { + return wrap(" ", str.replace(/\n/g, "\n ")); +} +function hasMultilineItems(maybeArray) { + var _maybeArray$some; + return (_maybeArray$some = maybeArray === null || maybeArray === void 0 ? void 0 : maybeArray.some((str) => str.includes("\n"))) !== null && _maybeArray$some !== void 0 ? _maybeArray$some : false; +} +const ACCEPT_HEADER = `Accept`; +const CONTENT_TYPE_HEADER = `Content-Type`; +const CONTENT_TYPE_JSON = `application/json`; +const CONTENT_TYPE_GQL = `application/graphql-response+json`; +const cleanQuery = (str) => str.replace(/([\s,]|#[^\n\r]+)+/g, ` `).trim(); +const isGraphQLContentType = (contentType) => { + const contentTypeLower = contentType.toLowerCase(); + return contentTypeLower.includes(CONTENT_TYPE_GQL) || contentTypeLower.includes(CONTENT_TYPE_JSON); +}; +const parseGraphQLExecutionResult = (result) => { + try { + if (Array.isArray(result)) { + return { + _tag: `Batch`, + executionResults: result.map(parseExecutionResult) + }; + } else if (isPlainObject(result)) { + return { + _tag: `Single`, + executionResult: parseExecutionResult(result) + }; + } else { + throw new Error(`Invalid execution result: result is not object or array. +Got: +${String(result)}`); + } + } catch (e) { + return e; + } +}; +const parseExecutionResult = (result) => { + if (typeof result !== `object` || result === null) { + throw new Error(`Invalid execution result: result is not object`); + } + let errors = void 0; + let data = void 0; + let extensions = void 0; + if (`errors` in result) { + if (!isPlainObject(result.errors) && !Array.isArray(result.errors)) { + throw new Error(`Invalid execution result: errors is not plain object OR array`); + } + errors = result.errors; + } + if (`data` in result) { + if (!isPlainObject(result.data) && result.data !== null) { + throw new Error(`Invalid execution result: data is not plain object`); + } + data = result.data; + } + if (`extensions` in result) { + if (!isPlainObject(result.extensions)) + throw new Error(`Invalid execution result: extensions is not plain object`); + extensions = result.extensions; + } + return { + data, + errors, + extensions + }; +}; +const isRequestResultHaveErrors = (result) => result._tag === `Batch` ? result.executionResults.some(isExecutionResultHaveErrors) : isExecutionResultHaveErrors(result.executionResult); +const isExecutionResultHaveErrors = (result) => Array.isArray(result.errors) ? result.errors.length > 0 : Boolean(result.errors); +const isOperationDefinitionNode = (definition) => { + return typeof definition === `object` && definition !== null && `kind` in definition && definition.kind === Kind.OPERATION_DEFINITION; +}; +const extractOperationName = (document2) => { + let operationName = void 0; + const defs = document2.definitions.filter(isOperationDefinitionNode); + if (defs.length === 1) { + operationName = defs[0].name?.value; + } + return operationName; +}; +const extractIsMutation = (document2) => { + let isMutation = false; + const defs = document2.definitions.filter(isOperationDefinitionNode); + if (defs.length === 1) { + isMutation = defs[0].operation === `mutation`; + } + return isMutation; +}; +const analyzeDocument = (document2, excludeOperationName) => { + const expression = typeof document2 === `string` ? document2 : print(document2); + let isMutation = false; + let operationName = void 0; + if (excludeOperationName) { + return { expression, isMutation, operationName }; + } + const docNode = tryCatch(() => typeof document2 === `string` ? parse(document2) : document2); + if (docNode instanceof Error) { + return { expression, isMutation, operationName }; + } + operationName = extractOperationName(docNode); + isMutation = extractIsMutation(docNode); + return { expression, operationName, isMutation }; +}; +const defaultJsonSerializer = JSON; +const runRequest = async (input) => { + const config2 = { + ...input, + method: input.request._tag === `Single` ? input.request.document.isMutation ? `POST` : uppercase(input.method ?? `post`) : input.request.hasMutations ? `POST` : uppercase(input.method ?? `post`), + fetchOptions: { + ...input.fetchOptions, + errorPolicy: input.fetchOptions.errorPolicy ?? `none` + } + }; + const fetcher = createFetcher(config2.method); + const fetchResponse = await fetcher(config2); + if (!fetchResponse.ok) { + return new ClientError({ status: fetchResponse.status, headers: fetchResponse.headers }, { + query: input.request._tag === `Single` ? input.request.document.expression : input.request.query, + variables: input.request.variables + }); + } + const result = await parseResultFromResponse(fetchResponse, input.fetchOptions.jsonSerializer ?? defaultJsonSerializer); + if (result instanceof Error) + throw result; + const clientResponseBase = { + status: fetchResponse.status, + headers: fetchResponse.headers + }; + if (isRequestResultHaveErrors(result) && config2.fetchOptions.errorPolicy === `none`) { + const clientResponse = result._tag === `Batch` ? { ...result.executionResults, ...clientResponseBase } : { + ...result.executionResult, + ...clientResponseBase + }; + return new ClientError(clientResponse, { + query: input.request._tag === `Single` ? input.request.document.expression : input.request.query, + variables: input.request.variables + }); + } + switch (result._tag) { + case `Single`: + return { + ...clientResponseBase, + ...executionResultClientResponseFields(config2)(result.executionResult) + }; + case `Batch`: + return { + ...clientResponseBase, + data: result.executionResults.map(executionResultClientResponseFields(config2)) + }; + default: + casesExhausted(result); + } +}; +const executionResultClientResponseFields = ($params) => (executionResult) => { + return { + extensions: executionResult.extensions, + data: executionResult.data, + errors: $params.fetchOptions.errorPolicy === `all` ? executionResult.errors : void 0 + }; +}; +const parseResultFromResponse = async (response, jsonSerializer) => { + const contentType = response.headers.get(CONTENT_TYPE_HEADER); + const text = await response.text(); + if (contentType && isGraphQLContentType(contentType)) { + return parseGraphQLExecutionResult(jsonSerializer.parse(text)); + } else { + return parseGraphQLExecutionResult(text); + } +}; +const createFetcher = (method) => async (params) => { + const headers = new Headers(params.headers); + let searchParams = null; + let body = void 0; + if (!headers.has(ACCEPT_HEADER)) { + headers.set(ACCEPT_HEADER, [CONTENT_TYPE_GQL, CONTENT_TYPE_JSON].join(`, `)); + } + if (method === `POST`) { + const $jsonSerializer = params.fetchOptions.jsonSerializer ?? defaultJsonSerializer; + body = $jsonSerializer.stringify(buildBody(params)); + if (typeof body === `string` && !headers.has(CONTENT_TYPE_HEADER)) { + headers.set(CONTENT_TYPE_HEADER, CONTENT_TYPE_JSON); + } + } else { + searchParams = buildQueryParams(params); + } + const init = { method, headers, body, ...params.fetchOptions }; + let url = new URL(params.url); + let initResolved = init; + if (params.middleware) { + const result = await Promise.resolve(params.middleware({ + ...init, + url: params.url, + operationName: params.request._tag === `Single` ? params.request.document.operationName : void 0, + variables: params.request.variables + })); + const { url: urlNew, ...initNew } = result; + url = new URL(urlNew); + initResolved = initNew; + } + if (searchParams) { + searchParams.forEach((value, name) => { + url.searchParams.append(name, value); + }); + } + const $fetch = params.fetch ?? fetch; + return await $fetch(url, initResolved); +}; +const buildBody = (params) => { + switch (params.request._tag) { + case `Single`: + return { + query: params.request.document.expression, + variables: params.request.variables, + operationName: params.request.document.operationName + }; + case `Batch`: + return zip(params.request.query, params.request.variables ?? []).map(([query, variables]) => ({ + query, + variables + })); + default: + throw casesExhausted(params.request); + } +}; +const buildQueryParams = (params) => { + const $jsonSerializer = params.fetchOptions.jsonSerializer ?? defaultJsonSerializer; + const searchParams = new URLSearchParams(); + switch (params.request._tag) { + case `Single`: { + searchParams.append(`query`, cleanQuery(params.request.document.expression)); + if (params.request.variables) { + searchParams.append(`variables`, $jsonSerializer.stringify(params.request.variables)); + } + if (params.request.document.operationName) { + searchParams.append(`operationName`, params.request.document.operationName); + } + return searchParams; + } + case `Batch`: { + const variablesSerialized = params.request.variables?.map((v) => $jsonSerializer.stringify(v)) ?? []; + const queriesCleaned = params.request.query.map(cleanQuery); + const payload = zip(queriesCleaned, variablesSerialized).map(([query, variables]) => ({ + query, + variables + })); + searchParams.append(`query`, $jsonSerializer.stringify(payload)); + return searchParams; + } + default: + throw casesExhausted(params.request); + } +}; +class GraphQLClient { + url; + requestConfig; + constructor(url, requestConfig = {}) { + this.url = url; + this.requestConfig = requestConfig; + } + /** + * Send a GraphQL query to the server. + */ + rawRequest = async (...args) => { + const [queryOrOptions, variables, requestHeaders] = args; + const rawRequestOptions = parseRawRequestArgs(queryOrOptions, variables, requestHeaders); + const { headers, fetch: fetch2 = globalThis.fetch, method = `POST`, requestMiddleware, responseMiddleware, excludeOperationName, ...fetchOptions } = this.requestConfig; + const { url } = this; + if (rawRequestOptions.signal !== void 0) { + fetchOptions.signal = rawRequestOptions.signal; + } + const document2 = analyzeDocument(rawRequestOptions.query, excludeOperationName); + const response = await runRequest({ + url, + request: { + _tag: `Single`, + document: document2, + variables: rawRequestOptions.variables + }, + headers: { + ...HeadersInitToPlainObject(callOrIdentity(headers)), + ...HeadersInitToPlainObject(rawRequestOptions.requestHeaders) + }, + fetch: fetch2, + method, + fetchOptions, + middleware: requestMiddleware + }); + if (responseMiddleware) { + await responseMiddleware(response, { + operationName: document2.operationName, + variables, + url: this.url + }); + } + if (response instanceof Error) { + throw response; + } + return response; + }; + async request(documentOrOptions, ...variablesAndRequestHeaders) { + const [variables, requestHeaders] = variablesAndRequestHeaders; + const requestOptions = parseRequestArgs(documentOrOptions, variables, requestHeaders); + const { headers, fetch: fetch2 = globalThis.fetch, method = `POST`, requestMiddleware, responseMiddleware, excludeOperationName, ...fetchOptions } = this.requestConfig; + const { url } = this; + if (requestOptions.signal !== void 0) { + fetchOptions.signal = requestOptions.signal; + } + const analyzedDocument = analyzeDocument(requestOptions.document, excludeOperationName); + const response = await runRequest({ + url, + request: { + _tag: `Single`, + document: analyzedDocument, + variables: requestOptions.variables + }, + headers: { + ...HeadersInitToPlainObject(callOrIdentity(headers)), + ...HeadersInitToPlainObject(requestOptions.requestHeaders) + }, + fetch: fetch2, + method, + fetchOptions, + middleware: requestMiddleware + }); + if (responseMiddleware) { + await responseMiddleware(response, { + operationName: analyzedDocument.operationName, + variables: requestOptions.variables, + url: this.url + }); + } + if (response instanceof Error) { + throw response; + } + return response.data; + } + async batchRequests(documentsOrOptions, requestHeaders) { + const batchRequestOptions = parseBatchRequestArgs(documentsOrOptions, requestHeaders); + const { headers, excludeOperationName, ...fetchOptions } = this.requestConfig; + if (batchRequestOptions.signal !== void 0) { + fetchOptions.signal = batchRequestOptions.signal; + } + const analyzedDocuments = batchRequestOptions.documents.map(({ document: document2 }) => analyzeDocument(document2, excludeOperationName)); + const expressions = analyzedDocuments.map(({ expression }) => expression); + const hasMutations = analyzedDocuments.some(({ isMutation }) => isMutation); + const variables = batchRequestOptions.documents.map(({ variables: variables2 }) => variables2); + const response = await runRequest({ + url: this.url, + request: { + _tag: `Batch`, + operationName: void 0, + query: expressions, + hasMutations, + variables + }, + headers: { + ...HeadersInitToPlainObject(callOrIdentity(headers)), + ...HeadersInitToPlainObject(batchRequestOptions.requestHeaders) + }, + fetch: this.requestConfig.fetch ?? globalThis.fetch, + method: this.requestConfig.method || `POST`, + fetchOptions, + middleware: this.requestConfig.requestMiddleware + }); + if (this.requestConfig.responseMiddleware) { + await this.requestConfig.responseMiddleware(response, { + operationName: void 0, + variables, + url: this.url + }); + } + if (response instanceof Error) { + throw response; + } + return response.data; + } + setHeaders(headers) { + this.requestConfig.headers = headers; + return this; + } + /** + * Attach a header to the client. All subsequent requests will have this header. + */ + setHeader(key2, value) { + const { headers } = this.requestConfig; + if (headers) { + headers[key2] = value; + } else { + this.requestConfig.headers = { [key2]: value }; + } + return this; + } + /** + * Change the client endpoint. All subsequent requests will send to this endpoint. + */ + setEndpoint(value) { + this.url = value; + return this; + } +} +const parseRequestArgs = (documentOrOptions, variables, requestHeaders) => { + return documentOrOptions.document ? documentOrOptions : { + document: documentOrOptions, + variables, + requestHeaders, + signal: void 0 + }; +}; +const isConfig = (props) => { + return typeof props === "object" && props !== null && "apis" in props && "basedAppsAPI" in props && "graphs" in props; +}; +const createConfig = (props) => { + const { publicClient, walletClient, beaconchainUrl, extendedConfig } = tryCatch$1.configArgsSchema.parse(props); + const chain = publicClient.chain.id; + const hasAPIKey = Boolean(extendedConfig?.subgraph?.apiKey); + const defaultBamGraphEndpoint = hasAPIKey ? bam_paid_graph_endpoints[chain] : bam_graph_endpoints[chain]; + const bapEndpoint = extendedConfig?.subgraph?.url || defaultBamGraphEndpoint; + const requestConfig = { + headers: { + Authorization: `Bearer ${extendedConfig?.subgraph?.apiKey}` + } + }; + const bamGraphQLClient = new GraphQLClient(bapEndpoint, hasAPIKey ? requestConfig : void 0); + const apis = { + beacon: createBeaconChainAPI(beaconchainUrl), + bam: createBAMQueries(bamGraphQLClient) + }; + const bappContractAddress = extendedConfig?.contract || contracts[chain].bapp; + return { + apis, + basedAppsAPI: createBasedAppsAPI(apis), + contracts: { + bapp: { + read: createReader({ + abi: BAppABI, + contractAddress: bappContractAddress, + publicClient + }), + write: createWriter({ + abi: BAppABI, + contractAddress: bappContractAddress, + publicClient, + walletClient + }), + address: bappContractAddress + } + }, + graphs: { + bam: { + client: bamGraphQLClient, + endpoint: bapEndpoint + } + }, + publicClient, + walletClient + }; +}; +const globals = { + MAX_WEI_AMOUNT: 115792089237316195423570985008687907853269984665640564039457584007913129639935n, + CLUSTER_SIZES: { + QUAD_CLUSTER: 4, + SEPT_CLUSTER: 7, + DECA_CLUSTER: 10, + TRISKAIDEKA_CLUSTER: 13 + }, + FIXED_VALIDATORS_COUNT_PER_CLUSTER_SIZE: { + QUAD_CLUSTER: 80, + SEPT_CLUSTER: 40, + DECA_CLUSTER: 30, + TRISKAIDEKA_CLUSTER: 20 + }, + BLOCKS_PER_DAY: 7160n, + OPERATORS_PER_PAGE: 50, + BLOCKS_PER_YEAR: 2613400n, + DEFAULT_CLUSTER_PERIOD: 730, + NUMBERS_OF_WEEKS_IN_YEAR: 52.1429, + MAX_VALIDATORS_COUNT_MULTI_FLOW: 50, + CLUSTER_VALIDITY_PERIOD_MINIMUM: 30, + OPERATOR_VALIDATORS_LIMIT_PRESERVE: 5, + MINIMUM_OPERATOR_FEE_PER_BLOCK: 1000000000n, + MIN_VALIDATORS_COUNT_PER_BULK_REGISTRATION: 1, + DEFAULT_ADDRESS_WHITELIST: "0x0000000000000000000000000000000000000000" +}; +const registerValidatorsByClusterSizeLimits = { + [globals.CLUSTER_SIZES.QUAD_CLUSTER]: globals.FIXED_VALIDATORS_COUNT_PER_CLUSTER_SIZE.QUAD_CLUSTER, + [globals.CLUSTER_SIZES.SEPT_CLUSTER]: globals.FIXED_VALIDATORS_COUNT_PER_CLUSTER_SIZE.SEPT_CLUSTER, + [globals.CLUSTER_SIZES.DECA_CLUSTER]: globals.FIXED_VALIDATORS_COUNT_PER_CLUSTER_SIZE.DECA_CLUSTER, + [globals.CLUSTER_SIZES.TRISKAIDEKA_CLUSTER]: globals.FIXED_VALIDATORS_COUNT_PER_CLUSTER_SIZE.TRISKAIDEKA_CLUSTER +}; +const TestnetV4GetterABI = [ + { + inputs: [], + stateMutability: "nonpayable", + type: "constructor" + }, + { + inputs: [ + { + internalType: "address", + name: "contractAddress", + type: "address" + } + ], + name: "AddressIsWhitelistingContract", + type: "error" + }, + { + inputs: [], + name: "ApprovalNotWithinTimeframe", + type: "error" + }, + { + inputs: [], + name: "CallerNotOwner", + type: "error" + }, + { + inputs: [ + { + internalType: "address", + name: "caller", + type: "address" + }, + { + internalType: "address", + name: "owner", + type: "address" + } + ], + name: "CallerNotOwnerWithData", + type: "error" + }, + { + inputs: [], + name: "CallerNotWhitelisted", + type: "error" + }, + { + inputs: [ + { + internalType: "uint64", + name: "operatorId", + type: "uint64" + } + ], + name: "CallerNotWhitelistedWithData", + type: "error" + }, + { + inputs: [], + name: "ClusterAlreadyEnabled", + type: "error" + }, + { + inputs: [], + name: "ClusterDoesNotExists", + type: "error" + }, + { + inputs: [], + name: "ClusterIsLiquidated", + type: "error" + }, + { + inputs: [], + name: "ClusterNotLiquidatable", + type: "error" + }, + { + inputs: [], + name: "EmptyPublicKeysList", + type: "error" + }, + { + inputs: [ + { + internalType: "uint64", + name: "operatorId", + type: "uint64" + } + ], + name: "ExceedValidatorLimit", + type: "error" + }, + { + inputs: [ + { + internalType: "uint64", + name: "operatorId", + type: "uint64" + } + ], + name: "ExceedValidatorLimitWithData", + type: "error" + }, + { + inputs: [], + name: "FeeExceedsIncreaseLimit", + type: "error" + }, + { + inputs: [], + name: "FeeIncreaseNotAllowed", + type: "error" + }, + { + inputs: [], + name: "FeeTooHigh", + type: "error" + }, + { + inputs: [], + name: "FeeTooLow", + type: "error" + }, + { + inputs: [], + name: "IncorrectClusterState", + type: "error" + }, + { + inputs: [], + name: "IncorrectValidatorState", + type: "error" + }, + { + inputs: [ + { + internalType: "bytes", + name: "publicKey", + type: "bytes" + } + ], + name: "IncorrectValidatorStateWithData", + type: "error" + }, + { + inputs: [], + name: "InsufficientBalance", + type: "error" + }, + { + inputs: [], + name: "InvalidContractAddress", + type: "error" + }, + { + inputs: [], + name: "InvalidOperatorIdsLength", + type: "error" + }, + { + inputs: [], + name: "InvalidPublicKeyLength", + type: "error" + }, + { + inputs: [], + name: "InvalidWhitelistAddressesLength", + type: "error" + }, + { + inputs: [ + { + internalType: "address", + name: "contractAddress", + type: "address" + } + ], + name: "InvalidWhitelistingContract", + type: "error" + }, + { + inputs: [], + name: "MaxValueExceeded", + type: "error" + }, + { + inputs: [], + name: "NewBlockPeriodIsBelowMinimum", + type: "error" + }, + { + inputs: [], + name: "NoFeeDeclared", + type: "error" + }, + { + inputs: [], + name: "NotAuthorized", + type: "error" + }, + { + inputs: [], + name: "OperatorAlreadyExists", + type: "error" + }, + { + inputs: [], + name: "OperatorDoesNotExist", + type: "error" + }, + { + inputs: [], + name: "OperatorsListNotUnique", + type: "error" + }, + { + inputs: [], + name: "PublicKeysSharesLengthMismatch", + type: "error" + }, + { + inputs: [], + name: "SameFeeChangeNotAllowed", + type: "error" + }, + { + inputs: [], + name: "TargetModuleDoesNotExist", + type: "error" + }, + { + inputs: [ + { + internalType: "uint8", + name: "moduleId", + type: "uint8" + } + ], + name: "TargetModuleDoesNotExistWithData", + type: "error" + }, + { + inputs: [], + name: "TokenTransferFailed", + type: "error" + }, + { + inputs: [], + name: "UnsortedOperatorsList", + type: "error" + }, + { + inputs: [], + name: "ValidatorAlreadyExists", + type: "error" + }, + { + inputs: [ + { + internalType: "bytes", + name: "publicKey", + type: "bytes" + } + ], + name: "ValidatorAlreadyExistsWithData", + type: "error" + }, + { + inputs: [], + name: "ValidatorDoesNotExist", + type: "error" + }, + { + inputs: [], + name: "ZeroAddressNotAllowed", + type: "error" + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "previousAdmin", + type: "address" + }, + { + indexed: false, + internalType: "address", + name: "newAdmin", + type: "address" + } + ], + name: "AdminChanged", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "beacon", + type: "address" + } + ], + name: "BeaconUpgraded", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint8", + name: "version", + type: "uint8" + } + ], + name: "Initialized", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "previousOwner", + type: "address" + }, + { + indexed: true, + internalType: "address", + name: "newOwner", + type: "address" + } + ], + name: "OwnershipTransferStarted", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "previousOwner", + type: "address" + }, + { + indexed: true, + internalType: "address", + name: "newOwner", + type: "address" + } + ], + name: "OwnershipTransferred", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "implementation", + type: "address" + } + ], + name: "Upgraded", + type: "event" + }, + { + inputs: [], + name: "acceptOwnership", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "address", + name: "clusterOwner", + type: "address" + }, + { + internalType: "uint64[]", + name: "operatorIds", + type: "uint64[]" + }, + { + components: [ + { + internalType: "uint32", + name: "validatorCount", + type: "uint32" + }, + { + internalType: "uint64", + name: "networkFeeIndex", + type: "uint64" + }, + { + internalType: "uint64", + name: "index", + type: "uint64" + }, + { + internalType: "bool", + name: "active", + type: "bool" + }, + { + internalType: "uint256", + name: "balance", + type: "uint256" + } + ], + internalType: "struct ISSVNetworkCore.Cluster", + name: "cluster", + type: "tuple" + } + ], + name: "getBalance", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256" + } + ], + stateMutability: "view", + type: "function" + }, + { + inputs: [ + { + internalType: "address", + name: "clusterOwner", + type: "address" + }, + { + internalType: "uint64[]", + name: "operatorIds", + type: "uint64[]" + }, + { + components: [ + { + internalType: "uint32", + name: "validatorCount", + type: "uint32" + }, + { + internalType: "uint64", + name: "networkFeeIndex", + type: "uint64" + }, + { + internalType: "uint64", + name: "index", + type: "uint64" + }, + { + internalType: "bool", + name: "active", + type: "bool" + }, + { + internalType: "uint256", + name: "balance", + type: "uint256" + } + ], + internalType: "struct ISSVNetworkCore.Cluster", + name: "cluster", + type: "tuple" + } + ], + name: "getBurnRate", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256" + } + ], + stateMutability: "view", + type: "function" + }, + { + inputs: [], + name: "getLiquidationThresholdPeriod", + outputs: [ + { + internalType: "uint64", + name: "", + type: "uint64" + } + ], + stateMutability: "view", + type: "function" + }, + { + inputs: [], + name: "getMaximumOperatorFee", + outputs: [ + { + internalType: "uint64", + name: "", + type: "uint64" + } + ], + stateMutability: "view", + type: "function" + }, + { + inputs: [], + name: "getMinimumLiquidationCollateral", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256" + } + ], + stateMutability: "view", + type: "function" + }, + { + inputs: [], + name: "getNetworkEarnings", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256" + } + ], + stateMutability: "view", + type: "function" + }, + { + inputs: [], + name: "getNetworkFee", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256" + } + ], + stateMutability: "view", + type: "function" + }, + { + inputs: [], + name: "getNetworkValidatorsCount", + outputs: [ + { + internalType: "uint32", + name: "", + type: "uint32" + } + ], + stateMutability: "view", + type: "function" + }, + { + inputs: [ + { + internalType: "uint64", + name: "operatorId", + type: "uint64" + } + ], + name: "getOperatorById", + outputs: [ + { + internalType: "address", + name: "", + type: "address" + }, + { + internalType: "uint256", + name: "", + type: "uint256" + }, + { + internalType: "uint32", + name: "", + type: "uint32" + }, + { + internalType: "address", + name: "", + type: "address" + }, + { + internalType: "bool", + name: "", + type: "bool" + }, + { + internalType: "bool", + name: "", + type: "bool" + } + ], + stateMutability: "view", + type: "function" + }, + { + inputs: [ + { + internalType: "uint64", + name: "operatorId", + type: "uint64" + } + ], + name: "getOperatorDeclaredFee", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool" + }, + { + internalType: "uint256", + name: "", + type: "uint256" + }, + { + internalType: "uint64", + name: "", + type: "uint64" + }, + { + internalType: "uint64", + name: "", + type: "uint64" + } + ], + stateMutability: "view", + type: "function" + }, + { + inputs: [ + { + internalType: "uint64", + name: "id", + type: "uint64" + } + ], + name: "getOperatorEarnings", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256" + } + ], + stateMutability: "view", + type: "function" + }, + { + inputs: [ + { + internalType: "uint64", + name: "operatorId", + type: "uint64" + } + ], + name: "getOperatorFee", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256" + } + ], + stateMutability: "view", + type: "function" + }, + { + inputs: [], + name: "getOperatorFeeIncreaseLimit", + outputs: [ + { + internalType: "uint64", + name: "", + type: "uint64" + } + ], + stateMutability: "view", + type: "function" + }, + { + inputs: [], + name: "getOperatorFeePeriods", + outputs: [ + { + internalType: "uint64", + name: "", + type: "uint64" + }, + { + internalType: "uint64", + name: "", + type: "uint64" + } + ], + stateMutability: "view", + type: "function" + }, + { + inputs: [ + { + internalType: "address", + name: "clusterOwner", + type: "address" + }, + { + internalType: "bytes", + name: "publicKey", + type: "bytes" + } + ], + name: "getValidator", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool" + } + ], + stateMutability: "view", + type: "function" + }, + { + inputs: [], + name: "getValidatorsPerOperatorLimit", + outputs: [ + { + internalType: "uint32", + name: "", + type: "uint32" + } + ], + stateMutability: "view", + type: "function" + }, + { + inputs: [], + name: "getVersion", + outputs: [ + { + internalType: "string", + name: "", + type: "string" + } + ], + stateMutability: "view", + type: "function" + }, + { + inputs: [ + { + internalType: "uint64[]", + name: "operatorIds", + type: "uint64[]" + }, + { + internalType: "address", + name: "whitelistedAddress", + type: "address" + } + ], + name: "getWhitelistedOperators", + outputs: [ + { + internalType: "uint64[]", + name: "whitelistedOperatorIds", + type: "uint64[]" + } + ], + stateMutability: "view", + type: "function" + }, + { + inputs: [ + { + internalType: "contract ISSVViews", + name: "ssvNetwork_", + type: "address" + } + ], + name: "initialize", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "address", + name: "addressToCheck", + type: "address" + }, + { + internalType: "uint256", + name: "operatorId", + type: "uint256" + }, + { + internalType: "address", + name: "whitelistingContract", + type: "address" + } + ], + name: "isAddressWhitelistedInWhitelistingContract", + outputs: [ + { + internalType: "bool", + name: "isWhitelisted", + type: "bool" + } + ], + stateMutability: "view", + type: "function" + }, + { + inputs: [ + { + internalType: "address", + name: "clusterOwner", + type: "address" + }, + { + internalType: "uint64[]", + name: "operatorIds", + type: "uint64[]" + }, + { + components: [ + { + internalType: "uint32", + name: "validatorCount", + type: "uint32" + }, + { + internalType: "uint64", + name: "networkFeeIndex", + type: "uint64" + }, + { + internalType: "uint64", + name: "index", + type: "uint64" + }, + { + internalType: "bool", + name: "active", + type: "bool" + }, + { + internalType: "uint256", + name: "balance", + type: "uint256" + } + ], + internalType: "struct ISSVNetworkCore.Cluster", + name: "cluster", + type: "tuple" + } + ], + name: "isLiquidatable", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool" + } + ], + stateMutability: "view", + type: "function" + }, + { + inputs: [ + { + internalType: "address", + name: "clusterOwner", + type: "address" + }, + { + internalType: "uint64[]", + name: "operatorIds", + type: "uint64[]" + }, + { + components: [ + { + internalType: "uint32", + name: "validatorCount", + type: "uint32" + }, + { + internalType: "uint64", + name: "networkFeeIndex", + type: "uint64" + }, + { + internalType: "uint64", + name: "index", + type: "uint64" + }, + { + internalType: "bool", + name: "active", + type: "bool" + }, + { + internalType: "uint256", + name: "balance", + type: "uint256" + } + ], + internalType: "struct ISSVNetworkCore.Cluster", + name: "cluster", + type: "tuple" + } + ], + name: "isLiquidated", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool" + } + ], + stateMutability: "view", + type: "function" + }, + { + inputs: [ + { + internalType: "address", + name: "contractAddress", + type: "address" + } + ], + name: "isWhitelistingContract", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool" + } + ], + stateMutability: "view", + type: "function" + }, + { + inputs: [], + name: "owner", + outputs: [ + { + internalType: "address", + name: "", + type: "address" + } + ], + stateMutability: "view", + type: "function" + }, + { + inputs: [], + name: "pendingOwner", + outputs: [ + { + internalType: "address", + name: "", + type: "address" + } + ], + stateMutability: "view", + type: "function" + }, + { + inputs: [], + name: "proxiableUUID", + outputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32" + } + ], + stateMutability: "view", + type: "function" + }, + { + inputs: [], + name: "renounceOwnership", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [], + name: "ssvNetwork", + outputs: [ + { + internalType: "contract ISSVViews", + name: "", + type: "address" + } + ], + stateMutability: "view", + type: "function" + }, + { + inputs: [ + { + internalType: "address", + name: "newOwner", + type: "address" + } + ], + name: "transferOwnership", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "address", + name: "newImplementation", + type: "address" + } + ], + name: "upgradeTo", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "address", + name: "newImplementation", + type: "address" + }, + { + internalType: "bytes", + name: "data", + type: "bytes" + } + ], + name: "upgradeToAndCall", + outputs: [], + stateMutability: "payable", + type: "function" + } +]; +const MainnetV4SetterABI = [ + { + inputs: [], + stateMutability: "nonpayable", + type: "constructor" + }, + { + inputs: [ + { + internalType: "address", + name: "contractAddress", + type: "address" + } + ], + name: "AddressIsWhitelistingContract", + type: "error" + }, + { + inputs: [], + name: "ApprovalNotWithinTimeframe", + type: "error" + }, + { + inputs: [], + name: "CallerNotOwner", + type: "error" + }, + { + inputs: [ + { + internalType: "address", + name: "caller", + type: "address" + }, + { + internalType: "address", + name: "owner", + type: "address" + } + ], + name: "CallerNotOwnerWithData", + type: "error" + }, + { + inputs: [], + name: "CallerNotWhitelisted", + type: "error" + }, + { + inputs: [ + { + internalType: "uint64", + name: "operatorId", + type: "uint64" + } + ], + name: "CallerNotWhitelistedWithData", + type: "error" + }, + { + inputs: [], + name: "ClusterAlreadyEnabled", + type: "error" + }, + { + inputs: [], + name: "ClusterDoesNotExists", + type: "error" + }, + { + inputs: [], + name: "ClusterIsLiquidated", + type: "error" + }, + { + inputs: [], + name: "ClusterNotLiquidatable", + type: "error" + }, + { + inputs: [], + name: "EmptyPublicKeysList", + type: "error" + }, + { + inputs: [ + { + internalType: "uint64", + name: "operatorId", + type: "uint64" + } + ], + name: "ExceedValidatorLimit", + type: "error" + }, + { + inputs: [ + { + internalType: "uint64", + name: "operatorId", + type: "uint64" + } + ], + name: "ExceedValidatorLimitWithData", + type: "error" + }, + { + inputs: [], + name: "FeeExceedsIncreaseLimit", + type: "error" + }, + { + inputs: [], + name: "FeeIncreaseNotAllowed", + type: "error" + }, + { + inputs: [], + name: "FeeTooHigh", + type: "error" + }, + { + inputs: [], + name: "FeeTooLow", + type: "error" + }, + { + inputs: [], + name: "IncorrectClusterState", + type: "error" + }, + { + inputs: [], + name: "IncorrectValidatorState", + type: "error" + }, + { + inputs: [ + { + internalType: "bytes", + name: "publicKey", + type: "bytes" + } + ], + name: "IncorrectValidatorStateWithData", + type: "error" + }, + { + inputs: [], + name: "InsufficientBalance", + type: "error" + }, + { + inputs: [], + name: "InvalidContractAddress", + type: "error" + }, + { + inputs: [], + name: "InvalidOperatorIdsLength", + type: "error" + }, + { + inputs: [], + name: "InvalidPublicKeyLength", + type: "error" + }, + { + inputs: [], + name: "InvalidWhitelistAddressesLength", + type: "error" + }, + { + inputs: [ + { + internalType: "address", + name: "contractAddress", + type: "address" + } + ], + name: "InvalidWhitelistingContract", + type: "error" + }, + { + inputs: [], + name: "MaxValueExceeded", + type: "error" + }, + { + inputs: [], + name: "NewBlockPeriodIsBelowMinimum", + type: "error" + }, + { + inputs: [], + name: "NoFeeDeclared", + type: "error" + }, + { + inputs: [], + name: "NotAuthorized", + type: "error" + }, + { + inputs: [], + name: "OperatorAlreadyExists", + type: "error" + }, + { + inputs: [], + name: "OperatorDoesNotExist", + type: "error" + }, + { + inputs: [], + name: "OperatorsListNotUnique", + type: "error" + }, + { + inputs: [], + name: "PublicKeysSharesLengthMismatch", + type: "error" + }, + { + inputs: [], + name: "SameFeeChangeNotAllowed", + type: "error" + }, + { + inputs: [], + name: "TargetModuleDoesNotExist", + type: "error" + }, + { + inputs: [ + { + internalType: "uint8", + name: "moduleId", + type: "uint8" + } + ], + name: "TargetModuleDoesNotExistWithData", + type: "error" + }, + { + inputs: [], + name: "TokenTransferFailed", + type: "error" + }, + { + inputs: [], + name: "UnsortedOperatorsList", + type: "error" + }, + { + inputs: [], + name: "ValidatorAlreadyExists", + type: "error" + }, + { + inputs: [ + { + internalType: "bytes", + name: "publicKey", + type: "bytes" + } + ], + name: "ValidatorAlreadyExistsWithData", + type: "error" + }, + { + inputs: [], + name: "ValidatorDoesNotExist", + type: "error" + }, + { + inputs: [], + name: "ZeroAddressNotAllowed", + type: "error" + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "previousAdmin", + type: "address" + }, + { + indexed: false, + internalType: "address", + name: "newAdmin", + type: "address" + } + ], + name: "AdminChanged", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "beacon", + type: "address" + } + ], + name: "BeaconUpgraded", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "owner", + type: "address" + }, + { + indexed: false, + internalType: "uint64[]", + name: "operatorIds", + type: "uint64[]" + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256" + }, + { + components: [ + { + internalType: "uint32", + name: "validatorCount", + type: "uint32" + }, + { + internalType: "uint64", + name: "networkFeeIndex", + type: "uint64" + }, + { + internalType: "uint64", + name: "index", + type: "uint64" + }, + { + internalType: "bool", + name: "active", + type: "bool" + }, + { + internalType: "uint256", + name: "balance", + type: "uint256" + } + ], + indexed: false, + internalType: "struct ISSVNetworkCore.Cluster", + name: "cluster", + type: "tuple" + } + ], + name: "ClusterDeposited", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "owner", + type: "address" + }, + { + indexed: false, + internalType: "uint64[]", + name: "operatorIds", + type: "uint64[]" + }, + { + components: [ + { + internalType: "uint32", + name: "validatorCount", + type: "uint32" + }, + { + internalType: "uint64", + name: "networkFeeIndex", + type: "uint64" + }, + { + internalType: "uint64", + name: "index", + type: "uint64" + }, + { + internalType: "bool", + name: "active", + type: "bool" + }, + { + internalType: "uint256", + name: "balance", + type: "uint256" + } + ], + indexed: false, + internalType: "struct ISSVNetworkCore.Cluster", + name: "cluster", + type: "tuple" + } + ], + name: "ClusterLiquidated", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "owner", + type: "address" + }, + { + indexed: false, + internalType: "uint64[]", + name: "operatorIds", + type: "uint64[]" + }, + { + components: [ + { + internalType: "uint32", + name: "validatorCount", + type: "uint32" + }, + { + internalType: "uint64", + name: "networkFeeIndex", + type: "uint64" + }, + { + internalType: "uint64", + name: "index", + type: "uint64" + }, + { + internalType: "bool", + name: "active", + type: "bool" + }, + { + internalType: "uint256", + name: "balance", + type: "uint256" + } + ], + indexed: false, + internalType: "struct ISSVNetworkCore.Cluster", + name: "cluster", + type: "tuple" + } + ], + name: "ClusterReactivated", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "owner", + type: "address" + }, + { + indexed: false, + internalType: "uint64[]", + name: "operatorIds", + type: "uint64[]" + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256" + }, + { + components: [ + { + internalType: "uint32", + name: "validatorCount", + type: "uint32" + }, + { + internalType: "uint64", + name: "networkFeeIndex", + type: "uint64" + }, + { + internalType: "uint64", + name: "index", + type: "uint64" + }, + { + internalType: "bool", + name: "active", + type: "bool" + }, + { + internalType: "uint256", + name: "balance", + type: "uint256" + } + ], + indexed: false, + internalType: "struct ISSVNetworkCore.Cluster", + name: "cluster", + type: "tuple" + } + ], + name: "ClusterWithdrawn", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint64", + name: "value", + type: "uint64" + } + ], + name: "DeclareOperatorFeePeriodUpdated", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint64", + name: "value", + type: "uint64" + } + ], + name: "ExecuteOperatorFeePeriodUpdated", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "owner", + type: "address" + }, + { + indexed: false, + internalType: "address", + name: "recipientAddress", + type: "address" + } + ], + name: "FeeRecipientAddressUpdated", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint8", + name: "version", + type: "uint8" + } + ], + name: "Initialized", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint64", + name: "value", + type: "uint64" + } + ], + name: "LiquidationThresholdPeriodUpdated", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256" + } + ], + name: "MinimumLiquidationCollateralUpdated", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "enum SSVModules", + name: "moduleId", + type: "uint8" + }, + { + indexed: false, + internalType: "address", + name: "moduleAddress", + type: "address" + } + ], + name: "ModuleUpgraded", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256" + }, + { + indexed: false, + internalType: "address", + name: "recipient", + type: "address" + } + ], + name: "NetworkEarningsWithdrawn", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint256", + name: "oldFee", + type: "uint256" + }, + { + indexed: false, + internalType: "uint256", + name: "newFee", + type: "uint256" + } + ], + name: "NetworkFeeUpdated", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "uint64", + name: "operatorId", + type: "uint64" + }, + { + indexed: true, + internalType: "address", + name: "owner", + type: "address" + }, + { + indexed: false, + internalType: "bytes", + name: "publicKey", + type: "bytes" + }, + { + indexed: false, + internalType: "uint256", + name: "fee", + type: "uint256" + } + ], + name: "OperatorAdded", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "owner", + type: "address" + }, + { + indexed: true, + internalType: "uint64", + name: "operatorId", + type: "uint64" + } + ], + name: "OperatorFeeDeclarationCancelled", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "owner", + type: "address" + }, + { + indexed: true, + internalType: "uint64", + name: "operatorId", + type: "uint64" + }, + { + indexed: false, + internalType: "uint256", + name: "blockNumber", + type: "uint256" + }, + { + indexed: false, + internalType: "uint256", + name: "fee", + type: "uint256" + } + ], + name: "OperatorFeeDeclared", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "owner", + type: "address" + }, + { + indexed: true, + internalType: "uint64", + name: "operatorId", + type: "uint64" + }, + { + indexed: false, + internalType: "uint256", + name: "blockNumber", + type: "uint256" + }, + { + indexed: false, + internalType: "uint256", + name: "fee", + type: "uint256" + } + ], + name: "OperatorFeeExecuted", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint64", + name: "value", + type: "uint64" + } + ], + name: "OperatorFeeIncreaseLimitUpdated", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint64", + name: "maxFee", + type: "uint64" + } + ], + name: "OperatorMaximumFeeUpdated", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint64[]", + name: "operatorIds", + type: "uint64[]" + }, + { + indexed: false, + internalType: "address[]", + name: "whitelistAddresses", + type: "address[]" + } + ], + name: "OperatorMultipleWhitelistRemoved", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint64[]", + name: "operatorIds", + type: "uint64[]" + }, + { + indexed: false, + internalType: "address[]", + name: "whitelistAddresses", + type: "address[]" + } + ], + name: "OperatorMultipleWhitelistUpdated", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint64[]", + name: "operatorIds", + type: "uint64[]" + }, + { + indexed: false, + internalType: "bool", + name: "toPrivate", + type: "bool" + } + ], + name: "OperatorPrivacyStatusUpdated", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "uint64", + name: "operatorId", + type: "uint64" + } + ], + name: "OperatorRemoved", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "uint64", + name: "operatorId", + type: "uint64" + }, + { + indexed: false, + internalType: "address", + name: "whitelisted", + type: "address" + } + ], + name: "OperatorWhitelistUpdated", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint64[]", + name: "operatorIds", + type: "uint64[]" + }, + { + indexed: false, + internalType: "address", + name: "whitelistingContract", + type: "address" + } + ], + name: "OperatorWhitelistingContractUpdated", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "owner", + type: "address" + }, + { + indexed: true, + internalType: "uint64", + name: "operatorId", + type: "uint64" + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256" + } + ], + name: "OperatorWithdrawn", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "previousOwner", + type: "address" + }, + { + indexed: true, + internalType: "address", + name: "newOwner", + type: "address" + } + ], + name: "OwnershipTransferStarted", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "previousOwner", + type: "address" + }, + { + indexed: true, + internalType: "address", + name: "newOwner", + type: "address" + } + ], + name: "OwnershipTransferred", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "implementation", + type: "address" + } + ], + name: "Upgraded", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "owner", + type: "address" + }, + { + indexed: false, + internalType: "uint64[]", + name: "operatorIds", + type: "uint64[]" + }, + { + indexed: false, + internalType: "bytes", + name: "publicKey", + type: "bytes" + }, + { + indexed: false, + internalType: "bytes", + name: "shares", + type: "bytes" + }, + { + components: [ + { + internalType: "uint32", + name: "validatorCount", + type: "uint32" + }, + { + internalType: "uint64", + name: "networkFeeIndex", + type: "uint64" + }, + { + internalType: "uint64", + name: "index", + type: "uint64" + }, + { + internalType: "bool", + name: "active", + type: "bool" + }, + { + internalType: "uint256", + name: "balance", + type: "uint256" + } + ], + indexed: false, + internalType: "struct ISSVNetworkCore.Cluster", + name: "cluster", + type: "tuple" + } + ], + name: "ValidatorAdded", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "owner", + type: "address" + }, + { + indexed: false, + internalType: "uint64[]", + name: "operatorIds", + type: "uint64[]" + }, + { + indexed: false, + internalType: "bytes", + name: "publicKey", + type: "bytes" + } + ], + name: "ValidatorExited", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "owner", + type: "address" + }, + { + indexed: false, + internalType: "uint64[]", + name: "operatorIds", + type: "uint64[]" + }, + { + indexed: false, + internalType: "bytes", + name: "publicKey", + type: "bytes" + }, + { + components: [ + { + internalType: "uint32", + name: "validatorCount", + type: "uint32" + }, + { + internalType: "uint64", + name: "networkFeeIndex", + type: "uint64" + }, + { + internalType: "uint64", + name: "index", + type: "uint64" + }, + { + internalType: "bool", + name: "active", + type: "bool" + }, + { + internalType: "uint256", + name: "balance", + type: "uint256" + } + ], + indexed: false, + internalType: "struct ISSVNetworkCore.Cluster", + name: "cluster", + type: "tuple" + } + ], + name: "ValidatorRemoved", + type: "event" + }, + { + stateMutability: "nonpayable", + type: "fallback" + }, + { + inputs: [], + name: "acceptOwnership", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "bytes[]", + name: "publicKeys", + type: "bytes[]" + }, + { + internalType: "uint64[]", + name: "operatorIds", + type: "uint64[]" + } + ], + name: "bulkExitValidator", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "bytes[]", + name: "publicKeys", + type: "bytes[]" + }, + { + internalType: "uint64[]", + name: "operatorIds", + type: "uint64[]" + }, + { + internalType: "bytes[]", + name: "sharesData", + type: "bytes[]" + }, + { + internalType: "uint256", + name: "amount", + type: "uint256" + }, + { + components: [ + { + internalType: "uint32", + name: "validatorCount", + type: "uint32" + }, + { + internalType: "uint64", + name: "networkFeeIndex", + type: "uint64" + }, + { + internalType: "uint64", + name: "index", + type: "uint64" + }, + { + internalType: "bool", + name: "active", + type: "bool" + }, + { + internalType: "uint256", + name: "balance", + type: "uint256" + } + ], + internalType: "struct ISSVNetworkCore.Cluster", + name: "cluster", + type: "tuple" + } + ], + name: "bulkRegisterValidator", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "bytes[]", + name: "publicKeys", + type: "bytes[]" + }, + { + internalType: "uint64[]", + name: "operatorIds", + type: "uint64[]" + }, + { + components: [ + { + internalType: "uint32", + name: "validatorCount", + type: "uint32" + }, + { + internalType: "uint64", + name: "networkFeeIndex", + type: "uint64" + }, + { + internalType: "uint64", + name: "index", + type: "uint64" + }, + { + internalType: "bool", + name: "active", + type: "bool" + }, + { + internalType: "uint256", + name: "balance", + type: "uint256" + } + ], + internalType: "struct ISSVNetworkCore.Cluster", + name: "cluster", + type: "tuple" + } + ], + name: "bulkRemoveValidator", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "uint64", + name: "operatorId", + type: "uint64" + } + ], + name: "cancelDeclaredOperatorFee", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "uint64", + name: "operatorId", + type: "uint64" + }, + { + internalType: "uint256", + name: "fee", + type: "uint256" + } + ], + name: "declareOperatorFee", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "address", + name: "clusterOwner", + type: "address" + }, + { + internalType: "uint64[]", + name: "operatorIds", + type: "uint64[]" + }, + { + internalType: "uint256", + name: "amount", + type: "uint256" + }, + { + components: [ + { + internalType: "uint32", + name: "validatorCount", + type: "uint32" + }, + { + internalType: "uint64", + name: "networkFeeIndex", + type: "uint64" + }, + { + internalType: "uint64", + name: "index", + type: "uint64" + }, + { + internalType: "bool", + name: "active", + type: "bool" + }, + { + internalType: "uint256", + name: "balance", + type: "uint256" + } + ], + internalType: "struct ISSVNetworkCore.Cluster", + name: "cluster", + type: "tuple" + } + ], + name: "deposit", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "uint64", + name: "operatorId", + type: "uint64" + } + ], + name: "executeOperatorFee", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "bytes", + name: "publicKey", + type: "bytes" + }, + { + internalType: "uint64[]", + name: "operatorIds", + type: "uint64[]" + } + ], + name: "exitValidator", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [], + name: "getVersion", + outputs: [ + { + internalType: "string", + name: "version", + type: "string" + } + ], + stateMutability: "pure", + type: "function" + }, + { + inputs: [ + { + internalType: "contract IERC20", + name: "token_", + type: "address" + }, + { + internalType: "contract ISSVOperators", + name: "ssvOperators_", + type: "address" + }, + { + internalType: "contract ISSVClusters", + name: "ssvClusters_", + type: "address" + }, + { + internalType: "contract ISSVDAO", + name: "ssvDAO_", + type: "address" + }, + { + internalType: "contract ISSVViews", + name: "ssvViews_", + type: "address" + }, + { + internalType: "uint64", + name: "minimumBlocksBeforeLiquidation_", + type: "uint64" + }, + { + internalType: "uint256", + name: "minimumLiquidationCollateral_", + type: "uint256" + }, + { + internalType: "uint32", + name: "validatorsPerOperatorLimit_", + type: "uint32" + }, + { + internalType: "uint64", + name: "declareOperatorFeePeriod_", + type: "uint64" + }, + { + internalType: "uint64", + name: "executeOperatorFeePeriod_", + type: "uint64" + }, + { + internalType: "uint64", + name: "operatorMaxFeeIncrease_", + type: "uint64" + } + ], + name: "initialize", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "address", + name: "clusterOwner", + type: "address" + }, + { + internalType: "uint64[]", + name: "operatorIds", + type: "uint64[]" + }, + { + components: [ + { + internalType: "uint32", + name: "validatorCount", + type: "uint32" + }, + { + internalType: "uint64", + name: "networkFeeIndex", + type: "uint64" + }, + { + internalType: "uint64", + name: "index", + type: "uint64" + }, + { + internalType: "bool", + name: "active", + type: "bool" + }, + { + internalType: "uint256", + name: "balance", + type: "uint256" + } + ], + internalType: "struct ISSVNetworkCore.Cluster", + name: "cluster", + type: "tuple" + } + ], + name: "liquidate", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [], + name: "owner", + outputs: [ + { + internalType: "address", + name: "", + type: "address" + } + ], + stateMutability: "view", + type: "function" + }, + { + inputs: [], + name: "pendingOwner", + outputs: [ + { + internalType: "address", + name: "", + type: "address" + } + ], + stateMutability: "view", + type: "function" + }, + { + inputs: [], + name: "proxiableUUID", + outputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32" + } + ], + stateMutability: "view", + type: "function" + }, + { + inputs: [ + { + internalType: "uint64[]", + name: "operatorIds", + type: "uint64[]" + }, + { + internalType: "uint256", + name: "amount", + type: "uint256" + }, + { + components: [ + { + internalType: "uint32", + name: "validatorCount", + type: "uint32" + }, + { + internalType: "uint64", + name: "networkFeeIndex", + type: "uint64" + }, + { + internalType: "uint64", + name: "index", + type: "uint64" + }, + { + internalType: "bool", + name: "active", + type: "bool" + }, + { + internalType: "uint256", + name: "balance", + type: "uint256" + } + ], + internalType: "struct ISSVNetworkCore.Cluster", + name: "cluster", + type: "tuple" + } + ], + name: "reactivate", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "uint64", + name: "operatorId", + type: "uint64" + }, + { + internalType: "uint256", + name: "fee", + type: "uint256" + } + ], + name: "reduceOperatorFee", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "bytes", + name: "publicKey", + type: "bytes" + }, + { + internalType: "uint256", + name: "fee", + type: "uint256" + }, + { + internalType: "bool", + name: "setPrivate", + type: "bool" + } + ], + name: "registerOperator", + outputs: [ + { + internalType: "uint64", + name: "id", + type: "uint64" + } + ], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "bytes", + name: "publicKey", + type: "bytes" + }, + { + internalType: "uint64[]", + name: "operatorIds", + type: "uint64[]" + }, + { + internalType: "bytes", + name: "sharesData", + type: "bytes" + }, + { + internalType: "uint256", + name: "amount", + type: "uint256" + }, + { + components: [ + { + internalType: "uint32", + name: "validatorCount", + type: "uint32" + }, + { + internalType: "uint64", + name: "networkFeeIndex", + type: "uint64" + }, + { + internalType: "uint64", + name: "index", + type: "uint64" + }, + { + internalType: "bool", + name: "active", + type: "bool" + }, + { + internalType: "uint256", + name: "balance", + type: "uint256" + } + ], + internalType: "struct ISSVNetworkCore.Cluster", + name: "cluster", + type: "tuple" + } + ], + name: "registerValidator", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "uint64", + name: "operatorId", + type: "uint64" + } + ], + name: "removeOperator", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "uint64[]", + name: "operatorIds", + type: "uint64[]" + } + ], + name: "removeOperatorsWhitelistingContract", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "uint64[]", + name: "operatorIds", + type: "uint64[]" + }, + { + internalType: "address[]", + name: "whitelistAddresses", + type: "address[]" + } + ], + name: "removeOperatorsWhitelists", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "bytes", + name: "publicKey", + type: "bytes" + }, + { + internalType: "uint64[]", + name: "operatorIds", + type: "uint64[]" + }, + { + components: [ + { + internalType: "uint32", + name: "validatorCount", + type: "uint32" + }, + { + internalType: "uint64", + name: "networkFeeIndex", + type: "uint64" + }, + { + internalType: "uint64", + name: "index", + type: "uint64" + }, + { + internalType: "bool", + name: "active", + type: "bool" + }, + { + internalType: "uint256", + name: "balance", + type: "uint256" + } + ], + internalType: "struct ISSVNetworkCore.Cluster", + name: "cluster", + type: "tuple" + } + ], + name: "removeValidator", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [], + name: "renounceOwnership", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "address", + name: "recipientAddress", + type: "address" + } + ], + name: "setFeeRecipientAddress", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "uint64[]", + name: "operatorIds", + type: "uint64[]" + } + ], + name: "setOperatorsPrivateUnchecked", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "uint64[]", + name: "operatorIds", + type: "uint64[]" + } + ], + name: "setOperatorsPublicUnchecked", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "uint64[]", + name: "operatorIds", + type: "uint64[]" + }, + { + internalType: "contract ISSVWhitelistingContract", + name: "whitelistingContract", + type: "address" + } + ], + name: "setOperatorsWhitelistingContract", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "uint64[]", + name: "operatorIds", + type: "uint64[]" + }, + { + internalType: "address[]", + name: "whitelistAddresses", + type: "address[]" + } + ], + name: "setOperatorsWhitelists", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "address", + name: "newOwner", + type: "address" + } + ], + name: "transferOwnership", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "uint64", + name: "timeInSeconds", + type: "uint64" + } + ], + name: "updateDeclareOperatorFeePeriod", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "uint64", + name: "timeInSeconds", + type: "uint64" + } + ], + name: "updateExecuteOperatorFeePeriod", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "uint64", + name: "blocks", + type: "uint64" + } + ], + name: "updateLiquidationThresholdPeriod", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "uint64", + name: "maxFee", + type: "uint64" + } + ], + name: "updateMaximumOperatorFee", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "uint256", + name: "amount", + type: "uint256" + } + ], + name: "updateMinimumLiquidationCollateral", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "enum SSVModules", + name: "moduleId", + type: "uint8" + }, + { + internalType: "address", + name: "moduleAddress", + type: "address" + } + ], + name: "updateModule", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "uint256", + name: "fee", + type: "uint256" + } + ], + name: "updateNetworkFee", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "uint64", + name: "percentage", + type: "uint64" + } + ], + name: "updateOperatorFeeIncreaseLimit", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "address", + name: "newImplementation", + type: "address" + } + ], + name: "upgradeTo", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "address", + name: "newImplementation", + type: "address" + }, + { + internalType: "bytes", + name: "data", + type: "bytes" + } + ], + name: "upgradeToAndCall", + outputs: [], + stateMutability: "payable", + type: "function" + }, + { + inputs: [ + { + internalType: "uint64[]", + name: "operatorIds", + type: "uint64[]" + }, + { + internalType: "uint256", + name: "amount", + type: "uint256" + }, + { + components: [ + { + internalType: "uint32", + name: "validatorCount", + type: "uint32" + }, + { + internalType: "uint64", + name: "networkFeeIndex", + type: "uint64" + }, + { + internalType: "uint64", + name: "index", + type: "uint64" + }, + { + internalType: "bool", + name: "active", + type: "bool" + }, + { + internalType: "uint256", + name: "balance", + type: "uint256" + } + ], + internalType: "struct ISSVNetworkCore.Cluster", + name: "cluster", + type: "tuple" + } + ], + name: "withdraw", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "uint64", + name: "operatorId", + type: "uint64" + } + ], + name: "withdrawAllOperatorEarnings", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "uint256", + name: "amount", + type: "uint256" + } + ], + name: "withdrawNetworkEarnings", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "uint64", + name: "operatorId", + type: "uint64" + }, + { + internalType: "uint256", + name: "amount", + type: "uint256" + } + ], + name: "withdrawOperatorEarnings", + outputs: [], + stateMutability: "nonpayable", + type: "function" + } +]; +const TokenABI = [ + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "owner", + type: "address" + }, + { + indexed: true, + internalType: "address", + name: "spender", + type: "address" + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256" + } + ], + name: "Approval", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "previousOwner", + type: "address" + }, + { + indexed: true, + internalType: "address", + name: "newOwner", + type: "address" + } + ], + name: "OwnershipTransferred", + type: "event" + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "from", + type: "address" + }, + { + indexed: true, + internalType: "address", + name: "to", + type: "address" + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256" + } + ], + name: "Transfer", + type: "event" + }, + { + inputs: [ + { + internalType: "address", + name: "owner", + type: "address" + }, + { + internalType: "address", + name: "spender", + type: "address" + } + ], + name: "allowance", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256" + } + ], + stateMutability: "view", + type: "function" + }, + { + inputs: [ + { + internalType: "address", + name: "spender", + type: "address" + }, + { + internalType: "uint256", + name: "amount", + type: "uint256" + } + ], + name: "approve", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool" + } + ], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "address", + name: "account", + type: "address" + } + ], + name: "balanceOf", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256" + } + ], + stateMutability: "view", + type: "function" + }, + { + inputs: [ + { + internalType: "uint256", + name: "amount", + type: "uint256" + } + ], + name: "burn", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "address", + name: "account", + type: "address" + }, + { + internalType: "uint256", + name: "amount", + type: "uint256" + } + ], + name: "burnFrom", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [], + name: "decimals", + outputs: [ + { + internalType: "uint8", + name: "", + type: "uint8" + } + ], + stateMutability: "view", + type: "function" + }, + { + inputs: [ + { + internalType: "address", + name: "spender", + type: "address" + }, + { + internalType: "uint256", + name: "subtractedValue", + type: "uint256" + } + ], + name: "decreaseAllowance", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool" + } + ], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "address", + name: "spender", + type: "address" + }, + { + internalType: "uint256", + name: "addedValue", + type: "uint256" + } + ], + name: "increaseAllowance", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool" + } + ], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [], + name: "initialize", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "address", + name: "to", + type: "address" + }, + { + internalType: "uint256", + name: "amount", + type: "uint256" + } + ], + name: "mint", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [], + name: "name", + outputs: [ + { + internalType: "string", + name: "", + type: "string" + } + ], + stateMutability: "view", + type: "function" + }, + { + inputs: [], + name: "owner", + outputs: [ + { + internalType: "address", + name: "", + type: "address" + } + ], + stateMutability: "view", + type: "function" + }, + { + inputs: [], + name: "renounceOwnership", + outputs: [], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [], + name: "symbol", + outputs: [ + { + internalType: "string", + name: "", + type: "string" + } + ], + stateMutability: "view", + type: "function" + }, + { + inputs: [], + name: "totalSupply", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256" + } + ], + stateMutability: "view", + type: "function" + }, + { + inputs: [ + { + internalType: "address", + name: "recipient", + type: "address" + }, + { + internalType: "uint256", + name: "amount", + type: "uint256" + } + ], + name: "transfer", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool" + } + ], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "address", + name: "sender", + type: "address" + }, + { + internalType: "address", + name: "recipient", + type: "address" + }, + { + internalType: "uint256", + name: "amount", + type: "uint256" + } + ], + name: "transferFrom", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool" + } + ], + stateMutability: "nonpayable", + type: "function" + }, + { + inputs: [ + { + internalType: "address", + name: "newOwner", + type: "address" + } + ], + name: "transferOwnership", + outputs: [], + stateMutability: "nonpayable", + type: "function" + } +]; +const paramsToArray = ({ + params, + abiFunction +}) => { + return tryCatch$1.stringifyBigints( + abiFunction.inputs.reduce( + (acc, param) => { + if (param.name && !tryCatch$1.isUndefined(params[param.name])) { + return [...acc, params[param.name]]; + } else { + console.error(`Missing argument for ${param}`); + } + return acc; + }, + [] + ) + ); +}; +const ABIS = [TokenABI, MainnetV4SetterABI, TestnetV4GetterABI]; +const createWriter = ({ + abi, + publicClient, + walletClient, + contractAddress +}) => { + const writeFnsMainnet = abi.filter( + (item) => item.type === "function" && (item.stateMutability === "nonpayable" || item.stateMutability === "payable") + ); + return Object.fromEntries( + writeFnsMainnet.map((fn) => { + const simulate = async (options) => publicClient.simulateContract({ + ...options, + address: contractAddress, + abi, + functionName: fn.name, + args: paramsToArray({ params: options.args, abiFunction: fn }), + account: walletClient.account + }); + const func = async (options) => { + const { request } = await simulate(options); + const hash2 = await walletClient.writeContract(request); + return { + hash: hash2, + wait: () => publicClient.waitForTransactionReceipt({ hash: hash2 }).then((receipt) => ({ + ...receipt, + events: receipt.logs.reduce( + (acc, log) => { + try { + const event = viem.decodeEventLog({ + abi, + data: log.data, + topics: log.topics + }); + acc.push(event); + } catch { + for (const eventAbi of ABIS) { + tryCatch$1.tryCatch(() => { + const event = viem.decodeEventLog({ + abi: eventAbi, + data: log.data, + topics: log.topics + }); + acc.push(event); + }); + } + } + return acc; + }, + [] + ) + })) + }; + }; + func.simulate = simulate; + return [fn.name, func]; + }) + ); +}; +const createReader = ({ + abi, + publicClient, + contractAddress +}) => { + const readFnsMainnet = abi.filter( + (item) => item.type === "function" && (item.stateMutability === "view" || item.stateMutability === "pure") + ); + return Object.fromEntries( + readFnsMainnet.map((fn) => { + const func = async (args) => { + return await publicClient.readContract({ + abi, + address: contractAddress, + functionName: fn.name, + args: paramsToArray({ params: args, abiFunction: fn }) + }); + }; + return [fn.name, func]; + }) + ); +}; +const calculateCoefficientsSum = (coefficients) => coefficients.reduce((acc, coeff) => acc + coeff.coefficient, 0); +const fillTokenWeightsMap = (strategy, coefficients) => new Map( + coefficients.map((coeff) => [ + coeff.token, + strategy.tokenWeights.find((tokenWeight) => tokenWeight.token === coeff.token)?.weight || 0 + ]) +); +const calculateWeightTotals = (strategy, coefficients, validatorCoefficient = 0) => coefficients.reduce( + (sum, coefficient) => { + const tokenWeightsMap = fillTokenWeightsMap(strategy, coefficients); + return sum + (tokenWeightsMap.get(coefficient.token) || 0) * coefficient.coefficient; + }, + (strategy.validatorBalanceWeight || 0) * validatorCoefficient +); +const calculateWeightedRatioSum = (strategy, coefficients, validatorCoefficient) => { + let weightCoeffRatioSum = 0; + if (validatorCoefficient && !strategy.validatorBalanceWeight) return weightCoeffRatioSum; + const tokenWeightsMap = fillTokenWeightsMap(strategy, coefficients); + if (Array.from(tokenWeightsMap.values()).some((item) => item == 0)) return weightCoeffRatioSum; + weightCoeffRatioSum = coefficients.reduce( + (sum, coeff) => sum + coeff.coefficient / (tokenWeightsMap.get(coeff.token) || 1), + // if the validator coefficient is non-zero (meaning it should be considered), + // start with the ratio between the coefficient and the validator balance weight + validatorCoefficient != 0 ? validatorCoefficient / (strategy.validatorBalanceWeight || 0) : 0 + ); + return weightCoeffRatioSum; +}; +const calculateWeightedLogSum = (strategy, coefficients, validatorCoefficient) => { + let weightedLogSum = 0; + if (validatorCoefficient && !strategy.validatorBalanceWeight) return weightedLogSum; + const tokenWeightsMap = fillTokenWeightsMap(strategy, coefficients); + if (Array.from(tokenWeightsMap.values()).some((item) => item == 0)) return weightedLogSum; + weightedLogSum = coefficients.reduce( + (acc, coeff) => acc + coeff.coefficient * Math.log(tokenWeightsMap.get(coeff.token) || 0), + // if the validator coefficient is non-zero (meaning it should be considered), + // start with the ratio between the coefficient and the validator balance weight + validatorCoefficient != 0 ? validatorCoefficient * Math.log(strategy.validatorBalanceWeight || 0) : 0 + ); + return weightedLogSum; +}; +const calcArithmeticStrategyWeights = (strategyTokenWeights, { coefficients, validatorCoefficient = 0 }) => { + const strategyWeights = strategyTokenWeights.reduce((weightMap, strategy) => { + const totalCoefficient = calculateCoefficientsSum(coefficients); + const totalWeight = calculateWeightTotals(strategy, coefficients, validatorCoefficient); + return weightMap.set(strategy.id, totalWeight / totalCoefficient); + }, /* @__PURE__ */ new Map()); + return strategyWeights; +}; +const calcHarmonicStrategyWeights = (strategyTokenWeights, { coefficients, validatorCoefficient = 0 }) => { + const coeffSum = calculateCoefficientsSum(coefficients) + validatorCoefficient; + const unnormalizedWeights = strategyTokenWeights.reduce((weightMap, strategy) => { + const denom = calculateWeightedRatioSum(strategy, coefficients, validatorCoefficient); + const finalWeight = denom != 0 ? coeffSum / denom : 0; + return weightMap.set(strategy.id, finalWeight); + }, /* @__PURE__ */ new Map()); + const weightSum = Array.from(unnormalizedWeights.values()).reduce( + (sum, weight) => sum + weight, + 0 + ); + const normalizedWeights = /* @__PURE__ */ new Map(); + for (const [id, weight] of unnormalizedWeights.entries()) { + normalizedWeights.set(id, weight / weightSum); + } + return normalizedWeights; +}; +const calcGeometricStrategyWeights = (strategyTokenWeights, { coefficients, validatorCoefficient = 0 }) => { + const unnormalizedWeights = strategyTokenWeights.reduce((weightMap, strategy) => { + const totalCoefficient = calculateCoefficientsSum(coefficients) + validatorCoefficient; + const logSum = calculateWeightedLogSum(strategy, coefficients, validatorCoefficient); + const finalWeight = logSum != 0 ? Math.exp(logSum / totalCoefficient) : 0; + return weightMap.set(strategy.id, finalWeight); + }, /* @__PURE__ */ new Map()); + const weightSum = Array.from(unnormalizedWeights.values()).reduce( + (sum, weight) => sum + weight, + 0 + ); + const normalizedWeights = /* @__PURE__ */ new Map(); + for (const [id, weight] of unnormalizedWeights.entries()) { + normalizedWeights.set(id, weight / weightSum); + } + return normalizedWeights; +}; +const utils = { + calcArithmeticStrategyWeights, + calcGeometricStrategyWeights, + calcHarmonicStrategyWeights +}; +class BasedAppsSDK { + core; + api; + contracts; + utils; + constructor(props) { + this.core = isConfig(props) ? props : createConfig(props); + this.api = { + ...this.core.basedAppsAPI, + ...this.core.apis.bam + }; + this.utils = utils; + this.contracts = this.core.contracts; + } +} +exports.BasedAppsSDK = BasedAppsSDK; +exports.bam_graph_endpoints = bam_graph_endpoints; +exports.bam_paid_graph_endpoints = bam_paid_graph_endpoints; +exports.chainIds = chainIds; +exports.chains = chains; +exports.contracts = contracts; +exports.createBAMQueries = createBAMQueries; +exports.createBasedAppsAPI = createBasedAppsAPI; +exports.createBeaconChainAPI = createBeaconChainAPI; +exports.createConfig = createConfig; +exports.createReader = createReader; +exports.createSSVAPI = createSSVAPI; +exports.createWriter = createWriter; +exports.globals = globals; +exports.hoodi = hoodi; +exports.isConfig = isConfig; +exports.networks = networks; +exports.registerValidatorsByClusterSizeLimits = registerValidatorsByClusterSizeLimits; diff --git a/dist/try-catch-CAXuSatr.cjs b/dist/try-catch-CAXuSatr.cjs new file mode 100644 index 0000000..5a76e3d --- /dev/null +++ b/dist/try-catch-CAXuSatr.cjs @@ -0,0 +1,3554 @@ +"use strict"; +const viem = require("viem"); +const global = globalThis || void 0 || self; +var freeGlobal = typeof global == "object" && global && global.Object === Object && global; +var freeSelf = typeof self == "object" && self && self.Object === Object && self; +var root = freeGlobal || freeSelf || Function("return this")(); +var Symbol$1 = root.Symbol; +var objectProto$b = Object.prototype; +var hasOwnProperty$8 = objectProto$b.hasOwnProperty; +var nativeObjectToString$1 = objectProto$b.toString; +var symToStringTag$1 = Symbol$1 ? Symbol$1.toStringTag : void 0; +function getRawTag(value) { + var isOwn = hasOwnProperty$8.call(value, symToStringTag$1), tag = value[symToStringTag$1]; + try { + value[symToStringTag$1] = void 0; + var unmasked = true; + } catch (e) { + } + var result = nativeObjectToString$1.call(value); + if (unmasked) { + if (isOwn) { + value[symToStringTag$1] = tag; + } else { + delete value[symToStringTag$1]; + } + } + return result; +} +var objectProto$a = Object.prototype; +var nativeObjectToString = objectProto$a.toString; +function objectToString(value) { + return nativeObjectToString.call(value); +} +var nullTag = "[object Null]", undefinedTag = "[object Undefined]"; +var symToStringTag = Symbol$1 ? Symbol$1.toStringTag : void 0; +function baseGetTag(value) { + if (value == null) { + return value === void 0 ? undefinedTag : nullTag; + } + return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value); +} +function isObjectLike(value) { + return value != null && typeof value == "object"; +} +var isArray = Array.isArray; +function isObject$1(value) { + var type = typeof value; + return value != null && (type == "object" || type == "function"); +} +var asyncTag = "[object AsyncFunction]", funcTag$2 = "[object Function]", genTag$1 = "[object GeneratorFunction]", proxyTag = "[object Proxy]"; +function isFunction(value) { + if (!isObject$1(value)) { + return false; + } + var tag = baseGetTag(value); + return tag == funcTag$2 || tag == genTag$1 || tag == asyncTag || tag == proxyTag; +} +var coreJsData = root["__core-js_shared__"]; +var maskSrcKey = function() { + var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || ""); + return uid ? "Symbol(src)_1." + uid : ""; +}(); +function isMasked(func) { + return !!maskSrcKey && maskSrcKey in func; +} +var funcProto$1 = Function.prototype; +var funcToString$1 = funcProto$1.toString; +function toSource(func) { + if (func != null) { + try { + return funcToString$1.call(func); + } catch (e) { + } + try { + return func + ""; + } catch (e) { + } + } + return ""; +} +var reRegExpChar = /[\\^$.*+?()[\]{}|]/g; +var reIsHostCtor = /^\[object .+?Constructor\]$/; +var funcProto = Function.prototype, objectProto$9 = Object.prototype; +var funcToString = funcProto.toString; +var hasOwnProperty$7 = objectProto$9.hasOwnProperty; +var reIsNative = RegExp( + "^" + funcToString.call(hasOwnProperty$7).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$" +); +function baseIsNative(value) { + if (!isObject$1(value) || isMasked(value)) { + return false; + } + var pattern = isFunction(value) ? reIsNative : reIsHostCtor; + return pattern.test(toSource(value)); +} +function getValue(object2, key) { + return object2 == null ? void 0 : object2[key]; +} +function getNative(object2, key) { + var value = getValue(object2, key); + return baseIsNative(value) ? value : void 0; +} +var WeakMap = getNative(root, "WeakMap"); +var objectCreate = Object.create; +var baseCreate = /* @__PURE__ */ function() { + function object2() { + } + return function(proto) { + if (!isObject$1(proto)) { + return {}; + } + if (objectCreate) { + return objectCreate(proto); + } + object2.prototype = proto; + var result = new object2(); + object2.prototype = void 0; + return result; + }; +}(); +var defineProperty = function() { + try { + var func = getNative(Object, "defineProperty"); + func({}, "", {}); + return func; + } catch (e) { + } +}(); +function arrayEach(array2, iteratee) { + var index = -1, length = array2 == null ? 0 : array2.length; + while (++index < length) { + if (iteratee(array2[index], index, array2) === false) { + break; + } + } + return array2; +} +var MAX_SAFE_INTEGER$1 = 9007199254740991; +var reIsUint = /^(?:0|[1-9]\d*)$/; +function isIndex(value, length) { + var type = typeof value; + length = length == null ? MAX_SAFE_INTEGER$1 : length; + return !!length && (type == "number" || type != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length); +} +function baseAssignValue(object2, key, value) { + if (key == "__proto__" && defineProperty) { + defineProperty(object2, key, { + "configurable": true, + "enumerable": true, + "value": value, + "writable": true + }); + } else { + object2[key] = value; + } +} +function eq(value, other) { + return value === other || value !== value && other !== other; +} +var objectProto$8 = Object.prototype; +var hasOwnProperty$6 = objectProto$8.hasOwnProperty; +function assignValue(object2, key, value) { + var objValue = object2[key]; + if (!(hasOwnProperty$6.call(object2, key) && eq(objValue, value)) || value === void 0 && !(key in object2)) { + baseAssignValue(object2, key, value); + } +} +var MAX_SAFE_INTEGER = 9007199254740991; +function isLength(value) { + return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER; +} +function isArrayLike(value) { + return value != null && isLength(value.length) && !isFunction(value); +} +var objectProto$7 = Object.prototype; +function isPrototype(value) { + var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto$7; + return value === proto; +} +function baseTimes(n, iteratee) { + var index = -1, result = Array(n); + while (++index < n) { + result[index] = iteratee(index); + } + return result; +} +var argsTag$2 = "[object Arguments]"; +function baseIsArguments(value) { + return isObjectLike(value) && baseGetTag(value) == argsTag$2; +} +var objectProto$6 = Object.prototype; +var hasOwnProperty$5 = objectProto$6.hasOwnProperty; +var propertyIsEnumerable$1 = objectProto$6.propertyIsEnumerable; +var isArguments = baseIsArguments(/* @__PURE__ */ function() { + return arguments; +}()) ? baseIsArguments : function(value) { + return isObjectLike(value) && hasOwnProperty$5.call(value, "callee") && !propertyIsEnumerable$1.call(value, "callee"); +}; +function stubFalse() { + return false; +} +var freeExports$2 = typeof exports == "object" && exports && !exports.nodeType && exports; +var freeModule$2 = freeExports$2 && typeof module == "object" && module && !module.nodeType && module; +var moduleExports$2 = freeModule$2 && freeModule$2.exports === freeExports$2; +var Buffer$1 = moduleExports$2 ? root.Buffer : void 0; +var nativeIsBuffer = Buffer$1 ? Buffer$1.isBuffer : void 0; +var isBuffer = nativeIsBuffer || stubFalse; +var argsTag$1 = "[object Arguments]", arrayTag$1 = "[object Array]", boolTag$2 = "[object Boolean]", dateTag$2 = "[object Date]", errorTag$1 = "[object Error]", funcTag$1 = "[object Function]", mapTag$4 = "[object Map]", numberTag$2 = "[object Number]", objectTag$2 = "[object Object]", regexpTag$2 = "[object RegExp]", setTag$4 = "[object Set]", stringTag$2 = "[object String]", weakMapTag$2 = "[object WeakMap]"; +var arrayBufferTag$2 = "[object ArrayBuffer]", dataViewTag$3 = "[object DataView]", float32Tag$2 = "[object Float32Array]", float64Tag$2 = "[object Float64Array]", int8Tag$2 = "[object Int8Array]", int16Tag$2 = "[object Int16Array]", int32Tag$2 = "[object Int32Array]", uint8Tag$2 = "[object Uint8Array]", uint8ClampedTag$2 = "[object Uint8ClampedArray]", uint16Tag$2 = "[object Uint16Array]", uint32Tag$2 = "[object Uint32Array]"; +var typedArrayTags = {}; +typedArrayTags[float32Tag$2] = typedArrayTags[float64Tag$2] = typedArrayTags[int8Tag$2] = typedArrayTags[int16Tag$2] = typedArrayTags[int32Tag$2] = typedArrayTags[uint8Tag$2] = typedArrayTags[uint8ClampedTag$2] = typedArrayTags[uint16Tag$2] = typedArrayTags[uint32Tag$2] = true; +typedArrayTags[argsTag$1] = typedArrayTags[arrayTag$1] = typedArrayTags[arrayBufferTag$2] = typedArrayTags[boolTag$2] = typedArrayTags[dataViewTag$3] = typedArrayTags[dateTag$2] = typedArrayTags[errorTag$1] = typedArrayTags[funcTag$1] = typedArrayTags[mapTag$4] = typedArrayTags[numberTag$2] = typedArrayTags[objectTag$2] = typedArrayTags[regexpTag$2] = typedArrayTags[setTag$4] = typedArrayTags[stringTag$2] = typedArrayTags[weakMapTag$2] = false; +function baseIsTypedArray(value) { + return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[baseGetTag(value)]; +} +function baseUnary(func) { + return function(value) { + return func(value); + }; +} +var freeExports$1 = typeof exports == "object" && exports && !exports.nodeType && exports; +var freeModule$1 = freeExports$1 && typeof module == "object" && module && !module.nodeType && module; +var moduleExports$1 = freeModule$1 && freeModule$1.exports === freeExports$1; +var freeProcess = moduleExports$1 && freeGlobal.process; +var nodeUtil = function() { + try { + var types = freeModule$1 && freeModule$1.require && freeModule$1.require("util").types; + if (types) { + return types; + } + return freeProcess && freeProcess.binding && freeProcess.binding("util"); + } catch (e) { + } +}(); +var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray; +var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray; +var objectProto$5 = Object.prototype; +var hasOwnProperty$4 = objectProto$5.hasOwnProperty; +function arrayLikeKeys(value, inherited) { + var isArr = isArray(value), isArg = !isArr && isArguments(value), isBuff = !isArr && !isArg && isBuffer(value), isType = !isArr && !isArg && !isBuff && isTypedArray(value), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? baseTimes(value.length, String) : [], length = result.length; + for (var key in value) { + if ((inherited || hasOwnProperty$4.call(value, key)) && !(skipIndexes && // Safari 9 has enumerable `arguments.length` in strict mode. + (key == "length" || // Node.js 0.10 has enumerable non-index properties on buffers. + isBuff && (key == "offset" || key == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays. + isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || // Skip index properties. + isIndex(key, length)))) { + result.push(key); + } + } + return result; +} +function overArg(func, transform2) { + return function(arg) { + return func(transform2(arg)); + }; +} +var nativeKeys = overArg(Object.keys, Object); +var objectProto$4 = Object.prototype; +var hasOwnProperty$3 = objectProto$4.hasOwnProperty; +function baseKeys(object2) { + if (!isPrototype(object2)) { + return nativeKeys(object2); + } + var result = []; + for (var key in Object(object2)) { + if (hasOwnProperty$3.call(object2, key) && key != "constructor") { + result.push(key); + } + } + return result; +} +function keys(object2) { + return isArrayLike(object2) ? arrayLikeKeys(object2) : baseKeys(object2); +} +var nativeCreate = getNative(Object, "create"); +function hashClear() { + this.__data__ = nativeCreate ? nativeCreate(null) : {}; + this.size = 0; +} +function hashDelete(key) { + var result = this.has(key) && delete this.__data__[key]; + this.size -= result ? 1 : 0; + return result; +} +var HASH_UNDEFINED$1 = "__lodash_hash_undefined__"; +var objectProto$3 = Object.prototype; +var hasOwnProperty$2 = objectProto$3.hasOwnProperty; +function hashGet(key) { + var data = this.__data__; + if (nativeCreate) { + var result = data[key]; + return result === HASH_UNDEFINED$1 ? void 0 : result; + } + return hasOwnProperty$2.call(data, key) ? data[key] : void 0; +} +var objectProto$2 = Object.prototype; +var hasOwnProperty$1 = objectProto$2.hasOwnProperty; +function hashHas(key) { + var data = this.__data__; + return nativeCreate ? data[key] !== void 0 : hasOwnProperty$1.call(data, key); +} +var HASH_UNDEFINED = "__lodash_hash_undefined__"; +function hashSet(key, value) { + var data = this.__data__; + this.size += this.has(key) ? 0 : 1; + data[key] = nativeCreate && value === void 0 ? HASH_UNDEFINED : value; + return this; +} +function Hash(entries) { + var index = -1, length = entries == null ? 0 : entries.length; + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } +} +Hash.prototype.clear = hashClear; +Hash.prototype["delete"] = hashDelete; +Hash.prototype.get = hashGet; +Hash.prototype.has = hashHas; +Hash.prototype.set = hashSet; +function listCacheClear() { + this.__data__ = []; + this.size = 0; +} +function assocIndexOf(array2, key) { + var length = array2.length; + while (length--) { + if (eq(array2[length][0], key)) { + return length; + } + } + return -1; +} +var arrayProto = Array.prototype; +var splice = arrayProto.splice; +function listCacheDelete(key) { + var data = this.__data__, index = assocIndexOf(data, key); + if (index < 0) { + return false; + } + var lastIndex = data.length - 1; + if (index == lastIndex) { + data.pop(); + } else { + splice.call(data, index, 1); + } + --this.size; + return true; +} +function listCacheGet(key) { + var data = this.__data__, index = assocIndexOf(data, key); + return index < 0 ? void 0 : data[index][1]; +} +function listCacheHas(key) { + return assocIndexOf(this.__data__, key) > -1; +} +function listCacheSet(key, value) { + var data = this.__data__, index = assocIndexOf(data, key); + if (index < 0) { + ++this.size; + data.push([key, value]); + } else { + data[index][1] = value; + } + return this; +} +function ListCache(entries) { + var index = -1, length = entries == null ? 0 : entries.length; + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } +} +ListCache.prototype.clear = listCacheClear; +ListCache.prototype["delete"] = listCacheDelete; +ListCache.prototype.get = listCacheGet; +ListCache.prototype.has = listCacheHas; +ListCache.prototype.set = listCacheSet; +var Map$1 = getNative(root, "Map"); +function mapCacheClear() { + this.size = 0; + this.__data__ = { + "hash": new Hash(), + "map": new (Map$1 || ListCache)(), + "string": new Hash() + }; +} +function isKeyable(value) { + var type = typeof value; + return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null; +} +function getMapData(map, key) { + var data = map.__data__; + return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map; +} +function mapCacheDelete(key) { + var result = getMapData(this, key)["delete"](key); + this.size -= result ? 1 : 0; + return result; +} +function mapCacheGet(key) { + return getMapData(this, key).get(key); +} +function mapCacheHas(key) { + return getMapData(this, key).has(key); +} +function mapCacheSet(key, value) { + var data = getMapData(this, key), size = data.size; + data.set(key, value); + this.size += data.size == size ? 0 : 1; + return this; +} +function MapCache(entries) { + var index = -1, length = entries == null ? 0 : entries.length; + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } +} +MapCache.prototype.clear = mapCacheClear; +MapCache.prototype["delete"] = mapCacheDelete; +MapCache.prototype.get = mapCacheGet; +MapCache.prototype.has = mapCacheHas; +MapCache.prototype.set = mapCacheSet; +function arrayPush(array2, values) { + var index = -1, length = values.length, offset = array2.length; + while (++index < length) { + array2[offset + index] = values[index]; + } + return array2; +} +var getPrototype = overArg(Object.getPrototypeOf, Object); +function stackClear() { + this.__data__ = new ListCache(); + this.size = 0; +} +function stackDelete(key) { + var data = this.__data__, result = data["delete"](key); + this.size = data.size; + return result; +} +function stackGet(key) { + return this.__data__.get(key); +} +function stackHas(key) { + return this.__data__.has(key); +} +var LARGE_ARRAY_SIZE = 200; +function stackSet(key, value) { + var data = this.__data__; + if (data instanceof ListCache) { + var pairs = data.__data__; + if (!Map$1 || pairs.length < LARGE_ARRAY_SIZE - 1) { + pairs.push([key, value]); + this.size = ++data.size; + return this; + } + data = this.__data__ = new MapCache(pairs); + } + data.set(key, value); + this.size = data.size; + return this; +} +function Stack(entries) { + var data = this.__data__ = new ListCache(entries); + this.size = data.size; +} +Stack.prototype.clear = stackClear; +Stack.prototype["delete"] = stackDelete; +Stack.prototype.get = stackGet; +Stack.prototype.has = stackHas; +Stack.prototype.set = stackSet; +var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports; +var freeModule = freeExports && typeof module == "object" && module && !module.nodeType && module; +var moduleExports = freeModule && freeModule.exports === freeExports; +var Buffer = moduleExports ? root.Buffer : void 0, allocUnsafe = Buffer ? Buffer.allocUnsafe : void 0; +function cloneBuffer(buffer, isDeep) { + if (isDeep) { + return buffer.slice(); + } + var length = buffer.length, result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length); + buffer.copy(result); + return result; +} +function arrayFilter(array2, predicate) { + var index = -1, length = array2 == null ? 0 : array2.length, resIndex = 0, result = []; + while (++index < length) { + var value = array2[index]; + if (predicate(value, index, array2)) { + result[resIndex++] = value; + } + } + return result; +} +function stubArray() { + return []; +} +var objectProto$1 = Object.prototype; +var propertyIsEnumerable = objectProto$1.propertyIsEnumerable; +var nativeGetSymbols = Object.getOwnPropertySymbols; +var getSymbols = !nativeGetSymbols ? stubArray : function(object2) { + if (object2 == null) { + return []; + } + object2 = Object(object2); + return arrayFilter(nativeGetSymbols(object2), function(symbol) { + return propertyIsEnumerable.call(object2, symbol); + }); +}; +function baseGetAllKeys(object2, keysFunc, symbolsFunc) { + var result = keysFunc(object2); + return isArray(object2) ? result : arrayPush(result, symbolsFunc(object2)); +} +function getAllKeys(object2) { + return baseGetAllKeys(object2, keys, getSymbols); +} +var DataView = getNative(root, "DataView"); +var Promise$1 = getNative(root, "Promise"); +var Set$1 = getNative(root, "Set"); +var mapTag$3 = "[object Map]", objectTag$1 = "[object Object]", promiseTag = "[object Promise]", setTag$3 = "[object Set]", weakMapTag$1 = "[object WeakMap]"; +var dataViewTag$2 = "[object DataView]"; +var dataViewCtorString = toSource(DataView), mapCtorString = toSource(Map$1), promiseCtorString = toSource(Promise$1), setCtorString = toSource(Set$1), weakMapCtorString = toSource(WeakMap); +var getTag = baseGetTag; +if (DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag$2 || Map$1 && getTag(new Map$1()) != mapTag$3 || Promise$1 && getTag(Promise$1.resolve()) != promiseTag || Set$1 && getTag(new Set$1()) != setTag$3 || WeakMap && getTag(new WeakMap()) != weakMapTag$1) { + getTag = function(value) { + var result = baseGetTag(value), Ctor = result == objectTag$1 ? value.constructor : void 0, ctorString = Ctor ? toSource(Ctor) : ""; + if (ctorString) { + switch (ctorString) { + case dataViewCtorString: + return dataViewTag$2; + case mapCtorString: + return mapTag$3; + case promiseCtorString: + return promiseTag; + case setCtorString: + return setTag$3; + case weakMapCtorString: + return weakMapTag$1; + } + } + return result; + }; +} +var objectProto = Object.prototype; +var hasOwnProperty = objectProto.hasOwnProperty; +function initCloneArray(array2) { + var length = array2.length, result = new array2.constructor(length); + if (length && typeof array2[0] == "string" && hasOwnProperty.call(array2, "index")) { + result.index = array2.index; + result.input = array2.input; + } + return result; +} +var Uint8Array = root.Uint8Array; +function cloneArrayBuffer(arrayBuffer) { + var result = new arrayBuffer.constructor(arrayBuffer.byteLength); + new Uint8Array(result).set(new Uint8Array(arrayBuffer)); + return result; +} +function cloneDataView(dataView, isDeep) { + var buffer = cloneArrayBuffer(dataView.buffer); + return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength); +} +var reFlags = /\w*$/; +function cloneRegExp(regexp) { + var result = new regexp.constructor(regexp.source, reFlags.exec(regexp)); + result.lastIndex = regexp.lastIndex; + return result; +} +var symbolProto = Symbol$1 ? Symbol$1.prototype : void 0, symbolValueOf = symbolProto ? symbolProto.valueOf : void 0; +function cloneSymbol(symbol) { + return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {}; +} +function cloneTypedArray(typedArray, isDeep) { + var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer; + return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length); +} +var boolTag$1 = "[object Boolean]", dateTag$1 = "[object Date]", mapTag$2 = "[object Map]", numberTag$1 = "[object Number]", regexpTag$1 = "[object RegExp]", setTag$2 = "[object Set]", stringTag$1 = "[object String]", symbolTag$1 = "[object Symbol]"; +var arrayBufferTag$1 = "[object ArrayBuffer]", dataViewTag$1 = "[object DataView]", float32Tag$1 = "[object Float32Array]", float64Tag$1 = "[object Float64Array]", int8Tag$1 = "[object Int8Array]", int16Tag$1 = "[object Int16Array]", int32Tag$1 = "[object Int32Array]", uint8Tag$1 = "[object Uint8Array]", uint8ClampedTag$1 = "[object Uint8ClampedArray]", uint16Tag$1 = "[object Uint16Array]", uint32Tag$1 = "[object Uint32Array]"; +function initCloneByTag(object2, tag, isDeep) { + var Ctor = object2.constructor; + switch (tag) { + case arrayBufferTag$1: + return cloneArrayBuffer(object2); + case boolTag$1: + case dateTag$1: + return new Ctor(+object2); + case dataViewTag$1: + return cloneDataView(object2); + case float32Tag$1: + case float64Tag$1: + case int8Tag$1: + case int16Tag$1: + case int32Tag$1: + case uint8Tag$1: + case uint8ClampedTag$1: + case uint16Tag$1: + case uint32Tag$1: + return cloneTypedArray(object2, isDeep); + case mapTag$2: + return new Ctor(); + case numberTag$1: + case stringTag$1: + return new Ctor(object2); + case regexpTag$1: + return cloneRegExp(object2); + case setTag$2: + return new Ctor(); + case symbolTag$1: + return cloneSymbol(object2); + } +} +function initCloneObject(object2) { + return typeof object2.constructor == "function" && !isPrototype(object2) ? baseCreate(getPrototype(object2)) : {}; +} +var mapTag$1 = "[object Map]"; +function baseIsMap(value) { + return isObjectLike(value) && getTag(value) == mapTag$1; +} +var nodeIsMap = nodeUtil && nodeUtil.isMap; +var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap; +var setTag$1 = "[object Set]"; +function baseIsSet(value) { + return isObjectLike(value) && getTag(value) == setTag$1; +} +var nodeIsSet = nodeUtil && nodeUtil.isSet; +var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet; +var CLONE_DEEP_FLAG$1 = 1; +var argsTag = "[object Arguments]", arrayTag = "[object Array]", boolTag = "[object Boolean]", dateTag = "[object Date]", errorTag = "[object Error]", funcTag = "[object Function]", genTag = "[object GeneratorFunction]", mapTag = "[object Map]", numberTag = "[object Number]", objectTag = "[object Object]", regexpTag = "[object RegExp]", setTag = "[object Set]", stringTag = "[object String]", symbolTag = "[object Symbol]", weakMapTag = "[object WeakMap]"; +var arrayBufferTag = "[object ArrayBuffer]", dataViewTag = "[object DataView]", float32Tag = "[object Float32Array]", float64Tag = "[object Float64Array]", int8Tag = "[object Int8Array]", int16Tag = "[object Int16Array]", int32Tag = "[object Int32Array]", uint8Tag = "[object Uint8Array]", uint8ClampedTag = "[object Uint8ClampedArray]", uint16Tag = "[object Uint16Array]", uint32Tag = "[object Uint32Array]"; +var cloneableTags = {}; +cloneableTags[argsTag] = cloneableTags[arrayTag] = cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] = cloneableTags[boolTag] = cloneableTags[dateTag] = cloneableTags[float32Tag] = cloneableTags[float64Tag] = cloneableTags[int8Tag] = cloneableTags[int16Tag] = cloneableTags[int32Tag] = cloneableTags[mapTag] = cloneableTags[numberTag] = cloneableTags[objectTag] = cloneableTags[regexpTag] = cloneableTags[setTag] = cloneableTags[stringTag] = cloneableTags[symbolTag] = cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] = cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true; +cloneableTags[errorTag] = cloneableTags[funcTag] = cloneableTags[weakMapTag] = false; +function baseClone(value, bitmask, customizer, key, object2, stack) { + var result, isDeep = bitmask & CLONE_DEEP_FLAG$1; + if (customizer) { + result = object2 ? customizer(value, key, object2, stack) : customizer(value); + } + if (result !== void 0) { + return result; + } + if (!isObject$1(value)) { + return value; + } + var isArr = isArray(value); + if (isArr) { + result = initCloneArray(value); + } else { + var tag = getTag(value), isFunc = tag == funcTag || tag == genTag; + if (isBuffer(value)) { + return cloneBuffer(value, isDeep); + } + if (tag == objectTag || tag == argsTag || isFunc && !object2) { + result = isFunc ? {} : initCloneObject(value); + } else { + if (!cloneableTags[tag]) { + return object2 ? value : {}; + } + result = initCloneByTag(value, tag, isDeep); + } + } + stack || (stack = new Stack()); + var stacked = stack.get(value); + if (stacked) { + return stacked; + } + stack.set(value, result); + if (isSet(value)) { + value.forEach(function(subValue) { + result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack)); + }); + } else if (isMap(value)) { + value.forEach(function(subValue, key2) { + result.set(key2, baseClone(subValue, bitmask, customizer, key2, value, stack)); + }); + } + var keysFunc = getAllKeys; + var props = isArr ? void 0 : keysFunc(value); + arrayEach(props || value, function(subValue, key2) { + if (props) { + key2 = subValue; + subValue = value[key2]; + } + assignValue(result, key2, baseClone(subValue, bitmask, customizer, key2, value, stack)); + }); + return result; +} +var CLONE_DEEP_FLAG = 1, CLONE_SYMBOLS_FLAG = 4; +function cloneDeepWith(value, customizer) { + customizer = typeof customizer == "function" ? customizer : void 0; + return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG, customizer); +} +function isUndefined(value) { + return value === void 0; +} +function $constructor(name, initializer2, params) { + function init(inst, def) { + var _a; + Object.defineProperty(inst, "_zod", { + value: inst._zod ?? {}, + enumerable: false + }); + (_a = inst._zod).traits ?? (_a.traits = /* @__PURE__ */ new Set()); + inst._zod.traits.add(name); + initializer2(inst, def); + for (const k in _.prototype) { + if (!(k in inst)) + Object.defineProperty(inst, k, { value: _.prototype[k].bind(inst) }); + } + inst._zod.constr = _; + inst._zod.def = def; + } + const Parent = params?.Parent ?? Object; + class Definition extends Parent { + } + Object.defineProperty(Definition, "name", { value: name }); + function _(def) { + var _a; + const inst = params?.Parent ? new Definition() : this; + init(inst, def); + (_a = inst._zod).deferred ?? (_a.deferred = []); + for (const fn of inst._zod.deferred) { + fn(); + } + return inst; + } + Object.defineProperty(_, "init", { value: init }); + Object.defineProperty(_, Symbol.hasInstance, { + value: (inst) => { + if (params?.Parent && inst instanceof params.Parent) + return true; + return inst?._zod?.traits?.has(name); + } + }); + Object.defineProperty(_, "name", { value: name }); + return _; +} +class $ZodAsyncError extends Error { + constructor() { + super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`); + } +} +const globalConfig = {}; +function config(newConfig) { + return globalConfig; +} +function getEnumValues(entries) { + const numericValues = Object.values(entries).filter((v) => typeof v === "number"); + const values = Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v); + return values; +} +function jsonStringifyReplacer(_, value) { + if (typeof value === "bigint") + return value.toString(); + return value; +} +function cached(getter) { + return { + get value() { + { + const value = getter(); + Object.defineProperty(this, "value", { value }); + return value; + } + } + }; +} +function nullish(input) { + return input === null || input === void 0; +} +function cleanRegex(source) { + const start = source.startsWith("^") ? 1 : 0; + const end = source.endsWith("$") ? source.length - 1 : source.length; + return source.slice(start, end); +} +function defineLazy(object2, key, getter) { + Object.defineProperty(object2, key, { + get() { + { + const value = getter(); + object2[key] = value; + return value; + } + }, + set(v) { + Object.defineProperty(object2, key, { + value: v + // configurable: true, + }); + }, + configurable: true + }); +} +function assignProp(target, prop, value) { + Object.defineProperty(target, prop, { + value, + writable: true, + enumerable: true, + configurable: true + }); +} +function esc(str) { + return JSON.stringify(str); +} +const captureStackTrace = Error.captureStackTrace ? Error.captureStackTrace : (..._args) => { +}; +function isObject(data) { + return typeof data === "object" && data !== null && !Array.isArray(data); +} +const allowsEval = cached(() => { + if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) { + return false; + } + try { + const F = Function; + new F(""); + return true; + } catch (_) { + return false; + } +}); +function isPlainObject(o) { + if (isObject(o) === false) + return false; + const ctor = o.constructor; + if (ctor === void 0) + return true; + const prot = ctor.prototype; + if (isObject(prot) === false) + return false; + if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) { + return false; + } + return true; +} +const propertyKeyTypes = /* @__PURE__ */ new Set(["string", "number", "symbol"]); +function escapeRegex(str) { + return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); +} +function clone(inst, def, params) { + const cl = new inst._zod.constr(def ?? inst._zod.def); + if (!def || params?.parent) + cl._zod.parent = inst; + return cl; +} +function normalizeParams(_params) { + const params = _params; + if (!params) + return {}; + if (typeof params === "string") + return { error: () => params }; + if (params?.message !== void 0) { + if (params?.error !== void 0) + throw new Error("Cannot specify both `message` and `error` params"); + params.error = params.message; + } + delete params.message; + if (typeof params.error === "string") + return { ...params, error: () => params.error }; + return params; +} +function optionalKeys(shape) { + return Object.keys(shape).filter((k) => { + return shape[k]._zod.optin === "optional" && shape[k]._zod.optout === "optional"; + }); +} +function pick(schema, mask) { + const newShape = {}; + const currDef = schema._zod.def; + for (const key in mask) { + if (!(key in currDef.shape)) { + throw new Error(`Unrecognized key: "${key}"`); + } + if (!mask[key]) + continue; + newShape[key] = currDef.shape[key]; + } + return clone(schema, { + ...schema._zod.def, + shape: newShape, + checks: [] + }); +} +function omit(schema, mask) { + const newShape = { ...schema._zod.def.shape }; + const currDef = schema._zod.def; + for (const key in mask) { + if (!(key in currDef.shape)) { + throw new Error(`Unrecognized key: "${key}"`); + } + if (!mask[key]) + continue; + delete newShape[key]; + } + return clone(schema, { + ...schema._zod.def, + shape: newShape, + checks: [] + }); +} +function extend(schema, shape) { + if (!isPlainObject(shape)) { + throw new Error("Invalid input to extend: expected a plain object"); + } + const def = { + ...schema._zod.def, + get shape() { + const _shape = { ...schema._zod.def.shape, ...shape }; + assignProp(this, "shape", _shape); + return _shape; + }, + checks: [] + // delete existing checks + }; + return clone(schema, def); +} +function merge(a, b) { + return clone(a, { + ...a._zod.def, + get shape() { + const _shape = { ...a._zod.def.shape, ...b._zod.def.shape }; + assignProp(this, "shape", _shape); + return _shape; + }, + catchall: b._zod.def.catchall, + checks: [] + // delete existing checks + }); +} +function partial(Class, schema, mask) { + const oldShape = schema._zod.def.shape; + const shape = { ...oldShape }; + if (mask) { + for (const key in mask) { + if (!(key in oldShape)) { + throw new Error(`Unrecognized key: "${key}"`); + } + if (!mask[key]) + continue; + shape[key] = Class ? new Class({ + type: "optional", + innerType: oldShape[key] + }) : oldShape[key]; + } + } else { + for (const key in oldShape) { + shape[key] = Class ? new Class({ + type: "optional", + innerType: oldShape[key] + }) : oldShape[key]; + } + } + return clone(schema, { + ...schema._zod.def, + shape, + checks: [] + }); +} +function required(Class, schema, mask) { + const oldShape = schema._zod.def.shape; + const shape = { ...oldShape }; + if (mask) { + for (const key in mask) { + if (!(key in shape)) { + throw new Error(`Unrecognized key: "${key}"`); + } + if (!mask[key]) + continue; + shape[key] = new Class({ + type: "nonoptional", + innerType: oldShape[key] + }); + } + } else { + for (const key in oldShape) { + shape[key] = new Class({ + type: "nonoptional", + innerType: oldShape[key] + }); + } + } + return clone(schema, { + ...schema._zod.def, + shape, + // optional: [], + checks: [] + }); +} +function aborted(x, startIndex = 0) { + for (let i = startIndex; i < x.issues.length; i++) { + if (x.issues[i]?.continue !== true) + return true; + } + return false; +} +function prefixIssues(path, issues) { + return issues.map((iss) => { + var _a; + (_a = iss).path ?? (_a.path = []); + iss.path.unshift(path); + return iss; + }); +} +function unwrapMessage(message) { + return typeof message === "string" ? message : message?.message; +} +function finalizeIssue(iss, ctx, config2) { + const full = { ...iss, path: iss.path ?? [] }; + if (!iss.message) { + const message = unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config2.customError?.(iss)) ?? unwrapMessage(config2.localeError?.(iss)) ?? "Invalid input"; + full.message = message; + } + delete full.inst; + delete full.continue; + if (!ctx?.reportInput) { + delete full.input; + } + return full; +} +function getLengthableOrigin(input) { + if (Array.isArray(input)) + return "array"; + if (typeof input === "string") + return "string"; + return "unknown"; +} +function issue(...args) { + const [iss, input, inst] = args; + if (typeof iss === "string") { + return { + message: iss, + code: "custom", + input, + inst + }; + } + return { ...iss }; +} +const initializer$1 = (inst, def) => { + inst.name = "$ZodError"; + Object.defineProperty(inst, "_zod", { + value: inst._zod, + enumerable: false + }); + Object.defineProperty(inst, "issues", { + value: def, + enumerable: false + }); + Object.defineProperty(inst, "message", { + get() { + return JSON.stringify(def, jsonStringifyReplacer, 2); + }, + enumerable: true + // configurable: false, + }); + Object.defineProperty(inst, "toString", { + value: () => inst.message, + enumerable: false + }); +}; +const $ZodError = $constructor("$ZodError", initializer$1); +const $ZodRealError = $constructor("$ZodError", initializer$1, { Parent: Error }); +function flattenError(error, mapper = (issue2) => issue2.message) { + const fieldErrors = {}; + const formErrors = []; + for (const sub of error.issues) { + if (sub.path.length > 0) { + fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || []; + fieldErrors[sub.path[0]].push(mapper(sub)); + } else { + formErrors.push(mapper(sub)); + } + } + return { formErrors, fieldErrors }; +} +function formatError(error, _mapper) { + const mapper = _mapper || function(issue2) { + return issue2.message; + }; + const fieldErrors = { _errors: [] }; + const processError = (error2) => { + for (const issue2 of error2.issues) { + if (issue2.code === "invalid_union" && issue2.errors.length) { + issue2.errors.map((issues) => processError({ issues })); + } else if (issue2.code === "invalid_key") { + processError({ issues: issue2.issues }); + } else if (issue2.code === "invalid_element") { + processError({ issues: issue2.issues }); + } else if (issue2.path.length === 0) { + fieldErrors._errors.push(mapper(issue2)); + } else { + let curr = fieldErrors; + let i = 0; + while (i < issue2.path.length) { + const el = issue2.path[i]; + const terminal = i === issue2.path.length - 1; + if (!terminal) { + curr[el] = curr[el] || { _errors: [] }; + } else { + curr[el] = curr[el] || { _errors: [] }; + curr[el]._errors.push(mapper(issue2)); + } + curr = curr[el]; + i++; + } + } + } + }; + processError(error); + return fieldErrors; +} +const _parse = (_Err) => (schema, value, _ctx, _params) => { + const ctx = _ctx ? Object.assign(_ctx, { async: false }) : { async: false }; + const result = schema._zod.run({ value, issues: [] }, ctx); + if (result instanceof Promise) { + throw new $ZodAsyncError(); + } + if (result.issues.length) { + const e = new (_params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config()))); + captureStackTrace(e, _params?.callee); + throw e; + } + return result.value; +}; +const _parseAsync = (_Err) => async (schema, value, _ctx, params) => { + const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true }; + let result = schema._zod.run({ value, issues: [] }, ctx); + if (result instanceof Promise) + result = await result; + if (result.issues.length) { + const e = new (params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config()))); + captureStackTrace(e, params?.callee); + throw e; + } + return result.value; +}; +const _safeParse = (_Err) => (schema, value, _ctx) => { + const ctx = _ctx ? { ..._ctx, async: false } : { async: false }; + const result = schema._zod.run({ value, issues: [] }, ctx); + if (result instanceof Promise) { + throw new $ZodAsyncError(); + } + return result.issues.length ? { + success: false, + error: new (_Err ?? $ZodError)(result.issues.map((iss) => finalizeIssue(iss, ctx, config()))) + } : { success: true, data: result.value }; +}; +const safeParse$1 = /* @__PURE__ */ _safeParse($ZodRealError); +const _safeParseAsync = (_Err) => async (schema, value, _ctx) => { + const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true }; + let result = schema._zod.run({ value, issues: [] }, ctx); + if (result instanceof Promise) + result = await result; + return result.issues.length ? { + success: false, + error: new _Err(result.issues.map((iss) => finalizeIssue(iss, ctx, config()))) + } : { success: true, data: result.value }; +}; +const safeParseAsync$1 = /* @__PURE__ */ _safeParseAsync($ZodRealError); +const cuid = /^[cC][^\s-]{8,}$/; +const cuid2 = /^[0-9a-z]+$/; +const ulid = /^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/; +const xid = /^[0-9a-vA-V]{20}$/; +const ksuid = /^[A-Za-z0-9]{27}$/; +const nanoid = /^[a-zA-Z0-9_-]{21}$/; +const duration$1 = /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/; +const guid = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/; +const uuid = (version2) => { + if (!version2) + return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000)$/; + return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version2}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`); +}; +const email = /^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$/; +const _emoji$1 = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`; +function emoji() { + return new RegExp(_emoji$1, "u"); +} +const ipv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/; +const ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})$/; +const cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/; +const cidrv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/; +const base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/; +const base64url = /^[A-Za-z0-9_-]*$/; +const hostname = /^([a-zA-Z0-9-]+\.)*[a-zA-Z0-9-]+$/; +const e164 = /^\+(?:[0-9]){6,14}[0-9]$/; +const dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`; +const date$1 = /* @__PURE__ */ new RegExp(`^${dateSource}$`); +function timeSource(args) { + const hhmm = `(?:[01]\\d|2[0-3]):[0-5]\\d`; + const regex = typeof args.precision === "number" ? args.precision === -1 ? `${hhmm}` : args.precision === 0 ? `${hhmm}:[0-5]\\d` : `${hhmm}:[0-5]\\d\\.\\d{${args.precision}}` : `${hhmm}(?::[0-5]\\d(?:\\.\\d+)?)?`; + return regex; +} +function time$1(args) { + return new RegExp(`^${timeSource(args)}$`); +} +function datetime$1(args) { + const time2 = timeSource({ precision: args.precision }); + const opts = ["Z"]; + if (args.local) + opts.push(""); + if (args.offset) + opts.push(`([+-]\\d{2}:\\d{2})`); + const timeRegex = `${time2}(?:${opts.join("|")})`; + return new RegExp(`^${dateSource}T(?:${timeRegex})$`); +} +const string$1 = (params) => { + const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`; + return new RegExp(`^${regex}$`); +}; +const lowercase = /^[^A-Z]*$/; +const uppercase = /^[^a-z]*$/; +const $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (inst, def) => { + var _a; + inst._zod ?? (inst._zod = {}); + inst._zod.def = def; + (_a = inst._zod).onattach ?? (_a.onattach = []); +}); +const $ZodCheckMaxLength = /* @__PURE__ */ $constructor("$ZodCheckMaxLength", (inst, def) => { + var _a; + $ZodCheck.init(inst, def); + (_a = inst._zod.def).when ?? (_a.when = (payload) => { + const val = payload.value; + return !nullish(val) && val.length !== void 0; + }); + inst._zod.onattach.push((inst2) => { + const curr = inst2._zod.bag.maximum ?? Number.POSITIVE_INFINITY; + if (def.maximum < curr) + inst2._zod.bag.maximum = def.maximum; + }); + inst._zod.check = (payload) => { + const input = payload.value; + const length = input.length; + if (length <= def.maximum) + return; + const origin = getLengthableOrigin(input); + payload.issues.push({ + origin, + code: "too_big", + maximum: def.maximum, + inclusive: true, + input, + inst, + continue: !def.abort + }); + }; +}); +const $ZodCheckMinLength = /* @__PURE__ */ $constructor("$ZodCheckMinLength", (inst, def) => { + var _a; + $ZodCheck.init(inst, def); + (_a = inst._zod.def).when ?? (_a.when = (payload) => { + const val = payload.value; + return !nullish(val) && val.length !== void 0; + }); + inst._zod.onattach.push((inst2) => { + const curr = inst2._zod.bag.minimum ?? Number.NEGATIVE_INFINITY; + if (def.minimum > curr) + inst2._zod.bag.minimum = def.minimum; + }); + inst._zod.check = (payload) => { + const input = payload.value; + const length = input.length; + if (length >= def.minimum) + return; + const origin = getLengthableOrigin(input); + payload.issues.push({ + origin, + code: "too_small", + minimum: def.minimum, + inclusive: true, + input, + inst, + continue: !def.abort + }); + }; +}); +const $ZodCheckLengthEquals = /* @__PURE__ */ $constructor("$ZodCheckLengthEquals", (inst, def) => { + var _a; + $ZodCheck.init(inst, def); + (_a = inst._zod.def).when ?? (_a.when = (payload) => { + const val = payload.value; + return !nullish(val) && val.length !== void 0; + }); + inst._zod.onattach.push((inst2) => { + const bag = inst2._zod.bag; + bag.minimum = def.length; + bag.maximum = def.length; + bag.length = def.length; + }); + inst._zod.check = (payload) => { + const input = payload.value; + const length = input.length; + if (length === def.length) + return; + const origin = getLengthableOrigin(input); + const tooBig = length > def.length; + payload.issues.push({ + origin, + ...tooBig ? { code: "too_big", maximum: def.length } : { code: "too_small", minimum: def.length }, + inclusive: true, + exact: true, + input: payload.value, + inst, + continue: !def.abort + }); + }; +}); +const $ZodCheckStringFormat = /* @__PURE__ */ $constructor("$ZodCheckStringFormat", (inst, def) => { + var _a, _b; + $ZodCheck.init(inst, def); + inst._zod.onattach.push((inst2) => { + const bag = inst2._zod.bag; + bag.format = def.format; + if (def.pattern) { + bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set()); + bag.patterns.add(def.pattern); + } + }); + if (def.pattern) + (_a = inst._zod).check ?? (_a.check = (payload) => { + def.pattern.lastIndex = 0; + if (def.pattern.test(payload.value)) + return; + payload.issues.push({ + origin: "string", + code: "invalid_format", + format: def.format, + input: payload.value, + ...def.pattern ? { pattern: def.pattern.toString() } : {}, + inst, + continue: !def.abort + }); + }); + else + (_b = inst._zod).check ?? (_b.check = () => { + }); +}); +const $ZodCheckRegex = /* @__PURE__ */ $constructor("$ZodCheckRegex", (inst, def) => { + $ZodCheckStringFormat.init(inst, def); + inst._zod.check = (payload) => { + def.pattern.lastIndex = 0; + if (def.pattern.test(payload.value)) + return; + payload.issues.push({ + origin: "string", + code: "invalid_format", + format: "regex", + input: payload.value, + pattern: def.pattern.toString(), + inst, + continue: !def.abort + }); + }; +}); +const $ZodCheckLowerCase = /* @__PURE__ */ $constructor("$ZodCheckLowerCase", (inst, def) => { + def.pattern ?? (def.pattern = lowercase); + $ZodCheckStringFormat.init(inst, def); +}); +const $ZodCheckUpperCase = /* @__PURE__ */ $constructor("$ZodCheckUpperCase", (inst, def) => { + def.pattern ?? (def.pattern = uppercase); + $ZodCheckStringFormat.init(inst, def); +}); +const $ZodCheckIncludes = /* @__PURE__ */ $constructor("$ZodCheckIncludes", (inst, def) => { + $ZodCheck.init(inst, def); + const escapedRegex = escapeRegex(def.includes); + const pattern = new RegExp(typeof def.position === "number" ? `^.{${def.position}}${escapedRegex}` : escapedRegex); + def.pattern = pattern; + inst._zod.onattach.push((inst2) => { + const bag = inst2._zod.bag; + bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set()); + bag.patterns.add(pattern); + }); + inst._zod.check = (payload) => { + if (payload.value.includes(def.includes, def.position)) + return; + payload.issues.push({ + origin: "string", + code: "invalid_format", + format: "includes", + includes: def.includes, + input: payload.value, + inst, + continue: !def.abort + }); + }; +}); +const $ZodCheckStartsWith = /* @__PURE__ */ $constructor("$ZodCheckStartsWith", (inst, def) => { + $ZodCheck.init(inst, def); + const pattern = new RegExp(`^${escapeRegex(def.prefix)}.*`); + def.pattern ?? (def.pattern = pattern); + inst._zod.onattach.push((inst2) => { + const bag = inst2._zod.bag; + bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set()); + bag.patterns.add(pattern); + }); + inst._zod.check = (payload) => { + if (payload.value.startsWith(def.prefix)) + return; + payload.issues.push({ + origin: "string", + code: "invalid_format", + format: "starts_with", + prefix: def.prefix, + input: payload.value, + inst, + continue: !def.abort + }); + }; +}); +const $ZodCheckEndsWith = /* @__PURE__ */ $constructor("$ZodCheckEndsWith", (inst, def) => { + $ZodCheck.init(inst, def); + const pattern = new RegExp(`.*${escapeRegex(def.suffix)}$`); + def.pattern ?? (def.pattern = pattern); + inst._zod.onattach.push((inst2) => { + const bag = inst2._zod.bag; + bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set()); + bag.patterns.add(pattern); + }); + inst._zod.check = (payload) => { + if (payload.value.endsWith(def.suffix)) + return; + payload.issues.push({ + origin: "string", + code: "invalid_format", + format: "ends_with", + suffix: def.suffix, + input: payload.value, + inst, + continue: !def.abort + }); + }; +}); +const $ZodCheckOverwrite = /* @__PURE__ */ $constructor("$ZodCheckOverwrite", (inst, def) => { + $ZodCheck.init(inst, def); + inst._zod.check = (payload) => { + payload.value = def.tx(payload.value); + }; +}); +class Doc { + constructor(args = []) { + this.content = []; + this.indent = 0; + if (this) + this.args = args; + } + indented(fn) { + this.indent += 1; + fn(this); + this.indent -= 1; + } + write(arg) { + if (typeof arg === "function") { + arg(this, { execution: "sync" }); + arg(this, { execution: "async" }); + return; + } + const content = arg; + const lines = content.split("\n").filter((x) => x); + const minIndent = Math.min(...lines.map((x) => x.length - x.trimStart().length)); + const dedented = lines.map((x) => x.slice(minIndent)).map((x) => " ".repeat(this.indent * 2) + x); + for (const line of dedented) { + this.content.push(line); + } + } + compile() { + const F = Function; + const args = this?.args; + const content = this?.content ?? [``]; + const lines = [...content.map((x) => ` ${x}`)]; + return new F(...args, lines.join("\n")); + } +} +const version = { + major: 4, + minor: 0, + patch: 5 +}; +const $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => { + var _a; + inst ?? (inst = {}); + inst._zod.def = def; + inst._zod.bag = inst._zod.bag || {}; + inst._zod.version = version; + const checks = [...inst._zod.def.checks ?? []]; + if (inst._zod.traits.has("$ZodCheck")) { + checks.unshift(inst); + } + for (const ch of checks) { + for (const fn of ch._zod.onattach) { + fn(inst); + } + } + if (checks.length === 0) { + (_a = inst._zod).deferred ?? (_a.deferred = []); + inst._zod.deferred?.push(() => { + inst._zod.run = inst._zod.parse; + }); + } else { + const runChecks = (payload, checks2, ctx) => { + let isAborted = aborted(payload); + let asyncResult; + for (const ch of checks2) { + if (ch._zod.def.when) { + const shouldRun = ch._zod.def.when(payload); + if (!shouldRun) + continue; + } else if (isAborted) { + continue; + } + const currLen = payload.issues.length; + const _ = ch._zod.check(payload); + if (_ instanceof Promise && ctx?.async === false) { + throw new $ZodAsyncError(); + } + if (asyncResult || _ instanceof Promise) { + asyncResult = (asyncResult ?? Promise.resolve()).then(async () => { + await _; + const nextLen = payload.issues.length; + if (nextLen === currLen) + return; + if (!isAborted) + isAborted = aborted(payload, currLen); + }); + } else { + const nextLen = payload.issues.length; + if (nextLen === currLen) + continue; + if (!isAborted) + isAborted = aborted(payload, currLen); + } + } + if (asyncResult) { + return asyncResult.then(() => { + return payload; + }); + } + return payload; + }; + inst._zod.run = (payload, ctx) => { + const result = inst._zod.parse(payload, ctx); + if (result instanceof Promise) { + if (ctx.async === false) + throw new $ZodAsyncError(); + return result.then((result2) => runChecks(result2, checks, ctx)); + } + return runChecks(result, checks, ctx); + }; + } + inst["~standard"] = { + validate: (value) => { + try { + const r = safeParse$1(inst, value); + return r.success ? { value: r.data } : { issues: r.error?.issues }; + } catch (_) { + return safeParseAsync$1(inst, value).then((r) => r.success ? { value: r.data } : { issues: r.error?.issues }); + } + }, + vendor: "zod", + version: 1 + }; +}); +const $ZodString = /* @__PURE__ */ $constructor("$ZodString", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.pattern = [...inst?._zod.bag?.patterns ?? []].pop() ?? string$1(inst._zod.bag); + inst._zod.parse = (payload, _) => { + if (def.coerce) + try { + payload.value = String(payload.value); + } catch (_2) { + } + if (typeof payload.value === "string") + return payload; + payload.issues.push({ + expected: "string", + code: "invalid_type", + input: payload.value, + inst + }); + return payload; + }; +}); +const $ZodStringFormat = /* @__PURE__ */ $constructor("$ZodStringFormat", (inst, def) => { + $ZodCheckStringFormat.init(inst, def); + $ZodString.init(inst, def); +}); +const $ZodGUID = /* @__PURE__ */ $constructor("$ZodGUID", (inst, def) => { + def.pattern ?? (def.pattern = guid); + $ZodStringFormat.init(inst, def); +}); +const $ZodUUID = /* @__PURE__ */ $constructor("$ZodUUID", (inst, def) => { + if (def.version) { + const versionMap = { + v1: 1, + v2: 2, + v3: 3, + v4: 4, + v5: 5, + v6: 6, + v7: 7, + v8: 8 + }; + const v = versionMap[def.version]; + if (v === void 0) + throw new Error(`Invalid UUID version: "${def.version}"`); + def.pattern ?? (def.pattern = uuid(v)); + } else + def.pattern ?? (def.pattern = uuid()); + $ZodStringFormat.init(inst, def); +}); +const $ZodEmail = /* @__PURE__ */ $constructor("$ZodEmail", (inst, def) => { + def.pattern ?? (def.pattern = email); + $ZodStringFormat.init(inst, def); +}); +const $ZodURL = /* @__PURE__ */ $constructor("$ZodURL", (inst, def) => { + $ZodStringFormat.init(inst, def); + inst._zod.check = (payload) => { + try { + const orig = payload.value; + const url2 = new URL(orig); + const href = url2.href; + if (def.hostname) { + def.hostname.lastIndex = 0; + if (!def.hostname.test(url2.hostname)) { + payload.issues.push({ + code: "invalid_format", + format: "url", + note: "Invalid hostname", + pattern: hostname.source, + input: payload.value, + inst, + continue: !def.abort + }); + } + } + if (def.protocol) { + def.protocol.lastIndex = 0; + if (!def.protocol.test(url2.protocol.endsWith(":") ? url2.protocol.slice(0, -1) : url2.protocol)) { + payload.issues.push({ + code: "invalid_format", + format: "url", + note: "Invalid protocol", + pattern: def.protocol.source, + input: payload.value, + inst, + continue: !def.abort + }); + } + } + if (!orig.endsWith("/") && href.endsWith("/")) { + payload.value = href.slice(0, -1); + } else { + payload.value = href; + } + return; + } catch (_) { + payload.issues.push({ + code: "invalid_format", + format: "url", + input: payload.value, + inst, + continue: !def.abort + }); + } + }; +}); +const $ZodEmoji = /* @__PURE__ */ $constructor("$ZodEmoji", (inst, def) => { + def.pattern ?? (def.pattern = emoji()); + $ZodStringFormat.init(inst, def); +}); +const $ZodNanoID = /* @__PURE__ */ $constructor("$ZodNanoID", (inst, def) => { + def.pattern ?? (def.pattern = nanoid); + $ZodStringFormat.init(inst, def); +}); +const $ZodCUID = /* @__PURE__ */ $constructor("$ZodCUID", (inst, def) => { + def.pattern ?? (def.pattern = cuid); + $ZodStringFormat.init(inst, def); +}); +const $ZodCUID2 = /* @__PURE__ */ $constructor("$ZodCUID2", (inst, def) => { + def.pattern ?? (def.pattern = cuid2); + $ZodStringFormat.init(inst, def); +}); +const $ZodULID = /* @__PURE__ */ $constructor("$ZodULID", (inst, def) => { + def.pattern ?? (def.pattern = ulid); + $ZodStringFormat.init(inst, def); +}); +const $ZodXID = /* @__PURE__ */ $constructor("$ZodXID", (inst, def) => { + def.pattern ?? (def.pattern = xid); + $ZodStringFormat.init(inst, def); +}); +const $ZodKSUID = /* @__PURE__ */ $constructor("$ZodKSUID", (inst, def) => { + def.pattern ?? (def.pattern = ksuid); + $ZodStringFormat.init(inst, def); +}); +const $ZodISODateTime = /* @__PURE__ */ $constructor("$ZodISODateTime", (inst, def) => { + def.pattern ?? (def.pattern = datetime$1(def)); + $ZodStringFormat.init(inst, def); +}); +const $ZodISODate = /* @__PURE__ */ $constructor("$ZodISODate", (inst, def) => { + def.pattern ?? (def.pattern = date$1); + $ZodStringFormat.init(inst, def); +}); +const $ZodISOTime = /* @__PURE__ */ $constructor("$ZodISOTime", (inst, def) => { + def.pattern ?? (def.pattern = time$1(def)); + $ZodStringFormat.init(inst, def); +}); +const $ZodISODuration = /* @__PURE__ */ $constructor("$ZodISODuration", (inst, def) => { + def.pattern ?? (def.pattern = duration$1); + $ZodStringFormat.init(inst, def); +}); +const $ZodIPv4 = /* @__PURE__ */ $constructor("$ZodIPv4", (inst, def) => { + def.pattern ?? (def.pattern = ipv4); + $ZodStringFormat.init(inst, def); + inst._zod.onattach.push((inst2) => { + const bag = inst2._zod.bag; + bag.format = `ipv4`; + }); +}); +const $ZodIPv6 = /* @__PURE__ */ $constructor("$ZodIPv6", (inst, def) => { + def.pattern ?? (def.pattern = ipv6); + $ZodStringFormat.init(inst, def); + inst._zod.onattach.push((inst2) => { + const bag = inst2._zod.bag; + bag.format = `ipv6`; + }); + inst._zod.check = (payload) => { + try { + new URL(`http://[${payload.value}]`); + } catch { + payload.issues.push({ + code: "invalid_format", + format: "ipv6", + input: payload.value, + inst, + continue: !def.abort + }); + } + }; +}); +const $ZodCIDRv4 = /* @__PURE__ */ $constructor("$ZodCIDRv4", (inst, def) => { + def.pattern ?? (def.pattern = cidrv4); + $ZodStringFormat.init(inst, def); +}); +const $ZodCIDRv6 = /* @__PURE__ */ $constructor("$ZodCIDRv6", (inst, def) => { + def.pattern ?? (def.pattern = cidrv6); + $ZodStringFormat.init(inst, def); + inst._zod.check = (payload) => { + const [address, prefix] = payload.value.split("/"); + try { + if (!prefix) + throw new Error(); + const prefixNum = Number(prefix); + if (`${prefixNum}` !== prefix) + throw new Error(); + if (prefixNum < 0 || prefixNum > 128) + throw new Error(); + new URL(`http://[${address}]`); + } catch { + payload.issues.push({ + code: "invalid_format", + format: "cidrv6", + input: payload.value, + inst, + continue: !def.abort + }); + } + }; +}); +function isValidBase64(data) { + if (data === "") + return true; + if (data.length % 4 !== 0) + return false; + try { + atob(data); + return true; + } catch { + return false; + } +} +const $ZodBase64 = /* @__PURE__ */ $constructor("$ZodBase64", (inst, def) => { + def.pattern ?? (def.pattern = base64); + $ZodStringFormat.init(inst, def); + inst._zod.onattach.push((inst2) => { + inst2._zod.bag.contentEncoding = "base64"; + }); + inst._zod.check = (payload) => { + if (isValidBase64(payload.value)) + return; + payload.issues.push({ + code: "invalid_format", + format: "base64", + input: payload.value, + inst, + continue: !def.abort + }); + }; +}); +function isValidBase64URL(data) { + if (!base64url.test(data)) + return false; + const base642 = data.replace(/[-_]/g, (c) => c === "-" ? "+" : "/"); + const padded = base642.padEnd(Math.ceil(base642.length / 4) * 4, "="); + return isValidBase64(padded); +} +const $ZodBase64URL = /* @__PURE__ */ $constructor("$ZodBase64URL", (inst, def) => { + def.pattern ?? (def.pattern = base64url); + $ZodStringFormat.init(inst, def); + inst._zod.onattach.push((inst2) => { + inst2._zod.bag.contentEncoding = "base64url"; + }); + inst._zod.check = (payload) => { + if (isValidBase64URL(payload.value)) + return; + payload.issues.push({ + code: "invalid_format", + format: "base64url", + input: payload.value, + inst, + continue: !def.abort + }); + }; +}); +const $ZodE164 = /* @__PURE__ */ $constructor("$ZodE164", (inst, def) => { + def.pattern ?? (def.pattern = e164); + $ZodStringFormat.init(inst, def); +}); +function isValidJWT(token, algorithm = null) { + try { + const tokensParts = token.split("."); + if (tokensParts.length !== 3) + return false; + const [header] = tokensParts; + if (!header) + return false; + const parsedHeader = JSON.parse(atob(header)); + if ("typ" in parsedHeader && parsedHeader?.typ !== "JWT") + return false; + if (!parsedHeader.alg) + return false; + if (algorithm && (!("alg" in parsedHeader) || parsedHeader.alg !== algorithm)) + return false; + return true; + } catch { + return false; + } +} +const $ZodJWT = /* @__PURE__ */ $constructor("$ZodJWT", (inst, def) => { + $ZodStringFormat.init(inst, def); + inst._zod.check = (payload) => { + if (isValidJWT(payload.value, def.alg)) + return; + payload.issues.push({ + code: "invalid_format", + format: "jwt", + input: payload.value, + inst, + continue: !def.abort + }); + }; +}); +const $ZodAny = /* @__PURE__ */ $constructor("$ZodAny", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload) => payload; +}); +const $ZodUnknown = /* @__PURE__ */ $constructor("$ZodUnknown", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload) => payload; +}); +const $ZodNever = /* @__PURE__ */ $constructor("$ZodNever", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload, _ctx) => { + payload.issues.push({ + expected: "never", + code: "invalid_type", + input: payload.value, + inst + }); + return payload; + }; +}); +function handleArrayResult(result, final, index) { + if (result.issues.length) { + final.issues.push(...prefixIssues(index, result.issues)); + } + final.value[index] = result.value; +} +const $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload, ctx) => { + const input = payload.value; + if (!Array.isArray(input)) { + payload.issues.push({ + expected: "array", + code: "invalid_type", + input, + inst + }); + return payload; + } + payload.value = Array(input.length); + const proms = []; + for (let i = 0; i < input.length; i++) { + const item = input[i]; + const result = def.element._zod.run({ + value: item, + issues: [] + }, ctx); + if (result instanceof Promise) { + proms.push(result.then((result2) => handleArrayResult(result2, payload, i))); + } else { + handleArrayResult(result, payload, i); + } + } + if (proms.length) { + return Promise.all(proms).then(() => payload); + } + return payload; + }; +}); +function handleObjectResult(result, final, key) { + if (result.issues.length) { + final.issues.push(...prefixIssues(key, result.issues)); + } + final.value[key] = result.value; +} +function handleOptionalObjectResult(result, final, key, input) { + if (result.issues.length) { + if (input[key] === void 0) { + if (key in input) { + final.value[key] = void 0; + } else { + final.value[key] = result.value; + } + } else { + final.issues.push(...prefixIssues(key, result.issues)); + } + } else if (result.value === void 0) { + if (key in input) + final.value[key] = void 0; + } else { + final.value[key] = result.value; + } +} +const $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => { + $ZodType.init(inst, def); + const _normalized = cached(() => { + const keys2 = Object.keys(def.shape); + for (const k of keys2) { + if (!(def.shape[k] instanceof $ZodType)) { + throw new Error(`Invalid element at key "${k}": expected a Zod schema`); + } + } + const okeys = optionalKeys(def.shape); + return { + shape: def.shape, + keys: keys2, + keySet: new Set(keys2), + numKeys: keys2.length, + optionalKeys: new Set(okeys) + }; + }); + defineLazy(inst._zod, "propValues", () => { + const shape = def.shape; + const propValues = {}; + for (const key in shape) { + const field = shape[key]._zod; + if (field.values) { + propValues[key] ?? (propValues[key] = /* @__PURE__ */ new Set()); + for (const v of field.values) + propValues[key].add(v); + } + } + return propValues; + }); + const generateFastpass = (shape) => { + const doc = new Doc(["shape", "payload", "ctx"]); + const normalized = _normalized.value; + const parseStr = (key) => { + const k = esc(key); + return `shape[${k}]._zod.run({ value: input[${k}], issues: [] }, ctx)`; + }; + doc.write(`const input = payload.value;`); + const ids = /* @__PURE__ */ Object.create(null); + let counter = 0; + for (const key of normalized.keys) { + ids[key] = `key_${counter++}`; + } + doc.write(`const newResult = {}`); + for (const key of normalized.keys) { + if (normalized.optionalKeys.has(key)) { + const id = ids[key]; + doc.write(`const ${id} = ${parseStr(key)};`); + const k = esc(key); + doc.write(` + if (${id}.issues.length) { + if (input[${k}] === undefined) { + if (${k} in input) { + newResult[${k}] = undefined; + } + } else { + payload.issues = payload.issues.concat( + ${id}.issues.map((iss) => ({ + ...iss, + path: iss.path ? [${k}, ...iss.path] : [${k}], + })) + ); + } + } else if (${id}.value === undefined) { + if (${k} in input) newResult[${k}] = undefined; + } else { + newResult[${k}] = ${id}.value; + } + `); + } else { + const id = ids[key]; + doc.write(`const ${id} = ${parseStr(key)};`); + doc.write(` + if (${id}.issues.length) payload.issues = payload.issues.concat(${id}.issues.map(iss => ({ + ...iss, + path: iss.path ? [${esc(key)}, ...iss.path] : [${esc(key)}] + })));`); + doc.write(`newResult[${esc(key)}] = ${id}.value`); + } + } + doc.write(`payload.value = newResult;`); + doc.write(`return payload;`); + const fn = doc.compile(); + return (payload, ctx) => fn(shape, payload, ctx); + }; + let fastpass; + const isObject$12 = isObject; + const jit = !globalConfig.jitless; + const allowsEval$1 = allowsEval; + const fastEnabled = jit && allowsEval$1.value; + const catchall = def.catchall; + let value; + inst._zod.parse = (payload, ctx) => { + value ?? (value = _normalized.value); + const input = payload.value; + if (!isObject$12(input)) { + payload.issues.push({ + expected: "object", + code: "invalid_type", + input, + inst + }); + return payload; + } + const proms = []; + if (jit && fastEnabled && ctx?.async === false && ctx.jitless !== true) { + if (!fastpass) + fastpass = generateFastpass(def.shape); + payload = fastpass(payload, ctx); + } else { + payload.value = {}; + const shape = value.shape; + for (const key of value.keys) { + const el = shape[key]; + const r = el._zod.run({ value: input[key], issues: [] }, ctx); + const isOptional = el._zod.optin === "optional" && el._zod.optout === "optional"; + if (r instanceof Promise) { + proms.push(r.then((r2) => isOptional ? handleOptionalObjectResult(r2, payload, key, input) : handleObjectResult(r2, payload, key))); + } else if (isOptional) { + handleOptionalObjectResult(r, payload, key, input); + } else { + handleObjectResult(r, payload, key); + } + } + } + if (!catchall) { + return proms.length ? Promise.all(proms).then(() => payload) : payload; + } + const unrecognized = []; + const keySet = value.keySet; + const _catchall = catchall._zod; + const t = _catchall.def.type; + for (const key of Object.keys(input)) { + if (keySet.has(key)) + continue; + if (t === "never") { + unrecognized.push(key); + continue; + } + const r = _catchall.run({ value: input[key], issues: [] }, ctx); + if (r instanceof Promise) { + proms.push(r.then((r2) => handleObjectResult(r2, payload, key))); + } else { + handleObjectResult(r, payload, key); + } + } + if (unrecognized.length) { + payload.issues.push({ + code: "unrecognized_keys", + keys: unrecognized, + input, + inst + }); + } + if (!proms.length) + return payload; + return Promise.all(proms).then(() => { + return payload; + }); + }; +}); +function handleUnionResults(results, final, inst, ctx) { + for (const result of results) { + if (result.issues.length === 0) { + final.value = result.value; + return final; + } + } + final.issues.push({ + code: "invalid_union", + input: final.value, + inst, + errors: results.map((result) => result.issues.map((iss) => finalizeIssue(iss, ctx, config()))) + }); + return final; +} +const $ZodUnion = /* @__PURE__ */ $constructor("$ZodUnion", (inst, def) => { + $ZodType.init(inst, def); + defineLazy(inst._zod, "optin", () => def.options.some((o) => o._zod.optin === "optional") ? "optional" : void 0); + defineLazy(inst._zod, "optout", () => def.options.some((o) => o._zod.optout === "optional") ? "optional" : void 0); + defineLazy(inst._zod, "values", () => { + if (def.options.every((o) => o._zod.values)) { + return new Set(def.options.flatMap((option) => Array.from(option._zod.values))); + } + return void 0; + }); + defineLazy(inst._zod, "pattern", () => { + if (def.options.every((o) => o._zod.pattern)) { + const patterns = def.options.map((o) => o._zod.pattern); + return new RegExp(`^(${patterns.map((p) => cleanRegex(p.source)).join("|")})$`); + } + return void 0; + }); + inst._zod.parse = (payload, ctx) => { + let async = false; + const results = []; + for (const option of def.options) { + const result = option._zod.run({ + value: payload.value, + issues: [] + }, ctx); + if (result instanceof Promise) { + results.push(result); + async = true; + } else { + if (result.issues.length === 0) + return result; + results.push(result); + } + } + if (!async) + return handleUnionResults(results, payload, inst, ctx); + return Promise.all(results).then((results2) => { + return handleUnionResults(results2, payload, inst, ctx); + }); + }; +}); +const $ZodIntersection = /* @__PURE__ */ $constructor("$ZodIntersection", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload, ctx) => { + const input = payload.value; + const left = def.left._zod.run({ value: input, issues: [] }, ctx); + const right = def.right._zod.run({ value: input, issues: [] }, ctx); + const async = left instanceof Promise || right instanceof Promise; + if (async) { + return Promise.all([left, right]).then(([left2, right2]) => { + return handleIntersectionResults(payload, left2, right2); + }); + } + return handleIntersectionResults(payload, left, right); + }; +}); +function mergeValues(a, b) { + if (a === b) { + return { valid: true, data: a }; + } + if (a instanceof Date && b instanceof Date && +a === +b) { + return { valid: true, data: a }; + } + if (isPlainObject(a) && isPlainObject(b)) { + const bKeys = Object.keys(b); + const sharedKeys = Object.keys(a).filter((key) => bKeys.indexOf(key) !== -1); + const newObj = { ...a, ...b }; + for (const key of sharedKeys) { + const sharedValue = mergeValues(a[key], b[key]); + if (!sharedValue.valid) { + return { + valid: false, + mergeErrorPath: [key, ...sharedValue.mergeErrorPath] + }; + } + newObj[key] = sharedValue.data; + } + return { valid: true, data: newObj }; + } + if (Array.isArray(a) && Array.isArray(b)) { + if (a.length !== b.length) { + return { valid: false, mergeErrorPath: [] }; + } + const newArray = []; + for (let index = 0; index < a.length; index++) { + const itemA = a[index]; + const itemB = b[index]; + const sharedValue = mergeValues(itemA, itemB); + if (!sharedValue.valid) { + return { + valid: false, + mergeErrorPath: [index, ...sharedValue.mergeErrorPath] + }; + } + newArray.push(sharedValue.data); + } + return { valid: true, data: newArray }; + } + return { valid: false, mergeErrorPath: [] }; +} +function handleIntersectionResults(result, left, right) { + if (left.issues.length) { + result.issues.push(...left.issues); + } + if (right.issues.length) { + result.issues.push(...right.issues); + } + if (aborted(result)) + return result; + const merged = mergeValues(left.value, right.value); + if (!merged.valid) { + throw new Error(`Unmergable intersection. Error path: ${JSON.stringify(merged.mergeErrorPath)}`); + } + result.value = merged.data; + return result; +} +const $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => { + $ZodType.init(inst, def); + const values = getEnumValues(def.entries); + inst._zod.values = new Set(values); + inst._zod.pattern = new RegExp(`^(${values.filter((k) => propertyKeyTypes.has(typeof k)).map((o) => typeof o === "string" ? escapeRegex(o) : o.toString()).join("|")})$`); + inst._zod.parse = (payload, _ctx) => { + const input = payload.value; + if (inst._zod.values.has(input)) { + return payload; + } + payload.issues.push({ + code: "invalid_value", + values, + input, + inst + }); + return payload; + }; +}); +const $ZodTransform = /* @__PURE__ */ $constructor("$ZodTransform", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload, _ctx) => { + const _out = def.transform(payload.value, payload); + if (_ctx.async) { + const output = _out instanceof Promise ? _out : Promise.resolve(_out); + return output.then((output2) => { + payload.value = output2; + return payload; + }); + } + if (_out instanceof Promise) { + throw new $ZodAsyncError(); + } + payload.value = _out; + return payload; + }; +}); +const $ZodOptional = /* @__PURE__ */ $constructor("$ZodOptional", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.optin = "optional"; + inst._zod.optout = "optional"; + defineLazy(inst._zod, "values", () => { + return def.innerType._zod.values ? /* @__PURE__ */ new Set([...def.innerType._zod.values, void 0]) : void 0; + }); + defineLazy(inst._zod, "pattern", () => { + const pattern = def.innerType._zod.pattern; + return pattern ? new RegExp(`^(${cleanRegex(pattern.source)})?$`) : void 0; + }); + inst._zod.parse = (payload, ctx) => { + if (def.innerType._zod.optin === "optional") { + return def.innerType._zod.run(payload, ctx); + } + if (payload.value === void 0) { + return payload; + } + return def.innerType._zod.run(payload, ctx); + }; +}); +const $ZodNullable = /* @__PURE__ */ $constructor("$ZodNullable", (inst, def) => { + $ZodType.init(inst, def); + defineLazy(inst._zod, "optin", () => def.innerType._zod.optin); + defineLazy(inst._zod, "optout", () => def.innerType._zod.optout); + defineLazy(inst._zod, "pattern", () => { + const pattern = def.innerType._zod.pattern; + return pattern ? new RegExp(`^(${cleanRegex(pattern.source)}|null)$`) : void 0; + }); + defineLazy(inst._zod, "values", () => { + return def.innerType._zod.values ? /* @__PURE__ */ new Set([...def.innerType._zod.values, null]) : void 0; + }); + inst._zod.parse = (payload, ctx) => { + if (payload.value === null) + return payload; + return def.innerType._zod.run(payload, ctx); + }; +}); +const $ZodDefault = /* @__PURE__ */ $constructor("$ZodDefault", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.optin = "optional"; + defineLazy(inst._zod, "values", () => def.innerType._zod.values); + inst._zod.parse = (payload, ctx) => { + if (payload.value === void 0) { + payload.value = def.defaultValue; + return payload; + } + const result = def.innerType._zod.run(payload, ctx); + if (result instanceof Promise) { + return result.then((result2) => handleDefaultResult(result2, def)); + } + return handleDefaultResult(result, def); + }; +}); +function handleDefaultResult(payload, def) { + if (payload.value === void 0) { + payload.value = def.defaultValue; + } + return payload; +} +const $ZodPrefault = /* @__PURE__ */ $constructor("$ZodPrefault", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.optin = "optional"; + defineLazy(inst._zod, "values", () => def.innerType._zod.values); + inst._zod.parse = (payload, ctx) => { + if (payload.value === void 0) { + payload.value = def.defaultValue; + } + return def.innerType._zod.run(payload, ctx); + }; +}); +const $ZodNonOptional = /* @__PURE__ */ $constructor("$ZodNonOptional", (inst, def) => { + $ZodType.init(inst, def); + defineLazy(inst._zod, "values", () => { + const v = def.innerType._zod.values; + return v ? new Set([...v].filter((x) => x !== void 0)) : void 0; + }); + inst._zod.parse = (payload, ctx) => { + const result = def.innerType._zod.run(payload, ctx); + if (result instanceof Promise) { + return result.then((result2) => handleNonOptionalResult(result2, inst)); + } + return handleNonOptionalResult(result, inst); + }; +}); +function handleNonOptionalResult(payload, inst) { + if (!payload.issues.length && payload.value === void 0) { + payload.issues.push({ + code: "invalid_type", + expected: "nonoptional", + input: payload.value, + inst + }); + } + return payload; +} +const $ZodCatch = /* @__PURE__ */ $constructor("$ZodCatch", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.optin = "optional"; + defineLazy(inst._zod, "optout", () => def.innerType._zod.optout); + defineLazy(inst._zod, "values", () => def.innerType._zod.values); + inst._zod.parse = (payload, ctx) => { + const result = def.innerType._zod.run(payload, ctx); + if (result instanceof Promise) { + return result.then((result2) => { + payload.value = result2.value; + if (result2.issues.length) { + payload.value = def.catchValue({ + ...payload, + error: { + issues: result2.issues.map((iss) => finalizeIssue(iss, ctx, config())) + }, + input: payload.value + }); + payload.issues = []; + } + return payload; + }); + } + payload.value = result.value; + if (result.issues.length) { + payload.value = def.catchValue({ + ...payload, + error: { + issues: result.issues.map((iss) => finalizeIssue(iss, ctx, config())) + }, + input: payload.value + }); + payload.issues = []; + } + return payload; + }; +}); +const $ZodPipe = /* @__PURE__ */ $constructor("$ZodPipe", (inst, def) => { + $ZodType.init(inst, def); + defineLazy(inst._zod, "values", () => def.in._zod.values); + defineLazy(inst._zod, "optin", () => def.in._zod.optin); + defineLazy(inst._zod, "optout", () => def.out._zod.optout); + defineLazy(inst._zod, "propValues", () => def.in._zod.propValues); + inst._zod.parse = (payload, ctx) => { + const left = def.in._zod.run(payload, ctx); + if (left instanceof Promise) { + return left.then((left2) => handlePipeResult(left2, def, ctx)); + } + return handlePipeResult(left, def, ctx); + }; +}); +function handlePipeResult(left, def, ctx) { + if (aborted(left)) { + return left; + } + return def.out._zod.run({ value: left.value, issues: left.issues }, ctx); +} +const $ZodReadonly = /* @__PURE__ */ $constructor("$ZodReadonly", (inst, def) => { + $ZodType.init(inst, def); + defineLazy(inst._zod, "propValues", () => def.innerType._zod.propValues); + defineLazy(inst._zod, "values", () => def.innerType._zod.values); + defineLazy(inst._zod, "optin", () => def.innerType._zod.optin); + defineLazy(inst._zod, "optout", () => def.innerType._zod.optout); + inst._zod.parse = (payload, ctx) => { + const result = def.innerType._zod.run(payload, ctx); + if (result instanceof Promise) { + return result.then(handleReadonlyResult); + } + return handleReadonlyResult(result); + }; +}); +function handleReadonlyResult(payload) { + payload.value = Object.freeze(payload.value); + return payload; +} +const $ZodCustom = /* @__PURE__ */ $constructor("$ZodCustom", (inst, def) => { + $ZodCheck.init(inst, def); + $ZodType.init(inst, def); + inst._zod.parse = (payload, _) => { + return payload; + }; + inst._zod.check = (payload) => { + const input = payload.value; + const r = def.fn(input); + if (r instanceof Promise) { + return r.then((r2) => handleRefineResult(r2, payload, input, inst)); + } + handleRefineResult(r, payload, input, inst); + return; + }; +}); +function handleRefineResult(result, payload, input, inst) { + if (!result) { + const _iss = { + code: "custom", + input, + inst, + // incorporates params.error into issue reporting + path: [...inst._zod.def.path ?? []], + // incorporates params.error into issue reporting + continue: !inst._zod.def.abort + // params: inst._zod.def.params, + }; + if (inst._zod.def.params) + _iss.params = inst._zod.def.params; + payload.issues.push(issue(_iss)); + } +} +class $ZodRegistry { + constructor() { + this._map = /* @__PURE__ */ new Map(); + this._idmap = /* @__PURE__ */ new Map(); + } + add(schema, ..._meta) { + const meta = _meta[0]; + this._map.set(schema, meta); + if (meta && typeof meta === "object" && "id" in meta) { + if (this._idmap.has(meta.id)) { + throw new Error(`ID ${meta.id} already exists in the registry`); + } + this._idmap.set(meta.id, schema); + } + return this; + } + clear() { + this._map = /* @__PURE__ */ new Map(); + this._idmap = /* @__PURE__ */ new Map(); + return this; + } + remove(schema) { + const meta = this._map.get(schema); + if (meta && typeof meta === "object" && "id" in meta) { + this._idmap.delete(meta.id); + } + this._map.delete(schema); + return this; + } + get(schema) { + const p = schema._zod.parent; + if (p) { + const pm = { ...this.get(p) ?? {} }; + delete pm.id; + return { ...pm, ...this._map.get(schema) }; + } + return this._map.get(schema); + } + has(schema) { + return this._map.has(schema); + } +} +function registry() { + return new $ZodRegistry(); +} +const globalRegistry = /* @__PURE__ */ registry(); +function _string(Class, params) { + return new Class({ + type: "string", + ...normalizeParams(params) + }); +} +function _email(Class, params) { + return new Class({ + type: "string", + format: "email", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +function _guid(Class, params) { + return new Class({ + type: "string", + format: "guid", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +function _uuid(Class, params) { + return new Class({ + type: "string", + format: "uuid", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +function _uuidv4(Class, params) { + return new Class({ + type: "string", + format: "uuid", + check: "string_format", + abort: false, + version: "v4", + ...normalizeParams(params) + }); +} +function _uuidv6(Class, params) { + return new Class({ + type: "string", + format: "uuid", + check: "string_format", + abort: false, + version: "v6", + ...normalizeParams(params) + }); +} +function _uuidv7(Class, params) { + return new Class({ + type: "string", + format: "uuid", + check: "string_format", + abort: false, + version: "v7", + ...normalizeParams(params) + }); +} +function _url(Class, params) { + return new Class({ + type: "string", + format: "url", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +function _emoji(Class, params) { + return new Class({ + type: "string", + format: "emoji", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +function _nanoid(Class, params) { + return new Class({ + type: "string", + format: "nanoid", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +function _cuid(Class, params) { + return new Class({ + type: "string", + format: "cuid", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +function _cuid2(Class, params) { + return new Class({ + type: "string", + format: "cuid2", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +function _ulid(Class, params) { + return new Class({ + type: "string", + format: "ulid", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +function _xid(Class, params) { + return new Class({ + type: "string", + format: "xid", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +function _ksuid(Class, params) { + return new Class({ + type: "string", + format: "ksuid", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +function _ipv4(Class, params) { + return new Class({ + type: "string", + format: "ipv4", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +function _ipv6(Class, params) { + return new Class({ + type: "string", + format: "ipv6", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +function _cidrv4(Class, params) { + return new Class({ + type: "string", + format: "cidrv4", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +function _cidrv6(Class, params) { + return new Class({ + type: "string", + format: "cidrv6", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +function _base64(Class, params) { + return new Class({ + type: "string", + format: "base64", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +function _base64url(Class, params) { + return new Class({ + type: "string", + format: "base64url", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +function _e164(Class, params) { + return new Class({ + type: "string", + format: "e164", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +function _jwt(Class, params) { + return new Class({ + type: "string", + format: "jwt", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +function _isoDateTime(Class, params) { + return new Class({ + type: "string", + format: "datetime", + check: "string_format", + offset: false, + local: false, + precision: null, + ...normalizeParams(params) + }); +} +function _isoDate(Class, params) { + return new Class({ + type: "string", + format: "date", + check: "string_format", + ...normalizeParams(params) + }); +} +function _isoTime(Class, params) { + return new Class({ + type: "string", + format: "time", + check: "string_format", + precision: null, + ...normalizeParams(params) + }); +} +function _isoDuration(Class, params) { + return new Class({ + type: "string", + format: "duration", + check: "string_format", + ...normalizeParams(params) + }); +} +function _any(Class) { + return new Class({ + type: "any" + }); +} +function _unknown(Class) { + return new Class({ + type: "unknown" + }); +} +function _never(Class, params) { + return new Class({ + type: "never", + ...normalizeParams(params) + }); +} +function _maxLength(maximum, params) { + const ch = new $ZodCheckMaxLength({ + check: "max_length", + ...normalizeParams(params), + maximum + }); + return ch; +} +function _minLength(minimum, params) { + return new $ZodCheckMinLength({ + check: "min_length", + ...normalizeParams(params), + minimum + }); +} +function _length(length, params) { + return new $ZodCheckLengthEquals({ + check: "length_equals", + ...normalizeParams(params), + length + }); +} +function _regex(pattern, params) { + return new $ZodCheckRegex({ + check: "string_format", + format: "regex", + ...normalizeParams(params), + pattern + }); +} +function _lowercase(params) { + return new $ZodCheckLowerCase({ + check: "string_format", + format: "lowercase", + ...normalizeParams(params) + }); +} +function _uppercase(params) { + return new $ZodCheckUpperCase({ + check: "string_format", + format: "uppercase", + ...normalizeParams(params) + }); +} +function _includes(includes, params) { + return new $ZodCheckIncludes({ + check: "string_format", + format: "includes", + ...normalizeParams(params), + includes + }); +} +function _startsWith(prefix, params) { + return new $ZodCheckStartsWith({ + check: "string_format", + format: "starts_with", + ...normalizeParams(params), + prefix + }); +} +function _endsWith(suffix, params) { + return new $ZodCheckEndsWith({ + check: "string_format", + format: "ends_with", + ...normalizeParams(params), + suffix + }); +} +function _overwrite(tx) { + return new $ZodCheckOverwrite({ + check: "overwrite", + tx + }); +} +function _normalize(form) { + return _overwrite((input) => input.normalize(form)); +} +function _trim() { + return _overwrite((input) => input.trim()); +} +function _toLowerCase() { + return _overwrite((input) => input.toLowerCase()); +} +function _toUpperCase() { + return _overwrite((input) => input.toUpperCase()); +} +function _array(Class, element, params) { + return new Class({ + type: "array", + element, + // get element() { + // return element; + // }, + ...normalizeParams(params) + }); +} +function _refine(Class, fn, _params) { + const schema = new Class({ + type: "custom", + check: "custom", + fn, + ...normalizeParams(_params) + }); + return schema; +} +const ZodISODateTime = /* @__PURE__ */ $constructor("ZodISODateTime", (inst, def) => { + $ZodISODateTime.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function datetime(params) { + return _isoDateTime(ZodISODateTime, params); +} +const ZodISODate = /* @__PURE__ */ $constructor("ZodISODate", (inst, def) => { + $ZodISODate.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function date(params) { + return _isoDate(ZodISODate, params); +} +const ZodISOTime = /* @__PURE__ */ $constructor("ZodISOTime", (inst, def) => { + $ZodISOTime.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function time(params) { + return _isoTime(ZodISOTime, params); +} +const ZodISODuration = /* @__PURE__ */ $constructor("ZodISODuration", (inst, def) => { + $ZodISODuration.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function duration(params) { + return _isoDuration(ZodISODuration, params); +} +const initializer = (inst, issues) => { + $ZodError.init(inst, issues); + inst.name = "ZodError"; + Object.defineProperties(inst, { + format: { + value: (mapper) => formatError(inst, mapper) + // enumerable: false, + }, + flatten: { + value: (mapper) => flattenError(inst, mapper) + // enumerable: false, + }, + addIssue: { + value: (issue2) => inst.issues.push(issue2) + // enumerable: false, + }, + addIssues: { + value: (issues2) => inst.issues.push(...issues2) + // enumerable: false, + }, + isEmpty: { + get() { + return inst.issues.length === 0; + } + // enumerable: false, + } + }); +}; +const ZodRealError = $constructor("ZodError", initializer, { + Parent: Error +}); +const parse = /* @__PURE__ */ _parse(ZodRealError); +const parseAsync = /* @__PURE__ */ _parseAsync(ZodRealError); +const safeParse = /* @__PURE__ */ _safeParse(ZodRealError); +const safeParseAsync = /* @__PURE__ */ _safeParseAsync(ZodRealError); +const ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => { + $ZodType.init(inst, def); + inst.def = def; + Object.defineProperty(inst, "_def", { value: def }); + inst.check = (...checks) => { + return inst.clone( + { + ...def, + checks: [ + ...def.checks ?? [], + ...checks.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch) + ] + } + // { parent: true } + ); + }; + inst.clone = (def2, params) => clone(inst, def2, params); + inst.brand = () => inst; + inst.register = (reg, meta) => { + reg.add(inst, meta); + return inst; + }; + inst.parse = (data, params) => parse(inst, data, params, { callee: inst.parse }); + inst.safeParse = (data, params) => safeParse(inst, data, params); + inst.parseAsync = async (data, params) => parseAsync(inst, data, params, { callee: inst.parseAsync }); + inst.safeParseAsync = async (data, params) => safeParseAsync(inst, data, params); + inst.spa = inst.safeParseAsync; + inst.refine = (check2, params) => inst.check(refine(check2, params)); + inst.superRefine = (refinement) => inst.check(superRefine(refinement)); + inst.overwrite = (fn) => inst.check(_overwrite(fn)); + inst.optional = () => optional(inst); + inst.nullable = () => nullable(inst); + inst.nullish = () => optional(nullable(inst)); + inst.nonoptional = (params) => nonoptional(inst, params); + inst.array = () => array(inst); + inst.or = (arg) => union([inst, arg]); + inst.and = (arg) => intersection(inst, arg); + inst.transform = (tx) => pipe(inst, transform(tx)); + inst.default = (def2) => _default(inst, def2); + inst.prefault = (def2) => prefault(inst, def2); + inst.catch = (params) => _catch(inst, params); + inst.pipe = (target) => pipe(inst, target); + inst.readonly = () => readonly(inst); + inst.describe = (description) => { + const cl = inst.clone(); + globalRegistry.add(cl, { description }); + return cl; + }; + Object.defineProperty(inst, "description", { + get() { + return globalRegistry.get(inst)?.description; + }, + configurable: true + }); + inst.meta = (...args) => { + if (args.length === 0) { + return globalRegistry.get(inst); + } + const cl = inst.clone(); + globalRegistry.add(cl, args[0]); + return cl; + }; + inst.isOptional = () => inst.safeParse(void 0).success; + inst.isNullable = () => inst.safeParse(null).success; + return inst; +}); +const _ZodString = /* @__PURE__ */ $constructor("_ZodString", (inst, def) => { + $ZodString.init(inst, def); + ZodType.init(inst, def); + const bag = inst._zod.bag; + inst.format = bag.format ?? null; + inst.minLength = bag.minimum ?? null; + inst.maxLength = bag.maximum ?? null; + inst.regex = (...args) => inst.check(_regex(...args)); + inst.includes = (...args) => inst.check(_includes(...args)); + inst.startsWith = (...args) => inst.check(_startsWith(...args)); + inst.endsWith = (...args) => inst.check(_endsWith(...args)); + inst.min = (...args) => inst.check(_minLength(...args)); + inst.max = (...args) => inst.check(_maxLength(...args)); + inst.length = (...args) => inst.check(_length(...args)); + inst.nonempty = (...args) => inst.check(_minLength(1, ...args)); + inst.lowercase = (params) => inst.check(_lowercase(params)); + inst.uppercase = (params) => inst.check(_uppercase(params)); + inst.trim = () => inst.check(_trim()); + inst.normalize = (...args) => inst.check(_normalize(...args)); + inst.toLowerCase = () => inst.check(_toLowerCase()); + inst.toUpperCase = () => inst.check(_toUpperCase()); +}); +const ZodString = /* @__PURE__ */ $constructor("ZodString", (inst, def) => { + $ZodString.init(inst, def); + _ZodString.init(inst, def); + inst.email = (params) => inst.check(_email(ZodEmail, params)); + inst.url = (params) => inst.check(_url(ZodURL, params)); + inst.jwt = (params) => inst.check(_jwt(ZodJWT, params)); + inst.emoji = (params) => inst.check(_emoji(ZodEmoji, params)); + inst.guid = (params) => inst.check(_guid(ZodGUID, params)); + inst.uuid = (params) => inst.check(_uuid(ZodUUID, params)); + inst.uuidv4 = (params) => inst.check(_uuidv4(ZodUUID, params)); + inst.uuidv6 = (params) => inst.check(_uuidv6(ZodUUID, params)); + inst.uuidv7 = (params) => inst.check(_uuidv7(ZodUUID, params)); + inst.nanoid = (params) => inst.check(_nanoid(ZodNanoID, params)); + inst.guid = (params) => inst.check(_guid(ZodGUID, params)); + inst.cuid = (params) => inst.check(_cuid(ZodCUID, params)); + inst.cuid2 = (params) => inst.check(_cuid2(ZodCUID2, params)); + inst.ulid = (params) => inst.check(_ulid(ZodULID, params)); + inst.base64 = (params) => inst.check(_base64(ZodBase64, params)); + inst.base64url = (params) => inst.check(_base64url(ZodBase64URL, params)); + inst.xid = (params) => inst.check(_xid(ZodXID, params)); + inst.ksuid = (params) => inst.check(_ksuid(ZodKSUID, params)); + inst.ipv4 = (params) => inst.check(_ipv4(ZodIPv4, params)); + inst.ipv6 = (params) => inst.check(_ipv6(ZodIPv6, params)); + inst.cidrv4 = (params) => inst.check(_cidrv4(ZodCIDRv4, params)); + inst.cidrv6 = (params) => inst.check(_cidrv6(ZodCIDRv6, params)); + inst.e164 = (params) => inst.check(_e164(ZodE164, params)); + inst.datetime = (params) => inst.check(datetime(params)); + inst.date = (params) => inst.check(date(params)); + inst.time = (params) => inst.check(time(params)); + inst.duration = (params) => inst.check(duration(params)); +}); +function string(params) { + return _string(ZodString, params); +} +const ZodStringFormat = /* @__PURE__ */ $constructor("ZodStringFormat", (inst, def) => { + $ZodStringFormat.init(inst, def); + _ZodString.init(inst, def); +}); +const ZodEmail = /* @__PURE__ */ $constructor("ZodEmail", (inst, def) => { + $ZodEmail.init(inst, def); + ZodStringFormat.init(inst, def); +}); +const ZodGUID = /* @__PURE__ */ $constructor("ZodGUID", (inst, def) => { + $ZodGUID.init(inst, def); + ZodStringFormat.init(inst, def); +}); +const ZodUUID = /* @__PURE__ */ $constructor("ZodUUID", (inst, def) => { + $ZodUUID.init(inst, def); + ZodStringFormat.init(inst, def); +}); +const ZodURL = /* @__PURE__ */ $constructor("ZodURL", (inst, def) => { + $ZodURL.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function url(params) { + return _url(ZodURL, params); +} +const ZodEmoji = /* @__PURE__ */ $constructor("ZodEmoji", (inst, def) => { + $ZodEmoji.init(inst, def); + ZodStringFormat.init(inst, def); +}); +const ZodNanoID = /* @__PURE__ */ $constructor("ZodNanoID", (inst, def) => { + $ZodNanoID.init(inst, def); + ZodStringFormat.init(inst, def); +}); +const ZodCUID = /* @__PURE__ */ $constructor("ZodCUID", (inst, def) => { + $ZodCUID.init(inst, def); + ZodStringFormat.init(inst, def); +}); +const ZodCUID2 = /* @__PURE__ */ $constructor("ZodCUID2", (inst, def) => { + $ZodCUID2.init(inst, def); + ZodStringFormat.init(inst, def); +}); +const ZodULID = /* @__PURE__ */ $constructor("ZodULID", (inst, def) => { + $ZodULID.init(inst, def); + ZodStringFormat.init(inst, def); +}); +const ZodXID = /* @__PURE__ */ $constructor("ZodXID", (inst, def) => { + $ZodXID.init(inst, def); + ZodStringFormat.init(inst, def); +}); +const ZodKSUID = /* @__PURE__ */ $constructor("ZodKSUID", (inst, def) => { + $ZodKSUID.init(inst, def); + ZodStringFormat.init(inst, def); +}); +const ZodIPv4 = /* @__PURE__ */ $constructor("ZodIPv4", (inst, def) => { + $ZodIPv4.init(inst, def); + ZodStringFormat.init(inst, def); +}); +const ZodIPv6 = /* @__PURE__ */ $constructor("ZodIPv6", (inst, def) => { + $ZodIPv6.init(inst, def); + ZodStringFormat.init(inst, def); +}); +const ZodCIDRv4 = /* @__PURE__ */ $constructor("ZodCIDRv4", (inst, def) => { + $ZodCIDRv4.init(inst, def); + ZodStringFormat.init(inst, def); +}); +const ZodCIDRv6 = /* @__PURE__ */ $constructor("ZodCIDRv6", (inst, def) => { + $ZodCIDRv6.init(inst, def); + ZodStringFormat.init(inst, def); +}); +const ZodBase64 = /* @__PURE__ */ $constructor("ZodBase64", (inst, def) => { + $ZodBase64.init(inst, def); + ZodStringFormat.init(inst, def); +}); +const ZodBase64URL = /* @__PURE__ */ $constructor("ZodBase64URL", (inst, def) => { + $ZodBase64URL.init(inst, def); + ZodStringFormat.init(inst, def); +}); +const ZodE164 = /* @__PURE__ */ $constructor("ZodE164", (inst, def) => { + $ZodE164.init(inst, def); + ZodStringFormat.init(inst, def); +}); +const ZodJWT = /* @__PURE__ */ $constructor("ZodJWT", (inst, def) => { + $ZodJWT.init(inst, def); + ZodStringFormat.init(inst, def); +}); +const ZodAny = /* @__PURE__ */ $constructor("ZodAny", (inst, def) => { + $ZodAny.init(inst, def); + ZodType.init(inst, def); +}); +function any() { + return _any(ZodAny); +} +const ZodUnknown = /* @__PURE__ */ $constructor("ZodUnknown", (inst, def) => { + $ZodUnknown.init(inst, def); + ZodType.init(inst, def); +}); +function unknown() { + return _unknown(ZodUnknown); +} +const ZodNever = /* @__PURE__ */ $constructor("ZodNever", (inst, def) => { + $ZodNever.init(inst, def); + ZodType.init(inst, def); +}); +function never(params) { + return _never(ZodNever, params); +} +const ZodArray = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => { + $ZodArray.init(inst, def); + ZodType.init(inst, def); + inst.element = def.element; + inst.min = (minLength, params) => inst.check(_minLength(minLength, params)); + inst.nonempty = (params) => inst.check(_minLength(1, params)); + inst.max = (maxLength, params) => inst.check(_maxLength(maxLength, params)); + inst.length = (len, params) => inst.check(_length(len, params)); + inst.unwrap = () => inst.element; +}); +function array(element, params) { + return _array(ZodArray, element, params); +} +const ZodObject = /* @__PURE__ */ $constructor("ZodObject", (inst, def) => { + $ZodObject.init(inst, def); + ZodType.init(inst, def); + defineLazy(inst, "shape", () => def.shape); + inst.keyof = () => _enum(Object.keys(inst._zod.def.shape)); + inst.catchall = (catchall) => inst.clone({ ...inst._zod.def, catchall }); + inst.passthrough = () => inst.clone({ ...inst._zod.def, catchall: unknown() }); + inst.loose = () => inst.clone({ ...inst._zod.def, catchall: unknown() }); + inst.strict = () => inst.clone({ ...inst._zod.def, catchall: never() }); + inst.strip = () => inst.clone({ ...inst._zod.def, catchall: void 0 }); + inst.extend = (incoming) => { + return extend(inst, incoming); + }; + inst.merge = (other) => merge(inst, other); + inst.pick = (mask) => pick(inst, mask); + inst.omit = (mask) => omit(inst, mask); + inst.partial = (...args) => partial(ZodOptional, inst, args[0]); + inst.required = (...args) => required(ZodNonOptional, inst, args[0]); +}); +function object(shape, params) { + const def = { + type: "object", + get shape() { + assignProp(this, "shape", { ...shape }); + return this.shape; + }, + ...normalizeParams(params) + }; + return new ZodObject(def); +} +const ZodUnion = /* @__PURE__ */ $constructor("ZodUnion", (inst, def) => { + $ZodUnion.init(inst, def); + ZodType.init(inst, def); + inst.options = def.options; +}); +function union(options, params) { + return new ZodUnion({ + type: "union", + options, + ...normalizeParams(params) + }); +} +const ZodIntersection = /* @__PURE__ */ $constructor("ZodIntersection", (inst, def) => { + $ZodIntersection.init(inst, def); + ZodType.init(inst, def); +}); +function intersection(left, right) { + return new ZodIntersection({ + type: "intersection", + left, + right + }); +} +const ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => { + $ZodEnum.init(inst, def); + ZodType.init(inst, def); + inst.enum = def.entries; + inst.options = Object.values(def.entries); + const keys2 = new Set(Object.keys(def.entries)); + inst.extract = (values, params) => { + const newEntries = {}; + for (const value of values) { + if (keys2.has(value)) { + newEntries[value] = def.entries[value]; + } else + throw new Error(`Key ${value} not found in enum`); + } + return new ZodEnum({ + ...def, + checks: [], + ...normalizeParams(params), + entries: newEntries + }); + }; + inst.exclude = (values, params) => { + const newEntries = { ...def.entries }; + for (const value of values) { + if (keys2.has(value)) { + delete newEntries[value]; + } else + throw new Error(`Key ${value} not found in enum`); + } + return new ZodEnum({ + ...def, + checks: [], + ...normalizeParams(params), + entries: newEntries + }); + }; +}); +function _enum(values, params) { + const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values; + return new ZodEnum({ + type: "enum", + entries, + ...normalizeParams(params) + }); +} +const ZodTransform = /* @__PURE__ */ $constructor("ZodTransform", (inst, def) => { + $ZodTransform.init(inst, def); + ZodType.init(inst, def); + inst._zod.parse = (payload, _ctx) => { + payload.addIssue = (issue$1) => { + if (typeof issue$1 === "string") { + payload.issues.push(issue(issue$1, payload.value, def)); + } else { + const _issue = issue$1; + if (_issue.fatal) + _issue.continue = false; + _issue.code ?? (_issue.code = "custom"); + _issue.input ?? (_issue.input = payload.value); + _issue.inst ?? (_issue.inst = inst); + _issue.continue ?? (_issue.continue = true); + payload.issues.push(issue(_issue)); + } + }; + const output = def.transform(payload.value, payload); + if (output instanceof Promise) { + return output.then((output2) => { + payload.value = output2; + return payload; + }); + } + payload.value = output; + return payload; + }; +}); +function transform(fn) { + return new ZodTransform({ + type: "transform", + transform: fn + }); +} +const ZodOptional = /* @__PURE__ */ $constructor("ZodOptional", (inst, def) => { + $ZodOptional.init(inst, def); + ZodType.init(inst, def); + inst.unwrap = () => inst._zod.def.innerType; +}); +function optional(innerType) { + return new ZodOptional({ + type: "optional", + innerType + }); +} +const ZodNullable = /* @__PURE__ */ $constructor("ZodNullable", (inst, def) => { + $ZodNullable.init(inst, def); + ZodType.init(inst, def); + inst.unwrap = () => inst._zod.def.innerType; +}); +function nullable(innerType) { + return new ZodNullable({ + type: "nullable", + innerType + }); +} +const ZodDefault = /* @__PURE__ */ $constructor("ZodDefault", (inst, def) => { + $ZodDefault.init(inst, def); + ZodType.init(inst, def); + inst.unwrap = () => inst._zod.def.innerType; + inst.removeDefault = inst.unwrap; +}); +function _default(innerType, defaultValue) { + return new ZodDefault({ + type: "default", + innerType, + get defaultValue() { + return typeof defaultValue === "function" ? defaultValue() : defaultValue; + } + }); +} +const ZodPrefault = /* @__PURE__ */ $constructor("ZodPrefault", (inst, def) => { + $ZodPrefault.init(inst, def); + ZodType.init(inst, def); + inst.unwrap = () => inst._zod.def.innerType; +}); +function prefault(innerType, defaultValue) { + return new ZodPrefault({ + type: "prefault", + innerType, + get defaultValue() { + return typeof defaultValue === "function" ? defaultValue() : defaultValue; + } + }); +} +const ZodNonOptional = /* @__PURE__ */ $constructor("ZodNonOptional", (inst, def) => { + $ZodNonOptional.init(inst, def); + ZodType.init(inst, def); + inst.unwrap = () => inst._zod.def.innerType; +}); +function nonoptional(innerType, params) { + return new ZodNonOptional({ + type: "nonoptional", + innerType, + ...normalizeParams(params) + }); +} +const ZodCatch = /* @__PURE__ */ $constructor("ZodCatch", (inst, def) => { + $ZodCatch.init(inst, def); + ZodType.init(inst, def); + inst.unwrap = () => inst._zod.def.innerType; + inst.removeCatch = inst.unwrap; +}); +function _catch(innerType, catchValue) { + return new ZodCatch({ + type: "catch", + innerType, + catchValue: typeof catchValue === "function" ? catchValue : () => catchValue + }); +} +const ZodPipe = /* @__PURE__ */ $constructor("ZodPipe", (inst, def) => { + $ZodPipe.init(inst, def); + ZodType.init(inst, def); + inst.in = def.in; + inst.out = def.out; +}); +function pipe(in_, out) { + return new ZodPipe({ + type: "pipe", + in: in_, + out + // ...util.normalizeParams(params), + }); +} +const ZodReadonly = /* @__PURE__ */ $constructor("ZodReadonly", (inst, def) => { + $ZodReadonly.init(inst, def); + ZodType.init(inst, def); +}); +function readonly(innerType) { + return new ZodReadonly({ + type: "readonly", + innerType + }); +} +const ZodCustom = /* @__PURE__ */ $constructor("ZodCustom", (inst, def) => { + $ZodCustom.init(inst, def); + ZodType.init(inst, def); +}); +function check(fn) { + const ch = new $ZodCheck({ + check: "custom" + // ...util.normalizeParams(params), + }); + ch._zod.check = fn; + return ch; +} +function refine(fn, _params = {}) { + return _refine(ZodCustom, fn, _params); +} +function superRefine(fn) { + const ch = check((payload) => { + payload.addIssue = (issue$1) => { + if (typeof issue$1 === "string") { + payload.issues.push(issue(issue$1, payload.value, ch._zod.def)); + } else { + const _issue = issue$1; + if (_issue.fatal) + _issue.continue = false; + _issue.code ?? (_issue.code = "custom"); + _issue.input ?? (_issue.input = payload.value); + _issue.inst ?? (_issue.inst = ch); + _issue.continue ?? (_issue.continue = !ch._zod.def.abort); + payload.issues.push(issue(_issue)); + } + }; + return fn(payload.value, payload); + }); + return ch; +} +const configArgsSchema = object({ + beaconchainUrl: url(), + publicClient: any().refine((val) => !!val, { message: "Public client must be provided" }).refine((val) => typeof val === "object" && val !== null && "chain" in val, { + message: "Public client must have a chain property" + }), + walletClient: any().refine((val) => !!val, { message: "Wallet client must be provided" }).refine((val) => typeof val === "object" && val !== null && "chain" in val, { + message: "Wallet client must have a chain property" + }), + extendedConfig: object({ + subgraph: object({ + url: url().optional(), + apiKey: string().optional() + }).optional(), + contract: string().optional() + }).optional() +}).refine( + (val) => { + const publicClient = val.publicClient; + const walletClient = val.walletClient; + return publicClient?.chain?.id === walletClient?.chain?.id; + }, + { + message: "Public and wallet client chains must be the same" + } +); +const bigintMax = (...args) => { + return args.filter((x) => !isUndefined(x)).reduce((max, cur) => cur > max ? cur : max); +}; +const bigintMin = (...args) => { + return args.filter((x) => !isUndefined(x)).reduce((min, cur) => cur < min ? cur : min); +}; +const bigintRound = (value, precision) => { + const remainder = value % precision; + return remainder >= precision / 2n ? value + (precision - remainder) : value - remainder; +}; +const bigintFloor = (value, precision = 10000000n) => { + return value - value % precision; +}; +const bigintAbs = (n) => n < 0n ? -n : n; +const isBigIntChanged = (a, b, tolerance = viem.parseUnits("0.0001", 18)) => { + return bigintAbs(a - b) > tolerance; +}; +const roundOperatorFee = (fee, precision = 10000000n) => { + return bigintRound(fee, precision); +}; +const stringifyBigints = (anything) => { + return cloneDeepWith(anything, (value) => { + if (typeof value === "bigint") return value.toString(); + }); +}; +const bigintifyNumbers = (numbers) => { + return cloneDeepWith(numbers, (value) => { + if (typeof value === "number") return BigInt(value); + }); +}; +const tryCatch = (fn) => { + try { + return [fn(), null]; + } catch (e) { + return [null, e]; + } +}; +exports.Stack = Stack; +exports.arrayLikeKeys = arrayLikeKeys; +exports.assignValue = assignValue; +exports.baseAssignValue = baseAssignValue; +exports.baseGetTag = baseGetTag; +exports.bigintAbs = bigintAbs; +exports.bigintFloor = bigintFloor; +exports.bigintMax = bigintMax; +exports.bigintMin = bigintMin; +exports.bigintRound = bigintRound; +exports.bigintifyNumbers = bigintifyNumbers; +exports.cloneBuffer = cloneBuffer; +exports.cloneTypedArray = cloneTypedArray; +exports.configArgsSchema = configArgsSchema; +exports.defineProperty = defineProperty; +exports.eq = eq; +exports.getPrototype = getPrototype; +exports.initCloneObject = initCloneObject; +exports.isArguments = isArguments; +exports.isArray = isArray; +exports.isArrayLike = isArrayLike; +exports.isBigIntChanged = isBigIntChanged; +exports.isBuffer = isBuffer; +exports.isFunction = isFunction; +exports.isIndex = isIndex; +exports.isObject = isObject$1; +exports.isObjectLike = isObjectLike; +exports.isPrototype = isPrototype; +exports.isTypedArray = isTypedArray; +exports.isUndefined = isUndefined; +exports.roundOperatorFee = roundOperatorFee; +exports.stringifyBigints = stringifyBigints; +exports.tryCatch = tryCatch; diff --git a/dist/utils.cjs b/dist/utils.cjs new file mode 100644 index 0000000..7a69c1d --- /dev/null +++ b/dist/utils.cjs @@ -0,0 +1,461 @@ +"use strict"; +Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" }); +const tryCatch = require("./try-catch-CAXuSatr.cjs"); +const viem = require("viem"); +function identity(value) { + return value; +} +function apply(func, thisArg, args) { + switch (args.length) { + case 0: + return func.call(thisArg); + case 1: + return func.call(thisArg, args[0]); + case 2: + return func.call(thisArg, args[0], args[1]); + case 3: + return func.call(thisArg, args[0], args[1], args[2]); + } + return func.apply(thisArg, args); +} +function copyArray(source, array) { + var index = -1, length = source.length; + array || (array = Array(length)); + while (++index < length) { + array[index] = source[index]; + } + return array; +} +var HOT_COUNT = 800, HOT_SPAN = 16; +var nativeNow = Date.now; +function shortOut(func) { + var count = 0, lastCalled = 0; + return function() { + var stamp = nativeNow(), remaining = HOT_SPAN - (stamp - lastCalled); + lastCalled = stamp; + if (remaining > 0) { + if (++count >= HOT_COUNT) { + return arguments[0]; + } + } else { + count = 0; + } + return func.apply(void 0, arguments); + }; +} +function constant(value) { + return function() { + return value; + }; +} +var baseSetToString = !tryCatch.defineProperty ? identity : function(func, string) { + return tryCatch.defineProperty(func, "toString", { + "configurable": true, + "enumerable": false, + "value": constant(string), + "writable": true + }); +}; +var setToString = shortOut(baseSetToString); +function copyObject(source, props, object, customizer) { + var isNew = !object; + object || (object = {}); + var index = -1, length = props.length; + while (++index < length) { + var key = props[index]; + var newValue = void 0; + if (newValue === void 0) { + newValue = source[key]; + } + if (isNew) { + tryCatch.baseAssignValue(object, key, newValue); + } else { + tryCatch.assignValue(object, key, newValue); + } + } + return object; +} +var nativeMax = Math.max; +function overRest(func, start, transform) { + start = nativeMax(start === void 0 ? func.length - 1 : start, 0); + return function() { + var args = arguments, index = -1, length = nativeMax(args.length - start, 0), array = Array(length); + while (++index < length) { + array[index] = args[start + index]; + } + index = -1; + var otherArgs = Array(start + 1); + while (++index < start) { + otherArgs[index] = args[index]; + } + otherArgs[start] = transform(array); + return apply(func, this, otherArgs); + }; +} +function baseRest(func, start) { + return setToString(overRest(func, start, identity), func + ""); +} +function isIterateeCall(value, index, object) { + if (!tryCatch.isObject(object)) { + return false; + } + var type = typeof index; + if (type == "number" ? tryCatch.isArrayLike(object) && tryCatch.isIndex(index, object.length) : type == "string" && index in object) { + return tryCatch.eq(object[index], value); + } + return false; +} +function createAssigner(assigner) { + return baseRest(function(object, sources) { + var index = -1, length = sources.length, customizer = length > 1 ? sources[length - 1] : void 0, guard = length > 2 ? sources[2] : void 0; + customizer = assigner.length > 3 && typeof customizer == "function" ? (length--, customizer) : void 0; + if (guard && isIterateeCall(sources[0], sources[1], guard)) { + customizer = length < 3 ? void 0 : customizer; + length = 1; + } + object = Object(object); + while (++index < length) { + var source = sources[index]; + if (source) { + assigner(object, source, index, customizer); + } + } + return object; + }); +} +function nativeKeysIn(object) { + var result = []; + if (object != null) { + for (var key in Object(object)) { + result.push(key); + } + } + return result; +} +var objectProto$1 = Object.prototype; +var hasOwnProperty$1 = objectProto$1.hasOwnProperty; +function baseKeysIn(object) { + if (!tryCatch.isObject(object)) { + return nativeKeysIn(object); + } + var isProto = tryCatch.isPrototype(object), result = []; + for (var key in object) { + if (!(key == "constructor" && (isProto || !hasOwnProperty$1.call(object, key)))) { + result.push(key); + } + } + return result; +} +function keysIn(object) { + return tryCatch.isArrayLike(object) ? tryCatch.arrayLikeKeys(object, true) : baseKeysIn(object); +} +var objectTag = "[object Object]"; +var funcProto = Function.prototype, objectProto = Object.prototype; +var funcToString = funcProto.toString; +var hasOwnProperty = objectProto.hasOwnProperty; +var objectCtorString = funcToString.call(Object); +function isPlainObject(value) { + if (!tryCatch.isObjectLike(value) || tryCatch.baseGetTag(value) != objectTag) { + return false; + } + var proto = tryCatch.getPrototype(value); + if (proto === null) { + return true; + } + var Ctor = hasOwnProperty.call(proto, "constructor") && proto.constructor; + return typeof Ctor == "function" && Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString; +} +function createBaseFor(fromRight) { + return function(object, iteratee, keysFunc) { + var index = -1, iterable = Object(object), props = keysFunc(object), length = props.length; + while (length--) { + var key = props[++index]; + if (iteratee(iterable[key], key, iterable) === false) { + break; + } + } + return object; + }; +} +var baseFor = createBaseFor(); +function assignMergeValue(object, key, value) { + if (value !== void 0 && !tryCatch.eq(object[key], value) || value === void 0 && !(key in object)) { + tryCatch.baseAssignValue(object, key, value); + } +} +function isArrayLikeObject(value) { + return tryCatch.isObjectLike(value) && tryCatch.isArrayLike(value); +} +function safeGet(object, key) { + if (key === "constructor" && typeof object[key] === "function") { + return; + } + if (key == "__proto__") { + return; + } + return object[key]; +} +function toPlainObject(value) { + return copyObject(value, keysIn(value)); +} +function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) { + var objValue = safeGet(object, key), srcValue = safeGet(source, key), stacked = stack.get(srcValue); + if (stacked) { + assignMergeValue(object, key, stacked); + return; + } + var newValue = customizer ? customizer(objValue, srcValue, key + "", object, source, stack) : void 0; + var isCommon = newValue === void 0; + if (isCommon) { + var isArr = tryCatch.isArray(srcValue), isBuff = !isArr && tryCatch.isBuffer(srcValue), isTyped = !isArr && !isBuff && tryCatch.isTypedArray(srcValue); + newValue = srcValue; + if (isArr || isBuff || isTyped) { + if (tryCatch.isArray(objValue)) { + newValue = objValue; + } else if (isArrayLikeObject(objValue)) { + newValue = copyArray(objValue); + } else if (isBuff) { + isCommon = false; + newValue = tryCatch.cloneBuffer(srcValue, true); + } else if (isTyped) { + isCommon = false; + newValue = tryCatch.cloneTypedArray(srcValue, true); + } else { + newValue = []; + } + } else if (isPlainObject(srcValue) || tryCatch.isArguments(srcValue)) { + newValue = objValue; + if (tryCatch.isArguments(objValue)) { + newValue = toPlainObject(objValue); + } else if (!tryCatch.isObject(objValue) || tryCatch.isFunction(objValue)) { + newValue = tryCatch.initCloneObject(srcValue); + } + } else { + isCommon = false; + } + } + if (isCommon) { + stack.set(srcValue, newValue); + mergeFunc(newValue, srcValue, srcIndex, customizer, stack); + stack["delete"](srcValue); + } + assignMergeValue(object, key, newValue); +} +function baseMerge(object, source, srcIndex, customizer, stack) { + if (object === source) { + return; + } + baseFor(source, function(srcValue, key) { + stack || (stack = new tryCatch.Stack()); + if (tryCatch.isObject(srcValue)) { + baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack); + } else { + var newValue = customizer ? customizer(safeGet(object, key), srcValue, key + "", object, source, stack) : void 0; + if (newValue === void 0) { + newValue = srcValue; + } + assignMergeValue(object, key, newValue); + } + }, keysIn); +} +var merge = createAssigner(function(object, source, srcIndex) { + baseMerge(object, source, srcIndex); +}); +const createClusterId = (ownerAddress, operatorIds) => { + if (!viem.isAddress(ownerAddress)) { + throw new Error("Invalid owner address"); + } + return `${ownerAddress.toLowerCase()}-${operatorIds.join("-")}`; +}; +const isClusterId = (clusterId) => { + const [ownerAddress, ...operatorIds] = clusterId.split("-"); + return viem.isAddress(ownerAddress) && operatorIds.length >= 4 && operatorIds.every((id) => !isNaN(Number(id))); +}; +const createEmptyCluster = (cluster = {}) => merge( + { + validatorCount: 0, + networkFeeIndex: 0n, + index: 0n, + balance: 0n, + active: true + }, + cluster +); +const add0x = (value) => !value.startsWith("0x") ? `0x${value}` : value; +const numberFormatter = new Intl.NumberFormat("en-US", { + useGrouping: true, + maximumFractionDigits: 2 +}); +const _percentageFormatter = new Intl.NumberFormat("en-US", { + style: "percent", + maximumFractionDigits: 2 +}); +const percentageFormatter = { + format: (value) => { + if (!value) return "0%"; + return _percentageFormatter.format(value / 100); + } +}; +const bigintFormatter = new Intl.NumberFormat("en-US", { + useGrouping: false, + maximumFractionDigits: 7 +}); +const ethFormatter = new Intl.NumberFormat("en-US", { + useGrouping: true, + maximumFractionDigits: 4 +}); +const formatSSV = (num, decimals = 18) => ethFormatter.format(+viem.formatUnits(num, decimals)); +const formatBigintInput = (num, decimals = 18) => bigintFormatter.format(+viem.formatUnits(num, decimals)); +const units = { + seconds: 1e3, + minutes: 6e4, + hours: 36e5, + days: 864e5, + weeks: 6048e5, + months: 2629746e3, + years: 31556952e3 +}; +const ms = (value, unit) => { + return value * units[unit]; +}; +const sortNumbers = (numbers) => { + return [...numbers].sort((a, b) => Number(a) - Number(b)); +}; +const getOperatorIds = (operators) => { + return sortNumbers(operators.map((operator) => operator.id)); +}; +const decodeOperatorPublicKey = (publicKey) => { + return viem.decodeAbiParameters([{ type: "string" }], publicKey)[0]; +}; +const isKeySharesItem = (item) => { + return !!item && typeof item === "object" && "data" in item && "payload" in item && "error" in item; +}; +var KeysharesValidationErrors = /* @__PURE__ */ ((KeysharesValidationErrors2) => { + KeysharesValidationErrors2[KeysharesValidationErrors2["OperatorDoesNotExist"] = 0] = "OperatorDoesNotExist"; + KeysharesValidationErrors2[KeysharesValidationErrors2["OperatorMismatch"] = 1] = "OperatorMismatch"; + KeysharesValidationErrors2[KeysharesValidationErrors2["ValidatorAlreadyExists"] = 2] = "ValidatorAlreadyExists"; + KeysharesValidationErrors2[KeysharesValidationErrors2["ClusterMismatch"] = 3] = "ClusterMismatch"; + KeysharesValidationErrors2[KeysharesValidationErrors2["DuplicateValidatorKeys"] = 4] = "DuplicateValidatorKeys"; + KeysharesValidationErrors2[KeysharesValidationErrors2["InconsistentOperatorPublicKeys"] = 5] = "InconsistentOperatorPublicKeys"; + KeysharesValidationErrors2[KeysharesValidationErrors2["InconsistentOperators"] = 6] = "InconsistentOperators"; + return KeysharesValidationErrors2; +})(KeysharesValidationErrors || {}); +const KeysharesValidationErrorsMessages = { + [ + 0 + /* OperatorDoesNotExist */ + ]: "Operator not found. Please verify the operator ID.", + [ + 1 + /* OperatorMismatch */ + ]: "Operator details mismatch. Check provided information.", + [ + 2 + /* ValidatorAlreadyExists */ + ]: "Validator public key already in use. Must be unique.", + [ + 3 + /* ClusterMismatch */ + ]: "The operators in the provided keyshares do not match the provided operators. Please ensure the keyshares correspond to the cluster you are trying to register.", + [ + 4 + /* DuplicateValidatorKeys */ + ]: "Duplicate validator keys detected. Each must be unique.", + [ + 5 + /* InconsistentOperatorPublicKeys */ + ]: "Operator public keys mismatch. Verify operator data.", + [ + 6 + /* InconsistentOperators */ + ]: "Inconsistent operator IDs across keyshares. Check all entries." +}; +class KeysharesValidationError extends Error { + constructor(code) { + super(KeysharesValidationErrorsMessages[code]); + this.code = code; + } +} +const validateConsistentOperatorIds = (keyshares) => { + const operatorIds = sortNumbers(keyshares[0].payload.operatorIds); + keyshares.every(({ payload, data }) => { + const payloadOperatorIds = sortNumbers(payload.operatorIds).toString(); + const dataOperatorIds = getOperatorIds(data.operators ?? []).toString(); + const valid = payloadOperatorIds === dataOperatorIds && dataOperatorIds === operatorIds.toString(); + if (!valid) { + throw new KeysharesValidationError( + 6 + /* InconsistentOperators */ + ); + } + return true; + }); + return operatorIds; +}; +const ensureValidatorsUniqueness = (keyshares) => { + const set = new Set(keyshares.map(({ data }) => data.publicKey)); + if (set.size !== keyshares.length) { + throw new KeysharesValidationError( + 4 + /* DuplicateValidatorKeys */ + ); + } + return true; +}; +const validateConsistentOperatorPublicKeys = (keyshares, operators) => { + const operatorsMap = new Map(operators.map((o) => [o.id, o.publicKey])); + const valid = keyshares.every(({ data }) => { + return data.operators?.every(({ id, operatorKey }) => { + return operatorsMap.get(id.toString()) === operatorKey; + }); + }); + if (!valid) { + throw new KeysharesValidationError( + 5 + /* InconsistentOperatorPublicKeys */ + ); + } + return valid; +}; +const ensureNoKeysharesErrors = (keyshares) => { + keyshares.forEach((share) => { + if (share.error) { + throw share.error; + } + }); + return true; +}; +exports.bigintAbs = tryCatch.bigintAbs; +exports.bigintFloor = tryCatch.bigintFloor; +exports.bigintMax = tryCatch.bigintMax; +exports.bigintMin = tryCatch.bigintMin; +exports.bigintRound = tryCatch.bigintRound; +exports.bigintifyNumbers = tryCatch.bigintifyNumbers; +exports.configArgsSchema = tryCatch.configArgsSchema; +exports.isBigIntChanged = tryCatch.isBigIntChanged; +exports.roundOperatorFee = tryCatch.roundOperatorFee; +exports.stringifyBigints = tryCatch.stringifyBigints; +exports.tryCatch = tryCatch.tryCatch; +exports.KeysharesValidationError = KeysharesValidationError; +exports.KeysharesValidationErrors = KeysharesValidationErrors; +exports.KeysharesValidationErrorsMessages = KeysharesValidationErrorsMessages; +exports._percentageFormatter = _percentageFormatter; +exports.add0x = add0x; +exports.bigintFormatter = bigintFormatter; +exports.createClusterId = createClusterId; +exports.createEmptyCluster = createEmptyCluster; +exports.decodeOperatorPublicKey = decodeOperatorPublicKey; +exports.ensureNoKeysharesErrors = ensureNoKeysharesErrors; +exports.ensureValidatorsUniqueness = ensureValidatorsUniqueness; +exports.ethFormatter = ethFormatter; +exports.formatBigintInput = formatBigintInput; +exports.formatSSV = formatSSV; +exports.getOperatorIds = getOperatorIds; +exports.isClusterId = isClusterId; +exports.isKeySharesItem = isKeySharesItem; +exports.ms = ms; +exports.numberFormatter = numberFormatter; +exports.percentageFormatter = percentageFormatter; +exports.sortNumbers = sortNumbers; +exports.validateConsistentOperatorIds = validateConsistentOperatorIds; +exports.validateConsistentOperatorPublicKeys = validateConsistentOperatorPublicKeys; diff --git a/package.json b/package.json index ea73215..aeea13e 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "@ssv-labs/bapps-sdk", - "version": "0.0.13", + "version": "0.0.14", "author": "SSV.Labs", "description": "ssv labs based apps sdk", "keywords": [ @@ -19,10 +19,12 @@ "exports": { ".": { "import": "./dist/main.mjs", + "require": "./dist/main.js", "types": "./dist/main.d.ts" }, "./utils": { "import": "./dist/utils.mjs", + "require": "./dist/utils.js", "types": "./dist/utils/index.d.ts" } }, diff --git a/vite.config.mts b/vite.config.ts similarity index 96% rename from vite.config.mts rename to vite.config.ts index 812466b..0fb7071 100644 --- a/vite.config.mts +++ b/vite.config.ts @@ -22,7 +22,7 @@ export default defineConfig({ main: resolve(__dirname, 'src/main.ts'), utils: resolve(__dirname, 'src/utils/index.ts'), }, - formats: ['es'], + formats: ['es', 'cjs'], }, rollupOptions: { external: [