@ssv-labs/bapps-sdk
Version:
ssv labs based apps sdk
32,053 lines • 961 kB
JavaScript
"use strict";
const viem = require("viem");
function getDefaultExportFromCjs$1(x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
}
var browser$e = { exports: {} };
var process = browser$e.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 len = queue.length;
while (len) {
currentQueue = queue;
queue = [];
while (++queueIndex < len) {
if (currentQueue) {
currentQueue[queueIndex].run();
}
}
queueIndex = -1;
len = 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 i = 1; i < arguments.length; i++) {
args[i - 1] = arguments[i];
}
}
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$2() {
}
process.on = noop$2;
process.addListener = noop$2;
process.once = noop$2;
process.off = noop$2;
process.removeListener = noop$2;
process.removeAllListeners = noop$2;
process.emit = noop$2;
process.prependListener = noop$2;
process.prependOnceListener = noop$2;
process.listeners = function(name2) {
return [];
};
process.binding = function(name2) {
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$1 = browser$e.exports;
const process$1 = /* @__PURE__ */ getDefaultExportFromCjs$1(browserExports$1);
var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
function getDefaultExportFromCjs(x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
}
var dist = {};
(function(exports2) {
Object.defineProperties(exports2, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
var buffer2 = {};
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 <https://feross.org/opensource> */
ieee754.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 i2 = isLE ? nBytes - 1 : 0;
var d = isLE ? -1 : 1;
var s2 = buffer3[offset + i2];
i2 += d;
e = s2 & (1 << -nBits) - 1;
s2 >>= -nBits;
nBits += eLen;
for (; nBits > 0; e = e * 256 + buffer3[offset + i2], i2 += d, nBits -= 8) {
}
m = e & (1 << -nBits) - 1;
e >>= -nBits;
nBits += mLen;
for (; nBits > 0; m = m * 256 + buffer3[offset + i2], i2 += d, nBits -= 8) {
}
if (e === 0) {
e = 1 - eBias;
} else if (e === eMax) {
return m ? NaN : (s2 ? -1 : 1) * Infinity;
} else {
m = m + Math.pow(2, mLen);
e = e - eBias;
}
return (s2 ? -1 : 1) * m * Math.pow(2, e - mLen);
};
ieee754.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 i2 = isLE ? 0 : nBytes - 1;
var d = isLE ? 1 : -1;
var s2 = 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 + i2] = m & 255, i2 += d, m /= 256, mLen -= 8) {
}
e = e << mLen | m;
eLen += mLen;
for (; eLen > 0; buffer3[offset + i2] = e & 255, i2 += d, e /= 256, eLen -= 8) {
}
buffer3[offset + i2 - d] |= s2 * 128;
};
/*!
* The buffer module from node.js, for the browser.
*
* @author Feross Aboukhadijeh <https://feross.org>
* @license MIT
*/
(function(exports3) {
const base64 = base64Js;
const ieee754$1 = ieee754;
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 proto2 = { foo: function() {
return 42;
} };
Object.setPrototypeOf(proto2, GlobalUint8Array.prototype);
Object.setPrototypeOf(arr, proto2);
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 allocUnsafe2(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 assertSize2(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) {
assertSize2(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 allocUnsafe2(size) {
assertSize2(size);
return createBuffer(size < 0 ? 0 : checked(size) | 0);
}
Buffer3.allocUnsafe = function(size) {
return allocUnsafe2(size);
};
Buffer3.allocUnsafeSlow = function(size) {
return allocUnsafe2(size);
};
function fromString(string, encoding) {
if (typeof encoding !== "string" || encoding === "") {
encoding = "utf8";
}
if (!Buffer3.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, Buffer3.prototype);
return buf;
}
function fromObject(obj) {
if (Buffer3.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 Buffer3.alloc(+length);
}
Buffer3.isBuffer = function isBuffer3(b) {
return b != null && b._isBuffer === true && b !== Buffer3.prototype;
};
Buffer3.compare = function compare2(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 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;
};
Buffer3.isEncoding = function isEncoding2(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 i2;
if (length === void 0) {
length = 0;
for (i2 = 0; i2 < list.length; ++i2) {
length += list[i2].length;
}
}
const buffer3 = Buffer3.allocUnsafe(length);
let pos = 0;
for (i2 = 0; i2 < list.length; ++i2) {
let buf = list[i2];
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 byteLength2(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 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;
}
}
}
Buffer3.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;
}
}
}
Buffer3.prototype._isBuffer = true;
function swap(b, n, m) {
const i2 = b[n];
b[n] = b[m];
b[m] = i2;
}
Buffer3.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;
};
Buffer3.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;
};
Buffer3.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;
};
Buffer3.prototype.toString = function toString2() {
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 inspect6() {
let str = "";
const max2 = exports3.INSPECT_MAX_BYTES;
str = this.toString("hex", 0, max2).replace(/(.{2})/g, "$1 ").trim();
if (this.length > max2) str += " ... ";
return "<Buffer " + str + ">";
};
if (customInspectSymbol) {
Buffer3.prototype[customInspectSymbol] = Buffer3.prototype.inspect;
}
Buffer3.prototype.compare = function compare2(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 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(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, 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;
}
Buffer3.prototype.includes = function includes2(val, byteOffset, encoding) {
return this.indexOf(val, byteOffset, encoding) !== -1;
};
Buffer3.prototype.indexOf = function indexOf3(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 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);
}
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 toJSON2() {
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;
}
Buffer3.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, 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, byteLength3, noAssert) {
offset = offset >>> 0;
byteLength3 = byteLength3 >>> 0;
if (!noAssert) checkOffset(offset, byteLength3, this.length);
let val = this[offset];
let mul5 = 1;
let i2 = 0;
while (++i2 < byteLength3 && (mul5 *= 256)) {
val += this[offset + i2] * mul5;
}
return val;
};
Buffer3.prototype.readUintBE = Buffer3.prototype.readUIntBE = function readUIntBE(offset, byteLength3, noAssert) {
offset = offset >>> 0;
byteLength3 = byteLength3 >>> 0;
if (!noAssert) {
checkOffset(offset, byteLength3, this.length);
}
let val = this[offset + --byteLength3];
let mul5 = 1;
while (byteLength3 > 0 && (mul5 *= 256)) {
val += this[offset + --byteLength3] * mul5;
}
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 readUInt32BE2(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, byteLength3, noAssert) {
offset = offset >>> 0;
byteLength3 = byteLength3 >>> 0;
if (!noAssert) checkOffset(offset, byteLength3, this.length);
let val = this[offset];
let mul5 = 1;
let i2 = 0;
while (++i2 < byteLength3 && (mul5 *= 256)) {
val += this[offset + i2] * mul5;
}
mul5 *= 128;
if (val >= mul5) val -= Math.pow(2, 8 * byteLength3);
return val;
};
Buffer3.prototype.readIntBE = function readIntBE(offset, byteLength3, noAssert) {
offset = offset >>> 0;
byteLength3 = byteLength3 >>> 0;
if (!noAssert) checkOffset(offset, byteLength3, this.length);
let i2 = byteLength3;
let mul5 = 1;
let val = this[offset + --i2];
while (i2 > 0 && (mul5 *= 256)) {
val += this[offset + --i2] * mul5;
}
mul5 *= 128;
if (val >= mul5) val -= Math.pow(2, 8 * byteLength3);
return val;
};
Buffer3.prototype.readInt8 = function readInt8(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 1, this.length);
if (!(this[offset] & 128)) return this[offset];
return (255 - this[offset] + 1) * -1;
};
Buffer3.prototype.readInt16LE = function readInt16LE(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 2, this.length);
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, max2, min) {
if (!Buffer3.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance');
if (value > max2 || 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, 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 mul5 = 1;
let i2 = 0;
this[offset] = value & 255;
while (++i2 < byteLength3 && (mul5 *= 256)) {
this[offset + i2] = value / mul5 & 255;
}
return offset + byteLength3;
};
Buffer3.prototype.writeUintBE = Buffer3.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength3, noAssert) {
value = +value;
offset = offset >>> 0;
byteLength3 = byteLength3 >>> 0;
if (!noAssert) {
const maxBytes = Math.pow(2, 8 * byteLength3) - 1;
checkInt(this, value, offset, byteLength3, maxBytes, 0);
}
let i2 = byteLength3 - 1;
let mul5 = 1;
this[offset + i2] = value & 255;
while (--i2 >= 0 && (mul5 *= 256)) {
this[offset + i2] = value / mul5 & 255;
}
return offset + byteLength3;
};
Buffer3.prototype.writeUint8 = Buffer3.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) checkInt(this, value, offset, 1, 255, 0);
this[offset] = value & 255;
return offset + 1;
};
Buffer3.prototype.writeUint16LE = Buffer3.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) checkInt(this, value, offset, 2, 65535, 0);
this[offset] = value & 255;
this[offset + 1] = value >>> 8;
return offset + 2;
};
Buffer3.prototype.writeUint16BE = Buffer3.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) checkInt(this, value, offset, 2, 65535, 0);
this[offset] = value >>> 8;
this[offset + 1] = value & 255;
return offset + 2;
};
Buffer3.prototype.writeUint32LE = Buffer3.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0);
this[offset + 3] = value >>> 24;
this[offset + 2] = value >>> 16;
this[offset + 1] = value >>> 8;
this[offset] = value & 255;
return offset + 4;
};
Buffer3.prototype.writeUint32BE = Buffer3.prototype.writeUInt32BE = function writeUInt32BE2(value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0);
this[offset] = value >>> 24;
this[offset + 1] = value >>> 16;
this[offset + 2] = value >>> 8;
this[offset + 3] = value & 255;
return offset + 4;
};
function wrtBigUInt64LE(buf, value, offset, min, max2) {
checkIntBI(value, min, max2, 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, max2) {
checkIntBI(value, min, max2, 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, 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 mul5 = 1;
let sub = 0;
this[offset] = value & 255;
while (++i2 < byteLength3 && (mul5 *= 256)) {
if (value < 0 && sub === 0 && this[offset + i2 - 1] !== 0) {
sub = 1;
}
this[offset + i2] = (value / mul5 >> 0) - sub & 255;
}
return offset + byteLength3;
};
Buffer3.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 mul5 = 1;
let sub = 0;
this[offset + i2] = value & 255;
while (--i2 >= 0 && (mul5 *= 256)) {
if (value < 0 && sub === 0 && this[offset + i2 + 1] !== 0) {
sub = 1;
}
this[offset + i2] = (value / mul5 >> 0) - sub & 255;
}
return offset + byteLength3;
};
Buffer3.prototype.writeInt8 = function writeInt8(value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) checkInt(this, value, offset, 1, 127, -128);
if (value < 0) value = 255 + value + 1;
this[offset] = value & 255;
return offset + 1;
};
Buffer3.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) checkInt(this, value, offset, 2, 32767, -32768);
this[offset] = value & 255;
this[offset + 1] = value >>> 8;
return offset + 2;
};
Buffer3.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) checkInt(this, value, offset, 2, 32767, -32768);
this[offset] = value >>> 8;
this[offset + 1] = value & 255;
return offset + 2;
};
Buffer3.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) checkInt(this, value, offset, 4, 2147483647, -2147483648);
this[offset] = value & 255;
this[offset + 1] = value >>> 8;
this[offset + 2] = value >>> 16;
this[offset + 3] = value >>> 24;
return offset + 4;
};
Buffer3.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) checkInt(this, value, offset, 4, 2147483647, -2147483648);
if (value < 0) value = 4294967295 + value + 1;
this[offset] = value >>> 24;
this[offset + 1] = value >>> 16;
this[offset + 2] = value >>> 8;
this[offset + 3] = value & 255;
return offset + 4;
};
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, max2, 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 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;
};
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 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 = Buffer3.isBuffer(val) ? val : Buffer3.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, Base2) {
errors[sym] = class NodeError extends Base2 {
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(name2) {
if (name2) {
return `${name2} is outside of buffer bounds`;
}
return "Attempt to access memory outside buffer bounds";
},
RangeError
);
E(
"ERR_INVALID_ARG_TYPE",
function(name2, actual) {
return `The "${name2}" 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, max2, buf, offset, byteLength3) {
if (value > max2 || 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, name2) {
if (typeof value !== "number") {
throw new errors.ERR_INVALID_ARG_TYPE(name2, "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");
}
})(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);
const Buffer$E = /* @__PURE__ */ getDefaultExportFromCjs(dist);
var main$2 = { exports: {} };
var empty = null;
var empty_1 = empty;
function assertPath(path3) {
if (typeof path3 !== "string") {
throw new TypeError("Path must be a string. Received " + JSON.stringify(path3));
}
}
function normalizeStringPosix(path3, allowAboveRoot) {
var res = "";
var lastSegmentLength = 0;
var lastSlash = -1;
var dots = 0;
var code;
for (var i = 0; i <= path3.length; ++i) {
if (i < path3.length)
code = path3.charCodeAt(i);
else if (code === 47)
break;
else
code = 47;
if (code === 47) {
if (lastSlash === i - 1 || dots === 1) ;
else if (lastSlash !== i - 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 = i;
dots = 0;
continue;
}
} else if (res.length === 2 || res.length === 1) {
res = "";
lastSegmentLength = 0;
lastSlash = i;
dots = 0;
continue;
}
}
if (allowAboveRoot) {
if (res.length > 0)
res += "/..";
else
res = "..";
lastSegmentLength = 2;
}
} else {
if (res.length > 0)
res += "/" + path3.slice(lastSlash + 1, i);
else
res = path3.slice(lastSlash + 1, i);
lastSegmentLength = i - lastSlash - 1;
}
lastSlash = i;
dots = 0;
} else if (code === 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 i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
var path3;
if (i >= 0)
path3 = arguments[i];
else {
if (cwd === void 0)
cwd = process$1.cwd();
path3 = cwd;
}
assertPath(path3);
if (path3.length === 0) {
continue;
}
resolvedPath = path3 + "/" + resolvedPath;
resolvedAbsolute = path3.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 normalize(path3) {
assertPath(path3);
if (path3.length === 0) return ".";
var isAbsolute2 = path3.charCodeAt(0) === 47;
var trailingSeparator = path3.charCodeAt(path3.length - 1) === 47;
path3 = normalizeStringPosix(path3, !isAbsolute2);
if (path3.length === 0 && !isAbsolute2) path3 = ".";
if (path3.length > 0 && trailingSeparator) path3 += "/";
if (isAbsolute2) return "/" + path3;
return path3;
},
isAbsolute: function isAbsolute(path3) {
assertPath(path3);
return path3.length > 0 && path3.charCodeAt(0) === 47;
},
join: function join() {
if (arguments.length === 0)
return ".";
var joined;
for (var i = 0; i < arguments.length; ++i) {
var arg = arguments[i];
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 i = 0;
for (; i <= length; ++i) {
if (i === length) {
if (toLen > length) {
if (to.charCodeAt(toStart + i) === 47) {
return to.slice(toStart + i + 1);
} else if (i === 0) {
return to.slice(toStart + i);
}
} else if (fromLen > length) {
if (from.charCodeAt(fromStart + i) === 47) {
lastCommonSep = i;
} else if (i === 0) {
lastCommonSep = 0;
}
}
break;
}
var fromCode = from.charCodeAt(fromStart + i);
var toCode = to.charCodeAt(toStart + i);
if (fromCode !== toCode)
break;
else if (fromCode === 47)
lastCommonSep = i;
}
var out = "";
for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
if (i === fromEnd || from.charCodeAt(i) === 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(path3) {
return path3;
},
dirname: function dirname(path3) {
assertPath(path3);
if (path3.length === 0) return ".";
var code = path3.charCodeAt(0);
var hasRoot = code === 47;
var end = -1;
var matchedSlash = true;
for (var i = path3.length - 1; i >= 1; --i) {
code = path3.charCodeAt(i);
if (code === 47) {
if (!matchedSlash) {
end = i;
break;
}
} else {
matchedSlash = false;
}
}
if (end === -1) return hasRoot ? "/" : ".";
if (hasRoot && end === 1) return "//";
return path3.slice(0, end);
},
basename: function basename(path3, ext) {
if (ext !== void 0 && typeof ext !== "string") throw new TypeError('"ext" argument must be a string');
assertPath(path3);
var start = 0;
var end = -1;
var matchedSlash = true;
var i;
if (ext !== void 0 && ext.length > 0 && ext.length <= path3.length) {
if (ext.length === path3.length && ext === path3) return "";
var extIdx = ext.length - 1;
var firstNonSlashEnd = -1;
for (i = path3.length - 1; i >= 0; --i) {
var code = path3.charCodeAt(i);
if (code === 47) {
if (!matchedSlash) {
start = i + 1;
break;
}
} else {
if (firstNonSlashEnd === -1) {
matchedSlash = false;
firstNonSlashEnd = i + 1;
}
if (extIdx >= 0) {
if (code === ext.charCodeAt(extIdx)) {
if (--extIdx === -1) {
end = i;
}
} else {
extIdx = -1;
end = firstNonSlashEnd;
}
}
}
}
if (start === end) end = firstNonSlashEnd;
else if (end === -1) end = path3.length;
return path3.slice(start, end);
} else {
for (i = path3.length - 1; i >= 0; --i) {
if (path3.charCodeAt(i) === 47) {
if (!matchedSlash) {
start = i + 1;
break;
}
} else if (end === -1) {
matchedSlash = false;
end = i + 1;
}
}
if (end === -1) return "";
return path3.slice(start, end);
}
},
extname: function extname(path3) {
assertPath(path3);
var startDot = -1;
var startPart = 0;
var end = -1;
var matchedSlash = true;
var preDotState = 0;
for (var i = path3.length - 1; i >= 0; --i) {
var code = path3.charCodeAt(i);
if (code === 47) {
if (!matchedSlash) {
startPart = i + 1;
break;
}
continue;
}
if (end === -1) {
matchedSlash = false;
end = i + 1;
}
if (code === 46) {
if (startDot === -1)
startDot = i;
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 path3.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(path3) {
assertPath(path3);
var ret = { root: "", dir: "", base: "", ext: "", name: "" };
if (path3.length === 0) return ret;
var code = path3.charCodeAt(0);
var isAbsolute2 = code === 47;
var start;
if (isAbsolute2) {
ret.root = "/";
start = 1;
} else {
start = 0;
}
var startDot = -1;
var startPart = 0;
var end = -1;
var matchedSlash = true;
var i = path3.length - 1;
var preDotState = 0;
for (; i >= start; --i) {
code = path3.charCodeAt(i);
if (code === 47) {
if (!matchedSlash) {
startPart = i + 1;
break;
}
continue;
}
if (end === -1) {
matchedSlash = false;
end = i + 1;
}
if (code === 46) {
if (startDot === -1) startDot = i;
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 && isAbsolute2) ret.base = ret.name = path3.slice(1, end);
else ret.base = ret.name = path3.slice(startPart, end);
}
} else {
if (startPart === 0 && isAbsolute2) {
ret.name = path3.slice(1, startDot);
ret.base = path3.slice(1, end);
} else {
ret.name = path3.slice(startPart, startDot);
ret.base = path3.slice(startPart, end);
}
ret.ext = path3.slice(startDot, end);
}
if (startPart > 0) ret.dir = path3.slice(0, startPart - 1);
else if (isAbsolute2) ret.dir = "/";
return ret;
},
sep: "/",
delimiter: ":",
win32: null,
posix: null
};
posix.posix = posix;
var pathBrowserify = posix;
var browser$d = {};
browser$d.endianness = function() {
return "LE";
};
browser$d.hostname = function() {
if (typeof location !== "undefined") {
return location.hostname;
} else return "";
};
browser$d.loadavg = function() {
return [];
};
browser$d.uptime = function() {
return 0;
};
browser$d.freemem = function() {
return Number.MAX_VALUE;
};
browser$d.totalmem = function() {
return Number.MAX_VALUE;
};
browser$d.cpus = function() {
return [];
};
browser$d.type = function() {
return "Browser";
};
browser$d.release = function() {
if (typeof navigator !== "undefined") {
return navigator.appVersion;
}
return "";
};
browser$d.networkInterfaces = browser$d.getNetworkInterfaces = function() {
return {};
};
browser$d.arch = function() {
return "javascript";
};
browser$d.platform = function() {
return "browser";
};
browser$d.tmpdir = browser$d.tmpDir = function() {
return "/tmp";
};
browser$d.EOL = "\n";
browser$d.homedir = function() {
return "/";
};
var cryptoBrowserify = {};
var browser$c = { exports: {} };
var safeBuffer$2 = { exports: {} };
/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
(function(module2, exports2) {
var buffer2 = dist;
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$2, safeBuffer$2.exports);
var safeBufferExports$1 = safeBuffer$2.exports;
var MAX_BYTES = 65536;
var MAX_UINT32 = 4294967295;
function oldBrowser$1() {
throw new Error("Secure random number generation is not supported by this browser.\nUse Chrome, Firefox or Internet Explorer 11");
}
var Buffer$D = safeBufferExports$1.Buffer;
var crypto$2 = commonjsGlobal.crypto || commonjsGlobal.msCrypto;
if (crypto$2 && crypto$2.getRandomValues) {
browser$c.exports = randomBytes$2;
} else {
browser$c.exports = oldBrowser$1;
}
function randomBytes$2(size, cb) {
if (size > MAX_UINT32) throw new RangeError("requested too many random bytes");
var bytes = Buffer$D.allocUnsafe(size);
if (size > 0) {
if (size > MAX_BYTES) {
for (var generated = 0; generated < size; generated += MAX_BYTES) {
crypto$2.getRandomValues(bytes.slice(generated, generated + MAX_BYTES));
}
} else {
crypto$2.getRandomValues(bytes);
}
}
if (typeof cb === "function") {
return process$1.nextTick(function() {
cb(null, bytes);
});
}
return bytes;
}
var browserExports = browser$c.exports;
var inherits_browser = { exports: {} };
if (typeof Object.create === "function") {
inherits_browser.exports = function inherits2(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 inherits2(ctor, superCtor) {
if (superCtor) {
ctor.super_ = superCtor;
var TempCtor = function() {
};
TempCtor.prototype = superCtor.prototype;
ctor.prototype = new TempCtor();
ctor.prototype.constructor = ctor;
}
};
}
var inherits_browserExports = inherits_browser.exports;
var readableBrowser$1 = { exports: {} };
var events = { exports: {} };
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$2;
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 i = 1; i < arguments.length; i++) args.push(arguments[i]);
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 len = handler.length;
var listeners2 = arrayClone(handler, len);
for (var i = 0; i < len; ++i)
ReflectApply(listeners2[i], 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, i, 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 (i = list.length - 1; i >= 0; i--) {
if (list[i] === listener || list[i].listener === listener) {
originalListener = list[i].listener;
position = i;
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 listeners2, events2, i;
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 keys2 = Object.keys(events2);
var key2;
for (i = 0; i < keys2.length; ++i) {
key2 = keys2[i];
if (key2 === "removeListener") continue;
this.removeAllListeners(key2);
}
this.removeAllListeners("removeListener");
this._events = /* @__PURE__ */ Object.create(null);
this._eventsCount = 0;
return this;
}
listeners2 = events2[type2];
if (typeof listeners2 === "function") {
this.removeListener(type2, listeners2);
} else if (listeners2 !== void 0) {
for (i = listeners2.length - 1; i >= 0; i--) {
this.removeListener(type2, listeners2[i]);
}
}
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 i = 0; i < n; ++i)
copy[i] = arr[i];
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 i = 0; i < ret.length; ++i) {
ret[i] = arr[i].listener || arr[i];
}
return ret;
}
function once$2(emitter, name2) {
return new Promise(function(resolve2, reject) {
function errorListener(err) {
emitter.removeListener(name2, resolver);
reject(err);
}
function resolver() {
if (typeof emitter.removeListener === "function") {
emitter.removeListener("error", errorListener);
}
resolve2([].slice.call(arguments));
}
eventTargetAgnosticAddListener(emitter, name2, resolver, { once: true });
if (name2 !== "error") {
addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
}
});
}
function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
if (typeof emitter.on === "function") {
eventTargetAgnosticAddListener(emitter, "error", handler, flags);
}
}
function eventTargetAgnosticAddListener(emitter, name2, listener, flags) {
if (typeof emitter.on === "function") {
if (flags.once) {
emitter.once(name2, listener);
} else {
emitter.on(name2, listener);
}
} else if (typeof emitter.addEventListener === "function") {
emitter.addEventListener(name2, function wrapListener(arg) {
if (flags.once) {
emitter.removeEventListener(name2, wrapListener);
}
listener(arg);
});
} else {
throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
}
}
var eventsExports = events.exports;
var streamBrowser$1 = eventsExports.EventEmitter;
var util$4 = {};
var types$1 = {};
var 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;
};
var hasSymbols$2 = shams$1;
var shams = function hasToStringTagShams() {
return hasSymbols$2() && !!Symbol.toStringTag;
};
var esErrors = Error;
var _eval = EvalError;
var range = RangeError;
var ref = ReferenceError;
var syntax = SyntaxError;
var type = TypeError;
var uri = URIError;
var origSymbol = typeof Symbol !== "undefined" && Symbol;
var hasSymbolSham = shams$1;
var hasSymbols$1 = 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();
};
var test = {
__proto__: null,
foo: {}
};
var $Object = Object;
var hasProto$1 = function hasProto2() {
return { __proto__: test }.foo === test.foo && !(test instanceof $Object);
};
var ERROR_MESSAGE = "Function.prototype.bind called on incompatible ";
var toStr$3 = Object.prototype.toString;
var max = Math.max;
var funcType = "[object Function]";
var concatty = function concatty2(a, b) {
var arr = [];
for (var i = 0; i < a.length; i += 1) {
arr[i] = a[i];
}
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 i = offset, j = 0; i < arrLike.length; i += 1, j += 1) {
arr[j] = arrLike[i];
}
return arr;
};
var joiny = function(arr, joiner) {
var str = "";
for (var i = 0; i < arr.length; i += 1) {
str += arr[i];
if (i + 1 < arr.length) {
str += joiner;
}
}
return str;
};
var implementation$1 = function bind2(that) {
var target = this;
if (typeof target !== "function" || toStr$3.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 i = 0; i < boundLength; i++) {
boundArgs[i] = "$" + i;
}
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;
};
var implementation = implementation$1;
var functionBind = Function.prototype.bind || implementation;
var call$1 = Function.prototype.call;
var $hasOwn = Object.prototype.hasOwnProperty;
var bind$1 = functionBind;
var hasown = bind$1.call(call$1, $hasOwn);
var undefined$1;
var $Error = esErrors;
var $EvalError = _eval;
var $RangeError = range;
var $ReferenceError = ref;
var $SyntaxError$1 = syntax;
var $TypeError$2 = type;
var $URIError = uri;
var $Function = Function;
var getEvalledConstructor = function(expressionSyntax) {
try {
return $Function('"use strict"; return (' + expressionSyntax + ").constructor;")();
} catch (e) {
}
};
var $gOPD$1 = Object.getOwnPropertyDescriptor;
if ($gOPD$1) {
try {
$gOPD$1({}, "");
} catch (e) {
$gOPD$1 = null;
}
}
var throwTypeError = function() {
throw new $TypeError$2();
};
var ThrowTypeError = $gOPD$1 ? function() {
try {
arguments.callee;
return throwTypeError;
} catch (calleeThrows) {
try {
return $gOPD$1(arguments, "callee").get;
} catch (gOPDthrows) {
return throwTypeError;
}
}
}() : throwTypeError;
var hasSymbols = hasSymbols$1();
var hasProto = hasProto$1();
var getProto$1 = Object.getPrototypeOf || (hasProto ? function(x) {
return x.__proto__;
} : null);
var needsEval = {};
var TypedArray = typeof Uint8Array === "undefined" || !getProto$1 ? undefined$1 : getProto$1(Uint8Array);
var INTRINSICS = {
__proto__: null,
"%AggregateError%": typeof AggregateError === "undefined" ? undefined$1 : AggregateError,
"%Array%": Array,
"%ArrayBuffer%": typeof ArrayBuffer === "undefined" ? undefined$1 : ArrayBuffer,
"%ArrayIteratorPrototype%": hasSymbols && getProto$1 ? getProto$1([][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%": hasSymbols && getProto$1 ? getProto$1(getProto$1([][Symbol.iterator]())) : undefined$1,
"%JSON%": typeof JSON === "object" ? JSON : undefined$1,
"%Map%": typeof Map === "undefined" ? undefined$1 : Map,
"%MapIteratorPrototype%": typeof Map === "undefined" || !hasSymbols || !getProto$1 ? undefined$1 : getProto$1((/* @__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" || !hasSymbols || !getProto$1 ? undefined$1 : getProto$1((/* @__PURE__ */ new Set())[Symbol.iterator]()),
"%SharedArrayBuffer%": typeof SharedArrayBuffer === "undefined" ? undefined$1 : SharedArrayBuffer,
"%String%": String,
"%StringIteratorPrototype%": hasSymbols && getProto$1 ? getProto$1(""[Symbol.iterator]()) : undefined$1,
"%Symbol%": hasSymbols ? Symbol : undefined$1,
"%SyntaxError%": $SyntaxError$1,
"%ThrowTypeError%": ThrowTypeError,
"%TypedArray%": TypedArray,
"%TypeError%": $TypeError$2,
"%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$1) {
try {
null.error;
} catch (e) {
var errorProto = getProto$1(getProto$1(e));
INTRINSICS["%Error.prototype%"] = errorProto;
}
}
var doEval = function doEval2(name2) {
var value;
if (name2 === "%AsyncFunction%") {
value = getEvalledConstructor("async function () {}");
} else if (name2 === "%GeneratorFunction%") {
value = getEvalledConstructor("function* () {}");
} else if (name2 === "%AsyncGeneratorFunction%") {
value = getEvalledConstructor("async function* () {}");
} else if (name2 === "%AsyncGenerator%") {
var fn = doEval2("%AsyncGeneratorFunction%");
if (fn) {
value = fn.prototype;
}
} else if (name2 === "%AsyncIteratorPrototype%") {
var gen = doEval2("%AsyncGenerator%");
if (gen && getProto$1) {
value = getProto$1(gen.prototype);
}
}
INTRINSICS[name2] = 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 = functionBind;
var hasOwn = hasown;
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$1("invalid intrinsic syntax, expected closing `%`");
} else if (last === "%" && first !== "%") {
throw new $SyntaxError$1("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(name2, allowMissing) {
var intrinsicName = name2;
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$2("intrinsic " + name2 + " exists, but is not available. Please file an issue!");
}
return {
alias,
name: intrinsicName,
value
};
}
throw new $SyntaxError$1("intrinsic " + name2 + " does not exist!");
};
var getIntrinsic = function GetIntrinsic2(name2, allowMissing) {
if (typeof name2 !== "string" || name2.length === 0) {
throw new $TypeError$2("intrinsic name must be a non-empty string");
}
if (arguments.length > 1 && typeof allowMissing !== "boolean") {
throw new $TypeError$2('"allowMissing" argument must be a boolean');
}
if ($exec(/^%?[^%]*%?$/, name2) === null) {
throw new $SyntaxError$1("`%` may not be present anywhere but at the beginning and end of the intrinsic name");
}
var parts = stringToPath(name2);
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 i = 1, isOwn = true; i < parts.length; i += 1) {
var part = parts[i];
var first = $strSlice(part, 0, 1);
var last = $strSlice(part, -1);
if ((first === '"' || first === "'" || first === "`" || (last === '"' || last === "'" || last === "`")) && first !== last) {
throw new $SyntaxError$1("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$2("base intrinsic for " + name2 + " exists, but the property is not available.");
}
return void 0;
}
if ($gOPD$1 && i + 1 >= parts.length) {
var desc = $gOPD$1(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;
};
var callBind$2 = { exports: {} };
var esDefineProperty;
var hasRequiredEsDefineProperty;
function requireEsDefineProperty() {
if (hasRequiredEsDefineProperty) return esDefineProperty;
hasRequiredEsDefineProperty = 1;
var GetIntrinsic3 = getIntrinsic;
var $defineProperty2 = GetIntrinsic3("%Object.defineProperty%", true) || false;
if ($defineProperty2) {
try {
$defineProperty2({}, "a", { value: 1 });
} catch (e) {
$defineProperty2 = false;
}
}
esDefineProperty = $defineProperty2;
return esDefineProperty;
}
var GetIntrinsic$2 = getIntrinsic;
var $gOPD = GetIntrinsic$2("%Object.getOwnPropertyDescriptor%", true);
if ($gOPD) {
try {
$gOPD([], "length");
} catch (e) {
$gOPD = null;
}
}
var gopd$1 = $gOPD;
var $defineProperty$1 = requireEsDefineProperty();
var $SyntaxError = syntax;
var $TypeError$1 = type;
var gopd = gopd$1;
var defineDataProperty = function defineDataProperty2(obj, property, value) {
if (!obj || typeof obj !== "object" && typeof obj !== "function") {
throw new $TypeError$1("`obj` must be an object or a function`");
}
if (typeof property !== "string" && typeof property !== "symbol") {
throw new $TypeError$1("`property` must be a string or a symbol`");
}
if (arguments.length > 3 && typeof arguments[3] !== "boolean" && arguments[3] !== null) {
throw new $TypeError$1("`nonEnumerable`, if provided, must be a boolean or null");
}
if (arguments.length > 4 && typeof arguments[4] !== "boolean" && arguments[4] !== null) {
throw new $TypeError$1("`nonWritable`, if provided, must be a boolean or null");
}
if (arguments.length > 5 && typeof arguments[5] !== "boolean" && arguments[5] !== null) {
throw new $TypeError$1("`nonConfigurable`, if provided, must be a boolean or null");
}
if (arguments.length > 6 && typeof arguments[6] !== "boolean") {
throw new $TypeError$1("`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 = !!gopd && gopd(obj, property);
if ($defineProperty$1) {
$defineProperty$1(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.");
}
};
var $defineProperty = 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;
}
};
var hasPropertyDescriptors_1 = hasPropertyDescriptors;
var GetIntrinsic$1 = getIntrinsic;
var define = defineDataProperty;
var hasDescriptors = hasPropertyDescriptors_1();
var gOPD$1 = gopd$1;
var $TypeError = type;
var $floor = GetIntrinsic$1("%Math.floor%");
var 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$1) {
var desc = gOPD$1(fn, "length");
if (desc && !desc.configurable) {
functionLengthIsConfigurable = false;
}
if (desc && !desc.writable) {
functionLengthIsWritable = false;
}
}
if (functionLengthIsConfigurable || functionLengthIsWritable || !loose) {
if (hasDescriptors) {
define(
/** @type {Parameters<define>[0]} */
fn,
"length",
length,
true,
true
);
} else {
define(
/** @type {Parameters<define>[0]} */
fn,
"length",
length
);
}
}
return fn;
};
(function(module2) {
var bind3 = functionBind;
var GetIntrinsic3 = getIntrinsic;
var setFunctionLength$1 = setFunctionLength;
var $TypeError2 = type;
var $apply = GetIntrinsic3("%Function.prototype.apply%");
var $call = GetIntrinsic3("%Function.prototype.call%");
var $reflectApply = GetIntrinsic3("%Reflect.apply%", true) || bind3.call($call, $apply);
var $defineProperty2 = requireEsDefineProperty();
var $max = GetIntrinsic3("%Math.max%");
module2.exports = function callBind2(originalFunction) {
if (typeof originalFunction !== "function") {
throw new $TypeError2("a function is required");
}
var func = $reflectApply(bind3, $call, arguments);
return setFunctionLength$1(
func,
1 + $max(0, originalFunction.length - (arguments.length - 1)),
true
);
};
var applyBind = function applyBind2() {
return $reflectApply(bind3, $apply, arguments);
};
if ($defineProperty2) {
$defineProperty2(module2.exports, "apply", { value: applyBind });
} else {
module2.exports.apply = applyBind;
}
})(callBind$2);
var callBindExports = callBind$2.exports;
var GetIntrinsic = getIntrinsic;
var callBind$1 = callBindExports;
var $indexOf$1 = callBind$1(GetIntrinsic("String.prototype.indexOf"));
var callBound$2 = function callBoundIntrinsic(name2, allowMissing) {
var intrinsic = GetIntrinsic(name2, !!allowMissing);
if (typeof intrinsic === "function" && $indexOf$1(name2, ".prototype.") > -1) {
return callBind$1(intrinsic);
}
return intrinsic;
};
var hasToStringTag$3 = shams();
var callBound$1 = callBound$2;
var $toString$1 = callBound$1("Object.prototype.toString");
var isStandardArguments = function isArguments2(value) {
if (hasToStringTag$3 && value && typeof value === "object" && Symbol.toStringTag in value) {
return false;
}
return $toString$1(value) === "[object Arguments]";
};
var isLegacyArguments = function isArguments3(value) {
if (isStandardArguments(value)) {
return true;
}
return value !== null && typeof value === "object" && typeof value.length === "number" && value.length >= 0 && $toString$1(value) !== "[object Array]" && $toString$1(value.callee) === "[object Function]";
};
var supportsStandardArguments = function() {
return isStandardArguments(arguments);
}();
isStandardArguments.isLegacyArguments = isLegacyArguments;
var isArguments$1 = supportsStandardArguments ? isStandardArguments : isLegacyArguments;
var toStr$2 = Object.prototype.toString;
var fnToStr$1 = Function.prototype.toString;
var isFnRegex = /^\s*(?:function)?\*/;
var hasToStringTag$2 = shams();
var getProto = Object.getPrototypeOf;
var getGeneratorFunc = function() {
if (!hasToStringTag$2) {
return false;
}
try {
return Function("return function*() {}")();
} catch (e) {
}
};
var GeneratorFunction;
var isGeneratorFunction = function isGeneratorFunction2(fn) {
if (typeof fn !== "function") {
return false;
}
if (isFnRegex.test(fnToStr$1.call(fn))) {
return true;
}
if (!hasToStringTag$2) {
var str = toStr$2.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;
};
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$1 = 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$1 = 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$1.call(all) === toStr$1.call(document.all)) {
isDDA = function isDocumentDotAll2(value) {
if ((isIE68 || !value) && (typeof value === "undefined" || typeof value === "object")) {
try {
var str = toStr$1.call(value);
return (str === ddaClass || str === ddaClass2 || str === ddaClass3 || str === objectClass) && value("") == null;
} catch (e) {
}
}
return false;
};
}
}
var isCallable$1 = 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 isCallable3(value) {
if (isDDA(value)) {
return true;
}
if (!value) {
return false;
}
if (typeof value !== "function" && typeof value !== "object") {
return false;
}
if (hasToStringTag$1) {
return tryFunctionObject(value);
}
if (isES6ClassFn(value)) {
return false;
}
var strClass = toStr$1.call(value);
if (strClass !== fnClass && strClass !== genClass && !/^\[object HTML/.test(strClass)) {
return false;
}
return tryFunctionObject(value);
};
var isCallable = isCallable$1;
var toStr = Object.prototype.toString;
var hasOwnProperty$a = Object.prototype.hasOwnProperty;
var forEachArray = function forEachArray2(array, iterator, receiver) {
for (var i = 0, len = array.length; i < len; i++) {
if (hasOwnProperty$a.call(array, i)) {
if (receiver == null) {
iterator(array[i], i, array);
} else {
iterator.call(receiver, array[i], i, array);
}
}
}
};
var forEachString = function forEachString2(string, iterator, receiver) {
for (var i = 0, len = string.length; i < len; i++) {
if (receiver == null) {
iterator(string.charAt(i), i, string);
} else {
iterator.call(receiver, string.charAt(i), i, string);
}
}
};
var forEachObject = function forEachObject2(object, iterator, receiver) {
for (var k in object) {
if (hasOwnProperty$a.call(object, k)) {
if (receiver == null) {
iterator(object[k], k, object);
} else {
iterator.call(receiver, object[k], k, object);
}
}
}
};
var forEach$1 = function forEach2(list, iterator, thisArg) {
if (!isCallable(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);
}
};
var forEach_1 = forEach$1;
var possibleTypedArrayNames = [
"Float32Array",
"Float64Array",
"Int8Array",
"Int16Array",
"Int32Array",
"Uint8Array",
"Uint8ClampedArray",
"Uint16Array",
"Uint32Array",
"BigInt64Array",
"BigUint64Array"
];
var possibleNames = possibleTypedArrayNames;
var g$1 = typeof globalThis === "undefined" ? commonjsGlobal : globalThis;
var availableTypedArrays$1 = function availableTypedArrays2() {
var out = [];
for (var i = 0; i < possibleNames.length; i++) {
if (typeof g$1[possibleNames[i]] === "function") {
out[out.length] = possibleNames[i];
}
}
return out;
};
var forEach = forEach_1;
var availableTypedArrays = availableTypedArrays$1;
var callBind = callBindExports;
var callBound = callBound$2;
var gOPD = gopd$1;
var $toString = callBound("Object.prototype.toString");
var hasToStringTag = shams();
var g = typeof globalThis === "undefined" ? commonjsGlobal : globalThis;
var typedArrays = availableTypedArrays();
var $slice = callBound("String.prototype.slice");
var getPrototypeOf = Object.getPrototypeOf;
var $indexOf = callBound("Array.prototype.indexOf", true) || function indexOf2(array, value) {
for (var i = 0; i < array.length; i += 1) {
if (array[i] === value) {
return i;
}
}
return -1;
};
var cache = { __proto__: null };
if (hasToStringTag && gOPD && getPrototypeOf) {
forEach(typedArrays, function(typedArray) {
var arr = new g[typedArray]();
if (Symbol.toStringTag in arr) {
var proto2 = getPrototypeOf(arr);
var descriptor = gOPD(proto2, Symbol.toStringTag);
if (!descriptor) {
var superProto = getPrototypeOf(proto2);
descriptor = gOPD(superProto, Symbol.toStringTag);
}
cache["$" + typedArray] = callBind(descriptor.get);
}
});
} else {
forEach(typedArrays, function(typedArray) {
var arr = new g[typedArray]();
var fn = arr.slice || arr.set;
if (fn) {
cache["$" + typedArray] = callBind(fn);
}
});
}
var tryTypedArrays = function tryAllTypedArrays(value) {
var found = false;
forEach(
// 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;
forEach(
// eslint-disable-next-line no-extra-parens
/** @type {Record<`\$${TypedArrayName}`, Getter>} */
/** @type {any} */
cache,
/** @type {(getter: typeof cache, name: `\$${import('.').TypedArrayName}`) => void} */
function(getter, name2) {
if (!found) {
try {
getter(value);
found = $slice(name2, 1);
} catch (e) {
}
}
}
);
return found;
};
var whichTypedArray$1 = 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);
};
var whichTypedArray = whichTypedArray$1;
var isTypedArray$1 = function isTypedArray2(value) {
return !!whichTypedArray(value);
};
(function(exports2) {
var isArgumentsObject = isArguments$1;
var isGeneratorFunction$1 = isGeneratorFunction;
var whichTypedArray3 = whichTypedArray$1;
var isTypedArray3 = isTypedArray$1;
function uncurryThis(f2) {
return f2.call.bind(f2);
}
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 = isGeneratorFunction$1;
exports2.isTypedArray = isTypedArray3;
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 isTypedArray3(value) || isDataView(value);
}
exports2.isArrayBufferView = isArrayBufferView;
function isUint8Array(value) {
return whichTypedArray3(value) === "Uint8Array";
}
exports2.isUint8Array = isUint8Array;
function isUint8ClampedArray(value) {
return whichTypedArray3(value) === "Uint8ClampedArray";
}
exports2.isUint8ClampedArray = isUint8ClampedArray;
function isUint16Array(value) {
return whichTypedArray3(value) === "Uint16Array";
}
exports2.isUint16Array = isUint16Array;
function isUint32Array(value) {
return whichTypedArray3(value) === "Uint32Array";
}
exports2.isUint32Array = isUint32Array;
function isInt8Array(value) {
return whichTypedArray3(value) === "Int8Array";
}
exports2.isInt8Array = isInt8Array;
function isInt16Array(value) {
return whichTypedArray3(value) === "Int16Array";
}
exports2.isInt16Array = isInt16Array;
function isInt32Array(value) {
return whichTypedArray3(value) === "Int32Array";
}
exports2.isInt32Array = isInt32Array;
function isFloat32Array(value) {
return whichTypedArray3(value) === "Float32Array";
}
exports2.isFloat32Array = isFloat32Array;
function isFloat64Array(value) {
return whichTypedArray3(value) === "Float64Array";
}
exports2.isFloat64Array = isFloat64Array;
function isBigInt64Array(value) {
return whichTypedArray3(value) === "BigInt64Array";
}
exports2.isBigInt64Array = isBigInt64Array;
function isBigUint64Array(value) {
return whichTypedArray3(value) === "BigUint64Array";
}
exports2.isBigUint64Array = isBigUint64Array;
function isMapToString(value) {
return ObjectToString(value) === "[object Map]";
}
isMapToString.working = typeof Map !== "undefined" && isMapToString(/* @__PURE__ */ new Map());
function isMap2(value) {
if (typeof Map === "undefined") {
return false;
}
return isMapToString.working ? isMapToString(value) : value instanceof Map;
}
exports2.isMap = isMap2;
function isSetToString(value) {
return ObjectToString(value) === "[object Set]";
}
isSetToString.working = typeof Set !== "undefined" && isSetToString(/* @__PURE__ */ new Set());
function isSet2(value) {
if (typeof Set === "undefined") {
return false;
}
return isSetToString.working ? isSetToString(value) : value instanceof Set;
}
exports2.isSet = isSet2;
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$1);
var isBufferBrowser = function isBuffer2(arg) {
return arg && typeof arg === "object" && typeof arg.copy === "function" && typeof arg.fill === "function" && typeof arg.readUInt8 === "function";
};
(function(exports2) {
var getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors || function getOwnPropertyDescriptors2(obj) {
var keys2 = Object.keys(obj);
var descriptors = {};
for (var i = 0; i < keys2.length; i++) {
descriptors[keys2[i]] = Object.getOwnPropertyDescriptor(obj, keys2[i]);
}
return descriptors;
};
var formatRegExp = /%[sdj%]/g;
exports2.format = function(f2) {
if (!isString2(f2)) {
var objects = [];
for (var i = 0; i < arguments.length; i++) {
objects.push(inspect6(arguments[i]));
}
return objects.join(" ");
}
var i = 1;
var args = arguments;
var len = args.length;
var str = String(f2).replace(formatRegExp, function(x2) {
if (x2 === "%%") return "%";
if (i >= len) return x2;
switch (x2) {
case "%s":
return String(args[i++]);
case "%d":
return Number(args[i++]);
case "%j":
try {
return JSON.stringify(args[i++]);
} catch (_) {
return "[Circular]";
}
default:
return x2;
}
});
for (var x = args[i]; i < len; x = args[++i]) {
if (isNull2(x) || !isObject2(x)) {
str += " " + x;
} else {
str += " " + inspect6(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 inspect6(obj, opts) {
var ctx = {
seen: [],
stylize: stylizeNoColor
};
if (arguments.length >= 3) ctx.depth = arguments[2];
if (arguments.length >= 4) ctx.colors = arguments[3];
if (isBoolean2(opts)) {
ctx.showHidden = opts;
} else if (opts) {
exports2._extend(ctx, opts);
}
if (isUndefined2(ctx.showHidden)) ctx.showHidden = false;
if (isUndefined2(ctx.depth)) ctx.depth = 2;
if (isUndefined2(ctx.colors)) ctx.colors = false;
if (isUndefined2(ctx.customInspect)) ctx.customInspect = true;
if (ctx.colors) ctx.stylize = stylizeWithColor;
return formatValue(ctx, obj, ctx.depth);
}
exports2.inspect = inspect6;
inspect6.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]
};
inspect6.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 = inspect6.styles[styleType];
if (style) {
return "\x1B[" + inspect6.colors[style][0] + "m" + str + "\x1B[" + inspect6.colors[style][1] + "m";
} else {
return str;
}
}
function stylizeNoColor(str, styleType) {
return str;
}
function arrayToHash(array) {
var hash3 = {};
array.forEach(function(val, idx) {
hash3[val] = true;
});
return hash3;
}
function formatValue(ctx, value, recurseTimes) {
if (ctx.customInspect && value && isFunction2(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 (!isString2(ret)) {
ret = formatValue(ctx, ret, recurseTimes);
}
return ret;
}
var primitive = formatPrimitive(ctx, value);
if (primitive) {
return primitive;
}
var keys2 = Object.keys(value);
var visibleKeys = arrayToHash(keys2);
if (ctx.showHidden) {
keys2 = Object.getOwnPropertyNames(value);
}
if (isError3(value) && (keys2.indexOf("message") >= 0 || keys2.indexOf("description") >= 0)) {
return formatError(value);
}
if (keys2.length === 0) {
if (isFunction2(value)) {
var name2 = value.name ? ": " + value.name : "";
return ctx.stylize("[Function" + name2 + "]", "special");
}
if (isRegExp2(value)) {
return ctx.stylize(RegExp.prototype.toString.call(value), "regexp");
}
if (isDate2(value)) {
return ctx.stylize(Date.prototype.toString.call(value), "date");
}
if (isError3(value)) {
return formatError(value);
}
}
var base2 = "", array = false, braces = ["{", "}"];
if (isArray2(value)) {
array = true;
braces = ["[", "]"];
}
if (isFunction2(value)) {
var n = value.name ? ": " + value.name : "";
base2 = " [Function" + n + "]";
}
if (isRegExp2(value)) {
base2 = " " + RegExp.prototype.toString.call(value);
}
if (isDate2(value)) {
base2 = " " + Date.prototype.toUTCString.call(value);
}
if (isError3(value)) {
base2 = " " + formatError(value);
}
if (keys2.length === 0 && (!array || value.length == 0)) {
return braces[0] + base2 + braces[1];
}
if (recurseTimes < 0) {
if (isRegExp2(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 = formatArray(ctx, value, recurseTimes, visibleKeys, keys2);
} else {
output = keys2.map(function(key2) {
return formatProperty(ctx, value, recurseTimes, visibleKeys, key2, array);
});
}
ctx.seen.pop();
return reduceToSingleString(output, base2, braces);
}
function formatPrimitive(ctx, value) {
if (isUndefined2(value))
return ctx.stylize("undefined", "undefined");
if (isString2(value)) {
var simple = "'" + JSON.stringify(value).replace(/^"|"$/g, "").replace(/'/g, "\\'").replace(/\\"/g, '"') + "'";
return ctx.stylize(simple, "string");
}
if (isNumber2(value))
return ctx.stylize("" + value, "number");
if (isBoolean2(value))
return ctx.stylize("" + value, "boolean");
if (isNull2(value))
return ctx.stylize("null", "null");
}
function formatError(value) {
return "[" + Error.prototype.toString.call(value) + "]";
}
function formatArray(ctx, value, recurseTimes, visibleKeys, keys2) {
var output = [];
for (var i = 0, l = value.length; i < l; ++i) {
if (hasOwnProperty2(value, String(i))) {
output.push(formatProperty(
ctx,
value,
recurseTimes,
visibleKeys,
String(i),
true
));
} else {
output.push("");
}
}
keys2.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 name2, 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 (!hasOwnProperty2(visibleKeys, key2)) {
name2 = "[" + key2 + "]";
}
if (!str) {
if (ctx.seen.indexOf(desc.value) < 0) {
if (isNull2(recurseTimes)) {
str = formatValue(ctx, desc.value, null);
} else {
str = formatValue(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 (isUndefined2(name2)) {
if (array && key2.match(/^\d+$/)) {
return str;
}
name2 = JSON.stringify("" + key2);
if (name2.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
name2 = name2.slice(1, -1);
name2 = ctx.stylize(name2, "name");
} else {
name2 = name2.replace(/'/g, "\\'").replace(/\\"/g, '"').replace(/(^"|"$)/g, "'");
name2 = ctx.stylize(name2, "string");
}
}
return name2 + ": " + 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 = types$1;
function isArray2(ar) {
return Array.isArray(ar);
}
exports2.isArray = isArray2;
function isBoolean2(arg) {
return typeof arg === "boolean";
}
exports2.isBoolean = isBoolean2;
function isNull2(arg) {
return arg === null;
}
exports2.isNull = isNull2;
function isNullOrUndefined2(arg) {
return arg == null;
}
exports2.isNullOrUndefined = isNullOrUndefined2;
function isNumber2(arg) {
return typeof arg === "number";
}
exports2.isNumber = isNumber2;
function isString2(arg) {
return typeof arg === "string";
}
exports2.isString = isString2;
function isSymbol2(arg) {
return typeof arg === "symbol";
}
exports2.isSymbol = isSymbol2;
function isUndefined2(arg) {
return arg === void 0;
}
exports2.isUndefined = isUndefined2;
function isRegExp2(re2) {
return isObject2(re2) && objectToString2(re2) === "[object RegExp]";
}
exports2.isRegExp = isRegExp2;
exports2.types.isRegExp = isRegExp2;
function isObject2(arg) {
return typeof arg === "object" && arg !== null;
}
exports2.isObject = isObject2;
function isDate2(d) {
return isObject2(d) && objectToString2(d) === "[object Date]";
}
exports2.isDate = isDate2;
exports2.types.isDate = isDate2;
function isError3(e) {
return isObject2(e) && (objectToString2(e) === "[object Error]" || e instanceof Error);
}
exports2.isError = isError3;
exports2.types.isNativeError = isError3;
function isFunction2(arg) {
return typeof arg === "function";
}
exports2.isFunction = isFunction2;
function isPrimitive2(arg) {
return arg === null || typeof arg === "boolean" || typeof arg === "number" || typeof arg === "string" || typeof arg === "symbol" || // ES6 symbol
typeof arg === "undefined";
}
exports2.isPrimitive = isPrimitive2;
exports2.isBuffer = isBufferBrowser;
function objectToString2(o) {
return Object.prototype.toString.call(o);
}
function pad2(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 = [
pad2(d.getHours()),
pad2(d.getMinutes()),
pad2(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 = inherits_browserExports;
exports2._extend = function(origin, add5) {
if (!add5 || !isObject2(add5)) return origin;
var keys2 = Object.keys(add5);
var i = keys2.length;
while (i--) {
origin[keys2[i]] = add5[keys2[i]];
}
return origin;
};
function hasOwnProperty2(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(resolve2, reject) {
promiseResolve = resolve2;
promiseReject = reject;
});
var args = [];
for (var i = 0; i < arguments.length; i++) {
args.push(arguments[i]);
}
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 i = 0; i < arguments.length; i++) {
args.push(arguments[i]);
}
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$4);
var buffer_list;
var hasRequiredBuffer_list;
function requireBuffer_list() {
if (hasRequiredBuffer_list) return buffer_list;
hasRequiredBuffer_list = 1;
function ownKeys(object, enumerableOnly) {
var keys2 = Object.keys(object);
if (Object.getOwnPropertySymbols) {
var symbols = Object.getOwnPropertySymbols(object);
enumerableOnly && (symbols = symbols.filter(function(sym) {
return Object.getOwnPropertyDescriptor(object, sym).enumerable;
})), keys2.push.apply(keys2, symbols);
}
return keys2;
}
function _objectSpread(target) {
for (var i = 1; i < arguments.length; i++) {
var source = null != arguments[i] ? arguments[i] : {};
i % 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 i = 0; i < props.length; i++) {
var descriptor = props[i];
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 || "default");
if (typeof res !== "object") return res;
throw new TypeError("@@toPrimitive must return a primitive value.");
}
return (hint === "string" ? String : Number)(input);
}
var _require = dist, Buffer2 = _require.Buffer;
var _require2 = util$4, inspect6 = _require2.inspect;
var custom2 = inspect6 && inspect6.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(s2) {
if (this.length === 0) return "";
var p = this.head;
var ret = "" + p.data;
while (p = p.next) ret += s2 + 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 i = 0;
while (p) {
copyBuffer(p.data, ret, i);
i += 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: custom2,
value: function value(_, options2) {
return inspect6(this, _objectSpread(_objectSpread({}, options2), {}, {
// Only inspect one level.
depth: 0,
// It should not recurse.
customInspect: false
}));
}
}]);
return BufferList2;
}();
return buffer_list;
}
function destroy$1(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$1, this, err);
} else if (!this._writableState.errorEmitted) {
this._writableState.errorEmitted = true;
process$1.nextTick(emitErrorNT$1, 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$1(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$1() {
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$1(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);
}
var destroy_1$1 = {
destroy: destroy$1,
undestroy: undestroy$1,
errorOrDestroy
};
var errorsBrowser = {};
function _inheritsLoose(subClass, superClass) {
subClass.prototype = Object.create(superClass.prototype);
subClass.prototype.constructor = subClass;
subClass.__proto__ = superClass;
}
var codes = {};
function createErrorType(code, message, Base2) {
if (!Base2) {
Base2 = 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;
}(Base2);
NodeError.prototype.name = Base2.name;
NodeError.prototype.code = code;
codes[code] = NodeError;
}
function oneOf(expected, thing) {
if (Array.isArray(expected)) {
var len = expected.length;
expected = expected.map(function(i) {
return String(i);
});
if (len > 2) {
return "one of ".concat(thing, " ").concat(expected.slice(0, len - 1).join(", "), ", or ") + expected[len - 1];
} else if (len === 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(name2, value) {
return 'The value "' + value + '" is invalid for option "' + name2 + '"';
}, TypeError);
createErrorType("ERR_INVALID_ARG_TYPE", function(name2, 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(name2, " argument")) {
msg = "The ".concat(name2, " ").concat(determiner, " ").concat(oneOf(expected, "type"));
} else {
var type2 = includes(name2, ".") ? "property" : "argument";
msg = 'The "'.concat(name2, '" ').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(name2) {
return "The " + name2 + " method is not implemented";
});
createErrorType("ERR_STREAM_PREMATURE_CLOSE", "Premature close");
createErrorType("ERR_STREAM_DESTROYED", function(name2) {
return "Cannot call " + name2 + " 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;
var ERR_INVALID_OPT_VALUE = errorsBrowser.codes.ERR_INVALID_OPT_VALUE;
function highWaterMarkFrom(options2, isDuplex, duplexKey) {
return options2.highWaterMark != null ? options2.highWaterMark : isDuplex ? options2[duplexKey] : null;
}
function getHighWaterMark(state2, options2, duplexKey, isDuplex) {
var hwm = highWaterMarkFrom(options2, isDuplex, duplexKey);
if (hwm != null) {
if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) {
var name2 = isDuplex ? duplexKey : "highWaterMark";
throw new ERR_INVALID_OPT_VALUE(name2, hwm);
}
return Math.floor(hwm);
}
return state2.objectMode ? 16 : 16 * 1024;
}
var state = {
getHighWaterMark
};
var browser$b = deprecate;
function deprecate(fn, msg) {
if (config$1("noDeprecation")) {
return fn;
}
var warned = false;
function deprecated() {
if (!warned) {
if (config$1("throwDeprecation")) {
throw new Error(msg);
} else if (config$1("traceDeprecation")) {
console.trace(msg);
} else {
console.warn(msg);
}
warned = true;
}
return fn.apply(this, arguments);
}
return deprecated;
}
function config$1(name2) {
try {
if (!commonjsGlobal.localStorage) return false;
} catch (_) {
return false;
}
var val = commonjsGlobal.localStorage[name2];
if (null == val) return false;
return String(val).toLowerCase() === "true";
}
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 Duplex2;
Writable.WritableState = WritableState;
var internalUtil = {
deprecate: browser$b
};
var Stream2 = streamBrowser$1;
var Buffer2 = dist.Buffer;
var OurUint8Array = (typeof commonjsGlobal !== "undefined" ? commonjsGlobal : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : {}).Uint8Array || function() {
};
function _uint8ArrayToBuffer(chunk) {
return Buffer2.from(chunk);
}
function _isUint8Array(obj) {
return Buffer2.isBuffer(obj) || obj instanceof OurUint8Array;
}
var destroyImpl = destroy_1$1;
var _require = state, getHighWaterMark2 = _require.getHighWaterMark;
var _require$codes2 = errorsBrowser.codes, ERR_INVALID_ARG_TYPE = _require$codes2.ERR_INVALID_ARG_TYPE, ERR_METHOD_NOT_IMPLEMENTED2 = _require$codes2.ERR_METHOD_NOT_IMPLEMENTED, ERR_MULTIPLE_CALLBACK2 = _require$codes2.ERR_MULTIPLE_CALLBACK, ERR_STREAM_CANNOT_PIPE = _require$codes2.ERR_STREAM_CANNOT_PIPE, ERR_STREAM_DESTROYED2 = _require$codes2.ERR_STREAM_DESTROYED, ERR_STREAM_NULL_VALUES = _require$codes2.ERR_STREAM_NULL_VALUES, ERR_STREAM_WRITE_AFTER_END = _require$codes2.ERR_STREAM_WRITE_AFTER_END, ERR_UNKNOWN_ENCODING = _require$codes2.ERR_UNKNOWN_ENCODING;
var errorOrDestroy2 = destroyImpl.errorOrDestroy;
inherits_browserExports(Writable, Stream2);
function nop() {
}
function WritableState(options2, stream, isDuplex) {
Duplex2 = Duplex2 || require_stream_duplex$1();
options2 = options2 || {};
if (typeof isDuplex !== "boolean") isDuplex = stream instanceof Duplex2;
this.objectMode = !!options2.objectMode;
if (isDuplex) this.objectMode = this.objectMode || !!options2.writableObjectMode;
this.highWaterMark = getHighWaterMark2(this, options2, "writableHighWaterMark", isDuplex);
this.finalCalled = false;
this.needDrain = false;
this.ending = false;
this.ended = false;
this.finished = false;
this.destroyed = false;
var noDecode = options2.decodeStrings === false;
this.decodeStrings = !noDecode;
this.defaultEncoding = options2.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 = options2.emitClose !== false;
this.autoDestroy = !!options2.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(options2) {
Duplex2 = Duplex2 || require_stream_duplex$1();
var isDuplex = this instanceof Duplex2;
if (!isDuplex && !realHasInstance.call(Writable, this)) return new Writable(options2);
this._writableState = new WritableState(options2, this, isDuplex);
this.writable = true;
if (options2) {
if (typeof options2.write === "function") this._write = options2.write;
if (typeof options2.writev === "function") this._writev = options2.writev;
if (typeof options2.destroy === "function") this._destroy = options2.destroy;
if (typeof options2.final === "function") this._final = options2.final;
}
Stream2.call(this);
}
Writable.prototype.pipe = function() {
errorOrDestroy2(this, new ERR_STREAM_CANNOT_PIPE());
};
function writeAfterEnd(stream, cb) {
var er = new ERR_STREAM_WRITE_AFTER_END();
errorOrDestroy2(stream, er);
process$1.nextTick(cb, er);
}
function validChunk(stream, state2, chunk, cb) {
var er;
if (chunk === null) {
er = new ERR_STREAM_NULL_VALUES();
} else if (typeof chunk !== "string" && !state2.objectMode) {
er = new ERR_INVALID_ARG_TYPE("chunk", ["string", "Buffer"], chunk);
}
if (er) {
errorOrDestroy2(stream, er);
process$1.nextTick(cb, er);
return false;
}
return true;
}
Writable.prototype.write = function(chunk, encoding, cb) {
var state2 = this._writableState;
var ret = false;
var isBuf = !state2.objectMode && _isUint8Array(chunk);
if (isBuf && !Buffer2.isBuffer(chunk)) {
chunk = _uint8ArrayToBuffer(chunk);
}
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, chunk, cb)) {
state2.pendingcb++;
ret = writeOrBuffer(this, state2, isBuf, chunk, 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, chunk, encoding) {
if (!state2.objectMode && state2.decodeStrings !== false && typeof chunk === "string") {
chunk = Buffer2.from(chunk, encoding);
}
return chunk;
}
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, chunk, encoding, cb) {
if (!isBuf) {
var newChunk = decodeChunk(state2, chunk, encoding);
if (chunk !== newChunk) {
isBuf = true;
encoding = "buffer";
chunk = newChunk;
}
}
var len = state2.objectMode ? 1 : chunk.length;
state2.length += len;
var ret = state2.length < state2.highWaterMark;
if (!ret) state2.needDrain = true;
if (state2.writing || state2.corked) {
var last = state2.lastBufferedRequest;
state2.lastBufferedRequest = {
chunk,
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, len, chunk, encoding, cb);
}
return ret;
}
function doWrite(stream, state2, writev, len, chunk, encoding, cb) {
state2.writelen = len;
state2.writecb = cb;
state2.writing = true;
state2.sync = true;
if (state2.destroyed) state2.onwrite(new ERR_STREAM_DESTROYED2("write"));
else if (writev) stream._writev(chunk, state2.onwrite);
else stream._write(chunk, encoding, state2.onwrite);
state2.sync = false;
}
function onwriteError(stream, state2, sync2, er, cb) {
--state2.pendingcb;
if (sync2) {
process$1.nextTick(cb, er);
process$1.nextTick(finishMaybe, stream, state2);
stream._writableState.errorEmitted = true;
errorOrDestroy2(stream, er);
} else {
cb(er);
stream._writableState.errorEmitted = true;
errorOrDestroy2(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 sync2 = state2.sync;
var cb = state2.writecb;
if (typeof cb !== "function") throw new ERR_MULTIPLE_CALLBACK2();
onwriteStateUpdate(state2);
if (er) onwriteError(stream, state2, sync2, er, cb);
else {
var finished = needFinish(state2) || stream.destroyed;
if (!finished && !state2.corked && !state2.bufferProcessing && state2.bufferedRequest) {
clearBuffer(stream, state2);
}
if (sync2) {
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 chunk = entry.chunk;
var encoding = entry.encoding;
var cb = entry.callback;
var len = state2.objectMode ? 1 : chunk.length;
doWrite(stream, state2, false, len, chunk, 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(chunk, encoding, cb) {
cb(new ERR_METHOD_NOT_IMPLEMENTED2("_write()"));
};
Writable.prototype._writev = null;
Writable.prototype.end = function(chunk, encoding, cb) {
var state2 = this._writableState;
if (typeof chunk === "function") {
cb = chunk;
chunk = null;
encoding = null;
} else if (typeof encoding === "function") {
cb = encoding;
encoding = null;
}
if (chunk !== null && chunk !== void 0) this.write(chunk, 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) {
errorOrDestroy2(stream, err);
}
state2.prefinished = true;
stream.emit("prefinish");
finishMaybe(stream, state2);
});
}
function prefinish2(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) {
prefinish2(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 keys3 = [];
for (var key2 in obj) keys3.push(key2);
return keys3;
};
_stream_duplex$1 = Duplex2;
var Readable = require_stream_readable$1();
var Writable = require_stream_writable$1();
inherits_browserExports(Duplex2, Readable);
{
var keys2 = objectKeys(Writable.prototype);
for (var v = 0; v < keys2.length; v++) {
var method = keys2[v];
if (!Duplex2.prototype[method]) Duplex2.prototype[method] = Writable.prototype[method];
}
}
function Duplex2(options2) {
if (!(this instanceof Duplex2)) return new Duplex2(options2);
Readable.call(this, options2);
Writable.call(this, options2);
this.allowHalfOpen = true;
if (options2) {
if (options2.readable === false) this.readable = false;
if (options2.writable === false) this.writable = false;
if (options2.allowHalfOpen === false) {
this.allowHalfOpen = false;
this.once("end", onend);
}
}
}
Object.defineProperty(Duplex2.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(Duplex2.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(Duplex2.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(Duplex2.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 Buffer$C = safeBufferExports$1.Buffer;
var isEncoding = Buffer$C.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" && (Buffer$C.isEncoding === isEncoding || !isEncoding(enc))) throw new Error("Unknown encoding: " + enc);
return nenc || enc;
}
string_decoder.StringDecoder = StringDecoder$1;
function StringDecoder$1(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 = Buffer$C.allocUnsafe(nb);
}
StringDecoder$1.prototype.write = function(buf) {
if (buf.length === 0) return "";
var r2;
var i;
if (this.lastNeed) {
r2 = this.fillLast(buf);
if (r2 === void 0) return "";
i = this.lastNeed;
this.lastNeed = 0;
} else {
i = 0;
}
if (i < buf.length) return r2 ? r2 + this.text(buf, i) : this.text(buf, i);
return r2 || "";
};
StringDecoder$1.prototype.end = utf8End;
StringDecoder$1.prototype.text = utf8Text;
StringDecoder$1.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, i) {
var j = buf.length - 1;
if (j < i) return 0;
var nb = utf8CheckByte(buf[j]);
if (nb >= 0) {
if (nb > 0) self2.lastNeed = nb - 1;
return nb;
}
if (--j < i || nb === -2) return 0;
nb = utf8CheckByte(buf[j]);
if (nb >= 0) {
if (nb > 0) self2.lastNeed = nb - 2;
return nb;
}
if (--j < i || 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 r2 = utf8CheckExtraBytes(this, buf);
if (r2 !== void 0) return r2;
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, i) {
var total = utf8CheckIncomplete(this, buf, i);
if (!this.lastNeed) return buf.toString("utf8", i);
this.lastTotal = total;
var end = buf.length - (total - this.lastNeed);
buf.copy(this.lastChar, 0, end);
return buf.toString("utf8", i, end);
}
function utf8End(buf) {
var r2 = buf && buf.length ? this.write(buf) : "";
if (this.lastNeed) return r2 + "�";
return r2;
}
function utf16Text(buf, i) {
if ((buf.length - i) % 2 === 0) {
var r2 = buf.toString("utf16le", i);
if (r2) {
var c = r2.charCodeAt(r2.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 r2.slice(0, -1);
}
}
return r2;
}
this.lastNeed = 1;
this.lastTotal = 2;
this.lastChar[0] = buf[buf.length - 1];
return buf.toString("utf16le", i, buf.length - 1);
}
function utf16End(buf) {
var r2 = buf && buf.length ? this.write(buf) : "";
if (this.lastNeed) {
var end = this.lastTotal - this.lastNeed;
return r2 + this.lastChar.toString("utf16le", 0, end);
}
return r2;
}
function base64Text(buf, i) {
var n = (buf.length - i) % 3;
if (n === 0) return buf.toString("base64", i);
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", i, buf.length - n);
}
function base64End(buf) {
var r2 = buf && buf.length ? this.write(buf) : "";
if (this.lastNeed) return r2 + this.lastChar.toString("base64", 0, 3 - this.lastNeed);
return r2;
}
function simpleWrite(buf) {
return buf.toString(this.encoding);
}
function simpleEnd(buf) {
return buf && buf.length ? this.write(buf) : "";
}
var ERR_STREAM_PREMATURE_CLOSE = errorsBrowser.codes.ERR_STREAM_PREMATURE_CLOSE;
function once$1(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 noop$1() {
}
function isRequest$1(stream) {
return stream.setHeader && typeof stream.abort === "function";
}
function eos$1(stream, opts, callback) {
if (typeof opts === "function") return eos$1(stream, null, opts);
if (!opts) opts = {};
callback = once$1(callback || noop$1);
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$1(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);
};
}
var endOfStream = eos$1;
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 || "default");
if (typeof res !== "object") return res;
throw new TypeError("@@toPrimitive must return a primitive value.");
}
return (hint === "string" ? String : Number)(input);
}
var finished = endOfStream;
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, done2) {
return {
value,
done: done2
};
}
function readAndResolve(iter) {
var resolve2 = iter[kLastResolve];
if (resolve2 !== null) {
var data = iter[kStream].read();
if (data !== null) {
iter[kLastPromise] = null;
iter[kLastResolve] = null;
iter[kLastReject] = null;
resolve2(createIterResult(data, false));
}
}
}
function onReadable(iter) {
process$1.nextTick(readAndResolve, iter);
}
function wrapForNext(lastPromise, iter) {
return function(resolve2, reject) {
lastPromise.then(function() {
if (iter[kEnded]) {
resolve2(createIterResult(void 0, true));
return;
}
iter[kHandlePromise](resolve2, 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 error2 = this[kError];
if (error2 !== null) {
return Promise.reject(error2);
}
if (this[kEnded]) {
return Promise.resolve(createIterResult(void 0, true));
}
if (this[kStream].destroyed) {
return new Promise(function(resolve2, reject) {
process$1.nextTick(function() {
if (_this[kError]) {
reject(_this[kError]);
} else {
resolve2(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(resolve2, reject) {
_this2[kStream].destroy(null, function(err) {
if (err) {
reject(err);
return;
}
resolve2(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(resolve2, reject) {
var data = iterator[kStream].read();
if (data) {
iterator[kLastPromise] = null;
iterator[kLastResolve] = null;
iterator[kLastReject] = null;
resolve2(createIterResult(data, false));
} else {
iterator[kLastResolve] = resolve2;
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 resolve2 = iterator[kLastResolve];
if (resolve2 !== null) {
iterator[kLastPromise] = null;
iterator[kLastResolve] = null;
iterator[kLastReject] = null;
resolve2(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 Duplex2;
Readable.ReadableState = ReadableState;
eventsExports.EventEmitter;
var EElistenerCount = function EElistenerCount2(emitter, type2) {
return emitter.listeners(type2).length;
};
var Stream2 = streamBrowser$1;
var Buffer2 = dist.Buffer;
var OurUint8Array = (typeof commonjsGlobal !== "undefined" ? commonjsGlobal : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : {}).Uint8Array || function() {
};
function _uint8ArrayToBuffer(chunk) {
return Buffer2.from(chunk);
}
function _isUint8Array(obj) {
return Buffer2.isBuffer(obj) || obj instanceof OurUint8Array;
}
var debugUtil = util$4;
var debug;
if (debugUtil && debugUtil.debuglog) {
debug = debugUtil.debuglog("stream");
} else {
debug = function debug2() {
};
}
var BufferList2 = requireBuffer_list();
var destroyImpl = destroy_1$1;
var _require = state, getHighWaterMark2 = _require.getHighWaterMark;
var _require$codes2 = errorsBrowser.codes, ERR_INVALID_ARG_TYPE = _require$codes2.ERR_INVALID_ARG_TYPE, ERR_STREAM_PUSH_AFTER_EOF = _require$codes2.ERR_STREAM_PUSH_AFTER_EOF, ERR_METHOD_NOT_IMPLEMENTED2 = _require$codes2.ERR_METHOD_NOT_IMPLEMENTED, ERR_STREAM_UNSHIFT_AFTER_END_EVENT = _require$codes2.ERR_STREAM_UNSHIFT_AFTER_END_EVENT;
var StringDecoder2;
var createReadableStreamAsyncIterator;
var from;
inherits_browserExports(Readable, Stream2);
var errorOrDestroy2 = destroyImpl.errorOrDestroy;
var kProxyEvents = ["error", "close", "destroy", "pause", "resume"];
function prependListener2(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(options2, stream, isDuplex) {
Duplex2 = Duplex2 || require_stream_duplex$1();
options2 = options2 || {};
if (typeof isDuplex !== "boolean") isDuplex = stream instanceof Duplex2;
this.objectMode = !!options2.objectMode;
if (isDuplex) this.objectMode = this.objectMode || !!options2.readableObjectMode;
this.highWaterMark = getHighWaterMark2(this, options2, "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 = options2.emitClose !== false;
this.autoDestroy = !!options2.autoDestroy;
this.destroyed = false;
this.defaultEncoding = options2.defaultEncoding || "utf8";
this.awaitDrain = 0;
this.readingMore = false;
this.decoder = null;
this.encoding = null;
if (options2.encoding) {
if (!StringDecoder2) StringDecoder2 = string_decoder.StringDecoder;
this.decoder = new StringDecoder2(options2.encoding);
this.encoding = options2.encoding;
}
}
function Readable(options2) {
Duplex2 = Duplex2 || require_stream_duplex$1();
if (!(this instanceof Readable)) return new Readable(options2);
var isDuplex = this instanceof Duplex2;
this._readableState = new ReadableState(options2, this, isDuplex);
this.readable = true;
if (options2) {
if (typeof options2.read === "function") this._read = options2.read;
if (typeof options2.destroy === "function") this._destroy = options2.destroy;
}
Stream2.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(chunk, encoding) {
var state2 = this._readableState;
var skipChunkCheck;
if (!state2.objectMode) {
if (typeof chunk === "string") {
encoding = encoding || state2.defaultEncoding;
if (encoding !== state2.encoding) {
chunk = Buffer2.from(chunk, encoding);
encoding = "";
}
skipChunkCheck = true;
}
} else {
skipChunkCheck = true;
}
return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);
};
Readable.prototype.unshift = function(chunk) {
return readableAddChunk(this, chunk, null, true, false);
};
function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {
debug("readableAddChunk", chunk);
var state2 = stream._readableState;
if (chunk === null) {
state2.reading = false;
onEofChunk(stream, state2);
} else {
var er;
if (!skipChunkCheck) er = chunkInvalid(state2, chunk);
if (er) {
errorOrDestroy2(stream, er);
} else if (state2.objectMode || chunk && chunk.length > 0) {
if (typeof chunk !== "string" && !state2.objectMode && Object.getPrototypeOf(chunk) !== Buffer2.prototype) {
chunk = _uint8ArrayToBuffer(chunk);
}
if (addToFront) {
if (state2.endEmitted) errorOrDestroy2(stream, new ERR_STREAM_UNSHIFT_AFTER_END_EVENT());
else addChunk(stream, state2, chunk, true);
} else if (state2.ended) {
errorOrDestroy2(stream, new ERR_STREAM_PUSH_AFTER_EOF());
} else if (state2.destroyed) {
return false;
} else {
state2.reading = false;
if (state2.decoder && !encoding) {
chunk = state2.decoder.write(chunk);
if (state2.objectMode || chunk.length !== 0) addChunk(stream, state2, chunk, false);
else maybeReadMore(stream, state2);
} else {
addChunk(stream, state2, chunk, false);
}
}
} else if (!addToFront) {
state2.reading = false;
maybeReadMore(stream, state2);
}
}
return !state2.ended && (state2.length < state2.highWaterMark || state2.length === 0);
}
function addChunk(stream, state2, chunk, addToFront) {
if (state2.flowing && state2.length === 0 && !state2.sync) {
state2.awaitDrain = 0;
stream.emit("data", chunk);
} else {
state2.length += state2.objectMode ? 1 : chunk.length;
if (addToFront) state2.buffer.unshift(chunk);
else state2.buffer.push(chunk);
if (state2.needReadable) emitReadable(stream);
}
maybeReadMore(stream, state2);
}
function chunkInvalid(state2, chunk) {
var er;
if (!_isUint8Array(chunk) && typeof chunk !== "string" && chunk !== void 0 && !state2.objectMode) {
er = new ERR_INVALID_ARG_TYPE("chunk", ["string", "Buffer", "Uint8Array"], chunk);
}
return er;
}
Readable.prototype.isPaused = function() {
return this._readableState.flowing === false;
};
Readable.prototype.setEncoding = function(enc) {
if (!StringDecoder2) StringDecoder2 = string_decoder.StringDecoder;
var decoder = new StringDecoder2(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 chunk = state2.decoder.end();
if (chunk && chunk.length) {
state2.buffer.push(chunk);
state2.length += state2.objectMode ? 1 : chunk.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 len = state2.length;
debug("maybeReadMore read 0");
stream.read(0);
if (len === state2.length)
break;
}
state2.readingMore = false;
}
Readable.prototype._read = function(n) {
errorOrDestroy2(this, new ERR_METHOD_NOT_IMPLEMENTED2("_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(chunk) {
debug("ondata");
var ret = dest.write(chunk);
debug("dest.write", ret);
if (ret === false) {
if ((state2.pipesCount === 1 && state2.pipes === dest || state2.pipesCount > 1 && indexOf3(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) errorOrDestroy2(dest, er);
}
prependListener2(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 len = state2.pipesCount;
state2.pipes = null;
state2.pipesCount = 0;
state2.flowing = false;
for (var i = 0; i < len; i++) dests[i].emit("unpipe", this, {
hasUnpiped: false
});
return this;
}
var index = indexOf3(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 = Stream2.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 = Stream2.prototype.removeListener.call(this, ev, fn);
if (ev === "readable") {
process$1.nextTick(updateReadableListening, this);
}
return res;
};
Readable.prototype.removeAllListeners = function(ev) {
var res = Stream2.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 chunk = state2.decoder.end();
if (chunk && chunk.length) _this.push(chunk);
}
_this.push(null);
});
stream.on("data", function(chunk) {
debug("wrapped data");
if (state2.decoder) chunk = state2.decoder.write(chunk);
if (state2.objectMode && (chunk === null || chunk === void 0)) return;
else if (!state2.objectMode && (!chunk || !chunk.length)) return;
var ret = _this.push(chunk);
if (!ret) {
paused = true;
stream.pause();
}
});
for (var i in stream) {
if (this[i] === void 0 && typeof stream[i] === "function") {
this[i] = /* @__PURE__ */ function methodWrap(method) {
return function methodWrapReturnFunction() {
return stream[method].apply(stream, arguments);
};
}(i);
}
}
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 indexOf3(xs, x) {
for (var i = 0, l = xs.length; i < l; i++) {
if (xs[i] === x) return i;
}
return -1;
}
return _stream_readable$1;
}
var _stream_transform$1 = Transform$9;
var _require$codes$1 = errorsBrowser.codes, ERR_METHOD_NOT_IMPLEMENTED = _require$codes$1.ERR_METHOD_NOT_IMPLEMENTED, ERR_MULTIPLE_CALLBACK = _require$codes$1.ERR_MULTIPLE_CALLBACK, ERR_TRANSFORM_ALREADY_TRANSFORMING = _require$codes$1.ERR_TRANSFORM_ALREADY_TRANSFORMING, ERR_TRANSFORM_WITH_LENGTH_0 = _require$codes$1.ERR_TRANSFORM_WITH_LENGTH_0;
var Duplex$1 = require_stream_duplex$1();
inherits_browserExports(Transform$9, Duplex$1);
function afterTransform$1(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$9(options2) {
if (!(this instanceof Transform$9)) return new Transform$9(options2);
Duplex$1.call(this, options2);
this._transformState = {
afterTransform: afterTransform$1.bind(this),
needTransform: false,
transforming: false,
writecb: null,
writechunk: null,
writeencoding: null
};
this._readableState.needReadable = true;
this._readableState.sync = false;
if (options2) {
if (typeof options2.transform === "function") this._transform = options2.transform;
if (typeof options2.flush === "function") this._flush = options2.flush;
}
this.on("prefinish", prefinish$1);
}
function prefinish$1() {
var _this = this;
if (typeof this._flush === "function" && !this._readableState.destroyed) {
this._flush(function(er, data) {
done$1(_this, er, data);
});
} else {
done$1(this, null, null);
}
}
Transform$9.prototype.push = function(chunk, encoding) {
this._transformState.needTransform = false;
return Duplex$1.prototype.push.call(this, chunk, encoding);
};
Transform$9.prototype._transform = function(chunk, encoding, cb) {
cb(new ERR_METHOD_NOT_IMPLEMENTED("_transform()"));
};
Transform$9.prototype._write = function(chunk, encoding, cb) {
var ts = this._transformState;
ts.writecb = cb;
ts.writechunk = chunk;
ts.writeencoding = encoding;
if (!ts.transforming) {
var rs = this._readableState;
if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);
}
};
Transform$9.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$9.prototype._destroy = function(err, cb) {
Duplex$1.prototype._destroy.call(this, err, function(err2) {
cb(err2);
});
};
function done$1(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);
}
var _stream_passthrough$1 = PassThrough$1;
var Transform$8 = _stream_transform$1;
inherits_browserExports(PassThrough$1, Transform$8);
function PassThrough$1(options2) {
if (!(this instanceof PassThrough$1)) return new PassThrough$1(options2);
Transform$8.call(this, options2);
}
PassThrough$1.prototype._transform = function(chunk, encoding, cb) {
cb(null, chunk);
};
var eos;
function once(callback) {
var called = false;
return function() {
if (called) return;
called = true;
callback.apply(void 0, arguments);
};
}
var _require$codes = errorsBrowser.codes, ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS, ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED;
function noop(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 = endOfStream;
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 noop;
if (typeof streams[streams.length - 1] !== "function") return noop;
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 error2;
var destroys = streams.map(function(stream, i) {
var reading = i < streams.length - 1;
var writing = i > 0;
return destroyer(stream, reading, writing, function(err) {
if (!error2) error2 = err;
if (err) destroys.forEach(call);
if (reading) return;
destroys.forEach(call);
callback(error2);
});
});
return streams.reduce(pipe);
}
var pipeline_1 = pipeline;
(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 = _stream_transform$1;
exports2.PassThrough = _stream_passthrough$1;
exports2.finished = endOfStream;
exports2.pipeline = pipeline_1;
})(readableBrowser$1, readableBrowser$1.exports);
var readableBrowserExports$1 = readableBrowser$1.exports;
var Buffer$B = safeBufferExports$1.Buffer;
var Transform$7 = readableBrowserExports$1.Transform;
var inherits$q = inherits_browserExports;
function throwIfNotStringOrBuffer(val, prefix) {
if (!Buffer$B.isBuffer(val) && typeof val !== "string") {
throw new TypeError(prefix + " must be a string or a buffer");
}
}
function HashBase$2(blockSize2) {
Transform$7.call(this);
this._block = Buffer$B.allocUnsafe(blockSize2);
this._blockSize = blockSize2;
this._blockOffset = 0;
this._length = [0, 0, 0, 0];
this._finalized = false;
}
inherits$q(HashBase$2, Transform$7);
HashBase$2.prototype._transform = function(chunk, encoding, callback) {
var error2 = null;
try {
this.update(chunk, encoding);
} catch (err) {
error2 = err;
}
callback(error2);
};
HashBase$2.prototype._flush = function(callback) {
var error2 = null;
try {
this.push(this.digest());
} catch (err) {
error2 = err;
}
callback(error2);
};
HashBase$2.prototype.update = function(data, encoding) {
throwIfNotStringOrBuffer(data, "Data");
if (this._finalized) throw new Error("Digest already called");
if (!Buffer$B.isBuffer(data)) data = Buffer$B.from(data, encoding);
var block = this._block;
var offset = 0;
while (this._blockOffset + data.length - offset >= this._blockSize) {
for (var i = this._blockOffset; i < this._blockSize; ) block[i++] = data[offset++];
this._update();
this._blockOffset = 0;
}
while (offset < data.length) block[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$2.prototype._update = function() {
throw new Error("_update is not implemented");
};
HashBase$2.prototype.digest = function(encoding) {
if (this._finalized) throw new Error("Digest already called");
this._finalized = true;
var digest9 = this._digest();
if (encoding !== void 0) digest9 = digest9.toString(encoding);
this._block.fill(0);
this._blockOffset = 0;
for (var i = 0; i < 4; ++i) this._length[i] = 0;
return digest9;
};
HashBase$2.prototype._digest = function() {
throw new Error("_digest is not implemented");
};
var hashBase = HashBase$2;
var inherits$p = inherits_browserExports;
var HashBase$1 = hashBase;
var Buffer$A = safeBufferExports$1.Buffer;
var ARRAY16$1 = new Array(16);
function MD5$3() {
HashBase$1.call(this, 64);
this._a = 1732584193;
this._b = 4023233417;
this._c = 2562383102;
this._d = 271733878;
}
inherits$p(MD5$3, HashBase$1);
MD5$3.prototype._update = function() {
var M = ARRAY16$1;
for (var i = 0; i < 16; ++i) M[i] = this._block.readInt32LE(i * 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$3.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 = Buffer$A.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$1(x, n) {
return x << n | x >>> 32 - n;
}
function fnF(a, b, c, d, m, k, s2) {
return rotl$1(a + (b & c | ~b & d) + m + k | 0, s2) + b | 0;
}
function fnG(a, b, c, d, m, k, s2) {
return rotl$1(a + (b & d | c & ~d) + m + k | 0, s2) + b | 0;
}
function fnH(a, b, c, d, m, k, s2) {
return rotl$1(a + (b ^ c ^ d) + m + k | 0, s2) + b | 0;
}
function fnI(a, b, c, d, m, k, s2) {
return rotl$1(a + (c ^ (b | ~d)) + m + k | 0, s2) + b | 0;
}
var md5_js = MD5$3;
var Buffer$z = dist.Buffer;
var inherits$o = inherits_browserExports;
var HashBase = hashBase;
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$4() {
HashBase.call(this, 64);
this._a = 1732584193;
this._b = 4023233417;
this._c = 2562383102;
this._d = 271733878;
this._e = 3285377520;
}
inherits$o(RIPEMD160$4, HashBase);
RIPEMD160$4.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 i = 0; i < 80; i += 1) {
var tl;
var tr;
if (i < 16) {
tl = fn1(al, bl, cl, dl, el, words[zl[i]], hl[0], sl[i]);
tr = fn5(ar, br, cr, dr, er, words[zr[i]], hr[0], sr[i]);
} else if (i < 32) {
tl = fn2(al, bl, cl, dl, el, words[zl[i]], hl[1], sl[i]);
tr = fn4(ar, br, cr, dr, er, words[zr[i]], hr[1], sr[i]);
} else if (i < 48) {
tl = fn3(al, bl, cl, dl, el, words[zl[i]], hl[2], sl[i]);
tr = fn3(ar, br, cr, dr, er, words[zr[i]], hr[2], sr[i]);
} else if (i < 64) {
tl = fn4(al, bl, cl, dl, el, words[zl[i]], hl[3], sl[i]);
tr = fn2(ar, br, cr, dr, er, words[zr[i]], hr[3], sr[i]);
} else {
tl = fn5(al, bl, cl, dl, el, words[zl[i]], hl[4], sl[i]);
tr = fn1(ar, br, cr, dr, er, words[zr[i]], hr[4], sr[i]);
}
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$4.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 = Buffer$z.alloc ? Buffer$z.alloc(20) : new Buffer$z(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, s2) {
return rotl(a + (b ^ c ^ d) + m + k | 0, s2) + e | 0;
}
function fn2(a, b, c, d, e, m, k, s2) {
return rotl(a + (b & c | ~b & d) + m + k | 0, s2) + e | 0;
}
function fn3(a, b, c, d, e, m, k, s2) {
return rotl(a + ((b | ~c) ^ d) + m + k | 0, s2) + e | 0;
}
function fn4(a, b, c, d, e, m, k, s2) {
return rotl(a + (b & d | c & ~d) + m + k | 0, s2) + e | 0;
}
function fn5(a, b, c, d, e, m, k, s2) {
return rotl(a + (b ^ (c | ~d)) + m + k | 0, s2) + e | 0;
}
var ripemd160 = RIPEMD160$4;
var sha_js = { exports: {} };
var Buffer$y = safeBufferExports$1.Buffer;
function Hash$8(blockSize2, finalSize) {
this._block = Buffer$y.alloc(blockSize2);
this._finalSize = finalSize;
this._blockSize = blockSize2;
this._len = 0;
}
Hash$8.prototype.update = function(data, enc) {
if (typeof data === "string") {
enc = enc || "utf8";
data = Buffer$y.from(data, enc);
}
var block = this._block;
var blockSize2 = this._blockSize;
var length = data.length;
var accum = this._len;
for (var offset = 0; offset < length; ) {
var assigned = accum % blockSize2;
var remainder = Math.min(length - offset, blockSize2 - assigned);
for (var i = 0; i < remainder; i++) {
block[assigned + i] = data[offset + i];
}
accum += remainder;
offset += remainder;
if (accum % blockSize2 === 0) {
this._update(block);
}
}
this._len += length;
return this;
};
Hash$8.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 hash3 = this._hash();
return enc ? hash3.toString(enc) : hash3;
};
Hash$8.prototype._update = function() {
throw new Error("_update must be implemented by subclass");
};
var hash$3 = Hash$8;
var inherits$n = inherits_browserExports;
var Hash$7 = hash$3;
var Buffer$x = safeBufferExports$1.Buffer;
var K$4 = [
1518500249,
1859775393,
2400959708 | 0,
3395469782 | 0
];
var W$5 = new Array(80);
function Sha() {
this.init();
this._w = W$5;
Hash$7.call(this, 64, 56);
}
inherits$n(Sha, Hash$7);
Sha.prototype.init = function() {
this._a = 1732584193;
this._b = 4023233417;
this._c = 2562383102;
this._d = 271733878;
this._e = 3285377520;
return this;
};
function rotl5$1(num) {
return num << 5 | num >>> 27;
}
function rotl30$1(num) {
return num << 30 | num >>> 2;
}
function ft$1(s2, b, c, d) {
if (s2 === 0) return b & c | ~b & d;
if (s2 === 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 i = 0; i < 16; ++i) W2[i] = M.readInt32BE(i * 4);
for (; i < 80; ++i) W2[i] = W2[i - 3] ^ W2[i - 8] ^ W2[i - 14] ^ W2[i - 16];
for (var j = 0; j < 80; ++j) {
var s2 = ~~(j / 20);
var t = rotl5$1(a) + ft$1(s2, b, c, d) + e + W2[j] + K$4[s2] | 0;
e = d;
d = c;
c = rotl30$1(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 = Buffer$x.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;
};
var sha$4 = Sha;
var inherits$m = inherits_browserExports;
var Hash$6 = hash$3;
var Buffer$w = safeBufferExports$1.Buffer;
var K$3 = [
1518500249,
1859775393,
2400959708 | 0,
3395469782 | 0
];
var W$4 = new Array(80);
function Sha1() {
this.init();
this._w = W$4;
Hash$6.call(this, 64, 56);
}
inherits$m(Sha1, Hash$6);
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(s2, b, c, d) {
if (s2 === 0) return b & c | ~b & d;
if (s2 === 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 i = 0; i < 16; ++i) W2[i] = M.readInt32BE(i * 4);
for (; i < 80; ++i) W2[i] = rotl1(W2[i - 3] ^ W2[i - 8] ^ W2[i - 14] ^ W2[i - 16]);
for (var j = 0; j < 80; ++j) {
var s2 = ~~(j / 20);
var t = rotl5(a) + ft(s2, b, c, d) + e + W2[j] + K$3[s2] | 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 = Buffer$w.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;
};
var sha1 = Sha1;
var inherits$l = inherits_browserExports;
var Hash$5 = hash$3;
var Buffer$v = safeBufferExports$1.Buffer;
var K$2 = [
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$3 = new Array(64);
function Sha256$1() {
this.init();
this._w = W$3;
Hash$5.call(this, 64, 56);
}
inherits$l(Sha256$1, Hash$5);
Sha256$1.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, z2) {
return z2 ^ x & (y ^ z2);
}
function maj$1(x, y, z2) {
return x & y | z2 & (x | y);
}
function sigma0$1(x) {
return (x >>> 2 | x << 30) ^ (x >>> 13 | x << 19) ^ (x >>> 22 | x << 10);
}
function sigma1$1(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$1.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 f2 = this._f | 0;
var g2 = this._g | 0;
var h = this._h | 0;
for (var i = 0; i < 16; ++i) W2[i] = M.readInt32BE(i * 4);
for (; i < 64; ++i) W2[i] = gamma1(W2[i - 2]) + W2[i - 7] + gamma0(W2[i - 15]) + W2[i - 16] | 0;
for (var j = 0; j < 64; ++j) {
var T1 = h + sigma1$1(e) + ch(e, f2, g2) + K$2[j] + W2[j] | 0;
var T2 = sigma0$1(a) + maj$1(a, b, c) | 0;
h = g2;
g2 = f2;
f2 = 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 = f2 + this._f | 0;
this._g = g2 + this._g | 0;
this._h = h + this._h | 0;
};
Sha256$1.prototype._hash = function() {
var H = Buffer$v.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;
};
var sha256$1 = Sha256$1;
var inherits$k = inherits_browserExports;
var Sha256 = sha256$1;
var Hash$4 = hash$3;
var Buffer$u = safeBufferExports$1.Buffer;
var W$2 = new Array(64);
function Sha224() {
this.init();
this._w = W$2;
Hash$4.call(this, 64, 56);
}
inherits$k(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 = Buffer$u.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;
};
var sha224$1 = Sha224;
var inherits$j = inherits_browserExports;
var Hash$3 = hash$3;
var Buffer$t = safeBufferExports$1.Buffer;
var K$1 = [
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$1 = new Array(160);
function Sha512() {
this.init();
this._w = W$1;
Hash$3.call(this, 128, 112);
}
inherits$j(Sha512, Hash$3);
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, z2) {
return z2 ^ x & (y ^ z2);
}
function maj(x, y, z2) {
return x & y | z2 & (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 ch2 = 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 hl2 = this._hl | 0;
for (var i = 0; i < 32; i += 2) {
W2[i] = M.readInt32BE(i * 4);
W2[i + 1] = M.readInt32BE(i * 4 + 4);
}
for (; i < 160; i += 2) {
var xh = W2[i - 15 * 2];
var xl = W2[i - 15 * 2 + 1];
var gamma02 = Gamma0(xh, xl);
var gamma0l = Gamma0l(xl, xh);
xh = W2[i - 2 * 2];
xl = W2[i - 2 * 2 + 1];
var gamma12 = Gamma1(xh, xl);
var gamma1l = Gamma1l(xl, xh);
var Wi7h = W2[i - 7 * 2];
var Wi7l = W2[i - 7 * 2 + 1];
var Wi16h = W2[i - 16 * 2];
var Wi16l = W2[i - 16 * 2 + 1];
var Wil = gamma0l + Wi7l | 0;
var Wih = gamma02 + Wi7h + getCarry(Wil, gamma0l) | 0;
Wil = Wil + gamma1l | 0;
Wih = Wih + gamma12 + getCarry(Wil, gamma1l) | 0;
Wil = Wil + Wi16l | 0;
Wih = Wih + Wi16h + getCarry(Wil, Wi16l) | 0;
W2[i] = Wih;
W2[i + 1] = Wil;
}
for (var j = 0; j < 160; j += 2) {
Wih = W2[j];
Wil = W2[j + 1];
var majh = maj(ah, bh, ch2);
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$1[j];
var Kil = K$1[j + 1];
var chh = Ch(eh, fh, gh);
var chl = Ch(el, fl, gl);
var t1l = hl2 + sigma1l | 0;
var t1h = hh + sigma1h + getCarry(t1l, hl2) | 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;
hl2 = gl;
gh = fh;
gl = fl;
fh = eh;
fl = el;
el = dl + t1l | 0;
eh = dh2 + t1h + getCarry(el, dl) | 0;
dh2 = ch2;
dl = cl;
ch2 = 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 + hl2 | 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 + ch2 + 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, hl2) | 0;
};
Sha512.prototype._hash = function() {
var H = Buffer$t.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;
};
var sha512$1 = Sha512;
var inherits$i = inherits_browserExports;
var SHA512$2 = sha512$1;
var Hash$2 = hash$3;
var Buffer$s = safeBufferExports$1.Buffer;
var W = new Array(160);
function Sha384() {
this.init();
this._w = W;
Hash$2.call(this, 128, 112);
}
inherits$i(Sha384, SHA512$2);
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 = Buffer$s.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;
};
var sha384$1 = Sha384;
var exports$2 = sha_js.exports = function SHA(algorithm) {
algorithm = algorithm.toLowerCase();
var Algorithm = exports$2[algorithm];
if (!Algorithm) throw new Error(algorithm + " is not supported (we accept pull requests)");
return new Algorithm();
};
exports$2.sha = sha$4;
exports$2.sha1 = sha1;
exports$2.sha224 = sha224$1;
exports$2.sha256 = sha256$1;
exports$2.sha384 = sha384$1;
exports$2.sha512 = sha512$1;
var sha_jsExports = sha_js.exports;
var streamBrowserify = Stream;
var EE = eventsExports.EventEmitter;
var inherits$h = inherits_browserExports;
inherits$h(Stream, EE);
Stream.Readable = require_stream_readable$1();
Stream.Writable = require_stream_writable$1();
Stream.Duplex = require_stream_duplex$1();
Stream.Transform = _stream_transform$1;
Stream.PassThrough = _stream_passthrough$1;
Stream.finished = endOfStream;
Stream.pipeline = pipeline_1;
Stream.Stream = Stream;
function Stream() {
EE.call(this);
}
Stream.prototype.pipe = function(dest, options2) {
var source = this;
function ondata(chunk) {
if (dest.writable) {
if (false === dest.write(chunk) && source.pause) {
source.pause();
}
}
}
source.on("data", ondata);
function ondrain() {
if (source.readable && source.resume) {
source.resume();
}
}
dest.on("drain", ondrain);
if (!dest._isStdio && (!options2 || options2.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;
};
var Buffer$r = safeBufferExports$1.Buffer;
var Transform$6 = streamBrowserify.Transform;
var StringDecoder = string_decoder.StringDecoder;
var inherits$g = inherits_browserExports;
function CipherBase$1(hashMode) {
Transform$6.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$g(CipherBase$1, Transform$6);
CipherBase$1.prototype.update = function(data, inputEnc, outputEnc) {
if (typeof data === "string") {
data = Buffer$r.from(data, inputEnc);
}
var outData = this._update(data);
if (this.hashMode) return this;
if (outputEnc) {
outData = this._toString(outData, outputEnc);
}
return outData;
};
CipherBase$1.prototype.setAutoPadding = function() {
};
CipherBase$1.prototype.getAuthTag = function() {
throw new Error("trying to get auth tag in unsupported state");
};
CipherBase$1.prototype.setAuthTag = function() {
throw new Error("trying to set auth tag in unsupported state");
};
CipherBase$1.prototype.setAAD = function() {
throw new Error("trying to set aad in unsupported state");
};
CipherBase$1.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$1.prototype._flush = function(done2) {
var err;
try {
this.push(this.__final());
} catch (e) {
err = e;
}
done2(err);
};
CipherBase$1.prototype._finalOrDigest = function(outputEnc) {
var outData = this.__final() || Buffer$r.alloc(0);
if (outputEnc) {
outData = this._toString(outData, outputEnc, true);
}
return outData;
};
CipherBase$1.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;
};
var cipherBase = CipherBase$1;
var inherits$f = inherits_browserExports;
var MD5$2 = md5_js;
var RIPEMD160$3 = ripemd160;
var sha$3 = sha_jsExports;
var Base$5 = cipherBase;
function Hash$1(hash3) {
Base$5.call(this, "digest");
this._hash = hash3;
}
inherits$f(Hash$1, Base$5);
Hash$1.prototype._update = function(data) {
this._hash.update(data);
};
Hash$1.prototype._final = function() {
return this._hash.digest();
};
var browser$a = function createHash2(alg) {
alg = alg.toLowerCase();
if (alg === "md5") return new MD5$2();
if (alg === "rmd160" || alg === "ripemd160") return new RIPEMD160$3();
return new Hash$1(sha$3(alg));
};
var inherits$e = inherits_browserExports;
var Buffer$q = safeBufferExports$1.Buffer;
var Base$4 = cipherBase;
var ZEROS$2 = Buffer$q.alloc(128);
var blocksize = 64;
function Hmac$3(alg, key2) {
Base$4.call(this, "digest");
if (typeof key2 === "string") {
key2 = Buffer$q.from(key2);
}
this._alg = alg;
this._key = key2;
if (key2.length > blocksize) {
key2 = alg(key2);
} else if (key2.length < blocksize) {
key2 = Buffer$q.concat([key2, ZEROS$2], blocksize);
}
var ipad = this._ipad = Buffer$q.allocUnsafe(blocksize);
var opad = this._opad = Buffer$q.allocUnsafe(blocksize);
for (var i = 0; i < blocksize; i++) {
ipad[i] = key2[i] ^ 54;
opad[i] = key2[i] ^ 92;
}
this._hash = [ipad];
}
inherits$e(Hmac$3, Base$4);
Hmac$3.prototype._update = function(data) {
this._hash.push(data);
};
Hmac$3.prototype._final = function() {
var h = this._alg(Buffer$q.concat(this._hash));
return this._alg(Buffer$q.concat([this._opad, h]));
};
var legacy = Hmac$3;
var MD5$1 = md5_js;
var md5$2 = function(buffer2) {
return new MD5$1().update(buffer2).digest();
};
var inherits$d = inherits_browserExports;
var Legacy = legacy;
var Base$3 = cipherBase;
var Buffer$p = safeBufferExports$1.Buffer;
var md5$1 = md5$2;
var RIPEMD160$2 = ripemd160;
var sha$2 = sha_jsExports;
var ZEROS$1 = Buffer$p.alloc(128);
function Hmac$2(alg, key2) {
Base$3.call(this, "digest");
if (typeof key2 === "string") {
key2 = Buffer$p.from(key2);
}
var blocksize2 = alg === "sha512" || alg === "sha384" ? 128 : 64;
this._alg = alg;
this._key = key2;
if (key2.length > blocksize2) {
var hash3 = alg === "rmd160" ? new RIPEMD160$2() : sha$2(alg);
key2 = hash3.update(key2).digest();
} else if (key2.length < blocksize2) {
key2 = Buffer$p.concat([key2, ZEROS$1], blocksize2);
}
var ipad = this._ipad = Buffer$p.allocUnsafe(blocksize2);
var opad = this._opad = Buffer$p.allocUnsafe(blocksize2);
for (var i = 0; i < blocksize2; i++) {
ipad[i] = key2[i] ^ 54;
opad[i] = key2[i] ^ 92;
}
this._hash = alg === "rmd160" ? new RIPEMD160$2() : sha$2(alg);
this._hash.update(ipad);
}
inherits$d(Hmac$2, Base$3);
Hmac$2.prototype._update = function(data) {
this._hash.update(data);
};
Hmac$2.prototype._final = function() {
var h = this._hash.digest();
var hash3 = this._alg === "rmd160" ? new RIPEMD160$2() : sha$2(this._alg);
return hash3.update(this._opad).update(h).digest();
};
var browser$9 = function createHmac(alg, key2) {
alg = alg.toLowerCase();
if (alg === "rmd160" || alg === "ripemd160") {
return new Hmac$2("rmd160", key2);
}
if (alg === "md5") {
return new Legacy(md5$1, key2);
}
return new Hmac$2(alg, key2);
};
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 = require$$6;
var browser$8 = {};
var MAX_ALLOC = Math.pow(2, 30) - 1;
var 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");
}
};
var defaultEncoding$2;
if (commonjsGlobal.process && commonjsGlobal.process.browser) {
defaultEncoding$2 = "utf-8";
} else if (commonjsGlobal.process && commonjsGlobal.process.version) {
var pVersionMajor = parseInt(process$1.version.split(".")[0].slice(1), 10);
defaultEncoding$2 = pVersionMajor >= 6 ? "utf-8" : "binary";
} else {
defaultEncoding$2 = "utf-8";
}
var defaultEncoding_1 = defaultEncoding$2;
var Buffer$o = safeBufferExports$1.Buffer;
var toBuffer$2 = function(thing, encoding, name2) {
if (Buffer$o.isBuffer(thing)) {
return thing;
} else if (typeof thing === "string") {
return Buffer$o.from(thing, encoding);
} else if (ArrayBuffer.isView(thing)) {
return Buffer$o.from(thing.buffer);
} else {
throw new TypeError(name2 + " must be a string, a Buffer, a typed array or a DataView");
}
};
var md5 = md5$2;
var RIPEMD160$1 = ripemd160;
var sha$1 = sha_jsExports;
var Buffer$n = safeBufferExports$1.Buffer;
var checkParameters$1 = precondition;
var defaultEncoding$1 = defaultEncoding_1;
var toBuffer$1 = toBuffer$2;
var ZEROS = Buffer$n.alloc(128);
var sizes = {
md5: 16,
sha1: 20,
sha224: 28,
sha256: 32,
sha384: 48,
sha512: 64,
rmd160: 20,
ripemd160: 20
};
function Hmac$1(alg, key2, saltLen) {
var hash3 = getDigest(alg);
var blocksize2 = alg === "sha512" || alg === "sha384" ? 128 : 64;
if (key2.length > blocksize2) {
key2 = hash3(key2);
} else if (key2.length < blocksize2) {
key2 = Buffer$n.concat([key2, ZEROS], blocksize2);
}
var ipad = Buffer$n.allocUnsafe(blocksize2 + sizes[alg]);
var opad = Buffer$n.allocUnsafe(blocksize2 + sizes[alg]);
for (var i = 0; i < blocksize2; i++) {
ipad[i] = key2[i] ^ 54;
opad[i] = key2[i] ^ 92;
}
var ipad1 = Buffer$n.allocUnsafe(blocksize2 + saltLen + 4);
ipad.copy(ipad1, 0, 0, blocksize2);
this.ipad1 = ipad1;
this.ipad2 = ipad;
this.opad = opad;
this.alg = alg;
this.blocksize = blocksize2;
this.hash = hash3;
this.size = sizes[alg];
}
Hmac$1.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 sha$1(alg).update(data).digest();
}
function rmd160Func(data) {
return new RIPEMD160$1().update(data).digest();
}
if (alg === "rmd160" || alg === "ripemd160") return rmd160Func;
if (alg === "md5") return md5;
return shaFunc;
}
function pbkdf2(password, salt, iterations, keylen, digest9) {
checkParameters$1(iterations, keylen);
password = toBuffer$1(password, defaultEncoding$1, "Password");
salt = toBuffer$1(salt, defaultEncoding$1, "Salt");
digest9 = digest9 || "sha1";
var hmac3 = new Hmac$1(digest9, password, salt.length);
var DK = Buffer$n.allocUnsafe(keylen);
var block1 = Buffer$n.allocUnsafe(salt.length + 4);
salt.copy(block1, 0, 0, salt.length);
var destPos = 0;
var hLen = sizes[digest9];
var l = Math.ceil(keylen / hLen);
for (var i = 1; i <= l; i++) {
block1.writeUInt32BE(i, salt.length);
var T = hmac3.run(block1, hmac3.ipad1);
var U = T;
for (var j = 1; j < iterations; j++) {
U = hmac3.run(U, hmac3.ipad2);
for (var k = 0; k < hLen; k++) T[k] ^= U[k];
}
T.copy(DK, destPos);
destPos += hLen;
}
return DK;
}
var syncBrowser = pbkdf2;
var Buffer$m = safeBufferExports$1.Buffer;
var checkParameters = precondition;
var defaultEncoding = defaultEncoding_1;
var sync = syncBrowser;
var toBuffer = toBuffer$2;
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 || Buffer$m.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$1;
function getNextTick() {
if (nextTick$1) {
return nextTick$1;
}
if (commonjsGlobal.process && commonjsGlobal.process.nextTick) {
nextTick$1 = commonjsGlobal.process.nextTick;
} else if (commonjsGlobal.queueMicrotask) {
nextTick$1 = commonjsGlobal.queueMicrotask;
} else if (commonjsGlobal.setImmediate) {
nextTick$1 = commonjsGlobal.setImmediate;
} else {
nextTick$1 = commonjsGlobal.setTimeout;
}
return nextTick$1;
}
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 Buffer$m.from(res);
});
}
function resolvePromise(promise, callback) {
promise.then(function(out) {
getNextTick()(function() {
callback(null, out);
});
}, function(e) {
getNextTick()(function() {
callback(e);
});
});
}
var async = function(password, salt, iterations, keylen, digest9, callback) {
if (typeof digest9 === "function") {
callback = digest9;
digest9 = void 0;
}
digest9 = digest9 || "sha1";
var algo = toBrowser[digest9.toLowerCase()];
if (!algo || typeof commonjsGlobal.Promise !== "function") {
getNextTick()(function() {
var out;
try {
out = sync(password, salt, iterations, keylen, digest9);
} catch (e) {
return callback(e);
}
callback(null, out);
});
return;
}
checkParameters(iterations, keylen);
password = toBuffer(password, defaultEncoding, "Password");
salt = toBuffer(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, digest9);
}), callback);
};
browser$8.pbkdf2 = async;
browser$8.pbkdf2Sync = syncBrowser;
var browser$7 = {};
var des$2 = {};
var utils$n = {};
utils$n.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$n.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$n.ip = function ip(inL, inR, out, off) {
var outL = 0;
var outR = 0;
for (var i = 6; i >= 0; i -= 2) {
for (var j = 0; j <= 24; j += 8) {
outL <<= 1;
outL |= inR >>> j + i & 1;
}
for (var j = 0; j <= 24; j += 8) {
outL <<= 1;
outL |= inL >>> j + i & 1;
}
}
for (var i = 6; i >= 0; i -= 2) {
for (var j = 1; j <= 25; j += 8) {
outR <<= 1;
outR |= inR >>> j + i & 1;
}
for (var j = 1; j <= 25; j += 8) {
outR <<= 1;
outR |= inL >>> j + i & 1;
}
}
out[off + 0] = outL >>> 0;
out[off + 1] = outR >>> 0;
};
utils$n.rip = function rip(inL, inR, out, off) {
var outL = 0;
var outR = 0;
for (var i = 0; i < 4; i++) {
for (var j = 24; j >= 0; j -= 8) {
outL <<= 1;
outL |= inR >>> j + i & 1;
outL <<= 1;
outL |= inL >>> j + i & 1;
}
}
for (var i = 4; i < 8; i++) {
for (var j = 24; j >= 0; j -= 8) {
outR <<= 1;
outR |= inR >>> j + i & 1;
outR <<= 1;
outR |= inL >>> j + i & 1;
}
}
out[off + 0] = outL >>> 0;
out[off + 1] = outR >>> 0;
};
utils$n.pc1 = function pc1(inL, inR, out, off) {
var outL = 0;
var outR = 0;
for (var i = 7; i >= 5; i--) {
for (var j = 0; j <= 24; j += 8) {
outL <<= 1;
outL |= inR >> j + i & 1;
}
for (var j = 0; j <= 24; j += 8) {
outL <<= 1;
outL |= inL >> j + i & 1;
}
}
for (var j = 0; j <= 24; j += 8) {
outL <<= 1;
outL |= inR >> j + i & 1;
}
for (var i = 1; i <= 3; i++) {
for (var j = 0; j <= 24; j += 8) {
outR <<= 1;
outR |= inR >> j + i & 1;
}
for (var j = 0; j <= 24; j += 8) {
outR <<= 1;
outR |= inL >> j + i & 1;
}
}
for (var j = 0; j <= 24; j += 8) {
outR <<= 1;
outR |= inL >> j + i & 1;
}
out[off + 0] = outL >>> 0;
out[off + 1] = outR >>> 0;
};
utils$n.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$n.pc2 = function pc2(inL, inR, out, off) {
var outL = 0;
var outR = 0;
var len = pc2table.length >>> 1;
for (var i = 0; i < len; i++) {
outL <<= 1;
outL |= inL >>> pc2table[i] & 1;
}
for (var i = len; i < pc2table.length; i++) {
outR <<= 1;
outR |= inR >>> pc2table[i] & 1;
}
out[off + 0] = outL >>> 0;
out[off + 1] = outR >>> 0;
};
utils$n.expand = function expand(r2, out, off) {
var outL = 0;
var outR = 0;
outL = (r2 & 1) << 5 | r2 >>> 27;
for (var i = 23; i >= 15; i -= 4) {
outL <<= 6;
outL |= r2 >>> i & 63;
}
for (var i = 11; i >= 3; i -= 4) {
outR |= r2 >>> i & 63;
outR <<= 6;
}
outR |= (r2 & 31) << 1 | r2 >>> 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$n.substitute = function substitute(inL, inR) {
var out = 0;
for (var i = 0; i < 4; i++) {
var b = inL >>> 18 - i * 6 & 63;
var sb = sTable[i * 64 + b];
out <<= 4;
out |= sb;
}
for (var i = 0; i < 4; i++) {
var b = inR >>> 18 - i * 6 & 63;
var sb = sTable[4 * 64 + i * 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$n.permute = function permute(num) {
var out = 0;
for (var i = 0; i < permuteTable.length; i++) {
out <<= 1;
out |= num >>> permuteTable[i] & 1;
}
return out >>> 0;
};
utils$n.padSplit = function padSplit(num, size, group) {
var str = num.toString(2);
while (str.length < size)
str = "0" + str;
var out = [];
for (var i = 0; i < size; i += group)
out.push(str.slice(i, i + group));
return out.join(" ");
};
var minimalisticAssert = assert$i;
function assert$i(val, msg) {
if (!val)
throw new Error(msg || "Assertion failed");
}
assert$i.equal = function assertEqual(l, r2, msg) {
if (l != r2)
throw new Error(msg || "Assertion failed: " + l + " != " + r2);
};
var assert$h = minimalisticAssert;
function Cipher$3(options2) {
this.options = options2;
this.type = this.options.type;
this.blockSize = 8;
this._init();
this.buffer = new Array(this.blockSize);
this.bufferOff = 0;
this.padding = options2.padding !== false;
}
var cipher = Cipher$3;
Cipher$3.prototype._init = function _init() {
};
Cipher$3.prototype.update = function update(data) {
if (data.length === 0)
return [];
if (this.type === "decrypt")
return this._updateDecrypt(data);
else
return this._updateEncrypt(data);
};
Cipher$3.prototype._buffer = function _buffer(data, off) {
var min = Math.min(this.buffer.length - this.bufferOff, data.length - off);
for (var i = 0; i < min; i++)
this.buffer[this.bufferOff + i] = data[off + i];
this.bufferOff += min;
return min;
};
Cipher$3.prototype._flushBuffer = function _flushBuffer(out, off) {
this._update(this.buffer, 0, out, off);
this.bufferOff = 0;
return this.blockSize;
};
Cipher$3.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 max2 = data.length - (data.length - inputOff) % this.blockSize;
for (; inputOff < max2; 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$3.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$3.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$3.prototype._pad = function _pad(buffer2, off) {
if (off === 0)
return false;
while (off < buffer2.length)
buffer2[off++] = 0;
return true;
};
Cipher$3.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$3.prototype._unpad = function _unpad(buffer2) {
return buffer2;
};
Cipher$3.prototype._finalDecrypt = function _finalDecrypt() {
assert$h.equal(this.bufferOff, this.blockSize, "Not enough data to decrypt");
var out = new Array(this.blockSize);
this._flushBuffer(out, 0);
return this._unpad(out);
};
var assert$g = minimalisticAssert;
var inherits$c = inherits_browserExports;
var utils$m = utils$n;
var Cipher$2 = cipher;
function DESState() {
this.tmp = new Array(2);
this.keys = null;
}
function DES$3(options2) {
Cipher$2.call(this, options2);
var state2 = new DESState();
this._desState = state2;
this.deriveKeys(state2, options2.key);
}
inherits$c(DES$3, Cipher$2);
var des$1 = DES$3;
DES$3.create = function create(options2) {
return new DES$3(options2);
};
var shiftTable = [
1,
1,
2,
2,
2,
2,
2,
2,
1,
2,
2,
2,
2,
2,
2,
1
];
DES$3.prototype.deriveKeys = function deriveKeys(state2, key2) {
state2.keys = new Array(16 * 2);
assert$g.equal(key2.length, this.blockSize, "Invalid key length");
var kL = utils$m.readUInt32BE(key2, 0);
var kR = utils$m.readUInt32BE(key2, 4);
utils$m.pc1(kL, kR, state2.tmp, 0);
kL = state2.tmp[0];
kR = state2.tmp[1];
for (var i = 0; i < state2.keys.length; i += 2) {
var shift = shiftTable[i >>> 1];
kL = utils$m.r28shl(kL, shift);
kR = utils$m.r28shl(kR, shift);
utils$m.pc2(kL, kR, state2.keys, i);
}
};
DES$3.prototype._update = function _update(inp, inOff, out, outOff) {
var state2 = this._desState;
var l = utils$m.readUInt32BE(inp, inOff);
var r2 = utils$m.readUInt32BE(inp, inOff + 4);
utils$m.ip(l, r2, state2.tmp, 0);
l = state2.tmp[0];
r2 = state2.tmp[1];
if (this.type === "encrypt")
this._encrypt(state2, l, r2, state2.tmp, 0);
else
this._decrypt(state2, l, r2, state2.tmp, 0);
l = state2.tmp[0];
r2 = state2.tmp[1];
utils$m.writeUInt32BE(out, l, outOff);
utils$m.writeUInt32BE(out, r2, outOff + 4);
};
DES$3.prototype._pad = function _pad2(buffer2, off) {
if (this.padding === false) {
return false;
}
var value = buffer2.length - off;
for (var i = off; i < buffer2.length; i++)
buffer2[i] = value;
return true;
};
DES$3.prototype._unpad = function _unpad2(buffer2) {
if (this.padding === false) {
return buffer2;
}
var pad2 = buffer2[buffer2.length - 1];
for (var i = buffer2.length - pad2; i < buffer2.length; i++)
assert$g.equal(buffer2[i], pad2);
return buffer2.slice(0, buffer2.length - pad2);
};
DES$3.prototype._encrypt = function _encrypt(state2, lStart, rStart, out, off) {
var l = lStart;
var r2 = rStart;
for (var i = 0; i < state2.keys.length; i += 2) {
var keyL = state2.keys[i];
var keyR = state2.keys[i + 1];
utils$m.expand(r2, state2.tmp, 0);
keyL ^= state2.tmp[0];
keyR ^= state2.tmp[1];
var s2 = utils$m.substitute(keyL, keyR);
var f2 = utils$m.permute(s2);
var t = r2;
r2 = (l ^ f2) >>> 0;
l = t;
}
utils$m.rip(r2, l, out, off);
};
DES$3.prototype._decrypt = function _decrypt(state2, lStart, rStart, out, off) {
var l = rStart;
var r2 = lStart;
for (var i = state2.keys.length - 2; i >= 0; i -= 2) {
var keyL = state2.keys[i];
var keyR = state2.keys[i + 1];
utils$m.expand(l, state2.tmp, 0);
keyL ^= state2.tmp[0];
keyR ^= state2.tmp[1];
var s2 = utils$m.substitute(keyL, keyR);
var f2 = utils$m.permute(s2);
var t = l;
l = (r2 ^ f2) >>> 0;
r2 = t;
}
utils$m.rip(l, r2, out, off);
};
var cbc$1 = {};
var assert$f = minimalisticAssert;
var inherits$b = inherits_browserExports;
var proto = {};
function CBCState(iv) {
assert$f.equal(iv.length, 8, "Invalid IV length");
this.iv = new Array(8);
for (var i = 0; i < this.iv.length; i++)
this.iv[i] = iv[i];
}
function instantiate(Base2) {
function CBC(options2) {
Base2.call(this, options2);
this._cbcInit();
}
inherits$b(CBC, Base2);
var keys2 = Object.keys(proto);
for (var i = 0; i < keys2.length; i++) {
var key2 = keys2[i];
CBC.prototype[key2] = proto[key2];
}
CBC.create = function create3(options2) {
return new CBC(options2);
};
return CBC;
}
cbc$1.instantiate = instantiate;
proto._cbcInit = function _cbcInit() {
var state2 = new CBCState(this.options.iv);
this._cbcState = state2;
};
proto._update = function _update2(inp, inOff, out, outOff) {
var state2 = this._cbcState;
var superProto = this.constructor.super_.prototype;
var iv = state2.iv;
if (this.type === "encrypt") {
for (var i = 0; i < this.blockSize; i++)
iv[i] ^= inp[inOff + i];
superProto._update.call(this, iv, 0, out, outOff);
for (var i = 0; i < this.blockSize; i++)
iv[i] = out[outOff + i];
} else {
superProto._update.call(this, inp, inOff, out, outOff);
for (var i = 0; i < this.blockSize; i++)
out[outOff + i] ^= iv[i];
for (var i = 0; i < this.blockSize; i++)
iv[i] = inp[inOff + i];
}
};
var assert$e = minimalisticAssert;
var inherits$a = inherits_browserExports;
var Cipher$1 = cipher;
var DES$2 = des$1;
function EDEState(type2, key2) {
assert$e.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$2.create({ type: "encrypt", key: k1 }),
DES$2.create({ type: "decrypt", key: k2 }),
DES$2.create({ type: "encrypt", key: k3 })
];
} else {
this.ciphers = [
DES$2.create({ type: "decrypt", key: k3 }),
DES$2.create({ type: "encrypt", key: k2 }),
DES$2.create({ type: "decrypt", key: k1 })
];
}
}
function EDE(options2) {
Cipher$1.call(this, options2);
var state2 = new EDEState(this.type, this.options.key);
this._edeState = state2;
}
inherits$a(EDE, Cipher$1);
var ede = EDE;
EDE.create = function create2(options2) {
return new EDE(options2);
};
EDE.prototype._update = function _update3(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$2.prototype._pad;
EDE.prototype._unpad = DES$2.prototype._unpad;
des$2.utils = utils$n;
des$2.Cipher = cipher;
des$2.DES = des$1;
des$2.CBC = cbc$1;
des$2.EDE = ede;
var CipherBase = cipherBase;
var des = des$2;
var inherits$9 = inherits_browserExports;
var Buffer$l = safeBufferExports$1.Buffer;
var modes$3 = {
"des-ede3-cbc": des.CBC.instantiate(des.EDE),
"des-ede3": des.EDE,
"des-ede-cbc": des.CBC.instantiate(des.EDE),
"des-ede": des.EDE,
"des-cbc": des.CBC.instantiate(des.DES),
"des-ecb": des.DES
};
modes$3.des = modes$3["des-cbc"];
modes$3.des3 = modes$3["des-ede3-cbc"];
var browserifyDes = DES$1;
inherits$9(DES$1, CipherBase);
function DES$1(opts) {
CipherBase.call(this);
var modeName = opts.mode.toLowerCase();
var mode = modes$3[modeName];
var type2;
if (opts.decrypt) {
type2 = "decrypt";
} else {
type2 = "encrypt";
}
var key2 = opts.key;
if (!Buffer$l.isBuffer(key2)) {
key2 = Buffer$l.from(key2);
}
if (modeName === "des-ede" || modeName === "des-ede-cbc") {
key2 = Buffer$l.concat([key2, key2.slice(0, 8)]);
}
var iv = opts.iv;
if (!Buffer$l.isBuffer(iv)) {
iv = Buffer$l.from(iv);
}
this._des = mode.create({
key: key2,
iv,
type: type2
});
}
DES$1.prototype._update = function(data) {
return Buffer$l.from(this._des.update(data));
};
DES$1.prototype._final = function() {
return Buffer$l.from(this._des.final());
};
var browser$6 = {};
var encrypter = {};
var ecb = {};
ecb.encrypt = function(self2, block) {
return self2._cipher.encryptBlock(block);
};
ecb.decrypt = function(self2, block) {
return self2._cipher.decryptBlock(block);
};
var cbc = {};
var bufferXor = function xor2(a, b) {
var length = Math.min(a.length, b.length);
var buffer2 = new Buffer$E(length);
for (var i = 0; i < length; ++i) {
buffer2[i] = a[i] ^ b[i];
}
return buffer2;
};
var xor$7 = bufferXor;
cbc.encrypt = function(self2, block) {
var data = xor$7(block, self2._prev);
self2._prev = self2._cipher.encryptBlock(data);
return self2._prev;
};
cbc.decrypt = function(self2, block) {
var pad2 = self2._prev;
self2._prev = block;
var out = self2._cipher.decryptBlock(block);
return xor$7(out, pad2);
};
var cfb = {};
var Buffer$k = safeBufferExports$1.Buffer;
var xor$6 = bufferXor;
function encryptStart(self2, data, decrypt2) {
var len = data.length;
var out = xor$6(data, self2._cache);
self2._cache = self2._cache.slice(len);
self2._prev = Buffer$k.concat([self2._prev, decrypt2 ? data : out]);
return out;
}
cfb.encrypt = function(self2, data, decrypt2) {
var out = Buffer$k.allocUnsafe(0);
var len;
while (data.length) {
if (self2._cache.length === 0) {
self2._cache = self2._cipher.encryptBlock(self2._prev);
self2._prev = Buffer$k.allocUnsafe(0);
}
if (self2._cache.length <= data.length) {
len = self2._cache.length;
out = Buffer$k.concat([out, encryptStart(self2, data.slice(0, len), decrypt2)]);
data = data.slice(len);
} else {
out = Buffer$k.concat([out, encryptStart(self2, data, decrypt2)]);
break;
}
}
return out;
};
var cfb8 = {};
var Buffer$j = safeBufferExports$1.Buffer;
function encryptByte$1(self2, byteParam, decrypt2) {
var pad2 = self2._cipher.encryptBlock(self2._prev);
var out = pad2[0] ^ byteParam;
self2._prev = Buffer$j.concat([
self2._prev.slice(1),
Buffer$j.from([decrypt2 ? byteParam : out])
]);
return out;
}
cfb8.encrypt = function(self2, chunk, decrypt2) {
var len = chunk.length;
var out = Buffer$j.allocUnsafe(len);
var i = -1;
while (++i < len) {
out[i] = encryptByte$1(self2, chunk[i], decrypt2);
}
return out;
};
var cfb1 = {};
var Buffer$i = safeBufferExports$1.Buffer;
function encryptByte(self2, byteParam, decrypt2) {
var pad2;
var i = -1;
var len = 8;
var out = 0;
var bit, value;
while (++i < len) {
pad2 = self2._cipher.encryptBlock(self2._prev);
bit = byteParam & 1 << 7 - i ? 128 : 0;
value = pad2[0] ^ bit;
out += (value & 128) >> i % 8;
self2._prev = shiftIn(self2._prev, decrypt2 ? bit : value);
}
return out;
}
function shiftIn(buffer2, value) {
var len = buffer2.length;
var i = -1;
var out = Buffer$i.allocUnsafe(buffer2.length);
buffer2 = Buffer$i.concat([buffer2, Buffer$i.from([value])]);
while (++i < len) {
out[i] = buffer2[i] << 1 | buffer2[i + 1] >> 7;
}
return out;
}
cfb1.encrypt = function(self2, chunk, decrypt2) {
var len = chunk.length;
var out = Buffer$i.allocUnsafe(len);
var i = -1;
while (++i < len) {
out[i] = encryptByte(self2, chunk[i], decrypt2);
}
return out;
};
var ofb = {};
var xor$5 = bufferXor;
function getBlock$1(self2) {
self2._prev = self2._cipher.encryptBlock(self2._prev);
return self2._prev;
}
ofb.encrypt = function(self2, chunk) {
while (self2._cache.length < chunk.length) {
self2._cache = Buffer$E.concat([self2._cache, getBlock$1(self2)]);
}
var pad2 = self2._cache.slice(0, chunk.length);
self2._cache = self2._cache.slice(chunk.length);
return xor$5(chunk, pad2);
};
var ctr = {};
function incr32$2(iv) {
var len = iv.length;
var item;
while (len--) {
item = iv.readUInt8(len);
if (item === 255) {
iv.writeUInt8(0, len);
} else {
item++;
iv.writeUInt8(item, len);
break;
}
}
}
var incr32_1 = incr32$2;
var xor$4 = bufferXor;
var Buffer$h = safeBufferExports$1.Buffer;
var incr32$1 = incr32_1;
function getBlock(self2) {
var out = self2._cipher.encryptBlockRaw(self2._prev);
incr32$1(self2._prev);
return out;
}
var blockSize = 16;
ctr.encrypt = function(self2, chunk) {
var chunkNum = Math.ceil(chunk.length / blockSize);
var start = self2._cache.length;
self2._cache = Buffer$h.concat([
self2._cache,
Buffer$h.allocUnsafe(chunkNum * blockSize)
]);
for (var i = 0; i < chunkNum; i++) {
var out = getBlock(self2);
var offset = start + i * 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 pad2 = self2._cache.slice(0, chunk.length);
self2._cache = self2._cache.slice(chunk.length);
return xor$4(chunk, pad2);
};
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 modeModules = {
ECB: ecb,
CBC: cbc,
CFB: cfb,
CFB8: cfb8,
CFB1: cfb1,
OFB: ofb,
CTR: ctr,
GCM: ctr
};
var modes$2 = require$$2;
for (var key$2 in modes$2) {
modes$2[key$2].module = modeModules[modes$2[key$2].mode];
}
var modes_1 = modes$2;
var aes$5 = {};
var Buffer$g = safeBufferExports$1.Buffer;
function asUInt32Array(buf) {
if (!Buffer$g.isBuffer(buf)) buf = Buffer$g.from(buf);
var len = buf.length / 4 | 0;
var out = new Array(len);
for (var i = 0; i < len; i++) {
out[i] = buf.readUInt32BE(i * 4);
}
return out;
}
function scrubVec(v) {
for (var i = 0; i < v.length; v++) {
v[i] = 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 i = 0; i < 256; ++i) {
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 = Buffer$g.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 = Buffer$g.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$5.AES = AES;
var Buffer$f = safeBufferExports$1.Buffer;
var ZEROES = Buffer$f.alloc(16, 0);
function toArray$1(buf) {
return [
buf.readUInt32BE(0),
buf.readUInt32BE(4),
buf.readUInt32BE(8),
buf.readUInt32BE(12)
];
}
function fromArray(out) {
var buf = Buffer$f.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$1(key2) {
this.h = key2;
this.state = Buffer$f.alloc(16, 0);
this.cache = Buffer$f.allocUnsafe(0);
}
GHASH$1.prototype.ghash = function(block) {
var i = -1;
while (++i < block.length) {
this.state[i] ^= block[i];
}
this._multiply();
};
GHASH$1.prototype._multiply = function() {
var Vi = toArray$1(this.h);
var Zi = [0, 0, 0, 0];
var j, xi, lsbVi;
var i = -1;
while (++i < 128) {
xi = (this.state[~~(i / 8)] & 1 << 7 - i % 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$1.prototype.update = function(buf) {
this.cache = Buffer$f.concat([this.cache, buf]);
var chunk;
while (this.cache.length >= 16) {
chunk = this.cache.slice(0, 16);
this.cache = this.cache.slice(16);
this.ghash(chunk);
}
};
GHASH$1.prototype.final = function(abl, bl) {
if (this.cache.length) {
this.ghash(Buffer$f.concat([this.cache, ZEROES], 16));
}
this.ghash(fromArray([0, abl, 0, bl]));
return this.state;
};
var ghash = GHASH$1;
var aes$4 = aes$5;
var Buffer$e = safeBufferExports$1.Buffer;
var Transform$5 = cipherBase;
var inherits$8 = inherits_browserExports;
var GHASH = ghash;
var xor$3 = bufferXor;
var incr32 = incr32_1;
function xorTest(a, b) {
var out = 0;
if (a.length !== b.length) out++;
var len = Math.min(a.length, b.length);
for (var i = 0; i < len; ++i) {
out += a[i] ^ b[i];
}
return out;
}
function calcIv(self2, iv, ck) {
if (iv.length === 12) {
self2._finID = Buffer$e.concat([iv, Buffer$e.from([0, 0, 0, 1])]);
return Buffer$e.concat([iv, Buffer$e.from([0, 0, 0, 2])]);
}
var ghash2 = new GHASH(ck);
var len = iv.length;
var toPad = len % 16;
ghash2.update(iv);
if (toPad) {
toPad = 16 - toPad;
ghash2.update(Buffer$e.alloc(toPad, 0));
}
ghash2.update(Buffer$e.alloc(8, 0));
var ivBits = len * 8;
var tail = Buffer$e.alloc(8);
tail.writeUIntBE(ivBits, 0, 8);
ghash2.update(tail);
self2._finID = ghash2.state;
var out = Buffer$e.from(self2._finID);
incr32(out);
return out;
}
function StreamCipher$3(mode, key2, iv, decrypt2) {
Transform$5.call(this);
var h = Buffer$e.alloc(4, 0);
this._cipher = new aes$4.AES(key2);
var ck = this._cipher.encryptBlock(h);
this._ghash = new GHASH(ck);
iv = calcIv(this, iv, ck);
this._prev = Buffer$e.from(iv);
this._cache = Buffer$e.allocUnsafe(0);
this._secCache = Buffer$e.allocUnsafe(0);
this._decrypt = decrypt2;
this._alen = 0;
this._len = 0;
this._mode = mode;
this._authTag = null;
this._called = false;
}
inherits$8(StreamCipher$3, Transform$5);
StreamCipher$3.prototype._update = function(chunk) {
if (!this._called && this._alen) {
var rump = 16 - this._alen % 16;
if (rump < 16) {
rump = Buffer$e.alloc(rump, 0);
this._ghash.update(rump);
}
}
this._called = true;
var out = this._mode.encrypt(this, chunk);
if (this._decrypt) {
this._ghash.update(chunk);
} else {
this._ghash.update(out);
}
this._len += chunk.length;
return out;
};
StreamCipher$3.prototype._final = function() {
if (this._decrypt && !this._authTag) throw new Error("Unsupported state or unable to authenticate data");
var tag = xor$3(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$3.prototype.getAuthTag = function getAuthTag() {
if (this._decrypt || !Buffer$e.isBuffer(this._authTag)) throw new Error("Attempting to get auth tag in unsupported state");
return this._authTag;
};
StreamCipher$3.prototype.setAuthTag = function setAuthTag(tag) {
if (!this._decrypt) throw new Error("Attempting to set auth tag in unsupported state");
this._authTag = tag;
};
StreamCipher$3.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;
};
var authCipher = StreamCipher$3;
var aes$3 = aes$5;
var Buffer$d = safeBufferExports$1.Buffer;
var Transform$4 = cipherBase;
var inherits$7 = inherits_browserExports;
function StreamCipher$2(mode, key2, iv, decrypt2) {
Transform$4.call(this);
this._cipher = new aes$3.AES(key2);
this._prev = Buffer$d.from(iv);
this._cache = Buffer$d.allocUnsafe(0);
this._secCache = Buffer$d.allocUnsafe(0);
this._decrypt = decrypt2;
this._mode = mode;
}
inherits$7(StreamCipher$2, Transform$4);
StreamCipher$2.prototype._update = function(chunk) {
return this._mode.encrypt(this, chunk, this._decrypt);
};
StreamCipher$2.prototype._final = function() {
this._cipher.scrub();
};
var streamCipher = StreamCipher$2;
var Buffer$c = safeBufferExports$1.Buffer;
var MD5 = md5_js;
function EVP_BytesToKey(password, salt, keyBits, ivLen) {
if (!Buffer$c.isBuffer(password)) password = Buffer$c.from(password, "binary");
if (salt) {
if (!Buffer$c.isBuffer(salt)) salt = Buffer$c.from(salt, "binary");
if (salt.length !== 8) throw new RangeError("salt should be Buffer with 8 byte length");
}
var keyLen = keyBits / 8;
var key2 = Buffer$c.alloc(keyLen);
var iv = Buffer$c.alloc(ivLen || 0);
var tmp = Buffer$c.alloc(0);
while (keyLen > 0 || ivLen > 0) {
var hash3 = new MD5();
hash3.update(tmp);
hash3.update(password);
if (salt) hash3.update(salt);
tmp = hash3.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 };
}
var evp_bytestokey = EVP_BytesToKey;
var MODES$1 = modes_1;
var AuthCipher$1 = authCipher;
var Buffer$b = safeBufferExports$1.Buffer;
var StreamCipher$1 = streamCipher;
var Transform$3 = cipherBase;
var aes$2 = aes$5;
var ebtk$2 = evp_bytestokey;
var inherits$6 = inherits_browserExports;
function Cipher(mode, key2, iv) {
Transform$3.call(this);
this._cache = new Splitter$1();
this._cipher = new aes$2.AES(key2);
this._prev = Buffer$b.from(iv);
this._mode = mode;
this._autopadding = true;
}
inherits$6(Cipher, Transform$3);
Cipher.prototype._update = function(data) {
this._cache.add(data);
var chunk;
var thing;
var out = [];
while (chunk = this._cache.get()) {
thing = this._mode.encrypt(this, chunk);
out.push(thing);
}
return Buffer$b.concat(out);
};
var PADDING = Buffer$b.alloc(16, 16);
Cipher.prototype._final = function() {
var chunk = this._cache.flush();
if (this._autopadding) {
chunk = this._mode.encrypt(this, chunk);
this._cipher.scrub();
return chunk;
}
if (!chunk.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$1() {
this.cache = Buffer$b.allocUnsafe(0);
}
Splitter$1.prototype.add = function(data) {
this.cache = Buffer$b.concat([this.cache, data]);
};
Splitter$1.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$1.prototype.flush = function() {
var len = 16 - this.cache.length;
var padBuff = Buffer$b.allocUnsafe(len);
var i = -1;
while (++i < len) {
padBuff.writeUInt8(len, i);
}
return Buffer$b.concat([this.cache, padBuff]);
};
function createCipheriv$1(suite, password, iv) {
var config2 = MODES$1[suite.toLowerCase()];
if (!config2) throw new TypeError("invalid suite type");
if (typeof password === "string") password = Buffer$b.from(password);
if (password.length !== config2.key / 8) throw new TypeError("invalid key length " + password.length);
if (typeof iv === "string") iv = Buffer$b.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$1(config2.module, password, iv);
} else if (config2.type === "auth") {
return new AuthCipher$1(config2.module, password, iv);
}
return new Cipher(config2.module, password, iv);
}
function createCipher$1(suite, password) {
var config2 = MODES$1[suite.toLowerCase()];
if (!config2) throw new TypeError("invalid suite type");
var keys2 = ebtk$2(password, false, config2.key, config2.iv);
return createCipheriv$1(suite, keys2.key, keys2.iv);
}
encrypter.createCipheriv = createCipheriv$1;
encrypter.createCipher = createCipher$1;
var decrypter = {};
var AuthCipher = authCipher;
var Buffer$a = safeBufferExports$1.Buffer;
var MODES = modes_1;
var StreamCipher = streamCipher;
var Transform$2 = cipherBase;
var aes$1 = aes$5;
var ebtk$1 = evp_bytestokey;
var inherits$5 = inherits_browserExports;
function Decipher(mode, key2, iv) {
Transform$2.call(this);
this._cache = new Splitter();
this._last = void 0;
this._cipher = new aes$1.AES(key2);
this._prev = Buffer$a.from(iv);
this._mode = mode;
this._autopadding = true;
}
inherits$5(Decipher, Transform$2);
Decipher.prototype._update = function(data) {
this._cache.add(data);
var chunk;
var thing;
var out = [];
while (chunk = this._cache.get(this._autopadding)) {
thing = this._mode.decrypt(this, chunk);
out.push(thing);
}
return Buffer$a.concat(out);
};
Decipher.prototype._final = function() {
var chunk = this._cache.flush();
if (this._autopadding) {
return unpad(this._mode.decrypt(this, chunk));
} else if (chunk) {
throw new Error("data not multiple of block length");
}
};
Decipher.prototype.setAutoPadding = function(setTo) {
this._autopadding = !!setTo;
return this;
};
function Splitter() {
this.cache = Buffer$a.allocUnsafe(0);
}
Splitter.prototype.add = function(data) {
this.cache = Buffer$a.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 i = -1;
while (++i < padded) {
if (last[i + (16 - padded)] !== padded) {
throw new Error("unable to decrypt data");
}
}
if (padded === 16) return;
return last.slice(0, 16 - padded);
}
function createDecipheriv$1(suite, password, iv) {
var config2 = MODES[suite.toLowerCase()];
if (!config2) throw new TypeError("invalid suite type");
if (typeof iv === "string") iv = Buffer$a.from(iv);
if (config2.mode !== "GCM" && iv.length !== config2.iv) throw new TypeError("invalid iv length " + iv.length);
if (typeof password === "string") password = Buffer$a.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$1(suite, password) {
var config2 = MODES[suite.toLowerCase()];
if (!config2) throw new TypeError("invalid suite type");
var keys2 = ebtk$1(password, false, config2.key, config2.iv);
return createDecipheriv$1(suite, keys2.key, keys2.iv);
}
decrypter.createDecipher = createDecipher$1;
decrypter.createDecipheriv = createDecipheriv$1;
var ciphers$2 = encrypter;
var deciphers = decrypter;
var modes$1 = require$$2;
function getCiphers$1() {
return Object.keys(modes$1);
}
browser$6.createCipher = browser$6.Cipher = ciphers$2.createCipher;
browser$6.createCipheriv = browser$6.Cipheriv = ciphers$2.createCipheriv;
browser$6.createDecipher = browser$6.Decipher = deciphers.createDecipher;
browser$6.createDecipheriv = browser$6.Decipheriv = deciphers.createDecipheriv;
browser$6.listCiphers = browser$6.getCiphers = getCiphers$1;
var modes = {};
(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);
var DES = browserifyDes;
var aes = browser$6;
var aesModes = modes_1;
var desModes = modes;
var ebtk = evp_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 keys2 = ebtk(password, false, keyLen, ivLen);
return createCipheriv(suite, keys2.key, keys2.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 keys2 = ebtk(password, false, keyLen, ivLen);
return createDecipheriv(suite, keys2.key, keys2.iv);
}
function createCipheriv(suite, key2, iv) {
suite = suite.toLowerCase();
if (aesModes[suite]) return aes.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 aes.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(aes.getCiphers());
}
browser$7.createCipher = browser$7.Cipher = createCipher;
browser$7.createCipheriv = browser$7.Cipheriv = createCipheriv;
browser$7.createDecipher = browser$7.Decipher = createDecipher;
browser$7.createDecipheriv = browser$7.Decipheriv = createDecipheriv;
browser$7.listCiphers = browser$7.getCiphers = getCiphers;
var browser$5 = {};
var bn$1 = { exports: {} };
bn$1.exports;
(function(module2) {
(function(module3, exports2) {
function assert2(val, msg) {
if (!val) throw new Error(msg || "Assertion failed");
}
function inherits2(ctor, superCtor) {
ctor.super_ = superCtor;
var TempCtor = function() {
};
TempCtor.prototype = superCtor.prototype;
ctor.prototype = new TempCtor();
ctor.prototype.constructor = ctor;
}
function BN2(number, base2, endian) {
if (BN2.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 = BN2;
} else {
exports2.BN = BN2;
}
BN2.BN = BN2;
BN2.wordSize = 26;
var Buffer2;
try {
if (typeof window !== "undefined" && typeof window.Buffer !== "undefined") {
Buffer2 = window.Buffer;
} else {
Buffer2 = dist.Buffer;
}
} catch (e) {
}
BN2.isBN = function isBN(num) {
if (num instanceof BN2) {
return true;
}
return num !== null && typeof num === "object" && num.constructor.wordSize === BN2.wordSize && Array.isArray(num.words);
};
BN2.max = function max2(left, right) {
if (left.cmp(right) > 0) return left;
return right;
};
BN2.min = function min(left, right) {
if (left.cmp(right) < 0) return left;
return right;
};
BN2.prototype._init = function init3(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;
}
assert2(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);
}
}
}
};
BN2.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 {
assert2(number < 9007199254740992);
this.words = [
number & 67108863,
number / 67108864 & 67108863,
1
];
this.length = 3;
}
if (endian !== "le") return;
this._initArray(this.toArray(), base2, endian);
};
BN2.prototype._initArray = function _initArray(number, base2, endian) {
assert2(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 i = 0; i < this.length; i++) {
this.words[i] = 0;
}
var j, w;
var off = 0;
if (endian === "be") {
for (i = number.length - 1, j = 0; i >= 0; i -= 3) {
w = number[i] | number[i - 1] << 8 | number[i - 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 (i = 0, j = 0; i < number.length; i += 3) {
w = number[i] | number[i + 1] << 8 | number[i + 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 r2 = parseHex4Bits(string, index);
if (index - 1 >= lowerBound) {
r2 |= parseHex4Bits(string, index - 1) << 4;
}
return r2;
}
BN2.prototype._parseHex = function _parseHex(number, start, endian) {
this.length = Math.ceil((number.length - start) / 6);
this.words = new Array(this.length);
for (var i = 0; i < this.length; i++) {
this.words[i] = 0;
}
var off = 0;
var j = 0;
var w;
if (endian === "be") {
for (i = number.length - 1; i >= start; i -= 2) {
w = parseHexByte(number, start, i) << 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 (i = parseLength % 2 === 0 ? start + 1 : start; i < number.length; i += 2) {
w = parseHexByte(number, start, i) << 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, mul5) {
var r2 = 0;
var len = Math.min(str.length, end);
for (var i = start; i < len; i++) {
var c = str.charCodeAt(i) - 48;
r2 *= mul5;
if (c >= 49) {
r2 += c - 49 + 10;
} else if (c >= 17) {
r2 += c - 17 + 10;
} else {
r2 += c;
}
}
return r2;
}
BN2.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 i = start; i < end; i += limbLen) {
word = parseBase(number, i, i + 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, i, number.length, base2);
for (i = 0; i < mod; i++) {
pow *= base2;
}
this.imuln(pow);
if (this.words[0] + word < 67108864) {
this.words[0] += word;
} else {
this._iaddn(word);
}
}
this.strip();
};
BN2.prototype.copy = function copy(dest) {
dest.words = new Array(this.length);
for (var i = 0; i < this.length; i++) {
dest.words[i] = this.words[i];
}
dest.length = this.length;
dest.negative = this.negative;
dest.red = this.red;
};
BN2.prototype.clone = function clone() {
var r2 = new BN2(null);
this.copy(r2);
return r2;
};
BN2.prototype._expand = function _expand(size) {
while (this.length < size) {
this.words[this.length++] = 0;
}
return this;
};
BN2.prototype.strip = function strip() {
while (this.length > 1 && this.words[this.length - 1] === 0) {
this.length--;
}
return this._normSign();
};
BN2.prototype._normSign = function _normSign() {
if (this.length === 1 && this.words[0] === 0) {
this.negative = 0;
}
return this;
};
BN2.prototype.inspect = function inspect6() {
return (this.red ? "<BN-R: " : "<BN: ") + this.toString(16) + ">";
};
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
];
BN2.prototype.toString = function toString2(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 i = 0; i < this.length; i++) {
var w = this.words[i];
var word = ((w << off | carry) & 16777215).toString(16);
carry = w >>> 24 - off & 16777215;
if (carry !== 0 || i !== this.length - 1) {
out = zeros[6 - word.length] + word + out;
} else {
out = word + out;
}
off += 2;
if (off >= 26) {
off -= 26;
i--;
}
}
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 r2 = c.modn(groupBase).toString(base2);
c = c.idivn(groupBase);
if (!c.isZero()) {
out = zeros[groupSize - r2.length] + r2 + out;
} else {
out = r2 + out;
}
}
if (this.isZero()) {
out = "0" + out;
}
while (out.length % padding !== 0) {
out = "0" + out;
}
if (this.negative !== 0) {
out = "-" + out;
}
return out;
}
assert2(false, "Base should be between 2 and 36");
};
BN2.prototype.toNumber = function toNumber() {
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) {
assert2(false, "Number can only safely store up to 53 bits");
}
return this.negative !== 0 ? -ret : ret;
};
BN2.prototype.toJSON = function toJSON2() {
return this.toString(16);
};
BN2.prototype.toBuffer = function toBuffer2(endian, length) {
assert2(typeof Buffer2 !== "undefined");
return this.toArrayLike(Buffer2, endian, length);
};
BN2.prototype.toArray = function toArray2(endian, length) {
return this.toArrayLike(Array, endian, length);
};
BN2.prototype.toArrayLike = function toArrayLike(ArrayType, endian, length) {
var byteLength = this.byteLength();
var reqLength = length || Math.max(1, byteLength);
assert2(byteLength <= reqLength, "byte array longer than desired length");
assert2(reqLength > 0, "Requested array length <= 0");
this.strip();
var littleEndian = endian === "le";
var res = new ArrayType(reqLength);
var b, i;
var q = this.clone();
if (!littleEndian) {
for (i = 0; i < reqLength - byteLength; i++) {
res[i] = 0;
}
for (i = 0; !q.isZero(); i++) {
b = q.andln(255);
q.iushrn(8);
res[reqLength - i - 1] = b;
}
} else {
for (i = 0; !q.isZero(); i++) {
b = q.andln(255);
q.iushrn(8);
res[i] = b;
}
for (; i < reqLength; i++) {
res[i] = 0;
}
}
return res;
};
if (Math.clz32) {
BN2.prototype._countBits = function _countBits(w) {
return 32 - Math.clz32(w);
};
} else {
BN2.prototype._countBits = function _countBits(w) {
var t = w;
var r2 = 0;
if (t >= 4096) {
r2 += 13;
t >>>= 13;
}
if (t >= 64) {
r2 += 7;
t >>>= 7;
}
if (t >= 8) {
r2 += 4;
t >>>= 4;
}
if (t >= 2) {
r2 += 2;
t >>>= 2;
}
return r2 + t;
};
}
BN2.prototype._zeroBits = function _zeroBits(w) {
if (w === 0) return 26;
var t = w;
var r2 = 0;
if ((t & 8191) === 0) {
r2 += 13;
t >>>= 13;
}
if ((t & 127) === 0) {
r2 += 7;
t >>>= 7;
}
if ((t & 15) === 0) {
r2 += 4;
t >>>= 4;
}
if ((t & 3) === 0) {
r2 += 2;
t >>>= 2;
}
if ((t & 1) === 0) {
r2++;
}
return r2;
};
BN2.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;
}
BN2.prototype.zeroBits = function zeroBits() {
if (this.isZero()) return 0;
var r2 = 0;
for (var i = 0; i < this.length; i++) {
var b = this._zeroBits(this.words[i]);
r2 += b;
if (b !== 26) break;
}
return r2;
};
BN2.prototype.byteLength = function byteLength() {
return Math.ceil(this.bitLength() / 8);
};
BN2.prototype.toTwos = function toTwos(width) {
if (this.negative !== 0) {
return this.abs().inotn(width).iaddn(1);
}
return this.clone();
};
BN2.prototype.fromTwos = function fromTwos(width) {
if (this.testn(width - 1)) {
return this.notn(width).iaddn(1).ineg();
}
return this.clone();
};
BN2.prototype.isNeg = function isNeg() {
return this.negative !== 0;
};
BN2.prototype.neg = function neg4() {
return this.clone().ineg();
};
BN2.prototype.ineg = function ineg() {
if (!this.isZero()) {
this.negative ^= 1;
}
return this;
};
BN2.prototype.iuor = function iuor(num) {
while (this.length < num.length) {
this.words[this.length++] = 0;
}
for (var i = 0; i < num.length; i++) {
this.words[i] = this.words[i] | num.words[i];
}
return this.strip();
};
BN2.prototype.ior = function ior(num) {
assert2((this.negative | num.negative) === 0);
return this.iuor(num);
};
BN2.prototype.or = function or(num) {
if (this.length > num.length) return this.clone().ior(num);
return num.clone().ior(this);
};
BN2.prototype.uor = function uor(num) {
if (this.length > num.length) return this.clone().iuor(num);
return num.clone().iuor(this);
};
BN2.prototype.iuand = function iuand(num) {
var b;
if (this.length > num.length) {
b = num;
} else {
b = this;
}
for (var i = 0; i < b.length; i++) {
this.words[i] = this.words[i] & num.words[i];
}
this.length = b.length;
return this.strip();
};
BN2.prototype.iand = function iand(num) {
assert2((this.negative | num.negative) === 0);
return this.iuand(num);
};
BN2.prototype.and = function and(num) {
if (this.length > num.length) return this.clone().iand(num);
return num.clone().iand(this);
};
BN2.prototype.uand = function uand(num) {
if (this.length > num.length) return this.clone().iuand(num);
return num.clone().iuand(this);
};
BN2.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 i = 0; i < b.length; i++) {
this.words[i] = a.words[i] ^ b.words[i];
}
if (this !== a) {
for (; i < a.length; i++) {
this.words[i] = a.words[i];
}
}
this.length = a.length;
return this.strip();
};
BN2.prototype.ixor = function ixor(num) {
assert2((this.negative | num.negative) === 0);
return this.iuxor(num);
};
BN2.prototype.xor = function xor4(num) {
if (this.length > num.length) return this.clone().ixor(num);
return num.clone().ixor(this);
};
BN2.prototype.uxor = function uxor(num) {
if (this.length > num.length) return this.clone().iuxor(num);
return num.clone().iuxor(this);
};
BN2.prototype.inotn = function inotn(width) {
assert2(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 i = 0; i < bytesNeeded; i++) {
this.words[i] = ~this.words[i] & 67108863;
}
if (bitsLeft > 0) {
this.words[i] = ~this.words[i] & 67108863 >> 26 - bitsLeft;
}
return this.strip();
};
BN2.prototype.notn = function notn(width) {
return this.clone().inotn(width);
};
BN2.prototype.setn = function setn(bit, val) {
assert2(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();
};
BN2.prototype.iadd = function iadd(num) {
var r2;
if (this.negative !== 0 && num.negative === 0) {
this.negative = 0;
r2 = this.isub(num);
this.negative ^= 1;
return this._normSign();
} else if (this.negative === 0 && num.negative !== 0) {
num.negative = 0;
r2 = this.isub(num);
num.negative = 1;
return r2._normSign();
}
var a, b;
if (this.length > num.length) {
a = this;
b = num;
} else {
a = num;
b = this;
}
var carry = 0;
for (var i = 0; i < b.length; i++) {
r2 = (a.words[i] | 0) + (b.words[i] | 0) + carry;
this.words[i] = r2 & 67108863;
carry = r2 >>> 26;
}
for (; carry !== 0 && i < a.length; i++) {
r2 = (a.words[i] | 0) + carry;
this.words[i] = r2 & 67108863;
carry = r2 >>> 26;
}
this.length = a.length;
if (carry !== 0) {
this.words[this.length] = carry;
this.length++;
} else if (a !== this) {
for (; i < a.length; i++) {
this.words[i] = a.words[i];
}
}
return this;
};
BN2.prototype.add = function add5(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);
};
BN2.prototype.isub = function isub(num) {
if (num.negative !== 0) {
num.negative = 0;
var r2 = this.iadd(num);
num.negative = 1;
return r2._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 i = 0; i < b.length; i++) {
r2 = (a.words[i] | 0) - (b.words[i] | 0) + carry;
carry = r2 >> 26;
this.words[i] = r2 & 67108863;
}
for (; carry !== 0 && i < a.length; i++) {
r2 = (a.words[i] | 0) + carry;
carry = r2 >> 26;
this.words[i] = r2 & 67108863;
}
if (carry === 0 && i < a.length && a !== this) {
for (; i < a.length; i++) {
this.words[i] = a.words[i];
}
}
this.length = Math.max(this.length, i);
if (a !== this) {
this.negative = 1;
}
return this.strip();
};
BN2.prototype.sub = function sub(num) {
return this.clone().isub(num);
};
function smallMulTo(self2, num, out) {
out.negative = num.negative ^ self2.negative;
var len = self2.length + num.length | 0;
out.length = len;
len = len - 1 | 0;
var a = self2.words[0] | 0;
var b = num.words[0] | 0;
var r2 = a * b;
var lo = r2 & 67108863;
var carry = r2 / 67108864 | 0;
out.words[0] = lo;
for (var k = 1; k < len; 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 i = k - j | 0;
a = self2.words[i] | 0;
b = num.words[j] | 0;
r2 = a * b + rword;
ncarry += r2 / 67108864 | 0;
rword = r2 & 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 i = k - j;
var a = self2.words[i] | 0;
var b = num.words[j] | 0;
var r2 = a * b;
var lo = r2 & 67108863;
ncarry = ncarry + (r2 / 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);
}
BN2.prototype.mulTo = function mulTo(num, out) {
var res;
var len = this.length + num.length;
if (this.length === 10 && num.length === 10) {
res = comb10MulTo(this, num, out);
} else if (len < 63) {
res = smallMulTo(this, num, out);
} else if (len < 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 = BN2.prototype._countBits(N) - 1;
for (var i = 0; i < N; i++) {
t[i] = this.revBin(i, 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 i = 0; i < l; i++) {
rb |= (x & 1) << l - i - 1;
x >>= 1;
}
return rb;
};
FFTM.prototype.permute = function permute2(rbt, rws, iws, rtws, itws, N) {
for (var i = 0; i < N; i++) {
rtws[i] = rws[rbt[i]];
itws[i] = iws[rbt[i]];
}
};
FFTM.prototype.transform = function transform(rws, iws, rtws, itws, N, rbt) {
this.permute(rbt, rws, iws, rtws, itws, N);
for (var s2 = 1; s2 < N; s2 <<= 1) {
var l = s2 << 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 < s2; j++) {
var re2 = rtws[p + j];
var ie = itws[p + j];
var ro = rtws[p + j + s2];
var io = itws[p + j + s2];
var rx = rtwdf_ * ro - itwdf_ * io;
io = rtwdf_ * io + itwdf_ * ro;
ro = rx;
rtws[p + j] = re2 + ro;
itws[p + j] = ie + io;
rtws[p + j + s2] = re2 - ro;
itws[p + j + s2] = 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 i = 0;
for (N = N / 2 | 0; N; N = N >>> 1) {
i++;
}
return 1 << i + 1 + odd;
};
FFTM.prototype.conjugate = function conjugate(rws, iws, N) {
if (N <= 1) return;
for (var i = 0; i < N / 2; i++) {
var t = rws[i];
rws[i] = rws[N - i - 1];
rws[N - i - 1] = t;
t = iws[i];
iws[i] = -iws[N - i - 1];
iws[N - i - 1] = -t;
}
};
FFTM.prototype.normalize13b = function normalize13b(ws, N) {
var carry = 0;
for (var i = 0; i < N / 2; i++) {
var w = Math.round(ws[2 * i + 1] / N) * 8192 + Math.round(ws[2 * i] / N) + carry;
ws[i] = w & 67108863;
if (w < 67108864) {
carry = 0;
} else {
carry = w / 67108864 | 0;
}
}
return ws;
};
FFTM.prototype.convert13b = function convert13b(ws, len, rws, N) {
var carry = 0;
for (var i = 0; i < len; i++) {
carry = carry + (ws[i] | 0);
rws[2 * i] = carry & 8191;
carry = carry >>> 13;
rws[2 * i + 1] = carry & 8191;
carry = carry >>> 13;
}
for (i = 2 * len; i < N; ++i) {
rws[i] = 0;
}
assert2(carry === 0);
assert2((carry & ~8191) === 0);
};
FFTM.prototype.stub = function stub(N) {
var ph = new Array(N);
for (var i = 0; i < N; i++) {
ph[i] = 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 i = 0; i < N; i++) {
var rx = rwst[i] * nrwst[i] - iwst[i] * niwst[i];
iwst[i] = rwst[i] * niwst[i] + iwst[i] * nrwst[i];
rwst[i] = 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();
};
BN2.prototype.mul = function mul5(num) {
var out = new BN2(null);
out.words = new Array(this.length + num.length);
return this.mulTo(num, out);
};
BN2.prototype.mulf = function mulf(num) {
var out = new BN2(null);
out.words = new Array(this.length + num.length);
return jumboMulTo(this, num, out);
};
BN2.prototype.imul = function imul(num) {
return this.clone().mulTo(num, this);
};
BN2.prototype.imuln = function imuln(num) {
assert2(typeof num === "number");
assert2(num < 67108864);
var carry = 0;
for (var i = 0; i < this.length; i++) {
var w = (this.words[i] | 0) * num;
var lo = (w & 67108863) + (carry & 67108863);
carry >>= 26;
carry += w / 67108864 | 0;
carry += lo >>> 26;
this.words[i] = lo & 67108863;
}
if (carry !== 0) {
this.words[i] = carry;
this.length++;
}
return this;
};
BN2.prototype.muln = function muln(num) {
return this.clone().imuln(num);
};
BN2.prototype.sqr = function sqr() {
return this.mul(this);
};
BN2.prototype.isqr = function isqr() {
return this.imul(this.clone());
};
BN2.prototype.pow = function pow(num) {
var w = toBitArray(num);
if (w.length === 0) return new BN2(1);
var res = this;
for (var i = 0; i < w.length; i++, res = res.sqr()) {
if (w[i] !== 0) break;
}
if (++i < w.length) {
for (var q = res.sqr(); i < w.length; i++, q = q.sqr()) {
if (w[i] === 0) continue;
res = res.mul(q);
}
}
return res;
};
BN2.prototype.iushln = function iushln(bits) {
assert2(typeof bits === "number" && bits >= 0);
var r2 = bits % 26;
var s2 = (bits - r2) / 26;
var carryMask = 67108863 >>> 26 - r2 << 26 - r2;
var i;
if (r2 !== 0) {
var carry = 0;
for (i = 0; i < this.length; i++) {
var newCarry = this.words[i] & carryMask;
var c = (this.words[i] | 0) - newCarry << r2;
this.words[i] = c | carry;
carry = newCarry >>> 26 - r2;
}
if (carry) {
this.words[i] = carry;
this.length++;
}
}
if (s2 !== 0) {
for (i = this.length - 1; i >= 0; i--) {
this.words[i + s2] = this.words[i];
}
for (i = 0; i < s2; i++) {
this.words[i] = 0;
}
this.length += s2;
}
return this.strip();
};
BN2.prototype.ishln = function ishln(bits) {
assert2(this.negative === 0);
return this.iushln(bits);
};
BN2.prototype.iushrn = function iushrn(bits, hint, extended) {
assert2(typeof bits === "number" && bits >= 0);
var h;
if (hint) {
h = (hint - hint % 26) / 26;
} else {
h = 0;
}
var r2 = bits % 26;
var s2 = Math.min((bits - r2) / 26, this.length);
var mask = 67108863 ^ 67108863 >>> r2 << r2;
var maskedWords = extended;
h -= s2;
h = Math.max(0, h);
if (maskedWords) {
for (var i = 0; i < s2; i++) {
maskedWords.words[i] = this.words[i];
}
maskedWords.length = s2;
}
if (s2 === 0) ;
else if (this.length > s2) {
this.length -= s2;
for (i = 0; i < this.length; i++) {
this.words[i] = this.words[i + s2];
}
} else {
this.words[0] = 0;
this.length = 1;
}
var carry = 0;
for (i = this.length - 1; i >= 0 && (carry !== 0 || i >= h); i--) {
var word = this.words[i] | 0;
this.words[i] = carry << 26 - r2 | word >>> r2;
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();
};
BN2.prototype.ishrn = function ishrn(bits, hint, extended) {
assert2(this.negative === 0);
return this.iushrn(bits, hint, extended);
};
BN2.prototype.shln = function shln(bits) {
return this.clone().ishln(bits);
};
BN2.prototype.ushln = function ushln(bits) {
return this.clone().iushln(bits);
};
BN2.prototype.shrn = function shrn(bits) {
return this.clone().ishrn(bits);
};
BN2.prototype.ushrn = function ushrn(bits) {
return this.clone().iushrn(bits);
};
BN2.prototype.testn = function testn(bit) {
assert2(typeof bit === "number" && bit >= 0);
var r2 = bit % 26;
var s2 = (bit - r2) / 26;
var q = 1 << r2;
if (this.length <= s2) return false;
var w = this.words[s2];
return !!(w & q);
};
BN2.prototype.imaskn = function imaskn(bits) {
assert2(typeof bits === "number" && bits >= 0);
var r2 = bits % 26;
var s2 = (bits - r2) / 26;
assert2(this.negative === 0, "imaskn works only with positive numbers");
if (this.length <= s2) {
return this;
}
if (r2 !== 0) {
s2++;
}
this.length = Math.min(s2, this.length);
if (r2 !== 0) {
var mask = 67108863 ^ 67108863 >>> r2 << r2;
this.words[this.length - 1] &= mask;
}
return this.strip();
};
BN2.prototype.maskn = function maskn(bits) {
return this.clone().imaskn(bits);
};
BN2.prototype.iaddn = function iaddn(num) {
assert2(typeof num === "number");
assert2(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);
};
BN2.prototype._iaddn = function _iaddn(num) {
this.words[0] += num;
for (var i = 0; i < this.length && this.words[i] >= 67108864; i++) {
this.words[i] -= 67108864;
if (i === this.length - 1) {
this.words[i + 1] = 1;
} else {
this.words[i + 1]++;
}
}
this.length = Math.max(this.length, i + 1);
return this;
};
BN2.prototype.isubn = function isubn(num) {
assert2(typeof num === "number");
assert2(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 i = 0; i < this.length && this.words[i] < 0; i++) {
this.words[i] += 67108864;
this.words[i + 1] -= 1;
}
}
return this.strip();
};
BN2.prototype.addn = function addn(num) {
return this.clone().iaddn(num);
};
BN2.prototype.subn = function subn(num) {
return this.clone().isubn(num);
};
BN2.prototype.iabs = function iabs() {
this.negative = 0;
return this;
};
BN2.prototype.abs = function abs() {
return this.clone().iabs();
};
BN2.prototype._ishlnsubmul = function _ishlnsubmul(num, mul5, shift) {
var len = num.length + shift;
var i;
this._expand(len);
var w;
var carry = 0;
for (i = 0; i < num.length; i++) {
w = (this.words[i + shift] | 0) + carry;
var right = (num.words[i] | 0) * mul5;
w -= right & 67108863;
carry = (w >> 26) - (right / 67108864 | 0);
this.words[i + shift] = w & 67108863;
}
for (; i < this.length - shift; i++) {
w = (this.words[i + shift] | 0) + carry;
carry = w >> 26;
this.words[i + shift] = w & 67108863;
}
if (carry === 0) return this.strip();
assert2(carry === -1);
carry = 0;
for (i = 0; i < this.length; i++) {
w = -(this.words[i] | 0) + carry;
carry = w >> 26;
this.words[i] = w & 67108863;
}
this.negative = 1;
return this.strip();
};
BN2.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 BN2(null);
q.length = m + 1;
q.words = new Array(q.length);
for (var i = 0; i < q.length; i++) {
q.words[i] = 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
};
};
BN2.prototype.divmod = function divmod(num, mode, positive) {
assert2(!num.isZero());
if (this.isZero()) {
return {
div: new BN2(0),
mod: new BN2(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 BN2(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 BN2(this.modn(num.words[0]))
};
}
return {
div: this.divn(num.words[0]),
mod: new BN2(this.modn(num.words[0]))
};
}
return this._wordDiv(num, mode);
};
BN2.prototype.div = function div(num) {
return this.divmod(num, "div", false).div;
};
BN2.prototype.mod = function mod(num) {
return this.divmod(num, "mod", false).mod;
};
BN2.prototype.umod = function umod(num) {
return this.divmod(num, "mod", true).mod;
};
BN2.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);
};
BN2.prototype.modn = function modn(num) {
assert2(num <= 67108863);
var p = (1 << 26) % num;
var acc = 0;
for (var i = this.length - 1; i >= 0; i--) {
acc = (p * acc + (this.words[i] | 0)) % num;
}
return acc;
};
BN2.prototype.idivn = function idivn(num) {
assert2(num <= 67108863);
var carry = 0;
for (var i = this.length - 1; i >= 0; i--) {
var w = (this.words[i] | 0) + carry * 67108864;
this.words[i] = w / num | 0;
carry = w % num;
}
return this.strip();
};
BN2.prototype.divn = function divn(num) {
return this.clone().idivn(num);
};
BN2.prototype.egcd = function egcd(p) {
assert2(p.negative === 0);
assert2(!p.isZero());
var x = this;
var y = p.clone();
if (x.negative !== 0) {
x = x.umod(p);
} else {
x = x.clone();
}
var A = new BN2(1);
var B = new BN2(0);
var C = new BN2(0);
var D = new BN2(1);
var g2 = 0;
while (x.isEven() && y.isEven()) {
x.iushrn(1);
y.iushrn(1);
++g2;
}
var yp = y.clone();
var xp = x.clone();
while (!x.isZero()) {
for (var i = 0, im = 1; (x.words[0] & im) === 0 && i < 26; ++i, im <<= 1) ;
if (i > 0) {
x.iushrn(i);
while (i-- > 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(g2)
};
};
BN2.prototype._invmp = function _invmp(p) {
assert2(p.negative === 0);
assert2(!p.isZero());
var a = this;
var b = p.clone();
if (a.negative !== 0) {
a = a.umod(p);
} else {
a = a.clone();
}
var x1 = new BN2(1);
var x2 = new BN2(0);
var delta = b.clone();
while (a.cmpn(1) > 0 && b.cmpn(1) > 0) {
for (var i = 0, im = 1; (a.words[0] & im) === 0 && i < 26; ++i, im <<= 1) ;
if (i > 0) {
a.iushrn(i);
while (i-- > 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;
};
BN2.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 r2 = a.cmp(b);
if (r2 < 0) {
var t = a;
a = b;
b = t;
} else if (r2 === 0 || b.cmpn(1) === 0) {
break;
}
a.isub(b);
} while (true);
return b.iushln(shift);
};
BN2.prototype.invm = function invm(num) {
return this.egcd(num).a.umod(num);
};
BN2.prototype.isEven = function isEven() {
return (this.words[0] & 1) === 0;
};
BN2.prototype.isOdd = function isOdd() {
return (this.words[0] & 1) === 1;
};
BN2.prototype.andln = function andln(num) {
return this.words[0] & num;
};
BN2.prototype.bincn = function bincn(bit) {
assert2(typeof bit === "number");
var r2 = bit % 26;
var s2 = (bit - r2) / 26;
var q = 1 << r2;
if (this.length <= s2) {
this._expand(s2 + 1);
this.words[s2] |= q;
return this;
}
var carry = q;
for (var i = s2; carry !== 0 && i < this.length; i++) {
var w = this.words[i] | 0;
w += carry;
carry = w >>> 26;
w &= 67108863;
this.words[i] = w;
}
if (carry !== 0) {
this.words[i] = carry;
this.length++;
}
return this;
};
BN2.prototype.isZero = function isZero() {
return this.length === 1 && this.words[0] === 0;
};
BN2.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;
}
assert2(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;
};
BN2.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;
};
BN2.prototype.ucmp = function ucmp(num) {
if (this.length > num.length) return 1;
if (this.length < num.length) return -1;
var res = 0;
for (var i = this.length - 1; i >= 0; i--) {
var a = this.words[i] | 0;
var b = num.words[i] | 0;
if (a === b) continue;
if (a < b) {
res = -1;
} else if (a > b) {
res = 1;
}
break;
}
return res;
};
BN2.prototype.gtn = function gtn(num) {
return this.cmpn(num) === 1;
};
BN2.prototype.gt = function gt(num) {
return this.cmp(num) === 1;
};
BN2.prototype.gten = function gten(num) {
return this.cmpn(num) >= 0;
};
BN2.prototype.gte = function gte(num) {
return this.cmp(num) >= 0;
};
BN2.prototype.ltn = function ltn(num) {
return this.cmpn(num) === -1;
};
BN2.prototype.lt = function lt(num) {
return this.cmp(num) === -1;
};
BN2.prototype.lten = function lten(num) {
return this.cmpn(num) <= 0;
};
BN2.prototype.lte = function lte(num) {
return this.cmp(num) <= 0;
};
BN2.prototype.eqn = function eqn(num) {
return this.cmpn(num) === 0;
};
BN2.prototype.eq = function eq7(num) {
return this.cmp(num) === 0;
};
BN2.red = function red(num) {
return new Red(num);
};
BN2.prototype.toRed = function toRed(ctx) {
assert2(!this.red, "Already a number in reduction context");
assert2(this.negative === 0, "red works only with positives");
return ctx.convertTo(this)._forceRed(ctx);
};
BN2.prototype.fromRed = function fromRed() {
assert2(this.red, "fromRed works only with numbers in reduction context");
return this.red.convertFrom(this);
};
BN2.prototype._forceRed = function _forceRed(ctx) {
this.red = ctx;
return this;
};
BN2.prototype.forceRed = function forceRed(ctx) {
assert2(!this.red, "Already a number in reduction context");
return this._forceRed(ctx);
};
BN2.prototype.redAdd = function redAdd(num) {
assert2(this.red, "redAdd works only with red numbers");
return this.red.add(this, num);
};
BN2.prototype.redIAdd = function redIAdd(num) {
assert2(this.red, "redIAdd works only with red numbers");
return this.red.iadd(this, num);
};
BN2.prototype.redSub = function redSub(num) {
assert2(this.red, "redSub works only with red numbers");
return this.red.sub(this, num);
};
BN2.prototype.redISub = function redISub(num) {
assert2(this.red, "redISub works only with red numbers");
return this.red.isub(this, num);
};
BN2.prototype.redShl = function redShl(num) {
assert2(this.red, "redShl works only with red numbers");
return this.red.shl(this, num);
};
BN2.prototype.redMul = function redMul(num) {
assert2(this.red, "redMul works only with red numbers");
this.red._verify2(this, num);
return this.red.mul(this, num);
};
BN2.prototype.redIMul = function redIMul(num) {
assert2(this.red, "redMul works only with red numbers");
this.red._verify2(this, num);
return this.red.imul(this, num);
};
BN2.prototype.redSqr = function redSqr() {
assert2(this.red, "redSqr works only with red numbers");
this.red._verify1(this);
return this.red.sqr(this);
};
BN2.prototype.redISqr = function redISqr() {
assert2(this.red, "redISqr works only with red numbers");
this.red._verify1(this);
return this.red.isqr(this);
};
BN2.prototype.redSqrt = function redSqrt() {
assert2(this.red, "redSqrt works only with red numbers");
this.red._verify1(this);
return this.red.sqrt(this);
};
BN2.prototype.redInvm = function redInvm() {
assert2(this.red, "redInvm works only with red numbers");
this.red._verify1(this);
return this.red.invm(this);
};
BN2.prototype.redNeg = function redNeg() {
assert2(this.red, "redNeg works only with red numbers");
this.red._verify1(this);
return this.red.neg(this);
};
BN2.prototype.redPow = function redPow(num) {
assert2(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(name2, p) {
this.name = name2;
this.p = new BN2(p, 16);
this.n = this.p.bitLength();
this.k = new BN2(1).iushln(this.n).isub(this.p);
this.tmp = this._tmp();
}
MPrime.prototype._tmp = function _tmp() {
var tmp = new BN2(null);
tmp.words = new Array(Math.ceil(this.n / 13));
return tmp;
};
MPrime.prototype.ireduce = function ireduce(num) {
var r2 = num;
var rlen;
do {
this.split(r2, this.tmp);
r2 = this.imulK(r2);
r2 = r2.iadd(this.tmp);
rlen = r2.bitLength();
} while (rlen > this.n);
var cmp = rlen < this.n ? -1 : r2.ucmp(this.p);
if (cmp === 0) {
r2.words[0] = 0;
r2.length = 1;
} else if (cmp > 0) {
r2.isub(this.p);
} else {
if (r2.strip !== void 0) {
r2.strip();
} else {
r2._strip();
}
}
return r2;
};
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"
);
}
inherits2(K256, MPrime);
K256.prototype.split = function split(input, output) {
var mask = 4194303;
var outLen = Math.min(input.length, 9);
for (var i = 0; i < outLen; i++) {
output.words[i] = input.words[i];
}
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 (i = 10; i < input.length; i++) {
var next = input.words[i] | 0;
input.words[i - 10] = (next & mask) << 4 | prev >>> 22;
prev = next;
}
prev >>>= 22;
input.words[i - 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 i = 0; i < num.length; i++) {
var w = num.words[i] | 0;
lo += w * 977;
num.words[i] = 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"
);
}
inherits2(P224, MPrime);
function P192() {
MPrime.call(
this,
"p192",
"ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff"
);
}
inherits2(P192, MPrime);
function P25519() {
MPrime.call(
this,
"25519",
"7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed"
);
}
inherits2(P25519, MPrime);
P25519.prototype.imulK = function imulK(num) {
var carry = 0;
for (var i = 0; i < num.length; i++) {
var hi = (num.words[i] | 0) * 19 + carry;
var lo = hi & 67108863;
hi >>>= 26;
num.words[i] = lo;
carry = hi;
}
if (carry !== 0) {
num.words[num.length++] = carry;
}
return num;
};
BN2._prime = function prime(name2) {
if (primes[name2]) return primes[name2];
var prime2;
if (name2 === "k256") {
prime2 = new K256();
} else if (name2 === "p224") {
prime2 = new P224();
} else if (name2 === "p192") {
prime2 = new P192();
} else if (name2 === "p25519") {
prime2 = new P25519();
} else {
throw new Error("Unknown prime " + name2);
}
primes[name2] = prime2;
return prime2;
};
function Red(m) {
if (typeof m === "string") {
var prime = BN2._prime(m);
this.m = prime.p;
this.prime = prime;
} else {
assert2(m.gtn(1), "modulus must be greater than 1");
this.m = m;
this.prime = null;
}
}
Red.prototype._verify1 = function _verify1(a) {
assert2(a.negative === 0, "red works only with positives");
assert2(a.red, "red works only with red numbers");
};
Red.prototype._verify2 = function _verify2(a, b) {
assert2((a.negative | b.negative) === 0, "red works only with positives");
assert2(
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 neg4(a) {
if (a.isZero()) {
return a.clone();
}
return this.m.sub(a)._forceRed(this);
};
Red.prototype.add = function add5(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 mul5(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);
assert2(mod3 % 2 === 1);
if (mod3 === 3) {
var pow = this.m.add(new BN2(1)).iushrn(2);
return this.pow(a, pow);
}
var q = this.m.subn(1);
var s2 = 0;
while (!q.isZero() && q.andln(1) === 0) {
s2++;
q.iushrn(1);
}
assert2(!q.isZero());
var one = new BN2(1).toRed(this);
var nOne = one.redNeg();
var lpow = this.m.subn(1).iushrn(1);
var z2 = this.m.bitLength();
z2 = new BN2(2 * z2 * z2).toRed(this);
while (this.pow(z2, lpow).cmp(nOne) !== 0) {
z2.redIAdd(nOne);
}
var c = this.pow(z2, q);
var r2 = this.pow(a, q.addn(1).iushrn(1));
var t = this.pow(a, q);
var m = s2;
while (t.cmp(one) !== 0) {
var tmp = t;
for (var i = 0; tmp.cmp(one) !== 0; i++) {
tmp = tmp.redSqr();
}
assert2(i < m);
var b = this.pow(c, new BN2(1).iushln(m - i - 1));
r2 = r2.redMul(b);
c = b.redSqr();
t = t.redMul(c);
m = i;
}
return r2;
};
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 BN2(1).toRed(this);
if (num.cmpn(1) === 0) return a.clone();
var windowSize = 4;
var wnd = new Array(1 << windowSize);
wnd[0] = new BN2(1).toRed(this);
wnd[1] = a;
for (var i = 2; i < wnd.length; i++) {
wnd[i] = this.mul(wnd[i - 1], a);
}
var res = wnd[0];
var current = 0;
var currentLen = 0;
var start = num.bitLength() % 26;
if (start === 0) {
start = 26;
}
for (i = num.length - 1; i >= 0; i--) {
var word = num.words[i];
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 && (i !== 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 r2 = num.umod(this.m);
return r2 === num ? r2.clone() : r2;
};
Red.prototype.convertFrom = function convertFrom(num) {
var res = num.clone();
res.red = null;
return res;
};
BN2.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 BN2(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);
}
inherits2(Mont, Red);
Mont.prototype.convertTo = function convertTo(num) {
return this.imod(num.ushln(this.shift));
};
Mont.prototype.convertFrom = function convertFrom(num) {
var r2 = this.imod(num.mul(this.rinv));
r2.red = null;
return r2;
};
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 mul5(a, b) {
if (a.isZero() || b.isZero()) return new BN2(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, commonjsGlobal);
})(bn$1);
var bnExports$1 = bn$1.exports;
var brorand = { exports: {} };
var hasRequiredBrorand;
function requireBrorand() {
if (hasRequiredBrorand) return brorand.exports;
hasRequiredBrorand = 1;
var r2;
brorand.exports = function rand(len) {
if (!r2)
r2 = new Rand(null);
return r2.generate(len);
};
function Rand(rand) {
this.rand = rand;
}
brorand.exports.Rand = Rand;
Rand.prototype.generate = function generate2(len) {
return this._rand(len);
};
Rand.prototype._rand = function _rand(n) {
if (this.rand.getBytes)
return this.rand.getBytes(n);
var res = new Uint8Array(n);
for (var i = 0; i < res.length; i++)
res[i] = 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 crypto2 = requireCryptoBrowserify();
if (typeof crypto2.randomBytes !== "function")
throw new Error("Not supported");
Rand.prototype._rand = function _rand(n) {
return crypto2.randomBytes(n);
};
} catch (e) {
}
}
return brorand.exports;
}
var mr;
var hasRequiredMr;
function requireMr() {
if (hasRequiredMr) return mr;
hasRequiredMr = 1;
var bn2 = bnExports$1;
var brorand2 = requireBrorand();
function MillerRabin(rand) {
this.rand = rand || new brorand2.Rand();
}
mr = MillerRabin;
MillerRabin.create = function create3(rand) {
return new MillerRabin(rand);
};
MillerRabin.prototype._randbelow = function _randbelow(n) {
var len = n.bitLength();
var min_bytes = Math.ceil(len / 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 test2(n, k, cb) {
var len = n.bitLength();
var red = bn2.mont(n);
var rone = new bn2(1).toRed(red);
if (!k)
k = Math.max(1, len / 48 | 0);
var n1 = n.subn(1);
for (var s2 = 0; !n1.testn(s2); s2++) {
}
var d = n.shrn(s2);
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 i = 1; i < s2; i++) {
x = x.redSqr();
if (x.cmp(rone) === 0)
return false;
if (x.cmp(rn1) === 0)
break;
}
if (i === s2)
return false;
}
return prime;
};
MillerRabin.prototype.getDivisor = function getDivisor(n, k) {
var len = n.bitLength();
var red = bn2.mont(n);
var rone = new bn2(1).toRed(red);
if (!k)
k = Math.max(1, len / 48 | 0);
var n1 = n.subn(1);
for (var s2 = 0; !n1.testn(s2); s2++) {
}
var d = n.shrn(s2);
var rn1 = n1.toRed(red);
for (; k > 0; k--) {
var a = this._randrange(new bn2(2), n1);
var g2 = n.gcd(a);
if (g2.cmpn(1) !== 0)
return g2;
var x = a.toRed(red).redPow(d);
if (x.cmp(rone) === 0 || x.cmp(rn1) === 0)
continue;
for (var i = 1; i < s2; i++) {
x = x.redSqr();
if (x.cmp(rone) === 0)
return x.fromRed().subn(1).gcd(n);
if (x.cmp(rn1) === 0)
break;
}
if (i === s2) {
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 randomBytes2 = browserExports;
generatePrime = findPrime;
findPrime.simpleSieve = simpleSieve;
findPrime.fermatTest = fermatTest;
var BN2 = bnExports$1;
var TWENTYFOUR = new BN2(24);
var MillerRabin = requireMr();
var millerRabin = new MillerRabin();
var ONE = new BN2(1);
var TWO = new BN2(2);
var FIVE = new BN2(5);
new BN2(16);
new BN2(8);
var TEN = new BN2(10);
var THREE = new BN2(3);
new BN2(7);
var ELEVEN = new BN2(11);
var FOUR = new BN2(4);
new BN2(12);
var primes = null;
function _getPrimes() {
if (primes !== null)
return primes;
var limit = 1048576;
var res = [];
res[0] = 2;
for (var i = 1, k = 3; k < limit; k += 2) {
var sqrt = Math.ceil(Math.sqrt(k));
for (var j = 0; j < i && res[j] <= sqrt; j++)
if (k % res[j] === 0)
break;
if (i !== j && res[j] <= sqrt)
continue;
res[i++] = k;
}
primes = res;
return res;
}
function simpleSieve(p) {
var primes2 = _getPrimes();
for (var i = 0; i < primes2.length; i++)
if (p.modn(primes2[i]) === 0) {
if (p.cmpn(primes2[i]) === 0) {
return true;
} else {
return false;
}
}
return true;
}
function fermatTest(p) {
var red = BN2.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 BN2([140, 123]);
} else {
return new BN2([140, 39]);
}
}
gen = new BN2(gen);
var num, n2;
while (true) {
num = new BN2(randomBytes2(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 BN2 = bnExports$1;
var MillerRabin = requireMr();
var millerRabin = new MillerRabin();
var TWENTYFOUR = new BN2(24);
var ELEVEN = new BN2(11);
var TEN = new BN2(10);
var THREE = new BN2(3);
var SEVEN = new BN2(7);
var primes = requireGeneratePrime();
var randomBytes2 = browserExports;
dh = DH;
function setPublicKey(pub2, enc) {
enc = enc || "utf8";
if (!Buffer$E.isBuffer(pub2)) {
pub2 = new Buffer$E(pub2, enc);
}
this._pub = new BN2(pub2);
return this;
}
function setPrivateKey(priv2, enc) {
enc = enc || "utf8";
if (!Buffer$E.isBuffer(priv2)) {
priv2 = new Buffer$E(priv2, enc);
}
this._priv = new BN2(priv2);
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 error2 = 0;
if (prime.isEven() || !primes.simpleSieve || !primes.fermatTest(prime) || !millerRabin.test(prime)) {
error2 += 1;
if (gen === "02" || gen === "05") {
error2 += 8;
} else {
error2 += 4;
}
primeCache[hex] = error2;
return error2;
}
if (!millerRabin.test(prime.shrn(1))) {
error2 += 2;
}
var rem;
switch (gen) {
case "02":
if (prime.mod(TWENTYFOUR).cmp(ELEVEN)) {
error2 += 8;
}
break;
case "05":
rem = prime.mod(TEN);
if (rem.cmp(THREE) && rem.cmp(SEVEN)) {
error2 += 8;
}
break;
default:
error2 += 4;
}
primeCache[hex] = error2;
return error2;
}
function DH(prime, generator, malleable) {
this.setGenerator(generator);
this.__prime = new BN2(prime);
this._prime = BN2.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 BN2(randomBytes2(this._primeLen));
}
this._pub = this._gen.toRed(this._prime).redPow(this._priv).fromRed();
return this.getPublicKey();
};
DH.prototype.computeSecret = function(other) {
other = new BN2(other);
other = other.toRed(this._prime);
var secret2 = other.redPow(this._priv).fromRed();
var out = new Buffer$E(secret2.toArray());
var prime = this.getPrime();
if (out.length < prime.length) {
var front = new Buffer$E(prime.length - out.length);
front.fill(0);
out = Buffer$E.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$E.isBuffer(gen)) {
gen = new Buffer$E(gen, enc);
}
this.__gen = gen;
this._gen = new BN2(gen);
return this;
};
function formatReturnValue(bn2, enc) {
var buf = new Buffer$E(bn2.toArray());
if (!enc) {
return buf;
} else {
return buf.toString(enc);
}
}
return dh;
}
var hasRequiredBrowser$2;
function requireBrowser$2() {
if (hasRequiredBrowser$2) return browser$5;
hasRequiredBrowser$2 = 1;
var generatePrime2 = requireGeneratePrime();
var primes = require$$1$1;
var DH = requireDh();
function getDiffieHellman(mod) {
var prime = new Buffer$E(primes[mod].prime, "hex");
var gen = new Buffer$E(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$E.isBuffer(enc) || ENCODINGS[enc] === void 0) {
return createDiffieHellman(prime, "binary", enc, generator);
}
enc = enc || "binary";
genc = genc || "binary";
generator = generator || new Buffer$E([2]);
if (!Buffer$E.isBuffer(generator)) {
generator = new Buffer$E(generator, genc);
}
if (typeof prime === "number") {
return new DH(generatePrime2(prime, generator), generator, true);
}
if (!Buffer$E.isBuffer(prime)) {
prime = new Buffer$E(prime, enc);
}
return new DH(prime, generator, true);
}
browser$5.DiffieHellmanGroup = browser$5.createDiffieHellmanGroup = browser$5.getDiffieHellman = getDiffieHellman;
browser$5.createDiffieHellman = browser$5.DiffieHellman = createDiffieHellman;
return browser$5;
}
var readableBrowser = { exports: {} };
var processNextickArgs = { exports: {} };
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 len = arguments.length;
var args, i;
switch (len) {
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(len - 1);
i = 0;
while (i < args.length) {
args[i++] = arguments[i];
}
return process$1.nextTick(function afterTick() {
fn.apply(null, args);
});
}
}
var processNextickArgsExports = processNextickArgs.exports;
var toString = {}.toString;
var isarray = Array.isArray || function(arr) {
return toString.call(arr) == "[object Array]";
};
var streamBrowser = eventsExports.EventEmitter;
var safeBuffer$1 = { exports: {} };
(function(module2, exports2) {
var buffer2 = dist;
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$1, safeBuffer$1.exports);
var safeBufferExports = safeBuffer$1.exports;
var util$3 = {};
function isArray$1(arg) {
if (Array.isArray) {
return Array.isArray(arg);
}
return objectToString$1(arg) === "[object Array]";
}
util$3.isArray = isArray$1;
function isBoolean(arg) {
return typeof arg === "boolean";
}
util$3.isBoolean = isBoolean;
function isNull(arg) {
return arg === null;
}
util$3.isNull = isNull;
function isNullOrUndefined(arg) {
return arg == null;
}
util$3.isNullOrUndefined = isNullOrUndefined;
function isNumber(arg) {
return typeof arg === "number";
}
util$3.isNumber = isNumber;
function isString(arg) {
return typeof arg === "string";
}
util$3.isString = isString;
function isSymbol(arg) {
return typeof arg === "symbol";
}
util$3.isSymbol = isSymbol;
function isUndefined$1(arg) {
return arg === void 0;
}
util$3.isUndefined = isUndefined$1;
function isRegExp(re2) {
return objectToString$1(re2) === "[object RegExp]";
}
util$3.isRegExp = isRegExp;
function isObject$1(arg) {
return typeof arg === "object" && arg !== null;
}
util$3.isObject = isObject$1;
function isDate(d) {
return objectToString$1(d) === "[object Date]";
}
util$3.isDate = isDate;
function isError(e) {
return objectToString$1(e) === "[object Error]" || e instanceof Error;
}
util$3.isError = isError;
function isFunction$1(arg) {
return typeof arg === "function";
}
util$3.isFunction = isFunction$1;
function isPrimitive(arg) {
return arg === null || typeof arg === "boolean" || typeof arg === "number" || typeof arg === "string" || typeof arg === "symbol" || // ES6 symbol
typeof arg === "undefined";
}
util$3.isPrimitive = isPrimitive;
util$3.isBuffer = dist.Buffer.isBuffer;
function objectToString$1(o) {
return Object.prototype.toString.call(o);
}
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 = safeBufferExports.Buffer;
var util2 = util$4;
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(s2) {
if (this.length === 0) return "";
var p = this.head;
var ret = "" + p.data;
while (p = p.next) {
ret += s2 + 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 i = 0;
while (p) {
copyBuffer(p.data, ret, i);
i += 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 pna = processNextickArgsExports;
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);
}
var destroy_1 = {
destroy,
undestroy
};
var _stream_writable;
var hasRequired_stream_writable;
function require_stream_writable() {
if (hasRequired_stream_writable) return _stream_writable;
hasRequired_stream_writable = 1;
var pna2 = processNextickArgsExports;
_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 : pna2.nextTick;
var Duplex2;
Writable.WritableState = WritableState;
var util2 = Object.create(util$3);
util2.inherits = inherits_browserExports;
var internalUtil = {
deprecate: browser$b
};
var Stream2 = streamBrowser;
var Buffer2 = safeBufferExports.Buffer;
var OurUint8Array = (typeof commonjsGlobal !== "undefined" ? commonjsGlobal : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : {}).Uint8Array || function() {
};
function _uint8ArrayToBuffer(chunk) {
return Buffer2.from(chunk);
}
function _isUint8Array(obj) {
return Buffer2.isBuffer(obj) || obj instanceof OurUint8Array;
}
var destroyImpl = destroy_1;
util2.inherits(Writable, Stream2);
function nop() {
}
function WritableState(options2, stream) {
Duplex2 = Duplex2 || require_stream_duplex();
options2 = options2 || {};
var isDuplex = stream instanceof Duplex2;
this.objectMode = !!options2.objectMode;
if (isDuplex) this.objectMode = this.objectMode || !!options2.writableObjectMode;
var hwm = options2.highWaterMark;
var writableHwm = options2.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 = options2.decodeStrings === false;
this.decodeStrings = !noDecode;
this.defaultEncoding = options2.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(options2) {
Duplex2 = Duplex2 || require_stream_duplex();
if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex2)) {
return new Writable(options2);
}
this._writableState = new WritableState(options2, this);
this.writable = true;
if (options2) {
if (typeof options2.write === "function") this._write = options2.write;
if (typeof options2.writev === "function") this._writev = options2.writev;
if (typeof options2.destroy === "function") this._destroy = options2.destroy;
if (typeof options2.final === "function") this._final = options2.final;
}
Stream2.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);
pna2.nextTick(cb, er);
}
function validChunk(stream, state2, chunk, cb) {
var valid = true;
var er = false;
if (chunk === null) {
er = new TypeError("May not write null values to stream");
} else if (typeof chunk !== "string" && chunk !== void 0 && !state2.objectMode) {
er = new TypeError("Invalid non-string/buffer chunk");
}
if (er) {
stream.emit("error", er);
pna2.nextTick(cb, er);
valid = false;
}
return valid;
}
Writable.prototype.write = function(chunk, encoding, cb) {
var state2 = this._writableState;
var ret = false;
var isBuf = !state2.objectMode && _isUint8Array(chunk);
if (isBuf && !Buffer2.isBuffer(chunk)) {
chunk = _uint8ArrayToBuffer(chunk);
}
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, chunk, cb)) {
state2.pendingcb++;
ret = writeOrBuffer(this, state2, isBuf, chunk, 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, chunk, encoding) {
if (!state2.objectMode && state2.decodeStrings !== false && typeof chunk === "string") {
chunk = Buffer2.from(chunk, encoding);
}
return chunk;
}
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, chunk, encoding, cb) {
if (!isBuf) {
var newChunk = decodeChunk(state2, chunk, encoding);
if (chunk !== newChunk) {
isBuf = true;
encoding = "buffer";
chunk = newChunk;
}
}
var len = state2.objectMode ? 1 : chunk.length;
state2.length += len;
var ret = state2.length < state2.highWaterMark;
if (!ret) state2.needDrain = true;
if (state2.writing || state2.corked) {
var last = state2.lastBufferedRequest;
state2.lastBufferedRequest = {
chunk,
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, len, chunk, encoding, cb);
}
return ret;
}
function doWrite(stream, state2, writev, len, chunk, encoding, cb) {
state2.writelen = len;
state2.writecb = cb;
state2.writing = true;
state2.sync = true;
if (writev) stream._writev(chunk, state2.onwrite);
else stream._write(chunk, encoding, state2.onwrite);
state2.sync = false;
}
function onwriteError(stream, state2, sync2, er, cb) {
--state2.pendingcb;
if (sync2) {
pna2.nextTick(cb, er);
pna2.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 sync2 = state2.sync;
var cb = state2.writecb;
onwriteStateUpdate(state2);
if (er) onwriteError(stream, state2, sync2, er, cb);
else {
var finished = needFinish(state2);
if (!finished && !state2.corked && !state2.bufferProcessing && state2.bufferedRequest) {
clearBuffer(stream, state2);
}
if (sync2) {
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 chunk = entry.chunk;
var encoding = entry.encoding;
var cb = entry.callback;
var len = state2.objectMode ? 1 : chunk.length;
doWrite(stream, state2, false, len, chunk, 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(chunk, encoding, cb) {
cb(new Error("_write() is not implemented"));
};
Writable.prototype._writev = null;
Writable.prototype.end = function(chunk, encoding, cb) {
var state2 = this._writableState;
if (typeof chunk === "function") {
cb = chunk;
chunk = null;
encoding = null;
} else if (typeof encoding === "function") {
cb = encoding;
encoding = null;
}
if (chunk !== null && chunk !== void 0) this.write(chunk, 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 prefinish2(stream, state2) {
if (!state2.prefinished && !state2.finalCalled) {
if (typeof stream._final === "function") {
state2.pendingcb++;
state2.finalCalled = true;
pna2.nextTick(callFinal, stream, state2);
} else {
state2.prefinished = true;
stream.emit("prefinish");
}
}
}
function finishMaybe(stream, state2) {
var need = needFinish(state2);
if (need) {
prefinish2(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) pna2.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 pna2 = processNextickArgsExports;
var objectKeys = Object.keys || function(obj) {
var keys3 = [];
for (var key2 in obj) {
keys3.push(key2);
}
return keys3;
};
_stream_duplex = Duplex2;
var util2 = Object.create(util$3);
util2.inherits = inherits_browserExports;
var Readable = require_stream_readable();
var Writable = require_stream_writable();
util2.inherits(Duplex2, Readable);
{
var keys2 = objectKeys(Writable.prototype);
for (var v = 0; v < keys2.length; v++) {
var method = keys2[v];
if (!Duplex2.prototype[method]) Duplex2.prototype[method] = Writable.prototype[method];
}
}
function Duplex2(options2) {
if (!(this instanceof Duplex2)) return new Duplex2(options2);
Readable.call(this, options2);
Writable.call(this, options2);
if (options2 && options2.readable === false) this.readable = false;
if (options2 && options2.writable === false) this.writable = false;
this.allowHalfOpen = true;
if (options2 && options2.allowHalfOpen === false) this.allowHalfOpen = false;
this.once("end", onend);
}
Object.defineProperty(Duplex2.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;
pna2.nextTick(onEndNT, this);
}
function onEndNT(self2) {
self2.end();
}
Object.defineProperty(Duplex2.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;
}
});
Duplex2.prototype._destroy = function(err, cb) {
this.push(null);
this.end();
pna2.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 pna2 = processNextickArgsExports;
_stream_readable = Readable;
var isArray2 = isarray;
var Duplex2;
Readable.ReadableState = ReadableState;
eventsExports.EventEmitter;
var EElistenerCount = function(emitter, type2) {
return emitter.listeners(type2).length;
};
var Stream2 = streamBrowser;
var Buffer2 = safeBufferExports.Buffer;
var OurUint8Array = (typeof commonjsGlobal !== "undefined" ? commonjsGlobal : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : {}).Uint8Array || function() {
};
function _uint8ArrayToBuffer(chunk) {
return Buffer2.from(chunk);
}
function _isUint8Array(obj) {
return Buffer2.isBuffer(obj) || obj instanceof OurUint8Array;
}
var util2 = Object.create(util$3);
util2.inherits = inherits_browserExports;
var debugUtil = util$4;
var debug = void 0;
if (debugUtil && debugUtil.debuglog) {
debug = debugUtil.debuglog("stream");
} else {
debug = function() {
};
}
var BufferList2 = requireBufferList();
var destroyImpl = destroy_1;
var StringDecoder2;
util2.inherits(Readable, Stream2);
var kProxyEvents = ["error", "close", "destroy", "pause", "resume"];
function prependListener2(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 (isArray2(emitter._events[event])) emitter._events[event].unshift(fn);
else emitter._events[event] = [fn, emitter._events[event]];
}
function ReadableState(options2, stream) {
Duplex2 = Duplex2 || require_stream_duplex();
options2 = options2 || {};
var isDuplex = stream instanceof Duplex2;
this.objectMode = !!options2.objectMode;
if (isDuplex) this.objectMode = this.objectMode || !!options2.readableObjectMode;
var hwm = options2.highWaterMark;
var readableHwm = options2.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 = options2.defaultEncoding || "utf8";
this.awaitDrain = 0;
this.readingMore = false;
this.decoder = null;
this.encoding = null;
if (options2.encoding) {
if (!StringDecoder2) StringDecoder2 = string_decoder.StringDecoder;
this.decoder = new StringDecoder2(options2.encoding);
this.encoding = options2.encoding;
}
}
function Readable(options2) {
Duplex2 = Duplex2 || require_stream_duplex();
if (!(this instanceof Readable)) return new Readable(options2);
this._readableState = new ReadableState(options2, this);
this.readable = true;
if (options2) {
if (typeof options2.read === "function") this._read = options2.read;
if (typeof options2.destroy === "function") this._destroy = options2.destroy;
}
Stream2.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(chunk, encoding) {
var state2 = this._readableState;
var skipChunkCheck;
if (!state2.objectMode) {
if (typeof chunk === "string") {
encoding = encoding || state2.defaultEncoding;
if (encoding !== state2.encoding) {
chunk = Buffer2.from(chunk, encoding);
encoding = "";
}
skipChunkCheck = true;
}
} else {
skipChunkCheck = true;
}
return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);
};
Readable.prototype.unshift = function(chunk) {
return readableAddChunk(this, chunk, null, true, false);
};
function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {
var state2 = stream._readableState;
if (chunk === null) {
state2.reading = false;
onEofChunk(stream, state2);
} else {
var er;
if (!skipChunkCheck) er = chunkInvalid(state2, chunk);
if (er) {
stream.emit("error", er);
} else if (state2.objectMode || chunk && chunk.length > 0) {
if (typeof chunk !== "string" && !state2.objectMode && Object.getPrototypeOf(chunk) !== Buffer2.prototype) {
chunk = _uint8ArrayToBuffer(chunk);
}
if (addToFront) {
if (state2.endEmitted) stream.emit("error", new Error("stream.unshift() after end event"));
else addChunk(stream, state2, chunk, true);
} else if (state2.ended) {
stream.emit("error", new Error("stream.push() after EOF"));
} else {
state2.reading = false;
if (state2.decoder && !encoding) {
chunk = state2.decoder.write(chunk);
if (state2.objectMode || chunk.length !== 0) addChunk(stream, state2, chunk, false);
else maybeReadMore(stream, state2);
} else {
addChunk(stream, state2, chunk, false);
}
}
} else if (!addToFront) {
state2.reading = false;
}
}
return needMoreData(state2);
}
function addChunk(stream, state2, chunk, addToFront) {
if (state2.flowing && state2.length === 0 && !state2.sync) {
stream.emit("data", chunk);
stream.read(0);
} else {
state2.length += state2.objectMode ? 1 : chunk.length;
if (addToFront) state2.buffer.unshift(chunk);
else state2.buffer.push(chunk);
if (state2.needReadable) emitReadable(stream);
}
maybeReadMore(stream, state2);
}
function chunkInvalid(state2, chunk) {
var er;
if (!_isUint8Array(chunk) && typeof chunk !== "string" && chunk !== 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 (!StringDecoder2) StringDecoder2 = string_decoder.StringDecoder;
this._readableState.decoder = new StringDecoder2(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 chunk = state2.decoder.end();
if (chunk && chunk.length) {
state2.buffer.push(chunk);
state2.length += state2.objectMode ? 1 : chunk.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) pna2.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;
pna2.nextTick(maybeReadMore_, stream, state2);
}
}
function maybeReadMore_(stream, state2) {
var len = state2.length;
while (!state2.reading && !state2.flowing && !state2.ended && state2.length < state2.highWaterMark) {
debug("maybeReadMore read 0");
stream.read(0);
if (len === state2.length)
break;
else len = 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) pna2.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(chunk) {
debug("ondata");
increasedAwaitDrain = false;
var ret = dest.write(chunk);
if (false === ret && !increasedAwaitDrain) {
if ((state2.pipesCount === 1 && state2.pipes === dest || state2.pipesCount > 1 && indexOf3(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);
}
prependListener2(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 len = state2.pipesCount;
state2.pipes = null;
state2.pipesCount = 0;
state2.flowing = false;
for (var i = 0; i < len; i++) {
dests[i].emit("unpipe", this, { hasUnpiped: false });
}
return this;
}
var index = indexOf3(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 = Stream2.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) {
pna2.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;
pna2.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 chunk = state2.decoder.end();
if (chunk && chunk.length) _this.push(chunk);
}
_this.push(null);
});
stream.on("data", function(chunk) {
debug("wrapped data");
if (state2.decoder) chunk = state2.decoder.write(chunk);
if (state2.objectMode && (chunk === null || chunk === void 0)) return;
else if (!state2.objectMode && (!chunk || !chunk.length)) return;
var ret = _this.push(chunk);
if (!ret) {
paused = true;
stream.pause();
}
});
for (var i in stream) {
if (this[i] === void 0 && typeof stream[i] === "function") {
this[i] = /* @__PURE__ */ function(method) {
return function() {
return stream[method].apply(stream, arguments);
};
}(i);
}
}
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;
pna2.nextTick(endReadableNT, state2, stream);
}
}
function endReadableNT(state2, stream) {
if (!state2.endEmitted && state2.length === 0) {
state2.endEmitted = true;
stream.readable = false;
stream.emit("end");
}
}
function indexOf3(xs, x) {
for (var i = 0, l = xs.length; i < l; i++) {
if (xs[i] === x) return i;
}
return -1;
}
return _stream_readable;
}
var _stream_transform = Transform$1;
var Duplex = require_stream_duplex();
var util$2 = Object.create(util$3);
util$2.inherits = inherits_browserExports;
util$2.inherits(Transform$1, 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$1(options2) {
if (!(this instanceof Transform$1)) return new Transform$1(options2);
Duplex.call(this, options2);
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 (options2) {
if (typeof options2.transform === "function") this._transform = options2.transform;
if (typeof options2.flush === "function") this._flush = options2.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$1.prototype.push = function(chunk, encoding) {
this._transformState.needTransform = false;
return Duplex.prototype.push.call(this, chunk, encoding);
};
Transform$1.prototype._transform = function(chunk, encoding, cb) {
throw new Error("_transform() is not implemented");
};
Transform$1.prototype._write = function(chunk, encoding, cb) {
var ts = this._transformState;
ts.writecb = cb;
ts.writechunk = chunk;
ts.writeencoding = encoding;
if (!ts.transforming) {
var rs = this._readableState;
if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);
}
};
Transform$1.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$1.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);
}
var _stream_passthrough = PassThrough;
var Transform = _stream_transform;
var util$1 = Object.create(util$3);
util$1.inherits = inherits_browserExports;
util$1.inherits(PassThrough, Transform);
function PassThrough(options2) {
if (!(this instanceof PassThrough)) return new PassThrough(options2);
Transform.call(this, options2);
}
PassThrough.prototype._transform = function(chunk, encoding, cb) {
cb(null, chunk);
};
(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 = _stream_transform;
exports2.PassThrough = _stream_passthrough;
})(readableBrowser, readableBrowser.exports);
var readableBrowserExports = readableBrowser.exports;
var sign = { exports: {} };
var bn = { exports: {} };
bn.exports;
(function(module2) {
(function(module3, exports2) {
function assert2(val, msg) {
if (!val) throw new Error(msg || "Assertion failed");
}
function inherits2(ctor, superCtor) {
ctor.super_ = superCtor;
var TempCtor = function() {
};
TempCtor.prototype = superCtor.prototype;
ctor.prototype = new TempCtor();
ctor.prototype.constructor = ctor;
}
function BN2(number, base2, endian) {
if (BN2.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 = BN2;
} else {
exports2.BN = BN2;
}
BN2.BN = BN2;
BN2.wordSize = 26;
var Buffer2;
try {
if (typeof window !== "undefined" && typeof window.Buffer !== "undefined") {
Buffer2 = window.Buffer;
} else {
Buffer2 = dist.Buffer;
}
} catch (e) {
}
BN2.isBN = function isBN(num) {
if (num instanceof BN2) {
return true;
}
return num !== null && typeof num === "object" && num.constructor.wordSize === BN2.wordSize && Array.isArray(num.words);
};
BN2.max = function max2(left, right) {
if (left.cmp(right) > 0) return left;
return right;
};
BN2.min = function min(left, right) {
if (left.cmp(right) < 0) return left;
return right;
};
BN2.prototype._init = function init3(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;
}
assert2(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);
}
}
}
};
BN2.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 {
assert2(number < 9007199254740992);
this.words = [
number & 67108863,
number / 67108864 & 67108863,
1
];
this.length = 3;
}
if (endian !== "le") return;
this._initArray(this.toArray(), base2, endian);
};
BN2.prototype._initArray = function _initArray(number, base2, endian) {
assert2(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 i = 0; i < this.length; i++) {
this.words[i] = 0;
}
var j, w;
var off = 0;
if (endian === "be") {
for (i = number.length - 1, j = 0; i >= 0; i -= 3) {
w = number[i] | number[i - 1] << 8 | number[i - 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 (i = 0, j = 0; i < number.length; i += 3) {
w = number[i] | number[i + 1] << 8 | number[i + 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 {
assert2(false, "Invalid character in " + string);
}
}
function parseHexByte(string, lowerBound, index) {
var r2 = parseHex4Bits(string, index);
if (index - 1 >= lowerBound) {
r2 |= parseHex4Bits(string, index - 1) << 4;
}
return r2;
}
BN2.prototype._parseHex = function _parseHex(number, start, endian) {
this.length = Math.ceil((number.length - start) / 6);
this.words = new Array(this.length);
for (var i = 0; i < this.length; i++) {
this.words[i] = 0;
}
var off = 0;
var j = 0;
var w;
if (endian === "be") {
for (i = number.length - 1; i >= start; i -= 2) {
w = parseHexByte(number, start, i) << 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 (i = parseLength % 2 === 0 ? start + 1 : start; i < number.length; i += 2) {
w = parseHexByte(number, start, i) << 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, mul5) {
var r2 = 0;
var b = 0;
var len = Math.min(str.length, end);
for (var i = start; i < len; i++) {
var c = str.charCodeAt(i) - 48;
r2 *= mul5;
if (c >= 49) {
b = c - 49 + 10;
} else if (c >= 17) {
b = c - 17 + 10;
} else {
b = c;
}
assert2(c >= 0 && b < mul5, "Invalid character");
r2 += b;
}
return r2;
}
BN2.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 i = start; i < end; i += limbLen) {
word = parseBase(number, i, i + 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, i, number.length, base2);
for (i = 0; i < mod; i++) {
pow *= base2;
}
this.imuln(pow);
if (this.words[0] + word < 67108864) {
this.words[0] += word;
} else {
this._iaddn(word);
}
}
this._strip();
};
BN2.prototype.copy = function copy(dest) {
dest.words = new Array(this.length);
for (var i = 0; i < this.length; i++) {
dest.words[i] = this.words[i];
}
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;
}
BN2.prototype._move = function _move(dest) {
move(dest, this);
};
BN2.prototype.clone = function clone() {
var r2 = new BN2(null);
this.copy(r2);
return r2;
};
BN2.prototype._expand = function _expand(size) {
while (this.length < size) {
this.words[this.length++] = 0;
}
return this;
};
BN2.prototype._strip = function strip() {
while (this.length > 1 && this.words[this.length - 1] === 0) {
this.length--;
}
return this._normSign();
};
BN2.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 {
BN2.prototype[Symbol.for("nodejs.util.inspect.custom")] = inspect6;
} catch (e) {
BN2.prototype.inspect = inspect6;
}
} else {
BN2.prototype.inspect = inspect6;
}
function inspect6() {
return (this.red ? "<BN-R: " : "<BN: ") + this.toString(16) + ">";
}
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
];
BN2.prototype.toString = function toString2(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 i = 0; i < this.length; i++) {
var w = this.words[i];
var word = ((w << off | carry) & 16777215).toString(16);
carry = w >>> 24 - off & 16777215;
off += 2;
if (off >= 26) {
off -= 26;
i--;
}
if (carry !== 0 || i !== 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 r2 = c.modrn(groupBase).toString(base2);
c = c.idivn(groupBase);
if (!c.isZero()) {
out = zeros[groupSize - r2.length] + r2 + out;
} else {
out = r2 + out;
}
}
if (this.isZero()) {
out = "0" + out;
}
while (out.length % padding !== 0) {
out = "0" + out;
}
if (this.negative !== 0) {
out = "-" + out;
}
return out;
}
assert2(false, "Base should be between 2 and 36");
};
BN2.prototype.toNumber = function toNumber() {
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) {
assert2(false, "Number can only safely store up to 53 bits");
}
return this.negative !== 0 ? -ret : ret;
};
BN2.prototype.toJSON = function toJSON2() {
return this.toString(16, 2);
};
if (Buffer2) {
BN2.prototype.toBuffer = function toBuffer2(endian, length) {
return this.toArrayLike(Buffer2, endian, length);
};
}
BN2.prototype.toArray = function toArray2(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);
};
BN2.prototype.toArrayLike = function toArrayLike(ArrayType, endian, length) {
this._strip();
var byteLength = this.byteLength();
var reqLength = length || Math.max(1, byteLength);
assert2(byteLength <= reqLength, "byte array longer than desired length");
assert2(reqLength > 0, "Requested array length <= 0");
var res = allocate(ArrayType, reqLength);
var postfix = endian === "le" ? "LE" : "BE";
this["_toArrayLike" + postfix](res, byteLength);
return res;
};
BN2.prototype._toArrayLikeLE = function _toArrayLikeLE(res, byteLength) {
var position = 0;
var carry = 0;
for (var i = 0, shift = 0; i < this.length; i++) {
var word = this.words[i] << 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;
}
}
};
BN2.prototype._toArrayLikeBE = function _toArrayLikeBE(res, byteLength) {
var position = res.length - 1;
var carry = 0;
for (var i = 0, shift = 0; i < this.length; i++) {
var word = this.words[i] << 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) {
BN2.prototype._countBits = function _countBits(w) {
return 32 - Math.clz32(w);
};
} else {
BN2.prototype._countBits = function _countBits(w) {
var t = w;
var r2 = 0;
if (t >= 4096) {
r2 += 13;
t >>>= 13;
}
if (t >= 64) {
r2 += 7;
t >>>= 7;
}
if (t >= 8) {
r2 += 4;
t >>>= 4;
}
if (t >= 2) {
r2 += 2;
t >>>= 2;
}
return r2 + t;
};
}
BN2.prototype._zeroBits = function _zeroBits(w) {
if (w === 0) return 26;
var t = w;
var r2 = 0;
if ((t & 8191) === 0) {
r2 += 13;
t >>>= 13;
}
if ((t & 127) === 0) {
r2 += 7;
t >>>= 7;
}
if ((t & 15) === 0) {
r2 += 4;
t >>>= 4;
}
if ((t & 3) === 0) {
r2 += 2;
t >>>= 2;
}
if ((t & 1) === 0) {
r2++;
}
return r2;
};
BN2.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;
}
BN2.prototype.zeroBits = function zeroBits() {
if (this.isZero()) return 0;
var r2 = 0;
for (var i = 0; i < this.length; i++) {
var b = this._zeroBits(this.words[i]);
r2 += b;
if (b !== 26) break;
}
return r2;
};
BN2.prototype.byteLength = function byteLength() {
return Math.ceil(this.bitLength() / 8);
};
BN2.prototype.toTwos = function toTwos(width) {
if (this.negative !== 0) {
return this.abs().inotn(width).iaddn(1);
}
return this.clone();
};
BN2.prototype.fromTwos = function fromTwos(width) {
if (this.testn(width - 1)) {
return this.notn(width).iaddn(1).ineg();
}
return this.clone();
};
BN2.prototype.isNeg = function isNeg() {
return this.negative !== 0;
};
BN2.prototype.neg = function neg4() {
return this.clone().ineg();
};
BN2.prototype.ineg = function ineg() {
if (!this.isZero()) {
this.negative ^= 1;
}
return this;
};
BN2.prototype.iuor = function iuor(num) {
while (this.length < num.length) {
this.words[this.length++] = 0;
}
for (var i = 0; i < num.length; i++) {
this.words[i] = this.words[i] | num.words[i];
}
return this._strip();
};
BN2.prototype.ior = function ior(num) {
assert2((this.negative | num.negative) === 0);
return this.iuor(num);
};
BN2.prototype.or = function or(num) {
if (this.length > num.length) return this.clone().ior(num);
return num.clone().ior(this);
};
BN2.prototype.uor = function uor(num) {
if (this.length > num.length) return this.clone().iuor(num);
return num.clone().iuor(this);
};
BN2.prototype.iuand = function iuand(num) {
var b;
if (this.length > num.length) {
b = num;
} else {
b = this;
}
for (var i = 0; i < b.length; i++) {
this.words[i] = this.words[i] & num.words[i];
}
this.length = b.length;
return this._strip();
};
BN2.prototype.iand = function iand(num) {
assert2((this.negative | num.negative) === 0);
return this.iuand(num);
};
BN2.prototype.and = function and(num) {
if (this.length > num.length) return this.clone().iand(num);
return num.clone().iand(this);
};
BN2.prototype.uand = function uand(num) {
if (this.length > num.length) return this.clone().iuand(num);
return num.clone().iuand(this);
};
BN2.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 i = 0; i < b.length; i++) {
this.words[i] = a.words[i] ^ b.words[i];
}
if (this !== a) {
for (; i < a.length; i++) {
this.words[i] = a.words[i];
}
}
this.length = a.length;
return this._strip();
};
BN2.prototype.ixor = function ixor(num) {
assert2((this.negative | num.negative) === 0);
return this.iuxor(num);
};
BN2.prototype.xor = function xor4(num) {
if (this.length > num.length) return this.clone().ixor(num);
return num.clone().ixor(this);
};
BN2.prototype.uxor = function uxor(num) {
if (this.length > num.length) return this.clone().iuxor(num);
return num.clone().iuxor(this);
};
BN2.prototype.inotn = function inotn(width) {
assert2(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 i = 0; i < bytesNeeded; i++) {
this.words[i] = ~this.words[i] & 67108863;
}
if (bitsLeft > 0) {
this.words[i] = ~this.words[i] & 67108863 >> 26 - bitsLeft;
}
return this._strip();
};
BN2.prototype.notn = function notn(width) {
return this.clone().inotn(width);
};
BN2.prototype.setn = function setn(bit, val) {
assert2(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();
};
BN2.prototype.iadd = function iadd(num) {
var r2;
if (this.negative !== 0 && num.negative === 0) {
this.negative = 0;
r2 = this.isub(num);
this.negative ^= 1;
return this._normSign();
} else if (this.negative === 0 && num.negative !== 0) {
num.negative = 0;
r2 = this.isub(num);
num.negative = 1;
return r2._normSign();
}
var a, b;
if (this.length > num.length) {
a = this;
b = num;
} else {
a = num;
b = this;
}
var carry = 0;
for (var i = 0; i < b.length; i++) {
r2 = (a.words[i] | 0) + (b.words[i] | 0) + carry;
this.words[i] = r2 & 67108863;
carry = r2 >>> 26;
}
for (; carry !== 0 && i < a.length; i++) {
r2 = (a.words[i] | 0) + carry;
this.words[i] = r2 & 67108863;
carry = r2 >>> 26;
}
this.length = a.length;
if (carry !== 0) {
this.words[this.length] = carry;
this.length++;
} else if (a !== this) {
for (; i < a.length; i++) {
this.words[i] = a.words[i];
}
}
return this;
};
BN2.prototype.add = function add5(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);
};
BN2.prototype.isub = function isub(num) {
if (num.negative !== 0) {
num.negative = 0;
var r2 = this.iadd(num);
num.negative = 1;
return r2._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 i = 0; i < b.length; i++) {
r2 = (a.words[i] | 0) - (b.words[i] | 0) + carry;
carry = r2 >> 26;
this.words[i] = r2 & 67108863;
}
for (; carry !== 0 && i < a.length; i++) {
r2 = (a.words[i] | 0) + carry;
carry = r2 >> 26;
this.words[i] = r2 & 67108863;
}
if (carry === 0 && i < a.length && a !== this) {
for (; i < a.length; i++) {
this.words[i] = a.words[i];
}
}
this.length = Math.max(this.length, i);
if (a !== this) {
this.negative = 1;
}
return this._strip();
};
BN2.prototype.sub = function sub(num) {
return this.clone().isub(num);
};
function smallMulTo(self2, num, out) {
out.negative = num.negative ^ self2.negative;
var len = self2.length + num.length | 0;
out.length = len;
len = len - 1 | 0;
var a = self2.words[0] | 0;
var b = num.words[0] | 0;
var r2 = a * b;
var lo = r2 & 67108863;
var carry = r2 / 67108864 | 0;
out.words[0] = lo;
for (var k = 1; k < len; 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 i = k - j | 0;
a = self2.words[i] | 0;
b = num.words[j] | 0;
r2 = a * b + rword;
ncarry += r2 / 67108864 | 0;
rword = r2 & 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 i = k - j;
var a = self2.words[i] | 0;
var b = num.words[j] | 0;
var r2 = a * b;
var lo = r2 & 67108863;
ncarry = ncarry + (r2 / 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);
}
BN2.prototype.mulTo = function mulTo(num, out) {
var res;
var len = this.length + num.length;
if (this.length === 10 && num.length === 10) {
res = comb10MulTo(this, num, out);
} else if (len < 63) {
res = smallMulTo(this, num, out);
} else if (len < 1024) {
res = bigMulTo(this, num, out);
} else {
res = jumboMulTo(this, num, out);
}
return res;
};
BN2.prototype.mul = function mul5(num) {
var out = new BN2(null);
out.words = new Array(this.length + num.length);
return this.mulTo(num, out);
};
BN2.prototype.mulf = function mulf(num) {
var out = new BN2(null);
out.words = new Array(this.length + num.length);
return jumboMulTo(this, num, out);
};
BN2.prototype.imul = function imul(num) {
return this.clone().mulTo(num, this);
};
BN2.prototype.imuln = function imuln(num) {
var isNegNum = num < 0;
if (isNegNum) num = -num;
assert2(typeof num === "number");
assert2(num < 67108864);
var carry = 0;
for (var i = 0; i < this.length; i++) {
var w = (this.words[i] | 0) * num;
var lo = (w & 67108863) + (carry & 67108863);
carry >>= 26;
carry += w / 67108864 | 0;
carry += lo >>> 26;
this.words[i] = lo & 67108863;
}
if (carry !== 0) {
this.words[i] = carry;
this.length++;
}
return isNegNum ? this.ineg() : this;
};
BN2.prototype.muln = function muln(num) {
return this.clone().imuln(num);
};
BN2.prototype.sqr = function sqr() {
return this.mul(this);
};
BN2.prototype.isqr = function isqr() {
return this.imul(this.clone());
};
BN2.prototype.pow = function pow(num) {
var w = toBitArray(num);
if (w.length === 0) return new BN2(1);
var res = this;
for (var i = 0; i < w.length; i++, res = res.sqr()) {
if (w[i] !== 0) break;
}
if (++i < w.length) {
for (var q = res.sqr(); i < w.length; i++, q = q.sqr()) {
if (w[i] === 0) continue;
res = res.mul(q);
}
}
return res;
};
BN2.prototype.iushln = function iushln(bits) {
assert2(typeof bits === "number" && bits >= 0);
var r2 = bits % 26;
var s2 = (bits - r2) / 26;
var carryMask = 67108863 >>> 26 - r2 << 26 - r2;
var i;
if (r2 !== 0) {
var carry = 0;
for (i = 0; i < this.length; i++) {
var newCarry = this.words[i] & carryMask;
var c = (this.words[i] | 0) - newCarry << r2;
this.words[i] = c | carry;
carry = newCarry >>> 26 - r2;
}
if (carry) {
this.words[i] = carry;
this.length++;
}
}
if (s2 !== 0) {
for (i = this.length - 1; i >= 0; i--) {
this.words[i + s2] = this.words[i];
}
for (i = 0; i < s2; i++) {
this.words[i] = 0;
}
this.length += s2;
}
return this._strip();
};
BN2.prototype.ishln = function ishln(bits) {
assert2(this.negative === 0);
return this.iushln(bits);
};
BN2.prototype.iushrn = function iushrn(bits, hint, extended) {
assert2(typeof bits === "number" && bits >= 0);
var h;
if (hint) {
h = (hint - hint % 26) / 26;
} else {
h = 0;
}
var r2 = bits % 26;
var s2 = Math.min((bits - r2) / 26, this.length);
var mask = 67108863 ^ 67108863 >>> r2 << r2;
var maskedWords = extended;
h -= s2;
h = Math.max(0, h);
if (maskedWords) {
for (var i = 0; i < s2; i++) {
maskedWords.words[i] = this.words[i];
}
maskedWords.length = s2;
}
if (s2 === 0) ;
else if (this.length > s2) {
this.length -= s2;
for (i = 0; i < this.length; i++) {
this.words[i] = this.words[i + s2];
}
} else {
this.words[0] = 0;
this.length = 1;
}
var carry = 0;
for (i = this.length - 1; i >= 0 && (carry !== 0 || i >= h); i--) {
var word = this.words[i] | 0;
this.words[i] = carry << 26 - r2 | word >>> r2;
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();
};
BN2.prototype.ishrn = function ishrn(bits, hint, extended) {
assert2(this.negative === 0);
return this.iushrn(bits, hint, extended);
};
BN2.prototype.shln = function shln(bits) {
return this.clone().ishln(bits);
};
BN2.prototype.ushln = function ushln(bits) {
return this.clone().iushln(bits);
};
BN2.prototype.shrn = function shrn(bits) {
return this.clone().ishrn(bits);
};
BN2.prototype.ushrn = function ushrn(bits) {
return this.clone().iushrn(bits);
};
BN2.prototype.testn = function testn(bit) {
assert2(typeof bit === "number" && bit >= 0);
var r2 = bit % 26;
var s2 = (bit - r2) / 26;
var q = 1 << r2;
if (this.length <= s2) return false;
var w = this.words[s2];
return !!(w & q);
};
BN2.prototype.imaskn = function imaskn(bits) {
assert2(typeof bits === "number" && bits >= 0);
var r2 = bits % 26;
var s2 = (bits - r2) / 26;
assert2(this.negative === 0, "imaskn works only with positive numbers");
if (this.length <= s2) {
return this;
}
if (r2 !== 0) {
s2++;
}
this.length = Math.min(s2, this.length);
if (r2 !== 0) {
var mask = 67108863 ^ 67108863 >>> r2 << r2;
this.words[this.length - 1] &= mask;
}
return this._strip();
};
BN2.prototype.maskn = function maskn(bits) {
return this.clone().imaskn(bits);
};
BN2.prototype.iaddn = function iaddn(num) {
assert2(typeof num === "number");
assert2(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);
};
BN2.prototype._iaddn = function _iaddn(num) {
this.words[0] += num;
for (var i = 0; i < this.length && this.words[i] >= 67108864; i++) {
this.words[i] -= 67108864;
if (i === this.length - 1) {
this.words[i + 1] = 1;
} else {
this.words[i + 1]++;
}
}
this.length = Math.max(this.length, i + 1);
return this;
};
BN2.prototype.isubn = function isubn(num) {
assert2(typeof num === "number");
assert2(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 i = 0; i < this.length && this.words[i] < 0; i++) {
this.words[i] += 67108864;
this.words[i + 1] -= 1;
}
}
return this._strip();
};
BN2.prototype.addn = function addn(num) {
return this.clone().iaddn(num);
};
BN2.prototype.subn = function subn(num) {
return this.clone().isubn(num);
};
BN2.prototype.iabs = function iabs() {
this.negative = 0;
return this;
};
BN2.prototype.abs = function abs() {
return this.clone().iabs();
};
BN2.prototype._ishlnsubmul = function _ishlnsubmul(num, mul5, shift) {
var len = num.length + shift;
var i;
this._expand(len);
var w;
var carry = 0;
for (i = 0; i < num.length; i++) {
w = (this.words[i + shift] | 0) + carry;
var right = (num.words[i] | 0) * mul5;
w -= right & 67108863;
carry = (w >> 26) - (right / 67108864 | 0);
this.words[i + shift] = w & 67108863;
}
for (; i < this.length - shift; i++) {
w = (this.words[i + shift] | 0) + carry;
carry = w >> 26;
this.words[i + shift] = w & 67108863;
}
if (carry === 0) return this._strip();
assert2(carry === -1);
carry = 0;
for (i = 0; i < this.length; i++) {
w = -(this.words[i] | 0) + carry;
carry = w >> 26;
this.words[i] = w & 67108863;
}
this.negative = 1;
return this._strip();
};
BN2.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 BN2(null);
q.length = m + 1;
q.words = new Array(q.length);
for (var i = 0; i < q.length; i++) {
q.words[i] = 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
};
};
BN2.prototype.divmod = function divmod(num, mode, positive) {
assert2(!num.isZero());
if (this.isZero()) {
return {
div: new BN2(0),
mod: new BN2(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 BN2(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 BN2(this.modrn(num.words[0]))
};
}
return {
div: this.divn(num.words[0]),
mod: new BN2(this.modrn(num.words[0]))
};
}
return this._wordDiv(num, mode);
};
BN2.prototype.div = function div(num) {
return this.divmod(num, "div", false).div;
};
BN2.prototype.mod = function mod(num) {
return this.divmod(num, "mod", false).mod;
};
BN2.prototype.umod = function umod(num) {
return this.divmod(num, "mod", true).mod;
};
BN2.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);
};
BN2.prototype.modrn = function modrn(num) {
var isNegNum = num < 0;
if (isNegNum) num = -num;
assert2(num <= 67108863);
var p = (1 << 26) % num;
var acc = 0;
for (var i = this.length - 1; i >= 0; i--) {
acc = (p * acc + (this.words[i] | 0)) % num;
}
return isNegNum ? -acc : acc;
};
BN2.prototype.modn = function modn(num) {
return this.modrn(num);
};
BN2.prototype.idivn = function idivn(num) {
var isNegNum = num < 0;
if (isNegNum) num = -num;
assert2(num <= 67108863);
var carry = 0;
for (var i = this.length - 1; i >= 0; i--) {
var w = (this.words[i] | 0) + carry * 67108864;
this.words[i] = w / num | 0;
carry = w % num;
}
this._strip();
return isNegNum ? this.ineg() : this;
};
BN2.prototype.divn = function divn(num) {
return this.clone().idivn(num);
};
BN2.prototype.egcd = function egcd(p) {
assert2(p.negative === 0);
assert2(!p.isZero());
var x = this;
var y = p.clone();
if (x.negative !== 0) {
x = x.umod(p);
} else {
x = x.clone();
}
var A = new BN2(1);
var B = new BN2(0);
var C = new BN2(0);
var D = new BN2(1);
var g2 = 0;
while (x.isEven() && y.isEven()) {
x.iushrn(1);
y.iushrn(1);
++g2;
}
var yp = y.clone();
var xp = x.clone();
while (!x.isZero()) {
for (var i = 0, im = 1; (x.words[0] & im) === 0 && i < 26; ++i, im <<= 1) ;
if (i > 0) {
x.iushrn(i);
while (i-- > 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(g2)
};
};
BN2.prototype._invmp = function _invmp(p) {
assert2(p.negative === 0);
assert2(!p.isZero());
var a = this;
var b = p.clone();
if (a.negative !== 0) {
a = a.umod(p);
} else {
a = a.clone();
}
var x1 = new BN2(1);
var x2 = new BN2(0);
var delta = b.clone();
while (a.cmpn(1) > 0 && b.cmpn(1) > 0) {
for (var i = 0, im = 1; (a.words[0] & im) === 0 && i < 26; ++i, im <<= 1) ;
if (i > 0) {
a.iushrn(i);
while (i-- > 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;
};
BN2.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 r2 = a.cmp(b);
if (r2 < 0) {
var t = a;
a = b;
b = t;
} else if (r2 === 0 || b.cmpn(1) === 0) {
break;
}
a.isub(b);
} while (true);
return b.iushln(shift);
};
BN2.prototype.invm = function invm(num) {
return this.egcd(num).a.umod(num);
};
BN2.prototype.isEven = function isEven() {
return (this.words[0] & 1) === 0;
};
BN2.prototype.isOdd = function isOdd() {
return (this.words[0] & 1) === 1;
};
BN2.prototype.andln = function andln(num) {
return this.words[0] & num;
};
BN2.prototype.bincn = function bincn(bit) {
assert2(typeof bit === "number");
var r2 = bit % 26;
var s2 = (bit - r2) / 26;
var q = 1 << r2;
if (this.length <= s2) {
this._expand(s2 + 1);
this.words[s2] |= q;
return this;
}
var carry = q;
for (var i = s2; carry !== 0 && i < this.length; i++) {
var w = this.words[i] | 0;
w += carry;
carry = w >>> 26;
w &= 67108863;
this.words[i] = w;
}
if (carry !== 0) {
this.words[i] = carry;
this.length++;
}
return this;
};
BN2.prototype.isZero = function isZero() {
return this.length === 1 && this.words[0] === 0;
};
BN2.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;
}
assert2(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;
};
BN2.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;
};
BN2.prototype.ucmp = function ucmp(num) {
if (this.length > num.length) return 1;
if (this.length < num.length) return -1;
var res = 0;
for (var i = this.length - 1; i >= 0; i--) {
var a = this.words[i] | 0;
var b = num.words[i] | 0;
if (a === b) continue;
if (a < b) {
res = -1;
} else if (a > b) {
res = 1;
}
break;
}
return res;
};
BN2.prototype.gtn = function gtn(num) {
return this.cmpn(num) === 1;
};
BN2.prototype.gt = function gt(num) {
return this.cmp(num) === 1;
};
BN2.prototype.gten = function gten(num) {
return this.cmpn(num) >= 0;
};
BN2.prototype.gte = function gte(num) {
return this.cmp(num) >= 0;
};
BN2.prototype.ltn = function ltn(num) {
return this.cmpn(num) === -1;
};
BN2.prototype.lt = function lt(num) {
return this.cmp(num) === -1;
};
BN2.prototype.lten = function lten(num) {
return this.cmpn(num) <= 0;
};
BN2.prototype.lte = function lte(num) {
return this.cmp(num) <= 0;
};
BN2.prototype.eqn = function eqn(num) {
return this.cmpn(num) === 0;
};
BN2.prototype.eq = function eq7(num) {
return this.cmp(num) === 0;
};
BN2.red = function red(num) {
return new Red(num);
};
BN2.prototype.toRed = function toRed(ctx) {
assert2(!this.red, "Already a number in reduction context");
assert2(this.negative === 0, "red works only with positives");
return ctx.convertTo(this)._forceRed(ctx);
};
BN2.prototype.fromRed = function fromRed() {
assert2(this.red, "fromRed works only with numbers in reduction context");
return this.red.convertFrom(this);
};
BN2.prototype._forceRed = function _forceRed(ctx) {
this.red = ctx;
return this;
};
BN2.prototype.forceRed = function forceRed(ctx) {
assert2(!this.red, "Already a number in reduction context");
return this._forceRed(ctx);
};
BN2.prototype.redAdd = function redAdd(num) {
assert2(this.red, "redAdd works only with red numbers");
return this.red.add(this, num);
};
BN2.prototype.redIAdd = function redIAdd(num) {
assert2(this.red, "redIAdd works only with red numbers");
return this.red.iadd(this, num);
};
BN2.prototype.redSub = function redSub(num) {
assert2(this.red, "redSub works only with red numbers");
return this.red.sub(this, num);
};
BN2.prototype.redISub = function redISub(num) {
assert2(this.red, "redISub works only with red numbers");
return this.red.isub(this, num);
};
BN2.prototype.redShl = function redShl(num) {
assert2(this.red, "redShl works only with red numbers");
return this.red.shl(this, num);
};
BN2.prototype.redMul = function redMul(num) {
assert2(this.red, "redMul works only with red numbers");
this.red._verify2(this, num);
return this.red.mul(this, num);
};
BN2.prototype.redIMul = function redIMul(num) {
assert2(this.red, "redMul works only with red numbers");
this.red._verify2(this, num);
return this.red.imul(this, num);
};
BN2.prototype.redSqr = function redSqr() {
assert2(this.red, "redSqr works only with red numbers");
this.red._verify1(this);
return this.red.sqr(this);
};
BN2.prototype.redISqr = function redISqr() {
assert2(this.red, "redISqr works only with red numbers");
this.red._verify1(this);
return this.red.isqr(this);
};
BN2.prototype.redSqrt = function redSqrt() {
assert2(this.red, "redSqrt works only with red numbers");
this.red._verify1(this);
return this.red.sqrt(this);
};
BN2.prototype.redInvm = function redInvm() {
assert2(this.red, "redInvm works only with red numbers");
this.red._verify1(this);
return this.red.invm(this);
};
BN2.prototype.redNeg = function redNeg() {
assert2(this.red, "redNeg works only with red numbers");
this.red._verify1(this);
return this.red.neg(this);
};
BN2.prototype.redPow = function redPow(num) {
assert2(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(name2, p) {
this.name = name2;
this.p = new BN2(p, 16);
this.n = this.p.bitLength();
this.k = new BN2(1).iushln(this.n).isub(this.p);
this.tmp = this._tmp();
}
MPrime.prototype._tmp = function _tmp() {
var tmp = new BN2(null);
tmp.words = new Array(Math.ceil(this.n / 13));
return tmp;
};
MPrime.prototype.ireduce = function ireduce(num) {
var r2 = num;
var rlen;
do {
this.split(r2, this.tmp);
r2 = this.imulK(r2);
r2 = r2.iadd(this.tmp);
rlen = r2.bitLength();
} while (rlen > this.n);
var cmp = rlen < this.n ? -1 : r2.ucmp(this.p);
if (cmp === 0) {
r2.words[0] = 0;
r2.length = 1;
} else if (cmp > 0) {
r2.isub(this.p);
} else {
if (r2.strip !== void 0) {
r2.strip();
} else {
r2._strip();
}
}
return r2;
};
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"
);
}
inherits2(K256, MPrime);
K256.prototype.split = function split(input, output) {
var mask = 4194303;
var outLen = Math.min(input.length, 9);
for (var i = 0; i < outLen; i++) {
output.words[i] = input.words[i];
}
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 (i = 10; i < input.length; i++) {
var next = input.words[i] | 0;
input.words[i - 10] = (next & mask) << 4 | prev >>> 22;
prev = next;
}
prev >>>= 22;
input.words[i - 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 i = 0; i < num.length; i++) {
var w = num.words[i] | 0;
lo += w * 977;
num.words[i] = 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"
);
}
inherits2(P224, MPrime);
function P192() {
MPrime.call(
this,
"p192",
"ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff"
);
}
inherits2(P192, MPrime);
function P25519() {
MPrime.call(
this,
"25519",
"7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed"
);
}
inherits2(P25519, MPrime);
P25519.prototype.imulK = function imulK(num) {
var carry = 0;
for (var i = 0; i < num.length; i++) {
var hi = (num.words[i] | 0) * 19 + carry;
var lo = hi & 67108863;
hi >>>= 26;
num.words[i] = lo;
carry = hi;
}
if (carry !== 0) {
num.words[num.length++] = carry;
}
return num;
};
BN2._prime = function prime(name2) {
if (primes[name2]) return primes[name2];
var prime2;
if (name2 === "k256") {
prime2 = new K256();
} else if (name2 === "p224") {
prime2 = new P224();
} else if (name2 === "p192") {
prime2 = new P192();
} else if (name2 === "p25519") {
prime2 = new P25519();
} else {
throw new Error("Unknown prime " + name2);
}
primes[name2] = prime2;
return prime2;
};
function Red(m) {
if (typeof m === "string") {
var prime = BN2._prime(m);
this.m = prime.p;
this.prime = prime;
} else {
assert2(m.gtn(1), "modulus must be greater than 1");
this.m = m;
this.prime = null;
}
}
Red.prototype._verify1 = function _verify1(a) {
assert2(a.negative === 0, "red works only with positives");
assert2(a.red, "red works only with red numbers");
};
Red.prototype._verify2 = function _verify2(a, b) {
assert2((a.negative | b.negative) === 0, "red works only with positives");
assert2(
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 neg4(a) {
if (a.isZero()) {
return a.clone();
}
return this.m.sub(a)._forceRed(this);
};
Red.prototype.add = function add5(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 mul5(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);
assert2(mod3 % 2 === 1);
if (mod3 === 3) {
var pow = this.m.add(new BN2(1)).iushrn(2);
return this.pow(a, pow);
}
var q = this.m.subn(1);
var s2 = 0;
while (!q.isZero() && q.andln(1) === 0) {
s2++;
q.iushrn(1);
}
assert2(!q.isZero());
var one = new BN2(1).toRed(this);
var nOne = one.redNeg();
var lpow = this.m.subn(1).iushrn(1);
var z2 = this.m.bitLength();
z2 = new BN2(2 * z2 * z2).toRed(this);
while (this.pow(z2, lpow).cmp(nOne) !== 0) {
z2.redIAdd(nOne);
}
var c = this.pow(z2, q);
var r2 = this.pow(a, q.addn(1).iushrn(1));
var t = this.pow(a, q);
var m = s2;
while (t.cmp(one) !== 0) {
var tmp = t;
for (var i = 0; tmp.cmp(one) !== 0; i++) {
tmp = tmp.redSqr();
}
assert2(i < m);
var b = this.pow(c, new BN2(1).iushln(m - i - 1));
r2 = r2.redMul(b);
c = b.redSqr();
t = t.redMul(c);
m = i;
}
return r2;
};
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 BN2(1).toRed(this);
if (num.cmpn(1) === 0) return a.clone();
var windowSize = 4;
var wnd = new Array(1 << windowSize);
wnd[0] = new BN2(1).toRed(this);
wnd[1] = a;
for (var i = 2; i < wnd.length; i++) {
wnd[i] = this.mul(wnd[i - 1], a);
}
var res = wnd[0];
var current = 0;
var currentLen = 0;
var start = num.bitLength() % 26;
if (start === 0) {
start = 26;
}
for (i = num.length - 1; i >= 0; i--) {
var word = num.words[i];
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 && (i !== 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 r2 = num.umod(this.m);
return r2 === num ? r2.clone() : r2;
};
Red.prototype.convertFrom = function convertFrom(num) {
var res = num.clone();
res.red = null;
return res;
};
BN2.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 BN2(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);
}
inherits2(Mont, Red);
Mont.prototype.convertTo = function convertTo(num) {
return this.imod(num.ushln(this.shift));
};
Mont.prototype.convertFrom = function convertFrom(num) {
var r2 = this.imod(num.mul(this.rinv));
r2.red = null;
return r2;
};
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 mul5(a, b) {
if (a.isZero() || b.isZero()) return new BN2(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, commonjsGlobal);
})(bn);
var bnExports = bn.exports;
var BN$a = bnExports;
var randomBytes$1 = browserExports;
var Buffer$9 = safeBufferExports$1.Buffer;
function getr(priv2) {
var len = priv2.modulus.byteLength();
var r2;
do {
r2 = new BN$a(randomBytes$1(len));
} while (r2.cmp(priv2.modulus) >= 0 || !r2.umod(priv2.prime1) || !r2.umod(priv2.prime2));
return r2;
}
function blind(priv2) {
var r2 = getr(priv2);
var blinder = r2.toRed(BN$a.mont(priv2.modulus)).redPow(new BN$a(priv2.publicExponent)).fromRed();
return { blinder, unblinder: r2.invm(priv2.modulus) };
}
function crt$2(msg, priv2) {
var blinds = blind(priv2);
var len = priv2.modulus.byteLength();
var blinded = new BN$a(msg).mul(blinds.blinder).umod(priv2.modulus);
var c1 = blinded.toRed(BN$a.mont(priv2.prime1));
var c2 = blinded.toRed(BN$a.mont(priv2.prime2));
var qinv = priv2.coefficient;
var p = priv2.prime1;
var q = priv2.prime2;
var m1 = c1.redPow(priv2.exponent1).fromRed();
var m2 = c2.redPow(priv2.exponent2).fromRed();
var h = m1.isub(m2).imul(qinv).umod(p).imul(q);
return m2.iadd(h).imul(blinds.unblinder).umod(priv2.modulus).toArrayLike(Buffer$9, "be", len);
}
crt$2.getr = getr;
var browserifyRsa = crt$2;
var elliptic = {};
const name$1 = "elliptic";
const version$2 = "6.5.7";
const description$1 = "EC cryptography";
const main$1 = "lib/elliptic.js";
const files = [
"lib"
];
const scripts$1 = {
lint: "eslint lib test",
"lint:fix": "npm run lint -- --fix",
unit: "istanbul test _mocha --reporter=spec test/index.js",
test: "npm run lint && npm run unit",
version: "grunt dist && git add dist/"
};
const repository$1 = {
type: "git",
url: "git@github.com:indutny/elliptic"
};
const keywords$1 = [
"EC",
"Elliptic",
"curve",
"Cryptography"
];
const author = "Fedor Indutny <fedor@indutny.com>";
const license$1 = "MIT";
const bugs = {
url: "https://github.com/indutny/elliptic/issues"
};
const homepage = "https://github.com/indutny/elliptic";
const devDependencies$1 = {
brfs: "^2.0.2",
coveralls: "^3.1.0",
eslint: "^7.6.0",
grunt: "^1.2.1",
"grunt-browserify": "^5.3.0",
"grunt-cli": "^1.3.2",
"grunt-contrib-connect": "^3.0.0",
"grunt-contrib-copy": "^1.0.0",
"grunt-contrib-uglify": "^5.0.0",
"grunt-mocha-istanbul": "^5.0.2",
"grunt-saucelabs": "^9.0.1",
istanbul: "^0.4.5",
mocha: "^8.0.1"
};
const dependencies = {
"bn.js": "^4.11.9",
brorand: "^1.1.0",
"hash.js": "^1.0.0",
"hmac-drbg": "^1.0.1",
inherits: "^2.0.4",
"minimalistic-assert": "^1.0.1",
"minimalistic-crypto-utils": "^1.0.1"
};
const require$$0 = {
name: name$1,
version: version$2,
description: description$1,
main: main$1,
files,
scripts: scripts$1,
repository: repository$1,
keywords: keywords$1,
author,
license: license$1,
bugs,
homepage,
devDependencies: devDependencies$1,
dependencies
};
var utils$l = {};
var utils$k = {};
(function(exports2) {
var utils2 = exports2;
function toArray2(msg, enc) {
if (Array.isArray(msg))
return msg.slice();
if (!msg)
return [];
var res = [];
if (typeof msg !== "string") {
for (var i = 0; i < msg.length; i++)
res[i] = msg[i] | 0;
return res;
}
if (enc === "hex") {
msg = msg.replace(/[^a-z0-9]+/ig, "");
if (msg.length % 2 !== 0)
msg = "0" + msg;
for (var i = 0; i < msg.length; i += 2)
res.push(parseInt(msg[i] + msg[i + 1], 16));
} else {
for (var i = 0; i < msg.length; i++) {
var c = msg.charCodeAt(i);
var hi = c >> 8;
var lo = c & 255;
if (hi)
res.push(hi, lo);
else
res.push(lo);
}
}
return res;
}
utils2.toArray = toArray2;
function zero22(word) {
if (word.length === 1)
return "0" + word;
else
return word;
}
utils2.zero2 = zero22;
function toHex3(msg) {
var res = "";
for (var i = 0; i < msg.length; i++)
res += zero22(msg[i].toString(16));
return res;
}
utils2.toHex = toHex3;
utils2.encode = function encode2(arr, enc) {
if (enc === "hex")
return toHex3(arr);
else
return arr;
};
})(utils$k);
(function(exports2) {
var utils2 = exports2;
var BN2 = bnExports$1;
var minAssert = minimalisticAssert;
var minUtils = utils$k;
utils2.assert = minAssert;
utils2.toArray = minUtils.toArray;
utils2.zero2 = minUtils.zero2;
utils2.toHex = minUtils.toHex;
utils2.encode = minUtils.encode;
function getNAF2(num, w, bits) {
var naf = new Array(Math.max(num.bitLength(), bits) + 1);
var i;
for (i = 0; i < naf.length; i += 1) {
naf[i] = 0;
}
var ws = 1 << w + 1;
var k = num.clone();
for (i = 0; i < naf.length; i++) {
var z2;
var mod = k.andln(ws - 1);
if (k.isOdd()) {
if (mod > (ws >> 1) - 1)
z2 = (ws >> 1) - mod;
else
z2 = mod;
k.isubn(z2);
} else {
z2 = 0;
}
naf[i] = z2;
k.iushrn(1);
}
return naf;
}
utils2.getNAF = getNAF2;
function getJSF2(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 = getJSF2;
function cachedProperty2(obj, name2, computer) {
var key2 = "_" + name2;
obj.prototype[name2] = function cachedProperty3() {
return this[key2] !== void 0 ? this[key2] : this[key2] = computer.call(this);
};
}
utils2.cachedProperty = cachedProperty2;
function parseBytes2(bytes) {
return typeof bytes === "string" ? utils2.toArray(bytes, "hex") : bytes;
}
utils2.parseBytes = parseBytes2;
function intFromLE(bytes) {
return new BN2(bytes, "hex", "le");
}
utils2.intFromLE = intFromLE;
})(utils$l);
var curve = {};
var BN$9 = bnExports$1;
var utils$j = utils$l;
var getNAF = utils$j.getNAF;
var getJSF = utils$j.getJSF;
var assert$d = utils$j.assert;
function BaseCurve(type2, conf) {
this.type = type2;
this.p = new BN$9(conf.p, 16);
this.red = conf.prime ? BN$9.red(conf.prime) : BN$9.mont(this.p);
this.zero = new BN$9(0).toRed(this.red);
this.one = new BN$9(1).toRed(this.red);
this.two = new BN$9(2).toRed(this.red);
this.n = conf.n && new BN$9(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);
}
}
var 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$d(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 i = I; i > 0; i--) {
for (j = 0; j < repr.length; j++) {
nafW = repr[j];
if (nafW === i)
b = b.mixedAdd(doubles.points[j]);
else if (nafW === -i)
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 i = naf.length - 1; i >= 0; i--) {
for (var l = 0; i >= 0 && naf[i] === 0; i--)
l++;
if (i >= 0)
l++;
acc = acc.dblp(l);
if (i < 0)
break;
var z2 = naf[i];
assert$d(z2 !== 0);
if (p.type === "affine") {
if (z2 > 0)
acc = acc.mixedAdd(wnd[z2 - 1 >> 1]);
else
acc = acc.mixedAdd(wnd[-z2 - 1 >> 1].neg());
} else {
if (z2 > 0)
acc = acc.add(wnd[z2 - 1 >> 1]);
else
acc = acc.add(wnd[-z2 - 1 >> 1].neg());
}
}
return p.type === "affine" ? acc.toP() : acc;
};
BaseCurve.prototype._wnafMulAdd = function _wnafMulAdd(defW, points, coeffs, len, jacobianResult) {
var wndWidth = this._wnafT1;
var wnd = this._wnafT2;
var naf = this._wnafT3;
var max2 = 0;
var i;
var j;
var p;
for (i = 0; i < len; i++) {
p = points[i];
var nafPoints = p._getNAFPoints(defW);
wndWidth[i] = nafPoints.wnd;
wnd[i] = nafPoints.points;
}
for (i = len - 1; i >= 1; i -= 2) {
var a = i - 1;
var b = i;
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);
max2 = Math.max(naf[a].length, max2);
max2 = Math.max(naf[b].length, max2);
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]);
max2 = Math.max(jsf[0].length, max2);
naf[a] = new Array(max2);
naf[b] = new Array(max2);
for (j = 0; j < max2; 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 (i = max2; i >= 0; i--) {
var k = 0;
while (i >= 0) {
var zero = true;
for (j = 0; j < len; j++) {
tmp[j] = naf[j][i] | 0;
if (tmp[j] !== 0)
zero = false;
}
if (!zero)
break;
k++;
i--;
}
if (i >= 0)
k++;
acc = acc.dblp(k);
if (i < 0)
break;
for (j = 0; j < len; j++) {
var z2 = tmp[j];
if (z2 === 0)
continue;
else if (z2 > 0)
p = wnd[j][z2 - 1 >> 1];
else if (z2 < 0)
p = wnd[j][-z2 - 1 >> 1].neg();
if (p.type === "affine")
acc = acc.mixedAdd(p);
else
acc = acc.add(p);
}
}
for (i = 0; i < len; i++)
wnd[i] = 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 eq2() {
throw new Error("Not implemented");
};
BasePoint.prototype.validate = function validate2() {
return this.curve.validate(this);
};
BaseCurve.prototype.decodePoint = function decodePoint(bytes, enc) {
bytes = utils$j.toArray(bytes, enc);
var len = this.p.byteLength();
if ((bytes[0] === 4 || bytes[0] === 6 || bytes[0] === 7) && bytes.length - 1 === 2 * len) {
if (bytes[0] === 6)
assert$d(bytes[bytes.length - 1] % 2 === 0);
else if (bytes[0] === 7)
assert$d(bytes[bytes.length - 1] % 2 === 1);
var res = this.point(
bytes.slice(1, 1 + len),
bytes.slice(1 + len, 1 + 2 * len)
);
return res;
} else if ((bytes[0] === 2 || bytes[0] === 3) && bytes.length - 1 === len) {
return this.pointFromX(bytes.slice(1, 1 + len), 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 len = this.curve.p.byteLength();
var x = this.getX().toArray("be", len);
if (compact)
return [this.getY().isEven() ? 2 : 3].concat(x);
return [4].concat(x, this.getY().toArray("be", len));
};
BasePoint.prototype.encode = function encode(enc, compact) {
return utils$j.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 i = 0; i < power; i += 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 max2 = (1 << wnd) - 1;
var dbl5 = max2 === 1 ? null : this.dbl();
for (var i = 1; i < max2; i++)
res[i] = res[i - 1].add(dbl5);
return {
wnd,
points: res
};
};
BasePoint.prototype._getBeta = function _getBeta() {
return null;
};
BasePoint.prototype.dblp = function dblp(k) {
var r2 = this;
for (var i = 0; i < k; i++)
r2 = r2.dbl();
return r2;
};
var utils$i = utils$l;
var BN$8 = bnExports$1;
var inherits$4 = inherits_browserExports;
var Base$2 = base$1;
var assert$c = utils$i.assert;
function ShortCurve(conf) {
Base$2.call(this, "short", conf);
this.a = new BN$8(conf.a, 16).toRed(this.red);
this.b = new BN$8(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$4(ShortCurve, Base$2);
var 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$8(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$8(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$c(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$8(vec.a, 16),
b: new BN$8(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$8.mont(num);
var tinv = new BN$8(2).toRed(red).redInvm();
var ntinv = tinv.redNeg();
var s2 = new BN$8(3).toRed(red).redNeg().redSqrt().redMul(tinv);
var l1 = ntinv.redAdd(s2).fromRed();
var l2 = ntinv.redSub(s2).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$8(1);
var y1 = new BN$8(0);
var x2 = new BN$8(0);
var y2 = new BN$8(1);
var a0;
var b0;
var a1;
var b1;
var a2;
var b2;
var prevR;
var i = 0;
var r2;
var x;
while (u.cmpn(0) !== 0) {
var q = v.div(u);
r2 = v.sub(q.mul(u));
x = x2.sub(q.mul(x1));
var y = y2.sub(q.mul(y1));
if (!a1 && r2.cmp(aprxSqrt) < 0) {
a0 = prevR.neg();
b0 = x1;
a1 = r2.neg();
b1 = x;
} else if (a1 && ++i === 2) {
break;
}
prevR = r2;
v = u;
u = r2;
x2 = x1;
x1 = x;
y2 = y1;
y1 = y;
}
a2 = r2.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$8(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 validate3(point5) {
if (point5.inf)
return true;
var x = point5.x;
var y = point5.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 i = 0; i < points.length; i++) {
var split = this._endoSplit(coeffs[i]);
var p = points[i];
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[i * 2] = p;
npoints[i * 2 + 1] = beta;
ncoeffs[i * 2] = split.k1;
ncoeffs[i * 2 + 1] = split.k2;
}
var res = this._wnafMulAdd(1, npoints, ncoeffs, i * 2, jacobianResult);
for (var j = 0; j < i * 2; j++) {
npoints[j] = null;
ncoeffs[j] = null;
}
return res;
};
function Point$2(curve2, x, y, isRed) {
Base$2.BasePoint.call(this, curve2, "affine");
if (x === null && y === null) {
this.x = null;
this.y = null;
this.inf = true;
} else {
this.x = new BN$8(x, 16);
this.y = new BN$8(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$4(Point$2, Base$2.BasePoint);
ShortCurve.prototype.point = function point2(x, y, isRed) {
return new Point$2(this, x, y, isRed);
};
ShortCurve.prototype.pointFromJSON = function pointFromJSON(obj, red) {
return Point$2.fromJSON(this, obj, red);
};
Point$2.prototype._getBeta = function _getBeta2() {
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$2.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$2.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$2.prototype.inspect = function inspect() {
if (this.isInfinity())
return "<EC Point Infinity>";
return "<EC Point x: " + this.x.fromRed().toString(16, 2) + " y: " + this.y.fromRed().toString(16, 2) + ">";
};
Point$2.prototype.isInfinity = function isInfinity() {
return this.inf;
};
Point$2.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$2.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$2.prototype.getX = function getX() {
return this.x.fromRed();
};
Point$2.prototype.getY = function getY() {
return this.y.fromRed();
};
Point$2.prototype.mul = function mul(k) {
k = new BN$8(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$2.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$2.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$2.prototype.eq = function eq3(p) {
return this === p || this.inf === p.inf && (this.inf || this.x.cmp(p.x) === 0 && this.y.cmp(p.y) === 0);
};
Point$2.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$2.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, z2) {
Base$2.BasePoint.call(this, curve2, "jacobian");
if (x === null && y === null && z2 === null) {
this.x = this.curve.one;
this.y = this.curve.one;
this.z = new BN$8(0);
} else {
this.x = new BN$8(x, 16);
this.y = new BN$8(y, 16);
this.z = new BN$8(z2, 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$4(JPoint, Base$2.BasePoint);
ShortCurve.prototype.jpoint = function jpoint(x, y, z2) {
return new JPoint(this, x, y, z2);
};
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 neg2() {
return this.curve.jpoint(this.x, this.y.redNeg(), this.z);
};
JPoint.prototype.add = function add2(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 r2 = s1.redSub(s2);
if (h.cmpn(0) === 0) {
if (r2.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 = r2.redSqr().redIAdd(h3).redISub(v).redISub(v);
var ny = r2.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 r2 = s1.redSub(s2);
if (h.cmpn(0) === 0) {
if (r2.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 = r2.redSqr().redIAdd(h3).redISub(v).redISub(v);
var ny = r2.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 dblp2(pow) {
if (pow === 0)
return this;
if (this.isInfinity())
return this;
if (!pow)
return this.dbl();
var i;
if (this.curve.zeroA || this.curve.threeA) {
var r2 = this;
for (i = 0; i < pow; i++)
r2 = r2.dbl();
return r2;
}
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 (i = 0; i < pow; i++) {
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 (i + 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 dbl2() {
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 s2 = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);
s2 = s2.redIAdd(s2);
var m = xx.redAdd(xx).redIAdd(xx);
var t = m.redSqr().redISub(s2).redISub(s2);
var yyyy8 = yyyy.redIAdd(yyyy);
yyyy8 = yyyy8.redIAdd(yyyy8);
yyyy8 = yyyy8.redIAdd(yyyy8);
nx = t;
ny = m.redMul(s2.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 f2 = e.redSqr();
var c8 = c.redIAdd(c);
c8 = c8.redIAdd(c8);
c8 = c8.redIAdd(c8);
nx = f2.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 s2 = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);
s2 = s2.redIAdd(s2);
var m = xx.redAdd(xx).redIAdd(xx).redIAdd(this.curve.a);
var t = m.redSqr().redISub(s2).redISub(s2);
nx = t;
var yyyy8 = yyyy.redIAdd(yyyy);
yyyy8 = yyyy8.redIAdd(yyyy8);
yyyy8 = yyyy8.redIAdd(yyyy8);
ny = m.redMul(s2.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 mul2(k, kbase) {
k = new BN$8(k, kbase);
return this.curve._wnafMul(this, k);
};
JPoint.prototype.eq = function eq4(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 "<EC JPoint Infinity>";
return "<EC JPoint x: " + this.x.toString(16, 2) + " y: " + this.y.toString(16, 2) + " z: " + this.z.toString(16, 2) + ">";
};
JPoint.prototype.isInfinity = function isInfinity2() {
return this.z.cmpn(0) === 0;
};
var BN$7 = bnExports$1;
var inherits$3 = inherits_browserExports;
var Base$1 = base$1;
var utils$h = utils$l;
function MontCurve(conf) {
Base$1.call(this, "mont", conf);
this.a = new BN$7(conf.a, 16).toRed(this.red);
this.b = new BN$7(conf.b, 16).toRed(this.red);
this.i4 = new BN$7(4).toRed(this.red).redInvm();
this.two = new BN$7(2).toRed(this.red);
this.a24 = this.i4.redMul(this.a.redAdd(this.two));
}
inherits$3(MontCurve, Base$1);
var mont = MontCurve;
MontCurve.prototype.validate = function validate4(point5) {
var x = point5.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$1(curve2, x, z2) {
Base$1.BasePoint.call(this, curve2, "projective");
if (x === null && z2 === null) {
this.x = this.curve.one;
this.z = this.curve.zero;
} else {
this.x = new BN$7(x, 16);
this.z = new BN$7(z2, 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$3(Point$1, Base$1.BasePoint);
MontCurve.prototype.decodePoint = function decodePoint2(bytes, enc) {
return this.point(utils$h.toArray(bytes, enc), 1);
};
MontCurve.prototype.point = function point3(x, z2) {
return new Point$1(this, x, z2);
};
MontCurve.prototype.pointFromJSON = function pointFromJSON2(obj) {
return Point$1.fromJSON(this, obj);
};
Point$1.prototype.precompute = function precompute2() {
};
Point$1.prototype._encode = function _encode2() {
return this.getX().toArray("be", this.curve.p.byteLength());
};
Point$1.fromJSON = function fromJSON2(curve2, obj) {
return new Point$1(curve2, obj[0], obj[1] || curve2.one);
};
Point$1.prototype.inspect = function inspect3() {
if (this.isInfinity())
return "<EC Point Infinity>";
return "<EC Point x: " + this.x.fromRed().toString(16, 2) + " z: " + this.z.fromRed().toString(16, 2) + ">";
};
Point$1.prototype.isInfinity = function isInfinity3() {
return this.z.cmpn(0) === 0;
};
Point$1.prototype.dbl = function dbl3() {
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$1.prototype.add = function add3() {
throw new Error("Not supported on Montgomery curve");
};
Point$1.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$1.prototype.mul = function mul3(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 i = bits.length - 1; i >= 0; i--) {
if (bits[i] === 0) {
a = a.diffAdd(b, c);
b = b.dbl();
} else {
b = a.diffAdd(b, c);
a = a.dbl();
}
}
return b;
};
Point$1.prototype.mulAdd = function mulAdd2() {
throw new Error("Not supported on Montgomery curve");
};
Point$1.prototype.jumlAdd = function jumlAdd() {
throw new Error("Not supported on Montgomery curve");
};
Point$1.prototype.eq = function eq5(other) {
return this.getX().cmp(other.getX()) === 0;
};
Point$1.prototype.normalize = function normalize2() {
this.x = this.x.redMul(this.z.redInvm());
this.z = this.curve.one;
return this;
};
Point$1.prototype.getX = function getX2() {
this.normalize();
return this.x.fromRed();
};
var utils$g = utils$l;
var BN$6 = bnExports$1;
var inherits$2 = inherits_browserExports;
var Base = base$1;
var assert$b = utils$g.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$6(conf.a, 16).umod(this.red.m);
this.a = this.a.toRed(this.red);
this.c = new BN$6(conf.c, 16).toRed(this.red);
this.c2 = this.c.redSqr();
this.d = new BN$6(conf.d, 16).toRed(this.red);
this.dd = this.d.redAdd(this.d);
assert$b(!this.twisted || this.c.fromRed().cmpn(1) === 0);
this.oneC = (conf.c | 0) === 1;
}
inherits$2(EdwardsCurve, Base);
var 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 jpoint2(x, y, z2, t) {
return this.point(x, y, z2, t);
};
EdwardsCurve.prototype.pointFromX = function pointFromX2(x, odd) {
x = new BN$6(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$6(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 validate5(point5) {
if (point5.isInfinity())
return true;
point5.normalize();
var x2 = point5.x.redSqr();
var y2 = point5.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, z2, t) {
Base.BasePoint.call(this, curve2, "projective");
if (x === null && y === null && z2 === 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$6(x, 16);
this.y = new BN$6(y, 16);
this.z = z2 ? new BN$6(z2, 16) : this.curve.one;
this.t = t && new BN$6(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$2(Point, Base.BasePoint);
EdwardsCurve.prototype.pointFromJSON = function pointFromJSON3(obj) {
return Point.fromJSON(this, obj);
};
EdwardsCurve.prototype.point = function point4(x, y, z2, t) {
return new Point(this, x, y, z2, t);
};
Point.fromJSON = function fromJSON3(curve2, obj) {
return new Point(curve2, obj[0], obj[1], obj[2]);
};
Point.prototype.inspect = function inspect4() {
if (this.isInfinity())
return "<EC Point Infinity>";
return "<EC Point x: " + this.x.fromRed().toString(16, 2) + " y: " + this.y.fromRed().toString(16, 2) + " z: " + this.z.fromRed().toString(16, 2) + ">";
};
Point.prototype.isInfinity = function isInfinity4() {
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 g2 = d.redAdd(b);
var f2 = g2.redSub(c);
var h = d.redSub(b);
var nx = e.redMul(f2);
var ny = g2.redMul(h);
var nt = e.redMul(h);
var nz = f2.redMul(g2);
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 f2 = e.redAdd(d);
if (this.zOne) {
nx = b.redSub(c).redSub(d).redMul(f2.redSub(this.curve.two));
ny = f2.redMul(e.redSub(d));
nz = f2.redSqr().redSub(f2).redSub(f2);
} else {
h = this.z.redSqr();
j = f2.redSub(h).redISub(h);
nx = b.redSub(c).redISub(d).redMul(j);
ny = f2.redMul(e.redSub(d));
nz = f2.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 dbl4() {
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 f2 = d.redSub(c);
var g2 = d.redAdd(c);
var h = b.redAdd(a);
var nx = e.redMul(f2);
var ny = g2.redMul(h);
var nt = e.redMul(h);
var nz = f2.redMul(g2);
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 f2 = b.redSub(e);
var g2 = b.redAdd(e);
var tmp = this.x.redAdd(this.y).redMul(p.x.redAdd(p.y)).redISub(c).redISub(d);
var nx = a.redMul(f2).redMul(tmp);
var ny;
var nz;
if (this.curve.twisted) {
ny = a.redMul(g2).redMul(d.redSub(this.curve._mulA(c)));
nz = f2.redMul(g2);
} else {
ny = a.redMul(g2).redMul(d.redSub(c));
nz = this.curve._mulC(f2).redMul(g2);
}
return this.curve.point(nx, ny, nz);
};
Point.prototype.add = function add4(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 mul4(k) {
if (this._hasDoubles(k))
return this.curve._fixedNafMul(this, k);
else
return this.curve._wnafMul(this, k);
};
Point.prototype.mulAdd = function mulAdd3(k1, p, k2) {
return this.curve._wnafMulAdd(1, [this, p], [k1, k2], 2, false);
};
Point.prototype.jmulAdd = function jmulAdd2(k1, p, k2) {
return this.curve._wnafMulAdd(1, [this, p], [k1, k2], 2, true);
};
Point.prototype.normalize = function normalize3() {
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 neg3() {
return this.curve.point(
this.x.redNeg(),
this.y,
this.z,
this.t && this.t.redNeg()
);
};
Point.prototype.getX = function getX3() {
this.normalize();
return this.x.fromRed();
};
Point.prototype.getY = function getY2() {
this.normalize();
return this.y.fromRed();
};
Point.prototype.eq = function eq6(other) {
return this === other || this.getX().cmp(other.getX()) === 0 && this.getY().cmp(other.getY()) === 0;
};
Point.prototype.eqXToP = function eqXToP2(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;
(function(exports2) {
var curve2 = exports2;
curve2.base = base$1;
curve2.short = short;
curve2.mont = mont;
curve2.edwards = edwards;
})(curve);
var curves$1 = {};
var hash$2 = {};
var utils$f = {};
var assert$a = minimalisticAssert;
var inherits$1 = inherits_browserExports;
utils$f.inherits = inherits$1;
function isSurrogatePair(msg, i) {
if ((msg.charCodeAt(i) & 64512) !== 55296) {
return false;
}
if (i < 0 || i + 1 >= msg.length) {
return false;
}
return (msg.charCodeAt(i + 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 i = 0; i < msg.length; i++) {
var c = msg.charCodeAt(i);
if (c < 128) {
res[p++] = c;
} else if (c < 2048) {
res[p++] = c >> 6 | 192;
res[p++] = c & 63 | 128;
} else if (isSurrogatePair(msg, i)) {
c = 65536 + ((c & 1023) << 10) + (msg.charCodeAt(++i) & 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 (i = 0; i < msg.length; i += 2)
res.push(parseInt(msg[i] + msg[i + 1], 16));
}
} else {
for (i = 0; i < msg.length; i++)
res[i] = msg[i] | 0;
}
return res;
}
utils$f.toArray = toArray;
function toHex(msg) {
var res = "";
for (var i = 0; i < msg.length; i++)
res += zero2(msg[i].toString(16));
return res;
}
utils$f.toHex = toHex;
function htonl(w) {
var res = w >>> 24 | w >>> 8 & 65280 | w << 8 & 16711680 | (w & 255) << 24;
return res >>> 0;
}
utils$f.htonl = htonl;
function toHex32(msg, endian) {
var res = "";
for (var i = 0; i < msg.length; i++) {
var w = msg[i];
if (endian === "little")
w = htonl(w);
res += zero8(w.toString(16));
}
return res;
}
utils$f.toHex32 = toHex32;
function zero2(word) {
if (word.length === 1)
return "0" + word;
else
return word;
}
utils$f.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$f.zero8 = zero8;
function join32(msg, start, end, endian) {
var len = end - start;
assert$a(len % 4 === 0);
var res = new Array(len / 4);
for (var i = 0, k = start; i < res.length; i++, 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[i] = w >>> 0;
}
return res;
}
utils$f.join32 = join32;
function split32(msg, endian) {
var res = new Array(msg.length * 4);
for (var i = 0, k = 0; i < msg.length; i++, k += 4) {
var m = msg[i];
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$f.split32 = split32;
function rotr32$1(w, b) {
return w >>> b | w << 32 - b;
}
utils$f.rotr32 = rotr32$1;
function rotl32$2(w, b) {
return w << b | w >>> 32 - b;
}
utils$f.rotl32 = rotl32$2;
function sum32$3(a, b) {
return a + b >>> 0;
}
utils$f.sum32 = sum32$3;
function sum32_3$1(a, b, c) {
return a + b + c >>> 0;
}
utils$f.sum32_3 = sum32_3$1;
function sum32_4$2(a, b, c, d) {
return a + b + c + d >>> 0;
}
utils$f.sum32_4 = sum32_4$2;
function sum32_5$2(a, b, c, d, e) {
return a + b + c + d + e >>> 0;
}
utils$f.sum32_5 = sum32_5$2;
function sum64$1(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$f.sum64 = sum64$1;
function sum64_hi$1(ah, al, bh, bl) {
var lo = al + bl >>> 0;
var hi = (lo < al ? 1 : 0) + ah + bh;
return hi >>> 0;
}
utils$f.sum64_hi = sum64_hi$1;
function sum64_lo$1(ah, al, bh, bl) {
var lo = al + bl;
return lo >>> 0;
}
utils$f.sum64_lo = sum64_lo$1;
function sum64_4_hi$1(ah, al, bh, bl, ch2, 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 + ch2 + dh2 + carry;
return hi >>> 0;
}
utils$f.sum64_4_hi = sum64_4_hi$1;
function sum64_4_lo$1(ah, al, bh, bl, ch2, cl, dh2, dl) {
var lo = al + bl + cl + dl;
return lo >>> 0;
}
utils$f.sum64_4_lo = sum64_4_lo$1;
function sum64_5_hi$1(ah, al, bh, bl, ch2, 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 + ch2 + dh2 + eh + carry;
return hi >>> 0;
}
utils$f.sum64_5_hi = sum64_5_hi$1;
function sum64_5_lo$1(ah, al, bh, bl, ch2, cl, dh2, dl, eh, el) {
var lo = al + bl + cl + dl + el;
return lo >>> 0;
}
utils$f.sum64_5_lo = sum64_5_lo$1;
function rotr64_hi$1(ah, al, num) {
var r2 = al << 32 - num | ah >>> num;
return r2 >>> 0;
}
utils$f.rotr64_hi = rotr64_hi$1;
function rotr64_lo$1(ah, al, num) {
var r2 = ah << 32 - num | al >>> num;
return r2 >>> 0;
}
utils$f.rotr64_lo = rotr64_lo$1;
function shr64_hi$1(ah, al, num) {
return ah >>> num;
}
utils$f.shr64_hi = shr64_hi$1;
function shr64_lo$1(ah, al, num) {
var r2 = ah << 32 - num | al >>> num;
return r2 >>> 0;
}
utils$f.shr64_lo = shr64_lo$1;
var common$5 = {};
var utils$e = utils$f;
var assert$9 = minimalisticAssert;
function BlockHash$4() {
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$5.BlockHash = BlockHash$4;
BlockHash$4.prototype.update = function update2(msg, enc) {
msg = utils$e.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 r2 = msg.length % this._delta8;
this.pending = msg.slice(msg.length - r2, msg.length);
if (this.pending.length === 0)
this.pending = null;
msg = utils$e.join32(msg, 0, msg.length - r2, this.endian);
for (var i = 0; i < msg.length; i += this._delta32)
this._update(msg, i, i + this._delta32);
}
return this;
};
BlockHash$4.prototype.digest = function digest(enc) {
this.update(this._pad());
assert$9(this.pending === null);
return this._digest(enc);
};
BlockHash$4.prototype._pad = function pad() {
var len = this.pendingTotal;
var bytes = this._delta8;
var k = bytes - (len + this.padLength) % bytes;
var res = new Array(k + this.padLength);
res[0] = 128;
for (var i = 1; i < k; i++)
res[i] = 0;
len <<= 3;
if (this.endian === "big") {
for (var t = 8; t < this.padLength; t++)
res[i++] = 0;
res[i++] = 0;
res[i++] = 0;
res[i++] = 0;
res[i++] = 0;
res[i++] = len >>> 24 & 255;
res[i++] = len >>> 16 & 255;
res[i++] = len >>> 8 & 255;
res[i++] = len & 255;
} else {
res[i++] = len & 255;
res[i++] = len >>> 8 & 255;
res[i++] = len >>> 16 & 255;
res[i++] = len >>> 24 & 255;
res[i++] = 0;
res[i++] = 0;
res[i++] = 0;
res[i++] = 0;
for (t = 8; t < this.padLength; t++)
res[i++] = 0;
}
return res;
};
var sha = {};
var common$4 = {};
var utils$d = utils$f;
var rotr32 = utils$d.rotr32;
function ft_1$1(s2, x, y, z2) {
if (s2 === 0)
return ch32$1(x, y, z2);
if (s2 === 1 || s2 === 3)
return p32(x, y, z2);
if (s2 === 2)
return maj32$1(x, y, z2);
}
common$4.ft_1 = ft_1$1;
function ch32$1(x, y, z2) {
return x & y ^ ~x & z2;
}
common$4.ch32 = ch32$1;
function maj32$1(x, y, z2) {
return x & y ^ x & z2 ^ y & z2;
}
common$4.maj32 = maj32$1;
function p32(x, y, z2) {
return x ^ y ^ z2;
}
common$4.p32 = p32;
function s0_256$1(x) {
return rotr32(x, 2) ^ rotr32(x, 13) ^ rotr32(x, 22);
}
common$4.s0_256 = s0_256$1;
function s1_256$1(x) {
return rotr32(x, 6) ^ rotr32(x, 11) ^ rotr32(x, 25);
}
common$4.s1_256 = s1_256$1;
function g0_256$1(x) {
return rotr32(x, 7) ^ rotr32(x, 18) ^ x >>> 3;
}
common$4.g0_256 = g0_256$1;
function g1_256$1(x) {
return rotr32(x, 17) ^ rotr32(x, 19) ^ x >>> 10;
}
common$4.g1_256 = g1_256$1;
var utils$c = utils$f;
var common$3 = common$5;
var shaCommon$1 = common$4;
var rotl32$1 = utils$c.rotl32;
var sum32$2 = utils$c.sum32;
var sum32_5$1 = utils$c.sum32_5;
var ft_1 = shaCommon$1.ft_1;
var BlockHash$3 = common$3.BlockHash;
var sha1_K = [
1518500249,
1859775393,
2400959708,
3395469782
];
function SHA1() {
if (!(this instanceof SHA1))
return new SHA1();
BlockHash$3.call(this);
this.h = [
1732584193,
4023233417,
2562383102,
271733878,
3285377520
];
this.W = new Array(80);
}
utils$c.inherits(SHA1, BlockHash$3);
var _1 = SHA1;
SHA1.blockSize = 512;
SHA1.outSize = 160;
SHA1.hmacStrength = 80;
SHA1.padLength = 64;
SHA1.prototype._update = function _update4(msg, start) {
var W2 = this.W;
for (var i = 0; i < 16; i++)
W2[i] = msg[start + i];
for (; i < W2.length; i++)
W2[i] = rotl32$1(W2[i - 3] ^ W2[i - 8] ^ W2[i - 14] ^ W2[i - 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 (i = 0; i < W2.length; i++) {
var s2 = ~~(i / 20);
var t = sum32_5$1(rotl32$1(a, 5), ft_1(s2, b, c, d), e, W2[i], sha1_K[s2]);
e = d;
d = c;
c = rotl32$1(b, 30);
b = a;
a = t;
}
this.h[0] = sum32$2(this.h[0], a);
this.h[1] = sum32$2(this.h[1], b);
this.h[2] = sum32$2(this.h[2], c);
this.h[3] = sum32$2(this.h[3], d);
this.h[4] = sum32$2(this.h[4], e);
};
SHA1.prototype._digest = function digest2(enc) {
if (enc === "hex")
return utils$c.toHex32(this.h, "big");
else
return utils$c.split32(this.h, "big");
};
var utils$b = utils$f;
var common$2 = common$5;
var shaCommon = common$4;
var assert$8 = minimalisticAssert;
var sum32$1 = utils$b.sum32;
var sum32_4$1 = utils$b.sum32_4;
var sum32_5 = utils$b.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$2 = common$2.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$1() {
if (!(this instanceof SHA256$1))
return new SHA256$1();
BlockHash$2.call(this);
this.h = [
1779033703,
3144134277,
1013904242,
2773480762,
1359893119,
2600822924,
528734635,
1541459225
];
this.k = sha256_K;
this.W = new Array(64);
}
utils$b.inherits(SHA256$1, BlockHash$2);
var _256 = SHA256$1;
SHA256$1.blockSize = 512;
SHA256$1.outSize = 256;
SHA256$1.hmacStrength = 192;
SHA256$1.padLength = 64;
SHA256$1.prototype._update = function _update5(msg, start) {
var W2 = this.W;
for (var i = 0; i < 16; i++)
W2[i] = msg[start + i];
for (; i < W2.length; i++)
W2[i] = sum32_4$1(g1_256(W2[i - 2]), W2[i - 7], g0_256(W2[i - 15]), W2[i - 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 f2 = this.h[5];
var g2 = this.h[6];
var h = this.h[7];
assert$8(this.k.length === W2.length);
for (i = 0; i < W2.length; i++) {
var T1 = sum32_5(h, s1_256(e), ch32(e, f2, g2), this.k[i], W2[i]);
var T2 = sum32$1(s0_256(a), maj32(a, b, c));
h = g2;
g2 = f2;
f2 = e;
e = sum32$1(d, T1);
d = c;
c = b;
b = a;
a = sum32$1(T1, T2);
}
this.h[0] = sum32$1(this.h[0], a);
this.h[1] = sum32$1(this.h[1], b);
this.h[2] = sum32$1(this.h[2], c);
this.h[3] = sum32$1(this.h[3], d);
this.h[4] = sum32$1(this.h[4], e);
this.h[5] = sum32$1(this.h[5], f2);
this.h[6] = sum32$1(this.h[6], g2);
this.h[7] = sum32$1(this.h[7], h);
};
SHA256$1.prototype._digest = function digest3(enc) {
if (enc === "hex")
return utils$b.toHex32(this.h, "big");
else
return utils$b.split32(this.h, "big");
};
var utils$a = utils$f;
var SHA256 = _256;
function SHA224() {
if (!(this instanceof SHA224))
return new SHA224();
SHA256.call(this);
this.h = [
3238371032,
914150663,
812702999,
4144912697,
4290775857,
1750603025,
1694076839,
3204075428
];
}
utils$a.inherits(SHA224, SHA256);
var _224 = SHA224;
SHA224.blockSize = 512;
SHA224.outSize = 224;
SHA224.hmacStrength = 192;
SHA224.padLength = 64;
SHA224.prototype._digest = function digest4(enc) {
if (enc === "hex")
return utils$a.toHex32(this.h.slice(0, 7), "big");
else
return utils$a.split32(this.h.slice(0, 7), "big");
};
var utils$9 = utils$f;
var common$1 = common$5;
var assert$7 = minimalisticAssert;
var rotr64_hi = utils$9.rotr64_hi;
var rotr64_lo = utils$9.rotr64_lo;
var shr64_hi = utils$9.shr64_hi;
var shr64_lo = utils$9.shr64_lo;
var sum64 = utils$9.sum64;
var sum64_hi = utils$9.sum64_hi;
var sum64_lo = utils$9.sum64_lo;
var sum64_4_hi = utils$9.sum64_4_hi;
var sum64_4_lo = utils$9.sum64_4_lo;
var sum64_5_hi = utils$9.sum64_5_hi;
var sum64_5_lo = utils$9.sum64_5_lo;
var BlockHash$1 = common$1.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$1() {
if (!(this instanceof SHA512$1))
return new SHA512$1();
BlockHash$1.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);
}
utils$9.inherits(SHA512$1, BlockHash$1);
var _512 = SHA512$1;
SHA512$1.blockSize = 1024;
SHA512$1.outSize = 512;
SHA512$1.hmacStrength = 192;
SHA512$1.padLength = 128;
SHA512$1.prototype._prepareBlock = function _prepareBlock(msg, start) {
var W2 = this.W;
for (var i = 0; i < 32; i++)
W2[i] = msg[start + i];
for (; i < W2.length; i += 2) {
var c0_hi = g1_512_hi(W2[i - 4], W2[i - 3]);
var c0_lo = g1_512_lo(W2[i - 4], W2[i - 3]);
var c1_hi = W2[i - 14];
var c1_lo = W2[i - 13];
var c2_hi = g0_512_hi(W2[i - 30], W2[i - 29]);
var c2_lo = g0_512_lo(W2[i - 30], W2[i - 29]);
var c3_hi = W2[i - 32];
var c3_lo = W2[i - 31];
W2[i] = sum64_4_hi(
c0_hi,
c0_lo,
c1_hi,
c1_lo,
c2_hi,
c2_lo,
c3_hi,
c3_lo
);
W2[i + 1] = sum64_4_lo(
c0_hi,
c0_lo,
c1_hi,
c1_lo,
c2_hi,
c2_lo,
c3_hi,
c3_lo
);
}
};
SHA512$1.prototype._update = function _update6(msg, start) {
this._prepareBlock(msg, start);
var W2 = this.W;
var ah = this.h[0];
var al = this.h[1];
var bh = this.h[2];
var bl = this.h[3];
var ch2 = 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 hl2 = this.h[15];
assert$7(this.k.length === W2.length);
for (var i = 0; i < W2.length; i += 2) {
var c0_hi = hh;
var c0_lo = hl2;
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[i];
var c3_lo = this.k[i + 1];
var c4_hi = W2[i];
var c4_lo = W2[i + 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, ch2);
c1_lo = maj64_lo(ah, al, bh, bl, ch2, 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;
hl2 = 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 = ch2;
dl = cl;
ch2 = 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, ch2, 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, hl2);
};
SHA512$1.prototype._digest = function digest5(enc) {
if (enc === "hex")
return utils$9.toHex32(this.h, "big");
else
return utils$9.split32(this.h, "big");
};
function ch64_hi(xh, xl, yh, yl, zh) {
var r2 = xh & yh ^ ~xh & zh;
if (r2 < 0)
r2 += 4294967296;
return r2;
}
function ch64_lo(xh, xl, yh, yl, zh, zl2) {
var r2 = xl & yl ^ ~xl & zl2;
if (r2 < 0)
r2 += 4294967296;
return r2;
}
function maj64_hi(xh, xl, yh, yl, zh) {
var r2 = xh & yh ^ xh & zh ^ yh & zh;
if (r2 < 0)
r2 += 4294967296;
return r2;
}
function maj64_lo(xh, xl, yh, yl, zh, zl2) {
var r2 = xl & yl ^ xl & zl2 ^ yl & zl2;
if (r2 < 0)
r2 += 4294967296;
return r2;
}
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 r2 = c0_hi ^ c1_hi ^ c2_hi;
if (r2 < 0)
r2 += 4294967296;
return r2;
}
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 r2 = c0_lo ^ c1_lo ^ c2_lo;
if (r2 < 0)
r2 += 4294967296;
return r2;
}
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 r2 = c0_hi ^ c1_hi ^ c2_hi;
if (r2 < 0)
r2 += 4294967296;
return r2;
}
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 r2 = c0_lo ^ c1_lo ^ c2_lo;
if (r2 < 0)
r2 += 4294967296;
return r2;
}
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 r2 = c0_hi ^ c1_hi ^ c2_hi;
if (r2 < 0)
r2 += 4294967296;
return r2;
}
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 r2 = c0_lo ^ c1_lo ^ c2_lo;
if (r2 < 0)
r2 += 4294967296;
return r2;
}
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 r2 = c0_hi ^ c1_hi ^ c2_hi;
if (r2 < 0)
r2 += 4294967296;
return r2;
}
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 r2 = c0_lo ^ c1_lo ^ c2_lo;
if (r2 < 0)
r2 += 4294967296;
return r2;
}
var utils$8 = utils$f;
var SHA512 = _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
];
}
utils$8.inherits(SHA384, SHA512);
var _384 = SHA384;
SHA384.blockSize = 1024;
SHA384.outSize = 384;
SHA384.hmacStrength = 192;
SHA384.padLength = 128;
SHA384.prototype._digest = function digest6(enc) {
if (enc === "hex")
return utils$8.toHex32(this.h.slice(0, 12), "big");
else
return utils$8.split32(this.h.slice(0, 12), "big");
};
sha.sha1 = _1;
sha.sha224 = _224;
sha.sha256 = _256;
sha.sha384 = _384;
sha.sha512 = _512;
var ripemd = {};
var utils$7 = utils$f;
var common = common$5;
var rotl32 = utils$7.rotl32;
var sum32 = utils$7.sum32;
var sum32_3 = utils$7.sum32_3;
var sum32_4 = utils$7.sum32_4;
var BlockHash = common.BlockHash;
function RIPEMD160() {
if (!(this instanceof RIPEMD160))
return new RIPEMD160();
BlockHash.call(this);
this.h = [1732584193, 4023233417, 2562383102, 271733878, 3285377520];
this.endian = "little";
}
utils$7.inherits(RIPEMD160, BlockHash);
ripemd.ripemd160 = RIPEMD160;
RIPEMD160.blockSize = 512;
RIPEMD160.outSize = 160;
RIPEMD160.hmacStrength = 192;
RIPEMD160.padLength = 64;
RIPEMD160.prototype._update = function update3(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 Ch2 = 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, Ch2, Dh), msg[rh[j] + start], Kh(j)),
sh[j]
),
Eh
);
Ah = Eh;
Eh = Dh;
Dh = rotl32(Ch2, 10);
Ch2 = 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, Ch2);
this.h[0] = T;
};
RIPEMD160.prototype._digest = function digest7(enc) {
if (enc === "hex")
return utils$7.toHex32(this.h, "little");
else
return utils$7.split32(this.h, "little");
};
function f(j, x, y, z2) {
if (j <= 15)
return x ^ y ^ z2;
else if (j <= 31)
return x & y | ~x & z2;
else if (j <= 47)
return (x | ~y) ^ z2;
else if (j <= 63)
return x & z2 | y & ~z2;
else
return x ^ (y | ~z2);
}
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
];
var utils$6 = utils$f;
var assert$6 = minimalisticAssert;
function Hmac(hash3, key2, enc) {
if (!(this instanceof Hmac))
return new Hmac(hash3, key2, enc);
this.Hash = hash3;
this.blockSize = hash3.blockSize / 8;
this.outSize = hash3.outSize / 8;
this.inner = null;
this.outer = null;
this._init(utils$6.toArray(key2, enc));
}
var hmac = Hmac;
Hmac.prototype._init = function init(key2) {
if (key2.length > this.blockSize)
key2 = new this.Hash().update(key2).digest();
assert$6(key2.length <= this.blockSize);
for (var i = key2.length; i < this.blockSize; i++)
key2.push(0);
for (i = 0; i < key2.length; i++)
key2[i] ^= 54;
this.inner = new this.Hash().update(key2);
for (i = 0; i < key2.length; i++)
key2[i] ^= 106;
this.outer = new this.Hash().update(key2);
};
Hmac.prototype.update = function update4(msg, enc) {
this.inner.update(msg, enc);
return this;
};
Hmac.prototype.digest = function digest8(enc) {
this.outer.update(this.inner.digest());
return this.outer.digest(enc);
};
(function(exports2) {
var hash3 = exports2;
hash3.utils = utils$f;
hash3.common = common$5;
hash3.sha = sha;
hash3.ripemd = ripemd;
hash3.hmac = hmac;
hash3.sha1 = hash3.sha.sha1;
hash3.sha256 = hash3.sha.sha256;
hash3.sha224 = hash3.sha.sha224;
hash3.sha384 = hash3.sha.sha384;
hash3.sha512 = hash3.sha.sha512;
hash3.ripemd160 = hash3.ripemd.ripemd160;
})(hash$2);
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;
}
(function(exports2) {
var curves2 = exports2;
var hash3 = hash$2;
var curve$1 = curve;
var utils2 = utils$l;
var assert2 = utils2.assert;
function PresetCurve(options2) {
if (options2.type === "short")
this.curve = new curve$1.short(options2);
else if (options2.type === "edwards")
this.curve = new curve$1.edwards(options2);
else
this.curve = new curve$1.mont(options2);
this.g = this.curve.g;
this.n = this.curve.n;
this.hash = options2.hash;
assert2(this.g.validate(), "Invalid curve");
assert2(this.g.mul(this.n).isInfinity(), "Invalid curve, G*N != O");
}
curves2.PresetCurve = PresetCurve;
function defineCurve(name2, options2) {
Object.defineProperty(curves2, name2, {
configurable: true,
enumerable: true,
get: function() {
var curve2 = new PresetCurve(options2);
Object.defineProperty(curves2, name2, {
configurable: true,
enumerable: true,
value: curve2
});
return curve2;
}
});
}
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: hash3.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: hash3.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: hash3.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: hash3.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: hash3.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: hash3.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: hash3.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: hash3.sha256,
// Precomputed endomorphism
beta: "7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee",
lambda: "5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72",
basis: [
{
a: "3086d221a7d46bcde86c90e49284eb15",
b: "-e4437ed6010e88286f547fa90abfe4c3"
},
{
a: "114ca50f7a8e2f3f657c1108d9d44cfd8",
b: "3086d221a7d46bcde86c90e49284eb15"
}
],
gRed: false,
g: [
"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
"483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8",
pre
]
});
})(curves$1);
var hash$1 = hash$2;
var utils$5 = utils$k;
var assert$5 = minimalisticAssert;
function HmacDRBG(options2) {
if (!(this instanceof HmacDRBG))
return new HmacDRBG(options2);
this.hash = options2.hash;
this.predResist = !!options2.predResist;
this.outLen = this.hash.outSize;
this.minEntropy = options2.minEntropy || this.hash.hmacStrength;
this._reseed = null;
this.reseedInterval = null;
this.K = null;
this.V = null;
var entropy = utils$5.toArray(options2.entropy, options2.entropyEnc || "hex");
var nonce = utils$5.toArray(options2.nonce, options2.nonceEnc || "hex");
var pers = utils$5.toArray(options2.pers, options2.persEnc || "hex");
assert$5(
entropy.length >= this.minEntropy / 8,
"Not enough entropy. Minimum is: " + this.minEntropy + " bits"
);
this._init(entropy, nonce, pers);
}
var hmacDrbg = HmacDRBG;
HmacDRBG.prototype._init = function init2(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 i = 0; i < this.V.length; i++) {
this.K[i] = 0;
this.V[i] = 1;
}
this._update(seed);
this._reseed = 1;
this.reseedInterval = 281474976710656;
};
HmacDRBG.prototype._hmac = function hmac2() {
return new hash$1.hmac(this.hash, this.K);
};
HmacDRBG.prototype._update = function update5(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, add5, addEnc) {
if (typeof entropyEnc !== "string") {
addEnc = add5;
add5 = entropyEnc;
entropyEnc = null;
}
entropy = utils$5.toArray(entropy, entropyEnc);
add5 = utils$5.toArray(add5, addEnc);
assert$5(
entropy.length >= this.minEntropy / 8,
"Not enough entropy. Minimum is: " + this.minEntropy + " bits"
);
this._update(entropy.concat(add5 || []));
this._reseed = 1;
};
HmacDRBG.prototype.generate = function generate(len, enc, add5, addEnc) {
if (this._reseed > this.reseedInterval)
throw new Error("Reseed is required");
if (typeof enc !== "string") {
addEnc = add5;
add5 = enc;
enc = null;
}
if (add5) {
add5 = utils$5.toArray(add5, addEnc || "hex");
this._update(add5);
}
var temp = [];
while (temp.length < len) {
this.V = this._hmac().update(this.V).digest();
temp = temp.concat(this.V);
}
var res = temp.slice(0, len);
this._update(add5);
this._reseed++;
return utils$5.encode(res, enc);
};
var BN$5 = bnExports$1;
var utils$4 = utils$l;
var assert$4 = utils$4.assert;
function KeyPair$2(ec2, options2) {
this.ec = ec2;
this.priv = null;
this.pub = null;
if (options2.priv)
this._importPrivate(options2.priv, options2.privEnc);
if (options2.pub)
this._importPublic(options2.pub, options2.pubEnc);
}
var key$1 = KeyPair$2;
KeyPair$2.fromPublic = function fromPublic(ec2, pub2, enc) {
if (pub2 instanceof KeyPair$2)
return pub2;
return new KeyPair$2(ec2, {
pub: pub2,
pubEnc: enc
});
};
KeyPair$2.fromPrivate = function fromPrivate(ec2, priv2, enc) {
if (priv2 instanceof KeyPair$2)
return priv2;
return new KeyPair$2(ec2, {
priv: priv2,
privEnc: enc
});
};
KeyPair$2.prototype.validate = function validate6() {
var pub2 = this.getPublic();
if (pub2.isInfinity())
return { result: false, reason: "Invalid public key" };
if (!pub2.validate())
return { result: false, reason: "Public key is not a point" };
if (!pub2.mul(this.ec.curve.n).isInfinity())
return { result: false, reason: "Public key * N != O" };
return { result: true, reason: null };
};
KeyPair$2.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$2.prototype.getPrivate = function getPrivate(enc) {
if (enc === "hex")
return this.priv.toString(16, 2);
else
return this.priv;
};
KeyPair$2.prototype._importPrivate = function _importPrivate(key2, enc) {
this.priv = new BN$5(key2, enc || 16);
this.priv = this.priv.umod(this.ec.curve.n);
};
KeyPair$2.prototype._importPublic = function _importPublic(key2, enc) {
if (key2.x || key2.y) {
if (this.ec.curve.type === "mont") {
assert$4(key2.x, "Need x coordinate");
} else if (this.ec.curve.type === "short" || this.ec.curve.type === "edwards") {
assert$4(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$2.prototype.derive = function derive(pub2) {
if (!pub2.validate()) {
assert$4(pub2.validate(), "public point not validated");
}
return pub2.mul(this.priv).getX();
};
KeyPair$2.prototype.sign = function sign2(msg, enc, options2) {
return this.ec.sign(msg, this, enc, options2);
};
KeyPair$2.prototype.verify = function verify(msg, signature2) {
return this.ec.verify(msg, signature2, this);
};
KeyPair$2.prototype.inspect = function inspect5() {
return "<Key priv: " + (this.priv && this.priv.toString(16, 2)) + " pub: " + (this.pub && this.pub.inspect()) + " >";
};
var BN$4 = bnExports$1;
var utils$3 = utils$l;
var assert$3 = utils$3.assert;
function Signature$2(options2, enc) {
if (options2 instanceof Signature$2)
return options2;
if (this._importDER(options2, enc))
return;
assert$3(options2.r && options2.s, "Signature without r or s");
this.r = new BN$4(options2.r, 16);
this.s = new BN$4(options2.s, 16);
if (options2.recoveryParam === void 0)
this.recoveryParam = null;
else
this.recoveryParam = options2.recoveryParam;
}
var signature$1 = Signature$2;
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 i = 0, off = p.place; i < octetLen; i++, off++) {
val <<= 8;
val |= buf[off];
val >>>= 0;
}
if (val <= 127) {
return false;
}
p.place = off;
return val;
}
function rmPadding(buf) {
var i = 0;
var len = buf.length - 1;
while (!buf[i] && !(buf[i + 1] & 128) && i < len) {
i++;
}
if (i === 0) {
return buf;
}
return buf.slice(i);
}
Signature$2.prototype._importDER = function _importDER(data, enc) {
data = utils$3.toArray(data, enc);
var p = new Position();
if (data[p.place++] !== 48) {
return false;
}
var len = getLength(data, p);
if (len === false) {
return false;
}
if (len + 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 r2 = 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 s2 = data.slice(p.place, slen + p.place);
if (r2[0] === 0) {
if (r2[1] & 128) {
r2 = r2.slice(1);
} else {
return false;
}
}
if (s2[0] === 0) {
if (s2[1] & 128) {
s2 = s2.slice(1);
} else {
return false;
}
}
this.r = new BN$4(r2);
this.s = new BN$4(s2);
this.recoveryParam = null;
return true;
};
function constructLength(arr, len) {
if (len < 128) {
arr.push(len);
return;
}
var octets = 1 + (Math.log(len) / Math.LN2 >>> 3);
arr.push(octets | 128);
while (--octets) {
arr.push(len >>> (octets << 3) & 255);
}
arr.push(len);
}
Signature$2.prototype.toDER = function toDER(enc) {
var r2 = this.r.toArray();
var s2 = this.s.toArray();
if (r2[0] & 128)
r2 = [0].concat(r2);
if (s2[0] & 128)
s2 = [0].concat(s2);
r2 = rmPadding(r2);
s2 = rmPadding(s2);
while (!s2[0] && !(s2[1] & 128)) {
s2 = s2.slice(1);
}
var arr = [2];
constructLength(arr, r2.length);
arr = arr.concat(r2);
arr.push(2);
constructLength(arr, s2.length);
var backHalf = arr.concat(s2);
var res = [48];
constructLength(res, backHalf.length);
res = res.concat(backHalf);
return utils$3.encode(res, enc);
};
var ec;
var hasRequiredEc;
function requireEc() {
if (hasRequiredEc) return ec;
hasRequiredEc = 1;
var BN2 = bnExports$1;
var HmacDRBG2 = hmacDrbg;
var utils2 = utils$l;
var curves2 = curves$1;
var rand = requireBrorand();
var assert2 = utils2.assert;
var KeyPair2 = key$1;
var Signature2 = signature$1;
function EC(options2) {
if (!(this instanceof EC))
return new EC(options2);
if (typeof options2 === "string") {
assert2(
Object.prototype.hasOwnProperty.call(curves2, options2),
"Unknown curve " + options2
);
options2 = curves2[options2];
}
if (options2 instanceof curves2.PresetCurve)
options2 = { curve: options2 };
this.curve = options2.curve.curve;
this.n = this.curve.n;
this.nh = this.n.ushrn(1);
this.g = this.curve.g;
this.g = options2.curve.g;
this.g.precompute(options2.curve.n.bitLength() + 1);
this.hash = options2.hash || options2.curve.hash;
}
ec = EC;
EC.prototype.keyPair = function keyPair(options2) {
return new KeyPair2(this, options2);
};
EC.prototype.keyFromPrivate = function keyFromPrivate(priv2, enc) {
return KeyPair2.fromPrivate(this, priv2, enc);
};
EC.prototype.keyFromPublic = function keyFromPublic2(pub2, enc) {
return KeyPair2.fromPublic(this, pub2, enc);
};
EC.prototype.genKeyPair = function genKeyPair(options2) {
if (!options2)
options2 = {};
var drbg = new HmacDRBG2({
hash: this.hash,
pers: options2.pers,
persEnc: options2.persEnc || "utf8",
entropy: options2.entropy || rand(this.hash.hmacStrength),
entropyEnc: options2.entropy && options2.entropyEnc || "utf8",
nonce: this.n.toArray()
});
var bytes = this.n.byteLength();
var ns2 = this.n.sub(new BN2(2));
for (; ; ) {
var priv2 = new BN2(drbg.generate(bytes));
if (priv2.cmp(ns2) > 0)
continue;
priv2.iaddn(1);
return this.keyFromPrivate(priv2);
}
};
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 sign5(msg, key2, enc, options2) {
if (typeof enc === "object") {
options2 = enc;
enc = null;
}
if (!options2)
options2 = {};
key2 = this.keyFromPrivate(key2, enc);
msg = this._truncateToN(new BN2(msg, 16));
var bytes = this.n.byteLength();
var bkey = key2.getPrivate().toArray("be", bytes);
var nonce = msg.toArray("be", bytes);
var drbg = new HmacDRBG2({
hash: this.hash,
entropy: bkey,
nonce,
pers: options2.pers,
persEnc: options2.persEnc || "utf8"
});
var ns1 = this.n.sub(new BN2(1));
for (var iter = 0; ; iter++) {
var k = options2.k ? options2.k(iter) : new BN2(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 r2 = kpX.umod(this.n);
if (r2.cmpn(0) === 0)
continue;
var s2 = k.invm(this.n).mul(r2.mul(key2.getPrivate()).iadd(msg));
s2 = s2.umod(this.n);
if (s2.cmpn(0) === 0)
continue;
var recoveryParam = (kp.getY().isOdd() ? 1 : 0) | (kpX.cmp(r2) !== 0 ? 2 : 0);
if (options2.canonical && s2.cmp(this.nh) > 0) {
s2 = this.n.sub(s2);
recoveryParam ^= 1;
}
return new Signature2({ r: r2, s: s2, recoveryParam });
}
};
EC.prototype.verify = function verify4(msg, signature2, key2, enc) {
msg = this._truncateToN(new BN2(msg, 16));
key2 = this.keyFromPublic(key2, enc);
signature2 = new Signature2(signature2, "hex");
var r2 = signature2.r;
var s2 = signature2.s;
if (r2.cmpn(1) < 0 || r2.cmp(this.n) >= 0)
return false;
if (s2.cmpn(1) < 0 || s2.cmp(this.n) >= 0)
return false;
var sinv = s2.invm(this.n);
var u1 = sinv.mul(msg).umod(this.n);
var u2 = sinv.mul(r2).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(r2) === 0;
}
p = this.g.jmulAdd(u1, key2.getPublic(), u2);
if (p.isInfinity())
return false;
return p.eqXToP(r2);
};
EC.prototype.recoverPubKey = function(msg, signature2, j, enc) {
assert2((3 & j) === j, "The recovery param is more than two bits");
signature2 = new Signature2(signature2, enc);
var n = this.n;
var e = new BN2(msg);
var r2 = signature2.r;
var s2 = signature2.s;
var isYOdd = j & 1;
var isSecondKey = j >> 1;
if (r2.cmp(this.curve.p.umod(this.curve.n)) >= 0 && isSecondKey)
throw new Error("Unable to find sencond key candinate");
if (isSecondKey)
r2 = this.curve.pointFromX(r2.add(this.curve.n), isYOdd);
else
r2 = this.curve.pointFromX(r2, isYOdd);
var rInv = signature2.r.invm(n);
var s1 = n.sub(e).mul(rInv).umod(n);
var s22 = s2.mul(rInv).umod(n);
return this.g.mulAdd(s1, r2, s22);
};
EC.prototype.getKeyRecoveryParam = function(e, signature2, Q, enc) {
signature2 = new Signature2(signature2, enc);
if (signature2.recoveryParam !== null)
return signature2.recoveryParam;
for (var i = 0; i < 4; i++) {
var Qprime;
try {
Qprime = this.recoverPubKey(e, signature2, i);
} catch (e2) {
continue;
}
if (Qprime.eq(Q))
return i;
}
throw new Error("Unable to find valid recovery factor");
};
return ec;
}
var utils$2 = utils$l;
var assert$2 = utils$2.assert;
var parseBytes$2 = utils$2.parseBytes;
var cachedProperty$1 = utils$2.cachedProperty;
function KeyPair$1(eddsa2, params) {
this.eddsa = eddsa2;
this._secret = parseBytes$2(params.secret);
if (eddsa2.isPoint(params.pub))
this._pub = params.pub;
else
this._pubBytes = parseBytes$2(params.pub);
}
KeyPair$1.fromPublic = function fromPublic2(eddsa2, pub2) {
if (pub2 instanceof KeyPair$1)
return pub2;
return new KeyPair$1(eddsa2, { pub: pub2 });
};
KeyPair$1.fromSecret = function fromSecret(eddsa2, secret2) {
if (secret2 instanceof KeyPair$1)
return secret2;
return new KeyPair$1(eddsa2, { secret: secret2 });
};
KeyPair$1.prototype.secret = function secret() {
return this._secret;
};
cachedProperty$1(KeyPair$1, "pubBytes", function pubBytes() {
return this.eddsa.encodePoint(this.pub());
});
cachedProperty$1(KeyPair$1, "pub", function pub() {
if (this._pubBytes)
return this.eddsa.decodePoint(this._pubBytes);
return this.eddsa.g.mul(this.priv());
});
cachedProperty$1(KeyPair$1, "privBytes", function privBytes() {
var eddsa2 = this.eddsa;
var hash3 = this.hash();
var lastIx = eddsa2.encodingLength - 1;
var a = hash3.slice(0, eddsa2.encodingLength);
a[0] &= 248;
a[lastIx] &= 127;
a[lastIx] |= 64;
return a;
});
cachedProperty$1(KeyPair$1, "priv", function priv() {
return this.eddsa.decodeInt(this.privBytes());
});
cachedProperty$1(KeyPair$1, "hash", function hash2() {
return this.eddsa.hash().update(this.secret()).digest();
});
cachedProperty$1(KeyPair$1, "messagePrefix", function messagePrefix() {
return this.hash().slice(this.eddsa.encodingLength);
});
KeyPair$1.prototype.sign = function sign3(message) {
assert$2(this._secret, "KeyPair can only verify");
return this.eddsa.sign(message, this);
};
KeyPair$1.prototype.verify = function verify2(message, sig) {
return this.eddsa.verify(message, sig, this);
};
KeyPair$1.prototype.getSecret = function getSecret(enc) {
assert$2(this._secret, "KeyPair is public only");
return utils$2.encode(this.secret(), enc);
};
KeyPair$1.prototype.getPublic = function getPublic2(enc) {
return utils$2.encode(this.pubBytes(), enc);
};
var key = KeyPair$1;
var BN$3 = bnExports$1;
var utils$1 = utils$l;
var assert$1 = utils$1.assert;
var cachedProperty = utils$1.cachedProperty;
var parseBytes$1 = utils$1.parseBytes;
function Signature$1(eddsa2, sig) {
this.eddsa = eddsa2;
if (typeof sig !== "object")
sig = parseBytes$1(sig);
if (Array.isArray(sig)) {
assert$1(sig.length === eddsa2.encodingLength * 2, "Signature has invalid size");
sig = {
R: sig.slice(0, eddsa2.encodingLength),
S: sig.slice(eddsa2.encodingLength)
};
}
assert$1(sig.R && sig.S, "Signature without R or S");
if (eddsa2.isPoint(sig.R))
this._R = sig.R;
if (sig.S instanceof BN$3)
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$1, "S", function S() {
return this.eddsa.decodeInt(this.Sencoded());
});
cachedProperty(Signature$1, "R", function R2() {
return this.eddsa.decodePoint(this.Rencoded());
});
cachedProperty(Signature$1, "Rencoded", function Rencoded() {
return this.eddsa.encodePoint(this.R());
});
cachedProperty(Signature$1, "Sencoded", function Sencoded() {
return this.eddsa.encodeInt(this.S());
});
Signature$1.prototype.toBytes = function toBytes() {
return this.Rencoded().concat(this.Sencoded());
};
Signature$1.prototype.toHex = function toHex2() {
return utils$1.encode(this.toBytes(), "hex").toUpperCase();
};
var signature = Signature$1;
var hash = hash$2;
var curves = curves$1;
var utils = utils$l;
var assert = utils.assert;
var parseBytes = utils.parseBytes;
var KeyPair = key;
var Signature = signature;
function EDDSA(curve2) {
assert(curve2 === "ed25519", "only tested with ed25519 so far");
if (!(this instanceof EDDSA))
return new EDDSA(curve2);
curve2 = curves[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 = hash.sha512;
}
var eddsa = EDDSA;
EDDSA.prototype.sign = function sign4(message, secret2) {
message = parseBytes(message);
var key2 = this.keyFromSecret(secret2);
var r2 = this.hashInt(key2.messagePrefix(), message);
var R3 = this.g.mul(r2);
var Rencoded2 = this.encodePoint(R3);
var s_ = this.hashInt(Rencoded2, key2.pubBytes(), message).mul(key2.priv());
var S2 = r2.add(s_).umod(this.curve.n);
return this.makeSignature({ R: R3, S: S2, Rencoded: Rencoded2 });
};
EDDSA.prototype.verify = function verify3(message, sig, pub2) {
message = parseBytes(message);
sig = this.makeSignature(sig);
if (sig.S().gte(sig.eddsa.curve.n) || sig.S().isNeg()) {
return false;
}
var key2 = this.keyFromPublic(pub2);
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 i = 0; i < arguments.length; i++)
hash3.update(arguments[i]);
return utils.intFromLE(hash3.digest()).umod(this.curve.n);
};
EDDSA.prototype.keyFromPublic = function keyFromPublic(pub2) {
return KeyPair.fromPublic(this, pub2);
};
EDDSA.prototype.keyFromSecret = function keyFromSecret(secret2) {
return KeyPair.fromSecret(this, secret2);
};
EDDSA.prototype.makeSignature = function makeSignature(sig) {
if (sig instanceof Signature)
return sig;
return new Signature(this, sig);
};
EDDSA.prototype.encodePoint = function encodePoint(point5) {
var enc = point5.getY().toArray("le", this.encodingLength);
enc[this.encodingLength - 1] |= point5.getX().isOdd() ? 128 : 0;
return enc;
};
EDDSA.prototype.decodePoint = function decodePoint3(bytes) {
bytes = utils.parseBytes(bytes);
var lastIx = bytes.length - 1;
var normed = bytes.slice(0, lastIx).concat(bytes[lastIx] & ~128);
var xIsOdd = (bytes[lastIx] & 128) !== 0;
var y = utils.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 utils.intFromLE(bytes);
};
EDDSA.prototype.isPoint = function isPoint(val) {
return val instanceof this.pointClass;
};
var hasRequiredElliptic;
function requireElliptic() {
if (hasRequiredElliptic) return elliptic;
hasRequiredElliptic = 1;
(function(exports2) {
var elliptic2 = exports2;
elliptic2.version = require$$0.version;
elliptic2.utils = utils$l;
elliptic2.rand = requireBrorand();
elliptic2.curve = curve;
elliptic2.curves = curves$1;
elliptic2.ec = requireEc();
elliptic2.eddsa = eddsa;
})(elliptic);
return elliptic;
}
var asn1$3 = {};
var asn1$2 = {};
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 i = 0; i < xs.length; i++) {
if (xs[i] === item) return i;
}
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 i = 0; i < xs.length; i++) {
fn(xs[i], i, xs);
}
};
var defineProp = function() {
try {
Object.defineProperty({}, "_", {});
return function(obj, name2, value) {
Object.defineProperty(obj, name2, {
writable: true,
enumerable: false,
configurable: true,
value
});
};
} catch (e) {
return function(obj, name2, value) {
obj[name2] = 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(code) {
if (!(this instanceof Script)) return new Script(code);
this.code = code;
};
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(name2) {
exports[name2] = Script[name2] = function(code) {
var s2 = Script(code);
return s2[name2].apply(s2, [].slice.call(arguments, 1));
};
});
exports.isContext = function(context) {
return context instanceof Context;
};
exports.createScript = function(code) {
return exports.Script(code);
};
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();
var inherits2 = inherits_browserExports;
var api2 = exports2;
api2.define = function define2(name2, body) {
return new Entity(name2, body);
};
function Entity(name2, body) {
this.name = name2;
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);
};
}
inherits2(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, options2) {
return this._getDecoder(enc).decode(data, options2);
};
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 encode2(data, enc, reporter2) {
return this._getEncoder(enc).encode(data, reporter2);
};
})(api);
return api;
}
var base = {};
var reporter = {};
var inherits = inherits_browserExports;
function Reporter(options2) {
this._reporterState = {
obj: null,
path: [],
options: options2 || {},
errors: []
};
}
reporter.Reporter = Reporter;
Reporter.prototype.isError = function isError2(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 path2() {
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(path3, msg) {
this.path = path3;
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;
};
var buffer = {};
var hasRequiredBuffer;
function requireBuffer() {
if (hasRequiredBuffer) return buffer;
hasRequiredBuffer = 1;
var inherits2 = inherits_browserExports;
var Reporter2 = requireBase().Reporter;
var Buffer2 = dist.Buffer;
function DecoderBuffer(base2, options2) {
Reporter2.call(this, options2);
if (!Buffer2.isBuffer(base2)) {
this.error("Input not Buffer");
return;
}
this.base = base2;
this.offset = 0;
this.length = base2.length;
}
inherits2(DecoderBuffer, Reporter2);
buffer.DecoderBuffer = DecoderBuffer;
DecoderBuffer.prototype.save = function save2() {
return { offset: this.offset, reporter: Reporter2.prototype.save.call(this) };
};
DecoderBuffer.prototype.restore = function restore2(save2) {
var res = new DecoderBuffer(this.base);
res.offset = save2.offset;
res.length = this.offset;
this.offset = save2.offset;
Reporter2.prototype.restore.call(this, save2.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(save2) {
return this.base.slice(save2 ? save2.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 Reporter2 = requireBase().Reporter;
var EncoderBuffer = requireBase().EncoderBuffer;
var DecoderBuffer = requireBase().DecoderBuffer;
var assert2 = minimalisticAssert;
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 wrap() {
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 init3(body) {
var state2 = this._baseState;
assert2(state2.parent === null);
body.call(this);
state2.children = state2.children.filter(function(child) {
return child._baseState.parent === this;
}, this);
assert2.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) {
assert2(state2.children === null);
state2.children = children;
children.forEach(function(child) {
child._baseState.parent = this;
}, this);
}
if (args.length !== 0) {
assert2(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);
assert2(state2.tag === null);
state2.tag = tag;
this._useArgs(args);
return this;
};
});
Node.prototype.use = function use(item) {
assert2(item);
var state2 = this._baseState;
assert2(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;
assert2(state2["default"] === null);
state2["default"] = val;
state2.optional = true;
return this;
};
Node.prototype.explicit = function explicit(num) {
var state2 = this._baseState;
assert2(state2.explicit === null && state2.implicit === null);
state2.explicit = num;
return this;
};
Node.prototype.implicit = function implicit(num) {
var state2 = this._baseState;
assert2(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;
assert2(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;
assert2(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;
assert2(state2.use === null);
state2.contains = item;
return this;
};
Node.prototype._decode = function decode(input, options2) {
var state2 = this._baseState;
if (state2.parent === null)
return input.wrapResult(state2.children[0]._decode(input, options2));
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 save2 = input.save();
try {
if (state2.choice === null)
this._decodeGeneric(state2.tag, input, options2);
else
this._decodeChoice(input, options2);
present = true;
} catch (e) {
present = false;
}
input.restore(save2);
} 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 save2 = 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(save2);
else
input = body;
}
if (options2 && options2.track && state2.tag !== null)
options2.track(input.path(), start, input.length, "tagged");
if (options2 && options2.track && state2.tag !== null)
options2.track(input.path(), input.offset, input.length, "content");
if (state2.any)
result = result;
else if (state2.choice === null)
result = this._decodeGeneric(state2.tag, input, options2);
else
result = this._decodeChoice(input, options2);
if (input.isError(result))
return result;
if (!state2.any && state2.choice === null && state2.children !== null) {
state2.children.forEach(function decodeChildren(child) {
child._decode(input, options2);
});
}
if (state2.contains && (state2.tag === "octstr" || state2.tag === "bitstr")) {
var data = new DecoderBuffer(result);
result = this._getUse(state2.contains, input._reporterState.obj)._decode(data, options2);
}
}
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, options2) {
var state2 = this._baseState;
if (tag === "seq" || tag === "set")
return null;
if (tag === "seqof" || tag === "setof")
return this._decodeList(input, tag, state2.args[0], options2);
else if (/str$/.test(tag))
return this._decodeStr(input, tag, options2);
else if (tag === "objid" && state2.args)
return this._decodeObjid(input, state2.args[0], state2.args[1], options2);
else if (tag === "objid")
return this._decodeObjid(input, null, null, options2);
else if (tag === "gentime" || tag === "utctime")
return this._decodeTime(input, tag, options2);
else if (tag === "null_")
return this._decodeNull(input, options2);
else if (tag === "bool")
return this._decodeBool(input, options2);
else if (tag === "objDesc")
return this._decodeStr(input, tag, options2);
else if (tag === "int" || tag === "enum")
return this._decodeInt(input, state2.args && state2.args[0], options2);
if (state2.use !== null) {
return this._getUse(state2.use, input._reporterState.obj)._decode(input, options2);
} else {
return input.error("unknown tag: " + tag);
}
};
Node.prototype._getUse = function _getUse(entity, obj) {
var state2 = this._baseState;
state2.useDecoder = this._use(entity, obj);
assert2(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, options2) {
var state2 = this._baseState;
var result = null;
var match = false;
Object.keys(state2.choice).some(function(key2) {
var save2 = input.save();
var node2 = state2.choice[key2];
try {
var value = node2._decode(input, options2);
if (input.isError(value))
return false;
result = { type: key2, value };
match = true;
} catch (e) {
input.restore(save2);
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 encode2(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 encode2(data, reporter2, parent) {
var state2 = this._baseState;
if (state2.parent === null)
return state2.children[0]._encode(data, reporter2 || new Reporter2());
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) {
assert2(
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 = reporter.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 inherits2 = inherits_browserExports;
var asn12 = requireAsn1();
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, options2) {
if (!(data instanceof base2.DecoderBuffer))
data = new base2.DecoderBuffer(data, options2);
return this.tree._decode(data, options2);
};
function DERNode(parent) {
base2.Node.call(this, "der", parent);
}
inherits2(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 len = derDecodeLen(
buffer2,
decodedTag.primitive,
'Failed to get length of "' + tag + '"'
);
if (buffer2.isError(len))
return len;
if (!any && decodedTag.tag !== tag && decodedTag.tagStr !== tag && decodedTag.tagStr + "of" !== tag) {
return buffer2.error('Failed to match tag: "' + tag + '"');
}
if (decodedTag.primitive || len !== null)
return buffer2.skip(len, '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;
len = buffer2.offset - state2.offset;
buffer2.restore(state2);
return buffer2.skip(len, '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 len = derDecodeLen(buffer2, tag.primitive, fail);
if (buffer2.isError(len))
return len;
var res;
if (tag.primitive || len !== null)
res = buffer2.skip(len);
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, options2) {
var result = [];
while (!buffer2.isEmpty()) {
var possibleEnd = this._peekTag(buffer2, "end");
if (buffer2.isError(possibleEnd))
return possibleEnd;
var res = decoder.decode(buffer2, "der", options2);
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 i = 0; i < raw.length / 2; i++) {
str += String.fromCharCode(raw.readUInt16BE(i * 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, relative2) {
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 (relative2)
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 decodeInt2(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 len = buf.readUInt8(fail);
if (buf.isError(len))
return len;
if (!primitive && len === 128)
return null;
if ((len & 128) === 0) {
return len;
}
var num = len & 127;
if (num > 4)
return buf.error("length octect is too long");
len = 0;
for (var i = 0; i < num; i++) {
len <<= 8;
var j = buf.readUInt8(fail);
if (buf.isError(j))
return j;
len |= j;
}
return len;
}
return der_1$1;
}
var pem$1;
var hasRequiredPem$1;
function requirePem$1() {
if (hasRequiredPem$1) return pem$1;
hasRequiredPem$1 = 1;
var inherits2 = inherits_browserExports;
var Buffer2 = dist.Buffer;
var DERDecoder = requireDer$1();
function PEMDecoder(entity) {
DERDecoder.call(this, entity);
this.enc = "pem";
}
inherits2(PEMDecoder, DERDecoder);
pem$1 = PEMDecoder;
PEMDecoder.prototype.decode = function decode(data, options2) {
var lines = data.toString().split(/[\r\n]+/g);
var label = options2.label.toUpperCase();
var re2 = /^-----(BEGIN|END) ([^-]+)-----$/;
var start = -1;
var end = -1;
for (var i = 0; i < lines.length; i++) {
var match = lines[i].match(re2);
if (match === null)
continue;
if (match[2] !== label)
continue;
if (start === -1) {
if (match[1] !== "BEGIN")
break;
start = i;
} else {
if (match[1] !== "END")
break;
end = i;
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, options2);
};
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 inherits2 = inherits_browserExports;
var Buffer2 = dist.Buffer;
var asn12 = requireAsn1();
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 encode2(data, reporter2) {
return this.tree._encode(data, reporter2).join();
};
function DERNode(parent) {
base2.Node.call(this, "der", parent);
}
inherits2(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 i = content.length; i >= 256; i >>= 8)
lenOctets++;
var header = new Buffer2(1 + 1 + lenOctets);
header[0] = encodedTag;
header[1] = 128 | lenOctets;
for (var i = 1 + lenOctets, j = content.length; j > 0; i--, j >>= 8)
header[i] = 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 i = 0; i < str.length; i++) {
buf.writeUInt16BE(str.charCodeAt(i), i * 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, relative2) {
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 i = 0; i < id.length; i++)
id[i] |= 0;
} else if (Array.isArray(id)) {
id = id.slice();
for (var i = 0; i < id.length; i++)
id[i] |= 0;
}
if (!Array.isArray(id)) {
return this.reporter.error("objid() should be either array or string, got: " + JSON.stringify(id));
}
if (!relative2) {
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 i = 0; i < id.length; i++) {
var ident = id[i];
for (size++; ident >= 128; ident >>= 7)
size++;
}
var objid = new Buffer2(size);
var offset = objid.length - 1;
for (var i = id.length - 1; i >= 0; i--) {
var ident = id[i];
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 encodeInt2(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 i = num; i >= 256; i >>= 8)
size++;
var out = new Array(size);
for (var i = out.length - 1; i >= 0; i--) {
out[i] = 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 i;
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 (i = 0; i < data.length; i++)
if (data[i] !== state2.defaultBuffer[i])
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 inherits2 = inherits_browserExports;
var DEREncoder = requireDer();
function PEMEncoder(entity) {
DEREncoder.call(this, entity);
this.enc = "pem";
}
inherits2(PEMEncoder, DEREncoder);
pem = PEMEncoder;
PEMEncoder.prototype.encode = function encode2(data, options2) {
var buf = DEREncoder.prototype.encode.call(this, data);
var p = buf.toString("base64");
var out = ["-----BEGIN " + options2.label + "-----"];
for (var i = 0; i < p.length; i += 64)
out.push(p.slice(i, i + 64));
out.push("-----END " + options2.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;
function requireAsn1() {
if (hasRequiredAsn1) return asn1$2;
hasRequiredAsn1 = 1;
(function(exports2) {
var asn12 = exports2;
asn12.bignum = bnExports$1;
asn12.define = requireApi().define;
asn12.base = requireBase();
asn12.constants = requireConstants();
asn12.decoders = requireDecoders();
asn12.encoders = requireEncoders();
})(asn1$2);
return asn1$2;
}
var asn = requireAsn1();
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$1 = 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$1),
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$1),
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$1),
this.key("signatureValue").bitstr()
);
});
var certificate = X509Certificate;
var asn1$1 = requireAsn1();
asn1$3.certificate = certificate;
var RSAPrivateKey = asn1$1.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$3.RSAPrivateKey = RSAPrivateKey;
var RSAPublicKey = asn1$1.define("RSAPublicKey", function() {
this.seq().obj(
this.key("modulus")["int"](),
this.key("publicExponent")["int"]()
);
});
asn1$3.RSAPublicKey = RSAPublicKey;
var AlgorithmIdentifier = asn1$1.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 = asn1$1.define("SubjectPublicKeyInfo", function() {
this.seq().obj(
this.key("algorithm").use(AlgorithmIdentifier),
this.key("subjectPublicKey").bitstr()
);
});
asn1$3.PublicKey = PublicKey;
var PrivateKeyInfo = asn1$1.define("PrivateKeyInfo", function() {
this.seq().obj(
this.key("version")["int"](),
this.key("algorithm").use(AlgorithmIdentifier),
this.key("subjectPrivateKey").octstr()
);
});
asn1$3.PrivateKey = PrivateKeyInfo;
var EncryptedPrivateKeyInfo = asn1$1.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$3.EncryptedPrivateKey = EncryptedPrivateKeyInfo;
var DSAPrivateKey = asn1$1.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$3.DSAPrivateKey = DSAPrivateKey;
asn1$3.DSAparam = asn1$1.define("DSAparam", function() {
this["int"]();
});
var ECParameters = asn1$1.define("ECParameters", function() {
this.choice({
namedCurve: this.objid()
});
});
var ECPrivateKey = asn1$1.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$3.ECPrivateKey = ECPrivateKey;
asn1$3.signature = asn1$1.define("signature", function() {
this.seq().obj(
this.key("r")["int"](),
this.key("s")["int"]()
);
});
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 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 = evp_bytestokey;
var ciphers$1 = browser$6;
var Buffer$8 = safeBufferExports$1.Buffer;
var fixProc$1 = function(okey, password) {
var key2 = okey.toString();
var match = key2.match(findProc);
var decrypted;
if (!match) {
var match2 = key2.match(fullRegex);
decrypted = Buffer$8.from(match2[2].replace(/[\r\n]/g, ""), "base64");
} else {
var suite = "aes" + match[1];
var iv = Buffer$8.from(match[2], "hex");
var cipherText = Buffer$8.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$1.createDecipheriv(suite, cipherKey, iv);
out.push(cipher2.update(cipherText));
out.push(cipher2["final"]());
decrypted = Buffer$8.concat(out);
}
var tag = key2.match(startRegex)[1];
return {
tag,
data: decrypted
};
};
var asn1 = asn1$3;
var aesid = require$$1;
var fixProc = fixProc$1;
var ciphers = browser$6;
var compat = browser$8;
var Buffer$7 = safeBufferExports$1.Buffer;
function decrypt$1(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 Buffer$7.concat(out);
}
function parseKeys$2(buffer2) {
var password;
if (typeof buffer2 === "object" && !Buffer$7.isBuffer(buffer2)) {
password = buffer2.passphrase;
buffer2 = buffer2.key;
}
if (typeof buffer2 === "string") {
buffer2 = Buffer$7.from(buffer2);
}
var stripped = fixProc(buffer2, password);
var type2 = stripped.tag;
var data = stripped.data;
var subtype, ndata;
switch (type2) {
case "CERTIFICATE":
ndata = asn1.certificate.decode(data, "der").tbsCertificate.subjectPublicKeyInfo;
case "PUBLIC KEY":
if (!ndata) {
ndata = asn1.PublicKey.decode(data, "der");
}
subtype = ndata.algorithm.algorithm.join(".");
switch (subtype) {
case "1.2.840.113549.1.1.1":
return asn1.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 = asn1.DSAparam.decode(ndata.subjectPublicKey.data, "der");
return {
type: "dsa",
data: ndata.algorithm.params
};
default:
throw new Error("unknown key id " + subtype);
}
case "ENCRYPTED PRIVATE KEY":
data = asn1.EncryptedPrivateKey.decode(data, "der");
data = decrypt$1(data, password);
case "PRIVATE KEY":
ndata = asn1.PrivateKey.decode(data, "der");
subtype = ndata.algorithm.algorithm.join(".");
switch (subtype) {
case "1.2.840.113549.1.1.1":
return asn1.RSAPrivateKey.decode(ndata.subjectPrivateKey, "der");
case "1.2.840.10045.2.1":
return {
curve: ndata.algorithm.curve,
privateKey: asn1.ECPrivateKey.decode(ndata.subjectPrivateKey, "der").privateKey
};
case "1.2.840.10040.4.1":
ndata.algorithm.params.priv_key = asn1.DSAparam.decode(ndata.subjectPrivateKey, "der");
return {
type: "dsa",
params: ndata.algorithm.params
};
default:
throw new Error("unknown key id " + subtype);
}
case "RSA PUBLIC KEY":
return asn1.RSAPublicKey.decode(data, "der");
case "RSA PRIVATE KEY":
return asn1.RSAPrivateKey.decode(data, "der");
case "DSA PRIVATE KEY":
return {
type: "dsa",
params: asn1.DSAPrivateKey.decode(data, "der")
};
case "EC PRIVATE KEY":
data = asn1.ECPrivateKey.decode(data, "der");
return {
curve: data.parameters.value,
privateKey: data.privateKey
};
default:
throw new Error("unknown key type " + type2);
}
}
parseKeys$2.signature = asn1.signature;
var parseAsn1 = parseKeys$2;
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 = safeBufferExports$1.Buffer;
var createHmac2 = browser$9;
var crt2 = browserifyRsa;
var EC = requireElliptic().ec;
var BN2 = bnExports;
var parseKeys2 = parseAsn1;
var curves2 = require$$4$1;
var RSA_PKCS1_PADDING = 1;
function sign$1(hash3, key2, hashType, signType, tag) {
var priv2 = parseKeys2(key2);
if (priv2.curve) {
if (signType !== "ecdsa" && signType !== "ecdsa/rsa") {
throw new Error("wrong private key type");
}
return ecSign(hash3, priv2);
} else if (priv2.type === "dsa") {
if (signType !== "dsa") {
throw new Error("wrong private key type");
}
return dsaSign(hash3, priv2, 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");
}
hash3 = Buffer2.concat([tag, hash3]);
var len = priv2.modulus.byteLength();
var pad2 = [0, 1];
while (hash3.length + pad2.length + 1 < len) {
pad2.push(255);
}
pad2.push(0);
var i = -1;
while (++i < hash3.length) {
pad2.push(hash3[i]);
}
var out = crt2(pad2, priv2);
return out;
}
function ecSign(hash3, priv2) {
var curveId = curves2[priv2.curve.join(".")];
if (!curveId) {
throw new Error("unknown curve " + priv2.curve.join("."));
}
var curve2 = new EC(curveId);
var key2 = curve2.keyFromPrivate(priv2.privateKey);
var out = key2.sign(hash3);
return Buffer2.from(out.toDER());
}
function dsaSign(hash3, priv2, algo) {
var x = priv2.params.priv_key;
var p = priv2.params.p;
var q = priv2.params.q;
var g2 = priv2.params.g;
var r2 = new BN2(0);
var k;
var H = bits2int(hash3, q).mod(q);
var s2 = false;
var kv = getKey(x, q, hash3, algo);
while (s2 === false) {
k = makeKey(q, kv, algo);
r2 = makeR(g2, k, p, q);
s2 = k.invm(q).imul(H.add(x.mul(r2))).mod(q);
if (s2.cmpn(0) === 0) {
s2 = false;
r2 = new BN2(0);
}
}
return toDER2(r2, s2);
}
function toDER2(r2, s2) {
r2 = r2.toArray();
s2 = s2.toArray();
if (r2[0] & 128) {
r2 = [0].concat(r2);
}
if (s2[0] & 128) {
s2 = [0].concat(s2);
}
var total = r2.length + s2.length + 4;
var res = [
48,
total,
2,
r2.length
];
res = res.concat(r2, [2, s2.length], s2);
return Buffer2.from(res);
}
function getKey(x, q, hash3, 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 = hash3.length;
var hbits = bits2octets(hash3, q);
var v = Buffer2.alloc(hlen);
v.fill(1);
var k = Buffer2.alloc(hlen);
k = createHmac2(algo, k).update(v).update(Buffer2.from([0])).update(x).update(hbits).digest();
v = createHmac2(algo, k).update(v).digest();
k = createHmac2(algo, k).update(v).update(Buffer2.from([1])).update(x).update(hbits).digest();
v = createHmac2(algo, k).update(v).digest();
return { k, v };
}
function bits2int(obits, q) {
var bits = new BN2(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 = createHmac2(algo, kv.k).update(kv.v).digest();
t = Buffer2.concat([t, kv.v]);
}
k = bits2int(t, q);
kv.k = createHmac2(algo, kv.k).update(kv.v).update(Buffer2.from([0])).digest();
kv.v = createHmac2(algo, kv.k).update(kv.v).digest();
} while (k.cmp(q) !== -1);
return k;
}
function makeR(g2, k, p, q) {
return g2.toRed(BN2.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 = safeBufferExports$1.Buffer;
var BN2 = bnExports;
var EC = requireElliptic().ec;
var parseKeys2 = parseAsn1;
var curves2 = require$$4$1;
function verify4(sig, hash3, key2, signType, tag) {
var pub2 = parseKeys2(key2);
if (pub2.type === "ec") {
if (signType !== "ecdsa" && signType !== "ecdsa/rsa") {
throw new Error("wrong public key type");
}
return ecVerify(sig, hash3, pub2);
} else if (pub2.type === "dsa") {
if (signType !== "dsa") {
throw new Error("wrong public key type");
}
return dsaVerify(sig, hash3, pub2);
}
if (signType !== "rsa" && signType !== "ecdsa/rsa") {
throw new Error("wrong public key type");
}
hash3 = Buffer2.concat([tag, hash3]);
var len = pub2.modulus.byteLength();
var pad2 = [1];
var padNum = 0;
while (hash3.length + pad2.length + 2 < len) {
pad2.push(255);
padNum += 1;
}
pad2.push(0);
var i = -1;
while (++i < hash3.length) {
pad2.push(hash3[i]);
}
pad2 = Buffer2.from(pad2);
var red = BN2.mont(pub2.modulus);
sig = new BN2(sig).toRed(red);
sig = sig.redPow(new BN2(pub2.publicExponent));
sig = Buffer2.from(sig.fromRed().toArray());
var out = padNum < 8 ? 1 : 0;
len = Math.min(sig.length, pad2.length);
if (sig.length !== pad2.length) {
out = 1;
}
i = -1;
while (++i < len) {
out |= sig[i] ^ pad2[i];
}
return out === 0;
}
function ecVerify(sig, hash3, pub2) {
var curveId = curves2[pub2.data.algorithm.curve.join(".")];
if (!curveId) {
throw new Error("unknown curve " + pub2.data.algorithm.curve.join("."));
}
var curve2 = new EC(curveId);
var pubkey = pub2.data.subjectPrivateKey.data;
return curve2.verify(hash3, sig, pubkey);
}
function dsaVerify(sig, hash3, pub2) {
var p = pub2.data.p;
var q = pub2.data.q;
var g2 = pub2.data.g;
var y = pub2.data.pub_key;
var unpacked = parseKeys2.signature.decode(sig, "der");
var s2 = unpacked.s;
var r2 = unpacked.r;
checkValue(s2, q);
checkValue(r2, q);
var montp = BN2.mont(p);
var w = s2.invm(q);
var v = g2.toRed(montp).redPow(new BN2(hash3).mul(w).mod(q)).fromRed().mul(y.toRed(montp).redPow(r2.mul(w).mod(q)).fromRed()).mod(p).mod(q);
return v.cmp(r2) === 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 = verify4;
return verify_1;
}
var browser$4;
var hasRequiredBrowser$1;
function requireBrowser$1() {
if (hasRequiredBrowser$1) return browser$4;
hasRequiredBrowser$1 = 1;
var Buffer2 = safeBufferExports$1.Buffer;
var createHash3 = browser$a;
var stream = readableBrowserExports;
var inherits2 = inherits_browserExports;
var sign5 = requireSign();
var verify4 = 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 = createHash3(data.hash);
this._tag = data.id;
this._signType = data.sign;
}
inherits2(Sign, stream.Writable);
Sign.prototype._write = function _write(data, _, done2) {
this._hash.update(data);
done2();
};
Sign.prototype.update = function update6(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 hash3 = this._hash.digest();
var sig = sign5(hash3, 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 = createHash3(data.hash);
this._tag = data.id;
this._signType = data.sign;
}
inherits2(Verify, stream.Writable);
Verify.prototype._write = function _write(data, _, done2) {
this._hash.update(data);
done2();
};
Verify.prototype.update = function update6(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 hash3 = this._hash.digest();
return verify4(sigBuffer, hash3, key2, this._signType, this._tag);
};
function createSign(algorithm) {
return new Sign(algorithm);
}
function createVerify(algorithm) {
return new Verify(algorithm);
}
browser$4 = {
Sign: createSign,
Verify: createVerify,
createSign,
createVerify
};
return browser$4;
}
var browser$3;
var hasRequiredBrowser;
function requireBrowser() {
if (hasRequiredBrowser) return browser$3;
hasRequiredBrowser = 1;
var elliptic2 = requireElliptic();
var BN2 = bnExports$1;
browser$3 = 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, format2) {
this.keys = this.curve.genKeyPair();
return this.getPublicKey(enc, format2);
};
ECDH.prototype.computeSecret = function(other, inenc, enc) {
inenc = inenc || "utf8";
if (!Buffer$E.isBuffer(other)) {
other = new Buffer$E(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, format2) {
var key2 = this.keys.getPublic(format2 === "compressed", true);
if (format2 === "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(pub2, enc) {
enc = enc || "utf8";
if (!Buffer$E.isBuffer(pub2)) {
pub2 = new Buffer$E(pub2, enc);
}
this.keys._importPublic(pub2);
return this;
};
ECDH.prototype.setPrivateKey = function(priv2, enc) {
enc = enc || "utf8";
if (!Buffer$E.isBuffer(priv2)) {
priv2 = new Buffer$E(priv2, enc);
}
var _priv = new BN2(priv2);
_priv = _priv.toString(16);
this.keys = this.curve.genKeyPair();
this.keys._importPrivate(_priv);
return this;
};
function formatReturnValue(bn2, enc, len) {
if (!Array.isArray(bn2)) {
bn2 = bn2.toArray();
}
var buf = new Buffer$E(bn2);
if (len && buf.length < len) {
var zeros = new Buffer$E(len - buf.length);
zeros.fill(0);
buf = Buffer$E.concat([zeros, buf]);
}
if (!enc) {
return buf;
} else {
return buf.toString(enc);
}
}
return browser$3;
}
var browser$2 = {};
var createHash$2 = browser$a;
var Buffer$6 = safeBufferExports$1.Buffer;
var mgf$2 = function(seed, len) {
var t = Buffer$6.alloc(0);
var i = 0;
var c;
while (t.length < len) {
c = i2ops(i++);
t = Buffer$6.concat([t, createHash$2("sha1").update(seed).update(c).digest()]);
}
return t.slice(0, len);
};
function i2ops(c) {
var out = Buffer$6.allocUnsafe(4);
out.writeUInt32BE(c, 0);
return out;
}
var xor$2 = function xor3(a, b) {
var len = a.length;
var i = -1;
while (++i < len) {
a[i] ^= b[i];
}
return a;
};
var BN$2 = bnExports$1;
var Buffer$5 = safeBufferExports$1.Buffer;
function withPublic$2(paddedMsg, key2) {
return Buffer$5.from(paddedMsg.toRed(BN$2.mont(key2.modulus)).redPow(new BN$2(key2.publicExponent)).fromRed().toArray());
}
var withPublic_1 = withPublic$2;
var parseKeys$1 = parseAsn1;
var randomBytes = browserExports;
var createHash$1 = browser$a;
var mgf$1 = mgf$2;
var xor$1 = xor$2;
var BN$1 = bnExports$1;
var withPublic$1 = withPublic_1;
var crt$1 = browserifyRsa;
var Buffer$4 = safeBufferExports$1.Buffer;
var 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$1(publicKey);
var paddedMsg;
if (padding === 4) {
paddedMsg = oaep$1(key2, msg);
} else if (padding === 1) {
paddedMsg = pkcs1$1(key2, msg, reverse);
} else if (padding === 3) {
paddedMsg = new BN$1(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$1(paddedMsg, key2);
} else {
return withPublic$1(paddedMsg, key2);
}
};
function oaep$1(key2, msg) {
var k = key2.modulus.byteLength();
var mLen = msg.length;
var iHash = createHash$1("sha1").update(Buffer$4.alloc(0)).digest();
var hLen = iHash.length;
var hLen2 = 2 * hLen;
if (mLen > k - hLen2 - 2) {
throw new Error("message too long");
}
var ps = Buffer$4.alloc(k - mLen - hLen2 - 2);
var dblen = k - hLen - 1;
var seed = randomBytes(hLen);
var maskedDb = xor$1(Buffer$4.concat([iHash, ps, Buffer$4.alloc(1, 1), msg], dblen), mgf$1(seed, dblen));
var maskedSeed = xor$1(seed, mgf$1(maskedDb, hLen));
return new BN$1(Buffer$4.concat([Buffer$4.alloc(1), maskedSeed, maskedDb], k));
}
function pkcs1$1(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 = Buffer$4.alloc(k - mLen - 3, 255);
} else {
ps = nonZero(k - mLen - 3);
}
return new BN$1(Buffer$4.concat([Buffer$4.from([0, reverse ? 1 : 2]), ps, Buffer$4.alloc(1), msg], k));
}
function nonZero(len) {
var out = Buffer$4.allocUnsafe(len);
var i = 0;
var cache2 = randomBytes(len * 2);
var cur = 0;
var num;
while (i < len) {
if (cur === cache2.length) {
cache2 = randomBytes(len * 2);
cur = 0;
}
num = cache2[cur++];
if (num) {
out[i++] = num;
}
}
return out;
}
var parseKeys = parseAsn1;
var mgf = mgf$2;
var xor = xor$2;
var BN = bnExports$1;
var crt = browserifyRsa;
var createHash = browser$a;
var withPublic = withPublic_1;
var Buffer$3 = safeBufferExports$1.Buffer;
var 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 = Buffer$3.alloc(k - msg.length);
msg = Buffer$3.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(Buffer$3.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 = xor(maskedSeed, mgf(maskedDb, hLen));
var db = xor(maskedDb, mgf(seed, k - hLen - 1));
if (compare(iHash, db.slice(0, hLen))) {
throw new Error("decryption error");
}
var i = hLen;
while (db[i] === 0) {
i++;
}
if (db[i++] !== 1) {
throw new Error("decryption error");
}
return db.slice(i);
}
function pkcs1(key2, msg, reverse) {
var p1 = msg.slice(0, 2);
var i = 2;
var status = 0;
while (msg[i++] !== 0) {
if (i >= msg.length) {
status++;
break;
}
}
var ps = msg.slice(2, i - 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(i);
}
function compare(a, b) {
a = Buffer$3.from(a);
b = Buffer$3.from(b);
var dif = 0;
var len = a.length;
if (a.length !== b.length) {
dif++;
len = Math.min(a.length, b.length);
}
var i = -1;
while (++i < len) {
dif += a[i] ^ b[i];
}
return dif;
}
(function(exports2) {
exports2.publicEncrypt = publicEncrypt;
exports2.privateDecrypt = privateDecrypt;
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$2);
var browser$1 = {};
function oldBrowser() {
throw new Error("secure random number generation not supported by this browser\nuse chrome, FireFox or Internet Explorer 11");
}
var safeBuffer = safeBufferExports$1;
var randombytes = browserExports;
var Buffer$2 = safeBuffer.Buffer;
var kBufferMaxLength = safeBuffer.kMaxLength;
var crypto$1 = 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$1 && crypto$1.getRandomValues || !process$1.browser) {
browser$1.randomFill = randomFill;
browser$1.randomFillSync = randomFillSync;
} else {
browser$1.randomFill = oldBrowser;
browser$1.randomFillSync = oldBrowser;
}
function randomFill(buf, offset, size, cb) {
if (!Buffer$2.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$1.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 (!Buffer$2.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);
}
var hasRequiredCryptoBrowserify;
function requireCryptoBrowserify() {
if (hasRequiredCryptoBrowserify) return cryptoBrowserify;
hasRequiredCryptoBrowserify = 1;
cryptoBrowserify.randomBytes = cryptoBrowserify.rng = cryptoBrowserify.pseudoRandomBytes = cryptoBrowserify.prng = browserExports;
cryptoBrowserify.createHash = cryptoBrowserify.Hash = browser$a;
cryptoBrowserify.createHmac = cryptoBrowserify.Hmac = browser$9;
var algos$1 = algos;
var algoKeys = Object.keys(algos$1);
var hashes = [
"sha1",
"sha224",
"sha256",
"sha384",
"sha512",
"md5",
"rmd160"
].concat(algoKeys);
cryptoBrowserify.getHashes = function() {
return hashes;
};
var p = browser$8;
cryptoBrowserify.pbkdf2 = p.pbkdf2;
cryptoBrowserify.pbkdf2Sync = p.pbkdf2Sync;
var aes2 = browser$7;
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$2();
cryptoBrowserify.DiffieHellmanGroup = dh2.DiffieHellmanGroup;
cryptoBrowserify.createDiffieHellmanGroup = dh2.createDiffieHellmanGroup;
cryptoBrowserify.getDiffieHellman = dh2.getDiffieHellman;
cryptoBrowserify.createDiffieHellman = dh2.createDiffieHellman;
cryptoBrowserify.DiffieHellman = dh2.DiffieHellman;
var sign5 = requireBrowser$1();
cryptoBrowserify.createSign = sign5.createSign;
cryptoBrowserify.Sign = sign5.Sign;
cryptoBrowserify.createVerify = sign5.createVerify;
cryptoBrowserify.Verify = sign5.Verify;
cryptoBrowserify.createECDH = requireBrowser();
var publicEncrypt3 = browser$2;
cryptoBrowserify.publicEncrypt = publicEncrypt3.publicEncrypt;
cryptoBrowserify.privateEncrypt = publicEncrypt3.privateEncrypt;
cryptoBrowserify.publicDecrypt = publicEncrypt3.publicDecrypt;
cryptoBrowserify.privateDecrypt = publicEncrypt3.privateDecrypt;
var rf = browser$1;
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 name = "dotenv";
const version$1 = "16.4.5";
const description = "Loads environment variables from .env file";
const main = "lib/main.js";
const types = "lib/main.d.ts";
const exports$1 = {
".": {
types: "./lib/main.d.ts",
require: "./lib/main.js",
"default": "./lib/main.js"
},
"./config": "./config.js",
"./config.js": "./config.js",
"./lib/env-options": "./lib/env-options.js",
"./lib/env-options.js": "./lib/env-options.js",
"./lib/cli-options": "./lib/cli-options.js",
"./lib/cli-options.js": "./lib/cli-options.js",
"./package.json": "./package.json"
};
const scripts = {
"dts-check": "tsc --project tests/types/tsconfig.json",
lint: "standard",
"lint-readme": "standard-markdown",
pretest: "npm run lint && npm run dts-check",
test: "tap tests/*.js --100 -Rspec",
"test:coverage": "tap --coverage-report=lcov",
prerelease: "npm test",
release: "standard-version"
};
const repository = {
type: "git",
url: "git://github.com/motdotla/dotenv.git"
};
const funding = "https://dotenvx.com";
const keywords = [
"dotenv",
"env",
".env",
"environment",
"variables",
"config",
"settings"
];
const readmeFilename = "README.md";
const license = "BSD-2-Clause";
const devDependencies = {
"@definitelytyped/dtslint": "^0.0.133",
"@types/node": "^18.11.3",
decache: "^4.6.1",
sinon: "^14.0.1",
standard: "^17.0.0",
"standard-markdown": "^7.1.0",
"standard-version": "^9.5.0",
tap: "^16.3.0",
tar: "^6.1.11",
typescript: "^4.8.4"
};
const engines = {
node: ">=12"
};
const browser = {
fs: false
};
const require$$4 = {
name,
version: version$1,
description,
main,
types,
exports: exports$1,
scripts,
repository,
funding,
keywords,
readmeFilename,
license,
devDependencies,
engines,
browser
};
const fs = empty_1;
const path = pathBrowserify;
const os = browser$d;
const crypto = requireCryptoBrowserify();
const packageJson = require$$4;
const version = packageJson.version;
const LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
function parse(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(options2) {
const vaultPath = _vaultPath(options2);
const result = DotenvModule.configDotenv({ path: vaultPath });
if (!result.parsed) {
const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
err.code = "MISSING_DATA";
throw err;
}
const keys2 = _dotenvKey(options2).split(",");
const length = keys2.length;
let decrypted;
for (let i = 0; i < length; i++) {
try {
const key2 = keys2[i].trim();
const attrs = _instructions(result, key2);
decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
break;
} catch (error2) {
if (i + 1 >= length) {
throw error2;
}
}
}
return DotenvModule.parse(decrypted);
}
function _log(message) {
console.log(`[dotenv@${version}][INFO] ${message}`);
}
function _warn(message) {
console.log(`[dotenv@${version}][WARN] ${message}`);
}
function _debug(message) {
console.log(`[dotenv@${version}][DEBUG] ${message}`);
}
function _dotenvKey(options2) {
if (options2 && options2.DOTENV_KEY && options2.DOTENV_KEY.length > 0) {
return options2.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 (error2) {
if (error2.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 error2;
}
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(options2) {
let possibleVaultPath = null;
if (options2 && options2.path && options2.path.length > 0) {
if (Array.isArray(options2.path)) {
for (const filepath of options2.path) {
if (fs.existsSync(filepath)) {
possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
}
}
} else {
possibleVaultPath = options2.path.endsWith(".vault") ? options2.path : `${options2.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(options2) {
_log("Loading env from encrypted .env.vault");
const parsed = DotenvModule._parseVault(options2);
let processEnv = process$1.env;
if (options2 && options2.processEnv != null) {
processEnv = options2.processEnv;
}
DotenvModule.populate(processEnv, parsed, options2);
return { parsed };
}
function configDotenv(options2) {
const dotenvPath = path.resolve(process$1.cwd(), ".env");
let encoding = "utf8";
const debug = Boolean(options2 && options2.debug);
if (options2 && options2.encoding) {
encoding = options2.encoding;
} else {
if (debug) {
_debug("No encoding is specified. UTF-8 is used by default");
}
}
let optionPaths = [dotenvPath];
if (options2 && options2.path) {
if (!Array.isArray(options2.path)) {
optionPaths = [_resolveHome(options2.path)];
} else {
optionPaths = [];
for (const filepath of options2.path) {
optionPaths.push(_resolveHome(filepath));
}
}
}
let lastError;
const parsedAll = {};
for (const path3 of optionPaths) {
try {
const parsed = DotenvModule.parse(fs.readFileSync(path3, { encoding }));
DotenvModule.populate(parsedAll, parsed, options2);
} catch (e) {
if (debug) {
_debug(`Failed to load ${path3} ${e.message}`);
}
lastError = e;
}
}
let processEnv = process$1.env;
if (options2 && options2.processEnv != null) {
processEnv = options2.processEnv;
}
DotenvModule.populate(processEnv, parsedAll, options2);
if (lastError) {
return { parsed: parsedAll, error: lastError };
} else {
return { parsed: parsedAll };
}
}
function config(options2) {
if (_dotenvKey(options2).length === 0) {
return DotenvModule.configDotenv(options2);
}
const vaultPath = _vaultPath(options2);
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(options2);
}
return DotenvModule._configVault(options2);
}
function decrypt(encrypted, keyStr) {
const key2 = Buffer$E.from(keyStr.slice(-64), "hex");
let ciphertext = Buffer$E.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 (error2) {
const isRange = error2 instanceof RangeError;
const invalidKeyLength = error2.message === "Invalid key length";
const decryptionFailed = error2.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 error2;
}
}
}
function populate(processEnv, parsed, options2 = {}) {
const debug = Boolean(options2 && options2.debug);
const override = Boolean(options2 && options2.override);
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];
}
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];
}
}
}
const DotenvModule = {
configDotenv,
_configVault,
_parseVault,
config,
decrypt,
parse,
populate
};
main$2.exports.configDotenv = DotenvModule.configDotenv;
main$2.exports._configVault = DotenvModule._configVault;
main$2.exports._parseVault = DotenvModule._parseVault;
main$2.exports.config = DotenvModule.config;
main$2.exports.decrypt = DotenvModule.decrypt;
main$2.exports.parse = DotenvModule.parse;
main$2.exports.populate = DotenvModule.populate;
main$2.exports = DotenvModule;
var mainExports = main$2.exports;
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_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;
}
var envOptions = options;
const re = /^dotenv_config_(encoding|path|debug|override|DOTENV_KEY)=(.+)$/;
var cliOptions = function optionMatcher(args) {
return args.reduce(function(acc, cur) {
const matches = cur.match(re);
if (matches) {
acc[matches[1]] = matches[2];
}
return acc;
}, {});
};
(function() {
mainExports.config(
Object.assign(
{},
envOptions,
cliOptions(process$1.argv)
)
);
})();
function defineChain(chain) {
return {
formatters: void 0,
fees: void 0,
serializers: void 0,
...chain
};
}
const holesky = /* @__PURE__ */ defineChain({
id: 17e3,
name: "Holesky",
nativeCurrency: { name: "Holesky Ether", symbol: "ETH", decimals: 18 },
rpcUrls: {
default: {
http: ["https://ethereum-holesky-rpc.publicnode.com"]
}
},
blockExplorers: {
default: {
name: "Etherscan",
url: "https://holesky.etherscan.io",
apiUrl: "https://api-holesky.etherscan.io/api"
}
},
contracts: {
multicall3: {
address: "0xca11bde05977b3631167028862be2a173976ca11",
blockCreated: 77
},
ensRegistry: {
address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e",
blockCreated: 801613
},
ensUniversalResolver: {
address: "0xa6AC935D4971E3CD133b950aE053bECD16fE7f3b",
blockCreated: 973484
}
},
testnet: true
});
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 = {
holesky,
hoodi
};
const chainIds = [holesky.id, hoodi.id];
const networks = ["holesky", "hoodi"];
const bam_graph_endpoints = {
[holesky.id]: "https://api.studio.thegraph.com/query/71118/based-applications-ssv-holesky/version/latest/",
[hoodi.id]: "https://graph-node-hoodi.stage.ops.ssvlabsinternal.com/subgraphs/name/ssv-bapps-hoodi-stage/graphql"
};
const contracts = {
[holesky.id]: {
bapp: "0x9B3345F3B1Ce2d8655FC4B6e2ed39322d52aA317"
},
[hoodi.id]: {
bapp: "0x3F2983b813054Eba76Ae137DfA77836CA8b00ACE"
}
};
const global$1 = globalThis || void 0 || self;
var freeGlobal = typeof global$1 == "object" && global$1 && global$1.Object === Object && global$1;
var freeSelf = typeof self == "object" && self && self.Object === Object && self;
var root = freeGlobal || freeSelf || Function("return this")();
var Symbol$1 = root.Symbol;
var objectProto$c = Object.prototype;
var hasOwnProperty$9 = objectProto$c.hasOwnProperty;
var nativeObjectToString$1 = objectProto$c.toString;
var symToStringTag$1 = Symbol$1 ? Symbol$1.toStringTag : void 0;
function getRawTag(value) {
var isOwn = hasOwnProperty$9.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$b = Object.prototype;
var nativeObjectToString = objectProto$b.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(value) {
var type2 = typeof value;
return value != null && (type2 == "object" || type2 == "function");
}
var asyncTag = "[object AsyncFunction]", funcTag$2 = "[object Function]", genTag$1 = "[object GeneratorFunction]", proxyTag = "[object Proxy]";
function isFunction(value) {
if (!isObject(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$a = Object.prototype;
var funcToString = funcProto.toString;
var hasOwnProperty$8 = objectProto$a.hasOwnProperty;
var reIsNative = RegExp(
"^" + funcToString.call(hasOwnProperty$8).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
);
function baseIsNative(value) {
if (!isObject(value) || isMasked(value)) {
return false;
}
var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
return pattern.test(toSource(value));
}
function getValue(object, key2) {
return object == null ? void 0 : object[key2];
}
function getNative(object, key2) {
var value = getValue(object, key2);
return baseIsNative(value) ? value : void 0;
}
var WeakMap$1 = getNative(root, "WeakMap");
var objectCreate = Object.create;
var baseCreate = /* @__PURE__ */ function() {
function object() {
}
return function(proto2) {
if (!isObject(proto2)) {
return {};
}
if (objectCreate) {
return objectCreate(proto2);
}
object.prototype = proto2;
var result = new object();
object.prototype = void 0;
return result;
};
}();
function copyArray(source, array) {
var index = -1, length = source.length;
array || (array = Array(length));
while (++index < length) {
array[index] = source[index];
}
return array;
}
var defineProperty = function() {
try {
var func = getNative(Object, "defineProperty");
func({}, "", {});
return func;
} catch (e) {
}
}();
function arrayEach(array, iteratee) {
var index = -1, length = array == null ? 0 : array.length;
while (++index < length) {
if (iteratee(array[index], index, array) === false) {
break;
}
}
return array;
}
var MAX_SAFE_INTEGER$1 = 9007199254740991;
var reIsUint = /^(?:0|[1-9]\d*)$/;
function isIndex(value, length) {
var type2 = typeof value;
length = length == null ? MAX_SAFE_INTEGER$1 : length;
return !!length && (type2 == "number" || type2 != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
}
function baseAssignValue(object, key2, value) {
if (key2 == "__proto__" && defineProperty) {
defineProperty(object, key2, {
"configurable": true,
"enumerable": true,
"value": value,
"writable": true
});
} else {
object[key2] = value;
}
}
function eq(value, other) {
return value === other || value !== value && other !== other;
}
var objectProto$9 = Object.prototype;
var hasOwnProperty$7 = objectProto$9.hasOwnProperty;
function assignValue(object, key2, value) {
var objValue = object[key2];
if (!(hasOwnProperty$7.call(object, key2) && eq(objValue, value)) || value === void 0 && !(key2 in object)) {
baseAssignValue(object, key2, value);
}
}
function copyObject(source, props, object, customizer) {
var isNew = !object;
object || (object = {});
var index = -1, length = props.length;
while (++index < length) {
var key2 = props[index];
var newValue = void 0;
if (newValue === void 0) {
newValue = source[key2];
}
if (isNew) {
baseAssignValue(object, key2, newValue);
} else {
assignValue(object, key2, newValue);
}
}
return object;
}
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$8 = Object.prototype;
function isPrototype(value) {
var Ctor = value && value.constructor, proto2 = typeof Ctor == "function" && Ctor.prototype || objectProto$8;
return value === proto2;
}
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$7 = Object.prototype;
var hasOwnProperty$6 = objectProto$7.hasOwnProperty;
var propertyIsEnumerable$1 = objectProto$7.propertyIsEnumerable;
var isArguments = baseIsArguments(/* @__PURE__ */ function() {
return arguments;
}()) ? baseIsArguments : function(value) {
return isObjectLike(value) && hasOwnProperty$6.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 types2 = freeModule$1 && freeModule$1.require && freeModule$1.require("util").types;
if (types2) {
return types2;
}
return freeProcess && freeProcess.binding && freeProcess.binding("util");
} catch (e) {
}
}();
var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
var objectProto$6 = Object.prototype;
var hasOwnProperty$5 = objectProto$6.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 key2 in value) {
if ((inherited || hasOwnProperty$5.call(value, key2)) && !(skipIndexes && // Safari 9 has enumerable `arguments.length` in strict mode.
(key2 == "length" || // Node.js 0.10 has enumerable non-index properties on buffers.
isBuff && (key2 == "offset" || key2 == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays.
isType && (key2 == "buffer" || key2 == "byteLength" || key2 == "byteOffset") || // Skip index properties.
isIndex(key2, length)))) {
result.push(key2);
}
}
return result;
}
function overArg(func, transform) {
return function(arg) {
return func(transform(arg));
};
}
var nativeKeys = overArg(Object.keys, Object);
var objectProto$5 = Object.prototype;
var hasOwnProperty$4 = objectProto$5.hasOwnProperty;
function baseKeys(object) {
if (!isPrototype(object)) {
return nativeKeys(object);
}
var result = [];
for (var key2 in Object(object)) {
if (hasOwnProperty$4.call(object, key2) && key2 != "constructor") {
result.push(key2);
}
}
return result;
}
function keys(object) {
return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
}
function nativeKeysIn(object) {
var result = [];
if (object != null) {
for (var key2 in Object(object)) {
result.push(key2);
}
}
return result;
}
var objectProto$4 = Object.prototype;
var hasOwnProperty$3 = objectProto$4.hasOwnProperty;
function baseKeysIn(object) {
if (!isObject(object)) {
return nativeKeysIn(object);
}
var isProto = isPrototype(object), result = [];
for (var key2 in object) {
if (!(key2 == "constructor" && (isProto || !hasOwnProperty$3.call(object, key2)))) {
result.push(key2);
}
}
return result;
}
function keysIn(object) {
return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
}
var nativeCreate = getNative(Object, "create");
function hashClear() {
this.__data__ = nativeCreate ? nativeCreate(null) : {};
this.size = 0;
}
function hashDelete(key2) {
var result = this.has(key2) && delete this.__data__[key2];
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(key2) {
var data = this.__data__;
if (nativeCreate) {
var result = data[key2];
return result === HASH_UNDEFINED$1 ? void 0 : result;
}
return hasOwnProperty$2.call(data, key2) ? data[key2] : void 0;
}
var objectProto$2 = Object.prototype;
var hasOwnProperty$1 = objectProto$2.hasOwnProperty;
function hashHas(key2) {
var data = this.__data__;
return nativeCreate ? data[key2] !== void 0 : hasOwnProperty$1.call(data, key2);
}
var HASH_UNDEFINED = "__lodash_hash_undefined__";
function hashSet(key2, value) {
var data = this.__data__;
this.size += this.has(key2) ? 0 : 1;
data[key2] = 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(array, key2) {
var length = array.length;
while (length--) {
if (eq(array[length][0], key2)) {
return length;
}
}
return -1;
}
var arrayProto = Array.prototype;
var splice = arrayProto.splice;
function listCacheDelete(key2) {
var data = this.__data__, index = assocIndexOf(data, key2);
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(key2) {
var data = this.__data__, index = assocIndexOf(data, key2);
return index < 0 ? void 0 : data[index][1];
}
function listCacheHas(key2) {
return assocIndexOf(this.__data__, key2) > -1;
}
function listCacheSet(key2, value) {
var data = this.__data__, index = assocIndexOf(data, key2);
if (index < 0) {
++this.size;
data.push([key2, 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 type2 = typeof value;
return type2 == "string" || type2 == "number" || type2 == "symbol" || type2 == "boolean" ? value !== "__proto__" : value === null;
}
function getMapData(map, key2) {
var data = map.__data__;
return isKeyable(key2) ? data[typeof key2 == "string" ? "string" : "hash"] : data.map;
}
function mapCacheDelete(key2) {
var result = getMapData(this, key2)["delete"](key2);
this.size -= result ? 1 : 0;
return result;
}
function mapCacheGet(key2) {
return getMapData(this, key2).get(key2);
}
function mapCacheHas(key2) {
return getMapData(this, key2).has(key2);
}
function mapCacheSet(key2, value) {
var data = getMapData(this, key2), size = data.size;
data.set(key2, 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(array, values) {
var index = -1, length = values.length, offset = array.length;
while (++index < length) {
array[offset + index] = values[index];
}
return array;
}
var getPrototype = overArg(Object.getPrototypeOf, Object);
function stackClear() {
this.__data__ = new ListCache();
this.size = 0;
}
function stackDelete(key2) {
var data = this.__data__, result = data["delete"](key2);
this.size = data.size;
return result;
}
function stackGet(key2) {
return this.__data__.get(key2);
}
function stackHas(key2) {
return this.__data__.has(key2);
}
var LARGE_ARRAY_SIZE = 200;
function stackSet(key2, value) {
var data = this.__data__;
if (data instanceof ListCache) {
var pairs = data.__data__;
if (!Map$1 || pairs.length < LARGE_ARRAY_SIZE - 1) {
pairs.push([key2, value]);
this.size = ++data.size;
return this;
}
data = this.__data__ = new MapCache(pairs);
}
data.set(key2, 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;
function baseAssign(object, source) {
return object && copyObject(source, keys(source), object);
}
function baseAssignIn(object, source) {
return object && copyObject(source, keysIn(source), object);
}
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(buffer2, isDeep) {
if (isDeep) {
return buffer2.slice();
}
var length = buffer2.length, result = allocUnsafe ? allocUnsafe(length) : new buffer2.constructor(length);
buffer2.copy(result);
return result;
}
function arrayFilter(array, predicate) {
var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result = [];
while (++index < length) {
var value = array[index];
if (predicate(value, index, array)) {
result[resIndex++] = value;
}
}
return result;
}
function stubArray() {
return [];
}
var objectProto$1 = Object.prototype;
var propertyIsEnumerable = objectProto$1.propertyIsEnumerable;
var nativeGetSymbols$1 = Object.getOwnPropertySymbols;
var getSymbols = !nativeGetSymbols$1 ? stubArray : function(object) {
if (object == null) {
return [];
}
object = Object(object);
return arrayFilter(nativeGetSymbols$1(object), function(symbol) {
return propertyIsEnumerable.call(object, symbol);
});
};
function copySymbols(source, object) {
return copyObject(source, getSymbols(source), object);
}
var nativeGetSymbols = Object.getOwnPropertySymbols;
var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {
var result = [];
while (object) {
arrayPush(result, getSymbols(object));
object = getPrototype(object);
}
return result;
};
function copySymbolsIn(source, object) {
return copyObject(source, getSymbolsIn(source), object);
}
function baseGetAllKeys(object, keysFunc, symbolsFunc) {
var result = keysFunc(object);
return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
}
function getAllKeys(object) {
return baseGetAllKeys(object, keys, getSymbols);
}
function getAllKeysIn(object) {
return baseGetAllKeys(object, keysIn, getSymbolsIn);
}
var DataView$1 = 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$1), mapCtorString = toSource(Map$1), promiseCtorString = toSource(Promise$1), setCtorString = toSource(Set$1), weakMapCtorString = toSource(WeakMap$1);
var getTag = baseGetTag;
if (DataView$1 && getTag(new DataView$1(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$1 && getTag(new WeakMap$1()) != 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(array) {
var length = array.length, result = new array.constructor(length);
if (length && typeof array[0] == "string" && hasOwnProperty.call(array, "index")) {
result.index = array.index;
result.input = array.input;
}
return result;
}
var Uint8Array$1 = root.Uint8Array;
function cloneArrayBuffer(arrayBuffer) {
var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
new Uint8Array$1(result).set(new Uint8Array$1(arrayBuffer));
return result;
}
function cloneDataView(dataView, isDeep) {
var buffer2 = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;
return new dataView.constructor(buffer2, 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 buffer2 = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
return new typedArray.constructor(buffer2, 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(object, tag, isDeep) {
var Ctor = object.constructor;
switch (tag) {
case arrayBufferTag$1:
return cloneArrayBuffer(object);
case boolTag$1:
case dateTag$1:
return new Ctor(+object);
case dataViewTag$1:
return cloneDataView(object, isDeep);
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(object, isDeep);
case mapTag$2:
return new Ctor();
case numberTag$1:
case stringTag$1:
return new Ctor(object);
case regexpTag$1:
return cloneRegExp(object);
case setTag$2:
return new Ctor();
case symbolTag$1:
return cloneSymbol(object);
}
}
function initCloneObject(object) {
return typeof object.constructor == "function" && !isPrototype(object) ? baseCreate(getPrototype(object)) : {};
}
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, CLONE_FLAT_FLAG = 2, CLONE_SYMBOLS_FLAG$1 = 4;
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, key2, object, stack) {
var result, isDeep = bitmask & CLONE_DEEP_FLAG$1, isFlat = bitmask & CLONE_FLAT_FLAG, isFull = bitmask & CLONE_SYMBOLS_FLAG$1;
if (customizer) {
result = object ? customizer(value, key2, object, stack) : customizer(value);
}
if (result !== void 0) {
return result;
}
if (!isObject(value)) {
return value;
}
var isArr = isArray(value);
if (isArr) {
result = initCloneArray(value);
if (!isDeep) {
return copyArray(value, result);
}
} else {
var tag = getTag(value), isFunc = tag == funcTag || tag == genTag;
if (isBuffer(value)) {
return cloneBuffer(value, isDeep);
}
if (tag == objectTag || tag == argsTag || isFunc && !object) {
result = isFlat || isFunc ? {} : initCloneObject(value);
if (!isDeep) {
return isFlat ? copySymbolsIn(value, baseAssignIn(result, value)) : copySymbols(value, baseAssign(result, value));
}
} else {
if (!cloneableTags[tag]) {
return object ? 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, key3) {
result.set(key3, baseClone(subValue, bitmask, customizer, key3, value, stack));
});
}
var keysFunc = isFull ? isFlat ? getAllKeysIn : getAllKeys : isFlat ? keysIn : keys;
var props = isArr ? void 0 : keysFunc(value);
arrayEach(props || value, function(subValue, key3) {
if (props) {
key3 = subValue;
subValue = value[key3];
}
assignValue(result, key3, baseClone(subValue, bitmask, customizer, key3, 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;
}
var util;
(function(util2) {
util2.assertEqual = (val) => val;
function assertIs(_arg) {
}
util2.assertIs = assertIs;
function assertNever(_x) {
throw new Error();
}
util2.assertNever = assertNever;
util2.arrayToEnum = (items) => {
const obj = {};
for (const item of items) {
obj[item] = item;
}
return obj;
};
util2.getValidEnumValues = (obj) => {
const validKeys = util2.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
const filtered = {};
for (const k of validKeys) {
filtered[k] = obj[k];
}
return util2.objectValues(filtered);
};
util2.objectValues = (obj) => {
return util2.objectKeys(obj).map(function(e) {
return obj[e];
});
};
util2.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object) => {
const keys2 = [];
for (const key2 in object) {
if (Object.prototype.hasOwnProperty.call(object, key2)) {
keys2.push(key2);
}
}
return keys2;
};
util2.find = (arr, checker) => {
for (const item of arr) {
if (checker(item))
return item;
}
return void 0;
};
util2.isInteger = typeof Number.isInteger === "function" ? (val) => Number.isInteger(val) : (val) => typeof val === "number" && isFinite(val) && Math.floor(val) === val;
function joinValues(array, separator = " | ") {
return array.map((val) => typeof val === "string" ? `'${val}'` : val).join(separator);
}
util2.joinValues = joinValues;
util2.jsonStringifyReplacer = (_, value) => {
if (typeof value === "bigint") {
return value.toString();
}
return value;
};
})(util || (util = {}));
var objectUtil;
(function(objectUtil2) {
objectUtil2.mergeShapes = (first, second) => {
return {
...first,
...second
// second overwrites first
};
};
})(objectUtil || (objectUtil = {}));
const ZodParsedType = util.arrayToEnum([
"string",
"nan",
"number",
"integer",
"float",
"boolean",
"date",
"bigint",
"symbol",
"function",
"undefined",
"null",
"array",
"object",
"unknown",
"promise",
"void",
"never",
"map",
"set"
]);
const getParsedType = (data) => {
const t = typeof data;
switch (t) {
case "undefined":
return ZodParsedType.undefined;
case "string":
return ZodParsedType.string;
case "number":
return isNaN(data) ? ZodParsedType.nan : ZodParsedType.number;
case "boolean":
return ZodParsedType.boolean;
case "function":
return ZodParsedType.function;
case "bigint":
return ZodParsedType.bigint;
case "symbol":
return ZodParsedType.symbol;
case "object":
if (Array.isArray(data)) {
return ZodParsedType.array;
}
if (data === null) {
return ZodParsedType.null;
}
if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") {
return ZodParsedType.promise;
}
if (typeof Map !== "undefined" && data instanceof Map) {
return ZodParsedType.map;
}
if (typeof Set !== "undefined" && data instanceof Set) {
return ZodParsedType.set;
}
if (typeof Date !== "undefined" && data instanceof Date) {
return ZodParsedType.date;
}
return ZodParsedType.object;
default:
return ZodParsedType.unknown;
}
};
const ZodIssueCode = util.arrayToEnum([
"invalid_type",
"invalid_literal",
"custom",
"invalid_union",
"invalid_union_discriminator",
"invalid_enum_value",
"unrecognized_keys",
"invalid_arguments",
"invalid_return_type",
"invalid_date",
"invalid_string",
"too_small",
"too_big",
"invalid_intersection_types",
"not_multiple_of",
"not_finite"
]);
const quotelessJson = (obj) => {
const json = JSON.stringify(obj, null, 2);
return json.replace(/"([^"]+)":/g, "$1:");
};
class ZodError extends Error {
constructor(issues) {
super();
this.issues = [];
this.addIssue = (sub) => {
this.issues = [...this.issues, sub];
};
this.addIssues = (subs = []) => {
this.issues = [...this.issues, ...subs];
};
const actualProto = new.target.prototype;
if (Object.setPrototypeOf) {
Object.setPrototypeOf(this, actualProto);
} else {
this.__proto__ = actualProto;
}
this.name = "ZodError";
this.issues = issues;
}
get errors() {
return this.issues;
}
format(_mapper) {
const mapper = _mapper || function(issue) {
return issue.message;
};
const fieldErrors = { _errors: [] };
const processError = (error2) => {
for (const issue of error2.issues) {
if (issue.code === "invalid_union") {
issue.unionErrors.map(processError);
} else if (issue.code === "invalid_return_type") {
processError(issue.returnTypeError);
} else if (issue.code === "invalid_arguments") {
processError(issue.argumentsError);
} else if (issue.path.length === 0) {
fieldErrors._errors.push(mapper(issue));
} else {
let curr = fieldErrors;
let i = 0;
while (i < issue.path.length) {
const el = issue.path[i];
const terminal = i === issue.path.length - 1;
if (!terminal) {
curr[el] = curr[el] || { _errors: [] };
} else {
curr[el] = curr[el] || { _errors: [] };
curr[el]._errors.push(mapper(issue));
}
curr = curr[el];
i++;
}
}
}
};
processError(this);
return fieldErrors;
}
static assert(value) {
if (!(value instanceof ZodError)) {
throw new Error(`Not a ZodError: ${value}`);
}
}
toString() {
return this.message;
}
get message() {
return JSON.stringify(this.issues, util.jsonStringifyReplacer, 2);
}
get isEmpty() {
return this.issues.length === 0;
}
flatten(mapper = (issue) => issue.message) {
const fieldErrors = {};
const formErrors = [];
for (const sub of this.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 };
}
get formErrors() {
return this.flatten();
}
}
ZodError.create = (issues) => {
const error2 = new ZodError(issues);
return error2;
};
const errorMap = (issue, _ctx) => {
let message;
switch (issue.code) {
case ZodIssueCode.invalid_type:
if (issue.received === ZodParsedType.undefined) {
message = "Required";
} else {
message = `Expected ${issue.expected}, received ${issue.received}`;
}
break;
case ZodIssueCode.invalid_literal:
message = `Invalid literal value, expected ${JSON.stringify(issue.expected, util.jsonStringifyReplacer)}`;
break;
case ZodIssueCode.unrecognized_keys:
message = `Unrecognized key(s) in object: ${util.joinValues(issue.keys, ", ")}`;
break;
case ZodIssueCode.invalid_union:
message = `Invalid input`;
break;
case ZodIssueCode.invalid_union_discriminator:
message = `Invalid discriminator value. Expected ${util.joinValues(issue.options)}`;
break;
case ZodIssueCode.invalid_enum_value:
message = `Invalid enum value. Expected ${util.joinValues(issue.options)}, received '${issue.received}'`;
break;
case ZodIssueCode.invalid_arguments:
message = `Invalid function arguments`;
break;
case ZodIssueCode.invalid_return_type:
message = `Invalid function return type`;
break;
case ZodIssueCode.invalid_date:
message = `Invalid date`;
break;
case ZodIssueCode.invalid_string:
if (typeof issue.validation === "object") {
if ("includes" in issue.validation) {
message = `Invalid input: must include "${issue.validation.includes}"`;
if (typeof issue.validation.position === "number") {
message = `${message} at one or more positions greater than or equal to ${issue.validation.position}`;
}
} else if ("startsWith" in issue.validation) {
message = `Invalid input: must start with "${issue.validation.startsWith}"`;
} else if ("endsWith" in issue.validation) {
message = `Invalid input: must end with "${issue.validation.endsWith}"`;
} else {
util.assertNever(issue.validation);
}
} else if (issue.validation !== "regex") {
message = `Invalid ${issue.validation}`;
} else {
message = "Invalid";
}
break;
case ZodIssueCode.too_small:
if (issue.type === "array")
message = `Array must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `more than`} ${issue.minimum} element(s)`;
else if (issue.type === "string")
message = `String must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `over`} ${issue.minimum} character(s)`;
else if (issue.type === "number")
message = `Number must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${issue.minimum}`;
else if (issue.type === "date")
message = `Date must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${new Date(Number(issue.minimum))}`;
else
message = "Invalid input";
break;
case ZodIssueCode.too_big:
if (issue.type === "array")
message = `Array must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `less than`} ${issue.maximum} element(s)`;
else if (issue.type === "string")
message = `String must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `under`} ${issue.maximum} character(s)`;
else if (issue.type === "number")
message = `Number must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`;
else if (issue.type === "bigint")
message = `BigInt must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`;
else if (issue.type === "date")
message = `Date must be ${issue.exact ? `exactly` : issue.inclusive ? `smaller than or equal to` : `smaller than`} ${new Date(Number(issue.maximum))}`;
else
message = "Invalid input";
break;
case ZodIssueCode.custom:
message = `Invalid input`;
break;
case ZodIssueCode.invalid_intersection_types:
message = `Intersection results could not be merged`;
break;
case ZodIssueCode.not_multiple_of:
message = `Number must be a multiple of ${issue.multipleOf}`;
break;
case ZodIssueCode.not_finite:
message = "Number must be finite";
break;
default:
message = _ctx.defaultError;
util.assertNever(issue);
}
return { message };
};
let overrideErrorMap = errorMap;
function setErrorMap(map) {
overrideErrorMap = map;
}
function getErrorMap() {
return overrideErrorMap;
}
const makeIssue = (params) => {
const { data, path: path3, errorMaps, issueData } = params;
const fullPath = [...path3, ...issueData.path || []];
const fullIssue = {
...issueData,
path: fullPath
};
if (issueData.message !== void 0) {
return {
...issueData,
path: fullPath,
message: issueData.message
};
}
let errorMessage = "";
const maps = errorMaps.filter((m) => !!m).slice().reverse();
for (const map of maps) {
errorMessage = map(fullIssue, { data, defaultError: errorMessage }).message;
}
return {
...issueData,
path: fullPath,
message: errorMessage
};
};
const EMPTY_PATH = [];
function addIssueToContext(ctx, issueData) {
const overrideMap = getErrorMap();
const issue = makeIssue({
issueData,
data: ctx.data,
path: ctx.path,
errorMaps: [
ctx.common.contextualErrorMap,
ctx.schemaErrorMap,
overrideMap,
overrideMap === errorMap ? void 0 : errorMap
// then global default map
].filter((x) => !!x)
});
ctx.common.issues.push(issue);
}
class ParseStatus {
constructor() {
this.value = "valid";
}
dirty() {
if (this.value === "valid")
this.value = "dirty";
}
abort() {
if (this.value !== "aborted")
this.value = "aborted";
}
static mergeArray(status, results) {
const arrayValue = [];
for (const s2 of results) {
if (s2.status === "aborted")
return INVALID;
if (s2.status === "dirty")
status.dirty();
arrayValue.push(s2.value);
}
return { status: status.value, value: arrayValue };
}
static async mergeObjectAsync(status, pairs) {
const syncPairs = [];
for (const pair of pairs) {
const key2 = await pair.key;
const value = await pair.value;
syncPairs.push({
key: key2,
value
});
}
return ParseStatus.mergeObjectSync(status, syncPairs);
}
static mergeObjectSync(status, pairs) {
const finalObject = {};
for (const pair of pairs) {
const { key: key2, value } = pair;
if (key2.status === "aborted")
return INVALID;
if (value.status === "aborted")
return INVALID;
if (key2.status === "dirty")
status.dirty();
if (value.status === "dirty")
status.dirty();
if (key2.value !== "__proto__" && (typeof value.value !== "undefined" || pair.alwaysSet)) {
finalObject[key2.value] = value.value;
}
}
return { status: status.value, value: finalObject };
}
}
const INVALID = Object.freeze({
status: "aborted"
});
const DIRTY = (value) => ({ status: "dirty", value });
const OK = (value) => ({ status: "valid", value });
const isAborted = (x) => x.status === "aborted";
const isDirty = (x) => x.status === "dirty";
const isValid = (x) => x.status === "valid";
const isAsync = (x) => typeof Promise !== "undefined" && x instanceof Promise;
function __classPrivateFieldGet(receiver, state2, kind, f2) {
if (typeof state2 === "function" ? receiver !== state2 || !f2 : !state2.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
return state2.get(receiver);
}
function __classPrivateFieldSet(receiver, state2, value, kind, f2) {
if (typeof state2 === "function" ? receiver !== state2 || !f2 : !state2.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
return state2.set(receiver, value), value;
}
typeof SuppressedError === "function" ? SuppressedError : function(error2, suppressed, message) {
var e = new Error(message);
return e.name = "SuppressedError", e.error = error2, e.suppressed = suppressed, e;
};
var errorUtil;
(function(errorUtil2) {
errorUtil2.errToObj = (message) => typeof message === "string" ? { message } : message || {};
errorUtil2.toString = (message) => typeof message === "string" ? message : message === null || message === void 0 ? void 0 : message.message;
})(errorUtil || (errorUtil = {}));
var _ZodEnum_cache, _ZodNativeEnum_cache;
class ParseInputLazyPath {
constructor(parent, value, path3, key2) {
this._cachedPath = [];
this.parent = parent;
this.data = value;
this._path = path3;
this._key = key2;
}
get path() {
if (!this._cachedPath.length) {
if (this._key instanceof Array) {
this._cachedPath.push(...this._path, ...this._key);
} else {
this._cachedPath.push(...this._path, this._key);
}
}
return this._cachedPath;
}
}
const handleResult = (ctx, result) => {
if (isValid(result)) {
return { success: true, data: result.value };
} else {
if (!ctx.common.issues.length) {
throw new Error("Validation failed but no issues detected.");
}
return {
success: false,
get error() {
if (this._error)
return this._error;
const error2 = new ZodError(ctx.common.issues);
this._error = error2;
return this._error;
}
};
}
};
function processCreateParams(params) {
if (!params)
return {};
const { errorMap: errorMap2, invalid_type_error, required_error, description: description2 } = params;
if (errorMap2 && (invalid_type_error || required_error)) {
throw new Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`);
}
if (errorMap2)
return { errorMap: errorMap2, description: description2 };
const customMap = (iss, ctx) => {
var _a, _b;
const { message } = params;
if (iss.code === "invalid_enum_value") {
return { message: message !== null && message !== void 0 ? message : ctx.defaultError };
}
if (typeof ctx.data === "undefined") {
return { message: (_a = message !== null && message !== void 0 ? message : required_error) !== null && _a !== void 0 ? _a : ctx.defaultError };
}
if (iss.code !== "invalid_type")
return { message: ctx.defaultError };
return { message: (_b = message !== null && message !== void 0 ? message : invalid_type_error) !== null && _b !== void 0 ? _b : ctx.defaultError };
};
return { errorMap: customMap, description: description2 };
}
class ZodType {
constructor(def) {
this.spa = this.safeParseAsync;
this._def = def;
this.parse = this.parse.bind(this);
this.safeParse = this.safeParse.bind(this);
this.parseAsync = this.parseAsync.bind(this);
this.safeParseAsync = this.safeParseAsync.bind(this);
this.spa = this.spa.bind(this);
this.refine = this.refine.bind(this);
this.refinement = this.refinement.bind(this);
this.superRefine = this.superRefine.bind(this);
this.optional = this.optional.bind(this);
this.nullable = this.nullable.bind(this);
this.nullish = this.nullish.bind(this);
this.array = this.array.bind(this);
this.promise = this.promise.bind(this);
this.or = this.or.bind(this);
this.and = this.and.bind(this);
this.transform = this.transform.bind(this);
this.brand = this.brand.bind(this);
this.default = this.default.bind(this);
this.catch = this.catch.bind(this);
this.describe = this.describe.bind(this);
this.pipe = this.pipe.bind(this);
this.readonly = this.readonly.bind(this);
this.isNullable = this.isNullable.bind(this);
this.isOptional = this.isOptional.bind(this);
}
get description() {
return this._def.description;
}
_getType(input) {
return getParsedType(input.data);
}
_getOrReturnCtx(input, ctx) {
return ctx || {
common: input.parent.common,
data: input.data,
parsedType: getParsedType(input.data),
schemaErrorMap: this._def.errorMap,
path: input.path,
parent: input.parent
};
}
_processInputParams(input) {
return {
status: new ParseStatus(),
ctx: {
common: input.parent.common,
data: input.data,
parsedType: getParsedType(input.data),
schemaErrorMap: this._def.errorMap,
path: input.path,
parent: input.parent
}
};
}
_parseSync(input) {
const result = this._parse(input);
if (isAsync(result)) {
throw new Error("Synchronous parse encountered promise.");
}
return result;
}
_parseAsync(input) {
const result = this._parse(input);
return Promise.resolve(result);
}
parse(data, params) {
const result = this.safeParse(data, params);
if (result.success)
return result.data;
throw result.error;
}
safeParse(data, params) {
var _a;
const ctx = {
common: {
issues: [],
async: (_a = params === null || params === void 0 ? void 0 : params.async) !== null && _a !== void 0 ? _a : false,
contextualErrorMap: params === null || params === void 0 ? void 0 : params.errorMap
},
path: (params === null || params === void 0 ? void 0 : params.path) || [],
schemaErrorMap: this._def.errorMap,
parent: null,
data,
parsedType: getParsedType(data)
};
const result = this._parseSync({ data, path: ctx.path, parent: ctx });
return handleResult(ctx, result);
}
async parseAsync(data, params) {
const result = await this.safeParseAsync(data, params);
if (result.success)
return result.data;
throw result.error;
}
async safeParseAsync(data, params) {
const ctx = {
common: {
issues: [],
contextualErrorMap: params === null || params === void 0 ? void 0 : params.errorMap,
async: true
},
path: (params === null || params === void 0 ? void 0 : params.path) || [],
schemaErrorMap: this._def.errorMap,
parent: null,
data,
parsedType: getParsedType(data)
};
const maybeAsyncResult = this._parse({ data, path: ctx.path, parent: ctx });
const result = await (isAsync(maybeAsyncResult) ? maybeAsyncResult : Promise.resolve(maybeAsyncResult));
return handleResult(ctx, result);
}
refine(check, message) {
const getIssueProperties = (val) => {
if (typeof message === "string" || typeof message === "undefined") {
return { message };
} else if (typeof message === "function") {
return message(val);
} else {
return message;
}
};
return this._refinement((val, ctx) => {
const result = check(val);
const setError = () => ctx.addIssue({
code: ZodIssueCode.custom,
...getIssueProperties(val)
});
if (typeof Promise !== "undefined" && result instanceof Promise) {
return result.then((data) => {
if (!data) {
setError();
return false;
} else {
return true;
}
});
}
if (!result) {
setError();
return false;
} else {
return true;
}
});
}
refinement(check, refinementData) {
return this._refinement((val, ctx) => {
if (!check(val)) {
ctx.addIssue(typeof refinementData === "function" ? refinementData(val, ctx) : refinementData);
return false;
} else {
return true;
}
});
}
_refinement(refinement) {
return new ZodEffects({
schema: this,
typeName: ZodFirstPartyTypeKind.ZodEffects,
effect: { type: "refinement", refinement }
});
}
superRefine(refinement) {
return this._refinement(refinement);
}
optional() {
return ZodOptional.create(this, this._def);
}
nullable() {
return ZodNullable.create(this, this._def);
}
nullish() {
return this.nullable().optional();
}
array() {
return ZodArray.create(this, this._def);
}
promise() {
return ZodPromise.create(this, this._def);
}
or(option) {
return ZodUnion.create([this, option], this._def);
}
and(incoming) {
return ZodIntersection.create(this, incoming, this._def);
}
transform(transform) {
return new ZodEffects({
...processCreateParams(this._def),
schema: this,
typeName: ZodFirstPartyTypeKind.ZodEffects,
effect: { type: "transform", transform }
});
}
default(def) {
const defaultValueFunc = typeof def === "function" ? def : () => def;
return new ZodDefault({
...processCreateParams(this._def),
innerType: this,
defaultValue: defaultValueFunc,
typeName: ZodFirstPartyTypeKind.ZodDefault
});
}
brand() {
return new ZodBranded({
typeName: ZodFirstPartyTypeKind.ZodBranded,
type: this,
...processCreateParams(this._def)
});
}
catch(def) {
const catchValueFunc = typeof def === "function" ? def : () => def;
return new ZodCatch({
...processCreateParams(this._def),
innerType: this,
catchValue: catchValueFunc,
typeName: ZodFirstPartyTypeKind.ZodCatch
});
}
describe(description2) {
const This = this.constructor;
return new This({
...this._def,
description: description2
});
}
pipe(target) {
return ZodPipeline.create(this, target);
}
readonly() {
return ZodReadonly.create(this);
}
isOptional() {
return this.safeParse(void 0).success;
}
isNullable() {
return this.safeParse(null).success;
}
}
const cuidRegex = /^c[^\s-]{8,}$/i;
const cuid2Regex = /^[0-9a-z]+$/;
const ulidRegex = /^[0-9A-HJKMNP-TV-Z]{26}$/;
const uuidRegex = /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/i;
const nanoidRegex = /^[a-z0-9_-]{21}$/i;
const durationRegex = /^[-+]?P(?!$)(?:(?:[-+]?\d+Y)|(?:[-+]?\d+[.,]\d+Y$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:(?:[-+]?\d+W)|(?:[-+]?\d+[.,]\d+W$))?(?:(?:[-+]?\d+D)|(?:[-+]?\d+[.,]\d+D$))?(?:T(?=[\d+-])(?:(?:[-+]?\d+H)|(?:[-+]?\d+[.,]\d+H$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:[-+]?\d+(?:[.,]\d+)?S)?)??$/;
const emailRegex = /^(?!\.)(?!.*\.\.)([A-Z0-9_'+\-\.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z0-9\-]*\.)+[A-Z]{2,}$/i;
const _emojiRegex = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
let emojiRegex;
const ipv4Regex = /^(?:(?: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 ipv6Regex = /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/;
const base64Regex = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/;
const dateRegexSource = `((\\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 dateRegex = new RegExp(`^${dateRegexSource}$`);
function timeRegexSource(args) {
let regex = `([01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d`;
if (args.precision) {
regex = `${regex}\\.\\d{${args.precision}}`;
} else if (args.precision == null) {
regex = `${regex}(\\.\\d+)?`;
}
return regex;
}
function timeRegex(args) {
return new RegExp(`^${timeRegexSource(args)}$`);
}
function datetimeRegex(args) {
let regex = `${dateRegexSource}T${timeRegexSource(args)}`;
const opts = [];
opts.push(args.local ? `Z?` : `Z`);
if (args.offset)
opts.push(`([+-]\\d{2}:?\\d{2})`);
regex = `${regex}(${opts.join("|")})`;
return new RegExp(`^${regex}$`);
}
function isValidIP(ip2, version2) {
if ((version2 === "v4" || !version2) && ipv4Regex.test(ip2)) {
return true;
}
if ((version2 === "v6" || !version2) && ipv6Regex.test(ip2)) {
return true;
}
return false;
}
class ZodString extends ZodType {
_parse(input) {
if (this._def.coerce) {
input.data = String(input.data);
}
const parsedType = this._getType(input);
if (parsedType !== ZodParsedType.string) {
const ctx2 = this._getOrReturnCtx(input);
addIssueToContext(ctx2, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.string,
received: ctx2.parsedType
});
return INVALID;
}
const status = new ParseStatus();
let ctx = void 0;
for (const check of this._def.checks) {
if (check.kind === "min") {
if (input.data.length < check.value) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.too_small,
minimum: check.value,
type: "string",
inclusive: true,
exact: false,
message: check.message
});
status.dirty();
}
} else if (check.kind === "max") {
if (input.data.length > check.value) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.too_big,
maximum: check.value,
type: "string",
inclusive: true,
exact: false,
message: check.message
});
status.dirty();
}
} else if (check.kind === "length") {
const tooBig = input.data.length > check.value;
const tooSmall = input.data.length < check.value;
if (tooBig || tooSmall) {
ctx = this._getOrReturnCtx(input, ctx);
if (tooBig) {
addIssueToContext(ctx, {
code: ZodIssueCode.too_big,
maximum: check.value,
type: "string",
inclusive: true,
exact: true,
message: check.message
});
} else if (tooSmall) {
addIssueToContext(ctx, {
code: ZodIssueCode.too_small,
minimum: check.value,
type: "string",
inclusive: true,
exact: true,
message: check.message
});
}
status.dirty();
}
} else if (check.kind === "email") {
if (!emailRegex.test(input.data)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
validation: "email",
code: ZodIssueCode.invalid_string,
message: check.message
});
status.dirty();
}
} else if (check.kind === "emoji") {
if (!emojiRegex) {
emojiRegex = new RegExp(_emojiRegex, "u");
}
if (!emojiRegex.test(input.data)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
validation: "emoji",
code: ZodIssueCode.invalid_string,
message: check.message
});
status.dirty();
}
} else if (check.kind === "uuid") {
if (!uuidRegex.test(input.data)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
validation: "uuid",
code: ZodIssueCode.invalid_string,
message: check.message
});
status.dirty();
}
} else if (check.kind === "nanoid") {
if (!nanoidRegex.test(input.data)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
validation: "nanoid",
code: ZodIssueCode.invalid_string,
message: check.message
});
status.dirty();
}
} else if (check.kind === "cuid") {
if (!cuidRegex.test(input.data)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
validation: "cuid",
code: ZodIssueCode.invalid_string,
message: check.message
});
status.dirty();
}
} else if (check.kind === "cuid2") {
if (!cuid2Regex.test(input.data)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
validation: "cuid2",
code: ZodIssueCode.invalid_string,
message: check.message
});
status.dirty();
}
} else if (check.kind === "ulid") {
if (!ulidRegex.test(input.data)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
validation: "ulid",
code: ZodIssueCode.invalid_string,
message: check.message
});
status.dirty();
}
} else if (check.kind === "url") {
try {
new URL(input.data);
} catch (_a) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
validation: "url",
code: ZodIssueCode.invalid_string,
message: check.message
});
status.dirty();
}
} else if (check.kind === "regex") {
check.regex.lastIndex = 0;
const testResult = check.regex.test(input.data);
if (!testResult) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
validation: "regex",
code: ZodIssueCode.invalid_string,
message: check.message
});
status.dirty();
}
} else if (check.kind === "trim") {
input.data = input.data.trim();
} else if (check.kind === "includes") {
if (!input.data.includes(check.value, check.position)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_string,
validation: { includes: check.value, position: check.position },
message: check.message
});
status.dirty();
}
} else if (check.kind === "toLowerCase") {
input.data = input.data.toLowerCase();
} else if (check.kind === "toUpperCase") {
input.data = input.data.toUpperCase();
} else if (check.kind === "startsWith") {
if (!input.data.startsWith(check.value)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_string,
validation: { startsWith: check.value },
message: check.message
});
status.dirty();
}
} else if (check.kind === "endsWith") {
if (!input.data.endsWith(check.value)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_string,
validation: { endsWith: check.value },
message: check.message
});
status.dirty();
}
} else if (check.kind === "datetime") {
const regex = datetimeRegex(check);
if (!regex.test(input.data)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_string,
validation: "datetime",
message: check.message
});
status.dirty();
}
} else if (check.kind === "date") {
const regex = dateRegex;
if (!regex.test(input.data)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_string,
validation: "date",
message: check.message
});
status.dirty();
}
} else if (check.kind === "time") {
const regex = timeRegex(check);
if (!regex.test(input.data)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_string,
validation: "time",
message: check.message
});
status.dirty();
}
} else if (check.kind === "duration") {
if (!durationRegex.test(input.data)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
validation: "duration",
code: ZodIssueCode.invalid_string,
message: check.message
});
status.dirty();
}
} else if (check.kind === "ip") {
if (!isValidIP(input.data, check.version)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
validation: "ip",
code: ZodIssueCode.invalid_string,
message: check.message
});
status.dirty();
}
} else if (check.kind === "base64") {
if (!base64Regex.test(input.data)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
validation: "base64",
code: ZodIssueCode.invalid_string,
message: check.message
});
status.dirty();
}
} else {
util.assertNever(check);
}
}
return { status: status.value, value: input.data };
}
_regex(regex, validation, message) {
return this.refinement((data) => regex.test(data), {
validation,
code: ZodIssueCode.invalid_string,
...errorUtil.errToObj(message)
});
}
_addCheck(check) {
return new ZodString({
...this._def,
checks: [...this._def.checks, check]
});
}
email(message) {
return this._addCheck({ kind: "email", ...errorUtil.errToObj(message) });
}
url(message) {
return this._addCheck({ kind: "url", ...errorUtil.errToObj(message) });
}
emoji(message) {
return this._addCheck({ kind: "emoji", ...errorUtil.errToObj(message) });
}
uuid(message) {
return this._addCheck({ kind: "uuid", ...errorUtil.errToObj(message) });
}
nanoid(message) {
return this._addCheck({ kind: "nanoid", ...errorUtil.errToObj(message) });
}
cuid(message) {
return this._addCheck({ kind: "cuid", ...errorUtil.errToObj(message) });
}
cuid2(message) {
return this._addCheck({ kind: "cuid2", ...errorUtil.errToObj(message) });
}
ulid(message) {
return this._addCheck({ kind: "ulid", ...errorUtil.errToObj(message) });
}
base64(message) {
return this._addCheck({ kind: "base64", ...errorUtil.errToObj(message) });
}
ip(options2) {
return this._addCheck({ kind: "ip", ...errorUtil.errToObj(options2) });
}
datetime(options2) {
var _a, _b;
if (typeof options2 === "string") {
return this._addCheck({
kind: "datetime",
precision: null,
offset: false,
local: false,
message: options2
});
}
return this._addCheck({
kind: "datetime",
precision: typeof (options2 === null || options2 === void 0 ? void 0 : options2.precision) === "undefined" ? null : options2 === null || options2 === void 0 ? void 0 : options2.precision,
offset: (_a = options2 === null || options2 === void 0 ? void 0 : options2.offset) !== null && _a !== void 0 ? _a : false,
local: (_b = options2 === null || options2 === void 0 ? void 0 : options2.local) !== null && _b !== void 0 ? _b : false,
...errorUtil.errToObj(options2 === null || options2 === void 0 ? void 0 : options2.message)
});
}
date(message) {
return this._addCheck({ kind: "date", message });
}
time(options2) {
if (typeof options2 === "string") {
return this._addCheck({
kind: "time",
precision: null,
message: options2
});
}
return this._addCheck({
kind: "time",
precision: typeof (options2 === null || options2 === void 0 ? void 0 : options2.precision) === "undefined" ? null : options2 === null || options2 === void 0 ? void 0 : options2.precision,
...errorUtil.errToObj(options2 === null || options2 === void 0 ? void 0 : options2.message)
});
}
duration(message) {
return this._addCheck({ kind: "duration", ...errorUtil.errToObj(message) });
}
regex(regex, message) {
return this._addCheck({
kind: "regex",
regex,
...errorUtil.errToObj(message)
});
}
includes(value, options2) {
return this._addCheck({
kind: "includes",
value,
position: options2 === null || options2 === void 0 ? void 0 : options2.position,
...errorUtil.errToObj(options2 === null || options2 === void 0 ? void 0 : options2.message)
});
}
startsWith(value, message) {
return this._addCheck({
kind: "startsWith",
value,
...errorUtil.errToObj(message)
});
}
endsWith(value, message) {
return this._addCheck({
kind: "endsWith",
value,
...errorUtil.errToObj(message)
});
}
min(minLength, message) {
return this._addCheck({
kind: "min",
value: minLength,
...errorUtil.errToObj(message)
});
}
max(maxLength, message) {
return this._addCheck({
kind: "max",
value: maxLength,
...errorUtil.errToObj(message)
});
}
length(len, message) {
return this._addCheck({
kind: "length",
value: len,
...errorUtil.errToObj(message)
});
}
/**
* @deprecated Use z.string().min(1) instead.
* @see {@link ZodString.min}
*/
nonempty(message) {
return this.min(1, errorUtil.errToObj(message));
}
trim() {
return new ZodString({
...this._def,
checks: [...this._def.checks, { kind: "trim" }]
});
}
toLowerCase() {
return new ZodString({
...this._def,
checks: [...this._def.checks, { kind: "toLowerCase" }]
});
}
toUpperCase() {
return new ZodString({
...this._def,
checks: [...this._def.checks, { kind: "toUpperCase" }]
});
}
get isDatetime() {
return !!this._def.checks.find((ch2) => ch2.kind === "datetime");
}
get isDate() {
return !!this._def.checks.find((ch2) => ch2.kind === "date");
}
get isTime() {
return !!this._def.checks.find((ch2) => ch2.kind === "time");
}
get isDuration() {
return !!this._def.checks.find((ch2) => ch2.kind === "duration");
}
get isEmail() {
return !!this._def.checks.find((ch2) => ch2.kind === "email");
}
get isURL() {
return !!this._def.checks.find((ch2) => ch2.kind === "url");
}
get isEmoji() {
return !!this._def.checks.find((ch2) => ch2.kind === "emoji");
}
get isUUID() {
return !!this._def.checks.find((ch2) => ch2.kind === "uuid");
}
get isNANOID() {
return !!this._def.checks.find((ch2) => ch2.kind === "nanoid");
}
get isCUID() {
return !!this._def.checks.find((ch2) => ch2.kind === "cuid");
}
get isCUID2() {
return !!this._def.checks.find((ch2) => ch2.kind === "cuid2");
}
get isULID() {
return !!this._def.checks.find((ch2) => ch2.kind === "ulid");
}
get isIP() {
return !!this._def.checks.find((ch2) => ch2.kind === "ip");
}
get isBase64() {
return !!this._def.checks.find((ch2) => ch2.kind === "base64");
}
get minLength() {
let min = null;
for (const ch2 of this._def.checks) {
if (ch2.kind === "min") {
if (min === null || ch2.value > min)
min = ch2.value;
}
}
return min;
}
get maxLength() {
let max2 = null;
for (const ch2 of this._def.checks) {
if (ch2.kind === "max") {
if (max2 === null || ch2.value < max2)
max2 = ch2.value;
}
}
return max2;
}
}
ZodString.create = (params) => {
var _a;
return new ZodString({
checks: [],
typeName: ZodFirstPartyTypeKind.ZodString,
coerce: (_a = params === null || params === void 0 ? void 0 : params.coerce) !== null && _a !== void 0 ? _a : false,
...processCreateParams(params)
});
};
function floatSafeRemainder(val, step) {
const valDecCount = (val.toString().split(".")[1] || "").length;
const stepDecCount = (step.toString().split(".")[1] || "").length;
const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
const valInt = parseInt(val.toFixed(decCount).replace(".", ""));
const stepInt = parseInt(step.toFixed(decCount).replace(".", ""));
return valInt % stepInt / Math.pow(10, decCount);
}
class ZodNumber extends ZodType {
constructor() {
super(...arguments);
this.min = this.gte;
this.max = this.lte;
this.step = this.multipleOf;
}
_parse(input) {
if (this._def.coerce) {
input.data = Number(input.data);
}
const parsedType = this._getType(input);
if (parsedType !== ZodParsedType.number) {
const ctx2 = this._getOrReturnCtx(input);
addIssueToContext(ctx2, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.number,
received: ctx2.parsedType
});
return INVALID;
}
let ctx = void 0;
const status = new ParseStatus();
for (const check of this._def.checks) {
if (check.kind === "int") {
if (!util.isInteger(input.data)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: "integer",
received: "float",
message: check.message
});
status.dirty();
}
} else if (check.kind === "min") {
const tooSmall = check.inclusive ? input.data < check.value : input.data <= check.value;
if (tooSmall) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.too_small,
minimum: check.value,
type: "number",
inclusive: check.inclusive,
exact: false,
message: check.message
});
status.dirty();
}
} else if (check.kind === "max") {
const tooBig = check.inclusive ? input.data > check.value : input.data >= check.value;
if (tooBig) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.too_big,
maximum: check.value,
type: "number",
inclusive: check.inclusive,
exact: false,
message: check.message
});
status.dirty();
}
} else if (check.kind === "multipleOf") {
if (floatSafeRemainder(input.data, check.value) !== 0) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.not_multiple_of,
multipleOf: check.value,
message: check.message
});
status.dirty();
}
} else if (check.kind === "finite") {
if (!Number.isFinite(input.data)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.not_finite,
message: check.message
});
status.dirty();
}
} else {
util.assertNever(check);
}
}
return { status: status.value, value: input.data };
}
gte(value, message) {
return this.setLimit("min", value, true, errorUtil.toString(message));
}
gt(value, message) {
return this.setLimit("min", value, false, errorUtil.toString(message));
}
lte(value, message) {
return this.setLimit("max", value, true, errorUtil.toString(message));
}
lt(value, message) {
return this.setLimit("max", value, false, errorUtil.toString(message));
}
setLimit(kind, value, inclusive, message) {
return new ZodNumber({
...this._def,
checks: [
...this._def.checks,
{
kind,
value,
inclusive,
message: errorUtil.toString(message)
}
]
});
}
_addCheck(check) {
return new ZodNumber({
...this._def,
checks: [...this._def.checks, check]
});
}
int(message) {
return this._addCheck({
kind: "int",
message: errorUtil.toString(message)
});
}
positive(message) {
return this._addCheck({
kind: "min",
value: 0,
inclusive: false,
message: errorUtil.toString(message)
});
}
negative(message) {
return this._addCheck({
kind: "max",
value: 0,
inclusive: false,
message: errorUtil.toString(message)
});
}
nonpositive(message) {
return this._addCheck({
kind: "max",
value: 0,
inclusive: true,
message: errorUtil.toString(message)
});
}
nonnegative(message) {
return this._addCheck({
kind: "min",
value: 0,
inclusive: true,
message: errorUtil.toString(message)
});
}
multipleOf(value, message) {
return this._addCheck({
kind: "multipleOf",
value,
message: errorUtil.toString(message)
});
}
finite(message) {
return this._addCheck({
kind: "finite",
message: errorUtil.toString(message)
});
}
safe(message) {
return this._addCheck({
kind: "min",
inclusive: true,
value: Number.MIN_SAFE_INTEGER,
message: errorUtil.toString(message)
})._addCheck({
kind: "max",
inclusive: true,
value: Number.MAX_SAFE_INTEGER,
message: errorUtil.toString(message)
});
}
get minValue() {
let min = null;
for (const ch2 of this._def.checks) {
if (ch2.kind === "min") {
if (min === null || ch2.value > min)
min = ch2.value;
}
}
return min;
}
get maxValue() {
let max2 = null;
for (const ch2 of this._def.checks) {
if (ch2.kind === "max") {
if (max2 === null || ch2.value < max2)
max2 = ch2.value;
}
}
return max2;
}
get isInt() {
return !!this._def.checks.find((ch2) => ch2.kind === "int" || ch2.kind === "multipleOf" && util.isInteger(ch2.value));
}
get isFinite() {
let max2 = null, min = null;
for (const ch2 of this._def.checks) {
if (ch2.kind === "finite" || ch2.kind === "int" || ch2.kind === "multipleOf") {
return true;
} else if (ch2.kind === "min") {
if (min === null || ch2.value > min)
min = ch2.value;
} else if (ch2.kind === "max") {
if (max2 === null || ch2.value < max2)
max2 = ch2.value;
}
}
return Number.isFinite(min) && Number.isFinite(max2);
}
}
ZodNumber.create = (params) => {
return new ZodNumber({
checks: [],
typeName: ZodFirstPartyTypeKind.ZodNumber,
coerce: (params === null || params === void 0 ? void 0 : params.coerce) || false,
...processCreateParams(params)
});
};
class ZodBigInt extends ZodType {
constructor() {
super(...arguments);
this.min = this.gte;
this.max = this.lte;
}
_parse(input) {
if (this._def.coerce) {
input.data = BigInt(input.data);
}
const parsedType = this._getType(input);
if (parsedType !== ZodParsedType.bigint) {
const ctx2 = this._getOrReturnCtx(input);
addIssueToContext(ctx2, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.bigint,
received: ctx2.parsedType
});
return INVALID;
}
let ctx = void 0;
const status = new ParseStatus();
for (const check of this._def.checks) {
if (check.kind === "min") {
const tooSmall = check.inclusive ? input.data < check.value : input.data <= check.value;
if (tooSmall) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.too_small,
type: "bigint",
minimum: check.value,
inclusive: check.inclusive,
message: check.message
});
status.dirty();
}
} else if (check.kind === "max") {
const tooBig = check.inclusive ? input.data > check.value : input.data >= check.value;
if (tooBig) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.too_big,
type: "bigint",
maximum: check.value,
inclusive: check.inclusive,
message: check.message
});
status.dirty();
}
} else if (check.kind === "multipleOf") {
if (input.data % check.value !== BigInt(0)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.not_multiple_of,
multipleOf: check.value,
message: check.message
});
status.dirty();
}
} else {
util.assertNever(check);
}
}
return { status: status.value, value: input.data };
}
gte(value, message) {
return this.setLimit("min", value, true, errorUtil.toString(message));
}
gt(value, message) {
return this.setLimit("min", value, false, errorUtil.toString(message));
}
lte(value, message) {
return this.setLimit("max", value, true, errorUtil.toString(message));
}
lt(value, message) {
return this.setLimit("max", value, false, errorUtil.toString(message));
}
setLimit(kind, value, inclusive, message) {
return new ZodBigInt({
...this._def,
checks: [
...this._def.checks,
{
kind,
value,
inclusive,
message: errorUtil.toString(message)
}
]
});
}
_addCheck(check) {
return new ZodBigInt({
...this._def,
checks: [...this._def.checks, check]
});
}
positive(message) {
return this._addCheck({
kind: "min",
value: BigInt(0),
inclusive: false,
message: errorUtil.toString(message)
});
}
negative(message) {
return this._addCheck({
kind: "max",
value: BigInt(0),
inclusive: false,
message: errorUtil.toString(message)
});
}
nonpositive(message) {
return this._addCheck({
kind: "max",
value: BigInt(0),
inclusive: true,
message: errorUtil.toString(message)
});
}
nonnegative(message) {
return this._addCheck({
kind: "min",
value: BigInt(0),
inclusive: true,
message: errorUtil.toString(message)
});
}
multipleOf(value, message) {
return this._addCheck({
kind: "multipleOf",
value,
message: errorUtil.toString(message)
});
}
get minValue() {
let min = null;
for (const ch2 of this._def.checks) {
if (ch2.kind === "min") {
if (min === null || ch2.value > min)
min = ch2.value;
}
}
return min;
}
get maxValue() {
let max2 = null;
for (const ch2 of this._def.checks) {
if (ch2.kind === "max") {
if (max2 === null || ch2.value < max2)
max2 = ch2.value;
}
}
return max2;
}
}
ZodBigInt.create = (params) => {
var _a;
return new ZodBigInt({
checks: [],
typeName: ZodFirstPartyTypeKind.ZodBigInt,
coerce: (_a = params === null || params === void 0 ? void 0 : params.coerce) !== null && _a !== void 0 ? _a : false,
...processCreateParams(params)
});
};
class ZodBoolean extends ZodType {
_parse(input) {
if (this._def.coerce) {
input.data = Boolean(input.data);
}
const parsedType = this._getType(input);
if (parsedType !== ZodParsedType.boolean) {
const ctx = this._getOrReturnCtx(input);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.boolean,
received: ctx.parsedType
});
return INVALID;
}
return OK(input.data);
}
}
ZodBoolean.create = (params) => {
return new ZodBoolean({
typeName: ZodFirstPartyTypeKind.ZodBoolean,
coerce: (params === null || params === void 0 ? void 0 : params.coerce) || false,
...processCreateParams(params)
});
};
class ZodDate extends ZodType {
_parse(input) {
if (this._def.coerce) {
input.data = new Date(input.data);
}
const parsedType = this._getType(input);
if (parsedType !== ZodParsedType.date) {
const ctx2 = this._getOrReturnCtx(input);
addIssueToContext(ctx2, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.date,
received: ctx2.parsedType
});
return INVALID;
}
if (isNaN(input.data.getTime())) {
const ctx2 = this._getOrReturnCtx(input);
addIssueToContext(ctx2, {
code: ZodIssueCode.invalid_date
});
return INVALID;
}
const status = new ParseStatus();
let ctx = void 0;
for (const check of this._def.checks) {
if (check.kind === "min") {
if (input.data.getTime() < check.value) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.too_small,
message: check.message,
inclusive: true,
exact: false,
minimum: check.value,
type: "date"
});
status.dirty();
}
} else if (check.kind === "max") {
if (input.data.getTime() > check.value) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.too_big,
message: check.message,
inclusive: true,
exact: false,
maximum: check.value,
type: "date"
});
status.dirty();
}
} else {
util.assertNever(check);
}
}
return {
status: status.value,
value: new Date(input.data.getTime())
};
}
_addCheck(check) {
return new ZodDate({
...this._def,
checks: [...this._def.checks, check]
});
}
min(minDate, message) {
return this._addCheck({
kind: "min",
value: minDate.getTime(),
message: errorUtil.toString(message)
});
}
max(maxDate, message) {
return this._addCheck({
kind: "max",
value: maxDate.getTime(),
message: errorUtil.toString(message)
});
}
get minDate() {
let min = null;
for (const ch2 of this._def.checks) {
if (ch2.kind === "min") {
if (min === null || ch2.value > min)
min = ch2.value;
}
}
return min != null ? new Date(min) : null;
}
get maxDate() {
let max2 = null;
for (const ch2 of this._def.checks) {
if (ch2.kind === "max") {
if (max2 === null || ch2.value < max2)
max2 = ch2.value;
}
}
return max2 != null ? new Date(max2) : null;
}
}
ZodDate.create = (params) => {
return new ZodDate({
checks: [],
coerce: (params === null || params === void 0 ? void 0 : params.coerce) || false,
typeName: ZodFirstPartyTypeKind.ZodDate,
...processCreateParams(params)
});
};
class ZodSymbol extends ZodType {
_parse(input) {
const parsedType = this._getType(input);
if (parsedType !== ZodParsedType.symbol) {
const ctx = this._getOrReturnCtx(input);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.symbol,
received: ctx.parsedType
});
return INVALID;
}
return OK(input.data);
}
}
ZodSymbol.create = (params) => {
return new ZodSymbol({
typeName: ZodFirstPartyTypeKind.ZodSymbol,
...processCreateParams(params)
});
};
class ZodUndefined extends ZodType {
_parse(input) {
const parsedType = this._getType(input);
if (parsedType !== ZodParsedType.undefined) {
const ctx = this._getOrReturnCtx(input);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.undefined,
received: ctx.parsedType
});
return INVALID;
}
return OK(input.data);
}
}
ZodUndefined.create = (params) => {
return new ZodUndefined({
typeName: ZodFirstPartyTypeKind.ZodUndefined,
...processCreateParams(params)
});
};
class ZodNull extends ZodType {
_parse(input) {
const parsedType = this._getType(input);
if (parsedType !== ZodParsedType.null) {
const ctx = this._getOrReturnCtx(input);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.null,
received: ctx.parsedType
});
return INVALID;
}
return OK(input.data);
}
}
ZodNull.create = (params) => {
return new ZodNull({
typeName: ZodFirstPartyTypeKind.ZodNull,
...processCreateParams(params)
});
};
class ZodAny extends ZodType {
constructor() {
super(...arguments);
this._any = true;
}
_parse(input) {
return OK(input.data);
}
}
ZodAny.create = (params) => {
return new ZodAny({
typeName: ZodFirstPartyTypeKind.ZodAny,
...processCreateParams(params)
});
};
class ZodUnknown extends ZodType {
constructor() {
super(...arguments);
this._unknown = true;
}
_parse(input) {
return OK(input.data);
}
}
ZodUnknown.create = (params) => {
return new ZodUnknown({
typeName: ZodFirstPartyTypeKind.ZodUnknown,
...processCreateParams(params)
});
};
class ZodNever extends ZodType {
_parse(input) {
const ctx = this._getOrReturnCtx(input);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.never,
received: ctx.parsedType
});
return INVALID;
}
}
ZodNever.create = (params) => {
return new ZodNever({
typeName: ZodFirstPartyTypeKind.ZodNever,
...processCreateParams(params)
});
};
class ZodVoid extends ZodType {
_parse(input) {
const parsedType = this._getType(input);
if (parsedType !== ZodParsedType.undefined) {
const ctx = this._getOrReturnCtx(input);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.void,
received: ctx.parsedType
});
return INVALID;
}
return OK(input.data);
}
}
ZodVoid.create = (params) => {
return new ZodVoid({
typeName: ZodFirstPartyTypeKind.ZodVoid,
...processCreateParams(params)
});
};
class ZodArray extends ZodType {
_parse(input) {
const { ctx, status } = this._processInputParams(input);
const def = this._def;
if (ctx.parsedType !== ZodParsedType.array) {
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.array,
received: ctx.parsedType
});
return INVALID;
}
if (def.exactLength !== null) {
const tooBig = ctx.data.length > def.exactLength.value;
const tooSmall = ctx.data.length < def.exactLength.value;
if (tooBig || tooSmall) {
addIssueToContext(ctx, {
code: tooBig ? ZodIssueCode.too_big : ZodIssueCode.too_small,
minimum: tooSmall ? def.exactLength.value : void 0,
maximum: tooBig ? def.exactLength.value : void 0,
type: "array",
inclusive: true,
exact: true,
message: def.exactLength.message
});
status.dirty();
}
}
if (def.minLength !== null) {
if (ctx.data.length < def.minLength.value) {
addIssueToContext(ctx, {
code: ZodIssueCode.too_small,
minimum: def.minLength.value,
type: "array",
inclusive: true,
exact: false,
message: def.minLength.message
});
status.dirty();
}
}
if (def.maxLength !== null) {
if (ctx.data.length > def.maxLength.value) {
addIssueToContext(ctx, {
code: ZodIssueCode.too_big,
maximum: def.maxLength.value,
type: "array",
inclusive: true,
exact: false,
message: def.maxLength.message
});
status.dirty();
}
}
if (ctx.common.async) {
return Promise.all([...ctx.data].map((item, i) => {
return def.type._parseAsync(new ParseInputLazyPath(ctx, item, ctx.path, i));
})).then((result2) => {
return ParseStatus.mergeArray(status, result2);
});
}
const result = [...ctx.data].map((item, i) => {
return def.type._parseSync(new ParseInputLazyPath(ctx, item, ctx.path, i));
});
return ParseStatus.mergeArray(status, result);
}
get element() {
return this._def.type;
}
min(minLength, message) {
return new ZodArray({
...this._def,
minLength: { value: minLength, message: errorUtil.toString(message) }
});
}
max(maxLength, message) {
return new ZodArray({
...this._def,
maxLength: { value: maxLength, message: errorUtil.toString(message) }
});
}
length(len, message) {
return new ZodArray({
...this._def,
exactLength: { value: len, message: errorUtil.toString(message) }
});
}
nonempty(message) {
return this.min(1, message);
}
}
ZodArray.create = (schema, params) => {
return new ZodArray({
type: schema,
minLength: null,
maxLength: null,
exactLength: null,
typeName: ZodFirstPartyTypeKind.ZodArray,
...processCreateParams(params)
});
};
function deepPartialify(schema) {
if (schema instanceof ZodObject) {
const newShape = {};
for (const key2 in schema.shape) {
const fieldSchema = schema.shape[key2];
newShape[key2] = ZodOptional.create(deepPartialify(fieldSchema));
}
return new ZodObject({
...schema._def,
shape: () => newShape
});
} else if (schema instanceof ZodArray) {
return new ZodArray({
...schema._def,
type: deepPartialify(schema.element)
});
} else if (schema instanceof ZodOptional) {
return ZodOptional.create(deepPartialify(schema.unwrap()));
} else if (schema instanceof ZodNullable) {
return ZodNullable.create(deepPartialify(schema.unwrap()));
} else if (schema instanceof ZodTuple) {
return ZodTuple.create(schema.items.map((item) => deepPartialify(item)));
} else {
return schema;
}
}
class ZodObject extends ZodType {
constructor() {
super(...arguments);
this._cached = null;
this.nonstrict = this.passthrough;
this.augment = this.extend;
}
_getCached() {
if (this._cached !== null)
return this._cached;
const shape = this._def.shape();
const keys2 = util.objectKeys(shape);
return this._cached = { shape, keys: keys2 };
}
_parse(input) {
const parsedType = this._getType(input);
if (parsedType !== ZodParsedType.object) {
const ctx2 = this._getOrReturnCtx(input);
addIssueToContext(ctx2, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.object,
received: ctx2.parsedType
});
return INVALID;
}
const { status, ctx } = this._processInputParams(input);
const { shape, keys: shapeKeys } = this._getCached();
const extraKeys = [];
if (!(this._def.catchall instanceof ZodNever && this._def.unknownKeys === "strip")) {
for (const key2 in ctx.data) {
if (!shapeKeys.includes(key2)) {
extraKeys.push(key2);
}
}
}
const pairs = [];
for (const key2 of shapeKeys) {
const keyValidator = shape[key2];
const value = ctx.data[key2];
pairs.push({
key: { status: "valid", value: key2 },
value: keyValidator._parse(new ParseInputLazyPath(ctx, value, ctx.path, key2)),
alwaysSet: key2 in ctx.data
});
}
if (this._def.catchall instanceof ZodNever) {
const unknownKeys = this._def.unknownKeys;
if (unknownKeys === "passthrough") {
for (const key2 of extraKeys) {
pairs.push({
key: { status: "valid", value: key2 },
value: { status: "valid", value: ctx.data[key2] }
});
}
} else if (unknownKeys === "strict") {
if (extraKeys.length > 0) {
addIssueToContext(ctx, {
code: ZodIssueCode.unrecognized_keys,
keys: extraKeys
});
status.dirty();
}
} else if (unknownKeys === "strip") ;
else {
throw new Error(`Internal ZodObject error: invalid unknownKeys value.`);
}
} else {
const catchall = this._def.catchall;
for (const key2 of extraKeys) {
const value = ctx.data[key2];
pairs.push({
key: { status: "valid", value: key2 },
value: catchall._parse(
new ParseInputLazyPath(ctx, value, ctx.path, key2)
//, ctx.child(key), value, getParsedType(value)
),
alwaysSet: key2 in ctx.data
});
}
}
if (ctx.common.async) {
return Promise.resolve().then(async () => {
const syncPairs = [];
for (const pair of pairs) {
const key2 = await pair.key;
const value = await pair.value;
syncPairs.push({
key: key2,
value,
alwaysSet: pair.alwaysSet
});
}
return syncPairs;
}).then((syncPairs) => {
return ParseStatus.mergeObjectSync(status, syncPairs);
});
} else {
return ParseStatus.mergeObjectSync(status, pairs);
}
}
get shape() {
return this._def.shape();
}
strict(message) {
errorUtil.errToObj;
return new ZodObject({
...this._def,
unknownKeys: "strict",
...message !== void 0 ? {
errorMap: (issue, ctx) => {
var _a, _b, _c, _d;
const defaultError = (_c = (_b = (_a = this._def).errorMap) === null || _b === void 0 ? void 0 : _b.call(_a, issue, ctx).message) !== null && _c !== void 0 ? _c : ctx.defaultError;
if (issue.code === "unrecognized_keys")
return {
message: (_d = errorUtil.errToObj(message).message) !== null && _d !== void 0 ? _d : defaultError
};
return {
message: defaultError
};
}
} : {}
});
}
strip() {
return new ZodObject({
...this._def,
unknownKeys: "strip"
});
}
passthrough() {
return new ZodObject({
...this._def,
unknownKeys: "passthrough"
});
}
// const AugmentFactory =
// <Def extends ZodObjectDef>(def: Def) =>
// <Augmentation extends ZodRawShape>(
// augmentation: Augmentation
// ): ZodObject<
// extendShape<ReturnType<Def["shape"]>, Augmentation>,
// Def["unknownKeys"],
// Def["catchall"]
// > => {
// return new ZodObject({
// ...def,
// shape: () => ({
// ...def.shape(),
// ...augmentation,
// }),
// }) as any;
// };
extend(augmentation) {
return new ZodObject({
...this._def,
shape: () => ({
...this._def.shape(),
...augmentation
})
});
}
/**
* Prior to zod@1.0.12 there was a bug in the
* inferred type of merged objects. Please
* upgrade if you are experiencing issues.
*/
merge(merging) {
const merged = new ZodObject({
unknownKeys: merging._def.unknownKeys,
catchall: merging._def.catchall,
shape: () => ({
...this._def.shape(),
...merging._def.shape()
}),
typeName: ZodFirstPartyTypeKind.ZodObject
});
return merged;
}
// merge<
// Incoming extends AnyZodObject,
// Augmentation extends Incoming["shape"],
// NewOutput extends {
// [k in keyof Augmentation | keyof Output]: k extends keyof Augmentation
// ? Augmentation[k]["_output"]
// : k extends keyof Output
// ? Output[k]
// : never;
// },
// NewInput extends {
// [k in keyof Augmentation | keyof Input]: k extends keyof Augmentation
// ? Augmentation[k]["_input"]
// : k extends keyof Input
// ? Input[k]
// : never;
// }
// >(
// merging: Incoming
// ): ZodObject<
// extendShape<T, ReturnType<Incoming["_def"]["shape"]>>,
// Incoming["_def"]["unknownKeys"],
// Incoming["_def"]["catchall"],
// NewOutput,
// NewInput
// > {
// const merged: any = new ZodObject({
// unknownKeys: merging._def.unknownKeys,
// catchall: merging._def.catchall,
// shape: () =>
// objectUtil.mergeShapes(this._def.shape(), merging._def.shape()),
// typeName: ZodFirstPartyTypeKind.ZodObject,
// }) as any;
// return merged;
// }
setKey(key2, schema) {
return this.augment({ [key2]: schema });
}
// merge<Incoming extends AnyZodObject>(
// merging: Incoming
// ): //ZodObject<T & Incoming["_shape"], UnknownKeys, Catchall> = (merging) => {
// ZodObject<
// extendShape<T, ReturnType<Incoming["_def"]["shape"]>>,
// Incoming["_def"]["unknownKeys"],
// Incoming["_def"]["catchall"]
// > {
// // const mergedShape = objectUtil.mergeShapes(
// // this._def.shape(),
// // merging._def.shape()
// // );
// const merged: any = new ZodObject({
// unknownKeys: merging._def.unknownKeys,
// catchall: merging._def.catchall,
// shape: () =>
// objectUtil.mergeShapes(this._def.shape(), merging._def.shape()),
// typeName: ZodFirstPartyTypeKind.ZodObject,
// }) as any;
// return merged;
// }
catchall(index) {
return new ZodObject({
...this._def,
catchall: index
});
}
pick(mask) {
const shape = {};
util.objectKeys(mask).forEach((key2) => {
if (mask[key2] && this.shape[key2]) {
shape[key2] = this.shape[key2];
}
});
return new ZodObject({
...this._def,
shape: () => shape
});
}
omit(mask) {
const shape = {};
util.objectKeys(this.shape).forEach((key2) => {
if (!mask[key2]) {
shape[key2] = this.shape[key2];
}
});
return new ZodObject({
...this._def,
shape: () => shape
});
}
/**
* @deprecated
*/
deepPartial() {
return deepPartialify(this);
}
partial(mask) {
const newShape = {};
util.objectKeys(this.shape).forEach((key2) => {
const fieldSchema = this.shape[key2];
if (mask && !mask[key2]) {
newShape[key2] = fieldSchema;
} else {
newShape[key2] = fieldSchema.optional();
}
});
return new ZodObject({
...this._def,
shape: () => newShape
});
}
required(mask) {
const newShape = {};
util.objectKeys(this.shape).forEach((key2) => {
if (mask && !mask[key2]) {
newShape[key2] = this.shape[key2];
} else {
const fieldSchema = this.shape[key2];
let newField = fieldSchema;
while (newField instanceof ZodOptional) {
newField = newField._def.innerType;
}
newShape[key2] = newField;
}
});
return new ZodObject({
...this._def,
shape: () => newShape
});
}
keyof() {
return createZodEnum(util.objectKeys(this.shape));
}
}
ZodObject.create = (shape, params) => {
return new ZodObject({
shape: () => shape,
unknownKeys: "strip",
catchall: ZodNever.create(),
typeName: ZodFirstPartyTypeKind.ZodObject,
...processCreateParams(params)
});
};
ZodObject.strictCreate = (shape, params) => {
return new ZodObject({
shape: () => shape,
unknownKeys: "strict",
catchall: ZodNever.create(),
typeName: ZodFirstPartyTypeKind.ZodObject,
...processCreateParams(params)
});
};
ZodObject.lazycreate = (shape, params) => {
return new ZodObject({
shape,
unknownKeys: "strip",
catchall: ZodNever.create(),
typeName: ZodFirstPartyTypeKind.ZodObject,
...processCreateParams(params)
});
};
class ZodUnion extends ZodType {
_parse(input) {
const { ctx } = this._processInputParams(input);
const options2 = this._def.options;
function handleResults(results) {
for (const result of results) {
if (result.result.status === "valid") {
return result.result;
}
}
for (const result of results) {
if (result.result.status === "dirty") {
ctx.common.issues.push(...result.ctx.common.issues);
return result.result;
}
}
const unionErrors = results.map((result) => new ZodError(result.ctx.common.issues));
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_union,
unionErrors
});
return INVALID;
}
if (ctx.common.async) {
return Promise.all(options2.map(async (option) => {
const childCtx = {
...ctx,
common: {
...ctx.common,
issues: []
},
parent: null
};
return {
result: await option._parseAsync({
data: ctx.data,
path: ctx.path,
parent: childCtx
}),
ctx: childCtx
};
})).then(handleResults);
} else {
let dirty = void 0;
const issues = [];
for (const option of options2) {
const childCtx = {
...ctx,
common: {
...ctx.common,
issues: []
},
parent: null
};
const result = option._parseSync({
data: ctx.data,
path: ctx.path,
parent: childCtx
});
if (result.status === "valid") {
return result;
} else if (result.status === "dirty" && !dirty) {
dirty = { result, ctx: childCtx };
}
if (childCtx.common.issues.length) {
issues.push(childCtx.common.issues);
}
}
if (dirty) {
ctx.common.issues.push(...dirty.ctx.common.issues);
return dirty.result;
}
const unionErrors = issues.map((issues2) => new ZodError(issues2));
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_union,
unionErrors
});
return INVALID;
}
}
get options() {
return this._def.options;
}
}
ZodUnion.create = (types2, params) => {
return new ZodUnion({
options: types2,
typeName: ZodFirstPartyTypeKind.ZodUnion,
...processCreateParams(params)
});
};
const getDiscriminator = (type2) => {
if (type2 instanceof ZodLazy) {
return getDiscriminator(type2.schema);
} else if (type2 instanceof ZodEffects) {
return getDiscriminator(type2.innerType());
} else if (type2 instanceof ZodLiteral) {
return [type2.value];
} else if (type2 instanceof ZodEnum) {
return type2.options;
} else if (type2 instanceof ZodNativeEnum) {
return util.objectValues(type2.enum);
} else if (type2 instanceof ZodDefault) {
return getDiscriminator(type2._def.innerType);
} else if (type2 instanceof ZodUndefined) {
return [void 0];
} else if (type2 instanceof ZodNull) {
return [null];
} else if (type2 instanceof ZodOptional) {
return [void 0, ...getDiscriminator(type2.unwrap())];
} else if (type2 instanceof ZodNullable) {
return [null, ...getDiscriminator(type2.unwrap())];
} else if (type2 instanceof ZodBranded) {
return getDiscriminator(type2.unwrap());
} else if (type2 instanceof ZodReadonly) {
return getDiscriminator(type2.unwrap());
} else if (type2 instanceof ZodCatch) {
return getDiscriminator(type2._def.innerType);
} else {
return [];
}
};
class ZodDiscriminatedUnion extends ZodType {
_parse(input) {
const { ctx } = this._processInputParams(input);
if (ctx.parsedType !== ZodParsedType.object) {
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.object,
received: ctx.parsedType
});
return INVALID;
}
const discriminator = this.discriminator;
const discriminatorValue = ctx.data[discriminator];
const option = this.optionsMap.get(discriminatorValue);
if (!option) {
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_union_discriminator,
options: Array.from(this.optionsMap.keys()),
path: [discriminator]
});
return INVALID;
}
if (ctx.common.async) {
return option._parseAsync({
data: ctx.data,
path: ctx.path,
parent: ctx
});
} else {
return option._parseSync({
data: ctx.data,
path: ctx.path,
parent: ctx
});
}
}
get discriminator() {
return this._def.discriminator;
}
get options() {
return this._def.options;
}
get optionsMap() {
return this._def.optionsMap;
}
/**
* The constructor of the discriminated union schema. Its behaviour is very similar to that of the normal z.union() constructor.
* However, it only allows a union of objects, all of which need to share a discriminator property. This property must
* have a different value for each object in the union.
* @param discriminator the name of the discriminator property
* @param types an array of object schemas
* @param params
*/
static create(discriminator, options2, params) {
const optionsMap = /* @__PURE__ */ new Map();
for (const type2 of options2) {
const discriminatorValues = getDiscriminator(type2.shape[discriminator]);
if (!discriminatorValues.length) {
throw new Error(`A discriminator value for key \`${discriminator}\` could not be extracted from all schema options`);
}
for (const value of discriminatorValues) {
if (optionsMap.has(value)) {
throw new Error(`Discriminator property ${String(discriminator)} has duplicate value ${String(value)}`);
}
optionsMap.set(value, type2);
}
}
return new ZodDiscriminatedUnion({
typeName: ZodFirstPartyTypeKind.ZodDiscriminatedUnion,
discriminator,
options: options2,
optionsMap,
...processCreateParams(params)
});
}
}
function mergeValues(a, b) {
const aType = getParsedType(a);
const bType = getParsedType(b);
if (a === b) {
return { valid: true, data: a };
} else if (aType === ZodParsedType.object && bType === ZodParsedType.object) {
const bKeys = util.objectKeys(b);
const sharedKeys = util.objectKeys(a).filter((key2) => bKeys.indexOf(key2) !== -1);
const newObj = { ...a, ...b };
for (const key2 of sharedKeys) {
const sharedValue = mergeValues(a[key2], b[key2]);
if (!sharedValue.valid) {
return { valid: false };
}
newObj[key2] = sharedValue.data;
}
return { valid: true, data: newObj };
} else if (aType === ZodParsedType.array && bType === ZodParsedType.array) {
if (a.length !== b.length) {
return { valid: false };
}
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 };
}
newArray.push(sharedValue.data);
}
return { valid: true, data: newArray };
} else if (aType === ZodParsedType.date && bType === ZodParsedType.date && +a === +b) {
return { valid: true, data: a };
} else {
return { valid: false };
}
}
class ZodIntersection extends ZodType {
_parse(input) {
const { status, ctx } = this._processInputParams(input);
const handleParsed = (parsedLeft, parsedRight) => {
if (isAborted(parsedLeft) || isAborted(parsedRight)) {
return INVALID;
}
const merged = mergeValues(parsedLeft.value, parsedRight.value);
if (!merged.valid) {
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_intersection_types
});
return INVALID;
}
if (isDirty(parsedLeft) || isDirty(parsedRight)) {
status.dirty();
}
return { status: status.value, value: merged.data };
};
if (ctx.common.async) {
return Promise.all([
this._def.left._parseAsync({
data: ctx.data,
path: ctx.path,
parent: ctx
}),
this._def.right._parseAsync({
data: ctx.data,
path: ctx.path,
parent: ctx
})
]).then(([left, right]) => handleParsed(left, right));
} else {
return handleParsed(this._def.left._parseSync({
data: ctx.data,
path: ctx.path,
parent: ctx
}), this._def.right._parseSync({
data: ctx.data,
path: ctx.path,
parent: ctx
}));
}
}
}
ZodIntersection.create = (left, right, params) => {
return new ZodIntersection({
left,
right,
typeName: ZodFirstPartyTypeKind.ZodIntersection,
...processCreateParams(params)
});
};
class ZodTuple extends ZodType {
_parse(input) {
const { status, ctx } = this._processInputParams(input);
if (ctx.parsedType !== ZodParsedType.array) {
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.array,
received: ctx.parsedType
});
return INVALID;
}
if (ctx.data.length < this._def.items.length) {
addIssueToContext(ctx, {
code: ZodIssueCode.too_small,
minimum: this._def.items.length,
inclusive: true,
exact: false,
type: "array"
});
return INVALID;
}
const rest = this._def.rest;
if (!rest && ctx.data.length > this._def.items.length) {
addIssueToContext(ctx, {
code: ZodIssueCode.too_big,
maximum: this._def.items.length,
inclusive: true,
exact: false,
type: "array"
});
status.dirty();
}
const items = [...ctx.data].map((item, itemIndex) => {
const schema = this._def.items[itemIndex] || this._def.rest;
if (!schema)
return null;
return schema._parse(new ParseInputLazyPath(ctx, item, ctx.path, itemIndex));
}).filter((x) => !!x);
if (ctx.common.async) {
return Promise.all(items).then((results) => {
return ParseStatus.mergeArray(status, results);
});
} else {
return ParseStatus.mergeArray(status, items);
}
}
get items() {
return this._def.items;
}
rest(rest) {
return new ZodTuple({
...this._def,
rest
});
}
}
ZodTuple.create = (schemas, params) => {
if (!Array.isArray(schemas)) {
throw new Error("You must pass an array of schemas to z.tuple([ ... ])");
}
return new ZodTuple({
items: schemas,
typeName: ZodFirstPartyTypeKind.ZodTuple,
rest: null,
...processCreateParams(params)
});
};
class ZodRecord extends ZodType {
get keySchema() {
return this._def.keyType;
}
get valueSchema() {
return this._def.valueType;
}
_parse(input) {
const { status, ctx } = this._processInputParams(input);
if (ctx.parsedType !== ZodParsedType.object) {
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.object,
received: ctx.parsedType
});
return INVALID;
}
const pairs = [];
const keyType = this._def.keyType;
const valueType = this._def.valueType;
for (const key2 in ctx.data) {
pairs.push({
key: keyType._parse(new ParseInputLazyPath(ctx, key2, ctx.path, key2)),
value: valueType._parse(new ParseInputLazyPath(ctx, ctx.data[key2], ctx.path, key2)),
alwaysSet: key2 in ctx.data
});
}
if (ctx.common.async) {
return ParseStatus.mergeObjectAsync(status, pairs);
} else {
return ParseStatus.mergeObjectSync(status, pairs);
}
}
get element() {
return this._def.valueType;
}
static create(first, second, third) {
if (second instanceof ZodType) {
return new ZodRecord({
keyType: first,
valueType: second,
typeName: ZodFirstPartyTypeKind.ZodRecord,
...processCreateParams(third)
});
}
return new ZodRecord({
keyType: ZodString.create(),
valueType: first,
typeName: ZodFirstPartyTypeKind.ZodRecord,
...processCreateParams(second)
});
}
}
class ZodMap extends ZodType {
get keySchema() {
return this._def.keyType;
}
get valueSchema() {
return this._def.valueType;
}
_parse(input) {
const { status, ctx } = this._processInputParams(input);
if (ctx.parsedType !== ZodParsedType.map) {
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.map,
received: ctx.parsedType
});
return INVALID;
}
const keyType = this._def.keyType;
const valueType = this._def.valueType;
const pairs = [...ctx.data.entries()].map(([key2, value], index) => {
return {
key: keyType._parse(new ParseInputLazyPath(ctx, key2, ctx.path, [index, "key"])),
value: valueType._parse(new ParseInputLazyPath(ctx, value, ctx.path, [index, "value"]))
};
});
if (ctx.common.async) {
const finalMap = /* @__PURE__ */ new Map();
return Promise.resolve().then(async () => {
for (const pair of pairs) {
const key2 = await pair.key;
const value = await pair.value;
if (key2.status === "aborted" || value.status === "aborted") {
return INVALID;
}
if (key2.status === "dirty" || value.status === "dirty") {
status.dirty();
}
finalMap.set(key2.value, value.value);
}
return { status: status.value, value: finalMap };
});
} else {
const finalMap = /* @__PURE__ */ new Map();
for (const pair of pairs) {
const key2 = pair.key;
const value = pair.value;
if (key2.status === "aborted" || value.status === "aborted") {
return INVALID;
}
if (key2.status === "dirty" || value.status === "dirty") {
status.dirty();
}
finalMap.set(key2.value, value.value);
}
return { status: status.value, value: finalMap };
}
}
}
ZodMap.create = (keyType, valueType, params) => {
return new ZodMap({
valueType,
keyType,
typeName: ZodFirstPartyTypeKind.ZodMap,
...processCreateParams(params)
});
};
class ZodSet extends ZodType {
_parse(input) {
const { status, ctx } = this._processInputParams(input);
if (ctx.parsedType !== ZodParsedType.set) {
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.set,
received: ctx.parsedType
});
return INVALID;
}
const def = this._def;
if (def.minSize !== null) {
if (ctx.data.size < def.minSize.value) {
addIssueToContext(ctx, {
code: ZodIssueCode.too_small,
minimum: def.minSize.value,
type: "set",
inclusive: true,
exact: false,
message: def.minSize.message
});
status.dirty();
}
}
if (def.maxSize !== null) {
if (ctx.data.size > def.maxSize.value) {
addIssueToContext(ctx, {
code: ZodIssueCode.too_big,
maximum: def.maxSize.value,
type: "set",
inclusive: true,
exact: false,
message: def.maxSize.message
});
status.dirty();
}
}
const valueType = this._def.valueType;
function finalizeSet(elements2) {
const parsedSet = /* @__PURE__ */ new Set();
for (const element of elements2) {
if (element.status === "aborted")
return INVALID;
if (element.status === "dirty")
status.dirty();
parsedSet.add(element.value);
}
return { status: status.value, value: parsedSet };
}
const elements = [...ctx.data.values()].map((item, i) => valueType._parse(new ParseInputLazyPath(ctx, item, ctx.path, i)));
if (ctx.common.async) {
return Promise.all(elements).then((elements2) => finalizeSet(elements2));
} else {
return finalizeSet(elements);
}
}
min(minSize, message) {
return new ZodSet({
...this._def,
minSize: { value: minSize, message: errorUtil.toString(message) }
});
}
max(maxSize, message) {
return new ZodSet({
...this._def,
maxSize: { value: maxSize, message: errorUtil.toString(message) }
});
}
size(size, message) {
return this.min(size, message).max(size, message);
}
nonempty(message) {
return this.min(1, message);
}
}
ZodSet.create = (valueType, params) => {
return new ZodSet({
valueType,
minSize: null,
maxSize: null,
typeName: ZodFirstPartyTypeKind.ZodSet,
...processCreateParams(params)
});
};
class ZodFunction extends ZodType {
constructor() {
super(...arguments);
this.validate = this.implement;
}
_parse(input) {
const { ctx } = this._processInputParams(input);
if (ctx.parsedType !== ZodParsedType.function) {
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.function,
received: ctx.parsedType
});
return INVALID;
}
function makeArgsIssue(args, error2) {
return makeIssue({
data: args,
path: ctx.path,
errorMaps: [
ctx.common.contextualErrorMap,
ctx.schemaErrorMap,
getErrorMap(),
errorMap
].filter((x) => !!x),
issueData: {
code: ZodIssueCode.invalid_arguments,
argumentsError: error2
}
});
}
function makeReturnsIssue(returns, error2) {
return makeIssue({
data: returns,
path: ctx.path,
errorMaps: [
ctx.common.contextualErrorMap,
ctx.schemaErrorMap,
getErrorMap(),
errorMap
].filter((x) => !!x),
issueData: {
code: ZodIssueCode.invalid_return_type,
returnTypeError: error2
}
});
}
const params = { errorMap: ctx.common.contextualErrorMap };
const fn = ctx.data;
if (this._def.returns instanceof ZodPromise) {
const me = this;
return OK(async function(...args) {
const error2 = new ZodError([]);
const parsedArgs = await me._def.args.parseAsync(args, params).catch((e) => {
error2.addIssue(makeArgsIssue(args, e));
throw error2;
});
const result = await Reflect.apply(fn, this, parsedArgs);
const parsedReturns = await me._def.returns._def.type.parseAsync(result, params).catch((e) => {
error2.addIssue(makeReturnsIssue(result, e));
throw error2;
});
return parsedReturns;
});
} else {
const me = this;
return OK(function(...args) {
const parsedArgs = me._def.args.safeParse(args, params);
if (!parsedArgs.success) {
throw new ZodError([makeArgsIssue(args, parsedArgs.error)]);
}
const result = Reflect.apply(fn, this, parsedArgs.data);
const parsedReturns = me._def.returns.safeParse(result, params);
if (!parsedReturns.success) {
throw new ZodError([makeReturnsIssue(result, parsedReturns.error)]);
}
return parsedReturns.data;
});
}
}
parameters() {
return this._def.args;
}
returnType() {
return this._def.returns;
}
args(...items) {
return new ZodFunction({
...this._def,
args: ZodTuple.create(items).rest(ZodUnknown.create())
});
}
returns(returnType) {
return new ZodFunction({
...this._def,
returns: returnType
});
}
implement(func) {
const validatedFunc = this.parse(func);
return validatedFunc;
}
strictImplement(func) {
const validatedFunc = this.parse(func);
return validatedFunc;
}
static create(args, returns, params) {
return new ZodFunction({
args: args ? args : ZodTuple.create([]).rest(ZodUnknown.create()),
returns: returns || ZodUnknown.create(),
typeName: ZodFirstPartyTypeKind.ZodFunction,
...processCreateParams(params)
});
}
}
class ZodLazy extends ZodType {
get schema() {
return this._def.getter();
}
_parse(input) {
const { ctx } = this._processInputParams(input);
const lazySchema = this._def.getter();
return lazySchema._parse({ data: ctx.data, path: ctx.path, parent: ctx });
}
}
ZodLazy.create = (getter, params) => {
return new ZodLazy({
getter,
typeName: ZodFirstPartyTypeKind.ZodLazy,
...processCreateParams(params)
});
};
class ZodLiteral extends ZodType {
_parse(input) {
if (input.data !== this._def.value) {
const ctx = this._getOrReturnCtx(input);
addIssueToContext(ctx, {
received: ctx.data,
code: ZodIssueCode.invalid_literal,
expected: this._def.value
});
return INVALID;
}
return { status: "valid", value: input.data };
}
get value() {
return this._def.value;
}
}
ZodLiteral.create = (value, params) => {
return new ZodLiteral({
value,
typeName: ZodFirstPartyTypeKind.ZodLiteral,
...processCreateParams(params)
});
};
function createZodEnum(values, params) {
return new ZodEnum({
values,
typeName: ZodFirstPartyTypeKind.ZodEnum,
...processCreateParams(params)
});
}
class ZodEnum extends ZodType {
constructor() {
super(...arguments);
_ZodEnum_cache.set(this, void 0);
}
_parse(input) {
if (typeof input.data !== "string") {
const ctx = this._getOrReturnCtx(input);
const expectedValues = this._def.values;
addIssueToContext(ctx, {
expected: util.joinValues(expectedValues),
received: ctx.parsedType,
code: ZodIssueCode.invalid_type
});
return INVALID;
}
if (!__classPrivateFieldGet(this, _ZodEnum_cache)) {
__classPrivateFieldSet(this, _ZodEnum_cache, new Set(this._def.values));
}
if (!__classPrivateFieldGet(this, _ZodEnum_cache).has(input.data)) {
const ctx = this._getOrReturnCtx(input);
const expectedValues = this._def.values;
addIssueToContext(ctx, {
received: ctx.data,
code: ZodIssueCode.invalid_enum_value,
options: expectedValues
});
return INVALID;
}
return OK(input.data);
}
get options() {
return this._def.values;
}
get enum() {
const enumValues = {};
for (const val of this._def.values) {
enumValues[val] = val;
}
return enumValues;
}
get Values() {
const enumValues = {};
for (const val of this._def.values) {
enumValues[val] = val;
}
return enumValues;
}
get Enum() {
const enumValues = {};
for (const val of this._def.values) {
enumValues[val] = val;
}
return enumValues;
}
extract(values, newDef = this._def) {
return ZodEnum.create(values, {
...this._def,
...newDef
});
}
exclude(values, newDef = this._def) {
return ZodEnum.create(this.options.filter((opt) => !values.includes(opt)), {
...this._def,
...newDef
});
}
}
_ZodEnum_cache = /* @__PURE__ */ new WeakMap();
ZodEnum.create = createZodEnum;
class ZodNativeEnum extends ZodType {
constructor() {
super(...arguments);
_ZodNativeEnum_cache.set(this, void 0);
}
_parse(input) {
const nativeEnumValues = util.getValidEnumValues(this._def.values);
const ctx = this._getOrReturnCtx(input);
if (ctx.parsedType !== ZodParsedType.string && ctx.parsedType !== ZodParsedType.number) {
const expectedValues = util.objectValues(nativeEnumValues);
addIssueToContext(ctx, {
expected: util.joinValues(expectedValues),
received: ctx.parsedType,
code: ZodIssueCode.invalid_type
});
return INVALID;
}
if (!__classPrivateFieldGet(this, _ZodNativeEnum_cache)) {
__classPrivateFieldSet(this, _ZodNativeEnum_cache, new Set(util.getValidEnumValues(this._def.values)));
}
if (!__classPrivateFieldGet(this, _ZodNativeEnum_cache).has(input.data)) {
const expectedValues = util.objectValues(nativeEnumValues);
addIssueToContext(ctx, {
received: ctx.data,
code: ZodIssueCode.invalid_enum_value,
options: expectedValues
});
return INVALID;
}
return OK(input.data);
}
get enum() {
return this._def.values;
}
}
_ZodNativeEnum_cache = /* @__PURE__ */ new WeakMap();
ZodNativeEnum.create = (values, params) => {
return new ZodNativeEnum({
values,
typeName: ZodFirstPartyTypeKind.ZodNativeEnum,
...processCreateParams(params)
});
};
class ZodPromise extends ZodType {
unwrap() {
return this._def.type;
}
_parse(input) {
const { ctx } = this._processInputParams(input);
if (ctx.parsedType !== ZodParsedType.promise && ctx.common.async === false) {
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.promise,
received: ctx.parsedType
});
return INVALID;
}
const promisified = ctx.parsedType === ZodParsedType.promise ? ctx.data : Promise.resolve(ctx.data);
return OK(promisified.then((data) => {
return this._def.type.parseAsync(data, {
path: ctx.path,
errorMap: ctx.common.contextualErrorMap
});
}));
}
}
ZodPromise.create = (schema, params) => {
return new ZodPromise({
type: schema,
typeName: ZodFirstPartyTypeKind.ZodPromise,
...processCreateParams(params)
});
};
class ZodEffects extends ZodType {
innerType() {
return this._def.schema;
}
sourceType() {
return this._def.schema._def.typeName === ZodFirstPartyTypeKind.ZodEffects ? this._def.schema.sourceType() : this._def.schema;
}
_parse(input) {
const { status, ctx } = this._processInputParams(input);
const effect = this._def.effect || null;
const checkCtx = {
addIssue: (arg) => {
addIssueToContext(ctx, arg);
if (arg.fatal) {
status.abort();
} else {
status.dirty();
}
},
get path() {
return ctx.path;
}
};
checkCtx.addIssue = checkCtx.addIssue.bind(checkCtx);
if (effect.type === "preprocess") {
const processed = effect.transform(ctx.data, checkCtx);
if (ctx.common.async) {
return Promise.resolve(processed).then(async (processed2) => {
if (status.value === "aborted")
return INVALID;
const result = await this._def.schema._parseAsync({
data: processed2,
path: ctx.path,
parent: ctx
});
if (result.status === "aborted")
return INVALID;
if (result.status === "dirty")
return DIRTY(result.value);
if (status.value === "dirty")
return DIRTY(result.value);
return result;
});
} else {
if (status.value === "aborted")
return INVALID;
const result = this._def.schema._parseSync({
data: processed,
path: ctx.path,
parent: ctx
});
if (result.status === "aborted")
return INVALID;
if (result.status === "dirty")
return DIRTY(result.value);
if (status.value === "dirty")
return DIRTY(result.value);
return result;
}
}
if (effect.type === "refinement") {
const executeRefinement = (acc) => {
const result = effect.refinement(acc, checkCtx);
if (ctx.common.async) {
return Promise.resolve(result);
}
if (result instanceof Promise) {
throw new Error("Async refinement encountered during synchronous parse operation. Use .parseAsync instead.");
}
return acc;
};
if (ctx.common.async === false) {
const inner = this._def.schema._parseSync({
data: ctx.data,
path: ctx.path,
parent: ctx
});
if (inner.status === "aborted")
return INVALID;
if (inner.status === "dirty")
status.dirty();
executeRefinement(inner.value);
return { status: status.value, value: inner.value };
} else {
return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((inner) => {
if (inner.status === "aborted")
return INVALID;
if (inner.status === "dirty")
status.dirty();
return executeRefinement(inner.value).then(() => {
return { status: status.value, value: inner.value };
});
});
}
}
if (effect.type === "transform") {
if (ctx.common.async === false) {
const base2 = this._def.schema._parseSync({
data: ctx.data,
path: ctx.path,
parent: ctx
});
if (!isValid(base2))
return base2;
const result = effect.transform(base2.value, checkCtx);
if (result instanceof Promise) {
throw new Error(`Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.`);
}
return { status: status.value, value: result };
} else {
return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((base2) => {
if (!isValid(base2))
return base2;
return Promise.resolve(effect.transform(base2.value, checkCtx)).then((result) => ({ status: status.value, value: result }));
});
}
}
util.assertNever(effect);
}
}
ZodEffects.create = (schema, effect, params) => {
return new ZodEffects({
schema,
typeName: ZodFirstPartyTypeKind.ZodEffects,
effect,
...processCreateParams(params)
});
};
ZodEffects.createWithPreprocess = (preprocess, schema, params) => {
return new ZodEffects({
schema,
effect: { type: "preprocess", transform: preprocess },
typeName: ZodFirstPartyTypeKind.ZodEffects,
...processCreateParams(params)
});
};
class ZodOptional extends ZodType {
_parse(input) {
const parsedType = this._getType(input);
if (parsedType === ZodParsedType.undefined) {
return OK(void 0);
}
return this._def.innerType._parse(input);
}
unwrap() {
return this._def.innerType;
}
}
ZodOptional.create = (type2, params) => {
return new ZodOptional({
innerType: type2,
typeName: ZodFirstPartyTypeKind.ZodOptional,
...processCreateParams(params)
});
};
class ZodNullable extends ZodType {
_parse(input) {
const parsedType = this._getType(input);
if (parsedType === ZodParsedType.null) {
return OK(null);
}
return this._def.innerType._parse(input);
}
unwrap() {
return this._def.innerType;
}
}
ZodNullable.create = (type2, params) => {
return new ZodNullable({
innerType: type2,
typeName: ZodFirstPartyTypeKind.ZodNullable,
...processCreateParams(params)
});
};
class ZodDefault extends ZodType {
_parse(input) {
const { ctx } = this._processInputParams(input);
let data = ctx.data;
if (ctx.parsedType === ZodParsedType.undefined) {
data = this._def.defaultValue();
}
return this._def.innerType._parse({
data,
path: ctx.path,
parent: ctx
});
}
removeDefault() {
return this._def.innerType;
}
}
ZodDefault.create = (type2, params) => {
return new ZodDefault({
innerType: type2,
typeName: ZodFirstPartyTypeKind.ZodDefault,
defaultValue: typeof params.default === "function" ? params.default : () => params.default,
...processCreateParams(params)
});
};
class ZodCatch extends ZodType {
_parse(input) {
const { ctx } = this._processInputParams(input);
const newCtx = {
...ctx,
common: {
...ctx.common,
issues: []
}
};
const result = this._def.innerType._parse({
data: newCtx.data,
path: newCtx.path,
parent: {
...newCtx
}
});
if (isAsync(result)) {
return result.then((result2) => {
return {
status: "valid",
value: result2.status === "valid" ? result2.value : this._def.catchValue({
get error() {
return new ZodError(newCtx.common.issues);
},
input: newCtx.data
})
};
});
} else {
return {
status: "valid",
value: result.status === "valid" ? result.value : this._def.catchValue({
get error() {
return new ZodError(newCtx.common.issues);
},
input: newCtx.data
})
};
}
}
removeCatch() {
return this._def.innerType;
}
}
ZodCatch.create = (type2, params) => {
return new ZodCatch({
innerType: type2,
typeName: ZodFirstPartyTypeKind.ZodCatch,
catchValue: typeof params.catch === "function" ? params.catch : () => params.catch,
...processCreateParams(params)
});
};
class ZodNaN extends ZodType {
_parse(input) {
const parsedType = this._getType(input);
if (parsedType !== ZodParsedType.nan) {
const ctx = this._getOrReturnCtx(input);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.nan,
received: ctx.parsedType
});
return INVALID;
}
return { status: "valid", value: input.data };
}
}
ZodNaN.create = (params) => {
return new ZodNaN({
typeName: ZodFirstPartyTypeKind.ZodNaN,
...processCreateParams(params)
});
};
const BRAND = Symbol("zod_brand");
class ZodBranded extends ZodType {
_parse(input) {
const { ctx } = this._processInputParams(input);
const data = ctx.data;
return this._def.type._parse({
data,
path: ctx.path,
parent: ctx
});
}
unwrap() {
return this._def.type;
}
}
class ZodPipeline extends ZodType {
_parse(input) {
const { status, ctx } = this._processInputParams(input);
if (ctx.common.async) {
const handleAsync = async () => {
const inResult = await this._def.in._parseAsync({
data: ctx.data,
path: ctx.path,
parent: ctx
});
if (inResult.status === "aborted")
return INVALID;
if (inResult.status === "dirty") {
status.dirty();
return DIRTY(inResult.value);
} else {
return this._def.out._parseAsync({
data: inResult.value,
path: ctx.path,
parent: ctx
});
}
};
return handleAsync();
} else {
const inResult = this._def.in._parseSync({
data: ctx.data,
path: ctx.path,
parent: ctx
});
if (inResult.status === "aborted")
return INVALID;
if (inResult.status === "dirty") {
status.dirty();
return {
status: "dirty",
value: inResult.value
};
} else {
return this._def.out._parseSync({
data: inResult.value,
path: ctx.path,
parent: ctx
});
}
}
}
static create(a, b) {
return new ZodPipeline({
in: a,
out: b,
typeName: ZodFirstPartyTypeKind.ZodPipeline
});
}
}
class ZodReadonly extends ZodType {
_parse(input) {
const result = this._def.innerType._parse(input);
const freeze = (data) => {
if (isValid(data)) {
data.value = Object.freeze(data.value);
}
return data;
};
return isAsync(result) ? result.then((data) => freeze(data)) : freeze(result);
}
unwrap() {
return this._def.innerType;
}
}
ZodReadonly.create = (type2, params) => {
return new ZodReadonly({
innerType: type2,
typeName: ZodFirstPartyTypeKind.ZodReadonly,
...processCreateParams(params)
});
};
function custom(check, params = {}, fatal) {
if (check)
return ZodAny.create().superRefine((data, ctx) => {
var _a, _b;
if (!check(data)) {
const p = typeof params === "function" ? params(data) : typeof params === "string" ? { message: params } : params;
const _fatal = (_b = (_a = p.fatal) !== null && _a !== void 0 ? _a : fatal) !== null && _b !== void 0 ? _b : true;
const p2 = typeof p === "string" ? { message: p } : p;
ctx.addIssue({ code: "custom", ...p2, fatal: _fatal });
}
});
return ZodAny.create();
}
const late = {
object: ZodObject.lazycreate
};
var ZodFirstPartyTypeKind;
(function(ZodFirstPartyTypeKind2) {
ZodFirstPartyTypeKind2["ZodString"] = "ZodString";
ZodFirstPartyTypeKind2["ZodNumber"] = "ZodNumber";
ZodFirstPartyTypeKind2["ZodNaN"] = "ZodNaN";
ZodFirstPartyTypeKind2["ZodBigInt"] = "ZodBigInt";
ZodFirstPartyTypeKind2["ZodBoolean"] = "ZodBoolean";
ZodFirstPartyTypeKind2["ZodDate"] = "ZodDate";
ZodFirstPartyTypeKind2["ZodSymbol"] = "ZodSymbol";
ZodFirstPartyTypeKind2["ZodUndefined"] = "ZodUndefined";
ZodFirstPartyTypeKind2["ZodNull"] = "ZodNull";
ZodFirstPartyTypeKind2["ZodAny"] = "ZodAny";
ZodFirstPartyTypeKind2["ZodUnknown"] = "ZodUnknown";
ZodFirstPartyTypeKind2["ZodNever"] = "ZodNever";
ZodFirstPartyTypeKind2["ZodVoid"] = "ZodVoid";
ZodFirstPartyTypeKind2["ZodArray"] = "ZodArray";
ZodFirstPartyTypeKind2["ZodObject"] = "ZodObject";
ZodFirstPartyTypeKind2["ZodUnion"] = "ZodUnion";
ZodFirstPartyTypeKind2["ZodDiscriminatedUnion"] = "ZodDiscriminatedUnion";
ZodFirstPartyTypeKind2["ZodIntersection"] = "ZodIntersection";
ZodFirstPartyTypeKind2["ZodTuple"] = "ZodTuple";
ZodFirstPartyTypeKind2["ZodRecord"] = "ZodRecord";
ZodFirstPartyTypeKind2["ZodMap"] = "ZodMap";
ZodFirstPartyTypeKind2["ZodSet"] = "ZodSet";
ZodFirstPartyTypeKind2["ZodFunction"] = "ZodFunction";
ZodFirstPartyTypeKind2["ZodLazy"] = "ZodLazy";
ZodFirstPartyTypeKind2["ZodLiteral"] = "ZodLiteral";
ZodFirstPartyTypeKind2["ZodEnum"] = "ZodEnum";
ZodFirstPartyTypeKind2["ZodEffects"] = "ZodEffects";
ZodFirstPartyTypeKind2["ZodNativeEnum"] = "ZodNativeEnum";
ZodFirstPartyTypeKind2["ZodOptional"] = "ZodOptional";
ZodFirstPartyTypeKind2["ZodNullable"] = "ZodNullable";
ZodFirstPartyTypeKind2["ZodDefault"] = "ZodDefault";
ZodFirstPartyTypeKind2["ZodCatch"] = "ZodCatch";
ZodFirstPartyTypeKind2["ZodPromise"] = "ZodPromise";
ZodFirstPartyTypeKind2["ZodBranded"] = "ZodBranded";
ZodFirstPartyTypeKind2["ZodPipeline"] = "ZodPipeline";
ZodFirstPartyTypeKind2["ZodReadonly"] = "ZodReadonly";
})(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
const instanceOfType = (cls, params = {
message: `Input not instance of ${cls.name}`
}) => custom((data) => data instanceof cls, params);
const stringType = ZodString.create;
const numberType = ZodNumber.create;
const nanType = ZodNaN.create;
const bigIntType = ZodBigInt.create;
const booleanType = ZodBoolean.create;
const dateType = ZodDate.create;
const symbolType = ZodSymbol.create;
const undefinedType = ZodUndefined.create;
const nullType = ZodNull.create;
const anyType = ZodAny.create;
const unknownType = ZodUnknown.create;
const neverType = ZodNever.create;
const voidType = ZodVoid.create;
const arrayType = ZodArray.create;
const objectType = ZodObject.create;
const strictObjectType = ZodObject.strictCreate;
const unionType = ZodUnion.create;
const discriminatedUnionType = ZodDiscriminatedUnion.create;
const intersectionType = ZodIntersection.create;
const tupleType = ZodTuple.create;
const recordType = ZodRecord.create;
const mapType = ZodMap.create;
const setType = ZodSet.create;
const functionType = ZodFunction.create;
const lazyType = ZodLazy.create;
const literalType = ZodLiteral.create;
const enumType = ZodEnum.create;
const nativeEnumType = ZodNativeEnum.create;
const promiseType = ZodPromise.create;
const effectsType = ZodEffects.create;
const optionalType = ZodOptional.create;
const nullableType = ZodNullable.create;
const preprocessType = ZodEffects.createWithPreprocess;
const pipelineType = ZodPipeline.create;
const ostring = () => stringType().optional();
const onumber = () => numberType().optional();
const oboolean = () => booleanType().optional();
const coerce = {
string: (arg) => ZodString.create({ ...arg, coerce: true }),
number: (arg) => ZodNumber.create({ ...arg, coerce: true }),
boolean: (arg) => ZodBoolean.create({
...arg,
coerce: true
}),
bigint: (arg) => ZodBigInt.create({ ...arg, coerce: true }),
date: (arg) => ZodDate.create({ ...arg, coerce: true })
};
const NEVER = INVALID;
var z = /* @__PURE__ */ Object.freeze({
__proto__: null,
defaultErrorMap: errorMap,
setErrorMap,
getErrorMap,
makeIssue,
EMPTY_PATH,
addIssueToContext,
ParseStatus,
INVALID,
DIRTY,
OK,
isAborted,
isDirty,
isValid,
isAsync,
get util() {
return util;
},
get objectUtil() {
return objectUtil;
},
ZodParsedType,
getParsedType,
ZodType,
datetimeRegex,
ZodString,
ZodNumber,
ZodBigInt,
ZodBoolean,
ZodDate,
ZodSymbol,
ZodUndefined,
ZodNull,
ZodAny,
ZodUnknown,
ZodNever,
ZodVoid,
ZodArray,
ZodObject,
ZodUnion,
ZodDiscriminatedUnion,
ZodIntersection,
ZodTuple,
ZodRecord,
ZodMap,
ZodSet,
ZodFunction,
ZodLazy,
ZodLiteral,
ZodEnum,
ZodNativeEnum,
ZodPromise,
ZodEffects,
ZodTransformer: ZodEffects,
ZodOptional,
ZodNullable,
ZodDefault,
ZodCatch,
ZodNaN,
BRAND,
ZodBranded,
ZodPipeline,
ZodReadonly,
custom,
Schema: ZodType,
ZodSchema: ZodType,
late,
get ZodFirstPartyTypeKind() {
return ZodFirstPartyTypeKind;
},
coerce,
any: anyType,
array: arrayType,
bigint: bigIntType,
boolean: booleanType,
date: dateType,
discriminatedUnion: discriminatedUnionType,
effect: effectsType,
"enum": enumType,
"function": functionType,
"instanceof": instanceOfType,
intersection: intersectionType,
lazy: lazyType,
literal: literalType,
map: mapType,
nan: nanType,
nativeEnum: nativeEnumType,
never: neverType,
"null": nullType,
nullable: nullableType,
number: numberType,
object: objectType,
oboolean,
onumber,
optional: optionalType,
ostring,
pipeline: pipelineType,
preprocess: preprocessType,
promise: promiseType,
record: recordType,
set: setType,
strictObject: strictObjectType,
string: stringType,
symbol: symbolType,
transformer: effectsType,
tuple: tupleType,
"undefined": undefinedType,
union: unionType,
unknown: unknownType,
"void": voidType,
NEVER,
ZodIssueCode,
quotelessJson,
ZodError
});
const configArgsSchema = z.object({
beaconchainUrl: z.string().url(),
publicClient: z.custom().superRefine((val, ctx) => {
const client = val;
if (!client) {
ctx.addIssue({
code: z.ZodIssueCode.custom,
message: "Public client must be provided"
});
return false;
}
if (client.chain === void 0) {
ctx.addIssue({
code: z.ZodIssueCode.custom,
message: "Public client must have a chain property"
});
return false;
}
if (!chainIds.includes(client.chain?.id)) {
ctx.addIssue({
code: z.ZodIssueCode.custom,
message: `Public client chain must be one of [${networks.join(", ")}]`
});
return false;
}
return true;
}),
walletClient: z.custom().superRefine((val, ctx) => {
const client = val;
if (!client) {
ctx.addIssue({
code: z.ZodIssueCode.custom,
message: "Wallet client must be provided"
});
return false;
}
if (client.chain === void 0) {
ctx.addIssue({
code: z.ZodIssueCode.custom,
message: "Wallet client must have a chain property"
});
return false;
}
if (!chainIds.includes(client.chain?.id)) {
ctx.addIssue({
code: z.ZodIssueCode.custom,
message: `Wallet client chain must be one of [${networks.join(", ")}]`
});
return false;
}
return true;
}),
_: z.object({
subgraphUrl: z.string().url().optional(),
contractAddress: z.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"
}
);
console.log("testing trigger");
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 bigintMax = (...args) => {
return args.filter((x) => !isUndefined(x)).reduce((max2, cur) => cur > max2 ? cur : max2);
};
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.bam_graph_endpoints = bam_graph_endpoints;
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.chainIds = chainIds;
exports.chains = chains;
exports.cloneBuffer = cloneBuffer;
exports.cloneTypedArray = cloneTypedArray;
exports.configArgsSchema = configArgsSchema;
exports.contracts = contracts;
exports.copyArray = copyArray;
exports.copyObject = copyObject;
exports.defineProperty = defineProperty;
exports.eq = eq;
exports.getPrototype = getPrototype;
exports.globals = globals;
exports.hoodi = hoodi;
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;
exports.isObjectLike = isObjectLike;
exports.isTypedArray = isTypedArray;
exports.isUndefined = isUndefined;
exports.keysIn = keysIn;
exports.networks = networks;
exports.process$1 = process$1;
exports.registerValidatorsByClusterSizeLimits = registerValidatorsByClusterSizeLimits;
exports.roundOperatorFee = roundOperatorFee;
exports.stringifyBigints = stringifyBigints;
exports.tryCatch = tryCatch;