parse
Version:
Parse JavaScript SDK
52,552 lines • 1.75 MB
JavaScript
/**
* Parse JavaScript SDK v8.6.2
*
* Copyright 2015-present Parse Platform
* All rights reserved.
*
* The source tree of this library can be found at:
* https://github.com/parse-community/Parse-SDK-JS
*
* This source code is licensed under the license found in the LICENSE
* file in the root directory of this source tree. Additional legal
* information can be found in the NOTICE file in the same directory.
*/
(function(factory) {
typeof define === "function" && define.amd ? define([], factory) : factory();
})(function() {
//#region \0rolldown/runtime.js
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __esmMin = (fn, res, err) => () => {
if (err) throw err[0];
try {
return fn && (res = fn(fn = 0)), res;
} catch (e) {
throw err = [e], e;
}
};
var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
var __exportAll = (all, no_symbols) => {
let target = {};
for (var name in all) __defProp(target, name, {
get: all[name],
enumerable: true
});
if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
return target;
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
key = keys[i];
if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
get: ((k) => from[k]).bind(null, key),
enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
});
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
value: mod,
enumerable: true
}) : target, mod));
var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["module.exports"] : __copyProps(__defProp({}, "__esModule", { value: true }), mod);
//#endregion
//#region node_modules/vite-plugin-node-polyfills/shims/process/dist/index.js
function getDefaultExportFromCjs(x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
}
function defaultSetTimout() {
throw new Error("setTimeout has not been defined");
}
function defaultClearTimeout() {
throw new Error("clearTimeout has not been defined");
}
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 (e) {
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 (e) {
return cachedClearTimeout.call(this, marker);
}
}
}
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);
}
function Item(fun, array) {
this.fun = fun;
this.array = array;
}
function noop() {}
var browser, process, cachedSetTimeout, cachedClearTimeout, queue, draining, currentQueue, queueIndex, browserExports, process$1;
var init_dist$2 = __esmMin((() => {
browser = { exports: {} };
process = browser.exports = {};
(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;
}
})();
queue = [];
draining = false;
queueIndex = -1;
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);
};
Item.prototype.run = function() {
this.fun.apply(null, this.array);
};
process.title = "browser";
process.browser = true;
process.env = {};
process.argv = [];
process.version = "";
process.versions = {};
process.on = noop;
process.addListener = noop;
process.once = noop;
process.off = noop;
process.removeListener = noop;
process.removeAllListeners = noop;
process.emit = noop;
process.prependListener = noop;
process.prependOnceListener = noop;
process.listeners = function(name) {
return [];
};
process.binding = function(name) {
throw new Error("process.binding is not supported");
};
process.cwd = function() {
return "/";
};
process.chdir = function(dir) {
throw new Error("process.chdir is not supported");
};
process.umask = function() {
return 0;
};
browserExports = browser.exports;
process$1 = /*@__PURE__*/ getDefaultExportFromCjs(browserExports);
}));
//#endregion
//#region src/CoreManager.ts
init_dist$2();
var config = {
IS_NODE: typeof process$1 !== "undefined" && !!process$1.versions && !!process$1.versions.node && !process$1.versions.electron,
REQUEST_ATTEMPT_LIMIT: 5,
REQUEST_BATCH_SIZE: 20,
REQUEST_HEADERS: {},
SERVER_URL: "https://api.parse.com/1",
LIVEQUERY_SERVER_URL: null,
ENCRYPTED_KEY: null,
VERSION: "js8.6.2",
APPLICATION_ID: null,
JAVASCRIPT_KEY: null,
MAINTENANCE_KEY: null,
MASTER_KEY: null,
USE_MASTER_KEY: false,
PERFORM_USER_REWRITE: true,
FORCE_REVOCABLE_SESSION: false,
ENCRYPTED_USER: false,
IDEMPOTENCY: false,
ALLOW_CUSTOM_OBJECT_ID: false,
PARSE_ERRORS: [],
NODE_LOGGING: false
};
function requireMethods(name, methods, controller) {
methods.forEach((func) => {
if (typeof controller[func] !== "function") throw new Error(`${name} must implement ${func}()`);
});
}
var CoreManager = {
get: function(key) {
if (Object.hasOwn(config, key)) return config[key];
throw new Error("Configuration key not found: " + key);
},
set: function(key, value) {
config[key] = value;
},
setIfNeeded: function(key, value) {
if (!Object.hasOwn(config, key)) config[key] = value;
return config[key];
},
setAnalyticsController(controller) {
requireMethods("AnalyticsController", ["track"], controller);
config["AnalyticsController"] = controller;
},
getAnalyticsController() {
return config["AnalyticsController"];
},
setCloudController(controller) {
requireMethods("CloudController", [
"run",
"getJobsData",
"startJob"
], controller);
config["CloudController"] = controller;
},
getCloudController() {
return config["CloudController"];
},
setConfigController(controller) {
requireMethods("ConfigController", [
"current",
"get",
"save"
], controller);
config["ConfigController"] = controller;
},
getConfigController() {
return config["ConfigController"];
},
setCryptoController(controller) {
requireMethods("CryptoController", ["encrypt", "decrypt"], controller);
config["CryptoController"] = controller;
},
getCryptoController() {
return config["CryptoController"];
},
setEventEmitter(eventEmitter) {
config["EventEmitter"] = eventEmitter;
},
getEventEmitter() {
return config["EventEmitter"];
},
setFileController(controller) {
requireMethods("FileController", ["saveFile", "saveBase64"], controller);
config["FileController"] = controller;
},
setEventuallyQueue(controller) {
requireMethods("EventuallyQueue", [
"poll",
"save",
"destroy"
], controller);
config["EventuallyQueue"] = controller;
},
getEventuallyQueue() {
return config["EventuallyQueue"];
},
getFileController() {
return config["FileController"];
},
setInstallationController(controller) {
requireMethods("InstallationController", [
"currentInstallationId",
"currentInstallation",
"updateInstallationOnDisk"
], controller);
config["InstallationController"] = controller;
},
getInstallationController() {
return config["InstallationController"];
},
setLiveQuery(liveQuery) {
config["LiveQuery"] = liveQuery;
},
getLiveQuery() {
return config["LiveQuery"];
},
setObjectController(controller) {
requireMethods("ObjectController", [
"save",
"fetch",
"destroy"
], controller);
config["ObjectController"] = controller;
},
getObjectController() {
return config["ObjectController"];
},
setObjectStateController(controller) {
requireMethods("ObjectStateController", [
"getState",
"initializeState",
"removeState",
"getServerData",
"setServerData",
"getPendingOps",
"setPendingOp",
"pushPendingState",
"popPendingState",
"mergeFirstPendingState",
"getObjectCache",
"estimateAttribute",
"estimateAttributes",
"commitServerChanges",
"enqueueTask",
"clearAllState"
], controller);
config["ObjectStateController"] = controller;
},
getObjectStateController() {
return config["ObjectStateController"];
},
setPushController(controller) {
requireMethods("PushController", ["send"], controller);
config["PushController"] = controller;
},
getPushController() {
return config["PushController"];
},
setQueryController(controller) {
requireMethods("QueryController", ["find", "aggregate"], controller);
config["QueryController"] = controller;
},
getQueryController() {
return config["QueryController"];
},
setRESTController(controller) {
requireMethods("RESTController", ["request", "ajax"], controller);
config["RESTController"] = controller;
},
getRESTController() {
return config["RESTController"];
},
setSchemaController(controller) {
requireMethods("SchemaController", [
"get",
"create",
"update",
"delete",
"send",
"purge"
], controller);
config["SchemaController"] = controller;
},
getSchemaController() {
return config["SchemaController"];
},
setSessionController(controller) {
requireMethods("SessionController", ["getSession"], controller);
config["SessionController"] = controller;
},
getSessionController() {
return config["SessionController"];
},
setStorageController(controller) {
if (controller.async) requireMethods("An async StorageController", [
"getItemAsync",
"setItemAsync",
"removeItemAsync",
"getAllKeysAsync"
], controller);
else requireMethods("A synchronous StorageController", [
"getItem",
"setItem",
"removeItem",
"getAllKeys"
], controller);
config["StorageController"] = controller;
},
setLocalDatastoreController(controller) {
requireMethods("LocalDatastoreController", [
"pinWithName",
"fromPinWithName",
"unPinWithName",
"getAllContents",
"clear"
], controller);
config["LocalDatastoreController"] = controller;
},
getLocalDatastoreController() {
return config["LocalDatastoreController"];
},
setLocalDatastore(store) {
config["LocalDatastore"] = store;
},
getLocalDatastore() {
return config["LocalDatastore"];
},
getStorageController() {
return config["StorageController"];
},
setAsyncStorage(storage) {
config["AsyncStorage"] = storage;
},
getAsyncStorage() {
return config["AsyncStorage"];
},
setWebSocketController(controller) {
config["WebSocketController"] = controller;
},
getWebSocketController() {
return config["WebSocketController"];
},
setUserController(controller) {
requireMethods("UserController", [
"setCurrentUser",
"currentUser",
"currentUserAsync",
"signUp",
"logIn",
"become",
"logOut",
"me",
"requestPasswordReset",
"upgradeToRevocableSession",
"requestEmailVerification",
"verifyPassword",
"linkWith"
], controller);
config["UserController"] = controller;
},
getUserController() {
return config["UserController"];
},
setLiveQueryController(controller) {
requireMethods("LiveQueryController", [
"setDefaultLiveQueryClient",
"getDefaultLiveQueryClient",
"_clearCachedDefaultClient"
], controller);
config["LiveQueryController"] = controller;
},
getLiveQueryController() {
return config["LiveQueryController"];
},
setHooksController(controller) {
requireMethods("HooksController", [
"create",
"get",
"update",
"remove"
], controller);
config["HooksController"] = controller;
},
getHooksController() {
return config["HooksController"];
},
setParseOp(op) {
config["ParseOp"] = op;
},
getParseOp() {
return config["ParseOp"];
},
setParseObject(object) {
config["ParseObject"] = object;
},
getParseObject() {
return config["ParseObject"];
},
setParseQuery(query) {
config["ParseQuery"] = query;
},
getParseQuery() {
return config["ParseQuery"];
},
setParseRole(role) {
config["ParseRole"] = role;
},
getParseRole() {
return config["ParseRole"];
},
setParseUser(user) {
config["ParseUser"] = user;
},
getParseUser() {
return config["ParseUser"];
}
};
//#endregion
//#region node_modules/vite-plugin-node-polyfills/shims/buffer/dist/index.js
function getLens(b64) {
var len = b64.length;
if (len % 4 > 0) throw new Error("Invalid string. Length must be a multiple of 4");
var validLen = b64.indexOf("=");
if (validLen === -1) validLen = len;
var placeHoldersLen = validLen === len ? 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 len = placeHoldersLen > 0 ? validLen - 4 : validLen;
var i;
for (i = 0; i < len; i += 4) {
tmp = revLookup[b64.charCodeAt(i)] << 18 | revLookup[b64.charCodeAt(i + 1)] << 12 | revLookup[b64.charCodeAt(i + 2)] << 6 | revLookup[b64.charCodeAt(i + 3)];
arr[curByte++] = tmp >> 16 & 255;
arr[curByte++] = tmp >> 8 & 255;
arr[curByte++] = tmp & 255;
}
if (placeHoldersLen === 2) {
tmp = revLookup[b64.charCodeAt(i)] << 2 | revLookup[b64.charCodeAt(i + 1)] >> 4;
arr[curByte++] = tmp & 255;
}
if (placeHoldersLen === 1) {
tmp = revLookup[b64.charCodeAt(i)] << 10 | revLookup[b64.charCodeAt(i + 1)] << 4 | revLookup[b64.charCodeAt(i + 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 i = start; i < end; i += 3) {
tmp = (uint8[i] << 16 & 16711680) + (uint8[i + 1] << 8 & 65280) + (uint8[i + 2] & 255);
output.push(tripletToBase64(tmp));
}
return output.join("");
}
function fromByteArray(uint8) {
var tmp;
var len = uint8.length;
var extraBytes = len % 3;
var parts = [];
var maxChunkLength = 16383;
for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) parts.push(encodeChunk(uint8, i, i + maxChunkLength > len2 ? len2 : i + maxChunkLength));
if (extraBytes === 1) {
tmp = uint8[len - 1];
parts.push(lookup[tmp >> 2] + lookup[tmp << 4 & 63] + "==");
} else if (extraBytes === 2) {
tmp = (uint8[len - 2] << 8) + uint8[len - 1];
parts.push(lookup[tmp >> 10] + lookup[tmp >> 4 & 63] + lookup[tmp << 2 & 63] + "=");
}
return parts.join("");
}
var buffer, base64Js, lookup, revLookup, Arr, code, i, len, ieee754, Buffer$1, Blob$1, BlobOptions, Buffer$1$1, File, FileOptions, INSPECT_MAX_BYTES, SlowBuffer, TranscodeEncoding, atob, btoa, constants, isAscii, isUtf8, kMaxLength, kStringMaxLength, resolveObjectURL, transcode;
var init_dist$1 = __esmMin((() => {
buffer = {};
base64Js = {};
base64Js.byteLength = byteLength;
base64Js.toByteArray = toByteArray;
base64Js.fromByteArray = fromByteArray;
lookup = [];
revLookup = [];
Arr = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
for (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;
ieee754 = {};
/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
ieee754.read = function(buffer, 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 i = isLE ? nBytes - 1 : 0;
var d = isLE ? -1 : 1;
var s = buffer[offset + i];
i += d;
e = s & (1 << -nBits) - 1;
s >>= -nBits;
nBits += eLen;
for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8);
m = e & (1 << -nBits) - 1;
e >>= -nBits;
nBits += mLen;
for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8);
if (e === 0) e = 1 - eBias;
else if (e === eMax) return m ? NaN : (s ? -1 : 1) * Infinity;
else {
m = m + Math.pow(2, mLen);
e = e - eBias;
}
return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
};
ieee754.write = function(buffer, 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 i = isLE ? 0 : nBytes - 1;
var d = isLE ? 1 : -1;
var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
value = Math.abs(value);
if (isNaN(value) || value === Infinity) {
m = isNaN(value) ? 1 : 0;
e = eMax;
} else {
e = Math.floor(Math.log(value) / Math.LN2);
if (value * (c = Math.pow(2, -e)) < 1) {
e--;
c *= 2;
}
if (e + eBias >= 1) value += rt / c;
else value += rt * Math.pow(2, 1 - eBias);
if (value * c >= 2) {
e++;
c /= 2;
}
if (e + eBias >= eMax) {
m = 0;
e = eMax;
} else if (e + eBias >= 1) {
m = (value * c - 1) * Math.pow(2, mLen);
e = e + eBias;
} else {
m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
e = 0;
}
}
for (; mLen >= 8; buffer[offset + i] = m & 255, i += d, m /= 256, mLen -= 8);
e = e << mLen | m;
eLen += mLen;
for (; eLen > 0; buffer[offset + i] = e & 255, i += d, e /= 256, eLen -= 8);
buffer[offset + i - d] |= s * 128;
};
/*!
* The buffer module from node.js, for the browser.
*
* @author Feross Aboukhadijeh <https://feross.org>
* @license MIT
*/
(function(exports) {
const base64 = base64Js;
const ieee754$1 = ieee754;
const customInspectSymbol = typeof Symbol === "function" && typeof Symbol["for"] === "function" ? Symbol["for"]("nodejs.util.inspect.custom") : null;
exports.Buffer = Buffer;
exports.SlowBuffer = SlowBuffer;
exports.INSPECT_MAX_BYTES = 50;
const K_MAX_LENGTH = 2147483647;
exports.kMaxLength = K_MAX_LENGTH;
const { Uint8Array: GlobalUint8Array, ArrayBuffer: GlobalArrayBuffer, SharedArrayBuffer: GlobalSharedArrayBuffer } = globalThis;
/**
* If `Buffer.TYPED_ARRAY_SUPPORT`:
* === true Use Uint8Array implementation (fastest)
* === false Print warning and recommend using `buffer` v4.x which has an Object
* implementation (most compatible, even IE6)
*
* Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
* Opera 11.6+, iOS 4.2+.
*
* We report that the browser does not support typed arrays if the are not subclassable
* using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`
* (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support
* for __proto__ and has a buggy typed array implementation.
*/
Buffer.TYPED_ARRAY_SUPPORT = typedArraySupport();
if (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== "undefined" && typeof console.error === "function") console.error("This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support.");
function typedArraySupport() {
try {
const arr = new GlobalUint8Array(1);
const proto = { foo: function() {
return 42;
} };
Object.setPrototypeOf(proto, GlobalUint8Array.prototype);
Object.setPrototypeOf(arr, proto);
return arr.foo() === 42;
} catch (e) {
return false;
}
}
Object.defineProperty(Buffer.prototype, "parent", {
enumerable: true,
get: function() {
if (!Buffer.isBuffer(this)) return void 0;
return this.buffer;
}
});
Object.defineProperty(Buffer.prototype, "offset", {
enumerable: true,
get: function() {
if (!Buffer.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, Buffer.prototype);
return buf;
}
/**
* The Buffer constructor returns instances of `Uint8Array` that have their
* prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
* `Uint8Array`, so the returned instances will have all the node `Buffer` methods
* and the `Uint8Array` methods. Square bracket notation works as expected -- it
* returns a single octet.
*
* The `Uint8Array` prototype remains unmodified.
*/
function Buffer(arg, encodingOrOffset, length) {
if (typeof arg === "number") {
if (typeof encodingOrOffset === "string") throw new TypeError("The \"string\" argument must be of type string. Received type number");
return allocUnsafe(arg);
}
return from(arg, encodingOrOffset, length);
}
Buffer.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 Buffer.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 Buffer.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);
}
/**
* Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
* if value is a number.
* Buffer.from(str[, encoding])
* Buffer.from(array)
* Buffer.from(buffer)
* Buffer.from(arrayBuffer[, byteOffset[, length]])
**/
Buffer.from = function(value, encodingOrOffset, length) {
return from(value, encodingOrOffset, length);
};
Object.setPrototypeOf(Buffer.prototype, GlobalUint8Array.prototype);
Object.setPrototypeOf(Buffer, GlobalUint8Array);
function assertSize(size) {
if (typeof size !== "number") throw new TypeError("\"size\" argument must be of type number");
else if (size < 0) throw new RangeError("The value \"" + size + "\" is invalid for option \"size\"");
}
function alloc(size, fill, encoding) {
assertSize(size);
if (size <= 0) return createBuffer(size);
if (fill !== void 0) return typeof encoding === "string" ? createBuffer(size).fill(fill, encoding) : createBuffer(size).fill(fill);
return createBuffer(size);
}
/**
* Creates a new filled Buffer instance.
* alloc(size[, fill[, encoding]])
**/
Buffer.alloc = function(size, fill, encoding) {
return alloc(size, fill, encoding);
};
function allocUnsafe(size) {
assertSize(size);
return createBuffer(size < 0 ? 0 : checked(size) | 0);
}
/**
* Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
* */
Buffer.allocUnsafe = function(size) {
return allocUnsafe(size);
};
/**
* Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
*/
Buffer.allocUnsafeSlow = function(size) {
return allocUnsafe(size);
};
function fromString(string, encoding) {
if (typeof encoding !== "string" || encoding === "") encoding = "utf8";
if (!Buffer.isEncoding(encoding)) throw new TypeError("Unknown encoding: " + encoding);
const length = byteLength(string, encoding) | 0;
let buf = createBuffer(length);
const actual = buf.write(string, encoding);
if (actual !== length) buf = buf.slice(0, actual);
return buf;
}
function fromArrayLike(array) {
const length = array.length < 0 ? 0 : checked(array.length) | 0;
const buf = createBuffer(length);
for (let i = 0; i < length; i += 1) buf[i] = array[i] & 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, Buffer.prototype);
return buf;
}
function fromObject(obj) {
if (Buffer.isBuffer(obj)) {
const len = checked(obj.length) | 0;
const buf = createBuffer(len);
if (buf.length === 0) return buf;
obj.copy(buf, 0, 0, len);
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 Buffer.alloc(+length);
}
Buffer.isBuffer = function isBuffer(b) {
return b != null && b._isBuffer === true && b !== Buffer.prototype;
};
Buffer.compare = function compare(a, b) {
if (isInstance(a, GlobalUint8Array)) a = Buffer.from(a, a.offset, a.byteLength);
if (isInstance(b, GlobalUint8Array)) b = Buffer.from(b, b.offset, b.byteLength);
if (!Buffer.isBuffer(a) || !Buffer.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 i = 0, len = Math.min(x, y); i < len; ++i) if (a[i] !== b[i]) {
x = a[i];
y = b[i];
break;
}
if (x < y) return -1;
if (y < x) return 1;
return 0;
};
Buffer.isEncoding = function isEncoding(encoding) {
switch (String(encoding).toLowerCase()) {
case "hex":
case "utf8":
case "utf-8":
case "ascii":
case "latin1":
case "binary":
case "base64":
case "ucs2":
case "ucs-2":
case "utf16le":
case "utf-16le": return true;
default: return false;
}
};
Buffer.concat = function concat(list, length) {
if (!Array.isArray(list)) throw new TypeError("\"list\" argument must be an Array of Buffers");
if (list.length === 0) return Buffer.alloc(0);
let i;
if (length === void 0) {
length = 0;
for (i = 0; i < list.length; ++i) length += list[i].length;
}
const buffer = Buffer.allocUnsafe(length);
let pos = 0;
for (i = 0; i < list.length; ++i) {
let buf = list[i];
if (isInstance(buf, GlobalUint8Array)) if (pos + buf.length > buffer.length) {
if (!Buffer.isBuffer(buf)) buf = Buffer.from(buf);
buf.copy(buffer, pos);
} else GlobalUint8Array.prototype.set.call(buffer, buf, pos);
else if (!Buffer.isBuffer(buf)) throw new TypeError("\"list\" argument must be an Array of Buffers");
else buf.copy(buffer, pos);
pos += buf.length;
}
return buffer;
};
function byteLength(string, encoding) {
if (Buffer.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 len = string.length;
const mustMatch = arguments.length > 2 && arguments[2] === true;
if (!mustMatch && len === 0) return 0;
let loweredCase = false;
for (;;) switch (encoding) {
case "ascii":
case "latin1":
case "binary": return len;
case "utf8":
case "utf-8": return utf8ToBytes(string).length;
case "ucs2":
case "ucs-2":
case "utf16le":
case "utf-16le": return len * 2;
case "hex": return len >>> 1;
case "base64": return base64ToBytes(string).length;
default:
if (loweredCase) return mustMatch ? -1 : utf8ToBytes(string).length;
encoding = ("" + encoding).toLowerCase();
loweredCase = true;
}
}
Buffer.byteLength = byteLength;
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;
}
}
Buffer.prototype._isBuffer = true;
function swap(b, n, m) {
const i = b[n];
b[n] = b[m];
b[m] = i;
}
Buffer.prototype.swap16 = function swap16() {
const len = this.length;
if (len % 2 !== 0) throw new RangeError("Buffer size must be a multiple of 16-bits");
for (let i = 0; i < len; i += 2) swap(this, i, i + 1);
return this;
};
Buffer.prototype.swap32 = function swap32() {
const len = this.length;
if (len % 4 !== 0) throw new RangeError("Buffer size must be a multiple of 32-bits");
for (let i = 0; i < len; i += 4) {
swap(this, i, i + 3);
swap(this, i + 1, i + 2);
}
return this;
};
Buffer.prototype.swap64 = function swap64() {
const len = this.length;
if (len % 8 !== 0) throw new RangeError("Buffer size must be a multiple of 64-bits");
for (let i = 0; i < len; i += 8) {
swap(this, i, i + 7);
swap(this, i + 1, i + 6);
swap(this, i + 2, i + 5);
swap(this, i + 3, i + 4);
}
return this;
};
Buffer.prototype.toString = function toString() {
const length = this.length;
if (length === 0) return "";
if (arguments.length === 0) return utf8Slice(this, 0, length);
return slowToString.apply(this, arguments);
};
Buffer.prototype.toLocaleString = Buffer.prototype.toString;
Buffer.prototype.equals = function equals(b) {
if (!Buffer.isBuffer(b)) throw new TypeError("Argument must be a Buffer");
if (this === b) return true;
return Buffer.compare(this, b) === 0;
};
Buffer.prototype.inspect = function inspect() {
let str = "";
const max = exports.INSPECT_MAX_BYTES;
str = this.toString("hex", 0, max).replace(/(.{2})/g, "$1 ").trim();
if (this.length > max) str += " ... ";
return "<Buffer " + str + ">";
};
if (customInspectSymbol) Buffer.prototype[customInspectSymbol] = Buffer.prototype.inspect;
Buffer.prototype.compare = function compare(target, start, end, thisStart, thisEnd) {
if (isInstance(target, GlobalUint8Array)) target = Buffer.from(target, target.offset, target.byteLength);
if (!Buffer.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 len = Math.min(x, y);
const thisCopy = this.slice(thisStart, thisEnd);
const targetCopy = target.slice(start, end);
for (let i = 0; i < len; ++i) if (thisCopy[i] !== targetCopy[i]) {
x = thisCopy[i];
y = targetCopy[i];
break;
}
if (x < y) return -1;
if (y < x) return 1;
return 0;
};
function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {
if (buffer.length === 0) return -1;
if (typeof byteOffset === "string") {
encoding = byteOffset;
byteOffset = 0;
} else if (byteOffset > 2147483647) byteOffset = 2147483647;
else if (byteOffset < -2147483648) byteOffset = -2147483648;
byteOffset = +byteOffset;
if (numberIsNaN(byteOffset)) byteOffset = dir ? 0 : buffer.length - 1;
if (byteOffset < 0) byteOffset = buffer.length + byteOffset;
if (byteOffset >= buffer.length) if (dir) return -1;
else byteOffset = buffer.length - 1;
else if (byteOffset < 0) if (dir) byteOffset = 0;
else return -1;
if (typeof val === "string") val = Buffer.from(val, encoding);
if (Buffer.isBuffer(val)) {
if (val.length === 0) return -1;
return arrayIndexOf(buffer, 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(buffer, val, byteOffset);
else return GlobalUint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset);
return arrayIndexOf(buffer, [val], byteOffset, encoding, dir);
}
throw new TypeError("val must be string, number or Buffer");
}
function arrayIndexOf(arr, val, byteOffset, encoding, dir) {
let indexSize = 1;
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, i) {
if (indexSize === 1) return buf[i];
else return buf.readUInt16BE(i * indexSize);
}
let i;
if (dir) {
let foundIndex = -1;
for (i = byteOffset; i < arrLength; i++) if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
if (foundIndex === -1) foundIndex = i;
if (i - foundIndex + 1 === valLength) return foundIndex * indexSize;
} else {
if (foundIndex !== -1) i -= i - foundIndex;
foundIndex = -1;
}
} else {
if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength;
for (i = byteOffset; i >= 0; i--) {
let found = true;
for (let j = 0; j < valLength; j++) if (read(arr, i + j) !== read(val, j)) {
found = false;
break;
}
if (found) return i;
}
}
return -1;
}
Buffer.prototype.includes = function includes(val, byteOffset, encoding) {
return this.indexOf(val, byteOffset, encoding) !== -1;
};
Buffer.prototype.indexOf = function indexOf(val, byteOffset, encoding) {
return bidirectionalIndexOf(this, val, byteOffset, encoding, true);
};
Buffer.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 i;
for (i = 0; i < length; ++i) {
const parsed = parseInt(string.substr(i * 2, 2), 16);
if (numberIsNaN(parsed)) return i;
buf[offset + i] = parsed;
}
return i;
}
function utf8Write(buf, string, offset, length) {
return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length);
}
function asciiWrite(buf, string, offset, length) {
return blitBuffer(asciiToBytes(string), buf, offset, length);
}
function base64Write(buf, string, offset, length) {
return blitBuffer(base64ToBytes(string), buf, offset, length);
}
function ucs2Write(buf, string, offset, length) {
return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length);
}
Buffer.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;
}
};
Buffer.prototype.toJSON = function toJSON() {
return {
type: "Buffer",
data: Array.prototype.slice.call(this._arr || this, 0)
};
};
function base64Slice(buf, start, end) {
if (start === 0 && end === buf.length) return base64.fromByteArray(buf);
else return base64.fromByteArray(buf.slice(start, end));
}
function utf8Slice(buf, start, end) {
end = Math.min(buf.length, end);
const res = [];
let i = start;
while (i < end) {
const firstByte = buf[i];
let codePoint = null;
let bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
if (i + bytesPerSequence <= end) {
let secondByte, thirdByte, fourthByte, tempCodePoint;
switch (bytesPerSequence) {
case 1:
if (firstByte < 128) codePoint = firstByte;
break;
case 2:
secondByte = buf[i + 1];
if ((secondByte & 192) === 128) {
tempCodePoint = (firstByte & 31) << 6 | secondByte & 63;
if (tempCodePoint > 127) codePoint = tempCodePoint;
}
break;
case 3:
secondByte = buf[i + 1];
thirdByte = buf[i + 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[i + 1];
thirdByte = buf[i + 2];
fourthByte = buf[i + 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);
i += bytesPerSequence;
}
return decodeCodePointsArray(res);
}
const MAX_ARGUMENTS_LENGTH = 4096;
function decodeCodePointsArray(codePoints) {
const len = codePoints.length;
if (len <= MAX_ARGUMENTS_LENGTH) return String.fromCharCode.apply(String, codePoints);
let res = "";
let i = 0;
while (i < len) res += String.fromCharCode.apply(String, codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH));
return res;
}
function asciiSlice(buf, start, end) {
let ret = "";
end = Math.min(buf.length, end);
for (let i = start; i < end; ++i) ret += String.fromCharCode(buf[i] & 127);
return ret;
}
function latin1Slice(buf, start, end) {
let ret = "";
end = Math.min(buf.length, end);
for (let i = start; i < end; ++i) ret += String.fromCharCode(buf[i]);
return ret;
}
function hexSlice(buf, start, end) {
const len = buf.length;
if (!start || start < 0) start = 0;
if (!end || end < 0 || end > len) end = len;
let out = "";
for (let i = start; i < end; ++i) out += hexSliceLookupTable[buf[i]];
return out;
}
function utf16leSlice(buf, start, end) {
const bytes = buf.slice(start, end);
let res = "";
for (let i = 0; i < bytes.length - 1; i += 2) res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);
return res;
}
Buffer.prototype.slice = function slice(start, end) {
const len = this.length;
start = ~~start;
end = end === void 0 ? len : ~~end;
if (start < 0) {
start += len;
if (start < 0) start = 0;
} else if (start > len) start = len;
if (end < 0) {
end += len;
if (end < 0) end = 0;
} else if (end > len) end = len;
if (end < start) end = start;
const newBuf = this.subarray(start, end);
Object.setPrototypeOf(newBuf, Buffer.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");
}
Buffer.prototype.readUintLE = Buffer.prototype.readUIntLE = function readUIntLE(offset, byteLength, noAssert) {
offset = offset >>> 0;
byteLength = byteLength >>> 0;
if (!noAssert) checkOffset(offset, byteLength, this.length);
let val = this[offset];
let mul = 1;
let i = 0;
while (++i < byteLength && (mul *= 256)) val += this[offset + i] * mul;
return val;
};
Buffer.prototype.readUintBE = Buffer.prototype.readUIntBE = function readUIntBE(offset, byteLength, noAssert) {
offset = offset >>> 0;
byteLength = byteLength >>> 0;
if (!noAssert) checkOffset(offset, byteLength, this.length);
let val = this[offset + --byteLength];
let mul = 1;
while (byteLength > 0 && (mul *= 256)) val += this[offset + --byteLength] * mul;
return val;
};
Buffer.prototype.readUint8 = Buffer.prototype.readUInt8 = function readUInt8(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 1, this.length);
return this[offset];
};
Buffer.prototype.readUint16LE = Buffer.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 2, this.length);
return this[offset] | this[offset + 1] << 8;
};
Buffer.prototype.readUint16BE = Buffer.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 2, this.length);
return this[offset] << 8 | this[offset + 1];
};
Buffer.prototype.readUint32LE = Buffer.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;
};
Buffer.prototype.readUint32BE = Buffer.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 4, this.length);
return this[offset] * 16777216 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]);
};
Buffer.prototype.readBigUInt64LE = defineBigIntMethod(function readBigUInt64LE(offset) {
offset = offset >>> 0;
validateNumber(offset, "offset");
const first = this[offset];
const last = this[offset + 7];
if (first === void 0 || last === void 0) boundsError(offset, this.length - 8);
const lo = first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24;
const hi = this[++offset] + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + last * 2 ** 24;
return BigInt(lo) + (BigInt(hi) << BigInt(32));
});
Buffer.prototype.readBigUInt64BE = defineBigIntMethod(function readBigUInt64BE(offset) {
offset = offset >>> 0;
validateNumber(offset, "offset");
const first = this[offset];
const last = this[offset + 7];
if (first === void 0 || last === void 0) boundsError(offset, this.length - 8);
const hi = first * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset];
const lo = this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last;
return (BigInt(hi) << BigInt(32)) + BigInt(lo);
});
Buffer.prototype.readIntLE = function readIntLE(offset, byteLength, noAssert) {
offset = offset >>> 0;
byteLength = byteLength >>> 0;
if (!noAssert) checkOffset(offset, byteLength, this.length);
let val = this[offset];
let mul = 1;
let i = 0;
while (++i < byteLength && (mul *= 256)) val += this[offset + i] * mul;
mul *= 128;
if (val >= mul) val -= Math.pow(2, 8 * byteLength);
return val;
};
Buffer.prototype.readIntBE = function readIntBE(offset, byteLength, noAssert) {
offset = offset >>> 0;
byteLength = byteLength >>> 0;
if (!noAssert) checkOffset(offset, byteLength, this.length);
let i = byteLength;
let mul = 1;
let val = this[offset + --i];
while (i > 0 && (mul *= 256)) val += this[offset + --i] * mul;
mul *= 128;
if (val >= mul) val -= Math.pow(2, 8 * byteLength);
return val;
};
Buffer.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;
};
Buffer.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;
};
Buffer.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;
};
Buffer.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;
};
Buffer.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];
};
Buffer.prototype.readBigInt64LE = defineBigIntMethod(function readBigInt64LE(offset) {
offset = offset >>> 0;
validateNumber(offset, "offset");
const first = this[offset];
const last = this[offset + 7];
if (first === void 0 || last === void 0) boundsError(offset, this.length - 8);
const val = this[offset + 4] + this[offset + 5] * 2 ** 8 + this[offset + 6] * 2 ** 16 + (last << 24);
return (BigInt(val) << BigInt(32)) + BigInt(first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24);
});
Buffer.prototype.readBigInt64BE = defineBigIntMethod(function readBigInt64BE(offset) {
offset = offset >>> 0;
validateNumber(offset, "offset");
const first = this[offset];
const last = this[offset + 7];
if (first === void 0 || last === void 0) boundsError(offset, this.length - 8);
const val = (first << 24) + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset];
return (BigInt(val) << BigInt(32)) + BigInt(this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last);
});
Buffer.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);
};
Buffer.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);
};
Buffer.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);
};
Buffer.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 8, this.length);
return ieee754$1.read(this, offset, false, 52, 8);
};
function checkInt(buf, value, offset, ext, max, min) {
if (!Buffer.isBuffer(buf)) throw new TypeError("\"buffer\" argument must be a Buffer instance");
if (value > max || value < min) throw new RangeError("\"value\" argument is out of bounds");
if (offset + ext > buf.length) throw new RangeError("Index out of range");
}
Buffer.prototype.writeUintLE = Buffer.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength, noAssert) {
value = +value;
offset = offset >>> 0;
byteLength = byteLength >>> 0;
if (!noAssert) {
const maxBytes = Math.pow(2, 8 * byteLength) - 1;
checkInt(this, value, offset, byteLength, maxBytes, 0);
}
let mul = 1;
let i = 0;
this[offset] = value & 255;
while (++i < byteLength && (mul *= 256)) this[offset + i] = value / mul & 255;
return offset + byteLength;
};
Buffer.prototype.writeUintBE = Buffer.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength, noAssert) {
value = +value;
offset = offset >>> 0;
byteLength = byteLength >>> 0;
if (!noAssert) {
const maxBytes = Math.pow(2, 8 * byteLength) - 1;
checkInt(this, value, offset, byteLength, maxBytes, 0);
}
let i = byteLength - 1;
let mul = 1;
this[offset + i] = value & 255;
while (--i >= 0 && (mul *= 256)) this[offset + i] = value / mul & 255;
return offset + byteLength;
};
Buffer.prototype.writeUint8 = Buffer.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;
};
Buffer.prototype.writeUint16LE = Buffer.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;
};
Buffer.prototype.writeUint16BE = Buffer.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;
};
Buffer.prototype.writeUint32LE = Buffer.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;
};
Buffer.prototype.writeUint32BE = Buffer.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0);
this[offset] = value >>> 24;
this[offset + 1] = value >>> 16;
this[offset + 2] = value >>> 8;
this[offset + 3] = value & 255;
return offset + 4;
};
function wrtBigUInt64LE(buf, value, offset, min, max) {
checkIntBI(value, min, max, buf, offset, 7);
let lo = Number(value & BigInt(4294967295));
buf[offset++] = lo;
lo = lo >> 8;
buf[offset++] = lo;
lo = lo >> 8;
buf[offset++] = lo;
lo = lo >> 8;
buf[offset++] = lo;
let hi = Number(value >> BigInt(32) & BigInt(4294967295));
buf[offset++] = hi;
hi = hi >> 8;
buf[offset++] = hi;
hi = hi >> 8;
buf[offset++] = hi;
hi = hi >> 8;
buf[offset++] = hi;
return offset;
}
function wrtBigUInt64BE(buf, value, offset, min, max) {
checkIntBI(value, min, max, buf, offset, 7);
let lo = Number(value & BigInt(4294967295));
buf[offset + 7] = lo;
lo = lo >> 8;
buf[offset + 6] = lo;
lo = lo >> 8;
buf[offset + 5] = lo;
lo = lo >> 8;
buf[offset + 4] = lo;
let hi = Number(value >> BigInt(32) & BigInt(4294967295));
buf[offset + 3] = hi;
hi = hi >> 8;
buf[offset + 2] = hi;
hi = hi >> 8;
buf[offset + 1] = hi;
hi = hi >> 8;
buf[offset] = hi;
return offset + 8;
}
Buffer.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE(value, offset = 0) {
return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
});
Buffer.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE(value, offset = 0) {
return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
});
Buffer.prototype.writeIntLE = function writeIntLE(value, offset, byteLength, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) {
const limit = Math.pow(2, 8 * byteLength - 1);
checkInt(this, value, offset, byteLength, limit - 1, -limit);
}
let i = 0;
let mul = 1;
let sub = 0;
this[offset] = value & 255;
while (++i < byteLength && (mul *= 256)) {
if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) sub = 1;
this[offset + i] = (value / mul >> 0) - sub & 255;
}
return offset + byteLength;
};
Buffer.prototype.writeIntBE = function writeIntBE(value, offset, byteLength, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) {
const limit = Math.pow(2, 8 * byteLength - 1);
checkInt(this, value, offset, byteLength, limit - 1, -limit);
}
let i = byteLength - 1;
let mul = 1;
let sub = 0;
this[offset + i] = value & 255;
while (--i >= 0 && (mul *= 256)) {
if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) sub = 1;
this[offset + i] = (value / mul >> 0) - sub & 255;
}
return offset + byteLength;
};
Buffer.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;
};
Buffer.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;
};
Buffer.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;
};
Buffer.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;
};
Buffer.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;
};
Buffer.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE(value, offset = 0) {
return wrtBigUInt64LE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
});
Buffer.prototype.writeBigInt64BE = defineBigIntMethod(function writeBigInt64BE(value, offset = 0) {
return wrtBigUInt64BE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
});
function checkIEEE754(buf, value, offset, ext, max, min) {
if (offset + ext > buf.length) throw new RangeError("Index out of range");
if (offset < 0) throw new RangeError("Index out of range");
}
function writeFloat(buf, value, offset, littleEndian, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) checkIEEE754(buf, value, offset, 4);
ieee754$1.write(buf, value, offset, littleEndian, 23, 4);
return offset + 4;
}
Buffer.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) {
return writeFloat(this, value, offset, true, noAssert);
};
Buffer.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;
}
Buffer.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) {
return writeDouble(this, value, offset, true, noAssert);
};
Buffer.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) {
return writeDouble(this, value, offset, false, noAssert);
};
Buffer.prototype.copy = function copy(target, targetStart, start, end) {
if (!Buffer.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 len = 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 len;
};
Buffer.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" && !Buffer.isEncoding(encoding)) throw new TypeError("Unknown encoding: " + encoding);
if (val.length === 1) {
const code = val.charCodeAt(0);
if (encoding === "utf8" && code < 128 || encoding === "latin1") val = code;
}
} 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 i;
if (typeof val === "number") for (i = start; i < end; ++i) this[i] = val;
else {
const bytes = Buffer.isBuffer(val) ? val : Buffer.from(val, encoding);
const len = bytes.length;
if (len === 0) throw new TypeError("The value \"" + val + "\" is invalid for argument \"value\"");
for (i = 0; i < end - start; ++i) this[i + start] = bytes[i % len];
}
return this;
};
const errors = {};
function E(sym, getMessage, Base) {
errors[sym] = class NodeError extends Base {
constructor() {
super();
Object.defineProperty(this, "message", {
value: getMessage.apply(this, arguments),
writable: true,
configurable: true
});
this.name = `${this.name} [${sym}]`;
this.stack;
delete this.name;
}
get code() {
return sym;
}
set code(value) {
Object.defineProperty(this, "code", {
configurable: true,
enumerable: true,
value,
writable: true
});
}
toString() {
return `${this.name} [${sym}]: ${this.message}`;
}
};
}
E("ERR_BUFFER_OUT_OF_BOUNDS", function(name) {
if (name) return `${name} is outside of buffer bounds`;
return "Attempt to access memory outside buffer bounds";
}, RangeError);
E("ERR_INVALID_ARG_TYPE", function(name, actual) {
return `The "${name}" argument must be of type number. Received type ${typeof actual}`;
}, TypeError);
E("ERR_OUT_OF_RANGE", function(str, range, input) {
let msg = `The value of "${str}" is out of range.`;
let received = input;
if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) received = addNumericalSeparator(String(input));
else if (typeof input === "bigint") {
received = String(input);
if (input > BigInt(2) ** BigInt(32) || input < -(BigInt(2) ** BigInt(32))) received = addNumericalSeparator(received);
received += "n";
}
msg += ` It must be ${range}. Received ${received}`;
return msg;
}, RangeError);
function addNumericalSeparator(val) {
let res = "";
let i = val.length;
const start = val[0] === "-" ? 1 : 0;
for (; i >= start + 4; i -= 3) res = `_${val.slice(i - 3, i)}${res}`;
return `${val.slice(0, i)}${res}`;
}
function checkBounds(buf, offset, byteLength) {
validateNumber(offset, "offset");
if (buf[offset] === void 0 || buf[offset + byteLength] === void 0) boundsError(offset, buf.length - (byteLength + 1));
}
function checkIntBI(value, min, max, buf, offset, byteLength) {
if (value > max || value < min) {
const n = typeof min === "bigint" ? "n" : "";
let range;
if (byteLength > 3) if (min === 0 || min === BigInt(0)) range = `>= 0${n} and < 2${n} ** ${(byteLength + 1) * 8}${n}`;
else range = `>= -(2${n} ** ${(byteLength + 1) * 8 - 1}${n}) and < 2 ** ${(byteLength + 1) * 8 - 1}${n}`;
else range = `>= ${min}${n} and <= ${max}${n}`;
throw new errors.ERR_OUT_OF_RANGE("value", range, value);
}
checkBounds(buf, offset, byteLength);
}
function validateNumber(value, name) {
if (typeof value !== "number") throw new errors.ERR_INVALID_ARG_TYPE(name, "number", value);
}
function boundsError(value, length, type) {
if (Math.floor(value) !== value) {
validateNumber(value, type);
throw new errors.ERR_OUT_OF_RANGE(type || "offset", "an integer", value);
}
if (length < 0) throw new errors.ERR_BUFFER_OUT_OF_BOUNDS();
throw new errors.ERR_OUT_OF_RANGE(type || "offset", `>= ${type ? 1 : 0} and <= ${length}`, value);
}
const INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g;
function base64clean(str) {
str = str.split("=")[0];
str = str.trim().replace(INVALID_BASE64_RE, "");
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 i = 0; i < length; ++i) {
codePoint = string.charCodeAt(i);
if (codePoint > 55295 && codePoint < 57344) {
if (!leadSurrogate) {
if (codePoint > 56319) {
if ((units -= 3) > -1) bytes.push(239, 191, 189);
continue;
} else if (i + 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 i = 0; i < str.length; ++i) byteArray.push(str.charCodeAt(i) & 255);
return byteArray;
}
function utf16leToBytes(str, units) {
let c, hi, lo;
const byteArray = [];
for (let i = 0; i < str.length; ++i) {
if ((units -= 2) < 0) break;
c = str.charCodeAt(i);
hi = c >> 8;
lo = c % 256;
byteArray.push(lo);
byteArray.push(hi);
}
return byteArray;
}
function base64ToBytes(str) {
return base64.toByteArray(base64clean(str));
}
function blitBuffer(src, dst, offset, length) {
let i;
for (i = 0; i < length; ++i) {
if (i + offset >= dst.length || i >= src.length) break;
dst[i + offset] = src[i];
}
return i;
}
function isInstance(obj, type) {
return obj instanceof type || obj != null && obj.constructor != null && obj.constructor.name != null && obj.constructor.name === type.name;
}
function numberIsNaN(obj) {
return obj !== obj;
}
const hexSliceLookupTable = (function() {
const alphabet = "0123456789abcdef";
const table = new Array(256);
for (let i = 0; i < 16; ++i) {
const i16 = i * 16;
for (let j = 0; j < 16; ++j) table[i16 + j] = alphabet[i] + alphabet[j];
}
return table;
})();
function defineBigIntMethod(fn) {
return typeof BigInt === "undefined" ? BufferBigIntNotDefined : fn;
}
function BufferBigIntNotDefined() {
throw new Error("BigInt not supported");
}
})(buffer);
Buffer$1 = buffer.Buffer;
buffer.Blob;
buffer.BlobOptions;
buffer.Buffer;
buffer.File;
buffer.FileOptions;
buffer.INSPECT_MAX_BYTES;
buffer.SlowBuffer;
buffer.TranscodeEncoding;
buffer.atob;
buffer.btoa;
buffer.constants;
buffer.isAscii;
buffer.isUtf8;
buffer.kMaxLength;
buffer.kStringMaxLength;
buffer.resolveObjectURL;
buffer.transcode;
}));
//#endregion
//#region node_modules/events/events.js
var require_events = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var R = typeof Reflect === "object" ? Reflect : null;
var ReflectApply = R && typeof R.apply === "function" ? R.apply : function ReflectApply(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 ReflectOwnKeys(target) {
return Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target));
};
else ReflectOwnKeys = function ReflectOwnKeys(target) {
return Object.getOwnPropertyNames(target);
};
function ProcessEmitWarning(warning) {
if (console && console.warn) console.warn(warning);
}
var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {
return value !== value;
};
function EventEmitter() {
EventEmitter.init.call(this);
}
module.exports = EventEmitter;
module.exports.once = once;
EventEmitter.EventEmitter = EventEmitter;
EventEmitter.prototype._events = void 0;
EventEmitter.prototype._eventsCount = 0;
EventEmitter.prototype._maxListeners = void 0;
var defaultMaxListeners = 10;
function checkListener(listener) {
if (typeof listener !== "function") throw new TypeError("The \"listener\" argument must be of type Function. Received type " + typeof listener);
}
Object.defineProperty(EventEmitter, "defaultMaxListeners", {
enumerable: true,
get: function() {
return defaultMaxListeners;
},
set: function(arg) {
if (typeof arg !== "number" || arg < 0 || NumberIsNaN(arg)) throw new RangeError("The value of \"defaultMaxListeners\" is out of range. It must be a non-negative number. Received " + arg + ".");
defaultMaxListeners = arg;
}
});
EventEmitter.init = function() {
if (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) {
this._events = 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(type) {
var args = [];
for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
var doError = type === "error";
var events = this._events;
if (events !== void 0) doError = doError && events.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 = /* @__PURE__ */ new Error("Unhandled error." + (er ? " (" + er.message + ")" : ""));
err.context = er;
throw err;
}
var handler = events[type];
if (handler === void 0) return false;
if (typeof handler === "function") ReflectApply(handler, this, args);
else {
var len = handler.length;
var listeners = arrayClone(handler, len);
for (var i = 0; i < len; ++i) ReflectApply(listeners[i], this, args);
}
return true;
};
function _addListener(target, type, listener, prepend) {
var m;
var events;
var existing;
checkListener(listener);
events = target._events;
if (events === void 0) {
events = target._events = Object.create(null);
target._eventsCount = 0;
} else {
if (events.newListener !== void 0) {
target.emit("newListener", type, listener.listener ? listener.listener : listener);
events = target._events;
}
existing = events[type];
}
if (existing === void 0) {
existing = events[type] = listener;
++target._eventsCount;
} else {
if (typeof existing === "function") existing = events[type] = 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 = /* @__PURE__ */ new Error("Possible EventEmitter memory leak detected. " + existing.length + " " + String(type) + " listeners added. Use emitter.setMaxListeners() to increase limit");
w.name = "MaxListenersExceededWarning";
w.emitter = target;
w.type = type;
w.count = existing.length;
ProcessEmitWarning(w);
}
}
return target;
}
EventEmitter.prototype.addListener = function addListener(type, listener) {
return _addListener(this, type, listener, false);
};
EventEmitter.prototype.on = EventEmitter.prototype.addListener;
EventEmitter.prototype.prependListener = function prependListener(type, listener) {
return _addListener(this, type, 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, type, listener) {
var state = {
fired: false,
wrapFn: void 0,
target,
type,
listener
};
var wrapped = onceWrapper.bind(state);
wrapped.listener = listener;
state.wrapFn = wrapped;
return wrapped;
}
EventEmitter.prototype.once = function once(type, listener) {
checkListener(listener);
this.on(type, _onceWrap(this, type, listener));
return this;
};
EventEmitter.prototype.prependOnceListener = function prependOnceListener(type, listener) {
checkListener(listener);
this.prependListener(type, _onceWrap(this, type, listener));
return this;
};
EventEmitter.prototype.removeListener = function removeListener(type, listener) {
var list, events, position, i, originalListener;
checkListener(listener);
events = this._events;
if (events === void 0) return this;
list = events[type];
if (list === void 0) return this;
if (list === listener || list.listener === listener) if (--this._eventsCount === 0) this._events = Object.create(null);
else {
delete events[type];
if (events.removeListener) this.emit("removeListener", type, 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) events[type] = list[0];
if (events.removeListener !== void 0) this.emit("removeListener", type, originalListener || listener);
}
return this;
};
EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
EventEmitter.prototype.removeAllListeners = function removeAllListeners(type) {
var listeners, events = this._events, i;
if (events === void 0) return this;
if (events.removeListener === void 0) {
if (arguments.length === 0) {
this._events = Object.create(null);
this._eventsCount = 0;
} else if (events[type] !== void 0) if (--this._eventsCount === 0) this._events = Object.create(null);
else delete events[type];
return this;
}
if (arguments.length === 0) {
var keys = Object.keys(events);
var key;
for (i = 0; i < keys.length; ++i) {
key = keys[i];
if (key === "removeListener") continue;
this.removeAllListeners(key);
}
this.removeAllListeners("removeListener");
this._events = Object.create(null);
this._eventsCount = 0;
return this;
}
listeners = events[type];
if (typeof listeners === "function") this.removeListener(type, listeners);
else if (listeners !== void 0) for (i = listeners.length - 1; i >= 0; i--) this.removeListener(type, listeners[i]);
return this;
};
function _listeners(target, type, unwrap) {
var events = target._events;
if (events === void 0) return [];
var evlistener = events[type];
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(type) {
return _listeners(this, type, true);
};
EventEmitter.prototype.rawListeners = function rawListeners(type) {
return _listeners(this, type, false);
};
EventEmitter.listenerCount = function(emitter, type) {
if (typeof emitter.listenerCount === "function") return emitter.listenerCount(type);
else return listenerCount.call(emitter, type);
};
EventEmitter.prototype.listenerCount = listenerCount;
function listenerCount(type) {
var events = this._events;
if (events !== void 0) {
var evlistener = events[type];
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(emitter, name) {
return new Promise(function(resolve, reject) {
function errorListener(err) {
emitter.removeListener(name, resolver);
reject(err);
}
function resolver() {
if (typeof emitter.removeListener === "function") emitter.removeListener("error", errorListener);
resolve([].slice.call(arguments));
}
eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
if (name !== "error") addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
});
}
function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
if (typeof emitter.on === "function") eventTargetAgnosticAddListener(emitter, "error", handler, flags);
}
function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
if (typeof emitter.on === "function") if (flags.once) emitter.once(name, listener);
else emitter.on(name, listener);
else if (typeof emitter.addEventListener === "function") emitter.addEventListener(name, function wrapListener(arg) {
if (flags.once) emitter.removeEventListener(name, wrapListener);
listener(arg);
});
else throw new TypeError("The \"emitter\" argument must be of type EventEmitter. Received type " + typeof emitter);
}
}));
//#endregion
//#region node_modules/inherits/inherits_browser.js
var require_inherits_browser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
if (typeof Object.create === "function") module.exports = function inherits(ctor, superCtor) {
if (superCtor) {
ctor.super_ = superCtor;
ctor.prototype = Object.create(superCtor.prototype, { constructor: {
value: ctor,
enumerable: false,
writable: true,
configurable: true
} });
}
};
else module.exports = function inherits(ctor, superCtor) {
if (superCtor) {
ctor.super_ = superCtor;
var TempCtor = function() {};
TempCtor.prototype = superCtor.prototype;
ctor.prototype = new TempCtor();
ctor.prototype.constructor = ctor;
}
};
}));
//#endregion
//#region node_modules/vite-plugin-node-polyfills/shims/global/dist/index.js
var global;
var init_dist = __esmMin((() => {
global = globalThis || self;
}));
//#endregion
//#region node_modules/readable-stream/lib/internal/streams/stream-browser.js
var require_stream_browser$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = require_events().EventEmitter;
}));
//#endregion
//#region node_modules/vite-plugin-node-polyfills/shims/buffer/dist/index.cjs
var require_dist = /* @__PURE__ */ __commonJSMin(((exports) => {
Object.defineProperties(exports, {
__esModule: { value: true },
[Symbol.toStringTag]: { value: "Module" }
});
var buffer = {};
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 len = b64.length;
if (len % 4 > 0) throw new Error("Invalid string. Length must be a multiple of 4");
var validLen = b64.indexOf("=");
if (validLen === -1) validLen = len;
var placeHoldersLen = validLen === len ? 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 len = placeHoldersLen > 0 ? validLen - 4 : validLen;
var i;
for (i = 0; i < len; i += 4) {
tmp = revLookup[b64.charCodeAt(i)] << 18 | revLookup[b64.charCodeAt(i + 1)] << 12 | revLookup[b64.charCodeAt(i + 2)] << 6 | revLookup[b64.charCodeAt(i + 3)];
arr[curByte++] = tmp >> 16 & 255;
arr[curByte++] = tmp >> 8 & 255;
arr[curByte++] = tmp & 255;
}
if (placeHoldersLen === 2) {
tmp = revLookup[b64.charCodeAt(i)] << 2 | revLookup[b64.charCodeAt(i + 1)] >> 4;
arr[curByte++] = tmp & 255;
}
if (placeHoldersLen === 1) {
tmp = revLookup[b64.charCodeAt(i)] << 10 | revLookup[b64.charCodeAt(i + 1)] << 4 | revLookup[b64.charCodeAt(i + 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 i = start; i < end; i += 3) {
tmp = (uint8[i] << 16 & 16711680) + (uint8[i + 1] << 8 & 65280) + (uint8[i + 2] & 255);
output.push(tripletToBase64(tmp));
}
return output.join("");
}
function fromByteArray(uint8) {
var tmp;
var len = uint8.length;
var extraBytes = len % 3;
var parts = [];
var maxChunkLength = 16383;
for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) parts.push(encodeChunk(uint8, i, i + maxChunkLength > len2 ? len2 : i + maxChunkLength));
if (extraBytes === 1) {
tmp = uint8[len - 1];
parts.push(lookup[tmp >> 2] + lookup[tmp << 4 & 63] + "==");
} else if (extraBytes === 2) {
tmp = (uint8[len - 2] << 8) + uint8[len - 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(buffer, 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 i = isLE ? nBytes - 1 : 0;
var d = isLE ? -1 : 1;
var s = buffer[offset + i];
i += d;
e = s & (1 << -nBits) - 1;
s >>= -nBits;
nBits += eLen;
for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8);
m = e & (1 << -nBits) - 1;
e >>= -nBits;
nBits += mLen;
for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8);
if (e === 0) e = 1 - eBias;
else if (e === eMax) return m ? NaN : (s ? -1 : 1) * Infinity;
else {
m = m + Math.pow(2, mLen);
e = e - eBias;
}
return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
};
ieee754.write = function(buffer, 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 i = isLE ? 0 : nBytes - 1;
var d = isLE ? 1 : -1;
var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
value = Math.abs(value);
if (isNaN(value) || value === Infinity) {
m = isNaN(value) ? 1 : 0;
e = eMax;
} else {
e = Math.floor(Math.log(value) / Math.LN2);
if (value * (c = Math.pow(2, -e)) < 1) {
e--;
c *= 2;
}
if (e + eBias >= 1) value += rt / c;
else value += rt * Math.pow(2, 1 - eBias);
if (value * c >= 2) {
e++;
c /= 2;
}
if (e + eBias >= eMax) {
m = 0;
e = eMax;
} else if (e + eBias >= 1) {
m = (value * c - 1) * Math.pow(2, mLen);
e = e + eBias;
} else {
m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
e = 0;
}
}
for (; mLen >= 8; buffer[offset + i] = m & 255, i += d, m /= 256, mLen -= 8);
e = e << mLen | m;
eLen += mLen;
for (; eLen > 0; buffer[offset + i] = e & 255, i += d, e /= 256, eLen -= 8);
buffer[offset + i - d] |= s * 128;
};
/*!
* The buffer module from node.js, for the browser.
*
* @author Feross Aboukhadijeh <https://feross.org>
* @license MIT
*/
(function(exports$8) {
const base64 = base64Js;
const ieee754$1 = ieee754;
const customInspectSymbol = typeof Symbol === "function" && typeof Symbol["for"] === "function" ? Symbol["for"]("nodejs.util.inspect.custom") : null;
exports$8.Buffer = Buffer;
exports$8.SlowBuffer = SlowBuffer;
exports$8.INSPECT_MAX_BYTES = 50;
const K_MAX_LENGTH = 2147483647;
exports$8.kMaxLength = K_MAX_LENGTH;
const { Uint8Array: GlobalUint8Array, ArrayBuffer: GlobalArrayBuffer, SharedArrayBuffer: GlobalSharedArrayBuffer } = globalThis;
/**
* If `Buffer.TYPED_ARRAY_SUPPORT`:
* === true Use Uint8Array implementation (fastest)
* === false Print warning and recommend using `buffer` v4.x which has an Object
* implementation (most compatible, even IE6)
*
* Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
* Opera 11.6+, iOS 4.2+.
*
* We report that the browser does not support typed arrays if the are not subclassable
* using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`
* (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support
* for __proto__ and has a buggy typed array implementation.
*/
Buffer.TYPED_ARRAY_SUPPORT = typedArraySupport();
if (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== "undefined" && typeof console.error === "function") console.error("This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support.");
function typedArraySupport() {
try {
const arr = new GlobalUint8Array(1);
const proto = { foo: function() {
return 42;
} };
Object.setPrototypeOf(proto, GlobalUint8Array.prototype);
Object.setPrototypeOf(arr, proto);
return arr.foo() === 42;
} catch (e) {
return false;
}
}
Object.defineProperty(Buffer.prototype, "parent", {
enumerable: true,
get: function() {
if (!Buffer.isBuffer(this)) return void 0;
return this.buffer;
}
});
Object.defineProperty(Buffer.prototype, "offset", {
enumerable: true,
get: function() {
if (!Buffer.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, Buffer.prototype);
return buf;
}
/**
* The Buffer constructor returns instances of `Uint8Array` that have their
* prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
* `Uint8Array`, so the returned instances will have all the node `Buffer` methods
* and the `Uint8Array` methods. Square bracket notation works as expected -- it
* returns a single octet.
*
* The `Uint8Array` prototype remains unmodified.
*/
function Buffer(arg, encodingOrOffset, length) {
if (typeof arg === "number") {
if (typeof encodingOrOffset === "string") throw new TypeError("The \"string\" argument must be of type string. Received type number");
return allocUnsafe(arg);
}
return from(arg, encodingOrOffset, length);
}
Buffer.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 Buffer.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 Buffer.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);
}
/**
* Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
* if value is a number.
* Buffer.from(str[, encoding])
* Buffer.from(array)
* Buffer.from(buffer)
* Buffer.from(arrayBuffer[, byteOffset[, length]])
**/
Buffer.from = function(value, encodingOrOffset, length) {
return from(value, encodingOrOffset, length);
};
Object.setPrototypeOf(Buffer.prototype, GlobalUint8Array.prototype);
Object.setPrototypeOf(Buffer, GlobalUint8Array);
function assertSize(size) {
if (typeof size !== "number") throw new TypeError("\"size\" argument must be of type number");
else if (size < 0) throw new RangeError("The value \"" + size + "\" is invalid for option \"size\"");
}
function alloc(size, fill, encoding) {
assertSize(size);
if (size <= 0) return createBuffer(size);
if (fill !== void 0) return typeof encoding === "string" ? createBuffer(size).fill(fill, encoding) : createBuffer(size).fill(fill);
return createBuffer(size);
}
/**
* Creates a new filled Buffer instance.
* alloc(size[, fill[, encoding]])
**/
Buffer.alloc = function(size, fill, encoding) {
return alloc(size, fill, encoding);
};
function allocUnsafe(size) {
assertSize(size);
return createBuffer(size < 0 ? 0 : checked(size) | 0);
}
/**
* Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
* */
Buffer.allocUnsafe = function(size) {
return allocUnsafe(size);
};
/**
* Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
*/
Buffer.allocUnsafeSlow = function(size) {
return allocUnsafe(size);
};
function fromString(string, encoding) {
if (typeof encoding !== "string" || encoding === "") encoding = "utf8";
if (!Buffer.isEncoding(encoding)) throw new TypeError("Unknown encoding: " + encoding);
const length = byteLength(string, encoding) | 0;
let buf = createBuffer(length);
const actual = buf.write(string, encoding);
if (actual !== length) buf = buf.slice(0, actual);
return buf;
}
function fromArrayLike(array) {
const length = array.length < 0 ? 0 : checked(array.length) | 0;
const buf = createBuffer(length);
for (let i = 0; i < length; i += 1) buf[i] = array[i] & 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, Buffer.prototype);
return buf;
}
function fromObject(obj) {
if (Buffer.isBuffer(obj)) {
const len = checked(obj.length) | 0;
const buf = createBuffer(len);
if (buf.length === 0) return buf;
obj.copy(buf, 0, 0, len);
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 Buffer.alloc(+length);
}
Buffer.isBuffer = function isBuffer(b) {
return b != null && b._isBuffer === true && b !== Buffer.prototype;
};
Buffer.compare = function compare(a, b) {
if (isInstance(a, GlobalUint8Array)) a = Buffer.from(a, a.offset, a.byteLength);
if (isInstance(b, GlobalUint8Array)) b = Buffer.from(b, b.offset, b.byteLength);
if (!Buffer.isBuffer(a) || !Buffer.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 i = 0, len = Math.min(x, y); i < len; ++i) if (a[i] !== b[i]) {
x = a[i];
y = b[i];
break;
}
if (x < y) return -1;
if (y < x) return 1;
return 0;
};
Buffer.isEncoding = function isEncoding(encoding) {
switch (String(encoding).toLowerCase()) {
case "hex":
case "utf8":
case "utf-8":
case "ascii":
case "latin1":
case "binary":
case "base64":
case "ucs2":
case "ucs-2":
case "utf16le":
case "utf-16le": return true;
default: return false;
}
};
Buffer.concat = function concat(list, length) {
if (!Array.isArray(list)) throw new TypeError("\"list\" argument must be an Array of Buffers");
if (list.length === 0) return Buffer.alloc(0);
let i;
if (length === void 0) {
length = 0;
for (i = 0; i < list.length; ++i) length += list[i].length;
}
const buffer = Buffer.allocUnsafe(length);
let pos = 0;
for (i = 0; i < list.length; ++i) {
let buf = list[i];
if (isInstance(buf, GlobalUint8Array)) if (pos + buf.length > buffer.length) {
if (!Buffer.isBuffer(buf)) buf = Buffer.from(buf);
buf.copy(buffer, pos);
} else GlobalUint8Array.prototype.set.call(buffer, buf, pos);
else if (!Buffer.isBuffer(buf)) throw new TypeError("\"list\" argument must be an Array of Buffers");
else buf.copy(buffer, pos);
pos += buf.length;
}
return buffer;
};
function byteLength(string, encoding) {
if (Buffer.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 len = string.length;
const mustMatch = arguments.length > 2 && arguments[2] === true;
if (!mustMatch && len === 0) return 0;
let loweredCase = false;
for (;;) switch (encoding) {
case "ascii":
case "latin1":
case "binary": return len;
case "utf8":
case "utf-8": return utf8ToBytes(string).length;
case "ucs2":
case "ucs-2":
case "utf16le":
case "utf-16le": return len * 2;
case "hex": return len >>> 1;
case "base64": return base64ToBytes(string).length;
default:
if (loweredCase) return mustMatch ? -1 : utf8ToBytes(string).length;
encoding = ("" + encoding).toLowerCase();
loweredCase = true;
}
}
Buffer.byteLength = byteLength;
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;
}
}
Buffer.prototype._isBuffer = true;
function swap(b, n, m) {
const i = b[n];
b[n] = b[m];
b[m] = i;
}
Buffer.prototype.swap16 = function swap16() {
const len = this.length;
if (len % 2 !== 0) throw new RangeError("Buffer size must be a multiple of 16-bits");
for (let i = 0; i < len; i += 2) swap(this, i, i + 1);
return this;
};
Buffer.prototype.swap32 = function swap32() {
const len = this.length;
if (len % 4 !== 0) throw new RangeError("Buffer size must be a multiple of 32-bits");
for (let i = 0; i < len; i += 4) {
swap(this, i, i + 3);
swap(this, i + 1, i + 2);
}
return this;
};
Buffer.prototype.swap64 = function swap64() {
const len = this.length;
if (len % 8 !== 0) throw new RangeError("Buffer size must be a multiple of 64-bits");
for (let i = 0; i < len; i += 8) {
swap(this, i, i + 7);
swap(this, i + 1, i + 6);
swap(this, i + 2, i + 5);
swap(this, i + 3, i + 4);
}
return this;
};
Buffer.prototype.toString = function toString() {
const length = this.length;
if (length === 0) return "";
if (arguments.length === 0) return utf8Slice(this, 0, length);
return slowToString.apply(this, arguments);
};
Buffer.prototype.toLocaleString = Buffer.prototype.toString;
Buffer.prototype.equals = function equals(b) {
if (!Buffer.isBuffer(b)) throw new TypeError("Argument must be a Buffer");
if (this === b) return true;
return Buffer.compare(this, b) === 0;
};
Buffer.prototype.inspect = function inspect() {
let str = "";
const max = exports$8.INSPECT_MAX_BYTES;
str = this.toString("hex", 0, max).replace(/(.{2})/g, "$1 ").trim();
if (this.length > max) str += " ... ";
return "<Buffer " + str + ">";
};
if (customInspectSymbol) Buffer.prototype[customInspectSymbol] = Buffer.prototype.inspect;
Buffer.prototype.compare = function compare(target, start, end, thisStart, thisEnd) {
if (isInstance(target, GlobalUint8Array)) target = Buffer.from(target, target.offset, target.byteLength);
if (!Buffer.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 len = Math.min(x, y);
const thisCopy = this.slice(thisStart, thisEnd);
const targetCopy = target.slice(start, end);
for (let i = 0; i < len; ++i) if (thisCopy[i] !== targetCopy[i]) {
x = thisCopy[i];
y = targetCopy[i];
break;
}
if (x < y) return -1;
if (y < x) return 1;
return 0;
};
function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {
if (buffer.length === 0) return -1;
if (typeof byteOffset === "string") {
encoding = byteOffset;
byteOffset = 0;
} else if (byteOffset > 2147483647) byteOffset = 2147483647;
else if (byteOffset < -2147483648) byteOffset = -2147483648;
byteOffset = +byteOffset;
if (numberIsNaN(byteOffset)) byteOffset = dir ? 0 : buffer.length - 1;
if (byteOffset < 0) byteOffset = buffer.length + byteOffset;
if (byteOffset >= buffer.length) if (dir) return -1;
else byteOffset = buffer.length - 1;
else if (byteOffset < 0) if (dir) byteOffset = 0;
else return -1;
if (typeof val === "string") val = Buffer.from(val, encoding);
if (Buffer.isBuffer(val)) {
if (val.length === 0) return -1;
return arrayIndexOf(buffer, 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(buffer, val, byteOffset);
else return GlobalUint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset);
return arrayIndexOf(buffer, [val], byteOffset, encoding, dir);
}
throw new TypeError("val must be string, number or Buffer");
}
function arrayIndexOf(arr, val, byteOffset, encoding, dir) {
let indexSize = 1;
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, i) {
if (indexSize === 1) return buf[i];
else return buf.readUInt16BE(i * indexSize);
}
let i;
if (dir) {
let foundIndex = -1;
for (i = byteOffset; i < arrLength; i++) if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
if (foundIndex === -1) foundIndex = i;
if (i - foundIndex + 1 === valLength) return foundIndex * indexSize;
} else {
if (foundIndex !== -1) i -= i - foundIndex;
foundIndex = -1;
}
} else {
if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength;
for (i = byteOffset; i >= 0; i--) {
let found = true;
for (let j = 0; j < valLength; j++) if (read(arr, i + j) !== read(val, j)) {
found = false;
break;
}
if (found) return i;
}
}
return -1;
}
Buffer.prototype.includes = function includes(val, byteOffset, encoding) {
return this.indexOf(val, byteOffset, encoding) !== -1;
};
Buffer.prototype.indexOf = function indexOf(val, byteOffset, encoding) {
return bidirectionalIndexOf(this, val, byteOffset, encoding, true);
};
Buffer.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 i;
for (i = 0; i < length; ++i) {
const parsed = parseInt(string.substr(i * 2, 2), 16);
if (numberIsNaN(parsed)) return i;
buf[offset + i] = parsed;
}
return i;
}
function utf8Write(buf, string, offset, length) {
return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length);
}
function asciiWrite(buf, string, offset, length) {
return blitBuffer(asciiToBytes(string), buf, offset, length);
}
function base64Write(buf, string, offset, length) {
return blitBuffer(base64ToBytes(string), buf, offset, length);
}
function ucs2Write(buf, string, offset, length) {
return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length);
}
Buffer.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;
}
};
Buffer.prototype.toJSON = function toJSON() {
return {
type: "Buffer",
data: Array.prototype.slice.call(this._arr || this, 0)
};
};
function base64Slice(buf, start, end) {
if (start === 0 && end === buf.length) return base64.fromByteArray(buf);
else return base64.fromByteArray(buf.slice(start, end));
}
function utf8Slice(buf, start, end) {
end = Math.min(buf.length, end);
const res = [];
let i = start;
while (i < end) {
const firstByte = buf[i];
let codePoint = null;
let bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
if (i + bytesPerSequence <= end) {
let secondByte, thirdByte, fourthByte, tempCodePoint;
switch (bytesPerSequence) {
case 1:
if (firstByte < 128) codePoint = firstByte;
break;
case 2:
secondByte = buf[i + 1];
if ((secondByte & 192) === 128) {
tempCodePoint = (firstByte & 31) << 6 | secondByte & 63;
if (tempCodePoint > 127) codePoint = tempCodePoint;
}
break;
case 3:
secondByte = buf[i + 1];
thirdByte = buf[i + 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[i + 1];
thirdByte = buf[i + 2];
fourthByte = buf[i + 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);
i += bytesPerSequence;
}
return decodeCodePointsArray(res);
}
const MAX_ARGUMENTS_LENGTH = 4096;
function decodeCodePointsArray(codePoints) {
const len = codePoints.length;
if (len <= MAX_ARGUMENTS_LENGTH) return String.fromCharCode.apply(String, codePoints);
let res = "";
let i = 0;
while (i < len) res += String.fromCharCode.apply(String, codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH));
return res;
}
function asciiSlice(buf, start, end) {
let ret = "";
end = Math.min(buf.length, end);
for (let i = start; i < end; ++i) ret += String.fromCharCode(buf[i] & 127);
return ret;
}
function latin1Slice(buf, start, end) {
let ret = "";
end = Math.min(buf.length, end);
for (let i = start; i < end; ++i) ret += String.fromCharCode(buf[i]);
return ret;
}
function hexSlice(buf, start, end) {
const len = buf.length;
if (!start || start < 0) start = 0;
if (!end || end < 0 || end > len) end = len;
let out = "";
for (let i = start; i < end; ++i) out += hexSliceLookupTable[buf[i]];
return out;
}
function utf16leSlice(buf, start, end) {
const bytes = buf.slice(start, end);
let res = "";
for (let i = 0; i < bytes.length - 1; i += 2) res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);
return res;
}
Buffer.prototype.slice = function slice(start, end) {
const len = this.length;
start = ~~start;
end = end === void 0 ? len : ~~end;
if (start < 0) {
start += len;
if (start < 0) start = 0;
} else if (start > len) start = len;
if (end < 0) {
end += len;
if (end < 0) end = 0;
} else if (end > len) end = len;
if (end < start) end = start;
const newBuf = this.subarray(start, end);
Object.setPrototypeOf(newBuf, Buffer.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");
}
Buffer.prototype.readUintLE = Buffer.prototype.readUIntLE = function readUIntLE(offset, byteLength, noAssert) {
offset = offset >>> 0;
byteLength = byteLength >>> 0;
if (!noAssert) checkOffset(offset, byteLength, this.length);
let val = this[offset];
let mul = 1;
let i = 0;
while (++i < byteLength && (mul *= 256)) val += this[offset + i] * mul;
return val;
};
Buffer.prototype.readUintBE = Buffer.prototype.readUIntBE = function readUIntBE(offset, byteLength, noAssert) {
offset = offset >>> 0;
byteLength = byteLength >>> 0;
if (!noAssert) checkOffset(offset, byteLength, this.length);
let val = this[offset + --byteLength];
let mul = 1;
while (byteLength > 0 && (mul *= 256)) val += this[offset + --byteLength] * mul;
return val;
};
Buffer.prototype.readUint8 = Buffer.prototype.readUInt8 = function readUInt8(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 1, this.length);
return this[offset];
};
Buffer.prototype.readUint16LE = Buffer.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 2, this.length);
return this[offset] | this[offset + 1] << 8;
};
Buffer.prototype.readUint16BE = Buffer.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 2, this.length);
return this[offset] << 8 | this[offset + 1];
};
Buffer.prototype.readUint32LE = Buffer.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;
};
Buffer.prototype.readUint32BE = Buffer.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 4, this.length);
return this[offset] * 16777216 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]);
};
Buffer.prototype.readBigUInt64LE = defineBigIntMethod(function readBigUInt64LE(offset) {
offset = offset >>> 0;
validateNumber(offset, "offset");
const first = this[offset];
const last = this[offset + 7];
if (first === void 0 || last === void 0) boundsError(offset, this.length - 8);
const lo = first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24;
const hi = this[++offset] + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + last * 2 ** 24;
return BigInt(lo) + (BigInt(hi) << BigInt(32));
});
Buffer.prototype.readBigUInt64BE = defineBigIntMethod(function readBigUInt64BE(offset) {
offset = offset >>> 0;
validateNumber(offset, "offset");
const first = this[offset];
const last = this[offset + 7];
if (first === void 0 || last === void 0) boundsError(offset, this.length - 8);
const hi = first * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset];
const lo = this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last;
return (BigInt(hi) << BigInt(32)) + BigInt(lo);
});
Buffer.prototype.readIntLE = function readIntLE(offset, byteLength, noAssert) {
offset = offset >>> 0;
byteLength = byteLength >>> 0;
if (!noAssert) checkOffset(offset, byteLength, this.length);
let val = this[offset];
let mul = 1;
let i = 0;
while (++i < byteLength && (mul *= 256)) val += this[offset + i] * mul;
mul *= 128;
if (val >= mul) val -= Math.pow(2, 8 * byteLength);
return val;
};
Buffer.prototype.readIntBE = function readIntBE(offset, byteLength, noAssert) {
offset = offset >>> 0;
byteLength = byteLength >>> 0;
if (!noAssert) checkOffset(offset, byteLength, this.length);
let i = byteLength;
let mul = 1;
let val = this[offset + --i];
while (i > 0 && (mul *= 256)) val += this[offset + --i] * mul;
mul *= 128;
if (val >= mul) val -= Math.pow(2, 8 * byteLength);
return val;
};
Buffer.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;
};
Buffer.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;
};
Buffer.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;
};
Buffer.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;
};
Buffer.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];
};
Buffer.prototype.readBigInt64LE = defineBigIntMethod(function readBigInt64LE(offset) {
offset = offset >>> 0;
validateNumber(offset, "offset");
const first = this[offset];
const last = this[offset + 7];
if (first === void 0 || last === void 0) boundsError(offset, this.length - 8);
const val = this[offset + 4] + this[offset + 5] * 2 ** 8 + this[offset + 6] * 2 ** 16 + (last << 24);
return (BigInt(val) << BigInt(32)) + BigInt(first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24);
});
Buffer.prototype.readBigInt64BE = defineBigIntMethod(function readBigInt64BE(offset) {
offset = offset >>> 0;
validateNumber(offset, "offset");
const first = this[offset];
const last = this[offset + 7];
if (first === void 0 || last === void 0) boundsError(offset, this.length - 8);
const val = (first << 24) + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset];
return (BigInt(val) << BigInt(32)) + BigInt(this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last);
});
Buffer.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);
};
Buffer.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);
};
Buffer.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);
};
Buffer.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {
offset = offset >>> 0;
if (!noAssert) checkOffset(offset, 8, this.length);
return ieee754$1.read(this, offset, false, 52, 8);
};
function checkInt(buf, value, offset, ext, max, min) {
if (!Buffer.isBuffer(buf)) throw new TypeError("\"buffer\" argument must be a Buffer instance");
if (value > max || value < min) throw new RangeError("\"value\" argument is out of bounds");
if (offset + ext > buf.length) throw new RangeError("Index out of range");
}
Buffer.prototype.writeUintLE = Buffer.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength, noAssert) {
value = +value;
offset = offset >>> 0;
byteLength = byteLength >>> 0;
if (!noAssert) {
const maxBytes = Math.pow(2, 8 * byteLength) - 1;
checkInt(this, value, offset, byteLength, maxBytes, 0);
}
let mul = 1;
let i = 0;
this[offset] = value & 255;
while (++i < byteLength && (mul *= 256)) this[offset + i] = value / mul & 255;
return offset + byteLength;
};
Buffer.prototype.writeUintBE = Buffer.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength, noAssert) {
value = +value;
offset = offset >>> 0;
byteLength = byteLength >>> 0;
if (!noAssert) {
const maxBytes = Math.pow(2, 8 * byteLength) - 1;
checkInt(this, value, offset, byteLength, maxBytes, 0);
}
let i = byteLength - 1;
let mul = 1;
this[offset + i] = value & 255;
while (--i >= 0 && (mul *= 256)) this[offset + i] = value / mul & 255;
return offset + byteLength;
};
Buffer.prototype.writeUint8 = Buffer.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;
};
Buffer.prototype.writeUint16LE = Buffer.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;
};
Buffer.prototype.writeUint16BE = Buffer.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;
};
Buffer.prototype.writeUint32LE = Buffer.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;
};
Buffer.prototype.writeUint32BE = Buffer.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0);
this[offset] = value >>> 24;
this[offset + 1] = value >>> 16;
this[offset + 2] = value >>> 8;
this[offset + 3] = value & 255;
return offset + 4;
};
function wrtBigUInt64LE(buf, value, offset, min, max) {
checkIntBI(value, min, max, buf, offset, 7);
let lo = Number(value & BigInt(4294967295));
buf[offset++] = lo;
lo = lo >> 8;
buf[offset++] = lo;
lo = lo >> 8;
buf[offset++] = lo;
lo = lo >> 8;
buf[offset++] = lo;
let hi = Number(value >> BigInt(32) & BigInt(4294967295));
buf[offset++] = hi;
hi = hi >> 8;
buf[offset++] = hi;
hi = hi >> 8;
buf[offset++] = hi;
hi = hi >> 8;
buf[offset++] = hi;
return offset;
}
function wrtBigUInt64BE(buf, value, offset, min, max) {
checkIntBI(value, min, max, buf, offset, 7);
let lo = Number(value & BigInt(4294967295));
buf[offset + 7] = lo;
lo = lo >> 8;
buf[offset + 6] = lo;
lo = lo >> 8;
buf[offset + 5] = lo;
lo = lo >> 8;
buf[offset + 4] = lo;
let hi = Number(value >> BigInt(32) & BigInt(4294967295));
buf[offset + 3] = hi;
hi = hi >> 8;
buf[offset + 2] = hi;
hi = hi >> 8;
buf[offset + 1] = hi;
hi = hi >> 8;
buf[offset] = hi;
return offset + 8;
}
Buffer.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE(value, offset = 0) {
return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
});
Buffer.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE(value, offset = 0) {
return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
});
Buffer.prototype.writeIntLE = function writeIntLE(value, offset, byteLength, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) {
const limit = Math.pow(2, 8 * byteLength - 1);
checkInt(this, value, offset, byteLength, limit - 1, -limit);
}
let i = 0;
let mul = 1;
let sub = 0;
this[offset] = value & 255;
while (++i < byteLength && (mul *= 256)) {
if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) sub = 1;
this[offset + i] = (value / mul >> 0) - sub & 255;
}
return offset + byteLength;
};
Buffer.prototype.writeIntBE = function writeIntBE(value, offset, byteLength, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) {
const limit = Math.pow(2, 8 * byteLength - 1);
checkInt(this, value, offset, byteLength, limit - 1, -limit);
}
let i = byteLength - 1;
let mul = 1;
let sub = 0;
this[offset + i] = value & 255;
while (--i >= 0 && (mul *= 256)) {
if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) sub = 1;
this[offset + i] = (value / mul >> 0) - sub & 255;
}
return offset + byteLength;
};
Buffer.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;
};
Buffer.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;
};
Buffer.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;
};
Buffer.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;
};
Buffer.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;
};
Buffer.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE(value, offset = 0) {
return wrtBigUInt64LE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
});
Buffer.prototype.writeBigInt64BE = defineBigIntMethod(function writeBigInt64BE(value, offset = 0) {
return wrtBigUInt64BE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
});
function checkIEEE754(buf, value, offset, ext, max, min) {
if (offset + ext > buf.length) throw new RangeError("Index out of range");
if (offset < 0) throw new RangeError("Index out of range");
}
function writeFloat(buf, value, offset, littleEndian, noAssert) {
value = +value;
offset = offset >>> 0;
if (!noAssert) checkIEEE754(buf, value, offset, 4);
ieee754$1.write(buf, value, offset, littleEndian, 23, 4);
return offset + 4;
}
Buffer.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) {
return writeFloat(this, value, offset, true, noAssert);
};
Buffer.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;
}
Buffer.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) {
return writeDouble(this, value, offset, true, noAssert);
};
Buffer.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) {
return writeDouble(this, value, offset, false, noAssert);
};
Buffer.prototype.copy = function copy(target, targetStart, start, end) {
if (!Buffer.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 len = 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 len;
};
Buffer.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" && !Buffer.isEncoding(encoding)) throw new TypeError("Unknown encoding: " + encoding);
if (val.length === 1) {
const code = val.charCodeAt(0);
if (encoding === "utf8" && code < 128 || encoding === "latin1") val = code;
}
} 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 i;
if (typeof val === "number") for (i = start; i < end; ++i) this[i] = val;
else {
const bytes = Buffer.isBuffer(val) ? val : Buffer.from(val, encoding);
const len = bytes.length;
if (len === 0) throw new TypeError("The value \"" + val + "\" is invalid for argument \"value\"");
for (i = 0; i < end - start; ++i) this[i + start] = bytes[i % len];
}
return this;
};
const errors = {};
function E(sym, getMessage, Base) {
errors[sym] = class NodeError extends Base {
constructor() {
super();
Object.defineProperty(this, "message", {
value: getMessage.apply(this, arguments),
writable: true,
configurable: true
});
this.name = `${this.name} [${sym}]`;
this.stack;
delete this.name;
}
get code() {
return sym;
}
set code(value) {
Object.defineProperty(this, "code", {
configurable: true,
enumerable: true,
value,
writable: true
});
}
toString() {
return `${this.name} [${sym}]: ${this.message}`;
}
};
}
E("ERR_BUFFER_OUT_OF_BOUNDS", function(name) {
if (name) return `${name} is outside of buffer bounds`;
return "Attempt to access memory outside buffer bounds";
}, RangeError);
E("ERR_INVALID_ARG_TYPE", function(name, actual) {
return `The "${name}" argument must be of type number. Received type ${typeof actual}`;
}, TypeError);
E("ERR_OUT_OF_RANGE", function(str, range, input) {
let msg = `The value of "${str}" is out of range.`;
let received = input;
if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) received = addNumericalSeparator(String(input));
else if (typeof input === "bigint") {
received = String(input);
if (input > BigInt(2) ** BigInt(32) || input < -(BigInt(2) ** BigInt(32))) received = addNumericalSeparator(received);
received += "n";
}
msg += ` It must be ${range}. Received ${received}`;
return msg;
}, RangeError);
function addNumericalSeparator(val) {
let res = "";
let i = val.length;
const start = val[0] === "-" ? 1 : 0;
for (; i >= start + 4; i -= 3) res = `_${val.slice(i - 3, i)}${res}`;
return `${val.slice(0, i)}${res}`;
}
function checkBounds(buf, offset, byteLength) {
validateNumber(offset, "offset");
if (buf[offset] === void 0 || buf[offset + byteLength] === void 0) boundsError(offset, buf.length - (byteLength + 1));
}
function checkIntBI(value, min, max, buf, offset, byteLength) {
if (value > max || value < min) {
const n = typeof min === "bigint" ? "n" : "";
let range;
if (byteLength > 3) if (min === 0 || min === BigInt(0)) range = `>= 0${n} and < 2${n} ** ${(byteLength + 1) * 8}${n}`;
else range = `>= -(2${n} ** ${(byteLength + 1) * 8 - 1}${n}) and < 2 ** ${(byteLength + 1) * 8 - 1}${n}`;
else range = `>= ${min}${n} and <= ${max}${n}`;
throw new errors.ERR_OUT_OF_RANGE("value", range, value);
}
checkBounds(buf, offset, byteLength);
}
function validateNumber(value, name) {
if (typeof value !== "number") throw new errors.ERR_INVALID_ARG_TYPE(name, "number", value);
}
function boundsError(value, length, type) {
if (Math.floor(value) !== value) {
validateNumber(value, type);
throw new errors.ERR_OUT_OF_RANGE(type || "offset", "an integer", value);
}
if (length < 0) throw new errors.ERR_BUFFER_OUT_OF_BOUNDS();
throw new errors.ERR_OUT_OF_RANGE(type || "offset", `>= ${type ? 1 : 0} and <= ${length}`, value);
}
const INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g;
function base64clean(str) {
str = str.split("=")[0];
str = str.trim().replace(INVALID_BASE64_RE, "");
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 i = 0; i < length; ++i) {
codePoint = string.charCodeAt(i);
if (codePoint > 55295 && codePoint < 57344) {
if (!leadSurrogate) {
if (codePoint > 56319) {
if ((units -= 3) > -1) bytes.push(239, 191, 189);
continue;
} else if (i + 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 i = 0; i < str.length; ++i) byteArray.push(str.charCodeAt(i) & 255);
return byteArray;
}
function utf16leToBytes(str, units) {
let c, hi, lo;
const byteArray = [];
for (let i = 0; i < str.length; ++i) {
if ((units -= 2) < 0) break;
c = str.charCodeAt(i);
hi = c >> 8;
lo = c % 256;
byteArray.push(lo);
byteArray.push(hi);
}
return byteArray;
}
function base64ToBytes(str) {
return base64.toByteArray(base64clean(str));
}
function blitBuffer(src, dst, offset, length) {
let i;
for (i = 0; i < length; ++i) {
if (i + offset >= dst.length || i >= src.length) break;
dst[i + offset] = src[i];
}
return i;
}
function isInstance(obj, type) {
return obj instanceof type || obj != null && obj.constructor != null && obj.constructor.name != null && obj.constructor.name === type.name;
}
function numberIsNaN(obj) {
return obj !== obj;
}
const hexSliceLookupTable = (function() {
const alphabet = "0123456789abcdef";
const table = new Array(256);
for (let i = 0; i < 16; ++i) {
const i16 = i * 16;
for (let j = 0; j < 16; ++j) table[i16 + j] = alphabet[i] + alphabet[j];
}
return table;
})();
function defineBigIntMethod(fn) {
return typeof BigInt === "undefined" ? BufferBigIntNotDefined : fn;
}
function BufferBigIntNotDefined() {
throw new Error("BigInt not supported");
}
})(buffer);
var Buffer = buffer.Buffer;
exports.Blob = buffer.Blob;
exports.BlobOptions = buffer.BlobOptions;
exports.Buffer = buffer.Buffer;
exports.File = buffer.File;
exports.FileOptions = buffer.FileOptions;
exports.INSPECT_MAX_BYTES = buffer.INSPECT_MAX_BYTES;
exports.SlowBuffer = buffer.SlowBuffer;
exports.TranscodeEncoding = buffer.TranscodeEncoding;
exports.atob = buffer.atob;
exports.btoa = buffer.btoa;
exports.constants = buffer.constants;
exports.default = Buffer;
exports.isAscii = buffer.isAscii;
exports.isUtf8 = buffer.isUtf8;
exports.kMaxLength = buffer.kMaxLength;
exports.kStringMaxLength = buffer.kStringMaxLength;
exports.resolveObjectURL = buffer.resolveObjectURL;
exports.transcode = buffer.transcode;
}));
//#endregion
//#region node_modules/has-symbols/shams.js
var require_shams$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
/** @type {import('./shams')} */
module.exports = function hasSymbols() {
if (typeof Symbol !== "function" || typeof Object.getOwnPropertySymbols !== "function") return false;
if (typeof Symbol.iterator === "symbol") return true;
/** @type {{ [k in symbol]?: unknown }} */
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 (var _ 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;
};
}));
//#endregion
//#region node_modules/has-tostringtag/shams.js
var require_shams = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var hasSymbols = require_shams$1();
/** @type {import('.')} */
module.exports = function hasToStringTagShams() {
return hasSymbols() && !!Symbol.toStringTag;
};
}));
//#endregion
//#region node_modules/es-object-atoms/index.js
var require_es_object_atoms = /* @__PURE__ */ __commonJSMin(((exports, module) => {
/** @type {import('.')} */
module.exports = Object;
}));
//#endregion
//#region node_modules/es-errors/index.js
var require_es_errors = /* @__PURE__ */ __commonJSMin(((exports, module) => {
/** @type {import('.')} */
module.exports = Error;
}));
//#endregion
//#region node_modules/es-errors/eval.js
var require_eval = /* @__PURE__ */ __commonJSMin(((exports, module) => {
/** @type {import('./eval')} */
module.exports = EvalError;
}));
//#endregion
//#region node_modules/es-errors/range.js
var require_range = /* @__PURE__ */ __commonJSMin(((exports, module) => {
/** @type {import('./range')} */
module.exports = RangeError;
}));
//#endregion
//#region node_modules/es-errors/ref.js
var require_ref = /* @__PURE__ */ __commonJSMin(((exports, module) => {
/** @type {import('./ref')} */
module.exports = ReferenceError;
}));
//#endregion
//#region node_modules/es-errors/syntax.js
var require_syntax = /* @__PURE__ */ __commonJSMin(((exports, module) => {
/** @type {import('./syntax')} */
module.exports = SyntaxError;
}));
//#endregion
//#region node_modules/es-errors/type.js
var require_type = /* @__PURE__ */ __commonJSMin(((exports, module) => {
/** @type {import('./type')} */
module.exports = TypeError;
}));
//#endregion
//#region node_modules/es-errors/uri.js
var require_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
/** @type {import('./uri')} */
module.exports = URIError;
}));
//#endregion
//#region node_modules/math-intrinsics/abs.js
var require_abs = /* @__PURE__ */ __commonJSMin(((exports, module) => {
/** @type {import('./abs')} */
module.exports = Math.abs;
}));
//#endregion
//#region node_modules/math-intrinsics/floor.js
var require_floor = /* @__PURE__ */ __commonJSMin(((exports, module) => {
/** @type {import('./floor')} */
module.exports = Math.floor;
}));
//#endregion
//#region node_modules/math-intrinsics/max.js
var require_max = /* @__PURE__ */ __commonJSMin(((exports, module) => {
/** @type {import('./max')} */
module.exports = Math.max;
}));
//#endregion
//#region node_modules/math-intrinsics/min.js
var require_min = /* @__PURE__ */ __commonJSMin(((exports, module) => {
/** @type {import('./min')} */
module.exports = Math.min;
}));
//#endregion
//#region node_modules/math-intrinsics/pow.js
var require_pow = /* @__PURE__ */ __commonJSMin(((exports, module) => {
/** @type {import('./pow')} */
module.exports = Math.pow;
}));
//#endregion
//#region node_modules/math-intrinsics/round.js
var require_round = /* @__PURE__ */ __commonJSMin(((exports, module) => {
/** @type {import('./round')} */
module.exports = Math.round;
}));
//#endregion
//#region node_modules/math-intrinsics/isNaN.js
var require_isNaN = /* @__PURE__ */ __commonJSMin(((exports, module) => {
/** @type {import('./isNaN')} */
module.exports = Number.isNaN || function isNaN(a) {
return a !== a;
};
}));
//#endregion
//#region node_modules/math-intrinsics/sign.js
var require_sign$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var $isNaN = require_isNaN();
/** @type {import('./sign')} */
module.exports = function sign(number) {
if ($isNaN(number) || number === 0) return number;
return number < 0 ? -1 : 1;
};
}));
//#endregion
//#region node_modules/gopd/gOPD.js
var require_gOPD = /* @__PURE__ */ __commonJSMin(((exports, module) => {
/** @type {import('./gOPD')} */
module.exports = Object.getOwnPropertyDescriptor;
}));
//#endregion
//#region node_modules/gopd/index.js
var require_gopd = /* @__PURE__ */ __commonJSMin(((exports, module) => {
/** @type {import('.')} */
var $gOPD = require_gOPD();
if ($gOPD) try {
$gOPD([], "length");
} catch (e) {
$gOPD = null;
}
module.exports = $gOPD;
}));
//#endregion
//#region node_modules/es-define-property/index.js
var require_es_define_property = /* @__PURE__ */ __commonJSMin(((exports, module) => {
/** @type {import('.')} */
var $defineProperty = Object.defineProperty || false;
if ($defineProperty) try {
$defineProperty({}, "a", { value: 1 });
} catch (e) {
$defineProperty = false;
}
module.exports = $defineProperty;
}));
//#endregion
//#region node_modules/has-symbols/index.js
var require_has_symbols = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var origSymbol = typeof Symbol !== "undefined" && Symbol;
var hasSymbolSham = require_shams$1();
/** @type {import('.')} */
module.exports = 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();
};
}));
//#endregion
//#region node_modules/get-proto/Reflect.getPrototypeOf.js
var require_Reflect_getPrototypeOf = /* @__PURE__ */ __commonJSMin(((exports, module) => {
/** @type {import('./Reflect.getPrototypeOf')} */
module.exports = typeof Reflect !== "undefined" && Reflect.getPrototypeOf || null;
}));
//#endregion
//#region node_modules/get-proto/Object.getPrototypeOf.js
var require_Object_getPrototypeOf = /* @__PURE__ */ __commonJSMin(((exports, module) => {
/** @type {import('./Object.getPrototypeOf')} */
module.exports = require_es_object_atoms().getPrototypeOf || null;
}));
//#endregion
//#region node_modules/function-bind/implementation.js
var require_implementation = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var ERROR_MESSAGE = "Function.prototype.bind called on incompatible ";
var toStr = Object.prototype.toString;
var max = Math.max;
var funcType = "[object Function]";
var concatty = function concatty(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 slicy(arrLike, offset) {
var arr = [];
for (var i = offset || 0, 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;
};
module.exports = function bind(that) {
var target = this;
if (typeof target !== "function" || toStr.apply(target) !== funcType) throw new TypeError(ERROR_MESSAGE + target);
var args = slicy(arguments, 1);
var bound;
var binder = function() {
if (this instanceof bound) {
var result = target.apply(this, concatty(args, arguments));
if (Object(result) === result) return result;
return this;
}
return target.apply(that, concatty(args, arguments));
};
var boundLength = max(0, target.length - args.length);
var boundArgs = [];
for (var 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 Empty() {};
Empty.prototype = target.prototype;
bound.prototype = new Empty();
Empty.prototype = null;
}
return bound;
};
}));
//#endregion
//#region node_modules/function-bind/index.js
var require_function_bind = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var implementation = require_implementation();
module.exports = Function.prototype.bind || implementation;
}));
//#endregion
//#region node_modules/call-bind-apply-helpers/functionCall.js
var require_functionCall = /* @__PURE__ */ __commonJSMin(((exports, module) => {
/** @type {import('./functionCall')} */
module.exports = Function.prototype.call;
}));
//#endregion
//#region node_modules/call-bind-apply-helpers/functionApply.js
var require_functionApply = /* @__PURE__ */ __commonJSMin(((exports, module) => {
/** @type {import('./functionApply')} */
module.exports = Function.prototype.apply;
}));
//#endregion
//#region node_modules/call-bind-apply-helpers/reflectApply.js
var require_reflectApply = /* @__PURE__ */ __commonJSMin(((exports, module) => {
/** @type {import('./reflectApply')} */
module.exports = typeof Reflect !== "undefined" && Reflect && Reflect.apply;
}));
//#endregion
//#region node_modules/call-bind-apply-helpers/actualApply.js
var require_actualApply = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var bind = require_function_bind();
var $apply = require_functionApply();
var $call = require_functionCall();
/** @type {import('./actualApply')} */
module.exports = require_reflectApply() || bind.call($call, $apply);
}));
//#endregion
//#region node_modules/call-bind-apply-helpers/index.js
var require_call_bind_apply_helpers = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var bind = require_function_bind();
var $TypeError = require_type();
var $call = require_functionCall();
var $actualApply = require_actualApply();
/** @type {(args: [Function, thisArg?: unknown, ...args: unknown[]]) => Function} TODO FIXME, find a way to use import('.') */
module.exports = function callBindBasic(args) {
if (args.length < 1 || typeof args[0] !== "function") throw new $TypeError("a function is required");
return $actualApply(bind, $call, args);
};
}));
//#endregion
//#region node_modules/dunder-proto/get.js
var require_get = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var callBind = require_call_bind_apply_helpers();
var gOPD = require_gopd();
var hasProtoAccessor;
try {
hasProtoAccessor = [].__proto__ === Array.prototype;
} catch (e) {
if (!e || typeof e !== "object" || !("code" in e) || e.code !== "ERR_PROTO_ACCESS") throw e;
}
var desc = !!hasProtoAccessor && gOPD && gOPD(Object.prototype, "__proto__");
var $Object = Object;
var $getPrototypeOf = $Object.getPrototypeOf;
/** @type {import('./get')} */
module.exports = desc && typeof desc.get === "function" ? callBind([desc.get]) : typeof $getPrototypeOf === "function" ? function getDunder(value) {
return $getPrototypeOf(value == null ? value : $Object(value));
} : false;
}));
//#endregion
//#region node_modules/get-proto/index.js
var require_get_proto = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var reflectGetProto = require_Reflect_getPrototypeOf();
var originalGetProto = require_Object_getPrototypeOf();
var getDunderProto = require_get();
/** @type {import('.')} */
module.exports = reflectGetProto ? function getProto(O) {
return reflectGetProto(O);
} : originalGetProto ? function getProto(O) {
if (!O || typeof O !== "object" && typeof O !== "function") throw new TypeError("getProto: not an object");
return originalGetProto(O);
} : getDunderProto ? function getProto(O) {
return getDunderProto(O);
} : null;
}));
//#endregion
//#region node_modules/hasown/index.js
var require_hasown = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var call = Function.prototype.call;
var $hasOwn = Object.prototype.hasOwnProperty;
/** @type {import('.')} */
module.exports = require_function_bind().call(call, $hasOwn);
}));
//#endregion
//#region node_modules/get-intrinsic/index.js
var require_get_intrinsic = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var undefined;
var $Object = require_es_object_atoms();
var $Error = require_es_errors();
var $EvalError = require_eval();
var $RangeError = require_range();
var $ReferenceError = require_ref();
var $SyntaxError = require_syntax();
var $TypeError = require_type();
var $URIError = require_uri();
var abs = require_abs();
var floor = require_floor();
var max = require_max();
var min = require_min();
var pow = require_pow();
var round = require_round();
var sign = require_sign$1();
var $Function = Function;
var getEvalledConstructor = function(expressionSyntax) {
try {
return $Function("\"use strict\"; return (" + expressionSyntax + ").constructor;")();
} catch (e) {}
};
var $gOPD = require_gopd();
var $defineProperty = require_es_define_property();
var throwTypeError = function() {
throw new $TypeError();
};
var ThrowTypeError = $gOPD ? function() {
try {
arguments.callee;
return throwTypeError;
} catch (calleeThrows) {
try {
return $gOPD(arguments, "callee").get;
} catch (gOPDthrows) {
return throwTypeError;
}
}
}() : throwTypeError;
var hasSymbols = require_has_symbols()();
var getProto = require_get_proto();
var $ObjectGPO = require_Object_getPrototypeOf();
var $ReflectGPO = require_Reflect_getPrototypeOf();
var $apply = require_functionApply();
var $call = require_functionCall();
var needsEval = {};
var TypedArray = typeof Uint8Array === "undefined" || !getProto ? undefined : getProto(Uint8Array);
var INTRINSICS = {
__proto__: null,
"%AggregateError%": typeof AggregateError === "undefined" ? undefined : AggregateError,
"%Array%": Array,
"%ArrayBuffer%": typeof ArrayBuffer === "undefined" ? undefined : ArrayBuffer,
"%ArrayIteratorPrototype%": hasSymbols && getProto ? getProto([][Symbol.iterator]()) : undefined,
"%AsyncFromSyncIteratorPrototype%": undefined,
"%AsyncFunction%": needsEval,
"%AsyncGenerator%": needsEval,
"%AsyncGeneratorFunction%": needsEval,
"%AsyncIteratorPrototype%": needsEval,
"%Atomics%": typeof Atomics === "undefined" ? undefined : Atomics,
"%BigInt%": typeof BigInt === "undefined" ? undefined : BigInt,
"%BigInt64Array%": typeof BigInt64Array === "undefined" ? undefined : BigInt64Array,
"%BigUint64Array%": typeof BigUint64Array === "undefined" ? undefined : BigUint64Array,
"%Boolean%": Boolean,
"%DataView%": typeof DataView === "undefined" ? undefined : DataView,
"%Date%": Date,
"%decodeURI%": decodeURI,
"%decodeURIComponent%": decodeURIComponent,
"%encodeURI%": encodeURI,
"%encodeURIComponent%": encodeURIComponent,
"%Error%": $Error,
"%eval%": eval,
"%EvalError%": $EvalError,
"%Float16Array%": typeof Float16Array === "undefined" ? undefined : Float16Array,
"%Float32Array%": typeof Float32Array === "undefined" ? undefined : Float32Array,
"%Float64Array%": typeof Float64Array === "undefined" ? undefined : Float64Array,
"%FinalizationRegistry%": typeof FinalizationRegistry === "undefined" ? undefined : FinalizationRegistry,
"%Function%": $Function,
"%GeneratorFunction%": needsEval,
"%Int8Array%": typeof Int8Array === "undefined" ? undefined : Int8Array,
"%Int16Array%": typeof Int16Array === "undefined" ? undefined : Int16Array,
"%Int32Array%": typeof Int32Array === "undefined" ? undefined : Int32Array,
"%isFinite%": isFinite,
"%isNaN%": isNaN,
"%IteratorPrototype%": hasSymbols && getProto ? getProto(getProto([][Symbol.iterator]())) : undefined,
"%JSON%": typeof JSON === "object" ? JSON : undefined,
"%Map%": typeof Map === "undefined" ? undefined : Map,
"%MapIteratorPrototype%": typeof Map === "undefined" || !hasSymbols || !getProto ? undefined : getProto((/* @__PURE__ */ new Map())[Symbol.iterator]()),
"%Math%": Math,
"%Number%": Number,
"%Object%": $Object,
"%Object.getOwnPropertyDescriptor%": $gOPD,
"%parseFloat%": parseFloat,
"%parseInt%": parseInt,
"%Promise%": typeof Promise === "undefined" ? undefined : Promise,
"%Proxy%": typeof Proxy === "undefined" ? undefined : Proxy,
"%RangeError%": $RangeError,
"%ReferenceError%": $ReferenceError,
"%Reflect%": typeof Reflect === "undefined" ? undefined : Reflect,
"%RegExp%": RegExp,
"%Set%": typeof Set === "undefined" ? undefined : Set,
"%SetIteratorPrototype%": typeof Set === "undefined" || !hasSymbols || !getProto ? undefined : getProto((/* @__PURE__ */ new Set())[Symbol.iterator]()),
"%SharedArrayBuffer%": typeof SharedArrayBuffer === "undefined" ? undefined : SharedArrayBuffer,
"%String%": String,
"%StringIteratorPrototype%": hasSymbols && getProto ? getProto(""[Symbol.iterator]()) : undefined,
"%Symbol%": hasSymbols ? Symbol : undefined,
"%SyntaxError%": $SyntaxError,
"%ThrowTypeError%": ThrowTypeError,
"%TypedArray%": TypedArray,
"%TypeError%": $TypeError,
"%Uint8Array%": typeof Uint8Array === "undefined" ? undefined : Uint8Array,
"%Uint8ClampedArray%": typeof Uint8ClampedArray === "undefined" ? undefined : Uint8ClampedArray,
"%Uint16Array%": typeof Uint16Array === "undefined" ? undefined : Uint16Array,
"%Uint32Array%": typeof Uint32Array === "undefined" ? undefined : Uint32Array,
"%URIError%": $URIError,
"%WeakMap%": typeof WeakMap === "undefined" ? undefined : WeakMap,
"%WeakRef%": typeof WeakRef === "undefined" ? undefined : WeakRef,
"%WeakSet%": typeof WeakSet === "undefined" ? undefined : WeakSet,
"%Function.prototype.call%": $call,
"%Function.prototype.apply%": $apply,
"%Object.defineProperty%": $defineProperty,
"%Object.getPrototypeOf%": $ObjectGPO,
"%Math.abs%": abs,
"%Math.floor%": floor,
"%Math.max%": max,
"%Math.min%": min,
"%Math.pow%": pow,
"%Math.round%": round,
"%Math.sign%": sign,
"%Reflect.getPrototypeOf%": $ReflectGPO
};
if (getProto) try {
null.error;
} catch (e) {
INTRINSICS["%Error.prototype%"] = getProto(getProto(e));
}
var doEval = function doEval(name) {
var value;
if (name === "%AsyncFunction%") value = getEvalledConstructor("async function () {}");
else if (name === "%GeneratorFunction%") value = getEvalledConstructor("function* () {}");
else if (name === "%AsyncGeneratorFunction%") value = getEvalledConstructor("async function* () {}");
else if (name === "%AsyncGenerator%") {
var fn = doEval("%AsyncGeneratorFunction%");
if (fn) value = fn.prototype;
} else if (name === "%AsyncIteratorPrototype%") {
var gen = doEval("%AsyncGenerator%");
if (gen && getProto) value = getProto(gen.prototype);
}
INTRINSICS[name] = value;
return value;
};
var LEGACY_ALIASES = {
__proto__: null,
"%ArrayBufferPrototype%": ["ArrayBuffer", "prototype"],
"%ArrayPrototype%": ["Array", "prototype"],
"%ArrayProto_entries%": [
"Array",
"prototype",
"entries"
],
"%ArrayProto_forEach%": [
"Array",
"prototype",
"forEach"
],
"%ArrayProto_keys%": [
"Array",
"prototype",
"keys"
],
"%ArrayProto_values%": [
"Array",
"prototype",
"values"
],
"%AsyncFunctionPrototype%": ["AsyncFunction", "prototype"],
"%AsyncGenerator%": ["AsyncGeneratorFunction", "prototype"],
"%AsyncGeneratorPrototype%": [
"AsyncGeneratorFunction",
"prototype",
"prototype"
],
"%BooleanPrototype%": ["Boolean", "prototype"],
"%DataViewPrototype%": ["DataView", "prototype"],
"%DatePrototype%": ["Date", "prototype"],
"%ErrorPrototype%": ["Error", "prototype"],
"%EvalErrorPrototype%": ["EvalError", "prototype"],
"%Float32ArrayPrototype%": ["Float32Array", "prototype"],
"%Float64ArrayPrototype%": ["Float64Array", "prototype"],
"%FunctionPrototype%": ["Function", "prototype"],
"%Generator%": ["GeneratorFunction", "prototype"],
"%GeneratorPrototype%": [
"GeneratorFunction",
"prototype",
"prototype"
],
"%Int8ArrayPrototype%": ["Int8Array", "prototype"],
"%Int16ArrayPrototype%": ["Int16Array", "prototype"],
"%Int32ArrayPrototype%": ["Int32Array", "prototype"],
"%JSONParse%": ["JSON", "parse"],
"%JSONStringify%": ["JSON", "stringify"],
"%MapPrototype%": ["Map", "prototype"],
"%NumberPrototype%": ["Number", "prototype"],
"%ObjectPrototype%": ["Object", "prototype"],
"%ObjProto_toString%": [
"Object",
"prototype",
"toString"
],
"%ObjProto_valueOf%": [
"Object",
"prototype",
"valueOf"
],
"%PromisePrototype%": ["Promise", "prototype"],
"%PromiseProto_then%": [
"Promise",
"prototype",
"then"
],
"%Promise_all%": ["Promise", "all"],
"%Promise_reject%": ["Promise", "reject"],
"%Promise_resolve%": ["Promise", "resolve"],
"%RangeErrorPrototype%": ["RangeError", "prototype"],
"%ReferenceErrorPrototype%": ["ReferenceError", "prototype"],
"%RegExpPrototype%": ["RegExp", "prototype"],
"%SetPrototype%": ["Set", "prototype"],
"%SharedArrayBufferPrototype%": ["SharedArrayBuffer", "prototype"],
"%StringPrototype%": ["String", "prototype"],
"%SymbolPrototype%": ["Symbol", "prototype"],
"%SyntaxErrorPrototype%": ["SyntaxError", "prototype"],
"%TypedArrayPrototype%": ["TypedArray", "prototype"],
"%TypeErrorPrototype%": ["TypeError", "prototype"],
"%Uint8ArrayPrototype%": ["Uint8Array", "prototype"],
"%Uint8ClampedArrayPrototype%": ["Uint8ClampedArray", "prototype"],
"%Uint16ArrayPrototype%": ["Uint16Array", "prototype"],
"%Uint32ArrayPrototype%": ["Uint32Array", "prototype"],
"%URIErrorPrototype%": ["URIError", "prototype"],
"%WeakMapPrototype%": ["WeakMap", "prototype"],
"%WeakSetPrototype%": ["WeakSet", "prototype"]
};
var bind = require_function_bind();
var hasOwn = require_hasown();
var $concat = bind.call($call, Array.prototype.concat);
var $spliceApply = bind.call($apply, Array.prototype.splice);
var $replace = bind.call($call, String.prototype.replace);
var $strSlice = bind.call($call, String.prototype.slice);
var $exec = bind.call($call, RegExp.prototype.exec);
var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g;
var reEscapeChar = /\\(\\)?/g;
var stringToPath = function stringToPath(string) {
var first = $strSlice(string, 0, 1);
var last = $strSlice(string, -1);
if (first === "%" && last !== "%") throw new $SyntaxError("invalid intrinsic syntax, expected closing `%`");
else if (last === "%" && first !== "%") throw new $SyntaxError("invalid intrinsic syntax, expected opening `%`");
var result = [];
$replace(string, rePropName, function(match, number, quote, subString) {
result[result.length] = quote ? $replace(subString, reEscapeChar, "$1") : number || match;
});
return result;
};
var getBaseIntrinsic = function getBaseIntrinsic(name, allowMissing) {
var intrinsicName = name;
var alias;
if (hasOwn(LEGACY_ALIASES, intrinsicName)) {
alias = LEGACY_ALIASES[intrinsicName];
intrinsicName = "%" + alias[0] + "%";
}
if (hasOwn(INTRINSICS, intrinsicName)) {
var value = INTRINSICS[intrinsicName];
if (value === needsEval) value = doEval(intrinsicName);
if (typeof value === "undefined" && !allowMissing) throw new $TypeError("intrinsic " + name + " exists, but is not available. Please file an issue!");
return {
alias,
name: intrinsicName,
value
};
}
throw new $SyntaxError("intrinsic " + name + " does not exist!");
};
module.exports = function GetIntrinsic(name, allowMissing) {
if (typeof name !== "string" || name.length === 0) throw new $TypeError("intrinsic name must be a non-empty string");
if (arguments.length > 1 && typeof allowMissing !== "boolean") throw new $TypeError("\"allowMissing\" argument must be a boolean");
if ($exec(/^%?[^%]*%?$/, name) === null) throw new $SyntaxError("`%` may not be present anywhere but at the beginning and end of the intrinsic name");
var parts = stringToPath(name);
var intrinsicBaseName = parts.length > 0 ? parts[0] : "";
var intrinsic = getBaseIntrinsic("%" + intrinsicBaseName + "%", allowMissing);
var intrinsicRealName = intrinsic.name;
var value = intrinsic.value;
var skipFurtherCaching = false;
var alias = intrinsic.alias;
if (alias) {
intrinsicBaseName = alias[0];
$spliceApply(parts, $concat([0, 1], alias));
}
for (var 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("property names with quotes must have matching quotes");
if (part === "constructor" || !isOwn) skipFurtherCaching = true;
intrinsicBaseName += "." + part;
intrinsicRealName = "%" + intrinsicBaseName + "%";
if (hasOwn(INTRINSICS, intrinsicRealName)) value = INTRINSICS[intrinsicRealName];
else if (value != null) {
if (!(part in value)) {
if (!allowMissing) throw new $TypeError("base intrinsic for " + name + " exists, but the property is not available.");
return;
}
if ($gOPD && i + 1 >= parts.length) {
var desc = $gOPD(value, part);
isOwn = !!desc;
if (isOwn && "get" in desc && !("originalValue" in desc.get)) value = desc.get;
else value = value[part];
} else {
isOwn = hasOwn(value, part);
value = value[part];
}
if (isOwn && !skipFurtherCaching) INTRINSICS[intrinsicRealName] = value;
}
}
return value;
};
}));
//#endregion
//#region node_modules/call-bound/index.js
var require_call_bound = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var GetIntrinsic = require_get_intrinsic();
var callBindBasic = require_call_bind_apply_helpers();
/** @type {(thisArg: string, searchString: string, position?: number) => number} */
var $indexOf = callBindBasic([GetIntrinsic("%String.prototype.indexOf%")]);
/** @type {import('.')} */
module.exports = function callBoundIntrinsic(name, allowMissing) {
var intrinsic = GetIntrinsic(name, !!allowMissing);
if (typeof intrinsic === "function" && $indexOf(name, ".prototype.") > -1) return callBindBasic([intrinsic]);
return intrinsic;
};
}));
//#endregion
//#region node_modules/is-arguments/index.js
var require_is_arguments = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var hasToStringTag = require_shams()();
var $toString = require_call_bound()("Object.prototype.toString");
/** @type {import('.')} */
var isStandardArguments = function isArguments(value) {
if (hasToStringTag && value && typeof value === "object" && Symbol.toStringTag in value) return false;
return $toString(value) === "[object Arguments]";
};
/** @type {import('.')} */
var isLegacyArguments = function isArguments(value) {
if (isStandardArguments(value)) return true;
return value !== null && typeof value === "object" && "length" in value && typeof value.length === "number" && value.length >= 0 && $toString(value) !== "[object Array]" && "callee" in value && $toString(value.callee) === "[object Function]";
};
var supportsStandardArguments = function() {
return isStandardArguments(arguments);
}();
isStandardArguments.isLegacyArguments = isLegacyArguments;
/** @type {import('.')} */
module.exports = supportsStandardArguments ? isStandardArguments : isLegacyArguments;
}));
//#endregion
//#region node_modules/is-regex/index.js
var require_is_regex = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var callBound = require_call_bound();
var hasToStringTag = require_shams()();
var hasOwn = require_hasown();
var gOPD = require_gopd();
/** @type {import('.')} */
var fn;
if (hasToStringTag) {
/** @type {(receiver: ThisParameterType<typeof RegExp.prototype.exec>, ...args: Parameters<typeof RegExp.prototype.exec>) => ReturnType<typeof RegExp.prototype.exec>} */
var $exec = callBound("RegExp.prototype.exec");
/** @type {object} */
var isRegexMarker = {};
var throwRegexMarker = function() {
throw isRegexMarker;
};
/** @type {{ toString(): never, valueOf(): never, [Symbol.toPrimitive]?(): never }} */
var badStringifier = {
toString: throwRegexMarker,
valueOf: throwRegexMarker
};
if (typeof Symbol.toPrimitive === "symbol") badStringifier[Symbol.toPrimitive] = throwRegexMarker;
/** @type {import('.')} */
fn = function isRegex(value) {
if (!value || typeof value !== "object") return false;
var descriptor = gOPD(value, "lastIndex");
if (!(descriptor && hasOwn(descriptor, "value"))) return false;
try {
$exec(value, badStringifier);
} catch (e) {
return e === isRegexMarker;
}
};
} else {
/** @type {(receiver: ThisParameterType<typeof Object.prototype.toString>, ...args: Parameters<typeof Object.prototype.toString>) => ReturnType<typeof Object.prototype.toString>} */
var $toString = callBound("Object.prototype.toString");
/** @const @type {'[object RegExp]'} */
var regexClass = "[object RegExp]";
/** @type {import('.')} */
fn = function isRegex(value) {
if (!value || typeof value !== "object" && typeof value !== "function") return false;
return $toString(value) === regexClass;
};
}
module.exports = fn;
}));
//#endregion
//#region node_modules/safe-regex-test/index.js
var require_safe_regex_test = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var callBound = require_call_bound();
var isRegex = require_is_regex();
var $exec = callBound("RegExp.prototype.exec");
var $TypeError = require_type();
/** @type {import('.')} */
module.exports = function regexTester(regex) {
if (!isRegex(regex)) throw new $TypeError("`regex` must be a RegExp");
return function test(s) {
return $exec(regex, s) !== null;
};
};
}));
//#endregion
//#region node_modules/is-generator-function/index.js
var require_is_generator_function = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var callBound = require_call_bound();
var isFnRegex = require_safe_regex_test()(/^\s*(?:function)?\*/);
var hasToStringTag = require_shams()();
var getProto = require_get_proto();
var toStr = callBound("Object.prototype.toString");
var fnToStr = callBound("Function.prototype.toString");
var getGeneratorFunc = function() {
if (!hasToStringTag) return false;
try {
return Function("return function*() {}")();
} catch (e) {}
};
/** @type {undefined | false | null | GeneratorFunctionConstructor} */
var GeneratorFunction;
/** @type {import('.')} */
module.exports = function isGeneratorFunction(fn) {
if (typeof fn !== "function") return false;
if (isFnRegex(fnToStr(fn))) return true;
if (!hasToStringTag) return toStr(fn) === "[object GeneratorFunction]";
if (!getProto) return false;
if (typeof GeneratorFunction === "undefined") {
var generatorFunc = getGeneratorFunc();
GeneratorFunction = generatorFunc ? getProto(generatorFunc) : false;
}
return getProto(fn) === GeneratorFunction;
};
}));
//#endregion
//#region node_modules/is-callable/index.js
var require_is_callable = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var fnToStr = Function.prototype.toString;
var reflectApply = typeof Reflect === "object" && Reflect !== null && Reflect.apply;
var badArrayLike;
var isCallableMarker;
if (typeof reflectApply === "function" && typeof Object.defineProperty === "function") try {
badArrayLike = Object.defineProperty({}, "length", { get: function() {
throw isCallableMarker;
} });
isCallableMarker = {};
reflectApply(function() {
throw 42;
}, null, badArrayLike);
} catch (_) {
if (_ !== isCallableMarker) reflectApply = null;
}
else reflectApply = null;
var constructorRegex = /^\s*class\b/;
var isES6ClassFn = function isES6ClassFunction(value) {
try {
var fnStr = fnToStr.call(value);
return constructorRegex.test(fnStr);
} catch (e) {
return false;
}
};
var tryFunctionObject = function tryFunctionToStr(value) {
try {
if (isES6ClassFn(value)) return false;
fnToStr.call(value);
return true;
} catch (e) {
return false;
}
};
var toStr = Object.prototype.toString;
var objectClass = "[object Object]";
var fnClass = "[object Function]";
var genClass = "[object GeneratorFunction]";
var ddaClass = "[object HTMLAllCollection]";
var ddaClass2 = "[object HTML document.all class]";
var ddaClass3 = "[object HTMLCollection]";
var hasToStringTag = typeof Symbol === "function" && !!Symbol.toStringTag;
var isIE68 = !(0 in [,]);
var isDDA = function isDocumentDotAll() {
return false;
};
if (typeof document === "object") {
var all = document.all;
if (toStr.call(all) === toStr.call(document.all)) isDDA = function isDocumentDotAll(value) {
if ((isIE68 || !value) && (typeof value === "undefined" || typeof value === "object")) try {
var str = toStr.call(value);
return (str === ddaClass || str === ddaClass2 || str === ddaClass3 || str === objectClass) && value("") == null;
} catch (e) {}
return false;
};
}
module.exports = reflectApply ? function isCallable(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 isCallable(value) {
if (isDDA(value)) return true;
if (!value) return false;
if (typeof value !== "function" && typeof value !== "object") return false;
if (hasToStringTag) return tryFunctionObject(value);
if (isES6ClassFn(value)) return false;
var strClass = toStr.call(value);
if (strClass !== fnClass && strClass !== genClass && !/^\[object HTML/.test(strClass)) return false;
return tryFunctionObject(value);
};
}));
//#endregion
//#region node_modules/for-each/index.js
var require_for_each = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var isCallable = require_is_callable();
var toStr = Object.prototype.toString;
var hasOwnProperty = Object.prototype.hasOwnProperty;
/** @type {<This, A extends readonly unknown[]>(arr: A, iterator: (this: This | void, value: A[number], index: number, arr: A) => void, receiver: This | undefined) => void} */
var forEachArray = function forEachArray(array, iterator, receiver) {
for (var i = 0, len = array.length; i < len; i++) if (hasOwnProperty.call(array, i)) if (receiver == null) iterator(array[i], i, array);
else iterator.call(receiver, array[i], i, array);
};
/** @type {<This, S extends string>(string: S, iterator: (this: This | void, value: S[number], index: number, string: S) => void, receiver: This | undefined) => void} */
var forEachString = function forEachString(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);
};
/** @type {<This, O>(obj: O, iterator: (this: This | void, value: O[keyof O], index: keyof O, obj: O) => void, receiver: This | undefined) => void} */
var forEachObject = function forEachObject(object, iterator, receiver) {
for (var k in object) if (hasOwnProperty.call(object, k)) if (receiver == null) iterator(object[k], k, object);
else iterator.call(receiver, object[k], k, object);
};
/** @type {(x: unknown) => x is readonly unknown[]} */
function isArray(x) {
return toStr.call(x) === "[object Array]";
}
/** @type {import('.')._internal} */
module.exports = function forEach(list, iterator, thisArg) {
if (!isCallable(iterator)) throw new TypeError("iterator must be a function");
var receiver;
if (arguments.length >= 3) receiver = thisArg;
if (isArray(list)) forEachArray(list, iterator, receiver);
else if (typeof list === "string") forEachString(list, iterator, receiver);
else forEachObject(list, iterator, receiver);
};
}));
//#endregion
//#region node_modules/possible-typed-array-names/index.js
var require_possible_typed_array_names = /* @__PURE__ */ __commonJSMin(((exports, module) => {
/** @type {import('.')} */
module.exports = [
"Float16Array",
"Float32Array",
"Float64Array",
"Int8Array",
"Int16Array",
"Int32Array",
"Uint8Array",
"Uint8ClampedArray",
"Uint16Array",
"Uint32Array",
"BigInt64Array",
"BigUint64Array"
];
}));
//#endregion
//#region node_modules/available-typed-arrays/index.js
var require_available_typed_arrays = /* @__PURE__ */ __commonJSMin(((exports, module) => {
init_dist();
var possibleNames = require_possible_typed_array_names();
var g = typeof globalThis === "undefined" ? global : globalThis;
/** @type {import('.')} */
module.exports = function availableTypedArrays() {
var out = [];
for (var i = 0; i < possibleNames.length; i++) if (typeof g[possibleNames[i]] === "function") out[out.length] = possibleNames[i];
return out;
};
}));
//#endregion
//#region node_modules/define-data-property/index.js
var require_define_data_property = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var $defineProperty = require_es_define_property();
var $SyntaxError = require_syntax();
var $TypeError = require_type();
var gopd = require_gopd();
/** @type {import('.')} */
module.exports = function defineDataProperty(obj, property, value) {
if (!obj || typeof obj !== "object" && typeof obj !== "function") throw new $TypeError("`obj` must be an object or a function`");
if (typeof property !== "string" && typeof property !== "symbol") throw new $TypeError("`property` must be a string or a symbol`");
if (arguments.length > 3 && typeof arguments[3] !== "boolean" && arguments[3] !== null) throw new $TypeError("`nonEnumerable`, if provided, must be a boolean or null");
if (arguments.length > 4 && typeof arguments[4] !== "boolean" && arguments[4] !== null) throw new $TypeError("`nonWritable`, if provided, must be a boolean or null");
if (arguments.length > 5 && typeof arguments[5] !== "boolean" && arguments[5] !== null) throw new $TypeError("`nonConfigurable`, if provided, must be a boolean or null");
if (arguments.length > 6 && typeof arguments[6] !== "boolean") throw new $TypeError("`loose`, if provided, must be a boolean");
var nonEnumerable = arguments.length > 3 ? arguments[3] : null;
var nonWritable = arguments.length > 4 ? arguments[4] : null;
var nonConfigurable = arguments.length > 5 ? arguments[5] : null;
var loose = arguments.length > 6 ? arguments[6] : false;
var desc = !!gopd && gopd(obj, property);
if ($defineProperty) $defineProperty(obj, property, {
configurable: nonConfigurable === null && desc ? desc.configurable : !nonConfigurable,
enumerable: nonEnumerable === null && desc ? desc.enumerable : !nonEnumerable,
value,
writable: nonWritable === null && desc ? desc.writable : !nonWritable
});
else if (loose || !nonEnumerable && !nonWritable && !nonConfigurable) obj[property] = value;
else throw new $SyntaxError("This environment does not support defining a property as non-configurable, non-writable, or non-enumerable.");
};
}));
//#endregion
//#region node_modules/has-property-descriptors/index.js
var require_has_property_descriptors = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var $defineProperty = require_es_define_property();
var hasPropertyDescriptors = function hasPropertyDescriptors() {
return !!$defineProperty;
};
hasPropertyDescriptors.hasArrayLengthDefineBug = function hasArrayLengthDefineBug() {
if (!$defineProperty) return null;
try {
return $defineProperty([], "length", { value: 1 }).length !== 1;
} catch (e) {
return true;
}
};
module.exports = hasPropertyDescriptors;
}));
//#endregion
//#region node_modules/set-function-length/index.js
var require_set_function_length = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var GetIntrinsic = require_get_intrinsic();
var define = require_define_data_property();
var hasDescriptors = require_has_property_descriptors()();
var gOPD = require_gopd();
var $TypeError = require_type();
var $floor = GetIntrinsic("%Math.floor%");
/** @type {import('.')} */
module.exports = function setFunctionLength(fn, length) {
if (typeof fn !== "function") throw new $TypeError("`fn` is not a function");
if (typeof length !== "number" || length < 0 || length > 4294967295 || $floor(length) !== length) throw new $TypeError("`length` must be a positive 32-bit integer");
var loose = arguments.length > 2 && !!arguments[2];
var functionLengthIsConfigurable = true;
var functionLengthIsWritable = true;
if ("length" in fn && gOPD) {
var desc = gOPD(fn, "length");
if (desc && !desc.configurable) functionLengthIsConfigurable = false;
if (desc && !desc.writable) functionLengthIsWritable = false;
}
if (functionLengthIsConfigurable || functionLengthIsWritable || !loose) if (hasDescriptors) define(fn, "length", length, true, true);
else define(fn, "length", length);
return fn;
};
}));
//#endregion
//#region node_modules/call-bind-apply-helpers/applyBind.js
var require_applyBind = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var bind = require_function_bind();
var $apply = require_functionApply();
var actualApply = require_actualApply();
/** @type {import('./applyBind')} */
module.exports = function applyBind() {
return actualApply(bind, $apply, arguments);
};
}));
//#endregion
//#region node_modules/call-bind/index.js
var require_call_bind = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var setFunctionLength = require_set_function_length();
var $defineProperty = require_es_define_property();
var callBindBasic = require_call_bind_apply_helpers();
var applyBind = require_applyBind();
module.exports = function callBind(originalFunction) {
var func = callBindBasic(arguments);
var adjustedLength = originalFunction.length - (arguments.length - 1);
return setFunctionLength(func, 1 + (adjustedLength > 0 ? adjustedLength : 0), true);
};
if ($defineProperty) $defineProperty(module.exports, "apply", { value: applyBind });
else module.exports.apply = applyBind;
}));
//#endregion
//#region node_modules/which-typed-array/index.js
var require_which_typed_array = /* @__PURE__ */ __commonJSMin(((exports, module) => {
init_dist();
var forEach = require_for_each();
var availableTypedArrays = require_available_typed_arrays();
var callBind = require_call_bind();
var callBound = require_call_bound();
var gOPD = require_gopd();
var getProto = require_get_proto();
var $toString = callBound("Object.prototype.toString");
var hasToStringTag = require_shams()();
var g = typeof globalThis === "undefined" ? global : globalThis;
var typedArrays = availableTypedArrays();
var $slice = callBound("String.prototype.slice");
/** @type {<T = unknown>(array: readonly T[], value: unknown) => number} */
var $indexOf = callBound("Array.prototype.indexOf", true) || function indexOf(array, value) {
for (var i = 0; i < array.length; i += 1) if (array[i] === value) return i;
return -1;
};
/** @typedef {import('./types').Getter} Getter */
/** @type {import('./types').Cache} */
var cache = { __proto__: null };
if (hasToStringTag && gOPD && getProto) forEach(typedArrays, function(typedArray) {
var arr = new g[typedArray]();
if (Symbol.toStringTag in arr && getProto) {
var proto = getProto(arr);
var descriptor = gOPD(proto, Symbol.toStringTag);
if (!descriptor && proto) descriptor = gOPD(getProto(proto), 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);
});
/** @type {(value: object) => false | import('.').TypedArrayName} */
var tryTypedArrays = function tryAllTypedArrays(value) {
/** @type {ReturnType<typeof tryAllTypedArrays>} */ var found = false;
forEach(
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;
};
/** @type {(value: object) => false | import('.').TypedArrayName} */
var trySlices = function tryAllSlices(value) {
/** @type {ReturnType<typeof tryAllSlices>} */ var found = false;
forEach(
cache,
/** @type {(getter: Getter, name: `\$${import('.').TypedArrayName}`) => void} */
function(getter, name) {
if (!found) try {
getter(value);
found = $slice(name, 1);
} catch (e) {}
}
);
return found;
};
/** @type {import('.')} */
module.exports = function whichTypedArray(value) {
if (!value || typeof value !== "object") return false;
if (!hasToStringTag) {
/** @type {string} */
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);
};
}));
//#endregion
//#region node_modules/is-typed-array/index.js
var require_is_typed_array = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var whichTypedArray = require_which_typed_array();
/** @type {import('.')} */
module.exports = function isTypedArray(value) {
return !!whichTypedArray(value);
};
}));
//#endregion
//#region node_modules/util/support/types.js
var require_types = /* @__PURE__ */ __commonJSMin(((exports) => {
var isArgumentsObject = require_is_arguments();
var isGeneratorFunction = require_is_generator_function();
var whichTypedArray = require_which_typed_array();
var isTypedArray = require_is_typed_array();
function uncurryThis(f) {
return f.call.bind(f);
}
var BigIntSupported = typeof BigInt !== "undefined";
var SymbolSupported = typeof Symbol !== "undefined";
var ObjectToString = uncurryThis(Object.prototype.toString);
var numberValue = uncurryThis(Number.prototype.valueOf);
var stringValue = uncurryThis(String.prototype.valueOf);
var booleanValue = uncurryThis(Boolean.prototype.valueOf);
if (BigIntSupported) var bigIntValue = uncurryThis(BigInt.prototype.valueOf);
if (SymbolSupported) var symbolValue = uncurryThis(Symbol.prototype.valueOf);
function checkBoxedPrimitive(value, prototypeValueOf) {
if (typeof value !== "object") return false;
try {
prototypeValueOf(value);
return true;
} catch (e) {
return false;
}
}
exports.isArgumentsObject = isArgumentsObject;
exports.isGeneratorFunction = isGeneratorFunction;
exports.isTypedArray = isTypedArray;
function isPromise(input) {
return typeof Promise !== "undefined" && input instanceof Promise || input !== null && typeof input === "object" && typeof input.then === "function" && typeof input.catch === "function";
}
exports.isPromise = isPromise;
function isArrayBufferView(value) {
if (typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView) return ArrayBuffer.isView(value);
return isTypedArray(value) || isDataView(value);
}
exports.isArrayBufferView = isArrayBufferView;
function isUint8Array(value) {
return whichTypedArray(value) === "Uint8Array";
}
exports.isUint8Array = isUint8Array;
function isUint8ClampedArray(value) {
return whichTypedArray(value) === "Uint8ClampedArray";
}
exports.isUint8ClampedArray = isUint8ClampedArray;
function isUint16Array(value) {
return whichTypedArray(value) === "Uint16Array";
}
exports.isUint16Array = isUint16Array;
function isUint32Array(value) {
return whichTypedArray(value) === "Uint32Array";
}
exports.isUint32Array = isUint32Array;
function isInt8Array(value) {
return whichTypedArray(value) === "Int8Array";
}
exports.isInt8Array = isInt8Array;
function isInt16Array(value) {
return whichTypedArray(value) === "Int16Array";
}
exports.isInt16Array = isInt16Array;
function isInt32Array(value) {
return whichTypedArray(value) === "Int32Array";
}
exports.isInt32Array = isInt32Array;
function isFloat32Array(value) {
return whichTypedArray(value) === "Float32Array";
}
exports.isFloat32Array = isFloat32Array;
function isFloat64Array(value) {
return whichTypedArray(value) === "Float64Array";
}
exports.isFloat64Array = isFloat64Array;
function isBigInt64Array(value) {
return whichTypedArray(value) === "BigInt64Array";
}
exports.isBigInt64Array = isBigInt64Array;
function isBigUint64Array(value) {
return whichTypedArray(value) === "BigUint64Array";
}
exports.isBigUint64Array = isBigUint64Array;
function isMapToString(value) {
return ObjectToString(value) === "[object Map]";
}
isMapToString.working = typeof Map !== "undefined" && isMapToString(/* @__PURE__ */ new Map());
function isMap(value) {
if (typeof Map === "undefined") return false;
return isMapToString.working ? isMapToString(value) : value instanceof Map;
}
exports.isMap = isMap;
function isSetToString(value) {
return ObjectToString(value) === "[object Set]";
}
isSetToString.working = typeof Set !== "undefined" && isSetToString(/* @__PURE__ */ new Set());
function isSet(value) {
if (typeof Set === "undefined") return false;
return isSetToString.working ? isSetToString(value) : value instanceof Set;
}
exports.isSet = isSet;
function isWeakMapToString(value) {
return ObjectToString(value) === "[object WeakMap]";
}
isWeakMapToString.working = typeof WeakMap !== "undefined" && isWeakMapToString(/* @__PURE__ */ new WeakMap());
function isWeakMap(value) {
if (typeof WeakMap === "undefined") return false;
return isWeakMapToString.working ? isWeakMapToString(value) : value instanceof WeakMap;
}
exports.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);
}
exports.isWeakSet = isWeakSet;
function isArrayBufferToString(value) {
return ObjectToString(value) === "[object ArrayBuffer]";
}
isArrayBufferToString.working = typeof ArrayBuffer !== "undefined" && isArrayBufferToString(/* @__PURE__ */ new ArrayBuffer());
function isArrayBuffer(value) {
if (typeof ArrayBuffer === "undefined") return false;
return isArrayBufferToString.working ? isArrayBufferToString(value) : value instanceof ArrayBuffer;
}
exports.isArrayBuffer = isArrayBuffer;
function isDataViewToString(value) {
return ObjectToString(value) === "[object DataView]";
}
isDataViewToString.working = typeof ArrayBuffer !== "undefined" && typeof DataView !== "undefined" && isDataViewToString(new DataView(/* @__PURE__ */ new ArrayBuffer(1), 0, 1));
function isDataView(value) {
if (typeof DataView === "undefined") return false;
return isDataViewToString.working ? isDataViewToString(value) : value instanceof DataView;
}
exports.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;
}
exports.isSharedArrayBuffer = isSharedArrayBuffer;
function isAsyncFunction(value) {
return ObjectToString(value) === "[object AsyncFunction]";
}
exports.isAsyncFunction = isAsyncFunction;
function isMapIterator(value) {
return ObjectToString(value) === "[object Map Iterator]";
}
exports.isMapIterator = isMapIterator;
function isSetIterator(value) {
return ObjectToString(value) === "[object Set Iterator]";
}
exports.isSetIterator = isSetIterator;
function isGeneratorObject(value) {
return ObjectToString(value) === "[object Generator]";
}
exports.isGeneratorObject = isGeneratorObject;
function isWebAssemblyCompiledModule(value) {
return ObjectToString(value) === "[object WebAssembly.Module]";
}
exports.isWebAssemblyCompiledModule = isWebAssemblyCompiledModule;
function isNumberObject(value) {
return checkBoxedPrimitive(value, numberValue);
}
exports.isNumberObject = isNumberObject;
function isStringObject(value) {
return checkBoxedPrimitive(value, stringValue);
}
exports.isStringObject = isStringObject;
function isBooleanObject(value) {
return checkBoxedPrimitive(value, booleanValue);
}
exports.isBooleanObject = isBooleanObject;
function isBigIntObject(value) {
return BigIntSupported && checkBoxedPrimitive(value, bigIntValue);
}
exports.isBigIntObject = isBigIntObject;
function isSymbolObject(value) {
return SymbolSupported && checkBoxedPrimitive(value, symbolValue);
}
exports.isSymbolObject = isSymbolObject;
function isBoxedPrimitive(value) {
return isNumberObject(value) || isStringObject(value) || isBooleanObject(value) || isBigIntObject(value) || isSymbolObject(value);
}
exports.isBoxedPrimitive = isBoxedPrimitive;
function isAnyArrayBuffer(value) {
return typeof Uint8Array !== "undefined" && (isArrayBuffer(value) || isSharedArrayBuffer(value));
}
exports.isAnyArrayBuffer = isAnyArrayBuffer;
[
"isProxy",
"isExternal",
"isModuleNamespaceObject"
].forEach(function(method) {
Object.defineProperty(exports, method, {
enumerable: false,
value: function() {
throw new Error(method + " is not supported in userland");
}
});
});
}));
//#endregion
//#region node_modules/util/support/isBufferBrowser.js
var require_isBufferBrowser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = function isBuffer(arg) {
return arg && typeof arg === "object" && typeof arg.copy === "function" && typeof arg.fill === "function" && typeof arg.readUInt8 === "function";
};
}));
//#endregion
//#region node_modules/util/util.js
var require_util$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
init_dist$2();
var getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors || function getOwnPropertyDescriptors(obj) {
var keys = Object.keys(obj);
var descriptors = {};
for (var i = 0; i < keys.length; i++) descriptors[keys[i]] = Object.getOwnPropertyDescriptor(obj, keys[i]);
return descriptors;
};
var formatRegExp = /%[sdj%]/g;
exports.format = function(f) {
if (!isString(f)) {
var objects = [];
for (var i = 0; i < arguments.length; i++) objects.push(inspect(arguments[i]));
return objects.join(" ");
}
var i = 1;
var args = arguments;
var len = args.length;
var str = String(f).replace(formatRegExp, function(x) {
if (x === "%%") return "%";
if (i >= len) return x;
switch (x) {
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 x;
}
});
for (var x = args[i]; i < len; x = args[++i]) if (isNull(x) || !isObject(x)) str += " " + x;
else str += " " + inspect(x);
return str;
};
exports.deprecate = function(fn, msg) {
if (typeof process$1 !== "undefined" && process$1.noDeprecation === true) return fn;
if (typeof process$1 === "undefined") return function() {
return exports.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 ({}.NODE_DEBUG) {
var debugEnv = {}.NODE_DEBUG;
debugEnv = debugEnv.replace(/[|\\{}()[\]^$+?.]/g, "\\$&").replace(/\*/g, ".*").replace(/,/g, "$|^").toUpperCase();
debugEnvRegex = new RegExp("^" + debugEnv + "$", "i");
}
exports.debuglog = function(set) {
set = set.toUpperCase();
if (!debugs[set]) if (debugEnvRegex.test(set)) {
var pid = process$1.pid;
debugs[set] = function() {
var msg = exports.format.apply(exports, arguments);
console.error("%s %d: %s", set, pid, msg);
};
} else debugs[set] = function() {};
return debugs[set];
};
/**
* Echos the value of a value. Trys to print the value out
* in the best way possible given the different types.
*
* @param {Object} obj The object to print out.
* @param {Object} opts Optional options object that alters the output.
*/
function inspect(obj, opts) {
var ctx = {
seen: [],
stylize: stylizeNoColor
};
if (arguments.length >= 3) ctx.depth = arguments[2];
if (arguments.length >= 4) ctx.colors = arguments[3];
if (isBoolean(opts)) ctx.showHidden = opts;
else if (opts) exports._extend(ctx, opts);
if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
if (isUndefined(ctx.depth)) ctx.depth = 2;
if (isUndefined(ctx.colors)) ctx.colors = false;
if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
if (ctx.colors) ctx.stylize = stylizeWithColor;
return formatValue(ctx, obj, ctx.depth);
}
exports.inspect = inspect;
inspect.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]
};
inspect.styles = {
"special": "cyan",
"number": "yellow",
"boolean": "yellow",
"undefined": "grey",
"null": "bold",
"string": "green",
"date": "magenta",
"regexp": "red"
};
function stylizeWithColor(str, styleType) {
var style = inspect.styles[styleType];
if (style) return "\x1B[" + inspect.colors[style][0] + "m" + str + "\x1B[" + inspect.colors[style][1] + "m";
else return str;
}
function stylizeNoColor(str, styleType) {
return str;
}
function arrayToHash(array) {
var hash = {};
array.forEach(function(val, idx) {
hash[val] = true;
});
return hash;
}
function formatValue(ctx, value, recurseTimes) {
if (ctx.customInspect && value && isFunction(value.inspect) && value.inspect !== exports.inspect && !(value.constructor && value.constructor.prototype === value)) {
var ret = value.inspect(recurseTimes, ctx);
if (!isString(ret)) ret = formatValue(ctx, ret, recurseTimes);
return ret;
}
var primitive = formatPrimitive(ctx, value);
if (primitive) return primitive;
var keys = Object.keys(value);
var visibleKeys = arrayToHash(keys);
if (ctx.showHidden) keys = Object.getOwnPropertyNames(value);
if (isError(value) && (keys.indexOf("message") >= 0 || keys.indexOf("description") >= 0)) return formatError(value);
if (keys.length === 0) {
if (isFunction(value)) {
var name = value.name ? ": " + value.name : "";
return ctx.stylize("[Function" + name + "]", "special");
}
if (isRegExp(value)) return ctx.stylize(RegExp.prototype.toString.call(value), "regexp");
if (isDate(value)) return ctx.stylize(Date.prototype.toString.call(value), "date");
if (isError(value)) return formatError(value);
}
var base = "", array = false, braces = ["{", "}"];
if (isArray(value)) {
array = true;
braces = ["[", "]"];
}
if (isFunction(value)) base = " [Function" + (value.name ? ": " + value.name : "") + "]";
if (isRegExp(value)) base = " " + RegExp.prototype.toString.call(value);
if (isDate(value)) base = " " + Date.prototype.toUTCString.call(value);
if (isError(value)) base = " " + formatError(value);
if (keys.length === 0 && (!array || value.length == 0)) return braces[0] + base + braces[1];
if (recurseTimes < 0) if (isRegExp(value)) return ctx.stylize(RegExp.prototype.toString.call(value), "regexp");
else return ctx.stylize("[Object]", "special");
ctx.seen.push(value);
var output;
if (array) output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
else output = keys.map(function(key) {
return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
});
ctx.seen.pop();
return reduceToSingleString(output, base, braces);
}
function formatPrimitive(ctx, value) {
if (isUndefined(value)) return ctx.stylize("undefined", "undefined");
if (isString(value)) {
var simple = "'" + JSON.stringify(value).replace(/^"|"$/g, "").replace(/'/g, "\\'").replace(/\\"/g, "\"") + "'";
return ctx.stylize(simple, "string");
}
if (isNumber(value)) return ctx.stylize("" + value, "number");
if (isBoolean(value)) return ctx.stylize("" + value, "boolean");
if (isNull(value)) return ctx.stylize("null", "null");
}
function formatError(value) {
return "[" + Error.prototype.toString.call(value) + "]";
}
function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
var output = [];
for (var i = 0, l = value.length; i < l; ++i) if (hasOwnProperty(value, String(i))) output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, String(i), true));
else output.push("");
keys.forEach(function(key) {
if (!key.match(/^\d+$/)) output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, key, true));
});
return output;
}
function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
var name, str, desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
if (desc.get) if (desc.set) str = ctx.stylize("[Getter/Setter]", "special");
else str = ctx.stylize("[Getter]", "special");
else if (desc.set) str = ctx.stylize("[Setter]", "special");
if (!hasOwnProperty(visibleKeys, key)) name = "[" + key + "]";
if (!str) if (ctx.seen.indexOf(desc.value) < 0) {
if (isNull(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 (isUndefined(name)) {
if (array && key.match(/^\d+$/)) return str;
name = JSON.stringify("" + key);
if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
name = name.slice(1, -1);
name = ctx.stylize(name, "name");
} else {
name = name.replace(/'/g, "\\'").replace(/\\"/g, "\"").replace(/(^"|"$)/g, "'");
name = ctx.stylize(name, "string");
}
}
return name + ": " + str;
}
function reduceToSingleString(output, base, braces) {
var numLinesEst = 0;
if (output.reduce(function(prev, cur) {
numLinesEst++;
if (cur.indexOf("\n") >= 0) numLinesEst++;
return prev + cur.replace(/\u001b\[\d\d?m/g, "").length + 1;
}, 0) > 60) return braces[0] + (base === "" ? "" : base + "\n ") + " " + output.join(",\n ") + " " + braces[1];
return braces[0] + base + " " + output.join(", ") + " " + braces[1];
}
exports.types = require_types();
function isArray(ar) {
return Array.isArray(ar);
}
exports.isArray = isArray;
function isBoolean(arg) {
return typeof arg === "boolean";
}
exports.isBoolean = isBoolean;
function isNull(arg) {
return arg === null;
}
exports.isNull = isNull;
function isNullOrUndefined(arg) {
return arg == null;
}
exports.isNullOrUndefined = isNullOrUndefined;
function isNumber(arg) {
return typeof arg === "number";
}
exports.isNumber = isNumber;
function isString(arg) {
return typeof arg === "string";
}
exports.isString = isString;
function isSymbol(arg) {
return typeof arg === "symbol";
}
exports.isSymbol = isSymbol;
function isUndefined(arg) {
return arg === void 0;
}
exports.isUndefined = isUndefined;
function isRegExp(re) {
return isObject(re) && objectToString(re) === "[object RegExp]";
}
exports.isRegExp = isRegExp;
exports.types.isRegExp = isRegExp;
function isObject(arg) {
return typeof arg === "object" && arg !== null;
}
exports.isObject = isObject;
function isDate(d) {
return isObject(d) && objectToString(d) === "[object Date]";
}
exports.isDate = isDate;
exports.types.isDate = isDate;
function isError(e) {
return isObject(e) && (objectToString(e) === "[object Error]" || e instanceof Error);
}
exports.isError = isError;
exports.types.isNativeError = isError;
function isFunction(arg) {
return typeof arg === "function";
}
exports.isFunction = isFunction;
function isPrimitive(arg) {
return arg === null || typeof arg === "boolean" || typeof arg === "number" || typeof arg === "string" || typeof arg === "symbol" || typeof arg === "undefined";
}
exports.isPrimitive = isPrimitive;
exports.isBuffer = require_isBufferBrowser();
function objectToString(o) {
return Object.prototype.toString.call(o);
}
function pad(n) {
return n < 10 ? "0" + n.toString(10) : n.toString(10);
}
var months = [
"Jan",
"Feb",
"Mar",
"Apr",
"May",
"Jun",
"Jul",
"Aug",
"Sep",
"Oct",
"Nov",
"Dec"
];
function timestamp() {
var d = /* @__PURE__ */ new Date();
var time = [
pad(d.getHours()),
pad(d.getMinutes()),
pad(d.getSeconds())
].join(":");
return [
d.getDate(),
months[d.getMonth()],
time
].join(" ");
}
exports.log = function() {
console.log("%s - %s", timestamp(), exports.format.apply(exports, arguments));
};
/**
* Inherit the prototype methods from one constructor into another.
*
* The Function.prototype.inherits from lang.js rewritten as a standalone
* function (not on Function.prototype). NOTE: If this file is to be loaded
* during bootstrapping this function needs to be rewritten using some native
* functions as prototype setup using normal JavaScript does not work as
* expected during bootstrapping (see mirror.js in r114903).
*
* @param {function} ctor Constructor function which needs to inherit the
* prototype.
* @param {function} superCtor Constructor function to inherit prototype from.
*/
exports.inherits = require_inherits_browser();
exports._extend = function(origin, add) {
if (!add || !isObject(add)) return origin;
var keys = Object.keys(add);
var i = keys.length;
while (i--) origin[keys[i]] = add[keys[i]];
return origin;
};
function hasOwnProperty(obj, prop) {
return Object.prototype.hasOwnProperty.call(obj, prop);
}
var kCustomPromisifiedSymbol = typeof Symbol !== "undefined" ? Symbol("util.promisify.custom") : void 0;
exports.promisify = function promisify(original) {
if (typeof original !== "function") throw new TypeError("The \"original\" argument must be of type Function");
if (kCustomPromisifiedSymbol && original[kCustomPromisifiedSymbol]) {
var fn = original[kCustomPromisifiedSymbol];
if (typeof fn !== "function") throw new TypeError("The \"util.promisify.custom\" argument must be of type Function");
Object.defineProperty(fn, kCustomPromisifiedSymbol, {
value: fn,
enumerable: false,
writable: false,
configurable: true
});
return fn;
}
function fn() {
var promiseResolve, promiseReject;
var promise = new Promise(function(resolve, reject) {
promiseResolve = resolve;
promiseReject = reject;
});
var args = [];
for (var 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));
};
exports.promisify.custom = kCustomPromisifiedSymbol;
function callbackifyOnRejected(reason, cb) {
if (!reason) {
var newReason = /* @__PURE__ */ 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 self = this;
var cb = function() {
return maybeCb.apply(self, 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;
}
exports.callbackify = callbackify;
}));
//#endregion
//#region node_modules/readable-stream/lib/internal/streams/buffer_list.js
var require_buffer_list = /* @__PURE__ */ __commonJSMin(((exports, module) => {
function ownKeys(object, enumerableOnly) {
var keys = Object.keys(object);
if (Object.getOwnPropertySymbols) {
var symbols = Object.getOwnPropertySymbols(object);
enumerableOnly && (symbols = symbols.filter(function(sym) {
return Object.getOwnPropertyDescriptor(object, sym).enumerable;
})), keys.push.apply(keys, symbols);
}
return keys;
}
function _objectSpread(target) {
for (var i = 1; i < arguments.length; i++) {
var source = null != arguments[i] ? arguments[i] : {};
i % 2 ? ownKeys(Object(source), !0).forEach(function(key) {
_defineProperty(target, key, source[key]);
}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function(key) {
Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
});
}
return target;
}
function _defineProperty(obj, key, value) {
key = _toPropertyKey(key);
if (key in obj) Object.defineProperty(obj, key, {
value,
enumerable: true,
configurable: true,
writable: true
});
else obj[key] = 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);
if (staticProps) _defineProperties(Constructor, staticProps);
Object.defineProperty(Constructor, "prototype", { writable: false });
return Constructor;
}
function _toPropertyKey(arg) {
var key = _toPrimitive(arg, "string");
return typeof key === "symbol" ? key : String(key);
}
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 Buffer = require_dist().Buffer;
var inspect = require_util$1().inspect;
var custom = inspect && inspect.custom || "inspect";
function copyBuffer(src, target, offset) {
Buffer.prototype.copy.call(src, target, offset);
}
module.exports = /*#__PURE__*/ function() {
function BufferList() {
_classCallCheck(this, BufferList);
this.head = null;
this.tail = null;
this.length = 0;
}
_createClass(BufferList, [
{
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 join(s) {
if (this.length === 0) return "";
var p = this.head;
var ret = "" + p.data;
while (p = p.next) ret += s + p.data;
return ret;
}
},
{
key: "concat",
value: function concat(n) {
if (this.length === 0) return Buffer.alloc(0);
var ret = Buffer.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;
}
},
{
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;
}
},
{
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;
}
},
{
key: "_getBuffer",
value: function _getBuffer(n) {
var ret = Buffer.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;
}
},
{
key: custom,
value: function value(_, options) {
return inspect(this, _objectSpread(_objectSpread({}, options), {}, {
depth: 0,
customInspect: false
}));
}
}
]);
return BufferList;
}();
}));
//#endregion
//#region node_modules/readable-stream/lib/internal/streams/destroy.js
var require_destroy$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
init_dist$2();
function destroy(err, cb) {
var _this = this;
var readableDestroyed = this._readableState && this._readableState.destroyed;
var writableDestroyed = this._writableState && this._writableState.destroyed;
if (readableDestroyed || writableDestroyed) {
if (cb) cb(err);
else if (err) {
if (!this._writableState) process$1.nextTick(emitErrorNT, this, err);
else if (!this._writableState.errorEmitted) {
this._writableState.errorEmitted = true;
process$1.nextTick(emitErrorNT, this, err);
}
}
return this;
}
if (this._readableState) this._readableState.destroyed = true;
if (this._writableState) this._writableState.destroyed = true;
this._destroy(err || null, function(err) {
if (!cb && err) if (!_this._writableState) process$1.nextTick(emitErrorAndCloseNT, _this, err);
else if (!_this._writableState.errorEmitted) {
_this._writableState.errorEmitted = true;
process$1.nextTick(emitErrorAndCloseNT, _this, err);
} else process$1.nextTick(emitCloseNT, _this);
else if (cb) {
process$1.nextTick(emitCloseNT, _this);
cb(err);
} else process$1.nextTick(emitCloseNT, _this);
});
return this;
}
function emitErrorAndCloseNT(self, err) {
emitErrorNT(self, err);
emitCloseNT(self);
}
function emitCloseNT(self) {
if (self._writableState && !self._writableState.emitClose) return;
if (self._readableState && !self._readableState.emitClose) return;
self.emit("close");
}
function undestroy() {
if (this._readableState) {
this._readableState.destroyed = false;
this._readableState.reading = false;
this._readableState.ended = false;
this._readableState.endEmitted = false;
}
if (this._writableState) {
this._writableState.destroyed = false;
this._writableState.ended = false;
this._writableState.ending = false;
this._writableState.finalCalled = false;
this._writableState.prefinished = false;
this._writableState.finished = false;
this._writableState.errorEmitted = false;
}
}
function emitErrorNT(self, err) {
self.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);
}
module.exports = {
destroy,
undestroy,
errorOrDestroy
};
}));
//#endregion
//#region node_modules/readable-stream/errors-browser.js
var require_errors_browser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
function _inheritsLoose(subClass, superClass) {
subClass.prototype = Object.create(superClass.prototype);
subClass.prototype.constructor = subClass;
subClass.__proto__ = superClass;
}
var codes = {};
function createErrorType(code, message, Base) {
if (!Base) Base = Error;
function getMessage(arg1, arg2, arg3) {
if (typeof message === "string") return message;
else return message(arg1, arg2, arg3);
}
var NodeError = /*#__PURE__*/ function(_Base) {
_inheritsLoose(NodeError, _Base);
function NodeError(arg1, arg2, arg3) {
return _Base.call(this, getMessage(arg1, arg2, arg3)) || this;
}
return NodeError;
}(Base);
NodeError.prototype.name = Base.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(!pos || pos < 0 ? 0 : +pos, search.length) === search;
}
function endsWith(str, search, this_len) {
if (this_len === void 0 || this_len > str.length) this_len = str.length;
return str.substring(this_len - search.length, this_len) === search;
}
function includes(str, search, start) {
if (typeof start !== "number") start = 0;
if (start + search.length > str.length) return false;
else return str.indexOf(search, start) !== -1;
}
createErrorType("ERR_INVALID_OPT_VALUE", function(name, value) {
return "The value \"" + value + "\" is invalid for option \"" + name + "\"";
}, TypeError);
createErrorType("ERR_INVALID_ARG_TYPE", function(name, expected, actual) {
var determiner;
if (typeof expected === "string" && startsWith(expected, "not ")) {
determiner = "must not be";
expected = expected.replace(/^not /, "");
} else determiner = "must be";
var msg;
if (endsWith(name, " argument")) msg = "The ".concat(name, " ").concat(determiner, " ").concat(oneOf(expected, "type"));
else {
var type = includes(name, ".") ? "property" : "argument";
msg = "The \"".concat(name, "\" ").concat(type, " ").concat(determiner, " ").concat(oneOf(expected, "type"));
}
msg += ". Received type ".concat(typeof actual);
return msg;
}, TypeError);
createErrorType("ERR_STREAM_PUSH_AFTER_EOF", "stream.push() after EOF");
createErrorType("ERR_METHOD_NOT_IMPLEMENTED", function(name) {
return "The " + name + " method is not implemented";
});
createErrorType("ERR_STREAM_PREMATURE_CLOSE", "Premature close");
createErrorType("ERR_STREAM_DESTROYED", function(name) {
return "Cannot call " + name + " after a stream was destroyed";
});
createErrorType("ERR_MULTIPLE_CALLBACK", "Callback called multiple times");
createErrorType("ERR_STREAM_CANNOT_PIPE", "Cannot pipe, not readable");
createErrorType("ERR_STREAM_WRITE_AFTER_END", "write after end");
createErrorType("ERR_STREAM_NULL_VALUES", "May not write null values to stream", TypeError);
createErrorType("ERR_UNKNOWN_ENCODING", function(arg) {
return "Unknown encoding: " + arg;
}, TypeError);
createErrorType("ERR_STREAM_UNSHIFT_AFTER_END_EVENT", "stream.unshift() after end event");
module.exports.codes = codes;
}));
//#endregion
//#region node_modules/readable-stream/lib/internal/streams/state.js
var require_state = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var ERR_INVALID_OPT_VALUE = require_errors_browser().codes.ERR_INVALID_OPT_VALUE;
function highWaterMarkFrom(options, isDuplex, duplexKey) {
return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;
}
function getHighWaterMark(state, options, duplexKey, isDuplex) {
var hwm = highWaterMarkFrom(options, isDuplex, duplexKey);
if (hwm != null) {
if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) throw new ERR_INVALID_OPT_VALUE(isDuplex ? duplexKey : "highWaterMark", hwm);
return Math.floor(hwm);
}
return state.objectMode ? 16 : 16 * 1024;
}
module.exports = { getHighWaterMark };
}));
//#endregion
//#region node_modules/util-deprecate/browser.js
var require_browser$12 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
init_dist();
/**
* Module exports.
*/
module.exports = deprecate;
/**
* Mark that a method should not be used.
* Returns a modified function which warns once by default.
*
* If `localStorage.noDeprecation = true` is set, then it is a no-op.
*
* If `localStorage.throwDeprecation = true` is set, then deprecated functions
* will throw an Error when invoked.
*
* If `localStorage.traceDeprecation = true` is set, then deprecated functions
* will invoke `console.trace()` instead of `console.error()`.
*
* @param {Function} fn - the function to deprecate
* @param {String} msg - the string to print to the console when `fn` is invoked
* @returns {Function} a new "deprecated" version of `fn`
* @api public
*/
function deprecate(fn, msg) {
if (config("noDeprecation")) return fn;
var warned = false;
function deprecated() {
if (!warned) {
if (config("throwDeprecation")) throw new Error(msg);
else if (config("traceDeprecation")) console.trace(msg);
else console.warn(msg);
warned = true;
}
return fn.apply(this, arguments);
}
return deprecated;
}
/**
* Checks `localStorage` for boolean values for the given `name`.
*
* @param {String} name
* @returns {Boolean}
* @api private
*/
function config(name) {
try {
if (!global.localStorage) return false;
} catch (_) {
return false;
}
var val = global.localStorage[name];
if (null == val) return false;
return String(val).toLowerCase() === "true";
}
}));
//#endregion
//#region node_modules/readable-stream/lib/_stream_writable.js
var require__stream_writable$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
init_dist();
init_dist$2();
module.exports = Writable;
function CorkedRequest(state) {
var _this = this;
this.next = null;
this.entry = null;
this.finish = function() {
onCorkedFinish(_this, state);
};
}
var Duplex;
Writable.WritableState = WritableState;
var internalUtil = { deprecate: require_browser$12() };
var Stream = require_stream_browser$1();
var Buffer = require_dist().Buffer;
var OurUint8Array = (typeof global !== "undefined" ? global : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : {}).Uint8Array || function() {};
function _uint8ArrayToBuffer(chunk) {
return Buffer.from(chunk);
}
function _isUint8Array(obj) {
return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
}
var destroyImpl = require_destroy$1();
var getHighWaterMark = require_state().getHighWaterMark;
var _require$codes = require_errors_browser().codes;
var ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE;
var ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED;
var ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK;
var ERR_STREAM_CANNOT_PIPE = _require$codes.ERR_STREAM_CANNOT_PIPE;
var ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED;
var ERR_STREAM_NULL_VALUES = _require$codes.ERR_STREAM_NULL_VALUES;
var ERR_STREAM_WRITE_AFTER_END = _require$codes.ERR_STREAM_WRITE_AFTER_END;
var ERR_UNKNOWN_ENCODING = _require$codes.ERR_UNKNOWN_ENCODING;
var errorOrDestroy = destroyImpl.errorOrDestroy;
require_inherits_browser()(Writable, Stream);
function nop() {}
function WritableState(options, stream, isDuplex) {
Duplex = Duplex || require__stream_duplex$1();
options = options || {};
if (typeof isDuplex !== "boolean") isDuplex = stream instanceof Duplex;
this.objectMode = !!options.objectMode;
if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode;
this.highWaterMark = getHighWaterMark(this, options, "writableHighWaterMark", isDuplex);
this.finalCalled = false;
this.needDrain = false;
this.ending = false;
this.ended = false;
this.finished = false;
this.destroyed = false;
var noDecode = options.decodeStrings === false;
this.decodeStrings = !noDecode;
this.defaultEncoding = options.defaultEncoding || "utf8";
this.length = 0;
this.writing = false;
this.corked = 0;
this.sync = true;
this.bufferProcessing = false;
this.onwrite = function(er) {
onwrite(stream, er);
};
this.writecb = null;
this.writelen = 0;
this.bufferedRequest = null;
this.lastBufferedRequest = null;
this.pendingcb = 0;
this.prefinished = false;
this.errorEmitted = false;
this.emitClose = options.emitClose !== false;
this.autoDestroy = !!options.autoDestroy;
this.bufferedRequestCount = 0;
this.corkedRequestsFree = new CorkedRequest(this);
}
WritableState.prototype.getBuffer = function getBuffer() {
var current = this.bufferedRequest;
var out = [];
while (current) {
out.push(current);
current = current.next;
}
return out;
};
(function() {
try {
Object.defineProperty(WritableState.prototype, "buffer", { get: internalUtil.deprecate(function writableStateBufferGetter() {
return this.getBuffer();
}, "_writableState.buffer is deprecated. Use _writableState.getBuffer instead.", "DEP0003") });
} catch (_) {}
})();
var realHasInstance;
if (typeof Symbol === "function" && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === "function") {
realHasInstance = Function.prototype[Symbol.hasInstance];
Object.defineProperty(Writable, Symbol.hasInstance, { value: function value(object) {
if (realHasInstance.call(this, object)) return true;
if (this !== Writable) return false;
return object && object._writableState instanceof WritableState;
} });
} else realHasInstance = function realHasInstance(object) {
return object instanceof this;
};
function Writable(options) {
Duplex = Duplex || require__stream_duplex$1();
var isDuplex = this instanceof Duplex;
if (!isDuplex && !realHasInstance.call(Writable, this)) return new Writable(options);
this._writableState = new WritableState(options, this, isDuplex);
this.writable = true;
if (options) {
if (typeof options.write === "function") this._write = options.write;
if (typeof options.writev === "function") this._writev = options.writev;
if (typeof options.destroy === "function") this._destroy = options.destroy;
if (typeof options.final === "function") this._final = options.final;
}
Stream.call(this);
}
Writable.prototype.pipe = function() {
errorOrDestroy(this, new ERR_STREAM_CANNOT_PIPE());
};
function writeAfterEnd(stream, cb) {
var er = new ERR_STREAM_WRITE_AFTER_END();
errorOrDestroy(stream, er);
process$1.nextTick(cb, er);
}
function validChunk(stream, state, chunk, cb) {
var er;
if (chunk === null) er = new ERR_STREAM_NULL_VALUES();
else if (typeof chunk !== "string" && !state.objectMode) er = new ERR_INVALID_ARG_TYPE("chunk", ["string", "Buffer"], chunk);
if (er) {
errorOrDestroy(stream, er);
process$1.nextTick(cb, er);
return false;
}
return true;
}
Writable.prototype.write = function(chunk, encoding, cb) {
var state = this._writableState;
var ret = false;
var isBuf = !state.objectMode && _isUint8Array(chunk);
if (isBuf && !Buffer.isBuffer(chunk)) chunk = _uint8ArrayToBuffer(chunk);
if (typeof encoding === "function") {
cb = encoding;
encoding = null;
}
if (isBuf) encoding = "buffer";
else if (!encoding) encoding = state.defaultEncoding;
if (typeof cb !== "function") cb = nop;
if (state.ending) writeAfterEnd(this, cb);
else if (isBuf || validChunk(this, state, chunk, cb)) {
state.pendingcb++;
ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);
}
return ret;
};
Writable.prototype.cork = function() {
this._writableState.corked++;
};
Writable.prototype.uncork = function() {
var state = this._writableState;
if (state.corked) {
state.corked--;
if (!state.writing && !state.corked && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);
}
};
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", {
enumerable: false,
get: function get() {
return this._writableState && this._writableState.getBuffer();
}
});
function decodeChunk(state, chunk, encoding) {
if (!state.objectMode && state.decodeStrings !== false && typeof chunk === "string") chunk = Buffer.from(chunk, encoding);
return chunk;
}
Object.defineProperty(Writable.prototype, "writableHighWaterMark", {
enumerable: false,
get: function get() {
return this._writableState.highWaterMark;
}
});
function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {
if (!isBuf) {
var newChunk = decodeChunk(state, chunk, encoding);
if (chunk !== newChunk) {
isBuf = true;
encoding = "buffer";
chunk = newChunk;
}
}
var len = state.objectMode ? 1 : chunk.length;
state.length += len;
var ret = state.length < state.highWaterMark;
if (!ret) state.needDrain = true;
if (state.writing || state.corked) {
var last = state.lastBufferedRequest;
state.lastBufferedRequest = {
chunk,
encoding,
isBuf,
callback: cb,
next: null
};
if (last) last.next = state.lastBufferedRequest;
else state.bufferedRequest = state.lastBufferedRequest;
state.bufferedRequestCount += 1;
} else doWrite(stream, state, false, len, chunk, encoding, cb);
return ret;
}
function doWrite(stream, state, writev, len, chunk, encoding, cb) {
state.writelen = len;
state.writecb = cb;
state.writing = true;
state.sync = true;
if (state.destroyed) state.onwrite(new ERR_STREAM_DESTROYED("write"));
else if (writev) stream._writev(chunk, state.onwrite);
else stream._write(chunk, encoding, state.onwrite);
state.sync = false;
}
function onwriteError(stream, state, sync, er, cb) {
--state.pendingcb;
if (sync) {
process$1.nextTick(cb, er);
process$1.nextTick(finishMaybe, stream, state);
stream._writableState.errorEmitted = true;
errorOrDestroy(stream, er);
} else {
cb(er);
stream._writableState.errorEmitted = true;
errorOrDestroy(stream, er);
finishMaybe(stream, state);
}
}
function onwriteStateUpdate(state) {
state.writing = false;
state.writecb = null;
state.length -= state.writelen;
state.writelen = 0;
}
function onwrite(stream, er) {
var state = stream._writableState;
var sync = state.sync;
var cb = state.writecb;
if (typeof cb !== "function") throw new ERR_MULTIPLE_CALLBACK();
onwriteStateUpdate(state);
if (er) onwriteError(stream, state, sync, er, cb);
else {
var finished = needFinish(state) || stream.destroyed;
if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) clearBuffer(stream, state);
if (sync) process$1.nextTick(afterWrite, stream, state, finished, cb);
else afterWrite(stream, state, finished, cb);
}
}
function afterWrite(stream, state, finished, cb) {
if (!finished) onwriteDrain(stream, state);
state.pendingcb--;
cb();
finishMaybe(stream, state);
}
function onwriteDrain(stream, state) {
if (state.length === 0 && state.needDrain) {
state.needDrain = false;
stream.emit("drain");
}
}
function clearBuffer(stream, state) {
state.bufferProcessing = true;
var entry = state.bufferedRequest;
if (stream._writev && entry && entry.next) {
var l = state.bufferedRequestCount;
var buffer = new Array(l);
var holder = state.corkedRequestsFree;
holder.entry = entry;
var count = 0;
var allBuffers = true;
while (entry) {
buffer[count] = entry;
if (!entry.isBuf) allBuffers = false;
entry = entry.next;
count += 1;
}
buffer.allBuffers = allBuffers;
doWrite(stream, state, true, state.length, buffer, "", holder.finish);
state.pendingcb++;
state.lastBufferedRequest = null;
if (holder.next) {
state.corkedRequestsFree = holder.next;
holder.next = null;
} else state.corkedRequestsFree = new CorkedRequest(state);
state.bufferedRequestCount = 0;
} else {
while (entry) {
var chunk = entry.chunk;
var encoding = entry.encoding;
var cb = entry.callback;
doWrite(stream, state, false, state.objectMode ? 1 : chunk.length, chunk, encoding, cb);
entry = entry.next;
state.bufferedRequestCount--;
if (state.writing) break;
}
if (entry === null) state.lastBufferedRequest = null;
}
state.bufferedRequest = entry;
state.bufferProcessing = false;
}
Writable.prototype._write = function(chunk, encoding, cb) {
cb(new ERR_METHOD_NOT_IMPLEMENTED("_write()"));
};
Writable.prototype._writev = null;
Writable.prototype.end = function(chunk, encoding, cb) {
var state = 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 (state.corked) {
state.corked = 1;
this.uncork();
}
if (!state.ending) endWritable(this, state, cb);
return this;
};
Object.defineProperty(Writable.prototype, "writableLength", {
enumerable: false,
get: function get() {
return this._writableState.length;
}
});
function needFinish(state) {
return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;
}
function callFinal(stream, state) {
stream._final(function(err) {
state.pendingcb--;
if (err) errorOrDestroy(stream, err);
state.prefinished = true;
stream.emit("prefinish");
finishMaybe(stream, state);
});
}
function prefinish(stream, state) {
if (!state.prefinished && !state.finalCalled) if (typeof stream._final === "function" && !state.destroyed) {
state.pendingcb++;
state.finalCalled = true;
process$1.nextTick(callFinal, stream, state);
} else {
state.prefinished = true;
stream.emit("prefinish");
}
}
function finishMaybe(stream, state) {
var need = needFinish(state);
if (need) {
prefinish(stream, state);
if (state.pendingcb === 0) {
state.finished = true;
stream.emit("finish");
if (state.autoDestroy) {
var rState = stream._readableState;
if (!rState || rState.autoDestroy && rState.endEmitted) stream.destroy();
}
}
}
return need;
}
function endWritable(stream, state, cb) {
state.ending = true;
finishMaybe(stream, state);
if (cb) if (state.finished) process$1.nextTick(cb);
else stream.once("finish", cb);
state.ended = true;
stream.writable = false;
}
function onCorkedFinish(corkReq, state, err) {
var entry = corkReq.entry;
corkReq.entry = null;
while (entry) {
var cb = entry.callback;
state.pendingcb--;
cb(err);
entry = entry.next;
}
state.corkedRequestsFree.next = corkReq;
}
Object.defineProperty(Writable.prototype, "destroyed", {
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);
};
}));
//#endregion
//#region node_modules/readable-stream/lib/_stream_duplex.js
var require__stream_duplex$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
init_dist$2();
var objectKeys = Object.keys || function(obj) {
var keys = [];
for (var key in obj) keys.push(key);
return keys;
};
module.exports = Duplex;
var Readable = require__stream_readable$1();
var Writable = require__stream_writable$1();
require_inherits_browser()(Duplex, Readable);
var keys = objectKeys(Writable.prototype);
for (var v = 0; v < keys.length; v++) {
var method = keys[v];
if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];
}
function Duplex(options) {
if (!(this instanceof Duplex)) return new Duplex(options);
Readable.call(this, options);
Writable.call(this, options);
this.allowHalfOpen = true;
if (options) {
if (options.readable === false) this.readable = false;
if (options.writable === false) this.writable = false;
if (options.allowHalfOpen === false) {
this.allowHalfOpen = false;
this.once("end", onend);
}
}
}
Object.defineProperty(Duplex.prototype, "writableHighWaterMark", {
enumerable: false,
get: function get() {
return this._writableState.highWaterMark;
}
});
Object.defineProperty(Duplex.prototype, "writableBuffer", {
enumerable: false,
get: function get() {
return this._writableState && this._writableState.getBuffer();
}
});
Object.defineProperty(Duplex.prototype, "writableLength", {
enumerable: false,
get: function get() {
return this._writableState.length;
}
});
function onend() {
if (this._writableState.ended) return;
process$1.nextTick(onEndNT, this);
}
function onEndNT(self) {
self.end();
}
Object.defineProperty(Duplex.prototype, "destroyed", {
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;
}
});
}));
//#endregion
//#region node_modules/string_decoder/node_modules/safe-buffer/index.js
var require_safe_buffer$10 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
var buffer = require_dist();
var Buffer = buffer.Buffer;
function copyProps(src, dst) {
for (var key in src) dst[key] = src[key];
}
if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) module.exports = buffer;
else {
copyProps(buffer, exports);
exports.Buffer = SafeBuffer;
}
function SafeBuffer(arg, encodingOrOffset, length) {
return Buffer(arg, encodingOrOffset, length);
}
SafeBuffer.prototype = Object.create(Buffer.prototype);
copyProps(Buffer, SafeBuffer);
SafeBuffer.from = function(arg, encodingOrOffset, length) {
if (typeof arg === "number") throw new TypeError("Argument must not be a number");
return Buffer(arg, encodingOrOffset, length);
};
SafeBuffer.alloc = function(size, fill, encoding) {
if (typeof size !== "number") throw new TypeError("Argument must be a number");
var buf = Buffer(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 Buffer(size);
};
SafeBuffer.allocUnsafeSlow = function(size) {
if (typeof size !== "number") throw new TypeError("Argument must be a number");
return buffer.SlowBuffer(size);
};
}));
//#endregion
//#region node_modules/string_decoder/lib/string_decoder.js
var require_string_decoder = /* @__PURE__ */ __commonJSMin(((exports) => {
var Buffer = require_safe_buffer$10().Buffer;
var isEncoding = Buffer.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.isEncoding === isEncoding || !isEncoding(enc))) throw new Error("Unknown encoding: " + enc);
return nenc || enc;
}
exports.StringDecoder = StringDecoder;
function StringDecoder(encoding) {
this.encoding = normalizeEncoding(encoding);
var nb;
switch (this.encoding) {
case "utf16le":
this.text = utf16Text;
this.end = utf16End;
nb = 4;
break;
case "utf8":
this.fillLast = utf8FillLast;
nb = 4;
break;
case "base64":
this.text = base64Text;
this.end = base64End;
nb = 3;
break;
default:
this.write = simpleWrite;
this.end = simpleEnd;
return;
}
this.lastNeed = 0;
this.lastTotal = 0;
this.lastChar = Buffer.allocUnsafe(nb);
}
StringDecoder.prototype.write = function(buf) {
if (buf.length === 0) return "";
var r;
var i;
if (this.lastNeed) {
r = this.fillLast(buf);
if (r === void 0) return "";
i = this.lastNeed;
this.lastNeed = 0;
} else i = 0;
if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);
return r || "";
};
StringDecoder.prototype.end = utf8End;
StringDecoder.prototype.text = utf8Text;
StringDecoder.prototype.fillLast = function(buf) {
if (this.lastNeed <= buf.length) {
buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);
return this.lastChar.toString(this.encoding, 0, this.lastTotal);
}
buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);
this.lastNeed -= buf.length;
};
function utf8CheckByte(byte) {
if (byte <= 127) return 0;
else if (byte >> 5 === 6) return 2;
else if (byte >> 4 === 14) return 3;
else if (byte >> 3 === 30) return 4;
return byte >> 6 === 2 ? -1 : -2;
}
function utf8CheckIncomplete(self, buf, i) {
var j = buf.length - 1;
if (j < i) return 0;
var nb = utf8CheckByte(buf[j]);
if (nb >= 0) {
if (nb > 0) self.lastNeed = nb - 1;
return nb;
}
if (--j < i || nb === -2) return 0;
nb = utf8CheckByte(buf[j]);
if (nb >= 0) {
if (nb > 0) self.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 self.lastNeed = nb - 3;
return nb;
}
return 0;
}
function utf8CheckExtraBytes(self, buf, p) {
if ((buf[0] & 192) !== 128) {
self.lastNeed = 0;
return "�";
}
if (self.lastNeed > 1 && buf.length > 1) {
if ((buf[1] & 192) !== 128) {
self.lastNeed = 1;
return "�";
}
if (self.lastNeed > 2 && buf.length > 2) {
if ((buf[2] & 192) !== 128) {
self.lastNeed = 2;
return "�";
}
}
}
}
function utf8FillLast(buf) {
var p = this.lastTotal - this.lastNeed;
var r = utf8CheckExtraBytes(this, buf, p);
if (r !== void 0) return r;
if (this.lastNeed <= buf.length) {
buf.copy(this.lastChar, p, 0, this.lastNeed);
return this.lastChar.toString(this.encoding, 0, this.lastTotal);
}
buf.copy(this.lastChar, p, 0, buf.length);
this.lastNeed -= buf.length;
}
function utf8Text(buf, 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 r = buf && buf.length ? this.write(buf) : "";
if (this.lastNeed) return r + "�";
return r;
}
function utf16Text(buf, i) {
if ((buf.length - i) % 2 === 0) {
var r = buf.toString("utf16le", i);
if (r) {
var c = r.charCodeAt(r.length - 1);
if (c >= 55296 && c <= 56319) {
this.lastNeed = 2;
this.lastTotal = 4;
this.lastChar[0] = buf[buf.length - 2];
this.lastChar[1] = buf[buf.length - 1];
return r.slice(0, -1);
}
}
return r;
}
this.lastNeed = 1;
this.lastTotal = 2;
this.lastChar[0] = buf[buf.length - 1];
return buf.toString("utf16le", i, buf.length - 1);
}
function utf16End(buf) {
var r = buf && buf.length ? this.write(buf) : "";
if (this.lastNeed) {
var end = this.lastTotal - this.lastNeed;
return r + this.lastChar.toString("utf16le", 0, end);
}
return r;
}
function base64Text(buf, 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 r = buf && buf.length ? this.write(buf) : "";
if (this.lastNeed) return r + this.lastChar.toString("base64", 0, 3 - this.lastNeed);
return r;
}
function simpleWrite(buf) {
return buf.toString(this.encoding);
}
function simpleEnd(buf) {
return buf && buf.length ? this.write(buf) : "";
}
}));
//#endregion
//#region node_modules/readable-stream/lib/internal/streams/end-of-stream.js
var require_end_of_stream = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var ERR_STREAM_PREMATURE_CLOSE = require_errors_browser().codes.ERR_STREAM_PREMATURE_CLOSE;
function once(callback) {
var called = false;
return function() {
if (called) return;
called = true;
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) args[_key] = arguments[_key];
callback.apply(this, args);
};
}
function noop() {}
function isRequest(stream) {
return stream.setHeader && typeof stream.abort === "function";
}
function eos(stream, opts, callback) {
if (typeof opts === "function") return eos(stream, null, opts);
if (!opts) opts = {};
callback = once(callback || noop);
var readable = opts.readable || opts.readable !== false && stream.readable;
var writable = opts.writable || opts.writable !== false && stream.writable;
var onlegacyfinish = function onlegacyfinish() {
if (!stream.writable) onfinish();
};
var writableEnded = stream._writableState && stream._writableState.finished;
var onfinish = function onfinish() {
writable = false;
writableEnded = true;
if (!readable) callback.call(stream);
};
var readableEnded = stream._readableState && stream._readableState.endEmitted;
var onend = function onend() {
readable = false;
readableEnded = true;
if (!writable) callback.call(stream);
};
var onerror = function onerror(err) {
callback.call(stream, err);
};
var onclose = function onclose() {
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 onrequest() {
stream.req.on("finish", onfinish);
};
if (isRequest(stream)) {
stream.on("complete", onfinish);
stream.on("abort", onclose);
if (stream.req) onrequest();
else stream.on("request", onrequest);
} else if (writable && !stream._writableState) {
stream.on("end", onlegacyfinish);
stream.on("close", onlegacyfinish);
}
stream.on("end", onend);
stream.on("finish", onfinish);
if (opts.error !== false) stream.on("error", onerror);
stream.on("close", onclose);
return function() {
stream.removeListener("complete", onfinish);
stream.removeListener("abort", onclose);
stream.removeListener("request", onrequest);
if (stream.req) stream.req.removeListener("finish", onfinish);
stream.removeListener("end", onlegacyfinish);
stream.removeListener("close", onlegacyfinish);
stream.removeListener("finish", onfinish);
stream.removeListener("end", onend);
stream.removeListener("error", onerror);
stream.removeListener("close", onclose);
};
}
module.exports = eos;
}));
//#endregion
//#region node_modules/readable-stream/lib/internal/streams/async_iterator.js
var require_async_iterator = /* @__PURE__ */ __commonJSMin(((exports, module) => {
init_dist$2();
var _Object$setPrototypeO;
function _defineProperty(obj, key, value) {
key = _toPropertyKey(key);
if (key in obj) Object.defineProperty(obj, key, {
value,
enumerable: true,
configurable: true,
writable: true
});
else obj[key] = value;
return obj;
}
function _toPropertyKey(arg) {
var key = _toPrimitive(arg, "string");
return typeof key === "symbol" ? key : String(key);
}
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 = require_end_of_stream();
var kLastResolve = Symbol("lastResolve");
var kLastReject = Symbol("lastReject");
var kError = Symbol("error");
var kEnded = Symbol("ended");
var kLastPromise = Symbol("lastPromise");
var kHandlePromise = Symbol("handlePromise");
var kStream = Symbol("stream");
function createIterResult(value, done) {
return {
value,
done
};
}
function readAndResolve(iter) {
var resolve = iter[kLastResolve];
if (resolve !== null) {
var data = iter[kStream].read();
if (data !== null) {
iter[kLastPromise] = null;
iter[kLastResolve] = null;
iter[kLastReject] = null;
resolve(createIterResult(data, false));
}
}
}
function onReadable(iter) {
process$1.nextTick(readAndResolve, iter);
}
function wrapForNext(lastPromise, iter) {
return function(resolve, reject) {
lastPromise.then(function() {
if (iter[kEnded]) {
resolve(createIterResult(void 0, true));
return;
}
iter[kHandlePromise](resolve, reject);
}, reject);
};
}
var AsyncIteratorPrototype = Object.getPrototypeOf(function() {});
var ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPrototypeO = {
get stream() {
return this[kStream];
},
next: function next() {
var _this = this;
var error = this[kError];
if (error !== null) return Promise.reject(error);
if (this[kEnded]) return Promise.resolve(createIterResult(void 0, true));
if (this[kStream].destroyed) return new Promise(function(resolve, reject) {
process$1.nextTick(function() {
if (_this[kError]) reject(_this[kError]);
else resolve(createIterResult(void 0, true));
});
});
var lastPromise = this[kLastPromise];
var promise;
if (lastPromise) promise = new Promise(wrapForNext(lastPromise, this));
else {
var data = this[kStream].read();
if (data !== null) return Promise.resolve(createIterResult(data, false));
promise = new Promise(this[kHandlePromise]);
}
this[kLastPromise] = promise;
return promise;
}
}, _defineProperty(_Object$setPrototypeO, Symbol.asyncIterator, function() {
return this;
}), _defineProperty(_Object$setPrototypeO, "return", function _return() {
var _this2 = this;
return new Promise(function(resolve, reject) {
_this2[kStream].destroy(null, function(err) {
if (err) {
reject(err);
return;
}
resolve(createIterResult(void 0, true));
});
});
}), _Object$setPrototypeO), AsyncIteratorPrototype);
module.exports = function createReadableStreamAsyncIterator(stream) {
var _Object$create;
var iterator = Object.create(ReadableStreamAsyncIteratorPrototype, (_Object$create = {}, _defineProperty(_Object$create, kStream, {
value: stream,
writable: true
}), _defineProperty(_Object$create, kLastResolve, {
value: null,
writable: true
}), _defineProperty(_Object$create, kLastReject, {
value: null,
writable: true
}), _defineProperty(_Object$create, kError, {
value: null,
writable: true
}), _defineProperty(_Object$create, kEnded, {
value: stream._readableState.endEmitted,
writable: true
}), _defineProperty(_Object$create, kHandlePromise, {
value: function value(resolve, reject) {
var data = iterator[kStream].read();
if (data) {
iterator[kLastPromise] = null;
iterator[kLastResolve] = null;
iterator[kLastReject] = null;
resolve(createIterResult(data, false));
} else {
iterator[kLastResolve] = resolve;
iterator[kLastReject] = reject;
}
},
writable: true
}), _Object$create));
iterator[kLastPromise] = null;
finished(stream, function(err) {
if (err && err.code !== "ERR_STREAM_PREMATURE_CLOSE") {
var reject = iterator[kLastReject];
if (reject !== null) {
iterator[kLastPromise] = null;
iterator[kLastResolve] = null;
iterator[kLastReject] = null;
reject(err);
}
iterator[kError] = err;
return;
}
var resolve = iterator[kLastResolve];
if (resolve !== null) {
iterator[kLastPromise] = null;
iterator[kLastResolve] = null;
iterator[kLastReject] = null;
resolve(createIterResult(void 0, true));
}
iterator[kEnded] = true;
});
stream.on("readable", onReadable.bind(null, iterator));
return iterator;
};
}));
//#endregion
//#region node_modules/readable-stream/lib/internal/streams/from-browser.js
var require_from_browser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = function() {
throw new Error("Readable.from is not available in the browser");
};
}));
//#endregion
//#region node_modules/readable-stream/lib/_stream_readable.js
var require__stream_readable$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
init_dist();
init_dist$2();
module.exports = Readable;
var Duplex;
Readable.ReadableState = ReadableState;
require_events().EventEmitter;
var EElistenerCount = function EElistenerCount(emitter, type) {
return emitter.listeners(type).length;
};
var Stream = require_stream_browser$1();
var Buffer = require_dist().Buffer;
var OurUint8Array = (typeof global !== "undefined" ? global : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : {}).Uint8Array || function() {};
function _uint8ArrayToBuffer(chunk) {
return Buffer.from(chunk);
}
function _isUint8Array(obj) {
return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
}
var debugUtil = require_util$1();
var debug;
if (debugUtil && debugUtil.debuglog) debug = debugUtil.debuglog("stream");
else debug = function debug() {};
var BufferList = require_buffer_list();
var destroyImpl = require_destroy$1();
var getHighWaterMark = require_state().getHighWaterMark;
var _require$codes = require_errors_browser().codes;
var ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE;
var ERR_STREAM_PUSH_AFTER_EOF = _require$codes.ERR_STREAM_PUSH_AFTER_EOF;
var ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED;
var ERR_STREAM_UNSHIFT_AFTER_END_EVENT = _require$codes.ERR_STREAM_UNSHIFT_AFTER_END_EVENT;
var StringDecoder;
var createReadableStreamAsyncIterator;
var from;
require_inherits_browser()(Readable, Stream);
var errorOrDestroy = destroyImpl.errorOrDestroy;
var kProxyEvents = [
"error",
"close",
"destroy",
"pause",
"resume"
];
function prependListener(emitter, event, fn) {
if (typeof emitter.prependListener === "function") return emitter.prependListener(event, fn);
if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);
else if (Array.isArray(emitter._events[event])) emitter._events[event].unshift(fn);
else emitter._events[event] = [fn, emitter._events[event]];
}
function ReadableState(options, stream, isDuplex) {
Duplex = Duplex || require__stream_duplex$1();
options = options || {};
if (typeof isDuplex !== "boolean") isDuplex = stream instanceof Duplex;
this.objectMode = !!options.objectMode;
if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode;
this.highWaterMark = getHighWaterMark(this, options, "readableHighWaterMark", isDuplex);
this.buffer = new BufferList();
this.length = 0;
this.pipes = null;
this.pipesCount = 0;
this.flowing = null;
this.ended = false;
this.endEmitted = false;
this.reading = false;
this.sync = true;
this.needReadable = false;
this.emittedReadable = false;
this.readableListening = false;
this.resumeScheduled = false;
this.paused = true;
this.emitClose = options.emitClose !== false;
this.autoDestroy = !!options.autoDestroy;
this.destroyed = false;
this.defaultEncoding = options.defaultEncoding || "utf8";
this.awaitDrain = 0;
this.readingMore = false;
this.decoder = null;
this.encoding = null;
if (options.encoding) {
if (!StringDecoder) StringDecoder = require_string_decoder().StringDecoder;
this.decoder = new StringDecoder(options.encoding);
this.encoding = options.encoding;
}
}
function Readable(options) {
Duplex = Duplex || require__stream_duplex$1();
if (!(this instanceof Readable)) return new Readable(options);
var isDuplex = this instanceof Duplex;
this._readableState = new ReadableState(options, this, isDuplex);
this.readable = true;
if (options) {
if (typeof options.read === "function") this._read = options.read;
if (typeof options.destroy === "function") this._destroy = options.destroy;
}
Stream.call(this);
}
Object.defineProperty(Readable.prototype, "destroyed", {
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 state = this._readableState;
var skipChunkCheck;
if (!state.objectMode) {
if (typeof chunk === "string") {
encoding = encoding || state.defaultEncoding;
if (encoding !== state.encoding) {
chunk = Buffer.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 state = stream._readableState;
if (chunk === null) {
state.reading = false;
onEofChunk(stream, state);
} else {
var er;
if (!skipChunkCheck) er = chunkInvalid(state, chunk);
if (er) errorOrDestroy(stream, er);
else if (state.objectMode || chunk && chunk.length > 0) {
if (typeof chunk !== "string" && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) chunk = _uint8ArrayToBuffer(chunk);
if (addToFront) if (state.endEmitted) errorOrDestroy(stream, new ERR_STREAM_UNSHIFT_AFTER_END_EVENT());
else addChunk(stream, state, chunk, true);
else if (state.ended) errorOrDestroy(stream, new ERR_STREAM_PUSH_AFTER_EOF());
else if (state.destroyed) return false;
else {
state.reading = false;
if (state.decoder && !encoding) {
chunk = state.decoder.write(chunk);
if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);
else maybeReadMore(stream, state);
} else addChunk(stream, state, chunk, false);
}
} else if (!addToFront) {
state.reading = false;
maybeReadMore(stream, state);
}
}
return !state.ended && (state.length < state.highWaterMark || state.length === 0);
}
function addChunk(stream, state, chunk, addToFront) {
if (state.flowing && state.length === 0 && !state.sync) {
state.awaitDrain = 0;
stream.emit("data", chunk);
} else {
state.length += state.objectMode ? 1 : chunk.length;
if (addToFront) state.buffer.unshift(chunk);
else state.buffer.push(chunk);
if (state.needReadable) emitReadable(stream);
}
maybeReadMore(stream, state);
}
function chunkInvalid(state, chunk) {
var er;
if (!_isUint8Array(chunk) && typeof chunk !== "string" && chunk !== void 0 && !state.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 (!StringDecoder) StringDecoder = require_string_decoder().StringDecoder;
var decoder = new StringDecoder(enc);
this._readableState.decoder = decoder;
this._readableState.encoding = this._readableState.decoder.encoding;
var p = this._readableState.buffer.head;
var content = "";
while (p !== null) {
content += decoder.write(p.data);
p = p.next;
}
this._readableState.buffer.clear();
if (content !== "") this._readableState.buffer.push(content);
this._readableState.length = content.length;
return this;
};
var MAX_HWM = 1073741824;
function computeNewHighWaterMark(n) {
if (n >= MAX_HWM) n = MAX_HWM;
else {
n--;
n |= n >>> 1;
n |= n >>> 2;
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
n++;
}
return n;
}
function howMuchToRead(n, state) {
if (n <= 0 || state.length === 0 && state.ended) return 0;
if (state.objectMode) return 1;
if (n !== n) if (state.flowing && state.length) return state.buffer.head.data.length;
else return state.length;
if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);
if (n <= state.length) return n;
if (!state.ended) {
state.needReadable = true;
return 0;
}
return state.length;
}
Readable.prototype.read = function(n) {
debug("read", n);
n = parseInt(n, 10);
var state = this._readableState;
var nOrig = n;
if (n !== 0) state.emittedReadable = false;
if (n === 0 && state.needReadable && ((state.highWaterMark !== 0 ? state.length >= state.highWaterMark : state.length > 0) || state.ended)) {
debug("read: emitReadable", state.length, state.ended);
if (state.length === 0 && state.ended) endReadable(this);
else emitReadable(this);
return null;
}
n = howMuchToRead(n, state);
if (n === 0 && state.ended) {
if (state.length === 0) endReadable(this);
return null;
}
var doRead = state.needReadable;
debug("need readable", doRead);
if (state.length === 0 || state.length - n < state.highWaterMark) {
doRead = true;
debug("length less than watermark", doRead);
}
if (state.ended || state.reading) {
doRead = false;
debug("reading or ended", doRead);
} else if (doRead) {
debug("do read");
state.reading = true;
state.sync = true;
if (state.length === 0) state.needReadable = true;
this._read(state.highWaterMark);
state.sync = false;
if (!state.reading) n = howMuchToRead(nOrig, state);
}
var ret;
if (n > 0) ret = fromList(n, state);
else ret = null;
if (ret === null) {
state.needReadable = state.length <= state.highWaterMark;
n = 0;
} else {
state.length -= n;
state.awaitDrain = 0;
}
if (state.length === 0) {
if (!state.ended) state.needReadable = true;
if (nOrig !== n && state.ended) endReadable(this);
}
if (ret !== null) this.emit("data", ret);
return ret;
};
function onEofChunk(stream, state) {
debug("onEofChunk");
if (state.ended) return;
if (state.decoder) {
var chunk = state.decoder.end();
if (chunk && chunk.length) {
state.buffer.push(chunk);
state.length += state.objectMode ? 1 : chunk.length;
}
}
state.ended = true;
if (state.sync) emitReadable(stream);
else {
state.needReadable = false;
if (!state.emittedReadable) {
state.emittedReadable = true;
emitReadable_(stream);
}
}
}
function emitReadable(stream) {
var state = stream._readableState;
debug("emitReadable", state.needReadable, state.emittedReadable);
state.needReadable = false;
if (!state.emittedReadable) {
debug("emitReadable", state.flowing);
state.emittedReadable = true;
process$1.nextTick(emitReadable_, stream);
}
}
function emitReadable_(stream) {
var state = stream._readableState;
debug("emitReadable_", state.destroyed, state.length, state.ended);
if (!state.destroyed && (state.length || state.ended)) {
stream.emit("readable");
state.emittedReadable = false;
}
state.needReadable = !state.flowing && !state.ended && state.length <= state.highWaterMark;
flow(stream);
}
function maybeReadMore(stream, state) {
if (!state.readingMore) {
state.readingMore = true;
process$1.nextTick(maybeReadMore_, stream, state);
}
}
function maybeReadMore_(stream, state) {
while (!state.reading && !state.ended && (state.length < state.highWaterMark || state.flowing && state.length === 0)) {
var len = state.length;
debug("maybeReadMore read 0");
stream.read(0);
if (len === state.length) break;
}
state.readingMore = false;
}
Readable.prototype._read = function(n) {
errorOrDestroy(this, new ERR_METHOD_NOT_IMPLEMENTED("_read()"));
};
Readable.prototype.pipe = function(dest, pipeOpts) {
var src = this;
var state = this._readableState;
switch (state.pipesCount) {
case 0:
state.pipes = dest;
break;
case 1:
state.pipes = [state.pipes, dest];
break;
default:
state.pipes.push(dest);
break;
}
state.pipesCount += 1;
debug("pipe count=%d opts=%j", state.pipesCount, pipeOpts);
var endFn = (!pipeOpts || pipeOpts.end !== false) && dest !== process$1.stdout && dest !== process$1.stderr ? onend : unpipe;
if (state.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 (state.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 ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {
debug("false write response, pause", state.awaitDrain);
state.awaitDrain++;
}
src.pause();
}
}
function onerror(er) {
debug("onerror", er);
unpipe();
dest.removeListener("error", onerror);
if (EElistenerCount(dest, "error") === 0) errorOrDestroy(dest, er);
}
prependListener(dest, "error", onerror);
function onclose() {
dest.removeListener("finish", onfinish);
unpipe();
}
dest.once("close", onclose);
function onfinish() {
debug("onfinish");
dest.removeListener("close", onclose);
unpipe();
}
dest.once("finish", onfinish);
function unpipe() {
debug("unpipe");
src.unpipe(dest);
}
dest.emit("pipe", src);
if (!state.flowing) {
debug("pipe resume");
src.resume();
}
return dest;
};
function pipeOnDrain(src) {
return function pipeOnDrainFunctionResult() {
var state = src._readableState;
debug("pipeOnDrain", state.awaitDrain);
if (state.awaitDrain) state.awaitDrain--;
if (state.awaitDrain === 0 && EElistenerCount(src, "data")) {
state.flowing = true;
flow(src);
}
};
}
Readable.prototype.unpipe = function(dest) {
var state = this._readableState;
var unpipeInfo = { hasUnpiped: false };
if (state.pipesCount === 0) return this;
if (state.pipesCount === 1) {
if (dest && dest !== state.pipes) return this;
if (!dest) dest = state.pipes;
state.pipes = null;
state.pipesCount = 0;
state.flowing = false;
if (dest) dest.emit("unpipe", this, unpipeInfo);
return this;
}
if (!dest) {
var dests = state.pipes;
var len = state.pipesCount;
state.pipes = null;
state.pipesCount = 0;
state.flowing = false;
for (var i = 0; i < len; i++) dests[i].emit("unpipe", this, { hasUnpiped: false });
return this;
}
var index = indexOf(state.pipes, dest);
if (index === -1) return this;
state.pipes.splice(index, 1);
state.pipesCount -= 1;
if (state.pipesCount === 1) state.pipes = state.pipes[0];
dest.emit("unpipe", this, unpipeInfo);
return this;
};
Readable.prototype.on = function(ev, fn) {
var res = Stream.prototype.on.call(this, ev, fn);
var state = this._readableState;
if (ev === "data") {
state.readableListening = this.listenerCount("readable") > 0;
if (state.flowing !== false) this.resume();
} else if (ev === "readable") {
if (!state.endEmitted && !state.readableListening) {
state.readableListening = state.needReadable = true;
state.flowing = false;
state.emittedReadable = false;
debug("on readable", state.length, state.reading);
if (state.length) emitReadable(this);
else if (!state.reading) process$1.nextTick(nReadingNextTick, this);
}
}
return res;
};
Readable.prototype.addListener = Readable.prototype.on;
Readable.prototype.removeListener = function(ev, fn) {
var res = Stream.prototype.removeListener.call(this, ev, fn);
if (ev === "readable") process$1.nextTick(updateReadableListening, this);
return res;
};
Readable.prototype.removeAllListeners = function(ev) {
var res = Stream.prototype.removeAllListeners.apply(this, arguments);
if (ev === "readable" || ev === void 0) process$1.nextTick(updateReadableListening, this);
return res;
};
function updateReadableListening(self) {
var state = self._readableState;
state.readableListening = self.listenerCount("readable") > 0;
if (state.resumeScheduled && !state.paused) state.flowing = true;
else if (self.listenerCount("data") > 0) self.resume();
}
function nReadingNextTick(self) {
debug("readable nexttick read 0");
self.read(0);
}
Readable.prototype.resume = function() {
var state = this._readableState;
if (!state.flowing) {
debug("resume");
state.flowing = !state.readableListening;
resume(this, state);
}
state.paused = false;
return this;
};
function resume(stream, state) {
if (!state.resumeScheduled) {
state.resumeScheduled = true;
process$1.nextTick(resume_, stream, state);
}
}
function resume_(stream, state) {
debug("resume", state.reading);
if (!state.reading) stream.read(0);
state.resumeScheduled = false;
stream.emit("resume");
flow(stream);
if (state.flowing && !state.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 state = stream._readableState;
debug("flow", state.flowing);
while (state.flowing && stream.read() !== null);
}
Readable.prototype.wrap = function(stream) {
var _this = this;
var state = this._readableState;
var paused = false;
stream.on("end", function() {
debug("wrapped end");
if (state.decoder && !state.ended) {
var chunk = state.decoder.end();
if (chunk && chunk.length) _this.push(chunk);
}
_this.push(null);
});
stream.on("data", function(chunk) {
debug("wrapped data");
if (state.decoder) chunk = state.decoder.write(chunk);
if (state.objectMode && (chunk === null || chunk === void 0)) return;
else if (!state.objectMode && (!chunk || !chunk.length)) return;
if (!_this.push(chunk)) {
paused = true;
stream.pause();
}
});
for (var i in stream) if (this[i] === void 0 && typeof stream[i] === "function") this[i] = 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(n) {
debug("wrapped _read", n);
if (paused) {
paused = false;
stream.resume();
}
};
return this;
};
if (typeof Symbol === "function") Readable.prototype[Symbol.asyncIterator] = function() {
if (createReadableStreamAsyncIterator === void 0) createReadableStreamAsyncIterator = require_async_iterator();
return createReadableStreamAsyncIterator(this);
};
Object.defineProperty(Readable.prototype, "readableHighWaterMark", {
enumerable: false,
get: function get() {
return this._readableState.highWaterMark;
}
});
Object.defineProperty(Readable.prototype, "readableBuffer", {
enumerable: false,
get: function get() {
return this._readableState && this._readableState.buffer;
}
});
Object.defineProperty(Readable.prototype, "readableFlowing", {
enumerable: false,
get: function get() {
return this._readableState.flowing;
},
set: function set(state) {
if (this._readableState) this._readableState.flowing = state;
}
});
Readable._fromList = fromList;
Object.defineProperty(Readable.prototype, "readableLength", {
enumerable: false,
get: function get() {
return this._readableState.length;
}
});
function fromList(n, state) {
if (state.length === 0) return null;
var ret;
if (state.objectMode) ret = state.buffer.shift();
else if (!n || n >= state.length) {
if (state.decoder) ret = state.buffer.join("");
else if (state.buffer.length === 1) ret = state.buffer.first();
else ret = state.buffer.concat(state.length);
state.buffer.clear();
} else ret = state.buffer.consume(n, state.decoder);
return ret;
}
function endReadable(stream) {
var state = stream._readableState;
debug("endReadable", state.endEmitted);
if (!state.endEmitted) {
state.ended = true;
process$1.nextTick(endReadableNT, state, stream);
}
}
function endReadableNT(state, stream) {
debug("endReadableNT", state.endEmitted, state.length);
if (!state.endEmitted && state.length === 0) {
state.endEmitted = true;
stream.readable = false;
stream.emit("end");
if (state.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 = require_from_browser();
return from(Readable, iterable, opts);
};
function indexOf(xs, x) {
for (var i = 0, l = xs.length; i < l; i++) if (xs[i] === x) return i;
return -1;
}
}));
//#endregion
//#region node_modules/readable-stream/lib/_stream_transform.js
var require__stream_transform$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = Transform;
var _require$codes = require_errors_browser().codes;
var ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED;
var ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK;
var ERR_TRANSFORM_ALREADY_TRANSFORMING = _require$codes.ERR_TRANSFORM_ALREADY_TRANSFORMING;
var ERR_TRANSFORM_WITH_LENGTH_0 = _require$codes.ERR_TRANSFORM_WITH_LENGTH_0;
var Duplex = require__stream_duplex$1();
require_inherits_browser()(Transform, Duplex);
function afterTransform(er, data) {
var ts = this._transformState;
ts.transforming = false;
var cb = ts.writecb;
if (cb === null) return this.emit("error", new ERR_MULTIPLE_CALLBACK());
ts.writechunk = null;
ts.writecb = null;
if (data != null) this.push(data);
cb(er);
var rs = this._readableState;
rs.reading = false;
if (rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);
}
function Transform(options) {
if (!(this instanceof Transform)) return new Transform(options);
Duplex.call(this, options);
this._transformState = {
afterTransform: afterTransform.bind(this),
needTransform: false,
transforming: false,
writecb: null,
writechunk: null,
writeencoding: null
};
this._readableState.needReadable = true;
this._readableState.sync = false;
if (options) {
if (typeof options.transform === "function") this._transform = options.transform;
if (typeof options.flush === "function") this._flush = options.flush;
}
this.on("prefinish", prefinish);
}
function prefinish() {
var _this = this;
if (typeof this._flush === "function" && !this._readableState.destroyed) this._flush(function(er, data) {
done(_this, er, data);
});
else done(this, null, null);
}
Transform.prototype.push = function(chunk, encoding) {
this._transformState.needTransform = false;
return Duplex.prototype.push.call(this, chunk, encoding);
};
Transform.prototype._transform = function(chunk, encoding, cb) {
cb(new ERR_METHOD_NOT_IMPLEMENTED("_transform()"));
};
Transform.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.prototype._read = function(n) {
var ts = this._transformState;
if (ts.writechunk !== null && !ts.transforming) {
ts.transforming = true;
this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
} else ts.needTransform = true;
};
Transform.prototype._destroy = function(err, cb) {
Duplex.prototype._destroy.call(this, err, function(err2) {
cb(err2);
});
};
function done(stream, er, data) {
if (er) return stream.emit("error", er);
if (data != null) stream.push(data);
if (stream._writableState.length) throw new ERR_TRANSFORM_WITH_LENGTH_0();
if (stream._transformState.transforming) throw new ERR_TRANSFORM_ALREADY_TRANSFORMING();
return stream.push(null);
}
}));
//#endregion
//#region node_modules/readable-stream/lib/_stream_passthrough.js
var require__stream_passthrough$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = PassThrough;
var Transform = require__stream_transform$1();
require_inherits_browser()(PassThrough, Transform);
function PassThrough(options) {
if (!(this instanceof PassThrough)) return new PassThrough(options);
Transform.call(this, options);
}
PassThrough.prototype._transform = function(chunk, encoding, cb) {
cb(null, chunk);
};
}));
//#endregion
//#region node_modules/readable-stream/lib/internal/streams/pipeline.js
var require_pipeline = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var eos;
function once(callback) {
var called = false;
return function() {
if (called) return;
called = true;
callback.apply(void 0, arguments);
};
}
var _require$codes = require_errors_browser().codes;
var ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS;
var 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 = require_end_of_stream();
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 error;
var destroys = streams.map(function(stream, i) {
var reading = i < streams.length - 1;
return destroyer(stream, reading, i > 0, function(err) {
if (!error) error = err;
if (err) destroys.forEach(call);
if (reading) return;
destroys.forEach(call);
callback(error);
});
});
return streams.reduce(pipe);
}
module.exports = pipeline;
}));
//#endregion
//#region node_modules/stream-browserify/index.js
var require_stream_browserify = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = Stream;
var EE = require_events().EventEmitter;
require_inherits_browser()(Stream, EE);
Stream.Readable = require__stream_readable$1();
Stream.Writable = require__stream_writable$1();
Stream.Duplex = require__stream_duplex$1();
Stream.Transform = require__stream_transform$1();
Stream.PassThrough = require__stream_passthrough$1();
Stream.finished = require_end_of_stream();
Stream.pipeline = require_pipeline();
Stream.Stream = Stream;
function Stream() {
EE.call(this);
}
Stream.prototype.pipe = function(dest, options) {
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 && (!options || options.end !== false)) {
source.on("end", onend);
source.on("close", onclose);
}
var didOnEnd = false;
function onend() {
if (didOnEnd) return;
didOnEnd = true;
dest.end();
}
function onclose() {
if (didOnEnd) return;
didOnEnd = true;
if (typeof dest.destroy === "function") dest.destroy();
}
function onerror(er) {
cleanup();
if (EE.listenerCount(this, "error") === 0) throw er;
}
source.on("error", onerror);
dest.on("error", onerror);
function cleanup() {
source.removeListener("data", ondata);
dest.removeListener("drain", ondrain);
source.removeListener("end", onend);
source.removeListener("close", onclose);
source.removeListener("error", onerror);
dest.removeListener("error", onerror);
source.removeListener("end", cleanup);
source.removeListener("close", cleanup);
dest.removeListener("close", cleanup);
}
source.on("end", cleanup);
source.on("close", cleanup);
dest.on("close", cleanup);
dest.emit("pipe", source);
return dest;
};
}));
//#endregion
//#region src/ParseError.ts
init_dist$1();
var import_stream_browserify = /* @__PURE__ */ __toESM(require_stream_browserify());
/**
* Constructs a new Parse.Error object with the given code and message.
*
* Parse.CoreManager.set('PARSE_ERRORS', [{ code, message }]) can be use to override error messages.
*
* @alias Parse.Error
*/
var ParseError = class extends Error {
/**
* @param {number} code An error code constant from <code>Parse.Error</code>.
* @param {string} message A detailed description of the error.
*/
constructor(code, message) {
super(message);
this.code = code;
let customMessage = message;
CoreManager.get("PARSE_ERRORS").forEach((error) => {
if (error.code === code && error.code) customMessage = error.message;
});
Object.defineProperty(this, "message", {
enumerable: true,
value: customMessage
});
}
toString() {
return "ParseError: " + this.code + " " + this.message;
}
static {
this.OTHER_CAUSE = -1;
}
static {
this.INTERNAL_SERVER_ERROR = 1;
}
static {
this.CONNECTION_FAILED = 100;
}
static {
this.OBJECT_NOT_FOUND = 101;
}
static {
this.INVALID_QUERY = 102;
}
static {
this.INVALID_CLASS_NAME = 103;
}
static {
this.MISSING_OBJECT_ID = 104;
}
static {
this.INVALID_KEY_NAME = 105;
}
static {
this.INVALID_POINTER = 106;
}
static {
this.INVALID_JSON = 107;
}
static {
this.COMMAND_UNAVAILABLE = 108;
}
static {
this.NOT_INITIALIZED = 109;
}
static {
this.INCORRECT_TYPE = 111;
}
static {
this.INVALID_CHANNEL_NAME = 112;
}
static {
this.PUSH_MISCONFIGURED = 115;
}
static {
this.OBJECT_TOO_LARGE = 116;
}
static {
this.OPERATION_FORBIDDEN = 119;
}
static {
this.CACHE_MISS = 120;
}
static {
this.INVALID_NESTED_KEY = 121;
}
static {
this.INVALID_FILE_NAME = 122;
}
static {
this.INVALID_ACL = 123;
}
static {
this.TIMEOUT = 124;
}
static {
this.INVALID_EMAIL_ADDRESS = 125;
}
static {
this.MISSING_CONTENT_TYPE = 126;
}
static {
this.MISSING_CONTENT_LENGTH = 127;
}
static {
this.INVALID_CONTENT_LENGTH = 128;
}
static {
this.FILE_TOO_LARGE = 129;
}
static {
this.FILE_SAVE_ERROR = 130;
}
static {
this.DUPLICATE_VALUE = 137;
}
static {
this.INVALID_ROLE_NAME = 139;
}
static {
this.EXCEEDED_QUOTA = 140;
}
static {
this.SCRIPT_FAILED = 141;
}
static {
this.VALIDATION_ERROR = 142;
}
static {
this.INVALID_IMAGE_DATA = 143;
}
static {
this.UNSAVED_FILE_ERROR = 151;
}
static {
this.INVALID_PUSH_TIME_ERROR = 152;
}
static {
this.FILE_DELETE_ERROR = 153;
}
static {
this.FILE_DELETE_UNNAMED_ERROR = 161;
}
static {
this.REQUEST_LIMIT_EXCEEDED = 155;
}
static {
this.DUPLICATE_REQUEST = 159;
}
static {
this.INVALID_EVENT_NAME = 160;
}
static {
this.INVALID_VALUE = 162;
}
static {
this.USERNAME_MISSING = 200;
}
static {
this.PASSWORD_MISSING = 201;
}
static {
this.USERNAME_TAKEN = 202;
}
static {
this.EMAIL_TAKEN = 203;
}
static {
this.EMAIL_MISSING = 204;
}
static {
this.EMAIL_NOT_FOUND = 205;
}
static {
this.SESSION_MISSING = 206;
}
static {
this.MUST_CREATE_USER_THROUGH_SIGNUP = 207;
}
static {
this.ACCOUNT_ALREADY_LINKED = 208;
}
static {
this.INVALID_SESSION_TOKEN = 209;
}
static {
this.MFA_ERROR = 210;
}
static {
this.MFA_TOKEN_REQUIRED = 211;
}
static {
this.LINKED_ID_MISSING = 250;
}
static {
this.INVALID_LINKED_SESSION = 251;
}
static {
this.UNSUPPORTED_SERVICE = 252;
}
static {
this.INVALID_SCHEMA_OPERATION = 255;
}
static {
this.AGGREGATE_ERROR = 600;
}
static {
this.FILE_READ_ERROR = 601;
}
static {
this.X_DOMAIN_REQUEST = 602;
}
};
//#endregion
//#region src/ParseFile.ts
var NodeReadable;
function b64Digit(number) {
if (number < 26) return String.fromCharCode(65 + number);
if (number < 52) return String.fromCharCode(97 + (number - 26));
if (number < 62) return String.fromCharCode(48 + (number - 52));
if (number === 62) return "+";
if (number === 63) return "/";
throw new TypeError("Tried to encode large digit " + number + " in base64.");
}
/**
* A Parse.File is a local representation of a file that is saved to the Parse
* cloud.
*
* @alias Parse.File
*/
var ParseFile = class ParseFile {
/**
* @param name {String} The file's name. This will be prefixed by a unique
* value once the file has finished saving. The file name must begin with
* an alphanumeric character, and consist of alphanumeric characters,
* periods, spaces, underscores, or dashes.
* @param data {Array} The data for the file, as either:
* 1. an Array of byte value Numbers or Uint8Array.
* 2. an Object like { base64: "..." } with a base64-encoded String.
* 3. an Object like { uri: "..." } with a uri String.
* 4. a File object selected with a file upload control.
* 5. (Node.js only) a Buffer. Uploaded as raw binary data instead of
* base64-encoding, reducing memory usage. Falls back to base64
* JSON encoding if metadata or tags are set.
* 6. (Node.js only) a Readable stream, or a Web ReadableStream.
* Streamed as raw binary data directly into the upload request.
* Supports metadata, tags, and directory when Parse Server >= 9.5.0.
* For example:
* <pre>
* var fileUploadControl = $("#profilePhotoFileUpload")[0];
* if (fileUploadControl.files.length > 0) {
* var file = fileUploadControl.files[0];
* var name = "photo.jpg";
* var parseFile = new Parse.File(name, file);
* parseFile.save().then(function() {
* // The file has been saved to Parse.
* }, function(error) {
* // The file either could not be read, or could not be saved to Parse.
* });
* }</pre>
* @param type {String} Optional Content-Type header to use for the file. If
* this is omitted, the content type will be inferred from the name's
* extension.
* @param metadata {object} Optional key value pairs to be stored with file object
* @param tags {object} Optional key value pairs to be stored with file object
*/
constructor(name, data, type, metadata, tags) {
const specifiedType = type || "";
this._name = name;
this._metadata = metadata || {};
this._tags = tags || {};
if (data !== void 0) if (typeof Buffer$1 !== "undefined" && Buffer$1.isBuffer(data)) this._source = {
format: "buffer",
buffer: data,
type: specifiedType
};
else if (data !== null && typeof data === "object" && typeof data.pipe === "function" && typeof data.read === "function") this._source = {
format: "stream",
stream: data,
type: specifiedType
};
else if (typeof ReadableStream !== "undefined" && data instanceof ReadableStream) this._source = {
format: "stream",
stream: data,
type: specifiedType
};
else if (Array.isArray(data) || data instanceof Uint8Array) {
this._data = ParseFile.encodeBase64(data);
this._source = {
format: "base64",
base64: this._data,
type: specifiedType
};
} else if (typeof Blob !== "undefined" && data instanceof Blob) this._source = {
format: "file",
file: data,
type: specifiedType
};
else if (data && typeof data.uri === "string" && data.uri !== void 0) this._source = {
format: "uri",
uri: data.uri,
type: specifiedType
};
else if (data && typeof data.base64 === "string") {
const base64 = data.base64.split(",").slice(-1)[0];
const dataType = specifiedType || data.base64.split(";").slice(0, 1)[0].split(":").slice(1, 2)[0] || "text/plain";
this._data = base64;
this._source = {
format: "base64",
base64,
type: dataType
};
} else throw new TypeError("Cannot create a Parse.File with that data.");
}
/**
* Return the data for the file, downloading it if not already present.
* Data is present if initialized with Byte Array, Base64 or Saved with Uri.
* Data is cleared if saved with File object selected with a file upload control
*
* @param {object} options
* @param {function} [options.progress] callback for download progress
* <pre>
* const parseFile = new Parse.File(name, file);
* parseFile.getData({
* progress: (progressValue, loaded, total) => {
* if (progressValue !== null) {
* // Update the UI using progressValue
* }
* }
* });
* </pre>
* @returns {Promise} Promise that is resolve with base64 data
*/
async getData(options) {
options = options || {};
if (this._data) return this._data;
if (this._source?.format === "buffer") {
this._data = this._source.buffer.toString("base64");
return this._data;
}
if (!this._url) throw new Error("Cannot retrieve data for unsaved ParseFile.");
options.requestTask = (task) => this._requestTask = task;
const result = await CoreManager.getFileController().download(this._url, options);
this._data = result.base64;
return this._data;
}
/**
* Gets the name of the file. Before save is called, this is the filename
* given by the user. After save is called, that name gets prefixed with a
* unique identifier.
*
* @returns {string}
*/
name() {
return this._name;
}
/**
* Gets the url of the file. It is only available after you save the file or
* after you get the file from a Parse.Object.
*
* @param {object} options An object to specify url options
* @param {boolean} [options.forceSecure] force the url to be secure
* @returns {string | undefined}
*/
url(options) {
options = options || {};
if (!this._url) return;
if (options.forceSecure) return this._url.replace(/^http:\/\//i, "https://");
else return this._url;
}
/**
* Gets the metadata of the file.
*
* @returns {object}
*/
metadata() {
return this._metadata;
}
/**
* Gets the tags of the file.
*
* @returns {object}
*/
tags() {
return this._tags;
}
/**
* Gets the directory of the file.
* Requires Parse Server >= 9.4.0.
*
* @returns {string | undefined}
*/
directory() {
return this._directory;
}
/**
* Saves the file to the Parse cloud.
*
* In Node.js, files created with Buffer or ReadableStream are uploaded as
* raw binary data, avoiding base64 encoding overhead. If metadata
* or tags are set on a Buffer-backed file, the upload falls back to base64
* JSON encoding. Stream-backed files support metadata, tags, and directory
* when Parse Server >= 9.5.0.
*
* @param {object} options
* Valid options are:<ul>
* <li>useMasterKey: In Cloud Code and Node only, causes the Master Key to
* be used for this request.
* <li>sessionToken: A valid session token, used for making a request on
* behalf of a specific user.
* <li>progress: callback for upload progress. For example:
* <pre>
* let parseFile = new Parse.File(name, file);
* parseFile.save({
* progress: (progressValue, loaded, total) => {
* if (progressValue !== null) {
* // Update the UI using progressValue
* }
* }
* });
* </pre>
* <li>maxUploadSize: Overrides the server's maxUploadSize for this upload.
* Requires the master key. Only supported for Buffer and Stream source
* types; files created from base64 strings, number arrays, Blobs, or URIs
* do not support this option. Requires Parse Server >= 9.5.0.
* </ul>
* @returns {Promise | undefined} Promise that is resolved when the save finishes.
*/
save(options) {
options = options || {};
options.requestTask = (task) => this._requestTask = task;
options.metadata = this._metadata;
options.tags = this._tags;
options.directory = this._directory;
const controller = CoreManager.getFileController();
if (!this._previousSave) if (this._source.format === "buffer" || this._source.format === "stream") {
if (this._source.format === "stream" && !controller.saveBinary) throw new Error("Cannot save a stream-based file without saveBinary support on the FileController.");
const hasFileData = this._metadata && Object.keys(this._metadata).length > 0 || this._tags && Object.keys(this._tags).length > 0 || !!this._directory;
if (controller.saveBinary && (this._source.format === "stream" || !hasFileData || options.maxUploadSize)) this._previousSave = controller.saveBinary(this._name, this._source, options).then((res) => {
this._name = res.name;
this._url = res.url;
this._data = null;
this._requestTask = null;
return this;
});
else if (this._source.format === "buffer") {
const base64Source = {
format: "base64",
base64: this._source.buffer.toString("base64"),
type: this._source.type
};
this._previousSave = controller.saveBase64(this._name, base64Source, options).then((res) => {
this._name = res.name;
this._url = res.url;
this._requestTask = null;
return this;
});
}
} else if (this._source.format === "file") this._previousSave = controller.saveFile(this._name, this._source, options).then((res) => {
this._name = res.name;
this._url = res.url;
this._data = null;
this._requestTask = null;
return this;
});
else if (this._source.format === "uri") this._previousSave = controller.download(this._source.uri, options).then((result) => {
if (!(result && result.base64)) return {};
const newSource = {
format: "base64",
base64: result.base64,
type: result.contentType
};
this._data = result.base64;
this._requestTask = null;
return controller.saveBase64(this._name, newSource, options);
}).then((res) => {
this._name = res.name;
this._url = res.url;
this._requestTask = null;
return this;
});
else this._previousSave = controller.saveBase64(this._name, this._source, options).then((res) => {
this._name = res.name;
this._url = res.url;
this._requestTask = null;
return this;
});
if (this._previousSave) return this._previousSave;
}
/**
* Aborts the request if it has already been sent.
*/
cancel() {
if (this._requestTask && typeof this._requestTask.abort === "function") {
this._requestTask._aborted = true;
this._requestTask.abort();
}
this._requestTask = null;
}
/**
* Deletes the file from the Parse cloud.
* In Cloud Code and Node only with Master Key.
*
* @param {object} options
* Valid options are:<ul>
* <li>useMasterKey: In Cloud Code and Node only, causes the Master Key to
* be used for this request.
* <pre>
* @returns {Promise} Promise that is resolved when the delete finishes.
*/
destroy(options = {}) {
if (!this._name) throw new ParseError(ParseError.FILE_DELETE_UNNAMED_ERROR, "Cannot delete an unnamed file.");
const destroyOptions = { useMasterKey: true };
if (Object.hasOwn(options, "useMasterKey")) destroyOptions.useMasterKey = !!options.useMasterKey;
return CoreManager.getFileController().deleteFile(this._name, destroyOptions).then(() => {
this._data = void 0;
this._requestTask = null;
return this;
});
}
toJSON() {
return {
__type: "File",
name: this._name,
url: this._url
};
}
equals(other) {
if (this === other) return true;
return other instanceof ParseFile && this.name() === other.name() && this.url() === other.url() && typeof this.url() !== "undefined";
}
/**
* Sets metadata to be saved with file object. Overwrites existing metadata.
* When used with a stream-based file, requires Parse Server >= 9.5.0.
*
* @param {object} metadata Key value pairs to be stored with file object
*/
setMetadata(metadata) {
if (metadata && typeof metadata === "object") Object.keys(metadata).forEach((key) => {
this.addMetadata(key, metadata[key]);
});
}
/**
* Sets metadata to be saved with file object. Adds to existing metadata.
* When used with a stream-based file, requires Parse Server >= 9.5.0.
*
* @param {string} key key to store the metadata
* @param {*} value metadata
*/
addMetadata(key, value) {
if (typeof key === "string") this._metadata[key] = value;
}
/**
* Sets tags to be saved with file object. Overwrites existing tags.
* When used with a stream-based file, requires Parse Server >= 9.5.0.
*
* @param {object} tags Key value pairs to be stored with file object
*/
setTags(tags) {
if (tags && typeof tags === "object") Object.keys(tags).forEach((key) => {
this.addTag(key, tags[key]);
});
}
/**
* Sets tags to be saved with file object. Adds to existing tags.
* When used with a stream-based file, requires Parse Server >= 9.5.0.
*
* @param {string} key key to store tags
* @param {*} value tag
*/
addTag(key, value) {
if (typeof key === "string") this._tags[key] = value;
}
/**
* Sets the directory where the file will be stored.
* Requires the Master Key when saving.
* Requires Parse Server >= 9.4.0; when used with a stream-based file, requires Parse Server >= 9.5.0.
*
* @param {string} directory the directory path
*/
setDirectory(directory) {
if (typeof directory === "string" && directory.length > 0) this._directory = directory;
}
static fromJSON(obj) {
if (obj.__type !== "File") throw new TypeError("JSON object does not represent a ParseFile");
const file = new ParseFile(obj.name);
file._url = obj.url;
return file;
}
static encodeBase64(bytes) {
const chunks = [];
chunks.length = Math.ceil(bytes.length / 3);
for (let i = 0; i < chunks.length; i++) {
const b1 = bytes[i * 3];
const b2 = bytes[i * 3 + 1] || 0;
const b3 = bytes[i * 3 + 2] || 0;
const has2 = i * 3 + 1 < bytes.length;
const has3 = i * 3 + 2 < bytes.length;
chunks[i] = [
b64Digit(b1 >> 2 & 63),
b64Digit(b1 << 4 & 48 | b2 >> 4 & 15),
has2 ? b64Digit(b2 << 2 & 60 | b3 >> 6 & 3) : "=",
has3 ? b64Digit(b3 & 63) : "="
].join("");
}
return chunks.join("");
}
};
var DefaultController$3 = {
saveFile: async function(name, source, options) {
if (source.format !== "file") throw new Error("saveFile can only be used with File-type sources.");
const [first, second] = (await new Promise((res, rej) => {
const reader = new FileReader();
reader.onload = () => res(reader.result);
reader.onerror = (error) => rej(error);
reader.readAsDataURL(source.file);
})).split(",");
const newSource = {
format: "base64",
base64: second ? second : first,
type: source.type || (source.file ? source.file.type : void 0)
};
return await DefaultController$3.saveBase64(name, newSource, options);
},
saveBase64: function(name, source, options = {}) {
if (source.format !== "base64") throw new Error("saveBase64 can only be used with Base64-type sources.");
const data = {
base64: source.base64,
fileData: {
metadata: { ...options.metadata },
tags: { ...options.tags },
...options.directory ? { directory: options.directory } : {}
}
};
delete options.metadata;
delete options.tags;
delete options.directory;
if (source.type) data._ContentType = source.type;
const path = "files/" + name;
return CoreManager.getRESTController().request("POST", path, data, options);
},
saveBinary: async function(name, source, options = {}) {
if (source.format !== "buffer" && source.format !== "stream") throw new Error("saveBinary can only be used with Buffer or Stream sources.");
const headers = {
"X-Parse-Application-ID": CoreManager.get("APPLICATION_ID"),
"X-Parse-Upload-Mode": "stream"
};
headers["Content-Type"] = (source.type || "application/octet-stream").replace(/[\r\n]/g, "");
if (options.directory) headers["X-Parse-File-Directory"] = options.directory.replace(/[\r\n]/g, "");
if (options.metadata && Object.keys(options.metadata).length > 0) headers["X-Parse-File-Metadata"] = JSON.stringify(options.metadata);
if (options.tags && Object.keys(options.tags).length > 0) headers["X-Parse-File-Tags"] = JSON.stringify(options.tags);
if (options.maxUploadSize) headers["X-Parse-File-Max-Upload-Size"] = options.maxUploadSize.replace(/[\r\n]/g, "");
const jsKey = CoreManager.get("JAVASCRIPT_KEY");
if (jsKey) headers["X-Parse-JavaScript-Key"] = jsKey;
let useMasterKey = options.useMasterKey;
if (typeof useMasterKey === "undefined") useMasterKey = CoreManager.get("USE_MASTER_KEY");
if (useMasterKey) if (CoreManager.get("MASTER_KEY")) {
delete headers["X-Parse-JavaScript-Key"];
headers["X-Parse-Master-Key"] = CoreManager.get("MASTER_KEY");
} else throw new Error("Cannot use the Master Key, it has not been provided.");
if (options.sessionToken) headers["X-Parse-Session-Token"] = options.sessionToken;
else {
const userController = CoreManager.getUserController();
if (userController) {
const user = await userController.currentUserAsync();
if (user) {
const token = user.getSessionToken();
if (token) headers["X-Parse-Session-Token"] = token;
}
}
}
let body;
if (source.format === "buffer") body = source.buffer;
else if (source.format === "stream") {
const stream = source.stream;
if (typeof stream.pipe === "function" && typeof stream.read === "function") body = NodeReadable.toWeb(stream);
else body = stream;
}
let url = CoreManager.get("SERVER_URL");
if (url[url.length - 1] !== "/") url += "/";
url += "files/" + encodeURIComponent(name);
return CoreManager.getRESTController().ajax("POST", url, body, headers, options).then(({ response }) => response);
},
download: async function(uri, options) {
const controller = new AbortController();
options.requestTask(controller);
const { signal } = controller;
try {
const response = await fetch(uri, { signal });
const reader = response.body.getReader();
const length = +response.headers.get("Content-Length") || 0;
const contentType = response.headers.get("Content-Type");
if (length === 0) {
options.progress?.(null, null, null);
return {
base64: "",
contentType
};
}
let recieved = 0;
const chunks = [];
while (true) {
const { done, value } = await reader.read();
if (done) break;
chunks.push(value);
recieved += value?.length || 0;
options.progress?.(recieved / length, recieved, length);
}
const body = new Uint8Array(recieved);
let offset = 0;
for (const chunk of chunks) {
body.set(chunk, offset);
offset += chunk.length;
}
return {
base64: ParseFile.encodeBase64(body),
contentType
};
} catch (error) {
if (error.name === "AbortError") return {};
else throw error;
}
},
deleteFile: function(name, options) {
const headers = { "X-Parse-Application-ID": CoreManager.get("APPLICATION_ID") };
if (options.useMasterKey) headers["X-Parse-Master-Key"] = CoreManager.get("MASTER_KEY");
let url = CoreManager.get("SERVER_URL");
if (url[url.length - 1] !== "/") url += "/";
url += "files/" + name;
return CoreManager.getRESTController().ajax("DELETE", url, "", headers).catch((response) => {
if (!response || response.toString() === "SyntaxError: Unexpected end of JSON input") return Promise.resolve();
else return CoreManager.getRESTController().handleError(response);
});
}
};
CoreManager.setFileController(DefaultController$3);
//#endregion
//#region src/ParseGeoPoint.ts
/**
* Creates a new GeoPoint with any of the following forms:<br>
* <pre>
* new GeoPoint(otherGeoPoint)
* new GeoPoint(30, 30)
* new GeoPoint([30, 30])
* new GeoPoint({latitude: 30, longitude: 30})
* new GeoPoint() // defaults to (0, 0)
* </pre>
* <p>Represents a latitude / longitude point that may be associated
* with a key in a ParseObject or used as a reference point for geo queries.
* This allows proximity-based queries on the key.</p>
*
* <p>Only one key in a class may contain a GeoPoint.</p>
*
* <p>Example:<pre>
* var point = new Parse.GeoPoint(30.0, -20.0);
* var object = new Parse.Object("PlaceObject");
* object.set("location", point);
* object.save();</pre></p>
*
* @alias Parse.GeoPoint
*/
var ParseGeoPoint = class ParseGeoPoint {
/**
* @param {(number[] | object | number)} arg1 Either a list of coordinate pairs, an object with `latitude`, `longitude`, or the latitude or the point.
* @param {number} arg2 The longitude of the GeoPoint
*/
constructor(arg1, arg2) {
if (Array.isArray(arg1)) {
ParseGeoPoint._validate(arg1[0], arg1[1]);
this._latitude = arg1[0];
this._longitude = arg1[1];
} else if (typeof arg1 === "object") {
ParseGeoPoint._validate(arg1.latitude, arg1.longitude);
this._latitude = arg1.latitude;
this._longitude = arg1.longitude;
} else if (arg1 !== void 0 && arg2 !== void 0) {
ParseGeoPoint._validate(arg1, arg2);
this._latitude = arg1;
this._longitude = arg2;
} else {
this._latitude = 0;
this._longitude = 0;
}
}
/**
* North-south portion of the coordinate, in range [-90, 90].
* Throws an exception if set out of range in a modern browser.
*
* @property {number} latitude
* @returns {number}
*/
get latitude() {
return this._latitude;
}
set latitude(val) {
ParseGeoPoint._validate(val, this.longitude);
this._latitude = val;
}
/**
* East-west portion of the coordinate, in range [-180, 180].
* Throws if set out of range in a modern browser.
*
* @property {number} longitude
* @returns {number}
*/
get longitude() {
return this._longitude;
}
set longitude(val) {
ParseGeoPoint._validate(this.latitude, val);
this._longitude = val;
}
/**
* Returns a JSON representation of the GeoPoint, suitable for Parse.
*
* @returns {object}
*/
toJSON() {
ParseGeoPoint._validate(this._latitude, this._longitude);
return {
__type: "GeoPoint",
latitude: this._latitude,
longitude: this._longitude
};
}
equals(other) {
return other instanceof ParseGeoPoint && this.latitude === other.latitude && this.longitude === other.longitude;
}
/**
* Returns the distance from this GeoPoint to another in radians.
*
* @param {Parse.GeoPoint} point the other Parse.GeoPoint.
* @returns {number}
*/
radiansTo(point) {
const d2r = Math.PI / 180;
const lat1rad = this.latitude * d2r;
const long1rad = this.longitude * d2r;
const lat2rad = point.latitude * d2r;
const long2rad = point.longitude * d2r;
const deltaLat = lat1rad - lat2rad;
const deltaLong = long1rad - long2rad;
const sinDeltaLatDiv2 = Math.sin(deltaLat / 2);
const sinDeltaLongDiv2 = Math.sin(deltaLong / 2);
let a = sinDeltaLatDiv2 * sinDeltaLatDiv2 + Math.cos(lat1rad) * Math.cos(lat2rad) * sinDeltaLongDiv2 * sinDeltaLongDiv2;
a = Math.min(1, a);
return 2 * Math.asin(Math.sqrt(a));
}
/**
* Returns the distance from this GeoPoint to another in kilometers.
*
* @param {Parse.GeoPoint} point the other Parse.GeoPoint.
* @returns {number}
*/
kilometersTo(point) {
return this.radiansTo(point) * 6371;
}
/**
* Returns the distance from this GeoPoint to another in miles.
*
* @param {Parse.GeoPoint} point the other Parse.GeoPoint.
* @returns {number}
*/
milesTo(point) {
return this.radiansTo(point) * 3958.8;
}
static _validate(latitude, longitude) {
if (isNaN(latitude) || isNaN(longitude) || typeof latitude !== "number" || typeof longitude !== "number") throw new TypeError("GeoPoint latitude and longitude must be valid numbers");
if (latitude < -90) throw new TypeError("GeoPoint latitude out of bounds: " + latitude + " < -90.0.");
if (latitude > 90) throw new TypeError("GeoPoint latitude out of bounds: " + latitude + " > 90.0.");
if (longitude < -180) throw new TypeError("GeoPoint longitude out of bounds: " + longitude + " < -180.0.");
if (longitude > 180) throw new TypeError("GeoPoint longitude out of bounds: " + longitude + " > 180.0.");
}
/**
* Creates a GeoPoint with the user's current location, if available.
*
* @param {object} options The options.
* @param {boolean} [options.enableHighAccuracy] A boolean value that indicates the application would like to receive the best possible results.
* If true and if the device is able to provide a more accurate position, it will do so.
* Note that this can result in slower response times or increased power consumption (with a GPS chip on a mobile device for example).
* On the other hand, if false, the device can take the liberty to save resources by responding more quickly and/or using less power. Default: false.
* @param {number} [options.timeout] A positive long value representing the maximum length of time (in milliseconds) the device is allowed to take in order to return a position.
* The default value is Infinity, meaning that getCurrentPosition() won't return until the position is available.
* @param {number} [options.maximumAge] A positive long value indicating the maximum age in milliseconds of a possible cached position that is acceptable to return.
* If set to 0, it means that the device cannot use a cached position and must attempt to retrieve the real current position.
* If set to Infinity the device must return a cached position regardless of its age. Default: 0.
* @static
* @returns {Promise<Parse.GeoPoint>} User's current location
*/
static current(options) {
return new Promise((resolve, reject) => {
navigator.geolocation.getCurrentPosition((location) => {
resolve(new ParseGeoPoint(location.coords.latitude, location.coords.longitude));
}, reject, options);
});
}
};
//#endregion
//#region src/ParsePolygon.ts
/**
* Creates a new Polygon with any of the following forms:<br>
* <pre>
* new Polygon([[0,0],[0,1],[1,1],[1,0]])
* new Polygon([GeoPoint, GeoPoint, GeoPoint])
* </pre>
*
* <p>Represents a coordinates that may be associated
* with a key in a ParseObject or used as a reference point for geo queries.
* This allows proximity-based queries on the key.</p>
*
* <p>Example:<pre>
* var polygon = new Parse.Polygon([[0,0],[0,1],[1,1],[1,0]]);
* var object = new Parse.Object("PlaceObject");
* object.set("area", polygon);
* object.save();</pre></p>
*
* @alias Parse.Polygon
*/
var ParsePolygon = class ParsePolygon {
/**
* @param {(Coordinates | Parse.GeoPoint[])} coordinates An Array of coordinate pairs
*/
constructor(coordinates) {
this._coordinates = ParsePolygon._validate(coordinates);
}
/**
* Coordinates value for this Polygon.
* Throws an exception if not valid type.
*
* @property {(Coordinates | Parse.GeoPoint[])} coordinates list of coordinates
* @returns {Coordinates}
*/
get coordinates() {
return this._coordinates;
}
set coordinates(coords) {
this._coordinates = ParsePolygon._validate(coords);
}
/**
* Returns a JSON representation of the Polygon, suitable for Parse.
*
* @returns {object}
*/
toJSON() {
ParsePolygon._validate(this._coordinates);
return {
__type: "Polygon",
coordinates: this._coordinates
};
}
/**
* Checks if two polygons are equal
*
* @param {(Parse.Polygon | object)} other
* @returns {boolean}
*/
equals(other) {
if (!(other instanceof ParsePolygon) || this.coordinates.length !== other.coordinates.length) return false;
let isEqual = true;
for (let i = 1; i < this._coordinates.length; i += 1) if (this._coordinates[i][0] != other.coordinates[i][0] || this._coordinates[i][1] != other.coordinates[i][1]) {
isEqual = false;
break;
}
return isEqual;
}
/**
*
* @param {Parse.GeoPoint} point
* @returns {boolean} Returns if the point is contained in the polygon
*/
containsPoint(point) {
let minX = this._coordinates[0][0];
let maxX = this._coordinates[0][0];
let minY = this._coordinates[0][1];
let maxY = this._coordinates[0][1];
for (let i = 1; i < this._coordinates.length; i += 1) {
const p = this._coordinates[i];
minX = Math.min(p[0], minX);
maxX = Math.max(p[0], maxX);
minY = Math.min(p[1], minY);
maxY = Math.max(p[1], maxY);
}
if (point.latitude < minX || point.latitude > maxX || point.longitude < minY || point.longitude > maxY) return false;
let inside = false;
for (let i = 0, j = this._coordinates.length - 1; i < this._coordinates.length; j = i++) {
const startX = this._coordinates[i][0];
const startY = this._coordinates[i][1];
const endX = this._coordinates[j][0];
const endY = this._coordinates[j][1];
if (startY > point.longitude != endY > point.longitude && point.latitude < (endX - startX) * (point.longitude - startY) / (endY - startY) + startX) inside = !inside;
}
return inside;
}
/**
* Validates that the list of coordinates can form a valid polygon
*
* @param {Array} coords the list of coordinates to validate as a polygon
* @throws {TypeError}
* @returns {number[][]} Array of coordinates if validated.
*/
static _validate(coords) {
if (!Array.isArray(coords)) throw new TypeError("Coordinates must be an Array");
if (coords.length < 3) throw new TypeError("Polygon must have at least 3 GeoPoints or Points");
const points = [];
for (let i = 0; i < coords.length; i += 1) {
const coord = coords[i];
let geoPoint;
if (coord instanceof ParseGeoPoint) geoPoint = coord;
else if (Array.isArray(coord) && coord.length === 2) geoPoint = new ParseGeoPoint(coord[0], coord[1]);
else throw new TypeError("Coordinates must be an Array of GeoPoints or Points");
points.push([geoPoint.latitude, geoPoint.longitude]);
}
return points;
}
};
//#endregion
//#region src/ParseRelation.ts
/**
* Creates a new Relation for the given parent object and key. This
* constructor should rarely be used directly, but rather created by
* Parse.Object.relation.
*
* <p>
* A class that is used to access all of the children of a many-to-many
* relationship. Each instance of Parse.Relation is associated with a
* particular parent object and key.
* </p>
*
* @alias Parse.Relation
*/
var ParseRelation = class {
/**
* @param {Parse.Object} parent The parent of this relation.
* @param {string} key The key for this relation on the parent.
*/
constructor(parent, key) {
this.parent = parent;
this.key = key;
this.targetClassName = null;
}
_ensureParentAndKey(parent, key) {
this.key = this.key || key;
if (this.key !== key) throw new Error("Internal Error. Relation retrieved from two different keys.");
if (this.parent) {
if (this.parent.className !== parent.className) throw new Error("Internal Error. Relation retrieved from two different Objects.");
if (this.parent.id) {
if (this.parent.id !== parent.id) throw new Error("Internal Error. Relation retrieved from two different Objects.");
} else if (parent.id) this.parent = parent;
} else this.parent = parent;
}
/**
* Adds a Parse.Object or an array of Parse.Objects to the relation.
*
* @param {(Parse.Object|Array)} objects The item or items to add.
* @returns {Parse.Object} The parent of the relation.
*/
add(objects) {
if (!Array.isArray(objects)) objects = [objects];
const { RelationOp } = CoreManager.getParseOp();
const change = new RelationOp(objects, []);
const parent = this.parent;
if (!parent) throw new Error("Cannot add to a Relation without a parent");
if (objects.length === 0) return parent;
parent.set(this.key, change);
this.targetClassName = change._targetClassName;
return parent;
}
/**
* Removes a Parse.Object or an array of Parse.Objects from this relation.
*
* @param {(Parse.Object|Array)} objects The item or items to remove.
*/
remove(objects) {
if (!Array.isArray(objects)) objects = [objects];
const { RelationOp } = CoreManager.getParseOp();
const change = new RelationOp([], objects);
if (!this.parent) throw new Error("Cannot remove from a Relation without a parent");
if (objects.length === 0) return;
this.parent.set(this.key, change);
this.targetClassName = change._targetClassName;
}
/**
* Returns a JSON version of the object suitable for saving to disk.
*
* @returns {object} JSON representation of Relation
*/
toJSON() {
return {
__type: "Relation",
className: this.targetClassName
};
}
/**
* Returns a Parse.Query that is limited to objects in this
* relation.
*
* @returns {Parse.Query} Relation Query
*/
query() {
let query;
const parent = this.parent;
if (!parent) throw new Error("Cannot construct a query for a Relation without a parent");
const ParseQuery = CoreManager.getParseQuery();
if (!this.targetClassName) {
query = new ParseQuery(parent.className);
query._extraOptions.redirectClassNameForKey = this.key;
} else query = new ParseQuery(this.targetClassName);
query._addCondition("$relatedTo", "object", {
__type: "Pointer",
className: parent.className,
objectId: parent.id
});
query._addCondition("$relatedTo", "key", this.key);
return query;
}
};
//#endregion
//#region src/isDangerousKey.ts
/**
* Check if a property name or path is potentially dangerous for prototype pollution
* Dangerous keys include: __proto__, constructor, prototype
* @param key - The property name or dotted path to check
* @returns true if the key is dangerous, false otherwise
*/
function isDangerousKey(key) {
const dangerousKeys = [
"__proto__",
"constructor",
"prototype"
];
if (dangerousKeys.includes(key)) return true;
if (key.includes(".")) return key.split(".").some((part) => dangerousKeys.includes(part));
return false;
}
//#endregion
//#region src/decode.ts
function decode(value) {
if (value === null || typeof value !== "object" || value instanceof Date) return value;
if (Array.isArray(value)) {
const dup = [];
value.forEach((v, i) => {
dup[i] = decode(v);
});
return dup;
}
if (typeof value.__op === "string") {
const { opFromJSON } = CoreManager.getParseOp();
return opFromJSON(value);
}
const ParseObject = CoreManager.getParseObject();
if (value.__type === "Pointer" && value.className) return ParseObject.fromJSON(value);
if (value.__type === "Object" && value.className) return ParseObject.fromJSON(value);
if (value.__type === "Relation") {
const relation = new ParseRelation(null, null);
relation.targetClassName = value.className;
return relation;
}
if (value.__type === "Date") return new Date(value.iso);
if (value.__type === "File") return ParseFile.fromJSON(value);
if (value.__type === "GeoPoint") return new ParseGeoPoint({
latitude: value.latitude,
longitude: value.longitude
});
if (value.__type === "Polygon") return new ParsePolygon(value.coordinates);
const copy = {};
for (const k in value) if (Object.prototype.hasOwnProperty.call(value, k)) {
if (isDangerousKey(k)) continue;
copy[k] = decode(value[k]);
}
return copy;
}
//#endregion
//#region src/ParseACL.ts
var PUBLIC_KEY$1 = "*";
/**
* Creates a new ACL.
* If no argument is given, the ACL has no permissions for anyone.
* If the argument is a Parse.User, the ACL will have read and write
* permission for only that user.
* If the argument is any other JSON object, that object will be interpretted
* as a serialized ACL created with toJSON().
*
* <p>An ACL, or Access Control List can be added to any
* <code>Parse.Object</code> to restrict access to only a subset of users
* of your application.</p>
*
* @alias Parse.ACL
*/
var ParseACL = class ParseACL {
/**
* @param {(Parse.User | object | null)} arg1 The user to initialize the ACL for
*/
constructor(arg1) {
this.permissionsById = {};
if (arg1 && typeof arg1 === "object") if (arg1 instanceof CoreManager.getParseUser()) {
this.setReadAccess(arg1, true);
this.setWriteAccess(arg1, true);
} else for (const userId in arg1) {
const accessList = arg1[userId];
this.permissionsById[userId] = {};
for (const permission in accessList) {
const allowed = accessList[permission];
if (permission !== "read" && permission !== "write") throw new TypeError("Tried to create an ACL with an invalid permission type.");
if (typeof allowed !== "boolean") throw new TypeError("Tried to create an ACL with an invalid permission value.");
this.permissionsById[userId][permission] = allowed;
}
}
else if (typeof arg1 === "function") throw new TypeError("ParseACL constructed with a function. Did you forget ()?");
}
/**
* Returns a JSON-encoded version of the ACL.
*
* @returns {object}
*/
toJSON() {
const permissions = {};
for (const p in this.permissionsById) permissions[p] = this.permissionsById[p];
return permissions;
}
/**
* Returns whether this ACL is equal to another object
*
* @param {ParseACL} other The other object's ACL to compare to
* @returns {boolean}
*/
equals(other) {
if (!(other instanceof ParseACL)) return false;
const users = Object.keys(this.permissionsById);
const otherUsers = Object.keys(other.permissionsById);
if (users.length !== otherUsers.length) return false;
for (const u in this.permissionsById) {
if (!other.permissionsById[u]) return false;
if (this.permissionsById[u].read !== other.permissionsById[u].read) return false;
if (this.permissionsById[u].write !== other.permissionsById[u].write) return false;
}
return true;
}
_setAccess(accessType, userId, allowed) {
const ParseRole = CoreManager.getParseRole();
const ParseUser = CoreManager.getParseUser();
if (userId instanceof ParseUser) userId = userId.id;
else if (userId instanceof ParseRole) {
const name = userId.getName();
if (!name) throw new TypeError("Role must have a name");
userId = "role:" + name;
}
if (typeof userId !== "string") throw new TypeError("userId must be a string.");
if (typeof allowed !== "boolean") throw new TypeError("allowed must be either true or false.");
let permissions = this.permissionsById[userId];
if (!permissions) if (!allowed) return;
else {
permissions = {};
this.permissionsById[userId] = permissions;
}
if (allowed) this.permissionsById[userId][accessType] = true;
else {
delete permissions[accessType];
if (Object.keys(permissions).length === 0) delete this.permissionsById[userId];
}
}
_getAccess(accessType, userId) {
const ParseRole = CoreManager.getParseRole();
const ParseUser = CoreManager.getParseUser();
if (userId instanceof ParseUser) {
userId = userId.id;
if (!userId) throw new Error("Cannot get access for a ParseUser without an ID");
} else if (userId instanceof ParseRole) {
const name = userId.getName();
if (!name) throw new TypeError("Role must have a name");
userId = "role:" + name;
}
const permissions = this.permissionsById[userId];
if (!permissions) return false;
return !!permissions[accessType];
}
/**
* Sets whether the given user is allowed to read this object.
*
* @param userId An instance of Parse.User or its objectId.
* @param {boolean} allowed Whether that user should have read access.
*/
setReadAccess(userId, allowed) {
this._setAccess("read", userId, allowed);
}
/**
* Get whether the given user id is *explicitly* allowed to read this object.
* Even if this returns false, the user may still be able to access it if
* getPublicReadAccess returns true or a role that the user belongs to has
* write access.
*
* @param userId An instance of Parse.User or its objectId, or a Parse.Role.
* @returns {boolean}
*/
getReadAccess(userId) {
return this._getAccess("read", userId);
}
/**
* Sets whether the given user id is allowed to write this object.
*
* @param userId An instance of Parse.User or its objectId, or a Parse.Role..
* @param {boolean} allowed Whether that user should have write access.
*/
setWriteAccess(userId, allowed) {
this._setAccess("write", userId, allowed);
}
/**
* Gets whether the given user id is *explicitly* allowed to write this object.
* Even if this returns false, the user may still be able to write it if
* getPublicWriteAccess returns true or a role that the user belongs to has
* write access.
*
* @param userId An instance of Parse.User or its objectId, or a Parse.Role.
* @returns {boolean}
*/
getWriteAccess(userId) {
return this._getAccess("write", userId);
}
/**
* Sets whether the public is allowed to read this object.
*
* @param {boolean} allowed
*/
setPublicReadAccess(allowed) {
this.setReadAccess(PUBLIC_KEY$1, allowed);
}
/**
* Gets whether the public is allowed to read this object.
*
* @returns {boolean}
*/
getPublicReadAccess() {
return this.getReadAccess(PUBLIC_KEY$1);
}
/**
* Sets whether the public is allowed to write this object.
*
* @param {boolean} allowed
*/
setPublicWriteAccess(allowed) {
this.setWriteAccess(PUBLIC_KEY$1, allowed);
}
/**
* Gets whether the public is allowed to write this object.
*
* @returns {boolean}
*/
getPublicWriteAccess() {
return this.getWriteAccess(PUBLIC_KEY$1);
}
/**
* Gets whether users belonging to the given role are allowed
* to read this object. Even if this returns false, the role may
* still be able to write it if a parent role has read access.
*
* @param role The name of the role, or a Parse.Role object.
* @returns {boolean} true if the role has read access. false otherwise.
* @throws {TypeError} If role is neither a Parse.Role nor a String.
*/
getRoleReadAccess(role) {
const ParseRole = CoreManager.getParseRole();
if (role instanceof ParseRole) role = role.getName();
if (typeof role !== "string") throw new TypeError("role must be a ParseRole or a String");
return this.getReadAccess("role:" + role);
}
/**
* Gets whether users belonging to the given role are allowed
* to write this object. Even if this returns false, the role may
* still be able to write it if a parent role has write access.
*
* @param role The name of the role, or a Parse.Role object.
* @returns {boolean} true if the role has write access. false otherwise.
* @throws {TypeError} If role is neither a Parse.Role nor a String.
*/
getRoleWriteAccess(role) {
const ParseRole = CoreManager.getParseRole();
if (role instanceof ParseRole) role = role.getName();
if (typeof role !== "string") throw new TypeError("role must be a ParseRole or a String");
return this.getWriteAccess("role:" + role);
}
/**
* Sets whether users belonging to the given role are allowed
* to read this object.
*
* @param role The name of the role, or a Parse.Role object.
* @param {boolean} allowed Whether the given role can read this object.
* @throws {TypeError} If role is neither a Parse.Role nor a String.
*/
setRoleReadAccess(role, allowed) {
const ParseRole = CoreManager.getParseRole();
if (role instanceof ParseRole) role = role.getName();
if (typeof role !== "string") throw new TypeError("role must be a ParseRole or a String");
this.setReadAccess("role:" + role, allowed);
}
/**
* Sets whether users belonging to the given role are allowed
* to write this object.
*
* @param role The name of the role, or a Parse.Role object.
* @param {boolean} allowed Whether the given role can write this object.
* @throws {TypeError} If role is neither a Parse.Role nor a String.
*/
setRoleWriteAccess(role, allowed) {
const ParseRole = CoreManager.getParseRole();
if (role instanceof ParseRole) role = role.getName();
if (typeof role !== "string") throw new TypeError("role must be a ParseRole or a String");
this.setWriteAccess("role:" + role, allowed);
}
};
//#endregion
//#region src/encode.ts
function encode(value, disallowObjects, forcePointers, seen, offline) {
if (value instanceof CoreManager.getParseObject()) {
if (disallowObjects) throw new Error("Parse Objects not allowed here");
const seenEntry = value.id ? value.className + ":" + value.id : value;
if (forcePointers || !seen || seen.indexOf(seenEntry) > -1 || value.dirty() || Object.keys(value._getServerData()).length < 1) {
if (offline && value._getId().startsWith("local")) return value.toOfflinePointer();
return value.toPointer();
}
seen = seen.concat(seenEntry);
return value._toFullJSON(seen, offline);
}
const { Op } = CoreManager.getParseOp();
if (value instanceof Op || value instanceof ParseACL || value instanceof ParseGeoPoint || value instanceof ParsePolygon || value instanceof ParseRelation) return value.toJSON();
if (value instanceof ParseFile) {
if (!value.url()) throw new Error("Tried to encode an unsaved file.");
return value.toJSON();
}
if (Object.prototype.toString.call(value) === "[object Date]") {
if (isNaN(value)) throw new Error("Tried to encode an invalid date.");
return {
__type: "Date",
iso: value.toJSON()
};
}
if (Object.prototype.toString.call(value) === "[object RegExp]" && typeof value.source === "string") return value.source;
if (Array.isArray(value)) return value.map((v) => {
return encode(v, disallowObjects, forcePointers, seen, offline);
});
if (value && typeof value === "object") {
const output = {};
for (const k in value) if (Object.prototype.hasOwnProperty.call(value, k)) {
if (isDangerousKey(k)) continue;
output[k] = encode(value[k], disallowObjects, forcePointers, seen, offline);
}
return output;
}
return value;
}
function encode_default(value, disallowObjects, forcePointers, seen, offline) {
return encode(value, !!disallowObjects, !!forcePointers, seen || [], offline);
}
//#endregion
//#region node_modules/react-native-crypto-js/CryptoJS.js
var require_CryptoJS = /* @__PURE__ */ __commonJSMin(((exports, module) => {
/**
* MIT License
*
* Copyright (c) 2018 [author-name]
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
/**
* MIT License
*
* Copyright (c) 2018 [Chintan Prajapati]
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
/**
* MIT License
*
* Copyright (c) 2018 Chintan Prajapati
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
var CryptoJS = function(u, p) {
var d = {}, l = d.lib = {}, s = function() {}, t = l.Base = {
extend: function(a) {
s.prototype = this;
var c = new s();
a && c.mixIn(a);
c.hasOwnProperty("init") || (c.init = function() {
c.$super.init.apply(this, arguments);
});
c.init.prototype = c;
c.$super = this;
return c;
},
create: function() {
var a = this.extend();
a.init.apply(a, arguments);
return a;
},
init: function() {},
mixIn: function(a) {
for (var c in a) a.hasOwnProperty(c) && (this[c] = a[c]);
a.hasOwnProperty("toString") && (this.toString = a.toString);
},
clone: function() {
return this.init.prototype.extend(this);
}
}, r = l.WordArray = t.extend({
init: function(a, c) {
a = this.words = a || [];
this.sigBytes = c != p ? c : 4 * a.length;
},
toString: function(a) {
return (a || v).stringify(this);
},
concat: function(a) {
var c = this.words, e = a.words, j = this.sigBytes;
a = a.sigBytes;
this.clamp();
if (j % 4) for (var k = 0; k < a; k++) c[j + k >>> 2] |= (e[k >>> 2] >>> 24 - 8 * (k % 4) & 255) << 24 - 8 * ((j + k) % 4);
else if (65535 < e.length) for (k = 0; k < a; k += 4) c[j + k >>> 2] = e[k >>> 2];
else c.push.apply(c, e);
this.sigBytes += a;
return this;
},
clamp: function() {
var a = this.words, c = this.sigBytes;
a[c >>> 2] &= 4294967295 << 32 - 8 * (c % 4);
a.length = u.ceil(c / 4);
},
clone: function() {
var a = t.clone.call(this);
a.words = this.words.slice(0);
return a;
},
random: function(a) {
for (var c = [], e = 0; e < a; e += 4) c.push(4294967296 * u.random() | 0);
return new r.init(c, a);
}
}), w = d.enc = {}, v = w.Hex = {
stringify: function(a) {
var c = a.words;
a = a.sigBytes;
for (var e = [], j = 0; j < a; j++) {
var k = c[j >>> 2] >>> 24 - 8 * (j % 4) & 255;
e.push((k >>> 4).toString(16));
e.push((k & 15).toString(16));
}
return e.join("");
},
parse: function(a) {
for (var c = a.length, e = [], j = 0; j < c; j += 2) e[j >>> 3] |= parseInt(a.substr(j, 2), 16) << 24 - 4 * (j % 8);
return new r.init(e, c / 2);
}
}, b = w.Latin1 = {
stringify: function(a) {
var c = a.words;
a = a.sigBytes;
for (var e = [], j = 0; j < a; j++) e.push(String.fromCharCode(c[j >>> 2] >>> 24 - 8 * (j % 4) & 255));
return e.join("");
},
parse: function(a) {
for (var c = a.length, e = [], j = 0; j < c; j++) e[j >>> 2] |= (a.charCodeAt(j) & 255) << 24 - 8 * (j % 4);
return new r.init(e, c);
}
}, x = w.Utf8 = {
stringify: function(a) {
try {
return decodeURIComponent(escape(b.stringify(a)));
} catch (c) {
throw Error("Malformed UTF-8 data");
}
},
parse: function(a) {
return b.parse(unescape(encodeURIComponent(a)));
}
}, q = l.BufferedBlockAlgorithm = t.extend({
reset: function() {
this._data = new r.init();
this._nDataBytes = 0;
},
_append: function(a) {
"string" == typeof a && (a = x.parse(a));
this._data.concat(a);
this._nDataBytes += a.sigBytes;
},
_process: function(a) {
var c = this._data, e = c.words, j = c.sigBytes, k = this.blockSize, b = j / (4 * k), b = a ? u.ceil(b) : u.max((b | 0) - this._minBufferSize, 0);
a = b * k;
j = u.min(4 * a, j);
if (a) {
for (var q = 0; q < a; q += k) this._doProcessBlock(e, q);
q = e.splice(0, a);
c.sigBytes -= j;
}
return new r.init(q, j);
},
clone: function() {
var a = t.clone.call(this);
a._data = this._data.clone();
return a;
},
_minBufferSize: 0
});
l.Hasher = q.extend({
cfg: t.extend(),
init: function(a) {
this.cfg = this.cfg.extend(a);
this.reset();
},
reset: function() {
q.reset.call(this);
this._doReset();
},
update: function(a) {
this._append(a);
this._process();
return this;
},
finalize: function(a) {
a && this._append(a);
return this._doFinalize();
},
blockSize: 16,
_createHelper: function(a) {
return function(b, e) {
return new a.init(e).finalize(b);
};
},
_createHmacHelper: function(a) {
return function(b, e) {
return new n.HMAC.init(a, e).finalize(b);
};
}
});
var n = d.algo = {};
return d;
}(Math);
(function() {
var u = CryptoJS, p = u.lib.WordArray;
u.enc.Base64 = {
stringify: function(d) {
var l = d.words, p = d.sigBytes, t = this._map;
d.clamp();
d = [];
for (var r = 0; r < p; r += 3) for (var w = (l[r >>> 2] >>> 24 - 8 * (r % 4) & 255) << 16 | (l[r + 1 >>> 2] >>> 24 - 8 * ((r + 1) % 4) & 255) << 8 | l[r + 2 >>> 2] >>> 24 - 8 * ((r + 2) % 4) & 255, v = 0; 4 > v && r + .75 * v < p; v++) d.push(t.charAt(w >>> 6 * (3 - v) & 63));
if (l = t.charAt(64)) for (; d.length % 4;) d.push(l);
return d.join("");
},
parse: function(d) {
var l = d.length, s = this._map, t = s.charAt(64);
t && (t = d.indexOf(t), -1 != t && (l = t));
for (var t = [], r = 0, w = 0; w < l; w++) if (w % 4) {
var v = s.indexOf(d.charAt(w - 1)) << 2 * (w % 4), b = s.indexOf(d.charAt(w)) >>> 6 - 2 * (w % 4);
t[r >>> 2] |= (v | b) << 24 - 8 * (r % 4);
r++;
}
return p.create(t, r);
},
_map: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="
};
})();
(function(u) {
function p(b, n, a, c, e, j, k) {
b = b + (n & a | ~n & c) + e + k;
return (b << j | b >>> 32 - j) + n;
}
function d(b, n, a, c, e, j, k) {
b = b + (n & c | a & ~c) + e + k;
return (b << j | b >>> 32 - j) + n;
}
function l(b, n, a, c, e, j, k) {
b = b + (n ^ a ^ c) + e + k;
return (b << j | b >>> 32 - j) + n;
}
function s(b, n, a, c, e, j, k) {
b = b + (a ^ (n | ~c)) + e + k;
return (b << j | b >>> 32 - j) + n;
}
for (var t = CryptoJS, r = t.lib, w = r.WordArray, v = r.Hasher, r = t.algo, b = [], x = 0; 64 > x; x++) b[x] = 4294967296 * u.abs(u.sin(x + 1)) | 0;
r = r.MD5 = v.extend({
_doReset: function() {
this._hash = new w.init([
1732584193,
4023233417,
2562383102,
271733878
]);
},
_doProcessBlock: function(q, n) {
for (var a = 0; 16 > a; a++) {
var c = n + a, e = q[c];
q[c] = (e << 8 | e >>> 24) & 16711935 | (e << 24 | e >>> 8) & 4278255360;
}
var a = this._hash.words, c = q[n + 0], e = q[n + 1], j = q[n + 2], k = q[n + 3], z = q[n + 4], r = q[n + 5], t = q[n + 6], w = q[n + 7], v = q[n + 8], A = q[n + 9], B = q[n + 10], C = q[n + 11], u = q[n + 12], D = q[n + 13], E = q[n + 14], x = q[n + 15], f = a[0], m = a[1], g = a[2], h = a[3], f = p(f, m, g, h, c, 7, b[0]), h = p(h, f, m, g, e, 12, b[1]), g = p(g, h, f, m, j, 17, b[2]), m = p(m, g, h, f, k, 22, b[3]), f = p(f, m, g, h, z, 7, b[4]), h = p(h, f, m, g, r, 12, b[5]), g = p(g, h, f, m, t, 17, b[6]), m = p(m, g, h, f, w, 22, b[7]), f = p(f, m, g, h, v, 7, b[8]), h = p(h, f, m, g, A, 12, b[9]), g = p(g, h, f, m, B, 17, b[10]), m = p(m, g, h, f, C, 22, b[11]), f = p(f, m, g, h, u, 7, b[12]), h = p(h, f, m, g, D, 12, b[13]), g = p(g, h, f, m, E, 17, b[14]), m = p(m, g, h, f, x, 22, b[15]), f = d(f, m, g, h, e, 5, b[16]), h = d(h, f, m, g, t, 9, b[17]), g = d(g, h, f, m, C, 14, b[18]), m = d(m, g, h, f, c, 20, b[19]), f = d(f, m, g, h, r, 5, b[20]), h = d(h, f, m, g, B, 9, b[21]), g = d(g, h, f, m, x, 14, b[22]), m = d(m, g, h, f, z, 20, b[23]), f = d(f, m, g, h, A, 5, b[24]), h = d(h, f, m, g, E, 9, b[25]), g = d(g, h, f, m, k, 14, b[26]), m = d(m, g, h, f, v, 20, b[27]), f = d(f, m, g, h, D, 5, b[28]), h = d(h, f, m, g, j, 9, b[29]), g = d(g, h, f, m, w, 14, b[30]), m = d(m, g, h, f, u, 20, b[31]), f = l(f, m, g, h, r, 4, b[32]), h = l(h, f, m, g, v, 11, b[33]), g = l(g, h, f, m, C, 16, b[34]), m = l(m, g, h, f, E, 23, b[35]), f = l(f, m, g, h, e, 4, b[36]), h = l(h, f, m, g, z, 11, b[37]), g = l(g, h, f, m, w, 16, b[38]), m = l(m, g, h, f, B, 23, b[39]), f = l(f, m, g, h, D, 4, b[40]), h = l(h, f, m, g, c, 11, b[41]), g = l(g, h, f, m, k, 16, b[42]), m = l(m, g, h, f, t, 23, b[43]), f = l(f, m, g, h, A, 4, b[44]), h = l(h, f, m, g, u, 11, b[45]), g = l(g, h, f, m, x, 16, b[46]), m = l(m, g, h, f, j, 23, b[47]), f = s(f, m, g, h, c, 6, b[48]), h = s(h, f, m, g, w, 10, b[49]), g = s(g, h, f, m, E, 15, b[50]), m = s(m, g, h, f, r, 21, b[51]), f = s(f, m, g, h, u, 6, b[52]), h = s(h, f, m, g, k, 10, b[53]), g = s(g, h, f, m, B, 15, b[54]), m = s(m, g, h, f, e, 21, b[55]), f = s(f, m, g, h, v, 6, b[56]), h = s(h, f, m, g, x, 10, b[57]), g = s(g, h, f, m, t, 15, b[58]), m = s(m, g, h, f, D, 21, b[59]), f = s(f, m, g, h, z, 6, b[60]), h = s(h, f, m, g, C, 10, b[61]), g = s(g, h, f, m, j, 15, b[62]), m = s(m, g, h, f, A, 21, b[63]);
a[0] = a[0] + f | 0;
a[1] = a[1] + m | 0;
a[2] = a[2] + g | 0;
a[3] = a[3] + h | 0;
},
_doFinalize: function() {
var b = this._data, n = b.words, a = 8 * this._nDataBytes, c = 8 * b.sigBytes;
n[c >>> 5] |= 128 << 24 - c % 32;
var e = u.floor(a / 4294967296);
n[(c + 64 >>> 9 << 4) + 15] = (e << 8 | e >>> 24) & 16711935 | (e << 24 | e >>> 8) & 4278255360;
n[(c + 64 >>> 9 << 4) + 14] = (a << 8 | a >>> 24) & 16711935 | (a << 24 | a >>> 8) & 4278255360;
b.sigBytes = 4 * (n.length + 1);
this._process();
b = this._hash;
n = b.words;
for (a = 0; 4 > a; a++) c = n[a], n[a] = (c << 8 | c >>> 24) & 16711935 | (c << 24 | c >>> 8) & 4278255360;
return b;
},
clone: function() {
var b = v.clone.call(this);
b._hash = this._hash.clone();
return b;
}
});
t.MD5 = v._createHelper(r);
t.HmacMD5 = v._createHmacHelper(r);
})(Math);
(function() {
var u = CryptoJS, p = u.lib, d = p.Base, l = p.WordArray, p = u.algo, s = p.EvpKDF = d.extend({
cfg: d.extend({
keySize: 4,
hasher: p.MD5,
iterations: 1
}),
init: function(d) {
this.cfg = this.cfg.extend(d);
},
compute: function(d, r) {
for (var p = this.cfg, s = p.hasher.create(), b = l.create(), u = b.words, q = p.keySize, p = p.iterations; u.length < q;) {
n && s.update(n);
var n = s.update(d).finalize(r);
s.reset();
for (var a = 1; a < p; a++) n = s.finalize(n), s.reset();
b.concat(n);
}
b.sigBytes = 4 * q;
return b;
}
});
u.EvpKDF = function(d, l, p) {
return s.create(p).compute(d, l);
};
})();
CryptoJS.lib.Cipher || function(u) {
var p = CryptoJS, d = p.lib, l = d.Base, s = d.WordArray, t = d.BufferedBlockAlgorithm, r = p.enc.Base64, w = p.algo.EvpKDF, v = d.Cipher = t.extend({
cfg: l.extend(),
createEncryptor: function(e, a) {
return this.create(this._ENC_XFORM_MODE, e, a);
},
createDecryptor: function(e, a) {
return this.create(this._DEC_XFORM_MODE, e, a);
},
init: function(e, a, b) {
this.cfg = this.cfg.extend(b);
this._xformMode = e;
this._key = a;
this.reset();
},
reset: function() {
t.reset.call(this);
this._doReset();
},
process: function(e) {
this._append(e);
return this._process();
},
finalize: function(e) {
e && this._append(e);
return this._doFinalize();
},
keySize: 4,
ivSize: 4,
_ENC_XFORM_MODE: 1,
_DEC_XFORM_MODE: 2,
_createHelper: function(e) {
return {
encrypt: function(b, k, d) {
return ("string" == typeof k ? c : a).encrypt(e, b, k, d);
},
decrypt: function(b, k, d) {
return ("string" == typeof k ? c : a).decrypt(e, b, k, d);
}
};
}
});
d.StreamCipher = v.extend({
_doFinalize: function() {
return this._process(!0);
},
blockSize: 1
});
var b = p.mode = {}, x = function(e, a, b) {
var c = this._iv;
c ? this._iv = u : c = this._prevBlock;
for (var d = 0; d < b; d++) e[a + d] ^= c[d];
}, q = (d.BlockCipherMode = l.extend({
createEncryptor: function(e, a) {
return this.Encryptor.create(e, a);
},
createDecryptor: function(e, a) {
return this.Decryptor.create(e, a);
},
init: function(e, a) {
this._cipher = e;
this._iv = a;
}
})).extend();
q.Encryptor = q.extend({ processBlock: function(e, a) {
var b = this._cipher, c = b.blockSize;
x.call(this, e, a, c);
b.encryptBlock(e, a);
this._prevBlock = e.slice(a, a + c);
} });
q.Decryptor = q.extend({ processBlock: function(e, a) {
var b = this._cipher, c = b.blockSize, d = e.slice(a, a + c);
b.decryptBlock(e, a);
x.call(this, e, a, c);
this._prevBlock = d;
} });
b = b.CBC = q;
q = (p.pad = {}).Pkcs7 = {
pad: function(a, b) {
for (var c = 4 * b, c = c - a.sigBytes % c, d = c << 24 | c << 16 | c << 8 | c, l = [], n = 0; n < c; n += 4) l.push(d);
c = s.create(l, c);
a.concat(c);
},
unpad: function(a) {
a.sigBytes -= a.words[a.sigBytes - 1 >>> 2] & 255;
}
};
d.BlockCipher = v.extend({
cfg: v.cfg.extend({
mode: b,
padding: q
}),
reset: function() {
v.reset.call(this);
var a = this.cfg, b = a.iv, a = a.mode;
if (this._xformMode == this._ENC_XFORM_MODE) var c = a.createEncryptor;
else c = a.createDecryptor, this._minBufferSize = 1;
this._mode = c.call(a, this, b && b.words);
},
_doProcessBlock: function(a, b) {
this._mode.processBlock(a, b);
},
_doFinalize: function() {
var a = this.cfg.padding;
if (this._xformMode == this._ENC_XFORM_MODE) {
a.pad(this._data, this.blockSize);
var b = this._process(!0);
} else b = this._process(!0), a.unpad(b);
return b;
},
blockSize: 4
});
var n = d.CipherParams = l.extend({
init: function(a) {
this.mixIn(a);
},
toString: function(a) {
return (a || this.formatter).stringify(this);
}
}), b = (p.format = {}).OpenSSL = {
stringify: function(a) {
var b = a.ciphertext;
a = a.salt;
return (a ? s.create([1398893684, 1701076831]).concat(a).concat(b) : b).toString(r);
},
parse: function(a) {
a = r.parse(a);
var b = a.words;
if (1398893684 == b[0] && 1701076831 == b[1]) {
var c = s.create(b.slice(2, 4));
b.splice(0, 4);
a.sigBytes -= 16;
}
return n.create({
ciphertext: a,
salt: c
});
}
}, a = d.SerializableCipher = l.extend({
cfg: l.extend({ format: b }),
encrypt: function(a, b, c, d) {
d = this.cfg.extend(d);
var l = a.createEncryptor(c, d);
b = l.finalize(b);
l = l.cfg;
return n.create({
ciphertext: b,
key: c,
iv: l.iv,
algorithm: a,
mode: l.mode,
padding: l.padding,
blockSize: a.blockSize,
formatter: d.format
});
},
decrypt: function(a, b, c, d) {
d = this.cfg.extend(d);
b = this._parse(b, d.format);
return a.createDecryptor(c, d).finalize(b.ciphertext);
},
_parse: function(a, b) {
return "string" == typeof a ? b.parse(a, this) : a;
}
}), p = (p.kdf = {}).OpenSSL = { execute: function(a, b, c, d) {
d || (d = s.random(8));
a = w.create({ keySize: b + c }).compute(a, d);
c = s.create(a.words.slice(b), 4 * c);
a.sigBytes = 4 * b;
return n.create({
key: a,
iv: c,
salt: d
});
} }, c = d.PasswordBasedCipher = a.extend({
cfg: a.cfg.extend({ kdf: p }),
encrypt: function(b, c, d, l) {
l = this.cfg.extend(l);
d = l.kdf.execute(d, b.keySize, b.ivSize);
l.iv = d.iv;
b = a.encrypt.call(this, b, c, d.key, l);
b.mixIn(d);
return b;
},
decrypt: function(b, c, d, l) {
l = this.cfg.extend(l);
c = this._parse(c, l.format);
d = l.kdf.execute(d, b.keySize, b.ivSize, c.salt);
l.iv = d.iv;
return a.decrypt.call(this, b, c, d.key, l);
}
});
}();
(function() {
for (var u = CryptoJS, p = u.lib.BlockCipher, d = u.algo, l = [], s = [], t = [], r = [], w = [], v = [], b = [], x = [], q = [], n = [], a = [], c = 0; 256 > c; c++) a[c] = 128 > c ? c << 1 : c << 1 ^ 283;
for (var e = 0, j = 0, c = 0; 256 > c; c++) {
var k = j ^ j << 1 ^ j << 2 ^ j << 3 ^ j << 4, k = k >>> 8 ^ k & 255 ^ 99;
l[e] = k;
s[k] = e;
var z = a[e], F = a[z], G = a[F], y = 257 * a[k] ^ 16843008 * k;
t[e] = y << 24 | y >>> 8;
r[e] = y << 16 | y >>> 16;
w[e] = y << 8 | y >>> 24;
v[e] = y;
y = 16843009 * G ^ 65537 * F ^ 257 * z ^ 16843008 * e;
b[k] = y << 24 | y >>> 8;
x[k] = y << 16 | y >>> 16;
q[k] = y << 8 | y >>> 24;
n[k] = y;
e ? (e = z ^ a[a[a[G ^ z]]], j ^= a[a[j]]) : e = j = 1;
}
var H = [
0,
1,
2,
4,
8,
16,
32,
64,
128,
27,
54
], d = d.AES = p.extend({
_doReset: function() {
for (var a = this._key, c = a.words, d = a.sigBytes / 4, a = 4 * ((this._nRounds = d + 6) + 1), e = this._keySchedule = [], j = 0; j < a; j++) if (j < d) e[j] = c[j];
else {
var k = e[j - 1];
j % d ? 6 < d && 4 == j % d && (k = l[k >>> 24] << 24 | l[k >>> 16 & 255] << 16 | l[k >>> 8 & 255] << 8 | l[k & 255]) : (k = k << 8 | k >>> 24, k = l[k >>> 24] << 24 | l[k >>> 16 & 255] << 16 | l[k >>> 8 & 255] << 8 | l[k & 255], k ^= H[j / d | 0] << 24);
e[j] = e[j - d] ^ k;
}
c = this._invKeySchedule = [];
for (d = 0; d < a; d++) j = a - d, k = d % 4 ? e[j] : e[j - 4], c[d] = 4 > d || 4 >= j ? k : b[l[k >>> 24]] ^ x[l[k >>> 16 & 255]] ^ q[l[k >>> 8 & 255]] ^ n[l[k & 255]];
},
encryptBlock: function(a, b) {
this._doCryptBlock(a, b, this._keySchedule, t, r, w, v, l);
},
decryptBlock: function(a, c) {
var d = a[c + 1];
a[c + 1] = a[c + 3];
a[c + 3] = d;
this._doCryptBlock(a, c, this._invKeySchedule, b, x, q, n, s);
d = a[c + 1];
a[c + 1] = a[c + 3];
a[c + 3] = d;
},
_doCryptBlock: function(a, b, c, d, e, j, l, f) {
for (var m = this._nRounds, g = a[b] ^ c[0], h = a[b + 1] ^ c[1], k = a[b + 2] ^ c[2], n = a[b + 3] ^ c[3], p = 4, r = 1; r < m; r++) var q = d[g >>> 24] ^ e[h >>> 16 & 255] ^ j[k >>> 8 & 255] ^ l[n & 255] ^ c[p++], s = d[h >>> 24] ^ e[k >>> 16 & 255] ^ j[n >>> 8 & 255] ^ l[g & 255] ^ c[p++], t = d[k >>> 24] ^ e[n >>> 16 & 255] ^ j[g >>> 8 & 255] ^ l[h & 255] ^ c[p++], n = d[n >>> 24] ^ e[g >>> 16 & 255] ^ j[h >>> 8 & 255] ^ l[k & 255] ^ c[p++], g = q, h = s, k = t;
q = (f[g >>> 24] << 24 | f[h >>> 16 & 255] << 16 | f[k >>> 8 & 255] << 8 | f[n & 255]) ^ c[p++];
s = (f[h >>> 24] << 24 | f[k >>> 16 & 255] << 16 | f[n >>> 8 & 255] << 8 | f[g & 255]) ^ c[p++];
t = (f[k >>> 24] << 24 | f[n >>> 16 & 255] << 16 | f[g >>> 8 & 255] << 8 | f[h & 255]) ^ c[p++];
n = (f[n >>> 24] << 24 | f[g >>> 16 & 255] << 16 | f[h >>> 8 & 255] << 8 | f[k & 255]) ^ c[p++];
a[b] = q;
a[b + 1] = s;
a[b + 2] = t;
a[b + 3] = n;
},
keySize: 8
});
u.AES = p._createHelper(d);
})();
module.exports = CryptoJS;
}));
//#endregion
//#region node_modules/safe-buffer/index.js
var require_safe_buffer$9 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var buffer = require_dist();
var Buffer = buffer.Buffer;
function copyProps(src, dst) {
for (var key in src) dst[key] = src[key];
}
if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) module.exports = buffer;
else {
copyProps(buffer, exports);
exports.Buffer = SafeBuffer;
}
function SafeBuffer(arg, encodingOrOffset, length) {
return Buffer(arg, encodingOrOffset, length);
}
copyProps(Buffer, SafeBuffer);
SafeBuffer.from = function(arg, encodingOrOffset, length) {
if (typeof arg === "number") throw new TypeError("Argument must not be a number");
return Buffer(arg, encodingOrOffset, length);
};
SafeBuffer.alloc = function(size, fill, encoding) {
if (typeof size !== "number") throw new TypeError("Argument must be a number");
var buf = Buffer(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 Buffer(size);
};
SafeBuffer.allocUnsafeSlow = function(size) {
if (typeof size !== "number") throw new TypeError("Argument must be a number");
return buffer.SlowBuffer(size);
};
}));
//#endregion
//#region node_modules/randombytes/browser.js
var require_browser$11 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
init_dist();
init_dist$2();
var MAX_BYTES = 65536;
var MAX_UINT32 = 4294967295;
function oldBrowser() {
throw new Error("Secure random number generation is not supported by this browser.\nUse Chrome, Firefox or Internet Explorer 11");
}
var Buffer = require_safe_buffer$9().Buffer;
var crypto = global.crypto || global.msCrypto;
if (crypto && crypto.getRandomValues) module.exports = randomBytes;
else module.exports = oldBrowser;
function randomBytes(size, cb) {
if (size > MAX_UINT32) throw new RangeError("requested too many random bytes");
var bytes = Buffer.allocUnsafe(size);
if (size > 0) if (size > MAX_BYTES) for (var generated = 0; generated < size; generated += MAX_BYTES) crypto.getRandomValues(bytes.slice(generated, generated + MAX_BYTES));
else crypto.getRandomValues(bytes);
if (typeof cb === "function") return process$1.nextTick(function() {
cb(null, bytes);
});
return bytes;
}
}));
//#endregion
//#region node_modules/hash-base/node_modules/safe-buffer/index.js
var require_safe_buffer$8 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
var buffer = require_dist();
var Buffer = buffer.Buffer;
function copyProps(src, dst) {
for (var key in src) dst[key] = src[key];
}
if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) module.exports = buffer;
else {
copyProps(buffer, exports);
exports.Buffer = SafeBuffer;
}
function SafeBuffer(arg, encodingOrOffset, length) {
return Buffer(arg, encodingOrOffset, length);
}
SafeBuffer.prototype = Object.create(Buffer.prototype);
copyProps(Buffer, SafeBuffer);
SafeBuffer.from = function(arg, encodingOrOffset, length) {
if (typeof arg === "number") throw new TypeError("Argument must not be a number");
return Buffer(arg, encodingOrOffset, length);
};
SafeBuffer.alloc = function(size, fill, encoding) {
if (typeof size !== "number") throw new TypeError("Argument must be a number");
var buf = Buffer(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 Buffer(size);
};
SafeBuffer.allocUnsafeSlow = function(size) {
if (typeof size !== "number") throw new TypeError("Argument must be a number");
return buffer.SlowBuffer(size);
};
}));
//#endregion
//#region node_modules/hash-base/index.js
var require_hash_base$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var Buffer = require_safe_buffer$8().Buffer;
var Transform = require_stream_browserify().Transform;
var inherits = require_inherits_browser();
function HashBase(blockSize) {
Transform.call(this);
this._block = Buffer.allocUnsafe(blockSize);
this._blockSize = blockSize;
this._blockOffset = 0;
this._length = [
0,
0,
0,
0
];
this._finalized = false;
}
inherits(HashBase, Transform);
HashBase.prototype._transform = function(chunk, encoding, callback) {
var error = null;
try {
this.update(chunk, encoding);
} catch (err) {
error = err;
}
callback(error);
};
HashBase.prototype._flush = function(callback) {
var error = null;
try {
this.push(this.digest());
} catch (err) {
error = err;
}
callback(error);
};
var useUint8Array = typeof Uint8Array !== "undefined";
var useArrayBuffer = typeof ArrayBuffer !== "undefined" && typeof Uint8Array !== "undefined" && ArrayBuffer.isView && (Buffer.prototype instanceof Uint8Array || Buffer.TYPED_ARRAY_SUPPORT);
function toBuffer(data, encoding) {
if (data instanceof Buffer) return data;
if (typeof data === "string") return Buffer.from(data, encoding);
if (useArrayBuffer && ArrayBuffer.isView(data)) {
if (data.byteLength === 0) return Buffer.alloc(0);
var res = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
if (res.byteLength === data.byteLength) return res;
}
if (useUint8Array && data instanceof Uint8Array) return Buffer.from(data);
if (Buffer.isBuffer(data) && data.constructor && typeof data.constructor.isBuffer === "function" && data.constructor.isBuffer(data)) return Buffer.from(data);
throw new TypeError("The \"data\" argument must be of type string or an instance of Buffer, TypedArray, or DataView.");
}
HashBase.prototype.update = function(data, encoding) {
if (this._finalized) throw new Error("Digest already called");
data = toBuffer(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.prototype._update = function() {
throw new Error("_update is not implemented");
};
HashBase.prototype.digest = function(encoding) {
if (this._finalized) throw new Error("Digest already called");
this._finalized = true;
var digest = this._digest();
if (encoding !== void 0) digest = digest.toString(encoding);
this._block.fill(0);
this._blockOffset = 0;
for (var i = 0; i < 4; ++i) this._length[i] = 0;
return digest;
};
HashBase.prototype._digest = function() {
throw new Error("_digest is not implemented");
};
module.exports = HashBase;
}));
//#endregion
//#region node_modules/md5.js/index.js
var require_md5_js = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var inherits = require_inherits_browser();
var HashBase = require_hash_base$1();
var Buffer = require_safe_buffer$9().Buffer;
var ARRAY16 = new Array(16);
function MD5() {
HashBase.call(this, 64);
this._a = 1732584193;
this._b = 4023233417;
this._c = 2562383102;
this._d = 271733878;
}
inherits(MD5, HashBase);
MD5.prototype._update = function() {
var M = ARRAY16;
for (var 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.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 buffer = Buffer.allocUnsafe(16);
buffer.writeInt32LE(this._a, 0);
buffer.writeInt32LE(this._b, 4);
buffer.writeInt32LE(this._c, 8);
buffer.writeInt32LE(this._d, 12);
return buffer;
};
function rotl(x, n) {
return x << n | x >>> 32 - n;
}
function fnF(a, b, c, d, m, k, s) {
return rotl(a + (b & c | ~b & d) + m + k | 0, s) + b | 0;
}
function fnG(a, b, c, d, m, k, s) {
return rotl(a + (b & d | c & ~d) + m + k | 0, s) + b | 0;
}
function fnH(a, b, c, d, m, k, s) {
return rotl(a + (b ^ c ^ d) + m + k | 0, s) + b | 0;
}
function fnI(a, b, c, d, m, k, s) {
return rotl(a + (c ^ (b | ~d)) + m + k | 0, s) + b | 0;
}
module.exports = MD5;
}));
//#endregion
//#region node_modules/ripemd160/index.js
var require_ripemd160$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var Buffer = require_dist().Buffer;
var inherits = require_inherits_browser();
var HashBase = require_hash_base$1();
var ARRAY16 = new Array(16);
var zl = [
0,
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
7,
4,
13,
1,
10,
6,
15,
3,
12,
0,
9,
5,
2,
14,
11,
8,
3,
10,
14,
4,
9,
15,
8,
1,
2,
7,
0,
6,
13,
11,
5,
12,
1,
9,
11,
10,
0,
8,
12,
4,
13,
3,
7,
15,
14,
5,
6,
2,
4,
0,
5,
9,
7,
12,
2,
10,
14,
1,
3,
8,
11,
6,
15,
13
];
var zr = [
5,
14,
7,
0,
9,
2,
11,
4,
13,
6,
15,
8,
1,
10,
3,
12,
6,
11,
3,
7,
0,
13,
5,
10,
14,
15,
8,
12,
4,
9,
1,
2,
15,
5,
1,
3,
7,
14,
6,
9,
11,
8,
12,
2,
10,
0,
4,
13,
8,
6,
4,
1,
3,
11,
15,
0,
5,
12,
2,
13,
9,
7,
10,
14,
12,
15,
10,
4,
1,
5,
8,
7,
6,
2,
13,
14,
0,
3,
9,
11
];
var sl = [
11,
14,
15,
12,
5,
8,
7,
9,
11,
13,
14,
15,
6,
7,
9,
8,
7,
6,
8,
13,
11,
9,
7,
15,
7,
12,
15,
9,
11,
7,
13,
12,
11,
13,
6,
7,
14,
9,
13,
15,
14,
8,
13,
6,
5,
12,
7,
5,
11,
12,
14,
15,
14,
15,
9,
8,
9,
14,
5,
6,
8,
6,
5,
12,
9,
15,
5,
11,
6,
8,
13,
12,
5,
12,
13,
14,
11,
8,
5,
6
];
var sr = [
8,
9,
9,
11,
13,
15,
15,
5,
7,
7,
8,
11,
14,
14,
12,
6,
9,
13,
15,
7,
12,
8,
9,
11,
7,
7,
12,
7,
6,
15,
13,
11,
9,
7,
15,
11,
8,
6,
6,
14,
12,
13,
5,
14,
13,
13,
7,
5,
15,
5,
8,
11,
14,
14,
6,
14,
6,
9,
12,
9,
12,
5,
15,
8,
8,
5,
12,
9,
12,
5,
14,
6,
8,
13,
6,
5,
15,
13,
11,
11
];
var hl = [
0,
1518500249,
1859775393,
2400959708,
2840853838
];
var hr = [
1352829926,
1548603684,
1836072691,
2053994217,
0
];
function RIPEMD160() {
HashBase.call(this, 64);
this._a = 1732584193;
this._b = 4023233417;
this._c = 2562383102;
this._d = 271733878;
this._e = 3285377520;
}
inherits(RIPEMD160, HashBase);
RIPEMD160.prototype._update = function() {
var words = ARRAY16;
for (var j = 0; j < 16; ++j) words[j] = this._block.readInt32LE(j * 4);
var al = this._a | 0;
var bl = this._b | 0;
var cl = this._c | 0;
var dl = this._d | 0;
var el = this._e | 0;
var ar = this._a | 0;
var br = this._b | 0;
var cr = this._c | 0;
var dr = this._d | 0;
var er = this._e | 0;
for (var 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.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 buffer = Buffer.alloc ? Buffer.alloc(20) : new Buffer(20);
buffer.writeInt32LE(this._a, 0);
buffer.writeInt32LE(this._b, 4);
buffer.writeInt32LE(this._c, 8);
buffer.writeInt32LE(this._d, 12);
buffer.writeInt32LE(this._e, 16);
return buffer;
};
function rotl(x, n) {
return x << n | x >>> 32 - n;
}
function fn1(a, b, c, d, e, m, k, s) {
return rotl(a + (b ^ c ^ d) + m + k | 0, s) + e | 0;
}
function fn2(a, b, c, d, e, m, k, s) {
return rotl(a + (b & c | ~b & d) + m + k | 0, s) + e | 0;
}
function fn3(a, b, c, d, e, m, k, s) {
return rotl(a + ((b | ~c) ^ d) + m + k | 0, s) + e | 0;
}
function fn4(a, b, c, d, e, m, k, s) {
return rotl(a + (b & d | c & ~d) + m + k | 0, s) + e | 0;
}
function fn5(a, b, c, d, e, m, k, s) {
return rotl(a + (b ^ (c | ~d)) + m + k | 0, s) + e | 0;
}
module.exports = RIPEMD160;
}));
//#endregion
//#region node_modules/sha.js/node_modules/safe-buffer/index.js
var require_safe_buffer$7 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
var buffer = require_dist();
var Buffer = buffer.Buffer;
function copyProps(src, dst) {
for (var key in src) dst[key] = src[key];
}
if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) module.exports = buffer;
else {
copyProps(buffer, exports);
exports.Buffer = SafeBuffer;
}
function SafeBuffer(arg, encodingOrOffset, length) {
return Buffer(arg, encodingOrOffset, length);
}
SafeBuffer.prototype = Object.create(Buffer.prototype);
copyProps(Buffer, SafeBuffer);
SafeBuffer.from = function(arg, encodingOrOffset, length) {
if (typeof arg === "number") throw new TypeError("Argument must not be a number");
return Buffer(arg, encodingOrOffset, length);
};
SafeBuffer.alloc = function(size, fill, encoding) {
if (typeof size !== "number") throw new TypeError("Argument must be a number");
var buf = Buffer(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 Buffer(size);
};
SafeBuffer.allocUnsafeSlow = function(size) {
if (typeof size !== "number") throw new TypeError("Argument must be a number");
return buffer.SlowBuffer(size);
};
}));
//#endregion
//#region node_modules/to-buffer/node_modules/safe-buffer/index.js
var require_safe_buffer$6 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
var buffer = require_dist();
var Buffer = buffer.Buffer;
function copyProps(src, dst) {
for (var key in src) dst[key] = src[key];
}
if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) module.exports = buffer;
else {
copyProps(buffer, exports);
exports.Buffer = SafeBuffer;
}
function SafeBuffer(arg, encodingOrOffset, length) {
return Buffer(arg, encodingOrOffset, length);
}
SafeBuffer.prototype = Object.create(Buffer.prototype);
copyProps(Buffer, SafeBuffer);
SafeBuffer.from = function(arg, encodingOrOffset, length) {
if (typeof arg === "number") throw new TypeError("Argument must not be a number");
return Buffer(arg, encodingOrOffset, length);
};
SafeBuffer.alloc = function(size, fill, encoding) {
if (typeof size !== "number") throw new TypeError("Argument must be a number");
var buf = Buffer(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 Buffer(size);
};
SafeBuffer.allocUnsafeSlow = function(size) {
if (typeof size !== "number") throw new TypeError("Argument must be a number");
return buffer.SlowBuffer(size);
};
}));
//#endregion
//#region node_modules/to-buffer/node_modules/isarray/index.js
var require_isarray$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var toString = {}.toString;
module.exports = Array.isArray || function(arr) {
return toString.call(arr) == "[object Array]";
};
}));
//#endregion
//#region node_modules/typed-array-buffer/index.js
var require_typed_array_buffer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var $TypeError = require_type();
/** @type {undefined | ((thisArg: import('.').TypedArray) => Buffer<ArrayBufferLike>)} */
var $typedArrayBuffer = require_call_bound()("TypedArray.prototype.buffer", true);
var isTypedArray = require_is_typed_array();
/** @type {import('.')} */
module.exports = $typedArrayBuffer || function typedArrayBuffer(x) {
if (!isTypedArray(x)) throw new $TypeError("Not a Typed Array");
return x.buffer;
};
}));
//#endregion
//#region node_modules/to-buffer/index.js
var require_to_buffer$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var Buffer = require_safe_buffer$6().Buffer;
var isArray = require_isarray$1();
var typedArrayBuffer = require_typed_array_buffer();
var isView = ArrayBuffer.isView || function isView(obj) {
try {
typedArrayBuffer(obj);
return true;
} catch (e) {
return false;
}
};
var useUint8Array = typeof Uint8Array !== "undefined";
var useArrayBuffer = typeof ArrayBuffer !== "undefined" && typeof Uint8Array !== "undefined";
var useFromArrayBuffer = useArrayBuffer && (Buffer.prototype instanceof Uint8Array || Buffer.TYPED_ARRAY_SUPPORT);
module.exports = function toBuffer(data, encoding) {
if (data instanceof Buffer) return data;
if (typeof data === "string") return Buffer.from(data, encoding);
if (useArrayBuffer && isView(data)) {
if (data.byteLength === 0) return Buffer.alloc(0);
if (useFromArrayBuffer) {
var res = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
if (res.byteLength === data.byteLength) return res;
}
var uint8 = data instanceof Uint8Array ? data : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
var result = Buffer.from(uint8);
if (result.length === data.byteLength) return result;
}
if (useUint8Array && data instanceof Uint8Array) return Buffer.from(data);
var isArr = isArray(data);
if (isArr) for (var i = 0; i < data.length; i += 1) {
var x = data[i];
if (typeof x !== "number" || x < 0 || x > 255 || ~~x !== x) throw new RangeError("Array items must be numbers in the range 0-255.");
}
if (isArr || Buffer.isBuffer(data) && data.constructor && typeof data.constructor.isBuffer === "function" && data.constructor.isBuffer(data)) return Buffer.from(data);
throw new TypeError("The \"data\" argument must be a string, an Array, a Buffer, a Uint8Array, or a DataView.");
};
}));
//#endregion
//#region node_modules/sha.js/hash.js
var require_hash$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var Buffer = require_safe_buffer$7().Buffer;
var toBuffer = require_to_buffer$1();
function Hash(blockSize, finalSize) {
this._block = Buffer.alloc(blockSize);
this._finalSize = finalSize;
this._blockSize = blockSize;
this._len = 0;
}
Hash.prototype.update = function(data, enc) {
data = toBuffer(data, enc || "utf8");
var block = this._block;
var blockSize = this._blockSize;
var length = data.length;
var accum = this._len;
for (var offset = 0; offset < length;) {
var assigned = accum % blockSize;
var remainder = Math.min(length - offset, blockSize - assigned);
for (var i = 0; i < remainder; i++) block[assigned + i] = data[offset + i];
accum += remainder;
offset += remainder;
if (accum % blockSize === 0) this._update(block);
}
this._len += length;
return this;
};
Hash.prototype.digest = function(enc) {
var rem = this._len % this._blockSize;
this._block[rem] = 128;
this._block.fill(0, rem + 1);
if (rem >= this._finalSize) {
this._update(this._block);
this._block.fill(0);
}
var bits = this._len * 8;
if (bits <= 4294967295) this._block.writeUInt32BE(bits, this._blockSize - 4);
else {
var lowBits = (bits & 4294967295) >>> 0;
var highBits = (bits - lowBits) / 4294967296;
this._block.writeUInt32BE(highBits, this._blockSize - 8);
this._block.writeUInt32BE(lowBits, this._blockSize - 4);
}
this._update(this._block);
var hash = this._hash();
return enc ? hash.toString(enc) : hash;
};
Hash.prototype._update = function() {
throw new Error("_update must be implemented by subclass");
};
module.exports = Hash;
}));
//#endregion
//#region node_modules/sha.js/sha.js
var require_sha$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var inherits = require_inherits_browser();
var Hash = require_hash$1();
var Buffer = require_safe_buffer$7().Buffer;
var K = [
1518500249,
1859775393,
-1894007588,
-899497514
];
var W = new Array(80);
function Sha() {
this.init();
this._w = W;
Hash.call(this, 64, 56);
}
inherits(Sha, Hash);
Sha.prototype.init = function() {
this._a = 1732584193;
this._b = 4023233417;
this._c = 2562383102;
this._d = 271733878;
this._e = 3285377520;
return this;
};
function rotl5(num) {
return num << 5 | num >>> 27;
}
function rotl30(num) {
return num << 30 | num >>> 2;
}
function ft(s, b, c, d) {
if (s === 0) return b & c | ~b & d;
if (s === 2) return b & c | b & d | c & d;
return b ^ c ^ d;
}
Sha.prototype._update = function(M) {
var w = 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) w[i] = M.readInt32BE(i * 4);
for (; i < 80; ++i) w[i] = w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16];
for (var j = 0; j < 80; ++j) {
var s = ~~(j / 20);
var t = rotl5(a) + ft(s, b, c, d) + e + w[j] + K[s] | 0;
e = d;
d = c;
c = rotl30(b);
b = a;
a = t;
}
this._a = a + this._a | 0;
this._b = b + this._b | 0;
this._c = c + this._c | 0;
this._d = d + this._d | 0;
this._e = e + this._e | 0;
};
Sha.prototype._hash = function() {
var H = Buffer.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;
};
module.exports = Sha;
}));
//#endregion
//#region node_modules/sha.js/sha1.js
var require_sha1$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var inherits = require_inherits_browser();
var Hash = require_hash$1();
var Buffer = require_safe_buffer$7().Buffer;
var K = [
1518500249,
1859775393,
-1894007588,
-899497514
];
var W = new Array(80);
function Sha1() {
this.init();
this._w = W;
Hash.call(this, 64, 56);
}
inherits(Sha1, Hash);
Sha1.prototype.init = function() {
this._a = 1732584193;
this._b = 4023233417;
this._c = 2562383102;
this._d = 271733878;
this._e = 3285377520;
return this;
};
function rotl1(num) {
return num << 1 | num >>> 31;
}
function rotl5(num) {
return num << 5 | num >>> 27;
}
function rotl30(num) {
return num << 30 | num >>> 2;
}
function ft(s, b, c, d) {
if (s === 0) return b & c | ~b & d;
if (s === 2) return b & c | b & d | c & d;
return b ^ c ^ d;
}
Sha1.prototype._update = function(M) {
var w = 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) w[i] = M.readInt32BE(i * 4);
for (; i < 80; ++i) w[i] = rotl1(w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16]);
for (var j = 0; j < 80; ++j) {
var s = ~~(j / 20);
var t = rotl5(a) + ft(s, b, c, d) + e + w[j] + K[s] | 0;
e = d;
d = c;
c = rotl30(b);
b = a;
a = t;
}
this._a = a + this._a | 0;
this._b = b + this._b | 0;
this._c = c + this._c | 0;
this._d = d + this._d | 0;
this._e = e + this._e | 0;
};
Sha1.prototype._hash = function() {
var H = Buffer.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;
};
module.exports = Sha1;
}));
//#endregion
//#region node_modules/sha.js/sha256.js
var require_sha256 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
/**
* A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined
* in FIPS 180-2
* Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.
* Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
*
*/
var inherits = require_inherits_browser();
var Hash = require_hash$1();
var Buffer = require_safe_buffer$7().Buffer;
var K = [
1116352408,
1899447441,
3049323471,
3921009573,
961987163,
1508970993,
2453635748,
2870763221,
3624381080,
310598401,
607225278,
1426881987,
1925078388,
2162078206,
2614888103,
3248222580,
3835390401,
4022224774,
264347078,
604807628,
770255983,
1249150122,
1555081692,
1996064986,
2554220882,
2821834349,
2952996808,
3210313671,
3336571891,
3584528711,
113926993,
338241895,
666307205,
773529912,
1294757372,
1396182291,
1695183700,
1986661051,
2177026350,
2456956037,
2730485921,
2820302411,
3259730800,
3345764771,
3516065817,
3600352804,
4094571909,
275423344,
430227734,
506948616,
659060556,
883997877,
958139571,
1322822218,
1537002063,
1747873779,
1955562222,
2024104815,
2227730452,
2361852424,
2428436474,
2756734187,
3204031479,
3329325298
];
var W = new Array(64);
function Sha256() {
this.init();
this._w = W;
Hash.call(this, 64, 56);
}
inherits(Sha256, Hash);
Sha256.prototype.init = function() {
this._a = 1779033703;
this._b = 3144134277;
this._c = 1013904242;
this._d = 2773480762;
this._e = 1359893119;
this._f = 2600822924;
this._g = 528734635;
this._h = 1541459225;
return this;
};
function ch(x, y, z) {
return z ^ x & (y ^ z);
}
function maj(x, y, z) {
return x & y | z & (x | y);
}
function sigma0(x) {
return (x >>> 2 | x << 30) ^ (x >>> 13 | x << 19) ^ (x >>> 22 | x << 10);
}
function sigma1(x) {
return (x >>> 6 | x << 26) ^ (x >>> 11 | x << 21) ^ (x >>> 25 | x << 7);
}
function gamma0(x) {
return (x >>> 7 | x << 25) ^ (x >>> 18 | x << 14) ^ x >>> 3;
}
function gamma1(x) {
return (x >>> 17 | x << 15) ^ (x >>> 19 | x << 13) ^ x >>> 10;
}
Sha256.prototype._update = function(M) {
var w = this._w;
var a = this._a | 0;
var b = this._b | 0;
var c = this._c | 0;
var d = this._d | 0;
var e = this._e | 0;
var f = this._f | 0;
var g = this._g | 0;
var h = this._h | 0;
for (var i = 0; i < 16; ++i) w[i] = M.readInt32BE(i * 4);
for (; i < 64; ++i) w[i] = gamma1(w[i - 2]) + w[i - 7] + gamma0(w[i - 15]) + w[i - 16] | 0;
for (var j = 0; j < 64; ++j) {
var T1 = h + sigma1(e) + ch(e, f, g) + K[j] + w[j] | 0;
var T2 = sigma0(a) + maj(a, b, c) | 0;
h = g;
g = f;
f = e;
e = d + T1 | 0;
d = c;
c = b;
b = a;
a = T1 + T2 | 0;
}
this._a = a + this._a | 0;
this._b = b + this._b | 0;
this._c = c + this._c | 0;
this._d = d + this._d | 0;
this._e = e + this._e | 0;
this._f = f + this._f | 0;
this._g = g + this._g | 0;
this._h = h + this._h | 0;
};
Sha256.prototype._hash = function() {
var H = Buffer.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;
};
module.exports = Sha256;
}));
//#endregion
//#region node_modules/sha.js/sha224.js
var require_sha224 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
/**
* A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined
* in FIPS 180-2
* Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.
* Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
*
*/
var inherits = require_inherits_browser();
var Sha256 = require_sha256();
var Hash = require_hash$1();
var Buffer = require_safe_buffer$7().Buffer;
var W = new Array(64);
function Sha224() {
this.init();
this._w = W;
Hash.call(this, 64, 56);
}
inherits(Sha224, Sha256);
Sha224.prototype.init = function() {
this._a = 3238371032;
this._b = 914150663;
this._c = 812702999;
this._d = 4144912697;
this._e = 4290775857;
this._f = 1750603025;
this._g = 1694076839;
this._h = 3204075428;
return this;
};
Sha224.prototype._hash = function() {
var H = Buffer.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;
};
module.exports = Sha224;
}));
//#endregion
//#region node_modules/sha.js/sha512.js
var require_sha512 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var inherits = require_inherits_browser();
var Hash = require_hash$1();
var Buffer = require_safe_buffer$7().Buffer;
var K = [
1116352408,
3609767458,
1899447441,
602891725,
3049323471,
3964484399,
3921009573,
2173295548,
961987163,
4081628472,
1508970993,
3053834265,
2453635748,
2937671579,
2870763221,
3664609560,
3624381080,
2734883394,
310598401,
1164996542,
607225278,
1323610764,
1426881987,
3590304994,
1925078388,
4068182383,
2162078206,
991336113,
2614888103,
633803317,
3248222580,
3479774868,
3835390401,
2666613458,
4022224774,
944711139,
264347078,
2341262773,
604807628,
2007800933,
770255983,
1495990901,
1249150122,
1856431235,
1555081692,
3175218132,
1996064986,
2198950837,
2554220882,
3999719339,
2821834349,
766784016,
2952996808,
2566594879,
3210313671,
3203337956,
3336571891,
1034457026,
3584528711,
2466948901,
113926993,
3758326383,
338241895,
168717936,
666307205,
1188179964,
773529912,
1546045734,
1294757372,
1522805485,
1396182291,
2643833823,
1695183700,
2343527390,
1986661051,
1014477480,
2177026350,
1206759142,
2456956037,
344077627,
2730485921,
1290863460,
2820302411,
3158454273,
3259730800,
3505952657,
3345764771,
106217008,
3516065817,
3606008344,
3600352804,
1432725776,
4094571909,
1467031594,
275423344,
851169720,
430227734,
3100823752,
506948616,
1363258195,
659060556,
3750685593,
883997877,
3785050280,
958139571,
3318307427,
1322822218,
3812723403,
1537002063,
2003034995,
1747873779,
3602036899,
1955562222,
1575990012,
2024104815,
1125592928,
2227730452,
2716904306,
2361852424,
442776044,
2428436474,
593698344,
2756734187,
3733110249,
3204031479,
2999351573,
3329325298,
3815920427,
3391569614,
3928383900,
3515267271,
566280711,
3940187606,
3454069534,
4118630271,
4000239992,
116418474,
1914138554,
174292421,
2731055270,
289380356,
3203993006,
460393269,
320620315,
685471733,
587496836,
852142971,
1086792851,
1017036298,
365543100,
1126000580,
2618297676,
1288033470,
3409855158,
1501505948,
4234509866,
1607167915,
987167468,
1816402316,
1246189591
];
var W = new Array(160);
function Sha512() {
this.init();
this._w = W;
Hash.call(this, 128, 112);
}
inherits(Sha512, Hash);
Sha512.prototype.init = function() {
this._ah = 1779033703;
this._bh = 3144134277;
this._ch = 1013904242;
this._dh = 2773480762;
this._eh = 1359893119;
this._fh = 2600822924;
this._gh = 528734635;
this._hh = 1541459225;
this._al = 4089235720;
this._bl = 2227873595;
this._cl = 4271175723;
this._dl = 1595750129;
this._el = 2917565137;
this._fl = 725511199;
this._gl = 4215389547;
this._hl = 327033209;
return this;
};
function Ch(x, y, z) {
return z ^ x & (y ^ z);
}
function maj(x, y, z) {
return x & y | z & (x | y);
}
function sigma0(x, xl) {
return (x >>> 28 | xl << 4) ^ (xl >>> 2 | x << 30) ^ (xl >>> 7 | x << 25);
}
function sigma1(x, xl) {
return (x >>> 14 | xl << 18) ^ (x >>> 18 | xl << 14) ^ (xl >>> 9 | x << 23);
}
function Gamma0(x, xl) {
return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ x >>> 7;
}
function Gamma0l(x, xl) {
return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ (x >>> 7 | xl << 25);
}
function Gamma1(x, xl) {
return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ x >>> 6;
}
function Gamma1l(x, xl) {
return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ (x >>> 6 | xl << 26);
}
function getCarry(a, b) {
return a >>> 0 < b >>> 0 ? 1 : 0;
}
Sha512.prototype._update = function(M) {
var w = this._w;
var ah = this._ah | 0;
var bh = this._bh | 0;
var ch = this._ch | 0;
var dh = this._dh | 0;
var eh = this._eh | 0;
var fh = this._fh | 0;
var gh = this._gh | 0;
var hh = this._hh | 0;
var al = this._al | 0;
var bl = this._bl | 0;
var cl = this._cl | 0;
var dl = this._dl | 0;
var el = this._el | 0;
var fl = this._fl | 0;
var gl = this._gl | 0;
var hl = this._hl | 0;
for (var i = 0; i < 32; i += 2) {
w[i] = M.readInt32BE(i * 4);
w[i + 1] = M.readInt32BE(i * 4 + 4);
}
for (; i < 160; i += 2) {
var xh = w[i - 30];
var xl = w[i - 30 + 1];
var gamma0 = Gamma0(xh, xl);
var gamma0l = Gamma0l(xl, xh);
xh = w[i - 4];
xl = w[i - 4 + 1];
var gamma1 = Gamma1(xh, xl);
var gamma1l = Gamma1l(xl, xh);
var Wi7h = w[i - 14];
var Wi7l = w[i - 14 + 1];
var Wi16h = w[i - 32];
var Wi16l = w[i - 32 + 1];
var Wil = gamma0l + Wi7l | 0;
var Wih = gamma0 + Wi7h + getCarry(Wil, gamma0l) | 0;
Wil = Wil + gamma1l | 0;
Wih = Wih + gamma1 + getCarry(Wil, gamma1l) | 0;
Wil = Wil + Wi16l | 0;
Wih = Wih + Wi16h + getCarry(Wil, Wi16l) | 0;
w[i] = Wih;
w[i + 1] = Wil;
}
for (var j = 0; j < 160; j += 2) {
Wih = w[j];
Wil = w[j + 1];
var majh = maj(ah, bh, ch);
var majl = maj(al, bl, cl);
var sigma0h = sigma0(ah, al);
var sigma0l = sigma0(al, ah);
var sigma1h = sigma1(eh, el);
var sigma1l = sigma1(el, eh);
var Kih = K[j];
var Kil = K[j + 1];
var chh = Ch(eh, fh, gh);
var chl = Ch(el, fl, gl);
var t1l = hl + sigma1l | 0;
var t1h = hh + sigma1h + getCarry(t1l, hl) | 0;
t1l = t1l + chl | 0;
t1h = t1h + chh + getCarry(t1l, chl) | 0;
t1l = t1l + Kil | 0;
t1h = t1h + Kih + getCarry(t1l, Kil) | 0;
t1l = t1l + Wil | 0;
t1h = t1h + Wih + getCarry(t1l, Wil) | 0;
var t2l = sigma0l + majl | 0;
var t2h = sigma0h + majh + getCarry(t2l, sigma0l) | 0;
hh = gh;
hl = gl;
gh = fh;
gl = fl;
fh = eh;
fl = el;
el = dl + t1l | 0;
eh = dh + t1h + getCarry(el, dl) | 0;
dh = ch;
dl = cl;
ch = bh;
cl = bl;
bh = ah;
bl = al;
al = t1l + t2l | 0;
ah = t1h + t2h + getCarry(al, t1l) | 0;
}
this._al = this._al + al | 0;
this._bl = this._bl + bl | 0;
this._cl = this._cl + cl | 0;
this._dl = this._dl + dl | 0;
this._el = this._el + el | 0;
this._fl = this._fl + fl | 0;
this._gl = this._gl + gl | 0;
this._hl = this._hl + hl | 0;
this._ah = this._ah + ah + getCarry(this._al, al) | 0;
this._bh = this._bh + bh + getCarry(this._bl, bl) | 0;
this._ch = this._ch + ch + getCarry(this._cl, cl) | 0;
this._dh = this._dh + dh + getCarry(this._dl, dl) | 0;
this._eh = this._eh + eh + getCarry(this._el, el) | 0;
this._fh = this._fh + fh + getCarry(this._fl, fl) | 0;
this._gh = this._gh + gh + getCarry(this._gl, gl) | 0;
this._hh = this._hh + hh + getCarry(this._hl, hl) | 0;
};
Sha512.prototype._hash = function() {
var H = Buffer.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;
};
module.exports = Sha512;
}));
//#endregion
//#region node_modules/sha.js/sha384.js
var require_sha384 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var inherits = require_inherits_browser();
var SHA512 = require_sha512();
var Hash = require_hash$1();
var Buffer = require_safe_buffer$7().Buffer;
var W = new Array(160);
function Sha384() {
this.init();
this._w = W;
Hash.call(this, 128, 112);
}
inherits(Sha384, SHA512);
Sha384.prototype.init = function() {
this._ah = 3418070365;
this._bh = 1654270250;
this._ch = 2438529370;
this._dh = 355462360;
this._eh = 1731405415;
this._fh = 2394180231;
this._gh = 3675008525;
this._hh = 1203062813;
this._al = 3238371032;
this._bl = 914150663;
this._cl = 812702999;
this._dl = 4144912697;
this._el = 4290775857;
this._fl = 1750603025;
this._gl = 1694076839;
this._hl = 3204075428;
return this;
};
Sha384.prototype._hash = function() {
var H = Buffer.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;
};
module.exports = Sha384;
}));
//#endregion
//#region node_modules/sha.js/index.js
var require_sha_js = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = function SHA(algorithm) {
var alg = algorithm.toLowerCase();
var Algorithm = module.exports[alg];
if (!Algorithm) throw new Error(alg + " is not supported (we accept pull requests)");
return new Algorithm();
};
module.exports.sha = require_sha$1();
module.exports.sha1 = require_sha1$1();
module.exports.sha224 = require_sha224();
module.exports.sha256 = require_sha256();
module.exports.sha384 = require_sha384();
module.exports.sha512 = require_sha512();
}));
//#endregion
//#region node_modules/cipher-base/node_modules/safe-buffer/index.js
var require_safe_buffer$5 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
var buffer = require_dist();
var Buffer = buffer.Buffer;
function copyProps(src, dst) {
for (var key in src) dst[key] = src[key];
}
if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) module.exports = buffer;
else {
copyProps(buffer, exports);
exports.Buffer = SafeBuffer;
}
function SafeBuffer(arg, encodingOrOffset, length) {
return Buffer(arg, encodingOrOffset, length);
}
SafeBuffer.prototype = Object.create(Buffer.prototype);
copyProps(Buffer, SafeBuffer);
SafeBuffer.from = function(arg, encodingOrOffset, length) {
if (typeof arg === "number") throw new TypeError("Argument must not be a number");
return Buffer(arg, encodingOrOffset, length);
};
SafeBuffer.alloc = function(size, fill, encoding) {
if (typeof size !== "number") throw new TypeError("Argument must be a number");
var buf = Buffer(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 Buffer(size);
};
SafeBuffer.allocUnsafeSlow = function(size) {
if (typeof size !== "number") throw new TypeError("Argument must be a number");
return buffer.SlowBuffer(size);
};
}));
//#endregion
//#region node_modules/cipher-base/index.js
var require_cipher_base = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var Buffer = require_safe_buffer$5().Buffer;
var Transform = require_stream_browserify().Transform;
var StringDecoder = require_string_decoder().StringDecoder;
var inherits = require_inherits_browser();
function CipherBase(hashMode) {
Transform.call(this);
this.hashMode = typeof hashMode === "string";
if (this.hashMode) this[hashMode] = this._finalOrDigest;
else this["final"] = this._finalOrDigest;
if (this._final) {
this.__final = this._final;
this._final = null;
}
this._decoder = null;
this._encoding = null;
}
inherits(CipherBase, Transform);
var useUint8Array = typeof Uint8Array !== "undefined";
var useArrayBuffer = typeof ArrayBuffer !== "undefined" && typeof Uint8Array !== "undefined" && ArrayBuffer.isView && (Buffer.prototype instanceof Uint8Array || Buffer.TYPED_ARRAY_SUPPORT);
function toBuffer(data, encoding) {
if (data instanceof Buffer) return data;
if (typeof data === "string") return Buffer.from(data, encoding);
if (useArrayBuffer && ArrayBuffer.isView(data)) {
if (data.byteLength === 0) return Buffer.alloc(0);
var res = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
if (res.byteLength === data.byteLength) return res;
}
if (useUint8Array && data instanceof Uint8Array) return Buffer.from(data);
if (Buffer.isBuffer(data) && data.constructor && typeof data.constructor.isBuffer === "function" && data.constructor.isBuffer(data)) return Buffer.from(data);
throw new TypeError("The \"data\" argument must be of type string or an instance of Buffer, TypedArray, or DataView.");
}
CipherBase.prototype.update = function(data, inputEnc, outputEnc) {
var bufferData = toBuffer(data, inputEnc);
var outData = this._update(bufferData);
if (this.hashMode) return this;
if (outputEnc) outData = this._toString(outData, outputEnc);
return outData;
};
CipherBase.prototype.setAutoPadding = function() {};
CipherBase.prototype.getAuthTag = function() {
throw new Error("trying to get auth tag in unsupported state");
};
CipherBase.prototype.setAuthTag = function() {
throw new Error("trying to set auth tag in unsupported state");
};
CipherBase.prototype.setAAD = function() {
throw new Error("trying to set aad in unsupported state");
};
CipherBase.prototype._transform = function(data, _, next) {
var err;
try {
if (this.hashMode) this._update(data);
else this.push(this._update(data));
} catch (e) {
err = e;
} finally {
next(err);
}
};
CipherBase.prototype._flush = function(done) {
var err;
try {
this.push(this.__final());
} catch (e) {
err = e;
}
done(err);
};
CipherBase.prototype._finalOrDigest = function(outputEnc) {
var outData = this.__final() || Buffer.alloc(0);
if (outputEnc) outData = this._toString(outData, outputEnc, true);
return outData;
};
CipherBase.prototype._toString = function(value, enc, fin) {
if (!this._decoder) {
this._decoder = new StringDecoder(enc);
this._encoding = enc;
}
if (this._encoding !== enc) throw new Error("can’t switch encodings");
var out = this._decoder.write(value);
if (fin) out += this._decoder.end();
return out;
};
module.exports = CipherBase;
}));
//#endregion
//#region node_modules/create-hash/browser.js
var require_browser$10 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var inherits = require_inherits_browser();
var MD5 = require_md5_js();
var RIPEMD160 = require_ripemd160$1();
var sha = require_sha_js();
var Base = require_cipher_base();
function Hash(hash) {
Base.call(this, "digest");
this._hash = hash;
}
inherits(Hash, Base);
Hash.prototype._update = function(data) {
this._hash.update(data);
};
Hash.prototype._final = function() {
return this._hash.digest();
};
module.exports = function createHash(alg) {
alg = alg.toLowerCase();
if (alg === "md5") return new MD5();
if (alg === "rmd160" || alg === "ripemd160") return new RIPEMD160();
return new Hash(sha(alg));
};
}));
//#endregion
//#region node_modules/create-hmac/legacy.js
var require_legacy = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var inherits = require_inherits_browser();
var Buffer = require_safe_buffer$9().Buffer;
var Base = require_cipher_base();
var ZEROS = Buffer.alloc(128);
var blocksize = 64;
function Hmac(alg, key) {
Base.call(this, "digest");
if (typeof key === "string") key = Buffer.from(key);
this._alg = alg;
this._key = key;
if (key.length > blocksize) key = alg(key);
else if (key.length < blocksize) key = Buffer.concat([key, ZEROS], blocksize);
var ipad = this._ipad = Buffer.allocUnsafe(blocksize);
var opad = this._opad = Buffer.allocUnsafe(blocksize);
for (var i = 0; i < blocksize; i++) {
ipad[i] = key[i] ^ 54;
opad[i] = key[i] ^ 92;
}
this._hash = [ipad];
}
inherits(Hmac, Base);
Hmac.prototype._update = function(data) {
this._hash.push(data);
};
Hmac.prototype._final = function() {
var h = this._alg(Buffer.concat(this._hash));
return this._alg(Buffer.concat([this._opad, h]));
};
module.exports = Hmac;
}));
//#endregion
//#region node_modules/create-hash/md5.js
var require_md5$2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var MD5 = require_md5_js();
module.exports = function(buffer) {
return new MD5().update(buffer).digest();
};
}));
//#endregion
//#region node_modules/create-hmac/browser.js
var require_browser$9 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var inherits = require_inherits_browser();
var Legacy = require_legacy();
var Base = require_cipher_base();
var Buffer = require_safe_buffer$9().Buffer;
var md5 = require_md5$2();
var RIPEMD160 = require_ripemd160$1();
var sha = require_sha_js();
var ZEROS = Buffer.alloc(128);
function Hmac(alg, key) {
Base.call(this, "digest");
if (typeof key === "string") key = Buffer.from(key);
var blocksize = alg === "sha512" || alg === "sha384" ? 128 : 64;
this._alg = alg;
this._key = key;
if (key.length > blocksize) key = (alg === "rmd160" ? new RIPEMD160() : sha(alg)).update(key).digest();
else if (key.length < blocksize) key = Buffer.concat([key, ZEROS], blocksize);
var ipad = this._ipad = Buffer.allocUnsafe(blocksize);
var opad = this._opad = Buffer.allocUnsafe(blocksize);
for (var i = 0; i < blocksize; i++) {
ipad[i] = key[i] ^ 54;
opad[i] = key[i] ^ 92;
}
this._hash = alg === "rmd160" ? new RIPEMD160() : sha(alg);
this._hash.update(ipad);
}
inherits(Hmac, Base);
Hmac.prototype._update = function(data) {
this._hash.update(data);
};
Hmac.prototype._final = function() {
var h = this._hash.digest();
return (this._alg === "rmd160" ? new RIPEMD160() : sha(this._alg)).update(this._opad).update(h).digest();
};
module.exports = function createHmac(alg, key) {
alg = alg.toLowerCase();
if (alg === "rmd160" || alg === "ripemd160") return new Hmac("rmd160", key);
if (alg === "md5") return new Legacy(md5, key);
return new Hmac(alg, key);
};
}));
//#endregion
//#region node_modules/browserify-sign/browser/algorithms.json
var algorithms_exports = /* @__PURE__ */ __exportAll({
DSA: () => DSA,
default: () => algorithms_default,
md5WithRSAEncryption: () => md5WithRSAEncryption,
ripemd160WithRSA: () => ripemd160WithRSA,
sha224: () => sha224,
sha224WithRSAEncryption: () => sha224WithRSAEncryption,
sha256: () => sha256,
sha256WithRSAEncryption: () => sha256WithRSAEncryption,
sha384: () => sha384,
sha384WithRSAEncryption: () => sha384WithRSAEncryption,
sha512: () => sha512,
sha512WithRSAEncryption: () => sha512WithRSAEncryption
});
var sha224WithRSAEncryption, sha256WithRSAEncryption, sha384WithRSAEncryption, sha512WithRSAEncryption, sha256, sha224, sha384, sha512, DSA, ripemd160WithRSA, md5WithRSAEncryption, algorithms_default;
var init_algorithms = __esmMin((() => {
sha224WithRSAEncryption = {
"sign": "rsa",
"hash": "sha224",
"id": "302d300d06096086480165030402040500041c"
};
sha256WithRSAEncryption = {
"sign": "rsa",
"hash": "sha256",
"id": "3031300d060960864801650304020105000420"
};
sha384WithRSAEncryption = {
"sign": "rsa",
"hash": "sha384",
"id": "3041300d060960864801650304020205000430"
};
sha512WithRSAEncryption = {
"sign": "rsa",
"hash": "sha512",
"id": "3051300d060960864801650304020305000440"
};
sha256 = {
"sign": "ecdsa",
"hash": "sha256",
"id": ""
};
sha224 = {
"sign": "ecdsa",
"hash": "sha224",
"id": ""
};
sha384 = {
"sign": "ecdsa",
"hash": "sha384",
"id": ""
};
sha512 = {
"sign": "ecdsa",
"hash": "sha512",
"id": ""
};
DSA = {
"sign": "dsa",
"hash": "sha1",
"id": ""
};
ripemd160WithRSA = {
"sign": "rsa",
"hash": "rmd160",
"id": "3021300906052b2403020105000414"
};
md5WithRSAEncryption = {
"sign": "rsa",
"hash": "md5",
"id": "3020300c06082a864886f70d020505000410"
};
algorithms_default = {
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"
}
};
}));
//#endregion
//#region node_modules/browserify-sign/algos.js
var require_algos = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = (init_algorithms(), __toCommonJS(algorithms_exports).default);
}));
//#endregion
//#region node_modules/pbkdf2/node_modules/safe-buffer/index.js
var require_safe_buffer$4 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
var buffer = require_dist();
var Buffer = buffer.Buffer;
function copyProps(src, dst) {
for (var key in src) dst[key] = src[key];
}
if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) module.exports = buffer;
else {
copyProps(buffer, exports);
exports.Buffer = SafeBuffer;
}
function SafeBuffer(arg, encodingOrOffset, length) {
return Buffer(arg, encodingOrOffset, length);
}
SafeBuffer.prototype = Object.create(Buffer.prototype);
copyProps(Buffer, SafeBuffer);
SafeBuffer.from = function(arg, encodingOrOffset, length) {
if (typeof arg === "number") throw new TypeError("Argument must not be a number");
return Buffer(arg, encodingOrOffset, length);
};
SafeBuffer.alloc = function(size, fill, encoding) {
if (typeof size !== "number") throw new TypeError("Argument must be a number");
var buf = Buffer(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 Buffer(size);
};
SafeBuffer.allocUnsafeSlow = function(size) {
if (typeof size !== "number") throw new TypeError("Argument must be a number");
return buffer.SlowBuffer(size);
};
}));
//#endregion
//#region node_modules/pbkdf2/lib/precondition.js
var require_precondition = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var MAX_ALLOC = Math.pow(2, 30) - 1;
module.exports = 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");
};
}));
//#endregion
//#region node_modules/pbkdf2/lib/default-encoding.js
var require_default_encoding = /* @__PURE__ */ __commonJSMin(((exports, module) => {
init_dist();
init_dist$2();
var defaultEncoding;
/* istanbul ignore next */
if (global.process && global.process.browser) defaultEncoding = "utf-8";
else if (global.process && global.process.version) defaultEncoding = parseInt(process$1.version.split(".")[0].slice(1), 10) >= 6 ? "utf-8" : "binary";
else defaultEncoding = "utf-8";
module.exports = defaultEncoding;
}));
//#endregion
//#region node_modules/pbkdf2/node_modules/create-hash/make-hash.js
var require_make_hash = /* @__PURE__ */ __commonJSMin(((exports, module) => {
init_dist$1();
var intSize = 4;
var zeroBuffer = new Buffer$1(intSize);
zeroBuffer.fill(0);
var charSize = 8;
var hashSize = 16;
function toArray(buf) {
if (buf.length % intSize !== 0) {
var len = buf.length + (intSize - buf.length % intSize);
buf = Buffer$1.concat([buf, zeroBuffer], len);
}
var arr = new Array(buf.length >>> 2);
for (var i = 0, j = 0; i < buf.length; i += intSize, j++) arr[j] = buf.readInt32LE(i);
return arr;
}
module.exports = function hash(buf, fn) {
var arr = fn(toArray(buf), buf.length * charSize);
buf = new Buffer$1(hashSize);
for (var i = 0; i < arr.length; i++) buf.writeInt32LE(arr[i], i << 2, true);
return buf;
};
}));
//#endregion
//#region node_modules/pbkdf2/node_modules/create-hash/md5.js
var require_md5$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var makeHash = require_make_hash();
function core_md5(x, len) {
x[len >> 5] |= 128 << len % 32;
x[(len + 64 >>> 9 << 4) + 14] = len;
var a = 1732584193;
var b = -271733879;
var c = -1732584194;
var d = 271733878;
for (var i = 0; i < x.length; i += 16) {
var olda = a;
var oldb = b;
var oldc = c;
var oldd = d;
a = md5_ff(a, b, c, d, x[i + 0], 7, -680876936);
d = md5_ff(d, a, b, c, x[i + 1], 12, -389564586);
c = md5_ff(c, d, a, b, x[i + 2], 17, 606105819);
b = md5_ff(b, c, d, a, x[i + 3], 22, -1044525330);
a = md5_ff(a, b, c, d, x[i + 4], 7, -176418897);
d = md5_ff(d, a, b, c, x[i + 5], 12, 1200080426);
c = md5_ff(c, d, a, b, x[i + 6], 17, -1473231341);
b = md5_ff(b, c, d, a, x[i + 7], 22, -45705983);
a = md5_ff(a, b, c, d, x[i + 8], 7, 1770035416);
d = md5_ff(d, a, b, c, x[i + 9], 12, -1958414417);
c = md5_ff(c, d, a, b, x[i + 10], 17, -42063);
b = md5_ff(b, c, d, a, x[i + 11], 22, -1990404162);
a = md5_ff(a, b, c, d, x[i + 12], 7, 1804603682);
d = md5_ff(d, a, b, c, x[i + 13], 12, -40341101);
c = md5_ff(c, d, a, b, x[i + 14], 17, -1502002290);
b = md5_ff(b, c, d, a, x[i + 15], 22, 1236535329);
a = md5_gg(a, b, c, d, x[i + 1], 5, -165796510);
d = md5_gg(d, a, b, c, x[i + 6], 9, -1069501632);
c = md5_gg(c, d, a, b, x[i + 11], 14, 643717713);
b = md5_gg(b, c, d, a, x[i + 0], 20, -373897302);
a = md5_gg(a, b, c, d, x[i + 5], 5, -701558691);
d = md5_gg(d, a, b, c, x[i + 10], 9, 38016083);
c = md5_gg(c, d, a, b, x[i + 15], 14, -660478335);
b = md5_gg(b, c, d, a, x[i + 4], 20, -405537848);
a = md5_gg(a, b, c, d, x[i + 9], 5, 568446438);
d = md5_gg(d, a, b, c, x[i + 14], 9, -1019803690);
c = md5_gg(c, d, a, b, x[i + 3], 14, -187363961);
b = md5_gg(b, c, d, a, x[i + 8], 20, 1163531501);
a = md5_gg(a, b, c, d, x[i + 13], 5, -1444681467);
d = md5_gg(d, a, b, c, x[i + 2], 9, -51403784);
c = md5_gg(c, d, a, b, x[i + 7], 14, 1735328473);
b = md5_gg(b, c, d, a, x[i + 12], 20, -1926607734);
a = md5_hh(a, b, c, d, x[i + 5], 4, -378558);
d = md5_hh(d, a, b, c, x[i + 8], 11, -2022574463);
c = md5_hh(c, d, a, b, x[i + 11], 16, 1839030562);
b = md5_hh(b, c, d, a, x[i + 14], 23, -35309556);
a = md5_hh(a, b, c, d, x[i + 1], 4, -1530992060);
d = md5_hh(d, a, b, c, x[i + 4], 11, 1272893353);
c = md5_hh(c, d, a, b, x[i + 7], 16, -155497632);
b = md5_hh(b, c, d, a, x[i + 10], 23, -1094730640);
a = md5_hh(a, b, c, d, x[i + 13], 4, 681279174);
d = md5_hh(d, a, b, c, x[i + 0], 11, -358537222);
c = md5_hh(c, d, a, b, x[i + 3], 16, -722521979);
b = md5_hh(b, c, d, a, x[i + 6], 23, 76029189);
a = md5_hh(a, b, c, d, x[i + 9], 4, -640364487);
d = md5_hh(d, a, b, c, x[i + 12], 11, -421815835);
c = md5_hh(c, d, a, b, x[i + 15], 16, 530742520);
b = md5_hh(b, c, d, a, x[i + 2], 23, -995338651);
a = md5_ii(a, b, c, d, x[i + 0], 6, -198630844);
d = md5_ii(d, a, b, c, x[i + 7], 10, 1126891415);
c = md5_ii(c, d, a, b, x[i + 14], 15, -1416354905);
b = md5_ii(b, c, d, a, x[i + 5], 21, -57434055);
a = md5_ii(a, b, c, d, x[i + 12], 6, 1700485571);
d = md5_ii(d, a, b, c, x[i + 3], 10, -1894986606);
c = md5_ii(c, d, a, b, x[i + 10], 15, -1051523);
b = md5_ii(b, c, d, a, x[i + 1], 21, -2054922799);
a = md5_ii(a, b, c, d, x[i + 8], 6, 1873313359);
d = md5_ii(d, a, b, c, x[i + 15], 10, -30611744);
c = md5_ii(c, d, a, b, x[i + 6], 15, -1560198380);
b = md5_ii(b, c, d, a, x[i + 13], 21, 1309151649);
a = md5_ii(a, b, c, d, x[i + 4], 6, -145523070);
d = md5_ii(d, a, b, c, x[i + 11], 10, -1120210379);
c = md5_ii(c, d, a, b, x[i + 2], 15, 718787259);
b = md5_ii(b, c, d, a, x[i + 9], 21, -343485551);
a = safe_add(a, olda);
b = safe_add(b, oldb);
c = safe_add(c, oldc);
d = safe_add(d, oldd);
}
return [
a,
b,
c,
d
];
}
function md5_cmn(q, a, b, x, s, t) {
return safe_add(bit_rol(safe_add(safe_add(a, q), safe_add(x, t)), s), b);
}
function md5_ff(a, b, c, d, x, s, t) {
return md5_cmn(b & c | ~b & d, a, b, x, s, t);
}
function md5_gg(a, b, c, d, x, s, t) {
return md5_cmn(b & d | c & ~d, a, b, x, s, t);
}
function md5_hh(a, b, c, d, x, s, t) {
return md5_cmn(b ^ c ^ d, a, b, x, s, t);
}
function md5_ii(a, b, c, d, x, s, t) {
return md5_cmn(c ^ (b | ~d), a, b, x, s, t);
}
function safe_add(x, y) {
var lsw = (x & 65535) + (y & 65535);
return (x >> 16) + (y >> 16) + (lsw >> 16) << 16 | lsw & 65535;
}
function bit_rol(num, cnt) {
return num << cnt | num >>> 32 - cnt;
}
module.exports = function md5(buf) {
return makeHash(buf, core_md5);
};
}));
//#endregion
//#region node_modules/pbkdf2/node_modules/hash-base/index.js
var require_hash_base = /* @__PURE__ */ __commonJSMin(((exports, module) => {
init_dist$1();
var Transform = require_stream_browserify().Transform;
var inherits = require_inherits_browser();
function HashBase(blockSize) {
Transform.call(this);
this._block = new Buffer$1(blockSize);
this._blockSize = blockSize;
this._blockOffset = 0;
this._length = [
0,
0,
0,
0
];
this._finalized = false;
}
inherits(HashBase, Transform);
HashBase.prototype._transform = function(chunk, encoding, callback) {
var error = null;
try {
if (encoding !== "buffer") chunk = new Buffer$1(chunk, encoding);
this.update(chunk);
} catch (err) {
error = err;
}
callback(error);
};
HashBase.prototype._flush = function(callback) {
var error = null;
try {
this.push(this._digest());
} catch (err) {
error = err;
}
callback(error);
};
HashBase.prototype.update = function(data, encoding) {
if (!Buffer$1.isBuffer(data) && typeof data !== "string") throw new TypeError("Data must be a string or a buffer");
if (this._finalized) throw new Error("Digest already called");
if (!Buffer$1.isBuffer(data)) data = new Buffer$1(data, encoding || "binary");
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.prototype._update = function(data) {
throw new Error("_update is not implemented");
};
HashBase.prototype.digest = function(encoding) {
if (this._finalized) throw new Error("Digest already called");
this._finalized = true;
var digest = this._digest();
if (encoding !== void 0) digest = digest.toString(encoding);
return digest;
};
HashBase.prototype._digest = function() {
throw new Error("_digest is not implemented");
};
module.exports = HashBase;
}));
//#endregion
//#region node_modules/pbkdf2/node_modules/ripemd160/index.js
var require_ripemd160 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
init_dist$1();
var inherits = require_inherits_browser();
var HashBase = require_hash_base();
function RIPEMD160() {
HashBase.call(this, 64);
this._a = 1732584193;
this._b = 4023233417;
this._c = 2562383102;
this._d = 271733878;
this._e = 3285377520;
}
inherits(RIPEMD160, HashBase);
RIPEMD160.prototype._update = function() {
var m = new Array(16);
for (var i = 0; i < 16; ++i) m[i] = this._block.readInt32LE(i * 4);
var al = this._a;
var bl = this._b;
var cl = this._c;
var dl = this._d;
var el = this._e;
al = fn1(al, bl, cl, dl, el, m[0], 0, 11);
cl = rotl(cl, 10);
el = fn1(el, al, bl, cl, dl, m[1], 0, 14);
bl = rotl(bl, 10);
dl = fn1(dl, el, al, bl, cl, m[2], 0, 15);
al = rotl(al, 10);
cl = fn1(cl, dl, el, al, bl, m[3], 0, 12);
el = rotl(el, 10);
bl = fn1(bl, cl, dl, el, al, m[4], 0, 5);
dl = rotl(dl, 10);
al = fn1(al, bl, cl, dl, el, m[5], 0, 8);
cl = rotl(cl, 10);
el = fn1(el, al, bl, cl, dl, m[6], 0, 7);
bl = rotl(bl, 10);
dl = fn1(dl, el, al, bl, cl, m[7], 0, 9);
al = rotl(al, 10);
cl = fn1(cl, dl, el, al, bl, m[8], 0, 11);
el = rotl(el, 10);
bl = fn1(bl, cl, dl, el, al, m[9], 0, 13);
dl = rotl(dl, 10);
al = fn1(al, bl, cl, dl, el, m[10], 0, 14);
cl = rotl(cl, 10);
el = fn1(el, al, bl, cl, dl, m[11], 0, 15);
bl = rotl(bl, 10);
dl = fn1(dl, el, al, bl, cl, m[12], 0, 6);
al = rotl(al, 10);
cl = fn1(cl, dl, el, al, bl, m[13], 0, 7);
el = rotl(el, 10);
bl = fn1(bl, cl, dl, el, al, m[14], 0, 9);
dl = rotl(dl, 10);
al = fn1(al, bl, cl, dl, el, m[15], 0, 8);
cl = rotl(cl, 10);
el = fn2(el, al, bl, cl, dl, m[7], 1518500249, 7);
bl = rotl(bl, 10);
dl = fn2(dl, el, al, bl, cl, m[4], 1518500249, 6);
al = rotl(al, 10);
cl = fn2(cl, dl, el, al, bl, m[13], 1518500249, 8);
el = rotl(el, 10);
bl = fn2(bl, cl, dl, el, al, m[1], 1518500249, 13);
dl = rotl(dl, 10);
al = fn2(al, bl, cl, dl, el, m[10], 1518500249, 11);
cl = rotl(cl, 10);
el = fn2(el, al, bl, cl, dl, m[6], 1518500249, 9);
bl = rotl(bl, 10);
dl = fn2(dl, el, al, bl, cl, m[15], 1518500249, 7);
al = rotl(al, 10);
cl = fn2(cl, dl, el, al, bl, m[3], 1518500249, 15);
el = rotl(el, 10);
bl = fn2(bl, cl, dl, el, al, m[12], 1518500249, 7);
dl = rotl(dl, 10);
al = fn2(al, bl, cl, dl, el, m[0], 1518500249, 12);
cl = rotl(cl, 10);
el = fn2(el, al, bl, cl, dl, m[9], 1518500249, 15);
bl = rotl(bl, 10);
dl = fn2(dl, el, al, bl, cl, m[5], 1518500249, 9);
al = rotl(al, 10);
cl = fn2(cl, dl, el, al, bl, m[2], 1518500249, 11);
el = rotl(el, 10);
bl = fn2(bl, cl, dl, el, al, m[14], 1518500249, 7);
dl = rotl(dl, 10);
al = fn2(al, bl, cl, dl, el, m[11], 1518500249, 13);
cl = rotl(cl, 10);
el = fn2(el, al, bl, cl, dl, m[8], 1518500249, 12);
bl = rotl(bl, 10);
dl = fn3(dl, el, al, bl, cl, m[3], 1859775393, 11);
al = rotl(al, 10);
cl = fn3(cl, dl, el, al, bl, m[10], 1859775393, 13);
el = rotl(el, 10);
bl = fn3(bl, cl, dl, el, al, m[14], 1859775393, 6);
dl = rotl(dl, 10);
al = fn3(al, bl, cl, dl, el, m[4], 1859775393, 7);
cl = rotl(cl, 10);
el = fn3(el, al, bl, cl, dl, m[9], 1859775393, 14);
bl = rotl(bl, 10);
dl = fn3(dl, el, al, bl, cl, m[15], 1859775393, 9);
al = rotl(al, 10);
cl = fn3(cl, dl, el, al, bl, m[8], 1859775393, 13);
el = rotl(el, 10);
bl = fn3(bl, cl, dl, el, al, m[1], 1859775393, 15);
dl = rotl(dl, 10);
al = fn3(al, bl, cl, dl, el, m[2], 1859775393, 14);
cl = rotl(cl, 10);
el = fn3(el, al, bl, cl, dl, m[7], 1859775393, 8);
bl = rotl(bl, 10);
dl = fn3(dl, el, al, bl, cl, m[0], 1859775393, 13);
al = rotl(al, 10);
cl = fn3(cl, dl, el, al, bl, m[6], 1859775393, 6);
el = rotl(el, 10);
bl = fn3(bl, cl, dl, el, al, m[13], 1859775393, 5);
dl = rotl(dl, 10);
al = fn3(al, bl, cl, dl, el, m[11], 1859775393, 12);
cl = rotl(cl, 10);
el = fn3(el, al, bl, cl, dl, m[5], 1859775393, 7);
bl = rotl(bl, 10);
dl = fn3(dl, el, al, bl, cl, m[12], 1859775393, 5);
al = rotl(al, 10);
cl = fn4(cl, dl, el, al, bl, m[1], 2400959708, 11);
el = rotl(el, 10);
bl = fn4(bl, cl, dl, el, al, m[9], 2400959708, 12);
dl = rotl(dl, 10);
al = fn4(al, bl, cl, dl, el, m[11], 2400959708, 14);
cl = rotl(cl, 10);
el = fn4(el, al, bl, cl, dl, m[10], 2400959708, 15);
bl = rotl(bl, 10);
dl = fn4(dl, el, al, bl, cl, m[0], 2400959708, 14);
al = rotl(al, 10);
cl = fn4(cl, dl, el, al, bl, m[8], 2400959708, 15);
el = rotl(el, 10);
bl = fn4(bl, cl, dl, el, al, m[12], 2400959708, 9);
dl = rotl(dl, 10);
al = fn4(al, bl, cl, dl, el, m[4], 2400959708, 8);
cl = rotl(cl, 10);
el = fn4(el, al, bl, cl, dl, m[13], 2400959708, 9);
bl = rotl(bl, 10);
dl = fn4(dl, el, al, bl, cl, m[3], 2400959708, 14);
al = rotl(al, 10);
cl = fn4(cl, dl, el, al, bl, m[7], 2400959708, 5);
el = rotl(el, 10);
bl = fn4(bl, cl, dl, el, al, m[15], 2400959708, 6);
dl = rotl(dl, 10);
al = fn4(al, bl, cl, dl, el, m[14], 2400959708, 8);
cl = rotl(cl, 10);
el = fn4(el, al, bl, cl, dl, m[5], 2400959708, 6);
bl = rotl(bl, 10);
dl = fn4(dl, el, al, bl, cl, m[6], 2400959708, 5);
al = rotl(al, 10);
cl = fn4(cl, dl, el, al, bl, m[2], 2400959708, 12);
el = rotl(el, 10);
bl = fn5(bl, cl, dl, el, al, m[4], 2840853838, 9);
dl = rotl(dl, 10);
al = fn5(al, bl, cl, dl, el, m[0], 2840853838, 15);
cl = rotl(cl, 10);
el = fn5(el, al, bl, cl, dl, m[5], 2840853838, 5);
bl = rotl(bl, 10);
dl = fn5(dl, el, al, bl, cl, m[9], 2840853838, 11);
al = rotl(al, 10);
cl = fn5(cl, dl, el, al, bl, m[7], 2840853838, 6);
el = rotl(el, 10);
bl = fn5(bl, cl, dl, el, al, m[12], 2840853838, 8);
dl = rotl(dl, 10);
al = fn5(al, bl, cl, dl, el, m[2], 2840853838, 13);
cl = rotl(cl, 10);
el = fn5(el, al, bl, cl, dl, m[10], 2840853838, 12);
bl = rotl(bl, 10);
dl = fn5(dl, el, al, bl, cl, m[14], 2840853838, 5);
al = rotl(al, 10);
cl = fn5(cl, dl, el, al, bl, m[1], 2840853838, 12);
el = rotl(el, 10);
bl = fn5(bl, cl, dl, el, al, m[3], 2840853838, 13);
dl = rotl(dl, 10);
al = fn5(al, bl, cl, dl, el, m[8], 2840853838, 14);
cl = rotl(cl, 10);
el = fn5(el, al, bl, cl, dl, m[11], 2840853838, 11);
bl = rotl(bl, 10);
dl = fn5(dl, el, al, bl, cl, m[6], 2840853838, 8);
al = rotl(al, 10);
cl = fn5(cl, dl, el, al, bl, m[15], 2840853838, 5);
el = rotl(el, 10);
bl = fn5(bl, cl, dl, el, al, m[13], 2840853838, 6);
dl = rotl(dl, 10);
var ar = this._a;
var br = this._b;
var cr = this._c;
var dr = this._d;
var er = this._e;
ar = fn5(ar, br, cr, dr, er, m[5], 1352829926, 8);
cr = rotl(cr, 10);
er = fn5(er, ar, br, cr, dr, m[14], 1352829926, 9);
br = rotl(br, 10);
dr = fn5(dr, er, ar, br, cr, m[7], 1352829926, 9);
ar = rotl(ar, 10);
cr = fn5(cr, dr, er, ar, br, m[0], 1352829926, 11);
er = rotl(er, 10);
br = fn5(br, cr, dr, er, ar, m[9], 1352829926, 13);
dr = rotl(dr, 10);
ar = fn5(ar, br, cr, dr, er, m[2], 1352829926, 15);
cr = rotl(cr, 10);
er = fn5(er, ar, br, cr, dr, m[11], 1352829926, 15);
br = rotl(br, 10);
dr = fn5(dr, er, ar, br, cr, m[4], 1352829926, 5);
ar = rotl(ar, 10);
cr = fn5(cr, dr, er, ar, br, m[13], 1352829926, 7);
er = rotl(er, 10);
br = fn5(br, cr, dr, er, ar, m[6], 1352829926, 7);
dr = rotl(dr, 10);
ar = fn5(ar, br, cr, dr, er, m[15], 1352829926, 8);
cr = rotl(cr, 10);
er = fn5(er, ar, br, cr, dr, m[8], 1352829926, 11);
br = rotl(br, 10);
dr = fn5(dr, er, ar, br, cr, m[1], 1352829926, 14);
ar = rotl(ar, 10);
cr = fn5(cr, dr, er, ar, br, m[10], 1352829926, 14);
er = rotl(er, 10);
br = fn5(br, cr, dr, er, ar, m[3], 1352829926, 12);
dr = rotl(dr, 10);
ar = fn5(ar, br, cr, dr, er, m[12], 1352829926, 6);
cr = rotl(cr, 10);
er = fn4(er, ar, br, cr, dr, m[6], 1548603684, 9);
br = rotl(br, 10);
dr = fn4(dr, er, ar, br, cr, m[11], 1548603684, 13);
ar = rotl(ar, 10);
cr = fn4(cr, dr, er, ar, br, m[3], 1548603684, 15);
er = rotl(er, 10);
br = fn4(br, cr, dr, er, ar, m[7], 1548603684, 7);
dr = rotl(dr, 10);
ar = fn4(ar, br, cr, dr, er, m[0], 1548603684, 12);
cr = rotl(cr, 10);
er = fn4(er, ar, br, cr, dr, m[13], 1548603684, 8);
br = rotl(br, 10);
dr = fn4(dr, er, ar, br, cr, m[5], 1548603684, 9);
ar = rotl(ar, 10);
cr = fn4(cr, dr, er, ar, br, m[10], 1548603684, 11);
er = rotl(er, 10);
br = fn4(br, cr, dr, er, ar, m[14], 1548603684, 7);
dr = rotl(dr, 10);
ar = fn4(ar, br, cr, dr, er, m[15], 1548603684, 7);
cr = rotl(cr, 10);
er = fn4(er, ar, br, cr, dr, m[8], 1548603684, 12);
br = rotl(br, 10);
dr = fn4(dr, er, ar, br, cr, m[12], 1548603684, 7);
ar = rotl(ar, 10);
cr = fn4(cr, dr, er, ar, br, m[4], 1548603684, 6);
er = rotl(er, 10);
br = fn4(br, cr, dr, er, ar, m[9], 1548603684, 15);
dr = rotl(dr, 10);
ar = fn4(ar, br, cr, dr, er, m[1], 1548603684, 13);
cr = rotl(cr, 10);
er = fn4(er, ar, br, cr, dr, m[2], 1548603684, 11);
br = rotl(br, 10);
dr = fn3(dr, er, ar, br, cr, m[15], 1836072691, 9);
ar = rotl(ar, 10);
cr = fn3(cr, dr, er, ar, br, m[5], 1836072691, 7);
er = rotl(er, 10);
br = fn3(br, cr, dr, er, ar, m[1], 1836072691, 15);
dr = rotl(dr, 10);
ar = fn3(ar, br, cr, dr, er, m[3], 1836072691, 11);
cr = rotl(cr, 10);
er = fn3(er, ar, br, cr, dr, m[7], 1836072691, 8);
br = rotl(br, 10);
dr = fn3(dr, er, ar, br, cr, m[14], 1836072691, 6);
ar = rotl(ar, 10);
cr = fn3(cr, dr, er, ar, br, m[6], 1836072691, 6);
er = rotl(er, 10);
br = fn3(br, cr, dr, er, ar, m[9], 1836072691, 14);
dr = rotl(dr, 10);
ar = fn3(ar, br, cr, dr, er, m[11], 1836072691, 12);
cr = rotl(cr, 10);
er = fn3(er, ar, br, cr, dr, m[8], 1836072691, 13);
br = rotl(br, 10);
dr = fn3(dr, er, ar, br, cr, m[12], 1836072691, 5);
ar = rotl(ar, 10);
cr = fn3(cr, dr, er, ar, br, m[2], 1836072691, 14);
er = rotl(er, 10);
br = fn3(br, cr, dr, er, ar, m[10], 1836072691, 13);
dr = rotl(dr, 10);
ar = fn3(ar, br, cr, dr, er, m[0], 1836072691, 13);
cr = rotl(cr, 10);
er = fn3(er, ar, br, cr, dr, m[4], 1836072691, 7);
br = rotl(br, 10);
dr = fn3(dr, er, ar, br, cr, m[13], 1836072691, 5);
ar = rotl(ar, 10);
cr = fn2(cr, dr, er, ar, br, m[8], 2053994217, 15);
er = rotl(er, 10);
br = fn2(br, cr, dr, er, ar, m[6], 2053994217, 5);
dr = rotl(dr, 10);
ar = fn2(ar, br, cr, dr, er, m[4], 2053994217, 8);
cr = rotl(cr, 10);
er = fn2(er, ar, br, cr, dr, m[1], 2053994217, 11);
br = rotl(br, 10);
dr = fn2(dr, er, ar, br, cr, m[3], 2053994217, 14);
ar = rotl(ar, 10);
cr = fn2(cr, dr, er, ar, br, m[11], 2053994217, 14);
er = rotl(er, 10);
br = fn2(br, cr, dr, er, ar, m[15], 2053994217, 6);
dr = rotl(dr, 10);
ar = fn2(ar, br, cr, dr, er, m[0], 2053994217, 14);
cr = rotl(cr, 10);
er = fn2(er, ar, br, cr, dr, m[5], 2053994217, 6);
br = rotl(br, 10);
dr = fn2(dr, er, ar, br, cr, m[12], 2053994217, 9);
ar = rotl(ar, 10);
cr = fn2(cr, dr, er, ar, br, m[2], 2053994217, 12);
er = rotl(er, 10);
br = fn2(br, cr, dr, er, ar, m[13], 2053994217, 9);
dr = rotl(dr, 10);
ar = fn2(ar, br, cr, dr, er, m[9], 2053994217, 12);
cr = rotl(cr, 10);
er = fn2(er, ar, br, cr, dr, m[7], 2053994217, 5);
br = rotl(br, 10);
dr = fn2(dr, er, ar, br, cr, m[10], 2053994217, 15);
ar = rotl(ar, 10);
cr = fn2(cr, dr, er, ar, br, m[14], 2053994217, 8);
er = rotl(er, 10);
br = fn1(br, cr, dr, er, ar, m[12], 0, 8);
dr = rotl(dr, 10);
ar = fn1(ar, br, cr, dr, er, m[15], 0, 5);
cr = rotl(cr, 10);
er = fn1(er, ar, br, cr, dr, m[10], 0, 12);
br = rotl(br, 10);
dr = fn1(dr, er, ar, br, cr, m[4], 0, 9);
ar = rotl(ar, 10);
cr = fn1(cr, dr, er, ar, br, m[1], 0, 12);
er = rotl(er, 10);
br = fn1(br, cr, dr, er, ar, m[5], 0, 5);
dr = rotl(dr, 10);
ar = fn1(ar, br, cr, dr, er, m[8], 0, 14);
cr = rotl(cr, 10);
er = fn1(er, ar, br, cr, dr, m[7], 0, 6);
br = rotl(br, 10);
dr = fn1(dr, er, ar, br, cr, m[6], 0, 8);
ar = rotl(ar, 10);
cr = fn1(cr, dr, er, ar, br, m[2], 0, 13);
er = rotl(er, 10);
br = fn1(br, cr, dr, er, ar, m[13], 0, 6);
dr = rotl(dr, 10);
ar = fn1(ar, br, cr, dr, er, m[14], 0, 5);
cr = rotl(cr, 10);
er = fn1(er, ar, br, cr, dr, m[0], 0, 15);
br = rotl(br, 10);
dr = fn1(dr, er, ar, br, cr, m[3], 0, 13);
ar = rotl(ar, 10);
cr = fn1(cr, dr, er, ar, br, m[9], 0, 11);
er = rotl(er, 10);
br = fn1(br, cr, dr, er, ar, m[11], 0, 11);
dr = rotl(dr, 10);
var t = this._b + cl + dr | 0;
this._b = this._c + dl + er | 0;
this._c = this._d + el + ar | 0;
this._d = this._e + al + br | 0;
this._e = this._a + bl + cr | 0;
this._a = t;
};
RIPEMD160.prototype._digest = function() {
this._block[this._blockOffset++] = 128;
if (this._blockOffset > 56) {
this._block.fill(0, this._blockOffset, 64);
this._update();
this._blockOffset = 0;
}
this._block.fill(0, this._blockOffset, 56);
this._block.writeUInt32LE(this._length[0], 56);
this._block.writeUInt32LE(this._length[1], 60);
this._update();
var buffer = new Buffer$1(20);
buffer.writeInt32LE(this._a, 0);
buffer.writeInt32LE(this._b, 4);
buffer.writeInt32LE(this._c, 8);
buffer.writeInt32LE(this._d, 12);
buffer.writeInt32LE(this._e, 16);
return buffer;
};
function rotl(x, n) {
return x << n | x >>> 32 - n;
}
function fn1(a, b, c, d, e, m, k, s) {
return rotl(a + (b ^ c ^ d) + m + k | 0, s) + e | 0;
}
function fn2(a, b, c, d, e, m, k, s) {
return rotl(a + (b & c | ~b & d) + m + k | 0, s) + e | 0;
}
function fn3(a, b, c, d, e, m, k, s) {
return rotl(a + ((b | ~c) ^ d) + m + k | 0, s) + e | 0;
}
function fn4(a, b, c, d, e, m, k, s) {
return rotl(a + (b & d | c & ~d) + m + k | 0, s) + e | 0;
}
function fn5(a, b, c, d, e, m, k, s) {
return rotl(a + (b ^ (c | ~d)) + m + k | 0, s) + e | 0;
}
module.exports = RIPEMD160;
}));
//#endregion
//#region node_modules/pbkdf2/lib/to-buffer.js
var require_to_buffer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var Buffer = require_safe_buffer$4().Buffer;
var toBuffer = require_to_buffer$1();
var useUint8Array = typeof Uint8Array !== "undefined";
var isView = useUint8Array && typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView;
module.exports = function(thing, encoding, name) {
if (typeof thing === "string" || Buffer.isBuffer(thing) || useUint8Array && thing instanceof Uint8Array || isView && isView(thing)) return toBuffer(thing, encoding);
throw new TypeError(name + " must be a string, a Buffer, a Uint8Array, or a DataView");
};
}));
//#endregion
//#region node_modules/pbkdf2/lib/sync-browser.js
var require_sync_browser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var md5 = require_md5$1();
var RIPEMD160 = require_ripemd160();
var sha = require_sha_js();
var Buffer = require_safe_buffer$4().Buffer;
var checkParameters = require_precondition();
var defaultEncoding = require_default_encoding();
var toBuffer = require_to_buffer();
var ZEROS = Buffer.alloc(128);
var sizes = {
__proto__: null,
md5: 16,
sha1: 20,
sha224: 28,
sha256: 32,
sha384: 48,
sha512: 64,
"sha512-256": 32,
ripemd160: 20,
rmd160: 20
};
var mapping = {
__proto__: null,
"sha-1": "sha1",
"sha-224": "sha224",
"sha-256": "sha256",
"sha-384": "sha384",
"sha-512": "sha512",
"ripemd-160": "ripemd160"
};
function rmd160Func(data) {
return new RIPEMD160().update(data).digest();
}
function getDigest(alg) {
function shaFunc(data) {
return sha(alg).update(data).digest();
}
if (alg === "rmd160" || alg === "ripemd160") return rmd160Func;
if (alg === "md5") return md5;
return shaFunc;
}
function Hmac(alg, key, saltLen) {
var hash = getDigest(alg);
var blocksize = alg === "sha512" || alg === "sha384" ? 128 : 64;
if (key.length > blocksize) key = hash(key);
else if (key.length < blocksize) key = Buffer.concat([key, ZEROS], blocksize);
var ipad = Buffer.allocUnsafe(blocksize + sizes[alg]);
var opad = Buffer.allocUnsafe(blocksize + sizes[alg]);
for (var i = 0; i < blocksize; i++) {
ipad[i] = key[i] ^ 54;
opad[i] = key[i] ^ 92;
}
var ipad1 = Buffer.allocUnsafe(blocksize + saltLen + 4);
ipad.copy(ipad1, 0, 0, blocksize);
this.ipad1 = ipad1;
this.ipad2 = ipad;
this.opad = opad;
this.alg = alg;
this.blocksize = blocksize;
this.hash = hash;
this.size = sizes[alg];
}
Hmac.prototype.run = function(data, ipad) {
data.copy(ipad, this.blocksize);
this.hash(ipad).copy(this.opad, this.blocksize);
return this.hash(this.opad);
};
function pbkdf2(password, salt, iterations, keylen, digest) {
checkParameters(iterations, keylen);
password = toBuffer(password, defaultEncoding, "Password");
salt = toBuffer(salt, defaultEncoding, "Salt");
var lowerDigest = (digest || "sha1").toLowerCase();
var mappedDigest = mapping[lowerDigest] || lowerDigest;
var size = sizes[mappedDigest];
if (typeof size !== "number" || !size) throw new TypeError("Digest algorithm not supported: " + digest);
var hmac = new Hmac(mappedDigest, password, salt.length);
var DK = Buffer.allocUnsafe(keylen);
var block1 = Buffer.allocUnsafe(salt.length + 4);
salt.copy(block1, 0, 0, salt.length);
var destPos = 0;
var hLen = size;
var l = Math.ceil(keylen / hLen);
for (var i = 1; i <= l; i++) {
block1.writeUInt32BE(i, salt.length);
var T = hmac.run(block1, hmac.ipad1);
var U = T;
for (var j = 1; j < iterations; j++) {
U = hmac.run(U, hmac.ipad2);
for (var k = 0; k < hLen; k++) T[k] ^= U[k];
}
T.copy(DK, destPos);
destPos += hLen;
}
return DK;
}
module.exports = pbkdf2;
}));
//#endregion
//#region node_modules/pbkdf2/lib/async.js
var require_async = /* @__PURE__ */ __commonJSMin(((exports, module) => {
init_dist();
var Buffer = require_safe_buffer$4().Buffer;
var checkParameters = require_precondition();
var defaultEncoding = require_default_encoding();
var sync = require_sync_browser();
var toBuffer = require_to_buffer();
var ZERO_BUF;
var subtle = global.crypto && global.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 = [];
var nextTick;
function getNextTick() {
if (nextTick) return nextTick;
if (global.process && global.process.nextTick) nextTick = global.process.nextTick;
else if (global.queueMicrotask) nextTick = global.queueMicrotask;
else if (global.setImmediate) nextTick = global.setImmediate;
else nextTick = global.setTimeout;
return nextTick;
}
function browserPbkdf2(password, salt, iterations, length, algo) {
return subtle.importKey("raw", password, { name: "PBKDF2" }, false, ["deriveBits"]).then(function(key) {
return subtle.deriveBits({
name: "PBKDF2",
salt,
iterations,
hash: { name: algo }
}, key, length << 3);
}).then(function(res) {
return Buffer.from(res);
});
}
function checkNative(algo) {
if (global.process && !global.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.alloc(8);
var prom = browserPbkdf2(ZERO_BUF, ZERO_BUF, 10, 128, algo).then(function() {
return true;
}, function() {
return false;
});
checks[algo] = prom;
return prom;
}
function resolvePromise(promise, callback) {
promise.then(function(out) {
getNextTick()(function() {
callback(null, out);
});
}, function(e) {
getNextTick()(function() {
callback(e);
});
});
}
module.exports = function(password, salt, iterations, keylen, digest, callback) {
if (typeof digest === "function") {
callback = digest;
digest = void 0;
}
digest = digest || "sha1";
var algo = toBrowser[digest.toLowerCase()];
if (!algo || typeof global.Promise !== "function") {
getNextTick()(function() {
var out;
try {
out = sync(password, salt, iterations, keylen, digest);
} catch (e) {
callback(e);
return;
}
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, digest);
}), callback);
};
}));
//#endregion
//#region node_modules/pbkdf2/browser.js
var require_browser$8 = /* @__PURE__ */ __commonJSMin(((exports) => {
exports.pbkdf2 = require_async();
exports.pbkdf2Sync = require_sync_browser();
}));
//#endregion
//#region node_modules/des.js/lib/des/utils.js
var require_utils$3 = /* @__PURE__ */ __commonJSMin(((exports) => {
exports.readUInt32BE = function readUInt32BE(bytes, off) {
return (bytes[0 + off] << 24 | bytes[1 + off] << 16 | bytes[2 + off] << 8 | bytes[3 + off]) >>> 0;
};
exports.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;
};
exports.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;
};
exports.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;
};
exports.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;
};
exports.r28shl = function r28shl(num, shift) {
return num << shift & 268435455 | num >>> 28 - shift;
};
var pc2table = [
14,
11,
17,
4,
27,
23,
25,
0,
13,
22,
7,
18,
5,
9,
16,
24,
2,
20,
12,
21,
1,
8,
15,
26,
15,
4,
25,
19,
9,
1,
26,
16,
5,
11,
23,
8,
12,
7,
17,
0,
22,
3,
10,
14,
6,
20,
27,
24
];
exports.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;
};
exports.expand = function expand(r, out, off) {
var outL = 0;
var outR = 0;
outL = (r & 1) << 5 | r >>> 27;
for (var i = 23; i >= 15; i -= 4) {
outL <<= 6;
outL |= r >>> i & 63;
}
for (var i = 11; i >= 3; i -= 4) {
outR |= r >>> i & 63;
outR <<= 6;
}
outR |= (r & 31) << 1 | r >>> 31;
out[off + 0] = outL >>> 0;
out[off + 1] = outR >>> 0;
};
var sTable = [
14,
0,
4,
15,
13,
7,
1,
4,
2,
14,
15,
2,
11,
13,
8,
1,
3,
10,
10,
6,
6,
12,
12,
11,
5,
9,
9,
5,
0,
3,
7,
8,
4,
15,
1,
12,
14,
8,
8,
2,
13,
4,
6,
9,
2,
1,
11,
7,
15,
5,
12,
11,
9,
3,
7,
14,
3,
10,
10,
0,
5,
6,
0,
13,
15,
3,
1,
13,
8,
4,
14,
7,
6,
15,
11,
2,
3,
8,
4,
14,
9,
12,
7,
0,
2,
1,
13,
10,
12,
6,
0,
9,
5,
11,
10,
5,
0,
13,
14,
8,
7,
10,
11,
1,
10,
3,
4,
15,
13,
4,
1,
2,
5,
11,
8,
6,
12,
7,
6,
12,
9,
0,
3,
5,
2,
14,
15,
9,
10,
13,
0,
7,
9,
0,
14,
9,
6,
3,
3,
4,
15,
6,
5,
10,
1,
2,
13,
8,
12,
5,
7,
14,
11,
12,
4,
11,
2,
15,
8,
1,
13,
1,
6,
10,
4,
13,
9,
0,
8,
6,
15,
9,
3,
8,
0,
7,
11,
4,
1,
15,
2,
14,
12,
3,
5,
11,
10,
5,
14,
2,
7,
12,
7,
13,
13,
8,
14,
11,
3,
5,
0,
6,
6,
15,
9,
0,
10,
3,
1,
4,
2,
7,
8,
2,
5,
12,
11,
1,
12,
10,
4,
14,
15,
9,
10,
3,
6,
15,
9,
0,
0,
6,
12,
10,
11,
1,
7,
13,
13,
8,
15,
9,
1,
4,
3,
5,
14,
11,
5,
12,
2,
7,
8,
2,
4,
14,
2,
14,
12,
11,
4,
2,
1,
12,
7,
4,
10,
7,
11,
13,
6,
1,
8,
5,
5,
0,
3,
15,
15,
10,
13,
3,
0,
9,
14,
8,
9,
6,
4,
11,
2,
8,
1,
12,
11,
7,
10,
1,
13,
14,
7,
2,
8,
13,
15,
6,
9,
15,
12,
0,
5,
9,
6,
10,
3,
4,
0,
5,
14,
3,
12,
10,
1,
15,
10,
4,
15,
2,
9,
7,
2,
12,
6,
9,
8,
5,
0,
6,
13,
1,
3,
13,
4,
14,
14,
0,
7,
11,
5,
3,
11,
8,
9,
4,
14,
3,
15,
2,
5,
12,
2,
9,
8,
5,
12,
15,
3,
10,
7,
11,
0,
14,
4,
1,
10,
7,
1,
6,
13,
0,
11,
8,
6,
13,
4,
13,
11,
0,
2,
11,
14,
7,
15,
4,
0,
9,
8,
1,
13,
10,
3,
14,
12,
3,
9,
5,
7,
12,
5,
2,
10,
15,
6,
8,
1,
6,
1,
6,
4,
11,
11,
13,
13,
8,
12,
1,
3,
4,
7,
10,
14,
7,
10,
9,
15,
5,
6,
0,
8,
15,
0,
14,
5,
2,
9,
3,
2,
12,
13,
1,
2,
15,
8,
13,
4,
8,
6,
10,
15,
3,
11,
7,
1,
4,
10,
12,
9,
5,
3,
6,
14,
11,
5,
0,
0,
14,
12,
9,
7,
2,
7,
2,
11,
1,
4,
14,
1,
7,
9,
4,
12,
10,
14,
8,
2,
13,
0,
15,
6,
12,
10,
9,
13,
0,
15,
3,
3,
5,
5,
6,
8,
11
];
exports.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[256 + 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
];
exports.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;
};
exports.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(" ");
};
}));
//#endregion
//#region node_modules/minimalistic-assert/index.js
var require_minimalistic_assert = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = assert;
function assert(val, msg) {
if (!val) throw new Error(msg || "Assertion failed");
}
assert.equal = function assertEqual(l, r, msg) {
if (l != r) throw new Error(msg || "Assertion failed: " + l + " != " + r);
};
}));
//#endregion
//#region node_modules/des.js/lib/des/cipher.js
var require_cipher = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var assert = require_minimalistic_assert();
function Cipher(options) {
this.options = options;
this.type = this.options.type;
this.blockSize = 8;
this._init();
this.buffer = new Array(this.blockSize);
this.bufferOff = 0;
this.padding = options.padding !== false;
}
module.exports = Cipher;
Cipher.prototype._init = function _init() {};
Cipher.prototype.update = function update(data) {
if (data.length === 0) return [];
if (this.type === "decrypt") return this._updateDecrypt(data);
else return this._updateEncrypt(data);
};
Cipher.prototype._buffer = function _buffer(data, off) {
var min = Math.min(this.buffer.length - this.bufferOff, data.length - off);
for (var i = 0; i < min; i++) this.buffer[this.bufferOff + i] = data[off + i];
this.bufferOff += min;
return min;
};
Cipher.prototype._flushBuffer = function _flushBuffer(out, off) {
this._update(this.buffer, 0, out, off);
this.bufferOff = 0;
return this.blockSize;
};
Cipher.prototype._updateEncrypt = function _updateEncrypt(data) {
var inputOff = 0;
var outputOff = 0;
var count = (this.bufferOff + data.length) / this.blockSize | 0;
var out = new Array(count * this.blockSize);
if (this.bufferOff !== 0) {
inputOff += this._buffer(data, inputOff);
if (this.bufferOff === this.buffer.length) outputOff += this._flushBuffer(out, outputOff);
}
var max = data.length - (data.length - inputOff) % this.blockSize;
for (; inputOff < max; inputOff += this.blockSize) {
this._update(data, inputOff, out, outputOff);
outputOff += this.blockSize;
}
for (; inputOff < data.length; inputOff++, this.bufferOff++) this.buffer[this.bufferOff] = data[inputOff];
return out;
};
Cipher.prototype._updateDecrypt = function _updateDecrypt(data) {
var inputOff = 0;
var outputOff = 0;
var count = Math.ceil((this.bufferOff + data.length) / this.blockSize) - 1;
var out = new Array(count * this.blockSize);
for (; count > 0; count--) {
inputOff += this._buffer(data, inputOff);
outputOff += this._flushBuffer(out, outputOff);
}
inputOff += this._buffer(data, inputOff);
return out;
};
Cipher.prototype.final = function final(buffer) {
var first;
if (buffer) first = this.update(buffer);
var last;
if (this.type === "encrypt") last = this._finalEncrypt();
else last = this._finalDecrypt();
if (first) return first.concat(last);
else return last;
};
Cipher.prototype._pad = function _pad(buffer, off) {
if (off === 0) return false;
while (off < buffer.length) buffer[off++] = 0;
return true;
};
Cipher.prototype._finalEncrypt = function _finalEncrypt() {
if (!this._pad(this.buffer, this.bufferOff)) return [];
var out = new Array(this.blockSize);
this._update(this.buffer, 0, out, 0);
return out;
};
Cipher.prototype._unpad = function _unpad(buffer) {
return buffer;
};
Cipher.prototype._finalDecrypt = function _finalDecrypt() {
assert.equal(this.bufferOff, this.blockSize, "Not enough data to decrypt");
var out = new Array(this.blockSize);
this._flushBuffer(out, 0);
return this._unpad(out);
};
}));
//#endregion
//#region node_modules/des.js/lib/des/des.js
var require_des$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var assert = require_minimalistic_assert();
var inherits = require_inherits_browser();
var utils = require_utils$3();
var Cipher = require_cipher();
function DESState() {
this.tmp = new Array(2);
this.keys = null;
}
function DES(options) {
Cipher.call(this, options);
var state = new DESState();
this._desState = state;
this.deriveKeys(state, options.key);
}
inherits(DES, Cipher);
module.exports = DES;
DES.create = function create(options) {
return new DES(options);
};
var shiftTable = [
1,
1,
2,
2,
2,
2,
2,
2,
1,
2,
2,
2,
2,
2,
2,
1
];
DES.prototype.deriveKeys = function deriveKeys(state, key) {
state.keys = new Array(32);
assert.equal(key.length, this.blockSize, "Invalid key length");
var kL = utils.readUInt32BE(key, 0);
var kR = utils.readUInt32BE(key, 4);
utils.pc1(kL, kR, state.tmp, 0);
kL = state.tmp[0];
kR = state.tmp[1];
for (var i = 0; i < state.keys.length; i += 2) {
var shift = shiftTable[i >>> 1];
kL = utils.r28shl(kL, shift);
kR = utils.r28shl(kR, shift);
utils.pc2(kL, kR, state.keys, i);
}
};
DES.prototype._update = function _update(inp, inOff, out, outOff) {
var state = this._desState;
var l = utils.readUInt32BE(inp, inOff);
var r = utils.readUInt32BE(inp, inOff + 4);
utils.ip(l, r, state.tmp, 0);
l = state.tmp[0];
r = state.tmp[1];
if (this.type === "encrypt") this._encrypt(state, l, r, state.tmp, 0);
else this._decrypt(state, l, r, state.tmp, 0);
l = state.tmp[0];
r = state.tmp[1];
utils.writeUInt32BE(out, l, outOff);
utils.writeUInt32BE(out, r, outOff + 4);
};
DES.prototype._pad = function _pad(buffer, off) {
if (this.padding === false) return false;
var value = buffer.length - off;
for (var i = off; i < buffer.length; i++) buffer[i] = value;
return true;
};
DES.prototype._unpad = function _unpad(buffer) {
if (this.padding === false) return buffer;
var pad = buffer[buffer.length - 1];
for (var i = buffer.length - pad; i < buffer.length; i++) assert.equal(buffer[i], pad);
return buffer.slice(0, buffer.length - pad);
};
DES.prototype._encrypt = function _encrypt(state, lStart, rStart, out, off) {
var l = lStart;
var r = rStart;
for (var i = 0; i < state.keys.length; i += 2) {
var keyL = state.keys[i];
var keyR = state.keys[i + 1];
utils.expand(r, state.tmp, 0);
keyL ^= state.tmp[0];
keyR ^= state.tmp[1];
var s = utils.substitute(keyL, keyR);
var f = utils.permute(s);
var t = r;
r = (l ^ f) >>> 0;
l = t;
}
utils.rip(r, l, out, off);
};
DES.prototype._decrypt = function _decrypt(state, lStart, rStart, out, off) {
var l = rStart;
var r = lStart;
for (var i = state.keys.length - 2; i >= 0; i -= 2) {
var keyL = state.keys[i];
var keyR = state.keys[i + 1];
utils.expand(l, state.tmp, 0);
keyL ^= state.tmp[0];
keyR ^= state.tmp[1];
var s = utils.substitute(keyL, keyR);
var f = utils.permute(s);
var t = l;
l = (r ^ f) >>> 0;
r = t;
}
utils.rip(l, r, out, off);
};
}));
//#endregion
//#region node_modules/des.js/lib/des/cbc.js
var require_cbc$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
var assert = require_minimalistic_assert();
var inherits = require_inherits_browser();
var proto = {};
function CBCState(iv) {
assert.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(Base) {
function CBC(options) {
Base.call(this, options);
this._cbcInit();
}
inherits(CBC, Base);
var keys = Object.keys(proto);
for (var i = 0; i < keys.length; i++) {
var key = keys[i];
CBC.prototype[key] = proto[key];
}
CBC.create = function create(options) {
return new CBC(options);
};
return CBC;
}
exports.instantiate = instantiate;
proto._cbcInit = function _cbcInit() {
var state = new CBCState(this.options.iv);
this._cbcState = state;
};
proto._update = function _update(inp, inOff, out, outOff) {
var state = this._cbcState;
var superProto = this.constructor.super_.prototype;
var iv = state.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];
}
};
}));
//#endregion
//#region node_modules/des.js/lib/des/ede.js
var require_ede = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var assert = require_minimalistic_assert();
var inherits = require_inherits_browser();
var Cipher = require_cipher();
var DES = require_des$1();
function EDEState(type, key) {
assert.equal(key.length, 24, "Invalid key length");
var k1 = key.slice(0, 8);
var k2 = key.slice(8, 16);
var k3 = key.slice(16, 24);
if (type === "encrypt") this.ciphers = [
DES.create({
type: "encrypt",
key: k1
}),
DES.create({
type: "decrypt",
key: k2
}),
DES.create({
type: "encrypt",
key: k3
})
];
else this.ciphers = [
DES.create({
type: "decrypt",
key: k3
}),
DES.create({
type: "encrypt",
key: k2
}),
DES.create({
type: "decrypt",
key: k1
})
];
}
function EDE(options) {
Cipher.call(this, options);
var state = new EDEState(this.type, this.options.key);
this._edeState = state;
}
inherits(EDE, Cipher);
module.exports = EDE;
EDE.create = function create(options) {
return new EDE(options);
};
EDE.prototype._update = function _update(inp, inOff, out, outOff) {
var state = this._edeState;
state.ciphers[0]._update(inp, inOff, out, outOff);
state.ciphers[1]._update(out, outOff, out, outOff);
state.ciphers[2]._update(out, outOff, out, outOff);
};
EDE.prototype._pad = DES.prototype._pad;
EDE.prototype._unpad = DES.prototype._unpad;
}));
//#endregion
//#region node_modules/des.js/lib/des.js
var require_des = /* @__PURE__ */ __commonJSMin(((exports) => {
exports.utils = require_utils$3();
exports.Cipher = require_cipher();
exports.DES = require_des$1();
exports.CBC = require_cbc$1();
exports.EDE = require_ede();
}));
//#endregion
//#region node_modules/browserify-des/index.js
var require_browserify_des = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var CipherBase = require_cipher_base();
var des = require_des();
var inherits = require_inherits_browser();
var Buffer = require_safe_buffer$9().Buffer;
var modes = {
"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.des = modes["des-cbc"];
modes.des3 = modes["des-ede3-cbc"];
module.exports = DES;
inherits(DES, CipherBase);
function DES(opts) {
CipherBase.call(this);
var modeName = opts.mode.toLowerCase();
var mode = modes[modeName];
var type;
if (opts.decrypt) type = "decrypt";
else type = "encrypt";
var key = opts.key;
if (!Buffer.isBuffer(key)) key = Buffer.from(key);
if (modeName === "des-ede" || modeName === "des-ede-cbc") key = Buffer.concat([key, key.slice(0, 8)]);
var iv = opts.iv;
if (!Buffer.isBuffer(iv)) iv = Buffer.from(iv);
this._des = mode.create({
key,
iv,
type
});
}
DES.prototype._update = function(data) {
return Buffer.from(this._des.update(data));
};
DES.prototype._final = function() {
return Buffer.from(this._des.final());
};
}));
//#endregion
//#region node_modules/browserify-aes/modes/ecb.js
var require_ecb = /* @__PURE__ */ __commonJSMin(((exports) => {
exports.encrypt = function(self, block) {
return self._cipher.encryptBlock(block);
};
exports.decrypt = function(self, block) {
return self._cipher.decryptBlock(block);
};
}));
//#endregion
//#region node_modules/buffer-xor/index.js
var require_buffer_xor = /* @__PURE__ */ __commonJSMin(((exports, module) => {
init_dist$1();
module.exports = function xor(a, b) {
var length = Math.min(a.length, b.length);
var buffer = new Buffer$1(length);
for (var i = 0; i < length; ++i) buffer[i] = a[i] ^ b[i];
return buffer;
};
}));
//#endregion
//#region node_modules/browserify-aes/modes/cbc.js
var require_cbc = /* @__PURE__ */ __commonJSMin(((exports) => {
var xor = require_buffer_xor();
exports.encrypt = function(self, block) {
var data = xor(block, self._prev);
self._prev = self._cipher.encryptBlock(data);
return self._prev;
};
exports.decrypt = function(self, block) {
var pad = self._prev;
self._prev = block;
return xor(self._cipher.decryptBlock(block), pad);
};
}));
//#endregion
//#region node_modules/browserify-aes/modes/cfb.js
var require_cfb = /* @__PURE__ */ __commonJSMin(((exports) => {
var Buffer = require_safe_buffer$9().Buffer;
var xor = require_buffer_xor();
function encryptStart(self, data, decrypt) {
var len = data.length;
var out = xor(data, self._cache);
self._cache = self._cache.slice(len);
self._prev = Buffer.concat([self._prev, decrypt ? data : out]);
return out;
}
exports.encrypt = function(self, data, decrypt) {
var out = Buffer.allocUnsafe(0);
var len;
while (data.length) {
if (self._cache.length === 0) {
self._cache = self._cipher.encryptBlock(self._prev);
self._prev = Buffer.allocUnsafe(0);
}
if (self._cache.length <= data.length) {
len = self._cache.length;
out = Buffer.concat([out, encryptStart(self, data.slice(0, len), decrypt)]);
data = data.slice(len);
} else {
out = Buffer.concat([out, encryptStart(self, data, decrypt)]);
break;
}
}
return out;
};
}));
//#endregion
//#region node_modules/browserify-aes/modes/cfb8.js
var require_cfb8 = /* @__PURE__ */ __commonJSMin(((exports) => {
var Buffer = require_safe_buffer$9().Buffer;
function encryptByte(self, byteParam, decrypt) {
var out = self._cipher.encryptBlock(self._prev)[0] ^ byteParam;
self._prev = Buffer.concat([self._prev.slice(1), Buffer.from([decrypt ? byteParam : out])]);
return out;
}
exports.encrypt = function(self, chunk, decrypt) {
var len = chunk.length;
var out = Buffer.allocUnsafe(len);
var i = -1;
while (++i < len) out[i] = encryptByte(self, chunk[i], decrypt);
return out;
};
}));
//#endregion
//#region node_modules/browserify-aes/modes/cfb1.js
var require_cfb1 = /* @__PURE__ */ __commonJSMin(((exports) => {
var Buffer = require_safe_buffer$9().Buffer;
function encryptByte(self, byteParam, decrypt) {
var pad;
var i = -1;
var len = 8;
var out = 0;
var bit, value;
while (++i < len) {
pad = self._cipher.encryptBlock(self._prev);
bit = byteParam & 1 << 7 - i ? 128 : 0;
value = pad[0] ^ bit;
out += (value & 128) >> i % 8;
self._prev = shiftIn(self._prev, decrypt ? bit : value);
}
return out;
}
function shiftIn(buffer, value) {
var len = buffer.length;
var i = -1;
var out = Buffer.allocUnsafe(buffer.length);
buffer = Buffer.concat([buffer, Buffer.from([value])]);
while (++i < len) out[i] = buffer[i] << 1 | buffer[i + 1] >> 7;
return out;
}
exports.encrypt = function(self, chunk, decrypt) {
var len = chunk.length;
var out = Buffer.allocUnsafe(len);
var i = -1;
while (++i < len) out[i] = encryptByte(self, chunk[i], decrypt);
return out;
};
}));
//#endregion
//#region node_modules/browserify-aes/modes/ofb.js
var require_ofb = /* @__PURE__ */ __commonJSMin(((exports) => {
init_dist$1();
var xor = require_buffer_xor();
function getBlock(self) {
self._prev = self._cipher.encryptBlock(self._prev);
return self._prev;
}
exports.encrypt = function(self, chunk) {
while (self._cache.length < chunk.length) self._cache = Buffer$1.concat([self._cache, getBlock(self)]);
var pad = self._cache.slice(0, chunk.length);
self._cache = self._cache.slice(chunk.length);
return xor(chunk, pad);
};
}));
//#endregion
//#region node_modules/browserify-aes/incr32.js
var require_incr32 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
function incr32(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;
}
}
}
module.exports = incr32;
}));
//#endregion
//#region node_modules/browserify-aes/modes/ctr.js
var require_ctr = /* @__PURE__ */ __commonJSMin(((exports) => {
var xor = require_buffer_xor();
var Buffer = require_safe_buffer$9().Buffer;
var incr32 = require_incr32();
function getBlock(self) {
var out = self._cipher.encryptBlockRaw(self._prev);
incr32(self._prev);
return out;
}
var blockSize = 16;
exports.encrypt = function(self, chunk) {
var chunkNum = Math.ceil(chunk.length / blockSize);
var start = self._cache.length;
self._cache = Buffer.concat([self._cache, Buffer.allocUnsafe(chunkNum * blockSize)]);
for (var i = 0; i < chunkNum; i++) {
var out = getBlock(self);
var offset = start + i * blockSize;
self._cache.writeUInt32BE(out[0], offset + 0);
self._cache.writeUInt32BE(out[1], offset + 4);
self._cache.writeUInt32BE(out[2], offset + 8);
self._cache.writeUInt32BE(out[3], offset + 12);
}
var pad = self._cache.slice(0, chunk.length);
self._cache = self._cache.slice(chunk.length);
return xor(chunk, pad);
};
}));
//#endregion
//#region node_modules/browserify-aes/modes/list.json
var list_exports = /* @__PURE__ */ __exportAll({
aes128: () => aes128,
aes192: () => aes192,
aes256: () => aes256,
default: () => list_default
});
var aes128, aes192, aes256, list_default;
var init_list = __esmMin((() => {
aes128 = {
"cipher": "AES",
"key": 128,
"iv": 16,
"mode": "CBC",
"type": "block"
};
aes192 = {
"cipher": "AES",
"key": 192,
"iv": 16,
"mode": "CBC",
"type": "block"
};
aes256 = {
"cipher": "AES",
"key": 256,
"iv": 16,
"mode": "CBC",
"type": "block"
};
list_default = {
"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"
}
};
}));
//#endregion
//#region node_modules/browserify-aes/modes/index.js
var require_modes$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var modeModules = {
ECB: require_ecb(),
CBC: require_cbc(),
CFB: require_cfb(),
CFB8: require_cfb8(),
CFB1: require_cfb1(),
OFB: require_ofb(),
CTR: require_ctr(),
GCM: require_ctr()
};
var modes = (init_list(), __toCommonJS(list_exports).default);
for (var key in modes) modes[key].module = modeModules[modes[key].mode];
module.exports = modes;
}));
//#endregion
//#region node_modules/browserify-aes/aes.js
var require_aes$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var Buffer = require_safe_buffer$9().Buffer;
function asUInt32Array(buf) {
if (!Buffer.isBuffer(buf)) buf = Buffer.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(key) {
this._key = asUInt32Array(key);
this._reset();
}
AES.blockSize = 16;
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.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.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);
};
module.exports.AES = AES;
}));
//#endregion
//#region node_modules/browserify-aes/ghash.js
var require_ghash = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var Buffer = require_safe_buffer$9().Buffer;
var ZEROES = Buffer.alloc(16, 0);
function toArray(buf) {
return [
buf.readUInt32BE(0),
buf.readUInt32BE(4),
buf.readUInt32BE(8),
buf.readUInt32BE(12)
];
}
function fromArray(out) {
var buf = Buffer.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(key) {
this.h = key;
this.state = Buffer.alloc(16, 0);
this.cache = Buffer.allocUnsafe(0);
}
GHASH.prototype.ghash = function(block) {
var i = -1;
while (++i < block.length) this.state[i] ^= block[i];
this._multiply();
};
GHASH.prototype._multiply = function() {
var Vi = toArray(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.prototype.update = function(buf) {
this.cache = Buffer.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.prototype.final = function(abl, bl) {
if (this.cache.length) this.ghash(Buffer.concat([this.cache, ZEROES], 16));
this.ghash(fromArray([
0,
abl,
0,
bl
]));
return this.state;
};
module.exports = GHASH;
}));
//#endregion
//#region node_modules/browserify-aes/authCipher.js
var require_authCipher = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var aes = require_aes$1();
var Buffer = require_safe_buffer$9().Buffer;
var Transform = require_cipher_base();
var inherits = require_inherits_browser();
var GHASH = require_ghash();
var xor = require_buffer_xor();
var incr32 = require_incr32();
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(self, iv, ck) {
if (iv.length === 12) {
self._finID = Buffer.concat([iv, Buffer.from([
0,
0,
0,
1
])]);
return Buffer.concat([iv, Buffer.from([
0,
0,
0,
2
])]);
}
var ghash = new GHASH(ck);
var len = iv.length;
var toPad = len % 16;
ghash.update(iv);
if (toPad) {
toPad = 16 - toPad;
ghash.update(Buffer.alloc(toPad, 0));
}
ghash.update(Buffer.alloc(8, 0));
var ivBits = len * 8;
var tail = Buffer.alloc(8);
tail.writeUIntBE(ivBits, 0, 8);
ghash.update(tail);
self._finID = ghash.state;
var out = Buffer.from(self._finID);
incr32(out);
return out;
}
function StreamCipher(mode, key, iv, decrypt) {
Transform.call(this);
var h = Buffer.alloc(4, 0);
this._cipher = new aes.AES(key);
var ck = this._cipher.encryptBlock(h);
this._ghash = new GHASH(ck);
iv = calcIv(this, iv, ck);
this._prev = Buffer.from(iv);
this._cache = Buffer.allocUnsafe(0);
this._secCache = Buffer.allocUnsafe(0);
this._decrypt = decrypt;
this._alen = 0;
this._len = 0;
this._mode = mode;
this._authTag = null;
this._called = false;
}
inherits(StreamCipher, Transform);
StreamCipher.prototype._update = function(chunk) {
if (!this._called && this._alen) {
var rump = 16 - this._alen % 16;
if (rump < 16) {
rump = Buffer.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.prototype._final = function() {
if (this._decrypt && !this._authTag) throw new Error("Unsupported state or unable to authenticate data");
var tag = xor(this._ghash.final(this._alen * 8, this._len * 8), this._cipher.encryptBlock(this._finID));
if (this._decrypt && xorTest(tag, this._authTag)) throw new Error("Unsupported state or unable to authenticate data");
this._authTag = tag;
this._cipher.scrub();
};
StreamCipher.prototype.getAuthTag = function getAuthTag() {
if (this._decrypt || !Buffer.isBuffer(this._authTag)) throw new Error("Attempting to get auth tag in unsupported state");
return this._authTag;
};
StreamCipher.prototype.setAuthTag = function setAuthTag(tag) {
if (!this._decrypt) throw new Error("Attempting to set auth tag in unsupported state");
this._authTag = tag;
};
StreamCipher.prototype.setAAD = function setAAD(buf) {
if (this._called) throw new Error("Attempting to set AAD in unsupported state");
this._ghash.update(buf);
this._alen += buf.length;
};
module.exports = StreamCipher;
}));
//#endregion
//#region node_modules/browserify-aes/streamCipher.js
var require_streamCipher = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var aes = require_aes$1();
var Buffer = require_safe_buffer$9().Buffer;
var Transform = require_cipher_base();
var inherits = require_inherits_browser();
function StreamCipher(mode, key, iv, decrypt) {
Transform.call(this);
this._cipher = new aes.AES(key);
this._prev = Buffer.from(iv);
this._cache = Buffer.allocUnsafe(0);
this._secCache = Buffer.allocUnsafe(0);
this._decrypt = decrypt;
this._mode = mode;
}
inherits(StreamCipher, Transform);
StreamCipher.prototype._update = function(chunk) {
return this._mode.encrypt(this, chunk, this._decrypt);
};
StreamCipher.prototype._final = function() {
this._cipher.scrub();
};
module.exports = StreamCipher;
}));
//#endregion
//#region node_modules/evp_bytestokey/index.js
var require_evp_bytestokey = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var Buffer = require_safe_buffer$9().Buffer;
var MD5 = require_md5_js();
function EVP_BytesToKey(password, salt, keyBits, ivLen) {
if (!Buffer.isBuffer(password)) password = Buffer.from(password, "binary");
if (salt) {
if (!Buffer.isBuffer(salt)) salt = Buffer.from(salt, "binary");
if (salt.length !== 8) throw new RangeError("salt should be Buffer with 8 byte length");
}
var keyLen = keyBits / 8;
var key = Buffer.alloc(keyLen);
var iv = Buffer.alloc(ivLen || 0);
var tmp = Buffer.alloc(0);
while (keyLen > 0 || ivLen > 0) {
var hash = new MD5();
hash.update(tmp);
hash.update(password);
if (salt) hash.update(salt);
tmp = hash.digest();
var used = 0;
if (keyLen > 0) {
var keyStart = key.length - keyLen;
used = Math.min(keyLen, tmp.length);
tmp.copy(key, 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,
iv
};
}
module.exports = EVP_BytesToKey;
}));
//#endregion
//#region node_modules/browserify-aes/encrypter.js
var require_encrypter = /* @__PURE__ */ __commonJSMin(((exports) => {
var MODES = require_modes$1();
var AuthCipher = require_authCipher();
var Buffer = require_safe_buffer$9().Buffer;
var StreamCipher = require_streamCipher();
var Transform = require_cipher_base();
var aes = require_aes$1();
var ebtk = require_evp_bytestokey();
var inherits = require_inherits_browser();
function Cipher(mode, key, iv) {
Transform.call(this);
this._cache = new Splitter();
this._cipher = new aes.AES(key);
this._prev = Buffer.from(iv);
this._mode = mode;
this._autopadding = true;
}
inherits(Cipher, Transform);
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.concat(out);
};
var PADDING = Buffer.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() {
this.cache = Buffer.allocUnsafe(0);
}
Splitter.prototype.add = function(data) {
this.cache = Buffer.concat([this.cache, data]);
};
Splitter.prototype.get = function() {
if (this.cache.length > 15) {
var out = this.cache.slice(0, 16);
this.cache = this.cache.slice(16);
return out;
}
return null;
};
Splitter.prototype.flush = function() {
var len = 16 - this.cache.length;
var padBuff = Buffer.allocUnsafe(len);
var i = -1;
while (++i < len) padBuff.writeUInt8(len, i);
return Buffer.concat([this.cache, padBuff]);
};
function createCipheriv(suite, password, iv) {
var config = MODES[suite.toLowerCase()];
if (!config) throw new TypeError("invalid suite type");
if (typeof password === "string") password = Buffer.from(password);
if (password.length !== config.key / 8) throw new TypeError("invalid key length " + password.length);
if (typeof iv === "string") iv = Buffer.from(iv);
if (config.mode !== "GCM" && iv.length !== config.iv) throw new TypeError("invalid iv length " + iv.length);
if (config.type === "stream") return new StreamCipher(config.module, password, iv);
else if (config.type === "auth") return new AuthCipher(config.module, password, iv);
return new Cipher(config.module, password, iv);
}
function createCipher(suite, password) {
var config = MODES[suite.toLowerCase()];
if (!config) throw new TypeError("invalid suite type");
var keys = ebtk(password, false, config.key, config.iv);
return createCipheriv(suite, keys.key, keys.iv);
}
exports.createCipheriv = createCipheriv;
exports.createCipher = createCipher;
}));
//#endregion
//#region node_modules/browserify-aes/decrypter.js
var require_decrypter = /* @__PURE__ */ __commonJSMin(((exports) => {
var AuthCipher = require_authCipher();
var Buffer = require_safe_buffer$9().Buffer;
var MODES = require_modes$1();
var StreamCipher = require_streamCipher();
var Transform = require_cipher_base();
var aes = require_aes$1();
var ebtk = require_evp_bytestokey();
var inherits = require_inherits_browser();
function Decipher(mode, key, iv) {
Transform.call(this);
this._cache = new Splitter();
this._last = void 0;
this._cipher = new aes.AES(key);
this._prev = Buffer.from(iv);
this._mode = mode;
this._autopadding = true;
}
inherits(Decipher, Transform);
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.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.allocUnsafe(0);
}
Splitter.prototype.add = function(data) {
this.cache = Buffer.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(suite, password, iv) {
var config = MODES[suite.toLowerCase()];
if (!config) throw new TypeError("invalid suite type");
if (typeof iv === "string") iv = Buffer.from(iv);
if (config.mode !== "GCM" && iv.length !== config.iv) throw new TypeError("invalid iv length " + iv.length);
if (typeof password === "string") password = Buffer.from(password);
if (password.length !== config.key / 8) throw new TypeError("invalid key length " + password.length);
if (config.type === "stream") return new StreamCipher(config.module, password, iv, true);
else if (config.type === "auth") return new AuthCipher(config.module, password, iv, true);
return new Decipher(config.module, password, iv);
}
function createDecipher(suite, password) {
var config = MODES[suite.toLowerCase()];
if (!config) throw new TypeError("invalid suite type");
var keys = ebtk(password, false, config.key, config.iv);
return createDecipheriv(suite, keys.key, keys.iv);
}
exports.createDecipher = createDecipher;
exports.createDecipheriv = createDecipheriv;
}));
//#endregion
//#region node_modules/browserify-aes/browser.js
var require_browser$7 = /* @__PURE__ */ __commonJSMin(((exports) => {
var ciphers = require_encrypter();
var deciphers = require_decrypter();
var modes = (init_list(), __toCommonJS(list_exports).default);
function getCiphers() {
return Object.keys(modes);
}
exports.createCipher = exports.Cipher = ciphers.createCipher;
exports.createCipheriv = exports.Cipheriv = ciphers.createCipheriv;
exports.createDecipher = exports.Decipher = deciphers.createDecipher;
exports.createDecipheriv = exports.Decipheriv = deciphers.createDecipheriv;
exports.listCiphers = exports.getCiphers = getCiphers;
}));
//#endregion
//#region node_modules/browserify-des/modes.js
var require_modes = /* @__PURE__ */ __commonJSMin(((exports) => {
exports["des-ecb"] = {
key: 8,
iv: 0
};
exports["des-cbc"] = exports.des = {
key: 8,
iv: 8
};
exports["des-ede3-cbc"] = exports.des3 = {
key: 24,
iv: 8
};
exports["des-ede3"] = {
key: 24,
iv: 0
};
exports["des-ede-cbc"] = {
key: 16,
iv: 8
};
exports["des-ede"] = {
key: 16,
iv: 0
};
}));
//#endregion
//#region node_modules/browserify-cipher/browser.js
var require_browser$6 = /* @__PURE__ */ __commonJSMin(((exports) => {
var DES = require_browserify_des();
var aes = require_browser$7();
var aesModes = require_modes$1();
var desModes = require_modes();
var ebtk = require_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 keys = ebtk(password, false, keyLen, ivLen);
return createCipheriv(suite, keys.key, keys.iv);
}
function createDecipher(suite, password) {
suite = suite.toLowerCase();
var keyLen, ivLen;
if (aesModes[suite]) {
keyLen = aesModes[suite].key;
ivLen = aesModes[suite].iv;
} else if (desModes[suite]) {
keyLen = desModes[suite].key * 8;
ivLen = desModes[suite].iv;
} else throw new TypeError("invalid suite type");
var keys = ebtk(password, false, keyLen, ivLen);
return createDecipheriv(suite, keys.key, keys.iv);
}
function createCipheriv(suite, key, iv) {
suite = suite.toLowerCase();
if (aesModes[suite]) return aes.createCipheriv(suite, key, iv);
if (desModes[suite]) return new DES({
key,
iv,
mode: suite
});
throw new TypeError("invalid suite type");
}
function createDecipheriv(suite, key, iv) {
suite = suite.toLowerCase();
if (aesModes[suite]) return aes.createDecipheriv(suite, key, iv);
if (desModes[suite]) return new DES({
key,
iv,
mode: suite,
decrypt: true
});
throw new TypeError("invalid suite type");
}
function getCiphers() {
return Object.keys(desModes).concat(aes.getCiphers());
}
exports.createCipher = exports.Cipher = createCipher;
exports.createCipheriv = exports.Cipheriv = createCipheriv;
exports.createDecipher = exports.Decipher = createDecipher;
exports.createDecipheriv = exports.Decipheriv = createDecipheriv;
exports.listCiphers = exports.getCiphers = getCiphers;
}));
//#endregion
//#region node_modules/diffie-hellman/node_modules/bn.js/lib/bn.js
var require_bn$6 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
(function(module$7, exports$7) {
"use strict";
function assert(val, msg) {
if (!val) throw new Error(msg || "Assertion failed");
}
function inherits(ctor, superCtor) {
ctor.super_ = superCtor;
var TempCtor = function() {};
TempCtor.prototype = superCtor.prototype;
ctor.prototype = new TempCtor();
ctor.prototype.constructor = ctor;
}
function BN(number, base, endian) {
if (BN.isBN(number)) return number;
this.negative = 0;
this.words = null;
this.length = 0;
this.red = null;
if (number !== null) {
if (base === "le" || base === "be") {
endian = base;
base = 10;
}
this._init(number || 0, base || 10, endian || "be");
}
}
if (typeof module$7 === "object") module$7.exports = BN;
else exports$7.BN = BN;
BN.BN = BN;
BN.wordSize = 26;
var Buffer;
try {
if (typeof window !== "undefined" && typeof window.Buffer !== "undefined") Buffer = window.Buffer;
else Buffer = require_dist().Buffer;
} catch (e) {}
BN.isBN = function isBN(num) {
if (num instanceof BN) return true;
return num !== null && typeof num === "object" && num.constructor.wordSize === BN.wordSize && Array.isArray(num.words);
};
BN.max = function max(left, right) {
if (left.cmp(right) > 0) return left;
return right;
};
BN.min = function min(left, right) {
if (left.cmp(right) < 0) return left;
return right;
};
BN.prototype._init = function init(number, base, endian) {
if (typeof number === "number") return this._initNumber(number, base, endian);
if (typeof number === "object") return this._initArray(number, base, endian);
if (base === "hex") base = 16;
assert(base === (base | 0) && base >= 2 && base <= 36);
number = number.toString().replace(/\s+/g, "");
var start = 0;
if (number[0] === "-") {
start++;
this.negative = 1;
}
if (start < number.length) if (base === 16) this._parseHex(number, start, endian);
else {
this._parseBase(number, base, start);
if (endian === "le") this._initArray(this.toArray(), base, endian);
}
};
BN.prototype._initNumber = function _initNumber(number, base, endian) {
if (number < 0) {
this.negative = 1;
number = -number;
}
if (number < 67108864) {
this.words = [number & 67108863];
this.length = 1;
} else if (number < 4503599627370496) {
this.words = [number & 67108863, number / 67108864 & 67108863];
this.length = 2;
} else {
assert(number < 9007199254740992);
this.words = [
number & 67108863,
number / 67108864 & 67108863,
1
];
this.length = 3;
}
if (endian !== "le") return;
this._initArray(this.toArray(), base, endian);
};
BN.prototype._initArray = function _initArray(number, base, endian) {
assert(typeof number.length === "number");
if (number.length <= 0) {
this.words = [0];
this.length = 1;
return this;
}
this.length = Math.ceil(number.length / 3);
this.words = new Array(this.length);
for (var 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 r = parseHex4Bits(string, index);
if (index - 1 >= lowerBound) r |= parseHex4Bits(string, index - 1) << 4;
return r;
}
BN.prototype._parseHex = function _parseHex(number, start, endian) {
this.length = Math.ceil((number.length - start) / 6);
this.words = new Array(this.length);
for (var 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 for (i = (number.length - start) % 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, mul) {
var r = 0;
var len = Math.min(str.length, end);
for (var i = start; i < len; i++) {
var c = str.charCodeAt(i) - 48;
r *= mul;
if (c >= 49) r += c - 49 + 10;
else if (c >= 17) r += c - 17 + 10;
else r += c;
}
return r;
}
BN.prototype._parseBase = function _parseBase(number, base, start) {
this.words = [0];
this.length = 1;
for (var limbLen = 0, limbPow = 1; limbPow <= 67108863; limbPow *= base) limbLen++;
limbLen--;
limbPow = limbPow / base | 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, base);
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, base);
for (i = 0; i < mod; i++) pow *= base;
this.imuln(pow);
if (this.words[0] + word < 67108864) this.words[0] += word;
else this._iaddn(word);
}
this.strip();
};
BN.prototype.copy = function copy(dest) {
dest.words = new Array(this.length);
for (var i = 0; i < this.length; i++) dest.words[i] = this.words[i];
dest.length = this.length;
dest.negative = this.negative;
dest.red = this.red;
};
BN.prototype.clone = function clone() {
var r = new BN(null);
this.copy(r);
return r;
};
BN.prototype._expand = function _expand(size) {
while (this.length < size) this.words[this.length++] = 0;
return this;
};
BN.prototype.strip = function strip() {
while (this.length > 1 && this.words[this.length - 1] === 0) this.length--;
return this._normSign();
};
BN.prototype._normSign = function _normSign() {
if (this.length === 1 && this.words[0] === 0) this.negative = 0;
return this;
};
BN.prototype.inspect = function inspect() {
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
];
BN.prototype.toString = function toString(base, padding) {
base = base || 10;
padding = padding | 0 || 1;
var out;
if (base === 16 || base === "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 (base === (base | 0) && base >= 2 && base <= 36) {
var groupSize = groupSizes[base];
var groupBase = groupBases[base];
out = "";
var c = this.clone();
c.negative = 0;
while (!c.isZero()) {
var r = c.modn(groupBase).toString(base);
c = c.idivn(groupBase);
if (!c.isZero()) out = zeros[groupSize - r.length] + r + out;
else out = r + out;
}
if (this.isZero()) out = "0" + out;
while (out.length % padding !== 0) out = "0" + out;
if (this.negative !== 0) out = "-" + out;
return out;
}
assert(false, "Base should be between 2 and 36");
};
BN.prototype.toNumber = function 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) assert(false, "Number can only safely store up to 53 bits");
return this.negative !== 0 ? -ret : ret;
};
BN.prototype.toJSON = function toJSON() {
return this.toString(16);
};
BN.prototype.toBuffer = function toBuffer(endian, length) {
assert(typeof Buffer !== "undefined");
return this.toArrayLike(Buffer, endian, length);
};
BN.prototype.toArray = function toArray(endian, length) {
return this.toArrayLike(Array, endian, length);
};
BN.prototype.toArrayLike = function toArrayLike(ArrayType, endian, length) {
var byteLength = this.byteLength();
var reqLength = length || Math.max(1, byteLength);
assert(byteLength <= reqLength, "byte array longer than desired length");
assert(reqLength > 0, "Requested array length <= 0");
this.strip();
var littleEndian = endian === "le";
var res = new ArrayType(reqLength);
var b, 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) BN.prototype._countBits = function _countBits(w) {
return 32 - Math.clz32(w);
};
else BN.prototype._countBits = function _countBits(w) {
var t = w;
var r = 0;
if (t >= 4096) {
r += 13;
t >>>= 13;
}
if (t >= 64) {
r += 7;
t >>>= 7;
}
if (t >= 8) {
r += 4;
t >>>= 4;
}
if (t >= 2) {
r += 2;
t >>>= 2;
}
return r + t;
};
BN.prototype._zeroBits = function _zeroBits(w) {
if (w === 0) return 26;
var t = w;
var r = 0;
if ((t & 8191) === 0) {
r += 13;
t >>>= 13;
}
if ((t & 127) === 0) {
r += 7;
t >>>= 7;
}
if ((t & 15) === 0) {
r += 4;
t >>>= 4;
}
if ((t & 3) === 0) {
r += 2;
t >>>= 2;
}
if ((t & 1) === 0) r++;
return r;
};
BN.prototype.bitLength = function bitLength() {
var w = this.words[this.length - 1];
var hi = this._countBits(w);
return (this.length - 1) * 26 + hi;
};
function toBitArray(num) {
var w = new Array(num.bitLength());
for (var bit = 0; bit < w.length; bit++) {
var off = bit / 26 | 0;
var wbit = bit % 26;
w[bit] = (num.words[off] & 1 << wbit) >>> wbit;
}
return w;
}
BN.prototype.zeroBits = function zeroBits() {
if (this.isZero()) return 0;
var r = 0;
for (var i = 0; i < this.length; i++) {
var b = this._zeroBits(this.words[i]);
r += b;
if (b !== 26) break;
}
return r;
};
BN.prototype.byteLength = function byteLength() {
return Math.ceil(this.bitLength() / 8);
};
BN.prototype.toTwos = function toTwos(width) {
if (this.negative !== 0) return this.abs().inotn(width).iaddn(1);
return this.clone();
};
BN.prototype.fromTwos = function fromTwos(width) {
if (this.testn(width - 1)) return this.notn(width).iaddn(1).ineg();
return this.clone();
};
BN.prototype.isNeg = function isNeg() {
return this.negative !== 0;
};
BN.prototype.neg = function neg() {
return this.clone().ineg();
};
BN.prototype.ineg = function ineg() {
if (!this.isZero()) this.negative ^= 1;
return this;
};
BN.prototype.iuor = function iuor(num) {
while (this.length < num.length) this.words[this.length++] = 0;
for (var i = 0; i < num.length; i++) this.words[i] = this.words[i] | num.words[i];
return this.strip();
};
BN.prototype.ior = function ior(num) {
assert((this.negative | num.negative) === 0);
return this.iuor(num);
};
BN.prototype.or = function or(num) {
if (this.length > num.length) return this.clone().ior(num);
return num.clone().ior(this);
};
BN.prototype.uor = function uor(num) {
if (this.length > num.length) return this.clone().iuor(num);
return num.clone().iuor(this);
};
BN.prototype.iuand = function iuand(num) {
var b;
if (this.length > num.length) b = num;
else b = this;
for (var i = 0; i < b.length; i++) this.words[i] = this.words[i] & num.words[i];
this.length = b.length;
return this.strip();
};
BN.prototype.iand = function iand(num) {
assert((this.negative | num.negative) === 0);
return this.iuand(num);
};
BN.prototype.and = function and(num) {
if (this.length > num.length) return this.clone().iand(num);
return num.clone().iand(this);
};
BN.prototype.uand = function uand(num) {
if (this.length > num.length) return this.clone().iuand(num);
return num.clone().iuand(this);
};
BN.prototype.iuxor = function iuxor(num) {
var a;
var b;
if (this.length > num.length) {
a = this;
b = num;
} else {
a = num;
b = this;
}
for (var 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();
};
BN.prototype.ixor = function ixor(num) {
assert((this.negative | num.negative) === 0);
return this.iuxor(num);
};
BN.prototype.xor = function xor(num) {
if (this.length > num.length) return this.clone().ixor(num);
return num.clone().ixor(this);
};
BN.prototype.uxor = function uxor(num) {
if (this.length > num.length) return this.clone().iuxor(num);
return num.clone().iuxor(this);
};
BN.prototype.inotn = function inotn(width) {
assert(typeof width === "number" && width >= 0);
var bytesNeeded = Math.ceil(width / 26) | 0;
var bitsLeft = width % 26;
this._expand(bytesNeeded);
if (bitsLeft > 0) bytesNeeded--;
for (var 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();
};
BN.prototype.notn = function notn(width) {
return this.clone().inotn(width);
};
BN.prototype.setn = function setn(bit, val) {
assert(typeof bit === "number" && bit >= 0);
var off = bit / 26 | 0;
var wbit = bit % 26;
this._expand(off + 1);
if (val) this.words[off] = this.words[off] | 1 << wbit;
else this.words[off] = this.words[off] & ~(1 << wbit);
return this.strip();
};
BN.prototype.iadd = function iadd(num) {
var r;
if (this.negative !== 0 && num.negative === 0) {
this.negative = 0;
r = this.isub(num);
this.negative ^= 1;
return this._normSign();
} else if (this.negative === 0 && num.negative !== 0) {
num.negative = 0;
r = this.isub(num);
num.negative = 1;
return r._normSign();
}
var a, b;
if (this.length > num.length) {
a = this;
b = num;
} else {
a = num;
b = this;
}
var carry = 0;
for (var i = 0; i < b.length; i++) {
r = (a.words[i] | 0) + (b.words[i] | 0) + carry;
this.words[i] = r & 67108863;
carry = r >>> 26;
}
for (; carry !== 0 && i < a.length; i++) {
r = (a.words[i] | 0) + carry;
this.words[i] = r & 67108863;
carry = r >>> 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;
};
BN.prototype.add = function add(num) {
var res;
if (num.negative !== 0 && this.negative === 0) {
num.negative = 0;
res = this.sub(num);
num.negative ^= 1;
return res;
} else if (num.negative === 0 && this.negative !== 0) {
this.negative = 0;
res = num.sub(this);
this.negative = 1;
return res;
}
if (this.length > num.length) return this.clone().iadd(num);
return num.clone().iadd(this);
};
BN.prototype.isub = function isub(num) {
if (num.negative !== 0) {
num.negative = 0;
var r = this.iadd(num);
num.negative = 1;
return r._normSign();
} else if (this.negative !== 0) {
this.negative = 0;
this.iadd(num);
this.negative = 1;
return this._normSign();
}
var cmp = this.cmp(num);
if (cmp === 0) {
this.negative = 0;
this.length = 1;
this.words[0] = 0;
return this;
}
var a, b;
if (cmp > 0) {
a = this;
b = num;
} else {
a = num;
b = this;
}
var carry = 0;
for (var i = 0; i < b.length; i++) {
r = (a.words[i] | 0) - (b.words[i] | 0) + carry;
carry = r >> 26;
this.words[i] = r & 67108863;
}
for (; carry !== 0 && i < a.length; i++) {
r = (a.words[i] | 0) + carry;
carry = r >> 26;
this.words[i] = r & 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();
};
BN.prototype.sub = function sub(num) {
return this.clone().isub(num);
};
function smallMulTo(self, num, out) {
out.negative = num.negative ^ self.negative;
var len = self.length + num.length | 0;
out.length = len;
len = len - 1 | 0;
var a = self.words[0] | 0;
var b = num.words[0] | 0;
var r = a * b;
var lo = r & 67108863;
var carry = r / 67108864 | 0;
out.words[0] = lo;
for (var k = 1; k < 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 - self.length + 1); j <= maxJ; j++) {
var i = k - j | 0;
a = self.words[i] | 0;
b = num.words[j] | 0;
r = a * b + rword;
ncarry += r / 67108864 | 0;
rword = r & 67108863;
}
out.words[k] = rword | 0;
carry = ncarry | 0;
}
if (carry !== 0) out.words[k] = carry | 0;
else out.length--;
return out.strip();
}
var comb10MulTo = function comb10MulTo(self, num, out) {
var a = self.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 = self.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(self, num, out) {
out.negative = num.negative ^ self.negative;
out.length = self.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 - self.length + 1); j <= maxJ; j++) {
var i = k - j;
var r = (self.words[i] | 0) * (num.words[j] | 0);
var lo = r & 67108863;
ncarry = ncarry + (r / 67108864 | 0) | 0;
lo = lo + rword | 0;
rword = lo & 67108863;
ncarry = ncarry + (lo >>> 26) | 0;
hncarry += ncarry >>> 26;
ncarry &= 67108863;
}
out.words[k] = rword;
carry = ncarry;
ncarry = hncarry;
}
if (carry !== 0) out.words[k] = carry;
else out.length--;
return out.strip();
}
function jumboMulTo(self, num, out) {
return new FFTM().mulp(self, num, out);
}
BN.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 = BN.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 permute(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 s = 1; s < N; s <<= 1) {
var l = s << 1;
var rtwdf = Math.cos(2 * Math.PI / l);
var itwdf = Math.sin(2 * Math.PI / l);
for (var p = 0; p < N; p += l) {
var rtwdf_ = rtwdf;
var itwdf_ = itwdf;
for (var j = 0; j < s; j++) {
var re = rtws[p + j];
var ie = itws[p + j];
var ro = rtws[p + j + s];
var io = itws[p + j + s];
var rx = rtwdf_ * ro - itwdf_ * io;
io = rtwdf_ * io + itwdf_ * ro;
ro = rx;
rtws[p + j] = re + ro;
itws[p + j] = ie + io;
rtws[p + j + s] = re - ro;
itws[p + j + s] = ie - io;
if (j !== l) {
rx = rtwdf * rtwdf_ - itwdf * itwdf_;
itwdf_ = rtwdf * itwdf_ + itwdf * rtwdf_;
rtwdf_ = rx;
}
}
}
}
};
FFTM.prototype.guessLen13b = function guessLen13b(n, m) {
var N = Math.max(m, n) | 1;
var odd = N & 1;
var 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;
assert(carry === 0);
assert((carry & -8192) === 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();
};
BN.prototype.mul = function mul(num) {
var out = new BN(null);
out.words = new Array(this.length + num.length);
return this.mulTo(num, out);
};
BN.prototype.mulf = function mulf(num) {
var out = new BN(null);
out.words = new Array(this.length + num.length);
return jumboMulTo(this, num, out);
};
BN.prototype.imul = function imul(num) {
return this.clone().mulTo(num, this);
};
BN.prototype.imuln = function imuln(num) {
assert(typeof num === "number");
assert(num < 67108864);
var carry = 0;
for (var 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;
};
BN.prototype.muln = function muln(num) {
return this.clone().imuln(num);
};
BN.prototype.sqr = function sqr() {
return this.mul(this);
};
BN.prototype.isqr = function isqr() {
return this.imul(this.clone());
};
BN.prototype.pow = function pow(num) {
var w = toBitArray(num);
if (w.length === 0) return new BN(1);
var res = this;
for (var 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;
};
BN.prototype.iushln = function iushln(bits) {
assert(typeof bits === "number" && bits >= 0);
var r = bits % 26;
var s = (bits - r) / 26;
var carryMask = 67108863 >>> 26 - r << 26 - r;
var i;
if (r !== 0) {
var carry = 0;
for (i = 0; i < this.length; i++) {
var newCarry = this.words[i] & carryMask;
var c = (this.words[i] | 0) - newCarry << r;
this.words[i] = c | carry;
carry = newCarry >>> 26 - r;
}
if (carry) {
this.words[i] = carry;
this.length++;
}
}
if (s !== 0) {
for (i = this.length - 1; i >= 0; i--) this.words[i + s] = this.words[i];
for (i = 0; i < s; i++) this.words[i] = 0;
this.length += s;
}
return this.strip();
};
BN.prototype.ishln = function ishln(bits) {
assert(this.negative === 0);
return this.iushln(bits);
};
BN.prototype.iushrn = function iushrn(bits, hint, extended) {
assert(typeof bits === "number" && bits >= 0);
var h;
if (hint) h = (hint - hint % 26) / 26;
else h = 0;
var r = bits % 26;
var s = Math.min((bits - r) / 26, this.length);
var mask = 67108863 ^ 67108863 >>> r << r;
var maskedWords = extended;
h -= s;
h = Math.max(0, h);
if (maskedWords) {
for (var i = 0; i < s; i++) maskedWords.words[i] = this.words[i];
maskedWords.length = s;
}
if (s === 0) {} else if (this.length > s) {
this.length -= s;
for (i = 0; i < this.length; i++) this.words[i] = this.words[i + s];
} 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 - r | word >>> r;
carry = word & mask;
}
if (maskedWords && carry !== 0) maskedWords.words[maskedWords.length++] = carry;
if (this.length === 0) {
this.words[0] = 0;
this.length = 1;
}
return this.strip();
};
BN.prototype.ishrn = function ishrn(bits, hint, extended) {
assert(this.negative === 0);
return this.iushrn(bits, hint, extended);
};
BN.prototype.shln = function shln(bits) {
return this.clone().ishln(bits);
};
BN.prototype.ushln = function ushln(bits) {
return this.clone().iushln(bits);
};
BN.prototype.shrn = function shrn(bits) {
return this.clone().ishrn(bits);
};
BN.prototype.ushrn = function ushrn(bits) {
return this.clone().iushrn(bits);
};
BN.prototype.testn = function testn(bit) {
assert(typeof bit === "number" && bit >= 0);
var r = bit % 26;
var s = (bit - r) / 26;
var q = 1 << r;
if (this.length <= s) return false;
return !!(this.words[s] & q);
};
BN.prototype.imaskn = function imaskn(bits) {
assert(typeof bits === "number" && bits >= 0);
var r = bits % 26;
var s = (bits - r) / 26;
assert(this.negative === 0, "imaskn works only with positive numbers");
if (this.length <= s) return this;
if (r !== 0) s++;
this.length = Math.min(s, this.length);
if (r !== 0) {
var mask = 67108863 ^ 67108863 >>> r << r;
this.words[this.length - 1] &= mask;
}
return this.strip();
};
BN.prototype.maskn = function maskn(bits) {
return this.clone().imaskn(bits);
};
BN.prototype.iaddn = function iaddn(num) {
assert(typeof num === "number");
assert(num < 67108864);
if (num < 0) return this.isubn(-num);
if (this.negative !== 0) {
if (this.length === 1 && (this.words[0] | 0) < num) {
this.words[0] = num - (this.words[0] | 0);
this.negative = 0;
return this;
}
this.negative = 0;
this.isubn(num);
this.negative = 1;
return this;
}
return this._iaddn(num);
};
BN.prototype._iaddn = function _iaddn(num) {
this.words[0] += num;
for (var 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;
};
BN.prototype.isubn = function isubn(num) {
assert(typeof num === "number");
assert(num < 67108864);
if (num < 0) return this.iaddn(-num);
if (this.negative !== 0) {
this.negative = 0;
this.iaddn(num);
this.negative = 1;
return this;
}
this.words[0] -= num;
if (this.length === 1 && this.words[0] < 0) {
this.words[0] = -this.words[0];
this.negative = 1;
} else for (var i = 0; i < this.length && this.words[i] < 0; i++) {
this.words[i] += 67108864;
this.words[i + 1] -= 1;
}
return this.strip();
};
BN.prototype.addn = function addn(num) {
return this.clone().iaddn(num);
};
BN.prototype.subn = function subn(num) {
return this.clone().isubn(num);
};
BN.prototype.iabs = function iabs() {
this.negative = 0;
return this;
};
BN.prototype.abs = function abs() {
return this.clone().iabs();
};
BN.prototype._ishlnsubmul = function _ishlnsubmul(num, mul, shift) {
var 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) * mul;
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();
assert(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();
};
BN.prototype._wordDiv = function _wordDiv(num, mode) {
var shift = this.length - num.length;
var a = this.clone();
var b = num;
var bhi = b.words[b.length - 1] | 0;
shift = 26 - this._countBits(bhi);
if (shift !== 0) {
b = b.ushln(shift);
a.iushln(shift);
bhi = b.words[b.length - 1] | 0;
}
var m = a.length - b.length;
var q;
if (mode !== "mod") {
q = new BN(null);
q.length = m + 1;
q.words = new Array(q.length);
for (var 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
};
};
BN.prototype.divmod = function divmod(num, mode, positive) {
assert(!num.isZero());
if (this.isZero()) return {
div: new BN(0),
mod: new BN(0)
};
var div, mod, res;
if (this.negative !== 0 && num.negative === 0) {
res = this.neg().divmod(num, mode);
if (mode !== "mod") div = res.div.neg();
if (mode !== "div") {
mod = res.mod.neg();
if (positive && mod.negative !== 0) mod.iadd(num);
}
return {
div,
mod
};
}
if (this.negative === 0 && num.negative !== 0) {
res = this.divmod(num.neg(), mode);
if (mode !== "mod") div = res.div.neg();
return {
div,
mod: res.mod
};
}
if ((this.negative & num.negative) !== 0) {
res = this.neg().divmod(num.neg(), mode);
if (mode !== "div") {
mod = res.mod.neg();
if (positive && mod.negative !== 0) mod.isub(num);
}
return {
div: res.div,
mod
};
}
if (num.length > this.length || this.cmp(num) < 0) return {
div: new BN(0),
mod: this
};
if (num.length === 1) {
if (mode === "div") return {
div: this.divn(num.words[0]),
mod: null
};
if (mode === "mod") return {
div: null,
mod: new BN(this.modn(num.words[0]))
};
return {
div: this.divn(num.words[0]),
mod: new BN(this.modn(num.words[0]))
};
}
return this._wordDiv(num, mode);
};
BN.prototype.div = function div(num) {
return this.divmod(num, "div", false).div;
};
BN.prototype.mod = function mod(num) {
return this.divmod(num, "mod", false).mod;
};
BN.prototype.umod = function umod(num) {
return this.divmod(num, "mod", true).mod;
};
BN.prototype.divRound = function divRound(num) {
var dm = this.divmod(num);
if (dm.mod.isZero()) return dm.div;
var mod = dm.div.negative !== 0 ? dm.mod.isub(num) : dm.mod;
var half = num.ushrn(1);
var r2 = num.andln(1);
var cmp = mod.cmp(half);
if (cmp < 0 || r2 === 1 && cmp === 0) return dm.div;
return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1);
};
BN.prototype.modn = function modn(num) {
assert(num <= 67108863);
var p = (1 << 26) % num;
var acc = 0;
for (var i = this.length - 1; i >= 0; i--) acc = (p * acc + (this.words[i] | 0)) % num;
return acc;
};
BN.prototype.idivn = function idivn(num) {
assert(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();
};
BN.prototype.divn = function divn(num) {
return this.clone().idivn(num);
};
BN.prototype.egcd = function egcd(p) {
assert(p.negative === 0);
assert(!p.isZero());
var x = this;
var y = p.clone();
if (x.negative !== 0) x = x.umod(p);
else x = x.clone();
var A = new BN(1);
var B = new BN(0);
var C = new BN(0);
var D = new BN(1);
var g = 0;
while (x.isEven() && y.isEven()) {
x.iushrn(1);
y.iushrn(1);
++g;
}
var yp = y.clone();
var xp = x.clone();
while (!x.isZero()) {
for (var 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(g)
};
};
BN.prototype._invmp = function _invmp(p) {
assert(p.negative === 0);
assert(!p.isZero());
var a = this;
var b = p.clone();
if (a.negative !== 0) a = a.umod(p);
else a = a.clone();
var x1 = new BN(1);
var x2 = new BN(0);
var delta = b.clone();
while (a.cmpn(1) > 0 && b.cmpn(1) > 0) {
for (var 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;
};
BN.prototype.gcd = function gcd(num) {
if (this.isZero()) return num.abs();
if (num.isZero()) return this.abs();
var a = this.clone();
var b = num.clone();
a.negative = 0;
b.negative = 0;
for (var shift = 0; a.isEven() && b.isEven(); shift++) {
a.iushrn(1);
b.iushrn(1);
}
do {
while (a.isEven()) a.iushrn(1);
while (b.isEven()) b.iushrn(1);
var r = a.cmp(b);
if (r < 0) {
var t = a;
a = b;
b = t;
} else if (r === 0 || b.cmpn(1) === 0) break;
a.isub(b);
} while (true);
return b.iushln(shift);
};
BN.prototype.invm = function invm(num) {
return this.egcd(num).a.umod(num);
};
BN.prototype.isEven = function isEven() {
return (this.words[0] & 1) === 0;
};
BN.prototype.isOdd = function isOdd() {
return (this.words[0] & 1) === 1;
};
BN.prototype.andln = function andln(num) {
return this.words[0] & num;
};
BN.prototype.bincn = function bincn(bit) {
assert(typeof bit === "number");
var r = bit % 26;
var s = (bit - r) / 26;
var q = 1 << r;
if (this.length <= s) {
this._expand(s + 1);
this.words[s] |= q;
return this;
}
var carry = q;
for (var i = s; 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;
};
BN.prototype.isZero = function isZero() {
return this.length === 1 && this.words[0] === 0;
};
BN.prototype.cmpn = function cmpn(num) {
var negative = num < 0;
if (this.negative !== 0 && !negative) return -1;
if (this.negative === 0 && negative) return 1;
this.strip();
var res;
if (this.length > 1) res = 1;
else {
if (negative) num = -num;
assert(num <= 67108863, "Number is too big");
var w = this.words[0] | 0;
res = w === num ? 0 : w < num ? -1 : 1;
}
if (this.negative !== 0) return -res | 0;
return res;
};
BN.prototype.cmp = function cmp(num) {
if (this.negative !== 0 && num.negative === 0) return -1;
if (this.negative === 0 && num.negative !== 0) return 1;
var res = this.ucmp(num);
if (this.negative !== 0) return -res | 0;
return res;
};
BN.prototype.ucmp = function ucmp(num) {
if (this.length > num.length) return 1;
if (this.length < num.length) return -1;
var res = 0;
for (var 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;
};
BN.prototype.gtn = function gtn(num) {
return this.cmpn(num) === 1;
};
BN.prototype.gt = function gt(num) {
return this.cmp(num) === 1;
};
BN.prototype.gten = function gten(num) {
return this.cmpn(num) >= 0;
};
BN.prototype.gte = function gte(num) {
return this.cmp(num) >= 0;
};
BN.prototype.ltn = function ltn(num) {
return this.cmpn(num) === -1;
};
BN.prototype.lt = function lt(num) {
return this.cmp(num) === -1;
};
BN.prototype.lten = function lten(num) {
return this.cmpn(num) <= 0;
};
BN.prototype.lte = function lte(num) {
return this.cmp(num) <= 0;
};
BN.prototype.eqn = function eqn(num) {
return this.cmpn(num) === 0;
};
BN.prototype.eq = function eq(num) {
return this.cmp(num) === 0;
};
BN.red = function red(num) {
return new Red(num);
};
BN.prototype.toRed = function toRed(ctx) {
assert(!this.red, "Already a number in reduction context");
assert(this.negative === 0, "red works only with positives");
return ctx.convertTo(this)._forceRed(ctx);
};
BN.prototype.fromRed = function fromRed() {
assert(this.red, "fromRed works only with numbers in reduction context");
return this.red.convertFrom(this);
};
BN.prototype._forceRed = function _forceRed(ctx) {
this.red = ctx;
return this;
};
BN.prototype.forceRed = function forceRed(ctx) {
assert(!this.red, "Already a number in reduction context");
return this._forceRed(ctx);
};
BN.prototype.redAdd = function redAdd(num) {
assert(this.red, "redAdd works only with red numbers");
return this.red.add(this, num);
};
BN.prototype.redIAdd = function redIAdd(num) {
assert(this.red, "redIAdd works only with red numbers");
return this.red.iadd(this, num);
};
BN.prototype.redSub = function redSub(num) {
assert(this.red, "redSub works only with red numbers");
return this.red.sub(this, num);
};
BN.prototype.redISub = function redISub(num) {
assert(this.red, "redISub works only with red numbers");
return this.red.isub(this, num);
};
BN.prototype.redShl = function redShl(num) {
assert(this.red, "redShl works only with red numbers");
return this.red.shl(this, num);
};
BN.prototype.redMul = function redMul(num) {
assert(this.red, "redMul works only with red numbers");
this.red._verify2(this, num);
return this.red.mul(this, num);
};
BN.prototype.redIMul = function redIMul(num) {
assert(this.red, "redMul works only with red numbers");
this.red._verify2(this, num);
return this.red.imul(this, num);
};
BN.prototype.redSqr = function redSqr() {
assert(this.red, "redSqr works only with red numbers");
this.red._verify1(this);
return this.red.sqr(this);
};
BN.prototype.redISqr = function redISqr() {
assert(this.red, "redISqr works only with red numbers");
this.red._verify1(this);
return this.red.isqr(this);
};
BN.prototype.redSqrt = function redSqrt() {
assert(this.red, "redSqrt works only with red numbers");
this.red._verify1(this);
return this.red.sqrt(this);
};
BN.prototype.redInvm = function redInvm() {
assert(this.red, "redInvm works only with red numbers");
this.red._verify1(this);
return this.red.invm(this);
};
BN.prototype.redNeg = function redNeg() {
assert(this.red, "redNeg works only with red numbers");
this.red._verify1(this);
return this.red.neg(this);
};
BN.prototype.redPow = function redPow(num) {
assert(this.red && !num.red, "redPow(normalNum)");
this.red._verify1(this);
return this.red.pow(this, num);
};
var primes = {
k256: null,
p224: null,
p192: null,
p25519: null
};
function MPrime(name, p) {
this.name = name;
this.p = new BN(p, 16);
this.n = this.p.bitLength();
this.k = new BN(1).iushln(this.n).isub(this.p);
this.tmp = this._tmp();
}
MPrime.prototype._tmp = function _tmp() {
var tmp = new BN(null);
tmp.words = new Array(Math.ceil(this.n / 13));
return tmp;
};
MPrime.prototype.ireduce = function ireduce(num) {
var r = num;
var rlen;
do {
this.split(r, this.tmp);
r = this.imulK(r);
r = r.iadd(this.tmp);
rlen = r.bitLength();
} while (rlen > this.n);
var cmp = rlen < this.n ? -1 : r.ucmp(this.p);
if (cmp === 0) {
r.words[0] = 0;
r.length = 1;
} else if (cmp > 0) r.isub(this.p);
else if (r.strip !== void 0) r.strip();
else r._strip();
return r;
};
MPrime.prototype.split = function split(input, out) {
input.iushrn(this.n, 0, out);
};
MPrime.prototype.imulK = function imulK(num) {
return num.imul(this.k);
};
function K256() {
MPrime.call(this, "k256", "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f");
}
inherits(K256, MPrime);
K256.prototype.split = function split(input, output) {
var mask = 4194303;
var outLen = Math.min(input.length, 9);
for (var 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");
}
inherits(P224, MPrime);
function P192() {
MPrime.call(this, "p192", "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff");
}
inherits(P192, MPrime);
function P25519() {
MPrime.call(this, "25519", "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed");
}
inherits(P25519, MPrime);
P25519.prototype.imulK = function imulK(num) {
var carry = 0;
for (var 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;
};
BN._prime = function prime(name) {
if (primes[name]) return primes[name];
var prime;
if (name === "k256") prime = new K256();
else if (name === "p224") prime = new P224();
else if (name === "p192") prime = new P192();
else if (name === "p25519") prime = new P25519();
else throw new Error("Unknown prime " + name);
primes[name] = prime;
return prime;
};
function Red(m) {
if (typeof m === "string") {
var prime = BN._prime(m);
this.m = prime.p;
this.prime = prime;
} else {
assert(m.gtn(1), "modulus must be greater than 1");
this.m = m;
this.prime = null;
}
}
Red.prototype._verify1 = function _verify1(a) {
assert(a.negative === 0, "red works only with positives");
assert(a.red, "red works only with red numbers");
};
Red.prototype._verify2 = function _verify2(a, b) {
assert((a.negative | b.negative) === 0, "red works only with positives");
assert(a.red && a.red === b.red, "red works only with red numbers");
};
Red.prototype.imod = function imod(a) {
if (this.prime) return this.prime.ireduce(a)._forceRed(this);
return a.umod(this.m)._forceRed(this);
};
Red.prototype.neg = function neg(a) {
if (a.isZero()) return a.clone();
return this.m.sub(a)._forceRed(this);
};
Red.prototype.add = function add(a, b) {
this._verify2(a, b);
var res = a.add(b);
if (res.cmp(this.m) >= 0) res.isub(this.m);
return res._forceRed(this);
};
Red.prototype.iadd = function iadd(a, b) {
this._verify2(a, b);
var res = a.iadd(b);
if (res.cmp(this.m) >= 0) res.isub(this.m);
return res;
};
Red.prototype.sub = function sub(a, b) {
this._verify2(a, b);
var res = a.sub(b);
if (res.cmpn(0) < 0) res.iadd(this.m);
return res._forceRed(this);
};
Red.prototype.isub = function isub(a, b) {
this._verify2(a, b);
var res = a.isub(b);
if (res.cmpn(0) < 0) res.iadd(this.m);
return res;
};
Red.prototype.shl = function shl(a, num) {
this._verify1(a);
return this.imod(a.ushln(num));
};
Red.prototype.imul = function imul(a, b) {
this._verify2(a, b);
return this.imod(a.imul(b));
};
Red.prototype.mul = function mul(a, b) {
this._verify2(a, b);
return this.imod(a.mul(b));
};
Red.prototype.isqr = function isqr(a) {
return this.imul(a, a.clone());
};
Red.prototype.sqr = function sqr(a) {
return this.mul(a, a);
};
Red.prototype.sqrt = function sqrt(a) {
if (a.isZero()) return a.clone();
var mod3 = this.m.andln(3);
assert(mod3 % 2 === 1);
if (mod3 === 3) {
var pow = this.m.add(new BN(1)).iushrn(2);
return this.pow(a, pow);
}
var q = this.m.subn(1);
var s = 0;
while (!q.isZero() && q.andln(1) === 0) {
s++;
q.iushrn(1);
}
assert(!q.isZero());
var one = new BN(1).toRed(this);
var nOne = one.redNeg();
var lpow = this.m.subn(1).iushrn(1);
var z = this.m.bitLength();
z = new BN(2 * z * z).toRed(this);
while (this.pow(z, lpow).cmp(nOne) !== 0) z.redIAdd(nOne);
var c = this.pow(z, q);
var r = this.pow(a, q.addn(1).iushrn(1));
var t = this.pow(a, q);
var m = s;
while (t.cmp(one) !== 0) {
var tmp = t;
for (var i = 0; tmp.cmp(one) !== 0; i++) tmp = tmp.redSqr();
assert(i < m);
var b = this.pow(c, new BN(1).iushln(m - i - 1));
r = r.redMul(b);
c = b.redSqr();
t = t.redMul(c);
m = i;
}
return r;
};
Red.prototype.invm = function invm(a) {
var inv = a._invmp(this.m);
if (inv.negative !== 0) {
inv.negative = 0;
return this.imod(inv).redNeg();
} else return this.imod(inv);
};
Red.prototype.pow = function pow(a, num) {
if (num.isZero()) return new BN(1).toRed(this);
if (num.cmpn(1) === 0) return a.clone();
var windowSize = 4;
var wnd = new Array(1 << windowSize);
wnd[0] = new BN(1).toRed(this);
wnd[1] = a;
for (var 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 r = num.umod(this.m);
return r === num ? r.clone() : r;
};
Red.prototype.convertFrom = function convertFrom(num) {
var res = num.clone();
res.red = null;
return res;
};
BN.mont = function mont(num) {
return new Mont(num);
};
function Mont(m) {
Red.call(this, m);
this.shift = this.m.bitLength();
if (this.shift % 26 !== 0) this.shift += 26 - this.shift % 26;
this.r = new BN(1).iushln(this.shift);
this.r2 = this.imod(this.r.sqr());
this.rinv = this.r._invmp(this.m);
this.minv = this.rinv.mul(this.r).isubn(1).div(this.m);
this.minv = this.minv.umod(this.r);
this.minv = this.r.sub(this.minv);
}
inherits(Mont, Red);
Mont.prototype.convertTo = function convertTo(num) {
return this.imod(num.ushln(this.shift));
};
Mont.prototype.convertFrom = function convertFrom(num) {
var r = this.imod(num.mul(this.rinv));
r.red = null;
return r;
};
Mont.prototype.imul = function imul(a, b) {
if (a.isZero() || b.isZero()) {
a.words[0] = 0;
a.length = 1;
return a;
}
var t = a.imul(b);
var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
var u = t.isub(c).iushrn(this.shift);
var res = u;
if (u.cmp(this.m) >= 0) res = u.isub(this.m);
else if (u.cmpn(0) < 0) res = u.iadd(this.m);
return res._forceRed(this);
};
Mont.prototype.mul = function mul(a, b) {
if (a.isZero() || b.isZero()) return new BN(0)._forceRed(this);
var t = a.mul(b);
var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
var u = t.isub(c).iushrn(this.shift);
var res = u;
if (u.cmp(this.m) >= 0) res = u.isub(this.m);
else if (u.cmpn(0) < 0) res = u.iadd(this.m);
return res._forceRed(this);
};
Mont.prototype.invm = function invm(a) {
return this.imod(a._invmp(this.m).mul(this.r2))._forceRed(this);
};
})(typeof module === "undefined" || module, exports);
}));
//#endregion
//#region node_modules/miller-rabin/node_modules/bn.js/lib/bn.js
var require_bn$5 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
(function(module$6, exports$6) {
"use strict";
function assert(val, msg) {
if (!val) throw new Error(msg || "Assertion failed");
}
function inherits(ctor, superCtor) {
ctor.super_ = superCtor;
var TempCtor = function() {};
TempCtor.prototype = superCtor.prototype;
ctor.prototype = new TempCtor();
ctor.prototype.constructor = ctor;
}
function BN(number, base, endian) {
if (BN.isBN(number)) return number;
this.negative = 0;
this.words = null;
this.length = 0;
this.red = null;
if (number !== null) {
if (base === "le" || base === "be") {
endian = base;
base = 10;
}
this._init(number || 0, base || 10, endian || "be");
}
}
if (typeof module$6 === "object") module$6.exports = BN;
else exports$6.BN = BN;
BN.BN = BN;
BN.wordSize = 26;
var Buffer;
try {
if (typeof window !== "undefined" && typeof window.Buffer !== "undefined") Buffer = window.Buffer;
else Buffer = require_dist().Buffer;
} catch (e) {}
BN.isBN = function isBN(num) {
if (num instanceof BN) return true;
return num !== null && typeof num === "object" && num.constructor.wordSize === BN.wordSize && Array.isArray(num.words);
};
BN.max = function max(left, right) {
if (left.cmp(right) > 0) return left;
return right;
};
BN.min = function min(left, right) {
if (left.cmp(right) < 0) return left;
return right;
};
BN.prototype._init = function init(number, base, endian) {
if (typeof number === "number") return this._initNumber(number, base, endian);
if (typeof number === "object") return this._initArray(number, base, endian);
if (base === "hex") base = 16;
assert(base === (base | 0) && base >= 2 && base <= 36);
number = number.toString().replace(/\s+/g, "");
var start = 0;
if (number[0] === "-") {
start++;
this.negative = 1;
}
if (start < number.length) if (base === 16) this._parseHex(number, start, endian);
else {
this._parseBase(number, base, start);
if (endian === "le") this._initArray(this.toArray(), base, endian);
}
};
BN.prototype._initNumber = function _initNumber(number, base, endian) {
if (number < 0) {
this.negative = 1;
number = -number;
}
if (number < 67108864) {
this.words = [number & 67108863];
this.length = 1;
} else if (number < 4503599627370496) {
this.words = [number & 67108863, number / 67108864 & 67108863];
this.length = 2;
} else {
assert(number < 9007199254740992);
this.words = [
number & 67108863,
number / 67108864 & 67108863,
1
];
this.length = 3;
}
if (endian !== "le") return;
this._initArray(this.toArray(), base, endian);
};
BN.prototype._initArray = function _initArray(number, base, endian) {
assert(typeof number.length === "number");
if (number.length <= 0) {
this.words = [0];
this.length = 1;
return this;
}
this.length = Math.ceil(number.length / 3);
this.words = new Array(this.length);
for (var 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 r = parseHex4Bits(string, index);
if (index - 1 >= lowerBound) r |= parseHex4Bits(string, index - 1) << 4;
return r;
}
BN.prototype._parseHex = function _parseHex(number, start, endian) {
this.length = Math.ceil((number.length - start) / 6);
this.words = new Array(this.length);
for (var 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 for (i = (number.length - start) % 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, mul) {
var r = 0;
var len = Math.min(str.length, end);
for (var i = start; i < len; i++) {
var c = str.charCodeAt(i) - 48;
r *= mul;
if (c >= 49) r += c - 49 + 10;
else if (c >= 17) r += c - 17 + 10;
else r += c;
}
return r;
}
BN.prototype._parseBase = function _parseBase(number, base, start) {
this.words = [0];
this.length = 1;
for (var limbLen = 0, limbPow = 1; limbPow <= 67108863; limbPow *= base) limbLen++;
limbLen--;
limbPow = limbPow / base | 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, base);
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, base);
for (i = 0; i < mod; i++) pow *= base;
this.imuln(pow);
if (this.words[0] + word < 67108864) this.words[0] += word;
else this._iaddn(word);
}
this.strip();
};
BN.prototype.copy = function copy(dest) {
dest.words = new Array(this.length);
for (var i = 0; i < this.length; i++) dest.words[i] = this.words[i];
dest.length = this.length;
dest.negative = this.negative;
dest.red = this.red;
};
BN.prototype.clone = function clone() {
var r = new BN(null);
this.copy(r);
return r;
};
BN.prototype._expand = function _expand(size) {
while (this.length < size) this.words[this.length++] = 0;
return this;
};
BN.prototype.strip = function strip() {
while (this.length > 1 && this.words[this.length - 1] === 0) this.length--;
return this._normSign();
};
BN.prototype._normSign = function _normSign() {
if (this.length === 1 && this.words[0] === 0) this.negative = 0;
return this;
};
BN.prototype.inspect = function inspect() {
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
];
BN.prototype.toString = function toString(base, padding) {
base = base || 10;
padding = padding | 0 || 1;
var out;
if (base === 16 || base === "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 (base === (base | 0) && base >= 2 && base <= 36) {
var groupSize = groupSizes[base];
var groupBase = groupBases[base];
out = "";
var c = this.clone();
c.negative = 0;
while (!c.isZero()) {
var r = c.modn(groupBase).toString(base);
c = c.idivn(groupBase);
if (!c.isZero()) out = zeros[groupSize - r.length] + r + out;
else out = r + out;
}
if (this.isZero()) out = "0" + out;
while (out.length % padding !== 0) out = "0" + out;
if (this.negative !== 0) out = "-" + out;
return out;
}
assert(false, "Base should be between 2 and 36");
};
BN.prototype.toNumber = function 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) assert(false, "Number can only safely store up to 53 bits");
return this.negative !== 0 ? -ret : ret;
};
BN.prototype.toJSON = function toJSON() {
return this.toString(16);
};
BN.prototype.toBuffer = function toBuffer(endian, length) {
assert(typeof Buffer !== "undefined");
return this.toArrayLike(Buffer, endian, length);
};
BN.prototype.toArray = function toArray(endian, length) {
return this.toArrayLike(Array, endian, length);
};
BN.prototype.toArrayLike = function toArrayLike(ArrayType, endian, length) {
var byteLength = this.byteLength();
var reqLength = length || Math.max(1, byteLength);
assert(byteLength <= reqLength, "byte array longer than desired length");
assert(reqLength > 0, "Requested array length <= 0");
this.strip();
var littleEndian = endian === "le";
var res = new ArrayType(reqLength);
var b, 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) BN.prototype._countBits = function _countBits(w) {
return 32 - Math.clz32(w);
};
else BN.prototype._countBits = function _countBits(w) {
var t = w;
var r = 0;
if (t >= 4096) {
r += 13;
t >>>= 13;
}
if (t >= 64) {
r += 7;
t >>>= 7;
}
if (t >= 8) {
r += 4;
t >>>= 4;
}
if (t >= 2) {
r += 2;
t >>>= 2;
}
return r + t;
};
BN.prototype._zeroBits = function _zeroBits(w) {
if (w === 0) return 26;
var t = w;
var r = 0;
if ((t & 8191) === 0) {
r += 13;
t >>>= 13;
}
if ((t & 127) === 0) {
r += 7;
t >>>= 7;
}
if ((t & 15) === 0) {
r += 4;
t >>>= 4;
}
if ((t & 3) === 0) {
r += 2;
t >>>= 2;
}
if ((t & 1) === 0) r++;
return r;
};
BN.prototype.bitLength = function bitLength() {
var w = this.words[this.length - 1];
var hi = this._countBits(w);
return (this.length - 1) * 26 + hi;
};
function toBitArray(num) {
var w = new Array(num.bitLength());
for (var bit = 0; bit < w.length; bit++) {
var off = bit / 26 | 0;
var wbit = bit % 26;
w[bit] = (num.words[off] & 1 << wbit) >>> wbit;
}
return w;
}
BN.prototype.zeroBits = function zeroBits() {
if (this.isZero()) return 0;
var r = 0;
for (var i = 0; i < this.length; i++) {
var b = this._zeroBits(this.words[i]);
r += b;
if (b !== 26) break;
}
return r;
};
BN.prototype.byteLength = function byteLength() {
return Math.ceil(this.bitLength() / 8);
};
BN.prototype.toTwos = function toTwos(width) {
if (this.negative !== 0) return this.abs().inotn(width).iaddn(1);
return this.clone();
};
BN.prototype.fromTwos = function fromTwos(width) {
if (this.testn(width - 1)) return this.notn(width).iaddn(1).ineg();
return this.clone();
};
BN.prototype.isNeg = function isNeg() {
return this.negative !== 0;
};
BN.prototype.neg = function neg() {
return this.clone().ineg();
};
BN.prototype.ineg = function ineg() {
if (!this.isZero()) this.negative ^= 1;
return this;
};
BN.prototype.iuor = function iuor(num) {
while (this.length < num.length) this.words[this.length++] = 0;
for (var i = 0; i < num.length; i++) this.words[i] = this.words[i] | num.words[i];
return this.strip();
};
BN.prototype.ior = function ior(num) {
assert((this.negative | num.negative) === 0);
return this.iuor(num);
};
BN.prototype.or = function or(num) {
if (this.length > num.length) return this.clone().ior(num);
return num.clone().ior(this);
};
BN.prototype.uor = function uor(num) {
if (this.length > num.length) return this.clone().iuor(num);
return num.clone().iuor(this);
};
BN.prototype.iuand = function iuand(num) {
var b;
if (this.length > num.length) b = num;
else b = this;
for (var i = 0; i < b.length; i++) this.words[i] = this.words[i] & num.words[i];
this.length = b.length;
return this.strip();
};
BN.prototype.iand = function iand(num) {
assert((this.negative | num.negative) === 0);
return this.iuand(num);
};
BN.prototype.and = function and(num) {
if (this.length > num.length) return this.clone().iand(num);
return num.clone().iand(this);
};
BN.prototype.uand = function uand(num) {
if (this.length > num.length) return this.clone().iuand(num);
return num.clone().iuand(this);
};
BN.prototype.iuxor = function iuxor(num) {
var a;
var b;
if (this.length > num.length) {
a = this;
b = num;
} else {
a = num;
b = this;
}
for (var 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();
};
BN.prototype.ixor = function ixor(num) {
assert((this.negative | num.negative) === 0);
return this.iuxor(num);
};
BN.prototype.xor = function xor(num) {
if (this.length > num.length) return this.clone().ixor(num);
return num.clone().ixor(this);
};
BN.prototype.uxor = function uxor(num) {
if (this.length > num.length) return this.clone().iuxor(num);
return num.clone().iuxor(this);
};
BN.prototype.inotn = function inotn(width) {
assert(typeof width === "number" && width >= 0);
var bytesNeeded = Math.ceil(width / 26) | 0;
var bitsLeft = width % 26;
this._expand(bytesNeeded);
if (bitsLeft > 0) bytesNeeded--;
for (var 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();
};
BN.prototype.notn = function notn(width) {
return this.clone().inotn(width);
};
BN.prototype.setn = function setn(bit, val) {
assert(typeof bit === "number" && bit >= 0);
var off = bit / 26 | 0;
var wbit = bit % 26;
this._expand(off + 1);
if (val) this.words[off] = this.words[off] | 1 << wbit;
else this.words[off] = this.words[off] & ~(1 << wbit);
return this.strip();
};
BN.prototype.iadd = function iadd(num) {
var r;
if (this.negative !== 0 && num.negative === 0) {
this.negative = 0;
r = this.isub(num);
this.negative ^= 1;
return this._normSign();
} else if (this.negative === 0 && num.negative !== 0) {
num.negative = 0;
r = this.isub(num);
num.negative = 1;
return r._normSign();
}
var a, b;
if (this.length > num.length) {
a = this;
b = num;
} else {
a = num;
b = this;
}
var carry = 0;
for (var i = 0; i < b.length; i++) {
r = (a.words[i] | 0) + (b.words[i] | 0) + carry;
this.words[i] = r & 67108863;
carry = r >>> 26;
}
for (; carry !== 0 && i < a.length; i++) {
r = (a.words[i] | 0) + carry;
this.words[i] = r & 67108863;
carry = r >>> 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;
};
BN.prototype.add = function add(num) {
var res;
if (num.negative !== 0 && this.negative === 0) {
num.negative = 0;
res = this.sub(num);
num.negative ^= 1;
return res;
} else if (num.negative === 0 && this.negative !== 0) {
this.negative = 0;
res = num.sub(this);
this.negative = 1;
return res;
}
if (this.length > num.length) return this.clone().iadd(num);
return num.clone().iadd(this);
};
BN.prototype.isub = function isub(num) {
if (num.negative !== 0) {
num.negative = 0;
var r = this.iadd(num);
num.negative = 1;
return r._normSign();
} else if (this.negative !== 0) {
this.negative = 0;
this.iadd(num);
this.negative = 1;
return this._normSign();
}
var cmp = this.cmp(num);
if (cmp === 0) {
this.negative = 0;
this.length = 1;
this.words[0] = 0;
return this;
}
var a, b;
if (cmp > 0) {
a = this;
b = num;
} else {
a = num;
b = this;
}
var carry = 0;
for (var i = 0; i < b.length; i++) {
r = (a.words[i] | 0) - (b.words[i] | 0) + carry;
carry = r >> 26;
this.words[i] = r & 67108863;
}
for (; carry !== 0 && i < a.length; i++) {
r = (a.words[i] | 0) + carry;
carry = r >> 26;
this.words[i] = r & 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();
};
BN.prototype.sub = function sub(num) {
return this.clone().isub(num);
};
function smallMulTo(self, num, out) {
out.negative = num.negative ^ self.negative;
var len = self.length + num.length | 0;
out.length = len;
len = len - 1 | 0;
var a = self.words[0] | 0;
var b = num.words[0] | 0;
var r = a * b;
var lo = r & 67108863;
var carry = r / 67108864 | 0;
out.words[0] = lo;
for (var k = 1; k < 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 - self.length + 1); j <= maxJ; j++) {
var i = k - j | 0;
a = self.words[i] | 0;
b = num.words[j] | 0;
r = a * b + rword;
ncarry += r / 67108864 | 0;
rword = r & 67108863;
}
out.words[k] = rword | 0;
carry = ncarry | 0;
}
if (carry !== 0) out.words[k] = carry | 0;
else out.length--;
return out.strip();
}
var comb10MulTo = function comb10MulTo(self, num, out) {
var a = self.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 = self.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(self, num, out) {
out.negative = num.negative ^ self.negative;
out.length = self.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 - self.length + 1); j <= maxJ; j++) {
var i = k - j;
var r = (self.words[i] | 0) * (num.words[j] | 0);
var lo = r & 67108863;
ncarry = ncarry + (r / 67108864 | 0) | 0;
lo = lo + rword | 0;
rword = lo & 67108863;
ncarry = ncarry + (lo >>> 26) | 0;
hncarry += ncarry >>> 26;
ncarry &= 67108863;
}
out.words[k] = rword;
carry = ncarry;
ncarry = hncarry;
}
if (carry !== 0) out.words[k] = carry;
else out.length--;
return out.strip();
}
function jumboMulTo(self, num, out) {
return new FFTM().mulp(self, num, out);
}
BN.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 = BN.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 permute(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 s = 1; s < N; s <<= 1) {
var l = s << 1;
var rtwdf = Math.cos(2 * Math.PI / l);
var itwdf = Math.sin(2 * Math.PI / l);
for (var p = 0; p < N; p += l) {
var rtwdf_ = rtwdf;
var itwdf_ = itwdf;
for (var j = 0; j < s; j++) {
var re = rtws[p + j];
var ie = itws[p + j];
var ro = rtws[p + j + s];
var io = itws[p + j + s];
var rx = rtwdf_ * ro - itwdf_ * io;
io = rtwdf_ * io + itwdf_ * ro;
ro = rx;
rtws[p + j] = re + ro;
itws[p + j] = ie + io;
rtws[p + j + s] = re - ro;
itws[p + j + s] = ie - io;
if (j !== l) {
rx = rtwdf * rtwdf_ - itwdf * itwdf_;
itwdf_ = rtwdf * itwdf_ + itwdf * rtwdf_;
rtwdf_ = rx;
}
}
}
}
};
FFTM.prototype.guessLen13b = function guessLen13b(n, m) {
var N = Math.max(m, n) | 1;
var odd = N & 1;
var 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;
assert(carry === 0);
assert((carry & -8192) === 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();
};
BN.prototype.mul = function mul(num) {
var out = new BN(null);
out.words = new Array(this.length + num.length);
return this.mulTo(num, out);
};
BN.prototype.mulf = function mulf(num) {
var out = new BN(null);
out.words = new Array(this.length + num.length);
return jumboMulTo(this, num, out);
};
BN.prototype.imul = function imul(num) {
return this.clone().mulTo(num, this);
};
BN.prototype.imuln = function imuln(num) {
assert(typeof num === "number");
assert(num < 67108864);
var carry = 0;
for (var 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;
};
BN.prototype.muln = function muln(num) {
return this.clone().imuln(num);
};
BN.prototype.sqr = function sqr() {
return this.mul(this);
};
BN.prototype.isqr = function isqr() {
return this.imul(this.clone());
};
BN.prototype.pow = function pow(num) {
var w = toBitArray(num);
if (w.length === 0) return new BN(1);
var res = this;
for (var 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;
};
BN.prototype.iushln = function iushln(bits) {
assert(typeof bits === "number" && bits >= 0);
var r = bits % 26;
var s = (bits - r) / 26;
var carryMask = 67108863 >>> 26 - r << 26 - r;
var i;
if (r !== 0) {
var carry = 0;
for (i = 0; i < this.length; i++) {
var newCarry = this.words[i] & carryMask;
var c = (this.words[i] | 0) - newCarry << r;
this.words[i] = c | carry;
carry = newCarry >>> 26 - r;
}
if (carry) {
this.words[i] = carry;
this.length++;
}
}
if (s !== 0) {
for (i = this.length - 1; i >= 0; i--) this.words[i + s] = this.words[i];
for (i = 0; i < s; i++) this.words[i] = 0;
this.length += s;
}
return this.strip();
};
BN.prototype.ishln = function ishln(bits) {
assert(this.negative === 0);
return this.iushln(bits);
};
BN.prototype.iushrn = function iushrn(bits, hint, extended) {
assert(typeof bits === "number" && bits >= 0);
var h;
if (hint) h = (hint - hint % 26) / 26;
else h = 0;
var r = bits % 26;
var s = Math.min((bits - r) / 26, this.length);
var mask = 67108863 ^ 67108863 >>> r << r;
var maskedWords = extended;
h -= s;
h = Math.max(0, h);
if (maskedWords) {
for (var i = 0; i < s; i++) maskedWords.words[i] = this.words[i];
maskedWords.length = s;
}
if (s === 0) {} else if (this.length > s) {
this.length -= s;
for (i = 0; i < this.length; i++) this.words[i] = this.words[i + s];
} 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 - r | word >>> r;
carry = word & mask;
}
if (maskedWords && carry !== 0) maskedWords.words[maskedWords.length++] = carry;
if (this.length === 0) {
this.words[0] = 0;
this.length = 1;
}
return this.strip();
};
BN.prototype.ishrn = function ishrn(bits, hint, extended) {
assert(this.negative === 0);
return this.iushrn(bits, hint, extended);
};
BN.prototype.shln = function shln(bits) {
return this.clone().ishln(bits);
};
BN.prototype.ushln = function ushln(bits) {
return this.clone().iushln(bits);
};
BN.prototype.shrn = function shrn(bits) {
return this.clone().ishrn(bits);
};
BN.prototype.ushrn = function ushrn(bits) {
return this.clone().iushrn(bits);
};
BN.prototype.testn = function testn(bit) {
assert(typeof bit === "number" && bit >= 0);
var r = bit % 26;
var s = (bit - r) / 26;
var q = 1 << r;
if (this.length <= s) return false;
return !!(this.words[s] & q);
};
BN.prototype.imaskn = function imaskn(bits) {
assert(typeof bits === "number" && bits >= 0);
var r = bits % 26;
var s = (bits - r) / 26;
assert(this.negative === 0, "imaskn works only with positive numbers");
if (this.length <= s) return this;
if (r !== 0) s++;
this.length = Math.min(s, this.length);
if (r !== 0) {
var mask = 67108863 ^ 67108863 >>> r << r;
this.words[this.length - 1] &= mask;
}
return this.strip();
};
BN.prototype.maskn = function maskn(bits) {
return this.clone().imaskn(bits);
};
BN.prototype.iaddn = function iaddn(num) {
assert(typeof num === "number");
assert(num < 67108864);
if (num < 0) return this.isubn(-num);
if (this.negative !== 0) {
if (this.length === 1 && (this.words[0] | 0) < num) {
this.words[0] = num - (this.words[0] | 0);
this.negative = 0;
return this;
}
this.negative = 0;
this.isubn(num);
this.negative = 1;
return this;
}
return this._iaddn(num);
};
BN.prototype._iaddn = function _iaddn(num) {
this.words[0] += num;
for (var 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;
};
BN.prototype.isubn = function isubn(num) {
assert(typeof num === "number");
assert(num < 67108864);
if (num < 0) return this.iaddn(-num);
if (this.negative !== 0) {
this.negative = 0;
this.iaddn(num);
this.negative = 1;
return this;
}
this.words[0] -= num;
if (this.length === 1 && this.words[0] < 0) {
this.words[0] = -this.words[0];
this.negative = 1;
} else for (var i = 0; i < this.length && this.words[i] < 0; i++) {
this.words[i] += 67108864;
this.words[i + 1] -= 1;
}
return this.strip();
};
BN.prototype.addn = function addn(num) {
return this.clone().iaddn(num);
};
BN.prototype.subn = function subn(num) {
return this.clone().isubn(num);
};
BN.prototype.iabs = function iabs() {
this.negative = 0;
return this;
};
BN.prototype.abs = function abs() {
return this.clone().iabs();
};
BN.prototype._ishlnsubmul = function _ishlnsubmul(num, mul, shift) {
var 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) * mul;
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();
assert(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();
};
BN.prototype._wordDiv = function _wordDiv(num, mode) {
var shift = this.length - num.length;
var a = this.clone();
var b = num;
var bhi = b.words[b.length - 1] | 0;
shift = 26 - this._countBits(bhi);
if (shift !== 0) {
b = b.ushln(shift);
a.iushln(shift);
bhi = b.words[b.length - 1] | 0;
}
var m = a.length - b.length;
var q;
if (mode !== "mod") {
q = new BN(null);
q.length = m + 1;
q.words = new Array(q.length);
for (var 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
};
};
BN.prototype.divmod = function divmod(num, mode, positive) {
assert(!num.isZero());
if (this.isZero()) return {
div: new BN(0),
mod: new BN(0)
};
var div, mod, res;
if (this.negative !== 0 && num.negative === 0) {
res = this.neg().divmod(num, mode);
if (mode !== "mod") div = res.div.neg();
if (mode !== "div") {
mod = res.mod.neg();
if (positive && mod.negative !== 0) mod.iadd(num);
}
return {
div,
mod
};
}
if (this.negative === 0 && num.negative !== 0) {
res = this.divmod(num.neg(), mode);
if (mode !== "mod") div = res.div.neg();
return {
div,
mod: res.mod
};
}
if ((this.negative & num.negative) !== 0) {
res = this.neg().divmod(num.neg(), mode);
if (mode !== "div") {
mod = res.mod.neg();
if (positive && mod.negative !== 0) mod.isub(num);
}
return {
div: res.div,
mod
};
}
if (num.length > this.length || this.cmp(num) < 0) return {
div: new BN(0),
mod: this
};
if (num.length === 1) {
if (mode === "div") return {
div: this.divn(num.words[0]),
mod: null
};
if (mode === "mod") return {
div: null,
mod: new BN(this.modn(num.words[0]))
};
return {
div: this.divn(num.words[0]),
mod: new BN(this.modn(num.words[0]))
};
}
return this._wordDiv(num, mode);
};
BN.prototype.div = function div(num) {
return this.divmod(num, "div", false).div;
};
BN.prototype.mod = function mod(num) {
return this.divmod(num, "mod", false).mod;
};
BN.prototype.umod = function umod(num) {
return this.divmod(num, "mod", true).mod;
};
BN.prototype.divRound = function divRound(num) {
var dm = this.divmod(num);
if (dm.mod.isZero()) return dm.div;
var mod = dm.div.negative !== 0 ? dm.mod.isub(num) : dm.mod;
var half = num.ushrn(1);
var r2 = num.andln(1);
var cmp = mod.cmp(half);
if (cmp < 0 || r2 === 1 && cmp === 0) return dm.div;
return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1);
};
BN.prototype.modn = function modn(num) {
assert(num <= 67108863);
var p = (1 << 26) % num;
var acc = 0;
for (var i = this.length - 1; i >= 0; i--) acc = (p * acc + (this.words[i] | 0)) % num;
return acc;
};
BN.prototype.idivn = function idivn(num) {
assert(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();
};
BN.prototype.divn = function divn(num) {
return this.clone().idivn(num);
};
BN.prototype.egcd = function egcd(p) {
assert(p.negative === 0);
assert(!p.isZero());
var x = this;
var y = p.clone();
if (x.negative !== 0) x = x.umod(p);
else x = x.clone();
var A = new BN(1);
var B = new BN(0);
var C = new BN(0);
var D = new BN(1);
var g = 0;
while (x.isEven() && y.isEven()) {
x.iushrn(1);
y.iushrn(1);
++g;
}
var yp = y.clone();
var xp = x.clone();
while (!x.isZero()) {
for (var 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(g)
};
};
BN.prototype._invmp = function _invmp(p) {
assert(p.negative === 0);
assert(!p.isZero());
var a = this;
var b = p.clone();
if (a.negative !== 0) a = a.umod(p);
else a = a.clone();
var x1 = new BN(1);
var x2 = new BN(0);
var delta = b.clone();
while (a.cmpn(1) > 0 && b.cmpn(1) > 0) {
for (var 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;
};
BN.prototype.gcd = function gcd(num) {
if (this.isZero()) return num.abs();
if (num.isZero()) return this.abs();
var a = this.clone();
var b = num.clone();
a.negative = 0;
b.negative = 0;
for (var shift = 0; a.isEven() && b.isEven(); shift++) {
a.iushrn(1);
b.iushrn(1);
}
do {
while (a.isEven()) a.iushrn(1);
while (b.isEven()) b.iushrn(1);
var r = a.cmp(b);
if (r < 0) {
var t = a;
a = b;
b = t;
} else if (r === 0 || b.cmpn(1) === 0) break;
a.isub(b);
} while (true);
return b.iushln(shift);
};
BN.prototype.invm = function invm(num) {
return this.egcd(num).a.umod(num);
};
BN.prototype.isEven = function isEven() {
return (this.words[0] & 1) === 0;
};
BN.prototype.isOdd = function isOdd() {
return (this.words[0] & 1) === 1;
};
BN.prototype.andln = function andln(num) {
return this.words[0] & num;
};
BN.prototype.bincn = function bincn(bit) {
assert(typeof bit === "number");
var r = bit % 26;
var s = (bit - r) / 26;
var q = 1 << r;
if (this.length <= s) {
this._expand(s + 1);
this.words[s] |= q;
return this;
}
var carry = q;
for (var i = s; 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;
};
BN.prototype.isZero = function isZero() {
return this.length === 1 && this.words[0] === 0;
};
BN.prototype.cmpn = function cmpn(num) {
var negative = num < 0;
if (this.negative !== 0 && !negative) return -1;
if (this.negative === 0 && negative) return 1;
this.strip();
var res;
if (this.length > 1) res = 1;
else {
if (negative) num = -num;
assert(num <= 67108863, "Number is too big");
var w = this.words[0] | 0;
res = w === num ? 0 : w < num ? -1 : 1;
}
if (this.negative !== 0) return -res | 0;
return res;
};
BN.prototype.cmp = function cmp(num) {
if (this.negative !== 0 && num.negative === 0) return -1;
if (this.negative === 0 && num.negative !== 0) return 1;
var res = this.ucmp(num);
if (this.negative !== 0) return -res | 0;
return res;
};
BN.prototype.ucmp = function ucmp(num) {
if (this.length > num.length) return 1;
if (this.length < num.length) return -1;
var res = 0;
for (var 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;
};
BN.prototype.gtn = function gtn(num) {
return this.cmpn(num) === 1;
};
BN.prototype.gt = function gt(num) {
return this.cmp(num) === 1;
};
BN.prototype.gten = function gten(num) {
return this.cmpn(num) >= 0;
};
BN.prototype.gte = function gte(num) {
return this.cmp(num) >= 0;
};
BN.prototype.ltn = function ltn(num) {
return this.cmpn(num) === -1;
};
BN.prototype.lt = function lt(num) {
return this.cmp(num) === -1;
};
BN.prototype.lten = function lten(num) {
return this.cmpn(num) <= 0;
};
BN.prototype.lte = function lte(num) {
return this.cmp(num) <= 0;
};
BN.prototype.eqn = function eqn(num) {
return this.cmpn(num) === 0;
};
BN.prototype.eq = function eq(num) {
return this.cmp(num) === 0;
};
BN.red = function red(num) {
return new Red(num);
};
BN.prototype.toRed = function toRed(ctx) {
assert(!this.red, "Already a number in reduction context");
assert(this.negative === 0, "red works only with positives");
return ctx.convertTo(this)._forceRed(ctx);
};
BN.prototype.fromRed = function fromRed() {
assert(this.red, "fromRed works only with numbers in reduction context");
return this.red.convertFrom(this);
};
BN.prototype._forceRed = function _forceRed(ctx) {
this.red = ctx;
return this;
};
BN.prototype.forceRed = function forceRed(ctx) {
assert(!this.red, "Already a number in reduction context");
return this._forceRed(ctx);
};
BN.prototype.redAdd = function redAdd(num) {
assert(this.red, "redAdd works only with red numbers");
return this.red.add(this, num);
};
BN.prototype.redIAdd = function redIAdd(num) {
assert(this.red, "redIAdd works only with red numbers");
return this.red.iadd(this, num);
};
BN.prototype.redSub = function redSub(num) {
assert(this.red, "redSub works only with red numbers");
return this.red.sub(this, num);
};
BN.prototype.redISub = function redISub(num) {
assert(this.red, "redISub works only with red numbers");
return this.red.isub(this, num);
};
BN.prototype.redShl = function redShl(num) {
assert(this.red, "redShl works only with red numbers");
return this.red.shl(this, num);
};
BN.prototype.redMul = function redMul(num) {
assert(this.red, "redMul works only with red numbers");
this.red._verify2(this, num);
return this.red.mul(this, num);
};
BN.prototype.redIMul = function redIMul(num) {
assert(this.red, "redMul works only with red numbers");
this.red._verify2(this, num);
return this.red.imul(this, num);
};
BN.prototype.redSqr = function redSqr() {
assert(this.red, "redSqr works only with red numbers");
this.red._verify1(this);
return this.red.sqr(this);
};
BN.prototype.redISqr = function redISqr() {
assert(this.red, "redISqr works only with red numbers");
this.red._verify1(this);
return this.red.isqr(this);
};
BN.prototype.redSqrt = function redSqrt() {
assert(this.red, "redSqrt works only with red numbers");
this.red._verify1(this);
return this.red.sqrt(this);
};
BN.prototype.redInvm = function redInvm() {
assert(this.red, "redInvm works only with red numbers");
this.red._verify1(this);
return this.red.invm(this);
};
BN.prototype.redNeg = function redNeg() {
assert(this.red, "redNeg works only with red numbers");
this.red._verify1(this);
return this.red.neg(this);
};
BN.prototype.redPow = function redPow(num) {
assert(this.red && !num.red, "redPow(normalNum)");
this.red._verify1(this);
return this.red.pow(this, num);
};
var primes = {
k256: null,
p224: null,
p192: null,
p25519: null
};
function MPrime(name, p) {
this.name = name;
this.p = new BN(p, 16);
this.n = this.p.bitLength();
this.k = new BN(1).iushln(this.n).isub(this.p);
this.tmp = this._tmp();
}
MPrime.prototype._tmp = function _tmp() {
var tmp = new BN(null);
tmp.words = new Array(Math.ceil(this.n / 13));
return tmp;
};
MPrime.prototype.ireduce = function ireduce(num) {
var r = num;
var rlen;
do {
this.split(r, this.tmp);
r = this.imulK(r);
r = r.iadd(this.tmp);
rlen = r.bitLength();
} while (rlen > this.n);
var cmp = rlen < this.n ? -1 : r.ucmp(this.p);
if (cmp === 0) {
r.words[0] = 0;
r.length = 1;
} else if (cmp > 0) r.isub(this.p);
else if (r.strip !== void 0) r.strip();
else r._strip();
return r;
};
MPrime.prototype.split = function split(input, out) {
input.iushrn(this.n, 0, out);
};
MPrime.prototype.imulK = function imulK(num) {
return num.imul(this.k);
};
function K256() {
MPrime.call(this, "k256", "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f");
}
inherits(K256, MPrime);
K256.prototype.split = function split(input, output) {
var mask = 4194303;
var outLen = Math.min(input.length, 9);
for (var 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");
}
inherits(P224, MPrime);
function P192() {
MPrime.call(this, "p192", "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff");
}
inherits(P192, MPrime);
function P25519() {
MPrime.call(this, "25519", "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed");
}
inherits(P25519, MPrime);
P25519.prototype.imulK = function imulK(num) {
var carry = 0;
for (var 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;
};
BN._prime = function prime(name) {
if (primes[name]) return primes[name];
var prime;
if (name === "k256") prime = new K256();
else if (name === "p224") prime = new P224();
else if (name === "p192") prime = new P192();
else if (name === "p25519") prime = new P25519();
else throw new Error("Unknown prime " + name);
primes[name] = prime;
return prime;
};
function Red(m) {
if (typeof m === "string") {
var prime = BN._prime(m);
this.m = prime.p;
this.prime = prime;
} else {
assert(m.gtn(1), "modulus must be greater than 1");
this.m = m;
this.prime = null;
}
}
Red.prototype._verify1 = function _verify1(a) {
assert(a.negative === 0, "red works only with positives");
assert(a.red, "red works only with red numbers");
};
Red.prototype._verify2 = function _verify2(a, b) {
assert((a.negative | b.negative) === 0, "red works only with positives");
assert(a.red && a.red === b.red, "red works only with red numbers");
};
Red.prototype.imod = function imod(a) {
if (this.prime) return this.prime.ireduce(a)._forceRed(this);
return a.umod(this.m)._forceRed(this);
};
Red.prototype.neg = function neg(a) {
if (a.isZero()) return a.clone();
return this.m.sub(a)._forceRed(this);
};
Red.prototype.add = function add(a, b) {
this._verify2(a, b);
var res = a.add(b);
if (res.cmp(this.m) >= 0) res.isub(this.m);
return res._forceRed(this);
};
Red.prototype.iadd = function iadd(a, b) {
this._verify2(a, b);
var res = a.iadd(b);
if (res.cmp(this.m) >= 0) res.isub(this.m);
return res;
};
Red.prototype.sub = function sub(a, b) {
this._verify2(a, b);
var res = a.sub(b);
if (res.cmpn(0) < 0) res.iadd(this.m);
return res._forceRed(this);
};
Red.prototype.isub = function isub(a, b) {
this._verify2(a, b);
var res = a.isub(b);
if (res.cmpn(0) < 0) res.iadd(this.m);
return res;
};
Red.prototype.shl = function shl(a, num) {
this._verify1(a);
return this.imod(a.ushln(num));
};
Red.prototype.imul = function imul(a, b) {
this._verify2(a, b);
return this.imod(a.imul(b));
};
Red.prototype.mul = function mul(a, b) {
this._verify2(a, b);
return this.imod(a.mul(b));
};
Red.prototype.isqr = function isqr(a) {
return this.imul(a, a.clone());
};
Red.prototype.sqr = function sqr(a) {
return this.mul(a, a);
};
Red.prototype.sqrt = function sqrt(a) {
if (a.isZero()) return a.clone();
var mod3 = this.m.andln(3);
assert(mod3 % 2 === 1);
if (mod3 === 3) {
var pow = this.m.add(new BN(1)).iushrn(2);
return this.pow(a, pow);
}
var q = this.m.subn(1);
var s = 0;
while (!q.isZero() && q.andln(1) === 0) {
s++;
q.iushrn(1);
}
assert(!q.isZero());
var one = new BN(1).toRed(this);
var nOne = one.redNeg();
var lpow = this.m.subn(1).iushrn(1);
var z = this.m.bitLength();
z = new BN(2 * z * z).toRed(this);
while (this.pow(z, lpow).cmp(nOne) !== 0) z.redIAdd(nOne);
var c = this.pow(z, q);
var r = this.pow(a, q.addn(1).iushrn(1));
var t = this.pow(a, q);
var m = s;
while (t.cmp(one) !== 0) {
var tmp = t;
for (var i = 0; tmp.cmp(one) !== 0; i++) tmp = tmp.redSqr();
assert(i < m);
var b = this.pow(c, new BN(1).iushln(m - i - 1));
r = r.redMul(b);
c = b.redSqr();
t = t.redMul(c);
m = i;
}
return r;
};
Red.prototype.invm = function invm(a) {
var inv = a._invmp(this.m);
if (inv.negative !== 0) {
inv.negative = 0;
return this.imod(inv).redNeg();
} else return this.imod(inv);
};
Red.prototype.pow = function pow(a, num) {
if (num.isZero()) return new BN(1).toRed(this);
if (num.cmpn(1) === 0) return a.clone();
var windowSize = 4;
var wnd = new Array(1 << windowSize);
wnd[0] = new BN(1).toRed(this);
wnd[1] = a;
for (var 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 r = num.umod(this.m);
return r === num ? r.clone() : r;
};
Red.prototype.convertFrom = function convertFrom(num) {
var res = num.clone();
res.red = null;
return res;
};
BN.mont = function mont(num) {
return new Mont(num);
};
function Mont(m) {
Red.call(this, m);
this.shift = this.m.bitLength();
if (this.shift % 26 !== 0) this.shift += 26 - this.shift % 26;
this.r = new BN(1).iushln(this.shift);
this.r2 = this.imod(this.r.sqr());
this.rinv = this.r._invmp(this.m);
this.minv = this.rinv.mul(this.r).isubn(1).div(this.m);
this.minv = this.minv.umod(this.r);
this.minv = this.r.sub(this.minv);
}
inherits(Mont, Red);
Mont.prototype.convertTo = function convertTo(num) {
return this.imod(num.ushln(this.shift));
};
Mont.prototype.convertFrom = function convertFrom(num) {
var r = this.imod(num.mul(this.rinv));
r.red = null;
return r;
};
Mont.prototype.imul = function imul(a, b) {
if (a.isZero() || b.isZero()) {
a.words[0] = 0;
a.length = 1;
return a;
}
var t = a.imul(b);
var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
var u = t.isub(c).iushrn(this.shift);
var res = u;
if (u.cmp(this.m) >= 0) res = u.isub(this.m);
else if (u.cmpn(0) < 0) res = u.iadd(this.m);
return res._forceRed(this);
};
Mont.prototype.mul = function mul(a, b) {
if (a.isZero() || b.isZero()) return new BN(0)._forceRed(this);
var t = a.mul(b);
var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
var u = t.isub(c).iushrn(this.shift);
var res = u;
if (u.cmp(this.m) >= 0) res = u.isub(this.m);
else if (u.cmpn(0) < 0) res = u.iadd(this.m);
return res._forceRed(this);
};
Mont.prototype.invm = function invm(a) {
return this.imod(a._invmp(this.m).mul(this.r2))._forceRed(this);
};
})(typeof module === "undefined" || module, exports);
}));
//#endregion
//#region node_modules/brorand/index.js
var require_brorand = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var r;
module.exports = function rand(len) {
if (!r) r = new Rand(null);
return r.generate(len);
};
function Rand(rand) {
this.rand = rand;
}
module.exports.Rand = Rand;
Rand.prototype.generate = function generate(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 crypto = require_crypto_browserify();
if (typeof crypto.randomBytes !== "function") throw new Error("Not supported");
Rand.prototype._rand = function _rand(n) {
return crypto.randomBytes(n);
};
} catch (e) {}
}));
//#endregion
//#region node_modules/miller-rabin/lib/mr.js
var require_mr = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var bn = require_bn$5();
var brorand = require_brorand();
function MillerRabin(rand) {
this.rand = rand || new brorand.Rand();
}
module.exports = MillerRabin;
MillerRabin.create = function create(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 bn(this.rand.generate(min_bytes));
while (a.cmp(n) >= 0);
return a;
};
MillerRabin.prototype._randrange = function _randrange(start, stop) {
var size = stop.sub(start);
return start.add(this._randbelow(size));
};
MillerRabin.prototype.test = function test(n, k, cb) {
var len = n.bitLength();
var red = bn.mont(n);
var rone = new bn(1).toRed(red);
if (!k) k = Math.max(1, len / 48 | 0);
var n1 = n.subn(1);
for (var s = 0; !n1.testn(s); s++);
var d = n.shrn(s);
var rn1 = n1.toRed(red);
var prime = true;
for (; k > 0; k--) {
var a = this._randrange(new bn(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 < s; i++) {
x = x.redSqr();
if (x.cmp(rone) === 0) return false;
if (x.cmp(rn1) === 0) break;
}
if (i === s) return false;
}
return prime;
};
MillerRabin.prototype.getDivisor = function getDivisor(n, k) {
var len = n.bitLength();
var red = bn.mont(n);
var rone = new bn(1).toRed(red);
if (!k) k = Math.max(1, len / 48 | 0);
var n1 = n.subn(1);
for (var s = 0; !n1.testn(s); s++);
var d = n.shrn(s);
var rn1 = n1.toRed(red);
for (; k > 0; k--) {
var a = this._randrange(new bn(2), n1);
var g = n.gcd(a);
if (g.cmpn(1) !== 0) return g;
var x = a.toRed(red).redPow(d);
if (x.cmp(rone) === 0 || x.cmp(rn1) === 0) continue;
for (var i = 1; i < s; i++) {
x = x.redSqr();
if (x.cmp(rone) === 0) return x.fromRed().subn(1).gcd(n);
if (x.cmp(rn1) === 0) break;
}
if (i === s) {
x = x.redSqr();
return x.fromRed().subn(1).gcd(n);
}
}
return false;
};
}));
//#endregion
//#region node_modules/diffie-hellman/lib/generatePrime.js
var require_generatePrime = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var randomBytes = require_browser$11();
module.exports = findPrime;
findPrime.simpleSieve = simpleSieve;
findPrime.fermatTest = fermatTest;
var BN = require_bn$6();
var TWENTYFOUR = new BN(24);
var millerRabin = new (require_mr())();
var ONE = new BN(1);
var TWO = new BN(2);
var FIVE = new BN(5);
new BN(16);
new BN(8);
var TEN = new BN(10);
var THREE = new BN(3);
new BN(7);
var ELEVEN = new BN(11);
var FOUR = new BN(4);
new BN(12);
var primes = null;
function _getPrimes() {
if (primes !== null) return primes;
var limit = 1048576;
var res = [];
res[0] = 2;
for (var 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 primes = _getPrimes();
for (var i = 0; i < primes.length; i++) if (p.modn(primes[i]) === 0) if (p.cmpn(primes[i]) === 0) return true;
else return false;
return true;
}
function fermatTest(p) {
var red = BN.mont(p);
return TWO.toRed(red).redPow(p.subn(1)).fromRed().cmpn(1) === 0;
}
function findPrime(bits, gen) {
if (bits < 16) if (gen === 2 || gen === 5) return new BN([140, 123]);
else return new BN([140, 39]);
gen = new BN(gen);
var num, n2;
while (true) {
num = new BN(randomBytes(Math.ceil(bits / 8)));
while (num.bitLength() > bits) num.ishrn(1);
if (num.isEven()) num.iadd(ONE);
if (!num.testn(1)) num.iadd(TWO);
if (!gen.cmp(TWO)) while (num.mod(TWENTYFOUR).cmp(ELEVEN)) num.iadd(FOUR);
else if (!gen.cmp(FIVE)) while (num.mod(TEN).cmp(THREE)) num.iadd(FOUR);
n2 = num.shrn(1);
if (simpleSieve(n2) && simpleSieve(num) && fermatTest(n2) && fermatTest(num) && millerRabin.test(n2) && millerRabin.test(num)) return num;
}
}
}));
//#endregion
//#region node_modules/diffie-hellman/lib/primes.json
var primes_exports = /* @__PURE__ */ __exportAll({
default: () => primes_default,
modp1: () => modp1,
modp14: () => modp14,
modp15: () => modp15,
modp16: () => modp16,
modp17: () => modp17,
modp18: () => modp18,
modp2: () => modp2,
modp5: () => modp5
});
var modp1, modp2, modp5, modp14, modp15, modp16, modp17, modp18, primes_default;
var init_primes = __esmMin((() => {
modp1 = {
"gen": "02",
"prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a63a3620ffffffffffffffff"
};
modp2 = {
"gen": "02",
"prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece65381ffffffffffffffff"
};
modp5 = {
"gen": "02",
"prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca237327ffffffffffffffff"
};
modp14 = {
"gen": "02",
"prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aacaa68ffffffffffffffff"
};
modp15 = {
"gen": "02",
"prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a93ad2caffffffffffffffff"
};
modp16 = {
"gen": "02",
"prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a92108011a723c12a787e6d788719a10bdba5b2699c327186af4e23c1a946834b6150bda2583e9ca2ad44ce8dbbbc2db04de8ef92e8efc141fbecaa6287c59474e6bc05d99b2964fa090c3a2233ba186515be7ed1f612970cee2d7afb81bdd762170481cd0069127d5b05aa993b4ea988d8fddc186ffb7dc90a6c08f4df435c934063199ffffffffffffffff"
};
modp17 = {
"gen": "02",
"prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a92108011a723c12a787e6d788719a10bdba5b2699c327186af4e23c1a946834b6150bda2583e9ca2ad44ce8dbbbc2db04de8ef92e8efc141fbecaa6287c59474e6bc05d99b2964fa090c3a2233ba186515be7ed1f612970cee2d7afb81bdd762170481cd0069127d5b05aa993b4ea988d8fddc186ffb7dc90a6c08f4df435c93402849236c3fab4d27c7026c1d4dcb2602646dec9751e763dba37bdf8ff9406ad9e530ee5db382f413001aeb06a53ed9027d831179727b0865a8918da3edbebcf9b14ed44ce6cbaced4bb1bdb7f1447e6cc254b332051512bd7af426fb8f401378cd2bf5983ca01c64b92ecf032ea15d1721d03f482d7ce6e74fef6d55e702f46980c82b5a84031900b1c9e59e7c97fbec7e8f323a97a7e36cc88be0f1d45b7ff585ac54bd407b22b4154aacc8f6d7ebf48e1d814cc5ed20f8037e0a79715eef29be32806a1d58bb7c5da76f550aa3d8a1fbff0eb19ccb1a313d55cda56c9ec2ef29632387fe8d76e3c0468043e8f663f4860ee12bf2d5b0b7474d6e694f91e6dcc4024ffffffffffffffff"
};
modp18 = {
"gen": "02",
"prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a92108011a723c12a787e6d788719a10bdba5b2699c327186af4e23c1a946834b6150bda2583e9ca2ad44ce8dbbbc2db04de8ef92e8efc141fbecaa6287c59474e6bc05d99b2964fa090c3a2233ba186515be7ed1f612970cee2d7afb81bdd762170481cd0069127d5b05aa993b4ea988d8fddc186ffb7dc90a6c08f4df435c93402849236c3fab4d27c7026c1d4dcb2602646dec9751e763dba37bdf8ff9406ad9e530ee5db382f413001aeb06a53ed9027d831179727b0865a8918da3edbebcf9b14ed44ce6cbaced4bb1bdb7f1447e6cc254b332051512bd7af426fb8f401378cd2bf5983ca01c64b92ecf032ea15d1721d03f482d7ce6e74fef6d55e702f46980c82b5a84031900b1c9e59e7c97fbec7e8f323a97a7e36cc88be0f1d45b7ff585ac54bd407b22b4154aacc8f6d7ebf48e1d814cc5ed20f8037e0a79715eef29be32806a1d58bb7c5da76f550aa3d8a1fbff0eb19ccb1a313d55cda56c9ec2ef29632387fe8d76e3c0468043e8f663f4860ee12bf2d5b0b7474d6e694f91e6dbe115974a3926f12fee5e438777cb6a932df8cd8bec4d073b931ba3bc832b68d9dd300741fa7bf8afc47ed2576f6936ba424663aab639c5ae4f5683423b4742bf1c978238f16cbe39d652de3fdb8befc848ad922222e04a4037c0713eb57a81a23f0c73473fc646cea306b4bcbc8862f8385ddfa9d4b7fa2c087e879683303ed5bdd3a062b3cf5b3a278a66d2a13f83f44f82ddf310ee074ab6a364597e899a0255dc164f31cc50846851df9ab48195ded7ea1b1d510bd7ee74d73faf36bc31ecfa268359046f4eb879f924009438b481c6cd7889a002ed5ee382bc9190da6fc026e479558e4475677e9aa9e3050e2765694dfc81f56e880b96e7160c980dd98edd3dfffffffffffffffff"
};
primes_default = {
modp1,
modp2,
modp5,
modp14,
modp15,
modp16,
modp17,
modp18
};
}));
//#endregion
//#region node_modules/diffie-hellman/lib/dh.js
var require_dh = /* @__PURE__ */ __commonJSMin(((exports, module) => {
init_dist$1();
var BN = require_bn$6();
var millerRabin = new (require_mr())();
var TWENTYFOUR = new BN(24);
var ELEVEN = new BN(11);
var TEN = new BN(10);
var THREE = new BN(3);
var SEVEN = new BN(7);
var primes = require_generatePrime();
var randomBytes = require_browser$11();
module.exports = DH;
function setPublicKey(pub, enc) {
enc = enc || "utf8";
if (!Buffer$1.isBuffer(pub)) pub = new Buffer$1(pub, enc);
this._pub = new BN(pub);
return this;
}
function setPrivateKey(priv, enc) {
enc = enc || "utf8";
if (!Buffer$1.isBuffer(priv)) priv = new Buffer$1(priv, enc);
this._priv = new BN(priv);
return this;
}
var primeCache = {};
function checkPrime(prime, generator) {
var gen = generator.toString("hex");
var hex = [gen, prime.toString(16)].join("_");
if (hex in primeCache) return primeCache[hex];
var error = 0;
if (prime.isEven() || !primes.simpleSieve || !primes.fermatTest(prime) || !millerRabin.test(prime)) {
error += 1;
if (gen === "02" || gen === "05") error += 8;
else error += 4;
primeCache[hex] = error;
return error;
}
if (!millerRabin.test(prime.shrn(1))) error += 2;
var rem;
switch (gen) {
case "02":
if (prime.mod(TWENTYFOUR).cmp(ELEVEN)) error += 8;
break;
case "05":
rem = prime.mod(TEN);
if (rem.cmp(THREE) && rem.cmp(SEVEN)) error += 8;
break;
default: error += 4;
}
primeCache[hex] = error;
return error;
}
function DH(prime, generator, malleable) {
this.setGenerator(generator);
this.__prime = new BN(prime);
this._prime = BN.mont(this.__prime);
this._primeLen = prime.length;
this._pub = void 0;
this._priv = void 0;
this._primeCode = void 0;
if (malleable) {
this.setPublicKey = setPublicKey;
this.setPrivateKey = setPrivateKey;
} else this._primeCode = 8;
}
Object.defineProperty(DH.prototype, "verifyError", {
enumerable: true,
get: function() {
if (typeof this._primeCode !== "number") this._primeCode = checkPrime(this.__prime, this.__gen);
return this._primeCode;
}
});
DH.prototype.generateKeys = function() {
if (!this._priv) this._priv = new BN(randomBytes(this._primeLen));
this._pub = this._gen.toRed(this._prime).redPow(this._priv).fromRed();
return this.getPublicKey();
};
DH.prototype.computeSecret = function(other) {
other = new BN(other);
other = other.toRed(this._prime);
var out = new Buffer$1(other.redPow(this._priv).fromRed().toArray());
var prime = this.getPrime();
if (out.length < prime.length) {
var front = new Buffer$1(prime.length - out.length);
front.fill(0);
out = Buffer$1.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$1.isBuffer(gen)) gen = new Buffer$1(gen, enc);
this.__gen = gen;
this._gen = new BN(gen);
return this;
};
function formatReturnValue(bn, enc) {
var buf = new Buffer$1(bn.toArray());
if (!enc) return buf;
else return buf.toString(enc);
}
}));
//#endregion
//#region node_modules/diffie-hellman/browser.js
var require_browser$5 = /* @__PURE__ */ __commonJSMin(((exports) => {
init_dist$1();
var generatePrime = require_generatePrime();
var primes = (init_primes(), __toCommonJS(primes_exports).default);
var DH = require_dh();
function getDiffieHellman(mod) {
return new DH(new Buffer$1(primes[mod].prime, "hex"), new Buffer$1(primes[mod].gen, "hex"));
}
var ENCODINGS = {
"binary": true,
"hex": true,
"base64": true
};
function createDiffieHellman(prime, enc, generator, genc) {
if (Buffer$1.isBuffer(enc) || ENCODINGS[enc] === void 0) return createDiffieHellman(prime, "binary", enc, generator);
enc = enc || "binary";
genc = genc || "binary";
generator = generator || new Buffer$1([2]);
if (!Buffer$1.isBuffer(generator)) generator = new Buffer$1(generator, genc);
if (typeof prime === "number") return new DH(generatePrime(prime, generator), generator, true);
if (!Buffer$1.isBuffer(prime)) prime = new Buffer$1(prime, enc);
return new DH(prime, generator, true);
}
exports.DiffieHellmanGroup = exports.createDiffieHellmanGroup = exports.getDiffieHellman = getDiffieHellman;
exports.createDiffieHellman = exports.DiffieHellman = createDiffieHellman;
}));
//#endregion
//#region node_modules/browserify-sign/node_modules/safe-buffer/index.js
var require_safe_buffer$3 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
var buffer = require_dist();
var Buffer = buffer.Buffer;
function copyProps(src, dst) {
for (var key in src) dst[key] = src[key];
}
if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) module.exports = buffer;
else {
copyProps(buffer, exports);
exports.Buffer = SafeBuffer;
}
function SafeBuffer(arg, encodingOrOffset, length) {
return Buffer(arg, encodingOrOffset, length);
}
SafeBuffer.prototype = Object.create(Buffer.prototype);
copyProps(Buffer, SafeBuffer);
SafeBuffer.from = function(arg, encodingOrOffset, length) {
if (typeof arg === "number") throw new TypeError("Argument must not be a number");
return Buffer(arg, encodingOrOffset, length);
};
SafeBuffer.alloc = function(size, fill, encoding) {
if (typeof size !== "number") throw new TypeError("Argument must be a number");
var buf = Buffer(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 Buffer(size);
};
SafeBuffer.allocUnsafeSlow = function(size) {
if (typeof size !== "number") throw new TypeError("Argument must be a number");
return buffer.SlowBuffer(size);
};
}));
//#endregion
//#region node_modules/process-nextick-args/index.js
var require_process_nextick_args = /* @__PURE__ */ __commonJSMin(((exports, module) => {
init_dist$2();
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) module.exports = { nextTick };
else module.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);
});
}
}
}));
//#endregion
//#region node_modules/isarray/index.js
var require_isarray = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var toString = {}.toString;
module.exports = Array.isArray || function(arr) {
return toString.call(arr) == "[object Array]";
};
}));
//#endregion
//#region node_modules/browserify-sign/node_modules/readable-stream/lib/internal/streams/stream-browser.js
var require_stream_browser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = require_events().EventEmitter;
}));
//#endregion
//#region node_modules/browserify-sign/node_modules/readable-stream/node_modules/safe-buffer/index.js
var require_safe_buffer$2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var buffer = require_dist();
var Buffer = buffer.Buffer;
function copyProps(src, dst) {
for (var key in src) dst[key] = src[key];
}
if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) module.exports = buffer;
else {
copyProps(buffer, exports);
exports.Buffer = SafeBuffer;
}
function SafeBuffer(arg, encodingOrOffset, length) {
return Buffer(arg, encodingOrOffset, length);
}
copyProps(Buffer, SafeBuffer);
SafeBuffer.from = function(arg, encodingOrOffset, length) {
if (typeof arg === "number") throw new TypeError("Argument must not be a number");
return Buffer(arg, encodingOrOffset, length);
};
SafeBuffer.alloc = function(size, fill, encoding) {
if (typeof size !== "number") throw new TypeError("Argument must be a number");
var buf = Buffer(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 Buffer(size);
};
SafeBuffer.allocUnsafeSlow = function(size) {
if (typeof size !== "number") throw new TypeError("Argument must be a number");
return buffer.SlowBuffer(size);
};
}));
//#endregion
//#region node_modules/core-util-is/lib/util.js
var require_util = /* @__PURE__ */ __commonJSMin(((exports) => {
function isArray(arg) {
if (Array.isArray) return Array.isArray(arg);
return objectToString(arg) === "[object Array]";
}
exports.isArray = isArray;
function isBoolean(arg) {
return typeof arg === "boolean";
}
exports.isBoolean = isBoolean;
function isNull(arg) {
return arg === null;
}
exports.isNull = isNull;
function isNullOrUndefined(arg) {
return arg == null;
}
exports.isNullOrUndefined = isNullOrUndefined;
function isNumber(arg) {
return typeof arg === "number";
}
exports.isNumber = isNumber;
function isString(arg) {
return typeof arg === "string";
}
exports.isString = isString;
function isSymbol(arg) {
return typeof arg === "symbol";
}
exports.isSymbol = isSymbol;
function isUndefined(arg) {
return arg === void 0;
}
exports.isUndefined = isUndefined;
function isRegExp(re) {
return objectToString(re) === "[object RegExp]";
}
exports.isRegExp = isRegExp;
function isObject(arg) {
return typeof arg === "object" && arg !== null;
}
exports.isObject = isObject;
function isDate(d) {
return objectToString(d) === "[object Date]";
}
exports.isDate = isDate;
function isError(e) {
return objectToString(e) === "[object Error]" || e instanceof Error;
}
exports.isError = isError;
function isFunction(arg) {
return typeof arg === "function";
}
exports.isFunction = isFunction;
function isPrimitive(arg) {
return arg === null || typeof arg === "boolean" || typeof arg === "number" || typeof arg === "string" || typeof arg === "symbol" || typeof arg === "undefined";
}
exports.isPrimitive = isPrimitive;
exports.isBuffer = require_dist().Buffer.isBuffer;
function objectToString(o) {
return Object.prototype.toString.call(o);
}
}));
//#endregion
//#region node_modules/browserify-sign/node_modules/readable-stream/lib/internal/streams/BufferList.js
var require_BufferList = /* @__PURE__ */ __commonJSMin(((exports, module) => {
function _classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
}
var Buffer = require_safe_buffer$2().Buffer;
var util = require_util$1();
function copyBuffer(src, target, offset) {
src.copy(target, offset);
}
module.exports = function() {
function BufferList() {
_classCallCheck(this, BufferList);
this.head = null;
this.tail = null;
this.length = 0;
}
BufferList.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;
};
BufferList.prototype.unshift = function unshift(v) {
var entry = {
data: v,
next: this.head
};
if (this.length === 0) this.tail = entry;
this.head = entry;
++this.length;
};
BufferList.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;
};
BufferList.prototype.clear = function clear() {
this.head = this.tail = null;
this.length = 0;
};
BufferList.prototype.join = function join(s) {
if (this.length === 0) return "";
var p = this.head;
var ret = "" + p.data;
while (p = p.next) ret += s + p.data;
return ret;
};
BufferList.prototype.concat = function concat(n) {
if (this.length === 0) return Buffer.alloc(0);
var ret = Buffer.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 BufferList;
}();
if (util && util.inspect && util.inspect.custom) module.exports.prototype[util.inspect.custom] = function() {
var obj = util.inspect({ length: this.length });
return this.constructor.name + " " + obj;
};
}));
//#endregion
//#region node_modules/browserify-sign/node_modules/readable-stream/lib/internal/streams/destroy.js
var require_destroy = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var pna = require_process_nextick_args();
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(err) {
if (!cb && err) {
if (!_this._writableState) pna.nextTick(emitErrorNT, _this, err);
else if (!_this._writableState.errorEmitted) {
_this._writableState.errorEmitted = true;
pna.nextTick(emitErrorNT, _this, err);
}
} else if (cb) cb(err);
});
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(self, err) {
self.emit("error", err);
}
module.exports = {
destroy,
undestroy
};
}));
//#endregion
//#region node_modules/browserify-sign/node_modules/readable-stream/lib/_stream_writable.js
var require__stream_writable = /* @__PURE__ */ __commonJSMin(((exports, module) => {
init_dist();
init_dist$2();
var pna = require_process_nextick_args();
module.exports = Writable;
function CorkedRequest(state) {
var _this = this;
this.next = null;
this.entry = null;
this.finish = function() {
onCorkedFinish(_this, state);
};
}
var asyncWrite = !process$1.browser && ["v0.10", "v0.9."].indexOf(process$1.version.slice(0, 5)) > -1 ? setImmediate : pna.nextTick;
var Duplex;
Writable.WritableState = WritableState;
var util = Object.create(require_util());
util.inherits = require_inherits_browser();
var internalUtil = { deprecate: require_browser$12() };
var Stream = require_stream_browser();
var Buffer = require_safe_buffer$2().Buffer;
var OurUint8Array = (typeof global !== "undefined" ? global : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : {}).Uint8Array || function() {};
function _uint8ArrayToBuffer(chunk) {
return Buffer.from(chunk);
}
function _isUint8Array(obj) {
return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
}
var destroyImpl = require_destroy();
util.inherits(Writable, Stream);
function nop() {}
function WritableState(options, stream) {
Duplex = Duplex || require__stream_duplex();
options = options || {};
var isDuplex = stream instanceof Duplex;
this.objectMode = !!options.objectMode;
if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode;
var hwm = options.highWaterMark;
var writableHwm = options.writableHighWaterMark;
var defaultHwm = this.objectMode ? 16 : 16 * 1024;
if (hwm || hwm === 0) this.highWaterMark = hwm;
else if (isDuplex && (writableHwm || writableHwm === 0)) this.highWaterMark = writableHwm;
else this.highWaterMark = defaultHwm;
this.highWaterMark = Math.floor(this.highWaterMark);
this.finalCalled = false;
this.needDrain = false;
this.ending = false;
this.ended = false;
this.finished = false;
this.destroyed = false;
var noDecode = options.decodeStrings === false;
this.decodeStrings = !noDecode;
this.defaultEncoding = options.defaultEncoding || "utf8";
this.length = 0;
this.writing = false;
this.corked = 0;
this.sync = true;
this.bufferProcessing = false;
this.onwrite = function(er) {
onwrite(stream, er);
};
this.writecb = null;
this.writelen = 0;
this.bufferedRequest = null;
this.lastBufferedRequest = null;
this.pendingcb = 0;
this.prefinished = false;
this.errorEmitted = false;
this.bufferedRequestCount = 0;
this.corkedRequestsFree = new CorkedRequest(this);
}
WritableState.prototype.getBuffer = function getBuffer() {
var current = this.bufferedRequest;
var out = [];
while (current) {
out.push(current);
current = current.next;
}
return out;
};
(function() {
try {
Object.defineProperty(WritableState.prototype, "buffer", { get: internalUtil.deprecate(function() {
return this.getBuffer();
}, "_writableState.buffer is deprecated. Use _writableState.getBuffer instead.", "DEP0003") });
} catch (_) {}
})();
var realHasInstance;
if (typeof Symbol === "function" && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === "function") {
realHasInstance = Function.prototype[Symbol.hasInstance];
Object.defineProperty(Writable, Symbol.hasInstance, { value: function(object) {
if (realHasInstance.call(this, object)) return true;
if (this !== Writable) return false;
return object && object._writableState instanceof WritableState;
} });
} else realHasInstance = function(object) {
return object instanceof this;
};
function Writable(options) {
Duplex = Duplex || require__stream_duplex();
if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) return new Writable(options);
this._writableState = new WritableState(options, this);
this.writable = true;
if (options) {
if (typeof options.write === "function") this._write = options.write;
if (typeof options.writev === "function") this._writev = options.writev;
if (typeof options.destroy === "function") this._destroy = options.destroy;
if (typeof options.final === "function") this._final = options.final;
}
Stream.call(this);
}
Writable.prototype.pipe = function() {
this.emit("error", /* @__PURE__ */ new Error("Cannot pipe, not readable"));
};
function writeAfterEnd(stream, cb) {
var er = /* @__PURE__ */ new Error("write after end");
stream.emit("error", er);
pna.nextTick(cb, er);
}
function validChunk(stream, state, chunk, cb) {
var valid = true;
var er = false;
if (chunk === null) er = /* @__PURE__ */ new TypeError("May not write null values to stream");
else if (typeof chunk !== "string" && chunk !== void 0 && !state.objectMode) er = /* @__PURE__ */ new TypeError("Invalid non-string/buffer chunk");
if (er) {
stream.emit("error", er);
pna.nextTick(cb, er);
valid = false;
}
return valid;
}
Writable.prototype.write = function(chunk, encoding, cb) {
var state = this._writableState;
var ret = false;
var isBuf = !state.objectMode && _isUint8Array(chunk);
if (isBuf && !Buffer.isBuffer(chunk)) chunk = _uint8ArrayToBuffer(chunk);
if (typeof encoding === "function") {
cb = encoding;
encoding = null;
}
if (isBuf) encoding = "buffer";
else if (!encoding) encoding = state.defaultEncoding;
if (typeof cb !== "function") cb = nop;
if (state.ended) writeAfterEnd(this, cb);
else if (isBuf || validChunk(this, state, chunk, cb)) {
state.pendingcb++;
ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);
}
return ret;
};
Writable.prototype.cork = function() {
var state = this._writableState;
state.corked++;
};
Writable.prototype.uncork = function() {
var state = this._writableState;
if (state.corked) {
state.corked--;
if (!state.writing && !state.corked && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);
}
};
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(state, chunk, encoding) {
if (!state.objectMode && state.decodeStrings !== false && typeof chunk === "string") chunk = Buffer.from(chunk, encoding);
return chunk;
}
Object.defineProperty(Writable.prototype, "writableHighWaterMark", {
enumerable: false,
get: function() {
return this._writableState.highWaterMark;
}
});
function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {
if (!isBuf) {
var newChunk = decodeChunk(state, chunk, encoding);
if (chunk !== newChunk) {
isBuf = true;
encoding = "buffer";
chunk = newChunk;
}
}
var len = state.objectMode ? 1 : chunk.length;
state.length += len;
var ret = state.length < state.highWaterMark;
if (!ret) state.needDrain = true;
if (state.writing || state.corked) {
var last = state.lastBufferedRequest;
state.lastBufferedRequest = {
chunk,
encoding,
isBuf,
callback: cb,
next: null
};
if (last) last.next = state.lastBufferedRequest;
else state.bufferedRequest = state.lastBufferedRequest;
state.bufferedRequestCount += 1;
} else doWrite(stream, state, false, len, chunk, encoding, cb);
return ret;
}
function doWrite(stream, state, writev, len, chunk, encoding, cb) {
state.writelen = len;
state.writecb = cb;
state.writing = true;
state.sync = true;
if (writev) stream._writev(chunk, state.onwrite);
else stream._write(chunk, encoding, state.onwrite);
state.sync = false;
}
function onwriteError(stream, state, sync, er, cb) {
--state.pendingcb;
if (sync) {
pna.nextTick(cb, er);
pna.nextTick(finishMaybe, stream, state);
stream._writableState.errorEmitted = true;
stream.emit("error", er);
} else {
cb(er);
stream._writableState.errorEmitted = true;
stream.emit("error", er);
finishMaybe(stream, state);
}
}
function onwriteStateUpdate(state) {
state.writing = false;
state.writecb = null;
state.length -= state.writelen;
state.writelen = 0;
}
function onwrite(stream, er) {
var state = stream._writableState;
var sync = state.sync;
var cb = state.writecb;
onwriteStateUpdate(state);
if (er) onwriteError(stream, state, sync, er, cb);
else {
var finished = needFinish(state);
if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) clearBuffer(stream, state);
if (sync) asyncWrite(afterWrite, stream, state, finished, cb);
else afterWrite(stream, state, finished, cb);
}
}
function afterWrite(stream, state, finished, cb) {
if (!finished) onwriteDrain(stream, state);
state.pendingcb--;
cb();
finishMaybe(stream, state);
}
function onwriteDrain(stream, state) {
if (state.length === 0 && state.needDrain) {
state.needDrain = false;
stream.emit("drain");
}
}
function clearBuffer(stream, state) {
state.bufferProcessing = true;
var entry = state.bufferedRequest;
if (stream._writev && entry && entry.next) {
var l = state.bufferedRequestCount;
var buffer = new Array(l);
var holder = state.corkedRequestsFree;
holder.entry = entry;
var count = 0;
var allBuffers = true;
while (entry) {
buffer[count] = entry;
if (!entry.isBuf) allBuffers = false;
entry = entry.next;
count += 1;
}
buffer.allBuffers = allBuffers;
doWrite(stream, state, true, state.length, buffer, "", holder.finish);
state.pendingcb++;
state.lastBufferedRequest = null;
if (holder.next) {
state.corkedRequestsFree = holder.next;
holder.next = null;
} else state.corkedRequestsFree = new CorkedRequest(state);
state.bufferedRequestCount = 0;
} else {
while (entry) {
var chunk = entry.chunk;
var encoding = entry.encoding;
var cb = entry.callback;
doWrite(stream, state, false, state.objectMode ? 1 : chunk.length, chunk, encoding, cb);
entry = entry.next;
state.bufferedRequestCount--;
if (state.writing) break;
}
if (entry === null) state.lastBufferedRequest = null;
}
state.bufferedRequest = entry;
state.bufferProcessing = false;
}
Writable.prototype._write = function(chunk, encoding, cb) {
cb(/* @__PURE__ */ new Error("_write() is not implemented"));
};
Writable.prototype._writev = null;
Writable.prototype.end = function(chunk, encoding, cb) {
var state = 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 (state.corked) {
state.corked = 1;
this.uncork();
}
if (!state.ending) endWritable(this, state, cb);
};
function needFinish(state) {
return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;
}
function callFinal(stream, state) {
stream._final(function(err) {
state.pendingcb--;
if (err) stream.emit("error", err);
state.prefinished = true;
stream.emit("prefinish");
finishMaybe(stream, state);
});
}
function prefinish(stream, state) {
if (!state.prefinished && !state.finalCalled) if (typeof stream._final === "function") {
state.pendingcb++;
state.finalCalled = true;
pna.nextTick(callFinal, stream, state);
} else {
state.prefinished = true;
stream.emit("prefinish");
}
}
function finishMaybe(stream, state) {
var need = needFinish(state);
if (need) {
prefinish(stream, state);
if (state.pendingcb === 0) {
state.finished = true;
stream.emit("finish");
}
}
return need;
}
function endWritable(stream, state, cb) {
state.ending = true;
finishMaybe(stream, state);
if (cb) if (state.finished) pna.nextTick(cb);
else stream.once("finish", cb);
state.ended = true;
stream.writable = false;
}
function onCorkedFinish(corkReq, state, err) {
var entry = corkReq.entry;
corkReq.entry = null;
while (entry) {
var cb = entry.callback;
state.pendingcb--;
cb(err);
entry = entry.next;
}
state.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);
};
}));
//#endregion
//#region node_modules/browserify-sign/node_modules/readable-stream/lib/_stream_duplex.js
var require__stream_duplex = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var pna = require_process_nextick_args();
var objectKeys = Object.keys || function(obj) {
var keys = [];
for (var key in obj) keys.push(key);
return keys;
};
module.exports = Duplex;
var util = Object.create(require_util());
util.inherits = require_inherits_browser();
var Readable = require__stream_readable();
var Writable = require__stream_writable();
util.inherits(Duplex, Readable);
var keys = objectKeys(Writable.prototype);
for (var v = 0; v < keys.length; v++) {
var method = keys[v];
if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];
}
function Duplex(options) {
if (!(this instanceof Duplex)) return new Duplex(options);
Readable.call(this, options);
Writable.call(this, options);
if (options && options.readable === false) this.readable = false;
if (options && options.writable === false) this.writable = false;
this.allowHalfOpen = true;
if (options && options.allowHalfOpen === false) this.allowHalfOpen = false;
this.once("end", onend);
}
Object.defineProperty(Duplex.prototype, "writableHighWaterMark", {
enumerable: false,
get: function() {
return this._writableState.highWaterMark;
}
});
function onend() {
if (this.allowHalfOpen || this._writableState.ended) return;
pna.nextTick(onEndNT, this);
}
function onEndNT(self) {
self.end();
}
Object.defineProperty(Duplex.prototype, "destroyed", {
get: function() {
if (this._readableState === void 0 || this._writableState === void 0) return false;
return this._readableState.destroyed && this._writableState.destroyed;
},
set: function(value) {
if (this._readableState === void 0 || this._writableState === void 0) return;
this._readableState.destroyed = value;
this._writableState.destroyed = value;
}
});
Duplex.prototype._destroy = function(err, cb) {
this.push(null);
this.end();
pna.nextTick(cb, err);
};
}));
//#endregion
//#region node_modules/browserify-sign/node_modules/readable-stream/lib/_stream_readable.js
var require__stream_readable = /* @__PURE__ */ __commonJSMin(((exports, module) => {
init_dist();
init_dist$2();
var pna = require_process_nextick_args();
module.exports = Readable;
var isArray = require_isarray();
var Duplex;
Readable.ReadableState = ReadableState;
require_events().EventEmitter;
var EElistenerCount = function(emitter, type) {
return emitter.listeners(type).length;
};
var Stream = require_stream_browser();
var Buffer = require_safe_buffer$2().Buffer;
var OurUint8Array = (typeof global !== "undefined" ? global : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : {}).Uint8Array || function() {};
function _uint8ArrayToBuffer(chunk) {
return Buffer.from(chunk);
}
function _isUint8Array(obj) {
return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
}
var util = Object.create(require_util());
util.inherits = require_inherits_browser();
var debugUtil = require_util$1();
var debug = void 0;
if (debugUtil && debugUtil.debuglog) debug = debugUtil.debuglog("stream");
else debug = function() {};
var BufferList = require_BufferList();
var destroyImpl = require_destroy();
var StringDecoder;
util.inherits(Readable, Stream);
var kProxyEvents = [
"error",
"close",
"destroy",
"pause",
"resume"
];
function prependListener(emitter, event, fn) {
if (typeof emitter.prependListener === "function") return emitter.prependListener(event, fn);
if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);
else if (isArray(emitter._events[event])) emitter._events[event].unshift(fn);
else emitter._events[event] = [fn, emitter._events[event]];
}
function ReadableState(options, stream) {
Duplex = Duplex || require__stream_duplex();
options = options || {};
var isDuplex = stream instanceof Duplex;
this.objectMode = !!options.objectMode;
if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode;
var hwm = options.highWaterMark;
var readableHwm = options.readableHighWaterMark;
var defaultHwm = this.objectMode ? 16 : 16 * 1024;
if (hwm || hwm === 0) this.highWaterMark = hwm;
else if (isDuplex && (readableHwm || readableHwm === 0)) this.highWaterMark = readableHwm;
else this.highWaterMark = defaultHwm;
this.highWaterMark = Math.floor(this.highWaterMark);
this.buffer = new BufferList();
this.length = 0;
this.pipes = null;
this.pipesCount = 0;
this.flowing = null;
this.ended = false;
this.endEmitted = false;
this.reading = false;
this.sync = true;
this.needReadable = false;
this.emittedReadable = false;
this.readableListening = false;
this.resumeScheduled = false;
this.destroyed = false;
this.defaultEncoding = options.defaultEncoding || "utf8";
this.awaitDrain = 0;
this.readingMore = false;
this.decoder = null;
this.encoding = null;
if (options.encoding) {
if (!StringDecoder) StringDecoder = require_string_decoder().StringDecoder;
this.decoder = new StringDecoder(options.encoding);
this.encoding = options.encoding;
}
}
function Readable(options) {
Duplex = Duplex || require__stream_duplex();
if (!(this instanceof Readable)) return new Readable(options);
this._readableState = new ReadableState(options, this);
this.readable = true;
if (options) {
if (typeof options.read === "function") this._read = options.read;
if (typeof options.destroy === "function") this._destroy = options.destroy;
}
Stream.call(this);
}
Object.defineProperty(Readable.prototype, "destroyed", {
get: function() {
if (this._readableState === void 0) return false;
return this._readableState.destroyed;
},
set: function(value) {
if (!this._readableState) return;
this._readableState.destroyed = value;
}
});
Readable.prototype.destroy = destroyImpl.destroy;
Readable.prototype._undestroy = destroyImpl.undestroy;
Readable.prototype._destroy = function(err, cb) {
this.push(null);
cb(err);
};
Readable.prototype.push = function(chunk, encoding) {
var state = this._readableState;
var skipChunkCheck;
if (!state.objectMode) {
if (typeof chunk === "string") {
encoding = encoding || state.defaultEncoding;
if (encoding !== state.encoding) {
chunk = Buffer.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 state = stream._readableState;
if (chunk === null) {
state.reading = false;
onEofChunk(stream, state);
} else {
var er;
if (!skipChunkCheck) er = chunkInvalid(state, chunk);
if (er) stream.emit("error", er);
else if (state.objectMode || chunk && chunk.length > 0) {
if (typeof chunk !== "string" && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) chunk = _uint8ArrayToBuffer(chunk);
if (addToFront) if (state.endEmitted) stream.emit("error", /* @__PURE__ */ new Error("stream.unshift() after end event"));
else addChunk(stream, state, chunk, true);
else if (state.ended) stream.emit("error", /* @__PURE__ */ new Error("stream.push() after EOF"));
else {
state.reading = false;
if (state.decoder && !encoding) {
chunk = state.decoder.write(chunk);
if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);
else maybeReadMore(stream, state);
} else addChunk(stream, state, chunk, false);
}
} else if (!addToFront) state.reading = false;
}
return needMoreData(state);
}
function addChunk(stream, state, chunk, addToFront) {
if (state.flowing && state.length === 0 && !state.sync) {
stream.emit("data", chunk);
stream.read(0);
} else {
state.length += state.objectMode ? 1 : chunk.length;
if (addToFront) state.buffer.unshift(chunk);
else state.buffer.push(chunk);
if (state.needReadable) emitReadable(stream);
}
maybeReadMore(stream, state);
}
function chunkInvalid(state, chunk) {
var er;
if (!_isUint8Array(chunk) && typeof chunk !== "string" && chunk !== void 0 && !state.objectMode) er = /* @__PURE__ */ new TypeError("Invalid non-string/buffer chunk");
return er;
}
function needMoreData(state) {
return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);
}
Readable.prototype.isPaused = function() {
return this._readableState.flowing === false;
};
Readable.prototype.setEncoding = function(enc) {
if (!StringDecoder) StringDecoder = require_string_decoder().StringDecoder;
this._readableState.decoder = new StringDecoder(enc);
this._readableState.encoding = enc;
return this;
};
var MAX_HWM = 8388608;
function computeNewHighWaterMark(n) {
if (n >= MAX_HWM) n = MAX_HWM;
else {
n--;
n |= n >>> 1;
n |= n >>> 2;
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
n++;
}
return n;
}
function howMuchToRead(n, state) {
if (n <= 0 || state.length === 0 && state.ended) return 0;
if (state.objectMode) return 1;
if (n !== n) if (state.flowing && state.length) return state.buffer.head.data.length;
else return state.length;
if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);
if (n <= state.length) return n;
if (!state.ended) {
state.needReadable = true;
return 0;
}
return state.length;
}
Readable.prototype.read = function(n) {
debug("read", n);
n = parseInt(n, 10);
var state = this._readableState;
var nOrig = n;
if (n !== 0) state.emittedReadable = false;
if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) {
debug("read: emitReadable", state.length, state.ended);
if (state.length === 0 && state.ended) endReadable(this);
else emitReadable(this);
return null;
}
n = howMuchToRead(n, state);
if (n === 0 && state.ended) {
if (state.length === 0) endReadable(this);
return null;
}
var doRead = state.needReadable;
debug("need readable", doRead);
if (state.length === 0 || state.length - n < state.highWaterMark) {
doRead = true;
debug("length less than watermark", doRead);
}
if (state.ended || state.reading) {
doRead = false;
debug("reading or ended", doRead);
} else if (doRead) {
debug("do read");
state.reading = true;
state.sync = true;
if (state.length === 0) state.needReadable = true;
this._read(state.highWaterMark);
state.sync = false;
if (!state.reading) n = howMuchToRead(nOrig, state);
}
var ret;
if (n > 0) ret = fromList(n, state);
else ret = null;
if (ret === null) {
state.needReadable = true;
n = 0;
} else state.length -= n;
if (state.length === 0) {
if (!state.ended) state.needReadable = true;
if (nOrig !== n && state.ended) endReadable(this);
}
if (ret !== null) this.emit("data", ret);
return ret;
};
function onEofChunk(stream, state) {
if (state.ended) return;
if (state.decoder) {
var chunk = state.decoder.end();
if (chunk && chunk.length) {
state.buffer.push(chunk);
state.length += state.objectMode ? 1 : chunk.length;
}
}
state.ended = true;
emitReadable(stream);
}
function emitReadable(stream) {
var state = stream._readableState;
state.needReadable = false;
if (!state.emittedReadable) {
debug("emitReadable", state.flowing);
state.emittedReadable = true;
if (state.sync) pna.nextTick(emitReadable_, stream);
else emitReadable_(stream);
}
}
function emitReadable_(stream) {
debug("emit readable");
stream.emit("readable");
flow(stream);
}
function maybeReadMore(stream, state) {
if (!state.readingMore) {
state.readingMore = true;
pna.nextTick(maybeReadMore_, stream, state);
}
}
function maybeReadMore_(stream, state) {
var len = state.length;
while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) {
debug("maybeReadMore read 0");
stream.read(0);
if (len === state.length) break;
else len = state.length;
}
state.readingMore = false;
}
Readable.prototype._read = function(n) {
this.emit("error", /* @__PURE__ */ new Error("_read() is not implemented"));
};
Readable.prototype.pipe = function(dest, pipeOpts) {
var src = this;
var state = this._readableState;
switch (state.pipesCount) {
case 0:
state.pipes = dest;
break;
case 1:
state.pipes = [state.pipes, dest];
break;
default:
state.pipes.push(dest);
break;
}
state.pipesCount += 1;
debug("pipe count=%d opts=%j", state.pipesCount, pipeOpts);
var endFn = (!pipeOpts || pipeOpts.end !== false) && dest !== process$1.stdout && dest !== process$1.stderr ? onend : unpipe;
if (state.endEmitted) pna.nextTick(endFn);
else src.once("end", endFn);
dest.on("unpipe", onunpipe);
function onunpipe(readable, unpipeInfo) {
debug("onunpipe");
if (readable === src) {
if (unpipeInfo && unpipeInfo.hasUnpiped === false) {
unpipeInfo.hasUnpiped = true;
cleanup();
}
}
}
function onend() {
debug("onend");
dest.end();
}
var ondrain = pipeOnDrain(src);
dest.on("drain", ondrain);
var cleanedUp = false;
function cleanup() {
debug("cleanup");
dest.removeListener("close", onclose);
dest.removeListener("finish", onfinish);
dest.removeListener("drain", ondrain);
dest.removeListener("error", onerror);
dest.removeListener("unpipe", onunpipe);
src.removeListener("end", onend);
src.removeListener("end", unpipe);
src.removeListener("data", ondata);
cleanedUp = true;
if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();
}
var increasedAwaitDrain = false;
src.on("data", ondata);
function ondata(chunk) {
debug("ondata");
increasedAwaitDrain = false;
if (false === dest.write(chunk) && !increasedAwaitDrain) {
if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {
debug("false write response, pause", state.awaitDrain);
state.awaitDrain++;
increasedAwaitDrain = true;
}
src.pause();
}
}
function onerror(er) {
debug("onerror", er);
unpipe();
dest.removeListener("error", onerror);
if (EElistenerCount(dest, "error") === 0) dest.emit("error", er);
}
prependListener(dest, "error", onerror);
function onclose() {
dest.removeListener("finish", onfinish);
unpipe();
}
dest.once("close", onclose);
function onfinish() {
debug("onfinish");
dest.removeListener("close", onclose);
unpipe();
}
dest.once("finish", onfinish);
function unpipe() {
debug("unpipe");
src.unpipe(dest);
}
dest.emit("pipe", src);
if (!state.flowing) {
debug("pipe resume");
src.resume();
}
return dest;
};
function pipeOnDrain(src) {
return function() {
var state = src._readableState;
debug("pipeOnDrain", state.awaitDrain);
if (state.awaitDrain) state.awaitDrain--;
if (state.awaitDrain === 0 && EElistenerCount(src, "data")) {
state.flowing = true;
flow(src);
}
};
}
Readable.prototype.unpipe = function(dest) {
var state = this._readableState;
var unpipeInfo = { hasUnpiped: false };
if (state.pipesCount === 0) return this;
if (state.pipesCount === 1) {
if (dest && dest !== state.pipes) return this;
if (!dest) dest = state.pipes;
state.pipes = null;
state.pipesCount = 0;
state.flowing = false;
if (dest) dest.emit("unpipe", this, unpipeInfo);
return this;
}
if (!dest) {
var dests = state.pipes;
var len = state.pipesCount;
state.pipes = null;
state.pipesCount = 0;
state.flowing = false;
for (var i = 0; i < len; i++) dests[i].emit("unpipe", this, { hasUnpiped: false });
return this;
}
var index = indexOf(state.pipes, dest);
if (index === -1) return this;
state.pipes.splice(index, 1);
state.pipesCount -= 1;
if (state.pipesCount === 1) state.pipes = state.pipes[0];
dest.emit("unpipe", this, unpipeInfo);
return this;
};
Readable.prototype.on = function(ev, fn) {
var res = Stream.prototype.on.call(this, ev, fn);
if (ev === "data") {
if (this._readableState.flowing !== false) this.resume();
} else if (ev === "readable") {
var state = this._readableState;
if (!state.endEmitted && !state.readableListening) {
state.readableListening = state.needReadable = true;
state.emittedReadable = false;
if (!state.reading) pna.nextTick(nReadingNextTick, this);
else if (state.length) emitReadable(this);
}
}
return res;
};
Readable.prototype.addListener = Readable.prototype.on;
function nReadingNextTick(self) {
debug("readable nexttick read 0");
self.read(0);
}
Readable.prototype.resume = function() {
var state = this._readableState;
if (!state.flowing) {
debug("resume");
state.flowing = true;
resume(this, state);
}
return this;
};
function resume(stream, state) {
if (!state.resumeScheduled) {
state.resumeScheduled = true;
pna.nextTick(resume_, stream, state);
}
}
function resume_(stream, state) {
if (!state.reading) {
debug("resume read 0");
stream.read(0);
}
state.resumeScheduled = false;
state.awaitDrain = 0;
stream.emit("resume");
flow(stream);
if (state.flowing && !state.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 state = stream._readableState;
debug("flow", state.flowing);
while (state.flowing && stream.read() !== null);
}
Readable.prototype.wrap = function(stream) {
var _this = this;
var state = this._readableState;
var paused = false;
stream.on("end", function() {
debug("wrapped end");
if (state.decoder && !state.ended) {
var chunk = state.decoder.end();
if (chunk && chunk.length) _this.push(chunk);
}
_this.push(null);
});
stream.on("data", function(chunk) {
debug("wrapped data");
if (state.decoder) chunk = state.decoder.write(chunk);
if (state.objectMode && (chunk === null || chunk === void 0)) return;
else if (!state.objectMode && (!chunk || !chunk.length)) return;
if (!_this.push(chunk)) {
paused = true;
stream.pause();
}
});
for (var i in stream) if (this[i] === void 0 && typeof stream[i] === "function") this[i] = 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(n) {
debug("wrapped _read", n);
if (paused) {
paused = false;
stream.resume();
}
};
return this;
};
Object.defineProperty(Readable.prototype, "readableHighWaterMark", {
enumerable: false,
get: function() {
return this._readableState.highWaterMark;
}
});
Readable._fromList = fromList;
function fromList(n, state) {
if (state.length === 0) return null;
var ret;
if (state.objectMode) ret = state.buffer.shift();
else if (!n || n >= state.length) {
if (state.decoder) ret = state.buffer.join("");
else if (state.buffer.length === 1) ret = state.buffer.head.data;
else ret = state.buffer.concat(state.length);
state.buffer.clear();
} else ret = fromListPartial(n, state.buffer, state.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 = Buffer.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 state = stream._readableState;
if (state.length > 0) throw new Error("\"endReadable()\" called on non-empty stream");
if (!state.endEmitted) {
state.ended = true;
pna.nextTick(endReadableNT, state, stream);
}
}
function endReadableNT(state, stream) {
if (!state.endEmitted && state.length === 0) {
state.endEmitted = true;
stream.readable = false;
stream.emit("end");
}
}
function indexOf(xs, x) {
for (var i = 0, l = xs.length; i < l; i++) if (xs[i] === x) return i;
return -1;
}
}));
//#endregion
//#region node_modules/browserify-sign/node_modules/readable-stream/lib/_stream_transform.js
var require__stream_transform = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = Transform;
var Duplex = require__stream_duplex();
var util = Object.create(require_util());
util.inherits = require_inherits_browser();
util.inherits(Transform, Duplex);
function afterTransform(er, data) {
var ts = this._transformState;
ts.transforming = false;
var cb = ts.writecb;
if (!cb) return this.emit("error", /* @__PURE__ */ new Error("write callback called multiple times"));
ts.writechunk = null;
ts.writecb = null;
if (data != null) this.push(data);
cb(er);
var rs = this._readableState;
rs.reading = false;
if (rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);
}
function Transform(options) {
if (!(this instanceof Transform)) return new Transform(options);
Duplex.call(this, options);
this._transformState = {
afterTransform: afterTransform.bind(this),
needTransform: false,
transforming: false,
writecb: null,
writechunk: null,
writeencoding: null
};
this._readableState.needReadable = true;
this._readableState.sync = false;
if (options) {
if (typeof options.transform === "function") this._transform = options.transform;
if (typeof options.flush === "function") this._flush = options.flush;
}
this.on("prefinish", prefinish);
}
function prefinish() {
var _this = this;
if (typeof this._flush === "function") this._flush(function(er, data) {
done(_this, er, data);
});
else done(this, null, null);
}
Transform.prototype.push = function(chunk, encoding) {
this._transformState.needTransform = false;
return Duplex.prototype.push.call(this, chunk, encoding);
};
Transform.prototype._transform = function(chunk, encoding, cb) {
throw new Error("_transform() is not implemented");
};
Transform.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.prototype._read = function(n) {
var ts = this._transformState;
if (ts.writechunk !== null && ts.writecb && !ts.transforming) {
ts.transforming = true;
this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
} else ts.needTransform = true;
};
Transform.prototype._destroy = function(err, cb) {
var _this2 = this;
Duplex.prototype._destroy.call(this, err, function(err2) {
cb(err2);
_this2.emit("close");
});
};
function done(stream, er, data) {
if (er) return stream.emit("error", er);
if (data != null) stream.push(data);
if (stream._writableState.length) throw new Error("Calling transform done when ws.length != 0");
if (stream._transformState.transforming) throw new Error("Calling transform done when still transforming");
return stream.push(null);
}
}));
//#endregion
//#region node_modules/browserify-sign/node_modules/readable-stream/lib/_stream_passthrough.js
var require__stream_passthrough = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = PassThrough;
var Transform = require__stream_transform();
var util = Object.create(require_util());
util.inherits = require_inherits_browser();
util.inherits(PassThrough, Transform);
function PassThrough(options) {
if (!(this instanceof PassThrough)) return new PassThrough(options);
Transform.call(this, options);
}
PassThrough.prototype._transform = function(chunk, encoding, cb) {
cb(null, chunk);
};
}));
//#endregion
//#region node_modules/browserify-sign/node_modules/readable-stream/readable-browser.js
var require_readable_browser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
exports = module.exports = require__stream_readable();
exports.Stream = exports;
exports.Readable = exports;
exports.Writable = require__stream_writable();
exports.Duplex = require__stream_duplex();
exports.Transform = require__stream_transform();
exports.PassThrough = require__stream_passthrough();
}));
//#endregion
//#region node_modules/bn.js/lib/bn.js
var require_bn$4 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
(function(module$5, exports$5) {
"use strict";
function assert(val, msg) {
if (!val) throw new Error(msg || "Assertion failed");
}
function inherits(ctor, superCtor) {
ctor.super_ = superCtor;
var TempCtor = function() {};
TempCtor.prototype = superCtor.prototype;
ctor.prototype = new TempCtor();
ctor.prototype.constructor = ctor;
}
function BN(number, base, endian) {
if (BN.isBN(number)) return number;
this.negative = 0;
this.words = null;
this.length = 0;
this.red = null;
if (number !== null) {
if (base === "le" || base === "be") {
endian = base;
base = 10;
}
this._init(number || 0, base || 10, endian || "be");
}
}
if (typeof module$5 === "object") module$5.exports = BN;
else exports$5.BN = BN;
BN.BN = BN;
BN.wordSize = 26;
var Buffer;
try {
if (typeof window !== "undefined" && typeof window.Buffer !== "undefined") Buffer = window.Buffer;
else Buffer = require_dist().Buffer;
} catch (e) {}
BN.isBN = function isBN(num) {
if (num instanceof BN) return true;
return num !== null && typeof num === "object" && num.constructor.wordSize === BN.wordSize && Array.isArray(num.words);
};
BN.max = function max(left, right) {
if (left.cmp(right) > 0) return left;
return right;
};
BN.min = function min(left, right) {
if (left.cmp(right) < 0) return left;
return right;
};
BN.prototype._init = function init(number, base, endian) {
if (typeof number === "number") return this._initNumber(number, base, endian);
if (typeof number === "object") return this._initArray(number, base, endian);
if (base === "hex") base = 16;
assert(base === (base | 0) && base >= 2 && base <= 36);
number = number.toString().replace(/\s+/g, "");
var start = 0;
if (number[0] === "-") {
start++;
this.negative = 1;
}
if (start < number.length) if (base === 16) this._parseHex(number, start, endian);
else {
this._parseBase(number, base, start);
if (endian === "le") this._initArray(this.toArray(), base, endian);
}
};
BN.prototype._initNumber = function _initNumber(number, base, endian) {
if (number < 0) {
this.negative = 1;
number = -number;
}
if (number < 67108864) {
this.words = [number & 67108863];
this.length = 1;
} else if (number < 4503599627370496) {
this.words = [number & 67108863, number / 67108864 & 67108863];
this.length = 2;
} else {
assert(number < 9007199254740992);
this.words = [
number & 67108863,
number / 67108864 & 67108863,
1
];
this.length = 3;
}
if (endian !== "le") return;
this._initArray(this.toArray(), base, endian);
};
BN.prototype._initArray = function _initArray(number, base, endian) {
assert(typeof number.length === "number");
if (number.length <= 0) {
this.words = [0];
this.length = 1;
return this;
}
this.length = Math.ceil(number.length / 3);
this.words = new Array(this.length);
for (var 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 assert(false, "Invalid character in " + string);
}
function parseHexByte(string, lowerBound, index) {
var r = parseHex4Bits(string, index);
if (index - 1 >= lowerBound) r |= parseHex4Bits(string, index - 1) << 4;
return r;
}
BN.prototype._parseHex = function _parseHex(number, start, endian) {
this.length = Math.ceil((number.length - start) / 6);
this.words = new Array(this.length);
for (var 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 for (i = (number.length - start) % 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, mul) {
var r = 0;
var b = 0;
var len = Math.min(str.length, end);
for (var i = start; i < len; i++) {
var c = str.charCodeAt(i) - 48;
r *= mul;
if (c >= 49) b = c - 49 + 10;
else if (c >= 17) b = c - 17 + 10;
else b = c;
assert(c >= 0 && b < mul, "Invalid character");
r += b;
}
return r;
}
BN.prototype._parseBase = function _parseBase(number, base, start) {
this.words = [0];
this.length = 1;
for (var limbLen = 0, limbPow = 1; limbPow <= 67108863; limbPow *= base) limbLen++;
limbLen--;
limbPow = limbPow / base | 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, base);
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, base);
for (i = 0; i < mod; i++) pow *= base;
this.imuln(pow);
if (this.words[0] + word < 67108864) this.words[0] += word;
else this._iaddn(word);
}
this._strip();
};
BN.prototype.copy = function copy(dest) {
dest.words = new Array(this.length);
for (var 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;
}
BN.prototype._move = function _move(dest) {
move(dest, this);
};
BN.prototype.clone = function clone() {
var r = new BN(null);
this.copy(r);
return r;
};
BN.prototype._expand = function _expand(size) {
while (this.length < size) this.words[this.length++] = 0;
return this;
};
BN.prototype._strip = function strip() {
while (this.length > 1 && this.words[this.length - 1] === 0) this.length--;
return this._normSign();
};
BN.prototype._normSign = function _normSign() {
if (this.length === 1 && this.words[0] === 0) this.negative = 0;
return this;
};
if (typeof Symbol !== "undefined" && typeof Symbol.for === "function") try {
BN.prototype[Symbol.for("nodejs.util.inspect.custom")] = inspect;
} catch (e) {
BN.prototype.inspect = inspect;
}
else BN.prototype.inspect = inspect;
function inspect() {
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
];
BN.prototype.toString = function toString(base, padding) {
base = base || 10;
padding = padding | 0 || 1;
var out;
if (base === 16 || base === "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 (base === (base | 0) && base >= 2 && base <= 36) {
var groupSize = groupSizes[base];
var groupBase = groupBases[base];
out = "";
var c = this.clone();
c.negative = 0;
while (!c.isZero()) {
var r = c.modrn(groupBase).toString(base);
c = c.idivn(groupBase);
if (!c.isZero()) out = zeros[groupSize - r.length] + r + out;
else out = r + out;
}
if (this.isZero()) out = "0" + out;
while (out.length % padding !== 0) out = "0" + out;
if (this.negative !== 0) out = "-" + out;
return out;
}
assert(false, "Base should be between 2 and 36");
};
BN.prototype.toNumber = function 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) assert(false, "Number can only safely store up to 53 bits");
return this.negative !== 0 ? -ret : ret;
};
BN.prototype.toJSON = function toJSON() {
return this.toString(16, 2);
};
if (Buffer) BN.prototype.toBuffer = function toBuffer(endian, length) {
return this.toArrayLike(Buffer, endian, length);
};
BN.prototype.toArray = function toArray(endian, length) {
return this.toArrayLike(Array, endian, length);
};
var allocate = function allocate(ArrayType, size) {
if (ArrayType.allocUnsafe) return ArrayType.allocUnsafe(size);
return new ArrayType(size);
};
BN.prototype.toArrayLike = function toArrayLike(ArrayType, endian, length) {
this._strip();
var byteLength = this.byteLength();
var reqLength = length || Math.max(1, byteLength);
assert(byteLength <= reqLength, "byte array longer than desired length");
assert(reqLength > 0, "Requested array length <= 0");
var res = allocate(ArrayType, reqLength);
var postfix = endian === "le" ? "LE" : "BE";
this["_toArrayLike" + postfix](res, byteLength);
return res;
};
BN.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;
}
};
BN.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) BN.prototype._countBits = function _countBits(w) {
return 32 - Math.clz32(w);
};
else BN.prototype._countBits = function _countBits(w) {
var t = w;
var r = 0;
if (t >= 4096) {
r += 13;
t >>>= 13;
}
if (t >= 64) {
r += 7;
t >>>= 7;
}
if (t >= 8) {
r += 4;
t >>>= 4;
}
if (t >= 2) {
r += 2;
t >>>= 2;
}
return r + t;
};
BN.prototype._zeroBits = function _zeroBits(w) {
if (w === 0) return 26;
var t = w;
var r = 0;
if ((t & 8191) === 0) {
r += 13;
t >>>= 13;
}
if ((t & 127) === 0) {
r += 7;
t >>>= 7;
}
if ((t & 15) === 0) {
r += 4;
t >>>= 4;
}
if ((t & 3) === 0) {
r += 2;
t >>>= 2;
}
if ((t & 1) === 0) r++;
return r;
};
BN.prototype.bitLength = function bitLength() {
var w = this.words[this.length - 1];
var hi = this._countBits(w);
return (this.length - 1) * 26 + hi;
};
function toBitArray(num) {
var w = new Array(num.bitLength());
for (var bit = 0; bit < w.length; bit++) {
var off = bit / 26 | 0;
var wbit = bit % 26;
w[bit] = num.words[off] >>> wbit & 1;
}
return w;
}
BN.prototype.zeroBits = function zeroBits() {
if (this.isZero()) return 0;
var r = 0;
for (var i = 0; i < this.length; i++) {
var b = this._zeroBits(this.words[i]);
r += b;
if (b !== 26) break;
}
return r;
};
BN.prototype.byteLength = function byteLength() {
return Math.ceil(this.bitLength() / 8);
};
BN.prototype.toTwos = function toTwos(width) {
if (this.negative !== 0) return this.abs().inotn(width).iaddn(1);
return this.clone();
};
BN.prototype.fromTwos = function fromTwos(width) {
if (this.testn(width - 1)) return this.notn(width).iaddn(1).ineg();
return this.clone();
};
BN.prototype.isNeg = function isNeg() {
return this.negative !== 0;
};
BN.prototype.neg = function neg() {
return this.clone().ineg();
};
BN.prototype.ineg = function ineg() {
if (!this.isZero()) this.negative ^= 1;
return this;
};
BN.prototype.iuor = function iuor(num) {
while (this.length < num.length) this.words[this.length++] = 0;
for (var i = 0; i < num.length; i++) this.words[i] = this.words[i] | num.words[i];
return this._strip();
};
BN.prototype.ior = function ior(num) {
assert((this.negative | num.negative) === 0);
return this.iuor(num);
};
BN.prototype.or = function or(num) {
if (this.length > num.length) return this.clone().ior(num);
return num.clone().ior(this);
};
BN.prototype.uor = function uor(num) {
if (this.length > num.length) return this.clone().iuor(num);
return num.clone().iuor(this);
};
BN.prototype.iuand = function iuand(num) {
var b;
if (this.length > num.length) b = num;
else b = this;
for (var i = 0; i < b.length; i++) this.words[i] = this.words[i] & num.words[i];
this.length = b.length;
return this._strip();
};
BN.prototype.iand = function iand(num) {
assert((this.negative | num.negative) === 0);
return this.iuand(num);
};
BN.prototype.and = function and(num) {
if (this.length > num.length) return this.clone().iand(num);
return num.clone().iand(this);
};
BN.prototype.uand = function uand(num) {
if (this.length > num.length) return this.clone().iuand(num);
return num.clone().iuand(this);
};
BN.prototype.iuxor = function iuxor(num) {
var a;
var b;
if (this.length > num.length) {
a = this;
b = num;
} else {
a = num;
b = this;
}
for (var 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();
};
BN.prototype.ixor = function ixor(num) {
assert((this.negative | num.negative) === 0);
return this.iuxor(num);
};
BN.prototype.xor = function xor(num) {
if (this.length > num.length) return this.clone().ixor(num);
return num.clone().ixor(this);
};
BN.prototype.uxor = function uxor(num) {
if (this.length > num.length) return this.clone().iuxor(num);
return num.clone().iuxor(this);
};
BN.prototype.inotn = function inotn(width) {
assert(typeof width === "number" && width >= 0);
var bytesNeeded = Math.ceil(width / 26) | 0;
var bitsLeft = width % 26;
this._expand(bytesNeeded);
if (bitsLeft > 0) bytesNeeded--;
for (var 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();
};
BN.prototype.notn = function notn(width) {
return this.clone().inotn(width);
};
BN.prototype.setn = function setn(bit, val) {
assert(typeof bit === "number" && bit >= 0);
var off = bit / 26 | 0;
var wbit = bit % 26;
this._expand(off + 1);
if (val) this.words[off] = this.words[off] | 1 << wbit;
else this.words[off] = this.words[off] & ~(1 << wbit);
return this._strip();
};
BN.prototype.iadd = function iadd(num) {
var r;
if (this.negative !== 0 && num.negative === 0) {
this.negative = 0;
r = this.isub(num);
this.negative ^= 1;
return this._normSign();
} else if (this.negative === 0 && num.negative !== 0) {
num.negative = 0;
r = this.isub(num);
num.negative = 1;
return r._normSign();
}
var a, b;
if (this.length > num.length) {
a = this;
b = num;
} else {
a = num;
b = this;
}
var carry = 0;
for (var i = 0; i < b.length; i++) {
r = (a.words[i] | 0) + (b.words[i] | 0) + carry;
this.words[i] = r & 67108863;
carry = r >>> 26;
}
for (; carry !== 0 && i < a.length; i++) {
r = (a.words[i] | 0) + carry;
this.words[i] = r & 67108863;
carry = r >>> 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;
};
BN.prototype.add = function add(num) {
var res;
if (num.negative !== 0 && this.negative === 0) {
num.negative = 0;
res = this.sub(num);
num.negative ^= 1;
return res;
} else if (num.negative === 0 && this.negative !== 0) {
this.negative = 0;
res = num.sub(this);
this.negative = 1;
return res;
}
if (this.length > num.length) return this.clone().iadd(num);
return num.clone().iadd(this);
};
BN.prototype.isub = function isub(num) {
if (num.negative !== 0) {
num.negative = 0;
var r = this.iadd(num);
num.negative = 1;
return r._normSign();
} else if (this.negative !== 0) {
this.negative = 0;
this.iadd(num);
this.negative = 1;
return this._normSign();
}
var cmp = this.cmp(num);
if (cmp === 0) {
this.negative = 0;
this.length = 1;
this.words[0] = 0;
return this;
}
var a, b;
if (cmp > 0) {
a = this;
b = num;
} else {
a = num;
b = this;
}
var carry = 0;
for (var i = 0; i < b.length; i++) {
r = (a.words[i] | 0) - (b.words[i] | 0) + carry;
carry = r >> 26;
this.words[i] = r & 67108863;
}
for (; carry !== 0 && i < a.length; i++) {
r = (a.words[i] | 0) + carry;
carry = r >> 26;
this.words[i] = r & 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();
};
BN.prototype.sub = function sub(num) {
return this.clone().isub(num);
};
function smallMulTo(self, num, out) {
out.negative = num.negative ^ self.negative;
var len = self.length + num.length | 0;
out.length = len;
len = len - 1 | 0;
var a = self.words[0] | 0;
var b = num.words[0] | 0;
var r = a * b;
var lo = r & 67108863;
var carry = r / 67108864 | 0;
out.words[0] = lo;
for (var k = 1; k < 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 - self.length + 1); j <= maxJ; j++) {
var i = k - j | 0;
a = self.words[i] | 0;
b = num.words[j] | 0;
r = a * b + rword;
ncarry += r / 67108864 | 0;
rword = r & 67108863;
}
out.words[k] = rword | 0;
carry = ncarry | 0;
}
if (carry !== 0) out.words[k] = carry | 0;
else out.length--;
return out._strip();
}
var comb10MulTo = function comb10MulTo(self, num, out) {
var a = self.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 = self.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(self, num, out) {
out.negative = num.negative ^ self.negative;
out.length = self.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 - self.length + 1); j <= maxJ; j++) {
var i = k - j;
var r = (self.words[i] | 0) * (num.words[j] | 0);
var lo = r & 67108863;
ncarry = ncarry + (r / 67108864 | 0) | 0;
lo = lo + rword | 0;
rword = lo & 67108863;
ncarry = ncarry + (lo >>> 26) | 0;
hncarry += ncarry >>> 26;
ncarry &= 67108863;
}
out.words[k] = rword;
carry = ncarry;
ncarry = hncarry;
}
if (carry !== 0) out.words[k] = carry;
else out.length--;
return out._strip();
}
function jumboMulTo(self, num, out) {
return bigMulTo(self, num, out);
}
BN.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 = BN.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 permute(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 s = 1; s < N; s <<= 1) {
var l = s << 1;
var rtwdf = Math.cos(2 * Math.PI / l);
var itwdf = Math.sin(2 * Math.PI / l);
for (var p = 0; p < N; p += l) {
var rtwdf_ = rtwdf;
var itwdf_ = itwdf;
for (var j = 0; j < s; j++) {
var re = rtws[p + j];
var ie = itws[p + j];
var ro = rtws[p + j + s];
var io = itws[p + j + s];
var rx = rtwdf_ * ro - itwdf_ * io;
io = rtwdf_ * io + itwdf_ * ro;
ro = rx;
rtws[p + j] = re + ro;
itws[p + j] = ie + io;
rtws[p + j + s] = re - ro;
itws[p + j + s] = ie - io;
if (j !== l) {
rx = rtwdf * rtwdf_ - itwdf * itwdf_;
itwdf_ = rtwdf * itwdf_ + itwdf * rtwdf_;
rtwdf_ = rx;
}
}
}
}
};
FFTM.prototype.guessLen13b = function guessLen13b(n, m) {
var N = Math.max(m, n) | 1;
var odd = N & 1;
var 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;
assert(carry === 0);
assert((carry & -8192) === 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();
};
BN.prototype.mul = function mul(num) {
var out = new BN(null);
out.words = new Array(this.length + num.length);
return this.mulTo(num, out);
};
BN.prototype.mulf = function mulf(num) {
var out = new BN(null);
out.words = new Array(this.length + num.length);
return jumboMulTo(this, num, out);
};
BN.prototype.imul = function imul(num) {
return this.clone().mulTo(num, this);
};
BN.prototype.imuln = function imuln(num) {
var isNegNum = num < 0;
if (isNegNum) num = -num;
assert(typeof num === "number");
assert(num < 67108864);
var carry = 0;
for (var 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;
};
BN.prototype.muln = function muln(num) {
return this.clone().imuln(num);
};
BN.prototype.sqr = function sqr() {
return this.mul(this);
};
BN.prototype.isqr = function isqr() {
return this.imul(this.clone());
};
BN.prototype.pow = function pow(num) {
var w = toBitArray(num);
if (w.length === 0) return new BN(1);
var res = this;
for (var 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;
};
BN.prototype.iushln = function iushln(bits) {
assert(typeof bits === "number" && bits >= 0);
var r = bits % 26;
var s = (bits - r) / 26;
var carryMask = 67108863 >>> 26 - r << 26 - r;
var i;
if (r !== 0) {
var carry = 0;
for (i = 0; i < this.length; i++) {
var newCarry = this.words[i] & carryMask;
var c = (this.words[i] | 0) - newCarry << r;
this.words[i] = c | carry;
carry = newCarry >>> 26 - r;
}
if (carry) {
this.words[i] = carry;
this.length++;
}
}
if (s !== 0) {
for (i = this.length - 1; i >= 0; i--) this.words[i + s] = this.words[i];
for (i = 0; i < s; i++) this.words[i] = 0;
this.length += s;
}
return this._strip();
};
BN.prototype.ishln = function ishln(bits) {
assert(this.negative === 0);
return this.iushln(bits);
};
BN.prototype.iushrn = function iushrn(bits, hint, extended) {
assert(typeof bits === "number" && bits >= 0);
var h;
if (hint) h = (hint - hint % 26) / 26;
else h = 0;
var r = bits % 26;
var s = Math.min((bits - r) / 26, this.length);
var mask = 67108863 ^ 67108863 >>> r << r;
var maskedWords = extended;
h -= s;
h = Math.max(0, h);
if (maskedWords) {
for (var i = 0; i < s; i++) maskedWords.words[i] = this.words[i];
maskedWords.length = s;
}
if (s === 0) {} else if (this.length > s) {
this.length -= s;
for (i = 0; i < this.length; i++) this.words[i] = this.words[i + s];
} 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 - r | word >>> r;
carry = word & mask;
}
if (maskedWords && carry !== 0) maskedWords.words[maskedWords.length++] = carry;
if (this.length === 0) {
this.words[0] = 0;
this.length = 1;
}
return this._strip();
};
BN.prototype.ishrn = function ishrn(bits, hint, extended) {
assert(this.negative === 0);
return this.iushrn(bits, hint, extended);
};
BN.prototype.shln = function shln(bits) {
return this.clone().ishln(bits);
};
BN.prototype.ushln = function ushln(bits) {
return this.clone().iushln(bits);
};
BN.prototype.shrn = function shrn(bits) {
return this.clone().ishrn(bits);
};
BN.prototype.ushrn = function ushrn(bits) {
return this.clone().iushrn(bits);
};
BN.prototype.testn = function testn(bit) {
assert(typeof bit === "number" && bit >= 0);
var r = bit % 26;
var s = (bit - r) / 26;
var q = 1 << r;
if (this.length <= s) return false;
return !!(this.words[s] & q);
};
BN.prototype.imaskn = function imaskn(bits) {
assert(typeof bits === "number" && bits >= 0);
var r = bits % 26;
var s = (bits - r) / 26;
assert(this.negative === 0, "imaskn works only with positive numbers");
if (this.length <= s) return this;
if (r !== 0) s++;
this.length = Math.min(s, this.length);
if (r !== 0) {
var mask = 67108863 ^ 67108863 >>> r << r;
this.words[this.length - 1] &= mask;
}
return this._strip();
};
BN.prototype.maskn = function maskn(bits) {
return this.clone().imaskn(bits);
};
BN.prototype.iaddn = function iaddn(num) {
assert(typeof num === "number");
assert(num < 67108864);
if (num < 0) return this.isubn(-num);
if (this.negative !== 0) {
if (this.length === 1 && (this.words[0] | 0) <= num) {
this.words[0] = num - (this.words[0] | 0);
this.negative = 0;
return this;
}
this.negative = 0;
this.isubn(num);
this.negative = 1;
return this;
}
return this._iaddn(num);
};
BN.prototype._iaddn = function _iaddn(num) {
this.words[0] += num;
for (var 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;
};
BN.prototype.isubn = function isubn(num) {
assert(typeof num === "number");
assert(num < 67108864);
if (num < 0) return this.iaddn(-num);
if (this.negative !== 0) {
this.negative = 0;
this.iaddn(num);
this.negative = 1;
return this;
}
this.words[0] -= num;
if (this.length === 1 && this.words[0] < 0) {
this.words[0] = -this.words[0];
this.negative = 1;
} else for (var i = 0; i < this.length && this.words[i] < 0; i++) {
this.words[i] += 67108864;
this.words[i + 1] -= 1;
}
return this._strip();
};
BN.prototype.addn = function addn(num) {
return this.clone().iaddn(num);
};
BN.prototype.subn = function subn(num) {
return this.clone().isubn(num);
};
BN.prototype.iabs = function iabs() {
this.negative = 0;
return this;
};
BN.prototype.abs = function abs() {
return this.clone().iabs();
};
BN.prototype._ishlnsubmul = function _ishlnsubmul(num, mul, shift) {
var 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) * mul;
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();
assert(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();
};
BN.prototype._wordDiv = function _wordDiv(num, mode) {
var shift = this.length - num.length;
var a = this.clone();
var b = num;
var bhi = b.words[b.length - 1] | 0;
shift = 26 - this._countBits(bhi);
if (shift !== 0) {
b = b.ushln(shift);
a.iushln(shift);
bhi = b.words[b.length - 1] | 0;
}
var m = a.length - b.length;
var q;
if (mode !== "mod") {
q = new BN(null);
q.length = m + 1;
q.words = new Array(q.length);
for (var 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
};
};
BN.prototype.divmod = function divmod(num, mode, positive) {
assert(!num.isZero());
if (this.isZero()) return {
div: new BN(0),
mod: new BN(0)
};
var div, mod, res;
if (this.negative !== 0 && num.negative === 0) {
res = this.neg().divmod(num, mode);
if (mode !== "mod") div = res.div.neg();
if (mode !== "div") {
mod = res.mod.neg();
if (positive && mod.negative !== 0) mod.iadd(num);
}
return {
div,
mod
};
}
if (this.negative === 0 && num.negative !== 0) {
res = this.divmod(num.neg(), mode);
if (mode !== "mod") div = res.div.neg();
return {
div,
mod: res.mod
};
}
if ((this.negative & num.negative) !== 0) {
res = this.neg().divmod(num.neg(), mode);
if (mode !== "div") {
mod = res.mod.neg();
if (positive && mod.negative !== 0) mod.isub(num);
}
return {
div: res.div,
mod
};
}
if (num.length > this.length || this.cmp(num) < 0) return {
div: new BN(0),
mod: this
};
if (num.length === 1) {
if (mode === "div") return {
div: this.divn(num.words[0]),
mod: null
};
if (mode === "mod") return {
div: null,
mod: new BN(this.modrn(num.words[0]))
};
return {
div: this.divn(num.words[0]),
mod: new BN(this.modrn(num.words[0]))
};
}
return this._wordDiv(num, mode);
};
BN.prototype.div = function div(num) {
return this.divmod(num, "div", false).div;
};
BN.prototype.mod = function mod(num) {
return this.divmod(num, "mod", false).mod;
};
BN.prototype.umod = function umod(num) {
return this.divmod(num, "mod", true).mod;
};
BN.prototype.divRound = function divRound(num) {
var dm = this.divmod(num);
if (dm.mod.isZero()) return dm.div;
var mod = dm.div.negative !== 0 ? dm.mod.isub(num) : dm.mod;
var half = num.ushrn(1);
var r2 = num.andln(1);
var cmp = mod.cmp(half);
if (cmp < 0 || r2 === 1 && cmp === 0) return dm.div;
return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1);
};
BN.prototype.modrn = function modrn(num) {
var isNegNum = num < 0;
if (isNegNum) num = -num;
assert(num <= 67108863);
var p = (1 << 26) % num;
var acc = 0;
for (var i = this.length - 1; i >= 0; i--) acc = (p * acc + (this.words[i] | 0)) % num;
return isNegNum ? -acc : acc;
};
BN.prototype.modn = function modn(num) {
return this.modrn(num);
};
BN.prototype.idivn = function idivn(num) {
var isNegNum = num < 0;
if (isNegNum) num = -num;
assert(num <= 67108863);
var carry = 0;
for (var 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;
};
BN.prototype.divn = function divn(num) {
return this.clone().idivn(num);
};
BN.prototype.egcd = function egcd(p) {
assert(p.negative === 0);
assert(!p.isZero());
var x = this;
var y = p.clone();
if (x.negative !== 0) x = x.umod(p);
else x = x.clone();
var A = new BN(1);
var B = new BN(0);
var C = new BN(0);
var D = new BN(1);
var g = 0;
while (x.isEven() && y.isEven()) {
x.iushrn(1);
y.iushrn(1);
++g;
}
var yp = y.clone();
var xp = x.clone();
while (!x.isZero()) {
for (var 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(g)
};
};
BN.prototype._invmp = function _invmp(p) {
assert(p.negative === 0);
assert(!p.isZero());
var a = this;
var b = p.clone();
if (a.negative !== 0) a = a.umod(p);
else a = a.clone();
var x1 = new BN(1);
var x2 = new BN(0);
var delta = b.clone();
while (a.cmpn(1) > 0 && b.cmpn(1) > 0) {
for (var 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;
};
BN.prototype.gcd = function gcd(num) {
if (this.isZero()) return num.abs();
if (num.isZero()) return this.abs();
var a = this.clone();
var b = num.clone();
a.negative = 0;
b.negative = 0;
for (var shift = 0; a.isEven() && b.isEven(); shift++) {
a.iushrn(1);
b.iushrn(1);
}
do {
while (a.isEven()) a.iushrn(1);
while (b.isEven()) b.iushrn(1);
var r = a.cmp(b);
if (r < 0) {
var t = a;
a = b;
b = t;
} else if (r === 0 || b.cmpn(1) === 0) break;
a.isub(b);
} while (true);
return b.iushln(shift);
};
BN.prototype.invm = function invm(num) {
return this.egcd(num).a.umod(num);
};
BN.prototype.isEven = function isEven() {
return (this.words[0] & 1) === 0;
};
BN.prototype.isOdd = function isOdd() {
return (this.words[0] & 1) === 1;
};
BN.prototype.andln = function andln(num) {
return this.words[0] & num;
};
BN.prototype.bincn = function bincn(bit) {
assert(typeof bit === "number");
var r = bit % 26;
var s = (bit - r) / 26;
var q = 1 << r;
if (this.length <= s) {
this._expand(s + 1);
this.words[s] |= q;
return this;
}
var carry = q;
for (var i = s; 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;
};
BN.prototype.isZero = function isZero() {
return this.length === 1 && this.words[0] === 0;
};
BN.prototype.cmpn = function cmpn(num) {
var negative = num < 0;
if (this.negative !== 0 && !negative) return -1;
if (this.negative === 0 && negative) return 1;
this._strip();
var res;
if (this.length > 1) res = 1;
else {
if (negative) num = -num;
assert(num <= 67108863, "Number is too big");
var w = this.words[0] | 0;
res = w === num ? 0 : w < num ? -1 : 1;
}
if (this.negative !== 0) return -res | 0;
return res;
};
BN.prototype.cmp = function cmp(num) {
if (this.negative !== 0 && num.negative === 0) return -1;
if (this.negative === 0 && num.negative !== 0) return 1;
var res = this.ucmp(num);
if (this.negative !== 0) return -res | 0;
return res;
};
BN.prototype.ucmp = function ucmp(num) {
if (this.length > num.length) return 1;
if (this.length < num.length) return -1;
var res = 0;
for (var 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;
};
BN.prototype.gtn = function gtn(num) {
return this.cmpn(num) === 1;
};
BN.prototype.gt = function gt(num) {
return this.cmp(num) === 1;
};
BN.prototype.gten = function gten(num) {
return this.cmpn(num) >= 0;
};
BN.prototype.gte = function gte(num) {
return this.cmp(num) >= 0;
};
BN.prototype.ltn = function ltn(num) {
return this.cmpn(num) === -1;
};
BN.prototype.lt = function lt(num) {
return this.cmp(num) === -1;
};
BN.prototype.lten = function lten(num) {
return this.cmpn(num) <= 0;
};
BN.prototype.lte = function lte(num) {
return this.cmp(num) <= 0;
};
BN.prototype.eqn = function eqn(num) {
return this.cmpn(num) === 0;
};
BN.prototype.eq = function eq(num) {
return this.cmp(num) === 0;
};
BN.red = function red(num) {
return new Red(num);
};
BN.prototype.toRed = function toRed(ctx) {
assert(!this.red, "Already a number in reduction context");
assert(this.negative === 0, "red works only with positives");
return ctx.convertTo(this)._forceRed(ctx);
};
BN.prototype.fromRed = function fromRed() {
assert(this.red, "fromRed works only with numbers in reduction context");
return this.red.convertFrom(this);
};
BN.prototype._forceRed = function _forceRed(ctx) {
this.red = ctx;
return this;
};
BN.prototype.forceRed = function forceRed(ctx) {
assert(!this.red, "Already a number in reduction context");
return this._forceRed(ctx);
};
BN.prototype.redAdd = function redAdd(num) {
assert(this.red, "redAdd works only with red numbers");
return this.red.add(this, num);
};
BN.prototype.redIAdd = function redIAdd(num) {
assert(this.red, "redIAdd works only with red numbers");
return this.red.iadd(this, num);
};
BN.prototype.redSub = function redSub(num) {
assert(this.red, "redSub works only with red numbers");
return this.red.sub(this, num);
};
BN.prototype.redISub = function redISub(num) {
assert(this.red, "redISub works only with red numbers");
return this.red.isub(this, num);
};
BN.prototype.redShl = function redShl(num) {
assert(this.red, "redShl works only with red numbers");
return this.red.shl(this, num);
};
BN.prototype.redMul = function redMul(num) {
assert(this.red, "redMul works only with red numbers");
this.red._verify2(this, num);
return this.red.mul(this, num);
};
BN.prototype.redIMul = function redIMul(num) {
assert(this.red, "redMul works only with red numbers");
this.red._verify2(this, num);
return this.red.imul(this, num);
};
BN.prototype.redSqr = function redSqr() {
assert(this.red, "redSqr works only with red numbers");
this.red._verify1(this);
return this.red.sqr(this);
};
BN.prototype.redISqr = function redISqr() {
assert(this.red, "redISqr works only with red numbers");
this.red._verify1(this);
return this.red.isqr(this);
};
BN.prototype.redSqrt = function redSqrt() {
assert(this.red, "redSqrt works only with red numbers");
this.red._verify1(this);
return this.red.sqrt(this);
};
BN.prototype.redInvm = function redInvm() {
assert(this.red, "redInvm works only with red numbers");
this.red._verify1(this);
return this.red.invm(this);
};
BN.prototype.redNeg = function redNeg() {
assert(this.red, "redNeg works only with red numbers");
this.red._verify1(this);
return this.red.neg(this);
};
BN.prototype.redPow = function redPow(num) {
assert(this.red && !num.red, "redPow(normalNum)");
this.red._verify1(this);
return this.red.pow(this, num);
};
var primes = {
k256: null,
p224: null,
p192: null,
p25519: null
};
function MPrime(name, p) {
this.name = name;
this.p = new BN(p, 16);
this.n = this.p.bitLength();
this.k = new BN(1).iushln(this.n).isub(this.p);
this.tmp = this._tmp();
}
MPrime.prototype._tmp = function _tmp() {
var tmp = new BN(null);
tmp.words = new Array(Math.ceil(this.n / 13));
return tmp;
};
MPrime.prototype.ireduce = function ireduce(num) {
var r = num;
var rlen;
do {
this.split(r, this.tmp);
r = this.imulK(r);
r = r.iadd(this.tmp);
rlen = r.bitLength();
} while (rlen > this.n);
var cmp = rlen < this.n ? -1 : r.ucmp(this.p);
if (cmp === 0) {
r.words[0] = 0;
r.length = 1;
} else if (cmp > 0) r.isub(this.p);
else if (r.strip !== void 0) r.strip();
else r._strip();
return r;
};
MPrime.prototype.split = function split(input, out) {
input.iushrn(this.n, 0, out);
};
MPrime.prototype.imulK = function imulK(num) {
return num.imul(this.k);
};
function K256() {
MPrime.call(this, "k256", "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f");
}
inherits(K256, MPrime);
K256.prototype.split = function split(input, output) {
var mask = 4194303;
var outLen = Math.min(input.length, 9);
for (var 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");
}
inherits(P224, MPrime);
function P192() {
MPrime.call(this, "p192", "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff");
}
inherits(P192, MPrime);
function P25519() {
MPrime.call(this, "25519", "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed");
}
inherits(P25519, MPrime);
P25519.prototype.imulK = function imulK(num) {
var carry = 0;
for (var 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;
};
BN._prime = function prime(name) {
if (primes[name]) return primes[name];
var prime;
if (name === "k256") prime = new K256();
else if (name === "p224") prime = new P224();
else if (name === "p192") prime = new P192();
else if (name === "p25519") prime = new P25519();
else throw new Error("Unknown prime " + name);
primes[name] = prime;
return prime;
};
function Red(m) {
if (typeof m === "string") {
var prime = BN._prime(m);
this.m = prime.p;
this.prime = prime;
} else {
assert(m.gtn(1), "modulus must be greater than 1");
this.m = m;
this.prime = null;
}
}
Red.prototype._verify1 = function _verify1(a) {
assert(a.negative === 0, "red works only with positives");
assert(a.red, "red works only with red numbers");
};
Red.prototype._verify2 = function _verify2(a, b) {
assert((a.negative | b.negative) === 0, "red works only with positives");
assert(a.red && a.red === b.red, "red works only with red numbers");
};
Red.prototype.imod = function imod(a) {
if (this.prime) return this.prime.ireduce(a)._forceRed(this);
move(a, a.umod(this.m)._forceRed(this));
return a;
};
Red.prototype.neg = function neg(a) {
if (a.isZero()) return a.clone();
return this.m.sub(a)._forceRed(this);
};
Red.prototype.add = function add(a, b) {
this._verify2(a, b);
var res = a.add(b);
if (res.cmp(this.m) >= 0) res.isub(this.m);
return res._forceRed(this);
};
Red.prototype.iadd = function iadd(a, b) {
this._verify2(a, b);
var res = a.iadd(b);
if (res.cmp(this.m) >= 0) res.isub(this.m);
return res;
};
Red.prototype.sub = function sub(a, b) {
this._verify2(a, b);
var res = a.sub(b);
if (res.cmpn(0) < 0) res.iadd(this.m);
return res._forceRed(this);
};
Red.prototype.isub = function isub(a, b) {
this._verify2(a, b);
var res = a.isub(b);
if (res.cmpn(0) < 0) res.iadd(this.m);
return res;
};
Red.prototype.shl = function shl(a, num) {
this._verify1(a);
return this.imod(a.ushln(num));
};
Red.prototype.imul = function imul(a, b) {
this._verify2(a, b);
return this.imod(a.imul(b));
};
Red.prototype.mul = function mul(a, b) {
this._verify2(a, b);
return this.imod(a.mul(b));
};
Red.prototype.isqr = function isqr(a) {
return this.imul(a, a.clone());
};
Red.prototype.sqr = function sqr(a) {
return this.mul(a, a);
};
Red.prototype.sqrt = function sqrt(a) {
if (a.isZero()) return a.clone();
var mod3 = this.m.andln(3);
assert(mod3 % 2 === 1);
if (mod3 === 3) {
var pow = this.m.add(new BN(1)).iushrn(2);
return this.pow(a, pow);
}
var q = this.m.subn(1);
var s = 0;
while (!q.isZero() && q.andln(1) === 0) {
s++;
q.iushrn(1);
}
assert(!q.isZero());
var one = new BN(1).toRed(this);
var nOne = one.redNeg();
var lpow = this.m.subn(1).iushrn(1);
var z = this.m.bitLength();
z = new BN(2 * z * z).toRed(this);
while (this.pow(z, lpow).cmp(nOne) !== 0) z.redIAdd(nOne);
var c = this.pow(z, q);
var r = this.pow(a, q.addn(1).iushrn(1));
var t = this.pow(a, q);
var m = s;
while (t.cmp(one) !== 0) {
var tmp = t;
for (var i = 0; tmp.cmp(one) !== 0; i++) tmp = tmp.redSqr();
assert(i < m);
var b = this.pow(c, new BN(1).iushln(m - i - 1));
r = r.redMul(b);
c = b.redSqr();
t = t.redMul(c);
m = i;
}
return r;
};
Red.prototype.invm = function invm(a) {
var inv = a._invmp(this.m);
if (inv.negative !== 0) {
inv.negative = 0;
return this.imod(inv).redNeg();
} else return this.imod(inv);
};
Red.prototype.pow = function pow(a, num) {
if (num.isZero()) return new BN(1).toRed(this);
if (num.cmpn(1) === 0) return a.clone();
var windowSize = 4;
var wnd = new Array(1 << windowSize);
wnd[0] = new BN(1).toRed(this);
wnd[1] = a;
for (var 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 r = num.umod(this.m);
return r === num ? r.clone() : r;
};
Red.prototype.convertFrom = function convertFrom(num) {
var res = num.clone();
res.red = null;
return res;
};
BN.mont = function mont(num) {
return new Mont(num);
};
function Mont(m) {
Red.call(this, m);
this.shift = this.m.bitLength();
if (this.shift % 26 !== 0) this.shift += 26 - this.shift % 26;
this.r = new BN(1).iushln(this.shift);
this.r2 = this.imod(this.r.sqr());
this.rinv = this.r._invmp(this.m);
this.minv = this.rinv.mul(this.r).isubn(1).div(this.m);
this.minv = this.minv.umod(this.r);
this.minv = this.r.sub(this.minv);
}
inherits(Mont, Red);
Mont.prototype.convertTo = function convertTo(num) {
return this.imod(num.ushln(this.shift));
};
Mont.prototype.convertFrom = function convertFrom(num) {
var r = this.imod(num.mul(this.rinv));
r.red = null;
return r;
};
Mont.prototype.imul = function imul(a, b) {
if (a.isZero() || b.isZero()) {
a.words[0] = 0;
a.length = 1;
return a;
}
var t = a.imul(b);
var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
var u = t.isub(c).iushrn(this.shift);
var res = u;
if (u.cmp(this.m) >= 0) res = u.isub(this.m);
else if (u.cmpn(0) < 0) res = u.iadd(this.m);
return res._forceRed(this);
};
Mont.prototype.mul = function mul(a, b) {
if (a.isZero() || b.isZero()) return new BN(0)._forceRed(this);
var t = a.mul(b);
var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
var u = t.isub(c).iushrn(this.shift);
var res = u;
if (u.cmp(this.m) >= 0) res = u.isub(this.m);
else if (u.cmpn(0) < 0) res = u.iadd(this.m);
return res._forceRed(this);
};
Mont.prototype.invm = function invm(a) {
return this.imod(a._invmp(this.m).mul(this.r2))._forceRed(this);
};
})(typeof module === "undefined" || module, exports);
}));
//#endregion
//#region node_modules/browserify-rsa/node_modules/safe-buffer/index.js
var require_safe_buffer$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
var buffer = require_dist();
var Buffer = buffer.Buffer;
function copyProps(src, dst) {
for (var key in src) dst[key] = src[key];
}
if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) module.exports = buffer;
else {
copyProps(buffer, exports);
exports.Buffer = SafeBuffer;
}
function SafeBuffer(arg, encodingOrOffset, length) {
return Buffer(arg, encodingOrOffset, length);
}
SafeBuffer.prototype = Object.create(Buffer.prototype);
copyProps(Buffer, SafeBuffer);
SafeBuffer.from = function(arg, encodingOrOffset, length) {
if (typeof arg === "number") throw new TypeError("Argument must not be a number");
return Buffer(arg, encodingOrOffset, length);
};
SafeBuffer.alloc = function(size, fill, encoding) {
if (typeof size !== "number") throw new TypeError("Argument must be a number");
var buf = Buffer(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 Buffer(size);
};
SafeBuffer.allocUnsafeSlow = function(size) {
if (typeof size !== "number") throw new TypeError("Argument must be a number");
return buffer.SlowBuffer(size);
};
}));
//#endregion
//#region node_modules/browserify-rsa/index.js
var require_browserify_rsa = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var BN = require_bn$4();
var randomBytes = require_browser$11();
var Buffer = require_safe_buffer$1().Buffer;
function getr(priv) {
var len = priv.modulus.byteLength();
var r;
do
r = new BN(randomBytes(len));
while (r.cmp(priv.modulus) >= 0 || !r.umod(priv.prime1) || !r.umod(priv.prime2));
return r;
}
function blind(priv) {
var r = getr(priv);
return {
blinder: r.toRed(BN.mont(priv.modulus)).redPow(new BN(priv.publicExponent)).fromRed(),
unblinder: r.invm(priv.modulus)
};
}
function crt(msg, priv) {
var blinds = blind(priv);
var len = priv.modulus.byteLength();
var blinded = new BN(msg).mul(blinds.blinder).umod(priv.modulus);
var c1 = blinded.toRed(BN.mont(priv.prime1));
var c2 = blinded.toRed(BN.mont(priv.prime2));
var qinv = priv.coefficient;
var p = priv.prime1;
var q = priv.prime2;
var m1 = c1.redPow(priv.exponent1).fromRed();
var m2 = c2.redPow(priv.exponent2).fromRed();
var h = m1.isub(m2).imul(qinv).umod(p).imul(q);
return m2.iadd(h).imul(blinds.unblinder).umod(priv.modulus).toArrayLike(Buffer, "be", len);
}
crt.getr = getr;
module.exports = crt;
}));
//#endregion
//#region node_modules/elliptic/package.json
var package_exports = /* @__PURE__ */ __exportAll({
author: () => author,
bugs: () => bugs,
default: () => package_default,
dependencies: () => dependencies,
description: () => description,
devDependencies: () => devDependencies,
files: () => files,
homepage: () => homepage,
keywords: () => keywords,
license: () => "MIT",
main: () => main,
name: () => name,
repository: () => repository,
scripts: () => scripts,
version: () => version
});
var name, version, description, main, files, scripts, repository, keywords, author, license, bugs, homepage, devDependencies, dependencies, package_default;
var init_package = __esmMin((() => {
name = "elliptic";
version = "6.6.1";
description = "EC cryptography";
main = "lib/elliptic.js";
files = ["lib"];
scripts = {
"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/"
};
repository = {
"type": "git",
"url": "git@github.com:indutny/elliptic"
};
keywords = [
"EC",
"Elliptic",
"curve",
"Cryptography"
];
author = "Fedor Indutny <fedor@indutny.com>";
bugs = { "url": "https://github.com/indutny/elliptic/issues" };
homepage = "https://github.com/indutny/elliptic";
devDependencies = {
"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"
};
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"
};
package_default = {
name,
version,
description,
main,
files,
scripts,
repository,
keywords,
author,
license: "MIT",
bugs,
homepage,
devDependencies,
dependencies
};
}));
//#endregion
//#region node_modules/elliptic/node_modules/bn.js/lib/bn.js
var require_bn$3 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
(function(module$4, exports$4) {
"use strict";
function assert(val, msg) {
if (!val) throw new Error(msg || "Assertion failed");
}
function inherits(ctor, superCtor) {
ctor.super_ = superCtor;
var TempCtor = function() {};
TempCtor.prototype = superCtor.prototype;
ctor.prototype = new TempCtor();
ctor.prototype.constructor = ctor;
}
function BN(number, base, endian) {
if (BN.isBN(number)) return number;
this.negative = 0;
this.words = null;
this.length = 0;
this.red = null;
if (number !== null) {
if (base === "le" || base === "be") {
endian = base;
base = 10;
}
this._init(number || 0, base || 10, endian || "be");
}
}
if (typeof module$4 === "object") module$4.exports = BN;
else exports$4.BN = BN;
BN.BN = BN;
BN.wordSize = 26;
var Buffer;
try {
if (typeof window !== "undefined" && typeof window.Buffer !== "undefined") Buffer = window.Buffer;
else Buffer = require_dist().Buffer;
} catch (e) {}
BN.isBN = function isBN(num) {
if (num instanceof BN) return true;
return num !== null && typeof num === "object" && num.constructor.wordSize === BN.wordSize && Array.isArray(num.words);
};
BN.max = function max(left, right) {
if (left.cmp(right) > 0) return left;
return right;
};
BN.min = function min(left, right) {
if (left.cmp(right) < 0) return left;
return right;
};
BN.prototype._init = function init(number, base, endian) {
if (typeof number === "number") return this._initNumber(number, base, endian);
if (typeof number === "object") return this._initArray(number, base, endian);
if (base === "hex") base = 16;
assert(base === (base | 0) && base >= 2 && base <= 36);
number = number.toString().replace(/\s+/g, "");
var start = 0;
if (number[0] === "-") {
start++;
this.negative = 1;
}
if (start < number.length) if (base === 16) this._parseHex(number, start, endian);
else {
this._parseBase(number, base, start);
if (endian === "le") this._initArray(this.toArray(), base, endian);
}
};
BN.prototype._initNumber = function _initNumber(number, base, endian) {
if (number < 0) {
this.negative = 1;
number = -number;
}
if (number < 67108864) {
this.words = [number & 67108863];
this.length = 1;
} else if (number < 4503599627370496) {
this.words = [number & 67108863, number / 67108864 & 67108863];
this.length = 2;
} else {
assert(number < 9007199254740992);
this.words = [
number & 67108863,
number / 67108864 & 67108863,
1
];
this.length = 3;
}
if (endian !== "le") return;
this._initArray(this.toArray(), base, endian);
};
BN.prototype._initArray = function _initArray(number, base, endian) {
assert(typeof number.length === "number");
if (number.length <= 0) {
this.words = [0];
this.length = 1;
return this;
}
this.length = Math.ceil(number.length / 3);
this.words = new Array(this.length);
for (var 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 r = parseHex4Bits(string, index);
if (index - 1 >= lowerBound) r |= parseHex4Bits(string, index - 1) << 4;
return r;
}
BN.prototype._parseHex = function _parseHex(number, start, endian) {
this.length = Math.ceil((number.length - start) / 6);
this.words = new Array(this.length);
for (var 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 for (i = (number.length - start) % 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, mul) {
var r = 0;
var len = Math.min(str.length, end);
for (var i = start; i < len; i++) {
var c = str.charCodeAt(i) - 48;
r *= mul;
if (c >= 49) r += c - 49 + 10;
else if (c >= 17) r += c - 17 + 10;
else r += c;
}
return r;
}
BN.prototype._parseBase = function _parseBase(number, base, start) {
this.words = [0];
this.length = 1;
for (var limbLen = 0, limbPow = 1; limbPow <= 67108863; limbPow *= base) limbLen++;
limbLen--;
limbPow = limbPow / base | 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, base);
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, base);
for (i = 0; i < mod; i++) pow *= base;
this.imuln(pow);
if (this.words[0] + word < 67108864) this.words[0] += word;
else this._iaddn(word);
}
this.strip();
};
BN.prototype.copy = function copy(dest) {
dest.words = new Array(this.length);
for (var i = 0; i < this.length; i++) dest.words[i] = this.words[i];
dest.length = this.length;
dest.negative = this.negative;
dest.red = this.red;
};
BN.prototype.clone = function clone() {
var r = new BN(null);
this.copy(r);
return r;
};
BN.prototype._expand = function _expand(size) {
while (this.length < size) this.words[this.length++] = 0;
return this;
};
BN.prototype.strip = function strip() {
while (this.length > 1 && this.words[this.length - 1] === 0) this.length--;
return this._normSign();
};
BN.prototype._normSign = function _normSign() {
if (this.length === 1 && this.words[0] === 0) this.negative = 0;
return this;
};
BN.prototype.inspect = function inspect() {
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
];
BN.prototype.toString = function toString(base, padding) {
base = base || 10;
padding = padding | 0 || 1;
var out;
if (base === 16 || base === "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 (base === (base | 0) && base >= 2 && base <= 36) {
var groupSize = groupSizes[base];
var groupBase = groupBases[base];
out = "";
var c = this.clone();
c.negative = 0;
while (!c.isZero()) {
var r = c.modn(groupBase).toString(base);
c = c.idivn(groupBase);
if (!c.isZero()) out = zeros[groupSize - r.length] + r + out;
else out = r + out;
}
if (this.isZero()) out = "0" + out;
while (out.length % padding !== 0) out = "0" + out;
if (this.negative !== 0) out = "-" + out;
return out;
}
assert(false, "Base should be between 2 and 36");
};
BN.prototype.toNumber = function 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) assert(false, "Number can only safely store up to 53 bits");
return this.negative !== 0 ? -ret : ret;
};
BN.prototype.toJSON = function toJSON() {
return this.toString(16);
};
BN.prototype.toBuffer = function toBuffer(endian, length) {
assert(typeof Buffer !== "undefined");
return this.toArrayLike(Buffer, endian, length);
};
BN.prototype.toArray = function toArray(endian, length) {
return this.toArrayLike(Array, endian, length);
};
BN.prototype.toArrayLike = function toArrayLike(ArrayType, endian, length) {
var byteLength = this.byteLength();
var reqLength = length || Math.max(1, byteLength);
assert(byteLength <= reqLength, "byte array longer than desired length");
assert(reqLength > 0, "Requested array length <= 0");
this.strip();
var littleEndian = endian === "le";
var res = new ArrayType(reqLength);
var b, 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) BN.prototype._countBits = function _countBits(w) {
return 32 - Math.clz32(w);
};
else BN.prototype._countBits = function _countBits(w) {
var t = w;
var r = 0;
if (t >= 4096) {
r += 13;
t >>>= 13;
}
if (t >= 64) {
r += 7;
t >>>= 7;
}
if (t >= 8) {
r += 4;
t >>>= 4;
}
if (t >= 2) {
r += 2;
t >>>= 2;
}
return r + t;
};
BN.prototype._zeroBits = function _zeroBits(w) {
if (w === 0) return 26;
var t = w;
var r = 0;
if ((t & 8191) === 0) {
r += 13;
t >>>= 13;
}
if ((t & 127) === 0) {
r += 7;
t >>>= 7;
}
if ((t & 15) === 0) {
r += 4;
t >>>= 4;
}
if ((t & 3) === 0) {
r += 2;
t >>>= 2;
}
if ((t & 1) === 0) r++;
return r;
};
BN.prototype.bitLength = function bitLength() {
var w = this.words[this.length - 1];
var hi = this._countBits(w);
return (this.length - 1) * 26 + hi;
};
function toBitArray(num) {
var w = new Array(num.bitLength());
for (var bit = 0; bit < w.length; bit++) {
var off = bit / 26 | 0;
var wbit = bit % 26;
w[bit] = (num.words[off] & 1 << wbit) >>> wbit;
}
return w;
}
BN.prototype.zeroBits = function zeroBits() {
if (this.isZero()) return 0;
var r = 0;
for (var i = 0; i < this.length; i++) {
var b = this._zeroBits(this.words[i]);
r += b;
if (b !== 26) break;
}
return r;
};
BN.prototype.byteLength = function byteLength() {
return Math.ceil(this.bitLength() / 8);
};
BN.prototype.toTwos = function toTwos(width) {
if (this.negative !== 0) return this.abs().inotn(width).iaddn(1);
return this.clone();
};
BN.prototype.fromTwos = function fromTwos(width) {
if (this.testn(width - 1)) return this.notn(width).iaddn(1).ineg();
return this.clone();
};
BN.prototype.isNeg = function isNeg() {
return this.negative !== 0;
};
BN.prototype.neg = function neg() {
return this.clone().ineg();
};
BN.prototype.ineg = function ineg() {
if (!this.isZero()) this.negative ^= 1;
return this;
};
BN.prototype.iuor = function iuor(num) {
while (this.length < num.length) this.words[this.length++] = 0;
for (var i = 0; i < num.length; i++) this.words[i] = this.words[i] | num.words[i];
return this.strip();
};
BN.prototype.ior = function ior(num) {
assert((this.negative | num.negative) === 0);
return this.iuor(num);
};
BN.prototype.or = function or(num) {
if (this.length > num.length) return this.clone().ior(num);
return num.clone().ior(this);
};
BN.prototype.uor = function uor(num) {
if (this.length > num.length) return this.clone().iuor(num);
return num.clone().iuor(this);
};
BN.prototype.iuand = function iuand(num) {
var b;
if (this.length > num.length) b = num;
else b = this;
for (var i = 0; i < b.length; i++) this.words[i] = this.words[i] & num.words[i];
this.length = b.length;
return this.strip();
};
BN.prototype.iand = function iand(num) {
assert((this.negative | num.negative) === 0);
return this.iuand(num);
};
BN.prototype.and = function and(num) {
if (this.length > num.length) return this.clone().iand(num);
return num.clone().iand(this);
};
BN.prototype.uand = function uand(num) {
if (this.length > num.length) return this.clone().iuand(num);
return num.clone().iuand(this);
};
BN.prototype.iuxor = function iuxor(num) {
var a;
var b;
if (this.length > num.length) {
a = this;
b = num;
} else {
a = num;
b = this;
}
for (var 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();
};
BN.prototype.ixor = function ixor(num) {
assert((this.negative | num.negative) === 0);
return this.iuxor(num);
};
BN.prototype.xor = function xor(num) {
if (this.length > num.length) return this.clone().ixor(num);
return num.clone().ixor(this);
};
BN.prototype.uxor = function uxor(num) {
if (this.length > num.length) return this.clone().iuxor(num);
return num.clone().iuxor(this);
};
BN.prototype.inotn = function inotn(width) {
assert(typeof width === "number" && width >= 0);
var bytesNeeded = Math.ceil(width / 26) | 0;
var bitsLeft = width % 26;
this._expand(bytesNeeded);
if (bitsLeft > 0) bytesNeeded--;
for (var 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();
};
BN.prototype.notn = function notn(width) {
return this.clone().inotn(width);
};
BN.prototype.setn = function setn(bit, val) {
assert(typeof bit === "number" && bit >= 0);
var off = bit / 26 | 0;
var wbit = bit % 26;
this._expand(off + 1);
if (val) this.words[off] = this.words[off] | 1 << wbit;
else this.words[off] = this.words[off] & ~(1 << wbit);
return this.strip();
};
BN.prototype.iadd = function iadd(num) {
var r;
if (this.negative !== 0 && num.negative === 0) {
this.negative = 0;
r = this.isub(num);
this.negative ^= 1;
return this._normSign();
} else if (this.negative === 0 && num.negative !== 0) {
num.negative = 0;
r = this.isub(num);
num.negative = 1;
return r._normSign();
}
var a, b;
if (this.length > num.length) {
a = this;
b = num;
} else {
a = num;
b = this;
}
var carry = 0;
for (var i = 0; i < b.length; i++) {
r = (a.words[i] | 0) + (b.words[i] | 0) + carry;
this.words[i] = r & 67108863;
carry = r >>> 26;
}
for (; carry !== 0 && i < a.length; i++) {
r = (a.words[i] | 0) + carry;
this.words[i] = r & 67108863;
carry = r >>> 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;
};
BN.prototype.add = function add(num) {
var res;
if (num.negative !== 0 && this.negative === 0) {
num.negative = 0;
res = this.sub(num);
num.negative ^= 1;
return res;
} else if (num.negative === 0 && this.negative !== 0) {
this.negative = 0;
res = num.sub(this);
this.negative = 1;
return res;
}
if (this.length > num.length) return this.clone().iadd(num);
return num.clone().iadd(this);
};
BN.prototype.isub = function isub(num) {
if (num.negative !== 0) {
num.negative = 0;
var r = this.iadd(num);
num.negative = 1;
return r._normSign();
} else if (this.negative !== 0) {
this.negative = 0;
this.iadd(num);
this.negative = 1;
return this._normSign();
}
var cmp = this.cmp(num);
if (cmp === 0) {
this.negative = 0;
this.length = 1;
this.words[0] = 0;
return this;
}
var a, b;
if (cmp > 0) {
a = this;
b = num;
} else {
a = num;
b = this;
}
var carry = 0;
for (var i = 0; i < b.length; i++) {
r = (a.words[i] | 0) - (b.words[i] | 0) + carry;
carry = r >> 26;
this.words[i] = r & 67108863;
}
for (; carry !== 0 && i < a.length; i++) {
r = (a.words[i] | 0) + carry;
carry = r >> 26;
this.words[i] = r & 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();
};
BN.prototype.sub = function sub(num) {
return this.clone().isub(num);
};
function smallMulTo(self, num, out) {
out.negative = num.negative ^ self.negative;
var len = self.length + num.length | 0;
out.length = len;
len = len - 1 | 0;
var a = self.words[0] | 0;
var b = num.words[0] | 0;
var r = a * b;
var lo = r & 67108863;
var carry = r / 67108864 | 0;
out.words[0] = lo;
for (var k = 1; k < 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 - self.length + 1); j <= maxJ; j++) {
var i = k - j | 0;
a = self.words[i] | 0;
b = num.words[j] | 0;
r = a * b + rword;
ncarry += r / 67108864 | 0;
rword = r & 67108863;
}
out.words[k] = rword | 0;
carry = ncarry | 0;
}
if (carry !== 0) out.words[k] = carry | 0;
else out.length--;
return out.strip();
}
var comb10MulTo = function comb10MulTo(self, num, out) {
var a = self.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 = self.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(self, num, out) {
out.negative = num.negative ^ self.negative;
out.length = self.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 - self.length + 1); j <= maxJ; j++) {
var i = k - j;
var r = (self.words[i] | 0) * (num.words[j] | 0);
var lo = r & 67108863;
ncarry = ncarry + (r / 67108864 | 0) | 0;
lo = lo + rword | 0;
rword = lo & 67108863;
ncarry = ncarry + (lo >>> 26) | 0;
hncarry += ncarry >>> 26;
ncarry &= 67108863;
}
out.words[k] = rword;
carry = ncarry;
ncarry = hncarry;
}
if (carry !== 0) out.words[k] = carry;
else out.length--;
return out.strip();
}
function jumboMulTo(self, num, out) {
return new FFTM().mulp(self, num, out);
}
BN.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 = BN.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 permute(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 s = 1; s < N; s <<= 1) {
var l = s << 1;
var rtwdf = Math.cos(2 * Math.PI / l);
var itwdf = Math.sin(2 * Math.PI / l);
for (var p = 0; p < N; p += l) {
var rtwdf_ = rtwdf;
var itwdf_ = itwdf;
for (var j = 0; j < s; j++) {
var re = rtws[p + j];
var ie = itws[p + j];
var ro = rtws[p + j + s];
var io = itws[p + j + s];
var rx = rtwdf_ * ro - itwdf_ * io;
io = rtwdf_ * io + itwdf_ * ro;
ro = rx;
rtws[p + j] = re + ro;
itws[p + j] = ie + io;
rtws[p + j + s] = re - ro;
itws[p + j + s] = ie - io;
if (j !== l) {
rx = rtwdf * rtwdf_ - itwdf * itwdf_;
itwdf_ = rtwdf * itwdf_ + itwdf * rtwdf_;
rtwdf_ = rx;
}
}
}
}
};
FFTM.prototype.guessLen13b = function guessLen13b(n, m) {
var N = Math.max(m, n) | 1;
var odd = N & 1;
var 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;
assert(carry === 0);
assert((carry & -8192) === 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();
};
BN.prototype.mul = function mul(num) {
var out = new BN(null);
out.words = new Array(this.length + num.length);
return this.mulTo(num, out);
};
BN.prototype.mulf = function mulf(num) {
var out = new BN(null);
out.words = new Array(this.length + num.length);
return jumboMulTo(this, num, out);
};
BN.prototype.imul = function imul(num) {
return this.clone().mulTo(num, this);
};
BN.prototype.imuln = function imuln(num) {
assert(typeof num === "number");
assert(num < 67108864);
var carry = 0;
for (var 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;
};
BN.prototype.muln = function muln(num) {
return this.clone().imuln(num);
};
BN.prototype.sqr = function sqr() {
return this.mul(this);
};
BN.prototype.isqr = function isqr() {
return this.imul(this.clone());
};
BN.prototype.pow = function pow(num) {
var w = toBitArray(num);
if (w.length === 0) return new BN(1);
var res = this;
for (var 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;
};
BN.prototype.iushln = function iushln(bits) {
assert(typeof bits === "number" && bits >= 0);
var r = bits % 26;
var s = (bits - r) / 26;
var carryMask = 67108863 >>> 26 - r << 26 - r;
var i;
if (r !== 0) {
var carry = 0;
for (i = 0; i < this.length; i++) {
var newCarry = this.words[i] & carryMask;
var c = (this.words[i] | 0) - newCarry << r;
this.words[i] = c | carry;
carry = newCarry >>> 26 - r;
}
if (carry) {
this.words[i] = carry;
this.length++;
}
}
if (s !== 0) {
for (i = this.length - 1; i >= 0; i--) this.words[i + s] = this.words[i];
for (i = 0; i < s; i++) this.words[i] = 0;
this.length += s;
}
return this.strip();
};
BN.prototype.ishln = function ishln(bits) {
assert(this.negative === 0);
return this.iushln(bits);
};
BN.prototype.iushrn = function iushrn(bits, hint, extended) {
assert(typeof bits === "number" && bits >= 0);
var h;
if (hint) h = (hint - hint % 26) / 26;
else h = 0;
var r = bits % 26;
var s = Math.min((bits - r) / 26, this.length);
var mask = 67108863 ^ 67108863 >>> r << r;
var maskedWords = extended;
h -= s;
h = Math.max(0, h);
if (maskedWords) {
for (var i = 0; i < s; i++) maskedWords.words[i] = this.words[i];
maskedWords.length = s;
}
if (s === 0) {} else if (this.length > s) {
this.length -= s;
for (i = 0; i < this.length; i++) this.words[i] = this.words[i + s];
} 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 - r | word >>> r;
carry = word & mask;
}
if (maskedWords && carry !== 0) maskedWords.words[maskedWords.length++] = carry;
if (this.length === 0) {
this.words[0] = 0;
this.length = 1;
}
return this.strip();
};
BN.prototype.ishrn = function ishrn(bits, hint, extended) {
assert(this.negative === 0);
return this.iushrn(bits, hint, extended);
};
BN.prototype.shln = function shln(bits) {
return this.clone().ishln(bits);
};
BN.prototype.ushln = function ushln(bits) {
return this.clone().iushln(bits);
};
BN.prototype.shrn = function shrn(bits) {
return this.clone().ishrn(bits);
};
BN.prototype.ushrn = function ushrn(bits) {
return this.clone().iushrn(bits);
};
BN.prototype.testn = function testn(bit) {
assert(typeof bit === "number" && bit >= 0);
var r = bit % 26;
var s = (bit - r) / 26;
var q = 1 << r;
if (this.length <= s) return false;
return !!(this.words[s] & q);
};
BN.prototype.imaskn = function imaskn(bits) {
assert(typeof bits === "number" && bits >= 0);
var r = bits % 26;
var s = (bits - r) / 26;
assert(this.negative === 0, "imaskn works only with positive numbers");
if (this.length <= s) return this;
if (r !== 0) s++;
this.length = Math.min(s, this.length);
if (r !== 0) {
var mask = 67108863 ^ 67108863 >>> r << r;
this.words[this.length - 1] &= mask;
}
return this.strip();
};
BN.prototype.maskn = function maskn(bits) {
return this.clone().imaskn(bits);
};
BN.prototype.iaddn = function iaddn(num) {
assert(typeof num === "number");
assert(num < 67108864);
if (num < 0) return this.isubn(-num);
if (this.negative !== 0) {
if (this.length === 1 && (this.words[0] | 0) < num) {
this.words[0] = num - (this.words[0] | 0);
this.negative = 0;
return this;
}
this.negative = 0;
this.isubn(num);
this.negative = 1;
return this;
}
return this._iaddn(num);
};
BN.prototype._iaddn = function _iaddn(num) {
this.words[0] += num;
for (var 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;
};
BN.prototype.isubn = function isubn(num) {
assert(typeof num === "number");
assert(num < 67108864);
if (num < 0) return this.iaddn(-num);
if (this.negative !== 0) {
this.negative = 0;
this.iaddn(num);
this.negative = 1;
return this;
}
this.words[0] -= num;
if (this.length === 1 && this.words[0] < 0) {
this.words[0] = -this.words[0];
this.negative = 1;
} else for (var i = 0; i < this.length && this.words[i] < 0; i++) {
this.words[i] += 67108864;
this.words[i + 1] -= 1;
}
return this.strip();
};
BN.prototype.addn = function addn(num) {
return this.clone().iaddn(num);
};
BN.prototype.subn = function subn(num) {
return this.clone().isubn(num);
};
BN.prototype.iabs = function iabs() {
this.negative = 0;
return this;
};
BN.prototype.abs = function abs() {
return this.clone().iabs();
};
BN.prototype._ishlnsubmul = function _ishlnsubmul(num, mul, shift) {
var 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) * mul;
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();
assert(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();
};
BN.prototype._wordDiv = function _wordDiv(num, mode) {
var shift = this.length - num.length;
var a = this.clone();
var b = num;
var bhi = b.words[b.length - 1] | 0;
shift = 26 - this._countBits(bhi);
if (shift !== 0) {
b = b.ushln(shift);
a.iushln(shift);
bhi = b.words[b.length - 1] | 0;
}
var m = a.length - b.length;
var q;
if (mode !== "mod") {
q = new BN(null);
q.length = m + 1;
q.words = new Array(q.length);
for (var 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
};
};
BN.prototype.divmod = function divmod(num, mode, positive) {
assert(!num.isZero());
if (this.isZero()) return {
div: new BN(0),
mod: new BN(0)
};
var div, mod, res;
if (this.negative !== 0 && num.negative === 0) {
res = this.neg().divmod(num, mode);
if (mode !== "mod") div = res.div.neg();
if (mode !== "div") {
mod = res.mod.neg();
if (positive && mod.negative !== 0) mod.iadd(num);
}
return {
div,
mod
};
}
if (this.negative === 0 && num.negative !== 0) {
res = this.divmod(num.neg(), mode);
if (mode !== "mod") div = res.div.neg();
return {
div,
mod: res.mod
};
}
if ((this.negative & num.negative) !== 0) {
res = this.neg().divmod(num.neg(), mode);
if (mode !== "div") {
mod = res.mod.neg();
if (positive && mod.negative !== 0) mod.isub(num);
}
return {
div: res.div,
mod
};
}
if (num.length > this.length || this.cmp(num) < 0) return {
div: new BN(0),
mod: this
};
if (num.length === 1) {
if (mode === "div") return {
div: this.divn(num.words[0]),
mod: null
};
if (mode === "mod") return {
div: null,
mod: new BN(this.modn(num.words[0]))
};
return {
div: this.divn(num.words[0]),
mod: new BN(this.modn(num.words[0]))
};
}
return this._wordDiv(num, mode);
};
BN.prototype.div = function div(num) {
return this.divmod(num, "div", false).div;
};
BN.prototype.mod = function mod(num) {
return this.divmod(num, "mod", false).mod;
};
BN.prototype.umod = function umod(num) {
return this.divmod(num, "mod", true).mod;
};
BN.prototype.divRound = function divRound(num) {
var dm = this.divmod(num);
if (dm.mod.isZero()) return dm.div;
var mod = dm.div.negative !== 0 ? dm.mod.isub(num) : dm.mod;
var half = num.ushrn(1);
var r2 = num.andln(1);
var cmp = mod.cmp(half);
if (cmp < 0 || r2 === 1 && cmp === 0) return dm.div;
return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1);
};
BN.prototype.modn = function modn(num) {
assert(num <= 67108863);
var p = (1 << 26) % num;
var acc = 0;
for (var i = this.length - 1; i >= 0; i--) acc = (p * acc + (this.words[i] | 0)) % num;
return acc;
};
BN.prototype.idivn = function idivn(num) {
assert(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();
};
BN.prototype.divn = function divn(num) {
return this.clone().idivn(num);
};
BN.prototype.egcd = function egcd(p) {
assert(p.negative === 0);
assert(!p.isZero());
var x = this;
var y = p.clone();
if (x.negative !== 0) x = x.umod(p);
else x = x.clone();
var A = new BN(1);
var B = new BN(0);
var C = new BN(0);
var D = new BN(1);
var g = 0;
while (x.isEven() && y.isEven()) {
x.iushrn(1);
y.iushrn(1);
++g;
}
var yp = y.clone();
var xp = x.clone();
while (!x.isZero()) {
for (var 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(g)
};
};
BN.prototype._invmp = function _invmp(p) {
assert(p.negative === 0);
assert(!p.isZero());
var a = this;
var b = p.clone();
if (a.negative !== 0) a = a.umod(p);
else a = a.clone();
var x1 = new BN(1);
var x2 = new BN(0);
var delta = b.clone();
while (a.cmpn(1) > 0 && b.cmpn(1) > 0) {
for (var 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;
};
BN.prototype.gcd = function gcd(num) {
if (this.isZero()) return num.abs();
if (num.isZero()) return this.abs();
var a = this.clone();
var b = num.clone();
a.negative = 0;
b.negative = 0;
for (var shift = 0; a.isEven() && b.isEven(); shift++) {
a.iushrn(1);
b.iushrn(1);
}
do {
while (a.isEven()) a.iushrn(1);
while (b.isEven()) b.iushrn(1);
var r = a.cmp(b);
if (r < 0) {
var t = a;
a = b;
b = t;
} else if (r === 0 || b.cmpn(1) === 0) break;
a.isub(b);
} while (true);
return b.iushln(shift);
};
BN.prototype.invm = function invm(num) {
return this.egcd(num).a.umod(num);
};
BN.prototype.isEven = function isEven() {
return (this.words[0] & 1) === 0;
};
BN.prototype.isOdd = function isOdd() {
return (this.words[0] & 1) === 1;
};
BN.prototype.andln = function andln(num) {
return this.words[0] & num;
};
BN.prototype.bincn = function bincn(bit) {
assert(typeof bit === "number");
var r = bit % 26;
var s = (bit - r) / 26;
var q = 1 << r;
if (this.length <= s) {
this._expand(s + 1);
this.words[s] |= q;
return this;
}
var carry = q;
for (var i = s; 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;
};
BN.prototype.isZero = function isZero() {
return this.length === 1 && this.words[0] === 0;
};
BN.prototype.cmpn = function cmpn(num) {
var negative = num < 0;
if (this.negative !== 0 && !negative) return -1;
if (this.negative === 0 && negative) return 1;
this.strip();
var res;
if (this.length > 1) res = 1;
else {
if (negative) num = -num;
assert(num <= 67108863, "Number is too big");
var w = this.words[0] | 0;
res = w === num ? 0 : w < num ? -1 : 1;
}
if (this.negative !== 0) return -res | 0;
return res;
};
BN.prototype.cmp = function cmp(num) {
if (this.negative !== 0 && num.negative === 0) return -1;
if (this.negative === 0 && num.negative !== 0) return 1;
var res = this.ucmp(num);
if (this.negative !== 0) return -res | 0;
return res;
};
BN.prototype.ucmp = function ucmp(num) {
if (this.length > num.length) return 1;
if (this.length < num.length) return -1;
var res = 0;
for (var 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;
};
BN.prototype.gtn = function gtn(num) {
return this.cmpn(num) === 1;
};
BN.prototype.gt = function gt(num) {
return this.cmp(num) === 1;
};
BN.prototype.gten = function gten(num) {
return this.cmpn(num) >= 0;
};
BN.prototype.gte = function gte(num) {
return this.cmp(num) >= 0;
};
BN.prototype.ltn = function ltn(num) {
return this.cmpn(num) === -1;
};
BN.prototype.lt = function lt(num) {
return this.cmp(num) === -1;
};
BN.prototype.lten = function lten(num) {
return this.cmpn(num) <= 0;
};
BN.prototype.lte = function lte(num) {
return this.cmp(num) <= 0;
};
BN.prototype.eqn = function eqn(num) {
return this.cmpn(num) === 0;
};
BN.prototype.eq = function eq(num) {
return this.cmp(num) === 0;
};
BN.red = function red(num) {
return new Red(num);
};
BN.prototype.toRed = function toRed(ctx) {
assert(!this.red, "Already a number in reduction context");
assert(this.negative === 0, "red works only with positives");
return ctx.convertTo(this)._forceRed(ctx);
};
BN.prototype.fromRed = function fromRed() {
assert(this.red, "fromRed works only with numbers in reduction context");
return this.red.convertFrom(this);
};
BN.prototype._forceRed = function _forceRed(ctx) {
this.red = ctx;
return this;
};
BN.prototype.forceRed = function forceRed(ctx) {
assert(!this.red, "Already a number in reduction context");
return this._forceRed(ctx);
};
BN.prototype.redAdd = function redAdd(num) {
assert(this.red, "redAdd works only with red numbers");
return this.red.add(this, num);
};
BN.prototype.redIAdd = function redIAdd(num) {
assert(this.red, "redIAdd works only with red numbers");
return this.red.iadd(this, num);
};
BN.prototype.redSub = function redSub(num) {
assert(this.red, "redSub works only with red numbers");
return this.red.sub(this, num);
};
BN.prototype.redISub = function redISub(num) {
assert(this.red, "redISub works only with red numbers");
return this.red.isub(this, num);
};
BN.prototype.redShl = function redShl(num) {
assert(this.red, "redShl works only with red numbers");
return this.red.shl(this, num);
};
BN.prototype.redMul = function redMul(num) {
assert(this.red, "redMul works only with red numbers");
this.red._verify2(this, num);
return this.red.mul(this, num);
};
BN.prototype.redIMul = function redIMul(num) {
assert(this.red, "redMul works only with red numbers");
this.red._verify2(this, num);
return this.red.imul(this, num);
};
BN.prototype.redSqr = function redSqr() {
assert(this.red, "redSqr works only with red numbers");
this.red._verify1(this);
return this.red.sqr(this);
};
BN.prototype.redISqr = function redISqr() {
assert(this.red, "redISqr works only with red numbers");
this.red._verify1(this);
return this.red.isqr(this);
};
BN.prototype.redSqrt = function redSqrt() {
assert(this.red, "redSqrt works only with red numbers");
this.red._verify1(this);
return this.red.sqrt(this);
};
BN.prototype.redInvm = function redInvm() {
assert(this.red, "redInvm works only with red numbers");
this.red._verify1(this);
return this.red.invm(this);
};
BN.prototype.redNeg = function redNeg() {
assert(this.red, "redNeg works only with red numbers");
this.red._verify1(this);
return this.red.neg(this);
};
BN.prototype.redPow = function redPow(num) {
assert(this.red && !num.red, "redPow(normalNum)");
this.red._verify1(this);
return this.red.pow(this, num);
};
var primes = {
k256: null,
p224: null,
p192: null,
p25519: null
};
function MPrime(name, p) {
this.name = name;
this.p = new BN(p, 16);
this.n = this.p.bitLength();
this.k = new BN(1).iushln(this.n).isub(this.p);
this.tmp = this._tmp();
}
MPrime.prototype._tmp = function _tmp() {
var tmp = new BN(null);
tmp.words = new Array(Math.ceil(this.n / 13));
return tmp;
};
MPrime.prototype.ireduce = function ireduce(num) {
var r = num;
var rlen;
do {
this.split(r, this.tmp);
r = this.imulK(r);
r = r.iadd(this.tmp);
rlen = r.bitLength();
} while (rlen > this.n);
var cmp = rlen < this.n ? -1 : r.ucmp(this.p);
if (cmp === 0) {
r.words[0] = 0;
r.length = 1;
} else if (cmp > 0) r.isub(this.p);
else if (r.strip !== void 0) r.strip();
else r._strip();
return r;
};
MPrime.prototype.split = function split(input, out) {
input.iushrn(this.n, 0, out);
};
MPrime.prototype.imulK = function imulK(num) {
return num.imul(this.k);
};
function K256() {
MPrime.call(this, "k256", "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f");
}
inherits(K256, MPrime);
K256.prototype.split = function split(input, output) {
var mask = 4194303;
var outLen = Math.min(input.length, 9);
for (var 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");
}
inherits(P224, MPrime);
function P192() {
MPrime.call(this, "p192", "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff");
}
inherits(P192, MPrime);
function P25519() {
MPrime.call(this, "25519", "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed");
}
inherits(P25519, MPrime);
P25519.prototype.imulK = function imulK(num) {
var carry = 0;
for (var 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;
};
BN._prime = function prime(name) {
if (primes[name]) return primes[name];
var prime;
if (name === "k256") prime = new K256();
else if (name === "p224") prime = new P224();
else if (name === "p192") prime = new P192();
else if (name === "p25519") prime = new P25519();
else throw new Error("Unknown prime " + name);
primes[name] = prime;
return prime;
};
function Red(m) {
if (typeof m === "string") {
var prime = BN._prime(m);
this.m = prime.p;
this.prime = prime;
} else {
assert(m.gtn(1), "modulus must be greater than 1");
this.m = m;
this.prime = null;
}
}
Red.prototype._verify1 = function _verify1(a) {
assert(a.negative === 0, "red works only with positives");
assert(a.red, "red works only with red numbers");
};
Red.prototype._verify2 = function _verify2(a, b) {
assert((a.negative | b.negative) === 0, "red works only with positives");
assert(a.red && a.red === b.red, "red works only with red numbers");
};
Red.prototype.imod = function imod(a) {
if (this.prime) return this.prime.ireduce(a)._forceRed(this);
return a.umod(this.m)._forceRed(this);
};
Red.prototype.neg = function neg(a) {
if (a.isZero()) return a.clone();
return this.m.sub(a)._forceRed(this);
};
Red.prototype.add = function add(a, b) {
this._verify2(a, b);
var res = a.add(b);
if (res.cmp(this.m) >= 0) res.isub(this.m);
return res._forceRed(this);
};
Red.prototype.iadd = function iadd(a, b) {
this._verify2(a, b);
var res = a.iadd(b);
if (res.cmp(this.m) >= 0) res.isub(this.m);
return res;
};
Red.prototype.sub = function sub(a, b) {
this._verify2(a, b);
var res = a.sub(b);
if (res.cmpn(0) < 0) res.iadd(this.m);
return res._forceRed(this);
};
Red.prototype.isub = function isub(a, b) {
this._verify2(a, b);
var res = a.isub(b);
if (res.cmpn(0) < 0) res.iadd(this.m);
return res;
};
Red.prototype.shl = function shl(a, num) {
this._verify1(a);
return this.imod(a.ushln(num));
};
Red.prototype.imul = function imul(a, b) {
this._verify2(a, b);
return this.imod(a.imul(b));
};
Red.prototype.mul = function mul(a, b) {
this._verify2(a, b);
return this.imod(a.mul(b));
};
Red.prototype.isqr = function isqr(a) {
return this.imul(a, a.clone());
};
Red.prototype.sqr = function sqr(a) {
return this.mul(a, a);
};
Red.prototype.sqrt = function sqrt(a) {
if (a.isZero()) return a.clone();
var mod3 = this.m.andln(3);
assert(mod3 % 2 === 1);
if (mod3 === 3) {
var pow = this.m.add(new BN(1)).iushrn(2);
return this.pow(a, pow);
}
var q = this.m.subn(1);
var s = 0;
while (!q.isZero() && q.andln(1) === 0) {
s++;
q.iushrn(1);
}
assert(!q.isZero());
var one = new BN(1).toRed(this);
var nOne = one.redNeg();
var lpow = this.m.subn(1).iushrn(1);
var z = this.m.bitLength();
z = new BN(2 * z * z).toRed(this);
while (this.pow(z, lpow).cmp(nOne) !== 0) z.redIAdd(nOne);
var c = this.pow(z, q);
var r = this.pow(a, q.addn(1).iushrn(1));
var t = this.pow(a, q);
var m = s;
while (t.cmp(one) !== 0) {
var tmp = t;
for (var i = 0; tmp.cmp(one) !== 0; i++) tmp = tmp.redSqr();
assert(i < m);
var b = this.pow(c, new BN(1).iushln(m - i - 1));
r = r.redMul(b);
c = b.redSqr();
t = t.redMul(c);
m = i;
}
return r;
};
Red.prototype.invm = function invm(a) {
var inv = a._invmp(this.m);
if (inv.negative !== 0) {
inv.negative = 0;
return this.imod(inv).redNeg();
} else return this.imod(inv);
};
Red.prototype.pow = function pow(a, num) {
if (num.isZero()) return new BN(1).toRed(this);
if (num.cmpn(1) === 0) return a.clone();
var windowSize = 4;
var wnd = new Array(1 << windowSize);
wnd[0] = new BN(1).toRed(this);
wnd[1] = a;
for (var 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 r = num.umod(this.m);
return r === num ? r.clone() : r;
};
Red.prototype.convertFrom = function convertFrom(num) {
var res = num.clone();
res.red = null;
return res;
};
BN.mont = function mont(num) {
return new Mont(num);
};
function Mont(m) {
Red.call(this, m);
this.shift = this.m.bitLength();
if (this.shift % 26 !== 0) this.shift += 26 - this.shift % 26;
this.r = new BN(1).iushln(this.shift);
this.r2 = this.imod(this.r.sqr());
this.rinv = this.r._invmp(this.m);
this.minv = this.rinv.mul(this.r).isubn(1).div(this.m);
this.minv = this.minv.umod(this.r);
this.minv = this.r.sub(this.minv);
}
inherits(Mont, Red);
Mont.prototype.convertTo = function convertTo(num) {
return this.imod(num.ushln(this.shift));
};
Mont.prototype.convertFrom = function convertFrom(num) {
var r = this.imod(num.mul(this.rinv));
r.red = null;
return r;
};
Mont.prototype.imul = function imul(a, b) {
if (a.isZero() || b.isZero()) {
a.words[0] = 0;
a.length = 1;
return a;
}
var t = a.imul(b);
var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
var u = t.isub(c).iushrn(this.shift);
var res = u;
if (u.cmp(this.m) >= 0) res = u.isub(this.m);
else if (u.cmpn(0) < 0) res = u.iadd(this.m);
return res._forceRed(this);
};
Mont.prototype.mul = function mul(a, b) {
if (a.isZero() || b.isZero()) return new BN(0)._forceRed(this);
var t = a.mul(b);
var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
var u = t.isub(c).iushrn(this.shift);
var res = u;
if (u.cmp(this.m) >= 0) res = u.isub(this.m);
else if (u.cmpn(0) < 0) res = u.iadd(this.m);
return res._forceRed(this);
};
Mont.prototype.invm = function invm(a) {
return this.imod(a._invmp(this.m).mul(this.r2))._forceRed(this);
};
})(typeof module === "undefined" || module, exports);
}));
//#endregion
//#region node_modules/minimalistic-crypto-utils/lib/utils.js
var require_utils$2 = /* @__PURE__ */ __commonJSMin(((exports) => {
var utils = exports;
function toArray(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]+/gi, "");
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;
}
utils.toArray = toArray;
function zero2(word) {
if (word.length === 1) return "0" + word;
else return word;
}
utils.zero2 = zero2;
function toHex(msg) {
var res = "";
for (var i = 0; i < msg.length; i++) res += zero2(msg[i].toString(16));
return res;
}
utils.toHex = toHex;
utils.encode = function encode(arr, enc) {
if (enc === "hex") return toHex(arr);
else return arr;
};
}));
//#endregion
//#region node_modules/elliptic/lib/elliptic/utils.js
var require_utils$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
var utils = exports;
var BN = require_bn$3();
var minAssert = require_minimalistic_assert();
var minUtils = require_utils$2();
utils.assert = minAssert;
utils.toArray = minUtils.toArray;
utils.zero2 = minUtils.zero2;
utils.toHex = minUtils.toHex;
utils.encode = minUtils.encode;
function getNAF(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 z;
var mod = k.andln(ws - 1);
if (k.isOdd()) {
if (mod > (ws >> 1) - 1) z = (ws >> 1) - mod;
else z = mod;
k.isubn(z);
} else z = 0;
naf[i] = z;
k.iushrn(1);
}
return naf;
}
utils.getNAF = getNAF;
function getJSF(k1, k2) {
var jsf = [[], []];
k1 = k1.clone();
k2 = k2.clone();
var d1 = 0;
var d2 = 0;
var m8;
while (k1.cmpn(-d1) > 0 || k2.cmpn(-d2) > 0) {
var m14 = k1.andln(3) + d1 & 3;
var m24 = k2.andln(3) + d2 & 3;
if (m14 === 3) m14 = -1;
if (m24 === 3) m24 = -1;
var u1;
if ((m14 & 1) === 0) u1 = 0;
else {
m8 = k1.andln(7) + d1 & 7;
if ((m8 === 3 || m8 === 5) && m24 === 2) u1 = -m14;
else u1 = m14;
}
jsf[0].push(u1);
var u2;
if ((m24 & 1) === 0) u2 = 0;
else {
m8 = k2.andln(7) + d2 & 7;
if ((m8 === 3 || m8 === 5) && m14 === 2) u2 = -m24;
else u2 = m24;
}
jsf[1].push(u2);
if (2 * d1 === u1 + 1) d1 = 1 - d1;
if (2 * d2 === u2 + 1) d2 = 1 - d2;
k1.iushrn(1);
k2.iushrn(1);
}
return jsf;
}
utils.getJSF = getJSF;
function cachedProperty(obj, name, computer) {
var key = "_" + name;
obj.prototype[name] = function cachedProperty() {
return this[key] !== void 0 ? this[key] : this[key] = computer.call(this);
};
}
utils.cachedProperty = cachedProperty;
function parseBytes(bytes) {
return typeof bytes === "string" ? utils.toArray(bytes, "hex") : bytes;
}
utils.parseBytes = parseBytes;
function intFromLE(bytes) {
return new BN(bytes, "hex", "le");
}
utils.intFromLE = intFromLE;
}));
//#endregion
//#region node_modules/elliptic/lib/elliptic/curve/base.js
var require_base$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var BN = require_bn$3();
var utils = require_utils$1();
var getNAF = utils.getNAF;
var getJSF = utils.getJSF;
var assert = utils.assert;
function BaseCurve(type, conf) {
this.type = type;
this.p = new BN(conf.p, 16);
this.red = conf.prime ? BN.red(conf.prime) : BN.mont(this.p);
this.zero = new BN(0).toRed(this.red);
this.one = new BN(1).toRed(this.red);
this.two = new BN(2).toRed(this.red);
this.n = conf.n && new BN(conf.n, 16);
this.g = conf.g && this.pointFromJSON(conf.g, conf.gRed);
this._wnafT1 = new Array(4);
this._wnafT2 = new Array(4);
this._wnafT3 = new Array(4);
this._wnafT4 = new Array(4);
this._bitLength = this.n ? this.n.bitLength() : 0;
var adjustCount = this.n && this.p.div(this.n);
if (!adjustCount || adjustCount.cmpn(100) > 0) this.redN = null;
else {
this._maxwellTrick = true;
this.redN = this.n.toRed(this.red);
}
}
module.exports = BaseCurve;
BaseCurve.prototype.point = function point() {
throw new Error("Not implemented");
};
BaseCurve.prototype.validate = function validate() {
throw new Error("Not implemented");
};
BaseCurve.prototype._fixedNafMul = function _fixedNafMul(p, k) {
assert(p.precomputed);
var doubles = p._getDoubles();
var naf = getNAF(k, 1, this._bitLength);
var I = (1 << doubles.step + 1) - (doubles.step % 2 === 0 ? 2 : 1);
I /= 3;
var repr = [];
var j;
var nafW;
for (j = 0; j < naf.length; j += doubles.step) {
nafW = 0;
for (var l = j + doubles.step - 1; l >= j; l--) nafW = (nafW << 1) + naf[l];
repr.push(nafW);
}
var a = this.jpoint(null, null, null);
var b = this.jpoint(null, null, null);
for (var 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 z = naf[i];
assert(z !== 0);
if (p.type === "affine") if (z > 0) acc = acc.mixedAdd(wnd[z - 1 >> 1]);
else acc = acc.mixedAdd(wnd[-z - 1 >> 1].neg());
else if (z > 0) acc = acc.add(wnd[z - 1 >> 1]);
else acc = acc.add(wnd[-z - 1 >> 1].neg());
}
return p.type === "affine" ? acc.toP() : acc;
};
BaseCurve.prototype._wnafMulAdd = function _wnafMulAdd(defW, points, coeffs, len, jacobianResult) {
var wndWidth = this._wnafT1;
var wnd = this._wnafT2;
var naf = this._wnafT3;
var max = 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);
max = Math.max(naf[a].length, max);
max = Math.max(naf[b].length, max);
continue;
}
var comb = [
points[a],
null,
null,
points[b]
];
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,
-5,
-7,
0,
7,
5,
1,
3
];
var jsf = getJSF(coeffs[a], coeffs[b]);
max = Math.max(jsf[0].length, max);
naf[a] = new Array(max);
naf[b] = new Array(max);
for (j = 0; j < max; j++) {
var ja = jsf[0][j] | 0;
var jb = jsf[1][j] | 0;
naf[a][j] = index[(ja + 1) * 3 + (jb + 1)];
naf[b][j] = 0;
wnd[a] = comb;
}
}
var acc = this.jpoint(null, null, null);
var tmp = this._wnafT4;
for (i = max; 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 z = tmp[j];
if (z === 0) continue;
else if (z > 0) p = wnd[j][z - 1 >> 1];
else if (z < 0) p = wnd[j][-z - 1 >> 1].neg();
if (p.type === "affine") acc = acc.mixedAdd(p);
else acc = acc.add(p);
}
}
for (i = 0; i < len; i++) wnd[i] = null;
if (jacobianResult) return acc;
else return acc.toP();
};
function BasePoint(curve, type) {
this.curve = curve;
this.type = type;
this.precomputed = null;
}
BaseCurve.BasePoint = BasePoint;
BasePoint.prototype.eq = function eq() {
throw new Error("Not implemented");
};
BasePoint.prototype.validate = function validate() {
return this.curve.validate(this);
};
BaseCurve.prototype.decodePoint = function decodePoint(bytes, enc) {
bytes = utils.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(bytes[bytes.length - 1] % 2 === 0);
else if (bytes[0] === 7) assert(bytes[bytes.length - 1] % 2 === 1);
return this.point(bytes.slice(1, 1 + len), bytes.slice(1 + len, 1 + 2 * len));
} 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.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 max = (1 << wnd) - 1;
var dbl = max === 1 ? null : this.dbl();
for (var i = 1; i < max; i++) res[i] = res[i - 1].add(dbl);
return {
wnd,
points: res
};
};
BasePoint.prototype._getBeta = function _getBeta() {
return null;
};
BasePoint.prototype.dblp = function dblp(k) {
var r = this;
for (var i = 0; i < k; i++) r = r.dbl();
return r;
};
}));
//#endregion
//#region node_modules/elliptic/lib/elliptic/curve/short.js
var require_short = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var utils = require_utils$1();
var BN = require_bn$3();
var inherits = require_inherits_browser();
var Base = require_base$1();
var assert = utils.assert;
function ShortCurve(conf) {
Base.call(this, "short", conf);
this.a = new BN(conf.a, 16).toRed(this.red);
this.b = new BN(conf.b, 16).toRed(this.red);
this.tinv = this.two.redInvm();
this.zeroA = this.a.fromRed().cmpn(0) === 0;
this.threeA = this.a.fromRed().sub(this.p).cmpn(-3) === 0;
this.endo = this._getEndomorphism(conf);
this._endoWnafT1 = new Array(4);
this._endoWnafT2 = new Array(4);
}
inherits(ShortCurve, Base);
module.exports = ShortCurve;
ShortCurve.prototype._getEndomorphism = function _getEndomorphism(conf) {
if (!this.zeroA || !this.g || !this.n || this.p.modn(3) !== 1) return;
var beta;
var lambda;
if (conf.beta) beta = new BN(conf.beta, 16).toRed(this.red);
else {
var betas = this._getEndoRoots(this.p);
beta = betas[0].cmp(betas[1]) < 0 ? betas[0] : betas[1];
beta = beta.toRed(this.red);
}
if (conf.lambda) lambda = new BN(conf.lambda, 16);
else {
var lambdas = this._getEndoRoots(this.n);
if (this.g.mul(lambdas[0]).x.cmp(this.g.x.redMul(beta)) === 0) lambda = lambdas[0];
else {
lambda = lambdas[1];
assert(this.g.mul(lambda).x.cmp(this.g.x.redMul(beta)) === 0);
}
}
var basis;
if (conf.basis) basis = conf.basis.map(function(vec) {
return {
a: new BN(vec.a, 16),
b: new BN(vec.b, 16)
};
});
else basis = this._getEndoBasis(lambda);
return {
beta,
lambda,
basis
};
};
ShortCurve.prototype._getEndoRoots = function _getEndoRoots(num) {
var red = num === this.p ? this.red : BN.mont(num);
var tinv = new BN(2).toRed(red).redInvm();
var ntinv = tinv.redNeg();
var s = new BN(3).toRed(red).redNeg().redSqrt().redMul(tinv);
return [ntinv.redAdd(s).fromRed(), ntinv.redSub(s).fromRed()];
};
ShortCurve.prototype._getEndoBasis = function _getEndoBasis(lambda) {
var aprxSqrt = this.n.ushrn(Math.floor(this.n.bitLength() / 2));
var u = lambda;
var v = this.n.clone();
var x1 = new BN(1);
var y1 = new BN(0);
var x2 = new BN(0);
var y2 = new BN(1);
var a0;
var b0;
var a1;
var b1;
var a2;
var b2;
var prevR;
var i = 0;
var r;
var x;
while (u.cmpn(0) !== 0) {
var q = v.div(u);
r = v.sub(q.mul(u));
x = x2.sub(q.mul(x1));
var y = y2.sub(q.mul(y1));
if (!a1 && r.cmp(aprxSqrt) < 0) {
a0 = prevR.neg();
b0 = x1;
a1 = r.neg();
b1 = x;
} else if (a1 && ++i === 2) break;
prevR = r;
v = u;
u = r;
x2 = x1;
x1 = x;
y2 = y1;
y1 = y;
}
a2 = r.neg();
b2 = x;
var len1 = a1.sqr().add(b1.sqr());
if (a2.sqr().add(b2.sqr()).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);
return {
k1: k.sub(p1).sub(p2),
k2: q1.add(q2).neg()
};
};
ShortCurve.prototype.pointFromX = function pointFromX(x, odd) {
x = new BN(x, 16);
if (!x.red) x = x.toRed(this.red);
var y2 = x.redSqr().redMul(x).redIAdd(x.redMul(this.a)).redIAdd(this.b);
var y = y2.redSqrt();
if (y.redSqr().redSub(y2).cmp(this.zero) !== 0) throw new Error("invalid point");
var isOdd = y.fromRed().isOdd();
if (odd && !isOdd || !odd && isOdd) y = y.redNeg();
return this.point(x, y);
};
ShortCurve.prototype.validate = function validate(point) {
if (point.inf) return true;
var x = point.x;
var y = point.y;
var ax = this.a.redMul(x);
var rhs = x.redSqr().redMul(x).redIAdd(ax).redIAdd(this.b);
return y.redSqr().redISub(rhs).cmpn(0) === 0;
};
ShortCurve.prototype._endoWnafMulAdd = function _endoWnafMulAdd(points, coeffs, jacobianResult) {
var npoints = this._endoWnafT1;
var ncoeffs = this._endoWnafT2;
for (var 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(curve, x, y, isRed) {
Base.BasePoint.call(this, curve, "affine");
if (x === null && y === null) {
this.x = null;
this.y = null;
this.inf = true;
} else {
this.x = new BN(x, 16);
this.y = new BN(y, 16);
if (isRed) {
this.x.forceRed(this.curve.red);
this.y.forceRed(this.curve.red);
}
if (!this.x.red) this.x = this.x.toRed(this.curve.red);
if (!this.y.red) this.y = this.y.toRed(this.curve.red);
this.inf = false;
}
}
inherits(Point, Base.BasePoint);
ShortCurve.prototype.point = function point(x, y, isRed) {
return new Point(this, x, y, isRed);
};
ShortCurve.prototype.pointFromJSON = function pointFromJSON(obj, red) {
return Point.fromJSON(this, obj, red);
};
Point.prototype._getBeta = function _getBeta() {
if (!this.curve.endo) return;
var pre = this.precomputed;
if (pre && pre.beta) return pre.beta;
var beta = this.curve.point(this.x.redMul(this.curve.endo.beta), this.y);
if (pre) {
var curve = this.curve;
var endoMul = function(p) {
return curve.point(p.x.redMul(curve.endo.beta), p.y);
};
pre.beta = beta;
beta.precomputed = {
beta: null,
naf: pre.naf && {
wnd: pre.naf.wnd,
points: pre.naf.points.map(endoMul)
},
doubles: pre.doubles && {
step: pre.doubles.step,
points: pre.doubles.points.map(endoMul)
}
};
}
return beta;
};
Point.prototype.toJSON = function toJSON() {
if (!this.precomputed) return [this.x, this.y];
return [
this.x,
this.y,
this.precomputed && {
doubles: this.precomputed.doubles && {
step: this.precomputed.doubles.step,
points: this.precomputed.doubles.points.slice(1)
},
naf: this.precomputed.naf && {
wnd: this.precomputed.naf.wnd,
points: this.precomputed.naf.points.slice(1)
}
}
];
};
Point.fromJSON = function fromJSON(curve, obj, red) {
if (typeof obj === "string") obj = JSON.parse(obj);
var res = curve.point(obj[0], obj[1], red);
if (!obj[2]) return res;
function obj2point(obj) {
return curve.point(obj[0], obj[1], red);
}
var pre = obj[2];
res.precomputed = {
beta: null,
doubles: pre.doubles && {
step: pre.doubles.step,
points: [res].concat(pre.doubles.points.map(obj2point))
},
naf: pre.naf && {
wnd: pre.naf.wnd,
points: [res].concat(pre.naf.points.map(obj2point))
}
};
return res;
};
Point.prototype.inspect = function 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.prototype.isInfinity = function isInfinity() {
return this.inf;
};
Point.prototype.add = function add(p) {
if (this.inf) return p;
if (p.inf) return this;
if (this.eq(p)) return this.dbl();
if (this.neg().eq(p)) return this.curve.point(null, null);
if (this.x.cmp(p.x) === 0) return this.curve.point(null, null);
var c = this.y.redSub(p.y);
if (c.cmpn(0) !== 0) c = c.redMul(this.x.redSub(p.x).redInvm());
var nx = c.redSqr().redISub(this.x).redISub(p.x);
var ny = c.redMul(this.x.redSub(nx)).redISub(this.y);
return this.curve.point(nx, ny);
};
Point.prototype.dbl = function dbl() {
if (this.inf) return this;
var ys1 = this.y.redAdd(this.y);
if (ys1.cmpn(0) === 0) return this.curve.point(null, null);
var a = this.curve.a;
var x2 = this.x.redSqr();
var dyinv = ys1.redInvm();
var c = x2.redAdd(x2).redIAdd(x2).redIAdd(a).redMul(dyinv);
var nx = c.redSqr().redISub(this.x.redAdd(this.x));
var ny = c.redMul(this.x.redSub(nx)).redISub(this.y);
return this.curve.point(nx, ny);
};
Point.prototype.getX = function getX() {
return this.x.fromRed();
};
Point.prototype.getY = function getY() {
return this.y.fromRed();
};
Point.prototype.mul = function mul(k) {
k = new BN(k, 16);
if (this.isInfinity()) return this;
else if (this._hasDoubles(k)) return this.curve._fixedNafMul(this, k);
else if (this.curve.endo) return this.curve._endoWnafMulAdd([this], [k]);
else return this.curve._wnafMul(this, k);
};
Point.prototype.mulAdd = function mulAdd(k1, p2, k2) {
var points = [this, p2];
var coeffs = [k1, k2];
if (this.curve.endo) return this.curve._endoWnafMulAdd(points, coeffs);
else return this.curve._wnafMulAdd(1, points, coeffs, 2);
};
Point.prototype.jmulAdd = function jmulAdd(k1, p2, k2) {
var points = [this, p2];
var coeffs = [k1, k2];
if (this.curve.endo) return this.curve._endoWnafMulAdd(points, coeffs, true);
else return this.curve._wnafMulAdd(1, points, coeffs, 2, true);
};
Point.prototype.eq = function eq(p) {
return this === p || this.inf === p.inf && (this.inf || this.x.cmp(p.x) === 0 && this.y.cmp(p.y) === 0);
};
Point.prototype.neg = function neg(_precompute) {
if (this.inf) return this;
var res = this.curve.point(this.x, this.y.redNeg());
if (_precompute && this.precomputed) {
var pre = this.precomputed;
var negate = function(p) {
return p.neg();
};
res.precomputed = {
naf: pre.naf && {
wnd: pre.naf.wnd,
points: pre.naf.points.map(negate)
},
doubles: pre.doubles && {
step: pre.doubles.step,
points: pre.doubles.points.map(negate)
}
};
}
return res;
};
Point.prototype.toJ = function toJ() {
if (this.inf) return this.curve.jpoint(null, null, null);
return this.curve.jpoint(this.x, this.y, this.curve.one);
};
function JPoint(curve, x, y, z) {
Base.BasePoint.call(this, curve, "jacobian");
if (x === null && y === null && z === null) {
this.x = this.curve.one;
this.y = this.curve.one;
this.z = new BN(0);
} else {
this.x = new BN(x, 16);
this.y = new BN(y, 16);
this.z = new BN(z, 16);
}
if (!this.x.red) this.x = this.x.toRed(this.curve.red);
if (!this.y.red) this.y = this.y.toRed(this.curve.red);
if (!this.z.red) this.z = this.z.toRed(this.curve.red);
this.zOne = this.z === this.curve.one;
}
inherits(JPoint, Base.BasePoint);
ShortCurve.prototype.jpoint = function jpoint(x, y, z) {
return new JPoint(this, x, y, z);
};
JPoint.prototype.toP = function toP() {
if (this.isInfinity()) return this.curve.point(null, null);
var zinv = this.z.redInvm();
var zinv2 = zinv.redSqr();
var ax = this.x.redMul(zinv2);
var ay = this.y.redMul(zinv2).redMul(zinv);
return this.curve.point(ax, ay);
};
JPoint.prototype.neg = function neg() {
return this.curve.jpoint(this.x, this.y.redNeg(), this.z);
};
JPoint.prototype.add = function add(p) {
if (this.isInfinity()) return p;
if (p.isInfinity()) return this;
var pz2 = p.z.redSqr();
var z2 = this.z.redSqr();
var u1 = this.x.redMul(pz2);
var u2 = p.x.redMul(z2);
var s1 = this.y.redMul(pz2.redMul(p.z));
var s2 = p.y.redMul(z2.redMul(this.z));
var h = u1.redSub(u2);
var r = s1.redSub(s2);
if (h.cmpn(0) === 0) if (r.cmpn(0) !== 0) return this.curve.jpoint(null, null, null);
else return this.dbl();
var h2 = h.redSqr();
var h3 = h2.redMul(h);
var v = u1.redMul(h2);
var nx = r.redSqr().redIAdd(h3).redISub(v).redISub(v);
var ny = r.redMul(v.redISub(nx)).redISub(s1.redMul(h3));
var nz = this.z.redMul(p.z).redMul(h);
return this.curve.jpoint(nx, ny, nz);
};
JPoint.prototype.mixedAdd = function mixedAdd(p) {
if (this.isInfinity()) return p.toJ();
if (p.isInfinity()) return this;
var z2 = this.z.redSqr();
var u1 = this.x;
var u2 = p.x.redMul(z2);
var s1 = this.y;
var s2 = p.y.redMul(z2).redMul(this.z);
var h = u1.redSub(u2);
var r = s1.redSub(s2);
if (h.cmpn(0) === 0) if (r.cmpn(0) !== 0) return this.curve.jpoint(null, null, null);
else return this.dbl();
var h2 = h.redSqr();
var h3 = h2.redMul(h);
var v = u1.redMul(h2);
var nx = r.redSqr().redIAdd(h3).redISub(v).redISub(v);
var ny = r.redMul(v.redISub(nx)).redISub(s1.redMul(h3));
var nz = this.z.redMul(h);
return this.curve.jpoint(nx, ny, nz);
};
JPoint.prototype.dblp = function dblp(pow) {
if (pow === 0) return this;
if (this.isInfinity()) return this;
if (!pow) return this.dbl();
var i;
if (this.curve.zeroA || this.curve.threeA) {
var r = this;
for (i = 0; i < pow; i++) r = r.dbl();
return r;
}
var a = this.curve.a;
var tinv = this.curve.tinv;
var jx = this.x;
var jy = this.y;
var jz = this.z;
var jz4 = jz.redSqr().redSqr();
var jyd = jy.redAdd(jy);
for (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 dbl() {
if (this.isInfinity()) return this;
if (this.curve.zeroA) return this._zeroDbl();
else if (this.curve.threeA) return this._threeDbl();
else return this._dbl();
};
JPoint.prototype._zeroDbl = function _zeroDbl() {
var nx;
var ny;
var nz;
if (this.zOne) {
var xx = this.x.redSqr();
var yy = this.y.redSqr();
var yyyy = yy.redSqr();
var s = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);
s = s.redIAdd(s);
var m = xx.redAdd(xx).redIAdd(xx);
var t = m.redSqr().redISub(s).redISub(s);
var yyyy8 = yyyy.redIAdd(yyyy);
yyyy8 = yyyy8.redIAdd(yyyy8);
yyyy8 = yyyy8.redIAdd(yyyy8);
nx = t;
ny = m.redMul(s.redISub(t)).redISub(yyyy8);
nz = this.y.redAdd(this.y);
} else {
var a = this.x.redSqr();
var b = this.y.redSqr();
var c = b.redSqr();
var d = this.x.redAdd(b).redSqr().redISub(a).redISub(c);
d = d.redIAdd(d);
var e = a.redAdd(a).redIAdd(a);
var f = e.redSqr();
var c8 = c.redIAdd(c);
c8 = c8.redIAdd(c8);
c8 = c8.redIAdd(c8);
nx = f.redISub(d).redISub(d);
ny = e.redMul(d.redISub(nx)).redISub(c8);
nz = this.y.redMul(this.z);
nz = nz.redIAdd(nz);
}
return this.curve.jpoint(nx, ny, nz);
};
JPoint.prototype._threeDbl = function _threeDbl() {
var nx;
var ny;
var nz;
if (this.zOne) {
var xx = this.x.redSqr();
var yy = this.y.redSqr();
var yyyy = yy.redSqr();
var s = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);
s = s.redIAdd(s);
var m = xx.redAdd(xx).redIAdd(xx).redIAdd(this.curve.a);
var t = m.redSqr().redISub(s).redISub(s);
nx = t;
var yyyy8 = yyyy.redIAdd(yyyy);
yyyy8 = yyyy8.redIAdd(yyyy8);
yyyy8 = yyyy8.redIAdd(yyyy8);
ny = m.redMul(s.redISub(t)).redISub(yyyy8);
nz = this.y.redAdd(this.y);
} else {
var delta = this.z.redSqr();
var gamma = this.y.redSqr();
var beta = this.x.redMul(gamma);
var alpha = this.x.redSub(delta).redMul(this.x.redAdd(delta));
alpha = alpha.redAdd(alpha).redIAdd(alpha);
var beta4 = beta.redIAdd(beta);
beta4 = beta4.redIAdd(beta4);
var beta8 = beta4.redAdd(beta4);
nx = alpha.redSqr().redISub(beta8);
nz = this.y.redAdd(this.z).redSqr().redISub(gamma).redISub(delta);
var ggamma8 = gamma.redSqr();
ggamma8 = ggamma8.redIAdd(ggamma8);
ggamma8 = ggamma8.redIAdd(ggamma8);
ggamma8 = ggamma8.redIAdd(ggamma8);
ny = alpha.redMul(beta4.redISub(nx)).redISub(ggamma8);
}
return this.curve.jpoint(nx, ny, nz);
};
JPoint.prototype._dbl = function _dbl() {
var a = this.curve.a;
var jx = this.x;
var jy = this.y;
var jz = this.z;
var jz4 = jz.redSqr().redSqr();
var jx2 = jx.redSqr();
var jy2 = jy.redSqr();
var c = jx2.redAdd(jx2).redIAdd(jx2).redIAdd(a.redMul(jz4));
var jxd4 = jx.redAdd(jx);
jxd4 = jxd4.redIAdd(jxd4);
var t1 = jxd4.redMul(jy2);
var nx = c.redSqr().redISub(t1.redAdd(t1));
var t2 = t1.redISub(nx);
var jyd8 = jy2.redSqr();
jyd8 = jyd8.redIAdd(jyd8);
jyd8 = jyd8.redIAdd(jyd8);
jyd8 = jyd8.redIAdd(jyd8);
var ny = c.redMul(t2).redISub(jyd8);
var nz = jy.redAdd(jy).redMul(jz);
return this.curve.jpoint(nx, ny, nz);
};
JPoint.prototype.trpl = function trpl() {
if (!this.curve.zeroA) return this.dbl().add(this);
var xx = this.x.redSqr();
var yy = this.y.redSqr();
var zz = this.z.redSqr();
var yyyy = yy.redSqr();
var m = xx.redAdd(xx).redIAdd(xx);
var mm = m.redSqr();
var e = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);
e = e.redIAdd(e);
e = e.redAdd(e).redIAdd(e);
e = e.redISub(mm);
var ee = e.redSqr();
var t = yyyy.redIAdd(yyyy);
t = t.redIAdd(t);
t = t.redIAdd(t);
t = t.redIAdd(t);
var u = m.redIAdd(e).redSqr().redISub(mm).redISub(ee).redISub(t);
var yyu4 = yy.redMul(u);
yyu4 = yyu4.redIAdd(yyu4);
yyu4 = yyu4.redIAdd(yyu4);
var nx = this.x.redMul(ee).redISub(yyu4);
nx = nx.redIAdd(nx);
nx = nx.redIAdd(nx);
var ny = this.y.redMul(u.redMul(t.redISub(u)).redISub(e.redMul(ee)));
ny = ny.redIAdd(ny);
ny = ny.redIAdd(ny);
ny = ny.redIAdd(ny);
var nz = this.z.redAdd(e).redSqr().redISub(zz).redISub(ee);
return this.curve.jpoint(nx, ny, nz);
};
JPoint.prototype.mul = function mul(k, kbase) {
k = new BN(k, kbase);
return this.curve._wnafMul(this, k);
};
JPoint.prototype.eq = function eq(p) {
if (p.type === "affine") return this.eq(p.toJ());
if (this === p) return true;
var z2 = this.z.redSqr();
var pz2 = p.z.redSqr();
if (this.x.redMul(pz2).redISub(p.x.redMul(z2)).cmpn(0) !== 0) return false;
var z3 = z2.redMul(this.z);
var pz3 = pz2.redMul(p.z);
return this.y.redMul(pz3).redISub(p.y.redMul(z3)).cmpn(0) === 0;
};
JPoint.prototype.eqXToP = function eqXToP(x) {
var zs = this.z.redSqr();
var rx = x.toRed(this.curve.red).redMul(zs);
if (this.x.cmp(rx) === 0) return true;
var xc = x.clone();
var t = this.curve.redN.redMul(zs);
for (;;) {
xc.iadd(this.curve.n);
if (xc.cmp(this.curve.p) >= 0) return false;
rx.redIAdd(t);
if (this.x.cmp(rx) === 0) return true;
}
};
JPoint.prototype.inspect = function inspect() {
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 isInfinity() {
return this.z.cmpn(0) === 0;
};
}));
//#endregion
//#region node_modules/elliptic/lib/elliptic/curve/mont.js
var require_mont = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var BN = require_bn$3();
var inherits = require_inherits_browser();
var Base = require_base$1();
var utils = require_utils$1();
function MontCurve(conf) {
Base.call(this, "mont", conf);
this.a = new BN(conf.a, 16).toRed(this.red);
this.b = new BN(conf.b, 16).toRed(this.red);
this.i4 = new BN(4).toRed(this.red).redInvm();
this.two = new BN(2).toRed(this.red);
this.a24 = this.i4.redMul(this.a.redAdd(this.two));
}
inherits(MontCurve, Base);
module.exports = MontCurve;
MontCurve.prototype.validate = function validate(point) {
var x = point.normalize().x;
var x2 = x.redSqr();
var rhs = x2.redMul(x).redAdd(x2.redMul(this.a)).redAdd(x);
return rhs.redSqrt().redSqr().cmp(rhs) === 0;
};
function Point(curve, x, z) {
Base.BasePoint.call(this, curve, "projective");
if (x === null && z === null) {
this.x = this.curve.one;
this.z = this.curve.zero;
} else {
this.x = new BN(x, 16);
this.z = new BN(z, 16);
if (!this.x.red) this.x = this.x.toRed(this.curve.red);
if (!this.z.red) this.z = this.z.toRed(this.curve.red);
}
}
inherits(Point, Base.BasePoint);
MontCurve.prototype.decodePoint = function decodePoint(bytes, enc) {
return this.point(utils.toArray(bytes, enc), 1);
};
MontCurve.prototype.point = function point(x, z) {
return new Point(this, x, z);
};
MontCurve.prototype.pointFromJSON = function pointFromJSON(obj) {
return Point.fromJSON(this, obj);
};
Point.prototype.precompute = function precompute() {};
Point.prototype._encode = function _encode() {
return this.getX().toArray("be", this.curve.p.byteLength());
};
Point.fromJSON = function fromJSON(curve, obj) {
return new Point(curve, obj[0], obj[1] || curve.one);
};
Point.prototype.inspect = function inspect() {
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.prototype.isInfinity = function isInfinity() {
return this.z.cmpn(0) === 0;
};
Point.prototype.dbl = function dbl() {
var aa = this.x.redAdd(this.z).redSqr();
var bb = this.x.redSub(this.z).redSqr();
var c = aa.redSub(bb);
var nx = aa.redMul(bb);
var nz = c.redMul(bb.redAdd(this.curve.a24.redMul(c)));
return this.curve.point(nx, nz);
};
Point.prototype.add = function add() {
throw new Error("Not supported on Montgomery curve");
};
Point.prototype.diffAdd = function diffAdd(p, diff) {
var a = this.x.redAdd(this.z);
var b = this.x.redSub(this.z);
var c = p.x.redAdd(p.z);
var da = p.x.redSub(p.z).redMul(a);
var cb = c.redMul(b);
var nx = diff.z.redMul(da.redAdd(cb).redSqr());
var nz = diff.x.redMul(da.redISub(cb).redSqr());
return this.curve.point(nx, nz);
};
Point.prototype.mul = function mul(k) {
var t = k.clone();
var a = this;
var b = this.curve.point(null, null);
var c = this;
for (var bits = []; t.cmpn(0) !== 0; t.iushrn(1)) bits.push(t.andln(1));
for (var 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.prototype.mulAdd = function mulAdd() {
throw new Error("Not supported on Montgomery curve");
};
Point.prototype.jumlAdd = function jumlAdd() {
throw new Error("Not supported on Montgomery curve");
};
Point.prototype.eq = function eq(other) {
return this.getX().cmp(other.getX()) === 0;
};
Point.prototype.normalize = function normalize() {
this.x = this.x.redMul(this.z.redInvm());
this.z = this.curve.one;
return this;
};
Point.prototype.getX = function getX() {
this.normalize();
return this.x.fromRed();
};
}));
//#endregion
//#region node_modules/elliptic/lib/elliptic/curve/edwards.js
var require_edwards = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var utils = require_utils$1();
var BN = require_bn$3();
var inherits = require_inherits_browser();
var Base = require_base$1();
var assert = utils.assert;
function EdwardsCurve(conf) {
this.twisted = (conf.a | 0) !== 1;
this.mOneA = this.twisted && (conf.a | 0) === -1;
this.extended = this.mOneA;
Base.call(this, "edwards", conf);
this.a = new BN(conf.a, 16).umod(this.red.m);
this.a = this.a.toRed(this.red);
this.c = new BN(conf.c, 16).toRed(this.red);
this.c2 = this.c.redSqr();
this.d = new BN(conf.d, 16).toRed(this.red);
this.dd = this.d.redAdd(this.d);
assert(!this.twisted || this.c.fromRed().cmpn(1) === 0);
this.oneC = (conf.c | 0) === 1;
}
inherits(EdwardsCurve, Base);
module.exports = EdwardsCurve;
EdwardsCurve.prototype._mulA = function _mulA(num) {
if (this.mOneA) return num.redNeg();
else return this.a.redMul(num);
};
EdwardsCurve.prototype._mulC = function _mulC(num) {
if (this.oneC) return num;
else return this.c.redMul(num);
};
EdwardsCurve.prototype.jpoint = function jpoint(x, y, z, t) {
return this.point(x, y, z, t);
};
EdwardsCurve.prototype.pointFromX = function pointFromX(x, odd) {
x = new BN(x, 16);
if (!x.red) x = x.toRed(this.red);
var x2 = x.redSqr();
var rhs = this.c2.redSub(this.a.redMul(x2));
var lhs = this.one.redSub(this.c2.redMul(this.d).redMul(x2));
var y2 = rhs.redMul(lhs.redInvm());
var y = y2.redSqrt();
if (y.redSqr().redSub(y2).cmp(this.zero) !== 0) throw new Error("invalid point");
var isOdd = y.fromRed().isOdd();
if (odd && !isOdd || !odd && isOdd) y = y.redNeg();
return this.point(x, y);
};
EdwardsCurve.prototype.pointFromY = function pointFromY(y, odd) {
y = new BN(y, 16);
if (!y.red) y = y.toRed(this.red);
var y2 = y.redSqr();
var lhs = y2.redSub(this.c2);
var rhs = y2.redMul(this.d).redMul(this.c2).redSub(this.a);
var x2 = lhs.redMul(rhs.redInvm());
if (x2.cmp(this.zero) === 0) if (odd) throw new Error("invalid point");
else return this.point(this.zero, y);
var x = x2.redSqrt();
if (x.redSqr().redSub(x2).cmp(this.zero) !== 0) throw new Error("invalid point");
if (x.fromRed().isOdd() !== odd) x = x.redNeg();
return this.point(x, y);
};
EdwardsCurve.prototype.validate = function validate(point) {
if (point.isInfinity()) return true;
point.normalize();
var x2 = point.x.redSqr();
var y2 = point.y.redSqr();
var lhs = x2.redMul(this.a).redAdd(y2);
var rhs = this.c2.redMul(this.one.redAdd(this.d.redMul(x2).redMul(y2)));
return lhs.cmp(rhs) === 0;
};
function Point(curve, x, y, z, t) {
Base.BasePoint.call(this, curve, "projective");
if (x === null && y === null && z === null) {
this.x = this.curve.zero;
this.y = this.curve.one;
this.z = this.curve.one;
this.t = this.curve.zero;
this.zOne = true;
} else {
this.x = new BN(x, 16);
this.y = new BN(y, 16);
this.z = z ? new BN(z, 16) : this.curve.one;
this.t = t && new BN(t, 16);
if (!this.x.red) this.x = this.x.toRed(this.curve.red);
if (!this.y.red) this.y = this.y.toRed(this.curve.red);
if (!this.z.red) this.z = this.z.toRed(this.curve.red);
if (this.t && !this.t.red) this.t = this.t.toRed(this.curve.red);
this.zOne = this.z === this.curve.one;
if (this.curve.extended && !this.t) {
this.t = this.x.redMul(this.y);
if (!this.zOne) this.t = this.t.redMul(this.z.redInvm());
}
}
}
inherits(Point, Base.BasePoint);
EdwardsCurve.prototype.pointFromJSON = function pointFromJSON(obj) {
return Point.fromJSON(this, obj);
};
EdwardsCurve.prototype.point = function point(x, y, z, t) {
return new Point(this, x, y, z, t);
};
Point.fromJSON = function fromJSON(curve, obj) {
return new Point(curve, obj[0], obj[1], obj[2]);
};
Point.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) + " z: " + this.z.fromRed().toString(16, 2) + ">";
};
Point.prototype.isInfinity = function isInfinity() {
return this.x.cmpn(0) === 0 && (this.y.cmp(this.z) === 0 || this.zOne && this.y.cmp(this.curve.c) === 0);
};
Point.prototype._extDbl = function _extDbl() {
var a = this.x.redSqr();
var b = this.y.redSqr();
var c = this.z.redSqr();
c = c.redIAdd(c);
var d = this.curve._mulA(a);
var e = this.x.redAdd(this.y).redSqr().redISub(a).redISub(b);
var g = d.redAdd(b);
var f = g.redSub(c);
var h = d.redSub(b);
var nx = e.redMul(f);
var ny = g.redMul(h);
var nt = e.redMul(h);
var nz = f.redMul(g);
return this.curve.point(nx, ny, nz, nt);
};
Point.prototype._projDbl = function _projDbl() {
var b = this.x.redAdd(this.y).redSqr();
var c = this.x.redSqr();
var d = this.y.redSqr();
var nx;
var ny;
var nz;
var e;
var h;
var j;
if (this.curve.twisted) {
e = this.curve._mulA(c);
var f = e.redAdd(d);
if (this.zOne) {
nx = b.redSub(c).redSub(d).redMul(f.redSub(this.curve.two));
ny = f.redMul(e.redSub(d));
nz = f.redSqr().redSub(f).redSub(f);
} else {
h = this.z.redSqr();
j = f.redSub(h).redISub(h);
nx = b.redSub(c).redISub(d).redMul(j);
ny = f.redMul(e.redSub(d));
nz = f.redMul(j);
}
} else {
e = c.redAdd(d);
h = this.curve._mulC(this.z).redSqr();
j = e.redSub(h).redSub(h);
nx = this.curve._mulC(b.redISub(e)).redMul(j);
ny = this.curve._mulC(e).redMul(c.redISub(d));
nz = e.redMul(j);
}
return this.curve.point(nx, ny, nz);
};
Point.prototype.dbl = function dbl() {
if (this.isInfinity()) return this;
if (this.curve.extended) return this._extDbl();
else return this._projDbl();
};
Point.prototype._extAdd = function _extAdd(p) {
var a = this.y.redSub(this.x).redMul(p.y.redSub(p.x));
var b = this.y.redAdd(this.x).redMul(p.y.redAdd(p.x));
var c = this.t.redMul(this.curve.dd).redMul(p.t);
var d = this.z.redMul(p.z.redAdd(p.z));
var e = b.redSub(a);
var f = d.redSub(c);
var g = d.redAdd(c);
var h = b.redAdd(a);
var nx = e.redMul(f);
var ny = g.redMul(h);
var nt = e.redMul(h);
var nz = f.redMul(g);
return this.curve.point(nx, ny, nz, nt);
};
Point.prototype._projAdd = function _projAdd(p) {
var a = this.z.redMul(p.z);
var b = a.redSqr();
var c = this.x.redMul(p.x);
var d = this.y.redMul(p.y);
var e = this.curve.d.redMul(c).redMul(d);
var f = b.redSub(e);
var g = b.redAdd(e);
var tmp = this.x.redAdd(this.y).redMul(p.x.redAdd(p.y)).redISub(c).redISub(d);
var nx = a.redMul(f).redMul(tmp);
var ny;
var nz;
if (this.curve.twisted) {
ny = a.redMul(g).redMul(d.redSub(this.curve._mulA(c)));
nz = f.redMul(g);
} else {
ny = a.redMul(g).redMul(d.redSub(c));
nz = this.curve._mulC(f).redMul(g);
}
return this.curve.point(nx, ny, nz);
};
Point.prototype.add = function add(p) {
if (this.isInfinity()) return p;
if (p.isInfinity()) return this;
if (this.curve.extended) return this._extAdd(p);
else return this._projAdd(p);
};
Point.prototype.mul = function mul(k) {
if (this._hasDoubles(k)) return this.curve._fixedNafMul(this, k);
else return this.curve._wnafMul(this, k);
};
Point.prototype.mulAdd = function mulAdd(k1, p, k2) {
return this.curve._wnafMulAdd(1, [this, p], [k1, k2], 2, false);
};
Point.prototype.jmulAdd = function jmulAdd(k1, p, k2) {
return this.curve._wnafMulAdd(1, [this, p], [k1, k2], 2, true);
};
Point.prototype.normalize = function normalize() {
if (this.zOne) return this;
var zi = this.z.redInvm();
this.x = this.x.redMul(zi);
this.y = this.y.redMul(zi);
if (this.t) this.t = this.t.redMul(zi);
this.z = this.curve.one;
this.zOne = true;
return this;
};
Point.prototype.neg = function neg() {
return this.curve.point(this.x.redNeg(), this.y, this.z, this.t && this.t.redNeg());
};
Point.prototype.getX = function getX() {
this.normalize();
return this.x.fromRed();
};
Point.prototype.getY = function getY() {
this.normalize();
return this.y.fromRed();
};
Point.prototype.eq = function eq(other) {
return this === other || this.getX().cmp(other.getX()) === 0 && this.getY().cmp(other.getY()) === 0;
};
Point.prototype.eqXToP = function eqXToP(x) {
var rx = x.toRed(this.curve.red).redMul(this.z);
if (this.x.cmp(rx) === 0) return true;
var xc = x.clone();
var t = this.curve.redN.redMul(this.z);
for (;;) {
xc.iadd(this.curve.n);
if (xc.cmp(this.curve.p) >= 0) return false;
rx.redIAdd(t);
if (this.x.cmp(rx) === 0) return true;
}
};
Point.prototype.toP = Point.prototype.normalize;
Point.prototype.mixedAdd = Point.prototype.add;
}));
//#endregion
//#region node_modules/elliptic/lib/elliptic/curve/index.js
var require_curve = /* @__PURE__ */ __commonJSMin(((exports) => {
var curve = exports;
curve.base = require_base$1();
curve.short = require_short();
curve.mont = require_mont();
curve.edwards = require_edwards();
}));
//#endregion
//#region node_modules/hash.js/lib/hash/utils.js
var require_utils = /* @__PURE__ */ __commonJSMin(((exports) => {
var assert = require_minimalistic_assert();
exports.inherits = require_inherits_browser();
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]+/gi, "");
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;
}
exports.toArray = toArray;
function toHex(msg) {
var res = "";
for (var i = 0; i < msg.length; i++) res += zero2(msg[i].toString(16));
return res;
}
exports.toHex = toHex;
function htonl(w) {
return (w >>> 24 | w >>> 8 & 65280 | w << 8 & 16711680 | (w & 255) << 24) >>> 0;
}
exports.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;
}
exports.toHex32 = toHex32;
function zero2(word) {
if (word.length === 1) return "0" + word;
else return word;
}
exports.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;
}
exports.zero8 = zero8;
function join32(msg, start, end, endian) {
var len = end - start;
assert(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;
}
exports.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;
}
exports.split32 = split32;
function rotr32(w, b) {
return w >>> b | w << 32 - b;
}
exports.rotr32 = rotr32;
function rotl32(w, b) {
return w << b | w >>> 32 - b;
}
exports.rotl32 = rotl32;
function sum32(a, b) {
return a + b >>> 0;
}
exports.sum32 = sum32;
function sum32_3(a, b, c) {
return a + b + c >>> 0;
}
exports.sum32_3 = sum32_3;
function sum32_4(a, b, c, d) {
return a + b + c + d >>> 0;
}
exports.sum32_4 = sum32_4;
function sum32_5(a, b, c, d, e) {
return a + b + c + d + e >>> 0;
}
exports.sum32_5 = sum32_5;
function sum64(buf, pos, ah, al) {
var bh = buf[pos];
var lo = al + buf[pos + 1] >>> 0;
buf[pos] = (lo < al ? 1 : 0) + ah + bh >>> 0;
buf[pos + 1] = lo;
}
exports.sum64 = sum64;
function sum64_hi(ah, al, bh, bl) {
return (al + bl >>> 0 < al ? 1 : 0) + ah + bh >>> 0;
}
exports.sum64_hi = sum64_hi;
function sum64_lo(ah, al, bh, bl) {
return al + bl >>> 0;
}
exports.sum64_lo = sum64_lo;
function sum64_4_hi(ah, al, bh, bl, ch, cl, dh, 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;
return ah + bh + ch + dh + carry >>> 0;
}
exports.sum64_4_hi = sum64_4_hi;
function sum64_4_lo(ah, al, bh, bl, ch, cl, dh, dl) {
return al + bl + cl + dl >>> 0;
}
exports.sum64_4_lo = sum64_4_lo;
function sum64_5_hi(ah, al, bh, bl, ch, cl, dh, 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;
return ah + bh + ch + dh + eh + carry >>> 0;
}
exports.sum64_5_hi = sum64_5_hi;
function sum64_5_lo(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {
return al + bl + cl + dl + el >>> 0;
}
exports.sum64_5_lo = sum64_5_lo;
function rotr64_hi(ah, al, num) {
return (al << 32 - num | ah >>> num) >>> 0;
}
exports.rotr64_hi = rotr64_hi;
function rotr64_lo(ah, al, num) {
return (ah << 32 - num | al >>> num) >>> 0;
}
exports.rotr64_lo = rotr64_lo;
function shr64_hi(ah, al, num) {
return ah >>> num;
}
exports.shr64_hi = shr64_hi;
function shr64_lo(ah, al, num) {
return (ah << 32 - num | al >>> num) >>> 0;
}
exports.shr64_lo = shr64_lo;
}));
//#endregion
//#region node_modules/hash.js/lib/hash/common.js
var require_common$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
var utils = require_utils();
var assert = require_minimalistic_assert();
function BlockHash() {
this.pending = null;
this.pendingTotal = 0;
this.blockSize = this.constructor.blockSize;
this.outSize = this.constructor.outSize;
this.hmacStrength = this.constructor.hmacStrength;
this.padLength = this.constructor.padLength / 8;
this.endian = "big";
this._delta8 = this.blockSize / 8;
this._delta32 = this.blockSize / 32;
}
exports.BlockHash = BlockHash;
BlockHash.prototype.update = function update(msg, enc) {
msg = utils.toArray(msg, enc);
if (!this.pending) this.pending = msg;
else this.pending = this.pending.concat(msg);
this.pendingTotal += msg.length;
if (this.pending.length >= this._delta8) {
msg = this.pending;
var r = msg.length % this._delta8;
this.pending = msg.slice(msg.length - r, msg.length);
if (this.pending.length === 0) this.pending = null;
msg = utils.join32(msg, 0, msg.length - r, this.endian);
for (var i = 0; i < msg.length; i += this._delta32) this._update(msg, i, i + this._delta32);
}
return this;
};
BlockHash.prototype.digest = function digest(enc) {
this.update(this._pad());
assert(this.pending === null);
return this._digest(enc);
};
BlockHash.prototype._pad = function pad() {
var 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;
};
}));
//#endregion
//#region node_modules/hash.js/lib/hash/sha/common.js
var require_common = /* @__PURE__ */ __commonJSMin(((exports) => {
var rotr32 = require_utils().rotr32;
function ft_1(s, x, y, z) {
if (s === 0) return ch32(x, y, z);
if (s === 1 || s === 3) return p32(x, y, z);
if (s === 2) return maj32(x, y, z);
}
exports.ft_1 = ft_1;
function ch32(x, y, z) {
return x & y ^ ~x & z;
}
exports.ch32 = ch32;
function maj32(x, y, z) {
return x & y ^ x & z ^ y & z;
}
exports.maj32 = maj32;
function p32(x, y, z) {
return x ^ y ^ z;
}
exports.p32 = p32;
function s0_256(x) {
return rotr32(x, 2) ^ rotr32(x, 13) ^ rotr32(x, 22);
}
exports.s0_256 = s0_256;
function s1_256(x) {
return rotr32(x, 6) ^ rotr32(x, 11) ^ rotr32(x, 25);
}
exports.s1_256 = s1_256;
function g0_256(x) {
return rotr32(x, 7) ^ rotr32(x, 18) ^ x >>> 3;
}
exports.g0_256 = g0_256;
function g1_256(x) {
return rotr32(x, 17) ^ rotr32(x, 19) ^ x >>> 10;
}
exports.g1_256 = g1_256;
}));
//#endregion
//#region node_modules/hash.js/lib/hash/sha/1.js
var require__1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var utils = require_utils();
var common = require_common$1();
var shaCommon = require_common();
var rotl32 = utils.rotl32;
var sum32 = utils.sum32;
var sum32_5 = utils.sum32_5;
var ft_1 = shaCommon.ft_1;
var BlockHash = common.BlockHash;
var sha1_K = [
1518500249,
1859775393,
2400959708,
3395469782
];
function SHA1() {
if (!(this instanceof SHA1)) return new SHA1();
BlockHash.call(this);
this.h = [
1732584193,
4023233417,
2562383102,
271733878,
3285377520
];
this.W = new Array(80);
}
utils.inherits(SHA1, BlockHash);
module.exports = SHA1;
SHA1.blockSize = 512;
SHA1.outSize = 160;
SHA1.hmacStrength = 80;
SHA1.padLength = 64;
SHA1.prototype._update = function _update(msg, start) {
var W = this.W;
for (var i = 0; i < 16; i++) W[i] = msg[start + i];
for (; i < W.length; i++) W[i] = rotl32(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[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 < W.length; i++) {
var s = ~~(i / 20);
var t = sum32_5(rotl32(a, 5), ft_1(s, b, c, d), e, W[i], sha1_K[s]);
e = d;
d = c;
c = rotl32(b, 30);
b = a;
a = t;
}
this.h[0] = sum32(this.h[0], a);
this.h[1] = sum32(this.h[1], b);
this.h[2] = sum32(this.h[2], c);
this.h[3] = sum32(this.h[3], d);
this.h[4] = sum32(this.h[4], e);
};
SHA1.prototype._digest = function digest(enc) {
if (enc === "hex") return utils.toHex32(this.h, "big");
else return utils.split32(this.h, "big");
};
}));
//#endregion
//#region node_modules/hash.js/lib/hash/sha/256.js
var require__256 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var utils = require_utils();
var common = require_common$1();
var shaCommon = require_common();
var assert = require_minimalistic_assert();
var sum32 = utils.sum32;
var sum32_4 = utils.sum32_4;
var sum32_5 = utils.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 = common.BlockHash;
var sha256_K = [
1116352408,
1899447441,
3049323471,
3921009573,
961987163,
1508970993,
2453635748,
2870763221,
3624381080,
310598401,
607225278,
1426881987,
1925078388,
2162078206,
2614888103,
3248222580,
3835390401,
4022224774,
264347078,
604807628,
770255983,
1249150122,
1555081692,
1996064986,
2554220882,
2821834349,
2952996808,
3210313671,
3336571891,
3584528711,
113926993,
338241895,
666307205,
773529912,
1294757372,
1396182291,
1695183700,
1986661051,
2177026350,
2456956037,
2730485921,
2820302411,
3259730800,
3345764771,
3516065817,
3600352804,
4094571909,
275423344,
430227734,
506948616,
659060556,
883997877,
958139571,
1322822218,
1537002063,
1747873779,
1955562222,
2024104815,
2227730452,
2361852424,
2428436474,
2756734187,
3204031479,
3329325298
];
function SHA256() {
if (!(this instanceof SHA256)) return new SHA256();
BlockHash.call(this);
this.h = [
1779033703,
3144134277,
1013904242,
2773480762,
1359893119,
2600822924,
528734635,
1541459225
];
this.k = sha256_K;
this.W = new Array(64);
}
utils.inherits(SHA256, BlockHash);
module.exports = SHA256;
SHA256.blockSize = 512;
SHA256.outSize = 256;
SHA256.hmacStrength = 192;
SHA256.padLength = 64;
SHA256.prototype._update = function _update(msg, start) {
var W = this.W;
for (var i = 0; i < 16; i++) W[i] = msg[start + i];
for (; i < W.length; i++) W[i] = sum32_4(g1_256(W[i - 2]), W[i - 7], g0_256(W[i - 15]), W[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 f = this.h[5];
var g = this.h[6];
var h = this.h[7];
assert(this.k.length === W.length);
for (i = 0; i < W.length; i++) {
var T1 = sum32_5(h, s1_256(e), ch32(e, f, g), this.k[i], W[i]);
var T2 = sum32(s0_256(a), maj32(a, b, c));
h = g;
g = f;
f = e;
e = sum32(d, T1);
d = c;
c = b;
b = a;
a = sum32(T1, T2);
}
this.h[0] = sum32(this.h[0], a);
this.h[1] = sum32(this.h[1], b);
this.h[2] = sum32(this.h[2], c);
this.h[3] = sum32(this.h[3], d);
this.h[4] = sum32(this.h[4], e);
this.h[5] = sum32(this.h[5], f);
this.h[6] = sum32(this.h[6], g);
this.h[7] = sum32(this.h[7], h);
};
SHA256.prototype._digest = function digest(enc) {
if (enc === "hex") return utils.toHex32(this.h, "big");
else return utils.split32(this.h, "big");
};
}));
//#endregion
//#region node_modules/hash.js/lib/hash/sha/224.js
var require__224 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var utils = require_utils();
var SHA256 = require__256();
function SHA224() {
if (!(this instanceof SHA224)) return new SHA224();
SHA256.call(this);
this.h = [
3238371032,
914150663,
812702999,
4144912697,
4290775857,
1750603025,
1694076839,
3204075428
];
}
utils.inherits(SHA224, SHA256);
module.exports = SHA224;
SHA224.blockSize = 512;
SHA224.outSize = 224;
SHA224.hmacStrength = 192;
SHA224.padLength = 64;
SHA224.prototype._digest = function digest(enc) {
if (enc === "hex") return utils.toHex32(this.h.slice(0, 7), "big");
else return utils.split32(this.h.slice(0, 7), "big");
};
}));
//#endregion
//#region node_modules/hash.js/lib/hash/sha/512.js
var require__512 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var utils = require_utils();
var common = require_common$1();
var assert = require_minimalistic_assert();
var rotr64_hi = utils.rotr64_hi;
var rotr64_lo = utils.rotr64_lo;
var shr64_hi = utils.shr64_hi;
var shr64_lo = utils.shr64_lo;
var sum64 = utils.sum64;
var sum64_hi = utils.sum64_hi;
var sum64_lo = utils.sum64_lo;
var sum64_4_hi = utils.sum64_4_hi;
var sum64_4_lo = utils.sum64_4_lo;
var sum64_5_hi = utils.sum64_5_hi;
var sum64_5_lo = utils.sum64_5_lo;
var BlockHash = common.BlockHash;
var sha512_K = [
1116352408,
3609767458,
1899447441,
602891725,
3049323471,
3964484399,
3921009573,
2173295548,
961987163,
4081628472,
1508970993,
3053834265,
2453635748,
2937671579,
2870763221,
3664609560,
3624381080,
2734883394,
310598401,
1164996542,
607225278,
1323610764,
1426881987,
3590304994,
1925078388,
4068182383,
2162078206,
991336113,
2614888103,
633803317,
3248222580,
3479774868,
3835390401,
2666613458,
4022224774,
944711139,
264347078,
2341262773,
604807628,
2007800933,
770255983,
1495990901,
1249150122,
1856431235,
1555081692,
3175218132,
1996064986,
2198950837,
2554220882,
3999719339,
2821834349,
766784016,
2952996808,
2566594879,
3210313671,
3203337956,
3336571891,
1034457026,
3584528711,
2466948901,
113926993,
3758326383,
338241895,
168717936,
666307205,
1188179964,
773529912,
1546045734,
1294757372,
1522805485,
1396182291,
2643833823,
1695183700,
2343527390,
1986661051,
1014477480,
2177026350,
1206759142,
2456956037,
344077627,
2730485921,
1290863460,
2820302411,
3158454273,
3259730800,
3505952657,
3345764771,
106217008,
3516065817,
3606008344,
3600352804,
1432725776,
4094571909,
1467031594,
275423344,
851169720,
430227734,
3100823752,
506948616,
1363258195,
659060556,
3750685593,
883997877,
3785050280,
958139571,
3318307427,
1322822218,
3812723403,
1537002063,
2003034995,
1747873779,
3602036899,
1955562222,
1575990012,
2024104815,
1125592928,
2227730452,
2716904306,
2361852424,
442776044,
2428436474,
593698344,
2756734187,
3733110249,
3204031479,
2999351573,
3329325298,
3815920427,
3391569614,
3928383900,
3515267271,
566280711,
3940187606,
3454069534,
4118630271,
4000239992,
116418474,
1914138554,
174292421,
2731055270,
289380356,
3203993006,
460393269,
320620315,
685471733,
587496836,
852142971,
1086792851,
1017036298,
365543100,
1126000580,
2618297676,
1288033470,
3409855158,
1501505948,
4234509866,
1607167915,
987167468,
1816402316,
1246189591
];
function SHA512() {
if (!(this instanceof SHA512)) return new SHA512();
BlockHash.call(this);
this.h = [
1779033703,
4089235720,
3144134277,
2227873595,
1013904242,
4271175723,
2773480762,
1595750129,
1359893119,
2917565137,
2600822924,
725511199,
528734635,
4215389547,
1541459225,
327033209
];
this.k = sha512_K;
this.W = new Array(160);
}
utils.inherits(SHA512, BlockHash);
module.exports = SHA512;
SHA512.blockSize = 1024;
SHA512.outSize = 512;
SHA512.hmacStrength = 192;
SHA512.padLength = 128;
SHA512.prototype._prepareBlock = function _prepareBlock(msg, start) {
var W = this.W;
for (var i = 0; i < 32; i++) W[i] = msg[start + i];
for (; i < W.length; i += 2) {
var c0_hi = g1_512_hi(W[i - 4], W[i - 3]);
var c0_lo = g1_512_lo(W[i - 4], W[i - 3]);
var c1_hi = W[i - 14];
var c1_lo = W[i - 13];
var c2_hi = g0_512_hi(W[i - 30], W[i - 29]);
var c2_lo = g0_512_lo(W[i - 30], W[i - 29]);
var c3_hi = W[i - 32];
var c3_lo = W[i - 31];
W[i] = sum64_4_hi(c0_hi, c0_lo, c1_hi, c1_lo, c2_hi, c2_lo, c3_hi, c3_lo);
W[i + 1] = sum64_4_lo(c0_hi, c0_lo, c1_hi, c1_lo, c2_hi, c2_lo, c3_hi, c3_lo);
}
};
SHA512.prototype._update = function _update(msg, start) {
this._prepareBlock(msg, start);
var W = this.W;
var ah = this.h[0];
var al = this.h[1];
var bh = this.h[2];
var bl = this.h[3];
var ch = this.h[4];
var cl = this.h[5];
var dh = this.h[6];
var dl = this.h[7];
var eh = this.h[8];
var el = this.h[9];
var fh = this.h[10];
var fl = this.h[11];
var gh = this.h[12];
var gl = this.h[13];
var hh = this.h[14];
var hl = this.h[15];
assert(this.k.length === W.length);
for (var i = 0; i < W.length; i += 2) {
var c0_hi = hh;
var c0_lo = hl;
var c1_hi = s1_512_hi(eh, el);
var c1_lo = s1_512_lo(eh, el);
var c2_hi = ch64_hi(eh, el, fh, fl, gh, gl);
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 = W[i];
var c4_lo = W[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, ch, cl);
c1_lo = maj64_lo(ah, al, bh, bl, ch, cl);
var T2_hi = sum64_hi(c0_hi, c0_lo, c1_hi, c1_lo);
var T2_lo = sum64_lo(c0_hi, c0_lo, c1_hi, c1_lo);
hh = gh;
hl = gl;
gh = fh;
gl = fl;
fh = eh;
fl = el;
eh = sum64_hi(dh, dl, T1_hi, T1_lo);
el = sum64_lo(dl, dl, T1_hi, T1_lo);
dh = ch;
dl = cl;
ch = bh;
cl = bl;
bh = ah;
bl = al;
ah = sum64_hi(T1_hi, T1_lo, T2_hi, T2_lo);
al = sum64_lo(T1_hi, T1_lo, T2_hi, T2_lo);
}
sum64(this.h, 0, ah, al);
sum64(this.h, 2, bh, bl);
sum64(this.h, 4, ch, cl);
sum64(this.h, 6, dh, dl);
sum64(this.h, 8, eh, el);
sum64(this.h, 10, fh, fl);
sum64(this.h, 12, gh, gl);
sum64(this.h, 14, hh, hl);
};
SHA512.prototype._digest = function digest(enc) {
if (enc === "hex") return utils.toHex32(this.h, "big");
else return utils.split32(this.h, "big");
};
function ch64_hi(xh, xl, yh, yl, zh) {
var r = xh & yh ^ ~xh & zh;
if (r < 0) r += 4294967296;
return r;
}
function ch64_lo(xh, xl, yh, yl, zh, zl) {
var r = xl & yl ^ ~xl & zl;
if (r < 0) r += 4294967296;
return r;
}
function maj64_hi(xh, xl, yh, yl, zh) {
var r = xh & yh ^ xh & zh ^ yh & zh;
if (r < 0) r += 4294967296;
return r;
}
function maj64_lo(xh, xl, yh, yl, zh, zl) {
var r = xl & yl ^ xl & zl ^ yl & zl;
if (r < 0) r += 4294967296;
return r;
}
function s0_512_hi(xh, xl) {
var c0_hi = rotr64_hi(xh, xl, 28);
var c1_hi = rotr64_hi(xl, xh, 2);
var c2_hi = rotr64_hi(xl, xh, 7);
var r = c0_hi ^ c1_hi ^ c2_hi;
if (r < 0) r += 4294967296;
return r;
}
function s0_512_lo(xh, xl) {
var c0_lo = rotr64_lo(xh, xl, 28);
var c1_lo = rotr64_lo(xl, xh, 2);
var c2_lo = rotr64_lo(xl, xh, 7);
var r = c0_lo ^ c1_lo ^ c2_lo;
if (r < 0) r += 4294967296;
return r;
}
function s1_512_hi(xh, xl) {
var c0_hi = rotr64_hi(xh, xl, 14);
var c1_hi = rotr64_hi(xh, xl, 18);
var c2_hi = rotr64_hi(xl, xh, 9);
var r = c0_hi ^ c1_hi ^ c2_hi;
if (r < 0) r += 4294967296;
return r;
}
function s1_512_lo(xh, xl) {
var c0_lo = rotr64_lo(xh, xl, 14);
var c1_lo = rotr64_lo(xh, xl, 18);
var c2_lo = rotr64_lo(xl, xh, 9);
var r = c0_lo ^ c1_lo ^ c2_lo;
if (r < 0) r += 4294967296;
return r;
}
function g0_512_hi(xh, xl) {
var c0_hi = rotr64_hi(xh, xl, 1);
var c1_hi = rotr64_hi(xh, xl, 8);
var c2_hi = shr64_hi(xh, xl, 7);
var r = c0_hi ^ c1_hi ^ c2_hi;
if (r < 0) r += 4294967296;
return r;
}
function g0_512_lo(xh, xl) {
var c0_lo = rotr64_lo(xh, xl, 1);
var c1_lo = rotr64_lo(xh, xl, 8);
var c2_lo = shr64_lo(xh, xl, 7);
var r = c0_lo ^ c1_lo ^ c2_lo;
if (r < 0) r += 4294967296;
return r;
}
function g1_512_hi(xh, xl) {
var c0_hi = rotr64_hi(xh, xl, 19);
var c1_hi = rotr64_hi(xl, xh, 29);
var c2_hi = shr64_hi(xh, xl, 6);
var r = c0_hi ^ c1_hi ^ c2_hi;
if (r < 0) r += 4294967296;
return r;
}
function g1_512_lo(xh, xl) {
var c0_lo = rotr64_lo(xh, xl, 19);
var c1_lo = rotr64_lo(xl, xh, 29);
var c2_lo = shr64_lo(xh, xl, 6);
var r = c0_lo ^ c1_lo ^ c2_lo;
if (r < 0) r += 4294967296;
return r;
}
}));
//#endregion
//#region node_modules/hash.js/lib/hash/sha/384.js
var require__384 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var utils = require_utils();
var SHA512 = require__512();
function SHA384() {
if (!(this instanceof SHA384)) return new SHA384();
SHA512.call(this);
this.h = [
3418070365,
3238371032,
1654270250,
914150663,
2438529370,
812702999,
355462360,
4144912697,
1731405415,
4290775857,
2394180231,
1750603025,
3675008525,
1694076839,
1203062813,
3204075428
];
}
utils.inherits(SHA384, SHA512);
module.exports = SHA384;
SHA384.blockSize = 1024;
SHA384.outSize = 384;
SHA384.hmacStrength = 192;
SHA384.padLength = 128;
SHA384.prototype._digest = function digest(enc) {
if (enc === "hex") return utils.toHex32(this.h.slice(0, 12), "big");
else return utils.split32(this.h.slice(0, 12), "big");
};
}));
//#endregion
//#region node_modules/hash.js/lib/hash/sha.js
var require_sha = /* @__PURE__ */ __commonJSMin(((exports) => {
exports.sha1 = require__1();
exports.sha224 = require__224();
exports.sha256 = require__256();
exports.sha384 = require__384();
exports.sha512 = require__512();
}));
//#endregion
//#region node_modules/hash.js/lib/hash/ripemd.js
var require_ripemd = /* @__PURE__ */ __commonJSMin(((exports) => {
var utils = require_utils();
var common = require_common$1();
var rotl32 = utils.rotl32;
var sum32 = utils.sum32;
var sum32_3 = utils.sum32_3;
var sum32_4 = utils.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.inherits(RIPEMD160, BlockHash);
exports.ripemd160 = RIPEMD160;
RIPEMD160.blockSize = 512;
RIPEMD160.outSize = 160;
RIPEMD160.hmacStrength = 192;
RIPEMD160.padLength = 64;
RIPEMD160.prototype._update = function update(msg, start) {
var A = this.h[0];
var B = this.h[1];
var C = this.h[2];
var D = this.h[3];
var E = this.h[4];
var Ah = A;
var Bh = B;
var Ch = C;
var Dh = D;
var Eh = E;
for (var j = 0; j < 80; j++) {
var T = sum32(rotl32(sum32_4(A, f(j, B, C, D), msg[r[j] + start], K(j)), s[j]), E);
A = E;
E = D;
D = rotl32(C, 10);
C = B;
B = T;
T = sum32(rotl32(sum32_4(Ah, f(79 - j, Bh, Ch, Dh), msg[rh[j] + start], Kh(j)), sh[j]), Eh);
Ah = Eh;
Eh = Dh;
Dh = rotl32(Ch, 10);
Ch = Bh;
Bh = T;
}
T = sum32_3(this.h[1], C, Dh);
this.h[1] = sum32_3(this.h[2], D, Eh);
this.h[2] = sum32_3(this.h[3], E, Ah);
this.h[3] = sum32_3(this.h[4], A, Bh);
this.h[4] = sum32_3(this.h[0], B, Ch);
this.h[0] = T;
};
RIPEMD160.prototype._digest = function digest(enc) {
if (enc === "hex") return utils.toHex32(this.h, "little");
else return utils.split32(this.h, "little");
};
function f(j, x, y, z) {
if (j <= 15) return x ^ y ^ z;
else if (j <= 31) return x & y | ~x & z;
else if (j <= 47) return (x | ~y) ^ z;
else if (j <= 63) return x & z | y & ~z;
else return x ^ (y | ~z);
}
function K(j) {
if (j <= 15) return 0;
else if (j <= 31) return 1518500249;
else if (j <= 47) return 1859775393;
else if (j <= 63) return 2400959708;
else return 2840853838;
}
function Kh(j) {
if (j <= 15) return 1352829926;
else if (j <= 31) return 1548603684;
else if (j <= 47) return 1836072691;
else if (j <= 63) return 2053994217;
else return 0;
}
var r = [
0,
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
7,
4,
13,
1,
10,
6,
15,
3,
12,
0,
9,
5,
2,
14,
11,
8,
3,
10,
14,
4,
9,
15,
8,
1,
2,
7,
0,
6,
13,
11,
5,
12,
1,
9,
11,
10,
0,
8,
12,
4,
13,
3,
7,
15,
14,
5,
6,
2,
4,
0,
5,
9,
7,
12,
2,
10,
14,
1,
3,
8,
11,
6,
15,
13
];
var rh = [
5,
14,
7,
0,
9,
2,
11,
4,
13,
6,
15,
8,
1,
10,
3,
12,
6,
11,
3,
7,
0,
13,
5,
10,
14,
15,
8,
12,
4,
9,
1,
2,
15,
5,
1,
3,
7,
14,
6,
9,
11,
8,
12,
2,
10,
0,
4,
13,
8,
6,
4,
1,
3,
11,
15,
0,
5,
12,
2,
13,
9,
7,
10,
14,
12,
15,
10,
4,
1,
5,
8,
7,
6,
2,
13,
14,
0,
3,
9,
11
];
var s = [
11,
14,
15,
12,
5,
8,
7,
9,
11,
13,
14,
15,
6,
7,
9,
8,
7,
6,
8,
13,
11,
9,
7,
15,
7,
12,
15,
9,
11,
7,
13,
12,
11,
13,
6,
7,
14,
9,
13,
15,
14,
8,
13,
6,
5,
12,
7,
5,
11,
12,
14,
15,
14,
15,
9,
8,
9,
14,
5,
6,
8,
6,
5,
12,
9,
15,
5,
11,
6,
8,
13,
12,
5,
12,
13,
14,
11,
8,
5,
6
];
var sh = [
8,
9,
9,
11,
13,
15,
15,
5,
7,
7,
8,
11,
14,
14,
12,
6,
9,
13,
15,
7,
12,
8,
9,
11,
7,
7,
12,
7,
6,
15,
13,
11,
9,
7,
15,
11,
8,
6,
6,
14,
12,
13,
5,
14,
13,
13,
7,
5,
15,
5,
8,
11,
14,
14,
6,
14,
6,
9,
12,
9,
12,
5,
15,
8,
8,
5,
12,
9,
12,
5,
14,
6,
8,
13,
6,
5,
15,
13,
11,
11
];
}));
//#endregion
//#region node_modules/hash.js/lib/hash/hmac.js
var require_hmac$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var utils = require_utils();
var assert = require_minimalistic_assert();
function Hmac(hash, key, enc) {
if (!(this instanceof Hmac)) return new Hmac(hash, key, enc);
this.Hash = hash;
this.blockSize = hash.blockSize / 8;
this.outSize = hash.outSize / 8;
this.inner = null;
this.outer = null;
this._init(utils.toArray(key, enc));
}
module.exports = Hmac;
Hmac.prototype._init = function init(key) {
if (key.length > this.blockSize) key = new this.Hash().update(key).digest();
assert(key.length <= this.blockSize);
for (var i = key.length; i < this.blockSize; i++) key.push(0);
for (i = 0; i < key.length; i++) key[i] ^= 54;
this.inner = new this.Hash().update(key);
for (i = 0; i < key.length; i++) key[i] ^= 106;
this.outer = new this.Hash().update(key);
};
Hmac.prototype.update = function update(msg, enc) {
this.inner.update(msg, enc);
return this;
};
Hmac.prototype.digest = function digest(enc) {
this.outer.update(this.inner.digest());
return this.outer.digest(enc);
};
}));
//#endregion
//#region node_modules/hash.js/lib/hash.js
var require_hash = /* @__PURE__ */ __commonJSMin(((exports) => {
var hash = exports;
hash.utils = require_utils();
hash.common = require_common$1();
hash.sha = require_sha();
hash.ripemd = require_ripemd();
hash.hmac = require_hmac$1();
hash.sha1 = hash.sha.sha1;
hash.sha256 = hash.sha.sha256;
hash.sha224 = hash.sha.sha224;
hash.sha384 = hash.sha.sha384;
hash.sha512 = hash.sha.sha512;
hash.ripemd160 = hash.ripemd.ripemd160;
}));
//#endregion
//#region node_modules/elliptic/lib/elliptic/precomputed/secp256k1.js
var require_secp256k1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = {
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"]
]
}
};
}));
//#endregion
//#region node_modules/elliptic/lib/elliptic/curves.js
var require_curves = /* @__PURE__ */ __commonJSMin(((exports) => {
var curves = exports;
var hash = require_hash();
var curve = require_curve();
var assert = require_utils$1().assert;
function PresetCurve(options) {
if (options.type === "short") this.curve = new curve.short(options);
else if (options.type === "edwards") this.curve = new curve.edwards(options);
else this.curve = new curve.mont(options);
this.g = this.curve.g;
this.n = this.curve.n;
this.hash = options.hash;
assert(this.g.validate(), "Invalid curve");
assert(this.g.mul(this.n).isInfinity(), "Invalid curve, G*N != O");
}
curves.PresetCurve = PresetCurve;
function defineCurve(name, options) {
Object.defineProperty(curves, name, {
configurable: true,
enumerable: true,
get: function() {
var curve = new PresetCurve(options);
Object.defineProperty(curves, name, {
configurable: true,
enumerable: true,
value: curve
});
return curve;
}
});
}
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: hash.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: hash.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: hash.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: hash.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: hash.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: hash.sha256,
gRed: false,
g: ["9"]
});
defineCurve("ed25519", {
type: "edwards",
prime: "p25519",
p: "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed",
a: "-1",
c: "1",
d: "52036cee2b6ffe73 8cc740797779e898 00700a4d4141d8ab 75eb4dca135978a3",
n: "1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed",
hash: hash.sha256,
gRed: false,
g: ["216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51a", "6666666666666666666666666666666666666666666666666666666666666658"]
});
var pre;
try {
pre = require_secp256k1();
} 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: hash.sha256,
beta: "7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee",
lambda: "5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72",
basis: [{
a: "3086d221a7d46bcde86c90e49284eb15",
b: "-e4437ed6010e88286f547fa90abfe4c3"
}, {
a: "114ca50f7a8e2f3f657c1108d9d44cfd8",
b: "3086d221a7d46bcde86c90e49284eb15"
}],
gRed: false,
g: [
"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
"483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8",
pre
]
});
}));
//#endregion
//#region node_modules/hmac-drbg/lib/hmac-drbg.js
var require_hmac_drbg = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var hash = require_hash();
var utils = require_utils$2();
var assert = require_minimalistic_assert();
function HmacDRBG(options) {
if (!(this instanceof HmacDRBG)) return new HmacDRBG(options);
this.hash = options.hash;
this.predResist = !!options.predResist;
this.outLen = this.hash.outSize;
this.minEntropy = options.minEntropy || this.hash.hmacStrength;
this._reseed = null;
this.reseedInterval = null;
this.K = null;
this.V = null;
var entropy = utils.toArray(options.entropy, options.entropyEnc || "hex");
var nonce = utils.toArray(options.nonce, options.nonceEnc || "hex");
var pers = utils.toArray(options.pers, options.persEnc || "hex");
assert(entropy.length >= this.minEntropy / 8, "Not enough entropy. Minimum is: " + this.minEntropy + " bits");
this._init(entropy, nonce, pers);
}
module.exports = HmacDRBG;
HmacDRBG.prototype._init = function init(entropy, nonce, pers) {
var seed = entropy.concat(nonce).concat(pers);
this.K = new Array(this.outLen / 8);
this.V = new Array(this.outLen / 8);
for (var 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 hmac() {
return new hash.hmac(this.hash, this.K);
};
HmacDRBG.prototype._update = function update(seed) {
var kmac = this._hmac().update(this.V).update([0]);
if (seed) kmac = kmac.update(seed);
this.K = kmac.digest();
this.V = this._hmac().update(this.V).digest();
if (!seed) return;
this.K = this._hmac().update(this.V).update([1]).update(seed).digest();
this.V = this._hmac().update(this.V).digest();
};
HmacDRBG.prototype.reseed = function reseed(entropy, entropyEnc, add, addEnc) {
if (typeof entropyEnc !== "string") {
addEnc = add;
add = entropyEnc;
entropyEnc = null;
}
entropy = utils.toArray(entropy, entropyEnc);
add = utils.toArray(add, addEnc);
assert(entropy.length >= this.minEntropy / 8, "Not enough entropy. Minimum is: " + this.minEntropy + " bits");
this._update(entropy.concat(add || []));
this._reseed = 1;
};
HmacDRBG.prototype.generate = function generate(len, enc, add, addEnc) {
if (this._reseed > this.reseedInterval) throw new Error("Reseed is required");
if (typeof enc !== "string") {
addEnc = add;
add = enc;
enc = null;
}
if (add) {
add = utils.toArray(add, addEnc || "hex");
this._update(add);
}
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(add);
this._reseed++;
return utils.encode(res, enc);
};
}));
//#endregion
//#region node_modules/elliptic/lib/elliptic/ec/key.js
var require_key$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var BN = require_bn$3();
var assert = require_utils$1().assert;
function KeyPair(ec, options) {
this.ec = ec;
this.priv = null;
this.pub = null;
if (options.priv) this._importPrivate(options.priv, options.privEnc);
if (options.pub) this._importPublic(options.pub, options.pubEnc);
}
module.exports = KeyPair;
KeyPair.fromPublic = function fromPublic(ec, pub, enc) {
if (pub instanceof KeyPair) return pub;
return new KeyPair(ec, {
pub,
pubEnc: enc
});
};
KeyPair.fromPrivate = function fromPrivate(ec, priv, enc) {
if (priv instanceof KeyPair) return priv;
return new KeyPair(ec, {
priv,
privEnc: enc
});
};
KeyPair.prototype.validate = function validate() {
var pub = this.getPublic();
if (pub.isInfinity()) return {
result: false,
reason: "Invalid public key"
};
if (!pub.validate()) return {
result: false,
reason: "Public key is not a point"
};
if (!pub.mul(this.ec.curve.n).isInfinity()) return {
result: false,
reason: "Public key * N != O"
};
return {
result: true,
reason: null
};
};
KeyPair.prototype.getPublic = function getPublic(compact, enc) {
if (typeof compact === "string") {
enc = compact;
compact = null;
}
if (!this.pub) this.pub = this.ec.g.mul(this.priv);
if (!enc) return this.pub;
return this.pub.encode(enc, compact);
};
KeyPair.prototype.getPrivate = function getPrivate(enc) {
if (enc === "hex") return this.priv.toString(16, 2);
else return this.priv;
};
KeyPair.prototype._importPrivate = function _importPrivate(key, enc) {
this.priv = new BN(key, enc || 16);
this.priv = this.priv.umod(this.ec.curve.n);
};
KeyPair.prototype._importPublic = function _importPublic(key, enc) {
if (key.x || key.y) {
if (this.ec.curve.type === "mont") assert(key.x, "Need x coordinate");
else if (this.ec.curve.type === "short" || this.ec.curve.type === "edwards") assert(key.x && key.y, "Need both x and y coordinate");
this.pub = this.ec.curve.point(key.x, key.y);
return;
}
this.pub = this.ec.curve.decodePoint(key, enc);
};
KeyPair.prototype.derive = function derive(pub) {
if (!pub.validate()) assert(pub.validate(), "public point not validated");
return pub.mul(this.priv).getX();
};
KeyPair.prototype.sign = function sign(msg, enc, options) {
return this.ec.sign(msg, this, enc, options);
};
KeyPair.prototype.verify = function verify(msg, signature, options) {
return this.ec.verify(msg, signature, this, void 0, options);
};
KeyPair.prototype.inspect = function inspect() {
return "<Key priv: " + (this.priv && this.priv.toString(16, 2)) + " pub: " + (this.pub && this.pub.inspect()) + " >";
};
}));
//#endregion
//#region node_modules/elliptic/lib/elliptic/ec/signature.js
var require_signature$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var BN = require_bn$3();
var utils = require_utils$1();
var assert = utils.assert;
function Signature(options, enc) {
if (options instanceof Signature) return options;
if (this._importDER(options, enc)) return;
assert(options.r && options.s, "Signature without r or s");
this.r = new BN(options.r, 16);
this.s = new BN(options.s, 16);
if (options.recoveryParam === void 0) this.recoveryParam = null;
else this.recoveryParam = options.recoveryParam;
}
module.exports = Signature;
function Position() {
this.place = 0;
}
function getLength(buf, p) {
var initial = buf[p.place++];
if (!(initial & 128)) return initial;
var octetLen = initial & 15;
if (octetLen === 0 || octetLen > 4) return false;
if (buf[p.place] === 0) return false;
var val = 0;
for (var 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.prototype._importDER = function _importDER(data, enc) {
data = utils.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 r = data.slice(p.place, rlen + p.place);
p.place += rlen;
if (data[p.place++] !== 2) return false;
var slen = getLength(data, p);
if (slen === false) return false;
if (data.length !== slen + p.place) return false;
if ((data[p.place] & 128) !== 0) return false;
var s = data.slice(p.place, slen + p.place);
if (r[0] === 0) if (r[1] & 128) r = r.slice(1);
else return false;
if (s[0] === 0) if (s[1] & 128) s = s.slice(1);
else return false;
this.r = new BN(r);
this.s = new BN(s);
this.recoveryParam = null;
return true;
};
function constructLength(arr, 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.prototype.toDER = function toDER(enc) {
var r = this.r.toArray();
var s = this.s.toArray();
if (r[0] & 128) r = [0].concat(r);
if (s[0] & 128) s = [0].concat(s);
r = rmPadding(r);
s = rmPadding(s);
while (!s[0] && !(s[1] & 128)) s = s.slice(1);
var arr = [2];
constructLength(arr, r.length);
arr = arr.concat(r);
arr.push(2);
constructLength(arr, s.length);
var backHalf = arr.concat(s);
var res = [48];
constructLength(res, backHalf.length);
res = res.concat(backHalf);
return utils.encode(res, enc);
};
}));
//#endregion
//#region node_modules/elliptic/lib/elliptic/ec/index.js
var require_ec = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var BN = require_bn$3();
var HmacDRBG = require_hmac_drbg();
var utils = require_utils$1();
var curves = require_curves();
var rand = require_brorand();
var assert = utils.assert;
var KeyPair = require_key$1();
var Signature = require_signature$1();
function EC(options) {
if (!(this instanceof EC)) return new EC(options);
if (typeof options === "string") {
assert(Object.prototype.hasOwnProperty.call(curves, options), "Unknown curve " + options);
options = curves[options];
}
if (options instanceof curves.PresetCurve) options = { curve: options };
this.curve = options.curve.curve;
this.n = this.curve.n;
this.nh = this.n.ushrn(1);
this.g = this.curve.g;
this.g = options.curve.g;
this.g.precompute(options.curve.n.bitLength() + 1);
this.hash = options.hash || options.curve.hash;
}
module.exports = EC;
EC.prototype.keyPair = function keyPair(options) {
return new KeyPair(this, options);
};
EC.prototype.keyFromPrivate = function keyFromPrivate(priv, enc) {
return KeyPair.fromPrivate(this, priv, enc);
};
EC.prototype.keyFromPublic = function keyFromPublic(pub, enc) {
return KeyPair.fromPublic(this, pub, enc);
};
EC.prototype.genKeyPair = function genKeyPair(options) {
if (!options) options = {};
var drbg = new HmacDRBG({
hash: this.hash,
pers: options.pers,
persEnc: options.persEnc || "utf8",
entropy: options.entropy || rand(this.hash.hmacStrength),
entropyEnc: options.entropy && options.entropyEnc || "utf8",
nonce: this.n.toArray()
});
var bytes = this.n.byteLength();
var ns2 = this.n.sub(new BN(2));
for (;;) {
var priv = new BN(drbg.generate(bytes));
if (priv.cmp(ns2) > 0) continue;
priv.iaddn(1);
return this.keyFromPrivate(priv);
}
};
EC.prototype._truncateToN = function _truncateToN(msg, truncOnly, bitLength) {
var byteLength;
if (BN.isBN(msg) || typeof msg === "number") {
msg = new BN(msg, 16);
byteLength = msg.byteLength();
} else if (typeof msg === "object") {
byteLength = msg.length;
msg = new BN(msg, 16);
} else {
var str = msg.toString();
byteLength = str.length + 1 >>> 1;
msg = new BN(str, 16);
}
if (typeof bitLength !== "number") bitLength = byteLength * 8;
var delta = bitLength - 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 sign(msg, key, enc, options) {
if (typeof enc === "object") {
options = enc;
enc = null;
}
if (!options) options = {};
if (typeof msg !== "string" && typeof msg !== "number" && !BN.isBN(msg)) {
assert(typeof msg === "object" && msg && typeof msg.length === "number", "Expected message to be an array-like, a hex string, or a BN instance");
assert(msg.length >>> 0 === msg.length);
for (var i = 0; i < msg.length; i++) assert((msg[i] & 255) === msg[i]);
}
key = this.keyFromPrivate(key, enc);
msg = this._truncateToN(msg, false, options.msgBitLength);
assert(!msg.isNeg(), "Can not sign a negative message");
var bytes = this.n.byteLength();
var bkey = key.getPrivate().toArray("be", bytes);
var nonce = msg.toArray("be", bytes);
assert(new BN(nonce).eq(msg), "Can not sign message");
var drbg = new HmacDRBG({
hash: this.hash,
entropy: bkey,
nonce,
pers: options.pers,
persEnc: options.persEnc || "utf8"
});
var ns1 = this.n.sub(new BN(1));
for (var iter = 0;; iter++) {
var k = options.k ? options.k(iter) : new BN(drbg.generate(this.n.byteLength()));
k = this._truncateToN(k, true);
if (k.cmpn(1) <= 0 || k.cmp(ns1) >= 0) continue;
var kp = this.g.mul(k);
if (kp.isInfinity()) continue;
var kpX = kp.getX();
var r = kpX.umod(this.n);
if (r.cmpn(0) === 0) continue;
var s = k.invm(this.n).mul(r.mul(key.getPrivate()).iadd(msg));
s = s.umod(this.n);
if (s.cmpn(0) === 0) continue;
var recoveryParam = (kp.getY().isOdd() ? 1 : 0) | (kpX.cmp(r) !== 0 ? 2 : 0);
if (options.canonical && s.cmp(this.nh) > 0) {
s = this.n.sub(s);
recoveryParam ^= 1;
}
return new Signature({
r,
s,
recoveryParam
});
}
};
EC.prototype.verify = function verify(msg, signature, key, enc, options) {
if (!options) options = {};
msg = this._truncateToN(msg, false, options.msgBitLength);
key = this.keyFromPublic(key, enc);
signature = new Signature(signature, "hex");
var r = signature.r;
var s = signature.s;
if (r.cmpn(1) < 0 || r.cmp(this.n) >= 0) return false;
if (s.cmpn(1) < 0 || s.cmp(this.n) >= 0) return false;
var sinv = s.invm(this.n);
var u1 = sinv.mul(msg).umod(this.n);
var u2 = sinv.mul(r).umod(this.n);
var p;
if (!this.curve._maxwellTrick) {
p = this.g.mulAdd(u1, key.getPublic(), u2);
if (p.isInfinity()) return false;
return p.getX().umod(this.n).cmp(r) === 0;
}
p = this.g.jmulAdd(u1, key.getPublic(), u2);
if (p.isInfinity()) return false;
return p.eqXToP(r);
};
EC.prototype.recoverPubKey = function(msg, signature, j, enc) {
assert((3 & j) === j, "The recovery param is more than two bits");
signature = new Signature(signature, enc);
var n = this.n;
var e = new BN(msg);
var r = signature.r;
var s = signature.s;
var isYOdd = j & 1;
var isSecondKey = j >> 1;
if (r.cmp(this.curve.p.umod(this.curve.n)) >= 0 && isSecondKey) throw new Error("Unable to find sencond key candinate");
if (isSecondKey) r = this.curve.pointFromX(r.add(this.curve.n), isYOdd);
else r = this.curve.pointFromX(r, isYOdd);
var rInv = signature.r.invm(n);
var s1 = n.sub(e).mul(rInv).umod(n);
var s2 = s.mul(rInv).umod(n);
return this.g.mulAdd(s1, r, s2);
};
EC.prototype.getKeyRecoveryParam = function(e, signature, Q, enc) {
signature = new Signature(signature, enc);
if (signature.recoveryParam !== null) return signature.recoveryParam;
for (var i = 0; i < 4; i++) {
var Qprime;
try {
Qprime = this.recoverPubKey(e, signature, i);
} catch (e) {
continue;
}
if (Qprime.eq(Q)) return i;
}
throw new Error("Unable to find valid recovery factor");
};
}));
//#endregion
//#region node_modules/elliptic/lib/elliptic/eddsa/key.js
var require_key = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var utils = require_utils$1();
var assert = utils.assert;
var parseBytes = utils.parseBytes;
var cachedProperty = utils.cachedProperty;
/**
* @param {EDDSA} eddsa - instance
* @param {Object} params - public/private key parameters
*
* @param {Array<Byte>} [params.secret] - secret seed bytes
* @param {Point} [params.pub] - public key point (aka `A` in eddsa terms)
* @param {Array<Byte>} [params.pub] - public key point encoded as bytes
*
*/
function KeyPair(eddsa, params) {
this.eddsa = eddsa;
this._secret = parseBytes(params.secret);
if (eddsa.isPoint(params.pub)) this._pub = params.pub;
else this._pubBytes = parseBytes(params.pub);
}
KeyPair.fromPublic = function fromPublic(eddsa, pub) {
if (pub instanceof KeyPair) return pub;
return new KeyPair(eddsa, { pub });
};
KeyPair.fromSecret = function fromSecret(eddsa, secret) {
if (secret instanceof KeyPair) return secret;
return new KeyPair(eddsa, { secret });
};
KeyPair.prototype.secret = function secret() {
return this._secret;
};
cachedProperty(KeyPair, "pubBytes", function pubBytes() {
return this.eddsa.encodePoint(this.pub());
});
cachedProperty(KeyPair, "pub", function pub() {
if (this._pubBytes) return this.eddsa.decodePoint(this._pubBytes);
return this.eddsa.g.mul(this.priv());
});
cachedProperty(KeyPair, "privBytes", function privBytes() {
var eddsa = this.eddsa;
var hash = this.hash();
var lastIx = eddsa.encodingLength - 1;
var a = hash.slice(0, eddsa.encodingLength);
a[0] &= 248;
a[lastIx] &= 127;
a[lastIx] |= 64;
return a;
});
cachedProperty(KeyPair, "priv", function priv() {
return this.eddsa.decodeInt(this.privBytes());
});
cachedProperty(KeyPair, "hash", function hash() {
return this.eddsa.hash().update(this.secret()).digest();
});
cachedProperty(KeyPair, "messagePrefix", function messagePrefix() {
return this.hash().slice(this.eddsa.encodingLength);
});
KeyPair.prototype.sign = function sign(message) {
assert(this._secret, "KeyPair can only verify");
return this.eddsa.sign(message, this);
};
KeyPair.prototype.verify = function verify(message, sig) {
return this.eddsa.verify(message, sig, this);
};
KeyPair.prototype.getSecret = function getSecret(enc) {
assert(this._secret, "KeyPair is public only");
return utils.encode(this.secret(), enc);
};
KeyPair.prototype.getPublic = function getPublic(enc) {
return utils.encode(this.pubBytes(), enc);
};
module.exports = KeyPair;
}));
//#endregion
//#region node_modules/elliptic/lib/elliptic/eddsa/signature.js
var require_signature = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var BN = require_bn$3();
var utils = require_utils$1();
var assert = utils.assert;
var cachedProperty = utils.cachedProperty;
var parseBytes = utils.parseBytes;
/**
* @param {EDDSA} eddsa - eddsa instance
* @param {Array<Bytes>|Object} sig -
* @param {Array<Bytes>|Point} [sig.R] - R point as Point or bytes
* @param {Array<Bytes>|bn} [sig.S] - S scalar as bn or bytes
* @param {Array<Bytes>} [sig.Rencoded] - R point encoded
* @param {Array<Bytes>} [sig.Sencoded] - S scalar encoded
*/
function Signature(eddsa, sig) {
this.eddsa = eddsa;
if (typeof sig !== "object") sig = parseBytes(sig);
if (Array.isArray(sig)) {
assert(sig.length === eddsa.encodingLength * 2, "Signature has invalid size");
sig = {
R: sig.slice(0, eddsa.encodingLength),
S: sig.slice(eddsa.encodingLength)
};
}
assert(sig.R && sig.S, "Signature without R or S");
if (eddsa.isPoint(sig.R)) this._R = sig.R;
if (sig.S instanceof BN) this._S = sig.S;
this._Rencoded = Array.isArray(sig.R) ? sig.R : sig.Rencoded;
this._Sencoded = Array.isArray(sig.S) ? sig.S : sig.Sencoded;
}
cachedProperty(Signature, "S", function S() {
return this.eddsa.decodeInt(this.Sencoded());
});
cachedProperty(Signature, "R", function R() {
return this.eddsa.decodePoint(this.Rencoded());
});
cachedProperty(Signature, "Rencoded", function Rencoded() {
return this.eddsa.encodePoint(this.R());
});
cachedProperty(Signature, "Sencoded", function Sencoded() {
return this.eddsa.encodeInt(this.S());
});
Signature.prototype.toBytes = function toBytes() {
return this.Rencoded().concat(this.Sencoded());
};
Signature.prototype.toHex = function toHex() {
return utils.encode(this.toBytes(), "hex").toUpperCase();
};
module.exports = Signature;
}));
//#endregion
//#region node_modules/elliptic/lib/elliptic/eddsa/index.js
var require_eddsa = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var hash = require_hash();
var curves = require_curves();
var utils = require_utils$1();
var assert = utils.assert;
var parseBytes = utils.parseBytes;
var KeyPair = require_key();
var Signature = require_signature();
function EDDSA(curve) {
assert(curve === "ed25519", "only tested with ed25519 so far");
if (!(this instanceof EDDSA)) return new EDDSA(curve);
curve = curves[curve].curve;
this.curve = curve;
this.g = curve.g;
this.g.precompute(curve.n.bitLength() + 1);
this.pointClass = curve.point().constructor;
this.encodingLength = Math.ceil(curve.n.bitLength() / 8);
this.hash = hash.sha512;
}
module.exports = EDDSA;
/**
* @param {Array|String} message - message bytes
* @param {Array|String|KeyPair} secret - secret bytes or a keypair
* @returns {Signature} - signature
*/
EDDSA.prototype.sign = function sign(message, secret) {
message = parseBytes(message);
var key = this.keyFromSecret(secret);
var r = this.hashInt(key.messagePrefix(), message);
var R = this.g.mul(r);
var Rencoded = this.encodePoint(R);
var s_ = this.hashInt(Rencoded, key.pubBytes(), message).mul(key.priv());
var S = r.add(s_).umod(this.curve.n);
return this.makeSignature({
R,
S,
Rencoded
});
};
/**
* @param {Array} message - message bytes
* @param {Array|String|Signature} sig - sig bytes
* @param {Array|String|Point|KeyPair} pub - public key
* @returns {Boolean} - true if public key matches sig of message
*/
EDDSA.prototype.verify = function verify(message, sig, pub) {
message = parseBytes(message);
sig = this.makeSignature(sig);
if (sig.S().gte(sig.eddsa.curve.n) || sig.S().isNeg()) return false;
var key = this.keyFromPublic(pub);
var h = this.hashInt(sig.Rencoded(), key.pubBytes(), message);
var SG = this.g.mul(sig.S());
return sig.R().add(key.pub().mul(h)).eq(SG);
};
EDDSA.prototype.hashInt = function hashInt() {
var hash = this.hash();
for (var i = 0; i < arguments.length; i++) hash.update(arguments[i]);
return utils.intFromLE(hash.digest()).umod(this.curve.n);
};
EDDSA.prototype.keyFromPublic = function keyFromPublic(pub) {
return KeyPair.fromPublic(this, pub);
};
EDDSA.prototype.keyFromSecret = function keyFromSecret(secret) {
return KeyPair.fromSecret(this, secret);
};
EDDSA.prototype.makeSignature = function makeSignature(sig) {
if (sig instanceof Signature) return sig;
return new Signature(this, sig);
};
/**
* * https://tools.ietf.org/html/draft-josefsson-eddsa-ed25519-03#section-5.2
*
* EDDSA defines methods for encoding and decoding points and integers. These are
* helper convenience methods, that pass along to utility functions implied
* parameters.
*
*/
EDDSA.prototype.encodePoint = function encodePoint(point) {
var enc = point.getY().toArray("le", this.encodingLength);
enc[this.encodingLength - 1] |= point.getX().isOdd() ? 128 : 0;
return enc;
};
EDDSA.prototype.decodePoint = function decodePoint(bytes) {
bytes = utils.parseBytes(bytes);
var lastIx = bytes.length - 1;
var normed = bytes.slice(0, lastIx).concat(bytes[lastIx] & -129);
var xIsOdd = (bytes[lastIx] & 128) !== 0;
var y = 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;
};
}));
//#endregion
//#region node_modules/elliptic/lib/elliptic.js
var require_elliptic = /* @__PURE__ */ __commonJSMin(((exports) => {
var elliptic = exports;
elliptic.version = (init_package(), __toCommonJS(package_exports).default).version;
elliptic.utils = require_utils$1();
elliptic.rand = require_brorand();
elliptic.curve = require_curve();
elliptic.curves = require_curves();
elliptic.ec = require_ec();
elliptic.eddsa = require_eddsa();
}));
//#endregion
//#region node_modules/parse-asn1/node_modules/bn.js/lib/bn.js
var require_bn$2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
(function(module$3, exports$3) {
"use strict";
function assert(val, msg) {
if (!val) throw new Error(msg || "Assertion failed");
}
function inherits(ctor, superCtor) {
ctor.super_ = superCtor;
var TempCtor = function() {};
TempCtor.prototype = superCtor.prototype;
ctor.prototype = new TempCtor();
ctor.prototype.constructor = ctor;
}
function BN(number, base, endian) {
if (BN.isBN(number)) return number;
this.negative = 0;
this.words = null;
this.length = 0;
this.red = null;
if (number !== null) {
if (base === "le" || base === "be") {
endian = base;
base = 10;
}
this._init(number || 0, base || 10, endian || "be");
}
}
if (typeof module$3 === "object") module$3.exports = BN;
else exports$3.BN = BN;
BN.BN = BN;
BN.wordSize = 26;
var Buffer;
try {
if (typeof window !== "undefined" && typeof window.Buffer !== "undefined") Buffer = window.Buffer;
else Buffer = require_dist().Buffer;
} catch (e) {}
BN.isBN = function isBN(num) {
if (num instanceof BN) return true;
return num !== null && typeof num === "object" && num.constructor.wordSize === BN.wordSize && Array.isArray(num.words);
};
BN.max = function max(left, right) {
if (left.cmp(right) > 0) return left;
return right;
};
BN.min = function min(left, right) {
if (left.cmp(right) < 0) return left;
return right;
};
BN.prototype._init = function init(number, base, endian) {
if (typeof number === "number") return this._initNumber(number, base, endian);
if (typeof number === "object") return this._initArray(number, base, endian);
if (base === "hex") base = 16;
assert(base === (base | 0) && base >= 2 && base <= 36);
number = number.toString().replace(/\s+/g, "");
var start = 0;
if (number[0] === "-") {
start++;
this.negative = 1;
}
if (start < number.length) if (base === 16) this._parseHex(number, start, endian);
else {
this._parseBase(number, base, start);
if (endian === "le") this._initArray(this.toArray(), base, endian);
}
};
BN.prototype._initNumber = function _initNumber(number, base, endian) {
if (number < 0) {
this.negative = 1;
number = -number;
}
if (number < 67108864) {
this.words = [number & 67108863];
this.length = 1;
} else if (number < 4503599627370496) {
this.words = [number & 67108863, number / 67108864 & 67108863];
this.length = 2;
} else {
assert(number < 9007199254740992);
this.words = [
number & 67108863,
number / 67108864 & 67108863,
1
];
this.length = 3;
}
if (endian !== "le") return;
this._initArray(this.toArray(), base, endian);
};
BN.prototype._initArray = function _initArray(number, base, endian) {
assert(typeof number.length === "number");
if (number.length <= 0) {
this.words = [0];
this.length = 1;
return this;
}
this.length = Math.ceil(number.length / 3);
this.words = new Array(this.length);
for (var 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 r = parseHex4Bits(string, index);
if (index - 1 >= lowerBound) r |= parseHex4Bits(string, index - 1) << 4;
return r;
}
BN.prototype._parseHex = function _parseHex(number, start, endian) {
this.length = Math.ceil((number.length - start) / 6);
this.words = new Array(this.length);
for (var 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 for (i = (number.length - start) % 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, mul) {
var r = 0;
var len = Math.min(str.length, end);
for (var i = start; i < len; i++) {
var c = str.charCodeAt(i) - 48;
r *= mul;
if (c >= 49) r += c - 49 + 10;
else if (c >= 17) r += c - 17 + 10;
else r += c;
}
return r;
}
BN.prototype._parseBase = function _parseBase(number, base, start) {
this.words = [0];
this.length = 1;
for (var limbLen = 0, limbPow = 1; limbPow <= 67108863; limbPow *= base) limbLen++;
limbLen--;
limbPow = limbPow / base | 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, base);
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, base);
for (i = 0; i < mod; i++) pow *= base;
this.imuln(pow);
if (this.words[0] + word < 67108864) this.words[0] += word;
else this._iaddn(word);
}
this.strip();
};
BN.prototype.copy = function copy(dest) {
dest.words = new Array(this.length);
for (var i = 0; i < this.length; i++) dest.words[i] = this.words[i];
dest.length = this.length;
dest.negative = this.negative;
dest.red = this.red;
};
BN.prototype.clone = function clone() {
var r = new BN(null);
this.copy(r);
return r;
};
BN.prototype._expand = function _expand(size) {
while (this.length < size) this.words[this.length++] = 0;
return this;
};
BN.prototype.strip = function strip() {
while (this.length > 1 && this.words[this.length - 1] === 0) this.length--;
return this._normSign();
};
BN.prototype._normSign = function _normSign() {
if (this.length === 1 && this.words[0] === 0) this.negative = 0;
return this;
};
BN.prototype.inspect = function inspect() {
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
];
BN.prototype.toString = function toString(base, padding) {
base = base || 10;
padding = padding | 0 || 1;
var out;
if (base === 16 || base === "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 (base === (base | 0) && base >= 2 && base <= 36) {
var groupSize = groupSizes[base];
var groupBase = groupBases[base];
out = "";
var c = this.clone();
c.negative = 0;
while (!c.isZero()) {
var r = c.modn(groupBase).toString(base);
c = c.idivn(groupBase);
if (!c.isZero()) out = zeros[groupSize - r.length] + r + out;
else out = r + out;
}
if (this.isZero()) out = "0" + out;
while (out.length % padding !== 0) out = "0" + out;
if (this.negative !== 0) out = "-" + out;
return out;
}
assert(false, "Base should be between 2 and 36");
};
BN.prototype.toNumber = function 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) assert(false, "Number can only safely store up to 53 bits");
return this.negative !== 0 ? -ret : ret;
};
BN.prototype.toJSON = function toJSON() {
return this.toString(16);
};
BN.prototype.toBuffer = function toBuffer(endian, length) {
assert(typeof Buffer !== "undefined");
return this.toArrayLike(Buffer, endian, length);
};
BN.prototype.toArray = function toArray(endian, length) {
return this.toArrayLike(Array, endian, length);
};
BN.prototype.toArrayLike = function toArrayLike(ArrayType, endian, length) {
var byteLength = this.byteLength();
var reqLength = length || Math.max(1, byteLength);
assert(byteLength <= reqLength, "byte array longer than desired length");
assert(reqLength > 0, "Requested array length <= 0");
this.strip();
var littleEndian = endian === "le";
var res = new ArrayType(reqLength);
var b, 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) BN.prototype._countBits = function _countBits(w) {
return 32 - Math.clz32(w);
};
else BN.prototype._countBits = function _countBits(w) {
var t = w;
var r = 0;
if (t >= 4096) {
r += 13;
t >>>= 13;
}
if (t >= 64) {
r += 7;
t >>>= 7;
}
if (t >= 8) {
r += 4;
t >>>= 4;
}
if (t >= 2) {
r += 2;
t >>>= 2;
}
return r + t;
};
BN.prototype._zeroBits = function _zeroBits(w) {
if (w === 0) return 26;
var t = w;
var r = 0;
if ((t & 8191) === 0) {
r += 13;
t >>>= 13;
}
if ((t & 127) === 0) {
r += 7;
t >>>= 7;
}
if ((t & 15) === 0) {
r += 4;
t >>>= 4;
}
if ((t & 3) === 0) {
r += 2;
t >>>= 2;
}
if ((t & 1) === 0) r++;
return r;
};
BN.prototype.bitLength = function bitLength() {
var w = this.words[this.length - 1];
var hi = this._countBits(w);
return (this.length - 1) * 26 + hi;
};
function toBitArray(num) {
var w = new Array(num.bitLength());
for (var bit = 0; bit < w.length; bit++) {
var off = bit / 26 | 0;
var wbit = bit % 26;
w[bit] = (num.words[off] & 1 << wbit) >>> wbit;
}
return w;
}
BN.prototype.zeroBits = function zeroBits() {
if (this.isZero()) return 0;
var r = 0;
for (var i = 0; i < this.length; i++) {
var b = this._zeroBits(this.words[i]);
r += b;
if (b !== 26) break;
}
return r;
};
BN.prototype.byteLength = function byteLength() {
return Math.ceil(this.bitLength() / 8);
};
BN.prototype.toTwos = function toTwos(width) {
if (this.negative !== 0) return this.abs().inotn(width).iaddn(1);
return this.clone();
};
BN.prototype.fromTwos = function fromTwos(width) {
if (this.testn(width - 1)) return this.notn(width).iaddn(1).ineg();
return this.clone();
};
BN.prototype.isNeg = function isNeg() {
return this.negative !== 0;
};
BN.prototype.neg = function neg() {
return this.clone().ineg();
};
BN.prototype.ineg = function ineg() {
if (!this.isZero()) this.negative ^= 1;
return this;
};
BN.prototype.iuor = function iuor(num) {
while (this.length < num.length) this.words[this.length++] = 0;
for (var i = 0; i < num.length; i++) this.words[i] = this.words[i] | num.words[i];
return this.strip();
};
BN.prototype.ior = function ior(num) {
assert((this.negative | num.negative) === 0);
return this.iuor(num);
};
BN.prototype.or = function or(num) {
if (this.length > num.length) return this.clone().ior(num);
return num.clone().ior(this);
};
BN.prototype.uor = function uor(num) {
if (this.length > num.length) return this.clone().iuor(num);
return num.clone().iuor(this);
};
BN.prototype.iuand = function iuand(num) {
var b;
if (this.length > num.length) b = num;
else b = this;
for (var i = 0; i < b.length; i++) this.words[i] = this.words[i] & num.words[i];
this.length = b.length;
return this.strip();
};
BN.prototype.iand = function iand(num) {
assert((this.negative | num.negative) === 0);
return this.iuand(num);
};
BN.prototype.and = function and(num) {
if (this.length > num.length) return this.clone().iand(num);
return num.clone().iand(this);
};
BN.prototype.uand = function uand(num) {
if (this.length > num.length) return this.clone().iuand(num);
return num.clone().iuand(this);
};
BN.prototype.iuxor = function iuxor(num) {
var a;
var b;
if (this.length > num.length) {
a = this;
b = num;
} else {
a = num;
b = this;
}
for (var 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();
};
BN.prototype.ixor = function ixor(num) {
assert((this.negative | num.negative) === 0);
return this.iuxor(num);
};
BN.prototype.xor = function xor(num) {
if (this.length > num.length) return this.clone().ixor(num);
return num.clone().ixor(this);
};
BN.prototype.uxor = function uxor(num) {
if (this.length > num.length) return this.clone().iuxor(num);
return num.clone().iuxor(this);
};
BN.prototype.inotn = function inotn(width) {
assert(typeof width === "number" && width >= 0);
var bytesNeeded = Math.ceil(width / 26) | 0;
var bitsLeft = width % 26;
this._expand(bytesNeeded);
if (bitsLeft > 0) bytesNeeded--;
for (var 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();
};
BN.prototype.notn = function notn(width) {
return this.clone().inotn(width);
};
BN.prototype.setn = function setn(bit, val) {
assert(typeof bit === "number" && bit >= 0);
var off = bit / 26 | 0;
var wbit = bit % 26;
this._expand(off + 1);
if (val) this.words[off] = this.words[off] | 1 << wbit;
else this.words[off] = this.words[off] & ~(1 << wbit);
return this.strip();
};
BN.prototype.iadd = function iadd(num) {
var r;
if (this.negative !== 0 && num.negative === 0) {
this.negative = 0;
r = this.isub(num);
this.negative ^= 1;
return this._normSign();
} else if (this.negative === 0 && num.negative !== 0) {
num.negative = 0;
r = this.isub(num);
num.negative = 1;
return r._normSign();
}
var a, b;
if (this.length > num.length) {
a = this;
b = num;
} else {
a = num;
b = this;
}
var carry = 0;
for (var i = 0; i < b.length; i++) {
r = (a.words[i] | 0) + (b.words[i] | 0) + carry;
this.words[i] = r & 67108863;
carry = r >>> 26;
}
for (; carry !== 0 && i < a.length; i++) {
r = (a.words[i] | 0) + carry;
this.words[i] = r & 67108863;
carry = r >>> 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;
};
BN.prototype.add = function add(num) {
var res;
if (num.negative !== 0 && this.negative === 0) {
num.negative = 0;
res = this.sub(num);
num.negative ^= 1;
return res;
} else if (num.negative === 0 && this.negative !== 0) {
this.negative = 0;
res = num.sub(this);
this.negative = 1;
return res;
}
if (this.length > num.length) return this.clone().iadd(num);
return num.clone().iadd(this);
};
BN.prototype.isub = function isub(num) {
if (num.negative !== 0) {
num.negative = 0;
var r = this.iadd(num);
num.negative = 1;
return r._normSign();
} else if (this.negative !== 0) {
this.negative = 0;
this.iadd(num);
this.negative = 1;
return this._normSign();
}
var cmp = this.cmp(num);
if (cmp === 0) {
this.negative = 0;
this.length = 1;
this.words[0] = 0;
return this;
}
var a, b;
if (cmp > 0) {
a = this;
b = num;
} else {
a = num;
b = this;
}
var carry = 0;
for (var i = 0; i < b.length; i++) {
r = (a.words[i] | 0) - (b.words[i] | 0) + carry;
carry = r >> 26;
this.words[i] = r & 67108863;
}
for (; carry !== 0 && i < a.length; i++) {
r = (a.words[i] | 0) + carry;
carry = r >> 26;
this.words[i] = r & 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();
};
BN.prototype.sub = function sub(num) {
return this.clone().isub(num);
};
function smallMulTo(self, num, out) {
out.negative = num.negative ^ self.negative;
var len = self.length + num.length | 0;
out.length = len;
len = len - 1 | 0;
var a = self.words[0] | 0;
var b = num.words[0] | 0;
var r = a * b;
var lo = r & 67108863;
var carry = r / 67108864 | 0;
out.words[0] = lo;
for (var k = 1; k < 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 - self.length + 1); j <= maxJ; j++) {
var i = k - j | 0;
a = self.words[i] | 0;
b = num.words[j] | 0;
r = a * b + rword;
ncarry += r / 67108864 | 0;
rword = r & 67108863;
}
out.words[k] = rword | 0;
carry = ncarry | 0;
}
if (carry !== 0) out.words[k] = carry | 0;
else out.length--;
return out.strip();
}
var comb10MulTo = function comb10MulTo(self, num, out) {
var a = self.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 = self.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(self, num, out) {
out.negative = num.negative ^ self.negative;
out.length = self.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 - self.length + 1); j <= maxJ; j++) {
var i = k - j;
var r = (self.words[i] | 0) * (num.words[j] | 0);
var lo = r & 67108863;
ncarry = ncarry + (r / 67108864 | 0) | 0;
lo = lo + rword | 0;
rword = lo & 67108863;
ncarry = ncarry + (lo >>> 26) | 0;
hncarry += ncarry >>> 26;
ncarry &= 67108863;
}
out.words[k] = rword;
carry = ncarry;
ncarry = hncarry;
}
if (carry !== 0) out.words[k] = carry;
else out.length--;
return out.strip();
}
function jumboMulTo(self, num, out) {
return new FFTM().mulp(self, num, out);
}
BN.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 = BN.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 permute(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 s = 1; s < N; s <<= 1) {
var l = s << 1;
var rtwdf = Math.cos(2 * Math.PI / l);
var itwdf = Math.sin(2 * Math.PI / l);
for (var p = 0; p < N; p += l) {
var rtwdf_ = rtwdf;
var itwdf_ = itwdf;
for (var j = 0; j < s; j++) {
var re = rtws[p + j];
var ie = itws[p + j];
var ro = rtws[p + j + s];
var io = itws[p + j + s];
var rx = rtwdf_ * ro - itwdf_ * io;
io = rtwdf_ * io + itwdf_ * ro;
ro = rx;
rtws[p + j] = re + ro;
itws[p + j] = ie + io;
rtws[p + j + s] = re - ro;
itws[p + j + s] = ie - io;
if (j !== l) {
rx = rtwdf * rtwdf_ - itwdf * itwdf_;
itwdf_ = rtwdf * itwdf_ + itwdf * rtwdf_;
rtwdf_ = rx;
}
}
}
}
};
FFTM.prototype.guessLen13b = function guessLen13b(n, m) {
var N = Math.max(m, n) | 1;
var odd = N & 1;
var 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;
assert(carry === 0);
assert((carry & -8192) === 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();
};
BN.prototype.mul = function mul(num) {
var out = new BN(null);
out.words = new Array(this.length + num.length);
return this.mulTo(num, out);
};
BN.prototype.mulf = function mulf(num) {
var out = new BN(null);
out.words = new Array(this.length + num.length);
return jumboMulTo(this, num, out);
};
BN.prototype.imul = function imul(num) {
return this.clone().mulTo(num, this);
};
BN.prototype.imuln = function imuln(num) {
assert(typeof num === "number");
assert(num < 67108864);
var carry = 0;
for (var 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;
};
BN.prototype.muln = function muln(num) {
return this.clone().imuln(num);
};
BN.prototype.sqr = function sqr() {
return this.mul(this);
};
BN.prototype.isqr = function isqr() {
return this.imul(this.clone());
};
BN.prototype.pow = function pow(num) {
var w = toBitArray(num);
if (w.length === 0) return new BN(1);
var res = this;
for (var 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;
};
BN.prototype.iushln = function iushln(bits) {
assert(typeof bits === "number" && bits >= 0);
var r = bits % 26;
var s = (bits - r) / 26;
var carryMask = 67108863 >>> 26 - r << 26 - r;
var i;
if (r !== 0) {
var carry = 0;
for (i = 0; i < this.length; i++) {
var newCarry = this.words[i] & carryMask;
var c = (this.words[i] | 0) - newCarry << r;
this.words[i] = c | carry;
carry = newCarry >>> 26 - r;
}
if (carry) {
this.words[i] = carry;
this.length++;
}
}
if (s !== 0) {
for (i = this.length - 1; i >= 0; i--) this.words[i + s] = this.words[i];
for (i = 0; i < s; i++) this.words[i] = 0;
this.length += s;
}
return this.strip();
};
BN.prototype.ishln = function ishln(bits) {
assert(this.negative === 0);
return this.iushln(bits);
};
BN.prototype.iushrn = function iushrn(bits, hint, extended) {
assert(typeof bits === "number" && bits >= 0);
var h;
if (hint) h = (hint - hint % 26) / 26;
else h = 0;
var r = bits % 26;
var s = Math.min((bits - r) / 26, this.length);
var mask = 67108863 ^ 67108863 >>> r << r;
var maskedWords = extended;
h -= s;
h = Math.max(0, h);
if (maskedWords) {
for (var i = 0; i < s; i++) maskedWords.words[i] = this.words[i];
maskedWords.length = s;
}
if (s === 0) {} else if (this.length > s) {
this.length -= s;
for (i = 0; i < this.length; i++) this.words[i] = this.words[i + s];
} 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 - r | word >>> r;
carry = word & mask;
}
if (maskedWords && carry !== 0) maskedWords.words[maskedWords.length++] = carry;
if (this.length === 0) {
this.words[0] = 0;
this.length = 1;
}
return this.strip();
};
BN.prototype.ishrn = function ishrn(bits, hint, extended) {
assert(this.negative === 0);
return this.iushrn(bits, hint, extended);
};
BN.prototype.shln = function shln(bits) {
return this.clone().ishln(bits);
};
BN.prototype.ushln = function ushln(bits) {
return this.clone().iushln(bits);
};
BN.prototype.shrn = function shrn(bits) {
return this.clone().ishrn(bits);
};
BN.prototype.ushrn = function ushrn(bits) {
return this.clone().iushrn(bits);
};
BN.prototype.testn = function testn(bit) {
assert(typeof bit === "number" && bit >= 0);
var r = bit % 26;
var s = (bit - r) / 26;
var q = 1 << r;
if (this.length <= s) return false;
return !!(this.words[s] & q);
};
BN.prototype.imaskn = function imaskn(bits) {
assert(typeof bits === "number" && bits >= 0);
var r = bits % 26;
var s = (bits - r) / 26;
assert(this.negative === 0, "imaskn works only with positive numbers");
if (this.length <= s) return this;
if (r !== 0) s++;
this.length = Math.min(s, this.length);
if (r !== 0) {
var mask = 67108863 ^ 67108863 >>> r << r;
this.words[this.length - 1] &= mask;
}
return this.strip();
};
BN.prototype.maskn = function maskn(bits) {
return this.clone().imaskn(bits);
};
BN.prototype.iaddn = function iaddn(num) {
assert(typeof num === "number");
assert(num < 67108864);
if (num < 0) return this.isubn(-num);
if (this.negative !== 0) {
if (this.length === 1 && (this.words[0] | 0) < num) {
this.words[0] = num - (this.words[0] | 0);
this.negative = 0;
return this;
}
this.negative = 0;
this.isubn(num);
this.negative = 1;
return this;
}
return this._iaddn(num);
};
BN.prototype._iaddn = function _iaddn(num) {
this.words[0] += num;
for (var 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;
};
BN.prototype.isubn = function isubn(num) {
assert(typeof num === "number");
assert(num < 67108864);
if (num < 0) return this.iaddn(-num);
if (this.negative !== 0) {
this.negative = 0;
this.iaddn(num);
this.negative = 1;
return this;
}
this.words[0] -= num;
if (this.length === 1 && this.words[0] < 0) {
this.words[0] = -this.words[0];
this.negative = 1;
} else for (var i = 0; i < this.length && this.words[i] < 0; i++) {
this.words[i] += 67108864;
this.words[i + 1] -= 1;
}
return this.strip();
};
BN.prototype.addn = function addn(num) {
return this.clone().iaddn(num);
};
BN.prototype.subn = function subn(num) {
return this.clone().isubn(num);
};
BN.prototype.iabs = function iabs() {
this.negative = 0;
return this;
};
BN.prototype.abs = function abs() {
return this.clone().iabs();
};
BN.prototype._ishlnsubmul = function _ishlnsubmul(num, mul, shift) {
var 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) * mul;
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();
assert(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();
};
BN.prototype._wordDiv = function _wordDiv(num, mode) {
var shift = this.length - num.length;
var a = this.clone();
var b = num;
var bhi = b.words[b.length - 1] | 0;
shift = 26 - this._countBits(bhi);
if (shift !== 0) {
b = b.ushln(shift);
a.iushln(shift);
bhi = b.words[b.length - 1] | 0;
}
var m = a.length - b.length;
var q;
if (mode !== "mod") {
q = new BN(null);
q.length = m + 1;
q.words = new Array(q.length);
for (var 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
};
};
BN.prototype.divmod = function divmod(num, mode, positive) {
assert(!num.isZero());
if (this.isZero()) return {
div: new BN(0),
mod: new BN(0)
};
var div, mod, res;
if (this.negative !== 0 && num.negative === 0) {
res = this.neg().divmod(num, mode);
if (mode !== "mod") div = res.div.neg();
if (mode !== "div") {
mod = res.mod.neg();
if (positive && mod.negative !== 0) mod.iadd(num);
}
return {
div,
mod
};
}
if (this.negative === 0 && num.negative !== 0) {
res = this.divmod(num.neg(), mode);
if (mode !== "mod") div = res.div.neg();
return {
div,
mod: res.mod
};
}
if ((this.negative & num.negative) !== 0) {
res = this.neg().divmod(num.neg(), mode);
if (mode !== "div") {
mod = res.mod.neg();
if (positive && mod.negative !== 0) mod.isub(num);
}
return {
div: res.div,
mod
};
}
if (num.length > this.length || this.cmp(num) < 0) return {
div: new BN(0),
mod: this
};
if (num.length === 1) {
if (mode === "div") return {
div: this.divn(num.words[0]),
mod: null
};
if (mode === "mod") return {
div: null,
mod: new BN(this.modn(num.words[0]))
};
return {
div: this.divn(num.words[0]),
mod: new BN(this.modn(num.words[0]))
};
}
return this._wordDiv(num, mode);
};
BN.prototype.div = function div(num) {
return this.divmod(num, "div", false).div;
};
BN.prototype.mod = function mod(num) {
return this.divmod(num, "mod", false).mod;
};
BN.prototype.umod = function umod(num) {
return this.divmod(num, "mod", true).mod;
};
BN.prototype.divRound = function divRound(num) {
var dm = this.divmod(num);
if (dm.mod.isZero()) return dm.div;
var mod = dm.div.negative !== 0 ? dm.mod.isub(num) : dm.mod;
var half = num.ushrn(1);
var r2 = num.andln(1);
var cmp = mod.cmp(half);
if (cmp < 0 || r2 === 1 && cmp === 0) return dm.div;
return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1);
};
BN.prototype.modn = function modn(num) {
assert(num <= 67108863);
var p = (1 << 26) % num;
var acc = 0;
for (var i = this.length - 1; i >= 0; i--) acc = (p * acc + (this.words[i] | 0)) % num;
return acc;
};
BN.prototype.idivn = function idivn(num) {
assert(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();
};
BN.prototype.divn = function divn(num) {
return this.clone().idivn(num);
};
BN.prototype.egcd = function egcd(p) {
assert(p.negative === 0);
assert(!p.isZero());
var x = this;
var y = p.clone();
if (x.negative !== 0) x = x.umod(p);
else x = x.clone();
var A = new BN(1);
var B = new BN(0);
var C = new BN(0);
var D = new BN(1);
var g = 0;
while (x.isEven() && y.isEven()) {
x.iushrn(1);
y.iushrn(1);
++g;
}
var yp = y.clone();
var xp = x.clone();
while (!x.isZero()) {
for (var 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(g)
};
};
BN.prototype._invmp = function _invmp(p) {
assert(p.negative === 0);
assert(!p.isZero());
var a = this;
var b = p.clone();
if (a.negative !== 0) a = a.umod(p);
else a = a.clone();
var x1 = new BN(1);
var x2 = new BN(0);
var delta = b.clone();
while (a.cmpn(1) > 0 && b.cmpn(1) > 0) {
for (var 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;
};
BN.prototype.gcd = function gcd(num) {
if (this.isZero()) return num.abs();
if (num.isZero()) return this.abs();
var a = this.clone();
var b = num.clone();
a.negative = 0;
b.negative = 0;
for (var shift = 0; a.isEven() && b.isEven(); shift++) {
a.iushrn(1);
b.iushrn(1);
}
do {
while (a.isEven()) a.iushrn(1);
while (b.isEven()) b.iushrn(1);
var r = a.cmp(b);
if (r < 0) {
var t = a;
a = b;
b = t;
} else if (r === 0 || b.cmpn(1) === 0) break;
a.isub(b);
} while (true);
return b.iushln(shift);
};
BN.prototype.invm = function invm(num) {
return this.egcd(num).a.umod(num);
};
BN.prototype.isEven = function isEven() {
return (this.words[0] & 1) === 0;
};
BN.prototype.isOdd = function isOdd() {
return (this.words[0] & 1) === 1;
};
BN.prototype.andln = function andln(num) {
return this.words[0] & num;
};
BN.prototype.bincn = function bincn(bit) {
assert(typeof bit === "number");
var r = bit % 26;
var s = (bit - r) / 26;
var q = 1 << r;
if (this.length <= s) {
this._expand(s + 1);
this.words[s] |= q;
return this;
}
var carry = q;
for (var i = s; 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;
};
BN.prototype.isZero = function isZero() {
return this.length === 1 && this.words[0] === 0;
};
BN.prototype.cmpn = function cmpn(num) {
var negative = num < 0;
if (this.negative !== 0 && !negative) return -1;
if (this.negative === 0 && negative) return 1;
this.strip();
var res;
if (this.length > 1) res = 1;
else {
if (negative) num = -num;
assert(num <= 67108863, "Number is too big");
var w = this.words[0] | 0;
res = w === num ? 0 : w < num ? -1 : 1;
}
if (this.negative !== 0) return -res | 0;
return res;
};
BN.prototype.cmp = function cmp(num) {
if (this.negative !== 0 && num.negative === 0) return -1;
if (this.negative === 0 && num.negative !== 0) return 1;
var res = this.ucmp(num);
if (this.negative !== 0) return -res | 0;
return res;
};
BN.prototype.ucmp = function ucmp(num) {
if (this.length > num.length) return 1;
if (this.length < num.length) return -1;
var res = 0;
for (var 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;
};
BN.prototype.gtn = function gtn(num) {
return this.cmpn(num) === 1;
};
BN.prototype.gt = function gt(num) {
return this.cmp(num) === 1;
};
BN.prototype.gten = function gten(num) {
return this.cmpn(num) >= 0;
};
BN.prototype.gte = function gte(num) {
return this.cmp(num) >= 0;
};
BN.prototype.ltn = function ltn(num) {
return this.cmpn(num) === -1;
};
BN.prototype.lt = function lt(num) {
return this.cmp(num) === -1;
};
BN.prototype.lten = function lten(num) {
return this.cmpn(num) <= 0;
};
BN.prototype.lte = function lte(num) {
return this.cmp(num) <= 0;
};
BN.prototype.eqn = function eqn(num) {
return this.cmpn(num) === 0;
};
BN.prototype.eq = function eq(num) {
return this.cmp(num) === 0;
};
BN.red = function red(num) {
return new Red(num);
};
BN.prototype.toRed = function toRed(ctx) {
assert(!this.red, "Already a number in reduction context");
assert(this.negative === 0, "red works only with positives");
return ctx.convertTo(this)._forceRed(ctx);
};
BN.prototype.fromRed = function fromRed() {
assert(this.red, "fromRed works only with numbers in reduction context");
return this.red.convertFrom(this);
};
BN.prototype._forceRed = function _forceRed(ctx) {
this.red = ctx;
return this;
};
BN.prototype.forceRed = function forceRed(ctx) {
assert(!this.red, "Already a number in reduction context");
return this._forceRed(ctx);
};
BN.prototype.redAdd = function redAdd(num) {
assert(this.red, "redAdd works only with red numbers");
return this.red.add(this, num);
};
BN.prototype.redIAdd = function redIAdd(num) {
assert(this.red, "redIAdd works only with red numbers");
return this.red.iadd(this, num);
};
BN.prototype.redSub = function redSub(num) {
assert(this.red, "redSub works only with red numbers");
return this.red.sub(this, num);
};
BN.prototype.redISub = function redISub(num) {
assert(this.red, "redISub works only with red numbers");
return this.red.isub(this, num);
};
BN.prototype.redShl = function redShl(num) {
assert(this.red, "redShl works only with red numbers");
return this.red.shl(this, num);
};
BN.prototype.redMul = function redMul(num) {
assert(this.red, "redMul works only with red numbers");
this.red._verify2(this, num);
return this.red.mul(this, num);
};
BN.prototype.redIMul = function redIMul(num) {
assert(this.red, "redMul works only with red numbers");
this.red._verify2(this, num);
return this.red.imul(this, num);
};
BN.prototype.redSqr = function redSqr() {
assert(this.red, "redSqr works only with red numbers");
this.red._verify1(this);
return this.red.sqr(this);
};
BN.prototype.redISqr = function redISqr() {
assert(this.red, "redISqr works only with red numbers");
this.red._verify1(this);
return this.red.isqr(this);
};
BN.prototype.redSqrt = function redSqrt() {
assert(this.red, "redSqrt works only with red numbers");
this.red._verify1(this);
return this.red.sqrt(this);
};
BN.prototype.redInvm = function redInvm() {
assert(this.red, "redInvm works only with red numbers");
this.red._verify1(this);
return this.red.invm(this);
};
BN.prototype.redNeg = function redNeg() {
assert(this.red, "redNeg works only with red numbers");
this.red._verify1(this);
return this.red.neg(this);
};
BN.prototype.redPow = function redPow(num) {
assert(this.red && !num.red, "redPow(normalNum)");
this.red._verify1(this);
return this.red.pow(this, num);
};
var primes = {
k256: null,
p224: null,
p192: null,
p25519: null
};
function MPrime(name, p) {
this.name = name;
this.p = new BN(p, 16);
this.n = this.p.bitLength();
this.k = new BN(1).iushln(this.n).isub(this.p);
this.tmp = this._tmp();
}
MPrime.prototype._tmp = function _tmp() {
var tmp = new BN(null);
tmp.words = new Array(Math.ceil(this.n / 13));
return tmp;
};
MPrime.prototype.ireduce = function ireduce(num) {
var r = num;
var rlen;
do {
this.split(r, this.tmp);
r = this.imulK(r);
r = r.iadd(this.tmp);
rlen = r.bitLength();
} while (rlen > this.n);
var cmp = rlen < this.n ? -1 : r.ucmp(this.p);
if (cmp === 0) {
r.words[0] = 0;
r.length = 1;
} else if (cmp > 0) r.isub(this.p);
else if (r.strip !== void 0) r.strip();
else r._strip();
return r;
};
MPrime.prototype.split = function split(input, out) {
input.iushrn(this.n, 0, out);
};
MPrime.prototype.imulK = function imulK(num) {
return num.imul(this.k);
};
function K256() {
MPrime.call(this, "k256", "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f");
}
inherits(K256, MPrime);
K256.prototype.split = function split(input, output) {
var mask = 4194303;
var outLen = Math.min(input.length, 9);
for (var 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");
}
inherits(P224, MPrime);
function P192() {
MPrime.call(this, "p192", "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff");
}
inherits(P192, MPrime);
function P25519() {
MPrime.call(this, "25519", "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed");
}
inherits(P25519, MPrime);
P25519.prototype.imulK = function imulK(num) {
var carry = 0;
for (var 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;
};
BN._prime = function prime(name) {
if (primes[name]) return primes[name];
var prime;
if (name === "k256") prime = new K256();
else if (name === "p224") prime = new P224();
else if (name === "p192") prime = new P192();
else if (name === "p25519") prime = new P25519();
else throw new Error("Unknown prime " + name);
primes[name] = prime;
return prime;
};
function Red(m) {
if (typeof m === "string") {
var prime = BN._prime(m);
this.m = prime.p;
this.prime = prime;
} else {
assert(m.gtn(1), "modulus must be greater than 1");
this.m = m;
this.prime = null;
}
}
Red.prototype._verify1 = function _verify1(a) {
assert(a.negative === 0, "red works only with positives");
assert(a.red, "red works only with red numbers");
};
Red.prototype._verify2 = function _verify2(a, b) {
assert((a.negative | b.negative) === 0, "red works only with positives");
assert(a.red && a.red === b.red, "red works only with red numbers");
};
Red.prototype.imod = function imod(a) {
if (this.prime) return this.prime.ireduce(a)._forceRed(this);
return a.umod(this.m)._forceRed(this);
};
Red.prototype.neg = function neg(a) {
if (a.isZero()) return a.clone();
return this.m.sub(a)._forceRed(this);
};
Red.prototype.add = function add(a, b) {
this._verify2(a, b);
var res = a.add(b);
if (res.cmp(this.m) >= 0) res.isub(this.m);
return res._forceRed(this);
};
Red.prototype.iadd = function iadd(a, b) {
this._verify2(a, b);
var res = a.iadd(b);
if (res.cmp(this.m) >= 0) res.isub(this.m);
return res;
};
Red.prototype.sub = function sub(a, b) {
this._verify2(a, b);
var res = a.sub(b);
if (res.cmpn(0) < 0) res.iadd(this.m);
return res._forceRed(this);
};
Red.prototype.isub = function isub(a, b) {
this._verify2(a, b);
var res = a.isub(b);
if (res.cmpn(0) < 0) res.iadd(this.m);
return res;
};
Red.prototype.shl = function shl(a, num) {
this._verify1(a);
return this.imod(a.ushln(num));
};
Red.prototype.imul = function imul(a, b) {
this._verify2(a, b);
return this.imod(a.imul(b));
};
Red.prototype.mul = function mul(a, b) {
this._verify2(a, b);
return this.imod(a.mul(b));
};
Red.prototype.isqr = function isqr(a) {
return this.imul(a, a.clone());
};
Red.prototype.sqr = function sqr(a) {
return this.mul(a, a);
};
Red.prototype.sqrt = function sqrt(a) {
if (a.isZero()) return a.clone();
var mod3 = this.m.andln(3);
assert(mod3 % 2 === 1);
if (mod3 === 3) {
var pow = this.m.add(new BN(1)).iushrn(2);
return this.pow(a, pow);
}
var q = this.m.subn(1);
var s = 0;
while (!q.isZero() && q.andln(1) === 0) {
s++;
q.iushrn(1);
}
assert(!q.isZero());
var one = new BN(1).toRed(this);
var nOne = one.redNeg();
var lpow = this.m.subn(1).iushrn(1);
var z = this.m.bitLength();
z = new BN(2 * z * z).toRed(this);
while (this.pow(z, lpow).cmp(nOne) !== 0) z.redIAdd(nOne);
var c = this.pow(z, q);
var r = this.pow(a, q.addn(1).iushrn(1));
var t = this.pow(a, q);
var m = s;
while (t.cmp(one) !== 0) {
var tmp = t;
for (var i = 0; tmp.cmp(one) !== 0; i++) tmp = tmp.redSqr();
assert(i < m);
var b = this.pow(c, new BN(1).iushln(m - i - 1));
r = r.redMul(b);
c = b.redSqr();
t = t.redMul(c);
m = i;
}
return r;
};
Red.prototype.invm = function invm(a) {
var inv = a._invmp(this.m);
if (inv.negative !== 0) {
inv.negative = 0;
return this.imod(inv).redNeg();
} else return this.imod(inv);
};
Red.prototype.pow = function pow(a, num) {
if (num.isZero()) return new BN(1).toRed(this);
if (num.cmpn(1) === 0) return a.clone();
var windowSize = 4;
var wnd = new Array(1 << windowSize);
wnd[0] = new BN(1).toRed(this);
wnd[1] = a;
for (var 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 r = num.umod(this.m);
return r === num ? r.clone() : r;
};
Red.prototype.convertFrom = function convertFrom(num) {
var res = num.clone();
res.red = null;
return res;
};
BN.mont = function mont(num) {
return new Mont(num);
};
function Mont(m) {
Red.call(this, m);
this.shift = this.m.bitLength();
if (this.shift % 26 !== 0) this.shift += 26 - this.shift % 26;
this.r = new BN(1).iushln(this.shift);
this.r2 = this.imod(this.r.sqr());
this.rinv = this.r._invmp(this.m);
this.minv = this.rinv.mul(this.r).isubn(1).div(this.m);
this.minv = this.minv.umod(this.r);
this.minv = this.r.sub(this.minv);
}
inherits(Mont, Red);
Mont.prototype.convertTo = function convertTo(num) {
return this.imod(num.ushln(this.shift));
};
Mont.prototype.convertFrom = function convertFrom(num) {
var r = this.imod(num.mul(this.rinv));
r.red = null;
return r;
};
Mont.prototype.imul = function imul(a, b) {
if (a.isZero() || b.isZero()) {
a.words[0] = 0;
a.length = 1;
return a;
}
var t = a.imul(b);
var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
var u = t.isub(c).iushrn(this.shift);
var res = u;
if (u.cmp(this.m) >= 0) res = u.isub(this.m);
else if (u.cmpn(0) < 0) res = u.iadd(this.m);
return res._forceRed(this);
};
Mont.prototype.mul = function mul(a, b) {
if (a.isZero() || b.isZero()) return new BN(0)._forceRed(this);
var t = a.mul(b);
var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
var u = t.isub(c).iushrn(this.shift);
var res = u;
if (u.cmp(this.m) >= 0) res = u.isub(this.m);
else if (u.cmpn(0) < 0) res = u.iadd(this.m);
return res._forceRed(this);
};
Mont.prototype.invm = function invm(a) {
return this.imod(a._invmp(this.m).mul(this.r2))._forceRed(this);
};
})(typeof module === "undefined" || module, exports);
}));
//#endregion
//#region node_modules/vm-browserify/index.js
var require_vm_browserify = /* @__PURE__ */ __commonJSMin(((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 key in obj) res.push(key);
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, name, value) {
Object.defineProperty(obj, name, {
writable: true,
enumerable: false,
configurable: true,
value
});
};
} catch (e) {
return function(obj, name, value) {
obj[name] = value;
};
}
}();
var globals = [
"Array",
"Boolean",
"Date",
"Error",
"EvalError",
"Function",
"Infinity",
"JSON",
"Math",
"NaN",
"Number",
"Object",
"RangeError",
"ReferenceError",
"RegExp",
"String",
"SyntaxError",
"TypeError",
"URIError",
"decodeURI",
"decodeURIComponent",
"encodeURI",
"encodeURIComponent",
"escape",
"eval",
"isFinite",
"isNaN",
"parseFloat",
"parseInt",
"undefined",
"unescape"
];
function Context() {}
Context.prototype = {};
var Script = exports.Script = function NodeScript(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(key) {
win[key] = context[key];
});
forEach(globals, function(key) {
if (context[key]) win[key] = context[key];
});
var winKeys = Object_keys(win);
var res = wEval.call(win, this.code);
forEach(Object_keys(win), function(key) {
if (key in context || indexOf(winKeys, key) === -1) context[key] = win[key];
});
forEach(globals, function(key) {
if (!(key in context)) defineProp(context, key, win[key]);
});
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(key) {
context[key] = ctx[key];
});
return res;
};
forEach(Object_keys(Script.prototype), function(name) {
exports[name] = Script[name] = function(code) {
var s = Script(code);
return s[name].apply(s, [].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(key) {
copy[key] = context[key];
});
return copy;
};
}));
//#endregion
//#region node_modules/parse-asn1/node_modules/asn1.js/lib/asn1/api.js
var require_api = /* @__PURE__ */ __commonJSMin(((exports) => {
var asn1 = require_asn1$1();
var inherits = require_inherits_browser();
var api = exports;
api.define = function define(name, body) {
return new Entity(name, body);
};
function Entity(name, body) {
this.name = name;
this.body = body;
this.decoders = {};
this.encoders = {};
}
Entity.prototype._createNamed = function createNamed(base) {
var named;
try {
named = require_vm_browserify().runInThisContext("(function " + this.name + "(entity) {\n this._initNamed(entity);\n})");
} catch (e) {
named = function(entity) {
this._initNamed(entity);
};
}
inherits(named, base);
named.prototype._initNamed = function initnamed(entity) {
base.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(asn1.decoders[enc]);
return this.decoders[enc];
};
Entity.prototype.decode = function decode(data, enc, options) {
return this._getDecoder(enc).decode(data, options);
};
Entity.prototype._getEncoder = function _getEncoder(enc) {
enc = enc || "der";
if (!this.encoders.hasOwnProperty(enc)) this.encoders[enc] = this._createNamed(asn1.encoders[enc]);
return this.encoders[enc];
};
Entity.prototype.encode = function encode(data, enc, reporter) {
return this._getEncoder(enc).encode(data, reporter);
};
}));
//#endregion
//#region node_modules/parse-asn1/node_modules/asn1.js/lib/asn1/base/reporter.js
var require_reporter = /* @__PURE__ */ __commonJSMin(((exports) => {
var inherits = require_inherits_browser();
function Reporter(options) {
this._reporterState = {
obj: null,
path: [],
options: options || {},
errors: []
};
}
exports.Reporter = Reporter;
Reporter.prototype.isError = function isError(obj) {
return obj instanceof ReporterError;
};
Reporter.prototype.save = function save() {
var state = this._reporterState;
return {
obj: state.obj,
pathLen: state.path.length
};
};
Reporter.prototype.restore = function restore(data) {
var state = this._reporterState;
state.obj = data.obj;
state.path = state.path.slice(0, data.pathLen);
};
Reporter.prototype.enterKey = function enterKey(key) {
return this._reporterState.path.push(key);
};
Reporter.prototype.exitKey = function exitKey(index) {
var state = this._reporterState;
state.path = state.path.slice(0, index - 1);
};
Reporter.prototype.leaveKey = function leaveKey(index, key, value) {
var state = this._reporterState;
this.exitKey(index);
if (state.obj !== null) state.obj[key] = value;
};
Reporter.prototype.path = function path() {
return this._reporterState.path.join("/");
};
Reporter.prototype.enterObject = function enterObject() {
var state = this._reporterState;
var prev = state.obj;
state.obj = {};
return prev;
};
Reporter.prototype.leaveObject = function leaveObject(prev) {
var state = this._reporterState;
var now = state.obj;
state.obj = prev;
return now;
};
Reporter.prototype.error = function error(msg) {
var err;
var state = this._reporterState;
var inherited = msg instanceof ReporterError;
if (inherited) err = msg;
else err = new ReporterError(state.path.map(function(elem) {
return "[" + JSON.stringify(elem) + "]";
}).join(""), msg.message || msg, msg.stack);
if (!state.options.partial) throw err;
if (!inherited) state.errors.push(err);
return err;
};
Reporter.prototype.wrapResult = function wrapResult(result) {
var state = this._reporterState;
if (!state.options.partial) return result;
return {
result: this.isError(result) ? null : result,
errors: state.errors
};
};
function ReporterError(path, msg) {
this.path = path;
this.rethrow(msg);
}
inherits(ReporterError, Error);
ReporterError.prototype.rethrow = function rethrow(msg) {
this.message = msg + " at: " + (this.path || "(shallow)");
if (Error.captureStackTrace) Error.captureStackTrace(this, ReporterError);
if (!this.stack) try {
throw new Error(this.message);
} catch (e) {
this.stack = e.stack;
}
return this;
};
}));
//#endregion
//#region node_modules/parse-asn1/node_modules/asn1.js/lib/asn1/base/buffer.js
var require_buffer = /* @__PURE__ */ __commonJSMin(((exports) => {
var inherits = require_inherits_browser();
var Reporter = require_base().Reporter;
var Buffer = require_dist().Buffer;
function DecoderBuffer(base, options) {
Reporter.call(this, options);
if (!Buffer.isBuffer(base)) {
this.error("Input not Buffer");
return;
}
this.base = base;
this.offset = 0;
this.length = base.length;
}
inherits(DecoderBuffer, Reporter);
exports.DecoderBuffer = DecoderBuffer;
DecoderBuffer.prototype.save = function save() {
return {
offset: this.offset,
reporter: Reporter.prototype.save.call(this)
};
};
DecoderBuffer.prototype.restore = function restore(save) {
var res = new DecoderBuffer(this.base);
res.offset = save.offset;
res.length = this.offset;
this.offset = save.offset;
Reporter.prototype.restore.call(this, save.reporter);
return res;
};
DecoderBuffer.prototype.isEmpty = function isEmpty() {
return this.offset === this.length;
};
DecoderBuffer.prototype.readUInt8 = function readUInt8(fail) {
if (this.offset + 1 <= this.length) return this.base.readUInt8(this.offset++, true);
else return this.error(fail || "DecoderBuffer overrun");
};
DecoderBuffer.prototype.skip = function skip(bytes, fail) {
if (!(this.offset + bytes <= this.length)) return this.error(fail || "DecoderBuffer overrun");
var res = new DecoderBuffer(this.base);
res._reporterState = this._reporterState;
res.offset = this.offset;
res.length = this.offset + bytes;
this.offset += bytes;
return res;
};
DecoderBuffer.prototype.raw = function raw(save) {
return this.base.slice(save ? save.offset : this.offset, this.length);
};
function EncoderBuffer(value, reporter) {
if (Array.isArray(value)) {
this.length = 0;
this.value = value.map(function(item) {
if (!(item instanceof EncoderBuffer)) item = new EncoderBuffer(item, reporter);
this.length += item.length;
return item;
}, this);
} else if (typeof value === "number") {
if (!(0 <= value && value <= 255)) return reporter.error("non-byte EncoderBuffer value");
this.value = value;
this.length = 1;
} else if (typeof value === "string") {
this.value = value;
this.length = Buffer.byteLength(value);
} else if (Buffer.isBuffer(value)) {
this.value = value;
this.length = value.length;
} else return reporter.error("Unsupported type: " + typeof value);
}
exports.EncoderBuffer = EncoderBuffer;
EncoderBuffer.prototype.join = function join(out, offset) {
if (!out) out = new Buffer(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 (Buffer.isBuffer(this.value)) this.value.copy(out, offset);
offset += this.length;
}
return out;
};
}));
//#endregion
//#region node_modules/parse-asn1/node_modules/asn1.js/lib/asn1/base/node.js
var require_node = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var Reporter = require_base().Reporter;
var EncoderBuffer = require_base().EncoderBuffer;
var DecoderBuffer = require_base().DecoderBuffer;
var assert = require_minimalistic_assert();
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 state = {};
this._baseState = state;
state.enc = enc;
state.parent = parent || null;
state.children = null;
state.tag = null;
state.args = null;
state.reverseArgs = null;
state.choice = null;
state.optional = false;
state.any = false;
state.obj = false;
state.use = null;
state.useDecoder = null;
state.key = null;
state["default"] = null;
state.explicit = null;
state.implicit = null;
state.contains = null;
if (!state.parent) {
state.children = [];
this._wrap();
}
}
module.exports = 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 state = this._baseState;
var cstate = {};
stateProps.forEach(function(prop) {
cstate[prop] = state[prop];
});
var res = new this.constructor(cstate.parent);
res._baseState = cstate;
return res;
};
Node.prototype._wrap = function wrap() {
var state = this._baseState;
methods.forEach(function(method) {
this[method] = function _wrappedMethod() {
var clone = new this.constructor(this);
state.children.push(clone);
return clone[method].apply(clone, arguments);
};
}, this);
};
Node.prototype._init = function init(body) {
var state = this._baseState;
assert(state.parent === null);
body.call(this);
state.children = state.children.filter(function(child) {
return child._baseState.parent === this;
}, this);
assert.equal(state.children.length, 1, "Root node can have only one child");
};
Node.prototype._useArgs = function useArgs(args) {
var state = this._baseState;
var children = args.filter(function(arg) {
return arg instanceof this.constructor;
}, this);
args = args.filter(function(arg) {
return !(arg instanceof this.constructor);
}, this);
if (children.length !== 0) {
assert(state.children === null);
state.children = children;
children.forEach(function(child) {
child._baseState.parent = this;
}, this);
}
if (args.length !== 0) {
assert(state.args === null);
state.args = args;
state.reverseArgs = args.map(function(arg) {
if (typeof arg !== "object" || arg.constructor !== Object) return arg;
var res = {};
Object.keys(arg).forEach(function(key) {
if (key == (key | 0)) key |= 0;
var value = arg[key];
res[value] = key;
});
return res;
});
}
};
overrided.forEach(function(method) {
Node.prototype[method] = function _overrided() {
var state = this._baseState;
throw new Error(method + " not implemented for encoding: " + state.enc);
};
});
tags.forEach(function(tag) {
Node.prototype[tag] = function _tagMethod() {
var state = this._baseState;
var args = Array.prototype.slice.call(arguments);
assert(state.tag === null);
state.tag = tag;
this._useArgs(args);
return this;
};
});
Node.prototype.use = function use(item) {
assert(item);
var state = this._baseState;
assert(state.use === null);
state.use = item;
return this;
};
Node.prototype.optional = function optional() {
var state = this._baseState;
state.optional = true;
return this;
};
Node.prototype.def = function def(val) {
var state = this._baseState;
assert(state["default"] === null);
state["default"] = val;
state.optional = true;
return this;
};
Node.prototype.explicit = function explicit(num) {
var state = this._baseState;
assert(state.explicit === null && state.implicit === null);
state.explicit = num;
return this;
};
Node.prototype.implicit = function implicit(num) {
var state = this._baseState;
assert(state.explicit === null && state.implicit === null);
state.implicit = num;
return this;
};
Node.prototype.obj = function obj() {
var state = this._baseState;
var args = Array.prototype.slice.call(arguments);
state.obj = true;
if (args.length !== 0) this._useArgs(args);
return this;
};
Node.prototype.key = function key(newKey) {
var state = this._baseState;
assert(state.key === null);
state.key = newKey;
return this;
};
Node.prototype.any = function any() {
var state = this._baseState;
state.any = true;
return this;
};
Node.prototype.choice = function choice(obj) {
var state = this._baseState;
assert(state.choice === null);
state.choice = obj;
this._useArgs(Object.keys(obj).map(function(key) {
return obj[key];
}));
return this;
};
Node.prototype.contains = function contains(item) {
var state = this._baseState;
assert(state.use === null);
state.contains = item;
return this;
};
Node.prototype._decode = function decode(input, options) {
var state = this._baseState;
if (state.parent === null) return input.wrapResult(state.children[0]._decode(input, options));
var result = state["default"];
var present = true;
var prevKey = null;
if (state.key !== null) prevKey = input.enterKey(state.key);
if (state.optional) {
var tag = null;
if (state.explicit !== null) tag = state.explicit;
else if (state.implicit !== null) tag = state.implicit;
else if (state.tag !== null) tag = state.tag;
if (tag === null && !state.any) {
var save = input.save();
try {
if (state.choice === null) this._decodeGeneric(state.tag, input, options);
else this._decodeChoice(input, options);
present = true;
} catch (e) {
present = false;
}
input.restore(save);
} else {
present = this._peekTag(input, tag, state.any);
if (input.isError(present)) return present;
}
}
var prevObj;
if (state.obj && present) prevObj = input.enterObject();
if (present) {
if (state.explicit !== null) {
var explicit = this._decodeTag(input, state.explicit);
if (input.isError(explicit)) return explicit;
input = explicit;
}
var start = input.offset;
if (state.use === null && state.choice === null) {
if (state.any) var save = input.save();
var body = this._decodeTag(input, state.implicit !== null ? state.implicit : state.tag, state.any);
if (input.isError(body)) return body;
if (state.any) result = input.raw(save);
else input = body;
}
if (options && options.track && state.tag !== null) options.track(input.path(), start, input.length, "tagged");
if (options && options.track && state.tag !== null) options.track(input.path(), input.offset, input.length, "content");
if (state.any) result = result;
else if (state.choice === null) result = this._decodeGeneric(state.tag, input, options);
else result = this._decodeChoice(input, options);
if (input.isError(result)) return result;
if (!state.any && state.choice === null && state.children !== null) state.children.forEach(function decodeChildren(child) {
child._decode(input, options);
});
if (state.contains && (state.tag === "octstr" || state.tag === "bitstr")) {
var data = new DecoderBuffer(result);
result = this._getUse(state.contains, input._reporterState.obj)._decode(data, options);
}
}
if (state.obj && present) result = input.leaveObject(prevObj);
if (state.key !== null && (result !== null || present === true)) input.leaveKey(prevKey, state.key, result);
else if (prevKey !== null) input.exitKey(prevKey);
return result;
};
Node.prototype._decodeGeneric = function decodeGeneric(tag, input, options) {
var state = this._baseState;
if (tag === "seq" || tag === "set") return null;
if (tag === "seqof" || tag === "setof") return this._decodeList(input, tag, state.args[0], options);
else if (/str$/.test(tag)) return this._decodeStr(input, tag, options);
else if (tag === "objid" && state.args) return this._decodeObjid(input, state.args[0], state.args[1], options);
else if (tag === "objid") return this._decodeObjid(input, null, null, options);
else if (tag === "gentime" || tag === "utctime") return this._decodeTime(input, tag, options);
else if (tag === "null_") return this._decodeNull(input, options);
else if (tag === "bool") return this._decodeBool(input, options);
else if (tag === "objDesc") return this._decodeStr(input, tag, options);
else if (tag === "int" || tag === "enum") return this._decodeInt(input, state.args && state.args[0], options);
if (state.use !== null) return this._getUse(state.use, input._reporterState.obj)._decode(input, options);
else return input.error("unknown tag: " + tag);
};
Node.prototype._getUse = function _getUse(entity, obj) {
var state = this._baseState;
state.useDecoder = this._use(entity, obj);
assert(state.useDecoder._baseState.parent === null);
state.useDecoder = state.useDecoder._baseState.children[0];
if (state.implicit !== state.useDecoder._baseState.implicit) {
state.useDecoder = state.useDecoder.clone();
state.useDecoder._baseState.implicit = state.implicit;
}
return state.useDecoder;
};
Node.prototype._decodeChoice = function decodeChoice(input, options) {
var state = this._baseState;
var result = null;
var match = false;
Object.keys(state.choice).some(function(key) {
var save = input.save();
var node = state.choice[key];
try {
var value = node._decode(input, options);
if (input.isError(value)) return false;
result = {
type: key,
value
};
match = true;
} catch (e) {
input.restore(save);
return false;
}
return true;
}, this);
if (!match) return input.error("Choice not matched");
return result;
};
Node.prototype._createEncoderBuffer = function createEncoderBuffer(data) {
return new EncoderBuffer(data, this.reporter);
};
Node.prototype._encode = function encode(data, reporter, parent) {
var state = this._baseState;
if (state["default"] !== null && state["default"] === data) return;
var result = this._encodeValue(data, reporter, parent);
if (result === void 0) return;
if (this._skipDefault(result, reporter, parent)) return;
return result;
};
Node.prototype._encodeValue = function encode(data, reporter, parent) {
var state = this._baseState;
if (state.parent === null) return state.children[0]._encode(data, reporter || new Reporter());
var result = null;
this.reporter = reporter;
if (state.optional && data === void 0) if (state["default"] !== null) data = state["default"];
else return;
var content = null;
var primitive = false;
if (state.any) result = this._createEncoderBuffer(data);
else if (state.choice) result = this._encodeChoice(data, reporter);
else if (state.contains) {
content = this._getUse(state.contains, parent)._encode(data, reporter);
primitive = true;
} else if (state.children) {
content = state.children.map(function(child) {
if (child._baseState.tag === "null_") return child._encode(null, reporter, data);
if (child._baseState.key === null) return reporter.error("Child should have a key");
var prevKey = reporter.enterKey(child._baseState.key);
if (typeof data !== "object") return reporter.error("Child expected, but input is not object");
var res = child._encode(data[child._baseState.key], reporter, data);
reporter.leaveKey(prevKey);
return res;
}, this).filter(function(child) {
return child;
});
content = this._createEncoderBuffer(content);
} else if (state.tag === "seqof" || state.tag === "setof") {
if (!(state.args && state.args.length === 1)) return reporter.error("Too many args for : " + state.tag);
if (!Array.isArray(data)) return reporter.error("seqof/setof, but data is not Array");
var child = this.clone();
child._baseState.implicit = null;
content = this._createEncoderBuffer(data.map(function(item) {
var state = this._baseState;
return this._getUse(state.args[0], data)._encode(item, reporter);
}, child));
} else if (state.use !== null) result = this._getUse(state.use, parent)._encode(data, reporter);
else {
content = this._encodePrimitive(state.tag, data);
primitive = true;
}
var result;
if (!state.any && state.choice === null) {
var tag = state.implicit !== null ? state.implicit : state.tag;
var cls = state.implicit === null ? "universal" : "context";
if (tag === null) {
if (state.use === null) reporter.error("Tag could be omitted only for .use()");
} else if (state.use === null) result = this._encodeComposite(tag, primitive, cls, content);
}
if (state.explicit !== null) result = this._encodeComposite(state.explicit, false, "context", result);
return result;
};
Node.prototype._encodeChoice = function encodeChoice(data, reporter) {
var state = this._baseState;
var node = state.choice[data.type];
if (!node) assert(false, data.type + " not found in " + JSON.stringify(Object.keys(state.choice)));
return node._encode(data.value, reporter);
};
Node.prototype._encodePrimitive = function encodePrimitive(tag, data) {
var state = this._baseState;
if (/str$/.test(tag)) return this._encodeStr(data, tag);
else if (tag === "objid" && state.args) return this._encodeObjid(data, state.reverseArgs[0], state.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, state.args && state.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);
};
}));
//#endregion
//#region node_modules/parse-asn1/node_modules/asn1.js/lib/asn1/base/index.js
var require_base = /* @__PURE__ */ __commonJSMin(((exports) => {
var base = exports;
base.Reporter = require_reporter().Reporter;
base.DecoderBuffer = require_buffer().DecoderBuffer;
base.EncoderBuffer = require_buffer().EncoderBuffer;
base.Node = require_node();
}));
//#endregion
//#region node_modules/parse-asn1/node_modules/asn1.js/lib/asn1/constants/der.js
var require_der$2 = /* @__PURE__ */ __commonJSMin(((exports) => {
var constants = require_constants();
exports.tagClass = {
0: "universal",
1: "application",
2: "context",
3: "private"
};
exports.tagClassByName = constants._reverse(exports.tagClass);
exports.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"
};
exports.tagByName = constants._reverse(exports.tag);
}));
//#endregion
//#region node_modules/parse-asn1/node_modules/asn1.js/lib/asn1/constants/index.js
var require_constants = /* @__PURE__ */ __commonJSMin(((exports) => {
var constants = exports;
constants._reverse = function reverse(map) {
var res = {};
Object.keys(map).forEach(function(key) {
if ((key | 0) == key) key = key | 0;
var value = map[key];
res[value] = key;
});
return res;
};
constants.der = require_der$2();
}));
//#endregion
//#region node_modules/parse-asn1/node_modules/asn1.js/lib/asn1/decoders/der.js
var require_der$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var inherits = require_inherits_browser();
var asn1 = require_asn1$1();
var base = asn1.base;
var bignum = asn1.bignum;
var der = asn1.constants.der;
function DERDecoder(entity) {
this.enc = "der";
this.name = entity.name;
this.entity = entity;
this.tree = new DERNode();
this.tree._init(entity.body);
}
module.exports = DERDecoder;
DERDecoder.prototype.decode = function decode(data, options) {
if (!(data instanceof base.DecoderBuffer)) data = new base.DecoderBuffer(data, options);
return this.tree._decode(data, options);
};
function DERNode(parent) {
base.Node.call(this, "der", parent);
}
inherits(DERNode, base.Node);
DERNode.prototype._peekTag = function peekTag(buffer, tag, any) {
if (buffer.isEmpty()) return false;
var state = buffer.save();
var decodedTag = derDecodeTag(buffer, "Failed to peek tag: \"" + tag + "\"");
if (buffer.isError(decodedTag)) return decodedTag;
buffer.restore(state);
return decodedTag.tag === tag || decodedTag.tagStr === tag || decodedTag.tagStr + "of" === tag || any;
};
DERNode.prototype._decodeTag = function decodeTag(buffer, tag, any) {
var decodedTag = derDecodeTag(buffer, "Failed to decode tag of \"" + tag + "\"");
if (buffer.isError(decodedTag)) return decodedTag;
var len = derDecodeLen(buffer, decodedTag.primitive, "Failed to get length of \"" + tag + "\"");
if (buffer.isError(len)) return len;
if (!any && decodedTag.tag !== tag && decodedTag.tagStr !== tag && decodedTag.tagStr + "of" !== tag) return buffer.error("Failed to match tag: \"" + tag + "\"");
if (decodedTag.primitive || len !== null) return buffer.skip(len, "Failed to match body of: \"" + tag + "\"");
var state = buffer.save();
var res = this._skipUntilEnd(buffer, "Failed to skip indefinite length body: \"" + this.tag + "\"");
if (buffer.isError(res)) return res;
len = buffer.offset - state.offset;
buffer.restore(state);
return buffer.skip(len, "Failed to match body of: \"" + tag + "\"");
};
DERNode.prototype._skipUntilEnd = function skipUntilEnd(buffer, fail) {
while (true) {
var tag = derDecodeTag(buffer, fail);
if (buffer.isError(tag)) return tag;
var len = derDecodeLen(buffer, tag.primitive, fail);
if (buffer.isError(len)) return len;
var res;
if (tag.primitive || len !== null) res = buffer.skip(len);
else res = this._skipUntilEnd(buffer, fail);
if (buffer.isError(res)) return res;
if (tag.tagStr === "end") break;
}
};
DERNode.prototype._decodeList = function decodeList(buffer, tag, decoder, options) {
var result = [];
while (!buffer.isEmpty()) {
var possibleEnd = this._peekTag(buffer, "end");
if (buffer.isError(possibleEnd)) return possibleEnd;
var res = decoder.decode(buffer, "der", options);
if (buffer.isError(res) && possibleEnd) break;
result.push(res);
}
return result;
};
DERNode.prototype._decodeStr = function decodeStr(buffer, tag) {
if (tag === "bitstr") {
var unused = buffer.readUInt8();
if (buffer.isError(unused)) return unused;
return {
unused,
data: buffer.raw()
};
} else if (tag === "bmpstr") {
var raw = buffer.raw();
if (raw.length % 2 === 1) return buffer.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 = buffer.raw().toString("ascii");
if (!this._isNumstr(numstr)) return buffer.error("Decoding of string type: numstr unsupported characters");
return numstr;
} else if (tag === "octstr") return buffer.raw();
else if (tag === "objDesc") return buffer.raw();
else if (tag === "printstr") {
var printstr = buffer.raw().toString("ascii");
if (!this._isPrintstr(printstr)) return buffer.error("Decoding of string type: printstr unsupported characters");
return printstr;
} else if (/str$/.test(tag)) return buffer.raw().toString();
else return buffer.error("Decoding of string type: " + tag + " unsupported");
};
DERNode.prototype._decodeObjid = function decodeObjid(buffer, values, relative) {
var result;
var identifiers = [];
var ident = 0;
while (!buffer.isEmpty()) {
var subident = buffer.readUInt8();
ident <<= 7;
ident |= subident & 127;
if ((subident & 128) === 0) {
identifiers.push(ident);
ident = 0;
}
}
if (subident & 128) identifiers.push(ident);
var first = identifiers[0] / 40 | 0;
var second = identifiers[0] % 40;
if (relative) result = identifiers;
else result = [first, second].concat(identifiers.slice(1));
if (values) {
var tmp = values[result.join(" ")];
if (tmp === void 0) tmp = values[result.join(".")];
if (tmp !== void 0) result = tmp;
}
return result;
};
DERNode.prototype._decodeTime = function decodeTime(buffer, tag) {
var str = buffer.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 buffer.error("Decoding " + tag + " time is not supported yet");
return Date.UTC(year, mon - 1, day, hour, min, sec, 0);
};
DERNode.prototype._decodeNull = function decodeNull(buffer) {
return null;
};
DERNode.prototype._decodeBool = function decodeBool(buffer) {
var res = buffer.readUInt8();
if (buffer.isError(res)) return res;
else return res !== 0;
};
DERNode.prototype._decodeInt = function decodeInt(buffer, values) {
var res = new bignum(buffer.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 = der.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 = der.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;
}
}));
//#endregion
//#region node_modules/parse-asn1/node_modules/asn1.js/lib/asn1/decoders/pem.js
var require_pem$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var inherits = require_inherits_browser();
var Buffer = require_dist().Buffer;
var DERDecoder = require_der$1();
function PEMDecoder(entity) {
DERDecoder.call(this, entity);
this.enc = "pem";
}
inherits(PEMDecoder, DERDecoder);
module.exports = PEMDecoder;
PEMDecoder.prototype.decode = function decode(data, options) {
var lines = data.toString().split(/[\r\n]+/g);
var label = options.label.toUpperCase();
var re = /^-----(BEGIN|END) ([^-]+)-----$/;
var start = -1;
var end = -1;
for (var i = 0; i < lines.length; i++) {
var match = lines[i].match(re);
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 Buffer(base64, "base64");
return DERDecoder.prototype.decode.call(this, input, options);
};
}));
//#endregion
//#region node_modules/parse-asn1/node_modules/asn1.js/lib/asn1/decoders/index.js
var require_decoders = /* @__PURE__ */ __commonJSMin(((exports) => {
var decoders = exports;
decoders.der = require_der$1();
decoders.pem = require_pem$1();
}));
//#endregion
//#region node_modules/parse-asn1/node_modules/asn1.js/lib/asn1/encoders/der.js
var require_der = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var inherits = require_inherits_browser();
var Buffer = require_dist().Buffer;
var asn1 = require_asn1$1();
var base = asn1.base;
var der = asn1.constants.der;
function DEREncoder(entity) {
this.enc = "der";
this.name = entity.name;
this.entity = entity;
this.tree = new DERNode();
this.tree._init(entity.body);
}
module.exports = DEREncoder;
DEREncoder.prototype.encode = function encode(data, reporter) {
return this.tree._encode(data, reporter).join();
};
function DERNode(parent) {
base.Node.call(this, "der", parent);
}
inherits(DERNode, base.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 Buffer(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 Buffer(2 + 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 Buffer(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, relative) {
if (typeof id === "string") {
if (!values) return this.reporter.error("string objid given, but no values map found");
if (!values.hasOwnProperty(id)) return this.reporter.error("objid not found in values map");
id = values[id].split(/[\s\.]+/g);
for (var 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 (!relative) {
if (id[1] >= 40) return this.reporter.error("Second objid identifier OOB");
id.splice(0, 2, id[0] * 40 + id[1]);
}
var size = 0;
for (var i = 0; i < id.length; i++) {
var ident = id[i];
for (size++; ident >= 128; ident >>= 7) size++;
}
var objid = new Buffer(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 encodeInt(num, values) {
if (typeof num === "string") {
if (!values) return this.reporter.error("String int or enum given, but no values map");
if (!values.hasOwnProperty(num)) return this.reporter.error("Values map doesn't contain: " + JSON.stringify(num));
num = values[num];
}
if (typeof num !== "number" && !Buffer.isBuffer(num)) {
var numArray = num.toArray();
if (!num.sign && numArray[0] & 128) numArray.unshift(0);
num = new Buffer(numArray);
}
if (Buffer.isBuffer(num)) {
var size = num.length;
if (num.length === 0) size++;
var out = new Buffer(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 Buffer(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, reporter, parent) {
var state = this._baseState;
var i;
if (state["default"] === null) return false;
var data = dataBuffer.join();
if (state.defaultBuffer === void 0) state.defaultBuffer = this._encodeValue(state["default"], reporter, parent).join();
if (data.length !== state.defaultBuffer.length) return false;
for (i = 0; i < data.length; i++) if (data[i] !== state.defaultBuffer[i]) return false;
return true;
};
function encodeTag(tag, primitive, cls, reporter) {
var res;
if (tag === "seqof") tag = "seq";
else if (tag === "setof") tag = "set";
if (der.tagByName.hasOwnProperty(tag)) res = der.tagByName[tag];
else if (typeof tag === "number" && (tag | 0) === tag) res = tag;
else return reporter.error("Unknown tag: " + tag);
if (res >= 31) return reporter.error("Multi-octet tag encoding unsupported");
if (!primitive) res |= 32;
res |= der.tagClassByName[cls || "universal"] << 6;
return res;
}
}));
//#endregion
//#region node_modules/parse-asn1/node_modules/asn1.js/lib/asn1/encoders/pem.js
var require_pem = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var inherits = require_inherits_browser();
var DEREncoder = require_der();
function PEMEncoder(entity) {
DEREncoder.call(this, entity);
this.enc = "pem";
}
inherits(PEMEncoder, DEREncoder);
module.exports = PEMEncoder;
PEMEncoder.prototype.encode = function encode(data, options) {
var p = DEREncoder.prototype.encode.call(this, data).toString("base64");
var out = ["-----BEGIN " + options.label + "-----"];
for (var i = 0; i < p.length; i += 64) out.push(p.slice(i, i + 64));
out.push("-----END " + options.label + "-----");
return out.join("\n");
};
}));
//#endregion
//#region node_modules/parse-asn1/node_modules/asn1.js/lib/asn1/encoders/index.js
var require_encoders = /* @__PURE__ */ __commonJSMin(((exports) => {
var encoders = exports;
encoders.der = require_der();
encoders.pem = require_pem();
}));
//#endregion
//#region node_modules/parse-asn1/node_modules/asn1.js/lib/asn1.js
var require_asn1$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
var asn1 = exports;
asn1.bignum = require_bn$2();
asn1.define = require_api().define;
asn1.base = require_base();
asn1.constants = require_constants();
asn1.decoders = require_decoders();
asn1.encoders = require_encoders();
}));
//#endregion
//#region node_modules/parse-asn1/certificate.js
var require_certificate = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var asn = require_asn1$1();
var Time = asn.define("Time", function() {
this.choice({
utcTime: this.utctime(),
generalTime: this.gentime()
});
});
var AttributeTypeValue = asn.define("AttributeTypeValue", function() {
this.seq().obj(this.key("type").objid(), this.key("value").any());
});
var AlgorithmIdentifier = asn.define("AlgorithmIdentifier", function() {
this.seq().obj(this.key("algorithm").objid(), this.key("parameters").optional(), this.key("curve").objid().optional());
});
var SubjectPublicKeyInfo = asn.define("SubjectPublicKeyInfo", function() {
this.seq().obj(this.key("algorithm").use(AlgorithmIdentifier), this.key("subjectPublicKey").bitstr());
});
var RelativeDistinguishedName = asn.define("RelativeDistinguishedName", function() {
this.setof(AttributeTypeValue);
});
var RDNSequence = asn.define("RDNSequence", function() {
this.seqof(RelativeDistinguishedName);
});
var Name = asn.define("Name", function() {
this.choice({ rdnSequence: this.use(RDNSequence) });
});
var Validity = asn.define("Validity", function() {
this.seq().obj(this.key("notBefore").use(Time), this.key("notAfter").use(Time));
});
var Extension = asn.define("Extension", function() {
this.seq().obj(this.key("extnID").objid(), this.key("critical").bool().def(false), this.key("extnValue").octstr());
});
var TBSCertificate = asn.define("TBSCertificate", function() {
this.seq().obj(this.key("version").explicit(0)["int"]().optional(), this.key("serialNumber")["int"](), this.key("signature").use(AlgorithmIdentifier), this.key("issuer").use(Name), this.key("validity").use(Validity), this.key("subject").use(Name), this.key("subjectPublicKeyInfo").use(SubjectPublicKeyInfo), this.key("issuerUniqueID").implicit(1).bitstr().optional(), this.key("subjectUniqueID").implicit(2).bitstr().optional(), this.key("extensions").explicit(3).seqof(Extension).optional());
});
module.exports = asn.define("X509Certificate", function() {
this.seq().obj(this.key("tbsCertificate").use(TBSCertificate), this.key("signatureAlgorithm").use(AlgorithmIdentifier), this.key("signatureValue").bitstr());
});
}));
//#endregion
//#region node_modules/parse-asn1/asn1.js
var require_asn1 = /* @__PURE__ */ __commonJSMin(((exports) => {
var asn1 = require_asn1$1();
exports.certificate = require_certificate();
exports.RSAPrivateKey = asn1.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"]());
});
exports.RSAPublicKey = asn1.define("RSAPublicKey", function() {
this.seq().obj(this.key("modulus")["int"](), this.key("publicExponent")["int"]());
});
var AlgorithmIdentifier = asn1.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());
});
exports.PublicKey = asn1.define("SubjectPublicKeyInfo", function() {
this.seq().obj(this.key("algorithm").use(AlgorithmIdentifier), this.key("subjectPublicKey").bitstr());
});
exports.PrivateKey = asn1.define("PrivateKeyInfo", function() {
this.seq().obj(this.key("version")["int"](), this.key("algorithm").use(AlgorithmIdentifier), this.key("subjectPrivateKey").octstr());
});
exports.EncryptedPrivateKey = asn1.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());
});
exports.DSAPrivateKey = asn1.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"]());
});
exports.DSAparam = asn1.define("DSAparam", function() {
this["int"]();
});
var ECParameters = asn1.define("ECParameters", function() {
this.choice({ namedCurve: this.objid() });
});
exports.ECPrivateKey = asn1.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());
});
exports.signature = asn1.define("signature", function() {
this.seq().obj(this.key("r")["int"](), this.key("s")["int"]());
});
}));
//#endregion
//#region node_modules/parse-asn1/aesid.json
var aesid_exports = /* @__PURE__ */ __exportAll({ default: () => aesid_default });
var aesid_default;
var init_aesid = __esmMin((() => {
aesid_default = {
"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"
};
}));
//#endregion
//#region node_modules/parse-asn1/node_modules/safe-buffer/index.js
var require_safe_buffer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
var buffer = require_dist();
var Buffer = buffer.Buffer;
function copyProps(src, dst) {
for (var key in src) dst[key] = src[key];
}
if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) module.exports = buffer;
else {
copyProps(buffer, exports);
exports.Buffer = SafeBuffer;
}
function SafeBuffer(arg, encodingOrOffset, length) {
return Buffer(arg, encodingOrOffset, length);
}
SafeBuffer.prototype = Object.create(Buffer.prototype);
copyProps(Buffer, SafeBuffer);
SafeBuffer.from = function(arg, encodingOrOffset, length) {
if (typeof arg === "number") throw new TypeError("Argument must not be a number");
return Buffer(arg, encodingOrOffset, length);
};
SafeBuffer.alloc = function(size, fill, encoding) {
if (typeof size !== "number") throw new TypeError("Argument must be a number");
var buf = Buffer(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 Buffer(size);
};
SafeBuffer.allocUnsafeSlow = function(size) {
if (typeof size !== "number") throw new TypeError("Argument must be a number");
return buffer.SlowBuffer(size);
};
}));
//#endregion
//#region node_modules/parse-asn1/fixProc.js
var require_fixProc = /* @__PURE__ */ __commonJSMin(((exports, module) => {
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 = require_evp_bytestokey();
var ciphers = require_browser$7();
var Buffer = require_safe_buffer().Buffer;
module.exports = function(okey, password) {
var key = okey.toString();
var match = key.match(findProc);
var decrypted;
if (!match) {
var match2 = key.match(fullRegex);
decrypted = Buffer.from(match2[2].replace(/[\r\n]/g, ""), "base64");
} else {
var suite = "aes" + match[1];
var iv = Buffer.from(match[2], "hex");
var cipherText = Buffer.from(match[3].replace(/[\r\n]/g, ""), "base64");
var cipherKey = evp(password, iv.slice(0, 8), parseInt(match[1], 10)).key;
var out = [];
var cipher = ciphers.createDecipheriv(suite, cipherKey, iv);
out.push(cipher.update(cipherText));
out.push(cipher["final"]());
decrypted = Buffer.concat(out);
}
return {
tag: key.match(startRegex)[1],
data: decrypted
};
};
}));
//#endregion
//#region node_modules/parse-asn1/index.js
var require_parse_asn1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var asn1 = require_asn1();
var aesid = (init_aesid(), __toCommonJS(aesid_exports).default);
var fixProc = require_fixProc();
var ciphers = require_browser$7();
var compat = require_browser$8();
var Buffer = require_safe_buffer().Buffer;
function decrypt(data, password) {
var salt = data.algorithm.decrypt.kde.kdeparams.salt;
var iters = parseInt(data.algorithm.decrypt.kde.kdeparams.iters.toString(), 10);
var algo = aesid[data.algorithm.decrypt.cipher.algo.join(".")];
var iv = data.algorithm.decrypt.cipher.iv;
var cipherText = data.subjectPrivateKey;
var keylen = parseInt(algo.split("-")[1], 10) / 8;
var key = compat.pbkdf2Sync(password, salt, iters, keylen, "sha1");
var cipher = ciphers.createDecipheriv(algo, key, iv);
var out = [];
out.push(cipher.update(cipherText));
out.push(cipher["final"]());
return Buffer.concat(out);
}
function parseKeys(buffer) {
var password;
if (typeof buffer === "object" && !Buffer.isBuffer(buffer)) {
password = buffer.passphrase;
buffer = buffer.key;
}
if (typeof buffer === "string") buffer = Buffer.from(buffer);
var stripped = fixProc(buffer, password);
var type = stripped.tag;
var data = stripped.data;
var subtype, ndata;
switch (type) {
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(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 " + type);
}
}
parseKeys.signature = asn1.signature;
module.exports = parseKeys;
}));
//#endregion
//#region node_modules/browserify-sign/browser/curves.json
var curves_exports = /* @__PURE__ */ __exportAll({ default: () => curves_default });
var curves_default;
var init_curves = __esmMin((() => {
curves_default = {
"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"
};
}));
//#endregion
//#region node_modules/browserify-sign/browser/sign.js
var require_sign = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var Buffer = require_safe_buffer$3().Buffer;
var createHmac = require_browser$9();
var crt = require_browserify_rsa();
var EC = require_elliptic().ec;
var BN = require_bn$4();
var parseKeys = require_parse_asn1();
var curves = (init_curves(), __toCommonJS(curves_exports).default);
var RSA_PKCS1_PADDING = 1;
function sign(hash, key, hashType, signType, tag) {
var priv = parseKeys(key);
if (priv.curve) {
if (signType !== "ecdsa" && signType !== "ecdsa/rsa") throw new Error("wrong private key type");
return ecSign(hash, priv);
} else if (priv.type === "dsa") {
if (signType !== "dsa") throw new Error("wrong private key type");
return dsaSign(hash, priv, hashType);
}
if (signType !== "rsa" && signType !== "ecdsa/rsa") throw new Error("wrong private key type");
if (key.padding !== void 0 && key.padding !== RSA_PKCS1_PADDING) throw new Error("illegal or unsupported padding mode");
hash = Buffer.concat([tag, hash]);
var len = priv.modulus.byteLength();
var pad = [0, 1];
while (hash.length + pad.length + 1 < len) pad.push(255);
pad.push(0);
var i = -1;
while (++i < hash.length) pad.push(hash[i]);
return crt(pad, priv);
}
function ecSign(hash, priv) {
var curveId = curves[priv.curve.join(".")];
if (!curveId) throw new Error("unknown curve " + priv.curve.join("."));
var out = new EC(curveId).keyFromPrivate(priv.privateKey).sign(hash);
return Buffer.from(out.toDER());
}
function dsaSign(hash, priv, algo) {
var x = priv.params.priv_key;
var p = priv.params.p;
var q = priv.params.q;
var g = priv.params.g;
var r = new BN(0);
var k;
var H = bits2int(hash, q).mod(q);
var s = false;
var kv = getKey(x, q, hash, algo);
while (s === false) {
k = makeKey(q, kv, algo);
r = makeR(g, k, p, q);
s = k.invm(q).imul(H.add(x.mul(r))).mod(q);
if (s.cmpn(0) === 0) {
s = false;
r = new BN(0);
}
}
return toDER(r, s);
}
function toDER(r, s) {
r = r.toArray();
s = s.toArray();
if (r[0] & 128) r = [0].concat(r);
if (s[0] & 128) s = [0].concat(s);
var res = [
48,
r.length + s.length + 4,
2,
r.length
];
res = res.concat(r, [2, s.length], s);
return Buffer.from(res);
}
function getKey(x, q, hash, algo) {
x = Buffer.from(x.toArray());
if (x.length < q.byteLength()) {
var zeros = Buffer.alloc(q.byteLength() - x.length);
x = Buffer.concat([zeros, x]);
}
var hlen = hash.length;
var hbits = bits2octets(hash, q);
var v = Buffer.alloc(hlen);
v.fill(1);
var k = Buffer.alloc(hlen);
k = createHmac(algo, k).update(v).update(Buffer.from([0])).update(x).update(hbits).digest();
v = createHmac(algo, k).update(v).digest();
k = createHmac(algo, k).update(v).update(Buffer.from([1])).update(x).update(hbits).digest();
v = createHmac(algo, k).update(v).digest();
return {
k,
v
};
}
function bits2int(obits, q) {
var bits = new BN(obits);
var shift = (obits.length << 3) - q.bitLength();
if (shift > 0) bits.ishrn(shift);
return bits;
}
function bits2octets(bits, q) {
bits = bits2int(bits, q);
bits = bits.mod(q);
var out = Buffer.from(bits.toArray());
if (out.length < q.byteLength()) {
var zeros = Buffer.alloc(q.byteLength() - out.length);
out = Buffer.concat([zeros, out]);
}
return out;
}
function makeKey(q, kv, algo) {
var t;
var k;
do {
t = Buffer.alloc(0);
while (t.length * 8 < q.bitLength()) {
kv.v = createHmac(algo, kv.k).update(kv.v).digest();
t = Buffer.concat([t, kv.v]);
}
k = bits2int(t, q);
kv.k = createHmac(algo, kv.k).update(kv.v).update(Buffer.from([0])).digest();
kv.v = createHmac(algo, kv.k).update(kv.v).digest();
} while (k.cmp(q) !== -1);
return k;
}
function makeR(g, k, p, q) {
return g.toRed(BN.mont(p)).redPow(k).fromRed().mod(q);
}
module.exports = sign;
module.exports.getKey = getKey;
module.exports.makeKey = makeKey;
}));
//#endregion
//#region node_modules/browserify-sign/browser/verify.js
var require_verify = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var Buffer = require_safe_buffer$3().Buffer;
var BN = require_bn$4();
var EC = require_elliptic().ec;
var parseKeys = require_parse_asn1();
var curves = (init_curves(), __toCommonJS(curves_exports).default);
function verify(sig, hash, key, signType, tag) {
var pub = parseKeys(key);
if (pub.type === "ec") {
if (signType !== "ecdsa" && signType !== "ecdsa/rsa") throw new Error("wrong public key type");
return ecVerify(sig, hash, pub);
} else if (pub.type === "dsa") {
if (signType !== "dsa") throw new Error("wrong public key type");
return dsaVerify(sig, hash, pub);
}
if (signType !== "rsa" && signType !== "ecdsa/rsa") throw new Error("wrong public key type");
hash = Buffer.concat([tag, hash]);
var len = pub.modulus.byteLength();
var pad = [1];
var padNum = 0;
while (hash.length + pad.length + 2 < len) {
pad.push(255);
padNum += 1;
}
pad.push(0);
var i = -1;
while (++i < hash.length) pad.push(hash[i]);
pad = Buffer.from(pad);
var red = BN.mont(pub.modulus);
sig = new BN(sig).toRed(red);
sig = sig.redPow(new BN(pub.publicExponent));
sig = Buffer.from(sig.fromRed().toArray());
var out = padNum < 8 ? 1 : 0;
len = Math.min(sig.length, pad.length);
if (sig.length !== pad.length) out = 1;
i = -1;
while (++i < len) out |= sig[i] ^ pad[i];
return out === 0;
}
function ecVerify(sig, hash, pub) {
var curveId = curves[pub.data.algorithm.curve.join(".")];
if (!curveId) throw new Error("unknown curve " + pub.data.algorithm.curve.join("."));
var curve = new EC(curveId);
var pubkey = pub.data.subjectPrivateKey.data;
return curve.verify(hash, sig, pubkey);
}
function dsaVerify(sig, hash, pub) {
var p = pub.data.p;
var q = pub.data.q;
var g = pub.data.g;
var y = pub.data.pub_key;
var unpacked = parseKeys.signature.decode(sig, "der");
var s = unpacked.s;
var r = unpacked.r;
checkValue(s, q);
checkValue(r, q);
var montp = BN.mont(p);
var w = s.invm(q);
return g.toRed(montp).redPow(new BN(hash).mul(w).mod(q)).fromRed().mul(y.toRed(montp).redPow(r.mul(w).mod(q)).fromRed()).mod(p).mod(q).cmp(r) === 0;
}
function checkValue(b, q) {
if (b.cmpn(0) <= 0) throw new Error("invalid sig");
if (b.cmp(q) >= 0) throw new Error("invalid sig");
}
module.exports = verify;
}));
//#endregion
//#region node_modules/browserify-sign/browser/index.js
var require_browser$4 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var Buffer = require_safe_buffer$3().Buffer;
var createHash = require_browser$10();
var stream = require_readable_browser();
var inherits = require_inherits_browser();
var sign = require_sign();
var verify = require_verify();
var algorithms = (init_algorithms(), __toCommonJS(algorithms_exports).default);
Object.keys(algorithms).forEach(function(key) {
algorithms[key].id = Buffer.from(algorithms[key].id, "hex");
algorithms[key.toLowerCase()] = algorithms[key];
});
function Sign(algorithm) {
stream.Writable.call(this);
var data = algorithms[algorithm];
if (!data) throw new Error("Unknown message digest");
this._hashType = data.hash;
this._hash = createHash(data.hash);
this._tag = data.id;
this._signType = data.sign;
}
inherits(Sign, stream.Writable);
Sign.prototype._write = function _write(data, _, done) {
this._hash.update(data);
done();
};
Sign.prototype.update = function update(data, enc) {
this._hash.update(typeof data === "string" ? Buffer.from(data, enc) : data);
return this;
};
Sign.prototype.sign = function signMethod(key, enc) {
this.end();
var sig = sign(this._hash.digest(), key, this._hashType, this._signType, this._tag);
return enc ? sig.toString(enc) : sig;
};
function Verify(algorithm) {
stream.Writable.call(this);
var data = algorithms[algorithm];
if (!data) throw new Error("Unknown message digest");
this._hash = createHash(data.hash);
this._tag = data.id;
this._signType = data.sign;
}
inherits(Verify, stream.Writable);
Verify.prototype._write = function _write(data, _, done) {
this._hash.update(data);
done();
};
Verify.prototype.update = function update(data, enc) {
this._hash.update(typeof data === "string" ? Buffer.from(data, enc) : data);
return this;
};
Verify.prototype.verify = function verifyMethod(key, sig, enc) {
var sigBuffer = typeof sig === "string" ? Buffer.from(sig, enc) : sig;
this.end();
return verify(sigBuffer, this._hash.digest(), key, this._signType, this._tag);
};
function createSign(algorithm) {
return new Sign(algorithm);
}
function createVerify(algorithm) {
return new Verify(algorithm);
}
module.exports = {
Sign: createSign,
Verify: createVerify,
createSign,
createVerify
};
}));
//#endregion
//#region node_modules/create-ecdh/node_modules/bn.js/lib/bn.js
var require_bn$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
(function(module$2, exports$2) {
"use strict";
function assert(val, msg) {
if (!val) throw new Error(msg || "Assertion failed");
}
function inherits(ctor, superCtor) {
ctor.super_ = superCtor;
var TempCtor = function() {};
TempCtor.prototype = superCtor.prototype;
ctor.prototype = new TempCtor();
ctor.prototype.constructor = ctor;
}
function BN(number, base, endian) {
if (BN.isBN(number)) return number;
this.negative = 0;
this.words = null;
this.length = 0;
this.red = null;
if (number !== null) {
if (base === "le" || base === "be") {
endian = base;
base = 10;
}
this._init(number || 0, base || 10, endian || "be");
}
}
if (typeof module$2 === "object") module$2.exports = BN;
else exports$2.BN = BN;
BN.BN = BN;
BN.wordSize = 26;
var Buffer;
try {
if (typeof window !== "undefined" && typeof window.Buffer !== "undefined") Buffer = window.Buffer;
else Buffer = require_dist().Buffer;
} catch (e) {}
BN.isBN = function isBN(num) {
if (num instanceof BN) return true;
return num !== null && typeof num === "object" && num.constructor.wordSize === BN.wordSize && Array.isArray(num.words);
};
BN.max = function max(left, right) {
if (left.cmp(right) > 0) return left;
return right;
};
BN.min = function min(left, right) {
if (left.cmp(right) < 0) return left;
return right;
};
BN.prototype._init = function init(number, base, endian) {
if (typeof number === "number") return this._initNumber(number, base, endian);
if (typeof number === "object") return this._initArray(number, base, endian);
if (base === "hex") base = 16;
assert(base === (base | 0) && base >= 2 && base <= 36);
number = number.toString().replace(/\s+/g, "");
var start = 0;
if (number[0] === "-") {
start++;
this.negative = 1;
}
if (start < number.length) if (base === 16) this._parseHex(number, start, endian);
else {
this._parseBase(number, base, start);
if (endian === "le") this._initArray(this.toArray(), base, endian);
}
};
BN.prototype._initNumber = function _initNumber(number, base, endian) {
if (number < 0) {
this.negative = 1;
number = -number;
}
if (number < 67108864) {
this.words = [number & 67108863];
this.length = 1;
} else if (number < 4503599627370496) {
this.words = [number & 67108863, number / 67108864 & 67108863];
this.length = 2;
} else {
assert(number < 9007199254740992);
this.words = [
number & 67108863,
number / 67108864 & 67108863,
1
];
this.length = 3;
}
if (endian !== "le") return;
this._initArray(this.toArray(), base, endian);
};
BN.prototype._initArray = function _initArray(number, base, endian) {
assert(typeof number.length === "number");
if (number.length <= 0) {
this.words = [0];
this.length = 1;
return this;
}
this.length = Math.ceil(number.length / 3);
this.words = new Array(this.length);
for (var 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 r = parseHex4Bits(string, index);
if (index - 1 >= lowerBound) r |= parseHex4Bits(string, index - 1) << 4;
return r;
}
BN.prototype._parseHex = function _parseHex(number, start, endian) {
this.length = Math.ceil((number.length - start) / 6);
this.words = new Array(this.length);
for (var 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 for (i = (number.length - start) % 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, mul) {
var r = 0;
var len = Math.min(str.length, end);
for (var i = start; i < len; i++) {
var c = str.charCodeAt(i) - 48;
r *= mul;
if (c >= 49) r += c - 49 + 10;
else if (c >= 17) r += c - 17 + 10;
else r += c;
}
return r;
}
BN.prototype._parseBase = function _parseBase(number, base, start) {
this.words = [0];
this.length = 1;
for (var limbLen = 0, limbPow = 1; limbPow <= 67108863; limbPow *= base) limbLen++;
limbLen--;
limbPow = limbPow / base | 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, base);
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, base);
for (i = 0; i < mod; i++) pow *= base;
this.imuln(pow);
if (this.words[0] + word < 67108864) this.words[0] += word;
else this._iaddn(word);
}
this.strip();
};
BN.prototype.copy = function copy(dest) {
dest.words = new Array(this.length);
for (var i = 0; i < this.length; i++) dest.words[i] = this.words[i];
dest.length = this.length;
dest.negative = this.negative;
dest.red = this.red;
};
BN.prototype.clone = function clone() {
var r = new BN(null);
this.copy(r);
return r;
};
BN.prototype._expand = function _expand(size) {
while (this.length < size) this.words[this.length++] = 0;
return this;
};
BN.prototype.strip = function strip() {
while (this.length > 1 && this.words[this.length - 1] === 0) this.length--;
return this._normSign();
};
BN.prototype._normSign = function _normSign() {
if (this.length === 1 && this.words[0] === 0) this.negative = 0;
return this;
};
BN.prototype.inspect = function inspect() {
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
];
BN.prototype.toString = function toString(base, padding) {
base = base || 10;
padding = padding | 0 || 1;
var out;
if (base === 16 || base === "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 (base === (base | 0) && base >= 2 && base <= 36) {
var groupSize = groupSizes[base];
var groupBase = groupBases[base];
out = "";
var c = this.clone();
c.negative = 0;
while (!c.isZero()) {
var r = c.modn(groupBase).toString(base);
c = c.idivn(groupBase);
if (!c.isZero()) out = zeros[groupSize - r.length] + r + out;
else out = r + out;
}
if (this.isZero()) out = "0" + out;
while (out.length % padding !== 0) out = "0" + out;
if (this.negative !== 0) out = "-" + out;
return out;
}
assert(false, "Base should be between 2 and 36");
};
BN.prototype.toNumber = function 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) assert(false, "Number can only safely store up to 53 bits");
return this.negative !== 0 ? -ret : ret;
};
BN.prototype.toJSON = function toJSON() {
return this.toString(16);
};
BN.prototype.toBuffer = function toBuffer(endian, length) {
assert(typeof Buffer !== "undefined");
return this.toArrayLike(Buffer, endian, length);
};
BN.prototype.toArray = function toArray(endian, length) {
return this.toArrayLike(Array, endian, length);
};
BN.prototype.toArrayLike = function toArrayLike(ArrayType, endian, length) {
var byteLength = this.byteLength();
var reqLength = length || Math.max(1, byteLength);
assert(byteLength <= reqLength, "byte array longer than desired length");
assert(reqLength > 0, "Requested array length <= 0");
this.strip();
var littleEndian = endian === "le";
var res = new ArrayType(reqLength);
var b, 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) BN.prototype._countBits = function _countBits(w) {
return 32 - Math.clz32(w);
};
else BN.prototype._countBits = function _countBits(w) {
var t = w;
var r = 0;
if (t >= 4096) {
r += 13;
t >>>= 13;
}
if (t >= 64) {
r += 7;
t >>>= 7;
}
if (t >= 8) {
r += 4;
t >>>= 4;
}
if (t >= 2) {
r += 2;
t >>>= 2;
}
return r + t;
};
BN.prototype._zeroBits = function _zeroBits(w) {
if (w === 0) return 26;
var t = w;
var r = 0;
if ((t & 8191) === 0) {
r += 13;
t >>>= 13;
}
if ((t & 127) === 0) {
r += 7;
t >>>= 7;
}
if ((t & 15) === 0) {
r += 4;
t >>>= 4;
}
if ((t & 3) === 0) {
r += 2;
t >>>= 2;
}
if ((t & 1) === 0) r++;
return r;
};
BN.prototype.bitLength = function bitLength() {
var w = this.words[this.length - 1];
var hi = this._countBits(w);
return (this.length - 1) * 26 + hi;
};
function toBitArray(num) {
var w = new Array(num.bitLength());
for (var bit = 0; bit < w.length; bit++) {
var off = bit / 26 | 0;
var wbit = bit % 26;
w[bit] = (num.words[off] & 1 << wbit) >>> wbit;
}
return w;
}
BN.prototype.zeroBits = function zeroBits() {
if (this.isZero()) return 0;
var r = 0;
for (var i = 0; i < this.length; i++) {
var b = this._zeroBits(this.words[i]);
r += b;
if (b !== 26) break;
}
return r;
};
BN.prototype.byteLength = function byteLength() {
return Math.ceil(this.bitLength() / 8);
};
BN.prototype.toTwos = function toTwos(width) {
if (this.negative !== 0) return this.abs().inotn(width).iaddn(1);
return this.clone();
};
BN.prototype.fromTwos = function fromTwos(width) {
if (this.testn(width - 1)) return this.notn(width).iaddn(1).ineg();
return this.clone();
};
BN.prototype.isNeg = function isNeg() {
return this.negative !== 0;
};
BN.prototype.neg = function neg() {
return this.clone().ineg();
};
BN.prototype.ineg = function ineg() {
if (!this.isZero()) this.negative ^= 1;
return this;
};
BN.prototype.iuor = function iuor(num) {
while (this.length < num.length) this.words[this.length++] = 0;
for (var i = 0; i < num.length; i++) this.words[i] = this.words[i] | num.words[i];
return this.strip();
};
BN.prototype.ior = function ior(num) {
assert((this.negative | num.negative) === 0);
return this.iuor(num);
};
BN.prototype.or = function or(num) {
if (this.length > num.length) return this.clone().ior(num);
return num.clone().ior(this);
};
BN.prototype.uor = function uor(num) {
if (this.length > num.length) return this.clone().iuor(num);
return num.clone().iuor(this);
};
BN.prototype.iuand = function iuand(num) {
var b;
if (this.length > num.length) b = num;
else b = this;
for (var i = 0; i < b.length; i++) this.words[i] = this.words[i] & num.words[i];
this.length = b.length;
return this.strip();
};
BN.prototype.iand = function iand(num) {
assert((this.negative | num.negative) === 0);
return this.iuand(num);
};
BN.prototype.and = function and(num) {
if (this.length > num.length) return this.clone().iand(num);
return num.clone().iand(this);
};
BN.prototype.uand = function uand(num) {
if (this.length > num.length) return this.clone().iuand(num);
return num.clone().iuand(this);
};
BN.prototype.iuxor = function iuxor(num) {
var a;
var b;
if (this.length > num.length) {
a = this;
b = num;
} else {
a = num;
b = this;
}
for (var 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();
};
BN.prototype.ixor = function ixor(num) {
assert((this.negative | num.negative) === 0);
return this.iuxor(num);
};
BN.prototype.xor = function xor(num) {
if (this.length > num.length) return this.clone().ixor(num);
return num.clone().ixor(this);
};
BN.prototype.uxor = function uxor(num) {
if (this.length > num.length) return this.clone().iuxor(num);
return num.clone().iuxor(this);
};
BN.prototype.inotn = function inotn(width) {
assert(typeof width === "number" && width >= 0);
var bytesNeeded = Math.ceil(width / 26) | 0;
var bitsLeft = width % 26;
this._expand(bytesNeeded);
if (bitsLeft > 0) bytesNeeded--;
for (var 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();
};
BN.prototype.notn = function notn(width) {
return this.clone().inotn(width);
};
BN.prototype.setn = function setn(bit, val) {
assert(typeof bit === "number" && bit >= 0);
var off = bit / 26 | 0;
var wbit = bit % 26;
this._expand(off + 1);
if (val) this.words[off] = this.words[off] | 1 << wbit;
else this.words[off] = this.words[off] & ~(1 << wbit);
return this.strip();
};
BN.prototype.iadd = function iadd(num) {
var r;
if (this.negative !== 0 && num.negative === 0) {
this.negative = 0;
r = this.isub(num);
this.negative ^= 1;
return this._normSign();
} else if (this.negative === 0 && num.negative !== 0) {
num.negative = 0;
r = this.isub(num);
num.negative = 1;
return r._normSign();
}
var a, b;
if (this.length > num.length) {
a = this;
b = num;
} else {
a = num;
b = this;
}
var carry = 0;
for (var i = 0; i < b.length; i++) {
r = (a.words[i] | 0) + (b.words[i] | 0) + carry;
this.words[i] = r & 67108863;
carry = r >>> 26;
}
for (; carry !== 0 && i < a.length; i++) {
r = (a.words[i] | 0) + carry;
this.words[i] = r & 67108863;
carry = r >>> 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;
};
BN.prototype.add = function add(num) {
var res;
if (num.negative !== 0 && this.negative === 0) {
num.negative = 0;
res = this.sub(num);
num.negative ^= 1;
return res;
} else if (num.negative === 0 && this.negative !== 0) {
this.negative = 0;
res = num.sub(this);
this.negative = 1;
return res;
}
if (this.length > num.length) return this.clone().iadd(num);
return num.clone().iadd(this);
};
BN.prototype.isub = function isub(num) {
if (num.negative !== 0) {
num.negative = 0;
var r = this.iadd(num);
num.negative = 1;
return r._normSign();
} else if (this.negative !== 0) {
this.negative = 0;
this.iadd(num);
this.negative = 1;
return this._normSign();
}
var cmp = this.cmp(num);
if (cmp === 0) {
this.negative = 0;
this.length = 1;
this.words[0] = 0;
return this;
}
var a, b;
if (cmp > 0) {
a = this;
b = num;
} else {
a = num;
b = this;
}
var carry = 0;
for (var i = 0; i < b.length; i++) {
r = (a.words[i] | 0) - (b.words[i] | 0) + carry;
carry = r >> 26;
this.words[i] = r & 67108863;
}
for (; carry !== 0 && i < a.length; i++) {
r = (a.words[i] | 0) + carry;
carry = r >> 26;
this.words[i] = r & 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();
};
BN.prototype.sub = function sub(num) {
return this.clone().isub(num);
};
function smallMulTo(self, num, out) {
out.negative = num.negative ^ self.negative;
var len = self.length + num.length | 0;
out.length = len;
len = len - 1 | 0;
var a = self.words[0] | 0;
var b = num.words[0] | 0;
var r = a * b;
var lo = r & 67108863;
var carry = r / 67108864 | 0;
out.words[0] = lo;
for (var k = 1; k < 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 - self.length + 1); j <= maxJ; j++) {
var i = k - j | 0;
a = self.words[i] | 0;
b = num.words[j] | 0;
r = a * b + rword;
ncarry += r / 67108864 | 0;
rword = r & 67108863;
}
out.words[k] = rword | 0;
carry = ncarry | 0;
}
if (carry !== 0) out.words[k] = carry | 0;
else out.length--;
return out.strip();
}
var comb10MulTo = function comb10MulTo(self, num, out) {
var a = self.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 = self.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(self, num, out) {
out.negative = num.negative ^ self.negative;
out.length = self.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 - self.length + 1); j <= maxJ; j++) {
var i = k - j;
var r = (self.words[i] | 0) * (num.words[j] | 0);
var lo = r & 67108863;
ncarry = ncarry + (r / 67108864 | 0) | 0;
lo = lo + rword | 0;
rword = lo & 67108863;
ncarry = ncarry + (lo >>> 26) | 0;
hncarry += ncarry >>> 26;
ncarry &= 67108863;
}
out.words[k] = rword;
carry = ncarry;
ncarry = hncarry;
}
if (carry !== 0) out.words[k] = carry;
else out.length--;
return out.strip();
}
function jumboMulTo(self, num, out) {
return new FFTM().mulp(self, num, out);
}
BN.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 = BN.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 permute(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 s = 1; s < N; s <<= 1) {
var l = s << 1;
var rtwdf = Math.cos(2 * Math.PI / l);
var itwdf = Math.sin(2 * Math.PI / l);
for (var p = 0; p < N; p += l) {
var rtwdf_ = rtwdf;
var itwdf_ = itwdf;
for (var j = 0; j < s; j++) {
var re = rtws[p + j];
var ie = itws[p + j];
var ro = rtws[p + j + s];
var io = itws[p + j + s];
var rx = rtwdf_ * ro - itwdf_ * io;
io = rtwdf_ * io + itwdf_ * ro;
ro = rx;
rtws[p + j] = re + ro;
itws[p + j] = ie + io;
rtws[p + j + s] = re - ro;
itws[p + j + s] = ie - io;
if (j !== l) {
rx = rtwdf * rtwdf_ - itwdf * itwdf_;
itwdf_ = rtwdf * itwdf_ + itwdf * rtwdf_;
rtwdf_ = rx;
}
}
}
}
};
FFTM.prototype.guessLen13b = function guessLen13b(n, m) {
var N = Math.max(m, n) | 1;
var odd = N & 1;
var 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;
assert(carry === 0);
assert((carry & -8192) === 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();
};
BN.prototype.mul = function mul(num) {
var out = new BN(null);
out.words = new Array(this.length + num.length);
return this.mulTo(num, out);
};
BN.prototype.mulf = function mulf(num) {
var out = new BN(null);
out.words = new Array(this.length + num.length);
return jumboMulTo(this, num, out);
};
BN.prototype.imul = function imul(num) {
return this.clone().mulTo(num, this);
};
BN.prototype.imuln = function imuln(num) {
assert(typeof num === "number");
assert(num < 67108864);
var carry = 0;
for (var 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;
};
BN.prototype.muln = function muln(num) {
return this.clone().imuln(num);
};
BN.prototype.sqr = function sqr() {
return this.mul(this);
};
BN.prototype.isqr = function isqr() {
return this.imul(this.clone());
};
BN.prototype.pow = function pow(num) {
var w = toBitArray(num);
if (w.length === 0) return new BN(1);
var res = this;
for (var 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;
};
BN.prototype.iushln = function iushln(bits) {
assert(typeof bits === "number" && bits >= 0);
var r = bits % 26;
var s = (bits - r) / 26;
var carryMask = 67108863 >>> 26 - r << 26 - r;
var i;
if (r !== 0) {
var carry = 0;
for (i = 0; i < this.length; i++) {
var newCarry = this.words[i] & carryMask;
var c = (this.words[i] | 0) - newCarry << r;
this.words[i] = c | carry;
carry = newCarry >>> 26 - r;
}
if (carry) {
this.words[i] = carry;
this.length++;
}
}
if (s !== 0) {
for (i = this.length - 1; i >= 0; i--) this.words[i + s] = this.words[i];
for (i = 0; i < s; i++) this.words[i] = 0;
this.length += s;
}
return this.strip();
};
BN.prototype.ishln = function ishln(bits) {
assert(this.negative === 0);
return this.iushln(bits);
};
BN.prototype.iushrn = function iushrn(bits, hint, extended) {
assert(typeof bits === "number" && bits >= 0);
var h;
if (hint) h = (hint - hint % 26) / 26;
else h = 0;
var r = bits % 26;
var s = Math.min((bits - r) / 26, this.length);
var mask = 67108863 ^ 67108863 >>> r << r;
var maskedWords = extended;
h -= s;
h = Math.max(0, h);
if (maskedWords) {
for (var i = 0; i < s; i++) maskedWords.words[i] = this.words[i];
maskedWords.length = s;
}
if (s === 0) {} else if (this.length > s) {
this.length -= s;
for (i = 0; i < this.length; i++) this.words[i] = this.words[i + s];
} 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 - r | word >>> r;
carry = word & mask;
}
if (maskedWords && carry !== 0) maskedWords.words[maskedWords.length++] = carry;
if (this.length === 0) {
this.words[0] = 0;
this.length = 1;
}
return this.strip();
};
BN.prototype.ishrn = function ishrn(bits, hint, extended) {
assert(this.negative === 0);
return this.iushrn(bits, hint, extended);
};
BN.prototype.shln = function shln(bits) {
return this.clone().ishln(bits);
};
BN.prototype.ushln = function ushln(bits) {
return this.clone().iushln(bits);
};
BN.prototype.shrn = function shrn(bits) {
return this.clone().ishrn(bits);
};
BN.prototype.ushrn = function ushrn(bits) {
return this.clone().iushrn(bits);
};
BN.prototype.testn = function testn(bit) {
assert(typeof bit === "number" && bit >= 0);
var r = bit % 26;
var s = (bit - r) / 26;
var q = 1 << r;
if (this.length <= s) return false;
return !!(this.words[s] & q);
};
BN.prototype.imaskn = function imaskn(bits) {
assert(typeof bits === "number" && bits >= 0);
var r = bits % 26;
var s = (bits - r) / 26;
assert(this.negative === 0, "imaskn works only with positive numbers");
if (this.length <= s) return this;
if (r !== 0) s++;
this.length = Math.min(s, this.length);
if (r !== 0) {
var mask = 67108863 ^ 67108863 >>> r << r;
this.words[this.length - 1] &= mask;
}
return this.strip();
};
BN.prototype.maskn = function maskn(bits) {
return this.clone().imaskn(bits);
};
BN.prototype.iaddn = function iaddn(num) {
assert(typeof num === "number");
assert(num < 67108864);
if (num < 0) return this.isubn(-num);
if (this.negative !== 0) {
if (this.length === 1 && (this.words[0] | 0) < num) {
this.words[0] = num - (this.words[0] | 0);
this.negative = 0;
return this;
}
this.negative = 0;
this.isubn(num);
this.negative = 1;
return this;
}
return this._iaddn(num);
};
BN.prototype._iaddn = function _iaddn(num) {
this.words[0] += num;
for (var 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;
};
BN.prototype.isubn = function isubn(num) {
assert(typeof num === "number");
assert(num < 67108864);
if (num < 0) return this.iaddn(-num);
if (this.negative !== 0) {
this.negative = 0;
this.iaddn(num);
this.negative = 1;
return this;
}
this.words[0] -= num;
if (this.length === 1 && this.words[0] < 0) {
this.words[0] = -this.words[0];
this.negative = 1;
} else for (var i = 0; i < this.length && this.words[i] < 0; i++) {
this.words[i] += 67108864;
this.words[i + 1] -= 1;
}
return this.strip();
};
BN.prototype.addn = function addn(num) {
return this.clone().iaddn(num);
};
BN.prototype.subn = function subn(num) {
return this.clone().isubn(num);
};
BN.prototype.iabs = function iabs() {
this.negative = 0;
return this;
};
BN.prototype.abs = function abs() {
return this.clone().iabs();
};
BN.prototype._ishlnsubmul = function _ishlnsubmul(num, mul, shift) {
var 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) * mul;
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();
assert(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();
};
BN.prototype._wordDiv = function _wordDiv(num, mode) {
var shift = this.length - num.length;
var a = this.clone();
var b = num;
var bhi = b.words[b.length - 1] | 0;
shift = 26 - this._countBits(bhi);
if (shift !== 0) {
b = b.ushln(shift);
a.iushln(shift);
bhi = b.words[b.length - 1] | 0;
}
var m = a.length - b.length;
var q;
if (mode !== "mod") {
q = new BN(null);
q.length = m + 1;
q.words = new Array(q.length);
for (var 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
};
};
BN.prototype.divmod = function divmod(num, mode, positive) {
assert(!num.isZero());
if (this.isZero()) return {
div: new BN(0),
mod: new BN(0)
};
var div, mod, res;
if (this.negative !== 0 && num.negative === 0) {
res = this.neg().divmod(num, mode);
if (mode !== "mod") div = res.div.neg();
if (mode !== "div") {
mod = res.mod.neg();
if (positive && mod.negative !== 0) mod.iadd(num);
}
return {
div,
mod
};
}
if (this.negative === 0 && num.negative !== 0) {
res = this.divmod(num.neg(), mode);
if (mode !== "mod") div = res.div.neg();
return {
div,
mod: res.mod
};
}
if ((this.negative & num.negative) !== 0) {
res = this.neg().divmod(num.neg(), mode);
if (mode !== "div") {
mod = res.mod.neg();
if (positive && mod.negative !== 0) mod.isub(num);
}
return {
div: res.div,
mod
};
}
if (num.length > this.length || this.cmp(num) < 0) return {
div: new BN(0),
mod: this
};
if (num.length === 1) {
if (mode === "div") return {
div: this.divn(num.words[0]),
mod: null
};
if (mode === "mod") return {
div: null,
mod: new BN(this.modn(num.words[0]))
};
return {
div: this.divn(num.words[0]),
mod: new BN(this.modn(num.words[0]))
};
}
return this._wordDiv(num, mode);
};
BN.prototype.div = function div(num) {
return this.divmod(num, "div", false).div;
};
BN.prototype.mod = function mod(num) {
return this.divmod(num, "mod", false).mod;
};
BN.prototype.umod = function umod(num) {
return this.divmod(num, "mod", true).mod;
};
BN.prototype.divRound = function divRound(num) {
var dm = this.divmod(num);
if (dm.mod.isZero()) return dm.div;
var mod = dm.div.negative !== 0 ? dm.mod.isub(num) : dm.mod;
var half = num.ushrn(1);
var r2 = num.andln(1);
var cmp = mod.cmp(half);
if (cmp < 0 || r2 === 1 && cmp === 0) return dm.div;
return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1);
};
BN.prototype.modn = function modn(num) {
assert(num <= 67108863);
var p = (1 << 26) % num;
var acc = 0;
for (var i = this.length - 1; i >= 0; i--) acc = (p * acc + (this.words[i] | 0)) % num;
return acc;
};
BN.prototype.idivn = function idivn(num) {
assert(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();
};
BN.prototype.divn = function divn(num) {
return this.clone().idivn(num);
};
BN.prototype.egcd = function egcd(p) {
assert(p.negative === 0);
assert(!p.isZero());
var x = this;
var y = p.clone();
if (x.negative !== 0) x = x.umod(p);
else x = x.clone();
var A = new BN(1);
var B = new BN(0);
var C = new BN(0);
var D = new BN(1);
var g = 0;
while (x.isEven() && y.isEven()) {
x.iushrn(1);
y.iushrn(1);
++g;
}
var yp = y.clone();
var xp = x.clone();
while (!x.isZero()) {
for (var 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(g)
};
};
BN.prototype._invmp = function _invmp(p) {
assert(p.negative === 0);
assert(!p.isZero());
var a = this;
var b = p.clone();
if (a.negative !== 0) a = a.umod(p);
else a = a.clone();
var x1 = new BN(1);
var x2 = new BN(0);
var delta = b.clone();
while (a.cmpn(1) > 0 && b.cmpn(1) > 0) {
for (var 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;
};
BN.prototype.gcd = function gcd(num) {
if (this.isZero()) return num.abs();
if (num.isZero()) return this.abs();
var a = this.clone();
var b = num.clone();
a.negative = 0;
b.negative = 0;
for (var shift = 0; a.isEven() && b.isEven(); shift++) {
a.iushrn(1);
b.iushrn(1);
}
do {
while (a.isEven()) a.iushrn(1);
while (b.isEven()) b.iushrn(1);
var r = a.cmp(b);
if (r < 0) {
var t = a;
a = b;
b = t;
} else if (r === 0 || b.cmpn(1) === 0) break;
a.isub(b);
} while (true);
return b.iushln(shift);
};
BN.prototype.invm = function invm(num) {
return this.egcd(num).a.umod(num);
};
BN.prototype.isEven = function isEven() {
return (this.words[0] & 1) === 0;
};
BN.prototype.isOdd = function isOdd() {
return (this.words[0] & 1) === 1;
};
BN.prototype.andln = function andln(num) {
return this.words[0] & num;
};
BN.prototype.bincn = function bincn(bit) {
assert(typeof bit === "number");
var r = bit % 26;
var s = (bit - r) / 26;
var q = 1 << r;
if (this.length <= s) {
this._expand(s + 1);
this.words[s] |= q;
return this;
}
var carry = q;
for (var i = s; 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;
};
BN.prototype.isZero = function isZero() {
return this.length === 1 && this.words[0] === 0;
};
BN.prototype.cmpn = function cmpn(num) {
var negative = num < 0;
if (this.negative !== 0 && !negative) return -1;
if (this.negative === 0 && negative) return 1;
this.strip();
var res;
if (this.length > 1) res = 1;
else {
if (negative) num = -num;
assert(num <= 67108863, "Number is too big");
var w = this.words[0] | 0;
res = w === num ? 0 : w < num ? -1 : 1;
}
if (this.negative !== 0) return -res | 0;
return res;
};
BN.prototype.cmp = function cmp(num) {
if (this.negative !== 0 && num.negative === 0) return -1;
if (this.negative === 0 && num.negative !== 0) return 1;
var res = this.ucmp(num);
if (this.negative !== 0) return -res | 0;
return res;
};
BN.prototype.ucmp = function ucmp(num) {
if (this.length > num.length) return 1;
if (this.length < num.length) return -1;
var res = 0;
for (var 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;
};
BN.prototype.gtn = function gtn(num) {
return this.cmpn(num) === 1;
};
BN.prototype.gt = function gt(num) {
return this.cmp(num) === 1;
};
BN.prototype.gten = function gten(num) {
return this.cmpn(num) >= 0;
};
BN.prototype.gte = function gte(num) {
return this.cmp(num) >= 0;
};
BN.prototype.ltn = function ltn(num) {
return this.cmpn(num) === -1;
};
BN.prototype.lt = function lt(num) {
return this.cmp(num) === -1;
};
BN.prototype.lten = function lten(num) {
return this.cmpn(num) <= 0;
};
BN.prototype.lte = function lte(num) {
return this.cmp(num) <= 0;
};
BN.prototype.eqn = function eqn(num) {
return this.cmpn(num) === 0;
};
BN.prototype.eq = function eq(num) {
return this.cmp(num) === 0;
};
BN.red = function red(num) {
return new Red(num);
};
BN.prototype.toRed = function toRed(ctx) {
assert(!this.red, "Already a number in reduction context");
assert(this.negative === 0, "red works only with positives");
return ctx.convertTo(this)._forceRed(ctx);
};
BN.prototype.fromRed = function fromRed() {
assert(this.red, "fromRed works only with numbers in reduction context");
return this.red.convertFrom(this);
};
BN.prototype._forceRed = function _forceRed(ctx) {
this.red = ctx;
return this;
};
BN.prototype.forceRed = function forceRed(ctx) {
assert(!this.red, "Already a number in reduction context");
return this._forceRed(ctx);
};
BN.prototype.redAdd = function redAdd(num) {
assert(this.red, "redAdd works only with red numbers");
return this.red.add(this, num);
};
BN.prototype.redIAdd = function redIAdd(num) {
assert(this.red, "redIAdd works only with red numbers");
return this.red.iadd(this, num);
};
BN.prototype.redSub = function redSub(num) {
assert(this.red, "redSub works only with red numbers");
return this.red.sub(this, num);
};
BN.prototype.redISub = function redISub(num) {
assert(this.red, "redISub works only with red numbers");
return this.red.isub(this, num);
};
BN.prototype.redShl = function redShl(num) {
assert(this.red, "redShl works only with red numbers");
return this.red.shl(this, num);
};
BN.prototype.redMul = function redMul(num) {
assert(this.red, "redMul works only with red numbers");
this.red._verify2(this, num);
return this.red.mul(this, num);
};
BN.prototype.redIMul = function redIMul(num) {
assert(this.red, "redMul works only with red numbers");
this.red._verify2(this, num);
return this.red.imul(this, num);
};
BN.prototype.redSqr = function redSqr() {
assert(this.red, "redSqr works only with red numbers");
this.red._verify1(this);
return this.red.sqr(this);
};
BN.prototype.redISqr = function redISqr() {
assert(this.red, "redISqr works only with red numbers");
this.red._verify1(this);
return this.red.isqr(this);
};
BN.prototype.redSqrt = function redSqrt() {
assert(this.red, "redSqrt works only with red numbers");
this.red._verify1(this);
return this.red.sqrt(this);
};
BN.prototype.redInvm = function redInvm() {
assert(this.red, "redInvm works only with red numbers");
this.red._verify1(this);
return this.red.invm(this);
};
BN.prototype.redNeg = function redNeg() {
assert(this.red, "redNeg works only with red numbers");
this.red._verify1(this);
return this.red.neg(this);
};
BN.prototype.redPow = function redPow(num) {
assert(this.red && !num.red, "redPow(normalNum)");
this.red._verify1(this);
return this.red.pow(this, num);
};
var primes = {
k256: null,
p224: null,
p192: null,
p25519: null
};
function MPrime(name, p) {
this.name = name;
this.p = new BN(p, 16);
this.n = this.p.bitLength();
this.k = new BN(1).iushln(this.n).isub(this.p);
this.tmp = this._tmp();
}
MPrime.prototype._tmp = function _tmp() {
var tmp = new BN(null);
tmp.words = new Array(Math.ceil(this.n / 13));
return tmp;
};
MPrime.prototype.ireduce = function ireduce(num) {
var r = num;
var rlen;
do {
this.split(r, this.tmp);
r = this.imulK(r);
r = r.iadd(this.tmp);
rlen = r.bitLength();
} while (rlen > this.n);
var cmp = rlen < this.n ? -1 : r.ucmp(this.p);
if (cmp === 0) {
r.words[0] = 0;
r.length = 1;
} else if (cmp > 0) r.isub(this.p);
else if (r.strip !== void 0) r.strip();
else r._strip();
return r;
};
MPrime.prototype.split = function split(input, out) {
input.iushrn(this.n, 0, out);
};
MPrime.prototype.imulK = function imulK(num) {
return num.imul(this.k);
};
function K256() {
MPrime.call(this, "k256", "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f");
}
inherits(K256, MPrime);
K256.prototype.split = function split(input, output) {
var mask = 4194303;
var outLen = Math.min(input.length, 9);
for (var 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");
}
inherits(P224, MPrime);
function P192() {
MPrime.call(this, "p192", "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff");
}
inherits(P192, MPrime);
function P25519() {
MPrime.call(this, "25519", "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed");
}
inherits(P25519, MPrime);
P25519.prototype.imulK = function imulK(num) {
var carry = 0;
for (var 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;
};
BN._prime = function prime(name) {
if (primes[name]) return primes[name];
var prime;
if (name === "k256") prime = new K256();
else if (name === "p224") prime = new P224();
else if (name === "p192") prime = new P192();
else if (name === "p25519") prime = new P25519();
else throw new Error("Unknown prime " + name);
primes[name] = prime;
return prime;
};
function Red(m) {
if (typeof m === "string") {
var prime = BN._prime(m);
this.m = prime.p;
this.prime = prime;
} else {
assert(m.gtn(1), "modulus must be greater than 1");
this.m = m;
this.prime = null;
}
}
Red.prototype._verify1 = function _verify1(a) {
assert(a.negative === 0, "red works only with positives");
assert(a.red, "red works only with red numbers");
};
Red.prototype._verify2 = function _verify2(a, b) {
assert((a.negative | b.negative) === 0, "red works only with positives");
assert(a.red && a.red === b.red, "red works only with red numbers");
};
Red.prototype.imod = function imod(a) {
if (this.prime) return this.prime.ireduce(a)._forceRed(this);
return a.umod(this.m)._forceRed(this);
};
Red.prototype.neg = function neg(a) {
if (a.isZero()) return a.clone();
return this.m.sub(a)._forceRed(this);
};
Red.prototype.add = function add(a, b) {
this._verify2(a, b);
var res = a.add(b);
if (res.cmp(this.m) >= 0) res.isub(this.m);
return res._forceRed(this);
};
Red.prototype.iadd = function iadd(a, b) {
this._verify2(a, b);
var res = a.iadd(b);
if (res.cmp(this.m) >= 0) res.isub(this.m);
return res;
};
Red.prototype.sub = function sub(a, b) {
this._verify2(a, b);
var res = a.sub(b);
if (res.cmpn(0) < 0) res.iadd(this.m);
return res._forceRed(this);
};
Red.prototype.isub = function isub(a, b) {
this._verify2(a, b);
var res = a.isub(b);
if (res.cmpn(0) < 0) res.iadd(this.m);
return res;
};
Red.prototype.shl = function shl(a, num) {
this._verify1(a);
return this.imod(a.ushln(num));
};
Red.prototype.imul = function imul(a, b) {
this._verify2(a, b);
return this.imod(a.imul(b));
};
Red.prototype.mul = function mul(a, b) {
this._verify2(a, b);
return this.imod(a.mul(b));
};
Red.prototype.isqr = function isqr(a) {
return this.imul(a, a.clone());
};
Red.prototype.sqr = function sqr(a) {
return this.mul(a, a);
};
Red.prototype.sqrt = function sqrt(a) {
if (a.isZero()) return a.clone();
var mod3 = this.m.andln(3);
assert(mod3 % 2 === 1);
if (mod3 === 3) {
var pow = this.m.add(new BN(1)).iushrn(2);
return this.pow(a, pow);
}
var q = this.m.subn(1);
var s = 0;
while (!q.isZero() && q.andln(1) === 0) {
s++;
q.iushrn(1);
}
assert(!q.isZero());
var one = new BN(1).toRed(this);
var nOne = one.redNeg();
var lpow = this.m.subn(1).iushrn(1);
var z = this.m.bitLength();
z = new BN(2 * z * z).toRed(this);
while (this.pow(z, lpow).cmp(nOne) !== 0) z.redIAdd(nOne);
var c = this.pow(z, q);
var r = this.pow(a, q.addn(1).iushrn(1));
var t = this.pow(a, q);
var m = s;
while (t.cmp(one) !== 0) {
var tmp = t;
for (var i = 0; tmp.cmp(one) !== 0; i++) tmp = tmp.redSqr();
assert(i < m);
var b = this.pow(c, new BN(1).iushln(m - i - 1));
r = r.redMul(b);
c = b.redSqr();
t = t.redMul(c);
m = i;
}
return r;
};
Red.prototype.invm = function invm(a) {
var inv = a._invmp(this.m);
if (inv.negative !== 0) {
inv.negative = 0;
return this.imod(inv).redNeg();
} else return this.imod(inv);
};
Red.prototype.pow = function pow(a, num) {
if (num.isZero()) return new BN(1).toRed(this);
if (num.cmpn(1) === 0) return a.clone();
var windowSize = 4;
var wnd = new Array(1 << windowSize);
wnd[0] = new BN(1).toRed(this);
wnd[1] = a;
for (var 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 r = num.umod(this.m);
return r === num ? r.clone() : r;
};
Red.prototype.convertFrom = function convertFrom(num) {
var res = num.clone();
res.red = null;
return res;
};
BN.mont = function mont(num) {
return new Mont(num);
};
function Mont(m) {
Red.call(this, m);
this.shift = this.m.bitLength();
if (this.shift % 26 !== 0) this.shift += 26 - this.shift % 26;
this.r = new BN(1).iushln(this.shift);
this.r2 = this.imod(this.r.sqr());
this.rinv = this.r._invmp(this.m);
this.minv = this.rinv.mul(this.r).isubn(1).div(this.m);
this.minv = this.minv.umod(this.r);
this.minv = this.r.sub(this.minv);
}
inherits(Mont, Red);
Mont.prototype.convertTo = function convertTo(num) {
return this.imod(num.ushln(this.shift));
};
Mont.prototype.convertFrom = function convertFrom(num) {
var r = this.imod(num.mul(this.rinv));
r.red = null;
return r;
};
Mont.prototype.imul = function imul(a, b) {
if (a.isZero() || b.isZero()) {
a.words[0] = 0;
a.length = 1;
return a;
}
var t = a.imul(b);
var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
var u = t.isub(c).iushrn(this.shift);
var res = u;
if (u.cmp(this.m) >= 0) res = u.isub(this.m);
else if (u.cmpn(0) < 0) res = u.iadd(this.m);
return res._forceRed(this);
};
Mont.prototype.mul = function mul(a, b) {
if (a.isZero() || b.isZero()) return new BN(0)._forceRed(this);
var t = a.mul(b);
var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
var u = t.isub(c).iushrn(this.shift);
var res = u;
if (u.cmp(this.m) >= 0) res = u.isub(this.m);
else if (u.cmpn(0) < 0) res = u.iadd(this.m);
return res._forceRed(this);
};
Mont.prototype.invm = function invm(a) {
return this.imod(a._invmp(this.m).mul(this.r2))._forceRed(this);
};
})(typeof module === "undefined" || module, exports);
}));
//#endregion
//#region node_modules/create-ecdh/browser.js
var require_browser$3 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
init_dist$1();
var elliptic = require_elliptic();
var BN = require_bn$1();
module.exports = function createECDH(curve) {
return new ECDH(curve);
};
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(curve) {
this.curveType = aliases[curve];
if (!this.curveType) this.curveType = { name: curve };
this.curve = new elliptic.ec(this.curveType.name);
this.keys = void 0;
}
ECDH.prototype.generateKeys = function(enc, format) {
this.keys = this.curve.genKeyPair();
return this.getPublicKey(enc, format);
};
ECDH.prototype.computeSecret = function(other, inenc, enc) {
inenc = inenc || "utf8";
if (!Buffer$1.isBuffer(other)) other = new Buffer$1(other, inenc);
return formatReturnValue(this.curve.keyFromPublic(other).getPublic().mul(this.keys.getPrivate()).getX(), enc, this.curveType.byteLength);
};
ECDH.prototype.getPublicKey = function(enc, format) {
var key = this.keys.getPublic(format === "compressed", true);
if (format === "hybrid") if (key[key.length - 1] % 2) key[0] = 7;
else key[0] = 6;
return formatReturnValue(key, enc);
};
ECDH.prototype.getPrivateKey = function(enc) {
return formatReturnValue(this.keys.getPrivate(), enc);
};
ECDH.prototype.setPublicKey = function(pub, enc) {
enc = enc || "utf8";
if (!Buffer$1.isBuffer(pub)) pub = new Buffer$1(pub, enc);
this.keys._importPublic(pub);
return this;
};
ECDH.prototype.setPrivateKey = function(priv, enc) {
enc = enc || "utf8";
if (!Buffer$1.isBuffer(priv)) priv = new Buffer$1(priv, enc);
var _priv = new BN(priv);
_priv = _priv.toString(16);
this.keys = this.curve.genKeyPair();
this.keys._importPrivate(_priv);
return this;
};
function formatReturnValue(bn, enc, len) {
if (!Array.isArray(bn)) bn = bn.toArray();
var buf = new Buffer$1(bn);
if (len && buf.length < len) {
var zeros = new Buffer$1(len - buf.length);
zeros.fill(0);
buf = Buffer$1.concat([zeros, buf]);
}
if (!enc) return buf;
else return buf.toString(enc);
}
}));
//#endregion
//#region node_modules/public-encrypt/mgf.js
var require_mgf = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var createHash = require_browser$10();
var Buffer = require_safe_buffer$9().Buffer;
module.exports = function(seed, len) {
var t = Buffer.alloc(0);
var i = 0;
var c;
while (t.length < len) {
c = i2ops(i++);
t = Buffer.concat([t, createHash("sha1").update(seed).update(c).digest()]);
}
return t.slice(0, len);
};
function i2ops(c) {
var out = Buffer.allocUnsafe(4);
out.writeUInt32BE(c, 0);
return out;
}
}));
//#endregion
//#region node_modules/public-encrypt/xor.js
var require_xor = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = function xor(a, b) {
var len = a.length;
var i = -1;
while (++i < len) a[i] ^= b[i];
return a;
};
}));
//#endregion
//#region node_modules/public-encrypt/node_modules/bn.js/lib/bn.js
var require_bn = /* @__PURE__ */ __commonJSMin(((exports, module) => {
(function(module$1, exports$1) {
"use strict";
function assert(val, msg) {
if (!val) throw new Error(msg || "Assertion failed");
}
function inherits(ctor, superCtor) {
ctor.super_ = superCtor;
var TempCtor = function() {};
TempCtor.prototype = superCtor.prototype;
ctor.prototype = new TempCtor();
ctor.prototype.constructor = ctor;
}
function BN(number, base, endian) {
if (BN.isBN(number)) return number;
this.negative = 0;
this.words = null;
this.length = 0;
this.red = null;
if (number !== null) {
if (base === "le" || base === "be") {
endian = base;
base = 10;
}
this._init(number || 0, base || 10, endian || "be");
}
}
if (typeof module$1 === "object") module$1.exports = BN;
else exports$1.BN = BN;
BN.BN = BN;
BN.wordSize = 26;
var Buffer;
try {
if (typeof window !== "undefined" && typeof window.Buffer !== "undefined") Buffer = window.Buffer;
else Buffer = require_dist().Buffer;
} catch (e) {}
BN.isBN = function isBN(num) {
if (num instanceof BN) return true;
return num !== null && typeof num === "object" && num.constructor.wordSize === BN.wordSize && Array.isArray(num.words);
};
BN.max = function max(left, right) {
if (left.cmp(right) > 0) return left;
return right;
};
BN.min = function min(left, right) {
if (left.cmp(right) < 0) return left;
return right;
};
BN.prototype._init = function init(number, base, endian) {
if (typeof number === "number") return this._initNumber(number, base, endian);
if (typeof number === "object") return this._initArray(number, base, endian);
if (base === "hex") base = 16;
assert(base === (base | 0) && base >= 2 && base <= 36);
number = number.toString().replace(/\s+/g, "");
var start = 0;
if (number[0] === "-") {
start++;
this.negative = 1;
}
if (start < number.length) if (base === 16) this._parseHex(number, start, endian);
else {
this._parseBase(number, base, start);
if (endian === "le") this._initArray(this.toArray(), base, endian);
}
};
BN.prototype._initNumber = function _initNumber(number, base, endian) {
if (number < 0) {
this.negative = 1;
number = -number;
}
if (number < 67108864) {
this.words = [number & 67108863];
this.length = 1;
} else if (number < 4503599627370496) {
this.words = [number & 67108863, number / 67108864 & 67108863];
this.length = 2;
} else {
assert(number < 9007199254740992);
this.words = [
number & 67108863,
number / 67108864 & 67108863,
1
];
this.length = 3;
}
if (endian !== "le") return;
this._initArray(this.toArray(), base, endian);
};
BN.prototype._initArray = function _initArray(number, base, endian) {
assert(typeof number.length === "number");
if (number.length <= 0) {
this.words = [0];
this.length = 1;
return this;
}
this.length = Math.ceil(number.length / 3);
this.words = new Array(this.length);
for (var 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 r = parseHex4Bits(string, index);
if (index - 1 >= lowerBound) r |= parseHex4Bits(string, index - 1) << 4;
return r;
}
BN.prototype._parseHex = function _parseHex(number, start, endian) {
this.length = Math.ceil((number.length - start) / 6);
this.words = new Array(this.length);
for (var 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 for (i = (number.length - start) % 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, mul) {
var r = 0;
var len = Math.min(str.length, end);
for (var i = start; i < len; i++) {
var c = str.charCodeAt(i) - 48;
r *= mul;
if (c >= 49) r += c - 49 + 10;
else if (c >= 17) r += c - 17 + 10;
else r += c;
}
return r;
}
BN.prototype._parseBase = function _parseBase(number, base, start) {
this.words = [0];
this.length = 1;
for (var limbLen = 0, limbPow = 1; limbPow <= 67108863; limbPow *= base) limbLen++;
limbLen--;
limbPow = limbPow / base | 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, base);
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, base);
for (i = 0; i < mod; i++) pow *= base;
this.imuln(pow);
if (this.words[0] + word < 67108864) this.words[0] += word;
else this._iaddn(word);
}
this.strip();
};
BN.prototype.copy = function copy(dest) {
dest.words = new Array(this.length);
for (var i = 0; i < this.length; i++) dest.words[i] = this.words[i];
dest.length = this.length;
dest.negative = this.negative;
dest.red = this.red;
};
BN.prototype.clone = function clone() {
var r = new BN(null);
this.copy(r);
return r;
};
BN.prototype._expand = function _expand(size) {
while (this.length < size) this.words[this.length++] = 0;
return this;
};
BN.prototype.strip = function strip() {
while (this.length > 1 && this.words[this.length - 1] === 0) this.length--;
return this._normSign();
};
BN.prototype._normSign = function _normSign() {
if (this.length === 1 && this.words[0] === 0) this.negative = 0;
return this;
};
BN.prototype.inspect = function inspect() {
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
];
BN.prototype.toString = function toString(base, padding) {
base = base || 10;
padding = padding | 0 || 1;
var out;
if (base === 16 || base === "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 (base === (base | 0) && base >= 2 && base <= 36) {
var groupSize = groupSizes[base];
var groupBase = groupBases[base];
out = "";
var c = this.clone();
c.negative = 0;
while (!c.isZero()) {
var r = c.modn(groupBase).toString(base);
c = c.idivn(groupBase);
if (!c.isZero()) out = zeros[groupSize - r.length] + r + out;
else out = r + out;
}
if (this.isZero()) out = "0" + out;
while (out.length % padding !== 0) out = "0" + out;
if (this.negative !== 0) out = "-" + out;
return out;
}
assert(false, "Base should be between 2 and 36");
};
BN.prototype.toNumber = function 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) assert(false, "Number can only safely store up to 53 bits");
return this.negative !== 0 ? -ret : ret;
};
BN.prototype.toJSON = function toJSON() {
return this.toString(16);
};
BN.prototype.toBuffer = function toBuffer(endian, length) {
assert(typeof Buffer !== "undefined");
return this.toArrayLike(Buffer, endian, length);
};
BN.prototype.toArray = function toArray(endian, length) {
return this.toArrayLike(Array, endian, length);
};
BN.prototype.toArrayLike = function toArrayLike(ArrayType, endian, length) {
var byteLength = this.byteLength();
var reqLength = length || Math.max(1, byteLength);
assert(byteLength <= reqLength, "byte array longer than desired length");
assert(reqLength > 0, "Requested array length <= 0");
this.strip();
var littleEndian = endian === "le";
var res = new ArrayType(reqLength);
var b, 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) BN.prototype._countBits = function _countBits(w) {
return 32 - Math.clz32(w);
};
else BN.prototype._countBits = function _countBits(w) {
var t = w;
var r = 0;
if (t >= 4096) {
r += 13;
t >>>= 13;
}
if (t >= 64) {
r += 7;
t >>>= 7;
}
if (t >= 8) {
r += 4;
t >>>= 4;
}
if (t >= 2) {
r += 2;
t >>>= 2;
}
return r + t;
};
BN.prototype._zeroBits = function _zeroBits(w) {
if (w === 0) return 26;
var t = w;
var r = 0;
if ((t & 8191) === 0) {
r += 13;
t >>>= 13;
}
if ((t & 127) === 0) {
r += 7;
t >>>= 7;
}
if ((t & 15) === 0) {
r += 4;
t >>>= 4;
}
if ((t & 3) === 0) {
r += 2;
t >>>= 2;
}
if ((t & 1) === 0) r++;
return r;
};
BN.prototype.bitLength = function bitLength() {
var w = this.words[this.length - 1];
var hi = this._countBits(w);
return (this.length - 1) * 26 + hi;
};
function toBitArray(num) {
var w = new Array(num.bitLength());
for (var bit = 0; bit < w.length; bit++) {
var off = bit / 26 | 0;
var wbit = bit % 26;
w[bit] = (num.words[off] & 1 << wbit) >>> wbit;
}
return w;
}
BN.prototype.zeroBits = function zeroBits() {
if (this.isZero()) return 0;
var r = 0;
for (var i = 0; i < this.length; i++) {
var b = this._zeroBits(this.words[i]);
r += b;
if (b !== 26) break;
}
return r;
};
BN.prototype.byteLength = function byteLength() {
return Math.ceil(this.bitLength() / 8);
};
BN.prototype.toTwos = function toTwos(width) {
if (this.negative !== 0) return this.abs().inotn(width).iaddn(1);
return this.clone();
};
BN.prototype.fromTwos = function fromTwos(width) {
if (this.testn(width - 1)) return this.notn(width).iaddn(1).ineg();
return this.clone();
};
BN.prototype.isNeg = function isNeg() {
return this.negative !== 0;
};
BN.prototype.neg = function neg() {
return this.clone().ineg();
};
BN.prototype.ineg = function ineg() {
if (!this.isZero()) this.negative ^= 1;
return this;
};
BN.prototype.iuor = function iuor(num) {
while (this.length < num.length) this.words[this.length++] = 0;
for (var i = 0; i < num.length; i++) this.words[i] = this.words[i] | num.words[i];
return this.strip();
};
BN.prototype.ior = function ior(num) {
assert((this.negative | num.negative) === 0);
return this.iuor(num);
};
BN.prototype.or = function or(num) {
if (this.length > num.length) return this.clone().ior(num);
return num.clone().ior(this);
};
BN.prototype.uor = function uor(num) {
if (this.length > num.length) return this.clone().iuor(num);
return num.clone().iuor(this);
};
BN.prototype.iuand = function iuand(num) {
var b;
if (this.length > num.length) b = num;
else b = this;
for (var i = 0; i < b.length; i++) this.words[i] = this.words[i] & num.words[i];
this.length = b.length;
return this.strip();
};
BN.prototype.iand = function iand(num) {
assert((this.negative | num.negative) === 0);
return this.iuand(num);
};
BN.prototype.and = function and(num) {
if (this.length > num.length) return this.clone().iand(num);
return num.clone().iand(this);
};
BN.prototype.uand = function uand(num) {
if (this.length > num.length) return this.clone().iuand(num);
return num.clone().iuand(this);
};
BN.prototype.iuxor = function iuxor(num) {
var a;
var b;
if (this.length > num.length) {
a = this;
b = num;
} else {
a = num;
b = this;
}
for (var 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();
};
BN.prototype.ixor = function ixor(num) {
assert((this.negative | num.negative) === 0);
return this.iuxor(num);
};
BN.prototype.xor = function xor(num) {
if (this.length > num.length) return this.clone().ixor(num);
return num.clone().ixor(this);
};
BN.prototype.uxor = function uxor(num) {
if (this.length > num.length) return this.clone().iuxor(num);
return num.clone().iuxor(this);
};
BN.prototype.inotn = function inotn(width) {
assert(typeof width === "number" && width >= 0);
var bytesNeeded = Math.ceil(width / 26) | 0;
var bitsLeft = width % 26;
this._expand(bytesNeeded);
if (bitsLeft > 0) bytesNeeded--;
for (var 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();
};
BN.prototype.notn = function notn(width) {
return this.clone().inotn(width);
};
BN.prototype.setn = function setn(bit, val) {
assert(typeof bit === "number" && bit >= 0);
var off = bit / 26 | 0;
var wbit = bit % 26;
this._expand(off + 1);
if (val) this.words[off] = this.words[off] | 1 << wbit;
else this.words[off] = this.words[off] & ~(1 << wbit);
return this.strip();
};
BN.prototype.iadd = function iadd(num) {
var r;
if (this.negative !== 0 && num.negative === 0) {
this.negative = 0;
r = this.isub(num);
this.negative ^= 1;
return this._normSign();
} else if (this.negative === 0 && num.negative !== 0) {
num.negative = 0;
r = this.isub(num);
num.negative = 1;
return r._normSign();
}
var a, b;
if (this.length > num.length) {
a = this;
b = num;
} else {
a = num;
b = this;
}
var carry = 0;
for (var i = 0; i < b.length; i++) {
r = (a.words[i] | 0) + (b.words[i] | 0) + carry;
this.words[i] = r & 67108863;
carry = r >>> 26;
}
for (; carry !== 0 && i < a.length; i++) {
r = (a.words[i] | 0) + carry;
this.words[i] = r & 67108863;
carry = r >>> 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;
};
BN.prototype.add = function add(num) {
var res;
if (num.negative !== 0 && this.negative === 0) {
num.negative = 0;
res = this.sub(num);
num.negative ^= 1;
return res;
} else if (num.negative === 0 && this.negative !== 0) {
this.negative = 0;
res = num.sub(this);
this.negative = 1;
return res;
}
if (this.length > num.length) return this.clone().iadd(num);
return num.clone().iadd(this);
};
BN.prototype.isub = function isub(num) {
if (num.negative !== 0) {
num.negative = 0;
var r = this.iadd(num);
num.negative = 1;
return r._normSign();
} else if (this.negative !== 0) {
this.negative = 0;
this.iadd(num);
this.negative = 1;
return this._normSign();
}
var cmp = this.cmp(num);
if (cmp === 0) {
this.negative = 0;
this.length = 1;
this.words[0] = 0;
return this;
}
var a, b;
if (cmp > 0) {
a = this;
b = num;
} else {
a = num;
b = this;
}
var carry = 0;
for (var i = 0; i < b.length; i++) {
r = (a.words[i] | 0) - (b.words[i] | 0) + carry;
carry = r >> 26;
this.words[i] = r & 67108863;
}
for (; carry !== 0 && i < a.length; i++) {
r = (a.words[i] | 0) + carry;
carry = r >> 26;
this.words[i] = r & 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();
};
BN.prototype.sub = function sub(num) {
return this.clone().isub(num);
};
function smallMulTo(self, num, out) {
out.negative = num.negative ^ self.negative;
var len = self.length + num.length | 0;
out.length = len;
len = len - 1 | 0;
var a = self.words[0] | 0;
var b = num.words[0] | 0;
var r = a * b;
var lo = r & 67108863;
var carry = r / 67108864 | 0;
out.words[0] = lo;
for (var k = 1; k < 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 - self.length + 1); j <= maxJ; j++) {
var i = k - j | 0;
a = self.words[i] | 0;
b = num.words[j] | 0;
r = a * b + rword;
ncarry += r / 67108864 | 0;
rword = r & 67108863;
}
out.words[k] = rword | 0;
carry = ncarry | 0;
}
if (carry !== 0) out.words[k] = carry | 0;
else out.length--;
return out.strip();
}
var comb10MulTo = function comb10MulTo(self, num, out) {
var a = self.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 = self.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(self, num, out) {
out.negative = num.negative ^ self.negative;
out.length = self.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 - self.length + 1); j <= maxJ; j++) {
var i = k - j;
var r = (self.words[i] | 0) * (num.words[j] | 0);
var lo = r & 67108863;
ncarry = ncarry + (r / 67108864 | 0) | 0;
lo = lo + rword | 0;
rword = lo & 67108863;
ncarry = ncarry + (lo >>> 26) | 0;
hncarry += ncarry >>> 26;
ncarry &= 67108863;
}
out.words[k] = rword;
carry = ncarry;
ncarry = hncarry;
}
if (carry !== 0) out.words[k] = carry;
else out.length--;
return out.strip();
}
function jumboMulTo(self, num, out) {
return new FFTM().mulp(self, num, out);
}
BN.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 = BN.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 permute(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 s = 1; s < N; s <<= 1) {
var l = s << 1;
var rtwdf = Math.cos(2 * Math.PI / l);
var itwdf = Math.sin(2 * Math.PI / l);
for (var p = 0; p < N; p += l) {
var rtwdf_ = rtwdf;
var itwdf_ = itwdf;
for (var j = 0; j < s; j++) {
var re = rtws[p + j];
var ie = itws[p + j];
var ro = rtws[p + j + s];
var io = itws[p + j + s];
var rx = rtwdf_ * ro - itwdf_ * io;
io = rtwdf_ * io + itwdf_ * ro;
ro = rx;
rtws[p + j] = re + ro;
itws[p + j] = ie + io;
rtws[p + j + s] = re - ro;
itws[p + j + s] = ie - io;
if (j !== l) {
rx = rtwdf * rtwdf_ - itwdf * itwdf_;
itwdf_ = rtwdf * itwdf_ + itwdf * rtwdf_;
rtwdf_ = rx;
}
}
}
}
};
FFTM.prototype.guessLen13b = function guessLen13b(n, m) {
var N = Math.max(m, n) | 1;
var odd = N & 1;
var 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;
assert(carry === 0);
assert((carry & -8192) === 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();
};
BN.prototype.mul = function mul(num) {
var out = new BN(null);
out.words = new Array(this.length + num.length);
return this.mulTo(num, out);
};
BN.prototype.mulf = function mulf(num) {
var out = new BN(null);
out.words = new Array(this.length + num.length);
return jumboMulTo(this, num, out);
};
BN.prototype.imul = function imul(num) {
return this.clone().mulTo(num, this);
};
BN.prototype.imuln = function imuln(num) {
assert(typeof num === "number");
assert(num < 67108864);
var carry = 0;
for (var 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;
};
BN.prototype.muln = function muln(num) {
return this.clone().imuln(num);
};
BN.prototype.sqr = function sqr() {
return this.mul(this);
};
BN.prototype.isqr = function isqr() {
return this.imul(this.clone());
};
BN.prototype.pow = function pow(num) {
var w = toBitArray(num);
if (w.length === 0) return new BN(1);
var res = this;
for (var 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;
};
BN.prototype.iushln = function iushln(bits) {
assert(typeof bits === "number" && bits >= 0);
var r = bits % 26;
var s = (bits - r) / 26;
var carryMask = 67108863 >>> 26 - r << 26 - r;
var i;
if (r !== 0) {
var carry = 0;
for (i = 0; i < this.length; i++) {
var newCarry = this.words[i] & carryMask;
var c = (this.words[i] | 0) - newCarry << r;
this.words[i] = c | carry;
carry = newCarry >>> 26 - r;
}
if (carry) {
this.words[i] = carry;
this.length++;
}
}
if (s !== 0) {
for (i = this.length - 1; i >= 0; i--) this.words[i + s] = this.words[i];
for (i = 0; i < s; i++) this.words[i] = 0;
this.length += s;
}
return this.strip();
};
BN.prototype.ishln = function ishln(bits) {
assert(this.negative === 0);
return this.iushln(bits);
};
BN.prototype.iushrn = function iushrn(bits, hint, extended) {
assert(typeof bits === "number" && bits >= 0);
var h;
if (hint) h = (hint - hint % 26) / 26;
else h = 0;
var r = bits % 26;
var s = Math.min((bits - r) / 26, this.length);
var mask = 67108863 ^ 67108863 >>> r << r;
var maskedWords = extended;
h -= s;
h = Math.max(0, h);
if (maskedWords) {
for (var i = 0; i < s; i++) maskedWords.words[i] = this.words[i];
maskedWords.length = s;
}
if (s === 0) {} else if (this.length > s) {
this.length -= s;
for (i = 0; i < this.length; i++) this.words[i] = this.words[i + s];
} 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 - r | word >>> r;
carry = word & mask;
}
if (maskedWords && carry !== 0) maskedWords.words[maskedWords.length++] = carry;
if (this.length === 0) {
this.words[0] = 0;
this.length = 1;
}
return this.strip();
};
BN.prototype.ishrn = function ishrn(bits, hint, extended) {
assert(this.negative === 0);
return this.iushrn(bits, hint, extended);
};
BN.prototype.shln = function shln(bits) {
return this.clone().ishln(bits);
};
BN.prototype.ushln = function ushln(bits) {
return this.clone().iushln(bits);
};
BN.prototype.shrn = function shrn(bits) {
return this.clone().ishrn(bits);
};
BN.prototype.ushrn = function ushrn(bits) {
return this.clone().iushrn(bits);
};
BN.prototype.testn = function testn(bit) {
assert(typeof bit === "number" && bit >= 0);
var r = bit % 26;
var s = (bit - r) / 26;
var q = 1 << r;
if (this.length <= s) return false;
return !!(this.words[s] & q);
};
BN.prototype.imaskn = function imaskn(bits) {
assert(typeof bits === "number" && bits >= 0);
var r = bits % 26;
var s = (bits - r) / 26;
assert(this.negative === 0, "imaskn works only with positive numbers");
if (this.length <= s) return this;
if (r !== 0) s++;
this.length = Math.min(s, this.length);
if (r !== 0) {
var mask = 67108863 ^ 67108863 >>> r << r;
this.words[this.length - 1] &= mask;
}
return this.strip();
};
BN.prototype.maskn = function maskn(bits) {
return this.clone().imaskn(bits);
};
BN.prototype.iaddn = function iaddn(num) {
assert(typeof num === "number");
assert(num < 67108864);
if (num < 0) return this.isubn(-num);
if (this.negative !== 0) {
if (this.length === 1 && (this.words[0] | 0) < num) {
this.words[0] = num - (this.words[0] | 0);
this.negative = 0;
return this;
}
this.negative = 0;
this.isubn(num);
this.negative = 1;
return this;
}
return this._iaddn(num);
};
BN.prototype._iaddn = function _iaddn(num) {
this.words[0] += num;
for (var 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;
};
BN.prototype.isubn = function isubn(num) {
assert(typeof num === "number");
assert(num < 67108864);
if (num < 0) return this.iaddn(-num);
if (this.negative !== 0) {
this.negative = 0;
this.iaddn(num);
this.negative = 1;
return this;
}
this.words[0] -= num;
if (this.length === 1 && this.words[0] < 0) {
this.words[0] = -this.words[0];
this.negative = 1;
} else for (var i = 0; i < this.length && this.words[i] < 0; i++) {
this.words[i] += 67108864;
this.words[i + 1] -= 1;
}
return this.strip();
};
BN.prototype.addn = function addn(num) {
return this.clone().iaddn(num);
};
BN.prototype.subn = function subn(num) {
return this.clone().isubn(num);
};
BN.prototype.iabs = function iabs() {
this.negative = 0;
return this;
};
BN.prototype.abs = function abs() {
return this.clone().iabs();
};
BN.prototype._ishlnsubmul = function _ishlnsubmul(num, mul, shift) {
var 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) * mul;
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();
assert(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();
};
BN.prototype._wordDiv = function _wordDiv(num, mode) {
var shift = this.length - num.length;
var a = this.clone();
var b = num;
var bhi = b.words[b.length - 1] | 0;
shift = 26 - this._countBits(bhi);
if (shift !== 0) {
b = b.ushln(shift);
a.iushln(shift);
bhi = b.words[b.length - 1] | 0;
}
var m = a.length - b.length;
var q;
if (mode !== "mod") {
q = new BN(null);
q.length = m + 1;
q.words = new Array(q.length);
for (var 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
};
};
BN.prototype.divmod = function divmod(num, mode, positive) {
assert(!num.isZero());
if (this.isZero()) return {
div: new BN(0),
mod: new BN(0)
};
var div, mod, res;
if (this.negative !== 0 && num.negative === 0) {
res = this.neg().divmod(num, mode);
if (mode !== "mod") div = res.div.neg();
if (mode !== "div") {
mod = res.mod.neg();
if (positive && mod.negative !== 0) mod.iadd(num);
}
return {
div,
mod
};
}
if (this.negative === 0 && num.negative !== 0) {
res = this.divmod(num.neg(), mode);
if (mode !== "mod") div = res.div.neg();
return {
div,
mod: res.mod
};
}
if ((this.negative & num.negative) !== 0) {
res = this.neg().divmod(num.neg(), mode);
if (mode !== "div") {
mod = res.mod.neg();
if (positive && mod.negative !== 0) mod.isub(num);
}
return {
div: res.div,
mod
};
}
if (num.length > this.length || this.cmp(num) < 0) return {
div: new BN(0),
mod: this
};
if (num.length === 1) {
if (mode === "div") return {
div: this.divn(num.words[0]),
mod: null
};
if (mode === "mod") return {
div: null,
mod: new BN(this.modn(num.words[0]))
};
return {
div: this.divn(num.words[0]),
mod: new BN(this.modn(num.words[0]))
};
}
return this._wordDiv(num, mode);
};
BN.prototype.div = function div(num) {
return this.divmod(num, "div", false).div;
};
BN.prototype.mod = function mod(num) {
return this.divmod(num, "mod", false).mod;
};
BN.prototype.umod = function umod(num) {
return this.divmod(num, "mod", true).mod;
};
BN.prototype.divRound = function divRound(num) {
var dm = this.divmod(num);
if (dm.mod.isZero()) return dm.div;
var mod = dm.div.negative !== 0 ? dm.mod.isub(num) : dm.mod;
var half = num.ushrn(1);
var r2 = num.andln(1);
var cmp = mod.cmp(half);
if (cmp < 0 || r2 === 1 && cmp === 0) return dm.div;
return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1);
};
BN.prototype.modn = function modn(num) {
assert(num <= 67108863);
var p = (1 << 26) % num;
var acc = 0;
for (var i = this.length - 1; i >= 0; i--) acc = (p * acc + (this.words[i] | 0)) % num;
return acc;
};
BN.prototype.idivn = function idivn(num) {
assert(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();
};
BN.prototype.divn = function divn(num) {
return this.clone().idivn(num);
};
BN.prototype.egcd = function egcd(p) {
assert(p.negative === 0);
assert(!p.isZero());
var x = this;
var y = p.clone();
if (x.negative !== 0) x = x.umod(p);
else x = x.clone();
var A = new BN(1);
var B = new BN(0);
var C = new BN(0);
var D = new BN(1);
var g = 0;
while (x.isEven() && y.isEven()) {
x.iushrn(1);
y.iushrn(1);
++g;
}
var yp = y.clone();
var xp = x.clone();
while (!x.isZero()) {
for (var 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(g)
};
};
BN.prototype._invmp = function _invmp(p) {
assert(p.negative === 0);
assert(!p.isZero());
var a = this;
var b = p.clone();
if (a.negative !== 0) a = a.umod(p);
else a = a.clone();
var x1 = new BN(1);
var x2 = new BN(0);
var delta = b.clone();
while (a.cmpn(1) > 0 && b.cmpn(1) > 0) {
for (var 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;
};
BN.prototype.gcd = function gcd(num) {
if (this.isZero()) return num.abs();
if (num.isZero()) return this.abs();
var a = this.clone();
var b = num.clone();
a.negative = 0;
b.negative = 0;
for (var shift = 0; a.isEven() && b.isEven(); shift++) {
a.iushrn(1);
b.iushrn(1);
}
do {
while (a.isEven()) a.iushrn(1);
while (b.isEven()) b.iushrn(1);
var r = a.cmp(b);
if (r < 0) {
var t = a;
a = b;
b = t;
} else if (r === 0 || b.cmpn(1) === 0) break;
a.isub(b);
} while (true);
return b.iushln(shift);
};
BN.prototype.invm = function invm(num) {
return this.egcd(num).a.umod(num);
};
BN.prototype.isEven = function isEven() {
return (this.words[0] & 1) === 0;
};
BN.prototype.isOdd = function isOdd() {
return (this.words[0] & 1) === 1;
};
BN.prototype.andln = function andln(num) {
return this.words[0] & num;
};
BN.prototype.bincn = function bincn(bit) {
assert(typeof bit === "number");
var r = bit % 26;
var s = (bit - r) / 26;
var q = 1 << r;
if (this.length <= s) {
this._expand(s + 1);
this.words[s] |= q;
return this;
}
var carry = q;
for (var i = s; 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;
};
BN.prototype.isZero = function isZero() {
return this.length === 1 && this.words[0] === 0;
};
BN.prototype.cmpn = function cmpn(num) {
var negative = num < 0;
if (this.negative !== 0 && !negative) return -1;
if (this.negative === 0 && negative) return 1;
this.strip();
var res;
if (this.length > 1) res = 1;
else {
if (negative) num = -num;
assert(num <= 67108863, "Number is too big");
var w = this.words[0] | 0;
res = w === num ? 0 : w < num ? -1 : 1;
}
if (this.negative !== 0) return -res | 0;
return res;
};
BN.prototype.cmp = function cmp(num) {
if (this.negative !== 0 && num.negative === 0) return -1;
if (this.negative === 0 && num.negative !== 0) return 1;
var res = this.ucmp(num);
if (this.negative !== 0) return -res | 0;
return res;
};
BN.prototype.ucmp = function ucmp(num) {
if (this.length > num.length) return 1;
if (this.length < num.length) return -1;
var res = 0;
for (var 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;
};
BN.prototype.gtn = function gtn(num) {
return this.cmpn(num) === 1;
};
BN.prototype.gt = function gt(num) {
return this.cmp(num) === 1;
};
BN.prototype.gten = function gten(num) {
return this.cmpn(num) >= 0;
};
BN.prototype.gte = function gte(num) {
return this.cmp(num) >= 0;
};
BN.prototype.ltn = function ltn(num) {
return this.cmpn(num) === -1;
};
BN.prototype.lt = function lt(num) {
return this.cmp(num) === -1;
};
BN.prototype.lten = function lten(num) {
return this.cmpn(num) <= 0;
};
BN.prototype.lte = function lte(num) {
return this.cmp(num) <= 0;
};
BN.prototype.eqn = function eqn(num) {
return this.cmpn(num) === 0;
};
BN.prototype.eq = function eq(num) {
return this.cmp(num) === 0;
};
BN.red = function red(num) {
return new Red(num);
};
BN.prototype.toRed = function toRed(ctx) {
assert(!this.red, "Already a number in reduction context");
assert(this.negative === 0, "red works only with positives");
return ctx.convertTo(this)._forceRed(ctx);
};
BN.prototype.fromRed = function fromRed() {
assert(this.red, "fromRed works only with numbers in reduction context");
return this.red.convertFrom(this);
};
BN.prototype._forceRed = function _forceRed(ctx) {
this.red = ctx;
return this;
};
BN.prototype.forceRed = function forceRed(ctx) {
assert(!this.red, "Already a number in reduction context");
return this._forceRed(ctx);
};
BN.prototype.redAdd = function redAdd(num) {
assert(this.red, "redAdd works only with red numbers");
return this.red.add(this, num);
};
BN.prototype.redIAdd = function redIAdd(num) {
assert(this.red, "redIAdd works only with red numbers");
return this.red.iadd(this, num);
};
BN.prototype.redSub = function redSub(num) {
assert(this.red, "redSub works only with red numbers");
return this.red.sub(this, num);
};
BN.prototype.redISub = function redISub(num) {
assert(this.red, "redISub works only with red numbers");
return this.red.isub(this, num);
};
BN.prototype.redShl = function redShl(num) {
assert(this.red, "redShl works only with red numbers");
return this.red.shl(this, num);
};
BN.prototype.redMul = function redMul(num) {
assert(this.red, "redMul works only with red numbers");
this.red._verify2(this, num);
return this.red.mul(this, num);
};
BN.prototype.redIMul = function redIMul(num) {
assert(this.red, "redMul works only with red numbers");
this.red._verify2(this, num);
return this.red.imul(this, num);
};
BN.prototype.redSqr = function redSqr() {
assert(this.red, "redSqr works only with red numbers");
this.red._verify1(this);
return this.red.sqr(this);
};
BN.prototype.redISqr = function redISqr() {
assert(this.red, "redISqr works only with red numbers");
this.red._verify1(this);
return this.red.isqr(this);
};
BN.prototype.redSqrt = function redSqrt() {
assert(this.red, "redSqrt works only with red numbers");
this.red._verify1(this);
return this.red.sqrt(this);
};
BN.prototype.redInvm = function redInvm() {
assert(this.red, "redInvm works only with red numbers");
this.red._verify1(this);
return this.red.invm(this);
};
BN.prototype.redNeg = function redNeg() {
assert(this.red, "redNeg works only with red numbers");
this.red._verify1(this);
return this.red.neg(this);
};
BN.prototype.redPow = function redPow(num) {
assert(this.red && !num.red, "redPow(normalNum)");
this.red._verify1(this);
return this.red.pow(this, num);
};
var primes = {
k256: null,
p224: null,
p192: null,
p25519: null
};
function MPrime(name, p) {
this.name = name;
this.p = new BN(p, 16);
this.n = this.p.bitLength();
this.k = new BN(1).iushln(this.n).isub(this.p);
this.tmp = this._tmp();
}
MPrime.prototype._tmp = function _tmp() {
var tmp = new BN(null);
tmp.words = new Array(Math.ceil(this.n / 13));
return tmp;
};
MPrime.prototype.ireduce = function ireduce(num) {
var r = num;
var rlen;
do {
this.split(r, this.tmp);
r = this.imulK(r);
r = r.iadd(this.tmp);
rlen = r.bitLength();
} while (rlen > this.n);
var cmp = rlen < this.n ? -1 : r.ucmp(this.p);
if (cmp === 0) {
r.words[0] = 0;
r.length = 1;
} else if (cmp > 0) r.isub(this.p);
else if (r.strip !== void 0) r.strip();
else r._strip();
return r;
};
MPrime.prototype.split = function split(input, out) {
input.iushrn(this.n, 0, out);
};
MPrime.prototype.imulK = function imulK(num) {
return num.imul(this.k);
};
function K256() {
MPrime.call(this, "k256", "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f");
}
inherits(K256, MPrime);
K256.prototype.split = function split(input, output) {
var mask = 4194303;
var outLen = Math.min(input.length, 9);
for (var 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");
}
inherits(P224, MPrime);
function P192() {
MPrime.call(this, "p192", "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff");
}
inherits(P192, MPrime);
function P25519() {
MPrime.call(this, "25519", "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed");
}
inherits(P25519, MPrime);
P25519.prototype.imulK = function imulK(num) {
var carry = 0;
for (var 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;
};
BN._prime = function prime(name) {
if (primes[name]) return primes[name];
var prime;
if (name === "k256") prime = new K256();
else if (name === "p224") prime = new P224();
else if (name === "p192") prime = new P192();
else if (name === "p25519") prime = new P25519();
else throw new Error("Unknown prime " + name);
primes[name] = prime;
return prime;
};
function Red(m) {
if (typeof m === "string") {
var prime = BN._prime(m);
this.m = prime.p;
this.prime = prime;
} else {
assert(m.gtn(1), "modulus must be greater than 1");
this.m = m;
this.prime = null;
}
}
Red.prototype._verify1 = function _verify1(a) {
assert(a.negative === 0, "red works only with positives");
assert(a.red, "red works only with red numbers");
};
Red.prototype._verify2 = function _verify2(a, b) {
assert((a.negative | b.negative) === 0, "red works only with positives");
assert(a.red && a.red === b.red, "red works only with red numbers");
};
Red.prototype.imod = function imod(a) {
if (this.prime) return this.prime.ireduce(a)._forceRed(this);
return a.umod(this.m)._forceRed(this);
};
Red.prototype.neg = function neg(a) {
if (a.isZero()) return a.clone();
return this.m.sub(a)._forceRed(this);
};
Red.prototype.add = function add(a, b) {
this._verify2(a, b);
var res = a.add(b);
if (res.cmp(this.m) >= 0) res.isub(this.m);
return res._forceRed(this);
};
Red.prototype.iadd = function iadd(a, b) {
this._verify2(a, b);
var res = a.iadd(b);
if (res.cmp(this.m) >= 0) res.isub(this.m);
return res;
};
Red.prototype.sub = function sub(a, b) {
this._verify2(a, b);
var res = a.sub(b);
if (res.cmpn(0) < 0) res.iadd(this.m);
return res._forceRed(this);
};
Red.prototype.isub = function isub(a, b) {
this._verify2(a, b);
var res = a.isub(b);
if (res.cmpn(0) < 0) res.iadd(this.m);
return res;
};
Red.prototype.shl = function shl(a, num) {
this._verify1(a);
return this.imod(a.ushln(num));
};
Red.prototype.imul = function imul(a, b) {
this._verify2(a, b);
return this.imod(a.imul(b));
};
Red.prototype.mul = function mul(a, b) {
this._verify2(a, b);
return this.imod(a.mul(b));
};
Red.prototype.isqr = function isqr(a) {
return this.imul(a, a.clone());
};
Red.prototype.sqr = function sqr(a) {
return this.mul(a, a);
};
Red.prototype.sqrt = function sqrt(a) {
if (a.isZero()) return a.clone();
var mod3 = this.m.andln(3);
assert(mod3 % 2 === 1);
if (mod3 === 3) {
var pow = this.m.add(new BN(1)).iushrn(2);
return this.pow(a, pow);
}
var q = this.m.subn(1);
var s = 0;
while (!q.isZero() && q.andln(1) === 0) {
s++;
q.iushrn(1);
}
assert(!q.isZero());
var one = new BN(1).toRed(this);
var nOne = one.redNeg();
var lpow = this.m.subn(1).iushrn(1);
var z = this.m.bitLength();
z = new BN(2 * z * z).toRed(this);
while (this.pow(z, lpow).cmp(nOne) !== 0) z.redIAdd(nOne);
var c = this.pow(z, q);
var r = this.pow(a, q.addn(1).iushrn(1));
var t = this.pow(a, q);
var m = s;
while (t.cmp(one) !== 0) {
var tmp = t;
for (var i = 0; tmp.cmp(one) !== 0; i++) tmp = tmp.redSqr();
assert(i < m);
var b = this.pow(c, new BN(1).iushln(m - i - 1));
r = r.redMul(b);
c = b.redSqr();
t = t.redMul(c);
m = i;
}
return r;
};
Red.prototype.invm = function invm(a) {
var inv = a._invmp(this.m);
if (inv.negative !== 0) {
inv.negative = 0;
return this.imod(inv).redNeg();
} else return this.imod(inv);
};
Red.prototype.pow = function pow(a, num) {
if (num.isZero()) return new BN(1).toRed(this);
if (num.cmpn(1) === 0) return a.clone();
var windowSize = 4;
var wnd = new Array(1 << windowSize);
wnd[0] = new BN(1).toRed(this);
wnd[1] = a;
for (var 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 r = num.umod(this.m);
return r === num ? r.clone() : r;
};
Red.prototype.convertFrom = function convertFrom(num) {
var res = num.clone();
res.red = null;
return res;
};
BN.mont = function mont(num) {
return new Mont(num);
};
function Mont(m) {
Red.call(this, m);
this.shift = this.m.bitLength();
if (this.shift % 26 !== 0) this.shift += 26 - this.shift % 26;
this.r = new BN(1).iushln(this.shift);
this.r2 = this.imod(this.r.sqr());
this.rinv = this.r._invmp(this.m);
this.minv = this.rinv.mul(this.r).isubn(1).div(this.m);
this.minv = this.minv.umod(this.r);
this.minv = this.r.sub(this.minv);
}
inherits(Mont, Red);
Mont.prototype.convertTo = function convertTo(num) {
return this.imod(num.ushln(this.shift));
};
Mont.prototype.convertFrom = function convertFrom(num) {
var r = this.imod(num.mul(this.rinv));
r.red = null;
return r;
};
Mont.prototype.imul = function imul(a, b) {
if (a.isZero() || b.isZero()) {
a.words[0] = 0;
a.length = 1;
return a;
}
var t = a.imul(b);
var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
var u = t.isub(c).iushrn(this.shift);
var res = u;
if (u.cmp(this.m) >= 0) res = u.isub(this.m);
else if (u.cmpn(0) < 0) res = u.iadd(this.m);
return res._forceRed(this);
};
Mont.prototype.mul = function mul(a, b) {
if (a.isZero() || b.isZero()) return new BN(0)._forceRed(this);
var t = a.mul(b);
var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
var u = t.isub(c).iushrn(this.shift);
var res = u;
if (u.cmp(this.m) >= 0) res = u.isub(this.m);
else if (u.cmpn(0) < 0) res = u.iadd(this.m);
return res._forceRed(this);
};
Mont.prototype.invm = function invm(a) {
return this.imod(a._invmp(this.m).mul(this.r2))._forceRed(this);
};
})(typeof module === "undefined" || module, exports);
}));
//#endregion
//#region node_modules/public-encrypt/withPublic.js
var require_withPublic = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var BN = require_bn();
var Buffer = require_safe_buffer$9().Buffer;
function withPublic(paddedMsg, key) {
return Buffer.from(paddedMsg.toRed(BN.mont(key.modulus)).redPow(new BN(key.publicExponent)).fromRed().toArray());
}
module.exports = withPublic;
}));
//#endregion
//#region node_modules/public-encrypt/publicEncrypt.js
var require_publicEncrypt = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var parseKeys = require_parse_asn1();
var randomBytes = require_browser$11();
var createHash = require_browser$10();
var mgf = require_mgf();
var xor = require_xor();
var BN = require_bn();
var withPublic = require_withPublic();
var crt = require_browserify_rsa();
var Buffer = require_safe_buffer$9().Buffer;
module.exports = function publicEncrypt(publicKey, msg, reverse) {
var padding;
if (publicKey.padding) padding = publicKey.padding;
else if (reverse) padding = 1;
else padding = 4;
var key = parseKeys(publicKey);
var paddedMsg;
if (padding === 4) paddedMsg = oaep(key, msg);
else if (padding === 1) paddedMsg = pkcs1(key, msg, reverse);
else if (padding === 3) {
paddedMsg = new BN(msg);
if (paddedMsg.cmp(key.modulus) >= 0) throw new Error("data too long for modulus");
} else throw new Error("unknown padding");
if (reverse) return crt(paddedMsg, key);
else return withPublic(paddedMsg, key);
};
function oaep(key, msg) {
var k = key.modulus.byteLength();
var mLen = msg.length;
var iHash = createHash("sha1").update(Buffer.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.alloc(k - mLen - hLen2 - 2);
var dblen = k - hLen - 1;
var seed = randomBytes(hLen);
var maskedDb = xor(Buffer.concat([
iHash,
ps,
Buffer.alloc(1, 1),
msg
], dblen), mgf(seed, dblen));
var maskedSeed = xor(seed, mgf(maskedDb, hLen));
return new BN(Buffer.concat([
Buffer.alloc(1),
maskedSeed,
maskedDb
], k));
}
function pkcs1(key, msg, reverse) {
var mLen = msg.length;
var k = key.modulus.byteLength();
if (mLen > k - 11) throw new Error("message too long");
var ps;
if (reverse) ps = Buffer.alloc(k - mLen - 3, 255);
else ps = nonZero(k - mLen - 3);
return new BN(Buffer.concat([
Buffer.from([0, reverse ? 1 : 2]),
ps,
Buffer.alloc(1),
msg
], k));
}
function nonZero(len) {
var out = Buffer.allocUnsafe(len);
var i = 0;
var cache = randomBytes(len * 2);
var cur = 0;
var num;
while (i < len) {
if (cur === cache.length) {
cache = randomBytes(len * 2);
cur = 0;
}
num = cache[cur++];
if (num) out[i++] = num;
}
return out;
}
}));
//#endregion
//#region node_modules/public-encrypt/privateDecrypt.js
var require_privateDecrypt = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var parseKeys = require_parse_asn1();
var mgf = require_mgf();
var xor = require_xor();
var BN = require_bn();
var crt = require_browserify_rsa();
var createHash = require_browser$10();
var withPublic = require_withPublic();
var Buffer = require_safe_buffer$9().Buffer;
module.exports = function privateDecrypt(privateKey, enc, reverse) {
var padding;
if (privateKey.padding) padding = privateKey.padding;
else if (reverse) padding = 1;
else padding = 4;
var key = parseKeys(privateKey);
var k = key.modulus.byteLength();
if (enc.length > k || new BN(enc).cmp(key.modulus) >= 0) throw new Error("decryption error");
var msg;
if (reverse) msg = withPublic(new BN(enc), key);
else msg = crt(enc, key);
var zBuffer = Buffer.alloc(k - msg.length);
msg = Buffer.concat([zBuffer, msg], k);
if (padding === 4) return oaep(key, msg);
else if (padding === 1) return pkcs1(key, msg, reverse);
else if (padding === 3) return msg;
else throw new Error("unknown padding");
};
function oaep(key, msg) {
var k = key.modulus.byteLength();
var iHash = createHash("sha1").update(Buffer.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 db = xor(maskedDb, mgf(xor(maskedSeed, mgf(maskedDb, hLen)), 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(key, 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.from(a);
b = Buffer.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;
}
}));
//#endregion
//#region node_modules/public-encrypt/browser.js
var require_browser$2 = /* @__PURE__ */ __commonJSMin(((exports) => {
exports.publicEncrypt = require_publicEncrypt();
exports.privateDecrypt = require_privateDecrypt();
exports.privateEncrypt = function privateEncrypt(key, buf) {
return exports.publicEncrypt(key, buf, true);
};
exports.publicDecrypt = function publicDecrypt(key, buf) {
return exports.privateDecrypt(key, buf, true);
};
}));
//#endregion
//#region node_modules/randomfill/browser.js
var require_browser$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
init_dist();
init_dist$2();
function oldBrowser() {
throw new Error("secure random number generation not supported by this browser\nuse chrome, FireFox or Internet Explorer 11");
}
var safeBuffer = require_safe_buffer$9();
var randombytes = require_browser$11();
var Buffer = safeBuffer.Buffer;
var kBufferMaxLength = safeBuffer.kMaxLength;
var crypto = global.crypto || global.msCrypto;
var kMaxUint32 = Math.pow(2, 32) - 1;
function assertOffset(offset, length) {
if (typeof offset !== "number" || offset !== offset) throw new TypeError("offset must be a number");
if (offset > kMaxUint32 || offset < 0) throw new TypeError("offset must be a uint32");
if (offset > kBufferMaxLength || offset > length) throw new RangeError("offset out of range");
}
function assertSize(size, offset, length) {
if (typeof size !== "number" || size !== size) throw new TypeError("size must be a number");
if (size > kMaxUint32 || size < 0) throw new TypeError("size must be a uint32");
if (size + offset > length || size > kBufferMaxLength) throw new RangeError("buffer too small");
}
if (crypto && crypto.getRandomValues || !process$1.browser) {
exports.randomFill = randomFill;
exports.randomFillSync = randomFillSync;
} else {
exports.randomFill = oldBrowser;
exports.randomFillSync = oldBrowser;
}
function randomFill(buf, offset, size, cb) {
if (!Buffer.isBuffer(buf) && !(buf instanceof global.Uint8Array)) throw new TypeError("\"buf\" argument must be a Buffer or Uint8Array");
if (typeof offset === "function") {
cb = offset;
offset = 0;
size = buf.length;
} else if (typeof size === "function") {
cb = size;
size = buf.length - offset;
} else if (typeof cb !== "function") throw new TypeError("\"cb\" argument must be a function");
assertOffset(offset, buf.length);
assertSize(size, offset, buf.length);
return actualFill(buf, offset, size, cb);
}
function actualFill(buf, offset, size, cb) {
if (process$1.browser) {
var ourBuf = buf.buffer;
var uint = new Uint8Array(ourBuf, offset, size);
crypto.getRandomValues(uint);
if (cb) {
process$1.nextTick(function() {
cb(null, buf);
});
return;
}
return buf;
}
if (cb) {
randombytes(size, function(err, bytes) {
if (err) return cb(err);
bytes.copy(buf, offset);
cb(null, buf);
});
return;
}
randombytes(size).copy(buf, offset);
return buf;
}
function randomFillSync(buf, offset, size) {
if (typeof offset === "undefined") offset = 0;
if (!Buffer.isBuffer(buf) && !(buf instanceof global.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);
}
}));
//#endregion
//#region node_modules/crypto-browserify/index.js
var require_crypto_browserify = /* @__PURE__ */ __commonJSMin(((exports) => {
exports.randomBytes = exports.rng = exports.pseudoRandomBytes = exports.prng = require_browser$11();
exports.createHash = exports.Hash = require_browser$10();
exports.createHmac = exports.Hmac = require_browser$9();
var algos = require_algos();
var algoKeys = Object.keys(algos);
var hashes = [
"sha1",
"sha224",
"sha256",
"sha384",
"sha512",
"md5",
"rmd160"
].concat(algoKeys);
exports.getHashes = function() {
return hashes;
};
var p = require_browser$8();
exports.pbkdf2 = p.pbkdf2;
exports.pbkdf2Sync = p.pbkdf2Sync;
var aes = require_browser$6();
exports.Cipher = aes.Cipher;
exports.createCipher = aes.createCipher;
exports.Cipheriv = aes.Cipheriv;
exports.createCipheriv = aes.createCipheriv;
exports.Decipher = aes.Decipher;
exports.createDecipher = aes.createDecipher;
exports.Decipheriv = aes.Decipheriv;
exports.createDecipheriv = aes.createDecipheriv;
exports.getCiphers = aes.getCiphers;
exports.listCiphers = aes.listCiphers;
var dh = require_browser$5();
exports.DiffieHellmanGroup = dh.DiffieHellmanGroup;
exports.createDiffieHellmanGroup = dh.createDiffieHellmanGroup;
exports.getDiffieHellman = dh.getDiffieHellman;
exports.createDiffieHellman = dh.createDiffieHellman;
exports.DiffieHellman = dh.DiffieHellman;
var sign = require_browser$4();
exports.createSign = sign.createSign;
exports.Sign = sign.Sign;
exports.createVerify = sign.createVerify;
exports.Verify = sign.Verify;
exports.createECDH = require_browser$3();
var publicEncrypt = require_browser$2();
exports.publicEncrypt = publicEncrypt.publicEncrypt;
exports.privateEncrypt = publicEncrypt.privateEncrypt;
exports.publicDecrypt = publicEncrypt.publicDecrypt;
exports.privateDecrypt = publicEncrypt.privateDecrypt;
var rf = require_browser$1();
exports.randomFill = rf.randomFill;
exports.randomFillSync = rf.randomFillSync;
exports.createCredentials = function() {
throw new Error("sorry, createCredentials is not implemented yet\nwe accept pull requests\nhttps://github.com/browserify/crypto-browserify");
};
exports.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
};
}));
//#endregion
//#region node_modules/crypto-js/core.js
var require_core = /* @__PURE__ */ __commonJSMin(((exports, module) => {
init_dist();
(function(root, factory) {
if (typeof exports === "object") module.exports = exports = factory();
else if (typeof define === "function" && define.amd) define([], factory);
else root.CryptoJS = factory();
})(exports, function() {
/**
* CryptoJS core components.
*/
var CryptoJS = CryptoJS || function(Math, undefined) {
var crypto;
if (typeof window !== "undefined" && window.crypto) crypto = window.crypto;
if (typeof self !== "undefined" && self.crypto) crypto = self.crypto;
if (typeof globalThis !== "undefined" && globalThis.crypto) crypto = globalThis.crypto;
if (!crypto && typeof window !== "undefined" && window.msCrypto) crypto = window.msCrypto;
if (!crypto && typeof global !== "undefined" && global.crypto) crypto = global.crypto;
if (!crypto && typeof require === "function") try {
crypto = require_crypto_browserify();
} catch (err) {}
var cryptoSecureRandomInt = function() {
if (crypto) {
if (typeof crypto.getRandomValues === "function") try {
return crypto.getRandomValues(/* @__PURE__ */ new Uint32Array(1))[0];
} catch (err) {}
if (typeof crypto.randomBytes === "function") try {
return crypto.randomBytes(4).readInt32LE();
} catch (err) {}
}
throw new Error("Native crypto module could not be used to get secure random number.");
};
var create = Object.create || function() {
function F() {}
return function(obj) {
var subtype;
F.prototype = obj;
subtype = new F();
F.prototype = null;
return subtype;
};
}();
/**
* CryptoJS namespace.
*/
var C = {};
/**
* Library namespace.
*/
var C_lib = C.lib = {};
/**
* Base object for prototypal inheritance.
*/
var Base = C_lib.Base = function() {
return {
/**
* Creates a new object that inherits from this object.
*
* @param {Object} overrides Properties to copy into the new object.
*
* @return {Object} The new object.
*
* @static
*
* @example
*
* var MyType = CryptoJS.lib.Base.extend({
* field: 'value',
*
* method: function () {
* }
* });
*/
extend: function(overrides) {
var subtype = create(this);
if (overrides) subtype.mixIn(overrides);
if (!subtype.hasOwnProperty("init") || this.init === subtype.init) subtype.init = function() {
subtype.$super.init.apply(this, arguments);
};
subtype.init.prototype = subtype;
subtype.$super = this;
return subtype;
},
/**
* Extends this object and runs the init method.
* Arguments to create() will be passed to init().
*
* @return {Object} The new object.
*
* @static
*
* @example
*
* var instance = MyType.create();
*/
create: function() {
var instance = this.extend();
instance.init.apply(instance, arguments);
return instance;
},
/**
* Initializes a newly created object.
* Override this method to add some logic when your objects are created.
*
* @example
*
* var MyType = CryptoJS.lib.Base.extend({
* init: function () {
* // ...
* }
* });
*/
init: function() {},
/**
* Copies properties into this object.
*
* @param {Object} properties The properties to mix in.
*
* @example
*
* MyType.mixIn({
* field: 'value'
* });
*/
mixIn: function(properties) {
for (var propertyName in properties) if (properties.hasOwnProperty(propertyName)) this[propertyName] = properties[propertyName];
if (properties.hasOwnProperty("toString")) this.toString = properties.toString;
},
/**
* Creates a copy of this object.
*
* @return {Object} The clone.
*
* @example
*
* var clone = instance.clone();
*/
clone: function() {
return this.init.prototype.extend(this);
}
};
}();
/**
* An array of 32-bit words.
*
* @property {Array} words The array of 32-bit words.
* @property {number} sigBytes The number of significant bytes in this word array.
*/
var WordArray = C_lib.WordArray = Base.extend({
/**
* Initializes a newly created word array.
*
* @param {Array} words (Optional) An array of 32-bit words.
* @param {number} sigBytes (Optional) The number of significant bytes in the words.
*
* @example
*
* var wordArray = CryptoJS.lib.WordArray.create();
* var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607]);
* var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607], 6);
*/
init: function(words, sigBytes) {
words = this.words = words || [];
if (sigBytes != undefined) this.sigBytes = sigBytes;
else this.sigBytes = words.length * 4;
},
/**
* Converts this word array to a string.
*
* @param {Encoder} encoder (Optional) The encoding strategy to use. Default: CryptoJS.enc.Hex
*
* @return {string} The stringified word array.
*
* @example
*
* var string = wordArray + '';
* var string = wordArray.toString();
* var string = wordArray.toString(CryptoJS.enc.Utf8);
*/
toString: function(encoder) {
return (encoder || Hex).stringify(this);
},
/**
* Concatenates a word array to this word array.
*
* @param {WordArray} wordArray The word array to append.
*
* @return {WordArray} This word array.
*
* @example
*
* wordArray1.concat(wordArray2);
*/
concat: function(wordArray) {
var thisWords = this.words;
var thatWords = wordArray.words;
var thisSigBytes = this.sigBytes;
var thatSigBytes = wordArray.sigBytes;
this.clamp();
if (thisSigBytes % 4) for (var i = 0; i < thatSigBytes; i++) {
var thatByte = thatWords[i >>> 2] >>> 24 - i % 4 * 8 & 255;
thisWords[thisSigBytes + i >>> 2] |= thatByte << 24 - (thisSigBytes + i) % 4 * 8;
}
else for (var j = 0; j < thatSigBytes; j += 4) thisWords[thisSigBytes + j >>> 2] = thatWords[j >>> 2];
this.sigBytes += thatSigBytes;
return this;
},
/**
* Removes insignificant bits.
*
* @example
*
* wordArray.clamp();
*/
clamp: function() {
var words = this.words;
var sigBytes = this.sigBytes;
words[sigBytes >>> 2] &= 4294967295 << 32 - sigBytes % 4 * 8;
words.length = Math.ceil(sigBytes / 4);
},
/**
* Creates a copy of this word array.
*
* @return {WordArray} The clone.
*
* @example
*
* var clone = wordArray.clone();
*/
clone: function() {
var clone = Base.clone.call(this);
clone.words = this.words.slice(0);
return clone;
},
/**
* Creates a word array filled with random bytes.
*
* @param {number} nBytes The number of random bytes to generate.
*
* @return {WordArray} The random word array.
*
* @static
*
* @example
*
* var wordArray = CryptoJS.lib.WordArray.random(16);
*/
random: function(nBytes) {
var words = [];
for (var i = 0; i < nBytes; i += 4) words.push(cryptoSecureRandomInt());
return new WordArray.init(words, nBytes);
}
});
/**
* Encoder namespace.
*/
var C_enc = C.enc = {};
/**
* Hex encoding strategy.
*/
var Hex = C_enc.Hex = {
/**
* Converts a word array to a hex string.
*
* @param {WordArray} wordArray The word array.
*
* @return {string} The hex string.
*
* @static
*
* @example
*
* var hexString = CryptoJS.enc.Hex.stringify(wordArray);
*/
stringify: function(wordArray) {
var words = wordArray.words;
var sigBytes = wordArray.sigBytes;
var hexChars = [];
for (var i = 0; i < sigBytes; i++) {
var bite = words[i >>> 2] >>> 24 - i % 4 * 8 & 255;
hexChars.push((bite >>> 4).toString(16));
hexChars.push((bite & 15).toString(16));
}
return hexChars.join("");
},
/**
* Converts a hex string to a word array.
*
* @param {string} hexStr The hex string.
*
* @return {WordArray} The word array.
*
* @static
*
* @example
*
* var wordArray = CryptoJS.enc.Hex.parse(hexString);
*/
parse: function(hexStr) {
var hexStrLength = hexStr.length;
var words = [];
for (var i = 0; i < hexStrLength; i += 2) words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << 24 - i % 8 * 4;
return new WordArray.init(words, hexStrLength / 2);
}
};
/**
* Latin1 encoding strategy.
*/
var Latin1 = C_enc.Latin1 = {
/**
* Converts a word array to a Latin1 string.
*
* @param {WordArray} wordArray The word array.
*
* @return {string} The Latin1 string.
*
* @static
*
* @example
*
* var latin1String = CryptoJS.enc.Latin1.stringify(wordArray);
*/
stringify: function(wordArray) {
var words = wordArray.words;
var sigBytes = wordArray.sigBytes;
var latin1Chars = [];
for (var i = 0; i < sigBytes; i++) {
var bite = words[i >>> 2] >>> 24 - i % 4 * 8 & 255;
latin1Chars.push(String.fromCharCode(bite));
}
return latin1Chars.join("");
},
/**
* Converts a Latin1 string to a word array.
*
* @param {string} latin1Str The Latin1 string.
*
* @return {WordArray} The word array.
*
* @static
*
* @example
*
* var wordArray = CryptoJS.enc.Latin1.parse(latin1String);
*/
parse: function(latin1Str) {
var latin1StrLength = latin1Str.length;
var words = [];
for (var i = 0; i < latin1StrLength; i++) words[i >>> 2] |= (latin1Str.charCodeAt(i) & 255) << 24 - i % 4 * 8;
return new WordArray.init(words, latin1StrLength);
}
};
/**
* UTF-8 encoding strategy.
*/
var Utf8 = C_enc.Utf8 = {
/**
* Converts a word array to a UTF-8 string.
*
* @param {WordArray} wordArray The word array.
*
* @return {string} The UTF-8 string.
*
* @static
*
* @example
*
* var utf8String = CryptoJS.enc.Utf8.stringify(wordArray);
*/
stringify: function(wordArray) {
try {
return decodeURIComponent(escape(Latin1.stringify(wordArray)));
} catch (e) {
throw new Error("Malformed UTF-8 data");
}
},
/**
* Converts a UTF-8 string to a word array.
*
* @param {string} utf8Str The UTF-8 string.
*
* @return {WordArray} The word array.
*
* @static
*
* @example
*
* var wordArray = CryptoJS.enc.Utf8.parse(utf8String);
*/
parse: function(utf8Str) {
return Latin1.parse(unescape(encodeURIComponent(utf8Str)));
}
};
/**
* Abstract buffered block algorithm template.
*
* The property blockSize must be implemented in a concrete subtype.
*
* @property {number} _minBufferSize The number of blocks that should be kept unprocessed in the buffer. Default: 0
*/
var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({
/**
* Resets this block algorithm's data buffer to its initial state.
*
* @example
*
* bufferedBlockAlgorithm.reset();
*/
reset: function() {
this._data = new WordArray.init();
this._nDataBytes = 0;
},
/**
* Adds new data to this block algorithm's buffer.
*
* @param {WordArray|string} data The data to append. Strings are converted to a WordArray using UTF-8.
*
* @example
*
* bufferedBlockAlgorithm._append('data');
* bufferedBlockAlgorithm._append(wordArray);
*/
_append: function(data) {
if (typeof data == "string") data = Utf8.parse(data);
this._data.concat(data);
this._nDataBytes += data.sigBytes;
},
/**
* Processes available data blocks.
*
* This method invokes _doProcessBlock(offset), which must be implemented by a concrete subtype.
*
* @param {boolean} doFlush Whether all blocks and partial blocks should be processed.
*
* @return {WordArray} The processed data.
*
* @example
*
* var processedData = bufferedBlockAlgorithm._process();
* var processedData = bufferedBlockAlgorithm._process(!!'flush');
*/
_process: function(doFlush) {
var processedWords;
var data = this._data;
var dataWords = data.words;
var dataSigBytes = data.sigBytes;
var blockSize = this.blockSize;
var nBlocksReady = dataSigBytes / (blockSize * 4);
if (doFlush) nBlocksReady = Math.ceil(nBlocksReady);
else nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);
var nWordsReady = nBlocksReady * blockSize;
var nBytesReady = Math.min(nWordsReady * 4, dataSigBytes);
if (nWordsReady) {
for (var offset = 0; offset < nWordsReady; offset += blockSize) this._doProcessBlock(dataWords, offset);
processedWords = dataWords.splice(0, nWordsReady);
data.sigBytes -= nBytesReady;
}
return new WordArray.init(processedWords, nBytesReady);
},
/**
* Creates a copy of this object.
*
* @return {Object} The clone.
*
* @example
*
* var clone = bufferedBlockAlgorithm.clone();
*/
clone: function() {
var clone = Base.clone.call(this);
clone._data = this._data.clone();
return clone;
},
_minBufferSize: 0
});
C_lib.Hasher = BufferedBlockAlgorithm.extend({
/**
* Configuration options.
*/
cfg: Base.extend(),
/**
* Initializes a newly created hasher.
*
* @param {Object} cfg (Optional) The configuration options to use for this hash computation.
*
* @example
*
* var hasher = CryptoJS.algo.SHA256.create();
*/
init: function(cfg) {
this.cfg = this.cfg.extend(cfg);
this.reset();
},
/**
* Resets this hasher to its initial state.
*
* @example
*
* hasher.reset();
*/
reset: function() {
BufferedBlockAlgorithm.reset.call(this);
this._doReset();
},
/**
* Updates this hasher with a message.
*
* @param {WordArray|string} messageUpdate The message to append.
*
* @return {Hasher} This hasher.
*
* @example
*
* hasher.update('message');
* hasher.update(wordArray);
*/
update: function(messageUpdate) {
this._append(messageUpdate);
this._process();
return this;
},
/**
* Finalizes the hash computation.
* Note that the finalize operation is effectively a destructive, read-once operation.
*
* @param {WordArray|string} messageUpdate (Optional) A final message update.
*
* @return {WordArray} The hash.
*
* @example
*
* var hash = hasher.finalize();
* var hash = hasher.finalize('message');
* var hash = hasher.finalize(wordArray);
*/
finalize: function(messageUpdate) {
if (messageUpdate) this._append(messageUpdate);
return this._doFinalize();
},
blockSize: 512 / 32,
/**
* Creates a shortcut function to a hasher's object interface.
*
* @param {Hasher} hasher The hasher to create a helper for.
*
* @return {Function} The shortcut function.
*
* @static
*
* @example
*
* var SHA256 = CryptoJS.lib.Hasher._createHelper(CryptoJS.algo.SHA256);
*/
_createHelper: function(hasher) {
return function(message, cfg) {
return new hasher.init(cfg).finalize(message);
};
},
/**
* Creates a shortcut function to the HMAC's object interface.
*
* @param {Hasher} hasher The hasher to use in this HMAC helper.
*
* @return {Function} The shortcut function.
*
* @static
*
* @example
*
* var HmacSHA256 = CryptoJS.lib.Hasher._createHmacHelper(CryptoJS.algo.SHA256);
*/
_createHmacHelper: function(hasher) {
return function(message, key) {
return new C_algo.HMAC.init(hasher, key).finalize(message);
};
}
});
/**
* Algorithm namespace.
*/
var C_algo = C.algo = {};
return C;
}(Math);
return CryptoJS;
});
}));
//#endregion
//#region node_modules/crypto-js/enc-base64.js
var require_enc_base64 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
(function(root, factory) {
if (typeof exports === "object") module.exports = exports = factory(require_core());
else if (typeof define === "function" && define.amd) define(["./core"], factory);
else factory(root.CryptoJS);
})(exports, function(CryptoJS) {
(function() {
var C = CryptoJS;
var WordArray = C.lib.WordArray;
var C_enc = C.enc;
C_enc.Base64 = {
/**
* Converts a word array to a Base64 string.
*
* @param {WordArray} wordArray The word array.
*
* @return {string} The Base64 string.
*
* @static
*
* @example
*
* var base64String = CryptoJS.enc.Base64.stringify(wordArray);
*/
stringify: function(wordArray) {
var words = wordArray.words;
var sigBytes = wordArray.sigBytes;
var map = this._map;
wordArray.clamp();
var base64Chars = [];
for (var i = 0; i < sigBytes; i += 3) {
var byte1 = words[i >>> 2] >>> 24 - i % 4 * 8 & 255;
var byte2 = words[i + 1 >>> 2] >>> 24 - (i + 1) % 4 * 8 & 255;
var byte3 = words[i + 2 >>> 2] >>> 24 - (i + 2) % 4 * 8 & 255;
var triplet = byte1 << 16 | byte2 << 8 | byte3;
for (var j = 0; j < 4 && i + j * .75 < sigBytes; j++) base64Chars.push(map.charAt(triplet >>> 6 * (3 - j) & 63));
}
var paddingChar = map.charAt(64);
if (paddingChar) while (base64Chars.length % 4) base64Chars.push(paddingChar);
return base64Chars.join("");
},
/**
* Converts a Base64 string to a word array.
*
* @param {string} base64Str The Base64 string.
*
* @return {WordArray} The word array.
*
* @static
*
* @example
*
* var wordArray = CryptoJS.enc.Base64.parse(base64String);
*/
parse: function(base64Str) {
var base64StrLength = base64Str.length;
var map = this._map;
var reverseMap = this._reverseMap;
if (!reverseMap) {
reverseMap = this._reverseMap = [];
for (var j = 0; j < map.length; j++) reverseMap[map.charCodeAt(j)] = j;
}
var paddingChar = map.charAt(64);
if (paddingChar) {
var paddingIndex = base64Str.indexOf(paddingChar);
if (paddingIndex !== -1) base64StrLength = paddingIndex;
}
return parseLoop(base64Str, base64StrLength, reverseMap);
},
_map: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="
};
function parseLoop(base64Str, base64StrLength, reverseMap) {
var words = [];
var nBytes = 0;
for (var i = 0; i < base64StrLength; i++) if (i % 4) {
var bitsCombined = reverseMap[base64Str.charCodeAt(i - 1)] << i % 4 * 2 | reverseMap[base64Str.charCodeAt(i)] >>> 6 - i % 4 * 2;
words[nBytes >>> 2] |= bitsCombined << 24 - nBytes % 4 * 8;
nBytes++;
}
return WordArray.create(words, nBytes);
}
})();
return CryptoJS.enc.Base64;
});
}));
//#endregion
//#region node_modules/crypto-js/md5.js
var require_md5 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
(function(root, factory) {
if (typeof exports === "object") module.exports = exports = factory(require_core());
else if (typeof define === "function" && define.amd) define(["./core"], factory);
else factory(root.CryptoJS);
})(exports, function(CryptoJS) {
(function(Math) {
var C = CryptoJS;
var C_lib = C.lib;
var WordArray = C_lib.WordArray;
var Hasher = C_lib.Hasher;
var C_algo = C.algo;
var T = [];
(function() {
for (var i = 0; i < 64; i++) T[i] = Math.abs(Math.sin(i + 1)) * 4294967296 | 0;
})();
/**
* MD5 hash algorithm.
*/
var MD5 = C_algo.MD5 = Hasher.extend({
_doReset: function() {
this._hash = new WordArray.init([
1732584193,
4023233417,
2562383102,
271733878
]);
},
_doProcessBlock: function(M, offset) {
for (var i = 0; i < 16; i++) {
var offset_i = offset + i;
var M_offset_i = M[offset_i];
M[offset_i] = (M_offset_i << 8 | M_offset_i >>> 24) & 16711935 | (M_offset_i << 24 | M_offset_i >>> 8) & 4278255360;
}
var H = this._hash.words;
var M_offset_0 = M[offset + 0];
var M_offset_1 = M[offset + 1];
var M_offset_2 = M[offset + 2];
var M_offset_3 = M[offset + 3];
var M_offset_4 = M[offset + 4];
var M_offset_5 = M[offset + 5];
var M_offset_6 = M[offset + 6];
var M_offset_7 = M[offset + 7];
var M_offset_8 = M[offset + 8];
var M_offset_9 = M[offset + 9];
var M_offset_10 = M[offset + 10];
var M_offset_11 = M[offset + 11];
var M_offset_12 = M[offset + 12];
var M_offset_13 = M[offset + 13];
var M_offset_14 = M[offset + 14];
var M_offset_15 = M[offset + 15];
var a = H[0];
var b = H[1];
var c = H[2];
var d = H[3];
a = FF(a, b, c, d, M_offset_0, 7, T[0]);
d = FF(d, a, b, c, M_offset_1, 12, T[1]);
c = FF(c, d, a, b, M_offset_2, 17, T[2]);
b = FF(b, c, d, a, M_offset_3, 22, T[3]);
a = FF(a, b, c, d, M_offset_4, 7, T[4]);
d = FF(d, a, b, c, M_offset_5, 12, T[5]);
c = FF(c, d, a, b, M_offset_6, 17, T[6]);
b = FF(b, c, d, a, M_offset_7, 22, T[7]);
a = FF(a, b, c, d, M_offset_8, 7, T[8]);
d = FF(d, a, b, c, M_offset_9, 12, T[9]);
c = FF(c, d, a, b, M_offset_10, 17, T[10]);
b = FF(b, c, d, a, M_offset_11, 22, T[11]);
a = FF(a, b, c, d, M_offset_12, 7, T[12]);
d = FF(d, a, b, c, M_offset_13, 12, T[13]);
c = FF(c, d, a, b, M_offset_14, 17, T[14]);
b = FF(b, c, d, a, M_offset_15, 22, T[15]);
a = GG(a, b, c, d, M_offset_1, 5, T[16]);
d = GG(d, a, b, c, M_offset_6, 9, T[17]);
c = GG(c, d, a, b, M_offset_11, 14, T[18]);
b = GG(b, c, d, a, M_offset_0, 20, T[19]);
a = GG(a, b, c, d, M_offset_5, 5, T[20]);
d = GG(d, a, b, c, M_offset_10, 9, T[21]);
c = GG(c, d, a, b, M_offset_15, 14, T[22]);
b = GG(b, c, d, a, M_offset_4, 20, T[23]);
a = GG(a, b, c, d, M_offset_9, 5, T[24]);
d = GG(d, a, b, c, M_offset_14, 9, T[25]);
c = GG(c, d, a, b, M_offset_3, 14, T[26]);
b = GG(b, c, d, a, M_offset_8, 20, T[27]);
a = GG(a, b, c, d, M_offset_13, 5, T[28]);
d = GG(d, a, b, c, M_offset_2, 9, T[29]);
c = GG(c, d, a, b, M_offset_7, 14, T[30]);
b = GG(b, c, d, a, M_offset_12, 20, T[31]);
a = HH(a, b, c, d, M_offset_5, 4, T[32]);
d = HH(d, a, b, c, M_offset_8, 11, T[33]);
c = HH(c, d, a, b, M_offset_11, 16, T[34]);
b = HH(b, c, d, a, M_offset_14, 23, T[35]);
a = HH(a, b, c, d, M_offset_1, 4, T[36]);
d = HH(d, a, b, c, M_offset_4, 11, T[37]);
c = HH(c, d, a, b, M_offset_7, 16, T[38]);
b = HH(b, c, d, a, M_offset_10, 23, T[39]);
a = HH(a, b, c, d, M_offset_13, 4, T[40]);
d = HH(d, a, b, c, M_offset_0, 11, T[41]);
c = HH(c, d, a, b, M_offset_3, 16, T[42]);
b = HH(b, c, d, a, M_offset_6, 23, T[43]);
a = HH(a, b, c, d, M_offset_9, 4, T[44]);
d = HH(d, a, b, c, M_offset_12, 11, T[45]);
c = HH(c, d, a, b, M_offset_15, 16, T[46]);
b = HH(b, c, d, a, M_offset_2, 23, T[47]);
a = II(a, b, c, d, M_offset_0, 6, T[48]);
d = II(d, a, b, c, M_offset_7, 10, T[49]);
c = II(c, d, a, b, M_offset_14, 15, T[50]);
b = II(b, c, d, a, M_offset_5, 21, T[51]);
a = II(a, b, c, d, M_offset_12, 6, T[52]);
d = II(d, a, b, c, M_offset_3, 10, T[53]);
c = II(c, d, a, b, M_offset_10, 15, T[54]);
b = II(b, c, d, a, M_offset_1, 21, T[55]);
a = II(a, b, c, d, M_offset_8, 6, T[56]);
d = II(d, a, b, c, M_offset_15, 10, T[57]);
c = II(c, d, a, b, M_offset_6, 15, T[58]);
b = II(b, c, d, a, M_offset_13, 21, T[59]);
a = II(a, b, c, d, M_offset_4, 6, T[60]);
d = II(d, a, b, c, M_offset_11, 10, T[61]);
c = II(c, d, a, b, M_offset_2, 15, T[62]);
b = II(b, c, d, a, M_offset_9, 21, T[63]);
H[0] = H[0] + a | 0;
H[1] = H[1] + b | 0;
H[2] = H[2] + c | 0;
H[3] = H[3] + d | 0;
},
_doFinalize: function() {
var data = this._data;
var dataWords = data.words;
var nBitsTotal = this._nDataBytes * 8;
var nBitsLeft = data.sigBytes * 8;
dataWords[nBitsLeft >>> 5] |= 128 << 24 - nBitsLeft % 32;
var nBitsTotalH = Math.floor(nBitsTotal / 4294967296);
var nBitsTotalL = nBitsTotal;
dataWords[(nBitsLeft + 64 >>> 9 << 4) + 15] = (nBitsTotalH << 8 | nBitsTotalH >>> 24) & 16711935 | (nBitsTotalH << 24 | nBitsTotalH >>> 8) & 4278255360;
dataWords[(nBitsLeft + 64 >>> 9 << 4) + 14] = (nBitsTotalL << 8 | nBitsTotalL >>> 24) & 16711935 | (nBitsTotalL << 24 | nBitsTotalL >>> 8) & 4278255360;
data.sigBytes = (dataWords.length + 1) * 4;
this._process();
var hash = this._hash;
var H = hash.words;
for (var i = 0; i < 4; i++) {
var H_i = H[i];
H[i] = (H_i << 8 | H_i >>> 24) & 16711935 | (H_i << 24 | H_i >>> 8) & 4278255360;
}
return hash;
},
clone: function() {
var clone = Hasher.clone.call(this);
clone._hash = this._hash.clone();
return clone;
}
});
function FF(a, b, c, d, x, s, t) {
var n = a + (b & c | ~b & d) + x + t;
return (n << s | n >>> 32 - s) + b;
}
function GG(a, b, c, d, x, s, t) {
var n = a + (b & d | c & ~d) + x + t;
return (n << s | n >>> 32 - s) + b;
}
function HH(a, b, c, d, x, s, t) {
var n = a + (b ^ c ^ d) + x + t;
return (n << s | n >>> 32 - s) + b;
}
function II(a, b, c, d, x, s, t) {
var n = a + (c ^ (b | ~d)) + x + t;
return (n << s | n >>> 32 - s) + b;
}
/**
* Shortcut function to the hasher's object interface.
*
* @param {WordArray|string} message The message to hash.
*
* @return {WordArray} The hash.
*
* @static
*
* @example
*
* var hash = CryptoJS.MD5('message');
* var hash = CryptoJS.MD5(wordArray);
*/
C.MD5 = Hasher._createHelper(MD5);
/**
* Shortcut function to the HMAC's object interface.
*
* @param {WordArray|string} message The message to hash.
* @param {WordArray|string} key The secret key.
*
* @return {WordArray} The HMAC.
*
* @static
*
* @example
*
* var hmac = CryptoJS.HmacMD5(message, key);
*/
C.HmacMD5 = Hasher._createHmacHelper(MD5);
})(Math);
return CryptoJS.MD5;
});
}));
//#endregion
//#region node_modules/crypto-js/sha1.js
var require_sha1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
(function(root, factory) {
if (typeof exports === "object") module.exports = exports = factory(require_core());
else if (typeof define === "function" && define.amd) define(["./core"], factory);
else factory(root.CryptoJS);
})(exports, function(CryptoJS) {
(function() {
var C = CryptoJS;
var C_lib = C.lib;
var WordArray = C_lib.WordArray;
var Hasher = C_lib.Hasher;
var C_algo = C.algo;
var W = [];
/**
* SHA-1 hash algorithm.
*/
var SHA1 = C_algo.SHA1 = Hasher.extend({
_doReset: function() {
this._hash = new WordArray.init([
1732584193,
4023233417,
2562383102,
271733878,
3285377520
]);
},
_doProcessBlock: function(M, offset) {
var H = this._hash.words;
var a = H[0];
var b = H[1];
var c = H[2];
var d = H[3];
var e = H[4];
for (var i = 0; i < 80; i++) {
if (i < 16) W[i] = M[offset + i] | 0;
else {
var n = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16];
W[i] = n << 1 | n >>> 31;
}
var t = (a << 5 | a >>> 27) + e + W[i];
if (i < 20) t += (b & c | ~b & d) + 1518500249;
else if (i < 40) t += (b ^ c ^ d) + 1859775393;
else if (i < 60) t += (b & c | b & d | c & d) - 1894007588;
else t += (b ^ c ^ d) - 899497514;
e = d;
d = c;
c = b << 30 | b >>> 2;
b = a;
a = t;
}
H[0] = H[0] + a | 0;
H[1] = H[1] + b | 0;
H[2] = H[2] + c | 0;
H[3] = H[3] + d | 0;
H[4] = H[4] + e | 0;
},
_doFinalize: function() {
var data = this._data;
var dataWords = data.words;
var nBitsTotal = this._nDataBytes * 8;
var nBitsLeft = data.sigBytes * 8;
dataWords[nBitsLeft >>> 5] |= 128 << 24 - nBitsLeft % 32;
dataWords[(nBitsLeft + 64 >>> 9 << 4) + 14] = Math.floor(nBitsTotal / 4294967296);
dataWords[(nBitsLeft + 64 >>> 9 << 4) + 15] = nBitsTotal;
data.sigBytes = dataWords.length * 4;
this._process();
return this._hash;
},
clone: function() {
var clone = Hasher.clone.call(this);
clone._hash = this._hash.clone();
return clone;
}
});
/**
* Shortcut function to the hasher's object interface.
*
* @param {WordArray|string} message The message to hash.
*
* @return {WordArray} The hash.
*
* @static
*
* @example
*
* var hash = CryptoJS.SHA1('message');
* var hash = CryptoJS.SHA1(wordArray);
*/
C.SHA1 = Hasher._createHelper(SHA1);
/**
* Shortcut function to the HMAC's object interface.
*
* @param {WordArray|string} message The message to hash.
* @param {WordArray|string} key The secret key.
*
* @return {WordArray} The HMAC.
*
* @static
*
* @example
*
* var hmac = CryptoJS.HmacSHA1(message, key);
*/
C.HmacSHA1 = Hasher._createHmacHelper(SHA1);
})();
return CryptoJS.SHA1;
});
}));
//#endregion
//#region node_modules/crypto-js/hmac.js
var require_hmac = /* @__PURE__ */ __commonJSMin(((exports, module) => {
(function(root, factory) {
if (typeof exports === "object") module.exports = exports = factory(require_core());
else if (typeof define === "function" && define.amd) define(["./core"], factory);
else factory(root.CryptoJS);
})(exports, function(CryptoJS) {
(function() {
var C = CryptoJS;
var Base = C.lib.Base;
var Utf8 = C.enc.Utf8;
var C_algo = C.algo;
C_algo.HMAC = Base.extend({
/**
* Initializes a newly created HMAC.
*
* @param {Hasher} hasher The hash algorithm to use.
* @param {WordArray|string} key The secret key.
*
* @example
*
* var hmacHasher = CryptoJS.algo.HMAC.create(CryptoJS.algo.SHA256, key);
*/
init: function(hasher, key) {
hasher = this._hasher = new hasher.init();
if (typeof key == "string") key = Utf8.parse(key);
var hasherBlockSize = hasher.blockSize;
var hasherBlockSizeBytes = hasherBlockSize * 4;
if (key.sigBytes > hasherBlockSizeBytes) key = hasher.finalize(key);
key.clamp();
var oKey = this._oKey = key.clone();
var iKey = this._iKey = key.clone();
var oKeyWords = oKey.words;
var iKeyWords = iKey.words;
for (var i = 0; i < hasherBlockSize; i++) {
oKeyWords[i] ^= 1549556828;
iKeyWords[i] ^= 909522486;
}
oKey.sigBytes = iKey.sigBytes = hasherBlockSizeBytes;
this.reset();
},
/**
* Resets this HMAC to its initial state.
*
* @example
*
* hmacHasher.reset();
*/
reset: function() {
var hasher = this._hasher;
hasher.reset();
hasher.update(this._iKey);
},
/**
* Updates this HMAC with a message.
*
* @param {WordArray|string} messageUpdate The message to append.
*
* @return {HMAC} This HMAC instance.
*
* @example
*
* hmacHasher.update('message');
* hmacHasher.update(wordArray);
*/
update: function(messageUpdate) {
this._hasher.update(messageUpdate);
return this;
},
/**
* Finalizes the HMAC computation.
* Note that the finalize operation is effectively a destructive, read-once operation.
*
* @param {WordArray|string} messageUpdate (Optional) A final message update.
*
* @return {WordArray} The HMAC.
*
* @example
*
* var hmac = hmacHasher.finalize();
* var hmac = hmacHasher.finalize('message');
* var hmac = hmacHasher.finalize(wordArray);
*/
finalize: function(messageUpdate) {
var hasher = this._hasher;
var innerHash = hasher.finalize(messageUpdate);
hasher.reset();
return hasher.finalize(this._oKey.clone().concat(innerHash));
}
});
})();
});
}));
//#endregion
//#region node_modules/crypto-js/evpkdf.js
var require_evpkdf = /* @__PURE__ */ __commonJSMin(((exports, module) => {
(function(root, factory, undef) {
if (typeof exports === "object") module.exports = exports = factory(require_core(), require_sha1(), require_hmac());
else if (typeof define === "function" && define.amd) define([
"./core",
"./sha1",
"./hmac"
], factory);
else factory(root.CryptoJS);
})(exports, function(CryptoJS) {
(function() {
var C = CryptoJS;
var C_lib = C.lib;
var Base = C_lib.Base;
var WordArray = C_lib.WordArray;
var C_algo = C.algo;
var MD5 = C_algo.MD5;
/**
* This key derivation function is meant to conform with EVP_BytesToKey.
* www.openssl.org/docs/crypto/EVP_BytesToKey.html
*/
var EvpKDF = C_algo.EvpKDF = Base.extend({
/**
* Configuration options.
*
* @property {number} keySize The key size in words to generate. Default: 4 (128 bits)
* @property {Hasher} hasher The hash algorithm to use. Default: MD5
* @property {number} iterations The number of iterations to perform. Default: 1
*/
cfg: Base.extend({
keySize: 128 / 32,
hasher: MD5,
iterations: 1
}),
/**
* Initializes a newly created key derivation function.
*
* @param {Object} cfg (Optional) The configuration options to use for the derivation.
*
* @example
*
* var kdf = CryptoJS.algo.EvpKDF.create();
* var kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8 });
* var kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8, iterations: 1000 });
*/
init: function(cfg) {
this.cfg = this.cfg.extend(cfg);
},
/**
* Derives a key from a password.
*
* @param {WordArray|string} password The password.
* @param {WordArray|string} salt A salt.
*
* @return {WordArray} The derived key.
*
* @example
*
* var key = kdf.compute(password, salt);
*/
compute: function(password, salt) {
var block;
var cfg = this.cfg;
var hasher = cfg.hasher.create();
var derivedKey = WordArray.create();
var derivedKeyWords = derivedKey.words;
var keySize = cfg.keySize;
var iterations = cfg.iterations;
while (derivedKeyWords.length < keySize) {
if (block) hasher.update(block);
block = hasher.update(password).finalize(salt);
hasher.reset();
for (var i = 1; i < iterations; i++) {
block = hasher.finalize(block);
hasher.reset();
}
derivedKey.concat(block);
}
derivedKey.sigBytes = keySize * 4;
return derivedKey;
}
});
/**
* Derives a key from a password.
*
* @param {WordArray|string} password The password.
* @param {WordArray|string} salt A salt.
* @param {Object} cfg (Optional) The configuration options to use for this computation.
*
* @return {WordArray} The derived key.
*
* @static
*
* @example
*
* var key = CryptoJS.EvpKDF(password, salt);
* var key = CryptoJS.EvpKDF(password, salt, { keySize: 8 });
* var key = CryptoJS.EvpKDF(password, salt, { keySize: 8, iterations: 1000 });
*/
C.EvpKDF = function(password, salt, cfg) {
return EvpKDF.create(cfg).compute(password, salt);
};
})();
return CryptoJS.EvpKDF;
});
}));
//#endregion
//#region node_modules/crypto-js/cipher-core.js
var require_cipher_core = /* @__PURE__ */ __commonJSMin(((exports, module) => {
(function(root, factory, undef) {
if (typeof exports === "object") module.exports = exports = factory(require_core(), require_evpkdf());
else if (typeof define === "function" && define.amd) define(["./core", "./evpkdf"], factory);
else factory(root.CryptoJS);
})(exports, function(CryptoJS) {
/**
* Cipher core components.
*/
CryptoJS.lib.Cipher || function(undefined) {
var C = CryptoJS;
var C_lib = C.lib;
var Base = C_lib.Base;
var WordArray = C_lib.WordArray;
var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm;
var C_enc = C.enc;
C_enc.Utf8;
var Base64 = C_enc.Base64;
var EvpKDF = C.algo.EvpKDF;
/**
* Abstract base cipher template.
*
* @property {number} keySize This cipher's key size. Default: 4 (128 bits)
* @property {number} ivSize This cipher's IV size. Default: 4 (128 bits)
* @property {number} _ENC_XFORM_MODE A constant representing encryption mode.
* @property {number} _DEC_XFORM_MODE A constant representing decryption mode.
*/
var Cipher = C_lib.Cipher = BufferedBlockAlgorithm.extend({
/**
* Configuration options.
*
* @property {WordArray} iv The IV to use for this operation.
*/
cfg: Base.extend(),
/**
* Creates this cipher in encryption mode.
*
* @param {WordArray} key The key.
* @param {Object} cfg (Optional) The configuration options to use for this operation.
*
* @return {Cipher} A cipher instance.
*
* @static
*
* @example
*
* var cipher = CryptoJS.algo.AES.createEncryptor(keyWordArray, { iv: ivWordArray });
*/
createEncryptor: function(key, cfg) {
return this.create(this._ENC_XFORM_MODE, key, cfg);
},
/**
* Creates this cipher in decryption mode.
*
* @param {WordArray} key The key.
* @param {Object} cfg (Optional) The configuration options to use for this operation.
*
* @return {Cipher} A cipher instance.
*
* @static
*
* @example
*
* var cipher = CryptoJS.algo.AES.createDecryptor(keyWordArray, { iv: ivWordArray });
*/
createDecryptor: function(key, cfg) {
return this.create(this._DEC_XFORM_MODE, key, cfg);
},
/**
* Initializes a newly created cipher.
*
* @param {number} xformMode Either the encryption or decryption transormation mode constant.
* @param {WordArray} key The key.
* @param {Object} cfg (Optional) The configuration options to use for this operation.
*
* @example
*
* var cipher = CryptoJS.algo.AES.create(CryptoJS.algo.AES._ENC_XFORM_MODE, keyWordArray, { iv: ivWordArray });
*/
init: function(xformMode, key, cfg) {
this.cfg = this.cfg.extend(cfg);
this._xformMode = xformMode;
this._key = key;
this.reset();
},
/**
* Resets this cipher to its initial state.
*
* @example
*
* cipher.reset();
*/
reset: function() {
BufferedBlockAlgorithm.reset.call(this);
this._doReset();
},
/**
* Adds data to be encrypted or decrypted.
*
* @param {WordArray|string} dataUpdate The data to encrypt or decrypt.
*
* @return {WordArray} The data after processing.
*
* @example
*
* var encrypted = cipher.process('data');
* var encrypted = cipher.process(wordArray);
*/
process: function(dataUpdate) {
this._append(dataUpdate);
return this._process();
},
/**
* Finalizes the encryption or decryption process.
* Note that the finalize operation is effectively a destructive, read-once operation.
*
* @param {WordArray|string} dataUpdate The final data to encrypt or decrypt.
*
* @return {WordArray} The data after final processing.
*
* @example
*
* var encrypted = cipher.finalize();
* var encrypted = cipher.finalize('data');
* var encrypted = cipher.finalize(wordArray);
*/
finalize: function(dataUpdate) {
if (dataUpdate) this._append(dataUpdate);
return this._doFinalize();
},
keySize: 128 / 32,
ivSize: 128 / 32,
_ENC_XFORM_MODE: 1,
_DEC_XFORM_MODE: 2,
/**
* Creates shortcut functions to a cipher's object interface.
*
* @param {Cipher} cipher The cipher to create a helper for.
*
* @return {Object} An object with encrypt and decrypt shortcut functions.
*
* @static
*
* @example
*
* var AES = CryptoJS.lib.Cipher._createHelper(CryptoJS.algo.AES);
*/
_createHelper: function() {
function selectCipherStrategy(key) {
if (typeof key == "string") return PasswordBasedCipher;
else return SerializableCipher;
}
return function(cipher) {
return {
encrypt: function(message, key, cfg) {
return selectCipherStrategy(key).encrypt(cipher, message, key, cfg);
},
decrypt: function(ciphertext, key, cfg) {
return selectCipherStrategy(key).decrypt(cipher, ciphertext, key, cfg);
}
};
};
}()
});
C_lib.StreamCipher = Cipher.extend({
_doFinalize: function() {
return this._process(true);
},
blockSize: 1
});
/**
* Mode namespace.
*/
var C_mode = C.mode = {};
/**
* Abstract base block cipher mode template.
*/
var BlockCipherMode = C_lib.BlockCipherMode = Base.extend({
/**
* Creates this mode for encryption.
*
* @param {Cipher} cipher A block cipher instance.
* @param {Array} iv The IV words.
*
* @static
*
* @example
*
* var mode = CryptoJS.mode.CBC.createEncryptor(cipher, iv.words);
*/
createEncryptor: function(cipher, iv) {
return this.Encryptor.create(cipher, iv);
},
/**
* Creates this mode for decryption.
*
* @param {Cipher} cipher A block cipher instance.
* @param {Array} iv The IV words.
*
* @static
*
* @example
*
* var mode = CryptoJS.mode.CBC.createDecryptor(cipher, iv.words);
*/
createDecryptor: function(cipher, iv) {
return this.Decryptor.create(cipher, iv);
},
/**
* Initializes a newly created mode.
*
* @param {Cipher} cipher A block cipher instance.
* @param {Array} iv The IV words.
*
* @example
*
* var mode = CryptoJS.mode.CBC.Encryptor.create(cipher, iv.words);
*/
init: function(cipher, iv) {
this._cipher = cipher;
this._iv = iv;
}
});
/**
* Cipher Block Chaining mode.
*/
var CBC = C_mode.CBC = function() {
/**
* Abstract base CBC mode.
*/
var CBC = BlockCipherMode.extend();
/**
* CBC encryptor.
*/
CBC.Encryptor = CBC.extend({
/**
* Processes the data block at offset.
*
* @param {Array} words The data words to operate on.
* @param {number} offset The offset where the block starts.
*
* @example
*
* mode.processBlock(data.words, offset);
*/
processBlock: function(words, offset) {
var cipher = this._cipher;
var blockSize = cipher.blockSize;
xorBlock.call(this, words, offset, blockSize);
cipher.encryptBlock(words, offset);
this._prevBlock = words.slice(offset, offset + blockSize);
} });
/**
* CBC decryptor.
*/
CBC.Decryptor = CBC.extend({
/**
* Processes the data block at offset.
*
* @param {Array} words The data words to operate on.
* @param {number} offset The offset where the block starts.
*
* @example
*
* mode.processBlock(data.words, offset);
*/
processBlock: function(words, offset) {
var cipher = this._cipher;
var blockSize = cipher.blockSize;
var thisBlock = words.slice(offset, offset + blockSize);
cipher.decryptBlock(words, offset);
xorBlock.call(this, words, offset, blockSize);
this._prevBlock = thisBlock;
} });
function xorBlock(words, offset, blockSize) {
var block;
var iv = this._iv;
if (iv) {
block = iv;
this._iv = undefined;
} else block = this._prevBlock;
for (var i = 0; i < blockSize; i++) words[offset + i] ^= block[i];
}
return CBC;
}();
/**
* Padding namespace.
*/
var C_pad = C.pad = {};
/**
* PKCS #5/7 padding strategy.
*/
var Pkcs7 = C_pad.Pkcs7 = {
/**
* Pads data using the algorithm defined in PKCS #5/7.
*
* @param {WordArray} data The data to pad.
* @param {number} blockSize The multiple that the data should be padded to.
*
* @static
*
* @example
*
* CryptoJS.pad.Pkcs7.pad(wordArray, 4);
*/
pad: function(data, blockSize) {
var blockSizeBytes = blockSize * 4;
var nPaddingBytes = blockSizeBytes - data.sigBytes % blockSizeBytes;
var paddingWord = nPaddingBytes << 24 | nPaddingBytes << 16 | nPaddingBytes << 8 | nPaddingBytes;
var paddingWords = [];
for (var i = 0; i < nPaddingBytes; i += 4) paddingWords.push(paddingWord);
var padding = WordArray.create(paddingWords, nPaddingBytes);
data.concat(padding);
},
/**
* Unpads data that had been padded using the algorithm defined in PKCS #5/7.
*
* @param {WordArray} data The data to unpad.
*
* @static
*
* @example
*
* CryptoJS.pad.Pkcs7.unpad(wordArray);
*/
unpad: function(data) {
var nPaddingBytes = data.words[data.sigBytes - 1 >>> 2] & 255;
data.sigBytes -= nPaddingBytes;
}
};
C_lib.BlockCipher = Cipher.extend({
/**
* Configuration options.
*
* @property {Mode} mode The block mode to use. Default: CBC
* @property {Padding} padding The padding strategy to use. Default: Pkcs7
*/
cfg: Cipher.cfg.extend({
mode: CBC,
padding: Pkcs7
}),
reset: function() {
var modeCreator;
Cipher.reset.call(this);
var cfg = this.cfg;
var iv = cfg.iv;
var mode = cfg.mode;
if (this._xformMode == this._ENC_XFORM_MODE) modeCreator = mode.createEncryptor;
else {
modeCreator = mode.createDecryptor;
this._minBufferSize = 1;
}
if (this._mode && this._mode.__creator == modeCreator) this._mode.init(this, iv && iv.words);
else {
this._mode = modeCreator.call(mode, this, iv && iv.words);
this._mode.__creator = modeCreator;
}
},
_doProcessBlock: function(words, offset) {
this._mode.processBlock(words, offset);
},
_doFinalize: function() {
var finalProcessedBlocks;
var padding = this.cfg.padding;
if (this._xformMode == this._ENC_XFORM_MODE) {
padding.pad(this._data, this.blockSize);
finalProcessedBlocks = this._process(true);
} else {
finalProcessedBlocks = this._process(true);
padding.unpad(finalProcessedBlocks);
}
return finalProcessedBlocks;
},
blockSize: 128 / 32
});
/**
* A collection of cipher parameters.
*
* @property {WordArray} ciphertext The raw ciphertext.
* @property {WordArray} key The key to this ciphertext.
* @property {WordArray} iv The IV used in the ciphering operation.
* @property {WordArray} salt The salt used with a key derivation function.
* @property {Cipher} algorithm The cipher algorithm.
* @property {Mode} mode The block mode used in the ciphering operation.
* @property {Padding} padding The padding scheme used in the ciphering operation.
* @property {number} blockSize The block size of the cipher.
* @property {Format} formatter The default formatting strategy to convert this cipher params object to a string.
*/
var CipherParams = C_lib.CipherParams = Base.extend({
/**
* Initializes a newly created cipher params object.
*
* @param {Object} cipherParams An object with any of the possible cipher parameters.
*
* @example
*
* var cipherParams = CryptoJS.lib.CipherParams.create({
* ciphertext: ciphertextWordArray,
* key: keyWordArray,
* iv: ivWordArray,
* salt: saltWordArray,
* algorithm: CryptoJS.algo.AES,
* mode: CryptoJS.mode.CBC,
* padding: CryptoJS.pad.PKCS7,
* blockSize: 4,
* formatter: CryptoJS.format.OpenSSL
* });
*/
init: function(cipherParams) {
this.mixIn(cipherParams);
},
/**
* Converts this cipher params object to a string.
*
* @param {Format} formatter (Optional) The formatting strategy to use.
*
* @return {string} The stringified cipher params.
*
* @throws Error If neither the formatter nor the default formatter is set.
*
* @example
*
* var string = cipherParams + '';
* var string = cipherParams.toString();
* var string = cipherParams.toString(CryptoJS.format.OpenSSL);
*/
toString: function(formatter) {
return (formatter || this.formatter).stringify(this);
}
});
/**
* Format namespace.
*/
var C_format = C.format = {};
/**
* OpenSSL formatting strategy.
*/
var OpenSSLFormatter = C_format.OpenSSL = {
/**
* Converts a cipher params object to an OpenSSL-compatible string.
*
* @param {CipherParams} cipherParams The cipher params object.
*
* @return {string} The OpenSSL-compatible string.
*
* @static
*
* @example
*
* var openSSLString = CryptoJS.format.OpenSSL.stringify(cipherParams);
*/
stringify: function(cipherParams) {
var wordArray;
var ciphertext = cipherParams.ciphertext;
var salt = cipherParams.salt;
if (salt) wordArray = WordArray.create([1398893684, 1701076831]).concat(salt).concat(ciphertext);
else wordArray = ciphertext;
return wordArray.toString(Base64);
},
/**
* Converts an OpenSSL-compatible string to a cipher params object.
*
* @param {string} openSSLStr The OpenSSL-compatible string.
*
* @return {CipherParams} The cipher params object.
*
* @static
*
* @example
*
* var cipherParams = CryptoJS.format.OpenSSL.parse(openSSLString);
*/
parse: function(openSSLStr) {
var salt;
var ciphertext = Base64.parse(openSSLStr);
var ciphertextWords = ciphertext.words;
if (ciphertextWords[0] == 1398893684 && ciphertextWords[1] == 1701076831) {
salt = WordArray.create(ciphertextWords.slice(2, 4));
ciphertextWords.splice(0, 4);
ciphertext.sigBytes -= 16;
}
return CipherParams.create({
ciphertext,
salt
});
}
};
/**
* A cipher wrapper that returns ciphertext as a serializable cipher params object.
*/
var SerializableCipher = C_lib.SerializableCipher = Base.extend({
/**
* Configuration options.
*
* @property {Formatter} format The formatting strategy to convert cipher param objects to and from a string. Default: OpenSSL
*/
cfg: Base.extend({ format: OpenSSLFormatter }),
/**
* Encrypts a message.
*
* @param {Cipher} cipher The cipher algorithm to use.
* @param {WordArray|string} message The message to encrypt.
* @param {WordArray} key The key.
* @param {Object} cfg (Optional) The configuration options to use for this operation.
*
* @return {CipherParams} A cipher params object.
*
* @static
*
* @example
*
* var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key);
* var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key, { iv: iv });
* var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key, { iv: iv, format: CryptoJS.format.OpenSSL });
*/
encrypt: function(cipher, message, key, cfg) {
cfg = this.cfg.extend(cfg);
var encryptor = cipher.createEncryptor(key, cfg);
var ciphertext = encryptor.finalize(message);
var cipherCfg = encryptor.cfg;
return CipherParams.create({
ciphertext,
key,
iv: cipherCfg.iv,
algorithm: cipher,
mode: cipherCfg.mode,
padding: cipherCfg.padding,
blockSize: cipher.blockSize,
formatter: cfg.format
});
},
/**
* Decrypts serialized ciphertext.
*
* @param {Cipher} cipher The cipher algorithm to use.
* @param {CipherParams|string} ciphertext The ciphertext to decrypt.
* @param {WordArray} key The key.
* @param {Object} cfg (Optional) The configuration options to use for this operation.
*
* @return {WordArray} The plaintext.
*
* @static
*
* @example
*
* var plaintext = CryptoJS.lib.SerializableCipher.decrypt(CryptoJS.algo.AES, formattedCiphertext, key, { iv: iv, format: CryptoJS.format.OpenSSL });
* var plaintext = CryptoJS.lib.SerializableCipher.decrypt(CryptoJS.algo.AES, ciphertextParams, key, { iv: iv, format: CryptoJS.format.OpenSSL });
*/
decrypt: function(cipher, ciphertext, key, cfg) {
cfg = this.cfg.extend(cfg);
ciphertext = this._parse(ciphertext, cfg.format);
return cipher.createDecryptor(key, cfg).finalize(ciphertext.ciphertext);
},
/**
* Converts serialized ciphertext to CipherParams,
* else assumed CipherParams already and returns ciphertext unchanged.
*
* @param {CipherParams|string} ciphertext The ciphertext.
* @param {Formatter} format The formatting strategy to use to parse serialized ciphertext.
*
* @return {CipherParams} The unserialized ciphertext.
*
* @static
*
* @example
*
* var ciphertextParams = CryptoJS.lib.SerializableCipher._parse(ciphertextStringOrParams, format);
*/
_parse: function(ciphertext, format) {
if (typeof ciphertext == "string") return format.parse(ciphertext, this);
else return ciphertext;
}
});
/**
* Key derivation function namespace.
*/
var C_kdf = C.kdf = {};
/**
* OpenSSL key derivation function.
*/
var OpenSSLKdf = C_kdf.OpenSSL = {
/**
* Derives a key and IV from a password.
*
* @param {string} password The password to derive from.
* @param {number} keySize The size in words of the key to generate.
* @param {number} ivSize The size in words of the IV to generate.
* @param {WordArray|string} salt (Optional) A 64-bit salt to use. If omitted, a salt will be generated randomly.
*
* @return {CipherParams} A cipher params object with the key, IV, and salt.
*
* @static
*
* @example
*
* var derivedParams = CryptoJS.kdf.OpenSSL.execute('Password', 256/32, 128/32);
* var derivedParams = CryptoJS.kdf.OpenSSL.execute('Password', 256/32, 128/32, 'saltsalt');
*/
execute: function(password, keySize, ivSize, salt, hasher) {
if (!salt) salt = WordArray.random(64 / 8);
if (!hasher) var key = EvpKDF.create({ keySize: keySize + ivSize }).compute(password, salt);
else var key = EvpKDF.create({
keySize: keySize + ivSize,
hasher
}).compute(password, salt);
var iv = WordArray.create(key.words.slice(keySize), ivSize * 4);
key.sigBytes = keySize * 4;
return CipherParams.create({
key,
iv,
salt
});
} };
/**
* A serializable cipher wrapper that derives the key from a password,
* and returns ciphertext as a serializable cipher params object.
*/
var PasswordBasedCipher = C_lib.PasswordBasedCipher = SerializableCipher.extend({
/**
* Configuration options.
*
* @property {KDF} kdf The key derivation function to use to generate a key and IV from a password. Default: OpenSSL
*/
cfg: SerializableCipher.cfg.extend({ kdf: OpenSSLKdf }),
/**
* Encrypts a message using a password.
*
* @param {Cipher} cipher The cipher algorithm to use.
* @param {WordArray|string} message The message to encrypt.
* @param {string} password The password.
* @param {Object} cfg (Optional) The configuration options to use for this operation.
*
* @return {CipherParams} A cipher params object.
*
* @static
*
* @example
*
* var ciphertextParams = CryptoJS.lib.PasswordBasedCipher.encrypt(CryptoJS.algo.AES, message, 'password');
* var ciphertextParams = CryptoJS.lib.PasswordBasedCipher.encrypt(CryptoJS.algo.AES, message, 'password', { format: CryptoJS.format.OpenSSL });
*/
encrypt: function(cipher, message, password, cfg) {
cfg = this.cfg.extend(cfg);
var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize, cfg.salt, cfg.hasher);
cfg.iv = derivedParams.iv;
var ciphertext = SerializableCipher.encrypt.call(this, cipher, message, derivedParams.key, cfg);
ciphertext.mixIn(derivedParams);
return ciphertext;
},
/**
* Decrypts serialized ciphertext using a password.
*
* @param {Cipher} cipher The cipher algorithm to use.
* @param {CipherParams|string} ciphertext The ciphertext to decrypt.
* @param {string} password The password.
* @param {Object} cfg (Optional) The configuration options to use for this operation.
*
* @return {WordArray} The plaintext.
*
* @static
*
* @example
*
* var plaintext = CryptoJS.lib.PasswordBasedCipher.decrypt(CryptoJS.algo.AES, formattedCiphertext, 'password', { format: CryptoJS.format.OpenSSL });
* var plaintext = CryptoJS.lib.PasswordBasedCipher.decrypt(CryptoJS.algo.AES, ciphertextParams, 'password', { format: CryptoJS.format.OpenSSL });
*/
decrypt: function(cipher, ciphertext, password, cfg) {
cfg = this.cfg.extend(cfg);
ciphertext = this._parse(ciphertext, cfg.format);
var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize, ciphertext.salt, cfg.hasher);
cfg.iv = derivedParams.iv;
return SerializableCipher.decrypt.call(this, cipher, ciphertext, derivedParams.key, cfg);
}
});
}();
});
}));
//#endregion
//#region node_modules/crypto-js/aes.js
var require_aes = /* @__PURE__ */ __commonJSMin(((exports, module) => {
(function(root, factory, undef) {
if (typeof exports === "object") module.exports = exports = factory(require_core(), require_enc_base64(), require_md5(), require_evpkdf(), require_cipher_core());
else if (typeof define === "function" && define.amd) define([
"./core",
"./enc-base64",
"./md5",
"./evpkdf",
"./cipher-core"
], factory);
else factory(root.CryptoJS);
})(exports, function(CryptoJS) {
(function() {
var C = CryptoJS;
var BlockCipher = C.lib.BlockCipher;
var C_algo = C.algo;
var SBOX = [];
var INV_SBOX = [];
var SUB_MIX_0 = [];
var SUB_MIX_1 = [];
var SUB_MIX_2 = [];
var SUB_MIX_3 = [];
var INV_SUB_MIX_0 = [];
var INV_SUB_MIX_1 = [];
var INV_SUB_MIX_2 = [];
var INV_SUB_MIX_3 = [];
(function() {
var d = [];
for (var i = 0; i < 256; i++) if (i < 128) d[i] = i << 1;
else d[i] = i << 1 ^ 283;
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;
var 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) x = xi = 1;
else {
x = x2 ^ d[d[d[x8 ^ x2]]];
xi ^= d[d[xi]];
}
}
})();
var RCON = [
0,
1,
2,
4,
8,
16,
32,
64,
128,
27,
54
];
/**
* AES block cipher algorithm.
*/
var AES = C_algo.AES = BlockCipher.extend({
_doReset: function() {
var t;
if (this._nRounds && this._keyPriorReset === this._key) return;
var key = this._keyPriorReset = this._key;
var keyWords = key.words;
var keySize = key.sigBytes / 4;
var ksRows = ((this._nRounds = keySize + 6) + 1) * 4;
var keySchedule = this._keySchedule = [];
for (var ksRow = 0; ksRow < ksRows; ksRow++) if (ksRow < keySize) keySchedule[ksRow] = keyWords[ksRow];
else {
t = keySchedule[ksRow - 1];
if (!(ksRow % keySize)) {
t = t << 8 | t >>> 24;
t = SBOX[t >>> 24] << 24 | SBOX[t >>> 16 & 255] << 16 | SBOX[t >>> 8 & 255] << 8 | SBOX[t & 255];
t ^= RCON[ksRow / keySize | 0] << 24;
} else if (keySize > 6 && ksRow % keySize == 4) t = SBOX[t >>> 24] << 24 | SBOX[t >>> 16 & 255] << 16 | SBOX[t >>> 8 & 255] << 8 | SBOX[t & 255];
keySchedule[ksRow] = keySchedule[ksRow - keySize] ^ t;
}
var invKeySchedule = this._invKeySchedule = [];
for (var invKsRow = 0; invKsRow < ksRows; invKsRow++) {
var ksRow = ksRows - invKsRow;
if (invKsRow % 4) var t = keySchedule[ksRow];
else var t = keySchedule[ksRow - 4];
if (invKsRow < 4 || ksRow <= 4) invKeySchedule[invKsRow] = t;
else invKeySchedule[invKsRow] = INV_SUB_MIX_0[SBOX[t >>> 24]] ^ INV_SUB_MIX_1[SBOX[t >>> 16 & 255]] ^ INV_SUB_MIX_2[SBOX[t >>> 8 & 255]] ^ INV_SUB_MIX_3[SBOX[t & 255]];
}
},
encryptBlock: function(M, offset) {
this._doCryptBlock(M, offset, this._keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX);
},
decryptBlock: function(M, offset) {
var t = M[offset + 1];
M[offset + 1] = M[offset + 3];
M[offset + 3] = t;
this._doCryptBlock(M, offset, this._invKeySchedule, INV_SUB_MIX_0, INV_SUB_MIX_1, INV_SUB_MIX_2, INV_SUB_MIX_3, INV_SBOX);
var t = M[offset + 1];
M[offset + 1] = M[offset + 3];
M[offset + 3] = t;
},
_doCryptBlock: function(M, offset, keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX) {
var nRounds = this._nRounds;
var s0 = M[offset] ^ keySchedule[0];
var s1 = M[offset + 1] ^ keySchedule[1];
var s2 = M[offset + 2] ^ keySchedule[2];
var s3 = M[offset + 3] ^ keySchedule[3];
var ksRow = 4;
for (var round = 1; round < nRounds; round++) {
var t0 = SUB_MIX_0[s0 >>> 24] ^ SUB_MIX_1[s1 >>> 16 & 255] ^ SUB_MIX_2[s2 >>> 8 & 255] ^ SUB_MIX_3[s3 & 255] ^ keySchedule[ksRow++];
var t1 = SUB_MIX_0[s1 >>> 24] ^ SUB_MIX_1[s2 >>> 16 & 255] ^ SUB_MIX_2[s3 >>> 8 & 255] ^ SUB_MIX_3[s0 & 255] ^ keySchedule[ksRow++];
var t2 = SUB_MIX_0[s2 >>> 24] ^ SUB_MIX_1[s3 >>> 16 & 255] ^ SUB_MIX_2[s0 >>> 8 & 255] ^ SUB_MIX_3[s1 & 255] ^ keySchedule[ksRow++];
var t3 = SUB_MIX_0[s3 >>> 24] ^ SUB_MIX_1[s0 >>> 16 & 255] ^ SUB_MIX_2[s1 >>> 8 & 255] ^ SUB_MIX_3[s2 & 255] ^ keySchedule[ksRow++];
s0 = t0;
s1 = t1;
s2 = t2;
s3 = t3;
}
var t0 = (SBOX[s0 >>> 24] << 24 | SBOX[s1 >>> 16 & 255] << 16 | SBOX[s2 >>> 8 & 255] << 8 | SBOX[s3 & 255]) ^ keySchedule[ksRow++];
var t1 = (SBOX[s1 >>> 24] << 24 | SBOX[s2 >>> 16 & 255] << 16 | SBOX[s3 >>> 8 & 255] << 8 | SBOX[s0 & 255]) ^ keySchedule[ksRow++];
var t2 = (SBOX[s2 >>> 24] << 24 | SBOX[s3 >>> 16 & 255] << 16 | SBOX[s0 >>> 8 & 255] << 8 | SBOX[s1 & 255]) ^ keySchedule[ksRow++];
var t3 = (SBOX[s3 >>> 24] << 24 | SBOX[s0 >>> 16 & 255] << 16 | SBOX[s1 >>> 8 & 255] << 8 | SBOX[s2 & 255]) ^ keySchedule[ksRow++];
M[offset] = t0;
M[offset + 1] = t1;
M[offset + 2] = t2;
M[offset + 3] = t3;
},
keySize: 256 / 32
});
/**
* Shortcut functions to the cipher's object interface.
*
* @example
*
* var ciphertext = CryptoJS.AES.encrypt(message, key, cfg);
* var plaintext = CryptoJS.AES.decrypt(ciphertext, key, cfg);
*/
C.AES = BlockCipher._createHelper(AES);
})();
return CryptoJS.AES;
});
}));
//#endregion
//#region node_modules/crypto-js/enc-utf8.js
var require_enc_utf8 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
(function(root, factory) {
if (typeof exports === "object") module.exports = exports = factory(require_core());
else if (typeof define === "function" && define.amd) define(["./core"], factory);
else factory(root.CryptoJS);
})(exports, function(CryptoJS) {
return CryptoJS.enc.Utf8;
});
}));
//#endregion
//#region src/CryptoController.ts
var import_CryptoJS = /* @__PURE__ */ __toESM(require_CryptoJS());
var import_aes = /* @__PURE__ */ __toESM(require_aes());
var import_enc_utf8 = /* @__PURE__ */ __toESM(require_enc_utf8());
var AES;
var ENC;
AES = import_aes.default || import_aes;
ENC = import_enc_utf8.default || import_enc_utf8;
var CryptoController = {
encrypt(obj, secretKey) {
return AES.encrypt(JSON.stringify(obj), secretKey).toString();
},
decrypt(encryptedText, secretKey) {
return AES.decrypt(encryptedText, secretKey).toString(ENC);
}
};
//#endregion
//#region src/canBeSerialized.ts
function canBeSerialized(obj) {
if (!(obj instanceof CoreManager.getParseObject())) return true;
const attributes = obj.attributes;
for (const attr in attributes) {
const val = attributes[attr];
if (!canBeSerializedHelper(val)) return false;
}
return true;
}
function canBeSerializedHelper(value) {
if (typeof value !== "object") return true;
if (value instanceof ParseRelation) return true;
if (value instanceof CoreManager.getParseObject()) return !!value.id;
if (value instanceof ParseFile) {
if (value.url()) return true;
return false;
}
if (Array.isArray(value)) {
for (let i = 0; i < value.length; i++) if (!canBeSerializedHelper(value[i])) return false;
return true;
}
for (const k in value) if (!canBeSerializedHelper(value[k])) return false;
return true;
}
//#endregion
//#region src/escape.ts
var encoded = {
"&": "&",
"<": "<",
">": ">",
"/": "/",
"'": "'",
"\"": """
};
function escape$1(str) {
return str.replace(/[&<>\/'"]/g, function(char) {
return encoded[char];
});
}
//#endregion
//#region src/parseDate.ts
function parseDate(iso8601) {
const match = (/* @__PURE__ */ new RegExp("^([0-9]{1,4})-([0-9]{1,2})-([0-9]{1,2})T([0-9]{1,2}):([0-9]{1,2}):([0-9]{1,2})(.([0-9]+))?Z$")).exec(iso8601);
if (!match) return null;
const year = parseInt(match[1]) || 0;
const month = (parseInt(match[2]) || 1) - 1;
const day = parseInt(match[3]) || 0;
const hour = parseInt(match[4]) || 0;
const minute = parseInt(match[5]) || 0;
const second = parseInt(match[6]) || 0;
const milli = parseInt(match[8]) || 0;
return new Date(Date.UTC(year, month, day, hour, minute, second, milli));
}
//#endregion
//#region src/promiseUtils.ts
function resolvingPromise() {
let res;
let rej;
const defer = new Promise((resolve, reject) => {
res = resolve;
rej = reject;
});
defer.resolve = res;
defer.reject = rej;
return defer;
}
function when(promises) {
let objects;
const arrayArgument = Array.isArray(promises);
if (arrayArgument) objects = promises;
else objects = arguments;
let total = objects.length;
let hadError = false;
const results = [];
const returnValue = arrayArgument ? [results] : results;
const errors = [];
results.length = objects.length;
errors.length = objects.length;
if (total === 0) return Promise.resolve(returnValue);
const promise = resolvingPromise();
const resolveOne = function() {
total--;
if (total <= 0) if (hadError) promise.reject(errors);
else promise.resolve(returnValue);
};
const chain = function(object, index) {
if (object && typeof object.then === "function") object.then(function(result) {
results[index] = result;
resolveOne();
}, function(error) {
errors[index] = error;
hadError = true;
resolveOne();
});
else {
results[index] = object;
resolveOne();
}
};
for (let i = 0; i < objects.length; i++) chain(objects[i], i);
return promise;
}
function continueWhile(test, emitter) {
if (test()) return emitter().then(() => {
return continueWhile(test, emitter);
});
return Promise.resolve();
}
//#endregion
//#region src/LocalDatastoreUtils.ts
var DEFAULT_PIN = "_default";
var PIN_PREFIX = "parsePin_";
var OBJECT_PREFIX = "Parse_LDS_";
function isLocalDatastoreKey(key) {
return !!(key && (key === "_default" || key.startsWith("parsePin_") || key.startsWith("Parse_LDS_")));
}
//#endregion
//#region src/uuid.ts
var uuid = function() {
const s = [];
const hexDigits = "0123456789abcdef";
for (let i = 0; i < 36; i++) s[i] = hexDigits.substr(Math.floor(Math.random() * 16), 1);
s[14] = "4";
s[19] = hexDigits.substr(Number(s[19]) & 3 | 8, 1);
s[8] = s[13] = s[18] = s[23] = "-";
return s.join("");
};
//#endregion
//#region src/arrayContainsObject.ts
function arrayContainsObject(array, object) {
if (array.indexOf(object) > -1) return true;
const ParseObject = CoreManager.getParseObject();
for (let i = 0; i < array.length; i++) if (array[i] instanceof ParseObject && array[i].className === object.className && array[i]._getId() === object._getId()) return true;
return false;
}
//#endregion
//#region src/unique.ts
function unique(arr) {
const uniques = [];
arr.forEach((value) => {
if (value instanceof CoreManager.getParseObject()) {
if (!arrayContainsObject(uniques, value)) uniques.push(value);
} else if (uniques.indexOf(value) < 0) uniques.push(value);
});
return uniques;
}
//#endregion
//#region src/ParseOp.ts
function opFromJSON(json) {
if (!json || !json.__op) return null;
switch (json.__op) {
case "Delete": return new UnsetOp();
case "Increment": return new IncrementOp(json.amount);
case "Add": return new AddOp(decode(json.objects));
case "AddUnique": return new AddUniqueOp(decode(json.objects));
case "Remove": return new RemoveOp(decode(json.objects));
case "AddRelation": {
const toAdd = decode(json.objects);
if (!Array.isArray(toAdd)) return new RelationOp([], []);
return new RelationOp(toAdd, []);
}
case "RemoveRelation": {
const toRemove = decode(json.objects);
if (!Array.isArray(toRemove)) return new RelationOp([], []);
return new RelationOp([], toRemove);
}
case "Batch": {
let toAdd = [];
let toRemove = [];
for (let i = 0; i < json.ops.length; i++) if (json.ops[i].__op === "AddRelation") toAdd = toAdd.concat(decode(json.ops[i].objects));
else if (json.ops[i].__op === "RemoveRelation") toRemove = toRemove.concat(decode(json.ops[i].objects));
return new RelationOp(toAdd, toRemove);
}
}
return null;
}
var Op = class {
applyTo(value) {}
mergeWith(previous) {}
toJSON(offline) {}
};
var SetOp = class SetOp extends Op {
constructor(value) {
super();
this._value = value;
}
applyTo() {
return this._value;
}
mergeWith() {
return new SetOp(this._value);
}
toJSON(offline) {
return encode_default(this._value, false, true, void 0, offline);
}
};
var UnsetOp = class UnsetOp extends Op {
applyTo() {}
mergeWith() {
return new UnsetOp();
}
toJSON() {
return { __op: "Delete" };
}
};
var IncrementOp = class IncrementOp extends Op {
constructor(amount) {
super();
if (typeof amount !== "number") throw new TypeError("Increment Op must be initialized with a numeric amount.");
this._amount = amount;
}
applyTo(value) {
if (typeof value === "undefined") return this._amount;
if (typeof value !== "number") throw new TypeError("Cannot increment a non-numeric value.");
return this._amount + value;
}
mergeWith(previous) {
if (!previous) return this;
if (previous instanceof SetOp) return new SetOp(this.applyTo(previous._value));
if (previous instanceof UnsetOp) return new SetOp(this._amount);
if (previous instanceof IncrementOp) return new IncrementOp(this.applyTo(previous._amount));
throw new Error("Cannot merge Increment Op with the previous Op");
}
toJSON() {
return {
__op: "Increment",
amount: this._amount
};
}
};
var AddOp = class AddOp extends Op {
constructor(value) {
super();
this._value = Array.isArray(value) ? value : [value];
}
applyTo(value) {
if (value == null) return this._value;
if (Array.isArray(value)) return value.concat(this._value);
throw new Error("Cannot add elements to a non-array value");
}
mergeWith(previous) {
if (!previous) return this;
if (previous instanceof SetOp) return new SetOp(this.applyTo(previous._value));
if (previous instanceof UnsetOp) return new SetOp(this._value);
if (previous instanceof AddOp) return new AddOp(this.applyTo(previous._value));
throw new Error("Cannot merge Add Op with the previous Op");
}
toJSON() {
return {
__op: "Add",
objects: encode_default(this._value, false, true)
};
}
};
var AddUniqueOp = class AddUniqueOp extends Op {
constructor(value) {
super();
this._value = unique(Array.isArray(value) ? value : [value]);
}
applyTo(value) {
if (value == null) return this._value || [];
if (Array.isArray(value)) {
const ParseObject = CoreManager.getParseObject();
const toAdd = [];
this._value.forEach((v) => {
if (v instanceof ParseObject) {
if (!arrayContainsObject(value, v)) toAdd.push(v);
} else if (value.indexOf(v) < 0) toAdd.push(v);
});
return value.concat(toAdd);
}
throw new Error("Cannot add elements to a non-array value");
}
mergeWith(previous) {
if (!previous) return this;
if (previous instanceof SetOp) return new SetOp(this.applyTo(previous._value));
if (previous instanceof UnsetOp) return new SetOp(this._value);
if (previous instanceof AddUniqueOp) return new AddUniqueOp(this.applyTo(previous._value));
throw new Error("Cannot merge AddUnique Op with the previous Op");
}
toJSON() {
return {
__op: "AddUnique",
objects: encode_default(this._value, false, true)
};
}
};
var RemoveOp = class RemoveOp extends Op {
constructor(value) {
super();
this._value = unique(Array.isArray(value) ? value : [value]);
}
applyTo(value) {
if (value == null) return [];
if (Array.isArray(value)) {
const ParseObject = CoreManager.getParseObject();
const removed = value.concat([]);
for (let i = 0; i < this._value.length; i++) {
let index = removed.indexOf(this._value[i]);
while (index > -1) {
removed.splice(index, 1);
index = removed.indexOf(this._value[i]);
}
if (this._value[i] instanceof ParseObject && this._value[i].id) {
for (let j = 0; j < removed.length; j++) if (removed[j] instanceof ParseObject && this._value[i].id === removed[j].id) {
removed.splice(j, 1);
j--;
}
}
}
return removed;
}
throw new Error("Cannot remove elements from a non-array value");
}
mergeWith(previous) {
if (!previous) return this;
if (previous instanceof SetOp) return new SetOp(this.applyTo(previous._value));
if (previous instanceof UnsetOp) return new UnsetOp();
if (previous instanceof RemoveOp) {
const ParseObject = CoreManager.getParseObject();
const uniques = previous._value.concat([]);
for (let i = 0; i < this._value.length; i++) if (this._value[i] instanceof ParseObject) {
if (!arrayContainsObject(uniques, this._value[i])) uniques.push(this._value[i]);
} else if (uniques.indexOf(this._value[i]) < 0) uniques.push(this._value[i]);
return new RemoveOp(uniques);
}
throw new Error("Cannot merge Remove Op with the previous Op");
}
toJSON() {
return {
__op: "Remove",
objects: encode_default(this._value, false, true)
};
}
};
var RelationOp = class RelationOp extends Op {
constructor(adds, removes) {
super();
this._targetClassName = null;
if (Array.isArray(adds)) this.relationsToAdd = unique(adds.map(this._extractId, this));
if (Array.isArray(removes)) this.relationsToRemove = unique(removes.map(this._extractId, this));
}
_extractId(obj) {
if (typeof obj === "string") return obj;
if (!obj.id) throw new Error("You cannot add or remove an unsaved Parse Object from a relation");
if (!this._targetClassName) this._targetClassName = obj.className;
if (this._targetClassName !== obj.className) throw new Error("Tried to create a Relation with 2 different object types: " + this._targetClassName + " and " + obj.className + ".");
return obj.id;
}
applyTo(value, parent, key) {
if (!value) {
if (!parent || !key) throw new Error("Cannot apply a RelationOp without either a previous value, or an object and a key");
const relation = new ParseRelation(parent, key);
relation.targetClassName = this._targetClassName;
return relation;
}
if (value instanceof ParseRelation) {
if (this._targetClassName) if (value.targetClassName) {
if (this._targetClassName !== value.targetClassName) throw new Error("Related object must be a " + value.targetClassName + ", but a " + this._targetClassName + " was passed in.");
} else value.targetClassName = this._targetClassName;
return value;
} else throw new Error("Relation cannot be applied to a non-relation field");
}
mergeWith(previous) {
if (!previous) return this;
else if (previous instanceof UnsetOp) throw new Error("You cannot modify a relation after deleting it.");
else if (previous instanceof SetOp && previous._value instanceof ParseRelation) return this;
else if (previous instanceof RelationOp) {
if (previous._targetClassName && previous._targetClassName !== this._targetClassName) throw new Error("Related object must be of class " + previous._targetClassName + ", but " + (this._targetClassName || "null") + " was passed in.");
const newAdd = previous.relationsToAdd.concat([]);
this.relationsToRemove.forEach((r) => {
const index = newAdd.indexOf(r);
if (index > -1) newAdd.splice(index, 1);
});
this.relationsToAdd.forEach((r) => {
if (newAdd.indexOf(r) < 0) newAdd.push(r);
});
const newRemove = previous.relationsToRemove.concat([]);
this.relationsToAdd.forEach((r) => {
const index = newRemove.indexOf(r);
if (index > -1) newRemove.splice(index, 1);
});
this.relationsToRemove.forEach((r) => {
if (newRemove.indexOf(r) < 0) newRemove.push(r);
});
const newRelation = new RelationOp(newAdd, newRemove);
newRelation._targetClassName = this._targetClassName;
return newRelation;
}
throw new Error("Cannot merge Relation Op with the previous Op");
}
toJSON() {
const idToPointer = (id) => {
return {
__type: "Pointer",
className: this._targetClassName,
objectId: id
};
};
let pointers = null;
let adds = null;
let removes = null;
if (this.relationsToAdd.length > 0) {
pointers = this.relationsToAdd.map(idToPointer);
adds = {
__op: "AddRelation",
objects: pointers
};
}
if (this.relationsToRemove.length > 0) {
pointers = this.relationsToRemove.map(idToPointer);
removes = {
__op: "RemoveRelation",
objects: pointers
};
}
if (adds && removes) return {
__op: "Batch",
ops: [adds, removes]
};
return adds || removes || {};
}
};
CoreManager.setParseOp({
Op,
opFromJSON,
SetOp,
UnsetOp,
IncrementOp,
AddOp,
RelationOp,
RemoveOp,
AddUniqueOp
});
//#endregion
//#region src/TaskQueue.ts
var TaskQueue = class {
constructor() {
this.queue = [];
}
enqueue(task) {
const taskComplete = resolvingPromise();
this.queue.push({
task,
_completion: taskComplete
});
if (this.queue.length === 1) task().then(() => {
this._dequeue();
taskComplete.resolve();
}, (error) => {
this._dequeue();
taskComplete.reject(error);
});
return taskComplete;
}
_dequeue() {
this.queue.shift();
if (this.queue.length) {
const next = this.queue[0];
next.task().then(() => {
this._dequeue();
next._completion.resolve();
}, (error) => {
this._dequeue();
next._completion.reject(error);
});
}
}
};
//#endregion
//#region src/ObjectStateMutations.ts
function defaultState() {
return {
serverData: Object.create(null),
pendingOps: [Object.create(null)],
objectCache: Object.create(null),
tasks: new TaskQueue(),
existed: false
};
}
function setServerData$2(serverData, attributes) {
for (const attr in attributes) {
if (!Object.prototype.hasOwnProperty.call(attributes, attr)) continue;
if (isDangerousKey(attr)) continue;
if (typeof attributes[attr] !== "undefined") serverData[attr] = attributes[attr];
else delete serverData[attr];
}
}
function setPendingOp$2(pendingOps, attr, op) {
if (isDangerousKey(attr)) return;
const last = pendingOps.length - 1;
if (op) pendingOps[last][attr] = op;
else delete pendingOps[last][attr];
}
function pushPendingState$2(pendingOps) {
pendingOps.push(Object.create(null));
}
function popPendingState$2(pendingOps) {
const first = pendingOps.shift();
if (!pendingOps.length) pendingOps[0] = Object.create(null);
return first;
}
function mergeFirstPendingState$2(pendingOps) {
const first = popPendingState$2(pendingOps);
const next = pendingOps[0];
for (const attr in first) {
if (!Object.prototype.hasOwnProperty.call(first, attr)) continue;
if (isDangerousKey(attr)) continue;
if (next[attr] && first[attr]) {
const merged = next[attr].mergeWith(first[attr]);
if (merged) next[attr] = merged;
} else next[attr] = first[attr];
}
}
function estimateAttribute$2(serverData, pendingOps, object, attr) {
if (isDangerousKey(attr)) return;
let value = serverData[attr];
for (let i = 0; i < pendingOps.length; i++) if (pendingOps[i][attr]) if (pendingOps[i][attr] instanceof RelationOp) {
if (object.id) value = pendingOps[i][attr].applyTo(value, object, attr);
} else value = pendingOps[i][attr].applyTo(value);
return value;
}
function estimateAttributes$2(serverData, pendingOps, object) {
const data = Object.create(null);
let attr;
for (attr in serverData) data[attr] = serverData[attr];
for (let i = 0; i < pendingOps.length; i++) for (attr in pendingOps[i]) {
if (!Object.prototype.hasOwnProperty.call(pendingOps[i], attr)) continue;
if (isDangerousKey(attr)) continue;
if (pendingOps[i][attr] instanceof RelationOp) {
if (object.id) data[attr] = pendingOps[i][attr].applyTo(data[attr], object, attr);
} else if (attr.includes(".")) {
const fields = attr.split(".");
const last = fields[fields.length - 1];
let object = data;
for (let i = 0; i < fields.length - 1; i++) {
const key = fields[i];
if (!(key in object)) {
const nextKey = fields[i + 1];
if (!isNaN(nextKey)) object[key] = [];
else object[key] = Object.create(null);
} else if (Array.isArray(object[key])) object[key] = [...object[key]];
else object[key] = { ...object[key] };
object = object[key];
}
object[last] = pendingOps[i][attr].applyTo(object[last]);
} else data[attr] = pendingOps[i][attr].applyTo(data[attr]);
}
return data;
}
/**
* Allows setting properties/variables deep in an object.
* Converts a.b into { a: { b: value } } for dot notation on Objects
* Converts a.0.b into { a: [{ b: value }] } for dot notation on Arrays
*
* @param obj The object to assign the value to
* @param key The key to assign. If it's in a deeper path, then use dot notation (`prop1.prop2.prop3`)
* Note that intermediate object(s) in the nested path are automatically created if they don't exist.
* @param value The value to assign. If it's an `undefined` then the key is deleted.
*/
function nestedSet(obj, key, value) {
const paths = key.split(".");
for (let i = 0; i < paths.length - 1; i++) {
const path = paths[i];
if (!(path in obj)) {
const nextPath = paths[i + 1];
if (!isNaN(nextPath)) obj[path] = [];
else obj[path] = Object.create(null);
}
obj = obj[path];
}
if (typeof value === "undefined") delete obj[paths[paths.length - 1]];
else obj[paths[paths.length - 1]] = value;
}
function commitServerChanges$2(serverData, objectCache, changes) {
const ParseObject = CoreManager.getParseObject();
for (const attr in changes) {
if (!Object.prototype.hasOwnProperty.call(changes, attr)) continue;
if (isDangerousKey(attr)) continue;
const val = changes[attr];
nestedSet(serverData, attr, val);
if (val && typeof val === "object" && !(val instanceof ParseObject) && !(val instanceof ParseFile) && !(val instanceof ParseRelation)) {
const json = encode_default(val, false, true);
objectCache[attr] = JSON.stringify(json);
}
}
}
//#endregion
//#region src/SingleInstanceStateController.ts
var SingleInstanceStateController_exports = /* @__PURE__ */ __exportAll({
clearAllState: () => clearAllState$1,
commitServerChanges: () => commitServerChanges$1,
duplicateState: () => duplicateState$1,
enqueueTask: () => enqueueTask$1,
estimateAttribute: () => estimateAttribute$1,
estimateAttributes: () => estimateAttributes$1,
getObjectCache: () => getObjectCache$1,
getPendingOps: () => getPendingOps$1,
getServerData: () => getServerData$1,
getState: () => getState$1,
initializeState: () => initializeState$1,
mergeFirstPendingState: () => mergeFirstPendingState$1,
popPendingState: () => popPendingState$1,
pushPendingState: () => pushPendingState$1,
removeState: () => removeState$1,
setPendingOp: () => setPendingOp$1,
setServerData: () => setServerData$1
});
var objectState$1 = Object.create(null);
function getState$1(obj) {
const classData = objectState$1[obj.className];
if (classData) return classData[obj.id] || null;
return null;
}
function initializeState$1(obj, initial) {
let state = getState$1(obj);
if (state) return state;
if (!objectState$1[obj.className]) objectState$1[obj.className] = Object.create(null);
if (!initial) initial = defaultState();
state = objectState$1[obj.className][obj.id] = initial;
return state;
}
function removeState$1(obj) {
const state = getState$1(obj);
if (state === null) return null;
delete objectState$1[obj.className][obj.id];
return state;
}
function getServerData$1(obj) {
const state = getState$1(obj);
if (state) return state.serverData;
return {};
}
function setServerData$1(obj, attributes) {
const serverData = initializeState$1(obj).serverData;
setServerData$2(serverData, attributes);
}
function getPendingOps$1(obj) {
const state = getState$1(obj);
if (state) return state.pendingOps;
return [{}];
}
function setPendingOp$1(obj, attr, op) {
const pendingOps = initializeState$1(obj).pendingOps;
setPendingOp$2(pendingOps, attr, op);
}
function pushPendingState$1(obj) {
const pendingOps = initializeState$1(obj).pendingOps;
pushPendingState$2(pendingOps);
}
function popPendingState$1(obj) {
const pendingOps = initializeState$1(obj).pendingOps;
return popPendingState$2(pendingOps);
}
function mergeFirstPendingState$1(obj) {
mergeFirstPendingState$2(getPendingOps$1(obj));
}
function getObjectCache$1(obj) {
const state = getState$1(obj);
if (state) return state.objectCache;
return {};
}
function estimateAttribute$1(obj, attr) {
return estimateAttribute$2(getServerData$1(obj), getPendingOps$1(obj), obj, attr);
}
function estimateAttributes$1(obj) {
return estimateAttributes$2(getServerData$1(obj), getPendingOps$1(obj), obj);
}
function commitServerChanges$1(obj, changes) {
const state = initializeState$1(obj);
commitServerChanges$2(state.serverData, state.objectCache, changes);
}
function enqueueTask$1(obj, task) {
return initializeState$1(obj).tasks.enqueue(task);
}
function clearAllState$1() {
objectState$1 = Object.create(null);
}
function duplicateState$1(source, dest) {
dest.id = source.id;
}
//#endregion
//#region src/UniqueInstanceStateController.ts
var UniqueInstanceStateController_exports = /* @__PURE__ */ __exportAll({
clearAllState: () => clearAllState,
commitServerChanges: () => commitServerChanges,
duplicateState: () => duplicateState,
enqueueTask: () => enqueueTask,
estimateAttribute: () => estimateAttribute,
estimateAttributes: () => estimateAttributes,
getObjectCache: () => getObjectCache,
getPendingOps: () => getPendingOps,
getServerData: () => getServerData,
getState: () => getState,
initializeState: () => initializeState,
mergeFirstPendingState: () => mergeFirstPendingState,
popPendingState: () => popPendingState,
pushPendingState: () => pushPendingState,
removeState: () => removeState,
setPendingOp: () => setPendingOp,
setServerData: () => setServerData
});
var objectState = /* @__PURE__ */ new WeakMap();
function getState(obj) {
return objectState.get(obj) || null;
}
function initializeState(obj, initial) {
let state = getState(obj);
if (state) return state;
if (!initial) initial = {
serverData: {},
pendingOps: [{}],
objectCache: {},
tasks: new TaskQueue(),
existed: false
};
state = initial;
objectState.set(obj, state);
return state;
}
function removeState(obj) {
const state = getState(obj);
if (state === null) return null;
objectState.delete(obj);
return state;
}
function getServerData(obj) {
const state = getState(obj);
if (state) return state.serverData;
return {};
}
function setServerData(obj, attributes) {
const serverData = initializeState(obj).serverData;
setServerData$2(serverData, attributes);
}
function getPendingOps(obj) {
const state = getState(obj);
if (state) return state.pendingOps;
return [{}];
}
function setPendingOp(obj, attr, op) {
const pendingOps = initializeState(obj).pendingOps;
setPendingOp$2(pendingOps, attr, op);
}
function pushPendingState(obj) {
const pendingOps = initializeState(obj).pendingOps;
pushPendingState$2(pendingOps);
}
function popPendingState(obj) {
const pendingOps = initializeState(obj).pendingOps;
return popPendingState$2(pendingOps);
}
function mergeFirstPendingState(obj) {
mergeFirstPendingState$2(getPendingOps(obj));
}
function getObjectCache(obj) {
const state = getState(obj);
if (state) return state.objectCache;
return {};
}
function estimateAttribute(obj, attr) {
return estimateAttribute$2(getServerData(obj), getPendingOps(obj), obj, attr);
}
function estimateAttributes(obj) {
return estimateAttributes$2(getServerData(obj), getPendingOps(obj), obj);
}
function commitServerChanges(obj, changes) {
const state = initializeState(obj);
commitServerChanges$2(state.serverData, state.objectCache, changes);
}
function enqueueTask(obj, task) {
return initializeState(obj).tasks.enqueue(task);
}
function duplicateState(source, dest) {
const oldState = initializeState(source);
const newState = initializeState(dest);
for (const key in oldState.serverData) newState.serverData[key] = oldState.serverData[key];
for (let index = 0; index < oldState.pendingOps.length; index++) for (const key in oldState.pendingOps[index]) newState.pendingOps[index][key] = oldState.pendingOps[index][key];
for (const key in oldState.objectCache) newState.objectCache[key] = oldState.objectCache[key];
newState.existed = oldState.existed;
}
function clearAllState() {
objectState = /* @__PURE__ */ new WeakMap();
}
//#endregion
//#region src/unsavedChildren.ts
/**
* Return an array of unsaved children, which are either Parse Objects or Files.
* If it encounters any dirty Objects without Ids, it will throw an exception.
*
* @param {Parse.Object} obj
* @param {boolean} allowDeepUnsaved
* @returns {Array}
*/
function unsavedChildren(obj, allowDeepUnsaved) {
const encountered = {
objects: {},
files: []
};
const identifier = obj.className + ":" + obj._getId();
encountered.objects[identifier] = obj.dirty() ? obj : true;
const attributes = obj.attributes;
for (const attr in attributes) if (typeof attributes[attr] === "object") traverse(attributes[attr], encountered, false, !!allowDeepUnsaved);
const unsaved = [];
for (const id in encountered.objects) if (id !== identifier && encountered.objects[id] !== true) unsaved.push(encountered.objects[id]);
return unsaved.concat(encountered.files);
}
function traverse(obj, encountered, shouldThrow, allowDeepUnsaved) {
if (obj instanceof CoreManager.getParseObject()) {
if (!obj.id && shouldThrow) throw new Error("Cannot create a pointer to an unsaved Object.");
const identifier = obj.className + ":" + obj._getId();
if (!encountered.objects[identifier]) {
encountered.objects[identifier] = obj.dirty() ? obj : true;
const attributes = obj.attributes;
for (const attr in attributes) if (typeof attributes[attr] === "object") traverse(attributes[attr], encountered, !allowDeepUnsaved, allowDeepUnsaved);
}
return;
}
if (obj instanceof ParseFile) {
if (!obj.url() && encountered.files.indexOf(obj) < 0) encountered.files.push(obj);
return;
}
if (obj instanceof ParseRelation) return;
if (Array.isArray(obj)) obj.forEach((el) => {
if (typeof el === "object") traverse(el, encountered, shouldThrow, allowDeepUnsaved);
});
for (const k in obj) if (typeof obj[k] === "object") traverse(obj[k], encountered, shouldThrow, allowDeepUnsaved);
}
//#endregion
//#region src/ParseObject.ts
var classMap = Object.create(null);
var objectCount = 0;
var singleInstance = !CoreManager.get("IS_NODE");
if (singleInstance) CoreManager.setObjectStateController(SingleInstanceStateController_exports);
else CoreManager.setObjectStateController(UniqueInstanceStateController_exports);
function getServerUrlPath() {
let serverUrl = CoreManager.get("SERVER_URL");
if (serverUrl[serverUrl.length - 1] !== "/") serverUrl += "/";
const url = serverUrl.replace(/https?:\/\//, "");
return url.substr(url.indexOf("/"));
}
/**
* Creates a new model with defined attributes.
*
* <p>You won't normally call this method directly. It is recommended that
* you use a subclass of <code>Parse.Object</code> instead, created by calling
* <code>extend</code>.</p>
*
* <p>However, if you don't want to use a subclass, or aren't sure which
* subclass is appropriate, you can use this form:<pre>
* var object = new Parse.Object("ClassName");
* </pre>
* That is basically equivalent to:<pre>
* var MyClass = Parse.Object.extend("ClassName");
* var object = new MyClass();
* </pre></p>
*
* @alias Parse.Object
*/
var ParseObject = class ParseObject {
/**
* @param {string} className The class name for the object
* @param {object} attributes The initial set of data to store in the object.
* @param {object} options The options for this object instance.
* @param {boolean} [options.ignoreValidation] Set to `true` ignore any attribute validation errors.
*/
constructor(className, attributes, options) {
if (typeof this.initialize === "function") this.initialize.apply(this, arguments);
let toSet = null;
this._objCount = objectCount++;
if (typeof className === "string") {
this.className = className;
if (attributes && typeof attributes === "object") toSet = attributes;
} else if (className && typeof className === "object") {
this.className = className.className;
toSet = {};
for (const attr in className) if (attr !== "className") toSet[attr] = className[attr];
if (attributes && typeof attributes === "object") options = attributes;
}
if (toSet) try {
this.set(toSet, options);
} catch (_) {
throw new Error("Can't create an invalid Parse Object");
}
if (CoreManager.get("NODE_LOGGING")) this[Symbol.for("nodejs.util.inspect.custom")] = function() {
return `ParseObject: className: ${this.className}, id: ${this.id}\nAttributes: ${JSON.stringify(this.attributes, null, 2)}`;
};
}
get attributes() {
const stateController = CoreManager.getObjectStateController();
return Object.freeze(stateController.estimateAttributes(this._getStateIdentifier()));
}
/**
* The first time this object was saved on the server.
*
* @property {Date} createdAt
* @returns {Date}
*/
get createdAt() {
return this._getServerData().createdAt;
}
/**
* The last time this object was updated on the server.
*
* @property {Date} updatedAt
* @returns {Date}
*/
get updatedAt() {
return this._getServerData().updatedAt;
}
/**
* Returns a local or server Id used uniquely identify this object
*
* @returns {string}
*/
_getId() {
if (typeof this.id === "string") return this.id;
if (typeof this._localId === "string") return this._localId;
const localId = "local" + uuid();
this._localId = localId;
return localId;
}
/**
* Returns a unique identifier used to pull data from the State Controller.
*
* @returns {Parse.Object|object}
*/
_getStateIdentifier() {
if (singleInstance) {
let id = this.id;
if (!id) id = this._getId();
return {
id,
className: this.className
};
} else return this;
}
_getServerData() {
return CoreManager.getObjectStateController().getServerData(this._getStateIdentifier());
}
_clearServerData() {
const serverData = this._getServerData();
const unset = {};
for (const attr in serverData) unset[attr] = void 0;
CoreManager.getObjectStateController().setServerData(this._getStateIdentifier(), unset);
}
_getPendingOps() {
return CoreManager.getObjectStateController().getPendingOps(this._getStateIdentifier());
}
/**
* @param {Array<string>} [keysToClear] - if specified, only ops matching
* these fields will be cleared
*/
_clearPendingOps(keysToClear) {
const pending = this._getPendingOps();
const latest = pending[pending.length - 1];
(keysToClear || Object.keys(latest)).forEach((key) => {
delete latest[key];
});
}
_getDirtyObjectAttributes() {
const attributes = this.attributes;
const objectCache = CoreManager.getObjectStateController().getObjectCache(this._getStateIdentifier());
const dirty = {};
for (const attr in attributes) {
const val = attributes[attr];
if (val && typeof val === "object" && !(val instanceof ParseObject) && !(val instanceof ParseFile) && !(val instanceof ParseRelation)) try {
const json = encode_default(val, false, true);
const stringified = JSON.stringify(json);
if (objectCache[attr] !== stringified) dirty[attr] = val;
} catch (_) {
dirty[attr] = val;
}
}
return dirty;
}
_toFullJSON(seen, offline) {
const json = this.toJSON(seen, offline);
json.__type = "Object";
json.className = this.className;
return json;
}
_getSaveJSON() {
const pending = this._getPendingOps();
const dirtyObjects = this._getDirtyObjectAttributes();
const json = {};
let attr;
for (attr in dirtyObjects) {
let isDotNotation = false;
for (let i = 0; i < pending.length; i += 1) for (const field in pending[i]) if (field.includes(".")) {
if (field.split(".")[0] === attr) {
isDotNotation = true;
break;
}
}
if (!isDotNotation) json[attr] = new SetOp(dirtyObjects[attr]).toJSON();
}
for (attr in pending[0]) json[attr] = pending[0][attr].toJSON();
return json;
}
_getSaveParams() {
let method = this.id ? "PUT" : "POST";
const body = this._getSaveJSON();
let path = "classes/" + this.className;
if (CoreManager.get("ALLOW_CUSTOM_OBJECT_ID")) if (!this.createdAt) {
method = "POST";
body.objectId = this.id;
} else {
method = "PUT";
path += "/" + this.id;
}
else if (this.id) path += "/" + this.id;
else if (this.className === "_User") path = "users";
return {
method,
body,
path
};
}
_finishFetch(serverData) {
if (!this.id && serverData.objectId) this.id = serverData.objectId;
const stateController = CoreManager.getObjectStateController();
stateController.initializeState(this._getStateIdentifier());
const decoded = {};
for (const attr in serverData) if (attr === "ACL") decoded[attr] = new ParseACL(serverData[attr]);
else if (attr !== "objectId") {
decoded[attr] = decode(serverData[attr]);
if (decoded[attr] instanceof ParseRelation) decoded[attr]._ensureParentAndKey(this, attr);
}
if (decoded.createdAt && typeof decoded.createdAt === "string") decoded.createdAt = parseDate(decoded.createdAt);
if (decoded.updatedAt && typeof decoded.updatedAt === "string") decoded.updatedAt = parseDate(decoded.updatedAt);
if (!decoded.updatedAt && decoded.createdAt) decoded.updatedAt = decoded.createdAt;
stateController.commitServerChanges(this._getStateIdentifier(), decoded);
}
_setExisted(existed) {
const state = CoreManager.getObjectStateController().getState(this._getStateIdentifier());
if (state) state.existed = existed;
}
_migrateId(serverId) {
if (this._localId && serverId) if (singleInstance) {
const stateController = CoreManager.getObjectStateController();
const oldState = stateController.removeState(this._getStateIdentifier());
this.id = serverId;
delete this._localId;
if (oldState) stateController.initializeState(this._getStateIdentifier(), oldState);
} else {
this.id = serverId;
delete this._localId;
}
}
_handleSaveResponse(response, status) {
const changes = {};
let attr;
const stateController = CoreManager.getObjectStateController();
const pending = stateController.popPendingState(this._getStateIdentifier());
for (attr in pending) if (pending[attr] instanceof RelationOp) changes[attr] = pending[attr].applyTo(void 0, this, attr);
else if (!(attr in response)) changes[attr] = pending[attr].applyTo(void 0);
for (attr in response) if ((attr === "createdAt" || attr === "updatedAt") && typeof response[attr] === "string") changes[attr] = parseDate(response[attr]);
else if (attr === "ACL") changes[attr] = new ParseACL(response[attr]);
else if (attr !== "objectId") {
const val = decode(response[attr]);
if (val && Object.getPrototypeOf(val) === Object.prototype) changes[attr] = {
...this.attributes[attr],
...val
};
else changes[attr] = val;
if (changes[attr] instanceof UnsetOp) changes[attr] = void 0;
}
if (changes.createdAt && !changes.updatedAt) changes.updatedAt = changes.createdAt;
this._migrateId(response.objectId);
if (status !== 201) this._setExisted(true);
stateController.commitServerChanges(this._getStateIdentifier(), changes);
}
_handleSaveError() {
CoreManager.getObjectStateController().mergeFirstPendingState(this._getStateIdentifier());
}
static _getClassMap() {
return classMap;
}
static _getRequestOptions(options = {}) {
const requestOptions = {};
if (Object.prototype.toString.call(options) !== "[object Object]") throw new Error("request options must be of type Object");
const { hasOwn } = Object;
if (hasOwn(options, "useMasterKey")) requestOptions.useMasterKey = !!options.useMasterKey;
if (hasOwn(options, "useMaintenanceKey")) requestOptions.useMaintenanceKey = !!options.useMaintenanceKey;
if (hasOwn(options, "sessionToken") && typeof options.sessionToken === "string") requestOptions.sessionToken = options.sessionToken;
if (hasOwn(options, "installationId") && typeof options.installationId === "string") requestOptions.installationId = options.installationId;
if (hasOwn(options, "transaction") && typeof options.transaction === "boolean") requestOptions.transaction = options.transaction;
if (hasOwn(options, "batchSize") && typeof options.batchSize === "number") requestOptions.batchSize = options.batchSize;
if (hasOwn(options, "context") && typeof options.context === "object") requestOptions.context = options.context;
if (hasOwn(options, "include")) requestOptions.include = ParseObject.handleIncludeOptions(options);
if (hasOwn(options, "usePost")) requestOptions.usePost = options.usePost;
if (hasOwn(options, "json")) requestOptions.json = options.json;
return requestOptions;
}
initialize() {}
/**
* Returns a JSON version of the object suitable for saving to Parse.
*
* @param seen
* @param offline
* @returns {object}
*/
toJSON(seen, offline) {
const seenEntry = this.id ? this.className + ":" + this.id : this;
seen = seen || [seenEntry];
const json = {};
const attrs = this.attributes;
for (const attr in attrs) if ((attr === "createdAt" || attr === "updatedAt") && attrs[attr].toJSON) json[attr] = attrs[attr].toJSON();
else json[attr] = encode_default(attrs[attr], false, false, seen, offline);
const pending = this._getPendingOps();
for (const attr in pending[0]) if (attr.indexOf(".") < 0) json[attr] = pending[0][attr].toJSON(offline);
if (this.id) json.objectId = this.id;
return json;
}
/**
* Determines whether this ParseObject is equal to another ParseObject
*
* @param {object} other - An other object ot compare
* @returns {boolean}
*/
equals(other) {
if (this === other) return true;
return other instanceof ParseObject && this.className === other.className && this.id === other.id && typeof this.id !== "undefined";
}
/**
* Returns true if this object has been modified since its last
* save/refresh. If an attribute is specified, it returns true only if that
* particular attribute has been modified since the last save/refresh.
*
* @param {string} attr An attribute name (optional).
* @returns {boolean}
*/
dirty(attr) {
if (!this.id) return true;
const pendingOps = this._getPendingOps();
const dirtyObjects = this._getDirtyObjectAttributes();
if (attr) {
if (Object.hasOwn(dirtyObjects, attr)) return true;
for (let i = 0; i < pendingOps.length; i++) if (Object.hasOwn(pendingOps[i], attr)) return true;
return false;
}
if (Object.keys(pendingOps[0]).length !== 0) return true;
if (Object.keys(dirtyObjects).length !== 0) return true;
return false;
}
/**
* Returns an array of keys that have been modified since last save/refresh
*
* @returns {string[]}
*/
dirtyKeys() {
const pendingOps = this._getPendingOps();
const keys = {};
for (let i = 0; i < pendingOps.length; i++) for (const attr in pendingOps[i]) keys[attr] = true;
const dirtyObjects = this._getDirtyObjectAttributes();
for (const attr in dirtyObjects) keys[attr] = true;
return Object.keys(keys);
}
/**
* Returns true if the object has been fetched.
*
* @returns {boolean}
*/
isDataAvailable() {
const serverData = this._getServerData();
return !!Object.keys(serverData).length;
}
/**
* Gets a Pointer referencing this Object.
*
* @returns {Pointer}
*/
toPointer() {
if (!this.id) throw new Error("Cannot create a pointer to an unsaved ParseObject");
return {
__type: "Pointer",
className: this.className,
objectId: this.id
};
}
/**
* Gets a Pointer referencing this Object.
*
* @returns {Pointer}
*/
toOfflinePointer() {
if (!this._localId) throw new Error("Cannot create a offline pointer to a saved ParseObject");
return {
__type: "Object",
className: this.className,
_localId: this._localId
};
}
/**
* Gets the value of an attribute.
*
* @param {string} attr The string name of an attribute.
* @returns {*}
*/
get(attr) {
return this.attributes[attr];
}
/**
* Gets a relation on the given class for the attribute.
*
* @param {string} attr The attribute to get the relation for.
* @returns {Parse.Relation}
*/
relation(attr) {
const value = this.get(attr);
if (value) {
if (!(value instanceof ParseRelation)) throw new Error("Called relation() on non-relation field " + attr);
value._ensureParentAndKey(this, attr);
return value;
}
return new ParseRelation(this, attr);
}
/**
* Gets the HTML-escaped value of an attribute.
*
* @param {string} attr The string name of an attribute.
* @returns {string}
*/
escape(attr) {
let val = this.attributes[attr];
if (val == null) return "";
if (typeof val !== "string") {
if (typeof val.toString !== "function") return "";
val = val.toString();
}
return escape$1(val);
}
/**
* Returns <code>true</code> if the attribute contains a value that is not
* null or undefined.
*
* @param {string} attr The string name of the attribute.
* @returns {boolean}
*/
has(attr) {
const attributes = this.attributes;
if (Object.hasOwn(attributes, attr)) return attributes[attr] != null;
return false;
}
/**
* Sets a hash of model attributes on the object.
*
* <p>You can call it with an object containing keys and values, with one
* key and value, or dot notation. For example:<pre>
* gameTurn.set({
* player: player1,
* diceRoll: 2
* }, {
* error: function(gameTurnAgain, error) {
* // The set failed validation.
* }
* });
*
* game.set("currentPlayer", player2, {
* error: function(gameTurnAgain, error) {
* // The set failed validation.
* }
* });
*
* game.set("finished", true);</pre></p>
*
* game.set("player.score", 10);</pre></p>
*
* @param {(string|object)} key The key to set.
* @param {(string|object)} value The value to give it.
* @param {object} options A set of options for the set.
* The only supported option is <code>error</code>.
* @returns {Parse.Object} Returns the object, so you can chain this call.
*/
set(key, value, options) {
let changes = {};
const newOps = {};
if (key && typeof key === "object") {
changes = key;
options = value;
} else if (typeof key === "string") changes[key] = value;
else return this;
options = options || {};
let readonly = [];
if (typeof this.constructor.readOnlyAttributes === "function") readonly = readonly.concat(this.constructor.readOnlyAttributes());
for (const k in changes) {
if (k === "createdAt" || k === "updatedAt") continue;
if (readonly.indexOf(k) > -1) throw new Error("Cannot modify readonly attribute: " + k);
if (options.unset) newOps[k] = new UnsetOp();
else if (changes[k] instanceof Op) newOps[k] = changes[k];
else if (changes[k] && typeof changes[k] === "object" && typeof changes[k].__op === "string") newOps[k] = opFromJSON(changes[k]);
else if (k === "objectId" || k === "id") {
if (typeof changes[k] === "string") this.id = changes[k];
} else if (k === "ACL" && typeof changes[k] === "object" && !(changes[k] instanceof ParseACL)) newOps[k] = new SetOp(new ParseACL(changes[k]));
else if (changes[k] instanceof ParseRelation) {
const relation = new ParseRelation(this, k);
relation.targetClassName = changes[k].targetClassName;
newOps[k] = new SetOp(relation);
} else newOps[k] = new SetOp(changes[k]);
}
const currentAttributes = this.attributes;
const newValues = {};
for (const attr in newOps) if (newOps[attr] instanceof RelationOp) newValues[attr] = newOps[attr].applyTo(currentAttributes[attr], this, attr);
else if (!(newOps[attr] instanceof UnsetOp)) newValues[attr] = newOps[attr].applyTo(currentAttributes[attr]);
if (!options.ignoreValidation) {
const validationError = this.validate(newValues);
if (validationError) throw validationError;
}
const pendingOps = this._getPendingOps();
const last = pendingOps.length - 1;
const stateController = CoreManager.getObjectStateController();
for (const attr in newOps) {
const nextOp = newOps[attr].mergeWith(pendingOps[last][attr]);
stateController.setPendingOp(this._getStateIdentifier(), attr, nextOp);
}
return this;
}
/**
* Remove an attribute from the model. This is a noop if the attribute doesn't
* exist.
*
* @param {string} attr The string name of an attribute.
* @param options
* @returns {Parse.Object} Returns the object, so you can chain this call.
*/
unset(attr, options) {
options = options || {};
options.unset = true;
return this.set(attr, null, options);
}
/**
* Atomically increments the value of the given attribute the next time the
* object is saved. If no amount is specified, 1 is used by default.
*
* @param attr {String} The key.
* @param amount {Number} The amount to increment by (optional).
* @returns {Parse.Object} Returns the object, so you can chain this call.
*/
increment(attr, amount) {
if (typeof amount === "undefined") amount = 1;
if (typeof amount !== "number") throw new Error("Cannot increment by a non-numeric amount.");
return this.set(attr, new IncrementOp(amount));
}
/**
* Atomically decrements the value of the given attribute the next time the
* object is saved. If no amount is specified, 1 is used by default.
*
* @param attr {String} The key.
* @param amount {Number} The amount to decrement by (optional).
* @returns {Parse.Object} Returns the object, so you can chain this call.
*/
decrement(attr, amount) {
if (typeof amount === "undefined") amount = 1;
if (typeof amount !== "number") throw new Error("Cannot decrement by a non-numeric amount.");
return this.set(attr, new IncrementOp(amount * -1));
}
/**
* Atomically add an object to the end of the array associated with a given
* key.
*
* @param attr {String} The key.
* @param item {} The item to add.
* @returns {Parse.Object} Returns the object, so you can chain this call.
*/
add(attr, item) {
return this.set(attr, new AddOp([item]));
}
/**
* Atomically add the objects to the end of the array associated with a given
* key.
*
* @param attr {String} The key.
* @param items {Object[]} The items to add.
* @returns {Parse.Object} Returns the object, so you can chain this call.
*/
addAll(attr, items) {
return this.set(attr, new AddOp(items));
}
/**
* Atomically add an object to the array associated with a given key, only
* if it is not already present in the array. The position of the insert is
* not guaranteed.
*
* @param attr {String} The key.
* @param item {} The object to add.
* @returns {Parse.Object} Returns the object, so you can chain this call.
*/
addUnique(attr, item) {
return this.set(attr, new AddUniqueOp([item]));
}
/**
* Atomically add the objects to the array associated with a given key, only
* if it is not already present in the array. The position of the insert is
* not guaranteed.
*
* @param attr {String} The key.
* @param items {Object[]} The objects to add.
* @returns {Parse.Object} Returns the object, so you can chain this call.
*/
addAllUnique(attr, items) {
return this.set(attr, new AddUniqueOp(items));
}
/**
* Atomically remove all instances of an object from the array associated
* with a given key.
*
* @param attr {String} The key.
* @param item {} The object to remove.
* @returns {Parse.Object} Returns the object, so you can chain this call.
*/
remove(attr, item) {
return this.set(attr, new RemoveOp([item]));
}
/**
* Atomically remove all instances of the objects from the array associated
* with a given key.
*
* @param attr {String} The key.
* @param items {Object[]} The object to remove.
* @returns {Parse.Object} Returns the object, so you can chain this call.
*/
removeAll(attr, items) {
return this.set(attr, new RemoveOp(items));
}
/**
* Returns an instance of a subclass of Parse.Op describing what kind of
* modification has been performed on this field since the last time it was
* saved. For example, after calling object.increment("x"), calling
* object.op("x") would return an instance of Parse.Op.Increment.
*
* @param attr {String} The key.
* @returns {Parse.Op | undefined} The operation, or undefined if none.
*/
op(attr) {
const pending = this._getPendingOps();
for (let i = 0; i < pending.length; i += 1) if (pending[i][attr]) return pending[i][attr];
}
/**
* Creates a new model with identical attributes to this one.
*
* @returns {Parse.Object}
*/
clone() {
const clone = new this.constructor(this.className);
let attributes = this.attributes;
if (typeof this.constructor.readOnlyAttributes === "function") {
const readonly = this.constructor.readOnlyAttributes() || [];
const copy = {};
for (const a in attributes) if (readonly.indexOf(a) < 0) copy[a] = attributes[a];
attributes = copy;
}
if (clone.set) clone.set(attributes);
return clone;
}
/**
* Creates a new instance of this object. Not to be confused with clone()
*
* @returns {Parse.Object}
*/
newInstance() {
const clone = new this.constructor(this.className);
clone.id = this.id;
if (singleInstance) return clone;
const stateController = CoreManager.getObjectStateController();
if (stateController) stateController.duplicateState(this._getStateIdentifier(), clone._getStateIdentifier());
return clone;
}
/**
* Returns true if this object has never been saved to Parse.
*
* @returns {boolean}
*/
isNew() {
return !this.id;
}
/**
* Returns true if this object was created by the Parse server when the
* object might have already been there (e.g. in the case of a Facebook
* login)
*
* @returns {boolean}
*/
existed() {
if (!this.id) return false;
const state = CoreManager.getObjectStateController().getState(this._getStateIdentifier());
if (state) return state.existed;
return false;
}
/**
* Returns true if this object exists on the Server
*
* @param {object} options
* Valid options are:<ul>
* <li>useMasterKey: In Cloud Code and Node only, causes the Master Key to
* be used for this request.
* <li>sessionToken: A valid session token, used for making a request on
* behalf of a specific user.
* </ul>
* @returns {Promise<boolean>} A boolean promise that is fulfilled if object exists.
*/
async exists(options) {
if (!this.id) return false;
try {
await new (CoreManager.getParseQuery())(this.className).get(this.id, options);
return true;
} catch (e) {
if (e.code === ParseError.OBJECT_NOT_FOUND) return false;
throw e;
}
}
/**
* Checks if the model is currently in a valid state.
*
* @returns {boolean}
*/
isValid() {
return !this.validate(this.attributes);
}
/**
* You should not call this function directly unless you subclass
* <code>Parse.Object</code>, in which case you can override this method
* to provide additional validation on <code>set</code> and
* <code>save</code>. Your implementation should return
*
* @param {object} attrs The current data to validate.
* @returns {Parse.Error|boolean} False if the data is valid. An error object otherwise.
* @see Parse.Object#set
*/
validate(attrs) {
if (Object.hasOwn(attrs, "ACL") && !(attrs.ACL instanceof ParseACL)) return new ParseError(ParseError.OTHER_CAUSE, "ACL must be a Parse ACL.");
for (const key in attrs) if (!/^[A-Za-z_][0-9A-Za-z_.]*$/.test(key)) return new ParseError(ParseError.INVALID_KEY_NAME, `Invalid key name: ${key}`);
return false;
}
/**
* Returns the ACL for this object.
*
* @returns {Parse.ACL|null} An instance of Parse.ACL.
* @see Parse.Object#get
*/
getACL() {
const acl = this.get("ACL");
if (acl instanceof ParseACL) return acl;
return null;
}
/**
* Sets the ACL to be used for this object.
*
* @param {Parse.ACL} acl An instance of Parse.ACL.
* @param {object} options
* @returns {Parse.Object} Returns the object, so you can chain this call.
* @see Parse.Object#set
*/
setACL(acl, options) {
return this.set("ACL", acl, options);
}
/**
* Clears any (or specific) changes to this object made since the last call to save()
*
* @param {string} [keys] - specify which fields to revert
*/
revert(...keys) {
let keysToRevert;
if (keys.length) {
keysToRevert = [];
for (const key of keys) if (typeof key === "string") keysToRevert.push(key);
else throw new Error("Parse.Object#revert expects either no, or a list of string, arguments.");
}
this._clearPendingOps(keysToRevert);
}
/**
* Clears all attributes on a model
*
* @returns {Parse.Object} Returns the object, so you can chain this call.
*/
clear() {
const attributes = this.attributes;
const erasable = {};
let readonly = ["createdAt", "updatedAt"];
if (typeof this.constructor.readOnlyAttributes === "function") readonly = readonly.concat(this.constructor.readOnlyAttributes());
for (const attr in attributes) if (readonly.indexOf(attr) < 0) erasable[attr] = true;
return this.set(erasable, { unset: true });
}
/**
* Fetch the model from the server. If the server's representation of the
* model differs from its current attributes, they will be overriden.
*
* @param {object} options
* Valid options are:<ul>
* <li>useMasterKey: In Cloud Code and Node only, causes the Master Key to
* be used for this request.
* <li>sessionToken: A valid session token, used for making a request on
* behalf of a specific user.
* <li>include: The name(s) of the key(s) to include. Can be a string, an array of strings,
* or an array of array of strings.
* <li>context: A dictionary that is accessible in Cloud Code `beforeFind` trigger.
* </ul>
* @returns {Promise} A promise that is fulfilled when the fetch
* completes.
*/
fetch(options) {
const fetchOptions = ParseObject._getRequestOptions(options);
return CoreManager.getObjectController().fetch(this, true, fetchOptions);
}
/**
* Fetch the model from the server. If the server's representation of the
* model differs from its current attributes, they will be overriden.
*
* Includes nested Parse.Objects for the provided key. You can use dot
* notation to specify which fields in the included object are also fetched.
*
* @param {string | Array<string | Array<string>>} keys The name(s) of the key(s) to include.
* @param {object} options
* Valid options are:<ul>
* <li>useMasterKey: In Cloud Code and Node only, causes the Master Key to
* be used for this request.
* <li>sessionToken: A valid session token, used for making a request on
* behalf of a specific user.
* </ul>
* @returns {Promise} A promise that is fulfilled when the fetch
* completes.
*/
fetchWithInclude(keys, options) {
options = options || {};
options.include = keys;
return this.fetch(options);
}
/**
* Saves this object to the server at some unspecified time in the future,
* even if Parse is currently inaccessible.
*
* Use this when you may not have a solid network connection, and don't need to know when the save completes.
* If there is some problem with the object such that it can't be saved, it will be silently discarded.
*
* Objects saved with this method will be stored locally in an on-disk cache until they can be delivered to Parse.
* They will be sent immediately if possible. Otherwise, they will be sent the next time a network connection is
* available. Objects saved this way will persist even after the app is closed, in which case they will be sent the
* next time the app is opened.
*
* @param {object} [options]
* Used to pass option parameters to method if arg1 and arg2 were both passed as strings.
* Valid options are:
* <ul>
* <li>sessionToken: A valid session token, used for making a request on
* behalf of a specific user.
* <li>cascadeSave: If `false`, nested objects will not be saved (default is `true`).
* <li>context: A dictionary that is accessible in Cloud Code `beforeSave` and `afterSave` triggers.
* </ul>
* @returns {Promise} A promise that is fulfilled when the save
* completes.
*/
async saveEventually(options) {
try {
await this.save(null, options);
} catch (e) {
if (e.code === ParseError.CONNECTION_FAILED) {
await CoreManager.getEventuallyQueue().save(this, options);
CoreManager.getEventuallyQueue().poll();
}
}
return this;
}
async save(arg1, arg2, arg3) {
let attrs;
let options;
if (typeof arg1 === "object" || typeof arg1 === "undefined") {
attrs = arg1;
if (typeof arg2 === "object") options = arg2;
} else {
attrs = {};
attrs[arg1] = arg2;
options = arg3;
}
options = options || {};
if (attrs) this.set(attrs, options);
const saveOptions = ParseObject._getRequestOptions(options);
const controller = CoreManager.getObjectController();
const unsaved = options.cascadeSave !== false ? unsavedChildren(this) : null;
if (unsaved && unsaved.length && options.transaction === true && unsaved.some((el) => el instanceof ParseObject)) {
const unsavedFiles = [];
const unsavedObjects = [];
unsaved.forEach((el) => {
if (el instanceof ParseFile) unsavedFiles.push(el);
else unsavedObjects.push(el);
});
unsavedObjects.push(this);
return (unsavedFiles.length ? controller.save(unsavedFiles, saveOptions) : Promise.resolve()).then(() => controller.save(unsavedObjects, saveOptions)).then((savedOjbects) => savedOjbects.pop());
}
await controller.save(unsaved, saveOptions);
return controller.save(this, saveOptions);
}
/**
* Deletes this object from the server at some unspecified time in the future,
* even if Parse is currently inaccessible.
*
* Use this when you may not have a solid network connection,
* and don't need to know when the delete completes. If there is some problem with the object
* such that it can't be deleted, the request will be silently discarded.
*
* Delete instructions made with this method will be stored locally in an on-disk cache until they can be transmitted
* to Parse. They will be sent immediately if possible. Otherwise, they will be sent the next time a network connection
* is available. Delete requests will persist even after the app is closed, in which case they will be sent the
* next time the app is opened.
*
* @param {object} [options]
* Valid options are:<ul>
* <li>sessionToken: A valid session token, used for making a request on
* behalf of a specific user.
* <li>context: A dictionary that is accessible in Cloud Code `beforeDelete` and `afterDelete` triggers.
* </ul>
* @returns {Promise} A promise that is fulfilled when the destroy
* completes.
*/
async destroyEventually(options) {
try {
await this.destroy(options);
} catch (e) {
if (e.code === ParseError.CONNECTION_FAILED) {
await CoreManager.getEventuallyQueue().destroy(this, options);
CoreManager.getEventuallyQueue().poll();
}
}
return this;
}
/**
* Destroy this model on the server if it was already persisted.
*
* @param {object} options
* Valid options are:<ul>
* <li>useMasterKey: In Cloud Code and Node only, causes the Master Key to
* be used for this request.
* <li>sessionToken: A valid session token, used for making a request on
* behalf of a specific user.
* <li>context: A dictionary that is accessible in Cloud Code `beforeDelete` and `afterDelete` triggers.
* </ul>
* @returns {Promise} A promise that is fulfilled when the destroy
* completes.
*/
destroy(options) {
if (!this.id) return Promise.resolve(void 0);
const destroyOptions = ParseObject._getRequestOptions(options);
return CoreManager.getObjectController().destroy(this, destroyOptions);
}
/**
* Asynchronously stores the object and every object it points to in the local datastore,
* recursively, using a default pin name: _default.
*
* If those other objects have not been fetched from Parse, they will not be stored.
* However, if they have changed data, all the changes will be retained.
*
* <pre>
* await object.pin();
* </pre>
*
* To retrieve object:
* <code>query.fromLocalDatastore()</code> or <code>query.fromPin()</code>
*
* @returns {Promise} A promise that is fulfilled when the pin completes.
*/
pin() {
return ParseObject.pinAllWithName(DEFAULT_PIN, [this]);
}
/**
* Asynchronously removes the object and every object it points to in the local datastore,
* recursively, using a default pin name: _default.
*
* <pre>
* await object.unPin();
* </pre>
*
* @returns {Promise} A promise that is fulfilled when the unPin completes.
*/
unPin() {
return ParseObject.unPinAllWithName(DEFAULT_PIN, [this]);
}
/**
* Asynchronously returns if the object is pinned
*
* <pre>
* const isPinned = await object.isPinned();
* </pre>
*
* @returns {Promise<boolean>} A boolean promise that is fulfilled if object is pinned.
*/
async isPinned() {
const localDatastore = CoreManager.getLocalDatastore();
if (!localDatastore.isEnabled) return Promise.reject("Parse.enableLocalDatastore() must be called first");
const objectKey = localDatastore.getKeyForObject(this);
return (await localDatastore.fromPinWithName(objectKey)).length > 0;
}
/**
* Asynchronously stores the objects and every object they point to in the local datastore, recursively.
*
* If those other objects have not been fetched from Parse, they will not be stored.
* However, if they have changed data, all the changes will be retained.
*
* <pre>
* await object.pinWithName(name);
* </pre>
*
* To retrieve object:
* <code>query.fromLocalDatastore()</code> or <code>query.fromPinWithName(name)</code>
*
* @param {string} name Name of Pin.
* @returns {Promise} A promise that is fulfilled when the pin completes.
*/
pinWithName(name) {
return ParseObject.pinAllWithName(name, [this]);
}
/**
* Asynchronously removes the object and every object it points to in the local datastore, recursively.
*
* <pre>
* await object.unPinWithName(name);
* </pre>
*
* @param {string} name Name of Pin.
* @returns {Promise} A promise that is fulfilled when the unPin completes.
*/
unPinWithName(name) {
return ParseObject.unPinAllWithName(name, [this]);
}
/**
* Asynchronously loads data from the local datastore into this object.
*
* <pre>
* await object.fetchFromLocalDatastore();
* </pre>
*
* You can create an unfetched pointer with <code>Parse.Object.createWithoutData()</code>
* and then call <code>fetchFromLocalDatastore()</code> on it.
*
* @returns {Promise} A promise that is fulfilled when the fetch completes.
*/
async fetchFromLocalDatastore() {
const localDatastore = CoreManager.getLocalDatastore();
if (!localDatastore.isEnabled) throw new Error("Parse.enableLocalDatastore() must be called first");
const objectKey = localDatastore.getKeyForObject(this);
const pinned = await localDatastore._serializeObject(objectKey);
if (!pinned) throw new Error("Cannot fetch an unsaved ParseObject");
const result = ParseObject.fromJSON(pinned);
this._finishFetch(result.toJSON());
return this;
}
static _clearAllState() {
CoreManager.getObjectStateController().clearAllState();
}
/**
* Fetches the given list of Parse.Object.
* If any error is encountered, stops and calls the error handler.
*
* <pre>
* Parse.Object.fetchAll([object1, object2, ...])
* .then((list) => {
* // All the objects were fetched.
* }, (error) => {
* // An error occurred while fetching one of the objects.
* });
* </pre>
*
* @param {Array} list A list of <code>Parse.Object</code>.
* @param {object} options
* Valid options are:<ul>
* <li>useMasterKey: In Cloud Code and Node only, causes the Master Key to
* be used for this request.
* <li>sessionToken: A valid session token, used for making a request on
* behalf of a specific user.
* <li>include: The name(s) of the key(s) to include. Can be a string, an array of strings,
* or an array of array of strings.
* </ul>
* @static
* @returns {Parse.Object[]}
*/
static fetchAll(list, options) {
const fetchOptions = ParseObject._getRequestOptions(options);
return CoreManager.getObjectController().fetch(list, true, fetchOptions);
}
/**
* Fetches the given list of Parse.Object.
*
* Includes nested Parse.Objects for the provided key. You can use dot
* notation to specify which fields in the included object are also fetched.
*
* If any error is encountered, stops and calls the error handler.
*
* <pre>
* Parse.Object.fetchAllWithInclude([object1, object2, ...], [pointer1, pointer2, ...])
* .then((list) => {
* // All the objects were fetched.
* }, (error) => {
* // An error occurred while fetching one of the objects.
* });
* </pre>
*
* @param {Array} list A list of <code>Parse.Object</code>.
* @param {string | Array<string | Array<string>>} keys The name(s) of the key(s) to include.
* @param {object} options
* Valid options are:<ul>
* <li>useMasterKey: In Cloud Code and Node only, causes the Master Key to
* be used for this request.
* <li>sessionToken: A valid session token, used for making a request on
* behalf of a specific user.
* </ul>
* @static
* @returns {Parse.Object[]}
*/
static fetchAllWithInclude(list, keys, options) {
options = options || {};
options.include = keys;
return ParseObject.fetchAll(list, options);
}
/**
* Fetches the given list of Parse.Object if needed.
* If any error is encountered, stops and calls the error handler.
*
* Includes nested Parse.Objects for the provided key. You can use dot
* notation to specify which fields in the included object are also fetched.
*
* If any error is encountered, stops and calls the error handler.
*
* <pre>
* Parse.Object.fetchAllIfNeededWithInclude([object1, object2, ...], [pointer1, pointer2, ...])
* .then((list) => {
* // All the objects were fetched.
* }, (error) => {
* // An error occurred while fetching one of the objects.
* });
* </pre>
*
* @param {Array} list A list of <code>Parse.Object</code>.
* @param {string | Array<string | Array<string>>} keys The name(s) of the key(s) to include.
* @param {object} options
* Valid options are:<ul>
* <li>useMasterKey: In Cloud Code and Node only, causes the Master Key to
* be used for this request.
* <li>sessionToken: A valid session token, used for making a request on
* behalf of a specific user.
* </ul>
* @static
* @returns {Parse.Object[]}
*/
static fetchAllIfNeededWithInclude(list, keys, options) {
options = options || {};
options.include = keys;
return ParseObject.fetchAllIfNeeded(list, options);
}
/**
* Fetches the given list of Parse.Object if needed.
* If any error is encountered, stops and calls the error handler.
*
* <pre>
* Parse.Object.fetchAllIfNeeded([object1, ...])
* .then((list) => {
* // Objects were fetched and updated.
* }, (error) => {
* // An error occurred while fetching one of the objects.
* });
* </pre>
*
* @param {Array} list A list of <code>Parse.Object</code>.
* @param {object} options
* Valid options are:<ul>
* <li>useMasterKey: In Cloud Code and Node only, causes the Master Key to
* be used for this request.
* <li>sessionToken: A valid session token, used for making a request on
* behalf of a specific user.
* <li>include: The name(s) of the key(s) to include. Can be a string, an array of strings,
* or an array of array of strings.
* <li>context: A dictionary that is accessible in Cloud Code `beforeFind` trigger.
* </ul>
* @static
* @returns {Parse.Object[]}
*/
static fetchAllIfNeeded(list, options) {
const fetchOptions = ParseObject._getRequestOptions(options);
return CoreManager.getObjectController().fetch(list, false, fetchOptions);
}
static handleIncludeOptions(options) {
let include = [];
if (Array.isArray(options.include)) options.include.forEach((key) => {
if (Array.isArray(key)) include = include.concat(key);
else include.push(key);
});
else include.push(options.include);
return include;
}
/**
* Destroy the given list of models on the server if it was already persisted.
*
* <p>Unlike saveAll, if an error occurs while deleting an individual model,
* this method will continue trying to delete the rest of the models if
* possible, except in the case of a fatal error like a connection error.
*
* <p>In particular, the Parse.Error object returned in the case of error may
* be one of two types:
*
* <ul>
* <li>A Parse.Error.AGGREGATE_ERROR. This object's "errors" property is an
* array of other Parse.Error objects. Each error object in this array
* has an "object" property that references the object that could not be
* deleted (for instance, because that object could not be found).</li>
* <li>A non-aggregate Parse.Error. This indicates a serious error that
* caused the delete operation to be aborted partway through (for
* instance, a connection failure in the middle of the delete).</li>
* </ul>
*
* <pre>
* Parse.Object.destroyAll([object1, object2, ...])
* .then((list) => {
* // All the objects were deleted.
* }, (error) => {
* // An error occurred while deleting one or more of the objects.
* // If this is an aggregate error, then we can inspect each error
* // object individually to determine the reason why a particular
* // object was not deleted.
* if (error.code === Parse.Error.AGGREGATE_ERROR) {
* for (var i = 0; i < error.errors.length; i++) {
* console.log("Couldn't delete " + error.errors[i].object.id +
* "due to " + error.errors[i].message);
* }
* } else {
* console.log("Delete aborted because of " + error.message);
* }
* });
* </pre>
*
* @param {Array} list A list of <code>Parse.Object</code>.
* @param {object} options
* Valid options are:<ul>
* <li>useMasterKey: In Cloud Code and Node only, causes the Master Key to
* be used for this request.
* <li>sessionToken: A valid session token, used for making a request on
* behalf of a specific user.
* <li>context: A dictionary that is accessible in Cloud Code `beforeDelete` and `afterDelete` triggers.
* <li>transaction: Set to true to enable transactions
* <li>batchSize: How many objects to yield in each batch (default: 20)
* </ul>
* @static
* @returns {Promise} A promise that is fulfilled when the destroyAll
* completes.
*/
static destroyAll(list, options) {
const destroyOptions = ParseObject._getRequestOptions(options);
return CoreManager.getObjectController().destroy(list, destroyOptions);
}
/**
* Saves the given list of Parse.Object.
* If any error is encountered, stops and calls the error handler.
*
* <pre>
* Parse.Object.saveAll([object1, object2, ...])
* .then((list) => {
* // All the objects were saved.
* }, (error) => {
* // An error occurred while saving one of the objects.
* });
* </pre>
*
* @param {Array} list A list of <code>Parse.Object</code>.
* @param {object} options
* Valid options are:
* <ul>
* <li>useMasterKey: In Cloud Code and Node only, causes the Master Key to
* be used for this request.
* <li>sessionToken: A valid session token, used for making a request on
* behalf of a specific user.
* <li>cascadeSave: If `false`, nested objects will not be saved (default is `true`).
* <li>context: A dictionary that is accessible in Cloud Code `beforeSave` and `afterSave` triggers.
* <li>transaction: Set to true to enable transactions
* <li>batchSize: How many objects to yield in each batch (default: 20)
* </ul>
* @static
* @returns {Parse.Object[]}
*/
static saveAll(list, options) {
const saveOptions = ParseObject._getRequestOptions(options);
return CoreManager.getObjectController().save(list, saveOptions);
}
/**
* Creates a reference to a subclass of Parse.Object with the given id. This
* does not exist on Parse.Object, only on subclasses.
*
* <p>A shortcut for: <pre>
* var Foo = Parse.Object.extend("Foo");
* var pointerToFoo = new Foo();
* pointerToFoo.id = "myObjectId";
* </pre>
*
* @param {string} id The ID of the object to create a reference to.
* @static
* @returns {Parse.Object} A Parse.Object reference.
*/
static createWithoutData(id) {
const obj = new this();
obj.id = id;
return obj;
}
/**
* Creates a new instance of a Parse Object from a JSON representation.
*
* @param {object} json The JSON map of the Object's data
* @param {boolean} override In single instance mode, all old server data
* is overwritten if this is set to true
* @param {boolean} dirty Whether the Parse.Object should set JSON keys to dirty
* @static
* @returns {Parse.Object} A Parse.Object reference
*/
static fromJSON(json, override, dirty) {
if (!json.className) throw new Error("Cannot create an object without a className");
const constructor = classMap[json.className];
const o = constructor ? new constructor(json.className) : new ParseObject(json.className);
const otherAttributes = {};
for (const attr in json) if (attr !== "className" && attr !== "__type") {
otherAttributes[attr] = json[attr];
if (dirty) o.set(attr, json[attr]);
}
if (override) {
if (otherAttributes.objectId) o.id = otherAttributes.objectId;
let preserved = null;
if (typeof o._preserveFieldsOnFetch === "function") preserved = o._preserveFieldsOnFetch();
o._clearServerData();
if (preserved) o._finishFetch(preserved);
}
o._finishFetch(otherAttributes);
if (json.objectId) o._setExisted(true);
return o;
}
/**
* Registers a subclass of Parse.Object with a specific class name.
* When objects of that class are retrieved from a query, they will be
* instantiated with this subclass.
* This is only necessary when using ES6 subclassing.
*
* @param {string} className The class name of the subclass
* @param {Function} constructor The subclass
*/
static registerSubclass(className, constructor) {
if (typeof className !== "string") throw new TypeError("The first argument must be a valid class name.");
if (typeof constructor === "undefined") throw new TypeError("You must supply a subclass constructor.");
if (typeof constructor !== "function") throw new TypeError("You must register the subclass constructor. Did you attempt to register an instance of the subclass?");
classMap[className] = constructor;
if (!constructor.className) constructor.className = className;
}
/**
* Unegisters a subclass of Parse.Object with a specific class name.
*
* @param {string} className The class name of the subclass
*/
static unregisterSubclass(className) {
if (typeof className !== "string") throw new TypeError("The first argument must be a valid class name.");
delete classMap[className];
}
/**
* Creates a new subclass of Parse.Object for the given Parse class name.
*
* <p>Every extension of a Parse class will inherit from the most recent
* previous extension of that class. When a Parse.Object is automatically
* created by parsing JSON, it will use the most recent extension of that
* class.</p>
*
* <p>You should call either:<pre>
* var MyClass = Parse.Object.extend("MyClass", {
* <i>Instance methods</i>,
* initialize: function(attrs, options) {
* this.someInstanceProperty = [],
* <i>Other instance properties</i>
* }
* }, {
* <i>Class properties</i>
* });</pre>
* or, for Backbone compatibility:<pre>
* var MyClass = Parse.Object.extend({
* className: "MyClass",
* <i>Instance methods</i>,
* initialize: function(attrs, options) {
* this.someInstanceProperty = [],
* <i>Other instance properties</i>
* }
* }, {
* <i>Class properties</i>
* });</pre></p>
*
* @param {string} className The name of the Parse class backing this model.
* @param {object} [protoProps] Instance properties to add to instances of the
* class returned from this method.
* @param {object} [classProps] Class properties to add the class returned from
* this method.
* @returns {Parse.Object} A new subclass of Parse.Object.
*/
static extend(className, protoProps, classProps) {
if (typeof className !== "string") if (className && typeof className.className === "string") return ParseObject.extend(className.className, className, protoProps);
else throw new Error("Parse.Object.extend's first argument should be the className.");
let adjustedClassName = className;
if (adjustedClassName === "User" && CoreManager.get("PERFORM_USER_REWRITE")) adjustedClassName = "_User";
let parentProto = ParseObject.prototype;
if (Object.hasOwn(this, "__super__") && this.__super__) parentProto = this.prototype;
let ParseObjectSubclass = function(attributes, options) {
this.className = adjustedClassName;
this._objCount = objectCount++;
if (typeof this.initialize === "function") this.initialize.apply(this, arguments);
if (this._initializers) for (const initializer of this._initializers) initializer.apply(this, arguments);
if (attributes && typeof attributes === "object") try {
this.set(attributes || {}, options);
} catch (_) {
throw new Error("Can't create an invalid Parse Object");
}
};
if (classMap[adjustedClassName]) ParseObjectSubclass = classMap[adjustedClassName];
else {
ParseObjectSubclass.extend = function(name, protoProps, classProps) {
if (typeof name === "string") return ParseObject.extend.call(ParseObjectSubclass, name, protoProps, classProps);
return ParseObject.extend.call(ParseObjectSubclass, adjustedClassName, name, protoProps);
};
ParseObjectSubclass.createWithoutData = ParseObject.createWithoutData;
ParseObjectSubclass.className = adjustedClassName;
ParseObjectSubclass.__super__ = parentProto;
ParseObjectSubclass.prototype = Object.create(parentProto, { constructor: {
value: ParseObjectSubclass,
enumerable: false,
writable: true,
configurable: true
} });
}
if (protoProps) for (const prop in protoProps) {
if (prop === "initialize") {
Object.defineProperty(ParseObjectSubclass.prototype, "_initializers", {
value: [...ParseObjectSubclass.prototype._initializers || [], protoProps[prop]],
enumerable: false,
writable: true,
configurable: true
});
continue;
}
if (prop !== "className") Object.defineProperty(ParseObjectSubclass.prototype, prop, {
value: protoProps[prop],
enumerable: false,
writable: true,
configurable: true
});
}
if (classProps) {
for (const prop in classProps) if (prop !== "className") Object.defineProperty(ParseObjectSubclass, prop, {
value: classProps[prop],
enumerable: false,
writable: true,
configurable: true
});
}
classMap[adjustedClassName] = ParseObjectSubclass;
return ParseObjectSubclass;
}
/**
* Enable single instance objects, where any local objects with the same Id
* share the same attributes, and stay synchronized with each other.
* This is disabled by default in server environments, since it can lead to
* security issues.
*
* @static
*/
static enableSingleInstance() {
singleInstance = true;
CoreManager.setObjectStateController(SingleInstanceStateController_exports);
}
/**
* Disable single instance objects, where any local objects with the same Id
* share the same attributes, and stay synchronized with each other.
* When disabled, you can have two instances of the same object in memory
* without them sharing attributes.
*
* @static
*/
static disableSingleInstance() {
singleInstance = false;
CoreManager.setObjectStateController(UniqueInstanceStateController_exports);
}
/**
* Asynchronously stores the objects and every object they point to in the local datastore,
* recursively, using a default pin name: _default.
*
* If those other objects have not been fetched from Parse, they will not be stored.
* However, if they have changed data, all the changes will be retained.
*
* <pre>
* await Parse.Object.pinAll([...]);
* </pre>
*
* To retrieve object:
* <code>query.fromLocalDatastore()</code> or <code>query.fromPin()</code>
*
* @param {Array} objects A list of <code>Parse.Object</code>.
* @returns {Promise} A promise that is fulfilled when the pin completes.
* @static
*/
static pinAll(objects) {
if (!CoreManager.getLocalDatastore().isEnabled) return Promise.reject("Parse.enableLocalDatastore() must be called first");
return ParseObject.pinAllWithName(DEFAULT_PIN, objects);
}
/**
* Asynchronously stores the objects and every object they point to in the local datastore, recursively.
*
* If those other objects have not been fetched from Parse, they will not be stored.
* However, if they have changed data, all the changes will be retained.
*
* <pre>
* await Parse.Object.pinAllWithName(name, [obj1, obj2, ...]);
* </pre>
*
* To retrieve object:
* <code>query.fromLocalDatastore()</code> or <code>query.fromPinWithName(name)</code>
*
* @param {string} name Name of Pin.
* @param {Array} objects A list of <code>Parse.Object</code>.
* @returns {Promise} A promise that is fulfilled when the pin completes.
* @static
*/
static pinAllWithName(name, objects) {
const localDatastore = CoreManager.getLocalDatastore();
if (!localDatastore.isEnabled) return Promise.reject("Parse.enableLocalDatastore() must be called first");
return localDatastore._handlePinAllWithName(name, objects);
}
/**
* Asynchronously removes the objects and every object they point to in the local datastore,
* recursively, using a default pin name: _default.
*
* <pre>
* await Parse.Object.unPinAll([...]);
* </pre>
*
* @param {Array} objects A list of <code>Parse.Object</code>.
* @returns {Promise} A promise that is fulfilled when the unPin completes.
* @static
*/
static unPinAll(objects) {
if (!CoreManager.getLocalDatastore().isEnabled) return Promise.reject("Parse.enableLocalDatastore() must be called first");
return ParseObject.unPinAllWithName(DEFAULT_PIN, objects);
}
/**
* Asynchronously removes the objects and every object they point to in the local datastore, recursively.
*
* <pre>
* await Parse.Object.unPinAllWithName(name, [obj1, obj2, ...]);
* </pre>
*
* @param {string} name Name of Pin.
* @param {Array} objects A list of <code>Parse.Object</code>.
* @returns {Promise} A promise that is fulfilled when the unPin completes.
* @static
*/
static unPinAllWithName(name, objects) {
const localDatastore = CoreManager.getLocalDatastore();
if (!localDatastore.isEnabled) return Promise.reject("Parse.enableLocalDatastore() must be called first");
return localDatastore._handleUnPinAllWithName(name, objects);
}
/**
* Asynchronously removes all objects in the local datastore using a default pin name: _default.
*
* <pre>
* await Parse.Object.unPinAllObjects();
* </pre>
*
* @returns {Promise} A promise that is fulfilled when the unPin completes.
* @static
*/
static unPinAllObjects() {
const localDatastore = CoreManager.getLocalDatastore();
if (!localDatastore.isEnabled) return Promise.reject("Parse.enableLocalDatastore() must be called first");
return localDatastore.unPinWithName(DEFAULT_PIN);
}
/**
* Asynchronously removes all objects with the specified pin name.
* Deletes the pin name also.
*
* <pre>
* await Parse.Object.unPinAllObjectsWithName(name);
* </pre>
*
* @param {string} name Name of Pin.
* @returns {Promise} A promise that is fulfilled when the unPin completes.
* @static
*/
static unPinAllObjectsWithName(name) {
const localDatastore = CoreManager.getLocalDatastore();
if (!localDatastore.isEnabled) return Promise.reject("Parse.enableLocalDatastore() must be called first");
return localDatastore.unPinWithName(PIN_PREFIX + name);
}
};
var DefaultController$2 = {
fetch(target, forceFetch, options) {
const localDatastore = CoreManager.getLocalDatastore();
if (Array.isArray(target)) {
if (target.length < 1) return Promise.resolve([]);
const objs = [];
const ids = [];
let className = null;
const results = [];
let error = null;
target.forEach((el) => {
if (error) return;
if (!className) className = el.className;
if (className !== el.className) error = new ParseError(ParseError.INVALID_CLASS_NAME, "All objects should be of the same class");
if (!el.id) error = new ParseError(ParseError.MISSING_OBJECT_ID, "All objects must have an ID");
if (forceFetch || !el.isDataAvailable()) {
ids.push(el.id);
objs.push(el);
}
results.push(el);
});
if (error) return Promise.reject(error);
const query = new (CoreManager.getParseQuery())(className);
query.containedIn("objectId", ids);
if (options && options.include) query.include(options.include);
query._limit = ids.length;
return query.find(options).then(async (objects) => {
const idMap = {};
objects.forEach((o) => {
idMap[o.id] = o;
});
for (let i = 0; i < objs.length; i++) {
const obj = objs[i];
if (!obj || !obj.id || !idMap[obj.id]) {
if (forceFetch) return Promise.reject(new ParseError(ParseError.OBJECT_NOT_FOUND, "All objects must exist on the server."));
}
}
if (!singleInstance) for (let i = 0; i < results.length; i++) {
const obj = results[i];
if (obj && obj.id && idMap[obj.id]) {
const id = obj.id;
obj._finishFetch(idMap[id].toJSON());
results[i] = idMap[id];
}
}
for (const object of results) await localDatastore._updateObjectIfPinned(object);
return Promise.resolve(results);
});
} else if (target instanceof ParseObject) {
if (!target.id) return Promise.reject(new ParseError(ParseError.MISSING_OBJECT_ID, "Object does not have an ID"));
const RESTController = CoreManager.getRESTController();
const params = {};
if (options && options.include) params.include = options.include.join();
return RESTController.request("GET", "classes/" + target.className + "/" + target._getId(), params, options).then(async (response) => {
target._clearPendingOps();
target._clearServerData();
target._finishFetch(response);
await localDatastore._updateObjectIfPinned(target);
return target;
});
}
return Promise.resolve(void 0);
},
async destroy(target, options) {
if (options && options.batchSize && options.transaction) throw new ParseError(ParseError.OTHER_CAUSE, "You cannot use both transaction and batchSize options simultaneously.");
let batchSize = options && options.batchSize ? options.batchSize : CoreManager.get("REQUEST_BATCH_SIZE");
const localDatastore = CoreManager.getLocalDatastore();
const RESTController = CoreManager.getRESTController();
if (Array.isArray(target)) {
if (options && options.transaction && target.length > 1) batchSize = target.length;
if (target.length < 1) return Promise.resolve([]);
const batches = [[]];
target.forEach((obj) => {
if (!obj.id) return;
batches[batches.length - 1].push(obj);
if (batches[batches.length - 1].length >= batchSize) batches.push([]);
});
if (batches[batches.length - 1].length === 0) batches.pop();
let deleteCompleted = Promise.resolve();
const errors = [];
batches.forEach((batch) => {
const requests = batch.map((obj) => {
return {
method: "DELETE",
path: getServerUrlPath() + "classes/" + obj.className + "/" + obj._getId(),
body: {}
};
});
const body = options && options.transaction && requests.length > 1 ? {
requests,
transaction: true
} : { requests };
deleteCompleted = deleteCompleted.then(() => {
return RESTController.request("POST", "batch", body, options).then((results) => {
for (let i = 0; i < results.length; i++) if (results[i] && Object.hasOwn(results[i], "error")) {
const err = new ParseError(results[i].error.code, results[i].error.error);
err.object = batch[i];
errors.push(err);
}
});
});
});
return deleteCompleted.then(async () => {
if (errors.length) {
const aggregate = new ParseError(ParseError.AGGREGATE_ERROR);
aggregate.errors = errors;
return Promise.reject(aggregate);
}
for (const object of target) await localDatastore._destroyObjectIfPinned(object);
return Promise.resolve(target);
});
} else if (target instanceof ParseObject) return RESTController.request("DELETE", "classes/" + target.className + "/" + target._getId(), {}, options).then(async () => {
await localDatastore._destroyObjectIfPinned(target);
return Promise.resolve(target);
});
return Promise.resolve(target);
},
save(target, options) {
if (options && options.batchSize && options.transaction) return Promise.reject(new ParseError(ParseError.OTHER_CAUSE, "You cannot use both transaction and batchSize options simultaneously."));
let batchSize = options && options.batchSize ? options.batchSize : CoreManager.get("REQUEST_BATCH_SIZE");
const localDatastore = CoreManager.getLocalDatastore();
const mapIdForPin = {};
const RESTController = CoreManager.getRESTController();
const stateController = CoreManager.getObjectStateController();
const allowCustomObjectId = CoreManager.get("ALLOW_CUSTOM_OBJECT_ID");
options = options || {};
options.returnStatus = options.returnStatus || true;
if (Array.isArray(target)) {
if (target.length < 1) return Promise.resolve([]);
let unsaved = target.concat();
for (let i = 0; i < target.length; i++) {
const target_i = target[i];
if (target_i instanceof ParseObject) unsaved = unsaved.concat(unsavedChildren(target_i, true));
}
unsaved = unique(unsaved);
const filesSaved = [];
let pending = [];
unsaved.forEach((el) => {
if (el instanceof ParseFile) filesSaved.push(el.save(options));
else if (el instanceof ParseObject) pending.push(el);
});
if (options && options.transaction && pending.length > 1) {
if (pending.some((el) => !canBeSerialized(el))) return Promise.reject(new ParseError(ParseError.OTHER_CAUSE, "Tried to save a transactional batch containing an object with unserializable attributes."));
batchSize = pending.length;
}
return Promise.all(filesSaved).then(() => {
let objectError = null;
return continueWhile(() => {
return pending.length > 0;
}, () => {
const batch = [];
const nextPending = [];
pending.forEach((el) => {
if (allowCustomObjectId && Object.hasOwn(el, "id") && !el.id) throw new ParseError(ParseError.MISSING_OBJECT_ID, "objectId must not be empty or null");
if (batch.length < batchSize && canBeSerialized(el)) batch.push(el);
else nextPending.push(el);
});
pending = nextPending;
if (batch.length < 1) return Promise.reject(new ParseError(ParseError.OTHER_CAUSE, "Tried to save a batch with a cycle."));
const batchReturned = resolvingPromise();
const batchReady = [];
const batchTasks = [];
batch.forEach((obj, index) => {
const ready = resolvingPromise();
batchReady.push(ready);
const task = function() {
ready.resolve();
return batchReturned.then((responses) => {
if (Object.hasOwn(responses[index], "success")) {
const objectId = responses[index].success.objectId;
const status = responses[index]._status;
delete responses[index]._status;
delete responses[index]._headers;
mapIdForPin[objectId] = obj._localId;
obj._handleSaveResponse(responses[index].success, status);
} else {
if (!objectError && Object.hasOwn(responses[index], "error")) {
const serverError = responses[index].error;
objectError = new ParseError(serverError.code, serverError.error);
pending = [];
}
obj._handleSaveError();
}
});
};
stateController.pushPendingState(obj._getStateIdentifier());
batchTasks.push(stateController.enqueueTask(obj._getStateIdentifier(), task));
});
when(batchReady).then(() => {
const requests = batch.map((obj) => {
const params = obj._getSaveParams();
params.path = getServerUrlPath() + params.path;
return params;
});
const body = options && options.transaction && requests.length > 1 ? {
requests,
transaction: true
} : { requests };
return RESTController.request("POST", "batch", body, options);
}).then(batchReturned.resolve, (error) => {
batchReturned.reject(new ParseError(ParseError.INCORRECT_TYPE, error.message));
});
return when(batchTasks);
}).then(async () => {
if (objectError) return Promise.reject(objectError);
for (const object of target) if (object instanceof ParseObject) {
await localDatastore._updateLocalIdForObject(mapIdForPin[object.id], object);
await localDatastore._updateObjectIfPinned(object);
}
return Promise.resolve(target);
});
});
} else if (target instanceof ParseObject) {
if (allowCustomObjectId && Object.hasOwn(target, "id") && !target.id) throw new ParseError(ParseError.MISSING_OBJECT_ID, "objectId must not be empty or null");
target._getId();
const localId = target._localId;
const targetCopy = target;
const task = function() {
const params = targetCopy._getSaveParams();
return RESTController.request(params.method, params.path, params.body, options).then((response) => {
const status = response._status;
delete response._status;
delete response._headers;
targetCopy._handleSaveResponse(response, status);
}, (error) => {
targetCopy._handleSaveError();
return Promise.reject(error);
});
};
stateController.pushPendingState(target._getStateIdentifier());
return stateController.enqueueTask(target._getStateIdentifier(), task).then(async () => {
await localDatastore._updateLocalIdForObject(localId, target);
await localDatastore._updateObjectIfPinned(target);
return target;
}, (error) => {
return Promise.reject(error);
});
}
return Promise.resolve(void 0);
}
};
CoreManager.setParseObject(ParseObject);
CoreManager.setObjectController(DefaultController$2);
//#endregion
//#region src/equals.ts
function equals(a, b) {
const toString = Object.prototype.toString;
if (toString.call(a) === "[object Date]" || toString.call(b) === "[object Date]") {
const dateA = new Date(a);
const dateB = new Date(b);
return +dateA === +dateB;
}
if (typeof a !== typeof b) return false;
if (!a || typeof a !== "object") return a === b;
if (Array.isArray(a) || Array.isArray(b)) {
if (!Array.isArray(a) || !Array.isArray(b)) return false;
if (a.length !== b.length) return false;
for (let i = 0; i < a.length; i += 1) if (!equals(a[i], b[i])) return false;
return true;
}
const ParseObject = CoreManager.getParseObject();
if (a instanceof ParseACL || a instanceof ParseFile || a instanceof ParseGeoPoint || a instanceof ParseObject) return a.equals(b);
if (b instanceof ParseObject) {
if (a.__type === "Object" || a.__type === "Pointer") return a.objectId === b.id && a.className === b.className;
}
if (Object.keys(a).length !== Object.keys(b).length) return false;
for (const k in a) if (!equals(a[k], b[k])) return false;
return true;
}
//#endregion
//#region src/OfflineQuery.ts
/**
* contains -- Determines if an object is contained in a list with special handling for Parse pointers.
*
* @param haystack
* @param needle
* @private
* @returns {boolean}
*/
function contains(haystack, needle) {
if (needle && needle.__type && (needle.__type === "Pointer" || needle.__type === "Object")) {
for (const i in haystack) {
const ptr = haystack[i];
if (typeof ptr === "string" && ptr === needle.objectId) return true;
if (ptr.className === needle.className && ptr.objectId === needle.objectId) return true;
}
return false;
}
if (Array.isArray(needle)) {
for (const need of needle) if (contains(haystack, need)) return true;
}
return haystack.indexOf(needle) > -1;
}
function transformObject(object) {
if (object._toFullJSON) return object._toFullJSON();
return object;
}
/**
* matchesQuery -- Determines if an object would be returned by a Parse Query
* It's a lightweight, where-clause only implementation of a full query engine.
* Since we find queries that match objects, rather than objects that match
* queries, we can avoid building a full-blown query tool.
*
* @param className
* @param object
* @param objects
* @param query
* @private
* @returns {boolean}
*/
function matchesQuery(className, object, objects, query) {
if (object.className !== className) return false;
let obj = object;
let q = query;
if (object.toJSON) obj = object.toJSON();
if (query.toJSON) q = query.toJSON().where;
obj.className = className;
for (const field in q) if (!matchesKeyConstraints(className, obj, objects, field, q[field])) return false;
return true;
}
function equalObjectsGeneric(obj, compareTo, eqlFn) {
if (Array.isArray(obj)) {
for (let i = 0; i < obj.length; i++) if (eqlFn(obj[i], compareTo)) return true;
return false;
}
return eqlFn(obj, compareTo);
}
/**
* @typedef RelativeTimeToDateResult
* @property {string} status The conversion status, `error` if conversion failed or
* `success` if conversion succeeded.
* @property {string} info The error message if conversion failed, or the relative
* time indication (`past`, `present`, `future`) if conversion succeeded.
* @property {Date|undefined} result The converted date, or `undefined` if conversion
* failed.
*/
/**
* Converts human readable relative date string, for example, 'in 10 days' to a date
* relative to now.
*
* @param {string} text The text to convert.
* @param {Date} [now] The date from which add or subtract. Default is now.
* @returns {RelativeTimeToDateResult}
*/
function relativeTimeToDate(text, now = /* @__PURE__ */ new Date()) {
text = text.toLowerCase();
let parts = text.split(" ");
parts = parts.filter((part) => part !== "");
const future = parts[0] === "in";
const past = parts[parts.length - 1] === "ago";
if (!future && !past && text !== "now") return {
status: "error",
info: "Time should either start with 'in' or end with 'ago'"
};
if (future && past) return {
status: "error",
info: "Time cannot have both 'in' and 'ago'"
};
if (future) parts = parts.slice(1);
else parts = parts.slice(0, parts.length - 1);
if (parts.length % 2 !== 0 && text !== "now") return {
status: "error",
info: "Invalid time string. Dangling unit or number."
};
const pairs = [];
while (parts.length) pairs.push([parts.shift(), parts.shift()]);
let seconds = 0;
for (const [num, interval] of pairs) {
const val = Number(num);
if (!Number.isInteger(val)) return {
status: "error",
info: `'${num}' is not an integer.`
};
switch (interval) {
case "yr":
case "yrs":
case "year":
case "years":
seconds += val * 31536e3;
break;
case "wk":
case "wks":
case "week":
case "weeks":
seconds += val * 604800;
break;
case "d":
case "day":
case "days":
seconds += val * 86400;
break;
case "hr":
case "hrs":
case "hour":
case "hours":
seconds += val * 3600;
break;
case "min":
case "mins":
case "minute":
case "minutes":
seconds += val * 60;
break;
case "sec":
case "secs":
case "second":
case "seconds":
seconds += val;
break;
default: return {
status: "error",
info: `Invalid interval: '${interval}'`
};
}
}
const milliseconds = seconds * 1e3;
if (future) return {
status: "success",
info: "future",
result: new Date(now.valueOf() + milliseconds)
};
else if (past) return {
status: "success",
info: "past",
result: new Date(now.valueOf() - milliseconds)
};
else return {
status: "success",
info: "present",
result: new Date(now.valueOf())
};
}
/**
* Determines whether an object matches a single key's constraints
*
* @param className
* @param object
* @param objects
* @param key
* @param constraints
* @private
* @returns {boolean}
*/
function matchesKeyConstraints(className, object, objects, key, constraints) {
if (constraints === null) return false;
if (key.indexOf(".") >= 0) {
const keyComponents = key.split(".");
const subObjectKey = keyComponents[0];
const keyRemainder = keyComponents.slice(1).join(".");
return matchesKeyConstraints(className, object[subObjectKey] || {}, objects, keyRemainder, constraints);
}
let i;
if (key === "$or") {
for (i = 0; i < constraints.length; i++) if (matchesQuery(className, object, objects, constraints[i])) return true;
return false;
}
if (key === "$and") {
for (i = 0; i < constraints.length; i++) if (!matchesQuery(className, object, objects, constraints[i])) return false;
return true;
}
if (key === "$nor") {
for (i = 0; i < constraints.length; i++) if (matchesQuery(className, object, objects, constraints[i])) return false;
return true;
}
if (key === "$relatedTo") return false;
if (!/^[A-Za-z][0-9A-Za-z_]*$/.test(key)) throw new ParseError(ParseError.INVALID_KEY_NAME, `Invalid Key: ${key}`);
if (typeof constraints !== "object") {
if (Array.isArray(object[key])) return object[key].indexOf(constraints) > -1;
return object[key] === constraints;
}
let compareTo;
if (constraints.__type) {
if (constraints.__type === "Pointer") return equalObjectsGeneric(object[key], constraints, function(obj, ptr) {
return typeof obj !== "undefined" && ptr.className === obj.className && ptr.objectId === obj.objectId;
});
return equalObjectsGeneric(decode(object[key]), decode(constraints), equals);
}
for (const condition in constraints) {
compareTo = constraints[condition];
if (compareTo?.__type) compareTo = decode(compareTo);
if (compareTo?.["$relativeTime"]) {
const parserResult = relativeTimeToDate(compareTo["$relativeTime"]);
if (parserResult.status !== "success") throw new ParseError(ParseError.INVALID_JSON, `bad $relativeTime (${key}) value. ${parserResult.info}`);
compareTo = parserResult.result;
}
if (toString.call(compareTo) === "[object Date]" || typeof compareTo === "string" && new Date(compareTo).toString() !== "Invalid Date") object[key] = new Date(object[key].iso ? object[key].iso : object[key]);
switch (condition) {
case "$lt":
if (object[key] >= compareTo) return false;
break;
case "$lte":
if (object[key] > compareTo) return false;
break;
case "$gt":
if (object[key] <= compareTo) return false;
break;
case "$gte":
if (object[key] < compareTo) return false;
break;
case "$ne":
if (equals(object[key], compareTo)) return false;
break;
case "$in":
if (!contains(compareTo, object[key])) return false;
break;
case "$nin":
if (contains(compareTo, object[key])) return false;
break;
case "$all":
for (i = 0; i < compareTo.length; i++) if (object[key].indexOf(compareTo[i]) < 0) return false;
break;
case "$exists": {
const propertyExists = typeof object[key] !== "undefined";
const existenceIsRequired = constraints["$exists"];
if (typeof constraints["$exists"] !== "boolean") break;
if (!propertyExists && existenceIsRequired || propertyExists && !existenceIsRequired) return false;
break;
}
case "$regex": {
if (typeof compareTo === "object") return compareTo.test(object[key]);
let expString = "";
let escapeEnd = -2;
let escapeStart = compareTo.indexOf("\\Q");
while (escapeStart > -1) {
expString += compareTo.substring(escapeEnd + 2, escapeStart);
escapeEnd = compareTo.indexOf("\\E", escapeStart);
if (escapeEnd > -1) expString += compareTo.substring(escapeStart + 2, escapeEnd).replace(/\\\\\\\\E/g, "\\E").replace(/\W/g, "\\$&");
escapeStart = compareTo.indexOf("\\Q", escapeEnd);
}
expString += compareTo.substring(Math.max(escapeStart, escapeEnd + 2));
let modifiers = constraints.$options || "";
modifiers = modifiers.replace("x", "").replace("s", "");
if (!new RegExp(expString, modifiers).test(object[key])) return false;
break;
}
case "$nearSphere":
if (!compareTo || !object[key]) return false;
return compareTo.radiansTo(object[key]) <= (constraints.$maxDistance || Infinity);
case "$within": {
if (!compareTo || !object[key]) return false;
const southWest = compareTo.$box[0];
const northEast = compareTo.$box[1];
if (southWest.latitude > northEast.latitude || southWest.longitude > northEast.longitude) return false;
return object[key].latitude > southWest.latitude && object[key].latitude < northEast.latitude && object[key].longitude > southWest.longitude && object[key].longitude < northEast.longitude;
}
case "$options": break;
case "$maxDistance": break;
case "$select": {
const subQueryObjects = objects.filter((obj, _index, arr) => {
return matchesQuery(compareTo.query.className, obj, arr, compareTo.query.where);
});
for (let i = 0; i < subQueryObjects.length; i += 1) {
const subObject = transformObject(subQueryObjects[i]);
return equals(object[key], subObject[compareTo.key]);
}
return false;
}
case "$dontSelect": {
const subQueryObjects = objects.filter((obj, _index, arr) => {
return matchesQuery(compareTo.query.className, obj, arr, compareTo.query.where);
});
for (let i = 0; i < subQueryObjects.length; i += 1) {
const subObject = transformObject(subQueryObjects[i]);
return !equals(object[key], subObject[compareTo.key]);
}
return false;
}
case "$inQuery": {
const subQueryObjects = objects.filter((obj, _index, arr) => {
return matchesQuery(compareTo.className, obj, arr, compareTo.where);
});
for (let i = 0; i < subQueryObjects.length; i += 1) {
const subObject = transformObject(subQueryObjects[i]);
if (object[key].className === subObject.className && object[key].objectId === subObject.objectId) return true;
}
return false;
}
case "$notInQuery": {
const subQueryObjects = objects.filter((obj, _index, arr) => {
return matchesQuery(compareTo.className, obj, arr, compareTo.where);
});
for (let i = 0; i < subQueryObjects.length; i += 1) {
const subObject = transformObject(subQueryObjects[i]);
if (object[key].className === subObject.className && object[key].objectId === subObject.objectId) return false;
}
return true;
}
case "$containedBy":
for (const value of object[key]) if (!contains(compareTo, value)) return false;
return true;
case "$geoWithin":
if (compareTo.$polygon) return new ParsePolygon(compareTo.$polygon.map((geoPoint) => [geoPoint.latitude, geoPoint.longitude])).containsPoint(object[key]);
if (compareTo.$centerSphere) {
const [WGS84Point, maxDistance] = compareTo.$centerSphere;
const centerPoint = new ParseGeoPoint({
latitude: WGS84Point[1],
longitude: WGS84Point[0]
});
return new ParseGeoPoint(object[key]).radiansTo(centerPoint) <= maxDistance;
}
return false;
case "$geoIntersects": {
const polygon = new ParsePolygon(object[key].coordinates);
const point = new ParseGeoPoint(compareTo.$point);
return polygon.containsPoint(point);
}
default: return false;
}
}
return true;
}
function validateQuery(query) {
let q = query;
if (query.toJSON) q = query.toJSON().where;
const specialQuerykeys = [
"$and",
"$or",
"$nor",
"_rperm",
"_wperm",
"_perishable_token",
"_email_verify_token",
"_email_verify_token_expires_at",
"_account_lockout_expires_at",
"_failed_login_count"
];
Object.keys(q).forEach((key) => {
if (q && q[key] && q[key].$regex) {
if (typeof q[key].$options === "string") {
if (!q[key].$options.match(/^[imxs]+$/)) throw new ParseError(ParseError.INVALID_QUERY, `Bad $options value for query: ${q[key].$options}`);
}
}
if (specialQuerykeys.indexOf(key) < 0 && !key.match(/^[a-zA-Z][a-zA-Z0-9_\.]*$/)) throw new ParseError(ParseError.INVALID_KEY_NAME, `Invalid key name: ${key}`);
});
}
var OfflineQuery = {
matchesQuery,
validateQuery
};
//#endregion
//#region src/ParseQuery.ts
/**
* Converts a string into a regex that matches it.
* Surrounding with \Q .. \E does this, we just need to escape any \E's in
* the text separately.
*
* @param s
* @private
* @returns {string}
*/
function quote(s) {
return "\\Q" + s.replace("\\E", "\\E\\\\E\\Q") + "\\E";
}
/**
* Extracts the class name from queries. If not all queries have the same
* class name an error will be thrown.
*
* @param queries
* @private
* @returns {string}
*/
function _getClassNameFromQueries(queries) {
let className = null;
queries.forEach((q) => {
if (!className) className = q.className;
if (className !== q.className) throw new Error("All queries must be for the same class.");
});
return className;
}
function handleSelectResult(data, select) {
const serverDataMask = {};
select.forEach((field) => {
const hasSubObjectSelect = field.indexOf(".") !== -1;
if (!hasSubObjectSelect && !Object.hasOwn(data, field)) data[field] = void 0;
else if (hasSubObjectSelect) {
const pathComponents = field.split(".");
let obj = data;
let serverMask = serverDataMask;
pathComponents.forEach((component, index, arr) => {
if (obj && !Object.hasOwn(obj, component)) obj[component] = void 0;
if (obj && typeof obj === "object") obj = obj[component];
if (index < arr.length - 1) {
if (!serverMask[component]) serverMask[component] = {};
serverMask = serverMask[component];
}
});
}
});
if (Object.keys(serverDataMask).length > 0) copyMissingDataWithMask(CoreManager.getObjectStateController().getServerData({
id: data.objectId,
className: data.className
}), data, serverDataMask, false);
}
function copyMissingDataWithMask(src, dest, mask, copyThisLevel) {
if (copyThisLevel) {
for (const key in src) if (Object.hasOwn(src, key) && !Object.hasOwn(dest, key)) dest[key] = src[key];
}
for (const key in mask) if (dest[key] !== void 0 && dest[key] !== null && src !== void 0 && src !== null) copyMissingDataWithMask(src[key], dest[key], mask[key], true);
}
function handleOfflineSort(a, b, sorts) {
let order = sorts[0];
const isDescending = order.slice(0, 1) === "-";
if (isDescending) order = order.substring(1);
if (order === "_created_at") order = "createdAt";
if (order === "_updated_at") order = "updatedAt";
if (!/^[A-Za-z][0-9A-Za-z_]*$/.test(order) || order === "password") throw new ParseError(ParseError.INVALID_KEY_NAME, `Invalid Key: ${order}`);
const field1 = a.get(order);
const field2 = b.get(order);
if (field1 < field2) return isDescending ? 1 : -1;
if (field1 > field2) return isDescending ? -1 : 1;
if (sorts.length > 1) return handleOfflineSort(a, b, sorts.slice(1));
return 0;
}
/**
* Creates a new parse Parse.Query for the given Parse.Object subclass.
*
* <p>Parse.Query defines a query that is used to fetch Parse.Objects. The
* most common use case is finding all objects that match a query through the
* <code>find</code> method. for example, this sample code fetches all objects
* of class <code>myclass</code>. it calls a different function depending on
* whether the fetch succeeded or not.
*
* <pre>
* var query = new Parse.Query(myclass);
* query.find().then((results) => {
* // results is an array of parse.object.
* }).catch((error) => {
* // error is an instance of parse.error.
* });</pre></p>
*
* <p>a Parse.Query can also be used to retrieve a single object whose id is
* known, through the get method. for example, this sample code fetches an
* object of class <code>myclass</code> and id <code>myid</code>. it calls a
* different function depending on whether the fetch succeeded or not.
*
* <pre>
* var query = new Parse.Query(myclass);
* query.get(myid).then((object) => {
* // object is an instance of parse.object.
* }).catch((error) => {
* // error is an instance of parse.error.
* });</pre></p>
*
* <p>a Parse.Query can also be used to count the number of objects that match
* the query without retrieving all of those objects. for example, this
* sample code counts the number of objects of the class <code>myclass</code>
* <pre>
* var query = new Parse.Query(myclass);
* query.count().then((number) => {
* // there are number instances of myclass.
* }).catch((error) => {
* // error is an instance of Parse.Error.
* });</pre></p>
*
* @alias Parse.Query
*/
var ParseQuery = class ParseQuery {
/**
* @param {(string | Parse.Object)} objectClass An instance of a subclass of Parse.Object, or a Parse className string.
*/
constructor(objectClass) {
if (typeof objectClass === "string") if (objectClass === "User" && CoreManager.get("PERFORM_USER_REWRITE")) this.className = "_User";
else this.className = objectClass;
else if (objectClass instanceof ParseObject) this.className = objectClass.className;
else if (typeof objectClass === "function") {
const objClass = objectClass;
if (typeof objClass.className === "string") this.className = objClass.className;
else {
const obj = new objClass();
this.className = obj.className;
}
} else throw new TypeError("A ParseQuery must be constructed with a ParseObject or class name.");
this._where = {};
this._watch = [];
this._include = [];
this._exclude = [];
this._count = false;
this._limit = -1;
this._skip = 0;
this._readPreference = null;
this._includeReadPreference = null;
this._subqueryReadPreference = null;
this._queriesLocalDatastore = false;
this._localDatastorePinName = null;
this._extraOptions = {};
this._xhrRequest = {
task: null,
onchange: () => {}
};
this._comment = null;
}
/**
* Adds constraint that at least one of the passed in queries matches.
*
* @param {Array} queries
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
_orQuery(queries) {
const queryJSON = queries.map((q) => {
return q.toJSON().where;
});
this._where.$or = queryJSON;
return this;
}
/**
* Adds constraint that all of the passed in queries match.
*
* @param {Array} queries
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
_andQuery(queries) {
const queryJSON = queries.map((q) => {
return q.toJSON().where;
});
this._where.$and = queryJSON;
return this;
}
/**
* Adds constraint that none of the passed in queries match.
*
* @param {Array} queries
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
_norQuery(queries) {
const queryJSON = queries.map((q) => {
return q.toJSON().where;
});
this._where.$nor = queryJSON;
return this;
}
/**
* Helper for condition queries
*
* @param key
* @param condition
* @param value
* @returns {Parse.Query}
*/
_addCondition(key, condition, value) {
if (!this._where[key] || typeof this._where[key] === "string") this._where[key] = {};
this._where[key][condition] = encode_default(value, false, true);
return this;
}
/**
* Converts string for regular expression at the beginning
*
* @param string
* @returns {string}
*/
_regexStartWith(string) {
return "^" + quote(string);
}
async _handleOfflineQuery(params) {
OfflineQuery.validateQuery(this);
let results = (await CoreManager.getLocalDatastore()._serializeObjectsFromPinName(this._localDatastorePinName)).map((json, _index, arr) => {
const object = ParseObject.fromJSON(json, false);
if (json._localId && !json.objectId) object._localId = json._localId;
if (!OfflineQuery.matchesQuery(this.className, object, arr, this)) return null;
return object;
}).filter((object) => object !== null);
if (params.keys) {
let keys = params.keys.split(",");
keys = keys.concat([
"className",
"objectId",
"createdAt",
"updatedAt",
"ACL"
]);
results = results.map((object) => {
const json = object._toFullJSON();
Object.keys(json).forEach((key) => {
if (!keys.includes(key)) delete json[key];
});
return ParseObject.fromJSON(json, false);
});
}
if (params.order) {
const sorts = params.order.split(",");
results.sort((a, b) => {
return handleOfflineSort(a, b, sorts);
});
}
let count;
if (params.count) count = results.length;
if (params.skip) if (params.skip >= results.length) results = [];
else results = results.splice(params.skip, results.length);
let limit = results.length;
if (params.limit !== 0 && params.limit < results.length) limit = params.limit;
results = results.splice(0, limit);
if (typeof count === "number") return {
results,
count
};
return results;
}
/**
* Returns a JSON representation of this query.
*
* @returns {object} The JSON representation of the query.
*/
toJSON() {
const params = { where: this._where };
if (this._watch.length) params.watch = this._watch.join(",");
if (this._include.length) params.include = this._include.join(",");
if (this._exclude.length) params.excludeKeys = this._exclude.join(",");
if (this._select) params.keys = this._select.join(",");
if (this._count) params.count = 1;
if (this._limit >= 0) params.limit = this._limit;
if (this._skip > 0) params.skip = this._skip;
if (this._order) params.order = this._order.join(",");
if (this._readPreference) params.readPreference = this._readPreference;
if (this._includeReadPreference) params.includeReadPreference = this._includeReadPreference;
if (this._subqueryReadPreference) params.subqueryReadPreference = this._subqueryReadPreference;
if (this._hint) params.hint = this._hint;
if (this._explain) params.explain = true;
if (this._comment) params.comment = this._comment;
for (const key in this._extraOptions) params[key] = this._extraOptions[key];
return params;
}
/**
* Return a query with conditions from json, can be useful to send query from server side to client
* Not static, all query conditions was set before calling this method will be deleted.
* For example on the server side we have
* var query = new Parse.Query("className");
* query.equalTo(key: value);
* query.limit(100);
* ... (others queries)
* Create JSON representation of Query Object
* var jsonFromServer = query.fromJSON();
*
* On client side getting query:
* var query = new Parse.Query("className");
* query.fromJSON(jsonFromServer);
*
* and continue to query...
* query.skip(100).find().then(...);
*
* @param {QueryJSON} json from Parse.Query.toJSON() method
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
withJSON(json) {
if (json.where) this._where = json.where;
if (json.watch) this._watch = json.watch.split(",");
if (json.include) this._include = json.include.split(",");
if (json.keys) this._select = json.keys.split(",");
if (json.excludeKeys) this._exclude = json.excludeKeys.split(",");
if (json.count) this._count = json.count === 1;
if (json.limit) this._limit = json.limit;
if (json.skip) this._skip = json.skip;
if (json.order) this._order = json.order.split(",");
if (json.readPreference) this._readPreference = json.readPreference;
if (json.includeReadPreference) this._includeReadPreference = json.includeReadPreference;
if (json.subqueryReadPreference) this._subqueryReadPreference = json.subqueryReadPreference;
if (json.hint) this._hint = json.hint;
if (json.explain) this._explain = !!json.explain;
if (json.comment) this._comment = json.comment;
for (const key in json) if (Object.hasOwn(json, key)) {
if ([
"where",
"include",
"keys",
"count",
"limit",
"skip",
"order",
"readPreference",
"includeReadPreference",
"subqueryReadPreference",
"hint",
"explain",
"comment"
].indexOf(key) === -1) this._extraOptions[key] = json[key];
}
return this;
}
/**
* Static method to restore Parse.Query by json representation
* Internally calling Parse.Query.withJSON
*
* @param {string} className
* @param {QueryJSON} json from Parse.Query.toJSON() method
* @returns {Parse.Query} new created query
*/
static fromJSON(className, json) {
return new ParseQuery(className).withJSON(json);
}
/**
* Constructs a Parse.Object whose id is already known by fetching data from
* the server. Unlike the <code>first</code> method, it never returns undefined.
*
* @param {string} objectId The id of the object to be fetched.
* @param {object} options
* Valid options are:<ul>
* <li>useMasterKey: In Cloud Code and Node only, causes the Master Key to
* be used for this request.
* <li>sessionToken: A valid session token, used for making a request on
* behalf of a specific user.
* <li>context: A dictionary that is accessible in Cloud Code `beforeFind` trigger.
* <li>json: Return raw json without converting to Parse.Object
* </ul>
* @returns {Promise} A promise that is resolved with the result when
* the query completes.
*/
get(objectId, options) {
this.equalTo("objectId", objectId);
const firstOptions = ParseObject._getRequestOptions(options);
return this.first(firstOptions).then((response) => {
if (response) return response;
const errorObject = new ParseError(ParseError.OBJECT_NOT_FOUND, "Object not found.");
return Promise.reject(errorObject);
});
}
/**
* Retrieves a list of ParseObjects that satisfy this query.
*
* @param {object} options Valid options
* are:<ul>
* <li>useMasterKey: In Cloud Code and Node only, causes the Master Key to
* be used for this request.
* <li>sessionToken: A valid session token, used for making a request on
* behalf of a specific user.
* <li>context: A dictionary that is accessible in Cloud Code `beforeFind` trigger.
* <li>json: Return raw json without converting to Parse.Object
* </ul>
* @returns {Promise} A promise that is resolved with the results when
* the query completes.
*/
find(options) {
const findOptions = ParseObject._getRequestOptions(options);
this._setRequestTask(findOptions);
const controller = CoreManager.getQueryController();
const select = this._select;
if (this._queriesLocalDatastore) return this._handleOfflineQuery(this.toJSON());
return controller.find(this.className, this.toJSON(), findOptions).then((response) => {
if (this._explain) return response.results;
const results = response.results?.map((data) => {
const override = response.className || this.className;
if (!data.className) data.className = override;
if (select) handleSelectResult(data, select);
if (findOptions.json) return data;
else return ParseObject.fromJSON(data, !select);
});
const count = response.count;
if (typeof count === "number") return {
results,
count
};
else return results;
});
}
/**
* Retrieves a complete list of ParseObjects that satisfy this query.
* Using `eachBatch` under the hood to fetch all the valid objects.
*
* @param {object} options Valid options are:<ul>
* <li>batchSize: How many objects to yield in each batch (default: 100)
* <li>useMasterKey: In Cloud Code and Node only, causes the Master Key to
* be used for this request.
* <li>sessionToken: A valid session token, used for making a request on
* behalf of a specific user.
* <li>json: Return raw JSON without converting to Parse.Object.
* </ul>
* @returns {Promise} A promise that is resolved with the results when
* the query completes.
*/
async findAll(options) {
let result = [];
await this.eachBatch((objects) => {
result = [...result, ...objects];
}, options);
return result;
}
/**
* Counts the number of objects that match this query.
*
* @param {object} options
* @param {boolean} [options.useMasterKey]
* @param {string} [options.sessionToken]
* Valid options are:<ul>
* <li>useMasterKey: In Cloud Code and Node only, causes the Master Key to
* be used for this request.
* <li>sessionToken: A valid session token, used for making a request on
* behalf of a specific user.
* </ul>
* @returns {Promise} A promise that is resolved with the count when
* the query completes.
*/
count(options) {
options = options || {};
const findOptions = ParseObject._getRequestOptions(options);
this._setRequestTask(findOptions);
const controller = CoreManager.getQueryController();
const params = this.toJSON();
params.limit = 0;
params.count = 1;
return controller.find(this.className, params, findOptions).then((result) => {
return result.count;
});
}
/**
* Executes a distinct query and returns unique values
*
* @param {string} key A field to find distinct values
* @returns {Promise} A promise that is resolved with the query completes.
*/
distinct(key) {
const distinctOptions = { useMasterKey: true };
this._setRequestTask(distinctOptions);
const params = {
distinct: key,
where: this._where,
hint: this._hint
};
return CoreManager.getQueryController().aggregate(this.className, params, distinctOptions).then((results) => {
return results.results;
});
}
/**
* Executes an aggregate query and returns aggregate results
*
* @param {(Array|object)} pipeline Array or Object of stages to process query
* @param {object} options Valid options are:<ul>
* <li>useMasterKey: In Cloud Code and Node only, causes the Master Key to
* be used for this request. Defaults to `true` when not provided, for
* backward compatibility.
* <li>sessionToken: A valid session token, used for making a request on
* behalf of a specific user.
* <li>context: A dictionary that is accessible in Cloud Code triggers.
* <li>rawValues: When `true`, disables schema-based value transformation
* in the pipeline. Pipeline values are interpreted using MongoDB
* Extended JSON (EJSON), so typed values such as `{ $date: '...' }`,
* `{ $oid: '...' }`, `{ $numberDecimal: '...' }`, etc. are converted
* to their corresponding BSON types by the server. Requires Parse
* Server 9.9.0+
* <li>rawFieldNames: When `true`, disables automatic field-name
* transformation (e.g. `createdAt` → `_created_at`) in the pipeline.
* Users write native MongoDB field names directly. Requires Parse
* Server 9.9.0+
* </ul>
* @returns {Promise} A promise that is resolved with the query completes.
*/
aggregate(pipeline, options) {
if (!Array.isArray(pipeline) && typeof pipeline !== "object") throw new Error("Invalid pipeline must be Array or Object");
if (Object.keys(this._where || {}).length) {
if (!Array.isArray(pipeline)) pipeline = [pipeline];
pipeline.unshift({ $match: this._where });
}
const params = {
pipeline,
hint: this._hint,
explain: this._explain,
readPreference: this._readPreference
};
if (options?.rawValues !== void 0) params.rawValues = options.rawValues;
if (options?.rawFieldNames !== void 0) params.rawFieldNames = options.rawFieldNames;
const aggregateOptions = ParseObject._getRequestOptions(options);
if (aggregateOptions.useMasterKey === void 0) aggregateOptions.useMasterKey = true;
this._setRequestTask(aggregateOptions);
return CoreManager.getQueryController().aggregate(this.className, params, aggregateOptions).then((results) => {
return results.results;
});
}
/**
* Retrieves at most one Parse.Object that satisfies this query.
*
* Returns the object if there is one, otherwise undefined.
*
* @param {object} options Valid options are:<ul>
* <li>useMasterKey: In Cloud Code and Node only, causes the Master Key to
* be used for this request.
* <li>sessionToken: A valid session token, used for making a request on
* behalf of a specific user.
* <li>context: A dictionary that is accessible in Cloud Code `beforeFind` trigger.
* <li>json: Return raw json without converting to Parse.Object
* </ul>
* @returns {Promise} A promise that is resolved with the object when
* the query completes.
*/
first(options = {}) {
const findOptions = ParseObject._getRequestOptions(options);
this._setRequestTask(findOptions);
const controller = CoreManager.getQueryController();
const params = this.toJSON();
params.limit = 1;
const select = this._select;
if (this._queriesLocalDatastore) return this._handleOfflineQuery(params).then((objects) => {
if (!objects[0]) return;
return objects[0];
});
return controller.find(this.className, params, findOptions).then((response) => {
const objects = response.results;
if (!objects[0]) return;
if (!objects[0].className) objects[0].className = this.className;
if (select) handleSelectResult(objects[0], select);
if (findOptions.json) return objects[0];
else return ParseObject.fromJSON(objects[0], !select);
});
}
/**
* Iterates over objects matching a query, calling a callback for each batch.
* If the callback returns a promise, the iteration will not continue until
* that promise has been fulfilled. If the callback returns a rejected
* promise, then iteration will stop with that error. The items are processed
* in an unspecified order. The query may not have any sort order, and may
* not use limit or skip.
*
* @param {Function} callback Callback that will be called with each result
* of the query.
* @param {object} options Valid options are:<ul>
* <li>batchSize: How many objects to yield in each batch (default: 100)
* <li>useMasterKey: In Cloud Code and Node only, causes the Master Key to
* be used for this request.
* <li>sessionToken: A valid session token, used for making a request on
* behalf of a specific user.
* <li>context: A dictionary that is accessible in Cloud Code `beforeFind` trigger.
* </ul>
* @returns {Promise} A promise that will be fulfilled once the
* iteration has completed.
*/
eachBatch(callback, options) {
options = options || {};
if (this._order || this._skip || this._limit >= 0) return Promise.reject("Cannot iterate on a query with sort, skip, or limit.");
const query = ParseQuery.fromJSON(this.className, this.toJSON());
query.ascending("objectId");
query._limit = options.batchSize || 100;
const findOptions = ParseObject._getRequestOptions(options);
let finished = false;
let previousResults = [];
return continueWhile(() => {
return !finished;
}, async () => {
const [results] = await Promise.all([query.find(findOptions), Promise.resolve(previousResults.length > 0 && callback(previousResults))]);
if (results.length >= query._limit) {
if (findOptions.json) query.greaterThan("objectId", results[results.length - 1].objectId);
else query.greaterThan("objectId", results[results.length - 1].id);
previousResults = results;
} else if (results.length > 0) {
await Promise.resolve(callback(results));
finished = true;
} else finished = true;
});
}
/**
* Iterates over each result of a query, calling a callback for each one. If
* the callback returns a promise, the iteration will not continue until
* that promise has been fulfilled. If the callback returns a rejected
* promise, then iteration will stop with that error. The items are
* processed in an unspecified order. The query may not have any sort order,
* and may not use limit or skip.
*
* @param {Function} callback Callback that will be called with each result
* of the query.
* @param {object} options Valid options are:<ul>
* <li>useMasterKey: In Cloud Code and Node only, causes the Master Key to
* be used for this request.
* <li>sessionToken: A valid session token, used for making a request on
* behalf of a specific user.
* <li>json: Return raw json without converting to Parse.Object
* </ul>
* @returns {Promise} A promise that will be fulfilled once the
* iteration has completed.
*/
each(callback, options) {
return this.eachBatch((results) => {
let callbacksDone = Promise.resolve();
results.forEach((result) => {
callbacksDone = callbacksDone.then(() => {
return callback(result);
});
});
return callbacksDone;
}, options);
}
/**
* Adds a hint to force index selection. (https://docs.mongodb.com/manual/reference/operator/meta/hint/)
*
* @param {(string|object)} value String or Object of index that should be used when executing query
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
hint(value) {
if (typeof value === "undefined") delete this._hint;
this._hint = value;
return this;
}
/**
* Investigates the query execution plan. Useful for optimizing queries. (https://docs.mongodb.com/manual/reference/operator/meta/explain/)
*
* @param {boolean} explain Used to toggle the information on the query plan.
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
explain(explain = true) {
if (typeof explain !== "boolean") throw new Error("You can only set explain to a boolean value");
this._explain = explain;
return this;
}
/**
* Iterates over each result of a query, calling a callback for each one. If
* the callback returns a promise, the iteration will not continue until
* that promise has been fulfilled. If the callback returns a rejected
* promise, then iteration will stop with that error. The items are
* processed in an unspecified order. The query may not have any sort order,
* and may not use limit or skip.
*
* @param {Function} callback Callback <ul>
* <li>currentObject: The current Parse.Object being processed in the array.</li>
* <li>index: The index of the current Parse.Object being processed in the array.</li>
* <li>query: The query map was called upon.</li>
* </ul>
* @param {object} options Valid options are:<ul>
* <li>useMasterKey: In Cloud Code and Node only, causes the Master Key to
* be used for this request.
* <li>sessionToken: A valid session token, used for making a request on
* behalf of a specific user.
* </ul>
* @returns {Promise} A promise that will be fulfilled once the
* iteration has completed.
*/
async map(callback, options) {
const array = [];
let index = 0;
await this.each((object) => {
return Promise.resolve(callback(object, index, this)).then((result) => {
array.push(result);
index += 1;
});
}, options);
return array;
}
/**
* Iterates over each result of a query, calling a callback for each one. If
* the callback returns a promise, the iteration will not continue until
* that promise has been fulfilled. If the callback returns a rejected
* promise, then iteration will stop with that error. The items are
* processed in an unspecified order. The query may not have any sort order,
* and may not use limit or skip.
*
* @param {Function} callback Callback <ul>
* <li>accumulator: The accumulator accumulates the callback's return values. It is the accumulated value previously returned in the last invocation of the callback.</li>
* <li>currentObject: The current Parse.Object being processed in the array.</li>
* <li>index: The index of the current Parse.Object being processed in the array.</li>
* </ul>
* @param {*} initialValue A value to use as the first argument to the first call of the callback. If no initialValue is supplied, the first object in the query will be used and skipped.
* @param {object} options Valid options are:<ul>
* <li>useMasterKey: In Cloud Code and Node only, causes the Master Key to
* be used for this request.
* <li>sessionToken: A valid session token, used for making a request on
* behalf of a specific user.
* </ul>
* @returns {Promise} A promise that will be fulfilled once the
* iteration has completed.
*/
async reduce(callback, initialValue, options) {
let accumulator = initialValue;
let index = 0;
await this.each((object) => {
if (index === 0 && initialValue === void 0) {
accumulator = object;
index += 1;
return;
}
return Promise.resolve(callback(accumulator, object, index)).then((result) => {
accumulator = result;
index += 1;
});
}, options);
if (index === 0 && initialValue === void 0) throw new TypeError("Reducing empty query result set with no initial value");
return accumulator;
}
/**
* Iterates over each result of a query, calling a callback for each one. If
* the callback returns a promise, the iteration will not continue until
* that promise has been fulfilled. If the callback returns a rejected
* promise, then iteration will stop with that error. The items are
* processed in an unspecified order. The query may not have any sort order,
* and may not use limit or skip.
*
* @param {Function} callback Callback <ul>
* <li>currentObject: The current Parse.Object being processed in the array.</li>
* <li>index: The index of the current Parse.Object being processed in the array.</li>
* <li>query: The query filter was called upon.</li>
* </ul>
* @param {object} options Valid options are:<ul>
* <li>useMasterKey: In Cloud Code and Node only, causes the Master Key to
* be used for this request.
* <li>sessionToken: A valid session token, used for making a request on
* behalf of a specific user.
* </ul>
* @returns {Promise} A promise that will be fulfilled once the
* iteration has completed.
*/
async filter(callback, options) {
const array = [];
let index = 0;
await this.each((object) => {
return Promise.resolve(callback(object, index, this)).then((flag) => {
if (flag) array.push(object);
index += 1;
});
}, options);
return array;
}
/**
* Adds a constraint to the query that requires a particular key's value to
* be equal to the provided value.
*
* @param {string} key The key to check.
* @param value The value that the Parse.Object must contain.
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
equalTo(key, value) {
if (key && typeof key === "object") {
Object.entries(key).forEach(([k, val]) => this.equalTo(k, val));
return this;
}
if (typeof value === "undefined") return this.doesNotExist(key);
this._where[key] = encode_default(value, false, true);
return this;
}
/**
* Adds a constraint to the query that requires a particular key's value to
* be not equal to the provided value.
*
* @param {string} key The key to check.
* @param value The value that must not be equalled.
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
notEqualTo(key, value) {
if (key && typeof key === "object") {
Object.entries(key).forEach(([k, val]) => this.notEqualTo(k, val));
return this;
}
return this._addCondition(key, "$ne", value);
}
/**
* Adds a constraint to the query that requires a particular key's value to
* be less than the provided value.
*
* @param {string} key The key to check.
* @param value The value that provides an upper bound.
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
lessThan(key, value) {
return this._addCondition(key, "$lt", value);
}
/**
* Adds a constraint to the query that requires a particular key's value to
* be greater than the provided value.
*
* @param {string} key The key to check.
* @param value The value that provides an lower bound.
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
greaterThan(key, value) {
return this._addCondition(key, "$gt", value);
}
/**
* Adds a constraint to the query that requires a particular key's value to
* be less than or equal to the provided value.
*
* @param {string} key The key to check.
* @param value The value that provides an upper bound.
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
lessThanOrEqualTo(key, value) {
return this._addCondition(key, "$lte", value);
}
/**
* Adds a constraint to the query that requires a particular key's value to
* be greater than or equal to the provided value.
*
* @param {string} key The key to check.
* @param {*} value The value that provides an lower bound.
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
greaterThanOrEqualTo(key, value) {
return this._addCondition(key, "$gte", value);
}
/**
* Adds a constraint to the query that requires a particular key's value to
* be contained in the provided list of values.
*
* @param {string} key The key to check.
* @param {Array<*>} values The values that will match.
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
containedIn(key, values) {
return this._addCondition(key, "$in", values);
}
/**
* Adds a constraint to the query that requires a particular key's value to
* not be contained in the provided list of values.
*
* @param {string} key The key to check.
* @param {Array<*>} values The values that will not match.
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
notContainedIn(key, values) {
return this._addCondition(key, "$nin", values);
}
/**
* Adds a constraint to the query that requires a particular key's value to
* be contained by the provided list of values. Get objects where all array elements match.
*
* @param {string} key The key to check.
* @param {Array} values The values that will match.
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
containedBy(key, values) {
return this._addCondition(key, "$containedBy", values);
}
/**
* Adds a constraint to the query that requires a particular key's value to
* contain each one of the provided list of values.
*
* @param {string} key The key to check. This key's value must be an array.
* @param {Array} values The values that will match.
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
containsAll(key, values) {
return this._addCondition(key, "$all", values);
}
/**
* Adds a constraint to the query that requires a particular key's value to
* contain each one of the provided list of values starting with given strings.
*
* @param {string} key The key to check. This key's value must be an array.
* @param {Array<string>} values The string values that will match as starting string.
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
containsAllStartingWith(key, values) {
if (!Array.isArray(values)) values = [values];
const regexObject = values.map((value) => {
return { $regex: this._regexStartWith(value) };
});
return this.containsAll(key, regexObject);
}
/**
* Adds a constraint for finding objects that contain the given key.
*
* @param {string} key The key that should exist.
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
exists(key) {
return this._addCondition(key, "$exists", true);
}
/**
* Adds a constraint for finding objects that do not contain a given key.
*
* @param {string} key The key that should not exist
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
doesNotExist(key) {
return this._addCondition(key, "$exists", false);
}
/**
* Adds a regular expression constraint for finding string values that match
* the provided regular expression.
* This may be slow for large datasets.
*
* @param {string} key The key that the string to match is stored in.
* @param {RegExp | string} regex The regular expression pattern to match.
* @param {string} modifiers The regular expression mode.
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
matches(key, regex, modifiers) {
this._addCondition(key, "$regex", regex);
if (!modifiers) modifiers = "";
if (typeof regex !== "string") {
if (regex.ignoreCase) modifiers += "i";
if (regex.multiline) modifiers += "m";
}
if (modifiers.length) this._addCondition(key, "$options", modifiers);
return this;
}
/**
* Adds a constraint that requires that a key's value matches a Parse.Query
* constraint.
*
* @param {string} key The key that the contains the object to match the
* query.
* @param {Parse.Query} query The query that should match.
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
matchesQuery(key, query) {
const queryJSON = query.toJSON();
queryJSON.className = query.className;
return this._addCondition(key, "$inQuery", queryJSON);
}
/**
* Adds a constraint that requires that a key's value not matches a
* Parse.Query constraint.
*
* @param {string} key The key that the contains the object to match the
* query.
* @param {Parse.Query} query The query that should not match.
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
doesNotMatchQuery(key, query) {
const queryJSON = query.toJSON();
queryJSON.className = query.className;
return this._addCondition(key, "$notInQuery", queryJSON);
}
/**
* Adds a constraint that requires that a key's value matches a value in
* an object returned by a different Parse.Query.
*
* @param {string} key The key that contains the value that is being
* matched.
* @param {string} queryKey The key in the objects returned by the query to
* match against.
* @param {Parse.Query} query The query to run.
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
matchesKeyInQuery(key, queryKey, query) {
const queryJSON = query.toJSON();
queryJSON.className = query.className;
return this._addCondition(key, "$select", {
key: queryKey,
query: queryJSON
});
}
/**
* Adds a constraint that requires that a key's value not match a value in
* an object returned by a different Parse.Query.
*
* @param {string} key The key that contains the value that is being
* excluded.
* @param {string} queryKey The key in the objects returned by the query to
* match against.
* @param {Parse.Query} query The query to run.
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
doesNotMatchKeyInQuery(key, queryKey, query) {
const queryJSON = query.toJSON();
queryJSON.className = query.className;
return this._addCondition(key, "$dontSelect", {
key: queryKey,
query: queryJSON
});
}
/**
* Adds a constraint for finding string values that contain a provided
* string. This may be slow for large datasets.
*
* @param {string} key The key that the string to match is stored in.
* @param {string} substring The substring that the value must contain.
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
contains(key, substring) {
if (typeof substring !== "string") throw new Error("The value being searched for must be a string.");
return this._addCondition(key, "$regex", quote(substring));
}
/**
* Adds a constraint for finding string values that contain a provided
* string. This may be slow for large datasets. Requires Parse-Server > 2.5.0
*
* In order to sort you must use select and ascending ($score is required)
* <pre>
* query.fullText('field', 'term');
* query.ascending('$score');
* query.select('$score');
* </pre>
*
* To retrieve the weight / rank
* <pre>
* object->get('score');
* </pre>
*
* You can define optionals by providing an object as a third parameter
* <pre>
* query.fullText('field', 'term', { language: 'es', diacriticSensitive: true });
* </pre>
*
* @param {string} key The key that the string to match is stored in.
* @param {string} value The string to search
* @param {object} options (Optional)
* @param {string} options.language The language that determines the list of stop words for the search and the rules for the stemmer and tokenizer.
* @param {boolean} options.caseSensitive A boolean flag to enable or disable case sensitive search.
* @param {boolean} options.diacriticSensitive A boolean flag to enable or disable diacritic sensitive search.
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
fullText(key, value, options) {
options = options || {};
if (!key) throw new Error("A key is required.");
if (!value) throw new Error("A search term is required");
if (typeof value !== "string") throw new Error("The value being searched for must be a string.");
const fullOptions = {};
fullOptions.$term = value;
for (const option in options) switch (option) {
case "language":
fullOptions.$language = options[option];
break;
case "caseSensitive":
fullOptions.$caseSensitive = options[option];
break;
case "diacriticSensitive":
fullOptions.$diacriticSensitive = options[option];
break;
default: throw new Error(`Unknown option: ${option}`);
}
return this._addCondition(key, "$text", { $search: fullOptions });
}
/**
* Method to sort the full text search by text score
*
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
sortByTextScore() {
this.ascending("$score");
this.select(["$score"]);
return this;
}
/**
* Adds a constraint for finding string values that start with a provided
* string. This query will use the backend index, so it will be fast even
* for large datasets.
*
* @param {string} key The key that the string to match is stored in.
* @param {string} prefix The substring that the value must start with.
* @param {string} modifiers The regular expression mode.
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
startsWith(key, prefix, modifiers) {
if (typeof prefix !== "string") throw new Error("The value being searched for must be a string.");
return this.matches(key, this._regexStartWith(prefix), modifiers);
}
/**
* Adds a constraint for finding string values that end with a provided
* string. This will be slow for large datasets.
*
* @param {string} key The key that the string to match is stored in.
* @param {string} suffix The substring that the value must end with.
* @param {string} modifiers The regular expression mode.
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
endsWith(key, suffix, modifiers) {
if (typeof suffix !== "string") throw new Error("The value being searched for must be a string.");
return this.matches(key, quote(suffix) + "$", modifiers);
}
/**
* Adds a proximity based constraint for finding objects with key point
* values near the point given.
*
* @param {string} key The key that the Parse.GeoPoint is stored in.
* @param {Parse.GeoPoint} point The reference Parse.GeoPoint that is used.
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
near(key, point) {
if (!(point instanceof ParseGeoPoint)) point = new ParseGeoPoint(point);
return this._addCondition(key, "$nearSphere", point);
}
/**
* Adds a proximity based constraint for finding objects with key point
* values near the point given and within the maximum distance given.
*
* @param {string} key The key that the Parse.GeoPoint is stored in.
* @param {Parse.GeoPoint} point The reference Parse.GeoPoint that is used.
* @param {number} maxDistance Maximum distance (in radians) of results to return.
* @param {boolean} sorted A Bool value that is true if results should be
* sorted by distance ascending, false is no sorting is required,
* defaults to true.
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
withinRadians(key, point, maxDistance, sorted) {
if (sorted || sorted === void 0) {
this.near(key, point);
return this._addCondition(key, "$maxDistance", maxDistance);
} else return this._addCondition(key, "$geoWithin", { $centerSphere: [[point.longitude, point.latitude], maxDistance] });
}
/**
* Adds a proximity based constraint for finding objects with key point
* values near the point given and within the maximum distance given.
* Radius of earth used is 3958.8 miles.
*
* @param {string} key The key that the Parse.GeoPoint is stored in.
* @param {Parse.GeoPoint} point The reference Parse.GeoPoint that is used.
* @param {number} maxDistance Maximum distance (in miles) of results to return.
* @param {boolean} sorted A Bool value that is true if results should be
* sorted by distance ascending, false is no sorting is required,
* defaults to true.
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
withinMiles(key, point, maxDistance, sorted) {
return this.withinRadians(key, point, maxDistance / 3958.8, sorted);
}
/**
* Adds a proximity based constraint for finding objects with key point
* values near the point given and within the maximum distance given.
* Radius of earth used is 6371.0 kilometers.
*
* @param {string} key The key that the Parse.GeoPoint is stored in.
* @param {Parse.GeoPoint} point The reference Parse.GeoPoint that is used.
* @param {number} maxDistance Maximum distance (in kilometers) of results to return.
* @param {boolean} sorted A Bool value that is true if results should be
* sorted by distance ascending, false is no sorting is required,
* defaults to true.
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
withinKilometers(key, point, maxDistance, sorted) {
return this.withinRadians(key, point, maxDistance / 6371, sorted);
}
/**
* Adds a constraint to the query that requires a particular key's
* coordinates be contained within a given rectangular geographic bounding
* box.
*
* @param {string} key The key to be constrained.
* @param {Parse.GeoPoint} southwest
* The lower-left inclusive corner of the box.
* @param {Parse.GeoPoint} northeast
* The upper-right inclusive corner of the box.
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
withinGeoBox(key, southwest, northeast) {
if (!(southwest instanceof ParseGeoPoint)) southwest = new ParseGeoPoint(southwest);
if (!(northeast instanceof ParseGeoPoint)) northeast = new ParseGeoPoint(northeast);
this._addCondition(key, "$within", { $box: [southwest, northeast] });
return this;
}
/**
* Adds a constraint to the query that requires a particular key's
* coordinates be contained within and on the bounds of a given polygon.
* Supports closed and open (last point is connected to first) paths
*
* Polygon must have at least 3 points
*
* @param {string} key The key to be constrained.
* @param {Array} points Array of Coordinates / GeoPoints
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
withinPolygon(key, points) {
return this._addCondition(key, "$geoWithin", { $polygon: points });
}
/**
* Add a constraint to the query that requires a particular key's
* coordinates that contains a ParseGeoPoint
*
* @param {string} key The key to be constrained.
* @param {Parse.GeoPoint} point
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
polygonContains(key, point) {
return this._addCondition(key, "$geoIntersects", { $point: point });
}
/**
* Sorts the results in ascending order by the given key.
*
* @param {(string|string[])} keys The key to order by, which is a
* string of comma separated values, or an Array of keys, or multiple keys.
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
ascending(...keys) {
this._order = [];
return this.addAscending.apply(this, keys);
}
/**
* Sorts the results in ascending order by the given key,
* but can also add secondary sort descriptors without overwriting _order.
*
* @param {(string|string[])} keys The key to order by, which is a
* string of comma separated values, or an Array of keys, or multiple keys.
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
addAscending(...keys) {
if (!this._order) this._order = [];
keys.forEach((key) => {
if (Array.isArray(key)) key = key.join();
this._order = this._order.concat(key.replace(/\s/g, "").split(","));
});
return this;
}
/**
* Sorts the results in descending order by the given key.
*
* @param {(string|string[])} keys The key to order by, which is a
* string of comma separated values, or an Array of keys, or multiple keys.
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
descending(...keys) {
this._order = [];
return this.addDescending.apply(this, keys);
}
/**
* Sorts the results in descending order by the given key,
* but can also add secondary sort descriptors without overwriting _order.
*
* @param {(string|string[])} keys The key to order by, which is a
* string of comma separated values, or an Array of keys, or multiple keys.
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
addDescending(...keys) {
if (!this._order) this._order = [];
keys.forEach((key) => {
if (Array.isArray(key)) key = key.join();
this._order = this._order.concat(key.replace(/\s/g, "").split(",").map((k) => {
return "-" + k;
}));
});
return this;
}
/**
* Sets the number of results to skip before returning any results.
* This is useful for pagination.
* Default is to skip zero results.
*
* @param {number} n the number of results to skip.
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
skip(n) {
if (typeof n !== "number" || n < 0) throw new Error("You can only skip by a positive number");
this._skip = n;
return this;
}
/**
* Sets the limit of the number of results to return. The default limit is 100.
*
* @param {number} n the number of results to limit to.
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
limit(n) {
if (typeof n !== "number") throw new Error("You can only set the limit to a numeric value");
this._limit = n;
return this;
}
/**
* Sets the flag to include with response the total number of objects satisfying this query,
* despite limits/skip. Might be useful for pagination.
* Note that result of this query will be wrapped as an object with
* `results`: holding {ParseObject} array and `count`: integer holding total number
*
* @param {boolean} includeCount false - disable, true - enable.
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
withCount(includeCount = true) {
if (typeof includeCount !== "boolean") throw new Error("You can only set withCount to a boolean value");
this._count = includeCount;
return this;
}
/**
* Includes nested Parse.Objects for the provided key. You can use dot
* notation to specify which fields in the included object are also fetched.
*
* You can include all nested Parse.Objects by passing in '*'.
* Requires Parse Server 3.0.0+
* <pre>query.include('*');</pre>
*
* @param {...string|Array<string>} keys The name(s) of the key(s) to include.
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
include(...keys) {
keys.forEach((key) => {
if (Array.isArray(key)) this._include = this._include.concat(key);
else this._include.push(key);
});
return this;
}
/**
* Includes all nested Parse.Objects one level deep.
*
* Requires Parse Server 3.0.0+
*
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
includeAll() {
return this.include("*");
}
/**
* Restricts the fields of the returned Parse.Objects to include only the
* provided keys. If this is called multiple times, then all of the keys
* specified in each of the calls will be included.
*
* When selecting `authData` on `Parse.User`, only auth data of currently
* configured auth providers is returned. Auth data of providers that are no
* longer configured is not included. To return all auth data regardless of
* the provider configuration, do not select `authData`.
*
* @param {...string|Array<string>} keys The name(s) of the key(s) to include.
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
select(...keys) {
if (!this._select) this._select = [];
keys.forEach((key) => {
if (Array.isArray(key)) this._select = this._select.concat(key);
else this._select.push(key);
});
return this;
}
/**
* Restricts the fields of the returned Parse.Objects to all keys except the
* provided keys. Exclude takes precedence over select and include.
*
* Requires Parse Server 3.6.0+
*
* @param {...string|Array<string>} keys The name(s) of the key(s) to exclude.
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
exclude(...keys) {
keys.forEach((key) => {
if (Array.isArray(key)) this._exclude = this._exclude.concat(key);
else this._exclude.push(key);
});
return this;
}
/**
* Restricts live query to trigger only for watched fields.
*
* Requires Parse Server 6.0.0+
*
* @param {...string|Array<string>} keys The name(s) of the key(s) to watch.
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
watch(...keys) {
keys.forEach((key) => {
if (Array.isArray(key)) this._watch = this._watch.concat(key);
else this._watch.push(key);
});
return this;
}
/**
* Changes the read preference that the backend will use when performing the query to the database.
*
* @param {string} readPreference The read preference for the main query.
* @param {string} includeReadPreference The read preference for the queries to include pointers.
* @param {string} subqueryReadPreference The read preference for the sub queries.
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
readPreference(readPreference, includeReadPreference, subqueryReadPreference) {
this._readPreference = readPreference;
this._includeReadPreference = includeReadPreference || null;
this._subqueryReadPreference = subqueryReadPreference || null;
return this;
}
/**
* Subscribe this query to get liveQuery updates
*
* @param {string} sessionToken (optional) Defaults to the currentUser
* @returns {Promise<LiveQuerySubscription>} Returns the liveQuerySubscription, it's an event emitter
* which can be used to get liveQuery updates.
*/
async subscribe(sessionToken) {
const currentUser = await CoreManager.getUserController().currentUserAsync();
if (!sessionToken) sessionToken = currentUser ? currentUser.getSessionToken() || void 0 : void 0;
const liveQueryClient = await CoreManager.getLiveQueryController().getDefaultLiveQueryClient();
if (liveQueryClient.shouldOpen()) liveQueryClient.open();
const subscription = liveQueryClient.subscribe(this, sessionToken);
return subscription.subscribePromise.then(() => {
return subscription;
});
}
/**
* Constructs a Parse.Query that is the OR of the passed in queries. For
* example:
* <pre>var compoundQuery = Parse.Query.or(query1, query2, query3);</pre>
*
* will create a compoundQuery that is an or of the query1, query2, and
* query3.
*
* @param {...Parse.Query} queries The list of queries to OR.
* @static
* @returns {Parse.Query} The query that is the OR of the passed in queries.
*/
static or(...queries) {
const className = _getClassNameFromQueries(queries);
const query = new ParseQuery(className);
query._orQuery(queries);
return query;
}
/**
* Constructs a Parse.Query that is the AND of the passed in queries. For
* example:
* <pre>var compoundQuery = Parse.Query.and(query1, query2, query3);</pre>
*
* will create a compoundQuery that is an and of the query1, query2, and
* query3.
*
* @param {...Parse.Query} queries The list of queries to AND.
* @static
* @returns {Parse.Query} The query that is the AND of the passed in queries.
*/
static and(...queries) {
const className = _getClassNameFromQueries(queries);
const query = new ParseQuery(className);
query._andQuery(queries);
return query;
}
/**
* Constructs a Parse.Query that is the NOR of the passed in queries. For
* example:
* <pre>const compoundQuery = Parse.Query.nor(query1, query2, query3);</pre>
*
* will create a compoundQuery that is a nor of the query1, query2, and
* query3.
*
* @param {...Parse.Query} queries The list of queries to NOR.
* @static
* @returns {Parse.Query} The query that is the NOR of the passed in queries.
*/
static nor(...queries) {
const className = _getClassNameFromQueries(queries);
const query = new ParseQuery(className);
query._norQuery(queries);
return query;
}
/**
* Change the source of this query to the server.
*
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
fromNetwork() {
this._queriesLocalDatastore = false;
this._localDatastorePinName = null;
return this;
}
/**
* Changes the source of this query to all pinned objects.
*
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
fromLocalDatastore() {
return this.fromPinWithName(null);
}
/**
* Changes the source of this query to the default group of pinned objects.
*
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
fromPin() {
return this.fromPinWithName(DEFAULT_PIN);
}
/**
* Changes the source of this query to a specific group of pinned objects.
*
* @param {string} name The name of query source.
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
fromPinWithName(name) {
if (CoreManager.getLocalDatastore().checkIfEnabled()) {
this._queriesLocalDatastore = true;
this._localDatastorePinName = name;
}
return this;
}
/**
* Cancels the current network request (if any is running).
*
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
cancel() {
if (this._xhrRequest.task && typeof this._xhrRequest.task.abort === "function") {
this._xhrRequest.task._aborted = true;
this._xhrRequest.task.abort();
this._xhrRequest.task = null;
this._xhrRequest.onchange = () => {};
return this;
}
this._xhrRequest.onchange = () => this.cancel();
return this;
}
_setRequestTask(options) {
options.requestTask = (task) => {
this._xhrRequest.task = task;
this._xhrRequest.onchange();
};
}
/**
* Sets a comment to the query so that the query
* can be identified when using a the profiler for MongoDB.
*
* @param {string} value a comment can make your profile data easier to interpret and trace.
* @returns {Parse.Query} Returns the query, so you can chain this call.
*/
comment(value) {
if (value == null) {
delete this._comment;
return this;
}
if (typeof value !== "string") throw new Error("The value of a comment to be sent with this query must be a string.");
this._comment = value;
return this;
}
};
var DefaultController$1 = {
find(className, params, options) {
return CoreManager.getRESTController().request("GET", "classes/" + className, params, options);
},
aggregate(className, params, options) {
return CoreManager.getRESTController().request("GET", "aggregate/" + className, params, options);
}
};
CoreManager.setParseQuery(ParseQuery);
CoreManager.setQueryController(DefaultController$1);
//#endregion
//#region src/Storage.ts
var Storage = {
async() {
return !!CoreManager.getStorageController().async;
},
getItem(path) {
const controller = CoreManager.getStorageController();
if (controller.async === 1) throw new Error("Synchronous storage is not supported by the current storage controller");
return controller.getItem(path);
},
getItemAsync(path) {
const controller = CoreManager.getStorageController();
if (controller.async === 1) return controller.getItemAsync(path);
return Promise.resolve(controller.getItem(path));
},
setItem(path, value) {
const controller = CoreManager.getStorageController();
if (controller.async === 1) throw new Error("Synchronous storage is not supported by the current storage controller");
return controller.setItem(path, value);
},
setItemAsync(path, value) {
const controller = CoreManager.getStorageController();
if (controller.async === 1) return controller.setItemAsync(path, value);
return Promise.resolve(controller.setItem(path, value));
},
removeItem(path) {
const controller = CoreManager.getStorageController();
if (controller.async === 1) throw new Error("Synchronous storage is not supported by the current storage controller");
return controller.removeItem(path);
},
removeItemAsync(path) {
const controller = CoreManager.getStorageController();
if (controller.async === 1) return controller.removeItemAsync(path);
return Promise.resolve(controller.removeItem(path));
},
getAllKeys() {
const controller = CoreManager.getStorageController();
if (controller.async === 1) throw new Error("Synchronous storage is not supported by the current storage controller");
return controller.getAllKeys();
},
getAllKeysAsync() {
const controller = CoreManager.getStorageController();
if (controller.async === 1) return controller.getAllKeysAsync();
return Promise.resolve(controller.getAllKeys());
},
generatePath(path) {
if (!CoreManager.get("APPLICATION_ID")) throw new Error("You need to call Parse.initialize before using Parse.");
if (typeof path !== "string") throw new Error("Tried to get a Storage path that was not a String.");
if (path[0] === "/") path = path.substr(1);
return "Parse/" + CoreManager.get("APPLICATION_ID") + "/" + path;
},
_clear() {
const controller = CoreManager.getStorageController();
if (Object.hasOwn(controller, "clear")) controller.clear();
}
};
//#endregion
//#region src/EventuallyQueue.ts
var QUEUE_KEY = "Parse/Eventually/Queue";
var queueCache = [];
var dirtyCache = true;
var polling = void 0;
/**
* Provides utility functions to queue objects that will be
* saved to the server at a later date.
*
* @class Parse.EventuallyQueue
* @static
*/
var EventuallyQueue = {
/**
* Add object to queue with save operation.
*
* @function save
* @name Parse.EventuallyQueue.save
* @param {ParseObject} object Parse.Object to be saved eventually
* @param {object} [serverOptions] See {@link https://parseplatform.org/Parse-SDK-JS/api/master/Parse.Object.html#save Parse.Object.save} options.
* @returns {Promise} A promise that is fulfilled if object is added to queue.
* @static
* @see Parse.Object#saveEventually
*/
save(object, serverOptions) {
return this.enqueue("save", object, serverOptions);
},
/**
* Add object to queue with save operation.
*
* @function destroy
* @name Parse.EventuallyQueue.destroy
* @param {ParseObject} object Parse.Object to be destroyed eventually
* @param {object} [serverOptions] See {@link https://parseplatform.org/Parse-SDK-JS/api/master/Parse.Object.html#destroy Parse.Object.destroy} options
* @returns {Promise} A promise that is fulfilled if object is added to queue.
* @static
* @see Parse.Object#destroyEventually
*/
destroy(object, serverOptions) {
return this.enqueue("destroy", object, serverOptions);
},
/**
* Generate unique identifier to avoid duplicates and maintain previous state.
*
* @param {string} action save / destroy
* @param {object} object Parse.Object to be queued
* @returns {string}
* @static
* @ignore
*/
generateQueueId(action, object) {
object._getId();
const { className, id, _localId } = object;
return [
action,
className,
id,
object.get("hash") || _localId
].join("_");
},
/**
* Build queue object and add to queue.
*
* @param {string} action save / destroy
* @param {object} object Parse.Object to be queued
* @param {object} [serverOptions]
* @returns {Promise} A promise that is fulfilled if object is added to queue.
* @static
* @ignore
*/
async enqueue(action, object, serverOptions) {
const queueData = await this.getQueue();
const queueId = this.generateQueueId(action, object);
let index = this.queueItemExists(queueData, queueId);
if (index > -1) {
for (const prop in queueData[index].object) if (typeof object.get(prop) === "undefined") object.set(prop, queueData[index].object[prop]);
} else index = queueData.length;
queueData[index] = {
queueId,
action,
object: object.toJSON(),
serverOptions: serverOptions || {},
id: object.id,
className: object.className,
hash: object.get("hash"),
createdAt: /* @__PURE__ */ new Date()
};
return this.setQueue(queueData);
},
store(data) {
return Storage.setItemAsync(QUEUE_KEY, JSON.stringify(data));
},
load() {
return Storage.getItemAsync(QUEUE_KEY);
},
/**
* Sets the in-memory queue from local storage and returns.
*
* @function getQueue
* @name Parse.EventuallyQueue.getQueue
* @returns {Promise<Queue>}
* @static
*/
async getQueue() {
if (dirtyCache) {
queueCache = JSON.parse(await this.load() || "[]");
dirtyCache = false;
}
return queueCache;
},
/**
* Saves the queue to local storage
*
* @param {Queue} queue Queue containing Parse.Object data.
* @returns {Promise} A promise that is fulfilled when queue is stored.
* @static
* @ignore
*/
setQueue(queue) {
queueCache = queue;
return this.store(queueCache);
},
/**
* Removes Parse.Object data from queue.
*
* @param {string} queueId Unique identifier for Parse.Object data.
* @returns {Promise} A promise that is fulfilled when queue is stored.
* @static
* @ignore
*/
async remove(queueId) {
const queueData = await this.getQueue();
const index = this.queueItemExists(queueData, queueId);
if (index > -1) {
queueData.splice(index, 1);
await this.setQueue(queueData);
}
},
/**
* Removes all objects from queue.
*
* @function clear
* @name Parse.EventuallyQueue.clear
* @returns {Promise} A promise that is fulfilled when queue is cleared.
* @static
*/
clear() {
queueCache = [];
return this.store([]);
},
/**
* Return the index of a queueId in the queue. Returns -1 if not found.
*
* @param {Queue} queue Queue containing Parse.Object data.
* @param {string} queueId Unique identifier for Parse.Object data.
* @returns {number}
* @static
* @ignore
*/
queueItemExists(queue, queueId) {
return queue.findIndex((data) => data.queueId === queueId);
},
/**
* Return the number of objects in the queue.
*
* @function length
* @name Parse.EventuallyQueue.length
* @returns {Promise<number>}
* @static
*/
async length() {
return (await this.getQueue()).length;
},
/**
* Sends the queue to the server.
*
* @function sendQueue
* @name Parse.EventuallyQueue.sendQueue
* @returns {Promise<boolean>} Returns true if queue was sent successfully.
* @static
*/
async sendQueue() {
const queueData = [...await this.getQueue()];
if (queueData.length === 0) return false;
for (let i = 0; i < queueData.length; i += 1) {
const queueObject = queueData[i];
const { id, hash, className } = queueObject;
const ObjectType = ParseObject.extend(className);
if (id) await this.process.byId(ObjectType, queueObject);
else if (hash) await this.process.byHash(ObjectType, queueObject);
else await this.process.create(ObjectType, queueObject);
}
return true;
},
/**
* Build queue object and add to queue.
*
* @param {ParseObject} object Parse.Object to be processed
* @param {QueueObject} queueObject Parse.Object data from the queue
* @returns {Promise} A promise that is fulfilled when operation is performed.
* @static
* @ignore
*/
async sendQueueCallback(object, queueObject) {
if (!object) return this.remove(queueObject.queueId);
switch (queueObject.action) {
case "save":
if (typeof object.updatedAt !== "undefined" && object.updatedAt > new Date(queueObject.object.createdAt)) return this.remove(queueObject.queueId);
try {
await object.save(queueObject.object, queueObject.serverOptions);
await this.remove(queueObject.queueId);
} catch (e) {
if (e.code !== ParseError.CONNECTION_FAILED) await this.remove(queueObject.queueId);
}
break;
case "destroy":
try {
await object.destroy(queueObject.serverOptions);
await this.remove(queueObject.queueId);
} catch (e) {
if (e.code !== ParseError.CONNECTION_FAILED) await this.remove(queueObject.queueId);
}
break;
}
},
/**
* Start polling server for network connection.
* Will send queue if connection is established.
*
* @function poll
* @name Parse.EventuallyQueue.poll
* @param [ms] Milliseconds to ping the server. Default 2000ms
* @static
*/
poll(ms) {
if (polling) return;
polling = setInterval(() => {
CoreManager.getRESTController().request("GET", "health").then(({ status }) => {
if (status === "ok") {
this.stopPoll();
return this.sendQueue();
}
}).catch((e) => e);
}, ms || 2e3);
},
/**
* Turns off polling.
*
* @function stopPoll
* @name Parse.EventuallyQueue.stopPoll
* @static
*/
stopPoll() {
clearInterval(polling);
polling = void 0;
},
/**
* Return true if pinging the server.
*
* @function isPolling
* @name Parse.EventuallyQueue.isPolling
* @returns {boolean}
* @static
*/
isPolling() {
return !!polling;
},
_setPolling(flag) {
polling = flag;
},
process: {
create(ObjectType, queueObject) {
const object = new ObjectType();
return EventuallyQueue.sendQueueCallback(object, queueObject);
},
async byId(ObjectType, queueObject) {
const { sessionToken } = queueObject.serverOptions;
const query = new ParseQuery(ObjectType);
query.equalTo("objectId", queueObject.id);
const results = await query.find({ sessionToken });
return EventuallyQueue.sendQueueCallback(results[0], queueObject);
},
async byHash(ObjectType, queueObject) {
const { sessionToken } = queueObject.serverOptions;
const query = new ParseQuery(ObjectType);
query.equalTo("hash", queueObject.hash);
const results = await query.find({ sessionToken });
if (results.length > 0) return EventuallyQueue.sendQueueCallback(results[0], queueObject);
return EventuallyQueue.process.create(ObjectType, queueObject);
}
}
};
//#endregion
//#region node_modules/idb-keyval/dist/index.js
function promisifyRequest(request) {
return new Promise((resolve, reject) => {
request.oncomplete = request.onsuccess = () => resolve(request.result);
request.onabort = request.onerror = () => reject(request.error);
});
}
function createStore(dbName, storeName) {
let dbp;
const getDB = () => {
if (dbp) return dbp;
const request = indexedDB.open(dbName);
request.onupgradeneeded = () => request.result.createObjectStore(storeName);
dbp = promisifyRequest(request);
dbp.then((db) => {
db.onclose = () => dbp = void 0;
}, () => {
dbp = void 0;
});
return dbp;
};
return (txMode, callback) => getDB().then((db) => callback(db.transaction(storeName, txMode).objectStore(storeName)));
}
var defaultGetStoreFunc;
function defaultGetStore() {
if (!defaultGetStoreFunc) defaultGetStoreFunc = createStore("keyval-store", "keyval");
return defaultGetStoreFunc;
}
/**
* Get a value by its key.
*
* @param key
* @param customStore Method to get a custom store. Use with caution (see the docs).
*/
function get(key, customStore = defaultGetStore()) {
return customStore("readonly", (store) => promisifyRequest(store.get(key)));
}
/**
* Set a value with a key.
*
* @param key
* @param value
* @param customStore Method to get a custom store. Use with caution (see the docs).
*/
function set(key, value, customStore = defaultGetStore()) {
return customStore("readwrite", (store) => {
store.put(value, key);
return promisifyRequest(store.transaction);
});
}
/**
* Delete a particular key from the store.
*
* @param key
* @param customStore Method to get a custom store. Use with caution (see the docs).
*/
function del(key, customStore = defaultGetStore()) {
return customStore("readwrite", (store) => {
store.delete(key);
return promisifyRequest(store.transaction);
});
}
/**
* Clear all values in the store.
*
* @param customStore Method to get a custom store. Use with caution (see the docs).
*/
function clear(customStore = defaultGetStore()) {
return customStore("readwrite", (store) => {
store.clear();
return promisifyRequest(store.transaction);
});
}
function eachCursor(store, callback) {
store.openCursor().onsuccess = function() {
if (!this.result) return;
callback(this.result);
this.result.continue();
};
return promisifyRequest(store.transaction);
}
/**
* Get all keys in the store.
*
* @param customStore Method to get a custom store. Use with caution (see the docs).
*/
function keys(customStore = defaultGetStore()) {
return customStore("readonly", (store) => {
if (store.getAllKeys) return promisifyRequest(store.getAllKeys());
const items = [];
return eachCursor(store, (cursor) => items.push(cursor.key)).then(() => items);
});
}
//#endregion
//#region src/IndexedDBStorageController.ts
var IndexedDBStorageController;
if (typeof window !== "undefined" && window.indexedDB) try {
const ParseStore = createStore("parseDB", "parseStore");
} catch (_) {}
else IndexedDBStorageController = void 0;
//#endregion
//#region src/ParseInstallation.ts
var DEVICE_TYPES = {
IOS: "ios",
MACOS: "macos",
TVOS: "tvos",
FCM: "fcm",
ANDROID: "android",
WEB: "web"
};
/**
* Parse.Installation is a local representation of installation data that can be saved and retrieved from the Parse cloud.
* This class is a subclass of a Parse.Object, and retains the same functionality of a Parse.Object, but also extends it with installation-specific features.
*
* <p>A valid Parse.Installation can only be instantiated via <code>Parse.Installation.currentInstallation()</code>
*
* Parse.Installation objects which have a valid <code>deviceToken</code> and are saved to the Parse cloud can be used to target push notifications.
* </p>
*
* @alias Parse.Installation
*/
var ParseInstallation = class extends ParseObject {
/**
* @param {object} attributes The initial set of data to store in the object.
*/
constructor(attributes) {
super("_Installation");
if (attributes && typeof attributes === "object") try {
this.set(attributes || {});
} catch (_) {
throw new Error("Can't create an invalid Installation");
}
}
/**
* A unique identifier for this installation’s client application. In iOS, this is the Bundle Identifier.
*
* @property {string} appIdentifier
* @static
* @returns {string}
*/
get appIdentifier() {
return this.get("appIdentifier");
}
/**
* The version string of the client application to which this installation belongs.
*
* @property {string} appVersion
* @static
* @returns {string}
*/
get appVersion() {
return this.get("appVersion");
}
/**
* The display name of the client application to which this installation belongs.
*
* @property {string} appName
* @static
* @returns {string}
*/
get appName() {
return this.get("appName");
}
/**
* The current value of the icon badge for iOS apps.
* Changes to this value on the server will be used
* for future badge-increment push notifications.
*
* @property {number} badge
* @static
* @returns {number}
*/
get badge() {
return this.get("badge");
}
/**
* An array of the channels to which a device is currently subscribed.
*
* @property {string[]} channels
* @static
* @returns {string[]}
*/
get channels() {
return this.get("channels");
}
/**
* Token used to deliver push notifications to the device.
*
* @property {string} deviceToken
* @static
* @returns {string}
*/
get deviceToken() {
return this.get("deviceToken");
}
/**
* The type of device, “ios”, “android”, “web”, etc.
*
* @property {string} deviceType
* @static
* @returns {string}
*/
get deviceType() {
return this.get("deviceType");
}
/**
* Gets the GCM sender identifier for this installation
*
* @property {string} GCMSenderId
* @static
* @returns {string}
*/
get GCMSenderId() {
return this.get("GCMSenderId");
}
/**
* Universally Unique Identifier (UUID) for the device used by Parse. It must be unique across all of an app’s installations.
*
* @property {string} installationId
* @static
* @returns {string}
*/
get installationId() {
return this.get("installationId");
}
/**
* Gets the local identifier for this installation
*
* @property {string} localeIdentifier
* @static
* @returns {string}
*/
get localeIdentifier() {
return this.get("localeIdentifier");
}
/**
* Gets the parse server version for this installation
*
* @property {string} parseVersion
* @static
* @returns {string}
*/
get parseVersion() {
return this.get("parseVersion");
}
/**
* This field is reserved for directing Parse to the push delivery network to be used.
*
* @property {string} pushType
* @static
* @returns {string}
*/
get pushType() {
return this.get("pushType");
}
/**
* Gets the time zone for this installation
*
* @property {string} timeZone
* @static
* @returns {string}
*/
get timeZone() {
return this.get("timeZone");
}
/**
* Returns the device types for used for Push Notifications.
*
* <pre>
* Parse.Installation.DEVICE_TYPES.IOS
* Parse.Installation.DEVICE_TYPES.MACOS
* Parse.Installation.DEVICE_TYPES.TVOS
* Parse.Installation.DEVICE_TYPES.FCM
* Parse.Installation.DEVICE_TYPES.ANDROID
* Parse.Installation.DEVICE_TYPES.WEB
* </pre
*
* @property {object} DEVICE_TYPES
* @static
* @returns {object}
*/
static get DEVICE_TYPES() {
return DEVICE_TYPES;
}
/**
* Wrap the default fetch behavior with functionality to update local storage.
* If the installation is deleted on the server, retry the fetch as a save operation.
*
* @param {...any} args
* @returns {Promise}
*/
async fetch(...args) {
try {
await super.fetch.apply(this, args);
} catch (e) {
if (e.code !== ParseError.OBJECT_NOT_FOUND) throw e;
delete this.id;
this._getId();
this._markAllFieldsDirty();
await super.save.apply(this, args);
}
await CoreManager.getInstallationController().updateInstallationOnDisk(this);
return this;
}
/**
* Wrap the default save behavior with functionality to update the local storage.
* If the installation is deleted on the server, retry saving a new installation.
*
* @param {...any} args
* @returns {Promise}
*/
async save(...args) {
try {
await super.save.apply(this, args);
} catch (e) {
if (e.code !== ParseError.OBJECT_NOT_FOUND) throw e;
delete this.id;
this._getId();
this._markAllFieldsDirty();
await super.save.apply(this, args);
}
await CoreManager.getInstallationController().updateInstallationOnDisk(this);
return this;
}
_markAllFieldsDirty() {
for (const [key, value] of Object.entries(this.attributes)) this.set(key, value);
}
/**
* Get the current Parse.Installation from disk. If doesn't exists, create an new installation.
*
* <pre>
* const installation = await Parse.Installation.currentInstallation();
* installation.set('deviceToken', '123');
* await installation.save();
* </pre>
*
* @returns {Promise} A promise that resolves to the local installation object.
*/
static currentInstallation() {
return CoreManager.getInstallationController().currentInstallation();
}
};
ParseObject.registerSubclass("_Installation", ParseInstallation);
//#endregion
//#region src/InstallationController.ts
var CURRENT_INSTALLATION_KEY = "currentInstallation";
var CURRENT_INSTALLATION_ID_KEY = "currentInstallationId";
var iidCache = null;
var currentInstallationCache = null;
var currentInstallationCacheMatchesDisk = false;
var InstallationController = {
async updateInstallationOnDisk(installation) {
const path = Storage.generatePath(CURRENT_INSTALLATION_KEY);
await Storage.setItemAsync(path, JSON.stringify(installation.toJSON()));
this._setCurrentInstallationCache(installation);
},
async currentInstallationId() {
if (typeof iidCache === "string") return iidCache;
const path = Storage.generatePath(CURRENT_INSTALLATION_ID_KEY);
let iid = await Storage.getItemAsync(path);
if (!iid) {
iid = uuid();
return Storage.setItemAsync(path, iid).then(() => {
iidCache = iid;
return iid;
});
}
iidCache = iid;
return iid;
},
async currentInstallation() {
if (currentInstallationCache) return currentInstallationCache;
if (currentInstallationCacheMatchesDisk) return null;
const path = Storage.generatePath(CURRENT_INSTALLATION_KEY);
let installationData = await Storage.getItemAsync(path);
currentInstallationCacheMatchesDisk = true;
if (installationData) {
installationData = JSON.parse(installationData);
installationData.className = "_Installation";
const current = ParseInstallation.fromJSON(installationData);
currentInstallationCache = current;
return current;
}
const installationId = await this.currentInstallationId();
const installation = new ParseInstallation();
installation.set("deviceType", ParseInstallation.DEVICE_TYPES.WEB);
installation.set("installationId", installationId);
installation.set("parseVersion", CoreManager.get("VERSION"));
currentInstallationCache = installation;
await Storage.setItemAsync(path, JSON.stringify(installation.toJSON()));
return installation;
},
_clearCache() {
iidCache = null;
currentInstallationCache = null;
currentInstallationCacheMatchesDisk = false;
},
_setInstallationIdCache(iid) {
iidCache = iid;
},
_setCurrentInstallationCache(installation, matchesDisk = true) {
currentInstallationCache = installation;
currentInstallationCacheMatchesDisk = matchesDisk;
}
};
//#endregion
//#region src/Xhr.weapp.ts
init_dist();
/* istanbul ignore file */
function parseResponse(res) {
let headers = res.header || {};
headers = Object.keys(headers).reduce((map, key) => {
map[key.toLowerCase()] = headers[key];
return map;
}, {});
return {
status: res.statusCode,
json: () => {
if (typeof res.data === "object") return Promise.resolve(res.data);
let json = {};
try {
json = JSON.parse(res.data);
} catch (err) {
console.error(err);
}
return Promise.resolve(json);
},
headers: {
keys: () => Object.keys(headers),
get: (n) => headers[n.toLowerCase()],
has: (n) => n.toLowerCase() in headers,
entries: () => {
const all = [];
for (const key in headers) if (headers[key]) all.push([key, headers[key]]);
return all;
}
}
};
}
function polyfillFetch() {
const typedGlobal = global;
if (typeof typedGlobal.fetch !== "function") typedGlobal.fetch = (url, options) => {
const dataType = url.match(/\.(txt|json|html|txt|csv)/) ? "text" : "arraybuffer";
return new Promise((resolve, reject) => {
wx.request({
url,
method: options.method || "GET",
data: options.body,
header: options.headers,
dataType,
responseType: dataType,
success: (response) => resolve(parseResponse(response)),
fail: (error) => reject(error)
});
});
};
}
//#endregion
//#region src/RESTController.ts
init_dist$2();
polyfillFetch();
var useXDomainRequest = false;
if (typeof XDomainRequest !== "undefined" && !("withCredentials" in new XMLHttpRequest())) useXDomainRequest = true;
function getPath(base, pathname) {
if (base.endsWith("/")) base = base.slice(0, -1);
if (!pathname.startsWith("/")) pathname = "/" + pathname;
return base + pathname;
}
function ajaxIE9(method, url, data, _headers, options) {
return new Promise((resolve, reject) => {
const xdr = new XDomainRequest();
xdr.onload = function() {
let response;
try {
response = JSON.parse(xdr.responseText);
} catch (e) {
reject(e);
}
if (response) resolve({ response });
};
xdr.onerror = xdr.ontimeout = function() {
reject({ responseText: JSON.stringify({
code: ParseError.X_DOMAIN_REQUEST,
error: "IE's XDomainRequest does not supply error info."
}) });
};
xdr.onprogress = function() {
if (options && typeof options.progress === "function") options.progress(xdr.responseText);
};
xdr.open(method, url);
xdr.send(data);
if (options && typeof options.requestTask === "function") options.requestTask(xdr);
});
}
var RESTController = {
async ajax(method, url, data, headers, options) {
if (useXDomainRequest) return ajaxIE9(method, url, data, headers, options);
if (typeof fetch !== "function") throw new Error("Cannot make a request: Fetch API not found.");
const promise = resolvingPromise();
const isIdempotent = CoreManager.get("IDEMPOTENCY") && ["POST", "PUT"].includes(method);
const requestId = isIdempotent ? uuid() : "";
let attempts = 0;
const dispatch = async function() {
const controller = new AbortController();
const { signal } = controller;
headers = headers || {};
if (typeof headers["Content-Type"] !== "string") headers["Content-Type"] = "text/plain";
if (CoreManager.get("IS_NODE")) headers["User-Agent"] = "Parse/" + CoreManager.get("VERSION") + " (NodeJS " + process$1.versions.node + ")";
if (isIdempotent) headers["X-Parse-Request-Id"] = requestId;
const customHeaders = CoreManager.get("REQUEST_HEADERS");
for (const key in customHeaders) headers[key] = customHeaders[key];
if (options && typeof options.requestTask === "function") options.requestTask(controller);
try {
const fetchOptions = {
method,
headers,
signal,
redirect: "manual"
};
if (data) {
fetchOptions.body = data;
if (typeof ReadableStream !== "undefined" && data instanceof ReadableStream) fetchOptions.duplex = "half";
}
const response = await fetch(url, fetchOptions);
const { status } = response;
if (status >= 200 && status < 300) {
let result;
const responseHeaders = {};
(response.headers.get("access-control-expose-headers") || "").split(", ").forEach((header) => {
if (header && response.headers.has(header)) responseHeaders[header] = response.headers.get(header);
});
if (options && typeof options.progress === "function" && response.body) {
const reader = response.body.getReader();
const length = +response.headers.get("Content-Length") || 0;
if (length === 0) {
options.progress(null, null, null);
result = await response.json();
} else {
let recieved = 0;
const chunks = [];
while (true) {
const { done, value } = await reader.read();
if (done) break;
chunks.push(value);
recieved += value?.length || 0;
options.progress(recieved / length, recieved, length);
}
const body = new Uint8Array(recieved);
let offset = 0;
for (const chunk of chunks) {
body.set(chunk, offset);
offset += chunk.length;
}
const jsonString = new TextDecoder().decode(body);
result = JSON.parse(jsonString);
}
} else result = await response.json();
promise.resolve({
status,
response: result,
headers: responseHeaders
});
} else if (status >= 400 && status < 500) {
const error = await response.json();
promise.reject(error);
} else if ([
301,
302,
303,
307,
308
].includes(status)) {
const location = response.headers.get("location");
promise.resolve({
status,
location,
method: status === 303 ? "GET" : method,
dropBody: status === 303
});
} else if (status >= 500 || status === 0) if (!(typeof ReadableStream !== "undefined" && data instanceof ReadableStream) && ++attempts < CoreManager.get("REQUEST_ATTEMPT_LIMIT")) {
const delay = Math.round(Math.random() * 125 * Math.pow(2, attempts));
setTimeout(dispatch, delay);
} else if (status === 0) promise.reject("Unable to connect to the Parse API");
else {
const error = await response.json();
promise.reject(error);
}
else promise.reject(response);
} catch (error) {
if (error.name === "AbortError") promise.resolve({
response: { results: [] },
status: 0
});
else if (error.cause?.code === "ECONNREFUSED") promise.reject("Unable to connect to the Parse API");
else promise.reject(error);
}
};
dispatch();
return promise;
},
request(method, path, data, options) {
options = options || {};
const url = getPath(CoreManager.get("SERVER_URL"), path);
const payload = {};
if (data && typeof data === "object") for (const k in data) payload[k] = data[k];
const context = options.context;
if (context !== void 0) payload._context = context;
if (method !== "POST") {
payload._method = method;
method = "POST";
}
payload._ApplicationId = CoreManager.get("APPLICATION_ID");
const jsKey = CoreManager.get("JAVASCRIPT_KEY");
if (jsKey) payload._JavaScriptKey = jsKey;
payload._ClientVersion = CoreManager.get("VERSION");
let useMasterKey = options.useMasterKey;
if (typeof useMasterKey === "undefined") useMasterKey = CoreManager.get("USE_MASTER_KEY");
if (useMasterKey) if (CoreManager.get("MASTER_KEY")) {
delete payload._JavaScriptKey;
payload._MasterKey = CoreManager.get("MASTER_KEY");
} else throw new Error("Cannot use the Master Key, it has not been provided.");
if (options.useMaintenanceKey) payload._MaintenanceKey = CoreManager.get("MAINTENANCE_KEY");
if (CoreManager.get("FORCE_REVOCABLE_SESSION")) payload._RevocableSession = "1";
const installationId = options.installationId;
let installationIdPromise;
if (installationId && typeof installationId === "string") installationIdPromise = Promise.resolve(installationId);
else installationIdPromise = CoreManager.getInstallationController().currentInstallationId();
return installationIdPromise.then((iid) => {
payload._InstallationId = iid;
const userController = CoreManager.getUserController();
if (options && typeof options.sessionToken === "string") return Promise.resolve(options.sessionToken);
else if (userController) return userController.currentUserAsync().then((user) => {
if (user) return Promise.resolve(user.getSessionToken());
return Promise.resolve(null);
});
return Promise.resolve(null);
}).then((token) => {
if (token) payload._SessionToken = token;
const payloadString = JSON.stringify(payload);
return RESTController.ajax(method, url, payloadString, {}, options).then(async (result) => {
if (result.location) {
let newURL = getPath(result.location, path);
let newMethod = result.method;
let newBody = result.dropBody ? void 0 : payloadString;
for (let i = 0; i < 5; i += 1) {
const r = await RESTController.ajax(newMethod, newURL, newBody, {}, options);
if (!r.location) {
result = r;
break;
}
newURL = getPath(r.location, path);
newMethod = r.method;
newBody = r.dropBody ? void 0 : payloadString;
}
}
const { response, status, headers } = result;
if (options.returnStatus) return {
...response,
_status: status,
_headers: headers
};
else return response;
});
}).catch(RESTController.handleError);
},
handleError(errorJSON) {
let error;
if (errorJSON.code || errorJSON.error || errorJSON.message) error = new ParseError(errorJSON.code, errorJSON.error || errorJSON.message);
else error = new ParseError(ParseError.CONNECTION_FAILED, "XMLHttpRequest failed: " + JSON.stringify(errorJSON));
return Promise.reject(error);
}
};
//#endregion
//#region src/Analytics.ts
var Analytics_exports = /* @__PURE__ */ __exportAll({ track: () => track });
/**
* Parse.Analytics provides an interface to Parse's logging and analytics
* backend.
*
* @class Parse.Analytics
* @static
* @hideconstructor
*/
/**
* Tracks the occurrence of a custom event with additional dimensions.
* Parse will store a data point at the time of invocation with the given
* event name.
*
* Dimensions will allow segmentation of the occurrences of this custom
* event. Keys and values should be {@code String}s, and will throw
* otherwise.
*
* To track a user signup along with additional metadata, consider the
* following:
* <pre>
* var dimensions = {
* gender: 'm',
* source: 'web',
* dayType: 'weekend'
* };
* Parse.Analytics.track('signup', dimensions);
* </pre>
*
* There is a default limit of 8 dimensions per event tracked.
*
* @function track
* @name Parse.Analytics.track
* @param {string} name The name of the custom event to report to Parse as
* having happened.
* @param {object} dimensions The dictionary of information by which to
* segment this event.
* @returns {Promise} A promise that is resolved when the round-trip
* to the server completes.
*/
function track(name, dimensions) {
name = name || "";
name = name.replace(/^\s*/, "");
name = name.replace(/\s*$/, "");
if (name.length === 0) throw new TypeError("A name for the custom event must be provided");
for (const key in dimensions) if (typeof key !== "string" || typeof dimensions[key] !== "string") throw new TypeError("track() dimensions expects keys and values of type \"string\".");
return CoreManager.getAnalyticsController().track(name, dimensions);
}
CoreManager.setAnalyticsController({ track(name, dimensions) {
const path = "events/" + name;
return CoreManager.getRESTController().request("POST", path, { dimensions });
} });
//#endregion
//#region src/isRevocableSession.ts
function isRevocableSession(token) {
return token.indexOf("r:") > -1;
}
//#endregion
//#region src/ParseUser.ts
var CURRENT_USER_KEY = "currentUser";
var canUseCurrentUser = !CoreManager.get("IS_NODE");
var currentUserCacheMatchesDisk = false;
var currentUserCache = null;
var authProviders = {};
/**
* <p>A Parse.User object is a local representation of a user persisted to the
* Parse cloud. This class is a subclass of a Parse.Object, and retains the
* same functionality of a Parse.Object, but also extends it with various
* user specific methods, like authentication, signing up, and validation of
* uniqueness.</p>
*
* @alias Parse.User
* @augments Parse.Object
*/
var ParseUser = class ParseUser extends ParseObject {
/**
* @param {object} attributes The initial set of data to store in the user.
*/
constructor(attributes) {
super("_User");
if (attributes && typeof attributes === "object") try {
this.set(attributes || {});
} catch (_) {
throw new Error("Can't create an invalid Parse User");
}
}
/**
* Request a revocable session token to replace the older style of token.
*
* @param {object} options
* Valid options are:<ul>
* <li>useMasterKey: In Cloud Code and Node only, causes the Master Key to
* be used for this request.
* </ul>
* @returns {Promise} A promise that is resolved when the replacement
* token has been fetched.
*/
_upgradeToRevocableSession(options) {
const upgradeOptions = ParseObject._getRequestOptions(options);
return CoreManager.getUserController().upgradeToRevocableSession(this, upgradeOptions);
}
/**
* Parse allows you to link your users with {@link https://docs.parseplatform.org/parse-server/guide/#oauth-and-3rd-party-authentication 3rd party authentication}, enabling
* your users to sign up or log into your application using their existing identities.
* Since 2.9.0
*
* @see {@link https://docs.parseplatform.org/js/guide/#linking-users Linking Users}
* @param {string | AuthProvider} provider Name of auth provider or {@link https://parseplatform.org/Parse-SDK-JS/api/master/AuthProvider.html AuthProvider}
* @param {object} options
* @param {object} [options.authData] AuthData to link with
* <ul>
* <li>If provider is string, options is {@link http://docs.parseplatform.org/parse-server/guide/#supported-3rd-party-authentications authData}
* <li>If provider is AuthProvider, options is saveOpts
* </ul>
* @param {object} saveOpts useMasterKey / sessionToken
* @returns {Promise} A promise that is fulfilled with the user is linked
*/
linkWith(provider, options, saveOpts = {}) {
saveOpts.sessionToken = saveOpts.sessionToken || this.getSessionToken() || "";
let authType;
if (typeof provider === "string") {
authType = provider;
if (authProviders[provider]) provider = authProviders[provider];
else {
const authProvider = {
restoreAuthentication() {
return true;
},
getAuthType() {
return authType;
}
};
authProviders[authProvider.getAuthType()] = authProvider;
provider = authProvider;
}
} else authType = provider.getAuthType();
if (options && Object.hasOwn(options, "authData")) {
const authData = this.get("authData") || {};
if (typeof authData !== "object") throw new Error("Invalid type: authData field should be an object");
authData[authType] = options.authData;
const oldAnonymousData = authData.anonymous;
this.stripAnonymity();
return CoreManager.getUserController().linkWith(this, authData, saveOpts).catch((e) => {
delete authData[authType];
this.restoreAnonimity(oldAnonymousData);
throw e;
});
} else return new Promise((resolve, reject) => {
provider.authenticate({
success: (provider, result) => {
const opts = {};
opts.authData = result;
this.linkWith(provider, opts, saveOpts).then(() => {
resolve(this);
}, (error) => {
reject(error);
});
},
error: (_provider, error) => {
reject(error);
}
});
});
}
/**
* @param provider
* @param options
* @param {object} [options.authData]
* @param saveOpts
* @deprecated since 2.9.0 see {@link https://parseplatform.org/Parse-SDK-JS/api/master/Parse.User.html#linkWith linkWith}
* @returns {Promise}
*/
_linkWith(provider, options, saveOpts = {}) {
return this.linkWith(provider, options, saveOpts);
}
/**
* Synchronizes auth data for a provider (e.g. puts the access token in the
* right place to be used by the Facebook SDK).
*
* @param provider
*/
_synchronizeAuthData(provider) {
if (!this.isCurrent() || !provider) return;
let authType;
if (typeof provider === "string") {
authType = provider;
provider = authProviders[authType];
} else authType = provider.getAuthType();
const authData = this.get("authData");
if (!provider || !authData || typeof authData !== "object") return;
if (!provider.restoreAuthentication(authData[authType])) this._unlinkFrom(provider);
}
/**
* Synchronizes authData for all providers.
*/
_synchronizeAllAuthData() {
const authData = this.get("authData");
if (typeof authData !== "object") return;
for (const key in authData) this._synchronizeAuthData(key);
}
/**
* Removes null values from authData (which exist temporarily for unlinking)
*/
_cleanupAuthData() {
if (!this.isCurrent()) return;
const authData = this.get("authData");
if (typeof authData !== "object") return;
for (const key in authData) if (!authData[key]) delete authData[key];
}
/**
* Unlinks a user from a service.
*
* @param {string | AuthProvider} provider Name of auth provider or {@link https://parseplatform.org/Parse-SDK-JS/api/master/AuthProvider.html AuthProvider}
* @param {object} options MasterKey / SessionToken
* @returns {Promise} A promise that is fulfilled when the unlinking
* finishes.
*/
_unlinkFrom(provider, options) {
return this.linkWith(provider, { authData: null }, options).then(() => {
this._synchronizeAuthData(provider);
return Promise.resolve(this);
});
}
/**
* Checks whether a user is linked to a service.
*
* @param {object} provider service to link to
* @returns {boolean} true if link was successful
*/
_isLinked(provider) {
let authType;
if (typeof provider === "string") authType = provider;
else authType = provider.getAuthType();
const authData = this.get("authData") || {};
if (typeof authData !== "object") return false;
return !!authData[authType];
}
/**
* Deauthenticates all providers.
*/
_logOutWithAll() {
const authData = this.get("authData");
if (typeof authData !== "object") return;
for (const key in authData) this._logOutWith(key);
}
/**
* Deauthenticates a single provider (e.g. removing access tokens from the
* Facebook SDK).
*
* @param {object} provider service to logout of
*/
_logOutWith(provider) {
if (!this.isCurrent()) return;
if (typeof provider === "string") provider = authProviders[provider];
if (provider && provider.deauthenticate) provider.deauthenticate();
}
/**
* Class instance method used to maintain specific keys when a fetch occurs.
* Used to ensure that the session token is not lost.
*
* @returns {object} sessionToken
*/
_preserveFieldsOnFetch() {
return { sessionToken: this.get("sessionToken") };
}
/**
* Returns true if <code>current</code> would return this user.
*
* @returns {boolean} true if user is cached on disk
*/
isCurrent() {
const current = ParseUser.current();
return !!current && current.id === this.id;
}
/**
* Returns true if <code>current</code> would return this user.
*
* @returns {Promise<boolean>} true if user is cached on disk
*/
async isCurrentAsync() {
const current = await ParseUser.currentAsync();
return !!current && current.id === this.id;
}
stripAnonymity() {
const authData = this.get("authData");
if (authData && typeof authData === "object" && Object.hasOwn(authData, "anonymous")) authData.anonymous = null;
}
restoreAnonimity(anonymousData) {
if (anonymousData) {
const authData = this.get("authData");
authData.anonymous = anonymousData;
}
}
/**
* Returns get("username").
*
* @returns {string}
*/
getUsername() {
const username = this.get("username");
if (username == null || typeof username === "string") return username;
return "";
}
/**
* Calls set("username", username, options) and returns the result.
*
* @param {string} username
*/
setUsername(username) {
this.stripAnonymity();
this.set("username", username);
}
/**
* Calls set("password", password, options) and returns the result.
*
* @param {string} password User's Password
*/
setPassword(password) {
this.set("password", password);
}
/**
* Returns get("email").
*
* @returns {string} User's Email
*/
getEmail() {
const email = this.get("email");
if (email == null || typeof email === "string") return email;
return "";
}
/**
* Calls set("email", email) and returns the result.
*
* @param {string} email
* @returns {boolean}
*/
setEmail(email) {
return this.set("email", email);
}
/**
* Returns the session token for this user, if the user has been logged in,
* or if it is the result of a query with the master key. Otherwise, returns
* undefined.
*
* @returns {string} the session token, or undefined
*/
getSessionToken() {
const token = this.get("sessionToken");
if (token == null || typeof token === "string") return token;
return "";
}
/**
* Checks whether this user is the current user and has been authenticated.
*
* @returns {boolean} whether this user is the current user and is logged in.
*/
authenticated() {
const current = ParseUser.current();
return !!this.get("sessionToken") && !!current && current.id === this.id;
}
/**
* Signs up a new user. You should call this instead of save for
* new Parse.Users. This will create a new Parse.User on the server, and
* also persist the session on disk so that you can access the user using
* <code>current</code>.
*
* <p>A username and password must be set before calling signUp.</p>
*
* @param {object} attrs Extra fields to set on the new user, or null.
* @param {object} options
* Valid options are:<ul>
* <li>useMasterKey: In Cloud Code and Node only, causes the Master Key to
* be used for this request.
* <li>installationId: the installationId which made the request
* <li>context: A dictionary that is accessible in Cloud Code `beforeLogin` and `afterLogin` triggers.
* </ul>
* @returns {Promise} A promise that is fulfilled when the signup
* finishes.
*/
signUp(attrs, options) {
const signupOptions = ParseObject._getRequestOptions(options);
return CoreManager.getUserController().signUp(this, attrs, signupOptions);
}
/**
* Logs in a Parse.User. On success, this saves the session to disk,
* so you can retrieve the currently logged in user using
* <code>current</code>.
*
* <p>A username and password must be set before calling logIn.</p>
*
* @param {object} options
* Valid options are:<ul>
* <li>useMasterKey: In Cloud Code and Node only, causes the Master Key to
* be used for this request.
* <li>usePost: Use POST method to make the request (default: true)
* <li>installationId: the installationId which made the request
* <li>context: A dictionary that is accessible in Cloud Code `beforeLogin` and `afterLogin` triggers.
* </ul>
* @returns {Promise} A promise that is fulfilled with the user when
* the login is complete.
*/
logIn(options = {}) {
const loginOptions = ParseObject._getRequestOptions(options);
if (!Object.hasOwn(loginOptions, "usePost")) loginOptions.usePost = true;
return CoreManager.getUserController().logIn(this, loginOptions);
}
/**
* Wrap the default save behavior with functionality to save to local
* storage if this is current user.
*
* @param {...any} args
* @returns {Promise}
*/
async save(...args) {
await super.save.apply(this, args);
if (await this.isCurrentAsync()) return CoreManager.getUserController().updateUserOnDisk(this);
return this;
}
/**
* Wrap the default destroy behavior with functionality that logs out
* the current user when it is destroyed
*
* @param {...any} args
* @returns {Parse.User}
*/
async destroy(...args) {
await super.destroy.apply(this, args);
if (await this.isCurrentAsync()) return CoreManager.getUserController().removeUserFromDisk();
return this;
}
/**
* Wrap the default fetch behavior with functionality to save to local
* storage if this is current user.
*
* @param {...any} args
* @returns {Parse.User}
*/
async fetch(...args) {
await super.fetch.apply(this, args);
if (await this.isCurrentAsync()) return CoreManager.getUserController().updateUserOnDisk(this);
return this;
}
/**
* Wrap the default fetchWithInclude behavior with functionality to save to local
* storage if this is current user.
*
* @param {...any} args
* @returns {Parse.User}
*/
async fetchWithInclude(...args) {
await super.fetchWithInclude.apply(this, args);
if (await this.isCurrentAsync()) return CoreManager.getUserController().updateUserOnDisk(this);
return this;
}
/**
* Verify whether a given password is the password of the current user.
*
* @param {string} password The password to be verified.
* @param {object} options The options.
* @param {boolean} [options.ignoreEmailVerification] Set to `true` to bypass email verification and verify
* the password regardless of whether the email has been verified. This requires the master key.
* @returns {Promise} A promise that is fulfilled with a user when the password is correct.
*/
verifyPassword(password, options) {
const username = this.getUsername() || "";
return ParseUser.verifyPassword(username, password, options);
}
static readOnlyAttributes() {
return ["sessionToken"];
}
/**
* Adds functionality to the existing Parse.User class.
*
* @param {object} protoProps A set of properties to add to the prototype
* @param {object} classProps A set of static properties to add to the class
* @static
* @returns {Parse.User} The newly extended Parse.User class
*/
static extend(protoProps, classProps) {
if (protoProps) {
for (const prop in protoProps) if (prop !== "className") Object.defineProperty(ParseUser.prototype, prop, {
value: protoProps[prop],
enumerable: false,
writable: true,
configurable: true
});
}
if (classProps) {
for (const prop in classProps) if (prop !== "className") Object.defineProperty(ParseUser, prop, {
value: classProps[prop],
enumerable: false,
writable: true,
configurable: true
});
}
return ParseUser;
}
/**
* Retrieves the currently logged in ParseUser with a valid session,
* either from memory or localStorage, if necessary.
*
* @static
* @returns {Parse.User} The currently logged in Parse.User.
*/
static current() {
if (!canUseCurrentUser) return null;
return CoreManager.getUserController().currentUser();
}
/**
* Retrieves the currently logged in ParseUser from asynchronous Storage.
*
* @static
* @returns {Promise} A Promise that is resolved with the currently
* logged in Parse User
*/
static currentAsync() {
if (!canUseCurrentUser) return Promise.resolve(null);
return CoreManager.getUserController().currentUserAsync();
}
/**
* Signs up a new user with a username (or email) and password.
* This will create a new Parse.User on the server, and also persist the
* session in localStorage so that you can access the user using
* {@link #current}.
*
* @param {string} username The username (or email) to sign up with.
* @param {string} password The password to sign up with.
* @param {object} attrs Extra fields to set on the new user.
* @param {object} options
* @static
* @returns {Promise} A promise that is fulfilled with the user when
* the signup completes.
*/
static signUp(username, password, attrs, options) {
attrs = attrs || {};
attrs.username = username;
attrs.password = password;
return new this(attrs).signUp({}, options);
}
/**
* Logs in a user with a username (or email) and password. On success, this
* saves the session to disk, so you can retrieve the currently logged in
* user using <code>current</code>.
*
* @param {string} username The username (or email) to log in with.
* @param {string} password The password to log in with.
* @param {object} options
* @static
* @returns {Promise} A promise that is fulfilled with the user when
* the login completes.
*/
static logIn(username, password, options) {
if (typeof username !== "string") return Promise.reject(new ParseError(ParseError.OTHER_CAUSE, "Username must be a string."));
else if (typeof password !== "string") return Promise.reject(new ParseError(ParseError.OTHER_CAUSE, "Password must be a string."));
const user = new this();
user._finishFetch({
username,
password
});
return user.logIn(options);
}
/**
* Logs in a user with a username (or email) and password, and authData. On success, this
* saves the session to disk, so you can retrieve the currently logged in
* user using <code>current</code>.
*
* @param {string} username The username (or email) to log in with.
* @param {string} password The password to log in with.
* @param {object} authData The authData to log in with.
* @param {object} options
* @static
* @returns {Promise} A promise that is fulfilled with the user when
* the login completes.
*/
static logInWithAdditionalAuth(username, password, authData, options) {
if (typeof username !== "string") return Promise.reject(new ParseError(ParseError.OTHER_CAUSE, "Username must be a string."));
if (typeof password !== "string") return Promise.reject(new ParseError(ParseError.OTHER_CAUSE, "Password must be a string."));
if (Object.prototype.toString.call(authData) !== "[object Object]") return Promise.reject(new ParseError(ParseError.OTHER_CAUSE, "Auth must be an object."));
const user = new this();
user._finishFetch({
username,
password,
authData
});
return user.logIn(options);
}
/**
* Logs in a user with an objectId. On success, this saves the session
* to disk, so you can retrieve the currently logged in user using
* <code>current</code>.
*
* @param {string} userId The objectId for the user.
* @static
* @returns {Promise} A promise that is fulfilled with the user when
* the login completes.
*/
static loginAs(userId) {
if (!userId) throw new ParseError(ParseError.USERNAME_MISSING, "Cannot log in as user with an empty user id");
const controller = CoreManager.getUserController();
const user = new this();
return controller.loginAs(user, userId);
}
/**
* Logs in a user with a session token. On success, this saves the session
* to disk, so you can retrieve the currently logged in user using
* <code>current</code>.
*
* @param {string} sessionToken The sessionToken to log in with.
* @param {object} options
* @param {boolean} [options.useMasterKey]
* @static
* @returns {Promise} A promise that is fulfilled with the user when
* the login completes.
*/
static become(sessionToken, options) {
if (!canUseCurrentUser) throw new Error("It is not memory-safe to become a user in a server environment");
const becomeOptions = ParseObject._getRequestOptions(options);
becomeOptions.sessionToken = sessionToken;
const controller = CoreManager.getUserController();
const user = new this();
return controller.become(user, becomeOptions);
}
/**
* Retrieves a user with a session token.
*
* @param {string} sessionToken The sessionToken to get user with.
* @param {object} options
* @param {boolean} [options.useMasterKey]
* @static
* @returns {Promise} A promise that is fulfilled with the user is fetched.
*/
static me(sessionToken, options) {
const controller = CoreManager.getUserController();
const meOptions = ParseObject._getRequestOptions(options);
meOptions.sessionToken = sessionToken;
const user = new this();
return controller.me(user, meOptions);
}
/**
* Logs in a user with a session token. On success, this saves the session
* to disk, so you can retrieve the currently logged in user using
* <code>current</code>. If there is no session token the user will not logged in.
*
* @param {object} userJSON The JSON map of the User's data
* @static
* @returns {Promise} A promise that is fulfilled with the user when
* the login completes.
*/
static hydrate(userJSON) {
const controller = CoreManager.getUserController();
const user = new this();
return controller.hydrate(user, userJSON);
}
/**
* Static version of {@link https://parseplatform.org/Parse-SDK-JS/api/master/Parse.User.html#linkWith linkWith}
*
* @param provider
* @param options
* @param {object} [options.authData]
* @param saveOpts
* @static
* @returns {Promise}
*/
static logInWith(provider, options, saveOpts) {
return new this().linkWith(provider, options, saveOpts);
}
/**
* Logs out the currently logged in user session. This will remove the
* session from disk, log out of linked services, and future calls to
* <code>current</code> will return <code>null</code>.
*
* @param {object} options
* @static
* @returns {Promise} A promise that is resolved when the session is
* destroyed on the server.
*/
static logOut(options) {
return CoreManager.getUserController().logOut(options);
}
/**
* Requests a password reset email to be sent to the specified email address
* associated with the user account. This email allows the user to securely
* reset their password on the Parse site.
*
* @param {string} email The email address associated with the user that
* forgot their password.
* @param {object} options
* Valid options are:<ul>
* <li>useMasterKey: In Cloud Code and Node only, causes the Master Key to
* be used for this request.
* </ul>
* @static
* @returns {Promise}
*/
static requestPasswordReset(email, options) {
const requestOptions = ParseObject._getRequestOptions(options);
return CoreManager.getUserController().requestPasswordReset(email, requestOptions);
}
/**
* Request an email verification.
*
* @param {string} email The email address associated with the user that
* needs to verify their email.
* @param {object} options
* Valid options are:<ul>
* <li>useMasterKey: In Cloud Code and Node only, causes the Master Key to
* be used for this request.
* </ul>
* @static
* @returns {Promise}
*/
static requestEmailVerification(email, options) {
const requestOptions = ParseObject._getRequestOptions(options);
return CoreManager.getUserController().requestEmailVerification(email, requestOptions);
}
/**
* Verify whether a given password is the password of the current user.
* @static
*
* @param {string} username The username of the user whose password should be verified.
* @param {string} password The password to be verified.
* @param {object} options The options.
* @param {boolean} [options.ignoreEmailVerification] Set to `true` to bypass email verification and verify
* the password regardless of whether the email has been verified. This requires the master key.
* @returns {Promise} A promise that is fulfilled with a user when the password is correct.
*/
static verifyPassword(username, password, options) {
if (typeof username !== "string") return Promise.reject(new ParseError(ParseError.OTHER_CAUSE, "Username must be a string."));
if (typeof password !== "string") return Promise.reject(new ParseError(ParseError.OTHER_CAUSE, "Password must be a string."));
return CoreManager.getUserController().verifyPassword(username, password, options || {});
}
/**
* Allow someone to define a custom User class without className
* being rewritten to _User. The default behavior is to rewrite
* User to _User for legacy reasons. This allows developers to
* override that behavior.
*
* @param {boolean} isAllowed Whether or not to allow custom User class
* @static
*/
static allowCustomUserClass(isAllowed) {
CoreManager.set("PERFORM_USER_REWRITE", !isAllowed);
}
/**
* Allows a legacy application to start using revocable sessions. If the
* current session token is not revocable, a request will be made for a new,
* revocable session.
* It is not necessary to call this method from cloud code unless you are
* handling user signup or login from the server side. In a cloud code call,
* this function will not attempt to upgrade the current token.
*
* @param {object} options
* @static
* @returns {Promise} A promise that is resolved when the process has
* completed. If a replacement session token is requested, the promise
* will be resolved after a new token has been fetched.
*/
static enableRevocableSession(options) {
options = options || {};
CoreManager.set("FORCE_REVOCABLE_SESSION", true);
if (canUseCurrentUser) {
const current = ParseUser.current();
if (current) return current._upgradeToRevocableSession(options);
}
return Promise.resolve();
}
/**
* Enables the use of become or the current user in a server
* environment. These features are disabled by default, since they depend on
* global objects that are not memory-safe for most servers.
*
* @static
*/
static enableUnsafeCurrentUser() {
canUseCurrentUser = true;
}
/**
* Disables the use of become or the current user in any environment.
* These features are disabled on servers by default, since they depend on
* global objects that are not memory-safe for most servers.
*
* @static
*/
static disableUnsafeCurrentUser() {
canUseCurrentUser = false;
}
/**
* When registering users with {@link https://parseplatform.org/Parse-SDK-JS/api/master/Parse.User.html#linkWith linkWith} a basic auth provider
* is automatically created for you.
*
* For advanced authentication, you can register an Auth provider to
* implement custom authentication, deauthentication.
*
* @param provider
* @see {@link https://parseplatform.org/Parse-SDK-JS/api/master/AuthProvider.html AuthProvider}
* @see {@link https://docs.parseplatform.org/js/guide/#custom-authentication-module Custom Authentication Module}
* @static
*/
static _registerAuthenticationProvider(provider) {
authProviders[provider.getAuthType()] = provider;
ParseUser.currentAsync().then((current) => {
if (current) current._synchronizeAuthData(provider.getAuthType());
});
}
/**
* @param provider
* @param options
* @param {object} [options.authData]
* @param saveOpts
* @deprecated since 2.9.0 see {@link https://parseplatform.org/Parse-SDK-JS/api/master/Parse.User.html#logInWith logInWith}
* @static
* @returns {Promise}
*/
static _logInWith(provider, options, saveOpts) {
return new this().linkWith(provider, options, saveOpts);
}
static _clearCache() {
currentUserCache = null;
currentUserCacheMatchesDisk = false;
}
static _setCurrentUserCache(user) {
currentUserCache = user;
}
};
ParseObject.registerSubclass("_User", ParseUser);
var DefaultController = {
updateUserOnDisk(user) {
const path = Storage.generatePath(CURRENT_USER_KEY);
const json = user.toJSON();
delete json.password;
json.className = "_User";
let userData = JSON.stringify(json);
if (CoreManager.get("ENCRYPTED_USER")) userData = CoreManager.getCryptoController().encrypt(json, CoreManager.get("ENCRYPTED_KEY"));
return Storage.setItemAsync(path, userData).then(() => {
return user;
});
},
removeUserFromDisk() {
const path = Storage.generatePath(CURRENT_USER_KEY);
currentUserCacheMatchesDisk = true;
currentUserCache = null;
return Storage.removeItemAsync(path);
},
setCurrentUser(user) {
currentUserCache = user;
user._cleanupAuthData();
user._synchronizeAllAuthData();
return DefaultController.updateUserOnDisk(user);
},
currentUser() {
if (currentUserCache) return currentUserCache;
if (currentUserCacheMatchesDisk) return null;
if (Storage.async()) throw new Error("Cannot call currentUser() when using a platform with an async storage system. Call currentUserAsync() instead.");
const path = Storage.generatePath(CURRENT_USER_KEY);
let userData = Storage.getItem(path);
currentUserCacheMatchesDisk = true;
if (!userData) {
currentUserCache = null;
return null;
}
if (CoreManager.get("ENCRYPTED_USER")) userData = CoreManager.getCryptoController().decrypt(userData, CoreManager.get("ENCRYPTED_KEY"));
userData = JSON.parse(userData);
if (!userData.className) userData.className = "_User";
if (userData._id) {
if (userData.objectId !== userData._id) userData.objectId = userData._id;
delete userData._id;
}
if (userData._sessionToken) {
userData.sessionToken = userData._sessionToken;
delete userData._sessionToken;
}
const current = ParseObject.fromJSON(userData);
currentUserCache = current;
current._synchronizeAllAuthData();
return current;
},
currentUserAsync() {
if (currentUserCache) return Promise.resolve(currentUserCache);
if (currentUserCacheMatchesDisk) return Promise.resolve(null);
const path = Storage.generatePath(CURRENT_USER_KEY);
return Storage.getItemAsync(path).then((userData) => {
currentUserCacheMatchesDisk = true;
if (!userData) {
currentUserCache = null;
return Promise.resolve(null);
}
if (CoreManager.get("ENCRYPTED_USER")) userData = CoreManager.getCryptoController().decrypt(userData.toString(), CoreManager.get("ENCRYPTED_KEY"));
userData = JSON.parse(userData);
if (!userData.className) userData.className = "_User";
if (userData._id) {
if (userData.objectId !== userData._id) userData.objectId = userData._id;
delete userData._id;
}
if (userData._sessionToken) {
userData.sessionToken = userData._sessionToken;
delete userData._sessionToken;
}
const current = ParseObject.fromJSON(userData);
currentUserCache = current;
current._synchronizeAllAuthData();
return Promise.resolve(current);
});
},
signUp(user, attrs, options) {
const username = attrs && attrs.username || user.get("username");
const password = attrs && attrs.password || user.get("password");
if (!username || !username.length) return Promise.reject(new ParseError(ParseError.OTHER_CAUSE, "Cannot sign up user with an empty username."));
if (!password || !password.length) return Promise.reject(new ParseError(ParseError.OTHER_CAUSE, "Cannot sign up user with an empty password."));
return user.save(attrs, options).then(() => {
user._finishFetch({ password: void 0 });
if (canUseCurrentUser) return DefaultController.setCurrentUser(user);
return user;
});
},
logIn(user, options) {
const RESTController = CoreManager.getRESTController();
const stateController = CoreManager.getObjectStateController();
const auth = {
username: user.get("username"),
password: user.get("password"),
authData: user.get("authData")
};
return RESTController.request(options.usePost ? "POST" : "GET", "login", auth, options).then((response) => {
user._migrateId(response.objectId);
user._setExisted(true);
stateController.setPendingOp(user._getStateIdentifier(), "username", void 0);
stateController.setPendingOp(user._getStateIdentifier(), "password", void 0);
response.password = void 0;
user._finishFetch(response);
if (!canUseCurrentUser) return Promise.resolve(user);
return DefaultController.setCurrentUser(user);
});
},
loginAs(user, userId) {
return CoreManager.getRESTController().request("POST", "loginAs", { userId }, { useMasterKey: true }).then((response) => {
user._finishFetch(response);
user._setExisted(true);
if (!canUseCurrentUser) return Promise.resolve(user);
return DefaultController.setCurrentUser(user);
});
},
become(user, options) {
return CoreManager.getRESTController().request("GET", "users/me", {}, options).then((response) => {
user._finishFetch(response);
user._setExisted(true);
return DefaultController.setCurrentUser(user);
});
},
hydrate(user, userJSON) {
user._finishFetch(userJSON);
user._setExisted(true);
if (userJSON.sessionToken && canUseCurrentUser) return DefaultController.setCurrentUser(user);
else return Promise.resolve(user);
},
me(user, options) {
return CoreManager.getRESTController().request("GET", "users/me", {}, options).then((response) => {
user._finishFetch(response);
user._setExisted(true);
return user;
});
},
logOut(options) {
const RESTController = CoreManager.getRESTController();
if (options?.sessionToken) return RESTController.request("POST", "logout", {}, options);
return DefaultController.currentUserAsync().then((currentUser) => {
const path = Storage.generatePath(CURRENT_USER_KEY);
let promise = Storage.removeItemAsync(path);
if (currentUser !== null) {
const currentSession = currentUser.getSessionToken();
if (currentSession && isRevocableSession(currentSession)) promise = promise.then(() => {
return RESTController.request("POST", "logout", {}, { sessionToken: currentSession });
});
currentUser._logOutWithAll();
currentUser._finishFetch({ sessionToken: void 0 });
}
currentUserCacheMatchesDisk = true;
currentUserCache = null;
return promise;
});
},
requestPasswordReset(email, options) {
return CoreManager.getRESTController().request("POST", "requestPasswordReset", { email }, options);
},
async upgradeToRevocableSession(user, options) {
const token = user.getSessionToken();
if (!token) return Promise.reject(new ParseError(ParseError.SESSION_MISSING, "Cannot upgrade a user with no session token"));
options.sessionToken = token;
const result = await CoreManager.getRESTController().request("POST", "upgradeToRevocableSession", {}, options);
user._finishFetch({ sessionToken: result?.sessionToken || "" });
if (await user.isCurrentAsync()) return DefaultController.setCurrentUser(user);
return Promise.resolve(user);
},
linkWith(user, authData, options) {
return user.save({ authData }, options).then(() => {
if (canUseCurrentUser) return DefaultController.setCurrentUser(user);
return user;
});
},
verifyPassword(username, password, options) {
const RESTController = CoreManager.getRESTController();
const data = {
username,
password,
...options.ignoreEmailVerification !== void 0 && { ignoreEmailVerification: options.ignoreEmailVerification }
};
return RESTController.request("GET", "verifyPassword", data, options);
},
requestEmailVerification(email, options) {
return CoreManager.getRESTController().request("POST", "verificationEmailRequest", { email }, options);
}
};
CoreManager.setParseUser(ParseUser);
CoreManager.setUserController(DefaultController);
//#endregion
//#region src/AnonymousUtils.ts
var registered = false;
/**
* Provides utility functions for working with Anonymously logged-in users. <br />
* Anonymous users have some unique characteristics:
* <ul>
* <li>Anonymous users don't need a user name or password.</li>
* <ul>
* <li>Once logged out, an anonymous user cannot be recovered.</li>
* </ul>
* <li>signUp converts an anonymous user to a standard user with the given username and password.</li>
* <ul>
* <li>Data associated with the anonymous user is retained.</li>
* </ul>
* <li>logIn switches users without converting the anonymous user.</li>
* <ul>
* <li>Data associated with the anonymous user will be lost.</li>
* </ul>
* <li>Service logIn (e.g. Facebook, Twitter) will attempt to convert
* the anonymous user into a standard user by linking it to the service.</li>
* <ul>
* <li>If a user already exists that is linked to the service, it will instead switch to the existing user.</li>
* </ul>
* <li>Service linking (e.g. Facebook, Twitter) will convert the anonymous user
* into a standard user by linking it to the service.</li>
* </ul>
*
* @class Parse.AnonymousUtils
* @static
*/
var AnonymousUtils = {
/**
* Gets whether the user has their account linked to anonymous user.
*
* @function isLinked
* @name Parse.AnonymousUtils.isLinked
* @param {Parse.User} user User to check for.
* The user must be logged in on this device.
* @returns {boolean} <code>true</code> if the user has their account
* linked to an anonymous user.
* @static
*/
isLinked(user) {
const provider = this._getAuthProvider();
return user._isLinked(provider.getAuthType());
},
/**
* Logs in a user Anonymously.
*
* @function logIn
* @name Parse.AnonymousUtils.logIn
* @param {object} options MasterKey / SessionToken.
* @returns {Promise} Logged in user
* @static
*/
logIn(options) {
const provider = this._getAuthProvider();
return ParseUser.logInWith(provider.getAuthType(), provider.getAuthData(), options);
},
/**
* Links Anonymous User to an existing PFUser.
*
* @function link
* @name Parse.AnonymousUtils.link
* @param {Parse.User} user User to link. This must be the current user.
* @param {object} options MasterKey / SessionToken.
* @returns {Promise} Linked with User
* @static
*/
link(user, options) {
const provider = this._getAuthProvider();
return user.linkWith(provider.getAuthType(), provider.getAuthData(), options);
},
/**
* Returns true if Authentication Provider has been registered for use.
*
* @function isRegistered
* @name Parse.AnonymousUtils.isRegistered
* @returns {boolean}
* @static
*/
isRegistered() {
return registered;
},
_getAuthProvider() {
const provider = {
restoreAuthentication() {
return true;
},
getAuthType() {
return "anonymous";
},
getAuthData() {
return { authData: { id: uuid() } };
}
};
if (!registered) {
ParseUser._registerAuthenticationProvider(provider);
registered = true;
}
return provider;
}
};
//#endregion
//#region src/Cloud.ts
var Cloud_exports = /* @__PURE__ */ __exportAll({
getJobStatus: () => getJobStatus,
getJobsData: () => getJobsData,
run: () => run,
startJob: () => startJob
});
function run(name, data, options) {
if (typeof name !== "string" || name.length === 0) throw new TypeError("Cloud function name must be a string.");
const requestOptions = ParseObject._getRequestOptions(options);
return CoreManager.getCloudController().run(name, data, requestOptions);
}
/**
* Gets data for the current set of cloud jobs.
*
* @function getJobsData
* @name Parse.Cloud.getJobsData
* @returns {Promise} A promise that will be resolved with the result
* of the function.
*/
function getJobsData() {
return CoreManager.getCloudController().getJobsData({ useMasterKey: true });
}
/**
* Starts a given cloud job, which will process asynchronously.
*
* @function startJob
* @name Parse.Cloud.startJob
* @param {string} name The function name.
* @param {object} data The parameters to send to the cloud function.
* @returns {Promise} A promise that will be resolved with the jobStatusId
* of the job.
*/
function startJob(name, data) {
if (typeof name !== "string" || name.length === 0) throw new TypeError("Cloud job name must be a string.");
return CoreManager.getCloudController().startJob(name, data, { useMasterKey: true });
}
/**
* Gets job status by Id
*
* @function getJobStatus
* @name Parse.Cloud.getJobStatus
* @param {string} jobStatusId The Id of Job Status.
* @returns {Parse.Object} Status of Job.
*/
function getJobStatus(jobStatusId) {
return new ParseQuery("_JobStatus").get(jobStatusId, { useMasterKey: true });
}
CoreManager.setCloudController({
run(name, data, options) {
const RESTController = CoreManager.getRESTController();
const payload = encode_default(data, true);
return RESTController.request("POST", "functions/" + name, payload, options).then((res) => {
if (typeof res === "object" && Object.keys(res).length > 0 && !Object.hasOwn(res, "result")) throw new ParseError(ParseError.INVALID_JSON, "The server returned an invalid response.");
const decoded = decode(res);
if (decoded && Object.hasOwn(decoded, "result")) return Promise.resolve(decoded.result);
return Promise.resolve(void 0);
});
},
getJobsData(options) {
return CoreManager.getRESTController().request("GET", "cloud_code/jobs/data", null, options);
},
async startJob(name, data, options) {
const RESTController = CoreManager.getRESTController();
const payload = encode_default(data, true);
options.returnStatus = true;
return (await RESTController.request("POST", "jobs/" + name, payload, options))._headers?.["X-Parse-Job-Status-Id"];
}
});
//#endregion
//#region src/ParseRole.ts
/**
* Represents a Role on the Parse server. Roles represent groupings of
* Users for the purposes of granting permissions (e.g. specifying an ACL
* for an Object). Roles are specified by their sets of child users and
* child roles, all of which are granted any permissions that the parent
* role has.
*
* <p>Roles must have a name (which cannot be changed after creation of the
* role), and must specify an ACL.</p>
*
* @alias Parse.Role
* @augments Parse.Object
*/
var ParseRole = class extends ParseObject {
/**
* @param {string} name The name of the Role to create.
* @param {Parse.ACL} acl The ACL for this role. Roles must have an ACL.
* A Parse.Role is a local representation of a role persisted to the Parse
* cloud.
*/
constructor(name, acl) {
super("_Role");
if (typeof name === "string" && acl instanceof ParseACL) {
this.setName(name);
this.setACL(acl);
}
}
/**
* Gets the name of the role. You can alternatively call role.get("name")
*
* @returns {string} the name of the role.
*/
getName() {
const name = this.get("name");
if (name == null || typeof name === "string") return name;
return "";
}
/**
* Sets the name for a role. This value must be set before the role has
* been saved to the server, and cannot be set once the role has been
* saved.
*
* <p>
* A role's name can only contain alphanumeric characters, _, -, and
* spaces.
* </p>
*
* <p>This is equivalent to calling role.set("name", name)</p>
*
* @param {string} name The name of the role.
* @param {object} options Standard options object with success and error
* callbacks.
* @returns {Parse.Object} Returns the object, so you can chain this call.
*/
setName(name, options) {
this._validateName(name);
return this.set("name", name, options);
}
/**
* Gets the Parse.Relation for the Parse.Users that are direct
* children of this role. These users are granted any privileges that this
* role has been granted (e.g. read or write access through ACLs). You can
* add or remove users from the role through this relation.
*
* <p>This is equivalent to calling role.relation("users")</p>
*
* @returns {Parse.Relation} the relation for the users belonging to this
* role.
*/
getUsers() {
return this.relation("users");
}
/**
* Gets the Parse.Relation for the Parse.Roles that are direct
* children of this role. These roles' users are granted any privileges that
* this role has been granted (e.g. read or write access through ACLs). You
* can add or remove child roles from this role through this relation.
*
* <p>This is equivalent to calling role.relation("roles")</p>
*
* @returns {Parse.Relation} the relation for the roles belonging to this
* role.
*/
getRoles() {
return this.relation("roles");
}
_validateName(newName) {
if (typeof newName !== "string") throw new ParseError(ParseError.OTHER_CAUSE, "A role's name must be a String.");
if (!/^[0-9a-zA-Z\-_ ]+$/.test(newName)) throw new ParseError(ParseError.OTHER_CAUSE, "A role's name can be only contain alphanumeric characters, _, -, and spaces.");
}
validate(attrs, options) {
const isInvalid = super.validate(attrs, options);
if (isInvalid) return isInvalid;
if ("name" in attrs && attrs.name !== this.getName()) {
const newName = attrs.name;
if (this.id && this.id !== attrs.objectId) return new ParseError(ParseError.OTHER_CAUSE, "A role's name can only be set before it has been saved.");
try {
this._validateName(newName);
} catch (e) {
return e;
}
}
return false;
}
};
CoreManager.setParseRole(ParseRole);
ParseObject.registerSubclass("_Role", ParseRole);
//#endregion
//#region src/ParseCLP.ts
var PUBLIC_KEY = "*";
var VALID_PERMISSIONS = /* @__PURE__ */ new Map();
VALID_PERMISSIONS.set("get", {});
VALID_PERMISSIONS.set("find", {});
VALID_PERMISSIONS.set("count", {});
VALID_PERMISSIONS.set("create", {});
VALID_PERMISSIONS.set("update", {});
VALID_PERMISSIONS.set("delete", {});
VALID_PERMISSIONS.set("addField", {});
var VALID_PERMISSIONS_EXTENDED = /* @__PURE__ */ new Map();
VALID_PERMISSIONS_EXTENDED.set("protectedFields", {});
/**
* Creates a new CLP.
* If no argument is given, the CLP has no permissions for anyone.
* If the argument is a Parse.User or Parse.Role, the CLP will have read and write
* permission for only that user or role.
* If the argument is any other JSON object, that object will be interpretted
* as a serialized CLP created with toJSON().
*
* <p>A CLP, or Class Level Permissions can be added to any
* <code>Parse.Schema</code> to restrict access to only a subset of users
* of your application.</p>
*
* <p>
* For get/count/find/create/update/delete/addField using the following functions:
*
* Entity is type Parse.User or Parse.Role or string
* Role is type Parse.Role or Name of Parse.Role
*
* getGetRequiresAuthentication()
* setGetRequiresAuthentication(allowed: boolean)
* getGetPointerFields()
* setGetPointerFields(pointerFields: string[])
* getGetAccess(entity: Entity)
* setGetAccess(entity: Entity, allowed: boolean)
* getPublicGetAccess()
* setPublicGetAccess(allowed: boolean)
* getRoleGetAccess(role: Role)
* setRoleGetAccess(role: Role, allowed: boolean)
* getFindRequiresAuthentication()
* setFindRequiresAuthentication(allowed: boolean)
* getFindPointerFields()
* setFindPointerFields(pointerFields: string[])
* getFindAccess(entity: Entity)
* setFindAccess(entity: Entity, allowed: boolean)
* getPublicFindAccess()
* setPublicFindAccess(allowed: boolean)
* getRoleFindAccess(role: Role)
* setRoleFindAccess(role: Role, allowed: boolean)
* getCountRequiresAuthentication()
* setCountRequiresAuthentication(allowed: boolean)
* getCountPointerFields()
* setCountPointerFields(pointerFields: string[])
* getCountAccess(entity: Entity)
* setCountAccess(entity: Entity, allowed: boolean)
* getPublicCountAccess()
* setPublicCountAccess(allowed: boolean)
* getRoleCountAccess(role: Role)
* setRoleCountAccess(role: Role, allowed: boolean)
* getCreateRequiresAuthentication()
* setCreateRequiresAuthentication(allowed: boolean)
* getCreatePointerFields()
* setCreatePointerFields(pointerFields: string[])
* getCreateAccess(entity: Entity)
* setCreateAccess(entity: Entity, allowed: boolean)
* getPublicCreateAccess()
* setPublicCreateAccess(allowed: Boolean)
* getRoleCreateAccess(role: Role)
* setRoleCreateAccess(role: Role, allowed: boolean)
* getUpdateRequiresAuthentication()
* setUpdateRequiresAuthentication(allowed: boolean)
* getUpdatePointerFields()
* setUpdatePointerFields(pointerFields: string[])
* getUpdateAccess(entity: Entity)
* setUpdateAccess(entity: Entity, allowed: boolean)
* getPublicUpdateAccess()
* setPublicUpdateAccess(allowed: boolean)
* getRoleUpdateAccess(role: Role)
* setRoleUpdateAccess(role: Role, allowed: boolean)
* getDeleteRequiresAuthentication()
* setDeleteRequiresAuthentication(allowed: boolean)
* getDeletePointerFields()
* setDeletePointerFields(pointerFields: string[])
* getDeleteAccess(entity: Entity)
* setDeleteAccess(entity: Entity, allowed: boolean)
* getPublicDeleteAccess()
* setPublicDeleteAccess(allowed: boolean)
* getRoleDeleteAccess(role: Role)
* setRoleDeleteAccess(role: Role, allowed: boolean)
* getAddFieldRequiresAuthentication()
* setAddFieldRequiresAuthentication(allowed: boolean)
* getAddFieldPointerFields()
* setAddFieldPointerFields(pointerFields: string[])
* getAddFieldAccess(entity: Entity)
* setAddFieldAccess(entity: Entity, allowed: boolean)
* getPublicAddFieldAccess()
* setPublicAddFieldAccess(allowed: boolean)
* getRoleAddFieldAccess(role: Role)
* setRoleAddFieldAccess(role: Role, allowed: boolean)
* </p>
*
* @alias Parse.CLP
*/
var ParseCLP = class ParseCLP {
/**
* @param {(Parse.User | Parse.Role | object)} userId The user to initialize the CLP for
*/
constructor(userId) {
this.permissionsMap = {};
for (const [operation, group] of VALID_PERMISSIONS.entries()) {
this.permissionsMap[operation] = Object.assign({}, group);
const action = operation.charAt(0).toUpperCase() + operation.slice(1);
this[`get${action}RequiresAuthentication`] = function() {
return this._getAccess(operation, "requiresAuthentication");
};
this[`set${action}RequiresAuthentication`] = function(allowed) {
this._setAccess(operation, "requiresAuthentication", allowed);
};
this[`get${action}PointerFields`] = function() {
return this._getAccess(operation, "pointerFields", false);
};
this[`set${action}PointerFields`] = function(pointerFields) {
this._setArrayAccess(operation, "pointerFields", pointerFields);
};
this[`get${action}Access`] = function(entity) {
return this._getAccess(operation, entity);
};
this[`set${action}Access`] = function(entity, allowed) {
this._setAccess(operation, entity, allowed);
};
this[`getPublic${action}Access`] = function() {
return this[`get${action}Access`](PUBLIC_KEY);
};
this[`setPublic${action}Access`] = function(allowed) {
this[`set${action}Access`](PUBLIC_KEY, allowed);
};
this[`getRole${action}Access`] = function(role) {
return this[`get${action}Access`](this._getRoleName(role));
};
this[`setRole${action}Access`] = function(role, allowed) {
this[`set${action}Access`](this._getRoleName(role), allowed);
};
}
for (const [operation, group] of VALID_PERMISSIONS_EXTENDED.entries()) this.permissionsMap[operation] = Object.assign({}, group);
if (userId && typeof userId === "object") if (userId instanceof ParseUser) {
this.setReadAccess(userId, true);
this.setWriteAccess(userId, true);
} else if (userId instanceof ParseRole) {
this.setRoleReadAccess(userId, true);
this.setRoleWriteAccess(userId, true);
} else for (const permission in userId) {
const users = userId[permission];
const isValidPermission = !!VALID_PERMISSIONS.get(permission);
const isValidPermissionExtended = !!VALID_PERMISSIONS_EXTENDED.get(permission);
const isValidGroupPermission = ["readUserFields", "writeUserFields"].includes(permission);
if (typeof permission !== "string" || !(isValidPermission || isValidPermissionExtended || isValidGroupPermission)) throw new TypeError("Tried to create an CLP with an invalid permission type.");
if (isValidGroupPermission) if (users.every((pointer) => typeof pointer === "string")) {
this.permissionsMap[permission] = users;
continue;
} else throw new TypeError("Tried to create an CLP with an invalid permission value.");
for (const user in users) {
const allowed = users[user];
if (typeof allowed !== "boolean" && !isValidPermissionExtended && user !== "pointerFields") throw new TypeError("Tried to create an CLP with an invalid permission value.");
this.permissionsMap[permission][user] = allowed;
}
}
else if (typeof userId === "function") throw new TypeError("ParseCLP constructed with a function. Did you forget ()?");
}
/**
* Returns a JSON-encoded version of the CLP.
*
* @returns {object}
*/
toJSON() {
return { ...this.permissionsMap };
}
/**
* Returns whether this CLP is equal to another object
*
* @param other The other object to compare to
* @returns {boolean}
*/
equals(other) {
if (!(other instanceof ParseCLP)) return false;
const permissions = Object.keys(this.permissionsMap);
const otherPermissions = Object.keys(other.permissionsMap);
if (permissions.length !== otherPermissions.length) return false;
for (const permission in this.permissionsMap) {
if (!other.permissionsMap[permission]) return false;
const users = Object.keys(this.permissionsMap[permission]);
const otherUsers = Object.keys(other.permissionsMap[permission]);
if (users.length !== otherUsers.length) return false;
for (const user in this.permissionsMap[permission]) {
if (!other.permissionsMap[permission][user]) return false;
if (this.permissionsMap[permission][user] !== other.permissionsMap[permission][user]) return false;
}
}
return true;
}
_getRoleName(role) {
let name = role;
if (role instanceof ParseRole) name = role.getName();
if (typeof name !== "string") throw new TypeError("role must be a Parse.Role or a String");
return `role:${name}`;
}
_parseEntity(entity) {
let userId = entity;
if (userId instanceof ParseUser) {
userId = userId.id;
if (!userId) throw new Error("Cannot get access for a Parse.User without an id.");
} else if (userId instanceof ParseRole) userId = this._getRoleName(userId);
if (typeof userId !== "string") throw new TypeError("userId must be a string.");
return userId;
}
_setAccess(permission, userId, allowed) {
userId = this._parseEntity(userId);
if (typeof allowed !== "boolean") throw new TypeError("allowed must be either true or false.");
if (!this.permissionsMap[permission][userId]) if (!allowed) return;
else this.permissionsMap[permission][userId] = {};
if (allowed) this.permissionsMap[permission][userId] = true;
else delete this.permissionsMap[permission][userId];
}
_getAccess(permission, userId, returnBoolean = true) {
userId = this._parseEntity(userId);
const permissions = this.permissionsMap[permission][userId];
if (returnBoolean) {
if (!permissions) return false;
return !!this.permissionsMap[permission][userId];
}
return permissions;
}
_setArrayAccess(permission, userId, fields) {
userId = this._parseEntity(userId);
if (!this.permissionsMap[permission][userId]) this.permissionsMap[permission][userId] = [];
if (!fields || Array.isArray(fields) && fields.length === 0) delete this.permissionsMap[permission][userId];
else if (Array.isArray(fields) && fields.every((field) => typeof field === "string")) this.permissionsMap[permission][userId] = fields;
else throw new TypeError("fields must be an array of strings or undefined.");
}
_setGroupPointerPermission(operation, pointerFields) {
if (!this.permissionsMap[operation]) this.permissionsMap[operation] = [];
if (!pointerFields || Array.isArray(pointerFields) && pointerFields.length === 0) delete this.permissionsMap[operation];
else if (Array.isArray(pointerFields) && pointerFields.every((field) => typeof field === "string")) this.permissionsMap[operation] = pointerFields;
else throw new TypeError(`${operation}.pointerFields must be an array of strings or undefined.`);
}
_getGroupPointerPermissions(operation) {
return this.permissionsMap[operation] || [];
}
/**
* Sets user pointer fields to allow permission for get/count/find operations.
*
* @param {string[]} pointerFields User pointer fields
*/
setReadUserFields(pointerFields) {
this._setGroupPointerPermission("readUserFields", pointerFields);
}
/**
* @returns {string[]} User pointer fields
*/
getReadUserFields() {
return this._getGroupPointerPermissions("readUserFields") || [];
}
/**
* Sets user pointer fields to allow permission for create/delete/update/addField operations
*
* @param {string[]} pointerFields User pointer fields
*/
setWriteUserFields(pointerFields) {
this._setGroupPointerPermission("writeUserFields", pointerFields);
}
/**
* @returns {string[]} User pointer fields
*/
getWriteUserFields() {
return this._getGroupPointerPermissions("writeUserFields") || [];
}
/**
* Sets whether the given user is allowed to retrieve fields from this class.
*
* @param userId An instance of Parse.User or its objectId.
* @param {string[]} fields fields to be protected
*/
setProtectedFields(userId, fields) {
this._setArrayAccess("protectedFields", userId, fields);
}
/**
* Returns array of fields are accessable to this user.
*
* @param userId An instance of Parse.User or its objectId, or a Parse.Role.
* @returns {string[]}
*/
getProtectedFields(userId) {
return this._getAccess("protectedFields", userId, false);
}
/**
* Sets whether the given user is allowed to read from this class.
*
* @param userId An instance of Parse.User or its objectId.
* @param {boolean} allowed whether that user should have read access.
*/
setReadAccess(userId, allowed) {
this._setAccess("find", userId, allowed);
this._setAccess("get", userId, allowed);
this._setAccess("count", userId, allowed);
}
/**
* Get whether the given user id is *explicitly* allowed to read from this class.
* Even if this returns false, the user may still be able to access it if
* getPublicReadAccess returns true or a role that the user belongs to has
* write access.
*
* @param userId An instance of Parse.User or its objectId, or a Parse.Role.
* @returns {boolean}
*/
getReadAccess(userId) {
return this._getAccess("find", userId) && this._getAccess("get", userId) && this._getAccess("count", userId);
}
/**
* Sets whether the given user id is allowed to write to this class.
*
* @param userId An instance of Parse.User or its objectId, or a Parse.Role..
* @param {boolean} allowed Whether that user should have write access.
*/
setWriteAccess(userId, allowed) {
this._setAccess("create", userId, allowed);
this._setAccess("update", userId, allowed);
this._setAccess("delete", userId, allowed);
this._setAccess("addField", userId, allowed);
}
/**
* Gets whether the given user id is *explicitly* allowed to write to this class.
* Even if this returns false, the user may still be able to write it if
* getPublicWriteAccess returns true or a role that the user belongs to has
* write access.
*
* @param userId An instance of Parse.User or its objectId, or a Parse.Role.
* @returns {boolean}
*/
getWriteAccess(userId) {
return this._getAccess("create", userId) && this._getAccess("update", userId) && this._getAccess("delete", userId) && this._getAccess("addField", userId);
}
/**
* Sets whether the public is allowed to read from this class.
*
* @param {boolean} allowed
*/
setPublicReadAccess(allowed) {
this.setReadAccess(PUBLIC_KEY, allowed);
}
/**
* Gets whether the public is allowed to read from this class.
*
* @returns {boolean}
*/
getPublicReadAccess() {
return this.getReadAccess(PUBLIC_KEY);
}
/**
* Sets whether the public is allowed to write to this class.
*
* @param {boolean} allowed
*/
setPublicWriteAccess(allowed) {
this.setWriteAccess(PUBLIC_KEY, allowed);
}
/**
* Gets whether the public is allowed to write to this class.
*
* @returns {boolean}
*/
getPublicWriteAccess() {
return this.getWriteAccess(PUBLIC_KEY);
}
/**
* Sets whether the public is allowed to protect fields in this class.
*
* @param {string[]} fields
*/
setPublicProtectedFields(fields) {
this.setProtectedFields(PUBLIC_KEY, fields);
}
/**
* Gets whether the public is allowed to read fields from this class.
*
* @returns {string[]}
*/
getPublicProtectedFields() {
return this.getProtectedFields(PUBLIC_KEY);
}
/**
* Gets whether users belonging to the given role are allowed
* to read from this class. Even if this returns false, the role may
* still be able to write it if a parent role has read access.
*
* @param role The name of the role, or a Parse.Role object.
* @returns {boolean} true if the role has read access. false otherwise.
* @throws {TypeError} If role is neither a Parse.Role nor a String.
*/
getRoleReadAccess(role) {
return this.getReadAccess(this._getRoleName(role));
}
/**
* Gets whether users belonging to the given role are allowed
* to write to this user. Even if this returns false, the role may
* still be able to write it if a parent role has write access.
*
* @param role The name of the role, or a Parse.Role object.
* @returns {boolean} true if the role has write access. false otherwise.
* @throws {TypeError} If role is neither a Parse.Role nor a String.
*/
getRoleWriteAccess(role) {
return this.getWriteAccess(this._getRoleName(role));
}
/**
* Sets whether users belonging to the given role are allowed
* to read from this class.
*
* @param role The name of the role, or a Parse.Role object.
* @param {boolean} allowed Whether the given role can read this object.
* @throws {TypeError} If role is neither a Parse.Role nor a String.
*/
setRoleReadAccess(role, allowed) {
this.setReadAccess(this._getRoleName(role), allowed);
}
/**
* Sets whether users belonging to the given role are allowed
* to write to this class.
*
* @param role The name of the role, or a Parse.Role object.
* @param {boolean} allowed Whether the given role can write this object.
* @throws {TypeError} If role is neither a Parse.Role nor a String.
*/
setRoleWriteAccess(role, allowed) {
this.setWriteAccess(this._getRoleName(role), allowed);
}
/**
* Gets whether users belonging to the given role are allowed
* to count to this user. Even if this returns false, the role may
* still be able to count it if a parent role has count access.
*
* @param role The name of the role, or a Parse.Role object.
* @returns {string[]}
* @throws {TypeError} If role is neither a Parse.Role nor a String.
*/
getRoleProtectedFields(role) {
return this.getProtectedFields(this._getRoleName(role));
}
/**
* Sets whether users belonging to the given role are allowed
* to set access field in this class.
*
* @param role The name of the role, or a Parse.Role object.
* @param {string[]} fields Fields to be protected by Role.
* @throws {TypeError} If role is neither a Parse.Role nor a String.
*/
setRoleProtectedFields(role, fields) {
this.setProtectedFields(this._getRoleName(role), fields);
}
};
//#endregion
//#region src/EventEmitter.ts
var import_events = /* @__PURE__ */ __toESM(require_events());
var EventEmitter;
try {
EventEmitter = (import_events.default || import_events).EventEmitter;
} catch (_) {}
var EventEmitter_default = EventEmitter;
//#endregion
//#region src/ParseConfig.ts
/**
* Parse.Config is a local representation of configuration data that
* can be set from the Parse dashboard.
*
* @alias Parse.Config
*/
var ParseConfig = class {
constructor() {
this.attributes = {};
this._escapedAttributes = {};
}
/**
* Gets the value of an attribute.
*
* @param {string} attr The name of an attribute.
* @returns {*}
*/
get(attr) {
return this.attributes[attr];
}
/**
* Gets the HTML-escaped value of an attribute.
*
* @param {string} attr The name of an attribute.
* @returns {string}
*/
escape(attr) {
const html = this._escapedAttributes[attr];
if (html) return html;
const val = this.attributes[attr];
let escaped = "";
if (val != null) escaped = escape$1(val.toString());
this._escapedAttributes[attr] = escaped;
return escaped;
}
/**
* Retrieves the most recently-fetched configuration object, either from
* memory or from local storage if necessary.
*
* @static
* @returns {Parse.Config} The most recently-fetched Parse.Config if it
* exists, else an empty Parse.Config.
*/
static current() {
return CoreManager.getConfigController().current();
}
/**
* Gets a new configuration object from the server.
*
* @static
* @param {object} options
* Valid options are:<ul>
* <li>useMasterKey: In Cloud Code and Node only, causes the Master Key to
* be used for this request.
* </ul>
* @returns {Promise} A promise that is resolved with a newly-created
* configuration object when the get completes.
*/
static get(options) {
return CoreManager.getConfigController().get(options);
}
/**
* Save value keys to the server.
*
* @static
* @param {object} attrs The config parameters and values.
* @param {object} masterKeyOnlyFlags The flags that define whether config parameters listed
* in `attrs` should be retrievable only by using the master key.
* For example: `param1: true` makes `param1` only retrievable by using the master key.
* If a parameter is not provided or set to `false`, it can be retrieved without
* using the master key.
* @returns {Promise} A promise that is resolved with a newly-created
* configuration object or with the current with the update.
*/
static save(attrs, masterKeyOnlyFlags) {
const controller = CoreManager.getConfigController();
return controller.save(attrs, masterKeyOnlyFlags).then(() => {
return controller.get({ useMasterKey: true });
}, (error) => {
return Promise.reject(error);
});
}
/**
* Used for testing
*
* @private
*/
static _clearCache() {
currentConfig = null;
}
};
var currentConfig = null;
var CURRENT_CONFIG_KEY = "currentConfig";
function decodePayload(data) {
try {
const json = JSON.parse(data);
if (json && typeof json === "object") return decode(json);
} catch (_) {
return null;
}
}
CoreManager.setConfigController({
current() {
if (currentConfig) return currentConfig;
const config = new ParseConfig();
const storagePath = Storage.generatePath(CURRENT_CONFIG_KEY);
if (!Storage.async()) {
const configData = Storage.getItem(storagePath);
if (configData) {
const attributes = decodePayload(configData);
if (attributes) {
config.attributes = attributes;
currentConfig = config;
}
}
return config;
}
return Storage.getItemAsync(storagePath).then((configData) => {
if (configData) {
const attributes = decodePayload(configData);
if (attributes) {
config.attributes = attributes;
currentConfig = config;
}
}
return config;
});
},
get(options) {
return CoreManager.getRESTController().request("GET", "config", {}, options).then((response) => {
if (!response || !response.params) {
const error = new ParseError(ParseError.INVALID_JSON, "Config JSON response invalid.");
return Promise.reject(error);
}
const config = new ParseConfig();
config.attributes = {};
for (const attr in response.params) config.attributes[attr] = decode(response.params[attr]);
currentConfig = config;
return Storage.setItemAsync(Storage.generatePath(CURRENT_CONFIG_KEY), JSON.stringify(response.params)).then(() => {
return config;
});
});
},
save(attrs, masterKeyOnlyFlags) {
const RESTController = CoreManager.getRESTController();
const encodedAttrs = {};
for (const key in attrs) encodedAttrs[key] = encode_default(attrs[key]);
return RESTController.request("PUT", "config", {
params: encodedAttrs,
masterKeyOnly: masterKeyOnlyFlags
}, { useMasterKey: true }).then((response) => {
if (response && response.result) return Promise.resolve();
else {
const error = new ParseError(ParseError.INTERNAL_SERVER_ERROR, "Error occured updating Config.");
return Promise.reject(error);
}
});
}
});
//#endregion
//#region src/FacebookUtils.ts
var initialized = false;
var requestedPermissions;
var initOptions;
var provider = {
authenticate(options) {
if (typeof FB === "undefined") options.error(this, "Facebook SDK not found.");
FB.login((response) => {
if (response.authResponse) {
if (options.success) options.success(this, {
id: response.authResponse.userID,
access_token: response.authResponse.accessToken,
expiration_date: new Date(response.authResponse.expiresIn * 1e3 + (/* @__PURE__ */ new Date()).getTime()).toJSON()
});
} else if (options.error) options.error(this, response);
}, { scope: requestedPermissions });
},
restoreAuthentication(authData) {
if (authData) {
const newOptions = {};
if (initOptions) for (const key in initOptions) newOptions[key] = initOptions[key];
newOptions.status = false;
const existingResponse = FB.getAuthResponse();
if (existingResponse && existingResponse.userID !== authData.id) FB.logout();
FB.init(newOptions);
}
return true;
},
getAuthType() {
return "facebook";
},
deauthenticate() {
this.restoreAuthentication(null);
}
};
/**
* Provides a set of utilities for using Parse with Facebook.
*
* @class Parse.FacebookUtils
* @static
* @hideconstructor
*/
var FacebookUtils = {
/**
* Initializes Parse Facebook integration. Call this function after you
* have loaded the Facebook Javascript SDK with the same parameters
* as you would pass to<code>
* <a href=
* "https://developers.facebook.com/docs/reference/javascript/FB.init/">
* FB.init()</a></code>. Parse.FacebookUtils will invoke FB.init() for you
* with these arguments.
*
* @function init
* @name Parse.FacebookUtils.init
* @param {object} options Facebook options argument as described here:
* <a href=
* "https://developers.facebook.com/docs/reference/javascript/FB.init/">
* FB.init()</a>. The status flag will be coerced to 'false' because it
* interferes with Parse Facebook integration. Call FB.getLoginStatus()
* explicitly if this behavior is required by your application.
*/
init(options) {
if (typeof FB === "undefined") throw new Error("The Facebook JavaScript SDK must be loaded before calling init.");
initOptions = {};
if (options) for (const key in options) initOptions[key] = options[key];
if (initOptions.status && typeof console !== "undefined") (console.warn || console.log || function() {}).call(console, "The \"status\" flag passed into FB.init, when set to true, can interfere with Parse Facebook integration, so it has been suppressed. Please call FB.getLoginStatus() explicitly if you require this behavior.");
initOptions.status = false;
FB.init(initOptions);
ParseUser._registerAuthenticationProvider(provider);
initialized = true;
},
/**
* Gets whether the user has their account linked to Facebook.
*
* @function isLinked
* @name Parse.FacebookUtils.isLinked
* @param {Parse.User} user User to check for a facebook link.
* The user must be logged in on this device.
* @returns {boolean} <code>true</code> if the user has their account
* linked to Facebook.
*/
isLinked(user) {
return user._isLinked("facebook");
},
/**
* Logs in a user using Facebook. This method delegates to the Facebook
* SDK to authenticate the user, and then automatically logs in (or
* creates, in the case where it is a new user) a Parse.User.
*
* Standard API:
*
* <code>logIn(permission: string, authData: Object);</code>
*
* Advanced API: Used for handling your own oAuth tokens
* {@link https://docs.parseplatform.org/rest/guide/#linking-users}
*
* <code>logIn(authData: Object, options?: Object);</code>
*
* @function logIn
* @name Parse.FacebookUtils.logIn
* @param {(string | object)} permissions The permissions required for Facebook
* log in. This is a comma-separated string of permissions.
* Alternatively, supply a Facebook authData object as described in our
* REST API docs if you want to handle getting facebook auth tokens
* yourself.
* @param {object} options MasterKey / SessionToken. Alternatively can be used for authData if permissions is a string
* @returns {Promise}
*/
logIn(permissions, options) {
if (!permissions || typeof permissions === "string") {
if (!initialized) throw new Error("You must initialize FacebookUtils before calling logIn.");
requestedPermissions = permissions;
return ParseUser.logInWith("facebook", options);
}
const authData = { authData: permissions };
return ParseUser.logInWith("facebook", authData, options);
},
/**
* Links Facebook to an existing PFUser. This method delegates to the
* Facebook SDK to authenticate the user, and then automatically links
* the account to the Parse.User.
*
* Standard API:
*
* <code>link(user: Parse.User, permission: string, authData?: Object);</code>
*
* Advanced API: Used for handling your own oAuth tokens
* {@link https://docs.parseplatform.org/rest/guide/#linking-users}
*
* <code>link(user: Parse.User, authData: Object, options?: FullOptions);</code>
*
* @function link
* @name Parse.FacebookUtils.link
* @param {Parse.User} user User to link to Facebook. This must be the
* current user.
* @param {(string | object)} permissions The permissions required for Facebook
* log in. This is a comma-separated string of permissions.
* Alternatively, supply a Facebook authData object as described in our
* REST API docs if you want to handle getting facebook auth tokens
* yourself.
* @param {object} options MasterKey / SessionToken. Alternatively can be used for authData if permissions is a string
* @returns {Promise}
*/
link(user, permissions, options) {
if (!permissions || typeof permissions === "string") {
if (!initialized) throw new Error("You must initialize FacebookUtils before calling link.");
requestedPermissions = permissions;
return user.linkWith("facebook", options);
}
const authData = { authData: permissions };
return user.linkWith("facebook", authData, options);
},
/**
* Unlinks the Parse.User from a Facebook account.
*
* @function unlink
* @name Parse.FacebookUtils.unlink
* @param {Parse.User} user User to unlink from Facebook. This must be the
* current user.
* @param {object} options Standard options object with success and error
* callbacks.
* @returns {Promise}
*/
unlink: function(user, options) {
if (!initialized) throw new Error("You must initialize FacebookUtils before calling unlink.");
return user._unlinkFrom("facebook", options);
},
_getAuthProvider() {
return provider;
}
};
//#endregion
//#region src/ParseHooks.ts
CoreManager.setHooksController({
get(type, functionName, triggerName) {
let url = "hooks/" + type;
if (functionName) {
url += "/" + functionName;
if (triggerName) url += "/" + triggerName;
}
return this.sendRequest("GET", url);
},
create(hook) {
let url;
if (hook.functionName && hook.url) url = "hooks/functions";
else if (hook.className && hook.triggerName && hook.url) url = "hooks/triggers";
else return Promise.reject({
error: "invalid hook declaration",
code: 143
});
return this.sendRequest("POST", url, hook);
},
remove(hook) {
let url;
if (hook.functionName) {
url = "hooks/functions/" + hook.functionName;
delete hook.functionName;
} else if (hook.className && hook.triggerName) {
url = "hooks/triggers/" + hook.className + "/" + hook.triggerName;
delete hook.className;
delete hook.triggerName;
} else return Promise.reject({
error: "invalid hook declaration",
code: 143
});
return this.sendRequest("PUT", url, { __op: "Delete" });
},
update(hook) {
let url;
if (hook.functionName && hook.url) {
url = "hooks/functions/" + hook.functionName;
delete hook.functionName;
} else if (hook.className && hook.triggerName && hook.url) {
url = "hooks/triggers/" + hook.className + "/" + hook.triggerName;
delete hook.className;
delete hook.triggerName;
} else return Promise.reject({
error: "invalid hook declaration",
code: 143
});
return this.sendRequest("PUT", url, hook);
},
sendRequest(method, url, body) {
return CoreManager.getRESTController().request(method, url, body, { useMasterKey: true }).then((res) => {
const decoded = decode(res);
if (decoded) return Promise.resolve(decoded);
return Promise.reject(new ParseError(ParseError.INVALID_JSON, "The server returned an invalid response."));
});
}
});
//#endregion
//#region src/LocalDatastoreController.default.ts
var LocalDatastoreController$1 = {
async fromPinWithName(name) {
const values = await Storage.getItemAsync(name);
if (!values) return [];
return JSON.parse(values);
},
pinWithName(name, value) {
const values = JSON.stringify(value);
return Storage.setItemAsync(name, values);
},
unPinWithName(name) {
return Storage.removeItemAsync(name);
},
async getAllContents() {
return (await Storage.getAllKeysAsync()).reduce(async (previousPromise, key) => {
const LDS = await previousPromise;
if (isLocalDatastoreKey(key)) {
const value = await Storage.getItemAsync(key);
try {
LDS[key] = JSON.parse(value);
} catch (error) {
console.error("Error getAllContents: ", error);
}
}
return LDS;
}, Promise.resolve({}));
},
async getRawStorage() {
return (await Storage.getAllKeysAsync()).reduce(async (previousPromise, key) => {
const LDS = await previousPromise;
LDS[key] = await Storage.getItemAsync(key);
return LDS;
}, Promise.resolve({}));
},
async clear() {
const keys = await Storage.getAllKeysAsync();
const toRemove = [];
for (const key of keys) if (isLocalDatastoreKey(key)) toRemove.push(key);
const promises = toRemove.map(this.unPinWithName);
return Promise.all(promises);
}
};
//#endregion
//#region src/LocalDatastoreController.ts
var LocalDatastoreController = LocalDatastoreController$1;
//#endregion
//#region src/LocalDatastore.ts
/**
* Provides a local datastore which can be used to store and retrieve <code>Parse.Object</code>. <br />
* To enable this functionality, call <code>Parse.enableLocalDatastore()</code>.
*
* Pin object to add to local datastore
*
* <pre>await object.pin();</pre>
* <pre>await object.pinWithName('pinName');</pre>
*
* Query pinned objects
*
* <pre>query.fromLocalDatastore();</pre>
* <pre>query.fromPin();</pre>
* <pre>query.fromPinWithName();</pre>
*
* <pre>const localObjects = await query.find();</pre>
*
* @class Parse.LocalDatastore
* @static
*/
var LocalDatastore = {
isEnabled: false,
isSyncing: false,
fromPinWithName(name) {
return CoreManager.getLocalDatastoreController().fromPinWithName(name);
},
async pinWithName(name, value) {
return CoreManager.getLocalDatastoreController().pinWithName(name, value);
},
async unPinWithName(name) {
return CoreManager.getLocalDatastoreController().unPinWithName(name);
},
_getAllContents() {
return CoreManager.getLocalDatastoreController().getAllContents();
},
async _getRawStorage() {
return CoreManager.getLocalDatastoreController().getRawStorage();
},
async _clear() {
return CoreManager.getLocalDatastoreController().clear();
},
async _handlePinAllWithName(name, objects) {
const pinName = this.getPinName(name);
const toPinPromises = [];
const objectKeys = [];
for (const parent of objects) {
const children = this._getChildren(parent);
const parentKey = this.getKeyForObject(parent);
const json = parent._toFullJSON(void 0, true);
if (parent._localId) json._localId = parent._localId;
children[parentKey] = json;
for (const objectKey in children) {
objectKeys.push(objectKey);
toPinPromises.push(this.pinWithName(objectKey, [children[objectKey]]));
}
}
const fromPinPromise = this.fromPinWithName(pinName);
const [pinned] = await Promise.all([fromPinPromise, toPinPromises]);
const toPin = [.../* @__PURE__ */ new Set([...pinned || [], ...objectKeys])];
return this.pinWithName(pinName, toPin);
},
async _handleUnPinAllWithName(name, objects) {
const localDatastore = await this._getAllContents();
const pinName = this.getPinName(name);
const promises = [];
let objectKeys = [];
for (const parent of objects) {
const children = this._getChildren(parent);
const parentKey = this.getKeyForObject(parent);
objectKeys.push(parentKey, ...Object.keys(children));
}
objectKeys = [...new Set(objectKeys)];
let pinned = localDatastore[pinName] || [];
pinned = pinned.filter((item) => !objectKeys.includes(item));
if (pinned.length == 0) {
promises.push(this.unPinWithName(pinName));
delete localDatastore[pinName];
} else {
promises.push(this.pinWithName(pinName, pinned));
localDatastore[pinName] = pinned;
}
for (const objectKey of objectKeys) {
let hasReference = false;
for (const key in localDatastore) if (key === "_default" || key.startsWith("parsePin_")) {
if ((localDatastore[key] || []).includes(objectKey)) {
hasReference = true;
break;
}
}
if (!hasReference) promises.push(this.unPinWithName(objectKey));
}
return Promise.all(promises);
},
_getChildren(object) {
const encountered = {};
const json = object._toFullJSON(void 0, true);
for (const key in json) if (json[key] && json[key].__type && json[key].__type === "Object") this._traverse(json[key], encountered);
return encountered;
},
_traverse(object, encountered) {
if (!object.objectId) return;
else {
const objectKey = this.getKeyForObject(object);
if (encountered[objectKey]) return;
encountered[objectKey] = object;
}
for (const key in object) {
let json = object[key];
if (!object[key]) json = object;
if (json.__type && json.__type === "Object") this._traverse(json, encountered);
}
},
async _serializeObjectsFromPinName(name) {
const localDatastore = await this._getAllContents();
const allObjects = [];
for (const key in localDatastore) if (key.startsWith("Parse_LDS_")) allObjects.push(localDatastore[key][0]);
if (!name) return allObjects;
const pinned = localDatastore[this.getPinName(name)];
if (!Array.isArray(pinned)) return [];
const promises = pinned.map((objectKey) => this.fromPinWithName(objectKey));
let objects = await Promise.all(promises);
objects = [].concat(...objects);
return objects.filter((object) => object != null);
},
async _serializeObject(objectKey, localDatastore) {
let LDS = localDatastore;
if (!LDS) LDS = await this._getAllContents();
if (!LDS[objectKey] || LDS[objectKey].length === 0) return null;
const root = LDS[objectKey][0];
const queue = [];
const meta = {};
let uniqueId = 0;
meta[uniqueId] = root;
queue.push(uniqueId);
while (queue.length !== 0) {
const subTreeRoot = meta[queue.shift()];
for (const field in subTreeRoot) {
const value = subTreeRoot[field];
if (value.__type && value.__type === "Object") {
const key = this.getKeyForObject(value);
if (LDS[key] && LDS[key].length > 0) {
const pointer = LDS[key][0];
uniqueId++;
meta[uniqueId] = pointer;
subTreeRoot[field] = pointer;
queue.push(uniqueId);
}
}
}
}
return root;
},
async _updateObjectIfPinned(object) {
if (!this.isEnabled) return;
const objectKey = this.getKeyForObject(object);
const pinned = await this.fromPinWithName(objectKey);
if (!pinned || pinned.length === 0) return;
return this.pinWithName(objectKey, [object._toFullJSON()]);
},
async _destroyObjectIfPinned(object) {
if (!this.isEnabled) return;
const localDatastore = await this._getAllContents();
const objectKey = this.getKeyForObject(object);
if (!localDatastore[objectKey]) return;
const promises = [this.unPinWithName(objectKey)];
delete localDatastore[objectKey];
for (const key in localDatastore) if (key === "_default" || key.startsWith("parsePin_")) {
let pinned = localDatastore[key] || [];
if (pinned.includes(objectKey)) {
pinned = pinned.filter((item) => item !== objectKey);
if (pinned.length == 0) {
promises.push(this.unPinWithName(key));
delete localDatastore[key];
} else {
promises.push(this.pinWithName(key, pinned));
localDatastore[key] = pinned;
}
}
}
return Promise.all(promises);
},
async _updateLocalIdForObject(localId, object) {
if (!this.isEnabled) return;
const localKey = `${OBJECT_PREFIX}${object.className}_${localId}`;
const objectKey = this.getKeyForObject(object);
const unsaved = await this.fromPinWithName(localKey);
if (!unsaved || unsaved.length === 0) return;
const promises = [this.unPinWithName(localKey), this.pinWithName(objectKey, unsaved)];
const localDatastore = await this._getAllContents();
for (const key in localDatastore) if (key === "_default" || key.startsWith("parsePin_")) {
let pinned = localDatastore[key] || [];
if (pinned.includes(localKey)) {
pinned = pinned.filter((item) => item !== localKey);
pinned.push(objectKey);
promises.push(this.pinWithName(key, pinned));
localDatastore[key] = pinned;
}
}
return Promise.all(promises);
},
/**
* Updates Local Datastore from Server
*
* <pre>
* await Parse.LocalDatastore.updateFromServer();
* </pre>
*
* @function updateFromServer
* @name Parse.LocalDatastore.updateFromServer
* @static
*/
async updateFromServer() {
if (!this.checkIfEnabled() || this.isSyncing) return;
const localDatastore = await this._getAllContents();
const keys = [];
for (const key in localDatastore) if (key.startsWith("Parse_LDS_")) keys.push(key);
if (keys.length === 0) return;
this.isSyncing = true;
const pointersHash = {};
for (const key of keys) {
let [, , className, objectId] = key.split("_");
if (key.split("_").length === 5 && key.split("_")[3] === "User") {
className = "_User";
objectId = key.split("_")[4];
}
if (objectId.startsWith("local")) continue;
if (!(className in pointersHash)) pointersHash[className] = /* @__PURE__ */ new Set();
pointersHash[className].add(objectId);
}
const queryPromises = Object.keys(pointersHash).map((className) => {
const objectIds = Array.from(pointersHash[className]);
const query = new ParseQuery(className);
query.limit(objectIds.length);
if (objectIds.length === 1) query.equalTo("objectId", objectIds[0]);
else query.containedIn("objectId", objectIds);
return query.find();
});
try {
const responses = await Promise.all(queryPromises);
const pinPromises = [].concat.apply([], responses).map((object) => {
const objectKey = this.getKeyForObject(object);
return this.pinWithName(objectKey, object._toFullJSON());
});
await Promise.all(pinPromises);
this.isSyncing = false;
} catch (error) {
console.error("Error syncing LocalDatastore: ", error);
this.isSyncing = false;
}
},
getKeyForObject(object) {
const objectId = object.objectId || object._getId();
return `${OBJECT_PREFIX}${object.className}_${objectId}`;
},
getPinName(pinName) {
if (!pinName || pinName === "_default") return DEFAULT_PIN;
return PIN_PREFIX + pinName;
},
checkIfEnabled() {
if (!this.isEnabled) console.error("Parse.enableLocalDatastore() must be called first");
return this.isEnabled;
}
};
CoreManager.setLocalDatastoreController(LocalDatastoreController);
CoreManager.setLocalDatastore(LocalDatastore);
//#endregion
//#region src/Push.ts
var Push_exports = /* @__PURE__ */ __exportAll({
getPushStatus: () => getPushStatus,
send: () => send
});
/**
* Contains functions to deal with Push in Parse.
*
* @class Parse.Push
* @static
* @hideconstructor
*/
/**
* Sends a push notification.
* **Available in Cloud Code only.**
*
* See {@link https://docs.parseplatform.org/js/guide/#push-notifications Push Notification Guide}
*
* @function send
* @name Parse.Push.send
* @param {object} data - The data of the push notification. Valid fields
* are:
* <ol>
* <li>channels - An Array of channels to push to.</li>
* <li>push_time - A Date object for when to send the push.</li>
* <li>expiration_time - A Date object for when to expire
* the push.</li>
* <li>expiration_interval - The seconds from now to expire the push.</li>
* <li>where - A Parse.Query over Parse.Installation that is used to match
* a set of installations to push to.</li>
* <li>data - The data to send as part of the push.</li>
* <ol>
* @param {object} options Valid options
* are:<ul>
* <li>useMasterKey: In Cloud Code and Node only, causes the Master Key to
* be used for this request.
* </ul>
* @returns {Promise} A promise that is fulfilled when the push request
* completes and returns `pushStatusId`.
*/
function send(data, options = {}) {
if (data.where && data.where instanceof ParseQuery) data.where = data.where.toJSON().where;
if (data.push_time && typeof data.push_time === "object") data.push_time = data.push_time.toJSON();
if (data.expiration_time && typeof data.expiration_time === "object") data.expiration_time = data.expiration_time.toJSON();
if (data.expiration_time && data.expiration_interval) throw new Error("expiration_time and expiration_interval cannot both be set.");
const pushOptions = { useMasterKey: true };
if (Object.hasOwn(options, "useMasterKey")) pushOptions.useMasterKey = options.useMasterKey;
return CoreManager.getPushController().send(data, pushOptions);
}
/**
* Gets push status by Id
*
* @function getPushStatus
* @name Parse.Push.getPushStatus
* @param {string} pushStatusId The Id of Push Status.
* @param {object} options Valid options
* are:<ul>
* <li>useMasterKey: In Cloud Code and Node only, causes the Master Key to
* be used for this request.
* </ul>
* @returns {Parse.Object} Status of Push.
*/
function getPushStatus(pushStatusId, options = {}) {
const pushOptions = { useMasterKey: true };
if (Object.hasOwn(options, "useMasterKey")) pushOptions.useMasterKey = options.useMasterKey;
return new ParseQuery("_PushStatus").get(pushStatusId, pushOptions);
}
CoreManager.setPushController({ async send(data, options) {
options.returnStatus = true;
return (await CoreManager.getRESTController().request("POST", "push", data, options))._headers?.["X-Parse-Push-Status-Id"];
} });
//#endregion
//#region src/ParseSchema.ts
var FIELD_TYPES = [
"String",
"Number",
"Boolean",
"Bytes",
"Date",
"File",
"GeoPoint",
"Polygon",
"Array",
"Object",
"Pointer",
"Relation"
];
/**
* A Parse.Schema object is for handling schema data from Parse.
* <p>All the schemas methods require MasterKey.
*
* When adding fields, you may set required and default values. (Requires Parse Server 3.7.0+)
*
* <pre>
* const options = { required: true, defaultValue: 'hello world' };
* const schema = new Parse.Schema('MyClass');
* schema.addString('field', options);
* schema.addIndex('index_name', { 'field': 1 });
* schema.save();
* </pre>
* </p>
*
* @alias Parse.Schema
*/
var ParseSchema = class {
/**
* @param {string} className Parse Class string.
*/
constructor(className) {
if (typeof className === "string") if (className === "User" && CoreManager.get("PERFORM_USER_REWRITE")) this.className = "_User";
else this.className = className;
this._fields = {};
this._indexes = {};
}
/**
* Static method to get all schemas
*
* @returns {Promise} A promise that is resolved with the result when
* the query completes.
*/
static all() {
return CoreManager.getSchemaController().get("").then((response) => {
if (response.results.length === 0) throw new Error("Schema not found.");
return response.results;
});
}
/**
* Get the Schema from Parse
*
* @returns {Promise} A promise that is resolved with the result when
* the query completes.
*/
get() {
this.assertClassName();
return CoreManager.getSchemaController().get(this.className).then((response) => {
if (!response) throw new Error("Schema not found.");
return response;
});
}
/**
* Create a new Schema on Parse
*
* @returns {Promise} A promise that is resolved with the result when
* the query completes.
*/
save() {
this.assertClassName();
const controller = CoreManager.getSchemaController();
const params = {
className: this.className,
fields: this._fields,
indexes: this._indexes,
classLevelPermissions: this._clp
};
return controller.create(this.className, params);
}
/**
* Update a Schema on Parse
*
* @returns {Promise} A promise that is resolved with the result when
* the query completes.
*/
update() {
this.assertClassName();
const controller = CoreManager.getSchemaController();
const params = {
className: this.className,
fields: this._fields,
indexes: this._indexes,
classLevelPermissions: this._clp
};
this._fields = {};
this._indexes = {};
return controller.update(this.className, params);
}
/**
* Removing a Schema from Parse
* Can only be used on Schema without objects
*
* @returns {Promise} A promise that is resolved with the result when
* the query completes.
*/
delete() {
this.assertClassName();
return CoreManager.getSchemaController().delete(this.className);
}
/**
* Removes all objects from a Schema (class) in Parse.
* EXERCISE CAUTION, running this will delete all objects for this schema and cannot be reversed
*
* @returns {Promise} A promise that is resolved with the result when
* the query completes.
*/
purge() {
this.assertClassName();
return CoreManager.getSchemaController().purge(this.className);
}
/**
* Assert if ClassName has been filled
*
* @private
*/
assertClassName() {
if (!this.className) throw new Error("You must set a Class Name before making any request.");
}
/**
* Sets Class Level Permissions when creating / updating a Schema.
* EXERCISE CAUTION, running this may override CLP for this schema and cannot be reversed
*
* @param {object | Parse.CLP} clp Class Level Permissions
* @returns {Parse.Schema} Returns the schema, so you can chain this call.
*/
setCLP(clp) {
if (clp instanceof ParseCLP) this._clp = clp.toJSON();
else this._clp = clp;
return this;
}
/**
* Adding a Field to Create / Update a Schema
*
* @param {string} name Name of the field that will be created on Parse
* @param {string} type Can be a (String|Number|Boolean|Date|Parse.File|Parse.GeoPoint|Array|Object|Pointer|Parse.Relation)
* @param {object} options
* Valid options are:<ul>
* <li>required: If field is not set, save operation fails (Requires Parse Server 3.7.0+)
* <li>defaultValue: If field is not set, a default value is selected (Requires Parse Server 3.7.0+)
* <li>targetClass: Required if type is Pointer or Parse.Relation
* </ul>
* @returns {Parse.Schema} Returns the schema, so you can chain this call.
*/
addField(name, type, options) {
type = type || "String";
options = options || {};
if (!name) throw new Error("field name may not be null.");
if (FIELD_TYPES.indexOf(type) === -1) throw new Error(`${type} is not a valid type.`);
if (type === "Pointer") return this.addPointer(name, options.targetClass, options);
if (type === "Relation") return this.addRelation(name, options.targetClass);
const fieldOptions = { type };
if (typeof options.required === "boolean") fieldOptions.required = options.required;
if (options.defaultValue !== void 0) fieldOptions.defaultValue = options.defaultValue;
if (type === "Date") {
if (options && options.defaultValue) fieldOptions.defaultValue = {
__type: "Date",
iso: new Date(options.defaultValue)
};
}
if (type === "Bytes") {
if (options && options.defaultValue) fieldOptions.defaultValue = {
__type: "Bytes",
base64: options.defaultValue
};
}
this._fields[name] = fieldOptions;
return this;
}
/**
* Adding an Index to Create / Update a Schema
*
* @param {string} name Name of the index
* @param {object} index { field: value }
* @returns {Parse.Schema} Returns the schema, so you can chain this call.
*
* <pre>
* schema.addIndex('index_name', { 'field': 1 });
* </pre>
*/
addIndex(name, index) {
if (!name) throw new Error("index name may not be null.");
if (!index) throw new Error("index may not be null.");
this._indexes[name] = index;
return this;
}
/**
* Adding String Field
*
* @param {string} name Name of the field that will be created on Parse
* @param {object} options See {@link https://parseplatform.org/Parse-SDK-JS/api/master/Parse.Schema.html#addField addField}
* @returns {Parse.Schema} Returns the schema, so you can chain this call.
*/
addString(name, options) {
return this.addField(name, "String", options);
}
/**
* Adding Number Field
*
* @param {string} name Name of the field that will be created on Parse
* @param {object} options See {@link https://parseplatform.org/Parse-SDK-JS/api/master/Parse.Schema.html#addField addField}
* @returns {Parse.Schema} Returns the schema, so you can chain this call.
*/
addNumber(name, options) {
return this.addField(name, "Number", options);
}
/**
* Adding Boolean Field
*
* @param {string} name Name of the field that will be created on Parse
* @param {object} options See {@link https://parseplatform.org/Parse-SDK-JS/api/master/Parse.Schema.html#addField addField}
* @returns {Parse.Schema} Returns the schema, so you can chain this call.
*/
addBoolean(name, options) {
return this.addField(name, "Boolean", options);
}
/**
* Adding Bytes Field
*
* @param {string} name Name of the field that will be created on Parse
* @param {object} options See {@link https://parseplatform.org/Parse-SDK-JS/api/master/Parse.Schema.html#addField addField}
* @returns {Parse.Schema} Returns the schema, so you can chain this call.
*/
addBytes(name, options) {
return this.addField(name, "Bytes", options);
}
/**
* Adding Date Field
*
* @param {string} name Name of the field that will be created on Parse
* @param {object} options See {@link https://parseplatform.org/Parse-SDK-JS/api/master/Parse.Schema.html#addField addField}
* @returns {Parse.Schema} Returns the schema, so you can chain this call.
*/
addDate(name, options) {
return this.addField(name, "Date", options);
}
/**
* Adding File Field
*
* @param {string} name Name of the field that will be created on Parse
* @param {object} options See {@link https://parseplatform.org/Parse-SDK-JS/api/master/Parse.Schema.html#addField addField}
* @returns {Parse.Schema} Returns the schema, so you can chain this call.
*/
addFile(name, options) {
return this.addField(name, "File", options);
}
/**
* Adding GeoPoint Field
*
* @param {string} name Name of the field that will be created on Parse
* @param {object} options See {@link https://parseplatform.org/Parse-SDK-JS/api/master/Parse.Schema.html#addField addField}
* @returns {Parse.Schema} Returns the schema, so you can chain this call.
*/
addGeoPoint(name, options) {
return this.addField(name, "GeoPoint", options);
}
/**
* Adding Polygon Field
*
* @param {string} name Name of the field that will be created on Parse
* @param {object} options See {@link https://parseplatform.org/Parse-SDK-JS/api/master/Parse.Schema.html#addField addField}
* @returns {Parse.Schema} Returns the schema, so you can chain this call.
*/
addPolygon(name, options) {
return this.addField(name, "Polygon", options);
}
/**
* Adding Array Field
*
* @param {string} name Name of the field that will be created on Parse
* @param {object} options See {@link https://parseplatform.org/Parse-SDK-JS/api/master/Parse.Schema.html#addField addField}
* @returns {Parse.Schema} Returns the schema, so you can chain this call.
*/
addArray(name, options) {
return this.addField(name, "Array", options);
}
/**
* Adding Object Field
*
* @param {string} name Name of the field that will be created on Parse
* @param {object} options See {@link https://parseplatform.org/Parse-SDK-JS/api/master/Parse.Schema.html#addField addField}
* @returns {Parse.Schema} Returns the schema, so you can chain this call.
*/
addObject(name, options) {
return this.addField(name, "Object", options);
}
/**
* Adding Pointer Field
*
* @param {string} name Name of the field that will be created on Parse
* @param {string} targetClass Name of the target Pointer Class
* @param {object} options See {@link https://parseplatform.org/Parse-SDK-JS/api/master/Parse.Schema.html#addField addField}
* @returns {Parse.Schema} Returns the schema, so you can chain this call.
*/
addPointer(name, targetClass, options) {
if (!name) throw new Error("field name may not be null.");
if (!targetClass) throw new Error("You need to set the targetClass of the Pointer.");
const fieldOptions = {
type: "Pointer",
targetClass
};
if (typeof options?.required === "boolean") fieldOptions.required = options.required;
if (options?.defaultValue !== void 0) {
fieldOptions.defaultValue = options.defaultValue;
if (options.defaultValue instanceof ParseObject) fieldOptions.defaultValue = options.defaultValue.toPointer();
}
this._fields[name] = fieldOptions;
return this;
}
/**
* Adding Relation Field
*
* @param {string} name Name of the field that will be created on Parse
* @param {string} targetClass Name of the target Pointer Class
* @returns {Parse.Schema} Returns the schema, so you can chain this call.
*/
addRelation(name, targetClass) {
if (!name) throw new Error("field name may not be null.");
if (!targetClass) throw new Error("You need to set the targetClass of the Relation.");
this._fields[name] = {
type: "Relation",
targetClass
};
return this;
}
/**
* Deleting a Field to Update on a Schema
*
* @param {string} name Name of the field
* @returns {Parse.Schema} Returns the schema, so you can chain this call.
*/
deleteField(name) {
this._fields[name] = { __op: "Delete" };
return this;
}
/**
* Deleting an Index to Update on a Schema
*
* @param {string} name Name of the field
* @returns {Parse.Schema} Returns the schema, so you can chain this call.
*/
deleteIndex(name) {
this._indexes[name] = { __op: "Delete" };
return this;
}
};
CoreManager.setSchemaController({
send(className, method, params = {}) {
return CoreManager.getRESTController().request(method, `schemas/${className}`, params, { useMasterKey: true });
},
get(className) {
return this.send(className, "GET");
},
create(className, params) {
return this.send(className, "POST", params);
},
update(className, params) {
return this.send(className, "PUT", params);
},
delete(className) {
return this.send(className, "DELETE");
},
purge(className) {
return CoreManager.getRESTController().request("DELETE", `purge/${className}`, {}, { useMasterKey: true });
}
});
//#endregion
//#region src/ParseSession.ts
/**
* <p>A Parse.Session object is a local representation of a revocable session.
* This class is a subclass of a Parse.Object, and retains the same
* functionality of a Parse.Object.</p>
*
* @alias Parse.Session
* @augments Parse.Object
*/
var ParseSession = class extends ParseObject {
/**
* @param {object} attributes The initial set of data to store in the user.
*/
constructor(attributes) {
super("_Session");
if (attributes && typeof attributes === "object") try {
this.set(attributes || {});
} catch (_) {
throw new Error("Can't create an invalid Session");
}
}
/**
* Returns the session token string.
*
* @returns {string}
*/
getSessionToken() {
const token = this.get("sessionToken");
if (typeof token === "string") return token;
return "";
}
static readOnlyAttributes() {
return [
"createdWith",
"expiresAt",
"installationId",
"restricted",
"sessionToken",
"user"
];
}
/**
* Retrieves the Session object for the currently logged in session.
*
* @param {object} options useMasterKey
* @static
* @returns {Promise} A promise that is resolved with the Parse.Session
* object after it has been fetched. If there is no current user, the
* promise will be rejected.
*/
static current(options) {
const controller = CoreManager.getSessionController();
const sessionOptions = ParseObject._getRequestOptions(options);
return ParseUser.currentAsync().then((user) => {
if (!user) return Promise.reject("There is no current user.");
sessionOptions.sessionToken = user.getSessionToken();
return controller.getSession(sessionOptions);
});
}
/**
* Determines whether the current session token is revocable.
* This method is useful for migrating Express.js or Node.js web apps to
* use revocable sessions. If you are migrating an app that uses the Parse
* SDK in the browser only, please use Parse.User.enableRevocableSession()
* instead, so that sessions can be automatically upgraded.
*
* @static
* @returns {boolean}
*/
static isCurrentSessionRevocable() {
const currentUser = ParseUser.current();
if (currentUser) return isRevocableSession(currentUser.getSessionToken() || "");
return false;
}
};
ParseObject.registerSubclass("_Session", ParseSession);
CoreManager.setSessionController({ getSession(options) {
const RESTController = CoreManager.getRESTController();
const session = new ParseSession();
return RESTController.request("GET", "sessions/me", {}, options).then((sessionData) => {
session._finishFetch(sessionData);
session._setExisted(true);
return session;
});
} });
//#endregion
//#region src/LiveQuerySubscription.ts
/**
* Creates a new LiveQuery Subscription.
* <a href="https://nodejs.org/api/events.html#events_class_eventemitter">cloud functions</a>.
*
* <p>Response Object - Contains data from the client that made the request
* <ul>
* <li>clientId</li>
* <li>installationId - requires Parse Server 4.0.0+</li>
* </ul>
* </p>
*
* <p>Open Event - When you call query.subscribe(), we send a subscribe request to
* the LiveQuery server, when we get the confirmation from the LiveQuery server,
* this event will be emitted. When the client loses WebSocket connection to the
* LiveQuery server, we will try to auto reconnect the LiveQuery server. If we
* reconnect the LiveQuery server and successfully resubscribe the ParseQuery,
* you'll also get this event.
*
* <pre>
* subscription.on('open', (response) => {
*
* });</pre></p>
*
* <p>Create Event - When a new ParseObject is created and it fulfills the ParseQuery you subscribe,
* you'll get this event. The object is the ParseObject which is created.
*
* <pre>
* subscription.on('create', (object, response) => {
*
* });</pre></p>
*
* <p>Update Event - When an existing ParseObject (original) which fulfills the ParseQuery you subscribe
* is updated (The ParseObject fulfills the ParseQuery before and after changes),
* you'll get this event. The object is the ParseObject which is updated.
* Its content is the latest value of the ParseObject.
*
* Parse-Server 3.1.3+ Required for original object parameter
*
* <pre>
* subscription.on('update', (object, original, response) => {
*
* });</pre></p>
*
* <p>Enter Event - When an existing ParseObject's (original) old value doesn't fulfill the ParseQuery
* but its new value fulfills the ParseQuery, you'll get this event. The object is the
* ParseObject which enters the ParseQuery. Its content is the latest value of the ParseObject.
*
* Parse-Server 3.1.3+ Required for original object parameter
*
* <pre>
* subscription.on('enter', (object, original, response) => {
*
* });</pre></p>
*
*
* <p>Update Event - When an existing ParseObject's old value fulfills the ParseQuery but its new value
* doesn't fulfill the ParseQuery, you'll get this event. The object is the ParseObject
* which leaves the ParseQuery. Its content is the latest value of the ParseObject.
*
* <pre>
* subscription.on('leave', (object, response) => {
*
* });</pre></p>
*
*
* <p>Delete Event - When an existing ParseObject which fulfills the ParseQuery is deleted, you'll
* get this event. The object is the ParseObject which is deleted.
*
* <pre>
* subscription.on('delete', (object, response) => {
*
* });</pre></p>
*
*
* <p>Close Event - When the client loses the WebSocket connection to the LiveQuery
* server and we stop receiving events, you'll get this event.
*
* <pre>
* subscription.on('close', () => {
*
* });</pre></p>
*/
var LiveQuerySubscription = class {
constructor(id, query, sessionToken, client) {
this.id = id;
this.query = query;
this.sessionToken = sessionToken;
this.client = client;
this.subscribePromise = resolvingPromise();
this.unsubscribePromise = resolvingPromise();
this.subscribed = false;
const Emitter = CoreManager.getEventEmitter();
this.emitter = new Emitter();
this.on = (eventName, listener) => this.emitter.on(eventName, listener);
this.emit = (eventName, ...args) => this.emitter.emit(eventName, ...args);
this.on("error", () => {});
}
/**
* Close the subscription
*
* @returns {Promise}
*/
unsubscribe() {
return CoreManager.getLiveQueryController().getDefaultLiveQueryClient().then((liveQueryClient) => {
this.emit("close");
return liveQueryClient.unsubscribe(this);
});
}
/**
* Execute a query on this subscription.
* The results will be delivered via the 'result' event.
*/
find() {
if (this.client) this.client.connectPromise.then(() => {
this.client.socket.send(JSON.stringify({
op: "query",
requestId: this.id
}));
});
}
};
//#endregion
//#region src/LiveQueryClient.ts
var CLIENT_STATE = {
INITIALIZED: "initialized",
CONNECTING: "connecting",
CONNECTED: "connected",
CLOSED: "closed",
RECONNECTING: "reconnecting",
DISCONNECTED: "disconnected"
};
var OP_TYPES = {
CONNECT: "connect",
SUBSCRIBE: "subscribe",
UNSUBSCRIBE: "unsubscribe",
ERROR: "error",
QUERY: "query"
};
var OP_EVENTS = {
CONNECTED: "connected",
SUBSCRIBED: "subscribed",
UNSUBSCRIBED: "unsubscribed",
ERROR: "error",
CREATE: "create",
UPDATE: "update",
ENTER: "enter",
LEAVE: "leave",
DELETE: "delete",
RESULT: "result"
};
var CLIENT_EMMITER_TYPES = {
CLOSE: "close",
ERROR: "error",
OPEN: "open"
};
var SUBSCRIPTION_EMMITER_TYPES = {
OPEN: "open",
CLOSE: "close",
ERROR: "error",
CREATE: "create",
UPDATE: "update",
ENTER: "enter",
LEAVE: "leave",
DELETE: "delete",
RESULT: "result"
};
var generateInterval = (k) => {
return Math.random() * Math.min(30, Math.pow(2, k) - 1) * 1e3;
};
/**
* Creates a new LiveQueryClient.
* <a href="https://nodejs.org/api/events.html#events_class_eventemitter">cloud functions</a>.
*
* A wrapper of a standard WebSocket client. We add several useful methods to
* help you connect/disconnect to LiveQueryServer, subscribe/unsubscribe a ParseQuery easily.
*
* javascriptKey and masterKey are used for verifying the LiveQueryClient when it tries
* to connect to the LiveQuery server
*
* We expose three events to help you monitor the status of the LiveQueryClient.
*
* <pre>
* const LiveQueryClient = Parse.LiveQueryClient;
* const client = new LiveQueryClient({
* applicationId: '',
* serverURL: '',
* javascriptKey: '',
* masterKey: ''
* });
* </pre>
*
* Open - When we establish the WebSocket connection to the LiveQuery server, you'll get this event.
* <pre>
* client.on('open', () => {
*
* });</pre>
*
* Close - When we lose the WebSocket connection to the LiveQuery server, you'll get this event.
* <pre>
* client.on('close', () => {
*
* });</pre>
*
* Error - When some network error or LiveQuery server error happens, you'll get this event.
* <pre>
* client.on('error', (error) => {
*
* });</pre>
*
* @alias Parse.LiveQueryClient
*/
var LiveQueryClient = class {
/**
* Creates a new LiveQueryClient instance.
*
* @param options - Configuration options for the LiveQuery client
* @param options.applicationId - The applicationId of your Parse app
* @param options.serverURL - The URL of your LiveQuery server (must start with 'ws' or 'wss')
* @param options.javascriptKey - (Optional) The JavaScript key for your Parse app
* @param options.masterKey - (Optional) Your Parse Master Key (Node.js only!)
* @param options.sessionToken - (Optional) Session token for authenticated requests
* @param options.installationId - (Optional) Installation ID for the client
*/
constructor({ applicationId, serverURL, javascriptKey, masterKey, sessionToken, installationId }) {
if (!serverURL || serverURL.indexOf("ws") !== 0) throw new Error("You need to set a proper Parse LiveQuery server url before using LiveQueryClient");
this.reconnectHandle = null;
this.attempts = 1;
this.id = 0;
this.requestId = 1;
this.serverURL = serverURL;
this.applicationId = applicationId;
this.javascriptKey = javascriptKey || void 0;
this.masterKey = masterKey || void 0;
this.sessionToken = sessionToken || void 0;
this.installationId = installationId || void 0;
this.additionalProperties = true;
this.connectPromise = resolvingPromise();
this.subscriptions = /* @__PURE__ */ new Map();
this.state = CLIENT_STATE.INITIALIZED;
const EventEmitter = CoreManager.getEventEmitter();
this.emitter = new EventEmitter();
this.on = (eventName, listener) => this.emitter.on(eventName, listener);
this.emit = (eventName, ...args) => this.emitter.emit(eventName, ...args);
this.on("error", () => {});
}
shouldOpen() {
return this.state === CLIENT_STATE.INITIALIZED || this.state === CLIENT_STATE.DISCONNECTED;
}
/**
* Subscribes to a ParseQuery
*
* If you provide the sessionToken, when the LiveQuery server gets ParseObject's
* updates from parse server, it'll try to check whether the sessionToken fulfills
* the ParseObject's ACL. The LiveQuery server will only send updates to clients whose
* sessionToken is fit for the ParseObject's ACL. You can check the LiveQuery protocol
* <a href="https://github.com/parse-community/parse-server/wiki/Parse-LiveQuery-Protocol-Specification">here</a> for more details. The subscription you get is the same subscription you get
* from our Standard API.
*
* @param {ParseQuery} query - the ParseQuery you want to subscribe to
* @param {string} sessionToken (optional)
* @returns {LiveQuerySubscription | undefined}
*/
subscribe(query, sessionToken) {
if (!query) return;
const className = query.className;
const queryJSON = query.toJSON();
const where = queryJSON.where;
const keys = queryJSON.keys?.split(",");
const watch = queryJSON.watch?.split(",");
const subscribeRequest = {
op: OP_TYPES.SUBSCRIBE,
requestId: this.requestId,
query: {
className,
where,
keys,
watch
},
sessionToken: void 0
};
if (sessionToken) subscribeRequest.sessionToken = sessionToken;
const subscription = new LiveQuerySubscription(this.requestId, query, sessionToken, this);
this.subscriptions.set(this.requestId, subscription);
this.requestId += 1;
this.connectPromise.then(() => {
this.socket.send(JSON.stringify(subscribeRequest));
}).catch((error) => {
subscription.subscribePromise.reject(error);
});
return subscription;
}
/**
* After calling unsubscribe you'll stop receiving events from the subscription object.
*
* @param {object} subscription - subscription you would like to unsubscribe from.
* @returns {Promise | undefined}
*/
async unsubscribe(subscription) {
if (!subscription) return;
const unsubscribeRequest = {
op: OP_TYPES.UNSUBSCRIBE,
requestId: subscription.id
};
return this.connectPromise.then(() => {
return this.socket.send(JSON.stringify(unsubscribeRequest));
}).then(() => {
return subscription.unsubscribePromise;
});
}
/**
* After open is called, the LiveQueryClient will try to send a connect request
* to the LiveQuery server.
*
*/
open() {
const WebSocketImplementation = CoreManager.getWebSocketController();
if (!WebSocketImplementation) {
this.emit(CLIENT_EMMITER_TYPES.ERROR, "Can not find WebSocket implementation");
return;
}
if (this.state !== CLIENT_STATE.RECONNECTING) this.state = CLIENT_STATE.CONNECTING;
this.socket = new WebSocketImplementation(this.serverURL);
this.socket.closingPromise = resolvingPromise();
this.socket.onopen = () => {
this._handleWebSocketOpen();
};
this.socket.onmessage = (event) => {
this._handleWebSocketMessage(event);
};
this.socket.onclose = (event) => {
this.socket.closingPromise?.resolve(event);
this._handleWebSocketClose();
};
this.socket.onerror = (error) => {
this._handleWebSocketError(error);
};
}
resubscribe() {
this.subscriptions.forEach((subscription, requestId) => {
const query = subscription.query;
const queryJSON = query.toJSON();
const where = queryJSON.where;
const keys = queryJSON.keys?.split(",");
const watch = queryJSON.watch?.split(",");
const className = query.className;
const sessionToken = subscription.sessionToken;
const subscribeRequest = {
op: OP_TYPES.SUBSCRIBE,
requestId,
query: {
className,
where,
keys,
watch
},
sessionToken: void 0
};
if (sessionToken) subscribeRequest.sessionToken = sessionToken;
this.connectPromise.then(() => {
this.socket.send(JSON.stringify(subscribeRequest));
});
});
}
/**
* This method will close the WebSocket connection to this LiveQueryClient,
* cancel the auto reconnect and unsubscribe all subscriptions based on it.
*
* @returns {Promise | undefined} CloseEvent {@link https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/close_event}
*/
async close() {
if (this.state === CLIENT_STATE.INITIALIZED || this.state === CLIENT_STATE.DISCONNECTED) return;
this.state = CLIENT_STATE.DISCONNECTED;
this.socket?.close();
for (const subscription of this.subscriptions.values()) {
subscription.subscribed = false;
subscription.emit(SUBSCRIPTION_EMMITER_TYPES.CLOSE);
}
this._handleReset();
this.emit(CLIENT_EMMITER_TYPES.CLOSE);
return this.socket?.closingPromise;
}
_handleReset() {
this.attempts = 1;
this.id = 0;
this.requestId = 1;
this.connectPromise = resolvingPromise();
this.subscriptions = /* @__PURE__ */ new Map();
}
_handleWebSocketOpen() {
const connectRequest = {
op: OP_TYPES.CONNECT,
applicationId: this.applicationId,
javascriptKey: this.javascriptKey,
masterKey: this.masterKey,
sessionToken: this.sessionToken,
installationId: void 0
};
if (this.additionalProperties) connectRequest.installationId = this.installationId;
this.socket.send(JSON.stringify(connectRequest));
}
_handleWebSocketMessage(event) {
let data = event.data;
if (typeof data === "string") data = JSON.parse(data);
let subscription = null;
if (data.requestId) subscription = this.subscriptions.get(data.requestId) || null;
const response = {
clientId: data.clientId,
installationId: data.installationId
};
switch (data.op) {
case OP_EVENTS.CONNECTED:
if (this.state === CLIENT_STATE.RECONNECTING) this.resubscribe();
this.emit(CLIENT_EMMITER_TYPES.OPEN);
this.id = data.clientId;
this.connectPromise.resolve();
this.state = CLIENT_STATE.CONNECTED;
break;
case OP_EVENTS.SUBSCRIBED:
if (subscription) {
this.attempts = 1;
subscription.subscribed = true;
subscription.subscribePromise.resolve();
setTimeout(() => subscription.emit(SUBSCRIPTION_EMMITER_TYPES.OPEN, response), 200);
}
break;
case OP_EVENTS.ERROR: {
const parseError = new ParseError(data.code, data.error);
if (!this.id) {
this.connectPromise.reject(parseError);
this.state = CLIENT_STATE.DISCONNECTED;
}
if (data.requestId) {
if (subscription) {
subscription.subscribePromise.reject(parseError);
setTimeout(() => subscription.emit(SUBSCRIPTION_EMMITER_TYPES.ERROR, data.error), 200);
}
} else this.emit(CLIENT_EMMITER_TYPES.ERROR, data.error);
if (data.error === "Additional properties not allowed") this.additionalProperties = false;
if (data.reconnect) this._handleReconnect();
break;
}
case OP_EVENTS.UNSUBSCRIBED:
if (subscription) {
this.subscriptions.delete(data.requestId);
subscription.subscribed = false;
subscription.unsubscribePromise.resolve();
}
break;
case OP_EVENTS.RESULT:
if (subscription) {
const objects = data.results.map((json) => {
if (!json.className && subscription.query) json.className = subscription.query.className;
return ParseObject.fromJSON(json, false);
});
subscription.emit(SUBSCRIPTION_EMMITER_TYPES.RESULT, objects);
}
break;
default: {
if (!subscription) break;
let override = false;
if (data.original) {
override = true;
delete data.original.__type;
for (const field in data.original) if (!(field in data.object)) data.object[field] = void 0;
data.original = ParseObject.fromJSON(data.original, false);
}
delete data.object.__type;
const parseObject = ParseObject.fromJSON(data.object, !(subscription.query && subscription.query._select) ? override : false);
if (data.original) subscription.emit(data.op, parseObject, data.original, response);
else subscription.emit(data.op, parseObject, response);
const localDatastore = CoreManager.getLocalDatastore();
if (override && localDatastore.isEnabled) localDatastore._updateObjectIfPinned(parseObject).then(() => {});
}
}
}
_handleWebSocketClose() {
if (this.state === CLIENT_STATE.DISCONNECTED) return;
this.state = CLIENT_STATE.CLOSED;
this.emit(CLIENT_EMMITER_TYPES.CLOSE);
for (const subscription of this.subscriptions.values()) subscription.emit(SUBSCRIPTION_EMMITER_TYPES.CLOSE);
this._handleReconnect();
}
_handleWebSocketError(error) {
this.emit(CLIENT_EMMITER_TYPES.ERROR, error);
for (const subscription of this.subscriptions.values()) subscription.emit(SUBSCRIPTION_EMMITER_TYPES.ERROR, error);
this._handleReconnect();
}
_handleReconnect() {
if (this.state === CLIENT_STATE.DISCONNECTED) return;
this.state = CLIENT_STATE.RECONNECTING;
const time = generateInterval(this.attempts);
if (this.reconnectHandle) clearTimeout(this.reconnectHandle);
this.reconnectHandle = setTimeout((() => {
this.attempts++;
this.connectPromise = resolvingPromise();
this.open();
}).bind(this), time);
}
};
//#endregion
//#region src/ParseLiveQuery.ts
function getLiveQueryClient() {
return CoreManager.getLiveQueryController().getDefaultLiveQueryClient();
}
/**
* We expose three events to help you monitor the status of the WebSocket connection:
*
* <p>Open - When we establish the WebSocket connection to the LiveQuery server, you'll get this event.
*
* <pre>
* Parse.LiveQuery.on('open', () => {
*
* });</pre></p>
*
* <p>Close - When we lose the WebSocket connection to the LiveQuery server, you'll get this event.
*
* <pre>
* Parse.LiveQuery.on('close', () => {
*
* });</pre></p>
*
* <p>Error - When some network error or LiveQuery server error happens, you'll get this event.
*
* <pre>
* Parse.LiveQuery.on('error', (error) => {
*
* });</pre></p>
*
* @class Parse.LiveQuery
* @static
*/
var LiveQuery = class {
constructor() {
const Emitter = CoreManager.getEventEmitter();
this.emitter = new Emitter();
this.on = (eventName, listener) => this.emitter.on(eventName, listener);
this.emit = (eventName, ...args) => this.emitter.emit(eventName, ...args);
this.on("error", () => {});
}
/**
* After open is called, the LiveQuery will try to send a connect request
* to the LiveQuery server.
*/
async open() {
(await getLiveQueryClient()).open();
}
/**
* When you're done using LiveQuery, you can call Parse.LiveQuery.close().
* This function will close the WebSocket connection to the LiveQuery server,
* cancel the auto reconnect, and unsubscribe all subscriptions based on it.
* If you call query.subscribe() after this, we'll create a new WebSocket
* connection to the LiveQuery server.
*/
async close() {
(await getLiveQueryClient()).close();
}
};
var defaultLiveQueryClient;
CoreManager.setLiveQueryController({
setDefaultLiveQueryClient(liveQueryClient) {
defaultLiveQueryClient = liveQueryClient;
},
async getDefaultLiveQueryClient() {
if (defaultLiveQueryClient) return defaultLiveQueryClient;
const [currentUser, installationId] = await Promise.all([CoreManager.getUserController().currentUserAsync(), CoreManager.getInstallationController().currentInstallationId()]);
const sessionToken = currentUser ? currentUser.getSessionToken() : void 0;
let liveQueryServerURL = CoreManager.get("LIVEQUERY_SERVER_URL");
if (liveQueryServerURL && liveQueryServerURL.indexOf("ws") !== 0) throw new Error("You need to set a proper Parse LiveQuery server url before using LiveQueryClient");
if (!liveQueryServerURL) {
const serverURL = CoreManager.get("SERVER_URL");
liveQueryServerURL = (serverURL.indexOf("https") === 0 ? "wss://" : "ws://") + serverURL.replace(/^https?:\/\//, "");
CoreManager.set("LIVEQUERY_SERVER_URL", liveQueryServerURL);
}
const applicationId = CoreManager.get("APPLICATION_ID");
const javascriptKey = CoreManager.get("JAVASCRIPT_KEY");
const masterKey = CoreManager.get("MASTER_KEY");
defaultLiveQueryClient = new LiveQueryClient({
applicationId,
serverURL: liveQueryServerURL,
javascriptKey,
masterKey,
sessionToken,
installationId
});
const LiveQuery = CoreManager.getLiveQuery();
defaultLiveQueryClient.on("error", (error) => {
LiveQuery.emit("error", error);
});
defaultLiveQueryClient.on("open", () => {
LiveQuery.emit("open");
});
defaultLiveQueryClient.on("close", () => {
LiveQuery.emit("close");
});
return defaultLiveQueryClient;
},
_clearCachedDefaultClient() {
defaultLiveQueryClient = null;
}
});
//#endregion
//#region src/StorageController.weapp.ts
var StorageController$2 = {
async: 0,
getItem(path) {
return wx.getStorageSync(path);
},
setItem(path, value) {
try {
wx.setStorageSync(path, value);
} catch (_) {}
},
removeItem(path) {
wx.removeStorageSync(path);
},
getAllKeys() {
return wx.getStorageInfoSync().keys;
},
clear() {
wx.clearStorageSync();
}
};
//#endregion
//#region src/StorageController.default.ts
var memMap = {};
var StorageController$1 = {
async: 0,
getItem(path) {
if (Object.hasOwn(memMap, path)) return memMap[path];
return null;
},
setItem(path, value) {
memMap[path] = String(value);
},
removeItem(path) {
delete memMap[path];
},
getAllKeys() {
return Object.keys(memMap);
},
clear() {
for (const key in memMap) if (Object.hasOwn(memMap, key)) delete memMap[key];
}
};
//#endregion
//#region src/StorageController.ts
var StorageController = StorageController$1;
StorageController = StorageController$2;
var StorageController_default = StorageController;
//#endregion
//#region node_modules/ws/browser.js
var require_browser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = function() {
throw new Error("ws does not work in the browser. Browser clients must use the native WebSocket object");
};
}));
//#endregion
//#region src/Socket.weapp.ts
var import_browser = /* @__PURE__ */ __toESM(require_browser());
var Socket_weapp_exports = /* @__PURE__ */ __exportAll({ default: () => SocketWeapp });
var SocketWeapp = class {
constructor(serverURL) {
this.onopen = () => {};
this.onmessage = () => {};
this.onclose = () => {};
this.onerror = () => {};
wx.onSocketOpen(() => {
this.onopen();
});
wx.onSocketMessage((msg) => {
this.onmessage(msg);
});
wx.onSocketClose((event) => {
this.onclose(event);
});
wx.onSocketError((error) => {
this.onerror(error);
});
wx.connectSocket({ url: serverURL });
}
send(data) {
wx.sendSocketMessage({ data });
}
close() {
wx.closeSocket();
}
};
//#endregion
//#region src/WebSocketController.ts
var WebSocketController;
try {
WebSocketController = SocketWeapp || Socket_weapp_exports;
} catch (_) {}
var WebSocketController_default = WebSocketController;
//#endregion
//#region src/Parse.ts
var Parse = {
ACL: ParseACL,
Analytics: Analytics_exports,
AnonymousUtils,
Cloud: Cloud_exports,
CLP: ParseCLP,
CoreManager,
Config: ParseConfig,
Error: ParseError,
FacebookUtils,
File: ParseFile,
GeoPoint: ParseGeoPoint,
Polygon: ParsePolygon,
Installation: ParseInstallation,
LocalDatastore,
Object: ParseObject,
Op: {
Set: SetOp,
Unset: UnsetOp,
Increment: IncrementOp,
Add: AddOp,
Remove: RemoveOp,
AddUnique: AddUniqueOp,
Relation: RelationOp
},
Push: Push_exports,
Query: ParseQuery,
Relation: ParseRelation,
Role: ParseRole,
Schema: ParseSchema,
Session: ParseSession,
Storage,
User: ParseUser,
LiveQueryClient,
IndexedDB: void 0,
Hooks: void 0,
Parse: void 0,
set EventuallyQueue(queue) {
CoreManager.setEventuallyQueue(queue);
},
get EventuallyQueue() {
return CoreManager.getEventuallyQueue();
},
initialize(applicationId, javaScriptKey) {
Parse._initialize(applicationId, javaScriptKey);
},
_initialize(applicationId, javaScriptKey, masterKey, maintenanceKey) {
CoreManager.set("APPLICATION_ID", applicationId);
CoreManager.set("JAVASCRIPT_KEY", javaScriptKey);
CoreManager.set("MAINTENANCE_KEY", maintenanceKey);
CoreManager.set("MASTER_KEY", masterKey);
CoreManager.set("USE_MASTER_KEY", false);
CoreManager.setIfNeeded("EventEmitter", EventEmitter_default);
CoreManager.setIfNeeded("LiveQuery", new LiveQuery());
CoreManager.setIfNeeded("CryptoController", CryptoController);
CoreManager.setIfNeeded("EventuallyQueue", EventuallyQueue);
CoreManager.setIfNeeded("InstallationController", InstallationController);
CoreManager.setIfNeeded("LocalDatastoreController", LocalDatastoreController);
CoreManager.setIfNeeded("StorageController", StorageController_default);
CoreManager.setIfNeeded("WebSocketController", WebSocketController_default);
},
setAsyncStorage(storage) {
CoreManager.setAsyncStorage(storage);
},
setLocalDatastoreController(controller) {
CoreManager.setLocalDatastoreController(controller);
},
getServerHealth() {
return CoreManager.getRESTController().request("GET", "health");
},
set applicationId(value) {
CoreManager.set("APPLICATION_ID", value);
},
get applicationId() {
return CoreManager.get("APPLICATION_ID");
},
set javaScriptKey(value) {
CoreManager.set("JAVASCRIPT_KEY", value);
},
get javaScriptKey() {
return CoreManager.get("JAVASCRIPT_KEY");
},
set masterKey(value) {
CoreManager.set("MASTER_KEY", value);
},
get masterKey() {
return CoreManager.get("MASTER_KEY");
},
set maintenanceKey(value) {
CoreManager.set("MAINTENANCE_KEY", value);
},
get maintenanceKey() {
return CoreManager.get("MAINTENANCE_KEY");
},
set serverURL(value) {
CoreManager.set("SERVER_URL", value);
},
get serverURL() {
return CoreManager.get("SERVER_URL");
},
set LiveQuery(liveQuery) {
CoreManager.setLiveQuery(liveQuery);
},
get LiveQuery() {
return CoreManager.getLiveQuery();
},
set liveQueryServerURL(value) {
CoreManager.set("LIVEQUERY_SERVER_URL", value);
},
get liveQueryServerURL() {
return CoreManager.get("LIVEQUERY_SERVER_URL");
},
set encryptedUser(value) {
CoreManager.set("ENCRYPTED_USER", value);
},
get encryptedUser() {
return CoreManager.get("ENCRYPTED_USER");
},
set secret(value) {
CoreManager.set("ENCRYPTED_KEY", value);
},
get secret() {
return CoreManager.get("ENCRYPTED_KEY");
},
set idempotency(value) {
CoreManager.set("IDEMPOTENCY", value);
},
get idempotency() {
return CoreManager.get("IDEMPOTENCY");
},
set allowCustomObjectId(value) {
CoreManager.set("ALLOW_CUSTOM_OBJECT_ID", value);
},
get allowCustomObjectId() {
return CoreManager.get("ALLOW_CUSTOM_OBJECT_ID");
},
set nodeLogging(value) {
CoreManager.set("NODE_LOGGING", value);
},
get nodeLogging() {
return CoreManager.get("NODE_LOGGING");
},
_request(...args) {
return CoreManager.getRESTController().request.apply(null, args);
},
_ajax(...args) {
return CoreManager.getRESTController().ajax.apply(null, args);
},
_decode(_, value) {
return decode(value);
},
_encode(value, _, disallowObjects) {
return encode_default(value, disallowObjects);
},
_getInstallationId() {
return CoreManager.getInstallationController().currentInstallationId();
},
enableLocalDatastore(polling, ms) {
if (!this.applicationId) {
console.log("'enableLocalDatastore' must be called after 'initialize'");
return;
}
if (!this.LocalDatastore.isEnabled) {
this.LocalDatastore.isEnabled = true;
if (polling || typeof polling === "undefined") CoreManager.getEventuallyQueue().poll(ms || 2e3);
}
},
isLocalDatastoreEnabled() {
return this.LocalDatastore.isEnabled;
},
dumpLocalDatastore() {
if (!this.LocalDatastore.isEnabled) {
console.log("Parse.enableLocalDatastore() must be called first");
return Promise.resolve({});
} else return Parse.LocalDatastore._getAllContents();
},
enableEncryptedUser() {
this.encryptedUser = true;
},
isEncryptedUserEnabled() {
return this.encryptedUser;
}
};
CoreManager.setRESTController(RESTController);
Parse.Parse = Parse;
//#endregion
});