20623 lines
2.3 MiB
20623 lines
2.3 MiB
// @bun
|
|
var __create = Object.create;
|
|
var __getProtoOf = Object.getPrototypeOf;
|
|
var __defProp = Object.defineProperty;
|
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
var __toESM = (mod, isNodeMode, target) => {
|
|
target = mod != null ? __create(__getProtoOf(mod)) : {};
|
|
const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
|
|
for (let key of __getOwnPropNames(mod))
|
|
if (!__hasOwnProp.call(to, key))
|
|
__defProp(to, key, {
|
|
get: () => mod[key],
|
|
enumerable: true
|
|
});
|
|
return to;
|
|
};
|
|
var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
|
|
var __require = import.meta.require;
|
|
|
|
// ../eve/node_modules/safe-buffer/index.js
|
|
var require_safe_buffer = __commonJS((exports, module) => {
|
|
/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
|
|
var buffer = __require("buffer");
|
|
var Buffer2 = buffer.Buffer;
|
|
function copyProps(src, dst) {
|
|
for (var key in src) {
|
|
dst[key] = src[key];
|
|
}
|
|
}
|
|
if (Buffer2.from && Buffer2.alloc && Buffer2.allocUnsafe && Buffer2.allocUnsafeSlow) {
|
|
module.exports = buffer;
|
|
} else {
|
|
copyProps(buffer, exports);
|
|
exports.Buffer = SafeBuffer;
|
|
}
|
|
function SafeBuffer(arg, encodingOrOffset, length) {
|
|
return Buffer2(arg, encodingOrOffset, length);
|
|
}
|
|
SafeBuffer.prototype = Object.create(Buffer2.prototype);
|
|
copyProps(Buffer2, SafeBuffer);
|
|
SafeBuffer.from = function(arg, encodingOrOffset, length) {
|
|
if (typeof arg === "number") {
|
|
throw new TypeError("Argument must not be a number");
|
|
}
|
|
return Buffer2(arg, encodingOrOffset, length);
|
|
};
|
|
SafeBuffer.alloc = function(size, fill, encoding) {
|
|
if (typeof size !== "number") {
|
|
throw new TypeError("Argument must be a number");
|
|
}
|
|
var buf = Buffer2(size);
|
|
if (fill !== undefined) {
|
|
if (typeof encoding === "string") {
|
|
buf.fill(fill, encoding);
|
|
} else {
|
|
buf.fill(fill);
|
|
}
|
|
} else {
|
|
buf.fill(0);
|
|
}
|
|
return buf;
|
|
};
|
|
SafeBuffer.allocUnsafe = function(size) {
|
|
if (typeof size !== "number") {
|
|
throw new TypeError("Argument must be a number");
|
|
}
|
|
return Buffer2(size);
|
|
};
|
|
SafeBuffer.allocUnsafeSlow = function(size) {
|
|
if (typeof size !== "number") {
|
|
throw new TypeError("Argument must be a number");
|
|
}
|
|
return buffer.SlowBuffer(size);
|
|
};
|
|
});
|
|
|
|
// ../eve/node_modules/jws/lib/data-stream.js
|
|
var require_data_stream = __commonJS((exports, module) => {
|
|
var Buffer2 = require_safe_buffer().Buffer;
|
|
var Stream = __require("stream");
|
|
var util = __require("util");
|
|
function DataStream(data) {
|
|
this.buffer = null;
|
|
this.writable = true;
|
|
this.readable = true;
|
|
if (!data) {
|
|
this.buffer = Buffer2.alloc(0);
|
|
return this;
|
|
}
|
|
if (typeof data.pipe === "function") {
|
|
this.buffer = Buffer2.alloc(0);
|
|
data.pipe(this);
|
|
return this;
|
|
}
|
|
if (data.length || typeof data === "object") {
|
|
this.buffer = data;
|
|
this.writable = false;
|
|
process.nextTick(function() {
|
|
this.emit("end", data);
|
|
this.readable = false;
|
|
this.emit("close");
|
|
}.bind(this));
|
|
return this;
|
|
}
|
|
throw new TypeError("Unexpected data type (" + typeof data + ")");
|
|
}
|
|
util.inherits(DataStream, Stream);
|
|
DataStream.prototype.write = function write(data) {
|
|
this.buffer = Buffer2.concat([this.buffer, Buffer2.from(data)]);
|
|
this.emit("data", data);
|
|
};
|
|
DataStream.prototype.end = function end(data) {
|
|
if (data)
|
|
this.write(data);
|
|
this.emit("end", data);
|
|
this.emit("close");
|
|
this.writable = false;
|
|
this.readable = false;
|
|
};
|
|
module.exports = DataStream;
|
|
});
|
|
|
|
// ../eve/node_modules/ecdsa-sig-formatter/src/param-bytes-for-alg.js
|
|
var require_param_bytes_for_alg = __commonJS((exports, module) => {
|
|
function getParamSize(keySize) {
|
|
var result = (keySize / 8 | 0) + (keySize % 8 === 0 ? 0 : 1);
|
|
return result;
|
|
}
|
|
var paramBytesForAlg = {
|
|
ES256: getParamSize(256),
|
|
ES384: getParamSize(384),
|
|
ES512: getParamSize(521)
|
|
};
|
|
function getParamBytesForAlg(alg) {
|
|
var paramBytes = paramBytesForAlg[alg];
|
|
if (paramBytes) {
|
|
return paramBytes;
|
|
}
|
|
throw new Error('Unknown algorithm "' + alg + '"');
|
|
}
|
|
module.exports = getParamBytesForAlg;
|
|
});
|
|
|
|
// ../eve/node_modules/ecdsa-sig-formatter/src/ecdsa-sig-formatter.js
|
|
var require_ecdsa_sig_formatter = __commonJS((exports, module) => {
|
|
var Buffer2 = require_safe_buffer().Buffer;
|
|
var getParamBytesForAlg = require_param_bytes_for_alg();
|
|
var MAX_OCTET = 128;
|
|
var CLASS_UNIVERSAL = 0;
|
|
var PRIMITIVE_BIT = 32;
|
|
var TAG_SEQ = 16;
|
|
var TAG_INT = 2;
|
|
var ENCODED_TAG_SEQ = TAG_SEQ | PRIMITIVE_BIT | CLASS_UNIVERSAL << 6;
|
|
var ENCODED_TAG_INT = TAG_INT | CLASS_UNIVERSAL << 6;
|
|
function base64Url(base64) {
|
|
return base64.replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
|
|
}
|
|
function signatureAsBuffer(signature) {
|
|
if (Buffer2.isBuffer(signature)) {
|
|
return signature;
|
|
} else if (typeof signature === "string") {
|
|
return Buffer2.from(signature, "base64");
|
|
}
|
|
throw new TypeError("ECDSA signature must be a Base64 string or a Buffer");
|
|
}
|
|
function derToJose(signature, alg) {
|
|
signature = signatureAsBuffer(signature);
|
|
var paramBytes = getParamBytesForAlg(alg);
|
|
var maxEncodedParamLength = paramBytes + 1;
|
|
var inputLength = signature.length;
|
|
var offset = 0;
|
|
if (signature[offset++] !== ENCODED_TAG_SEQ) {
|
|
throw new Error('Could not find expected "seq"');
|
|
}
|
|
var seqLength = signature[offset++];
|
|
if (seqLength === (MAX_OCTET | 1)) {
|
|
seqLength = signature[offset++];
|
|
}
|
|
if (inputLength - offset < seqLength) {
|
|
throw new Error('"seq" specified length of "' + seqLength + '", only "' + (inputLength - offset) + '" remaining');
|
|
}
|
|
if (signature[offset++] !== ENCODED_TAG_INT) {
|
|
throw new Error('Could not find expected "int" for "r"');
|
|
}
|
|
var rLength = signature[offset++];
|
|
if (inputLength - offset - 2 < rLength) {
|
|
throw new Error('"r" specified length of "' + rLength + '", only "' + (inputLength - offset - 2) + '" available');
|
|
}
|
|
if (maxEncodedParamLength < rLength) {
|
|
throw new Error('"r" specified length of "' + rLength + '", max of "' + maxEncodedParamLength + '" is acceptable');
|
|
}
|
|
var rOffset = offset;
|
|
offset += rLength;
|
|
if (signature[offset++] !== ENCODED_TAG_INT) {
|
|
throw new Error('Could not find expected "int" for "s"');
|
|
}
|
|
var sLength = signature[offset++];
|
|
if (inputLength - offset !== sLength) {
|
|
throw new Error('"s" specified length of "' + sLength + '", expected "' + (inputLength - offset) + '"');
|
|
}
|
|
if (maxEncodedParamLength < sLength) {
|
|
throw new Error('"s" specified length of "' + sLength + '", max of "' + maxEncodedParamLength + '" is acceptable');
|
|
}
|
|
var sOffset = offset;
|
|
offset += sLength;
|
|
if (offset !== inputLength) {
|
|
throw new Error('Expected to consume entire buffer, but "' + (inputLength - offset) + '" bytes remain');
|
|
}
|
|
var rPadding = paramBytes - rLength, sPadding = paramBytes - sLength;
|
|
var dst = Buffer2.allocUnsafe(rPadding + rLength + sPadding + sLength);
|
|
for (offset = 0;offset < rPadding; ++offset) {
|
|
dst[offset] = 0;
|
|
}
|
|
signature.copy(dst, offset, rOffset + Math.max(-rPadding, 0), rOffset + rLength);
|
|
offset = paramBytes;
|
|
for (var o = offset;offset < o + sPadding; ++offset) {
|
|
dst[offset] = 0;
|
|
}
|
|
signature.copy(dst, offset, sOffset + Math.max(-sPadding, 0), sOffset + sLength);
|
|
dst = dst.toString("base64");
|
|
dst = base64Url(dst);
|
|
return dst;
|
|
}
|
|
function countPadding(buf, start, stop) {
|
|
var padding = 0;
|
|
while (start + padding < stop && buf[start + padding] === 0) {
|
|
++padding;
|
|
}
|
|
var needsSign = buf[start + padding] >= MAX_OCTET;
|
|
if (needsSign) {
|
|
--padding;
|
|
}
|
|
return padding;
|
|
}
|
|
function joseToDer(signature, alg) {
|
|
signature = signatureAsBuffer(signature);
|
|
var paramBytes = getParamBytesForAlg(alg);
|
|
var signatureBytes = signature.length;
|
|
if (signatureBytes !== paramBytes * 2) {
|
|
throw new TypeError('"' + alg + '" signatures must be "' + paramBytes * 2 + '" bytes, saw "' + signatureBytes + '"');
|
|
}
|
|
var rPadding = countPadding(signature, 0, paramBytes);
|
|
var sPadding = countPadding(signature, paramBytes, signature.length);
|
|
var rLength = paramBytes - rPadding;
|
|
var sLength = paramBytes - sPadding;
|
|
var rsBytes = 1 + 1 + rLength + 1 + 1 + sLength;
|
|
var shortLength = rsBytes < MAX_OCTET;
|
|
var dst = Buffer2.allocUnsafe((shortLength ? 2 : 3) + rsBytes);
|
|
var offset = 0;
|
|
dst[offset++] = ENCODED_TAG_SEQ;
|
|
if (shortLength) {
|
|
dst[offset++] = rsBytes;
|
|
} else {
|
|
dst[offset++] = MAX_OCTET | 1;
|
|
dst[offset++] = rsBytes & 255;
|
|
}
|
|
dst[offset++] = ENCODED_TAG_INT;
|
|
dst[offset++] = rLength;
|
|
if (rPadding < 0) {
|
|
dst[offset++] = 0;
|
|
offset += signature.copy(dst, offset, 0, paramBytes);
|
|
} else {
|
|
offset += signature.copy(dst, offset, rPadding, paramBytes);
|
|
}
|
|
dst[offset++] = ENCODED_TAG_INT;
|
|
dst[offset++] = sLength;
|
|
if (sPadding < 0) {
|
|
dst[offset++] = 0;
|
|
signature.copy(dst, offset, paramBytes);
|
|
} else {
|
|
signature.copy(dst, offset, paramBytes + sPadding);
|
|
}
|
|
return dst;
|
|
}
|
|
module.exports = {
|
|
derToJose,
|
|
joseToDer
|
|
};
|
|
});
|
|
|
|
// ../eve/node_modules/buffer-equal-constant-time/index.js
|
|
var require_buffer_equal_constant_time = __commonJS((exports, module) => {
|
|
var Buffer2 = __require("buffer").Buffer;
|
|
var SlowBuffer = __require("buffer").SlowBuffer;
|
|
module.exports = bufferEq;
|
|
function bufferEq(a, b) {
|
|
if (!Buffer2.isBuffer(a) || !Buffer2.isBuffer(b)) {
|
|
return false;
|
|
}
|
|
if (a.length !== b.length) {
|
|
return false;
|
|
}
|
|
var c = 0;
|
|
for (var i = 0;i < a.length; i++) {
|
|
c |= a[i] ^ b[i];
|
|
}
|
|
return c === 0;
|
|
}
|
|
bufferEq.install = function() {
|
|
Buffer2.prototype.equal = SlowBuffer.prototype.equal = function equal(that) {
|
|
return bufferEq(this, that);
|
|
};
|
|
};
|
|
var origBufEqual = Buffer2.prototype.equal;
|
|
var origSlowBufEqual = SlowBuffer.prototype.equal;
|
|
bufferEq.restore = function() {
|
|
Buffer2.prototype.equal = origBufEqual;
|
|
SlowBuffer.prototype.equal = origSlowBufEqual;
|
|
};
|
|
});
|
|
|
|
// ../eve/node_modules/jwa/index.js
|
|
var require_jwa = __commonJS((exports, module) => {
|
|
var Buffer2 = require_safe_buffer().Buffer;
|
|
var crypto2 = __require("crypto");
|
|
var formatEcdsa = require_ecdsa_sig_formatter();
|
|
var util = __require("util");
|
|
var MSG_INVALID_ALGORITHM = `"%s" is not a valid algorithm.
|
|
Supported algorithms are:
|
|
"HS256", "HS384", "HS512", "RS256", "RS384", "RS512", "PS256", "PS384", "PS512", "ES256", "ES384", "ES512" and "none".`;
|
|
var MSG_INVALID_SECRET = "secret must be a string or buffer";
|
|
var MSG_INVALID_VERIFIER_KEY = "key must be a string or a buffer";
|
|
var MSG_INVALID_SIGNER_KEY = "key must be a string, a buffer or an object";
|
|
var supportsKeyObjects = typeof crypto2.createPublicKey === "function";
|
|
if (supportsKeyObjects) {
|
|
MSG_INVALID_VERIFIER_KEY += " or a KeyObject";
|
|
MSG_INVALID_SECRET += "or a KeyObject";
|
|
}
|
|
function checkIsPublicKey(key) {
|
|
if (Buffer2.isBuffer(key)) {
|
|
return;
|
|
}
|
|
if (typeof key === "string") {
|
|
return;
|
|
}
|
|
if (!supportsKeyObjects) {
|
|
throw typeError(MSG_INVALID_VERIFIER_KEY);
|
|
}
|
|
if (typeof key !== "object") {
|
|
throw typeError(MSG_INVALID_VERIFIER_KEY);
|
|
}
|
|
if (typeof key.type !== "string") {
|
|
throw typeError(MSG_INVALID_VERIFIER_KEY);
|
|
}
|
|
if (typeof key.asymmetricKeyType !== "string") {
|
|
throw typeError(MSG_INVALID_VERIFIER_KEY);
|
|
}
|
|
if (typeof key.export !== "function") {
|
|
throw typeError(MSG_INVALID_VERIFIER_KEY);
|
|
}
|
|
}
|
|
function checkIsPrivateKey(key) {
|
|
if (Buffer2.isBuffer(key)) {
|
|
return;
|
|
}
|
|
if (typeof key === "string") {
|
|
return;
|
|
}
|
|
if (typeof key === "object") {
|
|
return;
|
|
}
|
|
throw typeError(MSG_INVALID_SIGNER_KEY);
|
|
}
|
|
function checkIsSecretKey(key) {
|
|
if (Buffer2.isBuffer(key)) {
|
|
return;
|
|
}
|
|
if (typeof key === "string") {
|
|
return key;
|
|
}
|
|
if (!supportsKeyObjects) {
|
|
throw typeError(MSG_INVALID_SECRET);
|
|
}
|
|
if (typeof key !== "object") {
|
|
throw typeError(MSG_INVALID_SECRET);
|
|
}
|
|
if (key.type !== "secret") {
|
|
throw typeError(MSG_INVALID_SECRET);
|
|
}
|
|
if (typeof key.export !== "function") {
|
|
throw typeError(MSG_INVALID_SECRET);
|
|
}
|
|
}
|
|
function fromBase64(base64) {
|
|
return base64.replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
|
|
}
|
|
function toBase64(base64url) {
|
|
base64url = base64url.toString();
|
|
var padding = 4 - base64url.length % 4;
|
|
if (padding !== 4) {
|
|
for (var i = 0;i < padding; ++i) {
|
|
base64url += "=";
|
|
}
|
|
}
|
|
return base64url.replace(/\-/g, "+").replace(/_/g, "/");
|
|
}
|
|
function typeError(template) {
|
|
var args = [].slice.call(arguments, 1);
|
|
var errMsg = util.format.bind(util, template).apply(null, args);
|
|
return new TypeError(errMsg);
|
|
}
|
|
function bufferOrString(obj) {
|
|
return Buffer2.isBuffer(obj) || typeof obj === "string";
|
|
}
|
|
function normalizeInput(thing) {
|
|
if (!bufferOrString(thing))
|
|
thing = JSON.stringify(thing);
|
|
return thing;
|
|
}
|
|
function createHmacSigner(bits) {
|
|
return function sign(thing, secret) {
|
|
checkIsSecretKey(secret);
|
|
thing = normalizeInput(thing);
|
|
var hmac = crypto2.createHmac("sha" + bits, secret);
|
|
var sig = (hmac.update(thing), hmac.digest("base64"));
|
|
return fromBase64(sig);
|
|
};
|
|
}
|
|
var bufferEqual;
|
|
var timingSafeEqual = "timingSafeEqual" in crypto2 ? function timingSafeEqual(a, b) {
|
|
if (a.byteLength !== b.byteLength) {
|
|
return false;
|
|
}
|
|
return crypto2.timingSafeEqual(a, b);
|
|
} : function timingSafeEqual(a, b) {
|
|
if (!bufferEqual) {
|
|
bufferEqual = require_buffer_equal_constant_time();
|
|
}
|
|
return bufferEqual(a, b);
|
|
};
|
|
function createHmacVerifier(bits) {
|
|
return function verify(thing, signature, secret) {
|
|
var computedSig = createHmacSigner(bits)(thing, secret);
|
|
return timingSafeEqual(Buffer2.from(signature), Buffer2.from(computedSig));
|
|
};
|
|
}
|
|
function createKeySigner(bits) {
|
|
return function sign(thing, privateKey) {
|
|
checkIsPrivateKey(privateKey);
|
|
thing = normalizeInput(thing);
|
|
var signer = crypto2.createSign("RSA-SHA" + bits);
|
|
var sig = (signer.update(thing), signer.sign(privateKey, "base64"));
|
|
return fromBase64(sig);
|
|
};
|
|
}
|
|
function createKeyVerifier(bits) {
|
|
return function verify(thing, signature, publicKey) {
|
|
checkIsPublicKey(publicKey);
|
|
thing = normalizeInput(thing);
|
|
signature = toBase64(signature);
|
|
var verifier = crypto2.createVerify("RSA-SHA" + bits);
|
|
verifier.update(thing);
|
|
return verifier.verify(publicKey, signature, "base64");
|
|
};
|
|
}
|
|
function createPSSKeySigner(bits) {
|
|
return function sign(thing, privateKey) {
|
|
checkIsPrivateKey(privateKey);
|
|
thing = normalizeInput(thing);
|
|
var signer = crypto2.createSign("RSA-SHA" + bits);
|
|
var sig = (signer.update(thing), signer.sign({
|
|
key: privateKey,
|
|
padding: crypto2.constants.RSA_PKCS1_PSS_PADDING,
|
|
saltLength: crypto2.constants.RSA_PSS_SALTLEN_DIGEST
|
|
}, "base64"));
|
|
return fromBase64(sig);
|
|
};
|
|
}
|
|
function createPSSKeyVerifier(bits) {
|
|
return function verify(thing, signature, publicKey) {
|
|
checkIsPublicKey(publicKey);
|
|
thing = normalizeInput(thing);
|
|
signature = toBase64(signature);
|
|
var verifier = crypto2.createVerify("RSA-SHA" + bits);
|
|
verifier.update(thing);
|
|
return verifier.verify({
|
|
key: publicKey,
|
|
padding: crypto2.constants.RSA_PKCS1_PSS_PADDING,
|
|
saltLength: crypto2.constants.RSA_PSS_SALTLEN_DIGEST
|
|
}, signature, "base64");
|
|
};
|
|
}
|
|
function createECDSASigner(bits) {
|
|
var inner = createKeySigner(bits);
|
|
return function sign() {
|
|
var signature = inner.apply(null, arguments);
|
|
signature = formatEcdsa.derToJose(signature, "ES" + bits);
|
|
return signature;
|
|
};
|
|
}
|
|
function createECDSAVerifer(bits) {
|
|
var inner = createKeyVerifier(bits);
|
|
return function verify(thing, signature, publicKey) {
|
|
signature = formatEcdsa.joseToDer(signature, "ES" + bits).toString("base64");
|
|
var result = inner(thing, signature, publicKey);
|
|
return result;
|
|
};
|
|
}
|
|
function createNoneSigner() {
|
|
return function sign() {
|
|
return "";
|
|
};
|
|
}
|
|
function createNoneVerifier() {
|
|
return function verify(thing, signature) {
|
|
return signature === "";
|
|
};
|
|
}
|
|
module.exports = function jwa(algorithm) {
|
|
var signerFactories = {
|
|
hs: createHmacSigner,
|
|
rs: createKeySigner,
|
|
ps: createPSSKeySigner,
|
|
es: createECDSASigner,
|
|
none: createNoneSigner
|
|
};
|
|
var verifierFactories = {
|
|
hs: createHmacVerifier,
|
|
rs: createKeyVerifier,
|
|
ps: createPSSKeyVerifier,
|
|
es: createECDSAVerifer,
|
|
none: createNoneVerifier
|
|
};
|
|
var match = algorithm.match(/^(RS|PS|ES|HS)(256|384|512)$|^(none)$/i);
|
|
if (!match)
|
|
throw typeError(MSG_INVALID_ALGORITHM, algorithm);
|
|
var algo = (match[1] || match[3]).toLowerCase();
|
|
var bits = match[2];
|
|
return {
|
|
sign: signerFactories[algo](bits),
|
|
verify: verifierFactories[algo](bits)
|
|
};
|
|
};
|
|
});
|
|
|
|
// ../eve/node_modules/jws/lib/tostring.js
|
|
var require_tostring = __commonJS((exports, module) => {
|
|
var Buffer2 = __require("buffer").Buffer;
|
|
module.exports = function toString(obj) {
|
|
if (typeof obj === "string")
|
|
return obj;
|
|
if (typeof obj === "number" || Buffer2.isBuffer(obj))
|
|
return obj.toString();
|
|
return JSON.stringify(obj);
|
|
};
|
|
});
|
|
|
|
// ../eve/node_modules/jws/lib/sign-stream.js
|
|
var require_sign_stream = __commonJS((exports, module) => {
|
|
var Buffer2 = require_safe_buffer().Buffer;
|
|
var DataStream = require_data_stream();
|
|
var jwa = require_jwa();
|
|
var Stream = __require("stream");
|
|
var toString = require_tostring();
|
|
var util = __require("util");
|
|
function base64url(string, encoding) {
|
|
return Buffer2.from(string, encoding).toString("base64").replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
|
|
}
|
|
function jwsSecuredInput(header, payload, encoding) {
|
|
encoding = encoding || "utf8";
|
|
var encodedHeader = base64url(toString(header), "binary");
|
|
var encodedPayload = base64url(toString(payload), encoding);
|
|
return util.format("%s.%s", encodedHeader, encodedPayload);
|
|
}
|
|
function jwsSign(opts) {
|
|
var header = opts.header;
|
|
var payload = opts.payload;
|
|
var secretOrKey = opts.secret || opts.privateKey;
|
|
var encoding = opts.encoding;
|
|
var algo = jwa(header.alg);
|
|
var securedInput = jwsSecuredInput(header, payload, encoding);
|
|
var signature = algo.sign(securedInput, secretOrKey);
|
|
return util.format("%s.%s", securedInput, signature);
|
|
}
|
|
function SignStream(opts) {
|
|
var secret = opts.secret || opts.privateKey || opts.key;
|
|
var secretStream = new DataStream(secret);
|
|
this.readable = true;
|
|
this.header = opts.header;
|
|
this.encoding = opts.encoding;
|
|
this.secret = this.privateKey = this.key = secretStream;
|
|
this.payload = new DataStream(opts.payload);
|
|
this.secret.once("close", function() {
|
|
if (!this.payload.writable && this.readable)
|
|
this.sign();
|
|
}.bind(this));
|
|
this.payload.once("close", function() {
|
|
if (!this.secret.writable && this.readable)
|
|
this.sign();
|
|
}.bind(this));
|
|
}
|
|
util.inherits(SignStream, Stream);
|
|
SignStream.prototype.sign = function sign() {
|
|
try {
|
|
var signature = jwsSign({
|
|
header: this.header,
|
|
payload: this.payload.buffer,
|
|
secret: this.secret.buffer,
|
|
encoding: this.encoding
|
|
});
|
|
this.emit("done", signature);
|
|
this.emit("data", signature);
|
|
this.emit("end");
|
|
this.readable = false;
|
|
return signature;
|
|
} catch (e) {
|
|
this.readable = false;
|
|
this.emit("error", e);
|
|
this.emit("close");
|
|
}
|
|
};
|
|
SignStream.sign = jwsSign;
|
|
module.exports = SignStream;
|
|
});
|
|
|
|
// ../eve/node_modules/jws/lib/verify-stream.js
|
|
var require_verify_stream = __commonJS((exports, module) => {
|
|
var Buffer2 = require_safe_buffer().Buffer;
|
|
var DataStream = require_data_stream();
|
|
var jwa = require_jwa();
|
|
var Stream = __require("stream");
|
|
var toString = require_tostring();
|
|
var util = __require("util");
|
|
var JWS_REGEX = /^[a-zA-Z0-9\-_]+?\.[a-zA-Z0-9\-_]+?\.([a-zA-Z0-9\-_]+)?$/;
|
|
function isObject(thing) {
|
|
return Object.prototype.toString.call(thing) === "[object Object]";
|
|
}
|
|
function safeJsonParse(thing) {
|
|
if (isObject(thing))
|
|
return thing;
|
|
try {
|
|
return JSON.parse(thing);
|
|
} catch (e) {
|
|
return;
|
|
}
|
|
}
|
|
function headerFromJWS(jwsSig) {
|
|
var encodedHeader = jwsSig.split(".", 1)[0];
|
|
return safeJsonParse(Buffer2.from(encodedHeader, "base64").toString("binary"));
|
|
}
|
|
function securedInputFromJWS(jwsSig) {
|
|
return jwsSig.split(".", 2).join(".");
|
|
}
|
|
function signatureFromJWS(jwsSig) {
|
|
return jwsSig.split(".")[2];
|
|
}
|
|
function payloadFromJWS(jwsSig, encoding) {
|
|
encoding = encoding || "utf8";
|
|
var payload = jwsSig.split(".")[1];
|
|
return Buffer2.from(payload, "base64").toString(encoding);
|
|
}
|
|
function isValidJws(string) {
|
|
return JWS_REGEX.test(string) && !!headerFromJWS(string);
|
|
}
|
|
function jwsVerify(jwsSig, algorithm, secretOrKey) {
|
|
if (!algorithm) {
|
|
var err = new Error("Missing algorithm parameter for jws.verify");
|
|
err.code = "MISSING_ALGORITHM";
|
|
throw err;
|
|
}
|
|
jwsSig = toString(jwsSig);
|
|
var signature = signatureFromJWS(jwsSig);
|
|
var securedInput = securedInputFromJWS(jwsSig);
|
|
var algo = jwa(algorithm);
|
|
return algo.verify(securedInput, signature, secretOrKey);
|
|
}
|
|
function jwsDecode(jwsSig, opts) {
|
|
opts = opts || {};
|
|
jwsSig = toString(jwsSig);
|
|
if (!isValidJws(jwsSig))
|
|
return null;
|
|
var header = headerFromJWS(jwsSig);
|
|
if (!header)
|
|
return null;
|
|
var payload = payloadFromJWS(jwsSig);
|
|
if (header.typ === "JWT" || opts.json)
|
|
payload = JSON.parse(payload, opts.encoding);
|
|
return {
|
|
header,
|
|
payload,
|
|
signature: signatureFromJWS(jwsSig)
|
|
};
|
|
}
|
|
function VerifyStream(opts) {
|
|
opts = opts || {};
|
|
var secretOrKey = opts.secret || opts.publicKey || opts.key;
|
|
var secretStream = new DataStream(secretOrKey);
|
|
this.readable = true;
|
|
this.algorithm = opts.algorithm;
|
|
this.encoding = opts.encoding;
|
|
this.secret = this.publicKey = this.key = secretStream;
|
|
this.signature = new DataStream(opts.signature);
|
|
this.secret.once("close", function() {
|
|
if (!this.signature.writable && this.readable)
|
|
this.verify();
|
|
}.bind(this));
|
|
this.signature.once("close", function() {
|
|
if (!this.secret.writable && this.readable)
|
|
this.verify();
|
|
}.bind(this));
|
|
}
|
|
util.inherits(VerifyStream, Stream);
|
|
VerifyStream.prototype.verify = function verify() {
|
|
try {
|
|
var valid = jwsVerify(this.signature.buffer, this.algorithm, this.key.buffer);
|
|
var obj = jwsDecode(this.signature.buffer, this.encoding);
|
|
this.emit("done", valid, obj);
|
|
this.emit("data", valid);
|
|
this.emit("end");
|
|
this.readable = false;
|
|
return valid;
|
|
} catch (e) {
|
|
this.readable = false;
|
|
this.emit("error", e);
|
|
this.emit("close");
|
|
}
|
|
};
|
|
VerifyStream.decode = jwsDecode;
|
|
VerifyStream.isValid = isValidJws;
|
|
VerifyStream.verify = jwsVerify;
|
|
module.exports = VerifyStream;
|
|
});
|
|
|
|
// ../eve/node_modules/jws/index.js
|
|
var require_jws = __commonJS((exports) => {
|
|
var SignStream = require_sign_stream();
|
|
var VerifyStream = require_verify_stream();
|
|
var ALGORITHMS = [
|
|
"HS256",
|
|
"HS384",
|
|
"HS512",
|
|
"RS256",
|
|
"RS384",
|
|
"RS512",
|
|
"PS256",
|
|
"PS384",
|
|
"PS512",
|
|
"ES256",
|
|
"ES384",
|
|
"ES512"
|
|
];
|
|
exports.ALGORITHMS = ALGORITHMS;
|
|
exports.sign = SignStream.sign;
|
|
exports.verify = VerifyStream.verify;
|
|
exports.decode = VerifyStream.decode;
|
|
exports.isValid = VerifyStream.isValid;
|
|
exports.createSign = function createSign(opts) {
|
|
return new SignStream(opts);
|
|
};
|
|
exports.createVerify = function createVerify(opts) {
|
|
return new VerifyStream(opts);
|
|
};
|
|
});
|
|
|
|
// ../eve/node_modules/jsonwebtoken/decode.js
|
|
var require_decode = __commonJS((exports, module) => {
|
|
var jws = require_jws();
|
|
module.exports = function(jwt, options2) {
|
|
options2 = options2 || {};
|
|
var decoded = jws.decode(jwt, options2);
|
|
if (!decoded) {
|
|
return null;
|
|
}
|
|
var payload = decoded.payload;
|
|
if (typeof payload === "string") {
|
|
try {
|
|
var obj = JSON.parse(payload);
|
|
if (obj !== null && typeof obj === "object") {
|
|
payload = obj;
|
|
}
|
|
} catch (e) {}
|
|
}
|
|
if (options2.complete === true) {
|
|
return {
|
|
header: decoded.header,
|
|
payload,
|
|
signature: decoded.signature
|
|
};
|
|
}
|
|
return payload;
|
|
};
|
|
});
|
|
|
|
// ../eve/node_modules/jsonwebtoken/lib/JsonWebTokenError.js
|
|
var require_JsonWebTokenError = __commonJS((exports, module) => {
|
|
var JsonWebTokenError = function(message, error) {
|
|
Error.call(this, message);
|
|
if (Error.captureStackTrace) {
|
|
Error.captureStackTrace(this, this.constructor);
|
|
}
|
|
this.name = "JsonWebTokenError";
|
|
this.message = message;
|
|
if (error)
|
|
this.inner = error;
|
|
};
|
|
JsonWebTokenError.prototype = Object.create(Error.prototype);
|
|
JsonWebTokenError.prototype.constructor = JsonWebTokenError;
|
|
module.exports = JsonWebTokenError;
|
|
});
|
|
|
|
// ../eve/node_modules/jsonwebtoken/lib/NotBeforeError.js
|
|
var require_NotBeforeError = __commonJS((exports, module) => {
|
|
var JsonWebTokenError = require_JsonWebTokenError();
|
|
var NotBeforeError = function(message, date) {
|
|
JsonWebTokenError.call(this, message);
|
|
this.name = "NotBeforeError";
|
|
this.date = date;
|
|
};
|
|
NotBeforeError.prototype = Object.create(JsonWebTokenError.prototype);
|
|
NotBeforeError.prototype.constructor = NotBeforeError;
|
|
module.exports = NotBeforeError;
|
|
});
|
|
|
|
// ../eve/node_modules/jsonwebtoken/lib/TokenExpiredError.js
|
|
var require_TokenExpiredError = __commonJS((exports, module) => {
|
|
var JsonWebTokenError = require_JsonWebTokenError();
|
|
var TokenExpiredError = function(message, expiredAt) {
|
|
JsonWebTokenError.call(this, message);
|
|
this.name = "TokenExpiredError";
|
|
this.expiredAt = expiredAt;
|
|
};
|
|
TokenExpiredError.prototype = Object.create(JsonWebTokenError.prototype);
|
|
TokenExpiredError.prototype.constructor = TokenExpiredError;
|
|
module.exports = TokenExpiredError;
|
|
});
|
|
|
|
// ../eve/node_modules/ms/index.js
|
|
var require_ms = __commonJS((exports, module) => {
|
|
var s = 1000;
|
|
var m = s * 60;
|
|
var h = m * 60;
|
|
var d = h * 24;
|
|
var w = d * 7;
|
|
var y = d * 365.25;
|
|
module.exports = function(val, options2) {
|
|
options2 = options2 || {};
|
|
var type = typeof val;
|
|
if (type === "string" && val.length > 0) {
|
|
return parse(val);
|
|
} else if (type === "number" && isFinite(val)) {
|
|
return options2.long ? fmtLong(val) : fmtShort(val);
|
|
}
|
|
throw new Error("val is not a non-empty string or a valid number. val=" + JSON.stringify(val));
|
|
};
|
|
function parse(str) {
|
|
str = String(str);
|
|
if (str.length > 100) {
|
|
return;
|
|
}
|
|
var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(str);
|
|
if (!match) {
|
|
return;
|
|
}
|
|
var n = parseFloat(match[1]);
|
|
var type = (match[2] || "ms").toLowerCase();
|
|
switch (type) {
|
|
case "years":
|
|
case "year":
|
|
case "yrs":
|
|
case "yr":
|
|
case "y":
|
|
return n * y;
|
|
case "weeks":
|
|
case "week":
|
|
case "w":
|
|
return n * w;
|
|
case "days":
|
|
case "day":
|
|
case "d":
|
|
return n * d;
|
|
case "hours":
|
|
case "hour":
|
|
case "hrs":
|
|
case "hr":
|
|
case "h":
|
|
return n * h;
|
|
case "minutes":
|
|
case "minute":
|
|
case "mins":
|
|
case "min":
|
|
case "m":
|
|
return n * m;
|
|
case "seconds":
|
|
case "second":
|
|
case "secs":
|
|
case "sec":
|
|
case "s":
|
|
return n * s;
|
|
case "milliseconds":
|
|
case "millisecond":
|
|
case "msecs":
|
|
case "msec":
|
|
case "ms":
|
|
return n;
|
|
default:
|
|
return;
|
|
}
|
|
}
|
|
function fmtShort(ms) {
|
|
var msAbs = Math.abs(ms);
|
|
if (msAbs >= d) {
|
|
return Math.round(ms / d) + "d";
|
|
}
|
|
if (msAbs >= h) {
|
|
return Math.round(ms / h) + "h";
|
|
}
|
|
if (msAbs >= m) {
|
|
return Math.round(ms / m) + "m";
|
|
}
|
|
if (msAbs >= s) {
|
|
return Math.round(ms / s) + "s";
|
|
}
|
|
return ms + "ms";
|
|
}
|
|
function fmtLong(ms) {
|
|
var msAbs = Math.abs(ms);
|
|
if (msAbs >= d) {
|
|
return plural(ms, msAbs, d, "day");
|
|
}
|
|
if (msAbs >= h) {
|
|
return plural(ms, msAbs, h, "hour");
|
|
}
|
|
if (msAbs >= m) {
|
|
return plural(ms, msAbs, m, "minute");
|
|
}
|
|
if (msAbs >= s) {
|
|
return plural(ms, msAbs, s, "second");
|
|
}
|
|
return ms + " ms";
|
|
}
|
|
function plural(ms, msAbs, n, name) {
|
|
var isPlural = msAbs >= n * 1.5;
|
|
return Math.round(ms / n) + " " + name + (isPlural ? "s" : "");
|
|
}
|
|
});
|
|
|
|
// ../eve/node_modules/jsonwebtoken/lib/timespan.js
|
|
var require_timespan = __commonJS((exports, module) => {
|
|
var ms = require_ms();
|
|
module.exports = function(time, iat) {
|
|
var timestamp = iat || Math.floor(Date.now() / 1000);
|
|
if (typeof time === "string") {
|
|
var milliseconds = ms(time);
|
|
if (typeof milliseconds === "undefined") {
|
|
return;
|
|
}
|
|
return Math.floor(timestamp + milliseconds / 1000);
|
|
} else if (typeof time === "number") {
|
|
return timestamp + time;
|
|
} else {
|
|
return;
|
|
}
|
|
};
|
|
});
|
|
|
|
// ../eve/node_modules/semver/internal/constants.js
|
|
var require_constants = __commonJS((exports, module) => {
|
|
var SEMVER_SPEC_VERSION = "2.0.0";
|
|
var MAX_LENGTH = 256;
|
|
var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;
|
|
var MAX_SAFE_COMPONENT_LENGTH = 16;
|
|
var MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6;
|
|
var RELEASE_TYPES = [
|
|
"major",
|
|
"premajor",
|
|
"minor",
|
|
"preminor",
|
|
"patch",
|
|
"prepatch",
|
|
"prerelease"
|
|
];
|
|
module.exports = {
|
|
MAX_LENGTH,
|
|
MAX_SAFE_COMPONENT_LENGTH,
|
|
MAX_SAFE_BUILD_LENGTH,
|
|
MAX_SAFE_INTEGER,
|
|
RELEASE_TYPES,
|
|
SEMVER_SPEC_VERSION,
|
|
FLAG_INCLUDE_PRERELEASE: 1,
|
|
FLAG_LOOSE: 2
|
|
};
|
|
});
|
|
|
|
// ../eve/node_modules/semver/internal/debug.js
|
|
var require_debug = __commonJS((exports, module) => {
|
|
var debug = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {};
|
|
module.exports = debug;
|
|
});
|
|
|
|
// ../eve/node_modules/semver/internal/re.js
|
|
var require_re = __commonJS((exports, module) => {
|
|
var {
|
|
MAX_SAFE_COMPONENT_LENGTH,
|
|
MAX_SAFE_BUILD_LENGTH,
|
|
MAX_LENGTH
|
|
} = require_constants();
|
|
var debug = require_debug();
|
|
exports = module.exports = {};
|
|
var re = exports.re = [];
|
|
var safeRe = exports.safeRe = [];
|
|
var src = exports.src = [];
|
|
var safeSrc = exports.safeSrc = [];
|
|
var t = exports.t = {};
|
|
var R = 0;
|
|
var LETTERDASHNUMBER = "[a-zA-Z0-9-]";
|
|
var safeRegexReplacements = [
|
|
["\\s", 1],
|
|
["\\d", MAX_LENGTH],
|
|
[LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH]
|
|
];
|
|
var makeSafeRegex = (value) => {
|
|
for (const [token, max] of safeRegexReplacements) {
|
|
value = value.split(`${token}*`).join(`${token}{0,${max}}`).split(`${token}+`).join(`${token}{1,${max}}`);
|
|
}
|
|
return value;
|
|
};
|
|
var createToken = (name, value, isGlobal) => {
|
|
const safe = makeSafeRegex(value);
|
|
const index2 = R++;
|
|
debug(name, index2, value);
|
|
t[name] = index2;
|
|
src[index2] = value;
|
|
safeSrc[index2] = safe;
|
|
re[index2] = new RegExp(value, isGlobal ? "g" : undefined);
|
|
safeRe[index2] = new RegExp(safe, isGlobal ? "g" : undefined);
|
|
};
|
|
createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
|
|
createToken("NUMERICIDENTIFIERLOOSE", "\\d+");
|
|
createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
|
|
createToken("MAINVERSION", `(${src[t.NUMERICIDENTIFIER]})\\.` + `(${src[t.NUMERICIDENTIFIER]})\\.` + `(${src[t.NUMERICIDENTIFIER]})`);
|
|
createToken("MAINVERSIONLOOSE", `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` + `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` + `(${src[t.NUMERICIDENTIFIERLOOSE]})`);
|
|
createToken("PRERELEASEIDENTIFIER", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIER]})`);
|
|
createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIERLOOSE]})`);
|
|
createToken("PRERELEASE", `(?:-(${src[t.PRERELEASEIDENTIFIER]}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
|
|
createToken("PRERELEASELOOSE", `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
|
|
createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`);
|
|
createToken("BUILD", `(?:\\+(${src[t.BUILDIDENTIFIER]}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
|
|
createToken("FULLPLAIN", `v?${src[t.MAINVERSION]}${src[t.PRERELEASE]}?${src[t.BUILD]}?`);
|
|
createToken("FULL", `^${src[t.FULLPLAIN]}$`);
|
|
createToken("LOOSEPLAIN", `[v=\\s]*${src[t.MAINVERSIONLOOSE]}${src[t.PRERELEASELOOSE]}?${src[t.BUILD]}?`);
|
|
createToken("LOOSE", `^${src[t.LOOSEPLAIN]}$`);
|
|
createToken("GTLT", "((?:<|>)?=?)");
|
|
createToken("XRANGEIDENTIFIERLOOSE", `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
|
|
createToken("XRANGEIDENTIFIER", `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
|
|
createToken("XRANGEPLAIN", `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})` + `(?:\\.(${src[t.XRANGEIDENTIFIER]})` + `(?:\\.(${src[t.XRANGEIDENTIFIER]})` + `(?:${src[t.PRERELEASE]})?${src[t.BUILD]}?` + `)?)?`);
|
|
createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})` + `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` + `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` + `(?:${src[t.PRERELEASELOOSE]})?${src[t.BUILD]}?` + `)?)?`);
|
|
createToken("XRANGE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
|
|
createToken("XRANGELOOSE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
|
|
createToken("COERCEPLAIN", `${"(^|[^\\d])" + "(\\d{1,"}${MAX_SAFE_COMPONENT_LENGTH}})` + `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` + `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`);
|
|
createToken("COERCE", `${src[t.COERCEPLAIN]}(?:$|[^\\d])`);
|
|
createToken("COERCEFULL", src[t.COERCEPLAIN] + `(?:${src[t.PRERELEASE]})?` + `(?:${src[t.BUILD]})?` + `(?:$|[^\\d])`);
|
|
createToken("COERCERTL", src[t.COERCE], true);
|
|
createToken("COERCERTLFULL", src[t.COERCEFULL], true);
|
|
createToken("LONETILDE", "(?:~>?)");
|
|
createToken("TILDETRIM", `(\\s*)${src[t.LONETILDE]}\\s+`, true);
|
|
exports.tildeTrimReplace = "$1~";
|
|
createToken("TILDE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
|
|
createToken("TILDELOOSE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);
|
|
createToken("LONECARET", "(?:\\^)");
|
|
createToken("CARETTRIM", `(\\s*)${src[t.LONECARET]}\\s+`, true);
|
|
exports.caretTrimReplace = "$1^";
|
|
createToken("CARET", `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
|
|
createToken("CARETLOOSE", `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);
|
|
createToken("COMPARATORLOOSE", `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`);
|
|
createToken("COMPARATOR", `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`);
|
|
createToken("COMPARATORTRIM", `(\\s*)${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);
|
|
exports.comparatorTrimReplace = "$1$2$3";
|
|
createToken("HYPHENRANGE", `^\\s*(${src[t.XRANGEPLAIN]})` + `\\s+-\\s+` + `(${src[t.XRANGEPLAIN]})` + `\\s*$`);
|
|
createToken("HYPHENRANGELOOSE", `^\\s*(${src[t.XRANGEPLAINLOOSE]})` + `\\s+-\\s+` + `(${src[t.XRANGEPLAINLOOSE]})` + `\\s*$`);
|
|
createToken("STAR", "(<|>)?=?\\s*\\*");
|
|
createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
|
|
createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
|
|
});
|
|
|
|
// ../eve/node_modules/semver/internal/parse-options.js
|
|
var require_parse_options = __commonJS((exports, module) => {
|
|
var looseOption = Object.freeze({ loose: true });
|
|
var emptyOpts = Object.freeze({});
|
|
var parseOptions = (options2) => {
|
|
if (!options2) {
|
|
return emptyOpts;
|
|
}
|
|
if (typeof options2 !== "object") {
|
|
return looseOption;
|
|
}
|
|
return options2;
|
|
};
|
|
module.exports = parseOptions;
|
|
});
|
|
|
|
// ../eve/node_modules/semver/internal/identifiers.js
|
|
var require_identifiers = __commonJS((exports, module) => {
|
|
var numeric2 = /^[0-9]+$/;
|
|
var compareIdentifiers = (a, b) => {
|
|
const anum = numeric2.test(a);
|
|
const bnum = numeric2.test(b);
|
|
if (anum && bnum) {
|
|
a = +a;
|
|
b = +b;
|
|
}
|
|
return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
|
|
};
|
|
var rcompareIdentifiers = (a, b) => compareIdentifiers(b, a);
|
|
module.exports = {
|
|
compareIdentifiers,
|
|
rcompareIdentifiers
|
|
};
|
|
});
|
|
|
|
// ../eve/node_modules/semver/classes/semver.js
|
|
var require_semver = __commonJS((exports, module) => {
|
|
var debug = require_debug();
|
|
var { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants();
|
|
var { safeRe: re, t } = require_re();
|
|
var parseOptions = require_parse_options();
|
|
var { compareIdentifiers } = require_identifiers();
|
|
|
|
class SemVer {
|
|
constructor(version2, options2) {
|
|
options2 = parseOptions(options2);
|
|
if (version2 instanceof SemVer) {
|
|
if (version2.loose === !!options2.loose && version2.includePrerelease === !!options2.includePrerelease) {
|
|
return version2;
|
|
} else {
|
|
version2 = version2.version;
|
|
}
|
|
} else if (typeof version2 !== "string") {
|
|
throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version2}".`);
|
|
}
|
|
if (version2.length > MAX_LENGTH) {
|
|
throw new TypeError(`version is longer than ${MAX_LENGTH} characters`);
|
|
}
|
|
debug("SemVer", version2, options2);
|
|
this.options = options2;
|
|
this.loose = !!options2.loose;
|
|
this.includePrerelease = !!options2.includePrerelease;
|
|
const m = version2.trim().match(options2.loose ? re[t.LOOSE] : re[t.FULL]);
|
|
if (!m) {
|
|
throw new TypeError(`Invalid Version: ${version2}`);
|
|
}
|
|
this.raw = version2;
|
|
this.major = +m[1];
|
|
this.minor = +m[2];
|
|
this.patch = +m[3];
|
|
if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
|
|
throw new TypeError("Invalid major version");
|
|
}
|
|
if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
|
|
throw new TypeError("Invalid minor version");
|
|
}
|
|
if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
|
|
throw new TypeError("Invalid patch version");
|
|
}
|
|
if (!m[4]) {
|
|
this.prerelease = [];
|
|
} else {
|
|
this.prerelease = m[4].split(".").map((id) => {
|
|
if (/^[0-9]+$/.test(id)) {
|
|
const num = +id;
|
|
if (num >= 0 && num < MAX_SAFE_INTEGER) {
|
|
return num;
|
|
}
|
|
}
|
|
return id;
|
|
});
|
|
}
|
|
this.build = m[5] ? m[5].split(".") : [];
|
|
this.format();
|
|
}
|
|
format() {
|
|
this.version = `${this.major}.${this.minor}.${this.patch}`;
|
|
if (this.prerelease.length) {
|
|
this.version += `-${this.prerelease.join(".")}`;
|
|
}
|
|
return this.version;
|
|
}
|
|
toString() {
|
|
return this.version;
|
|
}
|
|
compare(other) {
|
|
debug("SemVer.compare", this.version, this.options, other);
|
|
if (!(other instanceof SemVer)) {
|
|
if (typeof other === "string" && other === this.version) {
|
|
return 0;
|
|
}
|
|
other = new SemVer(other, this.options);
|
|
}
|
|
if (other.version === this.version) {
|
|
return 0;
|
|
}
|
|
return this.compareMain(other) || this.comparePre(other);
|
|
}
|
|
compareMain(other) {
|
|
if (!(other instanceof SemVer)) {
|
|
other = new SemVer(other, this.options);
|
|
}
|
|
return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch);
|
|
}
|
|
comparePre(other) {
|
|
if (!(other instanceof SemVer)) {
|
|
other = new SemVer(other, this.options);
|
|
}
|
|
if (this.prerelease.length && !other.prerelease.length) {
|
|
return -1;
|
|
} else if (!this.prerelease.length && other.prerelease.length) {
|
|
return 1;
|
|
} else if (!this.prerelease.length && !other.prerelease.length) {
|
|
return 0;
|
|
}
|
|
let i = 0;
|
|
do {
|
|
const a = this.prerelease[i];
|
|
const b = other.prerelease[i];
|
|
debug("prerelease compare", i, a, b);
|
|
if (a === undefined && b === undefined) {
|
|
return 0;
|
|
} else if (b === undefined) {
|
|
return 1;
|
|
} else if (a === undefined) {
|
|
return -1;
|
|
} else if (a === b) {
|
|
continue;
|
|
} else {
|
|
return compareIdentifiers(a, b);
|
|
}
|
|
} while (++i);
|
|
}
|
|
compareBuild(other) {
|
|
if (!(other instanceof SemVer)) {
|
|
other = new SemVer(other, this.options);
|
|
}
|
|
let i = 0;
|
|
do {
|
|
const a = this.build[i];
|
|
const b = other.build[i];
|
|
debug("build compare", i, a, b);
|
|
if (a === undefined && b === undefined) {
|
|
return 0;
|
|
} else if (b === undefined) {
|
|
return 1;
|
|
} else if (a === undefined) {
|
|
return -1;
|
|
} else if (a === b) {
|
|
continue;
|
|
} else {
|
|
return compareIdentifiers(a, b);
|
|
}
|
|
} while (++i);
|
|
}
|
|
inc(release, identifier, identifierBase) {
|
|
if (release.startsWith("pre")) {
|
|
if (!identifier && identifierBase === false) {
|
|
throw new Error("invalid increment argument: identifier is empty");
|
|
}
|
|
if (identifier) {
|
|
const match = `-${identifier}`.match(this.options.loose ? re[t.PRERELEASELOOSE] : re[t.PRERELEASE]);
|
|
if (!match || match[1] !== identifier) {
|
|
throw new Error(`invalid identifier: ${identifier}`);
|
|
}
|
|
}
|
|
}
|
|
switch (release) {
|
|
case "premajor":
|
|
this.prerelease.length = 0;
|
|
this.patch = 0;
|
|
this.minor = 0;
|
|
this.major++;
|
|
this.inc("pre", identifier, identifierBase);
|
|
break;
|
|
case "preminor":
|
|
this.prerelease.length = 0;
|
|
this.patch = 0;
|
|
this.minor++;
|
|
this.inc("pre", identifier, identifierBase);
|
|
break;
|
|
case "prepatch":
|
|
this.prerelease.length = 0;
|
|
this.inc("patch", identifier, identifierBase);
|
|
this.inc("pre", identifier, identifierBase);
|
|
break;
|
|
case "prerelease":
|
|
if (this.prerelease.length === 0) {
|
|
this.inc("patch", identifier, identifierBase);
|
|
}
|
|
this.inc("pre", identifier, identifierBase);
|
|
break;
|
|
case "release":
|
|
if (this.prerelease.length === 0) {
|
|
throw new Error(`version ${this.raw} is not a prerelease`);
|
|
}
|
|
this.prerelease.length = 0;
|
|
break;
|
|
case "major":
|
|
if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
|
|
this.major++;
|
|
}
|
|
this.minor = 0;
|
|
this.patch = 0;
|
|
this.prerelease = [];
|
|
break;
|
|
case "minor":
|
|
if (this.patch !== 0 || this.prerelease.length === 0) {
|
|
this.minor++;
|
|
}
|
|
this.patch = 0;
|
|
this.prerelease = [];
|
|
break;
|
|
case "patch":
|
|
if (this.prerelease.length === 0) {
|
|
this.patch++;
|
|
}
|
|
this.prerelease = [];
|
|
break;
|
|
case "pre": {
|
|
const base = Number(identifierBase) ? 1 : 0;
|
|
if (this.prerelease.length === 0) {
|
|
this.prerelease = [base];
|
|
} else {
|
|
let i = this.prerelease.length;
|
|
while (--i >= 0) {
|
|
if (typeof this.prerelease[i] === "number") {
|
|
this.prerelease[i]++;
|
|
i = -2;
|
|
}
|
|
}
|
|
if (i === -1) {
|
|
if (identifier === this.prerelease.join(".") && identifierBase === false) {
|
|
throw new Error("invalid increment argument: identifier already exists");
|
|
}
|
|
this.prerelease.push(base);
|
|
}
|
|
}
|
|
if (identifier) {
|
|
let prerelease = [identifier, base];
|
|
if (identifierBase === false) {
|
|
prerelease = [identifier];
|
|
}
|
|
if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
|
|
if (isNaN(this.prerelease[1])) {
|
|
this.prerelease = prerelease;
|
|
}
|
|
} else {
|
|
this.prerelease = prerelease;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
throw new Error(`invalid increment argument: ${release}`);
|
|
}
|
|
this.raw = this.format();
|
|
if (this.build.length) {
|
|
this.raw += `+${this.build.join(".")}`;
|
|
}
|
|
return this;
|
|
}
|
|
}
|
|
module.exports = SemVer;
|
|
});
|
|
|
|
// ../eve/node_modules/semver/functions/parse.js
|
|
var require_parse = __commonJS((exports, module) => {
|
|
var SemVer = require_semver();
|
|
var parse = (version2, options2, throwErrors = false) => {
|
|
if (version2 instanceof SemVer) {
|
|
return version2;
|
|
}
|
|
try {
|
|
return new SemVer(version2, options2);
|
|
} catch (er) {
|
|
if (!throwErrors) {
|
|
return null;
|
|
}
|
|
throw er;
|
|
}
|
|
};
|
|
module.exports = parse;
|
|
});
|
|
|
|
// ../eve/node_modules/semver/functions/valid.js
|
|
var require_valid = __commonJS((exports, module) => {
|
|
var parse = require_parse();
|
|
var valid = (version2, options2) => {
|
|
const v = parse(version2, options2);
|
|
return v ? v.version : null;
|
|
};
|
|
module.exports = valid;
|
|
});
|
|
|
|
// ../eve/node_modules/semver/functions/clean.js
|
|
var require_clean = __commonJS((exports, module) => {
|
|
var parse = require_parse();
|
|
var clean = (version2, options2) => {
|
|
const s = parse(version2.trim().replace(/^[=v]+/, ""), options2);
|
|
return s ? s.version : null;
|
|
};
|
|
module.exports = clean;
|
|
});
|
|
|
|
// ../eve/node_modules/semver/functions/inc.js
|
|
var require_inc = __commonJS((exports, module) => {
|
|
var SemVer = require_semver();
|
|
var inc = (version2, release, options2, identifier, identifierBase) => {
|
|
if (typeof options2 === "string") {
|
|
identifierBase = identifier;
|
|
identifier = options2;
|
|
options2 = undefined;
|
|
}
|
|
try {
|
|
return new SemVer(version2 instanceof SemVer ? version2.version : version2, options2).inc(release, identifier, identifierBase).version;
|
|
} catch (er) {
|
|
return null;
|
|
}
|
|
};
|
|
module.exports = inc;
|
|
});
|
|
|
|
// ../eve/node_modules/semver/functions/diff.js
|
|
var require_diff = __commonJS((exports, module) => {
|
|
var parse = require_parse();
|
|
var diff = (version1, version2) => {
|
|
const v1 = parse(version1, null, true);
|
|
const v2 = parse(version2, null, true);
|
|
const comparison = v1.compare(v2);
|
|
if (comparison === 0) {
|
|
return null;
|
|
}
|
|
const v1Higher = comparison > 0;
|
|
const highVersion = v1Higher ? v1 : v2;
|
|
const lowVersion = v1Higher ? v2 : v1;
|
|
const highHasPre = !!highVersion.prerelease.length;
|
|
const lowHasPre = !!lowVersion.prerelease.length;
|
|
if (lowHasPre && !highHasPre) {
|
|
if (!lowVersion.patch && !lowVersion.minor) {
|
|
return "major";
|
|
}
|
|
if (lowVersion.compareMain(highVersion) === 0) {
|
|
if (lowVersion.minor && !lowVersion.patch) {
|
|
return "minor";
|
|
}
|
|
return "patch";
|
|
}
|
|
}
|
|
const prefix = highHasPre ? "pre" : "";
|
|
if (v1.major !== v2.major) {
|
|
return prefix + "major";
|
|
}
|
|
if (v1.minor !== v2.minor) {
|
|
return prefix + "minor";
|
|
}
|
|
if (v1.patch !== v2.patch) {
|
|
return prefix + "patch";
|
|
}
|
|
return "prerelease";
|
|
};
|
|
module.exports = diff;
|
|
});
|
|
|
|
// ../eve/node_modules/semver/functions/major.js
|
|
var require_major = __commonJS((exports, module) => {
|
|
var SemVer = require_semver();
|
|
var major = (a, loose) => new SemVer(a, loose).major;
|
|
module.exports = major;
|
|
});
|
|
|
|
// ../eve/node_modules/semver/functions/minor.js
|
|
var require_minor = __commonJS((exports, module) => {
|
|
var SemVer = require_semver();
|
|
var minor = (a, loose) => new SemVer(a, loose).minor;
|
|
module.exports = minor;
|
|
});
|
|
|
|
// ../eve/node_modules/semver/functions/patch.js
|
|
var require_patch = __commonJS((exports, module) => {
|
|
var SemVer = require_semver();
|
|
var patch = (a, loose) => new SemVer(a, loose).patch;
|
|
module.exports = patch;
|
|
});
|
|
|
|
// ../eve/node_modules/semver/functions/prerelease.js
|
|
var require_prerelease = __commonJS((exports, module) => {
|
|
var parse = require_parse();
|
|
var prerelease = (version2, options2) => {
|
|
const parsed = parse(version2, options2);
|
|
return parsed && parsed.prerelease.length ? parsed.prerelease : null;
|
|
};
|
|
module.exports = prerelease;
|
|
});
|
|
|
|
// ../eve/node_modules/semver/functions/compare.js
|
|
var require_compare = __commonJS((exports, module) => {
|
|
var SemVer = require_semver();
|
|
var compare = (a, b, loose) => new SemVer(a, loose).compare(new SemVer(b, loose));
|
|
module.exports = compare;
|
|
});
|
|
|
|
// ../eve/node_modules/semver/functions/rcompare.js
|
|
var require_rcompare = __commonJS((exports, module) => {
|
|
var compare = require_compare();
|
|
var rcompare = (a, b, loose) => compare(b, a, loose);
|
|
module.exports = rcompare;
|
|
});
|
|
|
|
// ../eve/node_modules/semver/functions/compare-loose.js
|
|
var require_compare_loose = __commonJS((exports, module) => {
|
|
var compare = require_compare();
|
|
var compareLoose = (a, b) => compare(a, b, true);
|
|
module.exports = compareLoose;
|
|
});
|
|
|
|
// ../eve/node_modules/semver/functions/compare-build.js
|
|
var require_compare_build = __commonJS((exports, module) => {
|
|
var SemVer = require_semver();
|
|
var compareBuild = (a, b, loose) => {
|
|
const versionA = new SemVer(a, loose);
|
|
const versionB = new SemVer(b, loose);
|
|
return versionA.compare(versionB) || versionA.compareBuild(versionB);
|
|
};
|
|
module.exports = compareBuild;
|
|
});
|
|
|
|
// ../eve/node_modules/semver/functions/sort.js
|
|
var require_sort = __commonJS((exports, module) => {
|
|
var compareBuild = require_compare_build();
|
|
var sort = (list, loose) => list.sort((a, b) => compareBuild(a, b, loose));
|
|
module.exports = sort;
|
|
});
|
|
|
|
// ../eve/node_modules/semver/functions/rsort.js
|
|
var require_rsort = __commonJS((exports, module) => {
|
|
var compareBuild = require_compare_build();
|
|
var rsort = (list, loose) => list.sort((a, b) => compareBuild(b, a, loose));
|
|
module.exports = rsort;
|
|
});
|
|
|
|
// ../eve/node_modules/semver/functions/gt.js
|
|
var require_gt = __commonJS((exports, module) => {
|
|
var compare = require_compare();
|
|
var gt2 = (a, b, loose) => compare(a, b, loose) > 0;
|
|
module.exports = gt2;
|
|
});
|
|
|
|
// ../eve/node_modules/semver/functions/lt.js
|
|
var require_lt = __commonJS((exports, module) => {
|
|
var compare = require_compare();
|
|
var lt2 = (a, b, loose) => compare(a, b, loose) < 0;
|
|
module.exports = lt2;
|
|
});
|
|
|
|
// ../eve/node_modules/semver/functions/eq.js
|
|
var require_eq = __commonJS((exports, module) => {
|
|
var compare = require_compare();
|
|
var eq2 = (a, b, loose) => compare(a, b, loose) === 0;
|
|
module.exports = eq2;
|
|
});
|
|
|
|
// ../eve/node_modules/semver/functions/neq.js
|
|
var require_neq = __commonJS((exports, module) => {
|
|
var compare = require_compare();
|
|
var neq = (a, b, loose) => compare(a, b, loose) !== 0;
|
|
module.exports = neq;
|
|
});
|
|
|
|
// ../eve/node_modules/semver/functions/gte.js
|
|
var require_gte = __commonJS((exports, module) => {
|
|
var compare = require_compare();
|
|
var gte2 = (a, b, loose) => compare(a, b, loose) >= 0;
|
|
module.exports = gte2;
|
|
});
|
|
|
|
// ../eve/node_modules/semver/functions/lte.js
|
|
var require_lte = __commonJS((exports, module) => {
|
|
var compare = require_compare();
|
|
var lte2 = (a, b, loose) => compare(a, b, loose) <= 0;
|
|
module.exports = lte2;
|
|
});
|
|
|
|
// ../eve/node_modules/semver/functions/cmp.js
|
|
var require_cmp = __commonJS((exports, module) => {
|
|
var eq2 = require_eq();
|
|
var neq = require_neq();
|
|
var gt2 = require_gt();
|
|
var gte2 = require_gte();
|
|
var lt2 = require_lt();
|
|
var lte2 = require_lte();
|
|
var cmp = (a, op, b, loose) => {
|
|
switch (op) {
|
|
case "===":
|
|
if (typeof a === "object") {
|
|
a = a.version;
|
|
}
|
|
if (typeof b === "object") {
|
|
b = b.version;
|
|
}
|
|
return a === b;
|
|
case "!==":
|
|
if (typeof a === "object") {
|
|
a = a.version;
|
|
}
|
|
if (typeof b === "object") {
|
|
b = b.version;
|
|
}
|
|
return a !== b;
|
|
case "":
|
|
case "=":
|
|
case "==":
|
|
return eq2(a, b, loose);
|
|
case "!=":
|
|
return neq(a, b, loose);
|
|
case ">":
|
|
return gt2(a, b, loose);
|
|
case ">=":
|
|
return gte2(a, b, loose);
|
|
case "<":
|
|
return lt2(a, b, loose);
|
|
case "<=":
|
|
return lte2(a, b, loose);
|
|
default:
|
|
throw new TypeError(`Invalid operator: ${op}`);
|
|
}
|
|
};
|
|
module.exports = cmp;
|
|
});
|
|
|
|
// ../eve/node_modules/semver/functions/coerce.js
|
|
var require_coerce = __commonJS((exports, module) => {
|
|
var SemVer = require_semver();
|
|
var parse = require_parse();
|
|
var { safeRe: re, t } = require_re();
|
|
var coerce = (version2, options2) => {
|
|
if (version2 instanceof SemVer) {
|
|
return version2;
|
|
}
|
|
if (typeof version2 === "number") {
|
|
version2 = String(version2);
|
|
}
|
|
if (typeof version2 !== "string") {
|
|
return null;
|
|
}
|
|
options2 = options2 || {};
|
|
let match = null;
|
|
if (!options2.rtl) {
|
|
match = version2.match(options2.includePrerelease ? re[t.COERCEFULL] : re[t.COERCE]);
|
|
} else {
|
|
const coerceRtlRegex = options2.includePrerelease ? re[t.COERCERTLFULL] : re[t.COERCERTL];
|
|
let next;
|
|
while ((next = coerceRtlRegex.exec(version2)) && (!match || match.index + match[0].length !== version2.length)) {
|
|
if (!match || next.index + next[0].length !== match.index + match[0].length) {
|
|
match = next;
|
|
}
|
|
coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length;
|
|
}
|
|
coerceRtlRegex.lastIndex = -1;
|
|
}
|
|
if (match === null) {
|
|
return null;
|
|
}
|
|
const major = match[2];
|
|
const minor = match[3] || "0";
|
|
const patch = match[4] || "0";
|
|
const prerelease = options2.includePrerelease && match[5] ? `-${match[5]}` : "";
|
|
const build = options2.includePrerelease && match[6] ? `+${match[6]}` : "";
|
|
return parse(`${major}.${minor}.${patch}${prerelease}${build}`, options2);
|
|
};
|
|
module.exports = coerce;
|
|
});
|
|
|
|
// ../eve/node_modules/semver/internal/lrucache.js
|
|
var require_lrucache = __commonJS((exports, module) => {
|
|
class LRUCache {
|
|
constructor() {
|
|
this.max = 1000;
|
|
this.map = new Map;
|
|
}
|
|
get(key) {
|
|
const value = this.map.get(key);
|
|
if (value === undefined) {
|
|
return;
|
|
} else {
|
|
this.map.delete(key);
|
|
this.map.set(key, value);
|
|
return value;
|
|
}
|
|
}
|
|
delete(key) {
|
|
return this.map.delete(key);
|
|
}
|
|
set(key, value) {
|
|
const deleted = this.delete(key);
|
|
if (!deleted && value !== undefined) {
|
|
if (this.map.size >= this.max) {
|
|
const firstKey = this.map.keys().next().value;
|
|
this.delete(firstKey);
|
|
}
|
|
this.map.set(key, value);
|
|
}
|
|
return this;
|
|
}
|
|
}
|
|
module.exports = LRUCache;
|
|
});
|
|
|
|
// ../eve/node_modules/semver/classes/range.js
|
|
var require_range = __commonJS((exports, module) => {
|
|
var SPACE_CHARACTERS = /\s+/g;
|
|
|
|
class Range {
|
|
constructor(range, options2) {
|
|
options2 = parseOptions(options2);
|
|
if (range instanceof Range) {
|
|
if (range.loose === !!options2.loose && range.includePrerelease === !!options2.includePrerelease) {
|
|
return range;
|
|
} else {
|
|
return new Range(range.raw, options2);
|
|
}
|
|
}
|
|
if (range instanceof Comparator) {
|
|
this.raw = range.value;
|
|
this.set = [[range]];
|
|
this.formatted = undefined;
|
|
return this;
|
|
}
|
|
this.options = options2;
|
|
this.loose = !!options2.loose;
|
|
this.includePrerelease = !!options2.includePrerelease;
|
|
this.raw = range.trim().replace(SPACE_CHARACTERS, " ");
|
|
this.set = this.raw.split("||").map((r) => this.parseRange(r.trim())).filter((c) => c.length);
|
|
if (!this.set.length) {
|
|
throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
|
|
}
|
|
if (this.set.length > 1) {
|
|
const first = this.set[0];
|
|
this.set = this.set.filter((c) => !isNullSet(c[0]));
|
|
if (this.set.length === 0) {
|
|
this.set = [first];
|
|
} else if (this.set.length > 1) {
|
|
for (const c of this.set) {
|
|
if (c.length === 1 && isAny(c[0])) {
|
|
this.set = [c];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
this.formatted = undefined;
|
|
}
|
|
get range() {
|
|
if (this.formatted === undefined) {
|
|
this.formatted = "";
|
|
for (let i = 0;i < this.set.length; i++) {
|
|
if (i > 0) {
|
|
this.formatted += "||";
|
|
}
|
|
const comps = this.set[i];
|
|
for (let k = 0;k < comps.length; k++) {
|
|
if (k > 0) {
|
|
this.formatted += " ";
|
|
}
|
|
this.formatted += comps[k].toString().trim();
|
|
}
|
|
}
|
|
}
|
|
return this.formatted;
|
|
}
|
|
format() {
|
|
return this.range;
|
|
}
|
|
toString() {
|
|
return this.range;
|
|
}
|
|
parseRange(range) {
|
|
const memoOpts = (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE);
|
|
const memoKey = memoOpts + ":" + range;
|
|
const cached = cache.get(memoKey);
|
|
if (cached) {
|
|
return cached;
|
|
}
|
|
const loose = this.options.loose;
|
|
const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
|
|
range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
|
|
debug("hyphen replace", range);
|
|
range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
|
|
debug("comparator trim", range);
|
|
range = range.replace(re[t.TILDETRIM], tildeTrimReplace);
|
|
debug("tilde trim", range);
|
|
range = range.replace(re[t.CARETTRIM], caretTrimReplace);
|
|
debug("caret trim", range);
|
|
let rangeList = range.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options));
|
|
if (loose) {
|
|
rangeList = rangeList.filter((comp) => {
|
|
debug("loose invalid filter", comp, this.options);
|
|
return !!comp.match(re[t.COMPARATORLOOSE]);
|
|
});
|
|
}
|
|
debug("range list", rangeList);
|
|
const rangeMap = new Map;
|
|
const comparators = rangeList.map((comp) => new Comparator(comp, this.options));
|
|
for (const comp of comparators) {
|
|
if (isNullSet(comp)) {
|
|
return [comp];
|
|
}
|
|
rangeMap.set(comp.value, comp);
|
|
}
|
|
if (rangeMap.size > 1 && rangeMap.has("")) {
|
|
rangeMap.delete("");
|
|
}
|
|
const result = [...rangeMap.values()];
|
|
cache.set(memoKey, result);
|
|
return result;
|
|
}
|
|
intersects(range, options2) {
|
|
if (!(range instanceof Range)) {
|
|
throw new TypeError("a Range is required");
|
|
}
|
|
return this.set.some((thisComparators) => {
|
|
return isSatisfiable(thisComparators, options2) && range.set.some((rangeComparators) => {
|
|
return isSatisfiable(rangeComparators, options2) && thisComparators.every((thisComparator) => {
|
|
return rangeComparators.every((rangeComparator) => {
|
|
return thisComparator.intersects(rangeComparator, options2);
|
|
});
|
|
});
|
|
});
|
|
});
|
|
}
|
|
test(version2) {
|
|
if (!version2) {
|
|
return false;
|
|
}
|
|
if (typeof version2 === "string") {
|
|
try {
|
|
version2 = new SemVer(version2, this.options);
|
|
} catch (er) {
|
|
return false;
|
|
}
|
|
}
|
|
for (let i = 0;i < this.set.length; i++) {
|
|
if (testSet(this.set[i], version2, this.options)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
module.exports = Range;
|
|
var LRU = require_lrucache();
|
|
var cache = new LRU;
|
|
var parseOptions = require_parse_options();
|
|
var Comparator = require_comparator();
|
|
var debug = require_debug();
|
|
var SemVer = require_semver();
|
|
var {
|
|
safeRe: re,
|
|
t,
|
|
comparatorTrimReplace,
|
|
tildeTrimReplace,
|
|
caretTrimReplace
|
|
} = require_re();
|
|
var { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants();
|
|
var isNullSet = (c) => c.value === "<0.0.0-0";
|
|
var isAny = (c) => c.value === "";
|
|
var isSatisfiable = (comparators, options2) => {
|
|
let result = true;
|
|
const remainingComparators = comparators.slice();
|
|
let testComparator = remainingComparators.pop();
|
|
while (result && remainingComparators.length) {
|
|
result = remainingComparators.every((otherComparator) => {
|
|
return testComparator.intersects(otherComparator, options2);
|
|
});
|
|
testComparator = remainingComparators.pop();
|
|
}
|
|
return result;
|
|
};
|
|
var parseComparator = (comp, options2) => {
|
|
debug("comp", comp, options2);
|
|
comp = replaceCarets(comp, options2);
|
|
debug("caret", comp);
|
|
comp = replaceTildes(comp, options2);
|
|
debug("tildes", comp);
|
|
comp = replaceXRanges(comp, options2);
|
|
debug("xrange", comp);
|
|
comp = replaceStars(comp, options2);
|
|
debug("stars", comp);
|
|
return comp;
|
|
};
|
|
var isX = (id) => !id || id.toLowerCase() === "x" || id === "*";
|
|
var replaceTildes = (comp, options2) => {
|
|
return comp.trim().split(/\s+/).map((c) => replaceTilde(c, options2)).join(" ");
|
|
};
|
|
var replaceTilde = (comp, options2) => {
|
|
const r = options2.loose ? re[t.TILDELOOSE] : re[t.TILDE];
|
|
return comp.replace(r, (_, M, m, p, pr) => {
|
|
debug("tilde", comp, _, M, m, p, pr);
|
|
let ret;
|
|
if (isX(M)) {
|
|
ret = "";
|
|
} else if (isX(m)) {
|
|
ret = `>=${M}.0.0 <${+M + 1}.0.0-0`;
|
|
} else if (isX(p)) {
|
|
ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`;
|
|
} else if (pr) {
|
|
debug("replaceTilde pr", pr);
|
|
ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
|
|
} else {
|
|
ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
|
|
}
|
|
debug("tilde return", ret);
|
|
return ret;
|
|
});
|
|
};
|
|
var replaceCarets = (comp, options2) => {
|
|
return comp.trim().split(/\s+/).map((c) => replaceCaret(c, options2)).join(" ");
|
|
};
|
|
var replaceCaret = (comp, options2) => {
|
|
debug("caret", comp, options2);
|
|
const r = options2.loose ? re[t.CARETLOOSE] : re[t.CARET];
|
|
const z = options2.includePrerelease ? "-0" : "";
|
|
return comp.replace(r, (_, M, m, p, pr) => {
|
|
debug("caret", comp, _, M, m, p, pr);
|
|
let ret;
|
|
if (isX(M)) {
|
|
ret = "";
|
|
} else if (isX(m)) {
|
|
ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
|
|
} else if (isX(p)) {
|
|
if (M === "0") {
|
|
ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
|
|
} else {
|
|
ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`;
|
|
}
|
|
} else if (pr) {
|
|
debug("replaceCaret pr", pr);
|
|
if (M === "0") {
|
|
if (m === "0") {
|
|
ret = `>=${M}.${m}.${p}-${pr} <${M}.${m}.${+p + 1}-0`;
|
|
} else {
|
|
ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
|
|
}
|
|
} else {
|
|
ret = `>=${M}.${m}.${p}-${pr} <${+M + 1}.0.0-0`;
|
|
}
|
|
} else {
|
|
debug("no pr");
|
|
if (M === "0") {
|
|
if (m === "0") {
|
|
ret = `>=${M}.${m}.${p}${z} <${M}.${m}.${+p + 1}-0`;
|
|
} else {
|
|
ret = `>=${M}.${m}.${p}${z} <${M}.${+m + 1}.0-0`;
|
|
}
|
|
} else {
|
|
ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`;
|
|
}
|
|
}
|
|
debug("caret return", ret);
|
|
return ret;
|
|
});
|
|
};
|
|
var replaceXRanges = (comp, options2) => {
|
|
debug("replaceXRanges", comp, options2);
|
|
return comp.split(/\s+/).map((c) => replaceXRange(c, options2)).join(" ");
|
|
};
|
|
var replaceXRange = (comp, options2) => {
|
|
comp = comp.trim();
|
|
const r = options2.loose ? re[t.XRANGELOOSE] : re[t.XRANGE];
|
|
return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
|
|
debug("xRange", comp, ret, gtlt, M, m, p, pr);
|
|
const xM = isX(M);
|
|
const xm = xM || isX(m);
|
|
const xp = xm || isX(p);
|
|
const anyX = xp;
|
|
if (gtlt === "=" && anyX) {
|
|
gtlt = "";
|
|
}
|
|
pr = options2.includePrerelease ? "-0" : "";
|
|
if (xM) {
|
|
if (gtlt === ">" || gtlt === "<") {
|
|
ret = "<0.0.0-0";
|
|
} else {
|
|
ret = "*";
|
|
}
|
|
} else if (gtlt && anyX) {
|
|
if (xm) {
|
|
m = 0;
|
|
}
|
|
p = 0;
|
|
if (gtlt === ">") {
|
|
gtlt = ">=";
|
|
if (xm) {
|
|
M = +M + 1;
|
|
m = 0;
|
|
p = 0;
|
|
} else {
|
|
m = +m + 1;
|
|
p = 0;
|
|
}
|
|
} else if (gtlt === "<=") {
|
|
gtlt = "<";
|
|
if (xm) {
|
|
M = +M + 1;
|
|
} else {
|
|
m = +m + 1;
|
|
}
|
|
}
|
|
if (gtlt === "<") {
|
|
pr = "-0";
|
|
}
|
|
ret = `${gtlt + M}.${m}.${p}${pr}`;
|
|
} else if (xm) {
|
|
ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`;
|
|
} else if (xp) {
|
|
ret = `>=${M}.${m}.0${pr} <${M}.${+m + 1}.0-0`;
|
|
}
|
|
debug("xRange return", ret);
|
|
return ret;
|
|
});
|
|
};
|
|
var replaceStars = (comp, options2) => {
|
|
debug("replaceStars", comp, options2);
|
|
return comp.trim().replace(re[t.STAR], "");
|
|
};
|
|
var replaceGTE0 = (comp, options2) => {
|
|
debug("replaceGTE0", comp, options2);
|
|
return comp.trim().replace(re[options2.includePrerelease ? t.GTE0PRE : t.GTE0], "");
|
|
};
|
|
var hyphenReplace = (incPr) => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr) => {
|
|
if (isX(fM)) {
|
|
from = "";
|
|
} else if (isX(fm)) {
|
|
from = `>=${fM}.0.0${incPr ? "-0" : ""}`;
|
|
} else if (isX(fp)) {
|
|
from = `>=${fM}.${fm}.0${incPr ? "-0" : ""}`;
|
|
} else if (fpr) {
|
|
from = `>=${from}`;
|
|
} else {
|
|
from = `>=${from}${incPr ? "-0" : ""}`;
|
|
}
|
|
if (isX(tM)) {
|
|
to = "";
|
|
} else if (isX(tm)) {
|
|
to = `<${+tM + 1}.0.0-0`;
|
|
} else if (isX(tp)) {
|
|
to = `<${tM}.${+tm + 1}.0-0`;
|
|
} else if (tpr) {
|
|
to = `<=${tM}.${tm}.${tp}-${tpr}`;
|
|
} else if (incPr) {
|
|
to = `<${tM}.${tm}.${+tp + 1}-0`;
|
|
} else {
|
|
to = `<=${to}`;
|
|
}
|
|
return `${from} ${to}`.trim();
|
|
};
|
|
var testSet = (set, version2, options2) => {
|
|
for (let i = 0;i < set.length; i++) {
|
|
if (!set[i].test(version2)) {
|
|
return false;
|
|
}
|
|
}
|
|
if (version2.prerelease.length && !options2.includePrerelease) {
|
|
for (let i = 0;i < set.length; i++) {
|
|
debug(set[i].semver);
|
|
if (set[i].semver === Comparator.ANY) {
|
|
continue;
|
|
}
|
|
if (set[i].semver.prerelease.length > 0) {
|
|
const allowed = set[i].semver;
|
|
if (allowed.major === version2.major && allowed.minor === version2.minor && allowed.patch === version2.patch) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
};
|
|
});
|
|
|
|
// ../eve/node_modules/semver/classes/comparator.js
|
|
var require_comparator = __commonJS((exports, module) => {
|
|
var ANY = Symbol("SemVer ANY");
|
|
|
|
class Comparator {
|
|
static get ANY() {
|
|
return ANY;
|
|
}
|
|
constructor(comp, options2) {
|
|
options2 = parseOptions(options2);
|
|
if (comp instanceof Comparator) {
|
|
if (comp.loose === !!options2.loose) {
|
|
return comp;
|
|
} else {
|
|
comp = comp.value;
|
|
}
|
|
}
|
|
comp = comp.trim().split(/\s+/).join(" ");
|
|
debug("comparator", comp, options2);
|
|
this.options = options2;
|
|
this.loose = !!options2.loose;
|
|
this.parse(comp);
|
|
if (this.semver === ANY) {
|
|
this.value = "";
|
|
} else {
|
|
this.value = this.operator + this.semver.version;
|
|
}
|
|
debug("comp", this);
|
|
}
|
|
parse(comp) {
|
|
const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
|
|
const m = comp.match(r);
|
|
if (!m) {
|
|
throw new TypeError(`Invalid comparator: ${comp}`);
|
|
}
|
|
this.operator = m[1] !== undefined ? m[1] : "";
|
|
if (this.operator === "=") {
|
|
this.operator = "";
|
|
}
|
|
if (!m[2]) {
|
|
this.semver = ANY;
|
|
} else {
|
|
this.semver = new SemVer(m[2], this.options.loose);
|
|
}
|
|
}
|
|
toString() {
|
|
return this.value;
|
|
}
|
|
test(version2) {
|
|
debug("Comparator.test", version2, this.options.loose);
|
|
if (this.semver === ANY || version2 === ANY) {
|
|
return true;
|
|
}
|
|
if (typeof version2 === "string") {
|
|
try {
|
|
version2 = new SemVer(version2, this.options);
|
|
} catch (er) {
|
|
return false;
|
|
}
|
|
}
|
|
return cmp(version2, this.operator, this.semver, this.options);
|
|
}
|
|
intersects(comp, options2) {
|
|
if (!(comp instanceof Comparator)) {
|
|
throw new TypeError("a Comparator is required");
|
|
}
|
|
if (this.operator === "") {
|
|
if (this.value === "") {
|
|
return true;
|
|
}
|
|
return new Range(comp.value, options2).test(this.value);
|
|
} else if (comp.operator === "") {
|
|
if (comp.value === "") {
|
|
return true;
|
|
}
|
|
return new Range(this.value, options2).test(comp.semver);
|
|
}
|
|
options2 = parseOptions(options2);
|
|
if (options2.includePrerelease && (this.value === "<0.0.0-0" || comp.value === "<0.0.0-0")) {
|
|
return false;
|
|
}
|
|
if (!options2.includePrerelease && (this.value.startsWith("<0.0.0") || comp.value.startsWith("<0.0.0"))) {
|
|
return false;
|
|
}
|
|
if (this.operator.startsWith(">") && comp.operator.startsWith(">")) {
|
|
return true;
|
|
}
|
|
if (this.operator.startsWith("<") && comp.operator.startsWith("<")) {
|
|
return true;
|
|
}
|
|
if (this.semver.version === comp.semver.version && this.operator.includes("=") && comp.operator.includes("=")) {
|
|
return true;
|
|
}
|
|
if (cmp(this.semver, "<", comp.semver, options2) && this.operator.startsWith(">") && comp.operator.startsWith("<")) {
|
|
return true;
|
|
}
|
|
if (cmp(this.semver, ">", comp.semver, options2) && this.operator.startsWith("<") && comp.operator.startsWith(">")) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
module.exports = Comparator;
|
|
var parseOptions = require_parse_options();
|
|
var { safeRe: re, t } = require_re();
|
|
var cmp = require_cmp();
|
|
var debug = require_debug();
|
|
var SemVer = require_semver();
|
|
var Range = require_range();
|
|
});
|
|
|
|
// ../eve/node_modules/semver/functions/satisfies.js
|
|
var require_satisfies = __commonJS((exports, module) => {
|
|
var Range = require_range();
|
|
var satisfies = (version2, range, options2) => {
|
|
try {
|
|
range = new Range(range, options2);
|
|
} catch (er) {
|
|
return false;
|
|
}
|
|
return range.test(version2);
|
|
};
|
|
module.exports = satisfies;
|
|
});
|
|
|
|
// ../eve/node_modules/semver/ranges/to-comparators.js
|
|
var require_to_comparators = __commonJS((exports, module) => {
|
|
var Range = require_range();
|
|
var toComparators = (range, options2) => new Range(range, options2).set.map((comp) => comp.map((c) => c.value).join(" ").trim().split(" "));
|
|
module.exports = toComparators;
|
|
});
|
|
|
|
// ../eve/node_modules/semver/ranges/max-satisfying.js
|
|
var require_max_satisfying = __commonJS((exports, module) => {
|
|
var SemVer = require_semver();
|
|
var Range = require_range();
|
|
var maxSatisfying = (versions, range, options2) => {
|
|
let max = null;
|
|
let maxSV = null;
|
|
let rangeObj = null;
|
|
try {
|
|
rangeObj = new Range(range, options2);
|
|
} catch (er) {
|
|
return null;
|
|
}
|
|
versions.forEach((v) => {
|
|
if (rangeObj.test(v)) {
|
|
if (!max || maxSV.compare(v) === -1) {
|
|
max = v;
|
|
maxSV = new SemVer(max, options2);
|
|
}
|
|
}
|
|
});
|
|
return max;
|
|
};
|
|
module.exports = maxSatisfying;
|
|
});
|
|
|
|
// ../eve/node_modules/semver/ranges/min-satisfying.js
|
|
var require_min_satisfying = __commonJS((exports, module) => {
|
|
var SemVer = require_semver();
|
|
var Range = require_range();
|
|
var minSatisfying = (versions, range, options2) => {
|
|
let min = null;
|
|
let minSV = null;
|
|
let rangeObj = null;
|
|
try {
|
|
rangeObj = new Range(range, options2);
|
|
} catch (er) {
|
|
return null;
|
|
}
|
|
versions.forEach((v) => {
|
|
if (rangeObj.test(v)) {
|
|
if (!min || minSV.compare(v) === 1) {
|
|
min = v;
|
|
minSV = new SemVer(min, options2);
|
|
}
|
|
}
|
|
});
|
|
return min;
|
|
};
|
|
module.exports = minSatisfying;
|
|
});
|
|
|
|
// ../eve/node_modules/semver/ranges/min-version.js
|
|
var require_min_version = __commonJS((exports, module) => {
|
|
var SemVer = require_semver();
|
|
var Range = require_range();
|
|
var gt2 = require_gt();
|
|
var minVersion = (range, loose) => {
|
|
range = new Range(range, loose);
|
|
let minver = new SemVer("0.0.0");
|
|
if (range.test(minver)) {
|
|
return minver;
|
|
}
|
|
minver = new SemVer("0.0.0-0");
|
|
if (range.test(minver)) {
|
|
return minver;
|
|
}
|
|
minver = null;
|
|
for (let i = 0;i < range.set.length; ++i) {
|
|
const comparators = range.set[i];
|
|
let setMin = null;
|
|
comparators.forEach((comparator) => {
|
|
const compver = new SemVer(comparator.semver.version);
|
|
switch (comparator.operator) {
|
|
case ">":
|
|
if (compver.prerelease.length === 0) {
|
|
compver.patch++;
|
|
} else {
|
|
compver.prerelease.push(0);
|
|
}
|
|
compver.raw = compver.format();
|
|
case "":
|
|
case ">=":
|
|
if (!setMin || gt2(compver, setMin)) {
|
|
setMin = compver;
|
|
}
|
|
break;
|
|
case "<":
|
|
case "<=":
|
|
break;
|
|
default:
|
|
throw new Error(`Unexpected operation: ${comparator.operator}`);
|
|
}
|
|
});
|
|
if (setMin && (!minver || gt2(minver, setMin))) {
|
|
minver = setMin;
|
|
}
|
|
}
|
|
if (minver && range.test(minver)) {
|
|
return minver;
|
|
}
|
|
return null;
|
|
};
|
|
module.exports = minVersion;
|
|
});
|
|
|
|
// ../eve/node_modules/semver/ranges/valid.js
|
|
var require_valid2 = __commonJS((exports, module) => {
|
|
var Range = require_range();
|
|
var validRange = (range, options2) => {
|
|
try {
|
|
return new Range(range, options2).range || "*";
|
|
} catch (er) {
|
|
return null;
|
|
}
|
|
};
|
|
module.exports = validRange;
|
|
});
|
|
|
|
// ../eve/node_modules/semver/ranges/outside.js
|
|
var require_outside = __commonJS((exports, module) => {
|
|
var SemVer = require_semver();
|
|
var Comparator = require_comparator();
|
|
var { ANY } = Comparator;
|
|
var Range = require_range();
|
|
var satisfies = require_satisfies();
|
|
var gt2 = require_gt();
|
|
var lt2 = require_lt();
|
|
var lte2 = require_lte();
|
|
var gte2 = require_gte();
|
|
var outside = (version2, range, hilo, options2) => {
|
|
version2 = new SemVer(version2, options2);
|
|
range = new Range(range, options2);
|
|
let gtfn, ltefn, ltfn, comp, ecomp;
|
|
switch (hilo) {
|
|
case ">":
|
|
gtfn = gt2;
|
|
ltefn = lte2;
|
|
ltfn = lt2;
|
|
comp = ">";
|
|
ecomp = ">=";
|
|
break;
|
|
case "<":
|
|
gtfn = lt2;
|
|
ltefn = gte2;
|
|
ltfn = gt2;
|
|
comp = "<";
|
|
ecomp = "<=";
|
|
break;
|
|
default:
|
|
throw new TypeError('Must provide a hilo val of "<" or ">"');
|
|
}
|
|
if (satisfies(version2, range, options2)) {
|
|
return false;
|
|
}
|
|
for (let i = 0;i < range.set.length; ++i) {
|
|
const comparators = range.set[i];
|
|
let high = null;
|
|
let low = null;
|
|
comparators.forEach((comparator) => {
|
|
if (comparator.semver === ANY) {
|
|
comparator = new Comparator(">=0.0.0");
|
|
}
|
|
high = high || comparator;
|
|
low = low || comparator;
|
|
if (gtfn(comparator.semver, high.semver, options2)) {
|
|
high = comparator;
|
|
} else if (ltfn(comparator.semver, low.semver, options2)) {
|
|
low = comparator;
|
|
}
|
|
});
|
|
if (high.operator === comp || high.operator === ecomp) {
|
|
return false;
|
|
}
|
|
if ((!low.operator || low.operator === comp) && ltefn(version2, low.semver)) {
|
|
return false;
|
|
} else if (low.operator === ecomp && ltfn(version2, low.semver)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
};
|
|
module.exports = outside;
|
|
});
|
|
|
|
// ../eve/node_modules/semver/ranges/gtr.js
|
|
var require_gtr = __commonJS((exports, module) => {
|
|
var outside = require_outside();
|
|
var gtr = (version2, range, options2) => outside(version2, range, ">", options2);
|
|
module.exports = gtr;
|
|
});
|
|
|
|
// ../eve/node_modules/semver/ranges/ltr.js
|
|
var require_ltr = __commonJS((exports, module) => {
|
|
var outside = require_outside();
|
|
var ltr = (version2, range, options2) => outside(version2, range, "<", options2);
|
|
module.exports = ltr;
|
|
});
|
|
|
|
// ../eve/node_modules/semver/ranges/intersects.js
|
|
var require_intersects = __commonJS((exports, module) => {
|
|
var Range = require_range();
|
|
var intersects = (r1, r2, options2) => {
|
|
r1 = new Range(r1, options2);
|
|
r2 = new Range(r2, options2);
|
|
return r1.intersects(r2, options2);
|
|
};
|
|
module.exports = intersects;
|
|
});
|
|
|
|
// ../eve/node_modules/semver/ranges/simplify.js
|
|
var require_simplify = __commonJS((exports, module) => {
|
|
var satisfies = require_satisfies();
|
|
var compare = require_compare();
|
|
module.exports = (versions, range, options2) => {
|
|
const set = [];
|
|
let first = null;
|
|
let prev = null;
|
|
const v = versions.sort((a, b) => compare(a, b, options2));
|
|
for (const version2 of v) {
|
|
const included = satisfies(version2, range, options2);
|
|
if (included) {
|
|
prev = version2;
|
|
if (!first) {
|
|
first = version2;
|
|
}
|
|
} else {
|
|
if (prev) {
|
|
set.push([first, prev]);
|
|
}
|
|
prev = null;
|
|
first = null;
|
|
}
|
|
}
|
|
if (first) {
|
|
set.push([first, null]);
|
|
}
|
|
const ranges = [];
|
|
for (const [min, max] of set) {
|
|
if (min === max) {
|
|
ranges.push(min);
|
|
} else if (!max && min === v[0]) {
|
|
ranges.push("*");
|
|
} else if (!max) {
|
|
ranges.push(`>=${min}`);
|
|
} else if (min === v[0]) {
|
|
ranges.push(`<=${max}`);
|
|
} else {
|
|
ranges.push(`${min} - ${max}`);
|
|
}
|
|
}
|
|
const simplified = ranges.join(" || ");
|
|
const original = typeof range.raw === "string" ? range.raw : String(range);
|
|
return simplified.length < original.length ? simplified : range;
|
|
};
|
|
});
|
|
|
|
// ../eve/node_modules/semver/ranges/subset.js
|
|
var require_subset = __commonJS((exports, module) => {
|
|
var Range = require_range();
|
|
var Comparator = require_comparator();
|
|
var { ANY } = Comparator;
|
|
var satisfies = require_satisfies();
|
|
var compare = require_compare();
|
|
var subset = (sub, dom, options2 = {}) => {
|
|
if (sub === dom) {
|
|
return true;
|
|
}
|
|
sub = new Range(sub, options2);
|
|
dom = new Range(dom, options2);
|
|
let sawNonNull = false;
|
|
OUTER:
|
|
for (const simpleSub of sub.set) {
|
|
for (const simpleDom of dom.set) {
|
|
const isSub = simpleSubset(simpleSub, simpleDom, options2);
|
|
sawNonNull = sawNonNull || isSub !== null;
|
|
if (isSub) {
|
|
continue OUTER;
|
|
}
|
|
}
|
|
if (sawNonNull) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
};
|
|
var minimumVersionWithPreRelease = [new Comparator(">=0.0.0-0")];
|
|
var minimumVersion = [new Comparator(">=0.0.0")];
|
|
var simpleSubset = (sub, dom, options2) => {
|
|
if (sub === dom) {
|
|
return true;
|
|
}
|
|
if (sub.length === 1 && sub[0].semver === ANY) {
|
|
if (dom.length === 1 && dom[0].semver === ANY) {
|
|
return true;
|
|
} else if (options2.includePrerelease) {
|
|
sub = minimumVersionWithPreRelease;
|
|
} else {
|
|
sub = minimumVersion;
|
|
}
|
|
}
|
|
if (dom.length === 1 && dom[0].semver === ANY) {
|
|
if (options2.includePrerelease) {
|
|
return true;
|
|
} else {
|
|
dom = minimumVersion;
|
|
}
|
|
}
|
|
const eqSet = new Set;
|
|
let gt2, lt2;
|
|
for (const c of sub) {
|
|
if (c.operator === ">" || c.operator === ">=") {
|
|
gt2 = higherGT(gt2, c, options2);
|
|
} else if (c.operator === "<" || c.operator === "<=") {
|
|
lt2 = lowerLT(lt2, c, options2);
|
|
} else {
|
|
eqSet.add(c.semver);
|
|
}
|
|
}
|
|
if (eqSet.size > 1) {
|
|
return null;
|
|
}
|
|
let gtltComp;
|
|
if (gt2 && lt2) {
|
|
gtltComp = compare(gt2.semver, lt2.semver, options2);
|
|
if (gtltComp > 0) {
|
|
return null;
|
|
} else if (gtltComp === 0 && (gt2.operator !== ">=" || lt2.operator !== "<=")) {
|
|
return null;
|
|
}
|
|
}
|
|
for (const eq2 of eqSet) {
|
|
if (gt2 && !satisfies(eq2, String(gt2), options2)) {
|
|
return null;
|
|
}
|
|
if (lt2 && !satisfies(eq2, String(lt2), options2)) {
|
|
return null;
|
|
}
|
|
for (const c of dom) {
|
|
if (!satisfies(eq2, String(c), options2)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
let higher, lower;
|
|
let hasDomLT, hasDomGT;
|
|
let needDomLTPre = lt2 && !options2.includePrerelease && lt2.semver.prerelease.length ? lt2.semver : false;
|
|
let needDomGTPre = gt2 && !options2.includePrerelease && gt2.semver.prerelease.length ? gt2.semver : false;
|
|
if (needDomLTPre && needDomLTPre.prerelease.length === 1 && lt2.operator === "<" && needDomLTPre.prerelease[0] === 0) {
|
|
needDomLTPre = false;
|
|
}
|
|
for (const c of dom) {
|
|
hasDomGT = hasDomGT || c.operator === ">" || c.operator === ">=";
|
|
hasDomLT = hasDomLT || c.operator === "<" || c.operator === "<=";
|
|
if (gt2) {
|
|
if (needDomGTPre) {
|
|
if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomGTPre.major && c.semver.minor === needDomGTPre.minor && c.semver.patch === needDomGTPre.patch) {
|
|
needDomGTPre = false;
|
|
}
|
|
}
|
|
if (c.operator === ">" || c.operator === ">=") {
|
|
higher = higherGT(gt2, c, options2);
|
|
if (higher === c && higher !== gt2) {
|
|
return false;
|
|
}
|
|
} else if (gt2.operator === ">=" && !satisfies(gt2.semver, String(c), options2)) {
|
|
return false;
|
|
}
|
|
}
|
|
if (lt2) {
|
|
if (needDomLTPre) {
|
|
if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomLTPre.major && c.semver.minor === needDomLTPre.minor && c.semver.patch === needDomLTPre.patch) {
|
|
needDomLTPre = false;
|
|
}
|
|
}
|
|
if (c.operator === "<" || c.operator === "<=") {
|
|
lower = lowerLT(lt2, c, options2);
|
|
if (lower === c && lower !== lt2) {
|
|
return false;
|
|
}
|
|
} else if (lt2.operator === "<=" && !satisfies(lt2.semver, String(c), options2)) {
|
|
return false;
|
|
}
|
|
}
|
|
if (!c.operator && (lt2 || gt2) && gtltComp !== 0) {
|
|
return false;
|
|
}
|
|
}
|
|
if (gt2 && hasDomLT && !lt2 && gtltComp !== 0) {
|
|
return false;
|
|
}
|
|
if (lt2 && hasDomGT && !gt2 && gtltComp !== 0) {
|
|
return false;
|
|
}
|
|
if (needDomGTPre || needDomLTPre) {
|
|
return false;
|
|
}
|
|
return true;
|
|
};
|
|
var higherGT = (a, b, options2) => {
|
|
if (!a) {
|
|
return b;
|
|
}
|
|
const comp = compare(a.semver, b.semver, options2);
|
|
return comp > 0 ? a : comp < 0 ? b : b.operator === ">" && a.operator === ">=" ? b : a;
|
|
};
|
|
var lowerLT = (a, b, options2) => {
|
|
if (!a) {
|
|
return b;
|
|
}
|
|
const comp = compare(a.semver, b.semver, options2);
|
|
return comp < 0 ? a : comp > 0 ? b : b.operator === "<" && a.operator === "<=" ? b : a;
|
|
};
|
|
module.exports = subset;
|
|
});
|
|
|
|
// ../eve/node_modules/semver/index.js
|
|
var require_semver2 = __commonJS((exports, module) => {
|
|
var internalRe = require_re();
|
|
var constants = require_constants();
|
|
var SemVer = require_semver();
|
|
var identifiers = require_identifiers();
|
|
var parse = require_parse();
|
|
var valid = require_valid();
|
|
var clean = require_clean();
|
|
var inc = require_inc();
|
|
var diff = require_diff();
|
|
var major = require_major();
|
|
var minor = require_minor();
|
|
var patch = require_patch();
|
|
var prerelease = require_prerelease();
|
|
var compare = require_compare();
|
|
var rcompare = require_rcompare();
|
|
var compareLoose = require_compare_loose();
|
|
var compareBuild = require_compare_build();
|
|
var sort = require_sort();
|
|
var rsort = require_rsort();
|
|
var gt2 = require_gt();
|
|
var lt2 = require_lt();
|
|
var eq2 = require_eq();
|
|
var neq = require_neq();
|
|
var gte2 = require_gte();
|
|
var lte2 = require_lte();
|
|
var cmp = require_cmp();
|
|
var coerce = require_coerce();
|
|
var Comparator = require_comparator();
|
|
var Range = require_range();
|
|
var satisfies = require_satisfies();
|
|
var toComparators = require_to_comparators();
|
|
var maxSatisfying = require_max_satisfying();
|
|
var minSatisfying = require_min_satisfying();
|
|
var minVersion = require_min_version();
|
|
var validRange = require_valid2();
|
|
var outside = require_outside();
|
|
var gtr = require_gtr();
|
|
var ltr = require_ltr();
|
|
var intersects = require_intersects();
|
|
var simplifyRange = require_simplify();
|
|
var subset = require_subset();
|
|
module.exports = {
|
|
parse,
|
|
valid,
|
|
clean,
|
|
inc,
|
|
diff,
|
|
major,
|
|
minor,
|
|
patch,
|
|
prerelease,
|
|
compare,
|
|
rcompare,
|
|
compareLoose,
|
|
compareBuild,
|
|
sort,
|
|
rsort,
|
|
gt: gt2,
|
|
lt: lt2,
|
|
eq: eq2,
|
|
neq,
|
|
gte: gte2,
|
|
lte: lte2,
|
|
cmp,
|
|
coerce,
|
|
Comparator,
|
|
Range,
|
|
satisfies,
|
|
toComparators,
|
|
maxSatisfying,
|
|
minSatisfying,
|
|
minVersion,
|
|
validRange,
|
|
outside,
|
|
gtr,
|
|
ltr,
|
|
intersects,
|
|
simplifyRange,
|
|
subset,
|
|
SemVer,
|
|
re: internalRe.re,
|
|
src: internalRe.src,
|
|
tokens: internalRe.t,
|
|
SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION,
|
|
RELEASE_TYPES: constants.RELEASE_TYPES,
|
|
compareIdentifiers: identifiers.compareIdentifiers,
|
|
rcompareIdentifiers: identifiers.rcompareIdentifiers
|
|
};
|
|
});
|
|
|
|
// ../eve/node_modules/jsonwebtoken/lib/asymmetricKeyDetailsSupported.js
|
|
var require_asymmetricKeyDetailsSupported = __commonJS((exports, module) => {
|
|
var semver = require_semver2();
|
|
module.exports = semver.satisfies(process.version, ">=15.7.0");
|
|
});
|
|
|
|
// ../eve/node_modules/jsonwebtoken/lib/rsaPssKeyDetailsSupported.js
|
|
var require_rsaPssKeyDetailsSupported = __commonJS((exports, module) => {
|
|
var semver = require_semver2();
|
|
module.exports = semver.satisfies(process.version, ">=16.9.0");
|
|
});
|
|
|
|
// ../eve/node_modules/jsonwebtoken/lib/validateAsymmetricKey.js
|
|
var require_validateAsymmetricKey = __commonJS((exports, module) => {
|
|
var ASYMMETRIC_KEY_DETAILS_SUPPORTED = require_asymmetricKeyDetailsSupported();
|
|
var RSA_PSS_KEY_DETAILS_SUPPORTED = require_rsaPssKeyDetailsSupported();
|
|
var allowedAlgorithmsForKeys = {
|
|
ec: ["ES256", "ES384", "ES512"],
|
|
rsa: ["RS256", "PS256", "RS384", "PS384", "RS512", "PS512"],
|
|
"rsa-pss": ["PS256", "PS384", "PS512"]
|
|
};
|
|
var allowedCurves = {
|
|
ES256: "prime256v1",
|
|
ES384: "secp384r1",
|
|
ES512: "secp521r1"
|
|
};
|
|
module.exports = function(algorithm, key) {
|
|
if (!algorithm || !key)
|
|
return;
|
|
const keyType = key.asymmetricKeyType;
|
|
if (!keyType)
|
|
return;
|
|
const allowedAlgorithms = allowedAlgorithmsForKeys[keyType];
|
|
if (!allowedAlgorithms) {
|
|
throw new Error(`Unknown key type "${keyType}".`);
|
|
}
|
|
if (!allowedAlgorithms.includes(algorithm)) {
|
|
throw new Error(`"alg" parameter for "${keyType}" key type must be one of: ${allowedAlgorithms.join(", ")}.`);
|
|
}
|
|
if (ASYMMETRIC_KEY_DETAILS_SUPPORTED) {
|
|
switch (keyType) {
|
|
case "ec":
|
|
const keyCurve = key.asymmetricKeyDetails.namedCurve;
|
|
const allowedCurve = allowedCurves[algorithm];
|
|
if (keyCurve !== allowedCurve) {
|
|
throw new Error(`"alg" parameter "${algorithm}" requires curve "${allowedCurve}".`);
|
|
}
|
|
break;
|
|
case "rsa-pss":
|
|
if (RSA_PSS_KEY_DETAILS_SUPPORTED) {
|
|
const length = parseInt(algorithm.slice(-3), 10);
|
|
const { hashAlgorithm, mgf1HashAlgorithm, saltLength } = key.asymmetricKeyDetails;
|
|
if (hashAlgorithm !== `sha${length}` || mgf1HashAlgorithm !== hashAlgorithm) {
|
|
throw new Error(`Invalid key for this operation, its RSA-PSS parameters do not meet the requirements of "alg" ${algorithm}.`);
|
|
}
|
|
if (saltLength !== undefined && saltLength > length >> 3) {
|
|
throw new Error(`Invalid key for this operation, its RSA-PSS parameter saltLength does not meet the requirements of "alg" ${algorithm}.`);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
};
|
|
});
|
|
|
|
// ../eve/node_modules/jsonwebtoken/lib/psSupported.js
|
|
var require_psSupported = __commonJS((exports, module) => {
|
|
var semver = require_semver2();
|
|
module.exports = semver.satisfies(process.version, "^6.12.0 || >=8.0.0");
|
|
});
|
|
|
|
// ../eve/node_modules/jsonwebtoken/verify.js
|
|
var require_verify = __commonJS((exports, module) => {
|
|
var JsonWebTokenError = require_JsonWebTokenError();
|
|
var NotBeforeError = require_NotBeforeError();
|
|
var TokenExpiredError = require_TokenExpiredError();
|
|
var decode = require_decode();
|
|
var timespan = require_timespan();
|
|
var validateAsymmetricKey = require_validateAsymmetricKey();
|
|
var PS_SUPPORTED = require_psSupported();
|
|
var jws = require_jws();
|
|
var { KeyObject, createSecretKey, createPublicKey } = __require("crypto");
|
|
var PUB_KEY_ALGS = ["RS256", "RS384", "RS512"];
|
|
var EC_KEY_ALGS = ["ES256", "ES384", "ES512"];
|
|
var RSA_KEY_ALGS = ["RS256", "RS384", "RS512"];
|
|
var HS_ALGS = ["HS256", "HS384", "HS512"];
|
|
if (PS_SUPPORTED) {
|
|
PUB_KEY_ALGS.splice(PUB_KEY_ALGS.length, 0, "PS256", "PS384", "PS512");
|
|
RSA_KEY_ALGS.splice(RSA_KEY_ALGS.length, 0, "PS256", "PS384", "PS512");
|
|
}
|
|
module.exports = function(jwtString, secretOrPublicKey, options2, callback) {
|
|
if (typeof options2 === "function" && !callback) {
|
|
callback = options2;
|
|
options2 = {};
|
|
}
|
|
if (!options2) {
|
|
options2 = {};
|
|
}
|
|
options2 = Object.assign({}, options2);
|
|
let done;
|
|
if (callback) {
|
|
done = callback;
|
|
} else {
|
|
done = function(err, data) {
|
|
if (err)
|
|
throw err;
|
|
return data;
|
|
};
|
|
}
|
|
if (options2.clockTimestamp && typeof options2.clockTimestamp !== "number") {
|
|
return done(new JsonWebTokenError("clockTimestamp must be a number"));
|
|
}
|
|
if (options2.nonce !== undefined && (typeof options2.nonce !== "string" || options2.nonce.trim() === "")) {
|
|
return done(new JsonWebTokenError("nonce must be a non-empty string"));
|
|
}
|
|
if (options2.allowInvalidAsymmetricKeyTypes !== undefined && typeof options2.allowInvalidAsymmetricKeyTypes !== "boolean") {
|
|
return done(new JsonWebTokenError("allowInvalidAsymmetricKeyTypes must be a boolean"));
|
|
}
|
|
const clockTimestamp = options2.clockTimestamp || Math.floor(Date.now() / 1000);
|
|
if (!jwtString) {
|
|
return done(new JsonWebTokenError("jwt must be provided"));
|
|
}
|
|
if (typeof jwtString !== "string") {
|
|
return done(new JsonWebTokenError("jwt must be a string"));
|
|
}
|
|
const parts = jwtString.split(".");
|
|
if (parts.length !== 3) {
|
|
return done(new JsonWebTokenError("jwt malformed"));
|
|
}
|
|
let decodedToken;
|
|
try {
|
|
decodedToken = decode(jwtString, { complete: true });
|
|
} catch (err) {
|
|
return done(err);
|
|
}
|
|
if (!decodedToken) {
|
|
return done(new JsonWebTokenError("invalid token"));
|
|
}
|
|
const header = decodedToken.header;
|
|
let getSecret;
|
|
if (typeof secretOrPublicKey === "function") {
|
|
if (!callback) {
|
|
return done(new JsonWebTokenError("verify must be called asynchronous if secret or public key is provided as a callback"));
|
|
}
|
|
getSecret = secretOrPublicKey;
|
|
} else {
|
|
getSecret = function(header2, secretCallback) {
|
|
return secretCallback(null, secretOrPublicKey);
|
|
};
|
|
}
|
|
return getSecret(header, function(err, secretOrPublicKey2) {
|
|
if (err) {
|
|
return done(new JsonWebTokenError("error in secret or public key callback: " + err.message));
|
|
}
|
|
const hasSignature = parts[2].trim() !== "";
|
|
if (!hasSignature && secretOrPublicKey2) {
|
|
return done(new JsonWebTokenError("jwt signature is required"));
|
|
}
|
|
if (hasSignature && !secretOrPublicKey2) {
|
|
return done(new JsonWebTokenError("secret or public key must be provided"));
|
|
}
|
|
if (!hasSignature && !options2.algorithms) {
|
|
return done(new JsonWebTokenError('please specify "none" in "algorithms" to verify unsigned tokens'));
|
|
}
|
|
if (secretOrPublicKey2 != null && !(secretOrPublicKey2 instanceof KeyObject)) {
|
|
try {
|
|
secretOrPublicKey2 = createPublicKey(secretOrPublicKey2);
|
|
} catch (_) {
|
|
try {
|
|
secretOrPublicKey2 = createSecretKey(typeof secretOrPublicKey2 === "string" ? Buffer.from(secretOrPublicKey2) : secretOrPublicKey2);
|
|
} catch (_2) {
|
|
return done(new JsonWebTokenError("secretOrPublicKey is not valid key material"));
|
|
}
|
|
}
|
|
}
|
|
if (!options2.algorithms) {
|
|
if (secretOrPublicKey2.type === "secret") {
|
|
options2.algorithms = HS_ALGS;
|
|
} else if (["rsa", "rsa-pss"].includes(secretOrPublicKey2.asymmetricKeyType)) {
|
|
options2.algorithms = RSA_KEY_ALGS;
|
|
} else if (secretOrPublicKey2.asymmetricKeyType === "ec") {
|
|
options2.algorithms = EC_KEY_ALGS;
|
|
} else {
|
|
options2.algorithms = PUB_KEY_ALGS;
|
|
}
|
|
}
|
|
if (options2.algorithms.indexOf(decodedToken.header.alg) === -1) {
|
|
return done(new JsonWebTokenError("invalid algorithm"));
|
|
}
|
|
if (header.alg.startsWith("HS") && secretOrPublicKey2.type !== "secret") {
|
|
return done(new JsonWebTokenError(`secretOrPublicKey must be a symmetric key when using ${header.alg}`));
|
|
} else if (/^(?:RS|PS|ES)/.test(header.alg) && secretOrPublicKey2.type !== "public") {
|
|
return done(new JsonWebTokenError(`secretOrPublicKey must be an asymmetric key when using ${header.alg}`));
|
|
}
|
|
if (!options2.allowInvalidAsymmetricKeyTypes) {
|
|
try {
|
|
validateAsymmetricKey(header.alg, secretOrPublicKey2);
|
|
} catch (e) {
|
|
return done(e);
|
|
}
|
|
}
|
|
let valid;
|
|
try {
|
|
valid = jws.verify(jwtString, decodedToken.header.alg, secretOrPublicKey2);
|
|
} catch (e) {
|
|
return done(e);
|
|
}
|
|
if (!valid) {
|
|
return done(new JsonWebTokenError("invalid signature"));
|
|
}
|
|
const payload = decodedToken.payload;
|
|
if (typeof payload.nbf !== "undefined" && !options2.ignoreNotBefore) {
|
|
if (typeof payload.nbf !== "number") {
|
|
return done(new JsonWebTokenError("invalid nbf value"));
|
|
}
|
|
if (payload.nbf > clockTimestamp + (options2.clockTolerance || 0)) {
|
|
return done(new NotBeforeError("jwt not active", new Date(payload.nbf * 1000)));
|
|
}
|
|
}
|
|
if (typeof payload.exp !== "undefined" && !options2.ignoreExpiration) {
|
|
if (typeof payload.exp !== "number") {
|
|
return done(new JsonWebTokenError("invalid exp value"));
|
|
}
|
|
if (clockTimestamp >= payload.exp + (options2.clockTolerance || 0)) {
|
|
return done(new TokenExpiredError("jwt expired", new Date(payload.exp * 1000)));
|
|
}
|
|
}
|
|
if (options2.audience) {
|
|
const audiences = Array.isArray(options2.audience) ? options2.audience : [options2.audience];
|
|
const target = Array.isArray(payload.aud) ? payload.aud : [payload.aud];
|
|
const match = target.some(function(targetAudience) {
|
|
return audiences.some(function(audience) {
|
|
return audience instanceof RegExp ? audience.test(targetAudience) : audience === targetAudience;
|
|
});
|
|
});
|
|
if (!match) {
|
|
return done(new JsonWebTokenError("jwt audience invalid. expected: " + audiences.join(" or ")));
|
|
}
|
|
}
|
|
if (options2.issuer) {
|
|
const invalid_issuer = typeof options2.issuer === "string" && payload.iss !== options2.issuer || Array.isArray(options2.issuer) && options2.issuer.indexOf(payload.iss) === -1;
|
|
if (invalid_issuer) {
|
|
return done(new JsonWebTokenError("jwt issuer invalid. expected: " + options2.issuer));
|
|
}
|
|
}
|
|
if (options2.subject) {
|
|
if (payload.sub !== options2.subject) {
|
|
return done(new JsonWebTokenError("jwt subject invalid. expected: " + options2.subject));
|
|
}
|
|
}
|
|
if (options2.jwtid) {
|
|
if (payload.jti !== options2.jwtid) {
|
|
return done(new JsonWebTokenError("jwt jwtid invalid. expected: " + options2.jwtid));
|
|
}
|
|
}
|
|
if (options2.nonce) {
|
|
if (payload.nonce !== options2.nonce) {
|
|
return done(new JsonWebTokenError("jwt nonce invalid. expected: " + options2.nonce));
|
|
}
|
|
}
|
|
if (options2.maxAge) {
|
|
if (typeof payload.iat !== "number") {
|
|
return done(new JsonWebTokenError("iat required when maxAge is specified"));
|
|
}
|
|
const maxAgeTimestamp = timespan(options2.maxAge, payload.iat);
|
|
if (typeof maxAgeTimestamp === "undefined") {
|
|
return done(new JsonWebTokenError('"maxAge" should be a number of seconds or string representing a timespan eg: "1d", "20h", 60'));
|
|
}
|
|
if (clockTimestamp >= maxAgeTimestamp + (options2.clockTolerance || 0)) {
|
|
return done(new TokenExpiredError("maxAge exceeded", new Date(maxAgeTimestamp * 1000)));
|
|
}
|
|
}
|
|
if (options2.complete === true) {
|
|
const signature = decodedToken.signature;
|
|
return done(null, {
|
|
header,
|
|
payload,
|
|
signature
|
|
});
|
|
}
|
|
return done(null, payload);
|
|
});
|
|
};
|
|
});
|
|
|
|
// ../eve/node_modules/lodash.includes/index.js
|
|
var require_lodash = __commonJS((exports, module) => {
|
|
var INFINITY = 1 / 0;
|
|
var MAX_SAFE_INTEGER = 9007199254740991;
|
|
var MAX_INTEGER = 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000;
|
|
var NAN = 0 / 0;
|
|
var argsTag = "[object Arguments]";
|
|
var funcTag = "[object Function]";
|
|
var genTag = "[object GeneratorFunction]";
|
|
var stringTag = "[object String]";
|
|
var symbolTag = "[object Symbol]";
|
|
var reTrim = /^\s+|\s+$/g;
|
|
var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
|
|
var reIsBinary = /^0b[01]+$/i;
|
|
var reIsOctal = /^0o[0-7]+$/i;
|
|
var reIsUint = /^(?:0|[1-9]\d*)$/;
|
|
var freeParseInt = parseInt;
|
|
function arrayMap(array, iteratee) {
|
|
var index2 = -1, length = array ? array.length : 0, result = Array(length);
|
|
while (++index2 < length) {
|
|
result[index2] = iteratee(array[index2], index2, array);
|
|
}
|
|
return result;
|
|
}
|
|
function baseFindIndex(array, predicate, fromIndex, fromRight) {
|
|
var length = array.length, index2 = fromIndex + (fromRight ? 1 : -1);
|
|
while (fromRight ? index2-- : ++index2 < length) {
|
|
if (predicate(array[index2], index2, array)) {
|
|
return index2;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
function baseIndexOf(array, value, fromIndex) {
|
|
if (value !== value) {
|
|
return baseFindIndex(array, baseIsNaN, fromIndex);
|
|
}
|
|
var index2 = fromIndex - 1, length = array.length;
|
|
while (++index2 < length) {
|
|
if (array[index2] === value) {
|
|
return index2;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
function baseIsNaN(value) {
|
|
return value !== value;
|
|
}
|
|
function baseTimes(n, iteratee) {
|
|
var index2 = -1, result = Array(n);
|
|
while (++index2 < n) {
|
|
result[index2] = iteratee(index2);
|
|
}
|
|
return result;
|
|
}
|
|
function baseValues(object, props) {
|
|
return arrayMap(props, function(key) {
|
|
return object[key];
|
|
});
|
|
}
|
|
function overArg(func, transform) {
|
|
return function(arg) {
|
|
return func(transform(arg));
|
|
};
|
|
}
|
|
var objectProto = Object.prototype;
|
|
var hasOwnProperty = objectProto.hasOwnProperty;
|
|
var objectToString = objectProto.toString;
|
|
var propertyIsEnumerable = objectProto.propertyIsEnumerable;
|
|
var nativeKeys = overArg(Object.keys, Object);
|
|
var nativeMax = Math.max;
|
|
function arrayLikeKeys(value, inherited) {
|
|
var result = isArray(value) || isArguments(value) ? baseTimes(value.length, String) : [];
|
|
var length = result.length, skipIndexes = !!length;
|
|
for (var key in value) {
|
|
if ((inherited || hasOwnProperty.call(value, key)) && !(skipIndexes && (key == "length" || isIndex(key, length)))) {
|
|
result.push(key);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function baseKeys(object) {
|
|
if (!isPrototype(object)) {
|
|
return nativeKeys(object);
|
|
}
|
|
var result = [];
|
|
for (var key in Object(object)) {
|
|
if (hasOwnProperty.call(object, key) && key != "constructor") {
|
|
result.push(key);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function isIndex(value, length) {
|
|
length = length == null ? MAX_SAFE_INTEGER : length;
|
|
return !!length && (typeof value == "number" || reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
|
|
}
|
|
function isPrototype(value) {
|
|
var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto;
|
|
return value === proto;
|
|
}
|
|
function includes(collection, value, fromIndex, guard) {
|
|
collection = isArrayLike(collection) ? collection : values(collection);
|
|
fromIndex = fromIndex && !guard ? toInteger(fromIndex) : 0;
|
|
var length = collection.length;
|
|
if (fromIndex < 0) {
|
|
fromIndex = nativeMax(length + fromIndex, 0);
|
|
}
|
|
return isString(collection) ? fromIndex <= length && collection.indexOf(value, fromIndex) > -1 : !!length && baseIndexOf(collection, value, fromIndex) > -1;
|
|
}
|
|
function isArguments(value) {
|
|
return isArrayLikeObject(value) && hasOwnProperty.call(value, "callee") && (!propertyIsEnumerable.call(value, "callee") || objectToString.call(value) == argsTag);
|
|
}
|
|
var isArray = Array.isArray;
|
|
function isArrayLike(value) {
|
|
return value != null && isLength(value.length) && !isFunction(value);
|
|
}
|
|
function isArrayLikeObject(value) {
|
|
return isObjectLike(value) && isArrayLike(value);
|
|
}
|
|
function isFunction(value) {
|
|
var tag = isObject(value) ? objectToString.call(value) : "";
|
|
return tag == funcTag || tag == genTag;
|
|
}
|
|
function isLength(value) {
|
|
return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
|
|
}
|
|
function isObject(value) {
|
|
var type = typeof value;
|
|
return !!value && (type == "object" || type == "function");
|
|
}
|
|
function isObjectLike(value) {
|
|
return !!value && typeof value == "object";
|
|
}
|
|
function isString(value) {
|
|
return typeof value == "string" || !isArray(value) && isObjectLike(value) && objectToString.call(value) == stringTag;
|
|
}
|
|
function isSymbol(value) {
|
|
return typeof value == "symbol" || isObjectLike(value) && objectToString.call(value) == symbolTag;
|
|
}
|
|
function toFinite(value) {
|
|
if (!value) {
|
|
return value === 0 ? value : 0;
|
|
}
|
|
value = toNumber(value);
|
|
if (value === INFINITY || value === -INFINITY) {
|
|
var sign = value < 0 ? -1 : 1;
|
|
return sign * MAX_INTEGER;
|
|
}
|
|
return value === value ? value : 0;
|
|
}
|
|
function toInteger(value) {
|
|
var result = toFinite(value), remainder = result % 1;
|
|
return result === result ? remainder ? result - remainder : result : 0;
|
|
}
|
|
function toNumber(value) {
|
|
if (typeof value == "number") {
|
|
return value;
|
|
}
|
|
if (isSymbol(value)) {
|
|
return NAN;
|
|
}
|
|
if (isObject(value)) {
|
|
var other = typeof value.valueOf == "function" ? value.valueOf() : value;
|
|
value = isObject(other) ? other + "" : other;
|
|
}
|
|
if (typeof value != "string") {
|
|
return value === 0 ? value : +value;
|
|
}
|
|
value = value.replace(reTrim, "");
|
|
var isBinary = reIsBinary.test(value);
|
|
return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
|
|
}
|
|
function keys(object) {
|
|
return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
|
|
}
|
|
function values(object) {
|
|
return object ? baseValues(object, keys(object)) : [];
|
|
}
|
|
module.exports = includes;
|
|
});
|
|
|
|
// ../eve/node_modules/lodash.isboolean/index.js
|
|
var require_lodash2 = __commonJS((exports, module) => {
|
|
var boolTag = "[object Boolean]";
|
|
var objectProto = Object.prototype;
|
|
var objectToString = objectProto.toString;
|
|
function isBoolean(value) {
|
|
return value === true || value === false || isObjectLike(value) && objectToString.call(value) == boolTag;
|
|
}
|
|
function isObjectLike(value) {
|
|
return !!value && typeof value == "object";
|
|
}
|
|
module.exports = isBoolean;
|
|
});
|
|
|
|
// ../eve/node_modules/lodash.isinteger/index.js
|
|
var require_lodash3 = __commonJS((exports, module) => {
|
|
var INFINITY = 1 / 0;
|
|
var MAX_INTEGER = 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000;
|
|
var NAN = 0 / 0;
|
|
var symbolTag = "[object Symbol]";
|
|
var reTrim = /^\s+|\s+$/g;
|
|
var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
|
|
var reIsBinary = /^0b[01]+$/i;
|
|
var reIsOctal = /^0o[0-7]+$/i;
|
|
var freeParseInt = parseInt;
|
|
var objectProto = Object.prototype;
|
|
var objectToString = objectProto.toString;
|
|
function isInteger(value) {
|
|
return typeof value == "number" && value == toInteger(value);
|
|
}
|
|
function isObject(value) {
|
|
var type = typeof value;
|
|
return !!value && (type == "object" || type == "function");
|
|
}
|
|
function isObjectLike(value) {
|
|
return !!value && typeof value == "object";
|
|
}
|
|
function isSymbol(value) {
|
|
return typeof value == "symbol" || isObjectLike(value) && objectToString.call(value) == symbolTag;
|
|
}
|
|
function toFinite(value) {
|
|
if (!value) {
|
|
return value === 0 ? value : 0;
|
|
}
|
|
value = toNumber(value);
|
|
if (value === INFINITY || value === -INFINITY) {
|
|
var sign = value < 0 ? -1 : 1;
|
|
return sign * MAX_INTEGER;
|
|
}
|
|
return value === value ? value : 0;
|
|
}
|
|
function toInteger(value) {
|
|
var result = toFinite(value), remainder = result % 1;
|
|
return result === result ? remainder ? result - remainder : result : 0;
|
|
}
|
|
function toNumber(value) {
|
|
if (typeof value == "number") {
|
|
return value;
|
|
}
|
|
if (isSymbol(value)) {
|
|
return NAN;
|
|
}
|
|
if (isObject(value)) {
|
|
var other = typeof value.valueOf == "function" ? value.valueOf() : value;
|
|
value = isObject(other) ? other + "" : other;
|
|
}
|
|
if (typeof value != "string") {
|
|
return value === 0 ? value : +value;
|
|
}
|
|
value = value.replace(reTrim, "");
|
|
var isBinary = reIsBinary.test(value);
|
|
return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
|
|
}
|
|
module.exports = isInteger;
|
|
});
|
|
|
|
// ../eve/node_modules/lodash.isnumber/index.js
|
|
var require_lodash4 = __commonJS((exports, module) => {
|
|
var numberTag = "[object Number]";
|
|
var objectProto = Object.prototype;
|
|
var objectToString = objectProto.toString;
|
|
function isObjectLike(value) {
|
|
return !!value && typeof value == "object";
|
|
}
|
|
function isNumber(value) {
|
|
return typeof value == "number" || isObjectLike(value) && objectToString.call(value) == numberTag;
|
|
}
|
|
module.exports = isNumber;
|
|
});
|
|
|
|
// ../eve/node_modules/lodash.isplainobject/index.js
|
|
var require_lodash5 = __commonJS((exports, module) => {
|
|
var objectTag = "[object Object]";
|
|
function isHostObject(value) {
|
|
var result = false;
|
|
if (value != null && typeof value.toString != "function") {
|
|
try {
|
|
result = !!(value + "");
|
|
} catch (e) {}
|
|
}
|
|
return result;
|
|
}
|
|
function overArg(func, transform) {
|
|
return function(arg) {
|
|
return func(transform(arg));
|
|
};
|
|
}
|
|
var funcProto = Function.prototype;
|
|
var objectProto = Object.prototype;
|
|
var funcToString = funcProto.toString;
|
|
var hasOwnProperty = objectProto.hasOwnProperty;
|
|
var objectCtorString = funcToString.call(Object);
|
|
var objectToString = objectProto.toString;
|
|
var getPrototype = overArg(Object.getPrototypeOf, Object);
|
|
function isObjectLike(value) {
|
|
return !!value && typeof value == "object";
|
|
}
|
|
function isPlainObject(value) {
|
|
if (!isObjectLike(value) || objectToString.call(value) != objectTag || isHostObject(value)) {
|
|
return false;
|
|
}
|
|
var proto = getPrototype(value);
|
|
if (proto === null) {
|
|
return true;
|
|
}
|
|
var Ctor = hasOwnProperty.call(proto, "constructor") && proto.constructor;
|
|
return typeof Ctor == "function" && Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString;
|
|
}
|
|
module.exports = isPlainObject;
|
|
});
|
|
|
|
// ../eve/node_modules/lodash.isstring/index.js
|
|
var require_lodash6 = __commonJS((exports, module) => {
|
|
var stringTag = "[object String]";
|
|
var objectProto = Object.prototype;
|
|
var objectToString = objectProto.toString;
|
|
var isArray = Array.isArray;
|
|
function isObjectLike(value) {
|
|
return !!value && typeof value == "object";
|
|
}
|
|
function isString(value) {
|
|
return typeof value == "string" || !isArray(value) && isObjectLike(value) && objectToString.call(value) == stringTag;
|
|
}
|
|
module.exports = isString;
|
|
});
|
|
|
|
// ../eve/node_modules/lodash.once/index.js
|
|
var require_lodash7 = __commonJS((exports, module) => {
|
|
var FUNC_ERROR_TEXT = "Expected a function";
|
|
var INFINITY = 1 / 0;
|
|
var MAX_INTEGER = 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000;
|
|
var NAN = 0 / 0;
|
|
var symbolTag = "[object Symbol]";
|
|
var reTrim = /^\s+|\s+$/g;
|
|
var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
|
|
var reIsBinary = /^0b[01]+$/i;
|
|
var reIsOctal = /^0o[0-7]+$/i;
|
|
var freeParseInt = parseInt;
|
|
var objectProto = Object.prototype;
|
|
var objectToString = objectProto.toString;
|
|
function before(n, func) {
|
|
var result;
|
|
if (typeof func != "function") {
|
|
throw new TypeError(FUNC_ERROR_TEXT);
|
|
}
|
|
n = toInteger(n);
|
|
return function() {
|
|
if (--n > 0) {
|
|
result = func.apply(this, arguments);
|
|
}
|
|
if (n <= 1) {
|
|
func = undefined;
|
|
}
|
|
return result;
|
|
};
|
|
}
|
|
function once(func) {
|
|
return before(2, func);
|
|
}
|
|
function isObject(value) {
|
|
var type = typeof value;
|
|
return !!value && (type == "object" || type == "function");
|
|
}
|
|
function isObjectLike(value) {
|
|
return !!value && typeof value == "object";
|
|
}
|
|
function isSymbol(value) {
|
|
return typeof value == "symbol" || isObjectLike(value) && objectToString.call(value) == symbolTag;
|
|
}
|
|
function toFinite(value) {
|
|
if (!value) {
|
|
return value === 0 ? value : 0;
|
|
}
|
|
value = toNumber(value);
|
|
if (value === INFINITY || value === -INFINITY) {
|
|
var sign = value < 0 ? -1 : 1;
|
|
return sign * MAX_INTEGER;
|
|
}
|
|
return value === value ? value : 0;
|
|
}
|
|
function toInteger(value) {
|
|
var result = toFinite(value), remainder = result % 1;
|
|
return result === result ? remainder ? result - remainder : result : 0;
|
|
}
|
|
function toNumber(value) {
|
|
if (typeof value == "number") {
|
|
return value;
|
|
}
|
|
if (isSymbol(value)) {
|
|
return NAN;
|
|
}
|
|
if (isObject(value)) {
|
|
var other = typeof value.valueOf == "function" ? value.valueOf() : value;
|
|
value = isObject(other) ? other + "" : other;
|
|
}
|
|
if (typeof value != "string") {
|
|
return value === 0 ? value : +value;
|
|
}
|
|
value = value.replace(reTrim, "");
|
|
var isBinary = reIsBinary.test(value);
|
|
return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
|
|
}
|
|
module.exports = once;
|
|
});
|
|
|
|
// ../eve/node_modules/jsonwebtoken/sign.js
|
|
var require_sign = __commonJS((exports, module) => {
|
|
var timespan = require_timespan();
|
|
var PS_SUPPORTED = require_psSupported();
|
|
var validateAsymmetricKey = require_validateAsymmetricKey();
|
|
var jws = require_jws();
|
|
var includes = require_lodash();
|
|
var isBoolean = require_lodash2();
|
|
var isInteger = require_lodash3();
|
|
var isNumber = require_lodash4();
|
|
var isPlainObject = require_lodash5();
|
|
var isString = require_lodash6();
|
|
var once = require_lodash7();
|
|
var { KeyObject, createSecretKey, createPrivateKey } = __require("crypto");
|
|
var SUPPORTED_ALGS = ["RS256", "RS384", "RS512", "ES256", "ES384", "ES512", "HS256", "HS384", "HS512", "none"];
|
|
if (PS_SUPPORTED) {
|
|
SUPPORTED_ALGS.splice(3, 0, "PS256", "PS384", "PS512");
|
|
}
|
|
var sign_options_schema = {
|
|
expiresIn: { isValid: function(value) {
|
|
return isInteger(value) || isString(value) && value;
|
|
}, message: '"expiresIn" should be a number of seconds or string representing a timespan' },
|
|
notBefore: { isValid: function(value) {
|
|
return isInteger(value) || isString(value) && value;
|
|
}, message: '"notBefore" should be a number of seconds or string representing a timespan' },
|
|
audience: { isValid: function(value) {
|
|
return isString(value) || Array.isArray(value);
|
|
}, message: '"audience" must be a string or array' },
|
|
algorithm: { isValid: includes.bind(null, SUPPORTED_ALGS), message: '"algorithm" must be a valid string enum value' },
|
|
header: { isValid: isPlainObject, message: '"header" must be an object' },
|
|
encoding: { isValid: isString, message: '"encoding" must be a string' },
|
|
issuer: { isValid: isString, message: '"issuer" must be a string' },
|
|
subject: { isValid: isString, message: '"subject" must be a string' },
|
|
jwtid: { isValid: isString, message: '"jwtid" must be a string' },
|
|
noTimestamp: { isValid: isBoolean, message: '"noTimestamp" must be a boolean' },
|
|
keyid: { isValid: isString, message: '"keyid" must be a string' },
|
|
mutatePayload: { isValid: isBoolean, message: '"mutatePayload" must be a boolean' },
|
|
allowInsecureKeySizes: { isValid: isBoolean, message: '"allowInsecureKeySizes" must be a boolean' },
|
|
allowInvalidAsymmetricKeyTypes: { isValid: isBoolean, message: '"allowInvalidAsymmetricKeyTypes" must be a boolean' }
|
|
};
|
|
var registered_claims_schema = {
|
|
iat: { isValid: isNumber, message: '"iat" should be a number of seconds' },
|
|
exp: { isValid: isNumber, message: '"exp" should be a number of seconds' },
|
|
nbf: { isValid: isNumber, message: '"nbf" should be a number of seconds' }
|
|
};
|
|
function validate(schema, allowUnknown, object, parameterName) {
|
|
if (!isPlainObject(object)) {
|
|
throw new Error('Expected "' + parameterName + '" to be a plain object.');
|
|
}
|
|
Object.keys(object).forEach(function(key) {
|
|
const validator = schema[key];
|
|
if (!validator) {
|
|
if (!allowUnknown) {
|
|
throw new Error('"' + key + '" is not allowed in "' + parameterName + '"');
|
|
}
|
|
return;
|
|
}
|
|
if (!validator.isValid(object[key])) {
|
|
throw new Error(validator.message);
|
|
}
|
|
});
|
|
}
|
|
function validateOptions(options2) {
|
|
return validate(sign_options_schema, false, options2, "options");
|
|
}
|
|
function validatePayload(payload) {
|
|
return validate(registered_claims_schema, true, payload, "payload");
|
|
}
|
|
var options_to_payload = {
|
|
audience: "aud",
|
|
issuer: "iss",
|
|
subject: "sub",
|
|
jwtid: "jti"
|
|
};
|
|
var options_for_objects = [
|
|
"expiresIn",
|
|
"notBefore",
|
|
"noTimestamp",
|
|
"audience",
|
|
"issuer",
|
|
"subject",
|
|
"jwtid"
|
|
];
|
|
module.exports = function(payload, secretOrPrivateKey, options2, callback) {
|
|
if (typeof options2 === "function") {
|
|
callback = options2;
|
|
options2 = {};
|
|
} else {
|
|
options2 = options2 || {};
|
|
}
|
|
const isObjectPayload = typeof payload === "object" && !Buffer.isBuffer(payload);
|
|
const header = Object.assign({
|
|
alg: options2.algorithm || "HS256",
|
|
typ: isObjectPayload ? "JWT" : undefined,
|
|
kid: options2.keyid
|
|
}, options2.header);
|
|
function failure(err) {
|
|
if (callback) {
|
|
return callback(err);
|
|
}
|
|
throw err;
|
|
}
|
|
if (!secretOrPrivateKey && options2.algorithm !== "none") {
|
|
return failure(new Error("secretOrPrivateKey must have a value"));
|
|
}
|
|
if (secretOrPrivateKey != null && !(secretOrPrivateKey instanceof KeyObject)) {
|
|
try {
|
|
secretOrPrivateKey = createPrivateKey(secretOrPrivateKey);
|
|
} catch (_) {
|
|
try {
|
|
secretOrPrivateKey = createSecretKey(typeof secretOrPrivateKey === "string" ? Buffer.from(secretOrPrivateKey) : secretOrPrivateKey);
|
|
} catch (_2) {
|
|
return failure(new Error("secretOrPrivateKey is not valid key material"));
|
|
}
|
|
}
|
|
}
|
|
if (header.alg.startsWith("HS") && secretOrPrivateKey.type !== "secret") {
|
|
return failure(new Error(`secretOrPrivateKey must be a symmetric key when using ${header.alg}`));
|
|
} else if (/^(?:RS|PS|ES)/.test(header.alg)) {
|
|
if (secretOrPrivateKey.type !== "private") {
|
|
return failure(new Error(`secretOrPrivateKey must be an asymmetric key when using ${header.alg}`));
|
|
}
|
|
if (!options2.allowInsecureKeySizes && !header.alg.startsWith("ES") && secretOrPrivateKey.asymmetricKeyDetails !== undefined && secretOrPrivateKey.asymmetricKeyDetails.modulusLength < 2048) {
|
|
return failure(new Error(`secretOrPrivateKey has a minimum key size of 2048 bits for ${header.alg}`));
|
|
}
|
|
}
|
|
if (typeof payload === "undefined") {
|
|
return failure(new Error("payload is required"));
|
|
} else if (isObjectPayload) {
|
|
try {
|
|
validatePayload(payload);
|
|
} catch (error) {
|
|
return failure(error);
|
|
}
|
|
if (!options2.mutatePayload) {
|
|
payload = Object.assign({}, payload);
|
|
}
|
|
} else {
|
|
const invalid_options = options_for_objects.filter(function(opt) {
|
|
return typeof options2[opt] !== "undefined";
|
|
});
|
|
if (invalid_options.length > 0) {
|
|
return failure(new Error("invalid " + invalid_options.join(",") + " option for " + typeof payload + " payload"));
|
|
}
|
|
}
|
|
if (typeof payload.exp !== "undefined" && typeof options2.expiresIn !== "undefined") {
|
|
return failure(new Error('Bad "options.expiresIn" option the payload already has an "exp" property.'));
|
|
}
|
|
if (typeof payload.nbf !== "undefined" && typeof options2.notBefore !== "undefined") {
|
|
return failure(new Error('Bad "options.notBefore" option the payload already has an "nbf" property.'));
|
|
}
|
|
try {
|
|
validateOptions(options2);
|
|
} catch (error) {
|
|
return failure(error);
|
|
}
|
|
if (!options2.allowInvalidAsymmetricKeyTypes) {
|
|
try {
|
|
validateAsymmetricKey(header.alg, secretOrPrivateKey);
|
|
} catch (error) {
|
|
return failure(error);
|
|
}
|
|
}
|
|
const timestamp = payload.iat || Math.floor(Date.now() / 1000);
|
|
if (options2.noTimestamp) {
|
|
delete payload.iat;
|
|
} else if (isObjectPayload) {
|
|
payload.iat = timestamp;
|
|
}
|
|
if (typeof options2.notBefore !== "undefined") {
|
|
try {
|
|
payload.nbf = timespan(options2.notBefore, timestamp);
|
|
} catch (err) {
|
|
return failure(err);
|
|
}
|
|
if (typeof payload.nbf === "undefined") {
|
|
return failure(new Error('"notBefore" should be a number of seconds or string representing a timespan eg: "1d", "20h", 60'));
|
|
}
|
|
}
|
|
if (typeof options2.expiresIn !== "undefined" && typeof payload === "object") {
|
|
try {
|
|
payload.exp = timespan(options2.expiresIn, timestamp);
|
|
} catch (err) {
|
|
return failure(err);
|
|
}
|
|
if (typeof payload.exp === "undefined") {
|
|
return failure(new Error('"expiresIn" should be a number of seconds or string representing a timespan eg: "1d", "20h", 60'));
|
|
}
|
|
}
|
|
Object.keys(options_to_payload).forEach(function(key) {
|
|
const claim = options_to_payload[key];
|
|
if (typeof options2[key] !== "undefined") {
|
|
if (typeof payload[claim] !== "undefined") {
|
|
return failure(new Error('Bad "options.' + key + '" option. The payload already has an "' + claim + '" property.'));
|
|
}
|
|
payload[claim] = options2[key];
|
|
}
|
|
});
|
|
const encoding = options2.encoding || "utf8";
|
|
if (typeof callback === "function") {
|
|
callback = callback && once(callback);
|
|
jws.createSign({
|
|
header,
|
|
privateKey: secretOrPrivateKey,
|
|
payload,
|
|
encoding
|
|
}).once("error", callback).once("done", function(signature) {
|
|
if (!options2.allowInsecureKeySizes && /^(?:RS|PS)/.test(header.alg) && signature.length < 256) {
|
|
return callback(new Error(`secretOrPrivateKey has a minimum key size of 2048 bits for ${header.alg}`));
|
|
}
|
|
callback(null, signature);
|
|
});
|
|
} else {
|
|
let signature = jws.sign({ header, payload, secret: secretOrPrivateKey, encoding });
|
|
if (!options2.allowInsecureKeySizes && /^(?:RS|PS)/.test(header.alg) && signature.length < 256) {
|
|
throw new Error(`secretOrPrivateKey has a minimum key size of 2048 bits for ${header.alg}`);
|
|
}
|
|
return signature;
|
|
}
|
|
};
|
|
});
|
|
|
|
// ../eve/node_modules/jsonwebtoken/index.js
|
|
var require_jsonwebtoken = __commonJS((exports, module) => {
|
|
module.exports = {
|
|
decode: require_decode(),
|
|
verify: require_verify(),
|
|
sign: require_sign(),
|
|
JsonWebTokenError: require_JsonWebTokenError(),
|
|
NotBeforeError: require_NotBeforeError(),
|
|
TokenExpiredError: require_TokenExpiredError()
|
|
};
|
|
});
|
|
|
|
// ../eve/node_modules/bn.js/lib/bn.js
|
|
var require_bn = __commonJS((exports, module) => {
|
|
(function(module2, exports2) {
|
|
function assert(val, msg) {
|
|
if (!val)
|
|
throw new Error(msg || "Assertion failed");
|
|
}
|
|
function inherits(ctor, superCtor) {
|
|
ctor.super_ = superCtor;
|
|
var TempCtor = function() {};
|
|
TempCtor.prototype = superCtor.prototype;
|
|
ctor.prototype = new TempCtor;
|
|
ctor.prototype.constructor = ctor;
|
|
}
|
|
function BN(number, 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 module2 === "object") {
|
|
module2.exports = BN;
|
|
} else {
|
|
exports2.BN = BN;
|
|
}
|
|
BN.BN = BN;
|
|
BN.wordSize = 26;
|
|
var Buffer2;
|
|
try {
|
|
if (typeof window !== "undefined" && typeof window.Buffer !== "undefined") {
|
|
Buffer2 = window.Buffer;
|
|
} else {
|
|
Buffer2 = __require("buffer").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, index2) {
|
|
var c = string.charCodeAt(index2);
|
|
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, index2) {
|
|
var r = parseHex4Bits(string, index2);
|
|
if (index2 - 1 >= lowerBound) {
|
|
r |= parseHex4Bits(string, index2 - 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 {
|
|
var parseLength = number.length - start;
|
|
for (i = parseLength % 2 === 0 ? start + 1 : start;i < number.length; i += 2) {
|
|
w = parseHexByte(number, start, i) << off;
|
|
this.words[j] |= w & 67108863;
|
|
if (off >= 18) {
|
|
off -= 18;
|
|
j += 1;
|
|
this.words[j] |= w >>> 26;
|
|
} else {
|
|
off += 8;
|
|
}
|
|
}
|
|
}
|
|
this.strip();
|
|
};
|
|
function parseBase(str, start, end, 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,
|
|
64000000,
|
|
4084101,
|
|
5153632,
|
|
6436343,
|
|
7962624,
|
|
9765625,
|
|
11881376,
|
|
14348907,
|
|
17210368,
|
|
20511149,
|
|
24300000,
|
|
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 Buffer2 !== "undefined");
|
|
return this.toArrayLike(Buffer2, endian, length);
|
|
};
|
|
BN.prototype.toArray = function toArray(endian, length) {
|
|
return this.toArrayLike(Array, endian, length);
|
|
};
|
|
BN.prototype.toArrayLike = function toArrayLike(ArrayType, endian, length) {
|
|
var 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(self2, num, out) {
|
|
out.negative = num.negative ^ self2.negative;
|
|
var len = self2.length + num.length | 0;
|
|
out.length = len;
|
|
len = len - 1 | 0;
|
|
var a = self2.words[0] | 0;
|
|
var b = num.words[0] | 0;
|
|
var 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 - self2.length + 1);j <= maxJ; j++) {
|
|
var i = k - j | 0;
|
|
a = self2.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(self2, num, out) {
|
|
var a = self2.words;
|
|
var b = num.words;
|
|
var o = out.words;
|
|
var c = 0;
|
|
var lo;
|
|
var mid;
|
|
var hi;
|
|
var a0 = a[0] | 0;
|
|
var al0 = a0 & 8191;
|
|
var ah0 = a0 >>> 13;
|
|
var a1 = a[1] | 0;
|
|
var al1 = a1 & 8191;
|
|
var ah1 = a1 >>> 13;
|
|
var a2 = a[2] | 0;
|
|
var al2 = a2 & 8191;
|
|
var ah2 = a2 >>> 13;
|
|
var a3 = a[3] | 0;
|
|
var al3 = a3 & 8191;
|
|
var ah3 = a3 >>> 13;
|
|
var a4 = a[4] | 0;
|
|
var al4 = a4 & 8191;
|
|
var ah4 = a4 >>> 13;
|
|
var a5 = a[5] | 0;
|
|
var al5 = a5 & 8191;
|
|
var ah5 = a5 >>> 13;
|
|
var a6 = a[6] | 0;
|
|
var al6 = a6 & 8191;
|
|
var ah6 = a6 >>> 13;
|
|
var a7 = a[7] | 0;
|
|
var al7 = a7 & 8191;
|
|
var ah7 = a7 >>> 13;
|
|
var a8 = a[8] | 0;
|
|
var al8 = a8 & 8191;
|
|
var ah8 = a8 >>> 13;
|
|
var a9 = a[9] | 0;
|
|
var al9 = a9 & 8191;
|
|
var ah9 = a9 >>> 13;
|
|
var b0 = b[0] | 0;
|
|
var bl0 = b0 & 8191;
|
|
var bh0 = b0 >>> 13;
|
|
var b1 = b[1] | 0;
|
|
var bl1 = b1 & 8191;
|
|
var bh1 = b1 >>> 13;
|
|
var b2 = b[2] | 0;
|
|
var bl2 = b2 & 8191;
|
|
var bh2 = b2 >>> 13;
|
|
var b3 = b[3] | 0;
|
|
var bl3 = b3 & 8191;
|
|
var bh3 = b3 >>> 13;
|
|
var b4 = b[4] | 0;
|
|
var bl4 = b4 & 8191;
|
|
var bh4 = b4 >>> 13;
|
|
var b5 = b[5] | 0;
|
|
var bl5 = b5 & 8191;
|
|
var bh5 = b5 >>> 13;
|
|
var b6 = b[6] | 0;
|
|
var bl6 = b6 & 8191;
|
|
var bh6 = b6 >>> 13;
|
|
var b7 = b[7] | 0;
|
|
var bl7 = b7 & 8191;
|
|
var bh7 = b7 >>> 13;
|
|
var b8 = b[8] | 0;
|
|
var bl8 = b8 & 8191;
|
|
var bh8 = b8 >>> 13;
|
|
var b9 = b[9] | 0;
|
|
var bl9 = b9 & 8191;
|
|
var bh9 = b9 >>> 13;
|
|
out.negative = self2.negative ^ num.negative;
|
|
out.length = 19;
|
|
lo = Math.imul(al0, bl0);
|
|
mid = Math.imul(al0, bh0);
|
|
mid = mid + Math.imul(ah0, bl0) | 0;
|
|
hi = Math.imul(ah0, bh0);
|
|
var w0 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
|
|
c = (hi + (mid >>> 13) | 0) + (w0 >>> 26) | 0;
|
|
w0 &= 67108863;
|
|
lo = Math.imul(al1, bl0);
|
|
mid = Math.imul(al1, bh0);
|
|
mid = mid + Math.imul(ah1, bl0) | 0;
|
|
hi = Math.imul(ah1, bh0);
|
|
lo = lo + Math.imul(al0, bl1) | 0;
|
|
mid = mid + Math.imul(al0, bh1) | 0;
|
|
mid = mid + Math.imul(ah0, bl1) | 0;
|
|
hi = hi + Math.imul(ah0, bh1) | 0;
|
|
var w1 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
|
|
c = (hi + (mid >>> 13) | 0) + (w1 >>> 26) | 0;
|
|
w1 &= 67108863;
|
|
lo = Math.imul(al2, bl0);
|
|
mid = Math.imul(al2, bh0);
|
|
mid = mid + Math.imul(ah2, bl0) | 0;
|
|
hi = Math.imul(ah2, bh0);
|
|
lo = lo + Math.imul(al1, bl1) | 0;
|
|
mid = mid + Math.imul(al1, bh1) | 0;
|
|
mid = mid + Math.imul(ah1, bl1) | 0;
|
|
hi = hi + Math.imul(ah1, bh1) | 0;
|
|
lo = lo + Math.imul(al0, bl2) | 0;
|
|
mid = mid + Math.imul(al0, bh2) | 0;
|
|
mid = mid + Math.imul(ah0, bl2) | 0;
|
|
hi = hi + Math.imul(ah0, bh2) | 0;
|
|
var w2 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
|
|
c = (hi + (mid >>> 13) | 0) + (w2 >>> 26) | 0;
|
|
w2 &= 67108863;
|
|
lo = Math.imul(al3, bl0);
|
|
mid = Math.imul(al3, bh0);
|
|
mid = mid + Math.imul(ah3, bl0) | 0;
|
|
hi = Math.imul(ah3, bh0);
|
|
lo = lo + Math.imul(al2, bl1) | 0;
|
|
mid = mid + Math.imul(al2, bh1) | 0;
|
|
mid = mid + Math.imul(ah2, bl1) | 0;
|
|
hi = hi + Math.imul(ah2, bh1) | 0;
|
|
lo = lo + Math.imul(al1, bl2) | 0;
|
|
mid = mid + Math.imul(al1, bh2) | 0;
|
|
mid = mid + Math.imul(ah1, bl2) | 0;
|
|
hi = hi + Math.imul(ah1, bh2) | 0;
|
|
lo = lo + Math.imul(al0, bl3) | 0;
|
|
mid = mid + Math.imul(al0, bh3) | 0;
|
|
mid = mid + Math.imul(ah0, bl3) | 0;
|
|
hi = hi + Math.imul(ah0, bh3) | 0;
|
|
var w3 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
|
|
c = (hi + (mid >>> 13) | 0) + (w3 >>> 26) | 0;
|
|
w3 &= 67108863;
|
|
lo = Math.imul(al4, bl0);
|
|
mid = Math.imul(al4, bh0);
|
|
mid = mid + Math.imul(ah4, bl0) | 0;
|
|
hi = Math.imul(ah4, bh0);
|
|
lo = lo + Math.imul(al3, bl1) | 0;
|
|
mid = mid + Math.imul(al3, bh1) | 0;
|
|
mid = mid + Math.imul(ah3, bl1) | 0;
|
|
hi = hi + Math.imul(ah3, bh1) | 0;
|
|
lo = lo + Math.imul(al2, bl2) | 0;
|
|
mid = mid + Math.imul(al2, bh2) | 0;
|
|
mid = mid + Math.imul(ah2, bl2) | 0;
|
|
hi = hi + Math.imul(ah2, bh2) | 0;
|
|
lo = lo + Math.imul(al1, bl3) | 0;
|
|
mid = mid + Math.imul(al1, bh3) | 0;
|
|
mid = mid + Math.imul(ah1, bl3) | 0;
|
|
hi = hi + Math.imul(ah1, bh3) | 0;
|
|
lo = lo + Math.imul(al0, bl4) | 0;
|
|
mid = mid + Math.imul(al0, bh4) | 0;
|
|
mid = mid + Math.imul(ah0, bl4) | 0;
|
|
hi = hi + Math.imul(ah0, bh4) | 0;
|
|
var w4 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
|
|
c = (hi + (mid >>> 13) | 0) + (w4 >>> 26) | 0;
|
|
w4 &= 67108863;
|
|
lo = Math.imul(al5, bl0);
|
|
mid = Math.imul(al5, bh0);
|
|
mid = mid + Math.imul(ah5, bl0) | 0;
|
|
hi = Math.imul(ah5, bh0);
|
|
lo = lo + Math.imul(al4, bl1) | 0;
|
|
mid = mid + Math.imul(al4, bh1) | 0;
|
|
mid = mid + Math.imul(ah4, bl1) | 0;
|
|
hi = hi + Math.imul(ah4, bh1) | 0;
|
|
lo = lo + Math.imul(al3, bl2) | 0;
|
|
mid = mid + Math.imul(al3, bh2) | 0;
|
|
mid = mid + Math.imul(ah3, bl2) | 0;
|
|
hi = hi + Math.imul(ah3, bh2) | 0;
|
|
lo = lo + Math.imul(al2, bl3) | 0;
|
|
mid = mid + Math.imul(al2, bh3) | 0;
|
|
mid = mid + Math.imul(ah2, bl3) | 0;
|
|
hi = hi + Math.imul(ah2, bh3) | 0;
|
|
lo = lo + Math.imul(al1, bl4) | 0;
|
|
mid = mid + Math.imul(al1, bh4) | 0;
|
|
mid = mid + Math.imul(ah1, bl4) | 0;
|
|
hi = hi + Math.imul(ah1, bh4) | 0;
|
|
lo = lo + Math.imul(al0, bl5) | 0;
|
|
mid = mid + Math.imul(al0, bh5) | 0;
|
|
mid = mid + Math.imul(ah0, bl5) | 0;
|
|
hi = hi + Math.imul(ah0, bh5) | 0;
|
|
var w5 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
|
|
c = (hi + (mid >>> 13) | 0) + (w5 >>> 26) | 0;
|
|
w5 &= 67108863;
|
|
lo = Math.imul(al6, bl0);
|
|
mid = Math.imul(al6, bh0);
|
|
mid = mid + Math.imul(ah6, bl0) | 0;
|
|
hi = Math.imul(ah6, bh0);
|
|
lo = lo + Math.imul(al5, bl1) | 0;
|
|
mid = mid + Math.imul(al5, bh1) | 0;
|
|
mid = mid + Math.imul(ah5, bl1) | 0;
|
|
hi = hi + Math.imul(ah5, bh1) | 0;
|
|
lo = lo + Math.imul(al4, bl2) | 0;
|
|
mid = mid + Math.imul(al4, bh2) | 0;
|
|
mid = mid + Math.imul(ah4, bl2) | 0;
|
|
hi = hi + Math.imul(ah4, bh2) | 0;
|
|
lo = lo + Math.imul(al3, bl3) | 0;
|
|
mid = mid + Math.imul(al3, bh3) | 0;
|
|
mid = mid + Math.imul(ah3, bl3) | 0;
|
|
hi = hi + Math.imul(ah3, bh3) | 0;
|
|
lo = lo + Math.imul(al2, bl4) | 0;
|
|
mid = mid + Math.imul(al2, bh4) | 0;
|
|
mid = mid + Math.imul(ah2, bl4) | 0;
|
|
hi = hi + Math.imul(ah2, bh4) | 0;
|
|
lo = lo + Math.imul(al1, bl5) | 0;
|
|
mid = mid + Math.imul(al1, bh5) | 0;
|
|
mid = mid + Math.imul(ah1, bl5) | 0;
|
|
hi = hi + Math.imul(ah1, bh5) | 0;
|
|
lo = lo + Math.imul(al0, bl6) | 0;
|
|
mid = mid + Math.imul(al0, bh6) | 0;
|
|
mid = mid + Math.imul(ah0, bl6) | 0;
|
|
hi = hi + Math.imul(ah0, bh6) | 0;
|
|
var w6 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
|
|
c = (hi + (mid >>> 13) | 0) + (w6 >>> 26) | 0;
|
|
w6 &= 67108863;
|
|
lo = Math.imul(al7, bl0);
|
|
mid = Math.imul(al7, bh0);
|
|
mid = mid + Math.imul(ah7, bl0) | 0;
|
|
hi = Math.imul(ah7, bh0);
|
|
lo = lo + Math.imul(al6, bl1) | 0;
|
|
mid = mid + Math.imul(al6, bh1) | 0;
|
|
mid = mid + Math.imul(ah6, bl1) | 0;
|
|
hi = hi + Math.imul(ah6, bh1) | 0;
|
|
lo = lo + Math.imul(al5, bl2) | 0;
|
|
mid = mid + Math.imul(al5, bh2) | 0;
|
|
mid = mid + Math.imul(ah5, bl2) | 0;
|
|
hi = hi + Math.imul(ah5, bh2) | 0;
|
|
lo = lo + Math.imul(al4, bl3) | 0;
|
|
mid = mid + Math.imul(al4, bh3) | 0;
|
|
mid = mid + Math.imul(ah4, bl3) | 0;
|
|
hi = hi + Math.imul(ah4, bh3) | 0;
|
|
lo = lo + Math.imul(al3, bl4) | 0;
|
|
mid = mid + Math.imul(al3, bh4) | 0;
|
|
mid = mid + Math.imul(ah3, bl4) | 0;
|
|
hi = hi + Math.imul(ah3, bh4) | 0;
|
|
lo = lo + Math.imul(al2, bl5) | 0;
|
|
mid = mid + Math.imul(al2, bh5) | 0;
|
|
mid = mid + Math.imul(ah2, bl5) | 0;
|
|
hi = hi + Math.imul(ah2, bh5) | 0;
|
|
lo = lo + Math.imul(al1, bl6) | 0;
|
|
mid = mid + Math.imul(al1, bh6) | 0;
|
|
mid = mid + Math.imul(ah1, bl6) | 0;
|
|
hi = hi + Math.imul(ah1, bh6) | 0;
|
|
lo = lo + Math.imul(al0, bl7) | 0;
|
|
mid = mid + Math.imul(al0, bh7) | 0;
|
|
mid = mid + Math.imul(ah0, bl7) | 0;
|
|
hi = hi + Math.imul(ah0, bh7) | 0;
|
|
var w7 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
|
|
c = (hi + (mid >>> 13) | 0) + (w7 >>> 26) | 0;
|
|
w7 &= 67108863;
|
|
lo = Math.imul(al8, bl0);
|
|
mid = Math.imul(al8, bh0);
|
|
mid = mid + Math.imul(ah8, bl0) | 0;
|
|
hi = Math.imul(ah8, bh0);
|
|
lo = lo + Math.imul(al7, bl1) | 0;
|
|
mid = mid + Math.imul(al7, bh1) | 0;
|
|
mid = mid + Math.imul(ah7, bl1) | 0;
|
|
hi = hi + Math.imul(ah7, bh1) | 0;
|
|
lo = lo + Math.imul(al6, bl2) | 0;
|
|
mid = mid + Math.imul(al6, bh2) | 0;
|
|
mid = mid + Math.imul(ah6, bl2) | 0;
|
|
hi = hi + Math.imul(ah6, bh2) | 0;
|
|
lo = lo + Math.imul(al5, bl3) | 0;
|
|
mid = mid + Math.imul(al5, bh3) | 0;
|
|
mid = mid + Math.imul(ah5, bl3) | 0;
|
|
hi = hi + Math.imul(ah5, bh3) | 0;
|
|
lo = lo + Math.imul(al4, bl4) | 0;
|
|
mid = mid + Math.imul(al4, bh4) | 0;
|
|
mid = mid + Math.imul(ah4, bl4) | 0;
|
|
hi = hi + Math.imul(ah4, bh4) | 0;
|
|
lo = lo + Math.imul(al3, bl5) | 0;
|
|
mid = mid + Math.imul(al3, bh5) | 0;
|
|
mid = mid + Math.imul(ah3, bl5) | 0;
|
|
hi = hi + Math.imul(ah3, bh5) | 0;
|
|
lo = lo + Math.imul(al2, bl6) | 0;
|
|
mid = mid + Math.imul(al2, bh6) | 0;
|
|
mid = mid + Math.imul(ah2, bl6) | 0;
|
|
hi = hi + Math.imul(ah2, bh6) | 0;
|
|
lo = lo + Math.imul(al1, bl7) | 0;
|
|
mid = mid + Math.imul(al1, bh7) | 0;
|
|
mid = mid + Math.imul(ah1, bl7) | 0;
|
|
hi = hi + Math.imul(ah1, bh7) | 0;
|
|
lo = lo + Math.imul(al0, bl8) | 0;
|
|
mid = mid + Math.imul(al0, bh8) | 0;
|
|
mid = mid + Math.imul(ah0, bl8) | 0;
|
|
hi = hi + Math.imul(ah0, bh8) | 0;
|
|
var w8 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
|
|
c = (hi + (mid >>> 13) | 0) + (w8 >>> 26) | 0;
|
|
w8 &= 67108863;
|
|
lo = Math.imul(al9, bl0);
|
|
mid = Math.imul(al9, bh0);
|
|
mid = mid + Math.imul(ah9, bl0) | 0;
|
|
hi = Math.imul(ah9, bh0);
|
|
lo = lo + Math.imul(al8, bl1) | 0;
|
|
mid = mid + Math.imul(al8, bh1) | 0;
|
|
mid = mid + Math.imul(ah8, bl1) | 0;
|
|
hi = hi + Math.imul(ah8, bh1) | 0;
|
|
lo = lo + Math.imul(al7, bl2) | 0;
|
|
mid = mid + Math.imul(al7, bh2) | 0;
|
|
mid = mid + Math.imul(ah7, bl2) | 0;
|
|
hi = hi + Math.imul(ah7, bh2) | 0;
|
|
lo = lo + Math.imul(al6, bl3) | 0;
|
|
mid = mid + Math.imul(al6, bh3) | 0;
|
|
mid = mid + Math.imul(ah6, bl3) | 0;
|
|
hi = hi + Math.imul(ah6, bh3) | 0;
|
|
lo = lo + Math.imul(al5, bl4) | 0;
|
|
mid = mid + Math.imul(al5, bh4) | 0;
|
|
mid = mid + Math.imul(ah5, bl4) | 0;
|
|
hi = hi + Math.imul(ah5, bh4) | 0;
|
|
lo = lo + Math.imul(al4, bl5) | 0;
|
|
mid = mid + Math.imul(al4, bh5) | 0;
|
|
mid = mid + Math.imul(ah4, bl5) | 0;
|
|
hi = hi + Math.imul(ah4, bh5) | 0;
|
|
lo = lo + Math.imul(al3, bl6) | 0;
|
|
mid = mid + Math.imul(al3, bh6) | 0;
|
|
mid = mid + Math.imul(ah3, bl6) | 0;
|
|
hi = hi + Math.imul(ah3, bh6) | 0;
|
|
lo = lo + Math.imul(al2, bl7) | 0;
|
|
mid = mid + Math.imul(al2, bh7) | 0;
|
|
mid = mid + Math.imul(ah2, bl7) | 0;
|
|
hi = hi + Math.imul(ah2, bh7) | 0;
|
|
lo = lo + Math.imul(al1, bl8) | 0;
|
|
mid = mid + Math.imul(al1, bh8) | 0;
|
|
mid = mid + Math.imul(ah1, bl8) | 0;
|
|
hi = hi + Math.imul(ah1, bh8) | 0;
|
|
lo = lo + Math.imul(al0, bl9) | 0;
|
|
mid = mid + Math.imul(al0, bh9) | 0;
|
|
mid = mid + Math.imul(ah0, bl9) | 0;
|
|
hi = hi + Math.imul(ah0, bh9) | 0;
|
|
var w9 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
|
|
c = (hi + (mid >>> 13) | 0) + (w9 >>> 26) | 0;
|
|
w9 &= 67108863;
|
|
lo = Math.imul(al9, bl1);
|
|
mid = Math.imul(al9, bh1);
|
|
mid = mid + Math.imul(ah9, bl1) | 0;
|
|
hi = Math.imul(ah9, bh1);
|
|
lo = lo + Math.imul(al8, bl2) | 0;
|
|
mid = mid + Math.imul(al8, bh2) | 0;
|
|
mid = mid + Math.imul(ah8, bl2) | 0;
|
|
hi = hi + Math.imul(ah8, bh2) | 0;
|
|
lo = lo + Math.imul(al7, bl3) | 0;
|
|
mid = mid + Math.imul(al7, bh3) | 0;
|
|
mid = mid + Math.imul(ah7, bl3) | 0;
|
|
hi = hi + Math.imul(ah7, bh3) | 0;
|
|
lo = lo + Math.imul(al6, bl4) | 0;
|
|
mid = mid + Math.imul(al6, bh4) | 0;
|
|
mid = mid + Math.imul(ah6, bl4) | 0;
|
|
hi = hi + Math.imul(ah6, bh4) | 0;
|
|
lo = lo + Math.imul(al5, bl5) | 0;
|
|
mid = mid + Math.imul(al5, bh5) | 0;
|
|
mid = mid + Math.imul(ah5, bl5) | 0;
|
|
hi = hi + Math.imul(ah5, bh5) | 0;
|
|
lo = lo + Math.imul(al4, bl6) | 0;
|
|
mid = mid + Math.imul(al4, bh6) | 0;
|
|
mid = mid + Math.imul(ah4, bl6) | 0;
|
|
hi = hi + Math.imul(ah4, bh6) | 0;
|
|
lo = lo + Math.imul(al3, bl7) | 0;
|
|
mid = mid + Math.imul(al3, bh7) | 0;
|
|
mid = mid + Math.imul(ah3, bl7) | 0;
|
|
hi = hi + Math.imul(ah3, bh7) | 0;
|
|
lo = lo + Math.imul(al2, bl8) | 0;
|
|
mid = mid + Math.imul(al2, bh8) | 0;
|
|
mid = mid + Math.imul(ah2, bl8) | 0;
|
|
hi = hi + Math.imul(ah2, bh8) | 0;
|
|
lo = lo + Math.imul(al1, bl9) | 0;
|
|
mid = mid + Math.imul(al1, bh9) | 0;
|
|
mid = mid + Math.imul(ah1, bl9) | 0;
|
|
hi = hi + Math.imul(ah1, bh9) | 0;
|
|
var w10 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
|
|
c = (hi + (mid >>> 13) | 0) + (w10 >>> 26) | 0;
|
|
w10 &= 67108863;
|
|
lo = Math.imul(al9, bl2);
|
|
mid = Math.imul(al9, bh2);
|
|
mid = mid + Math.imul(ah9, bl2) | 0;
|
|
hi = Math.imul(ah9, bh2);
|
|
lo = lo + Math.imul(al8, bl3) | 0;
|
|
mid = mid + Math.imul(al8, bh3) | 0;
|
|
mid = mid + Math.imul(ah8, bl3) | 0;
|
|
hi = hi + Math.imul(ah8, bh3) | 0;
|
|
lo = lo + Math.imul(al7, bl4) | 0;
|
|
mid = mid + Math.imul(al7, bh4) | 0;
|
|
mid = mid + Math.imul(ah7, bl4) | 0;
|
|
hi = hi + Math.imul(ah7, bh4) | 0;
|
|
lo = lo + Math.imul(al6, bl5) | 0;
|
|
mid = mid + Math.imul(al6, bh5) | 0;
|
|
mid = mid + Math.imul(ah6, bl5) | 0;
|
|
hi = hi + Math.imul(ah6, bh5) | 0;
|
|
lo = lo + Math.imul(al5, bl6) | 0;
|
|
mid = mid + Math.imul(al5, bh6) | 0;
|
|
mid = mid + Math.imul(ah5, bl6) | 0;
|
|
hi = hi + Math.imul(ah5, bh6) | 0;
|
|
lo = lo + Math.imul(al4, bl7) | 0;
|
|
mid = mid + Math.imul(al4, bh7) | 0;
|
|
mid = mid + Math.imul(ah4, bl7) | 0;
|
|
hi = hi + Math.imul(ah4, bh7) | 0;
|
|
lo = lo + Math.imul(al3, bl8) | 0;
|
|
mid = mid + Math.imul(al3, bh8) | 0;
|
|
mid = mid + Math.imul(ah3, bl8) | 0;
|
|
hi = hi + Math.imul(ah3, bh8) | 0;
|
|
lo = lo + Math.imul(al2, bl9) | 0;
|
|
mid = mid + Math.imul(al2, bh9) | 0;
|
|
mid = mid + Math.imul(ah2, bl9) | 0;
|
|
hi = hi + Math.imul(ah2, bh9) | 0;
|
|
var w11 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
|
|
c = (hi + (mid >>> 13) | 0) + (w11 >>> 26) | 0;
|
|
w11 &= 67108863;
|
|
lo = Math.imul(al9, bl3);
|
|
mid = Math.imul(al9, bh3);
|
|
mid = mid + Math.imul(ah9, bl3) | 0;
|
|
hi = Math.imul(ah9, bh3);
|
|
lo = lo + Math.imul(al8, bl4) | 0;
|
|
mid = mid + Math.imul(al8, bh4) | 0;
|
|
mid = mid + Math.imul(ah8, bl4) | 0;
|
|
hi = hi + Math.imul(ah8, bh4) | 0;
|
|
lo = lo + Math.imul(al7, bl5) | 0;
|
|
mid = mid + Math.imul(al7, bh5) | 0;
|
|
mid = mid + Math.imul(ah7, bl5) | 0;
|
|
hi = hi + Math.imul(ah7, bh5) | 0;
|
|
lo = lo + Math.imul(al6, bl6) | 0;
|
|
mid = mid + Math.imul(al6, bh6) | 0;
|
|
mid = mid + Math.imul(ah6, bl6) | 0;
|
|
hi = hi + Math.imul(ah6, bh6) | 0;
|
|
lo = lo + Math.imul(al5, bl7) | 0;
|
|
mid = mid + Math.imul(al5, bh7) | 0;
|
|
mid = mid + Math.imul(ah5, bl7) | 0;
|
|
hi = hi + Math.imul(ah5, bh7) | 0;
|
|
lo = lo + Math.imul(al4, bl8) | 0;
|
|
mid = mid + Math.imul(al4, bh8) | 0;
|
|
mid = mid + Math.imul(ah4, bl8) | 0;
|
|
hi = hi + Math.imul(ah4, bh8) | 0;
|
|
lo = lo + Math.imul(al3, bl9) | 0;
|
|
mid = mid + Math.imul(al3, bh9) | 0;
|
|
mid = mid + Math.imul(ah3, bl9) | 0;
|
|
hi = hi + Math.imul(ah3, bh9) | 0;
|
|
var w12 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
|
|
c = (hi + (mid >>> 13) | 0) + (w12 >>> 26) | 0;
|
|
w12 &= 67108863;
|
|
lo = Math.imul(al9, bl4);
|
|
mid = Math.imul(al9, bh4);
|
|
mid = mid + Math.imul(ah9, bl4) | 0;
|
|
hi = Math.imul(ah9, bh4);
|
|
lo = lo + Math.imul(al8, bl5) | 0;
|
|
mid = mid + Math.imul(al8, bh5) | 0;
|
|
mid = mid + Math.imul(ah8, bl5) | 0;
|
|
hi = hi + Math.imul(ah8, bh5) | 0;
|
|
lo = lo + Math.imul(al7, bl6) | 0;
|
|
mid = mid + Math.imul(al7, bh6) | 0;
|
|
mid = mid + Math.imul(ah7, bl6) | 0;
|
|
hi = hi + Math.imul(ah7, bh6) | 0;
|
|
lo = lo + Math.imul(al6, bl7) | 0;
|
|
mid = mid + Math.imul(al6, bh7) | 0;
|
|
mid = mid + Math.imul(ah6, bl7) | 0;
|
|
hi = hi + Math.imul(ah6, bh7) | 0;
|
|
lo = lo + Math.imul(al5, bl8) | 0;
|
|
mid = mid + Math.imul(al5, bh8) | 0;
|
|
mid = mid + Math.imul(ah5, bl8) | 0;
|
|
hi = hi + Math.imul(ah5, bh8) | 0;
|
|
lo = lo + Math.imul(al4, bl9) | 0;
|
|
mid = mid + Math.imul(al4, bh9) | 0;
|
|
mid = mid + Math.imul(ah4, bl9) | 0;
|
|
hi = hi + Math.imul(ah4, bh9) | 0;
|
|
var w13 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
|
|
c = (hi + (mid >>> 13) | 0) + (w13 >>> 26) | 0;
|
|
w13 &= 67108863;
|
|
lo = Math.imul(al9, bl5);
|
|
mid = Math.imul(al9, bh5);
|
|
mid = mid + Math.imul(ah9, bl5) | 0;
|
|
hi = Math.imul(ah9, bh5);
|
|
lo = lo + Math.imul(al8, bl6) | 0;
|
|
mid = mid + Math.imul(al8, bh6) | 0;
|
|
mid = mid + Math.imul(ah8, bl6) | 0;
|
|
hi = hi + Math.imul(ah8, bh6) | 0;
|
|
lo = lo + Math.imul(al7, bl7) | 0;
|
|
mid = mid + Math.imul(al7, bh7) | 0;
|
|
mid = mid + Math.imul(ah7, bl7) | 0;
|
|
hi = hi + Math.imul(ah7, bh7) | 0;
|
|
lo = lo + Math.imul(al6, bl8) | 0;
|
|
mid = mid + Math.imul(al6, bh8) | 0;
|
|
mid = mid + Math.imul(ah6, bl8) | 0;
|
|
hi = hi + Math.imul(ah6, bh8) | 0;
|
|
lo = lo + Math.imul(al5, bl9) | 0;
|
|
mid = mid + Math.imul(al5, bh9) | 0;
|
|
mid = mid + Math.imul(ah5, bl9) | 0;
|
|
hi = hi + Math.imul(ah5, bh9) | 0;
|
|
var w14 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
|
|
c = (hi + (mid >>> 13) | 0) + (w14 >>> 26) | 0;
|
|
w14 &= 67108863;
|
|
lo = Math.imul(al9, bl6);
|
|
mid = Math.imul(al9, bh6);
|
|
mid = mid + Math.imul(ah9, bl6) | 0;
|
|
hi = Math.imul(ah9, bh6);
|
|
lo = lo + Math.imul(al8, bl7) | 0;
|
|
mid = mid + Math.imul(al8, bh7) | 0;
|
|
mid = mid + Math.imul(ah8, bl7) | 0;
|
|
hi = hi + Math.imul(ah8, bh7) | 0;
|
|
lo = lo + Math.imul(al7, bl8) | 0;
|
|
mid = mid + Math.imul(al7, bh8) | 0;
|
|
mid = mid + Math.imul(ah7, bl8) | 0;
|
|
hi = hi + Math.imul(ah7, bh8) | 0;
|
|
lo = lo + Math.imul(al6, bl9) | 0;
|
|
mid = mid + Math.imul(al6, bh9) | 0;
|
|
mid = mid + Math.imul(ah6, bl9) | 0;
|
|
hi = hi + Math.imul(ah6, bh9) | 0;
|
|
var w15 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
|
|
c = (hi + (mid >>> 13) | 0) + (w15 >>> 26) | 0;
|
|
w15 &= 67108863;
|
|
lo = Math.imul(al9, bl7);
|
|
mid = Math.imul(al9, bh7);
|
|
mid = mid + Math.imul(ah9, bl7) | 0;
|
|
hi = Math.imul(ah9, bh7);
|
|
lo = lo + Math.imul(al8, bl8) | 0;
|
|
mid = mid + Math.imul(al8, bh8) | 0;
|
|
mid = mid + Math.imul(ah8, bl8) | 0;
|
|
hi = hi + Math.imul(ah8, bh8) | 0;
|
|
lo = lo + Math.imul(al7, bl9) | 0;
|
|
mid = mid + Math.imul(al7, bh9) | 0;
|
|
mid = mid + Math.imul(ah7, bl9) | 0;
|
|
hi = hi + Math.imul(ah7, bh9) | 0;
|
|
var w16 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
|
|
c = (hi + (mid >>> 13) | 0) + (w16 >>> 26) | 0;
|
|
w16 &= 67108863;
|
|
lo = Math.imul(al9, bl8);
|
|
mid = Math.imul(al9, bh8);
|
|
mid = mid + Math.imul(ah9, bl8) | 0;
|
|
hi = Math.imul(ah9, bh8);
|
|
lo = lo + Math.imul(al8, bl9) | 0;
|
|
mid = mid + Math.imul(al8, bh9) | 0;
|
|
mid = mid + Math.imul(ah8, bl9) | 0;
|
|
hi = hi + Math.imul(ah8, bh9) | 0;
|
|
var w17 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
|
|
c = (hi + (mid >>> 13) | 0) + (w17 >>> 26) | 0;
|
|
w17 &= 67108863;
|
|
lo = Math.imul(al9, bl9);
|
|
mid = Math.imul(al9, bh9);
|
|
mid = mid + Math.imul(ah9, bl9) | 0;
|
|
hi = Math.imul(ah9, bh9);
|
|
var w18 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
|
|
c = (hi + (mid >>> 13) | 0) + (w18 >>> 26) | 0;
|
|
w18 &= 67108863;
|
|
o[0] = w0;
|
|
o[1] = w1;
|
|
o[2] = w2;
|
|
o[3] = w3;
|
|
o[4] = w4;
|
|
o[5] = w5;
|
|
o[6] = w6;
|
|
o[7] = w7;
|
|
o[8] = w8;
|
|
o[9] = w9;
|
|
o[10] = w10;
|
|
o[11] = w11;
|
|
o[12] = w12;
|
|
o[13] = w13;
|
|
o[14] = w14;
|
|
o[15] = w15;
|
|
o[16] = w16;
|
|
o[17] = w17;
|
|
o[18] = w18;
|
|
if (c !== 0) {
|
|
o[19] = c;
|
|
out.length++;
|
|
}
|
|
return out;
|
|
};
|
|
if (!Math.imul) {
|
|
comb10MulTo = smallMulTo;
|
|
}
|
|
function bigMulTo(self2, num, out) {
|
|
out.negative = num.negative ^ self2.negative;
|
|
out.length = self2.length + num.length;
|
|
var carry = 0;
|
|
var hncarry = 0;
|
|
for (var k = 0;k < out.length - 1; k++) {
|
|
var ncarry = hncarry;
|
|
hncarry = 0;
|
|
var rword = carry & 67108863;
|
|
var maxJ = Math.min(k, num.length - 1);
|
|
for (var j = Math.max(0, k - self2.length + 1);j <= maxJ; j++) {
|
|
var i = k - j;
|
|
var a = self2.words[i] | 0;
|
|
var b = num.words[j] | 0;
|
|
var r = a * b;
|
|
var lo = r & 67108863;
|
|
ncarry = ncarry + (r / 67108864 | 0) | 0;
|
|
lo = lo + rword | 0;
|
|
rword = lo & 67108863;
|
|
ncarry = ncarry + (lo >>> 26) | 0;
|
|
hncarry += ncarry >>> 26;
|
|
ncarry &= 67108863;
|
|
}
|
|
out.words[k] = rword;
|
|
carry = ncarry;
|
|
ncarry = hncarry;
|
|
}
|
|
if (carry !== 0) {
|
|
out.words[k] = carry;
|
|
} else {
|
|
out.length--;
|
|
}
|
|
return out.strip();
|
|
}
|
|
function jumboMulTo(self2, num, out) {
|
|
var fftm = new FFTM;
|
|
return fftm.mulp(self2, num, out);
|
|
}
|
|
BN.prototype.mulTo = function mulTo(num, out) {
|
|
var res;
|
|
var 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 & ~8191) === 0);
|
|
};
|
|
FFTM.prototype.stub = function stub(N) {
|
|
var ph = new Array(N);
|
|
for (var i = 0;i < N; i++) {
|
|
ph[i] = 0;
|
|
}
|
|
return ph;
|
|
};
|
|
FFTM.prototype.mulp = function mulp(x, y, out) {
|
|
var N = 2 * this.guessLen13b(x.length, y.length);
|
|
var rbt = this.makeRBT(N);
|
|
var _ = this.stub(N);
|
|
var rws = new Array(N);
|
|
var rwst = new Array(N);
|
|
var iwst = new Array(N);
|
|
var nrws = new Array(N);
|
|
var nrwst = new Array(N);
|
|
var niwst = new Array(N);
|
|
var rmws = out.words;
|
|
rmws.length = N;
|
|
this.convert13b(x.words, x.length, rws, N);
|
|
this.convert13b(y.words, y.length, nrws, N);
|
|
this.transform(rws, _, rwst, iwst, N, rbt);
|
|
this.transform(nrws, _, nrwst, niwst, N, rbt);
|
|
for (var i = 0;i < N; i++) {
|
|
var rx = rwst[i] * nrwst[i] - iwst[i] * niwst[i];
|
|
iwst[i] = rwst[i] * niwst[i] + iwst[i] * nrwst[i];
|
|
rwst[i] = rx;
|
|
}
|
|
this.conjugate(rwst, iwst, N);
|
|
this.transform(rwst, iwst, rmws, _, N, rbt);
|
|
this.conjugate(rmws, _, N);
|
|
this.normalize13b(rmws, N);
|
|
out.negative = x.negative ^ y.negative;
|
|
out.length = x.length + y.length;
|
|
return out.strip();
|
|
};
|
|
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++;
|
|
}
|
|
this.length = num === 0 ? 1 : 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;
|
|
var w = this.words[s];
|
|
return !!(w & q);
|
|
};
|
|
BN.prototype.imaskn = function imaskn(bits) {
|
|
assert(typeof bits === "number" && bits >= 0);
|
|
var r = bits % 26;
|
|
var s = (bits - r) / 26;
|
|
assert(this.negative === 0, "imaskn works only with positive numbers");
|
|
if (this.length <= s) {
|
|
return this;
|
|
}
|
|
if (r !== 0) {
|
|
s++;
|
|
}
|
|
this.length = Math.min(s, this.length);
|
|
if (r !== 0) {
|
|
var mask = 67108863 ^ 67108863 >>> r << r;
|
|
this.words[this.length - 1] &= mask;
|
|
}
|
|
return this.strip();
|
|
};
|
|
BN.prototype.maskn = function maskn(bits) {
|
|
return this.clone().imaskn(bits);
|
|
};
|
|
BN.prototype.iaddn = function iaddn(num) {
|
|
assert(typeof num === "number");
|
|
assert(num < 67108864);
|
|
if (num < 0)
|
|
return this.isubn(-num);
|
|
if (this.negative !== 0) {
|
|
if (this.length === 1 && (this.words[0] | 0) < num) {
|
|
this.words[0] = num - (this.words[0] | 0);
|
|
this.negative = 0;
|
|
return this;
|
|
}
|
|
this.negative = 0;
|
|
this.isubn(num);
|
|
this.negative = 1;
|
|
return this;
|
|
}
|
|
return this._iaddn(num);
|
|
};
|
|
BN.prototype._iaddn = function _iaddn(num) {
|
|
this.words[0] += num;
|
|
for (var 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;
|
|
var bhiBits = this._countBits(bhi);
|
|
shift = 26 - bhiBits;
|
|
if (shift !== 0) {
|
|
b = b.ushln(shift);
|
|
a.iushln(shift);
|
|
bhi = b.words[b.length - 1] | 0;
|
|
}
|
|
var m = a.length - b.length;
|
|
var q;
|
|
if (mode !== "mod") {
|
|
q = new BN(null);
|
|
q.length = m + 1;
|
|
q.words = new Array(q.length);
|
|
for (var 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 !== undefined) {
|
|
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) {
|
|
var res = this.imod(a._invmp(this.m).mul(this.r2));
|
|
return res._forceRed(this);
|
|
};
|
|
})(typeof module === "undefined" || module, exports);
|
|
});
|
|
|
|
// ../eve/node_modules/inherits/inherits_browser.js
|
|
var require_inherits_browser = __commonJS((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;
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../eve/node_modules/inherits/inherits.js
|
|
var require_inherits = __commonJS((exports, module) => {
|
|
try {
|
|
util = __require("util");
|
|
if (typeof util.inherits !== "function")
|
|
throw "";
|
|
module.exports = util.inherits;
|
|
} catch (e) {
|
|
module.exports = require_inherits_browser();
|
|
}
|
|
var util;
|
|
});
|
|
|
|
// ../eve/node_modules/safer-buffer/safer.js
|
|
var require_safer = __commonJS((exports, module) => {
|
|
var buffer = __require("buffer");
|
|
var Buffer2 = buffer.Buffer;
|
|
var safer = {};
|
|
var key;
|
|
for (key in buffer) {
|
|
if (!buffer.hasOwnProperty(key))
|
|
continue;
|
|
if (key === "SlowBuffer" || key === "Buffer")
|
|
continue;
|
|
safer[key] = buffer[key];
|
|
}
|
|
var Safer = safer.Buffer = {};
|
|
for (key in Buffer2) {
|
|
if (!Buffer2.hasOwnProperty(key))
|
|
continue;
|
|
if (key === "allocUnsafe" || key === "allocUnsafeSlow")
|
|
continue;
|
|
Safer[key] = Buffer2[key];
|
|
}
|
|
safer.Buffer.prototype = Buffer2.prototype;
|
|
if (!Safer.from || Safer.from === Uint8Array.from) {
|
|
Safer.from = function(value, encodingOrOffset, length) {
|
|
if (typeof value === "number") {
|
|
throw new TypeError('The "value" argument must not be of type number. Received type ' + typeof value);
|
|
}
|
|
if (value && typeof value.length === "undefined") {
|
|
throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value);
|
|
}
|
|
return Buffer2(value, encodingOrOffset, length);
|
|
};
|
|
}
|
|
if (!Safer.alloc) {
|
|
Safer.alloc = function(size, fill, encoding) {
|
|
if (typeof size !== "number") {
|
|
throw new TypeError('The "size" argument must be of type number. Received type ' + typeof size);
|
|
}
|
|
if (size < 0 || size >= 2 * (1 << 30)) {
|
|
throw new RangeError('The value "' + size + '" is invalid for option "size"');
|
|
}
|
|
var buf = Buffer2(size);
|
|
if (!fill || fill.length === 0) {
|
|
buf.fill(0);
|
|
} else if (typeof encoding === "string") {
|
|
buf.fill(fill, encoding);
|
|
} else {
|
|
buf.fill(fill);
|
|
}
|
|
return buf;
|
|
};
|
|
}
|
|
if (!safer.kStringMaxLength) {
|
|
try {
|
|
safer.kStringMaxLength = process.binding("buffer").kStringMaxLength;
|
|
} catch (e) {}
|
|
}
|
|
if (!safer.constants) {
|
|
safer.constants = {
|
|
MAX_LENGTH: safer.kMaxLength
|
|
};
|
|
if (safer.kStringMaxLength) {
|
|
safer.constants.MAX_STRING_LENGTH = safer.kStringMaxLength;
|
|
}
|
|
}
|
|
module.exports = safer;
|
|
});
|
|
|
|
// ../eve/node_modules/asn1.js/lib/asn1/base/reporter.js
|
|
var require_reporter = __commonJS((exports) => {
|
|
var inherits = require_inherits();
|
|
function Reporter(options2) {
|
|
this._reporterState = {
|
|
obj: null,
|
|
path: [],
|
|
options: options2 || {},
|
|
errors: []
|
|
};
|
|
}
|
|
exports.Reporter = Reporter;
|
|
Reporter.prototype.isError = function isError(obj) {
|
|
return obj instanceof ReporterError;
|
|
};
|
|
Reporter.prototype.save = function save() {
|
|
const state = this._reporterState;
|
|
return { obj: state.obj, pathLen: state.path.length };
|
|
};
|
|
Reporter.prototype.restore = function restore(data) {
|
|
const 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(index2) {
|
|
const state = this._reporterState;
|
|
state.path = state.path.slice(0, index2 - 1);
|
|
};
|
|
Reporter.prototype.leaveKey = function leaveKey(index2, key, value) {
|
|
const state = this._reporterState;
|
|
this.exitKey(index2);
|
|
if (state.obj !== null)
|
|
state.obj[key] = value;
|
|
};
|
|
Reporter.prototype.path = function path() {
|
|
return this._reporterState.path.join("/");
|
|
};
|
|
Reporter.prototype.enterObject = function enterObject() {
|
|
const state = this._reporterState;
|
|
const prev = state.obj;
|
|
state.obj = {};
|
|
return prev;
|
|
};
|
|
Reporter.prototype.leaveObject = function leaveObject(prev) {
|
|
const state = this._reporterState;
|
|
const now = state.obj;
|
|
state.obj = prev;
|
|
return now;
|
|
};
|
|
Reporter.prototype.error = function error(msg) {
|
|
let err;
|
|
const state = this._reporterState;
|
|
const 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) {
|
|
const 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;
|
|
};
|
|
});
|
|
|
|
// ../eve/node_modules/asn1.js/lib/asn1/base/buffer.js
|
|
var require_buffer = __commonJS((exports) => {
|
|
var inherits = require_inherits();
|
|
var Reporter = require_reporter().Reporter;
|
|
var Buffer2 = require_safer().Buffer;
|
|
function DecoderBuffer(base, options2) {
|
|
Reporter.call(this, options2);
|
|
if (!Buffer2.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.isDecoderBuffer = function isDecoderBuffer(data) {
|
|
if (data instanceof DecoderBuffer) {
|
|
return true;
|
|
}
|
|
const isCompatible = typeof data === "object" && Buffer2.isBuffer(data.base) && data.constructor.name === "DecoderBuffer" && typeof data.offset === "number" && typeof data.length === "number" && typeof data.save === "function" && typeof data.restore === "function" && typeof data.isEmpty === "function" && typeof data.readUInt8 === "function" && typeof data.skip === "function" && typeof data.raw === "function";
|
|
return isCompatible;
|
|
};
|
|
DecoderBuffer.prototype.save = function save() {
|
|
return { offset: this.offset, reporter: Reporter.prototype.save.call(this) };
|
|
};
|
|
DecoderBuffer.prototype.restore = function restore(save) {
|
|
const 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");
|
|
const 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 (!EncoderBuffer.isEncoderBuffer(item))
|
|
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 = Buffer2.byteLength(value);
|
|
} else if (Buffer2.isBuffer(value)) {
|
|
this.value = value;
|
|
this.length = value.length;
|
|
} else {
|
|
return reporter.error("Unsupported type: " + typeof value);
|
|
}
|
|
}
|
|
exports.EncoderBuffer = EncoderBuffer;
|
|
EncoderBuffer.isEncoderBuffer = function isEncoderBuffer(data) {
|
|
if (data instanceof EncoderBuffer) {
|
|
return true;
|
|
}
|
|
const isCompatible = typeof data === "object" && data.constructor.name === "EncoderBuffer" && typeof data.length === "number" && typeof data.join === "function";
|
|
return isCompatible;
|
|
};
|
|
EncoderBuffer.prototype.join = function join(out, offset) {
|
|
if (!out)
|
|
out = Buffer2.alloc(this.length);
|
|
if (!offset)
|
|
offset = 0;
|
|
if (this.length === 0)
|
|
return out;
|
|
if (Array.isArray(this.value)) {
|
|
this.value.forEach(function(item) {
|
|
item.join(out, offset);
|
|
offset += item.length;
|
|
});
|
|
} else {
|
|
if (typeof this.value === "number")
|
|
out[offset] = this.value;
|
|
else if (typeof this.value === "string")
|
|
out.write(this.value, offset);
|
|
else if (Buffer2.isBuffer(this.value))
|
|
this.value.copy(out, offset);
|
|
offset += this.length;
|
|
}
|
|
return out;
|
|
};
|
|
});
|
|
|
|
// ../eve/node_modules/minimalistic-assert/index.js
|
|
var require_minimalistic_assert = __commonJS((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);
|
|
};
|
|
});
|
|
|
|
// ../eve/node_modules/asn1.js/lib/asn1/base/node.js
|
|
var require_node = __commonJS((exports, module) => {
|
|
var Reporter = require_reporter().Reporter;
|
|
var EncoderBuffer = require_buffer().EncoderBuffer;
|
|
var DecoderBuffer = require_buffer().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, name) {
|
|
const state = {};
|
|
this._baseState = state;
|
|
state.name = name;
|
|
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() {
|
|
const state = this._baseState;
|
|
const cstate = {};
|
|
stateProps.forEach(function(prop) {
|
|
cstate[prop] = state[prop];
|
|
});
|
|
const res = new this.constructor(cstate.parent);
|
|
res._baseState = cstate;
|
|
return res;
|
|
};
|
|
Node.prototype._wrap = function wrap() {
|
|
const state = this._baseState;
|
|
methods.forEach(function(method) {
|
|
this[method] = function _wrappedMethod() {
|
|
const clone = new this.constructor(this);
|
|
state.children.push(clone);
|
|
return clone[method].apply(clone, arguments);
|
|
};
|
|
}, this);
|
|
};
|
|
Node.prototype._init = function init(body) {
|
|
const 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) {
|
|
const state = this._baseState;
|
|
const 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;
|
|
const res = {};
|
|
Object.keys(arg).forEach(function(key) {
|
|
if (key == (key | 0))
|
|
key |= 0;
|
|
const value = arg[key];
|
|
res[value] = key;
|
|
});
|
|
return res;
|
|
});
|
|
}
|
|
};
|
|
overrided.forEach(function(method) {
|
|
Node.prototype[method] = function _overrided() {
|
|
const state = this._baseState;
|
|
throw new Error(method + " not implemented for encoding: " + state.enc);
|
|
};
|
|
});
|
|
tags.forEach(function(tag) {
|
|
Node.prototype[tag] = function _tagMethod() {
|
|
const state = this._baseState;
|
|
const 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);
|
|
const state = this._baseState;
|
|
assert(state.use === null);
|
|
state.use = item;
|
|
return this;
|
|
};
|
|
Node.prototype.optional = function optional() {
|
|
const state = this._baseState;
|
|
state.optional = true;
|
|
return this;
|
|
};
|
|
Node.prototype.def = function def(val) {
|
|
const state = this._baseState;
|
|
assert(state["default"] === null);
|
|
state["default"] = val;
|
|
state.optional = true;
|
|
return this;
|
|
};
|
|
Node.prototype.explicit = function explicit(num) {
|
|
const state = this._baseState;
|
|
assert(state.explicit === null && state.implicit === null);
|
|
state.explicit = num;
|
|
return this;
|
|
};
|
|
Node.prototype.implicit = function implicit(num) {
|
|
const state = this._baseState;
|
|
assert(state.explicit === null && state.implicit === null);
|
|
state.implicit = num;
|
|
return this;
|
|
};
|
|
Node.prototype.obj = function obj() {
|
|
const state = this._baseState;
|
|
const args = Array.prototype.slice.call(arguments);
|
|
state.obj = true;
|
|
if (args.length !== 0)
|
|
this._useArgs(args);
|
|
return this;
|
|
};
|
|
Node.prototype.key = function key(newKey) {
|
|
const state = this._baseState;
|
|
assert(state.key === null);
|
|
state.key = newKey;
|
|
return this;
|
|
};
|
|
Node.prototype.any = function any() {
|
|
const state = this._baseState;
|
|
state.any = true;
|
|
return this;
|
|
};
|
|
Node.prototype.choice = function choice(obj) {
|
|
const 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) {
|
|
const state = this._baseState;
|
|
assert(state.use === null);
|
|
state.contains = item;
|
|
return this;
|
|
};
|
|
Node.prototype._decode = function decode(input, options2) {
|
|
const state = this._baseState;
|
|
if (state.parent === null)
|
|
return input.wrapResult(state.children[0]._decode(input, options2));
|
|
let result = state["default"];
|
|
let present = true;
|
|
let prevKey = null;
|
|
if (state.key !== null)
|
|
prevKey = input.enterKey(state.key);
|
|
if (state.optional) {
|
|
let 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) {
|
|
const save = input.save();
|
|
try {
|
|
if (state.choice === null)
|
|
this._decodeGeneric(state.tag, input, options2);
|
|
else
|
|
this._decodeChoice(input, options2);
|
|
present = true;
|
|
} catch (e) {
|
|
present = false;
|
|
}
|
|
input.restore(save);
|
|
} else {
|
|
present = this._peekTag(input, tag, state.any);
|
|
if (input.isError(present))
|
|
return present;
|
|
}
|
|
}
|
|
let prevObj;
|
|
if (state.obj && present)
|
|
prevObj = input.enterObject();
|
|
if (present) {
|
|
if (state.explicit !== null) {
|
|
const explicit = this._decodeTag(input, state.explicit);
|
|
if (input.isError(explicit))
|
|
return explicit;
|
|
input = explicit;
|
|
}
|
|
const start = input.offset;
|
|
if (state.use === null && state.choice === null) {
|
|
let save;
|
|
if (state.any)
|
|
save = input.save();
|
|
const 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 (options2 && options2.track && state.tag !== null)
|
|
options2.track(input.path(), start, input.length, "tagged");
|
|
if (options2 && options2.track && state.tag !== null)
|
|
options2.track(input.path(), input.offset, input.length, "content");
|
|
if (state.any) {} else if (state.choice === null) {
|
|
result = this._decodeGeneric(state.tag, input, options2);
|
|
} else {
|
|
result = this._decodeChoice(input, options2);
|
|
}
|
|
if (input.isError(result))
|
|
return result;
|
|
if (!state.any && state.choice === null && state.children !== null) {
|
|
state.children.forEach(function decodeChildren(child) {
|
|
child._decode(input, options2);
|
|
});
|
|
}
|
|
if (state.contains && (state.tag === "octstr" || state.tag === "bitstr")) {
|
|
const data = new DecoderBuffer(result);
|
|
result = this._getUse(state.contains, input._reporterState.obj)._decode(data, options2);
|
|
}
|
|
}
|
|
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, options2) {
|
|
const state = this._baseState;
|
|
if (tag === "seq" || tag === "set")
|
|
return null;
|
|
if (tag === "seqof" || tag === "setof")
|
|
return this._decodeList(input, tag, state.args[0], options2);
|
|
else if (/str$/.test(tag))
|
|
return this._decodeStr(input, tag, options2);
|
|
else if (tag === "objid" && state.args)
|
|
return this._decodeObjid(input, state.args[0], state.args[1], options2);
|
|
else if (tag === "objid")
|
|
return this._decodeObjid(input, null, null, options2);
|
|
else if (tag === "gentime" || tag === "utctime")
|
|
return this._decodeTime(input, tag, options2);
|
|
else if (tag === "null_")
|
|
return this._decodeNull(input, options2);
|
|
else if (tag === "bool")
|
|
return this._decodeBool(input, options2);
|
|
else if (tag === "objDesc")
|
|
return this._decodeStr(input, tag, options2);
|
|
else if (tag === "int" || tag === "enum")
|
|
return this._decodeInt(input, state.args && state.args[0], options2);
|
|
if (state.use !== null) {
|
|
return this._getUse(state.use, input._reporterState.obj)._decode(input, options2);
|
|
} else {
|
|
return input.error("unknown tag: " + tag);
|
|
}
|
|
};
|
|
Node.prototype._getUse = function _getUse(entity, obj) {
|
|
const 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, options2) {
|
|
const state = this._baseState;
|
|
let result = null;
|
|
let match = false;
|
|
Object.keys(state.choice).some(function(key) {
|
|
const save = input.save();
|
|
const node = state.choice[key];
|
|
try {
|
|
const value = node._decode(input, options2);
|
|
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) {
|
|
const state = this._baseState;
|
|
if (state["default"] !== null && state["default"] === data)
|
|
return;
|
|
const result = this._encodeValue(data, reporter, parent);
|
|
if (result === undefined)
|
|
return;
|
|
if (this._skipDefault(result, reporter, parent))
|
|
return;
|
|
return result;
|
|
};
|
|
Node.prototype._encodeValue = function encode(data, reporter, parent) {
|
|
const state = this._baseState;
|
|
if (state.parent === null)
|
|
return state.children[0]._encode(data, reporter || new Reporter);
|
|
let result = null;
|
|
this.reporter = reporter;
|
|
if (state.optional && data === undefined) {
|
|
if (state["default"] !== null)
|
|
data = state["default"];
|
|
else
|
|
return;
|
|
}
|
|
let content = null;
|
|
let 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");
|
|
const prevKey = reporter.enterKey(child._baseState.key);
|
|
if (typeof data !== "object")
|
|
return reporter.error("Child expected, but input is not object");
|
|
const 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");
|
|
const child = this.clone();
|
|
child._baseState.implicit = null;
|
|
content = this._createEncoderBuffer(data.map(function(item) {
|
|
const state2 = this._baseState;
|
|
return this._getUse(state2.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;
|
|
}
|
|
}
|
|
if (!state.any && state.choice === null) {
|
|
const tag = state.implicit !== null ? state.implicit : state.tag;
|
|
const 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) {
|
|
const state = this._baseState;
|
|
const 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) {
|
|
const 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);
|
|
};
|
|
});
|
|
|
|
// ../eve/node_modules/asn1.js/lib/asn1/constants/der.js
|
|
var require_der = __commonJS((exports) => {
|
|
function reverse(map) {
|
|
const res = {};
|
|
Object.keys(map).forEach(function(key) {
|
|
if ((key | 0) == key)
|
|
key = key | 0;
|
|
const value = map[key];
|
|
res[value] = key;
|
|
});
|
|
return res;
|
|
}
|
|
exports.tagClass = {
|
|
0: "universal",
|
|
1: "application",
|
|
2: "context",
|
|
3: "private"
|
|
};
|
|
exports.tagClassByName = 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 = reverse(exports.tag);
|
|
});
|
|
|
|
// ../eve/node_modules/asn1.js/lib/asn1/encoders/der.js
|
|
var require_der2 = __commonJS((exports, module) => {
|
|
var inherits = require_inherits();
|
|
var Buffer2 = require_safer().Buffer;
|
|
var Node = require_node();
|
|
var der = require_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) {
|
|
Node.call(this, "der", parent);
|
|
}
|
|
inherits(DERNode, Node);
|
|
DERNode.prototype._encodeComposite = function encodeComposite(tag, primitive, cls, content) {
|
|
const encodedTag = encodeTag(tag, primitive, cls, this.reporter);
|
|
if (content.length < 128) {
|
|
const header2 = Buffer2.alloc(2);
|
|
header2[0] = encodedTag;
|
|
header2[1] = content.length;
|
|
return this._createEncoderBuffer([header2, content]);
|
|
}
|
|
let lenOctets = 1;
|
|
for (let i = content.length;i >= 256; i >>= 8)
|
|
lenOctets++;
|
|
const header = Buffer2.alloc(1 + 1 + lenOctets);
|
|
header[0] = encodedTag;
|
|
header[1] = 128 | lenOctets;
|
|
for (let 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") {
|
|
const buf = Buffer2.alloc(str.length * 2);
|
|
for (let 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 (let i = 0;i < id.length; i++)
|
|
id[i] |= 0;
|
|
} else if (Array.isArray(id)) {
|
|
id = id.slice();
|
|
for (let 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]);
|
|
}
|
|
let size = 0;
|
|
for (let i = 0;i < id.length; i++) {
|
|
let ident = id[i];
|
|
for (size++;ident >= 128; ident >>= 7)
|
|
size++;
|
|
}
|
|
const objid = Buffer2.alloc(size);
|
|
let offset = objid.length - 1;
|
|
for (let i = id.length - 1;i >= 0; i--) {
|
|
let 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) {
|
|
let str;
|
|
const date = new Date(time);
|
|
if (tag === "gentime") {
|
|
str = [
|
|
two(date.getUTCFullYear()),
|
|
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.getUTCFullYear() % 100),
|
|
two(date.getUTCMonth() + 1),
|
|
two(date.getUTCDate()),
|
|
two(date.getUTCHours()),
|
|
two(date.getUTCMinutes()),
|
|
two(date.getUTCSeconds()),
|
|
"Z"
|
|
].join("");
|
|
} else {
|
|
this.reporter.error("Encoding " + tag + " time is not supported yet");
|
|
}
|
|
return this._encodeStr(str, "octstr");
|
|
};
|
|
DERNode.prototype._encodeNull = function encodeNull() {
|
|
return this._createEncoderBuffer("");
|
|
};
|
|
DERNode.prototype._encodeInt = function encodeInt(num, values) {
|
|
if (typeof num === "string") {
|
|
if (!values)
|
|
return this.reporter.error("String int or enum given, but no values map");
|
|
if (!values.hasOwnProperty(num)) {
|
|
return this.reporter.error("Values map doesn't contain: " + JSON.stringify(num));
|
|
}
|
|
num = values[num];
|
|
}
|
|
if (typeof num !== "number" && !Buffer2.isBuffer(num)) {
|
|
const numArray = num.toArray();
|
|
if (!num.sign && numArray[0] & 128) {
|
|
numArray.unshift(0);
|
|
}
|
|
num = Buffer2.from(numArray);
|
|
}
|
|
if (Buffer2.isBuffer(num)) {
|
|
let size2 = num.length;
|
|
if (num.length === 0)
|
|
size2++;
|
|
const out2 = Buffer2.alloc(size2);
|
|
num.copy(out2);
|
|
if (num.length === 0)
|
|
out2[0] = 0;
|
|
return this._createEncoderBuffer(out2);
|
|
}
|
|
if (num < 128)
|
|
return this._createEncoderBuffer(num);
|
|
if (num < 256)
|
|
return this._createEncoderBuffer([0, num]);
|
|
let size = 1;
|
|
for (let i = num;i >= 256; i >>= 8)
|
|
size++;
|
|
const out = new Array(size);
|
|
for (let i = out.length - 1;i >= 0; i--) {
|
|
out[i] = num & 255;
|
|
num >>= 8;
|
|
}
|
|
if (out[0] & 128) {
|
|
out.unshift(0);
|
|
}
|
|
return this._createEncoderBuffer(Buffer2.from(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) {
|
|
const state = this._baseState;
|
|
let i;
|
|
if (state["default"] === null)
|
|
return false;
|
|
const data = dataBuffer.join();
|
|
if (state.defaultBuffer === undefined)
|
|
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) {
|
|
let 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;
|
|
}
|
|
});
|
|
|
|
// ../eve/node_modules/asn1.js/lib/asn1/encoders/pem.js
|
|
var require_pem = __commonJS((exports, module) => {
|
|
var inherits = require_inherits();
|
|
var DEREncoder = require_der2();
|
|
function PEMEncoder(entity) {
|
|
DEREncoder.call(this, entity);
|
|
this.enc = "pem";
|
|
}
|
|
inherits(PEMEncoder, DEREncoder);
|
|
module.exports = PEMEncoder;
|
|
PEMEncoder.prototype.encode = function encode(data, options2) {
|
|
const buf = DEREncoder.prototype.encode.call(this, data);
|
|
const p = buf.toString("base64");
|
|
const out = ["-----BEGIN " + options2.label + "-----"];
|
|
for (let i = 0;i < p.length; i += 64)
|
|
out.push(p.slice(i, i + 64));
|
|
out.push("-----END " + options2.label + "-----");
|
|
return out.join(`
|
|
`);
|
|
};
|
|
});
|
|
|
|
// ../eve/node_modules/asn1.js/lib/asn1/encoders/index.js
|
|
var require_encoders = __commonJS((exports) => {
|
|
var encoders = exports;
|
|
encoders.der = require_der2();
|
|
encoders.pem = require_pem();
|
|
});
|
|
|
|
// ../eve/node_modules/asn1.js/lib/asn1/decoders/der.js
|
|
var require_der3 = __commonJS((exports, module) => {
|
|
var inherits = require_inherits();
|
|
var bignum = require_bn();
|
|
var DecoderBuffer = require_buffer().DecoderBuffer;
|
|
var Node = require_node();
|
|
var der = require_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, options2) {
|
|
if (!DecoderBuffer.isDecoderBuffer(data)) {
|
|
data = new DecoderBuffer(data, options2);
|
|
}
|
|
return this.tree._decode(data, options2);
|
|
};
|
|
function DERNode(parent) {
|
|
Node.call(this, "der", parent);
|
|
}
|
|
inherits(DERNode, Node);
|
|
DERNode.prototype._peekTag = function peekTag(buffer, tag, any) {
|
|
if (buffer.isEmpty())
|
|
return false;
|
|
const state = buffer.save();
|
|
const 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) {
|
|
const decodedTag = derDecodeTag(buffer, 'Failed to decode tag of "' + tag + '"');
|
|
if (buffer.isError(decodedTag))
|
|
return decodedTag;
|
|
let 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 + '"');
|
|
const state = buffer.save();
|
|
const 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) {
|
|
for (;; ) {
|
|
const tag = derDecodeTag(buffer, fail);
|
|
if (buffer.isError(tag))
|
|
return tag;
|
|
const len = derDecodeLen(buffer, tag.primitive, fail);
|
|
if (buffer.isError(len))
|
|
return len;
|
|
let 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, options2) {
|
|
const result = [];
|
|
while (!buffer.isEmpty()) {
|
|
const possibleEnd = this._peekTag(buffer, "end");
|
|
if (buffer.isError(possibleEnd))
|
|
return possibleEnd;
|
|
const res = decoder.decode(buffer, "der", options2);
|
|
if (buffer.isError(res) && possibleEnd)
|
|
break;
|
|
result.push(res);
|
|
}
|
|
return result;
|
|
};
|
|
DERNode.prototype._decodeStr = function decodeStr(buffer, tag) {
|
|
if (tag === "bitstr") {
|
|
const unused = buffer.readUInt8();
|
|
if (buffer.isError(unused))
|
|
return unused;
|
|
return { unused, data: buffer.raw() };
|
|
} else if (tag === "bmpstr") {
|
|
const raw = buffer.raw();
|
|
if (raw.length % 2 === 1)
|
|
return buffer.error("Decoding of string type: bmpstr length mismatch");
|
|
let str = "";
|
|
for (let i = 0;i < raw.length / 2; i++) {
|
|
str += String.fromCharCode(raw.readUInt16BE(i * 2));
|
|
}
|
|
return str;
|
|
} else if (tag === "numstr") {
|
|
const 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") {
|
|
const 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) {
|
|
let result;
|
|
const identifiers = [];
|
|
let ident = 0;
|
|
let subident = 0;
|
|
while (!buffer.isEmpty()) {
|
|
subident = buffer.readUInt8();
|
|
ident <<= 7;
|
|
ident |= subident & 127;
|
|
if ((subident & 128) === 0) {
|
|
identifiers.push(ident);
|
|
ident = 0;
|
|
}
|
|
}
|
|
if (subident & 128)
|
|
identifiers.push(ident);
|
|
const first = identifiers[0] / 40 | 0;
|
|
const second = identifiers[0] % 40;
|
|
if (relative)
|
|
result = identifiers;
|
|
else
|
|
result = [first, second].concat(identifiers.slice(1));
|
|
if (values) {
|
|
let tmp = values[result.join(" ")];
|
|
if (tmp === undefined)
|
|
tmp = values[result.join(".")];
|
|
if (tmp !== undefined)
|
|
result = tmp;
|
|
}
|
|
return result;
|
|
};
|
|
DERNode.prototype._decodeTime = function decodeTime(buffer, tag) {
|
|
const str = buffer.raw().toString();
|
|
let year;
|
|
let mon;
|
|
let day;
|
|
let hour;
|
|
let min;
|
|
let sec;
|
|
if (tag === "gentime") {
|
|
year = str.slice(0, 4) | 0;
|
|
mon = str.slice(4, 6) | 0;
|
|
day = str.slice(6, 8) | 0;
|
|
hour = str.slice(8, 10) | 0;
|
|
min = str.slice(10, 12) | 0;
|
|
sec = str.slice(12, 14) | 0;
|
|
} else if (tag === "utctime") {
|
|
year = str.slice(0, 2) | 0;
|
|
mon = str.slice(2, 4) | 0;
|
|
day = str.slice(4, 6) | 0;
|
|
hour = str.slice(6, 8) | 0;
|
|
min = str.slice(8, 10) | 0;
|
|
sec = str.slice(10, 12) | 0;
|
|
if (year < 70)
|
|
year = 2000 + 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() {
|
|
return null;
|
|
};
|
|
DERNode.prototype._decodeBool = function decodeBool(buffer) {
|
|
const res = buffer.readUInt8();
|
|
if (buffer.isError(res))
|
|
return res;
|
|
else
|
|
return res !== 0;
|
|
};
|
|
DERNode.prototype._decodeInt = function decodeInt(buffer, values) {
|
|
const raw = buffer.raw();
|
|
let res = new bignum(raw);
|
|
if (values)
|
|
res = values[res.toString(10)] || res;
|
|
return res;
|
|
};
|
|
DERNode.prototype._use = function use(entity, obj) {
|
|
if (typeof entity === "function")
|
|
entity = entity(obj);
|
|
return entity._getDecoder("der").tree;
|
|
};
|
|
function derDecodeTag(buf, fail) {
|
|
let tag = buf.readUInt8(fail);
|
|
if (buf.isError(tag))
|
|
return tag;
|
|
const cls = der.tagClass[tag >> 6];
|
|
const primitive = (tag & 32) === 0;
|
|
if ((tag & 31) === 31) {
|
|
let 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;
|
|
}
|
|
const tagStr = der.tag[tag];
|
|
return {
|
|
cls,
|
|
primitive,
|
|
tag,
|
|
tagStr
|
|
};
|
|
}
|
|
function derDecodeLen(buf, primitive, fail) {
|
|
let len = buf.readUInt8(fail);
|
|
if (buf.isError(len))
|
|
return len;
|
|
if (!primitive && len === 128)
|
|
return null;
|
|
if ((len & 128) === 0) {
|
|
return len;
|
|
}
|
|
const num = len & 127;
|
|
if (num > 4)
|
|
return buf.error("length octect is too long");
|
|
len = 0;
|
|
for (let i = 0;i < num; i++) {
|
|
len <<= 8;
|
|
const j = buf.readUInt8(fail);
|
|
if (buf.isError(j))
|
|
return j;
|
|
len |= j;
|
|
}
|
|
return len;
|
|
}
|
|
});
|
|
|
|
// ../eve/node_modules/asn1.js/lib/asn1/decoders/pem.js
|
|
var require_pem2 = __commonJS((exports, module) => {
|
|
var inherits = require_inherits();
|
|
var Buffer2 = require_safer().Buffer;
|
|
var DERDecoder = require_der3();
|
|
function PEMDecoder(entity) {
|
|
DERDecoder.call(this, entity);
|
|
this.enc = "pem";
|
|
}
|
|
inherits(PEMDecoder, DERDecoder);
|
|
module.exports = PEMDecoder;
|
|
PEMDecoder.prototype.decode = function decode(data, options2) {
|
|
const lines = data.toString().split(/[\r\n]+/g);
|
|
const label = options2.label.toUpperCase();
|
|
const re = /^-----(BEGIN|END) ([^-]+)-----$/;
|
|
let start = -1;
|
|
let end = -1;
|
|
for (let i = 0;i < lines.length; i++) {
|
|
const 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);
|
|
const base64 = lines.slice(start + 1, end).join("");
|
|
base64.replace(/[^a-z0-9+/=]+/gi, "");
|
|
const input = Buffer2.from(base64, "base64");
|
|
return DERDecoder.prototype.decode.call(this, input, options2);
|
|
};
|
|
});
|
|
|
|
// ../eve/node_modules/asn1.js/lib/asn1/decoders/index.js
|
|
var require_decoders = __commonJS((exports) => {
|
|
var decoders = exports;
|
|
decoders.der = require_der3();
|
|
decoders.pem = require_pem2();
|
|
});
|
|
|
|
// ../eve/node_modules/asn1.js/lib/asn1/api.js
|
|
var require_api = __commonJS((exports) => {
|
|
var encoders = require_encoders();
|
|
var decoders = require_decoders();
|
|
var inherits = require_inherits();
|
|
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) {
|
|
const name = this.name;
|
|
function Generated(entity) {
|
|
this._initNamed(entity, name);
|
|
}
|
|
inherits(Generated, Base);
|
|
Generated.prototype._initNamed = function _initNamed(entity, name2) {
|
|
Base.call(this, entity, name2);
|
|
};
|
|
return new Generated(this);
|
|
};
|
|
Entity.prototype._getDecoder = function _getDecoder(enc) {
|
|
enc = enc || "der";
|
|
if (!this.decoders.hasOwnProperty(enc))
|
|
this.decoders[enc] = this._createNamed(decoders[enc]);
|
|
return this.decoders[enc];
|
|
};
|
|
Entity.prototype.decode = function decode(data, enc, options2) {
|
|
return this._getDecoder(enc).decode(data, options2);
|
|
};
|
|
Entity.prototype._getEncoder = function _getEncoder(enc) {
|
|
enc = enc || "der";
|
|
if (!this.encoders.hasOwnProperty(enc))
|
|
this.encoders[enc] = this._createNamed(encoders[enc]);
|
|
return this.encoders[enc];
|
|
};
|
|
Entity.prototype.encode = function encode(data, enc, reporter) {
|
|
return this._getEncoder(enc).encode(data, reporter);
|
|
};
|
|
});
|
|
|
|
// ../eve/node_modules/asn1.js/lib/asn1/base/index.js
|
|
var require_base = __commonJS((exports) => {
|
|
var base = exports;
|
|
base.Reporter = require_reporter().Reporter;
|
|
base.DecoderBuffer = require_buffer().DecoderBuffer;
|
|
base.EncoderBuffer = require_buffer().EncoderBuffer;
|
|
base.Node = require_node();
|
|
});
|
|
|
|
// ../eve/node_modules/asn1.js/lib/asn1/constants/index.js
|
|
var require_constants2 = __commonJS((exports) => {
|
|
var constants = exports;
|
|
constants._reverse = function reverse(map) {
|
|
const res = {};
|
|
Object.keys(map).forEach(function(key) {
|
|
if ((key | 0) == key)
|
|
key = key | 0;
|
|
const value = map[key];
|
|
res[value] = key;
|
|
});
|
|
return res;
|
|
};
|
|
constants.der = require_der();
|
|
});
|
|
|
|
// ../eve/node_modules/asn1.js/lib/asn1.js
|
|
var require_asn1 = __commonJS((exports) => {
|
|
var asn1 = exports;
|
|
asn1.bignum = require_bn();
|
|
asn1.define = require_api().define;
|
|
asn1.base = require_base();
|
|
asn1.constants = require_constants2();
|
|
asn1.decoders = require_decoders();
|
|
asn1.encoders = require_encoders();
|
|
});
|
|
|
|
// ../eve/node_modules/elliptic/package.json
|
|
var require_package = __commonJS((exports, module) => {
|
|
module.exports = {
|
|
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>",
|
|
license: "MIT",
|
|
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"
|
|
}
|
|
};
|
|
});
|
|
|
|
// ../eve/node_modules/minimalistic-crypto-utils/lib/utils.js
|
|
var require_utils = __commonJS((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]+/ig, "");
|
|
if (msg.length % 2 !== 0)
|
|
msg = "0" + msg;
|
|
for (var i = 0;i < msg.length; i += 2)
|
|
res.push(parseInt(msg[i] + msg[i + 1], 16));
|
|
} else {
|
|
for (var i = 0;i < msg.length; i++) {
|
|
var c = msg.charCodeAt(i);
|
|
var hi = c >> 8;
|
|
var lo = c & 255;
|
|
if (hi)
|
|
res.push(hi, lo);
|
|
else
|
|
res.push(lo);
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
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;
|
|
};
|
|
});
|
|
|
|
// ../eve/node_modules/elliptic/lib/elliptic/utils.js
|
|
var require_utils2 = __commonJS((exports) => {
|
|
var utils = exports;
|
|
var BN = require_bn();
|
|
var minAssert = require_minimalistic_assert();
|
|
var minUtils = require_utils();
|
|
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] !== undefined ? 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;
|
|
});
|
|
|
|
// ../eve/node_modules/brorand/index.js
|
|
var require_brorand = __commonJS((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 {
|
|
crypto2 = __require("crypto");
|
|
if (typeof crypto2.randomBytes !== "function")
|
|
throw new Error("Not supported");
|
|
Rand.prototype._rand = function _rand(n) {
|
|
return crypto2.randomBytes(n);
|
|
};
|
|
} catch (e) {}
|
|
}
|
|
var crypto2;
|
|
});
|
|
|
|
// ../eve/node_modules/elliptic/lib/elliptic/curve/base.js
|
|
var require_base2 = __commonJS((exports, module) => {
|
|
var BN = require_bn();
|
|
var utils = require_utils2();
|
|
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 index2 = [
|
|
-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] = index2[(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);
|
|
var res = this.point(bytes.slice(1, 1 + len), bytes.slice(1 + len, 1 + 2 * len));
|
|
return res;
|
|
} else if ((bytes[0] === 2 || bytes[0] === 3) && bytes.length - 1 === len) {
|
|
return this.pointFromX(bytes.slice(1, 1 + len), bytes[0] === 3);
|
|
}
|
|
throw new Error("Unknown point format");
|
|
};
|
|
BasePoint.prototype.encodeCompressed = function encodeCompressed(enc) {
|
|
return this.encode(enc, true);
|
|
};
|
|
BasePoint.prototype._encode = function _encode(compact) {
|
|
var len = this.curve.p.byteLength();
|
|
var x = this.getX().toArray("be", len);
|
|
if (compact)
|
|
return [this.getY().isEven() ? 2 : 3].concat(x);
|
|
return [4].concat(x, this.getY().toArray("be", len));
|
|
};
|
|
BasePoint.prototype.encode = function encode(enc, compact) {
|
|
return utils.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;
|
|
};
|
|
});
|
|
|
|
// ../eve/node_modules/elliptic/lib/elliptic/curve/short.js
|
|
var require_short = __commonJS((exports, module) => {
|
|
var utils = require_utils2();
|
|
var BN = require_bn();
|
|
var inherits = require_inherits();
|
|
var Base = require_base2();
|
|
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);
|
|
var l1 = ntinv.redAdd(s).fromRed();
|
|
var l2 = ntinv.redSub(s).fromRed();
|
|
return [l1, l2];
|
|
};
|
|
ShortCurve.prototype._getEndoBasis = function _getEndoBasis(lambda) {
|
|
var aprxSqrt = this.n.ushrn(Math.floor(this.n.bitLength() / 2));
|
|
var u = lambda;
|
|
var v = this.n.clone();
|
|
var x1 = new BN(1);
|
|
var y1 = new BN(0);
|
|
var x2 = new BN(0);
|
|
var y2 = new BN(1);
|
|
var a0;
|
|
var b0;
|
|
var a1;
|
|
var b1;
|
|
var a2;
|
|
var b2;
|
|
var prevR;
|
|
var 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());
|
|
var len2 = a2.sqr().add(b2.sqr());
|
|
if (len2.cmp(len1) >= 0) {
|
|
a2 = a0;
|
|
b2 = b0;
|
|
}
|
|
if (a1.negative) {
|
|
a1 = a1.neg();
|
|
b1 = b1.neg();
|
|
}
|
|
if (a2.negative) {
|
|
a2 = a2.neg();
|
|
b2 = b2.neg();
|
|
}
|
|
return [
|
|
{ a: a1, b: b1 },
|
|
{ a: a2, b: b2 }
|
|
];
|
|
};
|
|
ShortCurve.prototype._endoSplit = function _endoSplit(k) {
|
|
var basis = this.endo.basis;
|
|
var v1 = basis[0];
|
|
var v2 = basis[1];
|
|
var c1 = v2.b.mul(k).divRound(this.n);
|
|
var c2 = v1.b.neg().mul(k).divRound(this.n);
|
|
var p1 = c1.mul(v1.a);
|
|
var p2 = c2.mul(v2.a);
|
|
var q1 = c1.mul(v1.b);
|
|
var q2 = c2.mul(v2.b);
|
|
var k1 = k.sub(p1).sub(p2);
|
|
var k2 = q1.add(q2).neg();
|
|
return { k1, k2 };
|
|
};
|
|
ShortCurve.prototype.pointFromX = function pointFromX(x, odd) {
|
|
x = new BN(x, 16);
|
|
if (!x.red)
|
|
x = x.toRed(this.red);
|
|
var y2 = x.redSqr().redMul(x).redIAdd(x.redMul(this.a)).redIAdd(this.b);
|
|
var y = y2.redSqrt();
|
|
if (y.redSqr().redSub(y2).cmp(this.zero) !== 0)
|
|
throw new Error("invalid point");
|
|
var isOdd = y.fromRed().isOdd();
|
|
if (odd && !isOdd || !odd && isOdd)
|
|
y = y.redNeg();
|
|
return this.point(x, y);
|
|
};
|
|
ShortCurve.prototype.validate = function validate(point) {
|
|
if (point.inf)
|
|
return true;
|
|
var x = point.x;
|
|
var y = point.y;
|
|
var ax = this.a.redMul(x);
|
|
var rhs = x.redSqr().redMul(x).redIAdd(ax).redIAdd(this.b);
|
|
return y.redSqr().redISub(rhs).cmpn(0) === 0;
|
|
};
|
|
ShortCurve.prototype._endoWnafMulAdd = function _endoWnafMulAdd(points, coeffs, jacobianResult) {
|
|
var npoints = this._endoWnafT1;
|
|
var ncoeffs = this._endoWnafT2;
|
|
for (var 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(obj2) {
|
|
return curve.point(obj2[0], obj2[1], red);
|
|
}
|
|
var pre = obj[2];
|
|
res.precomputed = {
|
|
beta: null,
|
|
doubles: pre.doubles && {
|
|
step: pre.doubles.step,
|
|
points: [res].concat(pre.doubles.points.map(obj2point))
|
|
},
|
|
naf: pre.naf && {
|
|
wnd: pre.naf.wnd,
|
|
points: [res].concat(pre.naf.points.map(obj2point))
|
|
}
|
|
};
|
|
return res;
|
|
};
|
|
Point.prototype.inspect = function 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);
|
|
var res = this.curve.jpoint(this.x, this.y, this.curve.one);
|
|
return res;
|
|
};
|
|
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;
|
|
};
|
|
});
|
|
|
|
// ../eve/node_modules/elliptic/lib/elliptic/curve/mont.js
|
|
var require_mont = __commonJS((exports, module) => {
|
|
var BN = require_bn();
|
|
var inherits = require_inherits();
|
|
var Base = require_base2();
|
|
var utils = require_utils2();
|
|
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);
|
|
var y = rhs.redSqrt();
|
|
return y.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 a = this.x.redAdd(this.z);
|
|
var aa = a.redSqr();
|
|
var b = this.x.redSub(this.z);
|
|
var bb = b.redSqr();
|
|
var c = aa.redSub(bb);
|
|
var nx = aa.redMul(bb);
|
|
var nz = c.redMul(bb.redAdd(this.curve.a24.redMul(c)));
|
|
return this.curve.point(nx, nz);
|
|
};
|
|
Point.prototype.add = function add() {
|
|
throw new Error("Not supported on Montgomery curve");
|
|
};
|
|
Point.prototype.diffAdd = function diffAdd(p, diff) {
|
|
var a = this.x.redAdd(this.z);
|
|
var b = this.x.redSub(this.z);
|
|
var c = p.x.redAdd(p.z);
|
|
var d = p.x.redSub(p.z);
|
|
var da = d.redMul(a);
|
|
var cb = c.redMul(b);
|
|
var nx = diff.z.redMul(da.redAdd(cb).redSqr());
|
|
var nz = diff.x.redMul(da.redISub(cb).redSqr());
|
|
return this.curve.point(nx, nz);
|
|
};
|
|
Point.prototype.mul = function mul(k) {
|
|
var t = k.clone();
|
|
var a = this;
|
|
var b = this.curve.point(null, null);
|
|
var c = this;
|
|
for (var bits = [];t.cmpn(0) !== 0; t.iushrn(1))
|
|
bits.push(t.andln(1));
|
|
for (var 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();
|
|
};
|
|
});
|
|
|
|
// ../eve/node_modules/elliptic/lib/elliptic/curve/edwards.js
|
|
var require_edwards = __commonJS((exports, module) => {
|
|
var utils = require_utils2();
|
|
var BN = require_bn();
|
|
var inherits = require_inherits();
|
|
var Base = require_base2();
|
|
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;
|
|
});
|
|
|
|
// ../eve/node_modules/elliptic/lib/elliptic/curve/index.js
|
|
var require_curve = __commonJS((exports) => {
|
|
var curve = exports;
|
|
curve.base = require_base2();
|
|
curve.short = require_short();
|
|
curve.mont = require_mont();
|
|
curve.edwards = require_edwards();
|
|
});
|
|
|
|
// ../eve/node_modules/hash.js/lib/hash/utils.js
|
|
var require_utils3 = __commonJS((exports) => {
|
|
var assert = require_minimalistic_assert();
|
|
var inherits = require_inherits();
|
|
exports.inherits = inherits;
|
|
function isSurrogatePair(msg, i) {
|
|
if ((msg.charCodeAt(i) & 64512) !== 55296) {
|
|
return false;
|
|
}
|
|
if (i < 0 || i + 1 >= msg.length) {
|
|
return false;
|
|
}
|
|
return (msg.charCodeAt(i + 1) & 64512) === 56320;
|
|
}
|
|
function toArray(msg, enc) {
|
|
if (Array.isArray(msg))
|
|
return msg.slice();
|
|
if (!msg)
|
|
return [];
|
|
var res = [];
|
|
if (typeof msg === "string") {
|
|
if (!enc) {
|
|
var p = 0;
|
|
for (var i = 0;i < msg.length; i++) {
|
|
var c = msg.charCodeAt(i);
|
|
if (c < 128) {
|
|
res[p++] = c;
|
|
} else if (c < 2048) {
|
|
res[p++] = c >> 6 | 192;
|
|
res[p++] = c & 63 | 128;
|
|
} else if (isSurrogatePair(msg, i)) {
|
|
c = 65536 + ((c & 1023) << 10) + (msg.charCodeAt(++i) & 1023);
|
|
res[p++] = c >> 18 | 240;
|
|
res[p++] = c >> 12 & 63 | 128;
|
|
res[p++] = c >> 6 & 63 | 128;
|
|
res[p++] = c & 63 | 128;
|
|
} else {
|
|
res[p++] = c >> 12 | 224;
|
|
res[p++] = c >> 6 & 63 | 128;
|
|
res[p++] = c & 63 | 128;
|
|
}
|
|
}
|
|
} else if (enc === "hex") {
|
|
msg = msg.replace(/[^a-z0-9]+/ig, "");
|
|
if (msg.length % 2 !== 0)
|
|
msg = "0" + msg;
|
|
for (i = 0;i < msg.length; i += 2)
|
|
res.push(parseInt(msg[i] + msg[i + 1], 16));
|
|
}
|
|
} else {
|
|
for (i = 0;i < msg.length; i++)
|
|
res[i] = msg[i] | 0;
|
|
}
|
|
return res;
|
|
}
|
|
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) {
|
|
var res = w >>> 24 | w >>> 8 & 65280 | w << 8 & 16711680 | (w & 255) << 24;
|
|
return res >>> 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 bl = buf[pos + 1];
|
|
var lo = al + bl >>> 0;
|
|
var hi = (lo < al ? 1 : 0) + ah + bh;
|
|
buf[pos] = hi >>> 0;
|
|
buf[pos + 1] = lo;
|
|
}
|
|
exports.sum64 = sum64;
|
|
function sum64_hi(ah, al, bh, bl) {
|
|
var lo = al + bl >>> 0;
|
|
var hi = (lo < al ? 1 : 0) + ah + bh;
|
|
return hi >>> 0;
|
|
}
|
|
exports.sum64_hi = sum64_hi;
|
|
function sum64_lo(ah, al, bh, bl) {
|
|
var lo = al + bl;
|
|
return lo >>> 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;
|
|
var hi = ah + bh + ch + dh + carry;
|
|
return hi >>> 0;
|
|
}
|
|
exports.sum64_4_hi = sum64_4_hi;
|
|
function sum64_4_lo(ah, al, bh, bl, ch, cl, dh, dl) {
|
|
var lo = al + bl + cl + dl;
|
|
return lo >>> 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;
|
|
var hi = ah + bh + ch + dh + eh + carry;
|
|
return hi >>> 0;
|
|
}
|
|
exports.sum64_5_hi = sum64_5_hi;
|
|
function sum64_5_lo(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {
|
|
var lo = al + bl + cl + dl + el;
|
|
return lo >>> 0;
|
|
}
|
|
exports.sum64_5_lo = sum64_5_lo;
|
|
function rotr64_hi(ah, al, num) {
|
|
var r = al << 32 - num | ah >>> num;
|
|
return r >>> 0;
|
|
}
|
|
exports.rotr64_hi = rotr64_hi;
|
|
function rotr64_lo(ah, al, num) {
|
|
var r = ah << 32 - num | al >>> num;
|
|
return r >>> 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) {
|
|
var r = ah << 32 - num | al >>> num;
|
|
return r >>> 0;
|
|
}
|
|
exports.shr64_lo = shr64_lo;
|
|
});
|
|
|
|
// ../eve/node_modules/hash.js/lib/hash/common.js
|
|
var require_common = __commonJS((exports) => {
|
|
var utils = require_utils3();
|
|
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;
|
|
};
|
|
});
|
|
|
|
// ../eve/node_modules/hash.js/lib/hash/sha/common.js
|
|
var require_common2 = __commonJS((exports) => {
|
|
var utils = require_utils3();
|
|
var rotr32 = 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;
|
|
});
|
|
|
|
// ../eve/node_modules/hash.js/lib/hash/sha/1.js
|
|
var require_1 = __commonJS((exports, module) => {
|
|
var utils = require_utils3();
|
|
var common = require_common();
|
|
var shaCommon = require_common2();
|
|
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");
|
|
};
|
|
});
|
|
|
|
// ../eve/node_modules/hash.js/lib/hash/sha/256.js
|
|
var require_256 = __commonJS((exports, module) => {
|
|
var utils = require_utils3();
|
|
var common = require_common();
|
|
var shaCommon = require_common2();
|
|
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");
|
|
};
|
|
});
|
|
|
|
// ../eve/node_modules/hash.js/lib/hash/sha/224.js
|
|
var require_224 = __commonJS((exports, module) => {
|
|
var utils = require_utils3();
|
|
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");
|
|
};
|
|
});
|
|
|
|
// ../eve/node_modules/hash.js/lib/hash/sha/512.js
|
|
var require_512 = __commonJS((exports, module) => {
|
|
var utils = require_utils3();
|
|
var common = require_common();
|
|
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;
|
|
}
|
|
});
|
|
|
|
// ../eve/node_modules/hash.js/lib/hash/sha/384.js
|
|
var require_384 = __commonJS((exports, module) => {
|
|
var utils = require_utils3();
|
|
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");
|
|
};
|
|
});
|
|
|
|
// ../eve/node_modules/hash.js/lib/hash/sha.js
|
|
var require_sha = __commonJS((exports) => {
|
|
exports.sha1 = require_1();
|
|
exports.sha224 = require_224();
|
|
exports.sha256 = require_256();
|
|
exports.sha384 = require_384();
|
|
exports.sha512 = require_512();
|
|
});
|
|
|
|
// ../eve/node_modules/hash.js/lib/hash/ripemd.js
|
|
var require_ripemd = __commonJS((exports) => {
|
|
var utils = require_utils3();
|
|
var common = require_common();
|
|
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
|
|
];
|
|
});
|
|
|
|
// ../eve/node_modules/hash.js/lib/hash/hmac.js
|
|
var require_hmac = __commonJS((exports, module) => {
|
|
var utils = require_utils3();
|
|
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);
|
|
};
|
|
});
|
|
|
|
// ../eve/node_modules/hash.js/lib/hash.js
|
|
var require_hash = __commonJS((exports) => {
|
|
var hash = exports;
|
|
hash.utils = require_utils3();
|
|
hash.common = require_common();
|
|
hash.sha = require_sha();
|
|
hash.ripemd = require_ripemd();
|
|
hash.hmac = require_hmac();
|
|
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;
|
|
});
|
|
|
|
// ../eve/node_modules/elliptic/lib/elliptic/precomputed/secp256k1.js
|
|
var require_secp256k1 = __commonJS((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"
|
|
]
|
|
]
|
|
}
|
|
};
|
|
});
|
|
|
|
// ../eve/node_modules/elliptic/lib/elliptic/curves.js
|
|
var require_curves = __commonJS((exports) => {
|
|
var curves = exports;
|
|
var hash = require_hash();
|
|
var curve = require_curve();
|
|
var utils = require_utils2();
|
|
var assert = utils.assert;
|
|
function PresetCurve(options2) {
|
|
if (options2.type === "short")
|
|
this.curve = new curve.short(options2);
|
|
else if (options2.type === "edwards")
|
|
this.curve = new curve.edwards(options2);
|
|
else
|
|
this.curve = new curve.mont(options2);
|
|
this.g = this.curve.g;
|
|
this.n = this.curve.n;
|
|
this.hash = options2.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, options2) {
|
|
Object.defineProperty(curves, name, {
|
|
configurable: true,
|
|
enumerable: true,
|
|
get: function() {
|
|
var curve2 = new PresetCurve(options2);
|
|
Object.defineProperty(curves, name, {
|
|
configurable: true,
|
|
enumerable: true,
|
|
value: curve2
|
|
});
|
|
return curve2;
|
|
}
|
|
});
|
|
}
|
|
defineCurve("p192", {
|
|
type: "short",
|
|
prime: "p192",
|
|
p: "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff",
|
|
a: "ffffffff ffffffff ffffffff fffffffe ffffffff fffffffc",
|
|
b: "64210519 e59c80e7 0fa7e9ab 72243049 feb8deec c146b9b1",
|
|
n: "ffffffff ffffffff ffffffff 99def836 146bc9b1 b4d22831",
|
|
hash: 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 = undefined;
|
|
}
|
|
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
|
|
]
|
|
});
|
|
});
|
|
|
|
// ../eve/node_modules/hmac-drbg/lib/hmac-drbg.js
|
|
var require_hmac_drbg = __commonJS((exports, module) => {
|
|
var hash = require_hash();
|
|
var utils = require_utils();
|
|
var assert = require_minimalistic_assert();
|
|
function HmacDRBG(options2) {
|
|
if (!(this instanceof HmacDRBG))
|
|
return new HmacDRBG(options2);
|
|
this.hash = options2.hash;
|
|
this.predResist = !!options2.predResist;
|
|
this.outLen = this.hash.outSize;
|
|
this.minEntropy = options2.minEntropy || this.hash.hmacStrength;
|
|
this._reseed = null;
|
|
this.reseedInterval = null;
|
|
this.K = null;
|
|
this.V = null;
|
|
var entropy = utils.toArray(options2.entropy, options2.entropyEnc || "hex");
|
|
var nonce = utils.toArray(options2.nonce, options2.nonceEnc || "hex");
|
|
var pers = utils.toArray(options2.pers, options2.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);
|
|
};
|
|
});
|
|
|
|
// ../eve/node_modules/elliptic/lib/elliptic/ec/key.js
|
|
var require_key = __commonJS((exports, module) => {
|
|
var BN = require_bn();
|
|
var utils = require_utils2();
|
|
var assert = utils.assert;
|
|
function KeyPair(ec, options2) {
|
|
this.ec = ec;
|
|
this.priv = null;
|
|
this.pub = null;
|
|
if (options2.priv)
|
|
this._importPrivate(options2.priv, options2.privEnc);
|
|
if (options2.pub)
|
|
this._importPublic(options2.pub, options2.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, options2) {
|
|
return this.ec.sign(msg, this, enc, options2);
|
|
};
|
|
KeyPair.prototype.verify = function verify(msg, signature, options2) {
|
|
return this.ec.verify(msg, signature, this, undefined, options2);
|
|
};
|
|
KeyPair.prototype.inspect = function inspect() {
|
|
return "<Key priv: " + (this.priv && this.priv.toString(16, 2)) + " pub: " + (this.pub && this.pub.inspect()) + " >";
|
|
};
|
|
});
|
|
|
|
// ../eve/node_modules/elliptic/lib/elliptic/ec/signature.js
|
|
var require_signature = __commonJS((exports, module) => {
|
|
var BN = require_bn();
|
|
var utils = require_utils2();
|
|
var assert = utils.assert;
|
|
function Signature(options2, enc) {
|
|
if (options2 instanceof Signature)
|
|
return options2;
|
|
if (this._importDER(options2, enc))
|
|
return;
|
|
assert(options2.r && options2.s, "Signature without r or s");
|
|
this.r = new BN(options2.r, 16);
|
|
this.s = new BN(options2.s, 16);
|
|
if (options2.recoveryParam === undefined)
|
|
this.recoveryParam = null;
|
|
else
|
|
this.recoveryParam = options2.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);
|
|
};
|
|
});
|
|
|
|
// ../eve/node_modules/elliptic/lib/elliptic/ec/index.js
|
|
var require_ec = __commonJS((exports, module) => {
|
|
var BN = require_bn();
|
|
var HmacDRBG = require_hmac_drbg();
|
|
var utils = require_utils2();
|
|
var curves = require_curves();
|
|
var rand = require_brorand();
|
|
var assert = utils.assert;
|
|
var KeyPair = require_key();
|
|
var Signature = require_signature();
|
|
function EC(options2) {
|
|
if (!(this instanceof EC))
|
|
return new EC(options2);
|
|
if (typeof options2 === "string") {
|
|
assert(Object.prototype.hasOwnProperty.call(curves, options2), "Unknown curve " + options2);
|
|
options2 = curves[options2];
|
|
}
|
|
if (options2 instanceof curves.PresetCurve)
|
|
options2 = { curve: options2 };
|
|
this.curve = options2.curve.curve;
|
|
this.n = this.curve.n;
|
|
this.nh = this.n.ushrn(1);
|
|
this.g = this.curve.g;
|
|
this.g = options2.curve.g;
|
|
this.g.precompute(options2.curve.n.bitLength() + 1);
|
|
this.hash = options2.hash || options2.curve.hash;
|
|
}
|
|
module.exports = EC;
|
|
EC.prototype.keyPair = function keyPair(options2) {
|
|
return new KeyPair(this, options2);
|
|
};
|
|
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(options2) {
|
|
if (!options2)
|
|
options2 = {};
|
|
var drbg = new HmacDRBG({
|
|
hash: this.hash,
|
|
pers: options2.pers,
|
|
persEnc: options2.persEnc || "utf8",
|
|
entropy: options2.entropy || rand(this.hash.hmacStrength),
|
|
entropyEnc: options2.entropy && options2.entropyEnc || "utf8",
|
|
nonce: this.n.toArray()
|
|
});
|
|
var bytes = this.n.byteLength();
|
|
var ns2 = this.n.sub(new 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, options2) {
|
|
if (typeof enc === "object") {
|
|
options2 = enc;
|
|
enc = null;
|
|
}
|
|
if (!options2)
|
|
options2 = {};
|
|
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, options2.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: options2.pers,
|
|
persEnc: options2.persEnc || "utf8"
|
|
});
|
|
var ns1 = this.n.sub(new BN(1));
|
|
for (var iter = 0;; iter++) {
|
|
var k = options2.k ? options2.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 (options2.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, options2) {
|
|
if (!options2)
|
|
options2 = {};
|
|
msg = this._truncateToN(msg, false, options2.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 (e2) {
|
|
continue;
|
|
}
|
|
if (Qprime.eq(Q))
|
|
return i;
|
|
}
|
|
throw new Error("Unable to find valid recovery factor");
|
|
};
|
|
});
|
|
|
|
// ../eve/node_modules/elliptic/lib/elliptic/eddsa/key.js
|
|
var require_key2 = __commonJS((exports, module) => {
|
|
var utils = require_utils2();
|
|
var assert = utils.assert;
|
|
var parseBytes = utils.parseBytes;
|
|
var cachedProperty = utils.cachedProperty;
|
|
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;
|
|
});
|
|
|
|
// ../eve/node_modules/elliptic/lib/elliptic/eddsa/signature.js
|
|
var require_signature2 = __commonJS((exports, module) => {
|
|
var BN = require_bn();
|
|
var utils = require_utils2();
|
|
var assert = utils.assert;
|
|
var cachedProperty = utils.cachedProperty;
|
|
var parseBytes = utils.parseBytes;
|
|
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;
|
|
});
|
|
|
|
// ../eve/node_modules/elliptic/lib/elliptic/eddsa/index.js
|
|
var require_eddsa = __commonJS((exports, module) => {
|
|
var hash = require_hash();
|
|
var curves = require_curves();
|
|
var utils = require_utils2();
|
|
var assert = utils.assert;
|
|
var parseBytes = utils.parseBytes;
|
|
var KeyPair = require_key2();
|
|
var Signature = require_signature2();
|
|
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;
|
|
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 });
|
|
};
|
|
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());
|
|
var RplusAh = sig.R().add(key.pub().mul(h));
|
|
return RplusAh.eq(SG);
|
|
};
|
|
EDDSA.prototype.hashInt = function hashInt() {
|
|
var hash2 = this.hash();
|
|
for (var i = 0;i < arguments.length; i++)
|
|
hash2.update(arguments[i]);
|
|
return utils.intFromLE(hash2.digest()).umod(this.curve.n);
|
|
};
|
|
EDDSA.prototype.keyFromPublic = function keyFromPublic(pub) {
|
|
return KeyPair.fromPublic(this, pub);
|
|
};
|
|
EDDSA.prototype.keyFromSecret = function keyFromSecret(secret) {
|
|
return KeyPair.fromSecret(this, secret);
|
|
};
|
|
EDDSA.prototype.makeSignature = function makeSignature(sig) {
|
|
if (sig instanceof Signature)
|
|
return sig;
|
|
return new Signature(this, sig);
|
|
};
|
|
EDDSA.prototype.encodePoint = function encodePoint(point) {
|
|
var enc = point.getY().toArray("le", this.encodingLength);
|
|
enc[this.encodingLength - 1] |= point.getX().isOdd() ? 128 : 0;
|
|
return enc;
|
|
};
|
|
EDDSA.prototype.decodePoint = function decodePoint(bytes) {
|
|
bytes = utils.parseBytes(bytes);
|
|
var lastIx = bytes.length - 1;
|
|
var normed = bytes.slice(0, lastIx).concat(bytes[lastIx] & ~128);
|
|
var xIsOdd = (bytes[lastIx] & 128) !== 0;
|
|
var y = utils.intFromLE(normed);
|
|
return this.curve.pointFromY(y, xIsOdd);
|
|
};
|
|
EDDSA.prototype.encodeInt = function encodeInt(num) {
|
|
return num.toArray("le", this.encodingLength);
|
|
};
|
|
EDDSA.prototype.decodeInt = function decodeInt(bytes) {
|
|
return utils.intFromLE(bytes);
|
|
};
|
|
EDDSA.prototype.isPoint = function isPoint(val) {
|
|
return val instanceof this.pointClass;
|
|
};
|
|
});
|
|
|
|
// ../eve/node_modules/elliptic/lib/elliptic.js
|
|
var require_elliptic = __commonJS((exports) => {
|
|
var elliptic = exports;
|
|
elliptic.version = require_package().version;
|
|
elliptic.utils = require_utils2();
|
|
elliptic.rand = require_brorand();
|
|
elliptic.curve = require_curve();
|
|
elliptic.curves = require_curves();
|
|
elliptic.ec = require_ec();
|
|
elliptic.eddsa = require_eddsa();
|
|
});
|
|
|
|
// ../eve/node_modules/jwk-to-pem/src/b64-to-bn.js
|
|
var require_b64_to_bn = __commonJS((exports, module) => {
|
|
var BN = require_asn1().bignum;
|
|
var Buffer2 = require_safe_buffer().Buffer;
|
|
module.exports = function base64ToBigNum(val, zero) {
|
|
var buf = Buffer2.from(val, "base64");
|
|
var bn = val = new BN(buf, 10, "be").iabs();
|
|
if (zero) {
|
|
buf.fill(0);
|
|
}
|
|
return bn;
|
|
};
|
|
});
|
|
|
|
// ../eve/node_modules/jwk-to-pem/src/asn1/algorithm-identifier.js
|
|
var require_algorithm_identifier = __commonJS((exports, module) => {
|
|
module.exports = require_asn1().define("AlgorithmIdentifer", function() {
|
|
this.seq().obj(this.key("algorithm").objid(), this.key("parameters").optional().any());
|
|
});
|
|
});
|
|
|
|
// ../eve/node_modules/jwk-to-pem/src/asn1/public-key-info.js
|
|
var require_public_key_info = __commonJS((exports, module) => {
|
|
var AlgorithmIdentifier = require_algorithm_identifier();
|
|
module.exports = require_asn1().define("PublicKeyInfo", function() {
|
|
this.seq().obj(this.key("algorithm").use(AlgorithmIdentifier), this.key("PublicKey").bitstr());
|
|
});
|
|
});
|
|
|
|
// ../eve/node_modules/jwk-to-pem/src/asn1/version.js
|
|
var require_version = __commonJS((exports, module) => {
|
|
module.exports = require_asn1().define("Version", function() {
|
|
this.int();
|
|
});
|
|
});
|
|
|
|
// ../eve/node_modules/jwk-to-pem/src/asn1/private-key-info.js
|
|
var require_private_key_info = __commonJS((exports, module) => {
|
|
var AlgorithmIdentifier = require_algorithm_identifier();
|
|
var Version = require_version();
|
|
module.exports = require_asn1().define("PrivateKeyInfo", function() {
|
|
this.seq().obj(this.key("version").use(Version), this.key("privateKeyAlgorithm").use(AlgorithmIdentifier), this.key("privateKey").octstr(), this.key("attributes").optional().any());
|
|
});
|
|
});
|
|
|
|
// ../eve/node_modules/jwk-to-pem/src/ec.js
|
|
var require_ec2 = __commonJS((exports, module) => {
|
|
var asn1 = require_asn1();
|
|
var Buffer2 = require_safe_buffer().Buffer;
|
|
var EC = require_elliptic().ec;
|
|
var b64ToBn = require_b64_to_bn();
|
|
var PublicKeyInfo = require_public_key_info();
|
|
var PrivateKeyInfo = require_private_key_info();
|
|
var Version = require_version();
|
|
var ECParameters = asn1.define("ECParameters", function() {
|
|
this.choice({
|
|
namedCurve: this.objid()
|
|
});
|
|
});
|
|
var ecPrivkeyVer1 = 1;
|
|
var ECPrivateKey = asn1.define("ECPrivateKey", function() {
|
|
this.seq().obj(this.key("version").use(Version), this.key("privateKey").octstr(), this.key("parameters").explicit(0).optional().any(), this.key("publicKey").explicit(1).optional().bitstr());
|
|
});
|
|
var curves = {
|
|
"P-256": "p256",
|
|
"P-384": "p384",
|
|
"P-521": "p521"
|
|
};
|
|
var oids = {
|
|
"P-256": [1, 2, 840, 10045, 3, 1, 7],
|
|
"P-384": [1, 3, 132, 0, 34],
|
|
"P-521": [1, 3, 132, 0, 35]
|
|
};
|
|
var parameters = {};
|
|
var algorithms = {};
|
|
Object.keys(oids).forEach(function(crv) {
|
|
parameters[crv] = ECParameters.encode({
|
|
type: "namedCurve",
|
|
value: oids[crv]
|
|
}, "der");
|
|
algorithms[crv] = {
|
|
algorithm: [1, 2, 840, 10045, 2, 1],
|
|
parameters: parameters[crv]
|
|
};
|
|
});
|
|
oids = null;
|
|
function ecJwkToBuffer(jwk, opts) {
|
|
if (typeof jwk.crv !== "string") {
|
|
throw new TypeError('Expected "jwk.crv" to be a String');
|
|
}
|
|
var hasD = typeof jwk.d === "string";
|
|
var xyTypes = hasD ? ["undefined", "string"] : ["string"];
|
|
if (xyTypes.indexOf(typeof jwk.x) === -1) {
|
|
throw new TypeError('Expected "jwk.x" to be a String');
|
|
}
|
|
if (xyTypes.indexOf(typeof jwk.y) === -1) {
|
|
throw new TypeError('Expected "jwk.y" to be a String');
|
|
}
|
|
if (opts.private && !hasD) {
|
|
throw new TypeError('Expected "jwk.d" to be a String');
|
|
}
|
|
var curveName = curves[jwk.crv];
|
|
if (!curveName) {
|
|
throw new Error('Unsupported curve "' + jwk.crv + '"');
|
|
}
|
|
var curve = new EC(curveName);
|
|
var key = {};
|
|
var hasPub = jwk.x && jwk.y;
|
|
if (hasPub) {
|
|
key.pub = {
|
|
x: b64ToBn(jwk.x, false),
|
|
y: b64ToBn(jwk.y, false)
|
|
};
|
|
}
|
|
if (opts.private || !hasPub) {
|
|
key.priv = b64ToBn(jwk.d, true);
|
|
}
|
|
key = curve.keyPair(key);
|
|
var keyValidation = key.validate();
|
|
if (!keyValidation.result) {
|
|
throw new Error('Invalid key for curve: "' + keyValidation.reason + '"');
|
|
}
|
|
var result = keyToPem(jwk.crv, key, opts);
|
|
return result;
|
|
}
|
|
function keyToPem(crv, key, opts) {
|
|
var compact = false;
|
|
var publicKey = key.getPublic(compact, "hex");
|
|
publicKey = Buffer2.from(publicKey, "hex");
|
|
publicKey = {
|
|
unused: 0,
|
|
data: publicKey
|
|
};
|
|
var result;
|
|
if (opts.private) {
|
|
var privateKey = key.getPrivate("hex");
|
|
privateKey = Buffer2.from(privateKey, "hex");
|
|
result = PrivateKeyInfo.encode({
|
|
version: 0,
|
|
privateKeyAlgorithm: algorithms[crv],
|
|
privateKey: ECPrivateKey.encode({
|
|
version: ecPrivkeyVer1,
|
|
privateKey,
|
|
parameters: parameters[crv],
|
|
publicKey
|
|
}, "der")
|
|
}, "pem", {
|
|
label: "PRIVATE KEY"
|
|
});
|
|
privateKey.fill(0);
|
|
} else {
|
|
result = PublicKeyInfo.encode({
|
|
algorithm: algorithms[crv],
|
|
PublicKey: publicKey
|
|
}, "pem", {
|
|
label: "PUBLIC KEY"
|
|
});
|
|
}
|
|
if (result.slice(-1) !== `
|
|
`) {
|
|
result += `
|
|
`;
|
|
}
|
|
return result;
|
|
}
|
|
module.exports = ecJwkToBuffer;
|
|
});
|
|
|
|
// ../eve/node_modules/jwk-to-pem/src/rsa.js
|
|
var require_rsa = __commonJS((exports, module) => {
|
|
var asn1 = require_asn1();
|
|
var b64ToBn = require_b64_to_bn();
|
|
var PublicKeyInfo = require_public_key_info();
|
|
var PrivateKeyInfo = require_private_key_info();
|
|
var Version = require_version();
|
|
var RSAPrivateKey = asn1.define("RSAPrivateKey", function() {
|
|
this.seq().obj(this.key("version").use(Version), 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());
|
|
});
|
|
var RSAPublicKey = asn1.define("RSAPublicKey", function() {
|
|
this.seq().obj(this.key("modulus").int(), this.key("publicExponent").int());
|
|
});
|
|
var algorithm = {
|
|
algorithm: [1, 2, 840, 113549, 1, 1, 1],
|
|
parameters: [5, 0]
|
|
};
|
|
function rsaJwkToBuffer(jwk, opts) {
|
|
if (typeof jwk.e !== "string") {
|
|
throw new TypeError('Expected "jwk.e" to be a String');
|
|
}
|
|
if (typeof jwk.n !== "string") {
|
|
throw new TypeError('Expected "jwk.n" to be a String');
|
|
}
|
|
if (opts.private) {
|
|
if (typeof jwk.d !== "string") {
|
|
throw new TypeError('Expected "jwk.d" to be a String');
|
|
}
|
|
if (typeof jwk.p !== "string") {
|
|
throw new TypeError('Expected "jwk.p" to be a String');
|
|
}
|
|
if (typeof jwk.q !== "string") {
|
|
throw new TypeError('Expected "jwk.q" to be a String');
|
|
}
|
|
if (typeof jwk.dp !== "string") {
|
|
throw new TypeError('Expected "jwk.dp" to be a String');
|
|
}
|
|
if (typeof jwk.dq !== "string") {
|
|
throw new TypeError('Expected "jwk.dq" to be a String');
|
|
}
|
|
if (typeof jwk.qi !== "string") {
|
|
throw new TypeError('Expected "jwk.qi" to be a String');
|
|
}
|
|
}
|
|
var pem;
|
|
if (opts.private) {
|
|
pem = PrivateKeyInfo.encode({
|
|
version: 0,
|
|
privateKeyAlgorithm: algorithm,
|
|
privateKey: RSAPrivateKey.encode({
|
|
version: 0,
|
|
modulus: b64ToBn(jwk.n, false),
|
|
publicExponent: b64ToBn(jwk.e, false),
|
|
privateExponent: b64ToBn(jwk.d, true),
|
|
prime1: b64ToBn(jwk.p, true),
|
|
prime2: b64ToBn(jwk.q, true),
|
|
exponent1: b64ToBn(jwk.dp, true),
|
|
exponent2: b64ToBn(jwk.dq, true),
|
|
coefficient: b64ToBn(jwk.qi, true)
|
|
}, "der")
|
|
}, "pem", {
|
|
label: "PRIVATE KEY"
|
|
});
|
|
} else {
|
|
pem = PublicKeyInfo.encode({
|
|
algorithm,
|
|
PublicKey: {
|
|
unused: 0,
|
|
data: RSAPublicKey.encode({
|
|
modulus: b64ToBn(jwk.n, false),
|
|
publicExponent: b64ToBn(jwk.e, false)
|
|
}, "der")
|
|
}
|
|
}, "pem", {
|
|
label: "PUBLIC KEY"
|
|
});
|
|
}
|
|
if (pem.slice(-1) !== `
|
|
`) {
|
|
pem += `
|
|
`;
|
|
}
|
|
return pem;
|
|
}
|
|
module.exports = rsaJwkToBuffer;
|
|
});
|
|
|
|
// ../eve/node_modules/jwk-to-pem/src/jwk-to-pem.js
|
|
var require_jwk_to_pem = __commonJS((exports, module) => {
|
|
var ec = require_ec2();
|
|
var rsa = require_rsa();
|
|
function jwkToBuffer(jwk, opts) {
|
|
if (typeof jwk !== "object" || jwk === null) {
|
|
throw new TypeError('Expected "jwk" to be an Object');
|
|
}
|
|
var kty = jwk.kty;
|
|
if (typeof kty !== "string") {
|
|
throw new TypeError('Expected "jwk.kty" to be a String');
|
|
}
|
|
opts = opts || {};
|
|
opts.private = opts.private === true;
|
|
switch (kty) {
|
|
case "EC": {
|
|
return ec(jwk, opts);
|
|
}
|
|
case "RSA": {
|
|
return rsa(jwk, opts);
|
|
}
|
|
default: {
|
|
throw new Error('Unsupported key type "' + kty + '"');
|
|
}
|
|
}
|
|
}
|
|
module.exports = jwkToBuffer;
|
|
});
|
|
|
|
// ../util/node_modules/stream-chain/src/defs.js
|
|
var require_defs = __commonJS((exports, module) => {
|
|
var none = Symbol.for("object-stream.none");
|
|
var stop = Symbol.for("object-stream.stop");
|
|
var finalSymbol = Symbol.for("object-stream.final");
|
|
var manySymbol = Symbol.for("object-stream.many");
|
|
var flushSymbol = Symbol.for("object-stream.flush");
|
|
var fListSymbol = Symbol.for("object-stream.fList");
|
|
var finalValue = (value) => ({ [finalSymbol]: 1, value });
|
|
var many = (values) => ({ [manySymbol]: 1, values });
|
|
var isFinalValue = (o) => o && o[finalSymbol] === 1;
|
|
var isMany = (o) => o && o[manySymbol] === 1;
|
|
var isFlushable = (o) => o && o[flushSymbol] === 1;
|
|
var isFunctionList = (o) => o && o[fListSymbol] === 1;
|
|
var getFinalValue = (o) => o.value;
|
|
var getManyValues = (o) => o.values;
|
|
var getFunctionList = (o) => o.fList;
|
|
var flushable = (write, final2 = null) => {
|
|
const fn = final2 ? (value) => value === none ? final2() : write(value) : write;
|
|
fn[flushSymbol] = 1;
|
|
return fn;
|
|
};
|
|
var setFunctionList = (o, fns) => {
|
|
o.fList = fns;
|
|
o[fListSymbol] = 1;
|
|
return o;
|
|
};
|
|
var clearFunctionList = (o) => {
|
|
delete o.fList;
|
|
delete o[fListSymbol];
|
|
return o;
|
|
};
|
|
|
|
class Stop extends Error {
|
|
}
|
|
var toMany = (value) => value === none ? many([]) : value && value[manySymbol] === 1 ? value : many([value]);
|
|
var normalizeMany = (o) => {
|
|
if (o?.[manySymbol] === 1) {
|
|
switch (o.values.length) {
|
|
case 0:
|
|
return none;
|
|
case 1:
|
|
return o.values[0];
|
|
}
|
|
}
|
|
return o;
|
|
};
|
|
var combineMany = (a, b) => {
|
|
const values = a === none ? [] : a?.[manySymbol] === 1 ? a.values.slice() : [a];
|
|
if (b === none) {} else if (b?.[manySymbol] === 1) {
|
|
values.push(...b.values);
|
|
} else {
|
|
values.push(b);
|
|
}
|
|
return many(values);
|
|
};
|
|
var combineManyMut = (a, b) => {
|
|
const values = a === none ? [] : a?.[manySymbol] === 1 ? a.values : [a];
|
|
if (b === none) {} else if (b?.[manySymbol] === 1) {
|
|
values.push(...b.values);
|
|
} else {
|
|
values.push(b);
|
|
}
|
|
return many(values);
|
|
};
|
|
var final = finalValue;
|
|
exports.none = none;
|
|
exports.stop = stop;
|
|
exports.Stop = Stop;
|
|
exports.finalSymbol = finalSymbol;
|
|
exports.finalValue = finalValue;
|
|
exports.final = final;
|
|
exports.isFinalValue = isFinalValue;
|
|
exports.getFinalValue = getFinalValue;
|
|
exports.manySymbol = manySymbol;
|
|
exports.many = many;
|
|
exports.isMany = isMany;
|
|
exports.getManyValues = getManyValues;
|
|
exports.getFunctionList = getFunctionList;
|
|
exports.flushSymbol = flushSymbol;
|
|
exports.flushable = flushable;
|
|
exports.isFlushable = isFlushable;
|
|
exports.fListSymbol = fListSymbol;
|
|
exports.isFunctionList = isFunctionList;
|
|
exports.getFunctionList = getFunctionList;
|
|
exports.setFunctionList = setFunctionList;
|
|
exports.clearFunctionList = clearFunctionList;
|
|
exports.toMany = toMany;
|
|
exports.normalizeMany = normalizeMany;
|
|
exports.combineMany = combineMany;
|
|
exports.combineManyMut = combineManyMut;
|
|
});
|
|
|
|
// ../util/node_modules/stream-chain/src/gen.js
|
|
var require_gen = __commonJS((exports, module) => {
|
|
var defs = require_defs();
|
|
var next = async function* (value, fns, index2) {
|
|
for (let i = index2;i <= fns.length; ++i) {
|
|
if (value && typeof value.then == "function") {
|
|
value = await value;
|
|
}
|
|
if (value === defs.none)
|
|
break;
|
|
if (value === defs.stop)
|
|
throw new defs.Stop;
|
|
if (defs.isFinalValue(value)) {
|
|
yield defs.getFinalValue(value);
|
|
break;
|
|
}
|
|
if (defs.isMany(value)) {
|
|
const values = defs.getManyValues(value);
|
|
if (i == fns.length) {
|
|
yield* values;
|
|
} else {
|
|
for (let j = 0;j < values.length; ++j) {
|
|
yield* next(values[j], fns, i);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
if (value && typeof value.next == "function") {
|
|
for (;; ) {
|
|
let data = value.next();
|
|
if (data && typeof data.then == "function") {
|
|
data = await data;
|
|
}
|
|
if (data.done)
|
|
break;
|
|
if (i == fns.length) {
|
|
yield data.value;
|
|
} else {
|
|
yield* next(data.value, fns, i);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
if (i == fns.length) {
|
|
yield value;
|
|
break;
|
|
}
|
|
const f = fns[i];
|
|
value = f(value);
|
|
}
|
|
};
|
|
var gen = (...fns) => {
|
|
fns = fns.filter((fn) => fn).flat(Infinity).map((fn) => defs.isFunctionList(fn) ? defs.getFunctionList(fn) : fn).flat(Infinity);
|
|
if (!fns.length) {
|
|
fns = [(x) => x];
|
|
}
|
|
let flushed = false;
|
|
let g = async function* (value) {
|
|
if (flushed)
|
|
throw Error("Call to a flushed pipe.");
|
|
if (value !== defs.none) {
|
|
yield* next(value, fns, 0);
|
|
} else {
|
|
flushed = true;
|
|
for (let i = 0;i < fns.length; ++i) {
|
|
const f = fns[i];
|
|
if (defs.isFlushable(f)) {
|
|
yield* next(f(defs.none), fns, i + 1);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
const needToFlush = fns.some((fn) => defs.isFlushable(fn));
|
|
if (needToFlush)
|
|
g = defs.flushable(g);
|
|
return defs.setFunctionList(g, fns);
|
|
};
|
|
module.exports = gen;
|
|
module.exports.next = next;
|
|
});
|
|
|
|
// ../util/node_modules/stream-chain/src/asStream.js
|
|
var require_asStream = __commonJS((exports, module) => {
|
|
var { Duplex } = __require("stream");
|
|
var defs = require_defs();
|
|
var asStream = (fn, options2) => {
|
|
if (typeof fn != "function")
|
|
throw TypeError("Only a function is accepted as the first argument");
|
|
let paused = Promise.resolve(), resolvePaused = null;
|
|
const queue = [];
|
|
const resume = () => {
|
|
if (!resolvePaused)
|
|
return;
|
|
resolvePaused();
|
|
resolvePaused = null;
|
|
paused = Promise.resolve();
|
|
};
|
|
const pause = () => {
|
|
if (resolvePaused)
|
|
return;
|
|
paused = new Promise((resolve) => resolvePaused = resolve);
|
|
};
|
|
let stream = null;
|
|
const pushResults = (values) => {
|
|
if (values && typeof values.next == "function") {
|
|
queue.push(values);
|
|
return;
|
|
}
|
|
queue.push(values[Symbol.iterator]());
|
|
};
|
|
const pump = async () => {
|
|
while (queue.length) {
|
|
await paused;
|
|
const gen = queue[queue.length - 1];
|
|
let result = gen.next();
|
|
if (result && typeof result.then == "function") {
|
|
result = await result;
|
|
}
|
|
if (result.done) {
|
|
queue.pop();
|
|
continue;
|
|
}
|
|
let value = result.value;
|
|
if (value && typeof value.then == "function") {
|
|
value = await value;
|
|
}
|
|
await sanitize(value);
|
|
}
|
|
};
|
|
const sanitize = async (value) => {
|
|
if (value === undefined || value === null || value === defs.none)
|
|
return;
|
|
if (value === defs.stop)
|
|
throw new defs.Stop;
|
|
if (defs.isMany(value)) {
|
|
pushResults(defs.getManyValues(value));
|
|
return pump();
|
|
}
|
|
if (defs.isFinalValue(value)) {
|
|
value = defs.getFinalValue(value);
|
|
return processValue(value);
|
|
}
|
|
if (!stream.push(value)) {
|
|
pause();
|
|
}
|
|
};
|
|
const processChunk = async (chunk, encoding) => {
|
|
try {
|
|
const value = fn(chunk, encoding);
|
|
await processValue(value);
|
|
} catch (error) {
|
|
if (error instanceof defs.Stop) {
|
|
stream.push(null);
|
|
stream.destroy();
|
|
return;
|
|
}
|
|
throw error;
|
|
}
|
|
};
|
|
const processValue = async (value) => {
|
|
if (value && typeof value.then == "function") {
|
|
return value.then((value2) => processValue(value2));
|
|
}
|
|
if (value && typeof value.next == "function") {
|
|
pushResults(value);
|
|
return pump();
|
|
}
|
|
return sanitize(value);
|
|
};
|
|
stream = new Duplex(Object.assign({ writableObjectMode: true, readableObjectMode: true }, options2, {
|
|
write(chunk, encoding, callback) {
|
|
processChunk(chunk, encoding).then(() => callback(null), (error) => callback(error));
|
|
},
|
|
final(callback) {
|
|
if (!defs.isFlushable(fn)) {
|
|
stream.push(null);
|
|
callback(null);
|
|
return;
|
|
}
|
|
processChunk(defs.none, null).then(() => (stream.push(null), callback(null)), (error) => callback(error));
|
|
},
|
|
read() {
|
|
resume();
|
|
}
|
|
}));
|
|
return stream;
|
|
};
|
|
module.exports = asStream;
|
|
});
|
|
|
|
// ../util/node_modules/stream-chain/src/index.js
|
|
var require_src = __commonJS((exports, module) => {
|
|
var { Readable, Writable, Duplex } = __require("stream");
|
|
var defs = require_defs();
|
|
var gen = require_gen();
|
|
var asStream = require_asStream();
|
|
var isReadableNodeStream = (obj) => obj && typeof obj.pipe === "function" && typeof obj.on === "function" && (!obj._writableState || (typeof obj._readableState === "object" ? obj._readableState.readable : null) !== false) && (!obj._writableState || obj._readableState);
|
|
var isWritableNodeStream = (obj) => obj && typeof obj.write === "function" && typeof obj.on === "function" && (!obj._readableState || (typeof obj._writableState === "object" ? obj._writableState.writable : null) !== false);
|
|
var isDuplexNodeStream = (obj) => obj && typeof obj.pipe === "function" && obj._readableState && typeof obj.on === "function" && typeof obj.write === "function";
|
|
var isReadableWebStream = (obj) => obj && globalThis.ReadableStream && obj instanceof globalThis.ReadableStream;
|
|
var isWritableWebStream = (obj) => obj && globalThis.WritableStream && obj instanceof globalThis.WritableStream;
|
|
var isDuplexWebStream = (obj) => obj && globalThis.ReadableStream && obj.readable instanceof globalThis.ReadableStream && globalThis.WritableStream && obj.writable instanceof globalThis.WritableStream;
|
|
var groupFunctions = (output, fn, index2, fns) => {
|
|
if (isDuplexNodeStream(fn) || !index2 && isReadableNodeStream(fn) || index2 === fns.length - 1 && isWritableNodeStream(fn)) {
|
|
output.push(fn);
|
|
return output;
|
|
}
|
|
if (isDuplexWebStream(fn)) {
|
|
output.push(Duplex.fromWeb(fn, { objectMode: true }));
|
|
return output;
|
|
}
|
|
if (!index2 && isReadableWebStream(fn)) {
|
|
output.push(Readable.fromWeb(fn, { objectMode: true }));
|
|
return output;
|
|
}
|
|
if (index2 === fns.length - 1 && isWritableWebStream(fn)) {
|
|
output.push(Writable.fromWeb(fn, { objectMode: true }));
|
|
return output;
|
|
}
|
|
if (typeof fn != "function")
|
|
throw TypeError("Item #" + index2 + " is not a proper stream, nor a function.");
|
|
if (!output.length)
|
|
output.push([]);
|
|
const last = output[output.length - 1];
|
|
if (Array.isArray(last)) {
|
|
last.push(fn);
|
|
} else {
|
|
output.push([fn]);
|
|
}
|
|
return output;
|
|
};
|
|
var produceStreams = (item) => {
|
|
if (Array.isArray(item)) {
|
|
if (!item.length)
|
|
return null;
|
|
if (item.length == 1)
|
|
return item[0] && chain.asStream(item[0]);
|
|
return chain.asStream(chain.gen(...item));
|
|
}
|
|
return item;
|
|
};
|
|
var wrapFunctions = (fn, index2, fns) => {
|
|
if (isDuplexNodeStream(fn) || !index2 && isReadableNodeStream(fn) || index2 === fns.length - 1 && isWritableNodeStream(fn)) {
|
|
return fn;
|
|
}
|
|
if (isDuplexWebStream(fn)) {
|
|
return Duplex.fromWeb(fn, { objectMode: true });
|
|
}
|
|
if (!index2 && isReadableWebStream(fn)) {
|
|
return Readable.fromWeb(fn, { objectMode: true });
|
|
}
|
|
if (index2 === fns.length - 1 && isWritableWebStream(fn)) {
|
|
return Writable.fromWeb(fn, { objectMode: true });
|
|
}
|
|
if (typeof fn == "function")
|
|
return chain.asStream(fn);
|
|
throw TypeError("Item #" + index2 + " is not a proper stream, nor a function.");
|
|
};
|
|
var write = (input, chunk, encoding, callback) => {
|
|
let error = null;
|
|
try {
|
|
input.write(chunk, encoding, (e) => callback(e || error));
|
|
} catch (e) {
|
|
error = e;
|
|
}
|
|
};
|
|
var final = (input, callback) => {
|
|
let error = null;
|
|
try {
|
|
input.end(null, null, (e) => callback(e || error));
|
|
} catch (e) {
|
|
error = e;
|
|
}
|
|
};
|
|
var read = (output) => {
|
|
output.resume();
|
|
};
|
|
var chain = (fns, options2) => {
|
|
if (!Array.isArray(fns) || !fns.length) {
|
|
throw TypeError("Chain's first argument should be a non-empty array.");
|
|
}
|
|
fns = fns.flat(Infinity).filter((fn) => fn);
|
|
const streams = (options2 && options2.noGrouping ? fns.map(wrapFunctions) : fns.map((fn) => defs.isFunctionList(fn) ? defs.getFunctionList(fn) : fn).flat(Infinity).reduce(groupFunctions, []).map(produceStreams)).filter((s) => s), input = streams[0], output = streams.reduce((output2, item) => output2 && output2.pipe(item) || item);
|
|
let stream = null;
|
|
let writeMethod = (chunk, encoding, callback) => write(input, chunk, encoding, callback), finalMethod = (callback) => final(input, callback), readMethod = () => read(output);
|
|
if (!isWritableNodeStream(input)) {
|
|
writeMethod = (_1, _2, callback) => callback(null);
|
|
finalMethod = (callback) => callback(null);
|
|
input.on("end", () => stream.end());
|
|
}
|
|
if (isReadableNodeStream(output)) {
|
|
output.on("data", (chunk) => !stream.push(chunk) && output.pause());
|
|
output.on("end", () => stream.push(null));
|
|
} else {
|
|
readMethod = () => {};
|
|
output.on("finish", () => stream.push(null));
|
|
}
|
|
stream = new Duplex(Object.assign({ writableObjectMode: true, readableObjectMode: true }, options2, {
|
|
readable: isReadableNodeStream(output),
|
|
writable: isWritableNodeStream(input),
|
|
write: writeMethod,
|
|
final: finalMethod,
|
|
read: readMethod
|
|
}));
|
|
stream.streams = streams;
|
|
stream.input = input;
|
|
stream.output = output;
|
|
if (!isReadableNodeStream(output)) {
|
|
stream.resume();
|
|
}
|
|
if (!options2 || !options2.skipEvents) {
|
|
streams.forEach((item) => item.on("error", (error) => stream.emit("error", error)));
|
|
}
|
|
return stream;
|
|
};
|
|
var dataSource = (fn) => {
|
|
if (typeof fn == "function")
|
|
return fn;
|
|
if (fn) {
|
|
if (typeof fn[Symbol.asyncIterator] == "function")
|
|
return fn[Symbol.asyncIterator].bind(fn);
|
|
if (typeof fn[Symbol.iterator] == "function")
|
|
return fn[Symbol.iterator].bind(fn);
|
|
}
|
|
throw new TypeError("The argument should be a function or an iterable object.");
|
|
};
|
|
module.exports = chain;
|
|
module.exports.none = defs.none;
|
|
module.exports.stop = defs.stop;
|
|
module.exports.Stop = defs.Stop;
|
|
module.exports.finalSymbol = defs.finalSymbol;
|
|
module.exports.finalValue = defs.finalValue;
|
|
module.exports.final = defs.final;
|
|
module.exports.isFinalValue = defs.isFinalValue;
|
|
module.exports.getFinalValue = defs.getFinalValue;
|
|
module.exports.manySymbol = defs.manySymbol;
|
|
module.exports.many = defs.many;
|
|
module.exports.isMany = defs.isMany;
|
|
module.exports.getManyValues = defs.getManyValues;
|
|
module.exports.getFunctionList = defs.getFunctionList;
|
|
module.exports.flushSymbol = defs.flushSymbol;
|
|
module.exports.flushable = defs.flushable;
|
|
module.exports.isFlushable = defs.isFlushable;
|
|
module.exports.fListSymbol = defs.fListSymbol;
|
|
module.exports.isFunctionList = defs.isFunctionList;
|
|
module.exports.getFunctionList = defs.getFunctionList;
|
|
module.exports.setFunctionList = defs.setFunctionList;
|
|
module.exports.clearFunctionList = defs.clearFunctionList;
|
|
module.exports.toMany = defs.toMany;
|
|
module.exports.normalizeMany = defs.normalizeMany;
|
|
module.exports.combineMany = defs.combineMany;
|
|
module.exports.combineManyMut = defs.combineManyMut;
|
|
module.exports.chain = chain;
|
|
module.exports.chainUnchecked = chain;
|
|
module.exports.gen = gen;
|
|
module.exports.asStream = asStream;
|
|
module.exports.dataSource = dataSource;
|
|
});
|
|
|
|
// ../util/node_modules/stream-json/utils/Utf8Stream.js
|
|
var require_Utf8Stream = __commonJS((exports, module) => {
|
|
var { Transform } = __require("stream");
|
|
var { StringDecoder } = __require("string_decoder");
|
|
|
|
class Utf8Stream extends Transform {
|
|
constructor(options2) {
|
|
super(Object.assign({}, options2, { writableObjectMode: false }));
|
|
this._buffer = "";
|
|
}
|
|
_transform(chunk, encoding, callback) {
|
|
if (typeof chunk == "string") {
|
|
this._transform = this._transformString;
|
|
} else {
|
|
this._stringDecoder = new StringDecoder;
|
|
this._transform = this._transformBuffer;
|
|
}
|
|
this._transform(chunk, encoding, callback);
|
|
}
|
|
_transformBuffer(chunk, _, callback) {
|
|
this._buffer += this._stringDecoder.write(chunk);
|
|
this._processBuffer(callback);
|
|
}
|
|
_transformString(chunk, _, callback) {
|
|
this._buffer += chunk.toString();
|
|
this._processBuffer(callback);
|
|
}
|
|
_processBuffer(callback) {
|
|
if (this._buffer) {
|
|
this.push(this._buffer, "utf8");
|
|
this._buffer = "";
|
|
}
|
|
callback(null);
|
|
}
|
|
_flushInput() {
|
|
if (this._stringDecoder) {
|
|
this._buffer += this._stringDecoder.end();
|
|
}
|
|
}
|
|
_flush(callback) {
|
|
this._flushInput();
|
|
this._processBuffer(callback);
|
|
}
|
|
}
|
|
module.exports = Utf8Stream;
|
|
});
|
|
|
|
// ../util/node_modules/stream-json/Parser.js
|
|
var require_Parser = __commonJS((exports, module) => {
|
|
var Utf8Stream = require_Utf8Stream();
|
|
var patterns = {
|
|
value1: /^(?:[\"\{\[\]\-\d]|true\b|false\b|null\b|\s{1,256})/,
|
|
string: /^(?:[^\x00-\x1f\"\\]{1,256}|\\[bfnrt\"\\\/]|\\u[\da-fA-F]{4}|\")/,
|
|
key1: /^(?:[\"\}]|\s{1,256})/,
|
|
colon: /^(?:\:|\s{1,256})/,
|
|
comma: /^(?:[\,\]\}]|\s{1,256})/,
|
|
ws: /^\s{1,256}/,
|
|
numberStart: /^\d/,
|
|
numberDigit: /^\d{0,256}/,
|
|
numberFraction: /^[\.eE]/,
|
|
numberExponent: /^[eE]/,
|
|
numberExpSign: /^[-+]/
|
|
};
|
|
var MAX_PATTERN_SIZE = 16;
|
|
var noSticky = true;
|
|
try {
|
|
new RegExp(".", "y");
|
|
noSticky = false;
|
|
} catch (e) {}
|
|
!noSticky && Object.keys(patterns).forEach((key) => {
|
|
let src = patterns[key].source.slice(1);
|
|
if (src.slice(0, 3) === "(?:" && src.slice(-1) === ")") {
|
|
src = src.slice(3, -1);
|
|
}
|
|
patterns[key] = new RegExp(src, "y");
|
|
});
|
|
patterns.numberFracStart = patterns.numberExpStart = patterns.numberStart;
|
|
patterns.numberFracDigit = patterns.numberExpDigit = patterns.numberDigit;
|
|
var values = { true: true, false: false, null: null };
|
|
var expected = { object: "objectStop", array: "arrayStop", "": "done" };
|
|
var fromHex = (s) => String.fromCharCode(parseInt(s.slice(2), 16));
|
|
var codes = { b: "\b", f: "\f", n: `
|
|
`, r: "\r", t: "\t", '"': '"', "\\": "\\", "/": "/" };
|
|
|
|
class Parser extends Utf8Stream {
|
|
static make(options2) {
|
|
return new Parser(options2);
|
|
}
|
|
constructor(options2) {
|
|
super(Object.assign({}, options2, { readableObjectMode: true }));
|
|
this._packKeys = this._packStrings = this._packNumbers = this._streamKeys = this._streamStrings = this._streamNumbers = true;
|
|
if (options2) {
|
|
"packValues" in options2 && (this._packKeys = this._packStrings = this._packNumbers = options2.packValues);
|
|
"packKeys" in options2 && (this._packKeys = options2.packKeys);
|
|
"packStrings" in options2 && (this._packStrings = options2.packStrings);
|
|
"packNumbers" in options2 && (this._packNumbers = options2.packNumbers);
|
|
"streamValues" in options2 && (this._streamKeys = this._streamStrings = this._streamNumbers = options2.streamValues);
|
|
"streamKeys" in options2 && (this._streamKeys = options2.streamKeys);
|
|
"streamStrings" in options2 && (this._streamStrings = options2.streamStrings);
|
|
"streamNumbers" in options2 && (this._streamNumbers = options2.streamNumbers);
|
|
this._jsonStreaming = options2.jsonStreaming;
|
|
}
|
|
!this._packKeys && (this._streamKeys = true);
|
|
!this._packStrings && (this._streamStrings = true);
|
|
!this._packNumbers && (this._streamNumbers = true);
|
|
this._done = false;
|
|
this._expect = this._jsonStreaming ? "done" : "value";
|
|
this._stack = [];
|
|
this._parent = "";
|
|
this._open_number = false;
|
|
this._accumulator = "";
|
|
}
|
|
_flush(callback) {
|
|
this._done = true;
|
|
super._flush((error) => {
|
|
if (error)
|
|
return callback(error);
|
|
if (this._open_number) {
|
|
if (this._streamNumbers) {
|
|
this.push({ name: "endNumber" });
|
|
}
|
|
this._open_number = false;
|
|
if (this._packNumbers) {
|
|
this.push({ name: "numberValue", value: this._accumulator });
|
|
this._accumulator = "";
|
|
}
|
|
}
|
|
callback(null);
|
|
});
|
|
}
|
|
_processBuffer(callback) {
|
|
let match, value, index2 = 0;
|
|
main:
|
|
for (;; ) {
|
|
switch (this._expect) {
|
|
case "value1":
|
|
case "value":
|
|
patterns.value1.lastIndex = index2;
|
|
match = patterns.value1.exec(this._buffer);
|
|
if (!match) {
|
|
if (this._done || index2 + MAX_PATTERN_SIZE < this._buffer.length) {
|
|
if (index2 < this._buffer.length)
|
|
return callback(new Error("Parser cannot parse input: expected a value"));
|
|
return callback(new Error("Parser has expected a value"));
|
|
}
|
|
break main;
|
|
}
|
|
value = match[0];
|
|
switch (value) {
|
|
case '"':
|
|
this._streamStrings && this.push({ name: "startString" });
|
|
this._expect = "string";
|
|
break;
|
|
case "{":
|
|
this.push({ name: "startObject" });
|
|
this._stack.push(this._parent);
|
|
this._parent = "object";
|
|
this._expect = "key1";
|
|
break;
|
|
case "[":
|
|
this.push({ name: "startArray" });
|
|
this._stack.push(this._parent);
|
|
this._parent = "array";
|
|
this._expect = "value1";
|
|
break;
|
|
case "]":
|
|
if (this._expect !== "value1")
|
|
return callback(new Error("Parser cannot parse input: unexpected token ']'"));
|
|
if (this._open_number) {
|
|
this._streamNumbers && this.push({ name: "endNumber" });
|
|
this._open_number = false;
|
|
if (this._packNumbers) {
|
|
this.push({ name: "numberValue", value: this._accumulator });
|
|
this._accumulator = "";
|
|
}
|
|
}
|
|
this.push({ name: "endArray" });
|
|
this._parent = this._stack.pop();
|
|
this._expect = expected[this._parent];
|
|
break;
|
|
case "-":
|
|
this._open_number = true;
|
|
if (this._streamNumbers) {
|
|
this.push({ name: "startNumber" });
|
|
this.push({ name: "numberChunk", value: "-" });
|
|
}
|
|
this._packNumbers && (this._accumulator = "-");
|
|
this._expect = "numberStart";
|
|
break;
|
|
case "0":
|
|
this._open_number = true;
|
|
if (this._streamNumbers) {
|
|
this.push({ name: "startNumber" });
|
|
this.push({ name: "numberChunk", value: "0" });
|
|
}
|
|
this._packNumbers && (this._accumulator = "0");
|
|
this._expect = "numberFraction";
|
|
break;
|
|
case "1":
|
|
case "2":
|
|
case "3":
|
|
case "4":
|
|
case "5":
|
|
case "6":
|
|
case "7":
|
|
case "8":
|
|
case "9":
|
|
this._open_number = true;
|
|
if (this._streamNumbers) {
|
|
this.push({ name: "startNumber" });
|
|
this.push({ name: "numberChunk", value });
|
|
}
|
|
this._packNumbers && (this._accumulator = value);
|
|
this._expect = "numberDigit";
|
|
break;
|
|
case "true":
|
|
case "false":
|
|
case "null":
|
|
if (this._buffer.length - index2 === value.length && !this._done)
|
|
break main;
|
|
this.push({ name: value + "Value", value: values[value] });
|
|
this._expect = expected[this._parent];
|
|
break;
|
|
}
|
|
if (noSticky) {
|
|
this._buffer = this._buffer.slice(value.length);
|
|
} else {
|
|
index2 += value.length;
|
|
}
|
|
break;
|
|
case "keyVal":
|
|
case "string":
|
|
patterns.string.lastIndex = index2;
|
|
match = patterns.string.exec(this._buffer);
|
|
if (!match) {
|
|
if (index2 < this._buffer.length && (this._done || this._buffer.length - index2 >= 6))
|
|
return callback(new Error("Parser cannot parse input: escaped characters"));
|
|
if (this._done)
|
|
return callback(new Error("Parser has expected a string value"));
|
|
break main;
|
|
}
|
|
value = match[0];
|
|
if (value === '"') {
|
|
if (this._expect === "keyVal") {
|
|
this._streamKeys && this.push({ name: "endKey" });
|
|
if (this._packKeys) {
|
|
this.push({ name: "keyValue", value: this._accumulator });
|
|
this._accumulator = "";
|
|
}
|
|
this._expect = "colon";
|
|
} else {
|
|
this._streamStrings && this.push({ name: "endString" });
|
|
if (this._packStrings) {
|
|
this.push({ name: "stringValue", value: this._accumulator });
|
|
this._accumulator = "";
|
|
}
|
|
this._expect = expected[this._parent];
|
|
}
|
|
} else if (value.length > 1 && value.charAt(0) === "\\") {
|
|
const t = value.length == 2 ? codes[value.charAt(1)] : fromHex(value);
|
|
if (this._expect === "keyVal" ? this._streamKeys : this._streamStrings) {
|
|
this.push({ name: "stringChunk", value: t });
|
|
}
|
|
if (this._expect === "keyVal" ? this._packKeys : this._packStrings) {
|
|
this._accumulator += t;
|
|
}
|
|
} else {
|
|
if (this._expect === "keyVal" ? this._streamKeys : this._streamStrings) {
|
|
this.push({ name: "stringChunk", value });
|
|
}
|
|
if (this._expect === "keyVal" ? this._packKeys : this._packStrings) {
|
|
this._accumulator += value;
|
|
}
|
|
}
|
|
if (noSticky) {
|
|
this._buffer = this._buffer.slice(value.length);
|
|
} else {
|
|
index2 += value.length;
|
|
}
|
|
break;
|
|
case "key1":
|
|
case "key":
|
|
patterns.key1.lastIndex = index2;
|
|
match = patterns.key1.exec(this._buffer);
|
|
if (!match) {
|
|
if (index2 < this._buffer.length || this._done)
|
|
return callback(new Error("Parser cannot parse input: expected an object key"));
|
|
break main;
|
|
}
|
|
value = match[0];
|
|
if (value === '"') {
|
|
this._streamKeys && this.push({ name: "startKey" });
|
|
this._expect = "keyVal";
|
|
} else if (value === "}") {
|
|
if (this._expect !== "key1")
|
|
return callback(new Error("Parser cannot parse input: unexpected token '}'"));
|
|
this.push({ name: "endObject" });
|
|
this._parent = this._stack.pop();
|
|
this._expect = expected[this._parent];
|
|
}
|
|
if (noSticky) {
|
|
this._buffer = this._buffer.slice(value.length);
|
|
} else {
|
|
index2 += value.length;
|
|
}
|
|
break;
|
|
case "colon":
|
|
patterns.colon.lastIndex = index2;
|
|
match = patterns.colon.exec(this._buffer);
|
|
if (!match) {
|
|
if (index2 < this._buffer.length || this._done)
|
|
return callback(new Error("Parser cannot parse input: expected ':'"));
|
|
break main;
|
|
}
|
|
value = match[0];
|
|
value === ":" && (this._expect = "value");
|
|
if (noSticky) {
|
|
this._buffer = this._buffer.slice(value.length);
|
|
} else {
|
|
index2 += value.length;
|
|
}
|
|
break;
|
|
case "arrayStop":
|
|
case "objectStop":
|
|
patterns.comma.lastIndex = index2;
|
|
match = patterns.comma.exec(this._buffer);
|
|
if (!match) {
|
|
if (index2 < this._buffer.length || this._done)
|
|
return callback(new Error("Parser cannot parse input: expected ','"));
|
|
break main;
|
|
}
|
|
if (this._open_number) {
|
|
this._streamNumbers && this.push({ name: "endNumber" });
|
|
this._open_number = false;
|
|
if (this._packNumbers) {
|
|
this.push({ name: "numberValue", value: this._accumulator });
|
|
this._accumulator = "";
|
|
}
|
|
}
|
|
value = match[0];
|
|
if (value === ",") {
|
|
this._expect = this._expect === "arrayStop" ? "value" : "key";
|
|
} else if (value === "}" || value === "]") {
|
|
if (value === "}" ? this._expect === "arrayStop" : this._expect !== "arrayStop") {
|
|
return callback(new Error("Parser cannot parse input: expected '" + (this._expect === "arrayStop" ? "]" : "}") + "'"));
|
|
}
|
|
this.push({ name: value === "}" ? "endObject" : "endArray" });
|
|
this._parent = this._stack.pop();
|
|
this._expect = expected[this._parent];
|
|
}
|
|
if (noSticky) {
|
|
this._buffer = this._buffer.slice(value.length);
|
|
} else {
|
|
index2 += value.length;
|
|
}
|
|
break;
|
|
case "numberStart":
|
|
patterns.numberStart.lastIndex = index2;
|
|
match = patterns.numberStart.exec(this._buffer);
|
|
if (!match) {
|
|
if (index2 < this._buffer.length || this._done)
|
|
return callback(new Error("Parser cannot parse input: expected a starting digit"));
|
|
break main;
|
|
}
|
|
value = match[0];
|
|
this._streamNumbers && this.push({ name: "numberChunk", value });
|
|
this._packNumbers && (this._accumulator += value);
|
|
this._expect = value === "0" ? "numberFraction" : "numberDigit";
|
|
if (noSticky) {
|
|
this._buffer = this._buffer.slice(value.length);
|
|
} else {
|
|
index2 += value.length;
|
|
}
|
|
break;
|
|
case "numberDigit":
|
|
patterns.numberDigit.lastIndex = index2;
|
|
match = patterns.numberDigit.exec(this._buffer);
|
|
if (!match) {
|
|
if (index2 < this._buffer.length || this._done)
|
|
return callback(new Error("Parser cannot parse input: expected a digit"));
|
|
break main;
|
|
}
|
|
value = match[0];
|
|
if (value) {
|
|
this._streamNumbers && this.push({ name: "numberChunk", value });
|
|
this._packNumbers && (this._accumulator += value);
|
|
if (noSticky) {
|
|
this._buffer = this._buffer.slice(value.length);
|
|
} else {
|
|
index2 += value.length;
|
|
}
|
|
} else {
|
|
if (index2 < this._buffer.length) {
|
|
this._expect = "numberFraction";
|
|
break;
|
|
}
|
|
if (this._done) {
|
|
this._expect = expected[this._parent];
|
|
break;
|
|
}
|
|
break main;
|
|
}
|
|
break;
|
|
case "numberFraction":
|
|
patterns.numberFraction.lastIndex = index2;
|
|
match = patterns.numberFraction.exec(this._buffer);
|
|
if (!match) {
|
|
if (index2 < this._buffer.length || this._done) {
|
|
this._expect = expected[this._parent];
|
|
break;
|
|
}
|
|
break main;
|
|
}
|
|
value = match[0];
|
|
this._streamNumbers && this.push({ name: "numberChunk", value });
|
|
this._packNumbers && (this._accumulator += value);
|
|
this._expect = value === "." ? "numberFracStart" : "numberExpSign";
|
|
if (noSticky) {
|
|
this._buffer = this._buffer.slice(value.length);
|
|
} else {
|
|
index2 += value.length;
|
|
}
|
|
break;
|
|
case "numberFracStart":
|
|
patterns.numberFracStart.lastIndex = index2;
|
|
match = patterns.numberFracStart.exec(this._buffer);
|
|
if (!match) {
|
|
if (index2 < this._buffer.length || this._done)
|
|
return callback(new Error("Parser cannot parse input: expected a fractional part of a number"));
|
|
break main;
|
|
}
|
|
value = match[0];
|
|
this._streamNumbers && this.push({ name: "numberChunk", value });
|
|
this._packNumbers && (this._accumulator += value);
|
|
this._expect = "numberFracDigit";
|
|
if (noSticky) {
|
|
this._buffer = this._buffer.slice(value.length);
|
|
} else {
|
|
index2 += value.length;
|
|
}
|
|
break;
|
|
case "numberFracDigit":
|
|
patterns.numberFracDigit.lastIndex = index2;
|
|
match = patterns.numberFracDigit.exec(this._buffer);
|
|
value = match[0];
|
|
if (value) {
|
|
this._streamNumbers && this.push({ name: "numberChunk", value });
|
|
this._packNumbers && (this._accumulator += value);
|
|
if (noSticky) {
|
|
this._buffer = this._buffer.slice(value.length);
|
|
} else {
|
|
index2 += value.length;
|
|
}
|
|
} else {
|
|
if (index2 < this._buffer.length) {
|
|
this._expect = "numberExponent";
|
|
break;
|
|
}
|
|
if (this._done) {
|
|
this._expect = expected[this._parent];
|
|
break;
|
|
}
|
|
break main;
|
|
}
|
|
break;
|
|
case "numberExponent":
|
|
patterns.numberExponent.lastIndex = index2;
|
|
match = patterns.numberExponent.exec(this._buffer);
|
|
if (!match) {
|
|
if (index2 < this._buffer.length) {
|
|
this._expect = expected[this._parent];
|
|
break;
|
|
}
|
|
if (this._done) {
|
|
this._expect = "done";
|
|
break;
|
|
}
|
|
break main;
|
|
}
|
|
value = match[0];
|
|
this._streamNumbers && this.push({ name: "numberChunk", value });
|
|
this._packNumbers && (this._accumulator += value);
|
|
this._expect = "numberExpSign";
|
|
if (noSticky) {
|
|
this._buffer = this._buffer.slice(value.length);
|
|
} else {
|
|
index2 += value.length;
|
|
}
|
|
break;
|
|
case "numberExpSign":
|
|
patterns.numberExpSign.lastIndex = index2;
|
|
match = patterns.numberExpSign.exec(this._buffer);
|
|
if (!match) {
|
|
if (index2 < this._buffer.length) {
|
|
this._expect = "numberExpStart";
|
|
break;
|
|
}
|
|
if (this._done)
|
|
return callback(new Error("Parser has expected an exponent value of a number"));
|
|
break main;
|
|
}
|
|
value = match[0];
|
|
this._streamNumbers && this.push({ name: "numberChunk", value });
|
|
this._packNumbers && (this._accumulator += value);
|
|
this._expect = "numberExpStart";
|
|
if (noSticky) {
|
|
this._buffer = this._buffer.slice(value.length);
|
|
} else {
|
|
index2 += value.length;
|
|
}
|
|
break;
|
|
case "numberExpStart":
|
|
patterns.numberExpStart.lastIndex = index2;
|
|
match = patterns.numberExpStart.exec(this._buffer);
|
|
if (!match) {
|
|
if (index2 < this._buffer.length || this._done)
|
|
return callback(new Error("Parser cannot parse input: expected an exponent part of a number"));
|
|
break main;
|
|
}
|
|
value = match[0];
|
|
this._streamNumbers && this.push({ name: "numberChunk", value });
|
|
this._packNumbers && (this._accumulator += value);
|
|
this._expect = "numberExpDigit";
|
|
if (noSticky) {
|
|
this._buffer = this._buffer.slice(value.length);
|
|
} else {
|
|
index2 += value.length;
|
|
}
|
|
break;
|
|
case "numberExpDigit":
|
|
patterns.numberExpDigit.lastIndex = index2;
|
|
match = patterns.numberExpDigit.exec(this._buffer);
|
|
value = match[0];
|
|
if (value) {
|
|
this._streamNumbers && this.push({ name: "numberChunk", value });
|
|
this._packNumbers && (this._accumulator += value);
|
|
if (noSticky) {
|
|
this._buffer = this._buffer.slice(value.length);
|
|
} else {
|
|
index2 += value.length;
|
|
}
|
|
} else {
|
|
if (index2 < this._buffer.length || this._done) {
|
|
this._expect = expected[this._parent];
|
|
break;
|
|
}
|
|
break main;
|
|
}
|
|
break;
|
|
case "done":
|
|
patterns.ws.lastIndex = index2;
|
|
match = patterns.ws.exec(this._buffer);
|
|
if (!match) {
|
|
if (index2 < this._buffer.length) {
|
|
if (this._jsonStreaming) {
|
|
this._expect = "value";
|
|
break;
|
|
}
|
|
return callback(new Error("Parser cannot parse input: unexpected characters"));
|
|
}
|
|
break main;
|
|
}
|
|
value = match[0];
|
|
if (this._open_number) {
|
|
this._streamNumbers && this.push({ name: "endNumber" });
|
|
this._open_number = false;
|
|
if (this._packNumbers) {
|
|
this.push({ name: "numberValue", value: this._accumulator });
|
|
this._accumulator = "";
|
|
}
|
|
}
|
|
if (noSticky) {
|
|
this._buffer = this._buffer.slice(value.length);
|
|
} else {
|
|
index2 += value.length;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
!noSticky && (this._buffer = this._buffer.slice(index2));
|
|
callback(null);
|
|
}
|
|
}
|
|
Parser.parser = Parser.make;
|
|
Parser.make.Constructor = Parser;
|
|
module.exports = Parser;
|
|
});
|
|
|
|
// ../util/node_modules/stream-json/utils/emit.js
|
|
var require_emit = __commonJS((exports, module) => {
|
|
var emit = (stream) => stream.on("data", (item) => stream.emit(item.name, item.value));
|
|
module.exports = emit;
|
|
});
|
|
|
|
// ../util/node_modules/stream-json/index.js
|
|
var require_stream_json = __commonJS((exports, module) => {
|
|
var Parser = require_Parser();
|
|
var emit = require_emit();
|
|
var make = (options2) => emit(new Parser(options2));
|
|
make.Parser = Parser;
|
|
make.parser = Parser.parser;
|
|
module.exports = make;
|
|
});
|
|
|
|
// ../util/node_modules/stream-json/Assembler.js
|
|
var require_Assembler = __commonJS((exports, module) => {
|
|
var EventEmitter = __require("events");
|
|
var startObject = (Ctr) => function() {
|
|
if (this.done) {
|
|
this.done = false;
|
|
} else {
|
|
this.stack.push(this.current, this.key);
|
|
}
|
|
this.current = new Ctr;
|
|
this.key = null;
|
|
};
|
|
|
|
class Assembler extends EventEmitter {
|
|
static connectTo(stream, options2) {
|
|
return new Assembler(options2).connectTo(stream);
|
|
}
|
|
constructor(options2) {
|
|
super();
|
|
this.stack = [];
|
|
this.current = this.key = null;
|
|
this.done = true;
|
|
if (options2) {
|
|
this.reviver = typeof options2.reviver == "function" && options2.reviver;
|
|
if (this.reviver) {
|
|
this.stringValue = this._saveValue = this._saveValueWithReviver;
|
|
}
|
|
if (options2.numberAsString) {
|
|
this.numberValue = this.stringValue;
|
|
}
|
|
}
|
|
}
|
|
connectTo(stream) {
|
|
stream.on("data", (chunk) => {
|
|
if (this[chunk.name]) {
|
|
this[chunk.name](chunk.value);
|
|
if (this.done)
|
|
this.emit("done", this);
|
|
}
|
|
});
|
|
return this;
|
|
}
|
|
get depth() {
|
|
return (this.stack.length >> 1) + (this.done ? 0 : 1);
|
|
}
|
|
get path() {
|
|
const path = [];
|
|
for (let i = 0;i < this.stack.length; i += 2) {
|
|
const key = this.stack[i + 1];
|
|
path.push(key === null ? this.stack[i].length : key);
|
|
}
|
|
return path;
|
|
}
|
|
dropToLevel(level) {
|
|
if (level < this.depth) {
|
|
if (level) {
|
|
const index2 = level - 1 << 1;
|
|
this.current = this.stack[index2];
|
|
this.key = this.stack[index2 + 1];
|
|
this.stack.splice(index2);
|
|
} else {
|
|
this.stack = [];
|
|
this.current = this.key = null;
|
|
this.done = true;
|
|
}
|
|
}
|
|
return this;
|
|
}
|
|
consume(chunk) {
|
|
this[chunk.name] && this[chunk.name](chunk.value);
|
|
return this;
|
|
}
|
|
keyValue(value) {
|
|
this.key = value;
|
|
}
|
|
numberValue(value) {
|
|
this._saveValue(parseFloat(value));
|
|
}
|
|
nullValue() {
|
|
this._saveValue(null);
|
|
}
|
|
trueValue() {
|
|
this._saveValue(true);
|
|
}
|
|
falseValue() {
|
|
this._saveValue(false);
|
|
}
|
|
endObject() {
|
|
if (this.stack.length) {
|
|
const value = this.current;
|
|
this.key = this.stack.pop();
|
|
this.current = this.stack.pop();
|
|
this._saveValue(value);
|
|
} else {
|
|
this.done = true;
|
|
}
|
|
}
|
|
_saveValue(value) {
|
|
if (this.done) {
|
|
this.current = value;
|
|
} else {
|
|
if (this.current instanceof Array) {
|
|
this.current.push(value);
|
|
} else {
|
|
this.current[this.key] = value;
|
|
this.key = null;
|
|
}
|
|
}
|
|
}
|
|
_saveValueWithReviver(value) {
|
|
if (this.done) {
|
|
this.current = this.reviver("", value);
|
|
} else {
|
|
if (this.current instanceof Array) {
|
|
value = this.reviver("" + this.current.length, value);
|
|
this.current.push(value);
|
|
if (value === undefined) {
|
|
delete this.current[this.current.length - 1];
|
|
}
|
|
} else {
|
|
value = this.reviver(this.key, value);
|
|
if (value !== undefined) {
|
|
this.current[this.key] = value;
|
|
}
|
|
this.key = null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Assembler.prototype.stringValue = Assembler.prototype._saveValue;
|
|
Assembler.prototype.startObject = startObject(Object);
|
|
Assembler.prototype.startArray = startObject(Array);
|
|
Assembler.prototype.endArray = Assembler.prototype.endObject;
|
|
module.exports = Assembler;
|
|
});
|
|
|
|
// ../util/node_modules/stream-json/streamers/StreamBase.js
|
|
var require_StreamBase = __commonJS((exports, module) => {
|
|
var { Transform } = __require("stream");
|
|
var Assembler = require_Assembler();
|
|
|
|
class Counter {
|
|
constructor(initialDepth) {
|
|
this.depth = initialDepth;
|
|
}
|
|
startObject() {
|
|
++this.depth;
|
|
}
|
|
endObject() {
|
|
--this.depth;
|
|
}
|
|
startArray() {
|
|
++this.depth;
|
|
}
|
|
endArray() {
|
|
--this.depth;
|
|
}
|
|
}
|
|
|
|
class StreamBase extends Transform {
|
|
constructor(options2) {
|
|
super(Object.assign({}, options2, { writableObjectMode: true, readableObjectMode: true }));
|
|
if (options2) {
|
|
this.objectFilter = options2.objectFilter;
|
|
this.includeUndecided = options2.includeUndecided;
|
|
}
|
|
if (typeof this.objectFilter != "function") {
|
|
this._filter = this._transform;
|
|
}
|
|
this._transform = this._wait || this._filter;
|
|
this._assembler = new Assembler(options2);
|
|
}
|
|
_transform(chunk, encoding, callback) {
|
|
if (this._assembler[chunk.name]) {
|
|
this._assembler[chunk.name](chunk.value);
|
|
if (this._assembler.depth === this._level) {
|
|
this._push();
|
|
}
|
|
}
|
|
callback(null);
|
|
}
|
|
_filter(chunk, encoding, callback) {
|
|
if (this._assembler[chunk.name]) {
|
|
this._assembler[chunk.name](chunk.value);
|
|
const result = this.objectFilter(this._assembler);
|
|
if (result) {
|
|
if (this._assembler.depth === this._level) {
|
|
this._push();
|
|
this._transform = this._filter;
|
|
}
|
|
this._transform = this._accept;
|
|
return callback(null);
|
|
}
|
|
if (result === false) {
|
|
this._saved_assembler = this._assembler;
|
|
this._assembler = new Counter(this._saved_assembler.depth);
|
|
this._saved_assembler.dropToLevel(this._level);
|
|
if (this._assembler.depth === this._level) {
|
|
this._assembler = this._saved_assembler;
|
|
this._transform = this._filter;
|
|
}
|
|
this._transform = this._reject;
|
|
return callback(null);
|
|
}
|
|
if (this._assembler.depth === this._level) {
|
|
this._push(!this.includeUndecided);
|
|
}
|
|
}
|
|
callback(null);
|
|
}
|
|
_accept(chunk, encoding, callback) {
|
|
if (this._assembler[chunk.name]) {
|
|
this._assembler[chunk.name](chunk.value);
|
|
if (this._assembler.depth === this._level) {
|
|
this._push();
|
|
this._transform = this._filter;
|
|
}
|
|
}
|
|
callback(null);
|
|
}
|
|
_reject(chunk, encoding, callback) {
|
|
if (this._assembler[chunk.name]) {
|
|
this._assembler[chunk.name](chunk.value);
|
|
if (this._assembler.depth === this._level) {
|
|
this._assembler = this._saved_assembler;
|
|
this._transform = this._filter;
|
|
}
|
|
}
|
|
callback(null);
|
|
}
|
|
}
|
|
module.exports = StreamBase;
|
|
});
|
|
|
|
// ../util/node_modules/stream-json/node_modules/stream-chain/index.js
|
|
var require_stream_chain = __commonJS((exports, module) => {
|
|
var { Readable, Writable, Duplex, Transform } = __require("stream");
|
|
var none = Symbol.for("object-stream.none");
|
|
var finalSymbol = Symbol.for("object-stream.final");
|
|
var manySymbol = Symbol.for("object-stream.many");
|
|
var final = (value) => ({ [finalSymbol]: value });
|
|
var many = (values) => ({ [manySymbol]: values });
|
|
var isFinal = (o) => o && typeof o == "object" && (finalSymbol in o);
|
|
var isMany = (o) => o && typeof o == "object" && (manySymbol in o);
|
|
var getFinalValue = (o) => o[finalSymbol];
|
|
var getManyValues = (o) => o[manySymbol];
|
|
var runAsyncGenerator = async (gen, stream) => {
|
|
for (;; ) {
|
|
let data = gen.next();
|
|
if (data && typeof data.then == "function") {
|
|
data = await data;
|
|
}
|
|
if (data.done)
|
|
break;
|
|
let value = data.value;
|
|
if (value && typeof value.then == "function") {
|
|
value = await value;
|
|
}
|
|
Chain.sanitize(value, stream);
|
|
}
|
|
};
|
|
var wrapFunction = (fn) => new Transform({
|
|
writableObjectMode: true,
|
|
readableObjectMode: true,
|
|
transform(chunk, encoding, callback) {
|
|
try {
|
|
const result = fn.call(this, chunk, encoding);
|
|
if (result && typeof result.then == "function") {
|
|
result.then((result2) => (Chain.sanitize(result2, this), callback(null)), (error) => callback(error));
|
|
return;
|
|
}
|
|
if (result && typeof result.next == "function") {
|
|
runAsyncGenerator(result, this).then(() => callback(null), (error) => callback(error));
|
|
return;
|
|
}
|
|
Chain.sanitize(result, this);
|
|
callback(null);
|
|
} catch (error) {
|
|
callback(error);
|
|
}
|
|
}
|
|
});
|
|
var wrapArray = (fns) => new Transform({
|
|
writableObjectMode: true,
|
|
readableObjectMode: true,
|
|
transform(chunk, encoding, callback) {
|
|
try {
|
|
let value = chunk;
|
|
for (let i = 0;i < fns.length; ++i) {
|
|
const result = fns[i].call(this, value, encoding);
|
|
if (result === Chain.none) {
|
|
callback(null);
|
|
return;
|
|
}
|
|
if (Chain.isFinal(result)) {
|
|
value = Chain.getFinalValue(result);
|
|
break;
|
|
}
|
|
value = result;
|
|
}
|
|
Chain.sanitize(value, this);
|
|
callback(null);
|
|
} catch (error) {
|
|
callback(error);
|
|
}
|
|
}
|
|
});
|
|
var isReadableNodeStream = (obj) => obj && typeof obj.pipe === "function" && typeof obj.on === "function" && (!obj._writableState || (typeof obj._readableState === "object" ? obj._readableState.readable : null) !== false) && (!obj._writableState || obj._readableState);
|
|
var isWritableNodeStream = (obj) => obj && typeof obj.write === "function" && typeof obj.on === "function" && (!obj._readableState || (typeof obj._writableState === "object" ? obj._writableState.writable : null) !== false);
|
|
var isDuplexNodeStream = (obj) => obj && typeof obj.pipe === "function" && obj._readableState && typeof obj.on === "function" && typeof obj.write === "function";
|
|
|
|
class Chain extends Duplex {
|
|
constructor(fns, options2) {
|
|
super(options2 || { writableObjectMode: true, readableObjectMode: true });
|
|
if (!(fns instanceof Array) || !fns.length) {
|
|
throw Error("Chain's argument should be a non-empty array.");
|
|
}
|
|
this.streams = fns.filter((fn) => fn).map((fn, index2, fns2) => {
|
|
if (typeof fn === "function" || fn instanceof Array)
|
|
return Chain.convertToTransform(fn);
|
|
if (isDuplexNodeStream(fn) || !index2 && isReadableNodeStream(fn) || index2 === fns2.length - 1 && isWritableNodeStream(fn)) {
|
|
return fn;
|
|
}
|
|
throw Error("Arguments should be functions, arrays or streams.");
|
|
}).filter((s) => s);
|
|
this.input = this.streams[0];
|
|
this.output = this.streams.reduce((output, stream) => output && output.pipe(stream) || stream);
|
|
if (!isWritableNodeStream(this.input)) {
|
|
this._write = (_1, _2, callback) => callback(null);
|
|
this._final = (callback) => callback(null);
|
|
this.input.on("end", () => this.end());
|
|
}
|
|
if (isReadableNodeStream(this.output)) {
|
|
this.output.on("data", (chunk) => !this.push(chunk) && this.output.pause());
|
|
this.output.on("end", () => this.push(null));
|
|
} else {
|
|
this._read = () => {};
|
|
this.resume();
|
|
this.output.on("finish", () => this.push(null));
|
|
}
|
|
if (!options2 || !options2.skipEvents) {
|
|
this.streams.forEach((stream) => stream.on("error", (error) => this.emit("error", error)));
|
|
}
|
|
}
|
|
_write(chunk, encoding, callback) {
|
|
let error = null;
|
|
try {
|
|
this.input.write(chunk, encoding, (e) => callback(e || error));
|
|
} catch (e) {
|
|
error = e;
|
|
}
|
|
}
|
|
_final(callback) {
|
|
let error = null;
|
|
try {
|
|
this.input.end(null, null, (e) => callback(e || error));
|
|
} catch (e) {
|
|
error = e;
|
|
}
|
|
}
|
|
_read() {
|
|
this.output.resume();
|
|
}
|
|
static make(fns, options2) {
|
|
return new Chain(fns, options2);
|
|
}
|
|
static sanitize(result, stream) {
|
|
if (Chain.isFinal(result)) {
|
|
result = Chain.getFinalValue(result);
|
|
} else if (Chain.isMany(result)) {
|
|
result = Chain.getManyValues(result);
|
|
}
|
|
if (result !== undefined && result !== null && result !== Chain.none) {
|
|
if (result instanceof Array) {
|
|
result.forEach((value) => value !== undefined && value !== null && stream.push(value));
|
|
} else {
|
|
stream.push(result);
|
|
}
|
|
}
|
|
}
|
|
static convertToTransform(fn) {
|
|
if (typeof fn === "function")
|
|
return wrapFunction(fn);
|
|
if (fn instanceof Array)
|
|
return fn.length ? wrapArray(fn) : null;
|
|
return null;
|
|
}
|
|
}
|
|
Chain.none = none;
|
|
Chain.final = final;
|
|
Chain.isFinal = isFinal;
|
|
Chain.getFinalValue = getFinalValue;
|
|
Chain.many = many;
|
|
Chain.isMany = isMany;
|
|
Chain.getManyValues = getManyValues;
|
|
Chain.chain = Chain.make;
|
|
Chain.make.Constructor = Chain;
|
|
module.exports = Chain;
|
|
});
|
|
|
|
// ../util/node_modules/stream-json/utils/withParser.js
|
|
var require_withParser = __commonJS((exports, module) => {
|
|
var { chain } = require_stream_chain();
|
|
var Parser = require_Parser();
|
|
var withParser = (fn, options2) => chain([new Parser(options2), fn(options2)], Object.assign({}, options2, { writableObjectMode: false, readableObjectMode: true }));
|
|
module.exports = withParser;
|
|
});
|
|
|
|
// ../util/node_modules/stream-json/streamers/StreamArray.js
|
|
var require_StreamArray = __commonJS((exports, module) => {
|
|
var StreamBase = require_StreamBase();
|
|
var withParser = require_withParser();
|
|
|
|
class StreamArray extends StreamBase {
|
|
static make(options2) {
|
|
return new StreamArray(options2);
|
|
}
|
|
static withParser(options2) {
|
|
return withParser(StreamArray.make, options2);
|
|
}
|
|
constructor(options2) {
|
|
super(options2);
|
|
this._level = 1;
|
|
this._counter = 0;
|
|
}
|
|
_wait(chunk, _, callback) {
|
|
if (chunk.name !== "startArray") {
|
|
return callback(new Error("Top-level object should be an array."));
|
|
}
|
|
this._transform = this._filter;
|
|
return this._transform(chunk, _, callback);
|
|
}
|
|
_push(discard) {
|
|
if (this._assembler.current.length) {
|
|
if (discard) {
|
|
++this._counter;
|
|
this._assembler.current.pop();
|
|
} else {
|
|
this.push({ key: this._counter++, value: this._assembler.current.pop() });
|
|
}
|
|
}
|
|
}
|
|
}
|
|
StreamArray.streamArray = StreamArray.make;
|
|
StreamArray.make.Constructor = StreamArray;
|
|
module.exports = StreamArray;
|
|
});
|
|
|
|
// ../util/node_modules/stream-json/streamers/StreamObject.js
|
|
var require_StreamObject = __commonJS((exports, module) => {
|
|
var StreamBase = require_StreamBase();
|
|
var withParser = require_withParser();
|
|
|
|
class StreamObject extends StreamBase {
|
|
static make(options2) {
|
|
return new StreamObject(options2);
|
|
}
|
|
static withParser(options2) {
|
|
return withParser(StreamObject.make, options2);
|
|
}
|
|
constructor(options2) {
|
|
super(options2);
|
|
this._level = 1;
|
|
this._lastKey = null;
|
|
}
|
|
_wait(chunk, _, callback) {
|
|
if (chunk.name !== "startObject") {
|
|
return callback(new Error("Top-level object should be an object."));
|
|
}
|
|
this._transform = this._filter;
|
|
return this._transform(chunk, _, callback);
|
|
}
|
|
_push(discard) {
|
|
if (this._lastKey === null) {
|
|
this._lastKey = this._assembler.key;
|
|
} else {
|
|
!discard && this.push({ key: this._lastKey, value: this._assembler.current[this._lastKey] });
|
|
this._assembler.current = {};
|
|
this._lastKey = null;
|
|
}
|
|
}
|
|
}
|
|
StreamObject.streamObject = StreamObject.make;
|
|
StreamObject.make.Constructor = StreamObject;
|
|
module.exports = StreamObject;
|
|
});
|
|
|
|
// ../util/node_modules/clone/clone.js
|
|
var require_clone = __commonJS((exports, module) => {
|
|
var clone = function() {
|
|
function _instanceof(obj, type) {
|
|
return type != null && obj instanceof type;
|
|
}
|
|
var nativeMap;
|
|
try {
|
|
nativeMap = Map;
|
|
} catch (_) {
|
|
nativeMap = function() {};
|
|
}
|
|
var nativeSet;
|
|
try {
|
|
nativeSet = Set;
|
|
} catch (_) {
|
|
nativeSet = function() {};
|
|
}
|
|
var nativePromise;
|
|
try {
|
|
nativePromise = Promise;
|
|
} catch (_) {
|
|
nativePromise = function() {};
|
|
}
|
|
function clone2(parent, circular, depth, prototype, includeNonEnumerable) {
|
|
if (typeof circular === "object") {
|
|
depth = circular.depth;
|
|
prototype = circular.prototype;
|
|
includeNonEnumerable = circular.includeNonEnumerable;
|
|
circular = circular.circular;
|
|
}
|
|
var allParents = [];
|
|
var allChildren = [];
|
|
var useBuffer = typeof Buffer != "undefined";
|
|
if (typeof circular == "undefined")
|
|
circular = true;
|
|
if (typeof depth == "undefined")
|
|
depth = Infinity;
|
|
function _clone(parent2, depth2) {
|
|
if (parent2 === null)
|
|
return null;
|
|
if (depth2 === 0)
|
|
return parent2;
|
|
var child;
|
|
var proto;
|
|
if (typeof parent2 != "object") {
|
|
return parent2;
|
|
}
|
|
if (_instanceof(parent2, nativeMap)) {
|
|
child = new nativeMap;
|
|
} else if (_instanceof(parent2, nativeSet)) {
|
|
child = new nativeSet;
|
|
} else if (_instanceof(parent2, nativePromise)) {
|
|
child = new nativePromise(function(resolve, reject) {
|
|
parent2.then(function(value) {
|
|
resolve(_clone(value, depth2 - 1));
|
|
}, function(err) {
|
|
reject(_clone(err, depth2 - 1));
|
|
});
|
|
});
|
|
} else if (clone2.__isArray(parent2)) {
|
|
child = [];
|
|
} else if (clone2.__isRegExp(parent2)) {
|
|
child = new RegExp(parent2.source, __getRegExpFlags(parent2));
|
|
if (parent2.lastIndex)
|
|
child.lastIndex = parent2.lastIndex;
|
|
} else if (clone2.__isDate(parent2)) {
|
|
child = new Date(parent2.getTime());
|
|
} else if (useBuffer && Buffer.isBuffer(parent2)) {
|
|
if (Buffer.allocUnsafe) {
|
|
child = Buffer.allocUnsafe(parent2.length);
|
|
} else {
|
|
child = new Buffer(parent2.length);
|
|
}
|
|
parent2.copy(child);
|
|
return child;
|
|
} else if (_instanceof(parent2, Error)) {
|
|
child = Object.create(parent2);
|
|
} else {
|
|
if (typeof prototype == "undefined") {
|
|
proto = Object.getPrototypeOf(parent2);
|
|
child = Object.create(proto);
|
|
} else {
|
|
child = Object.create(prototype);
|
|
proto = prototype;
|
|
}
|
|
}
|
|
if (circular) {
|
|
var index2 = allParents.indexOf(parent2);
|
|
if (index2 != -1) {
|
|
return allChildren[index2];
|
|
}
|
|
allParents.push(parent2);
|
|
allChildren.push(child);
|
|
}
|
|
if (_instanceof(parent2, nativeMap)) {
|
|
parent2.forEach(function(value, key) {
|
|
var keyChild = _clone(key, depth2 - 1);
|
|
var valueChild = _clone(value, depth2 - 1);
|
|
child.set(keyChild, valueChild);
|
|
});
|
|
}
|
|
if (_instanceof(parent2, nativeSet)) {
|
|
parent2.forEach(function(value) {
|
|
var entryChild = _clone(value, depth2 - 1);
|
|
child.add(entryChild);
|
|
});
|
|
}
|
|
for (var i in parent2) {
|
|
var attrs;
|
|
if (proto) {
|
|
attrs = Object.getOwnPropertyDescriptor(proto, i);
|
|
}
|
|
if (attrs && attrs.set == null) {
|
|
continue;
|
|
}
|
|
child[i] = _clone(parent2[i], depth2 - 1);
|
|
}
|
|
if (Object.getOwnPropertySymbols) {
|
|
var symbols = Object.getOwnPropertySymbols(parent2);
|
|
for (var i = 0;i < symbols.length; i++) {
|
|
var symbol = symbols[i];
|
|
var descriptor = Object.getOwnPropertyDescriptor(parent2, symbol);
|
|
if (descriptor && !descriptor.enumerable && !includeNonEnumerable) {
|
|
continue;
|
|
}
|
|
child[symbol] = _clone(parent2[symbol], depth2 - 1);
|
|
if (!descriptor.enumerable) {
|
|
Object.defineProperty(child, symbol, {
|
|
enumerable: false
|
|
});
|
|
}
|
|
}
|
|
}
|
|
if (includeNonEnumerable) {
|
|
var allPropertyNames = Object.getOwnPropertyNames(parent2);
|
|
for (var i = 0;i < allPropertyNames.length; i++) {
|
|
var propertyName = allPropertyNames[i];
|
|
var descriptor = Object.getOwnPropertyDescriptor(parent2, propertyName);
|
|
if (descriptor && descriptor.enumerable) {
|
|
continue;
|
|
}
|
|
child[propertyName] = _clone(parent2[propertyName], depth2 - 1);
|
|
Object.defineProperty(child, propertyName, {
|
|
enumerable: false
|
|
});
|
|
}
|
|
}
|
|
return child;
|
|
}
|
|
return _clone(parent, depth);
|
|
}
|
|
clone2.clonePrototype = function clonePrototype(parent) {
|
|
if (parent === null)
|
|
return null;
|
|
var c = function() {};
|
|
c.prototype = parent;
|
|
return new c;
|
|
};
|
|
function __objToStr(o) {
|
|
return Object.prototype.toString.call(o);
|
|
}
|
|
clone2.__objToStr = __objToStr;
|
|
function __isDate(o) {
|
|
return typeof o === "object" && __objToStr(o) === "[object Date]";
|
|
}
|
|
clone2.__isDate = __isDate;
|
|
function __isArray(o) {
|
|
return typeof o === "object" && __objToStr(o) === "[object Array]";
|
|
}
|
|
clone2.__isArray = __isArray;
|
|
function __isRegExp(o) {
|
|
return typeof o === "object" && __objToStr(o) === "[object RegExp]";
|
|
}
|
|
clone2.__isRegExp = __isRegExp;
|
|
function __getRegExpFlags(re) {
|
|
var flags = "";
|
|
if (re.global)
|
|
flags += "g";
|
|
if (re.ignoreCase)
|
|
flags += "i";
|
|
if (re.multiline)
|
|
flags += "m";
|
|
return flags;
|
|
}
|
|
clone2.__getRegExpFlags = __getRegExpFlags;
|
|
return clone2;
|
|
}();
|
|
if (typeof module === "object" && module.exports) {
|
|
module.exports = clone;
|
|
}
|
|
});
|
|
|
|
// ../util/node_modules/node-cache/lib/node_cache.js
|
|
var require_node_cache = __commonJS((exports, module) => {
|
|
(function() {
|
|
var EventEmitter, NodeCache, clone, splice = [].splice, boundMethodCheck = function(instance, Constructor) {
|
|
if (!(instance instanceof Constructor)) {
|
|
throw new Error("Bound instance method accessed before binding");
|
|
}
|
|
}, indexOf = [].indexOf;
|
|
clone = require_clone();
|
|
EventEmitter = __require("events").EventEmitter;
|
|
module.exports = NodeCache = function() {
|
|
|
|
class NodeCache2 extends EventEmitter {
|
|
constructor(options2 = {}) {
|
|
super();
|
|
this.get = this.get.bind(this);
|
|
this.mget = this.mget.bind(this);
|
|
this.set = this.set.bind(this);
|
|
this.mset = this.mset.bind(this);
|
|
this.del = this.del.bind(this);
|
|
this.take = this.take.bind(this);
|
|
this.ttl = this.ttl.bind(this);
|
|
this.getTtl = this.getTtl.bind(this);
|
|
this.keys = this.keys.bind(this);
|
|
this.has = this.has.bind(this);
|
|
this.getStats = this.getStats.bind(this);
|
|
this.flushAll = this.flushAll.bind(this);
|
|
this.flushStats = this.flushStats.bind(this);
|
|
this.close = this.close.bind(this);
|
|
this._checkData = this._checkData.bind(this);
|
|
this._check = this._check.bind(this);
|
|
this._isInvalidKey = this._isInvalidKey.bind(this);
|
|
this._wrap = this._wrap.bind(this);
|
|
this._getValLength = this._getValLength.bind(this);
|
|
this._error = this._error.bind(this);
|
|
this._initErrors = this._initErrors.bind(this);
|
|
this.options = options2;
|
|
this._initErrors();
|
|
this.data = {};
|
|
this.options = Object.assign({
|
|
forceString: false,
|
|
objectValueSize: 80,
|
|
promiseValueSize: 80,
|
|
arrayValueSize: 40,
|
|
stdTTL: 0,
|
|
checkperiod: 600,
|
|
useClones: true,
|
|
deleteOnExpire: true,
|
|
enableLegacyCallbacks: false,
|
|
maxKeys: -1
|
|
}, this.options);
|
|
if (this.options.enableLegacyCallbacks) {
|
|
console.warn("WARNING! node-cache legacy callback support will drop in v6.x");
|
|
["get", "mget", "set", "del", "ttl", "getTtl", "keys", "has"].forEach((methodKey) => {
|
|
var oldMethod;
|
|
oldMethod = this[methodKey];
|
|
this[methodKey] = function(...args) {
|
|
var cb, err, ref, res;
|
|
ref = args, [...args] = ref, [cb] = splice.call(args, -1);
|
|
if (typeof cb === "function") {
|
|
try {
|
|
res = oldMethod(...args);
|
|
cb(null, res);
|
|
} catch (error1) {
|
|
err = error1;
|
|
cb(err);
|
|
}
|
|
} else {
|
|
return oldMethod(...args, cb);
|
|
}
|
|
};
|
|
});
|
|
}
|
|
this.stats = {
|
|
hits: 0,
|
|
misses: 0,
|
|
keys: 0,
|
|
ksize: 0,
|
|
vsize: 0
|
|
};
|
|
this.validKeyTypes = ["string", "number"];
|
|
this._checkData();
|
|
return;
|
|
}
|
|
get(key) {
|
|
var _ret, err;
|
|
boundMethodCheck(this, NodeCache2);
|
|
if ((err = this._isInvalidKey(key)) != null) {
|
|
throw err;
|
|
}
|
|
if (this.data[key] != null && this._check(key, this.data[key])) {
|
|
this.stats.hits++;
|
|
_ret = this._unwrap(this.data[key]);
|
|
return _ret;
|
|
} else {
|
|
this.stats.misses++;
|
|
return;
|
|
}
|
|
}
|
|
mget(keys) {
|
|
var _err, err, i, key, len, oRet;
|
|
boundMethodCheck(this, NodeCache2);
|
|
if (!Array.isArray(keys)) {
|
|
_err = this._error("EKEYSTYPE");
|
|
throw _err;
|
|
}
|
|
oRet = {};
|
|
for (i = 0, len = keys.length;i < len; i++) {
|
|
key = keys[i];
|
|
if ((err = this._isInvalidKey(key)) != null) {
|
|
throw err;
|
|
}
|
|
if (this.data[key] != null && this._check(key, this.data[key])) {
|
|
this.stats.hits++;
|
|
oRet[key] = this._unwrap(this.data[key]);
|
|
} else {
|
|
this.stats.misses++;
|
|
}
|
|
}
|
|
return oRet;
|
|
}
|
|
set(key, value, ttl) {
|
|
var _err, err, existent;
|
|
boundMethodCheck(this, NodeCache2);
|
|
if (this.options.maxKeys > -1 && this.stats.keys >= this.options.maxKeys) {
|
|
_err = this._error("ECACHEFULL");
|
|
throw _err;
|
|
}
|
|
if (this.options.forceString && false === "string") {
|
|
value = JSON.stringify(value);
|
|
}
|
|
if (ttl == null) {
|
|
ttl = this.options.stdTTL;
|
|
}
|
|
if ((err = this._isInvalidKey(key)) != null) {
|
|
throw err;
|
|
}
|
|
existent = false;
|
|
if (this.data[key]) {
|
|
existent = true;
|
|
this.stats.vsize -= this._getValLength(this._unwrap(this.data[key], false));
|
|
}
|
|
this.data[key] = this._wrap(value, ttl);
|
|
this.stats.vsize += this._getValLength(value);
|
|
if (!existent) {
|
|
this.stats.ksize += this._getKeyLength(key);
|
|
this.stats.keys++;
|
|
}
|
|
this.emit("set", key, value);
|
|
return true;
|
|
}
|
|
mset(keyValueSet) {
|
|
var _err, err, i, j, key, keyValuePair, len, len1, ttl, val;
|
|
boundMethodCheck(this, NodeCache2);
|
|
if (this.options.maxKeys > -1 && this.stats.keys + keyValueSet.length >= this.options.maxKeys) {
|
|
_err = this._error("ECACHEFULL");
|
|
throw _err;
|
|
}
|
|
for (i = 0, len = keyValueSet.length;i < len; i++) {
|
|
keyValuePair = keyValueSet[i];
|
|
({ key, val, ttl } = keyValuePair);
|
|
if (ttl && typeof ttl !== "number") {
|
|
_err = this._error("ETTLTYPE");
|
|
throw _err;
|
|
}
|
|
if ((err = this._isInvalidKey(key)) != null) {
|
|
throw err;
|
|
}
|
|
}
|
|
for (j = 0, len1 = keyValueSet.length;j < len1; j++) {
|
|
keyValuePair = keyValueSet[j];
|
|
({ key, val, ttl } = keyValuePair);
|
|
this.set(key, val, ttl);
|
|
}
|
|
return true;
|
|
}
|
|
del(keys) {
|
|
var delCount, err, i, key, len, oldVal;
|
|
boundMethodCheck(this, NodeCache2);
|
|
if (!Array.isArray(keys)) {
|
|
keys = [keys];
|
|
}
|
|
delCount = 0;
|
|
for (i = 0, len = keys.length;i < len; i++) {
|
|
key = keys[i];
|
|
if ((err = this._isInvalidKey(key)) != null) {
|
|
throw err;
|
|
}
|
|
if (this.data[key] != null) {
|
|
this.stats.vsize -= this._getValLength(this._unwrap(this.data[key], false));
|
|
this.stats.ksize -= this._getKeyLength(key);
|
|
this.stats.keys--;
|
|
delCount++;
|
|
oldVal = this.data[key];
|
|
delete this.data[key];
|
|
this.emit("del", key, oldVal.v);
|
|
}
|
|
}
|
|
return delCount;
|
|
}
|
|
take(key) {
|
|
var _ret;
|
|
boundMethodCheck(this, NodeCache2);
|
|
_ret = this.get(key);
|
|
if (_ret != null) {
|
|
this.del(key);
|
|
}
|
|
return _ret;
|
|
}
|
|
ttl(key, ttl) {
|
|
var err;
|
|
boundMethodCheck(this, NodeCache2);
|
|
ttl || (ttl = this.options.stdTTL);
|
|
if (!key) {
|
|
return false;
|
|
}
|
|
if ((err = this._isInvalidKey(key)) != null) {
|
|
throw err;
|
|
}
|
|
if (this.data[key] != null && this._check(key, this.data[key])) {
|
|
if (ttl >= 0) {
|
|
this.data[key] = this._wrap(this.data[key].v, ttl, false);
|
|
} else {
|
|
this.del(key);
|
|
}
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
getTtl(key) {
|
|
var _ttl, err;
|
|
boundMethodCheck(this, NodeCache2);
|
|
if (!key) {
|
|
return;
|
|
}
|
|
if ((err = this._isInvalidKey(key)) != null) {
|
|
throw err;
|
|
}
|
|
if (this.data[key] != null && this._check(key, this.data[key])) {
|
|
_ttl = this.data[key].t;
|
|
return _ttl;
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
keys() {
|
|
var _keys;
|
|
boundMethodCheck(this, NodeCache2);
|
|
_keys = Object.keys(this.data);
|
|
return _keys;
|
|
}
|
|
has(key) {
|
|
var _exists;
|
|
boundMethodCheck(this, NodeCache2);
|
|
_exists = this.data[key] != null && this._check(key, this.data[key]);
|
|
return _exists;
|
|
}
|
|
getStats() {
|
|
boundMethodCheck(this, NodeCache2);
|
|
return this.stats;
|
|
}
|
|
flushAll(_startPeriod = true) {
|
|
boundMethodCheck(this, NodeCache2);
|
|
this.data = {};
|
|
this.stats = {
|
|
hits: 0,
|
|
misses: 0,
|
|
keys: 0,
|
|
ksize: 0,
|
|
vsize: 0
|
|
};
|
|
this._killCheckPeriod();
|
|
this._checkData(_startPeriod);
|
|
this.emit("flush");
|
|
}
|
|
flushStats() {
|
|
boundMethodCheck(this, NodeCache2);
|
|
this.stats = {
|
|
hits: 0,
|
|
misses: 0,
|
|
keys: 0,
|
|
ksize: 0,
|
|
vsize: 0
|
|
};
|
|
this.emit("flush_stats");
|
|
}
|
|
close() {
|
|
boundMethodCheck(this, NodeCache2);
|
|
this._killCheckPeriod();
|
|
}
|
|
_checkData(startPeriod = true) {
|
|
var key, ref, value;
|
|
boundMethodCheck(this, NodeCache2);
|
|
ref = this.data;
|
|
for (key in ref) {
|
|
value = ref[key];
|
|
this._check(key, value);
|
|
}
|
|
if (startPeriod && this.options.checkperiod > 0) {
|
|
this.checkTimeout = setTimeout(this._checkData, this.options.checkperiod * 1000, startPeriod);
|
|
if (this.checkTimeout != null && this.checkTimeout.unref != null) {
|
|
this.checkTimeout.unref();
|
|
}
|
|
}
|
|
}
|
|
_killCheckPeriod() {
|
|
if (this.checkTimeout != null) {
|
|
return clearTimeout(this.checkTimeout);
|
|
}
|
|
}
|
|
_check(key, data) {
|
|
var _retval;
|
|
boundMethodCheck(this, NodeCache2);
|
|
_retval = true;
|
|
if (data.t !== 0 && data.t < Date.now()) {
|
|
if (this.options.deleteOnExpire) {
|
|
_retval = false;
|
|
this.del(key);
|
|
}
|
|
this.emit("expired", key, this._unwrap(data));
|
|
}
|
|
return _retval;
|
|
}
|
|
_isInvalidKey(key) {
|
|
var ref;
|
|
boundMethodCheck(this, NodeCache2);
|
|
if (ref = typeof key, indexOf.call(this.validKeyTypes, ref) < 0) {
|
|
return this._error("EKEYTYPE", {
|
|
type: typeof key
|
|
});
|
|
}
|
|
}
|
|
_wrap(value, ttl, asClone = true) {
|
|
var livetime, now, oReturn, ttlMultiplicator;
|
|
boundMethodCheck(this, NodeCache2);
|
|
if (!this.options.useClones) {
|
|
asClone = false;
|
|
}
|
|
now = Date.now();
|
|
livetime = 0;
|
|
ttlMultiplicator = 1000;
|
|
if (ttl === 0) {
|
|
livetime = 0;
|
|
} else if (ttl) {
|
|
livetime = now + ttl * ttlMultiplicator;
|
|
} else {
|
|
if (this.options.stdTTL === 0) {
|
|
livetime = this.options.stdTTL;
|
|
} else {
|
|
livetime = now + this.options.stdTTL * ttlMultiplicator;
|
|
}
|
|
}
|
|
return oReturn = {
|
|
t: livetime,
|
|
v: asClone ? clone(value) : value
|
|
};
|
|
}
|
|
_unwrap(value, asClone = true) {
|
|
if (!this.options.useClones) {
|
|
asClone = false;
|
|
}
|
|
if (value.v != null) {
|
|
if (asClone) {
|
|
return clone(value.v);
|
|
} else {
|
|
return value.v;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
_getKeyLength(key) {
|
|
return key.toString().length;
|
|
}
|
|
_getValLength(value) {
|
|
boundMethodCheck(this, NodeCache2);
|
|
if (typeof value === "string") {
|
|
return value.length;
|
|
} else if (this.options.forceString) {
|
|
return JSON.stringify(value).length;
|
|
} else if (Array.isArray(value)) {
|
|
return this.options.arrayValueSize * value.length;
|
|
} else if (typeof value === "number") {
|
|
return 8;
|
|
} else if (typeof (value != null ? value.then : undefined) === "function") {
|
|
return this.options.promiseValueSize;
|
|
} else if (typeof Buffer !== "undefined" && Buffer !== null ? Buffer.isBuffer(value) : undefined) {
|
|
return value.length;
|
|
} else if (value != null && typeof value === "object") {
|
|
return this.options.objectValueSize * Object.keys(value).length;
|
|
} else if (typeof value === "boolean") {
|
|
return 8;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
_error(type, data = {}) {
|
|
var error;
|
|
boundMethodCheck(this, NodeCache2);
|
|
error = new Error;
|
|
error.name = type;
|
|
error.errorcode = type;
|
|
error.message = this.ERRORS[type] != null ? this.ERRORS[type](data) : "-";
|
|
error.data = data;
|
|
return error;
|
|
}
|
|
_initErrors() {
|
|
var _errMsg, _errT, ref;
|
|
boundMethodCheck(this, NodeCache2);
|
|
this.ERRORS = {};
|
|
ref = this._ERRORS;
|
|
for (_errT in ref) {
|
|
_errMsg = ref[_errT];
|
|
this.ERRORS[_errT] = this.createErrorMessage(_errMsg);
|
|
}
|
|
}
|
|
createErrorMessage(errMsg) {
|
|
return function(args) {
|
|
return errMsg.replace("__key", args.type);
|
|
};
|
|
}
|
|
}
|
|
NodeCache2.prototype._ERRORS = {
|
|
ENOTFOUND: "Key `__key` not found",
|
|
ECACHEFULL: "Cache max keys amount exceeded",
|
|
EKEYTYPE: "The key argument has to be of type `string` or `number`. Found: `__key`",
|
|
EKEYSTYPE: "The keys argument has to be an array.",
|
|
ETTLTYPE: "The ttl argument has to be a number."
|
|
};
|
|
return NodeCache2;
|
|
}.call(this);
|
|
}).call(exports);
|
|
});
|
|
|
|
// ../util/node_modules/node-cache/index.js
|
|
var require_node_cache2 = __commonJS((exports, module) => {
|
|
(function() {
|
|
var exports2;
|
|
exports2 = module.exports = require_node_cache();
|
|
exports2.version = "5.1.2";
|
|
}).call(exports);
|
|
});
|
|
|
|
// ../eve/dist/_virtual/rolldown_runtime.js
|
|
var __defProp2 = Object.defineProperty;
|
|
var __export = (target, all) => {
|
|
for (var name in all)
|
|
__defProp2(target, name, {
|
|
get: all[name],
|
|
enumerable: true
|
|
});
|
|
};
|
|
|
|
// ../eve/node_modules/drizzle-orm/entity.js
|
|
var entityKind = Symbol.for("drizzle:entityKind");
|
|
var hasOwnEntityKind = Symbol.for("drizzle:hasOwnEntityKind");
|
|
function is(value, type) {
|
|
if (!value || typeof value !== "object") {
|
|
return false;
|
|
}
|
|
if (value instanceof type) {
|
|
return true;
|
|
}
|
|
if (!Object.prototype.hasOwnProperty.call(type, entityKind)) {
|
|
throw new Error(`Class "${type.name ?? "<unknown>"}" doesn't look like a Drizzle entity. If this is incorrect and the class is provided by Drizzle, please report this as a bug.`);
|
|
}
|
|
let cls = Object.getPrototypeOf(value).constructor;
|
|
if (cls) {
|
|
while (cls) {
|
|
if (entityKind in cls && cls[entityKind] === type[entityKind]) {
|
|
return true;
|
|
}
|
|
cls = Object.getPrototypeOf(cls);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// ../eve/node_modules/drizzle-orm/column.js
|
|
class Column {
|
|
constructor(table, config) {
|
|
this.table = table;
|
|
this.config = config;
|
|
this.name = config.name;
|
|
this.keyAsName = config.keyAsName;
|
|
this.notNull = config.notNull;
|
|
this.default = config.default;
|
|
this.defaultFn = config.defaultFn;
|
|
this.onUpdateFn = config.onUpdateFn;
|
|
this.hasDefault = config.hasDefault;
|
|
this.primary = config.primaryKey;
|
|
this.isUnique = config.isUnique;
|
|
this.uniqueName = config.uniqueName;
|
|
this.uniqueType = config.uniqueType;
|
|
this.dataType = config.dataType;
|
|
this.columnType = config.columnType;
|
|
this.generated = config.generated;
|
|
this.generatedIdentity = config.generatedIdentity;
|
|
}
|
|
static [entityKind] = "Column";
|
|
name;
|
|
keyAsName;
|
|
primary;
|
|
notNull;
|
|
default;
|
|
defaultFn;
|
|
onUpdateFn;
|
|
hasDefault;
|
|
isUnique;
|
|
uniqueName;
|
|
uniqueType;
|
|
dataType;
|
|
columnType;
|
|
enumValues = undefined;
|
|
generated = undefined;
|
|
generatedIdentity = undefined;
|
|
config;
|
|
mapFromDriverValue(value) {
|
|
return value;
|
|
}
|
|
mapToDriverValue(value) {
|
|
return value;
|
|
}
|
|
shouldDisableInsert() {
|
|
return this.config.generated !== undefined && this.config.generated.type !== "byDefault";
|
|
}
|
|
}
|
|
|
|
// ../eve/node_modules/drizzle-orm/column-builder.js
|
|
class ColumnBuilder {
|
|
static [entityKind] = "ColumnBuilder";
|
|
config;
|
|
constructor(name, dataType, columnType) {
|
|
this.config = {
|
|
name,
|
|
keyAsName: name === "",
|
|
notNull: false,
|
|
default: undefined,
|
|
hasDefault: false,
|
|
primaryKey: false,
|
|
isUnique: false,
|
|
uniqueName: undefined,
|
|
uniqueType: undefined,
|
|
dataType,
|
|
columnType,
|
|
generated: undefined
|
|
};
|
|
}
|
|
$type() {
|
|
return this;
|
|
}
|
|
notNull() {
|
|
this.config.notNull = true;
|
|
return this;
|
|
}
|
|
default(value) {
|
|
this.config.default = value;
|
|
this.config.hasDefault = true;
|
|
return this;
|
|
}
|
|
$defaultFn(fn) {
|
|
this.config.defaultFn = fn;
|
|
this.config.hasDefault = true;
|
|
return this;
|
|
}
|
|
$default = this.$defaultFn;
|
|
$onUpdateFn(fn) {
|
|
this.config.onUpdateFn = fn;
|
|
this.config.hasDefault = true;
|
|
return this;
|
|
}
|
|
$onUpdate = this.$onUpdateFn;
|
|
primaryKey() {
|
|
this.config.primaryKey = true;
|
|
this.config.notNull = true;
|
|
return this;
|
|
}
|
|
setName(name) {
|
|
if (this.config.name !== "")
|
|
return;
|
|
this.config.name = name;
|
|
}
|
|
}
|
|
|
|
// ../eve/node_modules/drizzle-orm/table.utils.js
|
|
var TableName = Symbol.for("drizzle:Name");
|
|
|
|
// ../eve/node_modules/drizzle-orm/tracing-utils.js
|
|
function iife(fn, ...args) {
|
|
return fn(...args);
|
|
}
|
|
|
|
// ../eve/node_modules/drizzle-orm/pg-core/unique-constraint.js
|
|
function uniqueKeyName(table, columns) {
|
|
return `${table[TableName]}_${columns.join("_")}_unique`;
|
|
}
|
|
|
|
// ../eve/node_modules/drizzle-orm/pg-core/columns/common.js
|
|
class PgColumn extends Column {
|
|
constructor(table, config) {
|
|
if (!config.uniqueName) {
|
|
config.uniqueName = uniqueKeyName(table, [config.name]);
|
|
}
|
|
super(table, config);
|
|
this.table = table;
|
|
}
|
|
static [entityKind] = "PgColumn";
|
|
}
|
|
|
|
class ExtraConfigColumn extends PgColumn {
|
|
static [entityKind] = "ExtraConfigColumn";
|
|
getSQLType() {
|
|
return this.getSQLType();
|
|
}
|
|
indexConfig = {
|
|
order: this.config.order ?? "asc",
|
|
nulls: this.config.nulls ?? "last",
|
|
opClass: this.config.opClass
|
|
};
|
|
defaultConfig = {
|
|
order: "asc",
|
|
nulls: "last",
|
|
opClass: undefined
|
|
};
|
|
asc() {
|
|
this.indexConfig.order = "asc";
|
|
return this;
|
|
}
|
|
desc() {
|
|
this.indexConfig.order = "desc";
|
|
return this;
|
|
}
|
|
nullsFirst() {
|
|
this.indexConfig.nulls = "first";
|
|
return this;
|
|
}
|
|
nullsLast() {
|
|
this.indexConfig.nulls = "last";
|
|
return this;
|
|
}
|
|
op(opClass) {
|
|
this.indexConfig.opClass = opClass;
|
|
return this;
|
|
}
|
|
}
|
|
|
|
// ../eve/node_modules/drizzle-orm/pg-core/columns/enum.js
|
|
class PgEnumObjectColumn extends PgColumn {
|
|
static [entityKind] = "PgEnumObjectColumn";
|
|
enum;
|
|
enumValues = this.config.enum.enumValues;
|
|
constructor(table, config) {
|
|
super(table, config);
|
|
this.enum = config.enum;
|
|
}
|
|
getSQLType() {
|
|
return this.enum.enumName;
|
|
}
|
|
}
|
|
var isPgEnumSym = Symbol.for("drizzle:isPgEnum");
|
|
function isPgEnum(obj) {
|
|
return !!obj && typeof obj === "function" && isPgEnumSym in obj && obj[isPgEnumSym] === true;
|
|
}
|
|
class PgEnumColumn extends PgColumn {
|
|
static [entityKind] = "PgEnumColumn";
|
|
enum = this.config.enum;
|
|
enumValues = this.config.enum.enumValues;
|
|
constructor(table, config) {
|
|
super(table, config);
|
|
this.enum = config.enum;
|
|
}
|
|
getSQLType() {
|
|
return this.enum.enumName;
|
|
}
|
|
}
|
|
|
|
// ../eve/node_modules/drizzle-orm/subquery.js
|
|
class Subquery {
|
|
static [entityKind] = "Subquery";
|
|
constructor(sql, fields, alias, isWith = false, usedTables = []) {
|
|
this._ = {
|
|
brand: "Subquery",
|
|
sql,
|
|
selectedFields: fields,
|
|
alias,
|
|
isWith,
|
|
usedTables
|
|
};
|
|
}
|
|
}
|
|
|
|
class WithSubquery extends Subquery {
|
|
static [entityKind] = "WithSubquery";
|
|
}
|
|
|
|
// ../eve/node_modules/drizzle-orm/version.js
|
|
var version = "0.44.5";
|
|
|
|
// ../eve/node_modules/drizzle-orm/tracing.js
|
|
var otel;
|
|
var rawTracer;
|
|
var tracer = {
|
|
startActiveSpan(name, fn) {
|
|
if (!otel) {
|
|
return fn();
|
|
}
|
|
if (!rawTracer) {
|
|
rawTracer = otel.trace.getTracer("drizzle-orm", version);
|
|
}
|
|
return iife((otel2, rawTracer2) => rawTracer2.startActiveSpan(name, (span) => {
|
|
try {
|
|
return fn(span);
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: otel2.SpanStatusCode.ERROR,
|
|
message: e instanceof Error ? e.message : "Unknown error"
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}), otel, rawTracer);
|
|
}
|
|
};
|
|
|
|
// ../eve/node_modules/drizzle-orm/view-common.js
|
|
var ViewBaseConfig = Symbol.for("drizzle:ViewBaseConfig");
|
|
|
|
// ../eve/node_modules/drizzle-orm/table.js
|
|
var Schema = Symbol.for("drizzle:Schema");
|
|
var Columns = Symbol.for("drizzle:Columns");
|
|
var ExtraConfigColumns = Symbol.for("drizzle:ExtraConfigColumns");
|
|
var OriginalName = Symbol.for("drizzle:OriginalName");
|
|
var BaseName = Symbol.for("drizzle:BaseName");
|
|
var IsAlias = Symbol.for("drizzle:IsAlias");
|
|
var ExtraConfigBuilder = Symbol.for("drizzle:ExtraConfigBuilder");
|
|
var IsDrizzleTable = Symbol.for("drizzle:IsDrizzleTable");
|
|
|
|
class Table {
|
|
static [entityKind] = "Table";
|
|
static Symbol = {
|
|
Name: TableName,
|
|
Schema,
|
|
OriginalName,
|
|
Columns,
|
|
ExtraConfigColumns,
|
|
BaseName,
|
|
IsAlias,
|
|
ExtraConfigBuilder
|
|
};
|
|
[TableName];
|
|
[OriginalName];
|
|
[Schema];
|
|
[Columns];
|
|
[ExtraConfigColumns];
|
|
[BaseName];
|
|
[IsAlias] = false;
|
|
[IsDrizzleTable] = true;
|
|
[ExtraConfigBuilder] = undefined;
|
|
constructor(name, schema, baseName) {
|
|
this[TableName] = this[OriginalName] = name;
|
|
this[Schema] = schema;
|
|
this[BaseName] = baseName;
|
|
}
|
|
}
|
|
function getTableName(table) {
|
|
return table[TableName];
|
|
}
|
|
function getTableUniqueName(table) {
|
|
return `${table[Schema] ?? "public"}.${table[TableName]}`;
|
|
}
|
|
|
|
// ../eve/node_modules/drizzle-orm/sql/sql.js
|
|
function isSQLWrapper(value) {
|
|
return value !== null && value !== undefined && typeof value.getSQL === "function";
|
|
}
|
|
function mergeQueries(queries) {
|
|
const result = { sql: "", params: [] };
|
|
for (const query of queries) {
|
|
result.sql += query.sql;
|
|
result.params.push(...query.params);
|
|
if (query.typings?.length) {
|
|
if (!result.typings) {
|
|
result.typings = [];
|
|
}
|
|
result.typings.push(...query.typings);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
class StringChunk {
|
|
static [entityKind] = "StringChunk";
|
|
value;
|
|
constructor(value) {
|
|
this.value = Array.isArray(value) ? value : [value];
|
|
}
|
|
getSQL() {
|
|
return new SQL([this]);
|
|
}
|
|
}
|
|
|
|
class SQL {
|
|
constructor(queryChunks) {
|
|
this.queryChunks = queryChunks;
|
|
for (const chunk of queryChunks) {
|
|
if (is(chunk, Table)) {
|
|
const schemaName = chunk[Table.Symbol.Schema];
|
|
this.usedTables.push(schemaName === undefined ? chunk[Table.Symbol.Name] : schemaName + "." + chunk[Table.Symbol.Name]);
|
|
}
|
|
}
|
|
}
|
|
static [entityKind] = "SQL";
|
|
decoder = noopDecoder;
|
|
shouldInlineParams = false;
|
|
usedTables = [];
|
|
append(query) {
|
|
this.queryChunks.push(...query.queryChunks);
|
|
return this;
|
|
}
|
|
toQuery(config) {
|
|
return tracer.startActiveSpan("drizzle.buildSQL", (span) => {
|
|
const query = this.buildQueryFromSourceParams(this.queryChunks, config);
|
|
span?.setAttributes({
|
|
"drizzle.query.text": query.sql,
|
|
"drizzle.query.params": JSON.stringify(query.params)
|
|
});
|
|
return query;
|
|
});
|
|
}
|
|
buildQueryFromSourceParams(chunks, _config) {
|
|
const config = Object.assign({}, _config, {
|
|
inlineParams: _config.inlineParams || this.shouldInlineParams,
|
|
paramStartIndex: _config.paramStartIndex || { value: 0 }
|
|
});
|
|
const {
|
|
casing,
|
|
escapeName,
|
|
escapeParam,
|
|
prepareTyping,
|
|
inlineParams,
|
|
paramStartIndex
|
|
} = config;
|
|
return mergeQueries(chunks.map((chunk) => {
|
|
if (is(chunk, StringChunk)) {
|
|
return { sql: chunk.value.join(""), params: [] };
|
|
}
|
|
if (is(chunk, Name)) {
|
|
return { sql: escapeName(chunk.value), params: [] };
|
|
}
|
|
if (chunk === undefined) {
|
|
return { sql: "", params: [] };
|
|
}
|
|
if (Array.isArray(chunk)) {
|
|
const result = [new StringChunk("(")];
|
|
for (const [i, p] of chunk.entries()) {
|
|
result.push(p);
|
|
if (i < chunk.length - 1) {
|
|
result.push(new StringChunk(", "));
|
|
}
|
|
}
|
|
result.push(new StringChunk(")"));
|
|
return this.buildQueryFromSourceParams(result, config);
|
|
}
|
|
if (is(chunk, SQL)) {
|
|
return this.buildQueryFromSourceParams(chunk.queryChunks, {
|
|
...config,
|
|
inlineParams: inlineParams || chunk.shouldInlineParams
|
|
});
|
|
}
|
|
if (is(chunk, Table)) {
|
|
const schemaName = chunk[Table.Symbol.Schema];
|
|
const tableName = chunk[Table.Symbol.Name];
|
|
return {
|
|
sql: schemaName === undefined || chunk[IsAlias] ? escapeName(tableName) : escapeName(schemaName) + "." + escapeName(tableName),
|
|
params: []
|
|
};
|
|
}
|
|
if (is(chunk, Column)) {
|
|
const columnName = casing.getColumnCasing(chunk);
|
|
if (_config.invokeSource === "indexes") {
|
|
return { sql: escapeName(columnName), params: [] };
|
|
}
|
|
const schemaName = chunk.table[Table.Symbol.Schema];
|
|
return {
|
|
sql: chunk.table[IsAlias] || schemaName === undefined ? escapeName(chunk.table[Table.Symbol.Name]) + "." + escapeName(columnName) : escapeName(schemaName) + "." + escapeName(chunk.table[Table.Symbol.Name]) + "." + escapeName(columnName),
|
|
params: []
|
|
};
|
|
}
|
|
if (is(chunk, View)) {
|
|
const schemaName = chunk[ViewBaseConfig].schema;
|
|
const viewName = chunk[ViewBaseConfig].name;
|
|
return {
|
|
sql: schemaName === undefined || chunk[ViewBaseConfig].isAlias ? escapeName(viewName) : escapeName(schemaName) + "." + escapeName(viewName),
|
|
params: []
|
|
};
|
|
}
|
|
if (is(chunk, Param)) {
|
|
if (is(chunk.value, Placeholder)) {
|
|
return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
|
|
}
|
|
const mappedValue = chunk.value === null ? null : chunk.encoder.mapToDriverValue(chunk.value);
|
|
if (is(mappedValue, SQL)) {
|
|
return this.buildQueryFromSourceParams([mappedValue], config);
|
|
}
|
|
if (inlineParams) {
|
|
return { sql: this.mapInlineParam(mappedValue, config), params: [] };
|
|
}
|
|
let typings = ["none"];
|
|
if (prepareTyping) {
|
|
typings = [prepareTyping(chunk.encoder)];
|
|
}
|
|
return { sql: escapeParam(paramStartIndex.value++, mappedValue), params: [mappedValue], typings };
|
|
}
|
|
if (is(chunk, Placeholder)) {
|
|
return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
|
|
}
|
|
if (is(chunk, SQL.Aliased) && chunk.fieldAlias !== undefined) {
|
|
return { sql: escapeName(chunk.fieldAlias), params: [] };
|
|
}
|
|
if (is(chunk, Subquery)) {
|
|
if (chunk._.isWith) {
|
|
return { sql: escapeName(chunk._.alias), params: [] };
|
|
}
|
|
return this.buildQueryFromSourceParams([
|
|
new StringChunk("("),
|
|
chunk._.sql,
|
|
new StringChunk(") "),
|
|
new Name(chunk._.alias)
|
|
], config);
|
|
}
|
|
if (isPgEnum(chunk)) {
|
|
if (chunk.schema) {
|
|
return { sql: escapeName(chunk.schema) + "." + escapeName(chunk.enumName), params: [] };
|
|
}
|
|
return { sql: escapeName(chunk.enumName), params: [] };
|
|
}
|
|
if (isSQLWrapper(chunk)) {
|
|
if (chunk.shouldOmitSQLParens?.()) {
|
|
return this.buildQueryFromSourceParams([chunk.getSQL()], config);
|
|
}
|
|
return this.buildQueryFromSourceParams([
|
|
new StringChunk("("),
|
|
chunk.getSQL(),
|
|
new StringChunk(")")
|
|
], config);
|
|
}
|
|
if (inlineParams) {
|
|
return { sql: this.mapInlineParam(chunk, config), params: [] };
|
|
}
|
|
return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
|
|
}));
|
|
}
|
|
mapInlineParam(chunk, { escapeString }) {
|
|
if (chunk === null) {
|
|
return "null";
|
|
}
|
|
if (typeof chunk === "number" || typeof chunk === "boolean") {
|
|
return chunk.toString();
|
|
}
|
|
if (typeof chunk === "string") {
|
|
return escapeString(chunk);
|
|
}
|
|
if (typeof chunk === "object") {
|
|
const mappedValueAsString = chunk.toString();
|
|
if (mappedValueAsString === "[object Object]") {
|
|
return escapeString(JSON.stringify(chunk));
|
|
}
|
|
return escapeString(mappedValueAsString);
|
|
}
|
|
throw new Error("Unexpected param value: " + chunk);
|
|
}
|
|
getSQL() {
|
|
return this;
|
|
}
|
|
as(alias) {
|
|
if (alias === undefined) {
|
|
return this;
|
|
}
|
|
return new SQL.Aliased(this, alias);
|
|
}
|
|
mapWith(decoder) {
|
|
this.decoder = typeof decoder === "function" ? { mapFromDriverValue: decoder } : decoder;
|
|
return this;
|
|
}
|
|
inlineParams() {
|
|
this.shouldInlineParams = true;
|
|
return this;
|
|
}
|
|
if(condition) {
|
|
return condition ? this : undefined;
|
|
}
|
|
}
|
|
|
|
class Name {
|
|
constructor(value) {
|
|
this.value = value;
|
|
}
|
|
static [entityKind] = "Name";
|
|
brand;
|
|
getSQL() {
|
|
return new SQL([this]);
|
|
}
|
|
}
|
|
function isDriverValueEncoder(value) {
|
|
return typeof value === "object" && value !== null && "mapToDriverValue" in value && typeof value.mapToDriverValue === "function";
|
|
}
|
|
var noopDecoder = {
|
|
mapFromDriverValue: (value) => value
|
|
};
|
|
var noopEncoder = {
|
|
mapToDriverValue: (value) => value
|
|
};
|
|
var noopMapper = {
|
|
...noopDecoder,
|
|
...noopEncoder
|
|
};
|
|
|
|
class Param {
|
|
constructor(value, encoder = noopEncoder) {
|
|
this.value = value;
|
|
this.encoder = encoder;
|
|
}
|
|
static [entityKind] = "Param";
|
|
brand;
|
|
getSQL() {
|
|
return new SQL([this]);
|
|
}
|
|
}
|
|
function sql(strings, ...params) {
|
|
const queryChunks = [];
|
|
if (params.length > 0 || strings.length > 0 && strings[0] !== "") {
|
|
queryChunks.push(new StringChunk(strings[0]));
|
|
}
|
|
for (const [paramIndex, param2] of params.entries()) {
|
|
queryChunks.push(param2, new StringChunk(strings[paramIndex + 1]));
|
|
}
|
|
return new SQL(queryChunks);
|
|
}
|
|
((sql2) => {
|
|
function empty() {
|
|
return new SQL([]);
|
|
}
|
|
sql2.empty = empty;
|
|
function fromList(list) {
|
|
return new SQL(list);
|
|
}
|
|
sql2.fromList = fromList;
|
|
function raw(str) {
|
|
return new SQL([new StringChunk(str)]);
|
|
}
|
|
sql2.raw = raw;
|
|
function join(chunks, separator) {
|
|
const result = [];
|
|
for (const [i, chunk] of chunks.entries()) {
|
|
if (i > 0 && separator !== undefined) {
|
|
result.push(separator);
|
|
}
|
|
result.push(chunk);
|
|
}
|
|
return new SQL(result);
|
|
}
|
|
sql2.join = join;
|
|
function identifier(value) {
|
|
return new Name(value);
|
|
}
|
|
sql2.identifier = identifier;
|
|
function placeholder2(name2) {
|
|
return new Placeholder(name2);
|
|
}
|
|
sql2.placeholder = placeholder2;
|
|
function param2(value, encoder) {
|
|
return new Param(value, encoder);
|
|
}
|
|
sql2.param = param2;
|
|
})(sql || (sql = {}));
|
|
((SQL2) => {
|
|
|
|
class Aliased {
|
|
constructor(sql2, fieldAlias) {
|
|
this.sql = sql2;
|
|
this.fieldAlias = fieldAlias;
|
|
}
|
|
static [entityKind] = "SQL.Aliased";
|
|
isSelectionField = false;
|
|
getSQL() {
|
|
return this.sql;
|
|
}
|
|
clone() {
|
|
return new Aliased(this.sql, this.fieldAlias);
|
|
}
|
|
}
|
|
SQL2.Aliased = Aliased;
|
|
})(SQL || (SQL = {}));
|
|
|
|
class Placeholder {
|
|
constructor(name2) {
|
|
this.name = name2;
|
|
}
|
|
static [entityKind] = "Placeholder";
|
|
getSQL() {
|
|
return new SQL([this]);
|
|
}
|
|
}
|
|
function fillPlaceholders(params, values) {
|
|
return params.map((p) => {
|
|
if (is(p, Placeholder)) {
|
|
if (!(p.name in values)) {
|
|
throw new Error(`No value for placeholder "${p.name}" was provided`);
|
|
}
|
|
return values[p.name];
|
|
}
|
|
if (is(p, Param) && is(p.value, Placeholder)) {
|
|
if (!(p.value.name in values)) {
|
|
throw new Error(`No value for placeholder "${p.value.name}" was provided`);
|
|
}
|
|
return p.encoder.mapToDriverValue(values[p.value.name]);
|
|
}
|
|
return p;
|
|
});
|
|
}
|
|
var IsDrizzleView = Symbol.for("drizzle:IsDrizzleView");
|
|
|
|
class View {
|
|
static [entityKind] = "View";
|
|
[ViewBaseConfig];
|
|
[IsDrizzleView] = true;
|
|
constructor({ name: name2, schema, selectedFields, query }) {
|
|
this[ViewBaseConfig] = {
|
|
name: name2,
|
|
originalName: name2,
|
|
schema,
|
|
selectedFields,
|
|
query,
|
|
isExisting: !query,
|
|
isAlias: false
|
|
};
|
|
}
|
|
getSQL() {
|
|
return new SQL([this]);
|
|
}
|
|
}
|
|
Column.prototype.getSQL = function() {
|
|
return new SQL([this]);
|
|
};
|
|
Table.prototype.getSQL = function() {
|
|
return new SQL([this]);
|
|
};
|
|
Subquery.prototype.getSQL = function() {
|
|
return new SQL([this]);
|
|
};
|
|
|
|
// ../eve/node_modules/drizzle-orm/alias.js
|
|
class ColumnAliasProxyHandler {
|
|
constructor(table) {
|
|
this.table = table;
|
|
}
|
|
static [entityKind] = "ColumnAliasProxyHandler";
|
|
get(columnObj, prop) {
|
|
if (prop === "table") {
|
|
return this.table;
|
|
}
|
|
return columnObj[prop];
|
|
}
|
|
}
|
|
|
|
class TableAliasProxyHandler {
|
|
constructor(alias, replaceOriginalName) {
|
|
this.alias = alias;
|
|
this.replaceOriginalName = replaceOriginalName;
|
|
}
|
|
static [entityKind] = "TableAliasProxyHandler";
|
|
get(target, prop) {
|
|
if (prop === Table.Symbol.IsAlias) {
|
|
return true;
|
|
}
|
|
if (prop === Table.Symbol.Name) {
|
|
return this.alias;
|
|
}
|
|
if (this.replaceOriginalName && prop === Table.Symbol.OriginalName) {
|
|
return this.alias;
|
|
}
|
|
if (prop === ViewBaseConfig) {
|
|
return {
|
|
...target[ViewBaseConfig],
|
|
name: this.alias,
|
|
isAlias: true
|
|
};
|
|
}
|
|
if (prop === Table.Symbol.Columns) {
|
|
const columns = target[Table.Symbol.Columns];
|
|
if (!columns) {
|
|
return columns;
|
|
}
|
|
const proxiedColumns = {};
|
|
Object.keys(columns).map((key) => {
|
|
proxiedColumns[key] = new Proxy(columns[key], new ColumnAliasProxyHandler(new Proxy(target, this)));
|
|
});
|
|
return proxiedColumns;
|
|
}
|
|
const value = target[prop];
|
|
if (is(value, Column)) {
|
|
return new Proxy(value, new ColumnAliasProxyHandler(new Proxy(target, this)));
|
|
}
|
|
return value;
|
|
}
|
|
}
|
|
function aliasedTable(table, tableAlias) {
|
|
return new Proxy(table, new TableAliasProxyHandler(tableAlias, false));
|
|
}
|
|
function aliasedTableColumn(column, tableAlias) {
|
|
return new Proxy(column, new ColumnAliasProxyHandler(new Proxy(column.table, new TableAliasProxyHandler(tableAlias, false))));
|
|
}
|
|
function mapColumnsInAliasedSQLToAlias(query, alias) {
|
|
return new SQL.Aliased(mapColumnsInSQLToAlias(query.sql, alias), query.fieldAlias);
|
|
}
|
|
function mapColumnsInSQLToAlias(query, alias) {
|
|
return sql.join(query.queryChunks.map((c) => {
|
|
if (is(c, Column)) {
|
|
return aliasedTableColumn(c, alias);
|
|
}
|
|
if (is(c, SQL)) {
|
|
return mapColumnsInSQLToAlias(c, alias);
|
|
}
|
|
if (is(c, SQL.Aliased)) {
|
|
return mapColumnsInAliasedSQLToAlias(c, alias);
|
|
}
|
|
return c;
|
|
}));
|
|
}
|
|
|
|
// ../eve/node_modules/drizzle-orm/utils.js
|
|
function mapResultRow(columns, row, joinsNotNullableMap) {
|
|
const nullifyMap = {};
|
|
const result = columns.reduce((result2, { path, field }, columnIndex) => {
|
|
let decoder;
|
|
if (is(field, Column)) {
|
|
decoder = field;
|
|
} else if (is(field, SQL)) {
|
|
decoder = field.decoder;
|
|
} else {
|
|
decoder = field.sql.decoder;
|
|
}
|
|
let node = result2;
|
|
for (const [pathChunkIndex, pathChunk] of path.entries()) {
|
|
if (pathChunkIndex < path.length - 1) {
|
|
if (!(pathChunk in node)) {
|
|
node[pathChunk] = {};
|
|
}
|
|
node = node[pathChunk];
|
|
} else {
|
|
const rawValue = row[columnIndex];
|
|
const value = node[pathChunk] = rawValue === null ? null : decoder.mapFromDriverValue(rawValue);
|
|
if (joinsNotNullableMap && is(field, Column) && path.length === 2) {
|
|
const objectName = path[0];
|
|
if (!(objectName in nullifyMap)) {
|
|
nullifyMap[objectName] = value === null ? getTableName(field.table) : false;
|
|
} else if (typeof nullifyMap[objectName] === "string" && nullifyMap[objectName] !== getTableName(field.table)) {
|
|
nullifyMap[objectName] = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return result2;
|
|
}, {});
|
|
if (joinsNotNullableMap && Object.keys(nullifyMap).length > 0) {
|
|
for (const [objectName, tableName] of Object.entries(nullifyMap)) {
|
|
if (typeof tableName === "string" && !joinsNotNullableMap[tableName]) {
|
|
result[objectName] = null;
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function orderSelectedFields(fields, pathPrefix) {
|
|
return Object.entries(fields).reduce((result, [name, field]) => {
|
|
if (typeof name !== "string") {
|
|
return result;
|
|
}
|
|
const newPath = pathPrefix ? [...pathPrefix, name] : [name];
|
|
if (is(field, Column) || is(field, SQL) || is(field, SQL.Aliased)) {
|
|
result.push({ path: newPath, field });
|
|
} else if (is(field, Table)) {
|
|
result.push(...orderSelectedFields(field[Table.Symbol.Columns], newPath));
|
|
} else {
|
|
result.push(...orderSelectedFields(field, newPath));
|
|
}
|
|
return result;
|
|
}, []);
|
|
}
|
|
function haveSameKeys(left, right) {
|
|
const leftKeys = Object.keys(left);
|
|
const rightKeys = Object.keys(right);
|
|
if (leftKeys.length !== rightKeys.length) {
|
|
return false;
|
|
}
|
|
for (const [index, key] of leftKeys.entries()) {
|
|
if (key !== rightKeys[index]) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function mapUpdateSet(table, values) {
|
|
const entries = Object.entries(values).filter(([, value]) => value !== undefined).map(([key, value]) => {
|
|
if (is(value, SQL) || is(value, Column)) {
|
|
return [key, value];
|
|
} else {
|
|
return [key, new Param(value, table[Table.Symbol.Columns][key])];
|
|
}
|
|
});
|
|
if (entries.length === 0) {
|
|
throw new Error("No values to set");
|
|
}
|
|
return Object.fromEntries(entries);
|
|
}
|
|
function applyMixins(baseClass, extendedClasses) {
|
|
for (const extendedClass of extendedClasses) {
|
|
for (const name of Object.getOwnPropertyNames(extendedClass.prototype)) {
|
|
if (name === "constructor")
|
|
continue;
|
|
Object.defineProperty(baseClass.prototype, name, Object.getOwnPropertyDescriptor(extendedClass.prototype, name) || /* @__PURE__ */ Object.create(null));
|
|
}
|
|
}
|
|
}
|
|
function getTableColumns(table) {
|
|
return table[Table.Symbol.Columns];
|
|
}
|
|
function getTableLikeName(table) {
|
|
return is(table, Subquery) ? table._.alias : is(table, View) ? table[ViewBaseConfig].name : is(table, SQL) ? undefined : table[Table.Symbol.IsAlias] ? table[Table.Symbol.Name] : table[Table.Symbol.BaseName];
|
|
}
|
|
function getColumnNameAndConfig(a, b) {
|
|
return {
|
|
name: typeof a === "string" && a.length > 0 ? a : "",
|
|
config: typeof a === "object" ? a : b
|
|
};
|
|
}
|
|
function isConfig(data) {
|
|
if (typeof data !== "object" || data === null)
|
|
return false;
|
|
if (data.constructor.name !== "Object")
|
|
return false;
|
|
if ("logger" in data) {
|
|
const type = typeof data["logger"];
|
|
if (type !== "boolean" && (type !== "object" || typeof data["logger"]["logQuery"] !== "function") && type !== "undefined")
|
|
return false;
|
|
return true;
|
|
}
|
|
if ("schema" in data) {
|
|
const type = typeof data["schema"];
|
|
if (type !== "object" && type !== "undefined")
|
|
return false;
|
|
return true;
|
|
}
|
|
if ("casing" in data) {
|
|
const type = typeof data["casing"];
|
|
if (type !== "string" && type !== "undefined")
|
|
return false;
|
|
return true;
|
|
}
|
|
if ("mode" in data) {
|
|
if (data["mode"] !== "default" || data["mode"] !== "planetscale" || data["mode"] !== undefined)
|
|
return false;
|
|
return true;
|
|
}
|
|
if ("connection" in data) {
|
|
const type = typeof data["connection"];
|
|
if (type !== "string" && type !== "object" && type !== "undefined")
|
|
return false;
|
|
return true;
|
|
}
|
|
if ("client" in data) {
|
|
const type = typeof data["client"];
|
|
if (type !== "object" && type !== "function" && type !== "undefined")
|
|
return false;
|
|
return true;
|
|
}
|
|
if (Object.keys(data).length === 0)
|
|
return true;
|
|
return false;
|
|
}
|
|
var textDecoder = typeof TextDecoder === "undefined" ? null : new TextDecoder;
|
|
|
|
// ../eve/node_modules/drizzle-orm/sqlite-core/foreign-keys.js
|
|
class ForeignKeyBuilder {
|
|
static [entityKind] = "SQLiteForeignKeyBuilder";
|
|
reference;
|
|
_onUpdate;
|
|
_onDelete;
|
|
constructor(config, actions) {
|
|
this.reference = () => {
|
|
const { name, columns, foreignColumns } = config();
|
|
return { name, columns, foreignTable: foreignColumns[0].table, foreignColumns };
|
|
};
|
|
if (actions) {
|
|
this._onUpdate = actions.onUpdate;
|
|
this._onDelete = actions.onDelete;
|
|
}
|
|
}
|
|
onUpdate(action) {
|
|
this._onUpdate = action;
|
|
return this;
|
|
}
|
|
onDelete(action) {
|
|
this._onDelete = action;
|
|
return this;
|
|
}
|
|
build(table) {
|
|
return new ForeignKey(table, this);
|
|
}
|
|
}
|
|
|
|
class ForeignKey {
|
|
constructor(table, builder) {
|
|
this.table = table;
|
|
this.reference = builder.reference;
|
|
this.onUpdate = builder._onUpdate;
|
|
this.onDelete = builder._onDelete;
|
|
}
|
|
static [entityKind] = "SQLiteForeignKey";
|
|
reference;
|
|
onUpdate;
|
|
onDelete;
|
|
getName() {
|
|
const { name, columns, foreignColumns } = this.reference();
|
|
const columnNames = columns.map((column) => column.name);
|
|
const foreignColumnNames = foreignColumns.map((column) => column.name);
|
|
const chunks = [
|
|
this.table[TableName],
|
|
...columnNames,
|
|
foreignColumns[0].table[TableName],
|
|
...foreignColumnNames
|
|
];
|
|
return name ?? `${chunks.join("_")}_fk`;
|
|
}
|
|
}
|
|
|
|
// ../eve/node_modules/drizzle-orm/sqlite-core/unique-constraint.js
|
|
function uniqueKeyName2(table, columns) {
|
|
return `${table[TableName]}_${columns.join("_")}_unique`;
|
|
}
|
|
|
|
// ../eve/node_modules/drizzle-orm/sqlite-core/columns/common.js
|
|
class SQLiteColumnBuilder extends ColumnBuilder {
|
|
static [entityKind] = "SQLiteColumnBuilder";
|
|
foreignKeyConfigs = [];
|
|
references(ref, actions = {}) {
|
|
this.foreignKeyConfigs.push({ ref, actions });
|
|
return this;
|
|
}
|
|
unique(name) {
|
|
this.config.isUnique = true;
|
|
this.config.uniqueName = name;
|
|
return this;
|
|
}
|
|
generatedAlwaysAs(as, config) {
|
|
this.config.generated = {
|
|
as,
|
|
type: "always",
|
|
mode: config?.mode ?? "virtual"
|
|
};
|
|
return this;
|
|
}
|
|
buildForeignKeys(column, table) {
|
|
return this.foreignKeyConfigs.map(({ ref, actions }) => {
|
|
return ((ref2, actions2) => {
|
|
const builder = new ForeignKeyBuilder(() => {
|
|
const foreignColumn = ref2();
|
|
return { columns: [column], foreignColumns: [foreignColumn] };
|
|
});
|
|
if (actions2.onUpdate) {
|
|
builder.onUpdate(actions2.onUpdate);
|
|
}
|
|
if (actions2.onDelete) {
|
|
builder.onDelete(actions2.onDelete);
|
|
}
|
|
return builder.build(table);
|
|
})(ref, actions);
|
|
});
|
|
}
|
|
}
|
|
|
|
class SQLiteColumn extends Column {
|
|
constructor(table, config) {
|
|
if (!config.uniqueName) {
|
|
config.uniqueName = uniqueKeyName2(table, [config.name]);
|
|
}
|
|
super(table, config);
|
|
this.table = table;
|
|
}
|
|
static [entityKind] = "SQLiteColumn";
|
|
}
|
|
|
|
// ../eve/node_modules/drizzle-orm/sqlite-core/columns/blob.js
|
|
class SQLiteBigIntBuilder extends SQLiteColumnBuilder {
|
|
static [entityKind] = "SQLiteBigIntBuilder";
|
|
constructor(name) {
|
|
super(name, "bigint", "SQLiteBigInt");
|
|
}
|
|
build(table) {
|
|
return new SQLiteBigInt(table, this.config);
|
|
}
|
|
}
|
|
|
|
class SQLiteBigInt extends SQLiteColumn {
|
|
static [entityKind] = "SQLiteBigInt";
|
|
getSQLType() {
|
|
return "blob";
|
|
}
|
|
mapFromDriverValue(value) {
|
|
if (typeof Buffer !== "undefined" && Buffer.from) {
|
|
const buf = Buffer.isBuffer(value) ? value : value instanceof ArrayBuffer ? Buffer.from(value) : value.buffer ? Buffer.from(value.buffer, value.byteOffset, value.byteLength) : Buffer.from(value);
|
|
return BigInt(buf.toString("utf8"));
|
|
}
|
|
return BigInt(textDecoder.decode(value));
|
|
}
|
|
mapToDriverValue(value) {
|
|
return Buffer.from(value.toString());
|
|
}
|
|
}
|
|
|
|
class SQLiteBlobJsonBuilder extends SQLiteColumnBuilder {
|
|
static [entityKind] = "SQLiteBlobJsonBuilder";
|
|
constructor(name) {
|
|
super(name, "json", "SQLiteBlobJson");
|
|
}
|
|
build(table) {
|
|
return new SQLiteBlobJson(table, this.config);
|
|
}
|
|
}
|
|
|
|
class SQLiteBlobJson extends SQLiteColumn {
|
|
static [entityKind] = "SQLiteBlobJson";
|
|
getSQLType() {
|
|
return "blob";
|
|
}
|
|
mapFromDriverValue(value) {
|
|
if (typeof Buffer !== "undefined" && Buffer.from) {
|
|
const buf = Buffer.isBuffer(value) ? value : value instanceof ArrayBuffer ? Buffer.from(value) : value.buffer ? Buffer.from(value.buffer, value.byteOffset, value.byteLength) : Buffer.from(value);
|
|
return JSON.parse(buf.toString("utf8"));
|
|
}
|
|
return JSON.parse(textDecoder.decode(value));
|
|
}
|
|
mapToDriverValue(value) {
|
|
return Buffer.from(JSON.stringify(value));
|
|
}
|
|
}
|
|
|
|
class SQLiteBlobBufferBuilder extends SQLiteColumnBuilder {
|
|
static [entityKind] = "SQLiteBlobBufferBuilder";
|
|
constructor(name) {
|
|
super(name, "buffer", "SQLiteBlobBuffer");
|
|
}
|
|
build(table) {
|
|
return new SQLiteBlobBuffer(table, this.config);
|
|
}
|
|
}
|
|
|
|
class SQLiteBlobBuffer extends SQLiteColumn {
|
|
static [entityKind] = "SQLiteBlobBuffer";
|
|
mapFromDriverValue(value) {
|
|
if (Buffer.isBuffer(value)) {
|
|
return value;
|
|
}
|
|
return Buffer.from(value);
|
|
}
|
|
getSQLType() {
|
|
return "blob";
|
|
}
|
|
}
|
|
function blob(a, b) {
|
|
const { name, config } = getColumnNameAndConfig(a, b);
|
|
if (config?.mode === "json") {
|
|
return new SQLiteBlobJsonBuilder(name);
|
|
}
|
|
if (config?.mode === "bigint") {
|
|
return new SQLiteBigIntBuilder(name);
|
|
}
|
|
return new SQLiteBlobBufferBuilder(name);
|
|
}
|
|
|
|
// ../eve/node_modules/drizzle-orm/sqlite-core/columns/custom.js
|
|
class SQLiteCustomColumnBuilder extends SQLiteColumnBuilder {
|
|
static [entityKind] = "SQLiteCustomColumnBuilder";
|
|
constructor(name, fieldConfig, customTypeParams) {
|
|
super(name, "custom", "SQLiteCustomColumn");
|
|
this.config.fieldConfig = fieldConfig;
|
|
this.config.customTypeParams = customTypeParams;
|
|
}
|
|
build(table) {
|
|
return new SQLiteCustomColumn(table, this.config);
|
|
}
|
|
}
|
|
|
|
class SQLiteCustomColumn extends SQLiteColumn {
|
|
static [entityKind] = "SQLiteCustomColumn";
|
|
sqlName;
|
|
mapTo;
|
|
mapFrom;
|
|
constructor(table, config) {
|
|
super(table, config);
|
|
this.sqlName = config.customTypeParams.dataType(config.fieldConfig);
|
|
this.mapTo = config.customTypeParams.toDriver;
|
|
this.mapFrom = config.customTypeParams.fromDriver;
|
|
}
|
|
getSQLType() {
|
|
return this.sqlName;
|
|
}
|
|
mapFromDriverValue(value) {
|
|
return typeof this.mapFrom === "function" ? this.mapFrom(value) : value;
|
|
}
|
|
mapToDriverValue(value) {
|
|
return typeof this.mapTo === "function" ? this.mapTo(value) : value;
|
|
}
|
|
}
|
|
function customType(customTypeParams) {
|
|
return (a, b) => {
|
|
const { name, config } = getColumnNameAndConfig(a, b);
|
|
return new SQLiteCustomColumnBuilder(name, config, customTypeParams);
|
|
};
|
|
}
|
|
|
|
// ../eve/node_modules/drizzle-orm/sqlite-core/columns/integer.js
|
|
class SQLiteBaseIntegerBuilder extends SQLiteColumnBuilder {
|
|
static [entityKind] = "SQLiteBaseIntegerBuilder";
|
|
constructor(name, dataType, columnType) {
|
|
super(name, dataType, columnType);
|
|
this.config.autoIncrement = false;
|
|
}
|
|
primaryKey(config) {
|
|
if (config?.autoIncrement) {
|
|
this.config.autoIncrement = true;
|
|
}
|
|
this.config.hasDefault = true;
|
|
return super.primaryKey();
|
|
}
|
|
}
|
|
|
|
class SQLiteBaseInteger extends SQLiteColumn {
|
|
static [entityKind] = "SQLiteBaseInteger";
|
|
autoIncrement = this.config.autoIncrement;
|
|
getSQLType() {
|
|
return "integer";
|
|
}
|
|
}
|
|
|
|
class SQLiteIntegerBuilder extends SQLiteBaseIntegerBuilder {
|
|
static [entityKind] = "SQLiteIntegerBuilder";
|
|
constructor(name) {
|
|
super(name, "number", "SQLiteInteger");
|
|
}
|
|
build(table) {
|
|
return new SQLiteInteger(table, this.config);
|
|
}
|
|
}
|
|
|
|
class SQLiteInteger extends SQLiteBaseInteger {
|
|
static [entityKind] = "SQLiteInteger";
|
|
}
|
|
|
|
class SQLiteTimestampBuilder extends SQLiteBaseIntegerBuilder {
|
|
static [entityKind] = "SQLiteTimestampBuilder";
|
|
constructor(name, mode) {
|
|
super(name, "date", "SQLiteTimestamp");
|
|
this.config.mode = mode;
|
|
}
|
|
defaultNow() {
|
|
return this.default(sql`(cast((julianday('now') - 2440587.5)*86400000 as integer))`);
|
|
}
|
|
build(table) {
|
|
return new SQLiteTimestamp(table, this.config);
|
|
}
|
|
}
|
|
|
|
class SQLiteTimestamp extends SQLiteBaseInteger {
|
|
static [entityKind] = "SQLiteTimestamp";
|
|
mode = this.config.mode;
|
|
mapFromDriverValue(value) {
|
|
if (this.config.mode === "timestamp") {
|
|
return new Date(value * 1000);
|
|
}
|
|
return new Date(value);
|
|
}
|
|
mapToDriverValue(value) {
|
|
const unix = value.getTime();
|
|
if (this.config.mode === "timestamp") {
|
|
return Math.floor(unix / 1000);
|
|
}
|
|
return unix;
|
|
}
|
|
}
|
|
|
|
class SQLiteBooleanBuilder extends SQLiteBaseIntegerBuilder {
|
|
static [entityKind] = "SQLiteBooleanBuilder";
|
|
constructor(name, mode) {
|
|
super(name, "boolean", "SQLiteBoolean");
|
|
this.config.mode = mode;
|
|
}
|
|
build(table) {
|
|
return new SQLiteBoolean(table, this.config);
|
|
}
|
|
}
|
|
|
|
class SQLiteBoolean extends SQLiteBaseInteger {
|
|
static [entityKind] = "SQLiteBoolean";
|
|
mode = this.config.mode;
|
|
mapFromDriverValue(value) {
|
|
return Number(value) === 1;
|
|
}
|
|
mapToDriverValue(value) {
|
|
return value ? 1 : 0;
|
|
}
|
|
}
|
|
function integer(a, b) {
|
|
const { name, config } = getColumnNameAndConfig(a, b);
|
|
if (config?.mode === "timestamp" || config?.mode === "timestamp_ms") {
|
|
return new SQLiteTimestampBuilder(name, config.mode);
|
|
}
|
|
if (config?.mode === "boolean") {
|
|
return new SQLiteBooleanBuilder(name, config.mode);
|
|
}
|
|
return new SQLiteIntegerBuilder(name);
|
|
}
|
|
|
|
// ../eve/node_modules/drizzle-orm/sqlite-core/columns/numeric.js
|
|
class SQLiteNumericBuilder extends SQLiteColumnBuilder {
|
|
static [entityKind] = "SQLiteNumericBuilder";
|
|
constructor(name) {
|
|
super(name, "string", "SQLiteNumeric");
|
|
}
|
|
build(table) {
|
|
return new SQLiteNumeric(table, this.config);
|
|
}
|
|
}
|
|
|
|
class SQLiteNumeric extends SQLiteColumn {
|
|
static [entityKind] = "SQLiteNumeric";
|
|
mapFromDriverValue(value) {
|
|
if (typeof value === "string")
|
|
return value;
|
|
return String(value);
|
|
}
|
|
getSQLType() {
|
|
return "numeric";
|
|
}
|
|
}
|
|
|
|
class SQLiteNumericNumberBuilder extends SQLiteColumnBuilder {
|
|
static [entityKind] = "SQLiteNumericNumberBuilder";
|
|
constructor(name) {
|
|
super(name, "number", "SQLiteNumericNumber");
|
|
}
|
|
build(table) {
|
|
return new SQLiteNumericNumber(table, this.config);
|
|
}
|
|
}
|
|
|
|
class SQLiteNumericNumber extends SQLiteColumn {
|
|
static [entityKind] = "SQLiteNumericNumber";
|
|
mapFromDriverValue(value) {
|
|
if (typeof value === "number")
|
|
return value;
|
|
return Number(value);
|
|
}
|
|
mapToDriverValue = String;
|
|
getSQLType() {
|
|
return "numeric";
|
|
}
|
|
}
|
|
|
|
class SQLiteNumericBigIntBuilder extends SQLiteColumnBuilder {
|
|
static [entityKind] = "SQLiteNumericBigIntBuilder";
|
|
constructor(name) {
|
|
super(name, "bigint", "SQLiteNumericBigInt");
|
|
}
|
|
build(table) {
|
|
return new SQLiteNumericBigInt(table, this.config);
|
|
}
|
|
}
|
|
|
|
class SQLiteNumericBigInt extends SQLiteColumn {
|
|
static [entityKind] = "SQLiteNumericBigInt";
|
|
mapFromDriverValue = BigInt;
|
|
mapToDriverValue = String;
|
|
getSQLType() {
|
|
return "numeric";
|
|
}
|
|
}
|
|
function numeric(a, b) {
|
|
const { name, config } = getColumnNameAndConfig(a, b);
|
|
const mode = config?.mode;
|
|
return mode === "number" ? new SQLiteNumericNumberBuilder(name) : mode === "bigint" ? new SQLiteNumericBigIntBuilder(name) : new SQLiteNumericBuilder(name);
|
|
}
|
|
|
|
// ../eve/node_modules/drizzle-orm/sqlite-core/columns/real.js
|
|
class SQLiteRealBuilder extends SQLiteColumnBuilder {
|
|
static [entityKind] = "SQLiteRealBuilder";
|
|
constructor(name) {
|
|
super(name, "number", "SQLiteReal");
|
|
}
|
|
build(table) {
|
|
return new SQLiteReal(table, this.config);
|
|
}
|
|
}
|
|
|
|
class SQLiteReal extends SQLiteColumn {
|
|
static [entityKind] = "SQLiteReal";
|
|
getSQLType() {
|
|
return "real";
|
|
}
|
|
}
|
|
function real(name) {
|
|
return new SQLiteRealBuilder(name ?? "");
|
|
}
|
|
|
|
// ../eve/node_modules/drizzle-orm/sqlite-core/columns/text.js
|
|
class SQLiteTextBuilder extends SQLiteColumnBuilder {
|
|
static [entityKind] = "SQLiteTextBuilder";
|
|
constructor(name, config) {
|
|
super(name, "string", "SQLiteText");
|
|
this.config.enumValues = config.enum;
|
|
this.config.length = config.length;
|
|
}
|
|
build(table) {
|
|
return new SQLiteText(table, this.config);
|
|
}
|
|
}
|
|
|
|
class SQLiteText extends SQLiteColumn {
|
|
static [entityKind] = "SQLiteText";
|
|
enumValues = this.config.enumValues;
|
|
length = this.config.length;
|
|
constructor(table, config) {
|
|
super(table, config);
|
|
}
|
|
getSQLType() {
|
|
return `text${this.config.length ? `(${this.config.length})` : ""}`;
|
|
}
|
|
}
|
|
|
|
class SQLiteTextJsonBuilder extends SQLiteColumnBuilder {
|
|
static [entityKind] = "SQLiteTextJsonBuilder";
|
|
constructor(name) {
|
|
super(name, "json", "SQLiteTextJson");
|
|
}
|
|
build(table) {
|
|
return new SQLiteTextJson(table, this.config);
|
|
}
|
|
}
|
|
|
|
class SQLiteTextJson extends SQLiteColumn {
|
|
static [entityKind] = "SQLiteTextJson";
|
|
getSQLType() {
|
|
return "text";
|
|
}
|
|
mapFromDriverValue(value) {
|
|
return JSON.parse(value);
|
|
}
|
|
mapToDriverValue(value) {
|
|
return JSON.stringify(value);
|
|
}
|
|
}
|
|
function text(a, b = {}) {
|
|
const { name, config } = getColumnNameAndConfig(a, b);
|
|
if (config.mode === "json") {
|
|
return new SQLiteTextJsonBuilder(name);
|
|
}
|
|
return new SQLiteTextBuilder(name, config);
|
|
}
|
|
|
|
// ../eve/node_modules/drizzle-orm/selection-proxy.js
|
|
class SelectionProxyHandler {
|
|
static [entityKind] = "SelectionProxyHandler";
|
|
config;
|
|
constructor(config) {
|
|
this.config = { ...config };
|
|
}
|
|
get(subquery, prop) {
|
|
if (prop === "_") {
|
|
return {
|
|
...subquery["_"],
|
|
selectedFields: new Proxy(subquery._.selectedFields, this)
|
|
};
|
|
}
|
|
if (prop === ViewBaseConfig) {
|
|
return {
|
|
...subquery[ViewBaseConfig],
|
|
selectedFields: new Proxy(subquery[ViewBaseConfig].selectedFields, this)
|
|
};
|
|
}
|
|
if (typeof prop === "symbol") {
|
|
return subquery[prop];
|
|
}
|
|
const columns = is(subquery, Subquery) ? subquery._.selectedFields : is(subquery, View) ? subquery[ViewBaseConfig].selectedFields : subquery;
|
|
const value = columns[prop];
|
|
if (is(value, SQL.Aliased)) {
|
|
if (this.config.sqlAliasedBehavior === "sql" && !value.isSelectionField) {
|
|
return value.sql;
|
|
}
|
|
const newValue = value.clone();
|
|
newValue.isSelectionField = true;
|
|
return newValue;
|
|
}
|
|
if (is(value, SQL)) {
|
|
if (this.config.sqlBehavior === "sql") {
|
|
return value;
|
|
}
|
|
throw new Error(`You tried to reference "${prop}" field from a subquery, which is a raw SQL field, but it doesn't have an alias declared. Please add an alias to the field using ".as('alias')" method.`);
|
|
}
|
|
if (is(value, Column)) {
|
|
if (this.config.alias) {
|
|
return new Proxy(value, new ColumnAliasProxyHandler(new Proxy(value.table, new TableAliasProxyHandler(this.config.alias, this.config.replaceOriginalName ?? false))));
|
|
}
|
|
return value;
|
|
}
|
|
if (typeof value !== "object" || value === null) {
|
|
return value;
|
|
}
|
|
return new Proxy(value, new SelectionProxyHandler(this.config));
|
|
}
|
|
}
|
|
|
|
// ../eve/node_modules/drizzle-orm/query-promise.js
|
|
class QueryPromise {
|
|
static [entityKind] = "QueryPromise";
|
|
[Symbol.toStringTag] = "QueryPromise";
|
|
catch(onRejected) {
|
|
return this.then(undefined, onRejected);
|
|
}
|
|
finally(onFinally) {
|
|
return this.then((value) => {
|
|
onFinally?.();
|
|
return value;
|
|
}, (reason) => {
|
|
onFinally?.();
|
|
throw reason;
|
|
});
|
|
}
|
|
then(onFulfilled, onRejected) {
|
|
return this.execute().then(onFulfilled, onRejected);
|
|
}
|
|
}
|
|
|
|
// ../eve/node_modules/drizzle-orm/sqlite-core/columns/all.js
|
|
function getSQLiteColumnBuilders() {
|
|
return {
|
|
blob,
|
|
customType,
|
|
integer,
|
|
numeric,
|
|
real,
|
|
text
|
|
};
|
|
}
|
|
|
|
// ../eve/node_modules/drizzle-orm/sqlite-core/table.js
|
|
var InlineForeignKeys = Symbol.for("drizzle:SQLiteInlineForeignKeys");
|
|
|
|
class SQLiteTable extends Table {
|
|
static [entityKind] = "SQLiteTable";
|
|
static Symbol = Object.assign({}, Table.Symbol, {
|
|
InlineForeignKeys
|
|
});
|
|
[Table.Symbol.Columns];
|
|
[InlineForeignKeys] = [];
|
|
[Table.Symbol.ExtraConfigBuilder] = undefined;
|
|
}
|
|
function sqliteTableBase(name, columns, extraConfig, schema, baseName = name) {
|
|
const rawTable = new SQLiteTable(name, schema, baseName);
|
|
const parsedColumns = typeof columns === "function" ? columns(getSQLiteColumnBuilders()) : columns;
|
|
const builtColumns = Object.fromEntries(Object.entries(parsedColumns).map(([name2, colBuilderBase]) => {
|
|
const colBuilder = colBuilderBase;
|
|
colBuilder.setName(name2);
|
|
const column = colBuilder.build(rawTable);
|
|
rawTable[InlineForeignKeys].push(...colBuilder.buildForeignKeys(column, rawTable));
|
|
return [name2, column];
|
|
}));
|
|
const table = Object.assign(rawTable, builtColumns);
|
|
table[Table.Symbol.Columns] = builtColumns;
|
|
table[Table.Symbol.ExtraConfigColumns] = builtColumns;
|
|
if (extraConfig) {
|
|
table[SQLiteTable.Symbol.ExtraConfigBuilder] = extraConfig;
|
|
}
|
|
return table;
|
|
}
|
|
var sqliteTable = (name, columns, extraConfig) => {
|
|
return sqliteTableBase(name, columns, extraConfig);
|
|
};
|
|
|
|
// ../eve/node_modules/drizzle-orm/sqlite-core/indexes.js
|
|
class IndexBuilderOn {
|
|
constructor(name, unique) {
|
|
this.name = name;
|
|
this.unique = unique;
|
|
}
|
|
static [entityKind] = "SQLiteIndexBuilderOn";
|
|
on(...columns) {
|
|
return new IndexBuilder(this.name, columns, this.unique);
|
|
}
|
|
}
|
|
|
|
class IndexBuilder {
|
|
static [entityKind] = "SQLiteIndexBuilder";
|
|
config;
|
|
constructor(name, columns, unique) {
|
|
this.config = {
|
|
name,
|
|
columns,
|
|
unique,
|
|
where: undefined
|
|
};
|
|
}
|
|
where(condition) {
|
|
this.config.where = condition;
|
|
return this;
|
|
}
|
|
build(table) {
|
|
return new Index(this.config, table);
|
|
}
|
|
}
|
|
|
|
class Index {
|
|
static [entityKind] = "SQLiteIndex";
|
|
config;
|
|
constructor(config, table) {
|
|
this.config = { ...config, table };
|
|
}
|
|
}
|
|
function index(name) {
|
|
return new IndexBuilderOn(name, false);
|
|
}
|
|
|
|
// ../eve/node_modules/drizzle-orm/sqlite-core/utils.js
|
|
function extractUsedTable(table) {
|
|
if (is(table, SQLiteTable)) {
|
|
return [`${table[Table.Symbol.BaseName]}`];
|
|
}
|
|
if (is(table, Subquery)) {
|
|
return table._.usedTables ?? [];
|
|
}
|
|
if (is(table, SQL)) {
|
|
return table.usedTables ?? [];
|
|
}
|
|
return [];
|
|
}
|
|
|
|
// ../eve/node_modules/drizzle-orm/sqlite-core/query-builders/delete.js
|
|
class SQLiteDeleteBase extends QueryPromise {
|
|
constructor(table, session, dialect, withList) {
|
|
super();
|
|
this.table = table;
|
|
this.session = session;
|
|
this.dialect = dialect;
|
|
this.config = { table, withList };
|
|
}
|
|
static [entityKind] = "SQLiteDelete";
|
|
config;
|
|
where(where) {
|
|
this.config.where = where;
|
|
return this;
|
|
}
|
|
orderBy(...columns) {
|
|
if (typeof columns[0] === "function") {
|
|
const orderBy = columns[0](new Proxy(this.config.table[Table.Symbol.Columns], new SelectionProxyHandler({ sqlAliasedBehavior: "alias", sqlBehavior: "sql" })));
|
|
const orderByArray = Array.isArray(orderBy) ? orderBy : [orderBy];
|
|
this.config.orderBy = orderByArray;
|
|
} else {
|
|
const orderByArray = columns;
|
|
this.config.orderBy = orderByArray;
|
|
}
|
|
return this;
|
|
}
|
|
limit(limit) {
|
|
this.config.limit = limit;
|
|
return this;
|
|
}
|
|
returning(fields = this.table[SQLiteTable.Symbol.Columns]) {
|
|
this.config.returning = orderSelectedFields(fields);
|
|
return this;
|
|
}
|
|
getSQL() {
|
|
return this.dialect.buildDeleteQuery(this.config);
|
|
}
|
|
toSQL() {
|
|
const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
|
|
return rest;
|
|
}
|
|
_prepare(isOneTimeQuery = true) {
|
|
return this.session[isOneTimeQuery ? "prepareOneTimeQuery" : "prepareQuery"](this.dialect.sqlToQuery(this.getSQL()), this.config.returning, this.config.returning ? "all" : "run", true, undefined, {
|
|
type: "delete",
|
|
tables: extractUsedTable(this.config.table)
|
|
});
|
|
}
|
|
prepare() {
|
|
return this._prepare(false);
|
|
}
|
|
run = (placeholderValues) => {
|
|
return this._prepare().run(placeholderValues);
|
|
};
|
|
all = (placeholderValues) => {
|
|
return this._prepare().all(placeholderValues);
|
|
};
|
|
get = (placeholderValues) => {
|
|
return this._prepare().get(placeholderValues);
|
|
};
|
|
values = (placeholderValues) => {
|
|
return this._prepare().values(placeholderValues);
|
|
};
|
|
async execute(placeholderValues) {
|
|
return this._prepare().execute(placeholderValues);
|
|
}
|
|
$dynamic() {
|
|
return this;
|
|
}
|
|
}
|
|
|
|
// ../eve/node_modules/drizzle-orm/casing.js
|
|
function toSnakeCase(input) {
|
|
const words = input.replace(/['\u2019]/g, "").match(/[\da-z]+|[A-Z]+(?![a-z])|[A-Z][\da-z]+/g) ?? [];
|
|
return words.map((word) => word.toLowerCase()).join("_");
|
|
}
|
|
function toCamelCase(input) {
|
|
const words = input.replace(/['\u2019]/g, "").match(/[\da-z]+|[A-Z]+(?![a-z])|[A-Z][\da-z]+/g) ?? [];
|
|
return words.reduce((acc, word, i) => {
|
|
const formattedWord = i === 0 ? word.toLowerCase() : `${word[0].toUpperCase()}${word.slice(1)}`;
|
|
return acc + formattedWord;
|
|
}, "");
|
|
}
|
|
function noopCase(input) {
|
|
return input;
|
|
}
|
|
|
|
class CasingCache {
|
|
static [entityKind] = "CasingCache";
|
|
cache = {};
|
|
cachedTables = {};
|
|
convert;
|
|
constructor(casing) {
|
|
this.convert = casing === "snake_case" ? toSnakeCase : casing === "camelCase" ? toCamelCase : noopCase;
|
|
}
|
|
getColumnCasing(column) {
|
|
if (!column.keyAsName)
|
|
return column.name;
|
|
const schema = column.table[Table.Symbol.Schema] ?? "public";
|
|
const tableName = column.table[Table.Symbol.OriginalName];
|
|
const key = `${schema}.${tableName}.${column.name}`;
|
|
if (!this.cache[key]) {
|
|
this.cacheTable(column.table);
|
|
}
|
|
return this.cache[key];
|
|
}
|
|
cacheTable(table) {
|
|
const schema = table[Table.Symbol.Schema] ?? "public";
|
|
const tableName = table[Table.Symbol.OriginalName];
|
|
const tableKey = `${schema}.${tableName}`;
|
|
if (!this.cachedTables[tableKey]) {
|
|
for (const column of Object.values(table[Table.Symbol.Columns])) {
|
|
const columnKey = `${tableKey}.${column.name}`;
|
|
this.cache[columnKey] = this.convert(column.name);
|
|
}
|
|
this.cachedTables[tableKey] = true;
|
|
}
|
|
}
|
|
clearCache() {
|
|
this.cache = {};
|
|
this.cachedTables = {};
|
|
}
|
|
}
|
|
|
|
// ../eve/node_modules/drizzle-orm/errors.js
|
|
class DrizzleError extends Error {
|
|
static [entityKind] = "DrizzleError";
|
|
constructor({ message, cause }) {
|
|
super(message);
|
|
this.name = "DrizzleError";
|
|
this.cause = cause;
|
|
}
|
|
}
|
|
|
|
class DrizzleQueryError extends Error {
|
|
constructor(query, params, cause) {
|
|
super(`Failed query: ${query}
|
|
params: ${params}`);
|
|
this.query = query;
|
|
this.params = params;
|
|
this.cause = cause;
|
|
Error.captureStackTrace(this, DrizzleQueryError);
|
|
if (cause)
|
|
this.cause = cause;
|
|
}
|
|
}
|
|
|
|
class TransactionRollbackError extends DrizzleError {
|
|
static [entityKind] = "TransactionRollbackError";
|
|
constructor() {
|
|
super({ message: "Rollback" });
|
|
}
|
|
}
|
|
|
|
// ../eve/node_modules/drizzle-orm/pg-core/table.js
|
|
var InlineForeignKeys2 = Symbol.for("drizzle:PgInlineForeignKeys");
|
|
var EnableRLS = Symbol.for("drizzle:EnableRLS");
|
|
|
|
class PgTable extends Table {
|
|
static [entityKind] = "PgTable";
|
|
static Symbol = Object.assign({}, Table.Symbol, {
|
|
InlineForeignKeys: InlineForeignKeys2,
|
|
EnableRLS
|
|
});
|
|
[InlineForeignKeys2] = [];
|
|
[EnableRLS] = false;
|
|
[Table.Symbol.ExtraConfigBuilder] = undefined;
|
|
[Table.Symbol.ExtraConfigColumns] = {};
|
|
}
|
|
|
|
// ../eve/node_modules/drizzle-orm/pg-core/primary-keys.js
|
|
class PrimaryKeyBuilder {
|
|
static [entityKind] = "PgPrimaryKeyBuilder";
|
|
columns;
|
|
name;
|
|
constructor(columns, name) {
|
|
this.columns = columns;
|
|
this.name = name;
|
|
}
|
|
build(table) {
|
|
return new PrimaryKey(table, this.columns, this.name);
|
|
}
|
|
}
|
|
|
|
class PrimaryKey {
|
|
constructor(table, columns, name) {
|
|
this.table = table;
|
|
this.columns = columns;
|
|
this.name = name;
|
|
}
|
|
static [entityKind] = "PgPrimaryKey";
|
|
columns;
|
|
name;
|
|
getName() {
|
|
return this.name ?? `${this.table[PgTable.Symbol.Name]}_${this.columns.map((column) => column.name).join("_")}_pk`;
|
|
}
|
|
}
|
|
|
|
// ../eve/node_modules/drizzle-orm/sql/expressions/conditions.js
|
|
function bindIfParam(value, column) {
|
|
if (isDriverValueEncoder(column) && !isSQLWrapper(value) && !is(value, Param) && !is(value, Placeholder) && !is(value, Column) && !is(value, Table) && !is(value, View)) {
|
|
return new Param(value, column);
|
|
}
|
|
return value;
|
|
}
|
|
var eq = (left, right) => {
|
|
return sql`${left} = ${bindIfParam(right, left)}`;
|
|
};
|
|
var ne = (left, right) => {
|
|
return sql`${left} <> ${bindIfParam(right, left)}`;
|
|
};
|
|
function and(...unfilteredConditions) {
|
|
const conditions = unfilteredConditions.filter((c) => c !== undefined);
|
|
if (conditions.length === 0) {
|
|
return;
|
|
}
|
|
if (conditions.length === 1) {
|
|
return new SQL(conditions);
|
|
}
|
|
return new SQL([
|
|
new StringChunk("("),
|
|
sql.join(conditions, new StringChunk(" and ")),
|
|
new StringChunk(")")
|
|
]);
|
|
}
|
|
function or(...unfilteredConditions) {
|
|
const conditions = unfilteredConditions.filter((c) => c !== undefined);
|
|
if (conditions.length === 0) {
|
|
return;
|
|
}
|
|
if (conditions.length === 1) {
|
|
return new SQL(conditions);
|
|
}
|
|
return new SQL([
|
|
new StringChunk("("),
|
|
sql.join(conditions, new StringChunk(" or ")),
|
|
new StringChunk(")")
|
|
]);
|
|
}
|
|
function not(condition) {
|
|
return sql`not ${condition}`;
|
|
}
|
|
var gt = (left, right) => {
|
|
return sql`${left} > ${bindIfParam(right, left)}`;
|
|
};
|
|
var gte = (left, right) => {
|
|
return sql`${left} >= ${bindIfParam(right, left)}`;
|
|
};
|
|
var lt = (left, right) => {
|
|
return sql`${left} < ${bindIfParam(right, left)}`;
|
|
};
|
|
var lte = (left, right) => {
|
|
return sql`${left} <= ${bindIfParam(right, left)}`;
|
|
};
|
|
function inArray(column, values) {
|
|
if (Array.isArray(values)) {
|
|
if (values.length === 0) {
|
|
return sql`false`;
|
|
}
|
|
return sql`${column} in ${values.map((v) => bindIfParam(v, column))}`;
|
|
}
|
|
return sql`${column} in ${bindIfParam(values, column)}`;
|
|
}
|
|
function notInArray(column, values) {
|
|
if (Array.isArray(values)) {
|
|
if (values.length === 0) {
|
|
return sql`true`;
|
|
}
|
|
return sql`${column} not in ${values.map((v) => bindIfParam(v, column))}`;
|
|
}
|
|
return sql`${column} not in ${bindIfParam(values, column)}`;
|
|
}
|
|
function isNull(value) {
|
|
return sql`${value} is null`;
|
|
}
|
|
function isNotNull(value) {
|
|
return sql`${value} is not null`;
|
|
}
|
|
function exists(subquery) {
|
|
return sql`exists ${subquery}`;
|
|
}
|
|
function notExists(subquery) {
|
|
return sql`not exists ${subquery}`;
|
|
}
|
|
function between(column, min, max) {
|
|
return sql`${column} between ${bindIfParam(min, column)} and ${bindIfParam(max, column)}`;
|
|
}
|
|
function notBetween(column, min, max) {
|
|
return sql`${column} not between ${bindIfParam(min, column)} and ${bindIfParam(max, column)}`;
|
|
}
|
|
function like(column, value) {
|
|
return sql`${column} like ${value}`;
|
|
}
|
|
function notLike(column, value) {
|
|
return sql`${column} not like ${value}`;
|
|
}
|
|
function ilike(column, value) {
|
|
return sql`${column} ilike ${value}`;
|
|
}
|
|
function notIlike(column, value) {
|
|
return sql`${column} not ilike ${value}`;
|
|
}
|
|
|
|
// ../eve/node_modules/drizzle-orm/sql/expressions/select.js
|
|
function asc(column) {
|
|
return sql`${column} asc`;
|
|
}
|
|
function desc(column) {
|
|
return sql`${column} desc`;
|
|
}
|
|
|
|
// ../eve/node_modules/drizzle-orm/relations.js
|
|
class Relation {
|
|
constructor(sourceTable, referencedTable, relationName) {
|
|
this.sourceTable = sourceTable;
|
|
this.referencedTable = referencedTable;
|
|
this.relationName = relationName;
|
|
this.referencedTableName = referencedTable[Table.Symbol.Name];
|
|
}
|
|
static [entityKind] = "Relation";
|
|
referencedTableName;
|
|
fieldName;
|
|
}
|
|
|
|
class Relations {
|
|
constructor(table, config) {
|
|
this.table = table;
|
|
this.config = config;
|
|
}
|
|
static [entityKind] = "Relations";
|
|
}
|
|
|
|
class One extends Relation {
|
|
constructor(sourceTable, referencedTable, config, isNullable) {
|
|
super(sourceTable, referencedTable, config?.relationName);
|
|
this.config = config;
|
|
this.isNullable = isNullable;
|
|
}
|
|
static [entityKind] = "One";
|
|
withFieldName(fieldName) {
|
|
const relation = new One(this.sourceTable, this.referencedTable, this.config, this.isNullable);
|
|
relation.fieldName = fieldName;
|
|
return relation;
|
|
}
|
|
}
|
|
|
|
class Many extends Relation {
|
|
constructor(sourceTable, referencedTable, config) {
|
|
super(sourceTable, referencedTable, config?.relationName);
|
|
this.config = config;
|
|
}
|
|
static [entityKind] = "Many";
|
|
withFieldName(fieldName) {
|
|
const relation = new Many(this.sourceTable, this.referencedTable, this.config);
|
|
relation.fieldName = fieldName;
|
|
return relation;
|
|
}
|
|
}
|
|
function getOperators() {
|
|
return {
|
|
and,
|
|
between,
|
|
eq,
|
|
exists,
|
|
gt,
|
|
gte,
|
|
ilike,
|
|
inArray,
|
|
isNull,
|
|
isNotNull,
|
|
like,
|
|
lt,
|
|
lte,
|
|
ne,
|
|
not,
|
|
notBetween,
|
|
notExists,
|
|
notLike,
|
|
notIlike,
|
|
notInArray,
|
|
or,
|
|
sql
|
|
};
|
|
}
|
|
function getOrderByOperators() {
|
|
return {
|
|
sql,
|
|
asc,
|
|
desc
|
|
};
|
|
}
|
|
function extractTablesRelationalConfig(schema, configHelpers) {
|
|
if (Object.keys(schema).length === 1 && "default" in schema && !is(schema["default"], Table)) {
|
|
schema = schema["default"];
|
|
}
|
|
const tableNamesMap = {};
|
|
const relationsBuffer = {};
|
|
const tablesConfig = {};
|
|
for (const [key, value] of Object.entries(schema)) {
|
|
if (is(value, Table)) {
|
|
const dbName = getTableUniqueName(value);
|
|
const bufferedRelations = relationsBuffer[dbName];
|
|
tableNamesMap[dbName] = key;
|
|
tablesConfig[key] = {
|
|
tsName: key,
|
|
dbName: value[Table.Symbol.Name],
|
|
schema: value[Table.Symbol.Schema],
|
|
columns: value[Table.Symbol.Columns],
|
|
relations: bufferedRelations?.relations ?? {},
|
|
primaryKey: bufferedRelations?.primaryKey ?? []
|
|
};
|
|
for (const column of Object.values(value[Table.Symbol.Columns])) {
|
|
if (column.primary) {
|
|
tablesConfig[key].primaryKey.push(column);
|
|
}
|
|
}
|
|
const extraConfig = value[Table.Symbol.ExtraConfigBuilder]?.(value[Table.Symbol.ExtraConfigColumns]);
|
|
if (extraConfig) {
|
|
for (const configEntry of Object.values(extraConfig)) {
|
|
if (is(configEntry, PrimaryKeyBuilder)) {
|
|
tablesConfig[key].primaryKey.push(...configEntry.columns);
|
|
}
|
|
}
|
|
}
|
|
} else if (is(value, Relations)) {
|
|
const dbName = getTableUniqueName(value.table);
|
|
const tableName = tableNamesMap[dbName];
|
|
const relations2 = value.config(configHelpers(value.table));
|
|
let primaryKey;
|
|
for (const [relationName, relation] of Object.entries(relations2)) {
|
|
if (tableName) {
|
|
const tableConfig = tablesConfig[tableName];
|
|
tableConfig.relations[relationName] = relation;
|
|
if (primaryKey) {
|
|
tableConfig.primaryKey.push(...primaryKey);
|
|
}
|
|
} else {
|
|
if (!(dbName in relationsBuffer)) {
|
|
relationsBuffer[dbName] = {
|
|
relations: {},
|
|
primaryKey
|
|
};
|
|
}
|
|
relationsBuffer[dbName].relations[relationName] = relation;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return { tables: tablesConfig, tableNamesMap };
|
|
}
|
|
function relations(table, relations2) {
|
|
return new Relations(table, (helpers) => Object.fromEntries(Object.entries(relations2(helpers)).map(([key, value]) => [
|
|
key,
|
|
value.withFieldName(key)
|
|
])));
|
|
}
|
|
function createOne(sourceTable) {
|
|
return function one(table, config) {
|
|
return new One(sourceTable, table, config, config?.fields.reduce((res, f) => res && f.notNull, true) ?? false);
|
|
};
|
|
}
|
|
function createMany(sourceTable) {
|
|
return function many(referencedTable, config) {
|
|
return new Many(sourceTable, referencedTable, config);
|
|
};
|
|
}
|
|
function normalizeRelation(schema, tableNamesMap, relation) {
|
|
if (is(relation, One) && relation.config) {
|
|
return {
|
|
fields: relation.config.fields,
|
|
references: relation.config.references
|
|
};
|
|
}
|
|
const referencedTableTsName = tableNamesMap[getTableUniqueName(relation.referencedTable)];
|
|
if (!referencedTableTsName) {
|
|
throw new Error(`Table "${relation.referencedTable[Table.Symbol.Name]}" not found in schema`);
|
|
}
|
|
const referencedTableConfig = schema[referencedTableTsName];
|
|
if (!referencedTableConfig) {
|
|
throw new Error(`Table "${referencedTableTsName}" not found in schema`);
|
|
}
|
|
const sourceTable = relation.sourceTable;
|
|
const sourceTableTsName = tableNamesMap[getTableUniqueName(sourceTable)];
|
|
if (!sourceTableTsName) {
|
|
throw new Error(`Table "${sourceTable[Table.Symbol.Name]}" not found in schema`);
|
|
}
|
|
const reverseRelations = [];
|
|
for (const referencedTableRelation of Object.values(referencedTableConfig.relations)) {
|
|
if (relation.relationName && relation !== referencedTableRelation && referencedTableRelation.relationName === relation.relationName || !relation.relationName && referencedTableRelation.referencedTable === relation.sourceTable) {
|
|
reverseRelations.push(referencedTableRelation);
|
|
}
|
|
}
|
|
if (reverseRelations.length > 1) {
|
|
throw relation.relationName ? new Error(`There are multiple relations with name "${relation.relationName}" in table "${referencedTableTsName}"`) : new Error(`There are multiple relations between "${referencedTableTsName}" and "${relation.sourceTable[Table.Symbol.Name]}". Please specify relation name`);
|
|
}
|
|
if (reverseRelations[0] && is(reverseRelations[0], One) && reverseRelations[0].config) {
|
|
return {
|
|
fields: reverseRelations[0].config.references,
|
|
references: reverseRelations[0].config.fields
|
|
};
|
|
}
|
|
throw new Error(`There is not enough information to infer relation "${sourceTableTsName}.${relation.fieldName}"`);
|
|
}
|
|
function createTableRelationsHelpers(sourceTable) {
|
|
return {
|
|
one: createOne(sourceTable),
|
|
many: createMany(sourceTable)
|
|
};
|
|
}
|
|
function mapRelationalRow(tablesConfig, tableConfig, row, buildQueryResultSelection, mapColumnValue = (value) => value) {
|
|
const result = {};
|
|
for (const [
|
|
selectionItemIndex,
|
|
selectionItem
|
|
] of buildQueryResultSelection.entries()) {
|
|
if (selectionItem.isJson) {
|
|
const relation = tableConfig.relations[selectionItem.tsKey];
|
|
const rawSubRows = row[selectionItemIndex];
|
|
const subRows = typeof rawSubRows === "string" ? JSON.parse(rawSubRows) : rawSubRows;
|
|
result[selectionItem.tsKey] = is(relation, One) ? subRows && mapRelationalRow(tablesConfig, tablesConfig[selectionItem.relationTableTsKey], subRows, selectionItem.selection, mapColumnValue) : subRows.map((subRow) => mapRelationalRow(tablesConfig, tablesConfig[selectionItem.relationTableTsKey], subRow, selectionItem.selection, mapColumnValue));
|
|
} else {
|
|
const value = mapColumnValue(row[selectionItemIndex]);
|
|
const field = selectionItem.field;
|
|
let decoder;
|
|
if (is(field, Column)) {
|
|
decoder = field;
|
|
} else if (is(field, SQL)) {
|
|
decoder = field.decoder;
|
|
} else {
|
|
decoder = field.sql.decoder;
|
|
}
|
|
result[selectionItem.tsKey] = value === null ? null : decoder.mapFromDriverValue(value);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// ../eve/node_modules/drizzle-orm/sqlite-core/view-base.js
|
|
class SQLiteViewBase extends View {
|
|
static [entityKind] = "SQLiteViewBase";
|
|
}
|
|
|
|
// ../eve/node_modules/drizzle-orm/sqlite-core/dialect.js
|
|
class SQLiteDialect {
|
|
static [entityKind] = "SQLiteDialect";
|
|
casing;
|
|
constructor(config) {
|
|
this.casing = new CasingCache(config?.casing);
|
|
}
|
|
escapeName(name) {
|
|
return `"${name}"`;
|
|
}
|
|
escapeParam(_num) {
|
|
return "?";
|
|
}
|
|
escapeString(str) {
|
|
return `'${str.replace(/'/g, "''")}'`;
|
|
}
|
|
buildWithCTE(queries) {
|
|
if (!queries?.length)
|
|
return;
|
|
const withSqlChunks = [sql`with `];
|
|
for (const [i, w] of queries.entries()) {
|
|
withSqlChunks.push(sql`${sql.identifier(w._.alias)} as (${w._.sql})`);
|
|
if (i < queries.length - 1) {
|
|
withSqlChunks.push(sql`, `);
|
|
}
|
|
}
|
|
withSqlChunks.push(sql` `);
|
|
return sql.join(withSqlChunks);
|
|
}
|
|
buildDeleteQuery({ table, where, returning, withList, limit, orderBy }) {
|
|
const withSql = this.buildWithCTE(withList);
|
|
const returningSql = returning ? sql` returning ${this.buildSelection(returning, { isSingleTable: true })}` : undefined;
|
|
const whereSql = where ? sql` where ${where}` : undefined;
|
|
const orderBySql = this.buildOrderBy(orderBy);
|
|
const limitSql = this.buildLimit(limit);
|
|
return sql`${withSql}delete from ${table}${whereSql}${returningSql}${orderBySql}${limitSql}`;
|
|
}
|
|
buildUpdateSet(table, set) {
|
|
const tableColumns = table[Table.Symbol.Columns];
|
|
const columnNames = Object.keys(tableColumns).filter((colName) => set[colName] !== undefined || tableColumns[colName]?.onUpdateFn !== undefined);
|
|
const setSize = columnNames.length;
|
|
return sql.join(columnNames.flatMap((colName, i) => {
|
|
const col = tableColumns[colName];
|
|
const value = set[colName] ?? sql.param(col.onUpdateFn(), col);
|
|
const res = sql`${sql.identifier(this.casing.getColumnCasing(col))} = ${value}`;
|
|
if (i < setSize - 1) {
|
|
return [res, sql.raw(", ")];
|
|
}
|
|
return [res];
|
|
}));
|
|
}
|
|
buildUpdateQuery({ table, set, where, returning, withList, joins, from, limit, orderBy }) {
|
|
const withSql = this.buildWithCTE(withList);
|
|
const setSql = this.buildUpdateSet(table, set);
|
|
const fromSql = from && sql.join([sql.raw(" from "), this.buildFromTable(from)]);
|
|
const joinsSql = this.buildJoins(joins);
|
|
const returningSql = returning ? sql` returning ${this.buildSelection(returning, { isSingleTable: true })}` : undefined;
|
|
const whereSql = where ? sql` where ${where}` : undefined;
|
|
const orderBySql = this.buildOrderBy(orderBy);
|
|
const limitSql = this.buildLimit(limit);
|
|
return sql`${withSql}update ${table} set ${setSql}${fromSql}${joinsSql}${whereSql}${returningSql}${orderBySql}${limitSql}`;
|
|
}
|
|
buildSelection(fields, { isSingleTable = false } = {}) {
|
|
const columnsLen = fields.length;
|
|
const chunks = fields.flatMap(({ field }, i) => {
|
|
const chunk = [];
|
|
if (is(field, SQL.Aliased) && field.isSelectionField) {
|
|
chunk.push(sql.identifier(field.fieldAlias));
|
|
} else if (is(field, SQL.Aliased) || is(field, SQL)) {
|
|
const query = is(field, SQL.Aliased) ? field.sql : field;
|
|
if (isSingleTable) {
|
|
chunk.push(new SQL(query.queryChunks.map((c) => {
|
|
if (is(c, Column)) {
|
|
return sql.identifier(this.casing.getColumnCasing(c));
|
|
}
|
|
return c;
|
|
})));
|
|
} else {
|
|
chunk.push(query);
|
|
}
|
|
if (is(field, SQL.Aliased)) {
|
|
chunk.push(sql` as ${sql.identifier(field.fieldAlias)}`);
|
|
}
|
|
} else if (is(field, Column)) {
|
|
const tableName = field.table[Table.Symbol.Name];
|
|
if (field.columnType === "SQLiteNumericBigInt") {
|
|
if (isSingleTable) {
|
|
chunk.push(sql`cast(${sql.identifier(this.casing.getColumnCasing(field))} as text)`);
|
|
} else {
|
|
chunk.push(sql`cast(${sql.identifier(tableName)}.${sql.identifier(this.casing.getColumnCasing(field))} as text)`);
|
|
}
|
|
} else {
|
|
if (isSingleTable) {
|
|
chunk.push(sql.identifier(this.casing.getColumnCasing(field)));
|
|
} else {
|
|
chunk.push(sql`${sql.identifier(tableName)}.${sql.identifier(this.casing.getColumnCasing(field))}`);
|
|
}
|
|
}
|
|
}
|
|
if (i < columnsLen - 1) {
|
|
chunk.push(sql`, `);
|
|
}
|
|
return chunk;
|
|
});
|
|
return sql.join(chunks);
|
|
}
|
|
buildJoins(joins) {
|
|
if (!joins || joins.length === 0) {
|
|
return;
|
|
}
|
|
const joinsArray = [];
|
|
if (joins) {
|
|
for (const [index2, joinMeta] of joins.entries()) {
|
|
if (index2 === 0) {
|
|
joinsArray.push(sql` `);
|
|
}
|
|
const table = joinMeta.table;
|
|
const onSql = joinMeta.on ? sql` on ${joinMeta.on}` : undefined;
|
|
if (is(table, SQLiteTable)) {
|
|
const tableName = table[SQLiteTable.Symbol.Name];
|
|
const tableSchema = table[SQLiteTable.Symbol.Schema];
|
|
const origTableName = table[SQLiteTable.Symbol.OriginalName];
|
|
const alias = tableName === origTableName ? undefined : joinMeta.alias;
|
|
joinsArray.push(sql`${sql.raw(joinMeta.joinType)} join ${tableSchema ? sql`${sql.identifier(tableSchema)}.` : undefined}${sql.identifier(origTableName)}${alias && sql` ${sql.identifier(alias)}`}${onSql}`);
|
|
} else {
|
|
joinsArray.push(sql`${sql.raw(joinMeta.joinType)} join ${table}${onSql}`);
|
|
}
|
|
if (index2 < joins.length - 1) {
|
|
joinsArray.push(sql` `);
|
|
}
|
|
}
|
|
}
|
|
return sql.join(joinsArray);
|
|
}
|
|
buildLimit(limit) {
|
|
return typeof limit === "object" || typeof limit === "number" && limit >= 0 ? sql` limit ${limit}` : undefined;
|
|
}
|
|
buildOrderBy(orderBy) {
|
|
const orderByList = [];
|
|
if (orderBy) {
|
|
for (const [index2, orderByValue] of orderBy.entries()) {
|
|
orderByList.push(orderByValue);
|
|
if (index2 < orderBy.length - 1) {
|
|
orderByList.push(sql`, `);
|
|
}
|
|
}
|
|
}
|
|
return orderByList.length > 0 ? sql` order by ${sql.join(orderByList)}` : undefined;
|
|
}
|
|
buildFromTable(table) {
|
|
if (is(table, Table) && table[Table.Symbol.IsAlias]) {
|
|
return sql`${sql`${sql.identifier(table[Table.Symbol.Schema] ?? "")}.`.if(table[Table.Symbol.Schema])}${sql.identifier(table[Table.Symbol.OriginalName])} ${sql.identifier(table[Table.Symbol.Name])}`;
|
|
}
|
|
return table;
|
|
}
|
|
buildSelectQuery({
|
|
withList,
|
|
fields,
|
|
fieldsFlat,
|
|
where,
|
|
having,
|
|
table,
|
|
joins,
|
|
orderBy,
|
|
groupBy,
|
|
limit,
|
|
offset,
|
|
distinct,
|
|
setOperators
|
|
}) {
|
|
const fieldsList = fieldsFlat ?? orderSelectedFields(fields);
|
|
for (const f of fieldsList) {
|
|
if (is(f.field, Column) && getTableName(f.field.table) !== (is(table, Subquery) ? table._.alias : is(table, SQLiteViewBase) ? table[ViewBaseConfig].name : is(table, SQL) ? undefined : getTableName(table)) && !((table2) => joins?.some(({ alias }) => alias === (table2[Table.Symbol.IsAlias] ? getTableName(table2) : table2[Table.Symbol.BaseName])))(f.field.table)) {
|
|
const tableName = getTableName(f.field.table);
|
|
throw new Error(`Your "${f.path.join("->")}" field references a column "${tableName}"."${f.field.name}", but the table "${tableName}" is not part of the query! Did you forget to join it?`);
|
|
}
|
|
}
|
|
const isSingleTable = !joins || joins.length === 0;
|
|
const withSql = this.buildWithCTE(withList);
|
|
const distinctSql = distinct ? sql` distinct` : undefined;
|
|
const selection = this.buildSelection(fieldsList, { isSingleTable });
|
|
const tableSql = this.buildFromTable(table);
|
|
const joinsSql = this.buildJoins(joins);
|
|
const whereSql = where ? sql` where ${where}` : undefined;
|
|
const havingSql = having ? sql` having ${having}` : undefined;
|
|
const groupByList = [];
|
|
if (groupBy) {
|
|
for (const [index2, groupByValue] of groupBy.entries()) {
|
|
groupByList.push(groupByValue);
|
|
if (index2 < groupBy.length - 1) {
|
|
groupByList.push(sql`, `);
|
|
}
|
|
}
|
|
}
|
|
const groupBySql = groupByList.length > 0 ? sql` group by ${sql.join(groupByList)}` : undefined;
|
|
const orderBySql = this.buildOrderBy(orderBy);
|
|
const limitSql = this.buildLimit(limit);
|
|
const offsetSql = offset ? sql` offset ${offset}` : undefined;
|
|
const finalQuery = sql`${withSql}select${distinctSql} ${selection} from ${tableSql}${joinsSql}${whereSql}${groupBySql}${havingSql}${orderBySql}${limitSql}${offsetSql}`;
|
|
if (setOperators.length > 0) {
|
|
return this.buildSetOperations(finalQuery, setOperators);
|
|
}
|
|
return finalQuery;
|
|
}
|
|
buildSetOperations(leftSelect, setOperators) {
|
|
const [setOperator, ...rest] = setOperators;
|
|
if (!setOperator) {
|
|
throw new Error("Cannot pass undefined values to any set operator");
|
|
}
|
|
if (rest.length === 0) {
|
|
return this.buildSetOperationQuery({ leftSelect, setOperator });
|
|
}
|
|
return this.buildSetOperations(this.buildSetOperationQuery({ leftSelect, setOperator }), rest);
|
|
}
|
|
buildSetOperationQuery({
|
|
leftSelect,
|
|
setOperator: { type, isAll, rightSelect, limit, orderBy, offset }
|
|
}) {
|
|
const leftChunk = sql`${leftSelect.getSQL()} `;
|
|
const rightChunk = sql`${rightSelect.getSQL()}`;
|
|
let orderBySql;
|
|
if (orderBy && orderBy.length > 0) {
|
|
const orderByValues = [];
|
|
for (const singleOrderBy of orderBy) {
|
|
if (is(singleOrderBy, SQLiteColumn)) {
|
|
orderByValues.push(sql.identifier(singleOrderBy.name));
|
|
} else if (is(singleOrderBy, SQL)) {
|
|
for (let i = 0;i < singleOrderBy.queryChunks.length; i++) {
|
|
const chunk = singleOrderBy.queryChunks[i];
|
|
if (is(chunk, SQLiteColumn)) {
|
|
singleOrderBy.queryChunks[i] = sql.identifier(this.casing.getColumnCasing(chunk));
|
|
}
|
|
}
|
|
orderByValues.push(sql`${singleOrderBy}`);
|
|
} else {
|
|
orderByValues.push(sql`${singleOrderBy}`);
|
|
}
|
|
}
|
|
orderBySql = sql` order by ${sql.join(orderByValues, sql`, `)}`;
|
|
}
|
|
const limitSql = typeof limit === "object" || typeof limit === "number" && limit >= 0 ? sql` limit ${limit}` : undefined;
|
|
const operatorChunk = sql.raw(`${type} ${isAll ? "all " : ""}`);
|
|
const offsetSql = offset ? sql` offset ${offset}` : undefined;
|
|
return sql`${leftChunk}${operatorChunk}${rightChunk}${orderBySql}${limitSql}${offsetSql}`;
|
|
}
|
|
buildInsertQuery({ table, values: valuesOrSelect, onConflict, returning, withList, select }) {
|
|
const valuesSqlList = [];
|
|
const columns = table[Table.Symbol.Columns];
|
|
const colEntries = Object.entries(columns).filter(([_, col]) => !col.shouldDisableInsert());
|
|
const insertOrder = colEntries.map(([, column]) => sql.identifier(this.casing.getColumnCasing(column)));
|
|
if (select) {
|
|
const select2 = valuesOrSelect;
|
|
if (is(select2, SQL)) {
|
|
valuesSqlList.push(select2);
|
|
} else {
|
|
valuesSqlList.push(select2.getSQL());
|
|
}
|
|
} else {
|
|
const values = valuesOrSelect;
|
|
valuesSqlList.push(sql.raw("values "));
|
|
for (const [valueIndex, value] of values.entries()) {
|
|
const valueList = [];
|
|
for (const [fieldName, col] of colEntries) {
|
|
const colValue = value[fieldName];
|
|
if (colValue === undefined || is(colValue, Param) && colValue.value === undefined) {
|
|
let defaultValue;
|
|
if (col.default !== null && col.default !== undefined) {
|
|
defaultValue = is(col.default, SQL) ? col.default : sql.param(col.default, col);
|
|
} else if (col.defaultFn !== undefined) {
|
|
const defaultFnResult = col.defaultFn();
|
|
defaultValue = is(defaultFnResult, SQL) ? defaultFnResult : sql.param(defaultFnResult, col);
|
|
} else if (!col.default && col.onUpdateFn !== undefined) {
|
|
const onUpdateFnResult = col.onUpdateFn();
|
|
defaultValue = is(onUpdateFnResult, SQL) ? onUpdateFnResult : sql.param(onUpdateFnResult, col);
|
|
} else {
|
|
defaultValue = sql`null`;
|
|
}
|
|
valueList.push(defaultValue);
|
|
} else {
|
|
valueList.push(colValue);
|
|
}
|
|
}
|
|
valuesSqlList.push(valueList);
|
|
if (valueIndex < values.length - 1) {
|
|
valuesSqlList.push(sql`, `);
|
|
}
|
|
}
|
|
}
|
|
const withSql = this.buildWithCTE(withList);
|
|
const valuesSql = sql.join(valuesSqlList);
|
|
const returningSql = returning ? sql` returning ${this.buildSelection(returning, { isSingleTable: true })}` : undefined;
|
|
const onConflictSql = onConflict?.length ? sql.join(onConflict) : undefined;
|
|
return sql`${withSql}insert into ${table} ${insertOrder} ${valuesSql}${onConflictSql}${returningSql}`;
|
|
}
|
|
sqlToQuery(sql2, invokeSource) {
|
|
return sql2.toQuery({
|
|
casing: this.casing,
|
|
escapeName: this.escapeName,
|
|
escapeParam: this.escapeParam,
|
|
escapeString: this.escapeString,
|
|
invokeSource
|
|
});
|
|
}
|
|
buildRelationalQuery({
|
|
fullSchema,
|
|
schema,
|
|
tableNamesMap,
|
|
table,
|
|
tableConfig,
|
|
queryConfig: config,
|
|
tableAlias,
|
|
nestedQueryRelation,
|
|
joinOn
|
|
}) {
|
|
let selection = [];
|
|
let limit, offset, orderBy = [], where;
|
|
const joins = [];
|
|
if (config === true) {
|
|
const selectionEntries = Object.entries(tableConfig.columns);
|
|
selection = selectionEntries.map(([key, value]) => ({
|
|
dbKey: value.name,
|
|
tsKey: key,
|
|
field: aliasedTableColumn(value, tableAlias),
|
|
relationTableTsKey: undefined,
|
|
isJson: false,
|
|
selection: []
|
|
}));
|
|
} else {
|
|
const aliasedColumns = Object.fromEntries(Object.entries(tableConfig.columns).map(([key, value]) => [key, aliasedTableColumn(value, tableAlias)]));
|
|
if (config.where) {
|
|
const whereSql = typeof config.where === "function" ? config.where(aliasedColumns, getOperators()) : config.where;
|
|
where = whereSql && mapColumnsInSQLToAlias(whereSql, tableAlias);
|
|
}
|
|
const fieldsSelection = [];
|
|
let selectedColumns = [];
|
|
if (config.columns) {
|
|
let isIncludeMode = false;
|
|
for (const [field, value] of Object.entries(config.columns)) {
|
|
if (value === undefined) {
|
|
continue;
|
|
}
|
|
if (field in tableConfig.columns) {
|
|
if (!isIncludeMode && value === true) {
|
|
isIncludeMode = true;
|
|
}
|
|
selectedColumns.push(field);
|
|
}
|
|
}
|
|
if (selectedColumns.length > 0) {
|
|
selectedColumns = isIncludeMode ? selectedColumns.filter((c) => config.columns?.[c] === true) : Object.keys(tableConfig.columns).filter((key) => !selectedColumns.includes(key));
|
|
}
|
|
} else {
|
|
selectedColumns = Object.keys(tableConfig.columns);
|
|
}
|
|
for (const field of selectedColumns) {
|
|
const column = tableConfig.columns[field];
|
|
fieldsSelection.push({ tsKey: field, value: column });
|
|
}
|
|
let selectedRelations = [];
|
|
if (config.with) {
|
|
selectedRelations = Object.entries(config.with).filter((entry) => !!entry[1]).map(([tsKey, queryConfig]) => ({ tsKey, queryConfig, relation: tableConfig.relations[tsKey] }));
|
|
}
|
|
let extras;
|
|
if (config.extras) {
|
|
extras = typeof config.extras === "function" ? config.extras(aliasedColumns, { sql }) : config.extras;
|
|
for (const [tsKey, value] of Object.entries(extras)) {
|
|
fieldsSelection.push({
|
|
tsKey,
|
|
value: mapColumnsInAliasedSQLToAlias(value, tableAlias)
|
|
});
|
|
}
|
|
}
|
|
for (const { tsKey, value } of fieldsSelection) {
|
|
selection.push({
|
|
dbKey: is(value, SQL.Aliased) ? value.fieldAlias : tableConfig.columns[tsKey].name,
|
|
tsKey,
|
|
field: is(value, Column) ? aliasedTableColumn(value, tableAlias) : value,
|
|
relationTableTsKey: undefined,
|
|
isJson: false,
|
|
selection: []
|
|
});
|
|
}
|
|
let orderByOrig = typeof config.orderBy === "function" ? config.orderBy(aliasedColumns, getOrderByOperators()) : config.orderBy ?? [];
|
|
if (!Array.isArray(orderByOrig)) {
|
|
orderByOrig = [orderByOrig];
|
|
}
|
|
orderBy = orderByOrig.map((orderByValue) => {
|
|
if (is(orderByValue, Column)) {
|
|
return aliasedTableColumn(orderByValue, tableAlias);
|
|
}
|
|
return mapColumnsInSQLToAlias(orderByValue, tableAlias);
|
|
});
|
|
limit = config.limit;
|
|
offset = config.offset;
|
|
for (const {
|
|
tsKey: selectedRelationTsKey,
|
|
queryConfig: selectedRelationConfigValue,
|
|
relation
|
|
} of selectedRelations) {
|
|
const normalizedRelation = normalizeRelation(schema, tableNamesMap, relation);
|
|
const relationTableName = getTableUniqueName(relation.referencedTable);
|
|
const relationTableTsName = tableNamesMap[relationTableName];
|
|
const relationTableAlias = `${tableAlias}_${selectedRelationTsKey}`;
|
|
const joinOn2 = and(...normalizedRelation.fields.map((field2, i) => eq(aliasedTableColumn(normalizedRelation.references[i], relationTableAlias), aliasedTableColumn(field2, tableAlias))));
|
|
const builtRelation = this.buildRelationalQuery({
|
|
fullSchema,
|
|
schema,
|
|
tableNamesMap,
|
|
table: fullSchema[relationTableTsName],
|
|
tableConfig: schema[relationTableTsName],
|
|
queryConfig: is(relation, One) ? selectedRelationConfigValue === true ? { limit: 1 } : { ...selectedRelationConfigValue, limit: 1 } : selectedRelationConfigValue,
|
|
tableAlias: relationTableAlias,
|
|
joinOn: joinOn2,
|
|
nestedQueryRelation: relation
|
|
});
|
|
const field = sql`(${builtRelation.sql})`.as(selectedRelationTsKey);
|
|
selection.push({
|
|
dbKey: selectedRelationTsKey,
|
|
tsKey: selectedRelationTsKey,
|
|
field,
|
|
relationTableTsKey: relationTableTsName,
|
|
isJson: true,
|
|
selection: builtRelation.selection
|
|
});
|
|
}
|
|
}
|
|
if (selection.length === 0) {
|
|
throw new DrizzleError({
|
|
message: `No fields selected for table "${tableConfig.tsName}" ("${tableAlias}"). You need to have at least one item in "columns", "with" or "extras". If you need to select all columns, omit the "columns" key or set it to undefined.`
|
|
});
|
|
}
|
|
let result;
|
|
where = and(joinOn, where);
|
|
if (nestedQueryRelation) {
|
|
let field = sql`json_array(${sql.join(selection.map(({ field: field2 }) => is(field2, SQLiteColumn) ? sql.identifier(this.casing.getColumnCasing(field2)) : is(field2, SQL.Aliased) ? field2.sql : field2), sql`, `)})`;
|
|
if (is(nestedQueryRelation, Many)) {
|
|
field = sql`coalesce(json_group_array(${field}), json_array())`;
|
|
}
|
|
const nestedSelection = [{
|
|
dbKey: "data",
|
|
tsKey: "data",
|
|
field: field.as("data"),
|
|
isJson: true,
|
|
relationTableTsKey: tableConfig.tsName,
|
|
selection
|
|
}];
|
|
const needsSubquery = limit !== undefined || offset !== undefined || orderBy.length > 0;
|
|
if (needsSubquery) {
|
|
result = this.buildSelectQuery({
|
|
table: aliasedTable(table, tableAlias),
|
|
fields: {},
|
|
fieldsFlat: [
|
|
{
|
|
path: [],
|
|
field: sql.raw("*")
|
|
}
|
|
],
|
|
where,
|
|
limit,
|
|
offset,
|
|
orderBy,
|
|
setOperators: []
|
|
});
|
|
where = undefined;
|
|
limit = undefined;
|
|
offset = undefined;
|
|
orderBy = undefined;
|
|
} else {
|
|
result = aliasedTable(table, tableAlias);
|
|
}
|
|
result = this.buildSelectQuery({
|
|
table: is(result, SQLiteTable) ? result : new Subquery(result, {}, tableAlias),
|
|
fields: {},
|
|
fieldsFlat: nestedSelection.map(({ field: field2 }) => ({
|
|
path: [],
|
|
field: is(field2, Column) ? aliasedTableColumn(field2, tableAlias) : field2
|
|
})),
|
|
joins,
|
|
where,
|
|
limit,
|
|
offset,
|
|
orderBy,
|
|
setOperators: []
|
|
});
|
|
} else {
|
|
result = this.buildSelectQuery({
|
|
table: aliasedTable(table, tableAlias),
|
|
fields: {},
|
|
fieldsFlat: selection.map(({ field }) => ({
|
|
path: [],
|
|
field: is(field, Column) ? aliasedTableColumn(field, tableAlias) : field
|
|
})),
|
|
joins,
|
|
where,
|
|
limit,
|
|
offset,
|
|
orderBy,
|
|
setOperators: []
|
|
});
|
|
}
|
|
return {
|
|
tableTsKey: tableConfig.tsName,
|
|
sql: result,
|
|
selection
|
|
};
|
|
}
|
|
}
|
|
|
|
class SQLiteSyncDialect extends SQLiteDialect {
|
|
static [entityKind] = "SQLiteSyncDialect";
|
|
migrate(migrations, session, config) {
|
|
const migrationsTable = config === undefined ? "__drizzle_migrations" : typeof config === "string" ? "__drizzle_migrations" : config.migrationsTable ?? "__drizzle_migrations";
|
|
const migrationTableCreate = sql`
|
|
CREATE TABLE IF NOT EXISTS ${sql.identifier(migrationsTable)} (
|
|
id SERIAL PRIMARY KEY,
|
|
hash text NOT NULL,
|
|
created_at numeric
|
|
)
|
|
`;
|
|
session.run(migrationTableCreate);
|
|
const dbMigrations = session.values(sql`SELECT id, hash, created_at FROM ${sql.identifier(migrationsTable)} ORDER BY created_at DESC LIMIT 1`);
|
|
const lastDbMigration = dbMigrations[0] ?? undefined;
|
|
session.run(sql`BEGIN`);
|
|
try {
|
|
for (const migration of migrations) {
|
|
if (!lastDbMigration || Number(lastDbMigration[2]) < migration.folderMillis) {
|
|
for (const stmt of migration.sql) {
|
|
session.run(sql.raw(stmt));
|
|
}
|
|
session.run(sql`INSERT INTO ${sql.identifier(migrationsTable)} ("hash", "created_at") VALUES(${migration.hash}, ${migration.folderMillis})`);
|
|
}
|
|
}
|
|
session.run(sql`COMMIT`);
|
|
} catch (e) {
|
|
session.run(sql`ROLLBACK`);
|
|
throw e;
|
|
}
|
|
}
|
|
}
|
|
|
|
// ../eve/node_modules/drizzle-orm/query-builders/query-builder.js
|
|
class TypedQueryBuilder {
|
|
static [entityKind] = "TypedQueryBuilder";
|
|
getSelectedFields() {
|
|
return this._.selectedFields;
|
|
}
|
|
}
|
|
|
|
// ../eve/node_modules/drizzle-orm/sqlite-core/query-builders/select.js
|
|
class SQLiteSelectBuilder {
|
|
static [entityKind] = "SQLiteSelectBuilder";
|
|
fields;
|
|
session;
|
|
dialect;
|
|
withList;
|
|
distinct;
|
|
constructor(config) {
|
|
this.fields = config.fields;
|
|
this.session = config.session;
|
|
this.dialect = config.dialect;
|
|
this.withList = config.withList;
|
|
this.distinct = config.distinct;
|
|
}
|
|
from(source) {
|
|
const isPartialSelect = !!this.fields;
|
|
let fields;
|
|
if (this.fields) {
|
|
fields = this.fields;
|
|
} else if (is(source, Subquery)) {
|
|
fields = Object.fromEntries(Object.keys(source._.selectedFields).map((key) => [key, source[key]]));
|
|
} else if (is(source, SQLiteViewBase)) {
|
|
fields = source[ViewBaseConfig].selectedFields;
|
|
} else if (is(source, SQL)) {
|
|
fields = {};
|
|
} else {
|
|
fields = getTableColumns(source);
|
|
}
|
|
return new SQLiteSelectBase({
|
|
table: source,
|
|
fields,
|
|
isPartialSelect,
|
|
session: this.session,
|
|
dialect: this.dialect,
|
|
withList: this.withList,
|
|
distinct: this.distinct
|
|
});
|
|
}
|
|
}
|
|
|
|
class SQLiteSelectQueryBuilderBase extends TypedQueryBuilder {
|
|
static [entityKind] = "SQLiteSelectQueryBuilder";
|
|
_;
|
|
config;
|
|
joinsNotNullableMap;
|
|
tableName;
|
|
isPartialSelect;
|
|
session;
|
|
dialect;
|
|
cacheConfig = undefined;
|
|
usedTables = /* @__PURE__ */ new Set;
|
|
constructor({ table, fields, isPartialSelect, session, dialect, withList, distinct }) {
|
|
super();
|
|
this.config = {
|
|
withList,
|
|
table,
|
|
fields: { ...fields },
|
|
distinct,
|
|
setOperators: []
|
|
};
|
|
this.isPartialSelect = isPartialSelect;
|
|
this.session = session;
|
|
this.dialect = dialect;
|
|
this._ = {
|
|
selectedFields: fields,
|
|
config: this.config
|
|
};
|
|
this.tableName = getTableLikeName(table);
|
|
this.joinsNotNullableMap = typeof this.tableName === "string" ? { [this.tableName]: true } : {};
|
|
for (const item of extractUsedTable(table))
|
|
this.usedTables.add(item);
|
|
}
|
|
getUsedTables() {
|
|
return [...this.usedTables];
|
|
}
|
|
createJoin(joinType) {
|
|
return (table, on) => {
|
|
const baseTableName = this.tableName;
|
|
const tableName = getTableLikeName(table);
|
|
for (const item of extractUsedTable(table))
|
|
this.usedTables.add(item);
|
|
if (typeof tableName === "string" && this.config.joins?.some((join) => join.alias === tableName)) {
|
|
throw new Error(`Alias "${tableName}" is already used in this query`);
|
|
}
|
|
if (!this.isPartialSelect) {
|
|
if (Object.keys(this.joinsNotNullableMap).length === 1 && typeof baseTableName === "string") {
|
|
this.config.fields = {
|
|
[baseTableName]: this.config.fields
|
|
};
|
|
}
|
|
if (typeof tableName === "string" && !is(table, SQL)) {
|
|
const selection = is(table, Subquery) ? table._.selectedFields : is(table, View) ? table[ViewBaseConfig].selectedFields : table[Table.Symbol.Columns];
|
|
this.config.fields[tableName] = selection;
|
|
}
|
|
}
|
|
if (typeof on === "function") {
|
|
on = on(new Proxy(this.config.fields, new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })));
|
|
}
|
|
if (!this.config.joins) {
|
|
this.config.joins = [];
|
|
}
|
|
this.config.joins.push({ on, table, joinType, alias: tableName });
|
|
if (typeof tableName === "string") {
|
|
switch (joinType) {
|
|
case "left": {
|
|
this.joinsNotNullableMap[tableName] = false;
|
|
break;
|
|
}
|
|
case "right": {
|
|
this.joinsNotNullableMap = Object.fromEntries(Object.entries(this.joinsNotNullableMap).map(([key]) => [key, false]));
|
|
this.joinsNotNullableMap[tableName] = true;
|
|
break;
|
|
}
|
|
case "cross":
|
|
case "inner": {
|
|
this.joinsNotNullableMap[tableName] = true;
|
|
break;
|
|
}
|
|
case "full": {
|
|
this.joinsNotNullableMap = Object.fromEntries(Object.entries(this.joinsNotNullableMap).map(([key]) => [key, false]));
|
|
this.joinsNotNullableMap[tableName] = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return this;
|
|
};
|
|
}
|
|
leftJoin = this.createJoin("left");
|
|
rightJoin = this.createJoin("right");
|
|
innerJoin = this.createJoin("inner");
|
|
fullJoin = this.createJoin("full");
|
|
crossJoin = this.createJoin("cross");
|
|
createSetOperator(type, isAll) {
|
|
return (rightSelection) => {
|
|
const rightSelect = typeof rightSelection === "function" ? rightSelection(getSQLiteSetOperators()) : rightSelection;
|
|
if (!haveSameKeys(this.getSelectedFields(), rightSelect.getSelectedFields())) {
|
|
throw new Error("Set operator error (union / intersect / except): selected fields are not the same or are in a different order");
|
|
}
|
|
this.config.setOperators.push({ type, isAll, rightSelect });
|
|
return this;
|
|
};
|
|
}
|
|
union = this.createSetOperator("union", false);
|
|
unionAll = this.createSetOperator("union", true);
|
|
intersect = this.createSetOperator("intersect", false);
|
|
except = this.createSetOperator("except", false);
|
|
addSetOperators(setOperators) {
|
|
this.config.setOperators.push(...setOperators);
|
|
return this;
|
|
}
|
|
where(where) {
|
|
if (typeof where === "function") {
|
|
where = where(new Proxy(this.config.fields, new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })));
|
|
}
|
|
this.config.where = where;
|
|
return this;
|
|
}
|
|
having(having) {
|
|
if (typeof having === "function") {
|
|
having = having(new Proxy(this.config.fields, new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })));
|
|
}
|
|
this.config.having = having;
|
|
return this;
|
|
}
|
|
groupBy(...columns) {
|
|
if (typeof columns[0] === "function") {
|
|
const groupBy = columns[0](new Proxy(this.config.fields, new SelectionProxyHandler({ sqlAliasedBehavior: "alias", sqlBehavior: "sql" })));
|
|
this.config.groupBy = Array.isArray(groupBy) ? groupBy : [groupBy];
|
|
} else {
|
|
this.config.groupBy = columns;
|
|
}
|
|
return this;
|
|
}
|
|
orderBy(...columns) {
|
|
if (typeof columns[0] === "function") {
|
|
const orderBy = columns[0](new Proxy(this.config.fields, new SelectionProxyHandler({ sqlAliasedBehavior: "alias", sqlBehavior: "sql" })));
|
|
const orderByArray = Array.isArray(orderBy) ? orderBy : [orderBy];
|
|
if (this.config.setOperators.length > 0) {
|
|
this.config.setOperators.at(-1).orderBy = orderByArray;
|
|
} else {
|
|
this.config.orderBy = orderByArray;
|
|
}
|
|
} else {
|
|
const orderByArray = columns;
|
|
if (this.config.setOperators.length > 0) {
|
|
this.config.setOperators.at(-1).orderBy = orderByArray;
|
|
} else {
|
|
this.config.orderBy = orderByArray;
|
|
}
|
|
}
|
|
return this;
|
|
}
|
|
limit(limit) {
|
|
if (this.config.setOperators.length > 0) {
|
|
this.config.setOperators.at(-1).limit = limit;
|
|
} else {
|
|
this.config.limit = limit;
|
|
}
|
|
return this;
|
|
}
|
|
offset(offset) {
|
|
if (this.config.setOperators.length > 0) {
|
|
this.config.setOperators.at(-1).offset = offset;
|
|
} else {
|
|
this.config.offset = offset;
|
|
}
|
|
return this;
|
|
}
|
|
getSQL() {
|
|
return this.dialect.buildSelectQuery(this.config);
|
|
}
|
|
toSQL() {
|
|
const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
|
|
return rest;
|
|
}
|
|
as(alias) {
|
|
const usedTables = [];
|
|
usedTables.push(...extractUsedTable(this.config.table));
|
|
if (this.config.joins) {
|
|
for (const it of this.config.joins)
|
|
usedTables.push(...extractUsedTable(it.table));
|
|
}
|
|
return new Proxy(new Subquery(this.getSQL(), this.config.fields, alias, false, [...new Set(usedTables)]), new SelectionProxyHandler({ alias, sqlAliasedBehavior: "alias", sqlBehavior: "error" }));
|
|
}
|
|
getSelectedFields() {
|
|
return new Proxy(this.config.fields, new SelectionProxyHandler({ alias: this.tableName, sqlAliasedBehavior: "alias", sqlBehavior: "error" }));
|
|
}
|
|
$dynamic() {
|
|
return this;
|
|
}
|
|
}
|
|
|
|
class SQLiteSelectBase extends SQLiteSelectQueryBuilderBase {
|
|
static [entityKind] = "SQLiteSelect";
|
|
_prepare(isOneTimeQuery = true) {
|
|
if (!this.session) {
|
|
throw new Error("Cannot execute a query on a query builder. Please use a database instance instead.");
|
|
}
|
|
const fieldsList = orderSelectedFields(this.config.fields);
|
|
const query = this.session[isOneTimeQuery ? "prepareOneTimeQuery" : "prepareQuery"](this.dialect.sqlToQuery(this.getSQL()), fieldsList, "all", true, undefined, {
|
|
type: "select",
|
|
tables: [...this.usedTables]
|
|
}, this.cacheConfig);
|
|
query.joinsNotNullableMap = this.joinsNotNullableMap;
|
|
return query;
|
|
}
|
|
$withCache(config) {
|
|
this.cacheConfig = config === undefined ? { config: {}, enable: true, autoInvalidate: true } : config === false ? { enable: false } : { enable: true, autoInvalidate: true, ...config };
|
|
return this;
|
|
}
|
|
prepare() {
|
|
return this._prepare(false);
|
|
}
|
|
run = (placeholderValues) => {
|
|
return this._prepare().run(placeholderValues);
|
|
};
|
|
all = (placeholderValues) => {
|
|
return this._prepare().all(placeholderValues);
|
|
};
|
|
get = (placeholderValues) => {
|
|
return this._prepare().get(placeholderValues);
|
|
};
|
|
values = (placeholderValues) => {
|
|
return this._prepare().values(placeholderValues);
|
|
};
|
|
async execute() {
|
|
return this.all();
|
|
}
|
|
}
|
|
applyMixins(SQLiteSelectBase, [QueryPromise]);
|
|
function createSetOperator(type, isAll) {
|
|
return (leftSelect, rightSelect, ...restSelects) => {
|
|
const setOperators = [rightSelect, ...restSelects].map((select) => ({
|
|
type,
|
|
isAll,
|
|
rightSelect: select
|
|
}));
|
|
for (const setOperator of setOperators) {
|
|
if (!haveSameKeys(leftSelect.getSelectedFields(), setOperator.rightSelect.getSelectedFields())) {
|
|
throw new Error("Set operator error (union / intersect / except): selected fields are not the same or are in a different order");
|
|
}
|
|
}
|
|
return leftSelect.addSetOperators(setOperators);
|
|
};
|
|
}
|
|
var getSQLiteSetOperators = () => ({
|
|
union,
|
|
unionAll,
|
|
intersect,
|
|
except
|
|
});
|
|
var union = createSetOperator("union", false);
|
|
var unionAll = createSetOperator("union", true);
|
|
var intersect = createSetOperator("intersect", false);
|
|
var except = createSetOperator("except", false);
|
|
|
|
// ../eve/node_modules/drizzle-orm/sqlite-core/query-builders/query-builder.js
|
|
class QueryBuilder {
|
|
static [entityKind] = "SQLiteQueryBuilder";
|
|
dialect;
|
|
dialectConfig;
|
|
constructor(dialect) {
|
|
this.dialect = is(dialect, SQLiteDialect) ? dialect : undefined;
|
|
this.dialectConfig = is(dialect, SQLiteDialect) ? undefined : dialect;
|
|
}
|
|
$with = (alias, selection) => {
|
|
const queryBuilder = this;
|
|
const as = (qb) => {
|
|
if (typeof qb === "function") {
|
|
qb = qb(queryBuilder);
|
|
}
|
|
return new Proxy(new WithSubquery(qb.getSQL(), selection ?? ("getSelectedFields" in qb ? qb.getSelectedFields() ?? {} : {}), alias, true), new SelectionProxyHandler({ alias, sqlAliasedBehavior: "alias", sqlBehavior: "error" }));
|
|
};
|
|
return { as };
|
|
};
|
|
with(...queries) {
|
|
const self2 = this;
|
|
function select(fields) {
|
|
return new SQLiteSelectBuilder({
|
|
fields: fields ?? undefined,
|
|
session: undefined,
|
|
dialect: self2.getDialect(),
|
|
withList: queries
|
|
});
|
|
}
|
|
function selectDistinct(fields) {
|
|
return new SQLiteSelectBuilder({
|
|
fields: fields ?? undefined,
|
|
session: undefined,
|
|
dialect: self2.getDialect(),
|
|
withList: queries,
|
|
distinct: true
|
|
});
|
|
}
|
|
return { select, selectDistinct };
|
|
}
|
|
select(fields) {
|
|
return new SQLiteSelectBuilder({ fields: fields ?? undefined, session: undefined, dialect: this.getDialect() });
|
|
}
|
|
selectDistinct(fields) {
|
|
return new SQLiteSelectBuilder({
|
|
fields: fields ?? undefined,
|
|
session: undefined,
|
|
dialect: this.getDialect(),
|
|
distinct: true
|
|
});
|
|
}
|
|
getDialect() {
|
|
if (!this.dialect) {
|
|
this.dialect = new SQLiteSyncDialect(this.dialectConfig);
|
|
}
|
|
return this.dialect;
|
|
}
|
|
}
|
|
|
|
// ../eve/node_modules/drizzle-orm/sqlite-core/query-builders/insert.js
|
|
class SQLiteInsertBuilder {
|
|
constructor(table, session, dialect, withList) {
|
|
this.table = table;
|
|
this.session = session;
|
|
this.dialect = dialect;
|
|
this.withList = withList;
|
|
}
|
|
static [entityKind] = "SQLiteInsertBuilder";
|
|
values(values) {
|
|
values = Array.isArray(values) ? values : [values];
|
|
if (values.length === 0) {
|
|
throw new Error("values() must be called with at least one value");
|
|
}
|
|
const mappedValues = values.map((entry) => {
|
|
const result = {};
|
|
const cols = this.table[Table.Symbol.Columns];
|
|
for (const colKey of Object.keys(entry)) {
|
|
const colValue = entry[colKey];
|
|
result[colKey] = is(colValue, SQL) ? colValue : new Param(colValue, cols[colKey]);
|
|
}
|
|
return result;
|
|
});
|
|
return new SQLiteInsertBase(this.table, mappedValues, this.session, this.dialect, this.withList);
|
|
}
|
|
select(selectQuery) {
|
|
const select = typeof selectQuery === "function" ? selectQuery(new QueryBuilder) : selectQuery;
|
|
if (!is(select, SQL) && !haveSameKeys(this.table[Columns], select._.selectedFields)) {
|
|
throw new Error("Insert select error: selected fields are not the same or are in a different order compared to the table definition");
|
|
}
|
|
return new SQLiteInsertBase(this.table, select, this.session, this.dialect, this.withList, true);
|
|
}
|
|
}
|
|
|
|
class SQLiteInsertBase extends QueryPromise {
|
|
constructor(table, values, session, dialect, withList, select) {
|
|
super();
|
|
this.session = session;
|
|
this.dialect = dialect;
|
|
this.config = { table, values, withList, select };
|
|
}
|
|
static [entityKind] = "SQLiteInsert";
|
|
config;
|
|
returning(fields = this.config.table[SQLiteTable.Symbol.Columns]) {
|
|
this.config.returning = orderSelectedFields(fields);
|
|
return this;
|
|
}
|
|
onConflictDoNothing(config = {}) {
|
|
if (!this.config.onConflict)
|
|
this.config.onConflict = [];
|
|
if (config.target === undefined) {
|
|
this.config.onConflict.push(sql` on conflict do nothing`);
|
|
} else {
|
|
const targetSql = Array.isArray(config.target) ? sql`${config.target}` : sql`${[config.target]}`;
|
|
const whereSql = config.where ? sql` where ${config.where}` : sql``;
|
|
this.config.onConflict.push(sql` on conflict ${targetSql} do nothing${whereSql}`);
|
|
}
|
|
return this;
|
|
}
|
|
onConflictDoUpdate(config) {
|
|
if (config.where && (config.targetWhere || config.setWhere)) {
|
|
throw new Error('You cannot use both "where" and "targetWhere"/"setWhere" at the same time - "where" is deprecated, use "targetWhere" or "setWhere" instead.');
|
|
}
|
|
if (!this.config.onConflict)
|
|
this.config.onConflict = [];
|
|
const whereSql = config.where ? sql` where ${config.where}` : undefined;
|
|
const targetWhereSql = config.targetWhere ? sql` where ${config.targetWhere}` : undefined;
|
|
const setWhereSql = config.setWhere ? sql` where ${config.setWhere}` : undefined;
|
|
const targetSql = Array.isArray(config.target) ? sql`${config.target}` : sql`${[config.target]}`;
|
|
const setSql = this.dialect.buildUpdateSet(this.config.table, mapUpdateSet(this.config.table, config.set));
|
|
this.config.onConflict.push(sql` on conflict ${targetSql}${targetWhereSql} do update set ${setSql}${whereSql}${setWhereSql}`);
|
|
return this;
|
|
}
|
|
getSQL() {
|
|
return this.dialect.buildInsertQuery(this.config);
|
|
}
|
|
toSQL() {
|
|
const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
|
|
return rest;
|
|
}
|
|
_prepare(isOneTimeQuery = true) {
|
|
return this.session[isOneTimeQuery ? "prepareOneTimeQuery" : "prepareQuery"](this.dialect.sqlToQuery(this.getSQL()), this.config.returning, this.config.returning ? "all" : "run", true, undefined, {
|
|
type: "insert",
|
|
tables: extractUsedTable(this.config.table)
|
|
});
|
|
}
|
|
prepare() {
|
|
return this._prepare(false);
|
|
}
|
|
run = (placeholderValues) => {
|
|
return this._prepare().run(placeholderValues);
|
|
};
|
|
all = (placeholderValues) => {
|
|
return this._prepare().all(placeholderValues);
|
|
};
|
|
get = (placeholderValues) => {
|
|
return this._prepare().get(placeholderValues);
|
|
};
|
|
values = (placeholderValues) => {
|
|
return this._prepare().values(placeholderValues);
|
|
};
|
|
async execute() {
|
|
return this.config.returning ? this.all() : this.run();
|
|
}
|
|
$dynamic() {
|
|
return this;
|
|
}
|
|
}
|
|
|
|
// ../eve/node_modules/drizzle-orm/sqlite-core/query-builders/update.js
|
|
class SQLiteUpdateBuilder {
|
|
constructor(table, session, dialect, withList) {
|
|
this.table = table;
|
|
this.session = session;
|
|
this.dialect = dialect;
|
|
this.withList = withList;
|
|
}
|
|
static [entityKind] = "SQLiteUpdateBuilder";
|
|
set(values) {
|
|
return new SQLiteUpdateBase(this.table, mapUpdateSet(this.table, values), this.session, this.dialect, this.withList);
|
|
}
|
|
}
|
|
|
|
class SQLiteUpdateBase extends QueryPromise {
|
|
constructor(table, set, session, dialect, withList) {
|
|
super();
|
|
this.session = session;
|
|
this.dialect = dialect;
|
|
this.config = { set, table, withList, joins: [] };
|
|
}
|
|
static [entityKind] = "SQLiteUpdate";
|
|
config;
|
|
from(source) {
|
|
this.config.from = source;
|
|
return this;
|
|
}
|
|
createJoin(joinType) {
|
|
return (table, on) => {
|
|
const tableName = getTableLikeName(table);
|
|
if (typeof tableName === "string" && this.config.joins.some((join) => join.alias === tableName)) {
|
|
throw new Error(`Alias "${tableName}" is already used in this query`);
|
|
}
|
|
if (typeof on === "function") {
|
|
const from = this.config.from ? is(table, SQLiteTable) ? table[Table.Symbol.Columns] : is(table, Subquery) ? table._.selectedFields : is(table, SQLiteViewBase) ? table[ViewBaseConfig].selectedFields : undefined : undefined;
|
|
on = on(new Proxy(this.config.table[Table.Symbol.Columns], new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })), from && new Proxy(from, new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })));
|
|
}
|
|
this.config.joins.push({ on, table, joinType, alias: tableName });
|
|
return this;
|
|
};
|
|
}
|
|
leftJoin = this.createJoin("left");
|
|
rightJoin = this.createJoin("right");
|
|
innerJoin = this.createJoin("inner");
|
|
fullJoin = this.createJoin("full");
|
|
where(where) {
|
|
this.config.where = where;
|
|
return this;
|
|
}
|
|
orderBy(...columns) {
|
|
if (typeof columns[0] === "function") {
|
|
const orderBy = columns[0](new Proxy(this.config.table[Table.Symbol.Columns], new SelectionProxyHandler({ sqlAliasedBehavior: "alias", sqlBehavior: "sql" })));
|
|
const orderByArray = Array.isArray(orderBy) ? orderBy : [orderBy];
|
|
this.config.orderBy = orderByArray;
|
|
} else {
|
|
const orderByArray = columns;
|
|
this.config.orderBy = orderByArray;
|
|
}
|
|
return this;
|
|
}
|
|
limit(limit) {
|
|
this.config.limit = limit;
|
|
return this;
|
|
}
|
|
returning(fields = this.config.table[SQLiteTable.Symbol.Columns]) {
|
|
this.config.returning = orderSelectedFields(fields);
|
|
return this;
|
|
}
|
|
getSQL() {
|
|
return this.dialect.buildUpdateQuery(this.config);
|
|
}
|
|
toSQL() {
|
|
const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
|
|
return rest;
|
|
}
|
|
_prepare(isOneTimeQuery = true) {
|
|
return this.session[isOneTimeQuery ? "prepareOneTimeQuery" : "prepareQuery"](this.dialect.sqlToQuery(this.getSQL()), this.config.returning, this.config.returning ? "all" : "run", true, undefined, {
|
|
type: "insert",
|
|
tables: extractUsedTable(this.config.table)
|
|
});
|
|
}
|
|
prepare() {
|
|
return this._prepare(false);
|
|
}
|
|
run = (placeholderValues) => {
|
|
return this._prepare().run(placeholderValues);
|
|
};
|
|
all = (placeholderValues) => {
|
|
return this._prepare().all(placeholderValues);
|
|
};
|
|
get = (placeholderValues) => {
|
|
return this._prepare().get(placeholderValues);
|
|
};
|
|
values = (placeholderValues) => {
|
|
return this._prepare().values(placeholderValues);
|
|
};
|
|
async execute() {
|
|
return this.config.returning ? this.all() : this.run();
|
|
}
|
|
$dynamic() {
|
|
return this;
|
|
}
|
|
}
|
|
|
|
// ../eve/node_modules/drizzle-orm/sqlite-core/query-builders/count.js
|
|
class SQLiteCountBuilder extends SQL {
|
|
constructor(params) {
|
|
super(SQLiteCountBuilder.buildEmbeddedCount(params.source, params.filters).queryChunks);
|
|
this.params = params;
|
|
this.session = params.session;
|
|
this.sql = SQLiteCountBuilder.buildCount(params.source, params.filters);
|
|
}
|
|
sql;
|
|
static [entityKind] = "SQLiteCountBuilderAsync";
|
|
[Symbol.toStringTag] = "SQLiteCountBuilderAsync";
|
|
session;
|
|
static buildEmbeddedCount(source, filters) {
|
|
return sql`(select count(*) from ${source}${sql.raw(" where ").if(filters)}${filters})`;
|
|
}
|
|
static buildCount(source, filters) {
|
|
return sql`select count(*) from ${source}${sql.raw(" where ").if(filters)}${filters}`;
|
|
}
|
|
then(onfulfilled, onrejected) {
|
|
return Promise.resolve(this.session.count(this.sql)).then(onfulfilled, onrejected);
|
|
}
|
|
catch(onRejected) {
|
|
return this.then(undefined, onRejected);
|
|
}
|
|
finally(onFinally) {
|
|
return this.then((value) => {
|
|
onFinally?.();
|
|
return value;
|
|
}, (reason) => {
|
|
onFinally?.();
|
|
throw reason;
|
|
});
|
|
}
|
|
}
|
|
|
|
// ../eve/node_modules/drizzle-orm/sqlite-core/query-builders/query.js
|
|
class RelationalQueryBuilder {
|
|
constructor(mode, fullSchema, schema, tableNamesMap, table, tableConfig, dialect, session) {
|
|
this.mode = mode;
|
|
this.fullSchema = fullSchema;
|
|
this.schema = schema;
|
|
this.tableNamesMap = tableNamesMap;
|
|
this.table = table;
|
|
this.tableConfig = tableConfig;
|
|
this.dialect = dialect;
|
|
this.session = session;
|
|
}
|
|
static [entityKind] = "SQLiteAsyncRelationalQueryBuilder";
|
|
findMany(config) {
|
|
return this.mode === "sync" ? new SQLiteSyncRelationalQuery(this.fullSchema, this.schema, this.tableNamesMap, this.table, this.tableConfig, this.dialect, this.session, config ? config : {}, "many") : new SQLiteRelationalQuery(this.fullSchema, this.schema, this.tableNamesMap, this.table, this.tableConfig, this.dialect, this.session, config ? config : {}, "many");
|
|
}
|
|
findFirst(config) {
|
|
return this.mode === "sync" ? new SQLiteSyncRelationalQuery(this.fullSchema, this.schema, this.tableNamesMap, this.table, this.tableConfig, this.dialect, this.session, config ? { ...config, limit: 1 } : { limit: 1 }, "first") : new SQLiteRelationalQuery(this.fullSchema, this.schema, this.tableNamesMap, this.table, this.tableConfig, this.dialect, this.session, config ? { ...config, limit: 1 } : { limit: 1 }, "first");
|
|
}
|
|
}
|
|
|
|
class SQLiteRelationalQuery extends QueryPromise {
|
|
constructor(fullSchema, schema, tableNamesMap, table, tableConfig, dialect, session, config, mode) {
|
|
super();
|
|
this.fullSchema = fullSchema;
|
|
this.schema = schema;
|
|
this.tableNamesMap = tableNamesMap;
|
|
this.table = table;
|
|
this.tableConfig = tableConfig;
|
|
this.dialect = dialect;
|
|
this.session = session;
|
|
this.config = config;
|
|
this.mode = mode;
|
|
}
|
|
static [entityKind] = "SQLiteAsyncRelationalQuery";
|
|
mode;
|
|
getSQL() {
|
|
return this.dialect.buildRelationalQuery({
|
|
fullSchema: this.fullSchema,
|
|
schema: this.schema,
|
|
tableNamesMap: this.tableNamesMap,
|
|
table: this.table,
|
|
tableConfig: this.tableConfig,
|
|
queryConfig: this.config,
|
|
tableAlias: this.tableConfig.tsName
|
|
}).sql;
|
|
}
|
|
_prepare(isOneTimeQuery = false) {
|
|
const { query, builtQuery } = this._toSQL();
|
|
return this.session[isOneTimeQuery ? "prepareOneTimeQuery" : "prepareQuery"](builtQuery, undefined, this.mode === "first" ? "get" : "all", true, (rawRows, mapColumnValue) => {
|
|
const rows = rawRows.map((row) => mapRelationalRow(this.schema, this.tableConfig, row, query.selection, mapColumnValue));
|
|
if (this.mode === "first") {
|
|
return rows[0];
|
|
}
|
|
return rows;
|
|
});
|
|
}
|
|
prepare() {
|
|
return this._prepare(false);
|
|
}
|
|
_toSQL() {
|
|
const query = this.dialect.buildRelationalQuery({
|
|
fullSchema: this.fullSchema,
|
|
schema: this.schema,
|
|
tableNamesMap: this.tableNamesMap,
|
|
table: this.table,
|
|
tableConfig: this.tableConfig,
|
|
queryConfig: this.config,
|
|
tableAlias: this.tableConfig.tsName
|
|
});
|
|
const builtQuery = this.dialect.sqlToQuery(query.sql);
|
|
return { query, builtQuery };
|
|
}
|
|
toSQL() {
|
|
return this._toSQL().builtQuery;
|
|
}
|
|
executeRaw() {
|
|
if (this.mode === "first") {
|
|
return this._prepare(false).get();
|
|
}
|
|
return this._prepare(false).all();
|
|
}
|
|
async execute() {
|
|
return this.executeRaw();
|
|
}
|
|
}
|
|
|
|
class SQLiteSyncRelationalQuery extends SQLiteRelationalQuery {
|
|
static [entityKind] = "SQLiteSyncRelationalQuery";
|
|
sync() {
|
|
return this.executeRaw();
|
|
}
|
|
}
|
|
|
|
// ../eve/node_modules/drizzle-orm/sqlite-core/query-builders/raw.js
|
|
class SQLiteRaw extends QueryPromise {
|
|
constructor(execute, getSQL, action, dialect, mapBatchResult) {
|
|
super();
|
|
this.execute = execute;
|
|
this.getSQL = getSQL;
|
|
this.dialect = dialect;
|
|
this.mapBatchResult = mapBatchResult;
|
|
this.config = { action };
|
|
}
|
|
static [entityKind] = "SQLiteRaw";
|
|
config;
|
|
getQuery() {
|
|
return { ...this.dialect.sqlToQuery(this.getSQL()), method: this.config.action };
|
|
}
|
|
mapResult(result, isFromBatch) {
|
|
return isFromBatch ? this.mapBatchResult(result) : result;
|
|
}
|
|
_prepare() {
|
|
return this;
|
|
}
|
|
isResponseInArrayMode() {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// ../eve/node_modules/drizzle-orm/sqlite-core/db.js
|
|
class BaseSQLiteDatabase {
|
|
constructor(resultKind, dialect, session, schema) {
|
|
this.resultKind = resultKind;
|
|
this.dialect = dialect;
|
|
this.session = session;
|
|
this._ = schema ? {
|
|
schema: schema.schema,
|
|
fullSchema: schema.fullSchema,
|
|
tableNamesMap: schema.tableNamesMap
|
|
} : {
|
|
schema: undefined,
|
|
fullSchema: {},
|
|
tableNamesMap: {}
|
|
};
|
|
this.query = {};
|
|
const query = this.query;
|
|
if (this._.schema) {
|
|
for (const [tableName, columns] of Object.entries(this._.schema)) {
|
|
query[tableName] = new RelationalQueryBuilder(resultKind, schema.fullSchema, this._.schema, this._.tableNamesMap, schema.fullSchema[tableName], columns, dialect, session);
|
|
}
|
|
}
|
|
this.$cache = { invalidate: async (_params) => {} };
|
|
}
|
|
static [entityKind] = "BaseSQLiteDatabase";
|
|
query;
|
|
$with = (alias, selection) => {
|
|
const self2 = this;
|
|
const as = (qb) => {
|
|
if (typeof qb === "function") {
|
|
qb = qb(new QueryBuilder(self2.dialect));
|
|
}
|
|
return new Proxy(new WithSubquery(qb.getSQL(), selection ?? ("getSelectedFields" in qb ? qb.getSelectedFields() ?? {} : {}), alias, true), new SelectionProxyHandler({ alias, sqlAliasedBehavior: "alias", sqlBehavior: "error" }));
|
|
};
|
|
return { as };
|
|
};
|
|
$count(source, filters) {
|
|
return new SQLiteCountBuilder({ source, filters, session: this.session });
|
|
}
|
|
with(...queries) {
|
|
const self2 = this;
|
|
function select(fields) {
|
|
return new SQLiteSelectBuilder({
|
|
fields: fields ?? undefined,
|
|
session: self2.session,
|
|
dialect: self2.dialect,
|
|
withList: queries
|
|
});
|
|
}
|
|
function selectDistinct(fields) {
|
|
return new SQLiteSelectBuilder({
|
|
fields: fields ?? undefined,
|
|
session: self2.session,
|
|
dialect: self2.dialect,
|
|
withList: queries,
|
|
distinct: true
|
|
});
|
|
}
|
|
function update(table) {
|
|
return new SQLiteUpdateBuilder(table, self2.session, self2.dialect, queries);
|
|
}
|
|
function insert(into) {
|
|
return new SQLiteInsertBuilder(into, self2.session, self2.dialect, queries);
|
|
}
|
|
function delete_(from) {
|
|
return new SQLiteDeleteBase(from, self2.session, self2.dialect, queries);
|
|
}
|
|
return { select, selectDistinct, update, insert, delete: delete_ };
|
|
}
|
|
select(fields) {
|
|
return new SQLiteSelectBuilder({ fields: fields ?? undefined, session: this.session, dialect: this.dialect });
|
|
}
|
|
selectDistinct(fields) {
|
|
return new SQLiteSelectBuilder({
|
|
fields: fields ?? undefined,
|
|
session: this.session,
|
|
dialect: this.dialect,
|
|
distinct: true
|
|
});
|
|
}
|
|
update(table) {
|
|
return new SQLiteUpdateBuilder(table, this.session, this.dialect);
|
|
}
|
|
$cache;
|
|
insert(into) {
|
|
return new SQLiteInsertBuilder(into, this.session, this.dialect);
|
|
}
|
|
delete(from) {
|
|
return new SQLiteDeleteBase(from, this.session, this.dialect);
|
|
}
|
|
run(query) {
|
|
const sequel = typeof query === "string" ? sql.raw(query) : query.getSQL();
|
|
if (this.resultKind === "async") {
|
|
return new SQLiteRaw(async () => this.session.run(sequel), () => sequel, "run", this.dialect, this.session.extractRawRunValueFromBatchResult.bind(this.session));
|
|
}
|
|
return this.session.run(sequel);
|
|
}
|
|
all(query) {
|
|
const sequel = typeof query === "string" ? sql.raw(query) : query.getSQL();
|
|
if (this.resultKind === "async") {
|
|
return new SQLiteRaw(async () => this.session.all(sequel), () => sequel, "all", this.dialect, this.session.extractRawAllValueFromBatchResult.bind(this.session));
|
|
}
|
|
return this.session.all(sequel);
|
|
}
|
|
get(query) {
|
|
const sequel = typeof query === "string" ? sql.raw(query) : query.getSQL();
|
|
if (this.resultKind === "async") {
|
|
return new SQLiteRaw(async () => this.session.get(sequel), () => sequel, "get", this.dialect, this.session.extractRawGetValueFromBatchResult.bind(this.session));
|
|
}
|
|
return this.session.get(sequel);
|
|
}
|
|
values(query) {
|
|
const sequel = typeof query === "string" ? sql.raw(query) : query.getSQL();
|
|
if (this.resultKind === "async") {
|
|
return new SQLiteRaw(async () => this.session.values(sequel), () => sequel, "values", this.dialect, this.session.extractRawValuesValueFromBatchResult.bind(this.session));
|
|
}
|
|
return this.session.values(sequel);
|
|
}
|
|
transaction(transaction, config) {
|
|
return this.session.transaction(transaction, config);
|
|
}
|
|
}
|
|
|
|
// ../eve/node_modules/drizzle-orm/cache/core/cache.js
|
|
class Cache {
|
|
static [entityKind] = "Cache";
|
|
}
|
|
|
|
class NoopCache extends Cache {
|
|
strategy() {
|
|
return "all";
|
|
}
|
|
static [entityKind] = "NoopCache";
|
|
async get(_key) {
|
|
return;
|
|
}
|
|
async put(_hashedQuery, _response, _tables, _config) {}
|
|
async onMutate(_params) {}
|
|
}
|
|
async function hashQuery(sql2, params) {
|
|
const dataToHash = `${sql2}-${JSON.stringify(params)}`;
|
|
const encoder = new TextEncoder;
|
|
const data = encoder.encode(dataToHash);
|
|
const hashBuffer = await crypto.subtle.digest("SHA-256", data);
|
|
const hashArray = [...new Uint8Array(hashBuffer)];
|
|
const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
|
|
return hashHex;
|
|
}
|
|
|
|
// ../eve/node_modules/drizzle-orm/sqlite-core/session.js
|
|
class ExecuteResultSync extends QueryPromise {
|
|
constructor(resultCb) {
|
|
super();
|
|
this.resultCb = resultCb;
|
|
}
|
|
static [entityKind] = "ExecuteResultSync";
|
|
async execute() {
|
|
return this.resultCb();
|
|
}
|
|
sync() {
|
|
return this.resultCb();
|
|
}
|
|
}
|
|
|
|
class SQLitePreparedQuery {
|
|
constructor(mode, executeMethod, query, cache, queryMetadata, cacheConfig) {
|
|
this.mode = mode;
|
|
this.executeMethod = executeMethod;
|
|
this.query = query;
|
|
this.cache = cache;
|
|
this.queryMetadata = queryMetadata;
|
|
this.cacheConfig = cacheConfig;
|
|
if (cache && cache.strategy() === "all" && cacheConfig === undefined) {
|
|
this.cacheConfig = { enable: true, autoInvalidate: true };
|
|
}
|
|
if (!this.cacheConfig?.enable) {
|
|
this.cacheConfig = undefined;
|
|
}
|
|
}
|
|
static [entityKind] = "PreparedQuery";
|
|
joinsNotNullableMap;
|
|
async queryWithCache(queryString, params, query) {
|
|
if (this.cache === undefined || is(this.cache, NoopCache) || this.queryMetadata === undefined) {
|
|
try {
|
|
return await query();
|
|
} catch (e) {
|
|
throw new DrizzleQueryError(queryString, params, e);
|
|
}
|
|
}
|
|
if (this.cacheConfig && !this.cacheConfig.enable) {
|
|
try {
|
|
return await query();
|
|
} catch (e) {
|
|
throw new DrizzleQueryError(queryString, params, e);
|
|
}
|
|
}
|
|
if ((this.queryMetadata.type === "insert" || this.queryMetadata.type === "update" || this.queryMetadata.type === "delete") && this.queryMetadata.tables.length > 0) {
|
|
try {
|
|
const [res] = await Promise.all([
|
|
query(),
|
|
this.cache.onMutate({ tables: this.queryMetadata.tables })
|
|
]);
|
|
return res;
|
|
} catch (e) {
|
|
throw new DrizzleQueryError(queryString, params, e);
|
|
}
|
|
}
|
|
if (!this.cacheConfig) {
|
|
try {
|
|
return await query();
|
|
} catch (e) {
|
|
throw new DrizzleQueryError(queryString, params, e);
|
|
}
|
|
}
|
|
if (this.queryMetadata.type === "select") {
|
|
const fromCache = await this.cache.get(this.cacheConfig.tag ?? await hashQuery(queryString, params), this.queryMetadata.tables, this.cacheConfig.tag !== undefined, this.cacheConfig.autoInvalidate);
|
|
if (fromCache === undefined) {
|
|
let result;
|
|
try {
|
|
result = await query();
|
|
} catch (e) {
|
|
throw new DrizzleQueryError(queryString, params, e);
|
|
}
|
|
await this.cache.put(this.cacheConfig.tag ?? await hashQuery(queryString, params), result, this.cacheConfig.autoInvalidate ? this.queryMetadata.tables : [], this.cacheConfig.tag !== undefined, this.cacheConfig.config);
|
|
return result;
|
|
}
|
|
return fromCache;
|
|
}
|
|
try {
|
|
return await query();
|
|
} catch (e) {
|
|
throw new DrizzleQueryError(queryString, params, e);
|
|
}
|
|
}
|
|
getQuery() {
|
|
return this.query;
|
|
}
|
|
mapRunResult(result, _isFromBatch) {
|
|
return result;
|
|
}
|
|
mapAllResult(_result, _isFromBatch) {
|
|
throw new Error("Not implemented");
|
|
}
|
|
mapGetResult(_result, _isFromBatch) {
|
|
throw new Error("Not implemented");
|
|
}
|
|
execute(placeholderValues) {
|
|
if (this.mode === "async") {
|
|
return this[this.executeMethod](placeholderValues);
|
|
}
|
|
return new ExecuteResultSync(() => this[this.executeMethod](placeholderValues));
|
|
}
|
|
mapResult(response, isFromBatch) {
|
|
switch (this.executeMethod) {
|
|
case "run": {
|
|
return this.mapRunResult(response, isFromBatch);
|
|
}
|
|
case "all": {
|
|
return this.mapAllResult(response, isFromBatch);
|
|
}
|
|
case "get": {
|
|
return this.mapGetResult(response, isFromBatch);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
class SQLiteSession {
|
|
constructor(dialect) {
|
|
this.dialect = dialect;
|
|
}
|
|
static [entityKind] = "SQLiteSession";
|
|
prepareOneTimeQuery(query, fields, executeMethod, isResponseInArrayMode, customResultMapper, queryMetadata, cacheConfig) {
|
|
return this.prepareQuery(query, fields, executeMethod, isResponseInArrayMode, customResultMapper, queryMetadata, cacheConfig);
|
|
}
|
|
run(query) {
|
|
const staticQuery = this.dialect.sqlToQuery(query);
|
|
try {
|
|
return this.prepareOneTimeQuery(staticQuery, undefined, "run", false).run();
|
|
} catch (err) {
|
|
throw new DrizzleError({ cause: err, message: `Failed to run the query '${staticQuery.sql}'` });
|
|
}
|
|
}
|
|
extractRawRunValueFromBatchResult(result) {
|
|
return result;
|
|
}
|
|
all(query) {
|
|
return this.prepareOneTimeQuery(this.dialect.sqlToQuery(query), undefined, "run", false).all();
|
|
}
|
|
extractRawAllValueFromBatchResult(_result) {
|
|
throw new Error("Not implemented");
|
|
}
|
|
get(query) {
|
|
return this.prepareOneTimeQuery(this.dialect.sqlToQuery(query), undefined, "run", false).get();
|
|
}
|
|
extractRawGetValueFromBatchResult(_result) {
|
|
throw new Error("Not implemented");
|
|
}
|
|
values(query) {
|
|
return this.prepareOneTimeQuery(this.dialect.sqlToQuery(query), undefined, "run", false).values();
|
|
}
|
|
async count(sql2) {
|
|
const result = await this.values(sql2);
|
|
return result[0][0];
|
|
}
|
|
extractRawValuesValueFromBatchResult(_result) {
|
|
throw new Error("Not implemented");
|
|
}
|
|
}
|
|
|
|
class SQLiteTransaction extends BaseSQLiteDatabase {
|
|
constructor(resultType, dialect, session, schema, nestedIndex = 0) {
|
|
super(resultType, dialect, session, schema);
|
|
this.schema = schema;
|
|
this.nestedIndex = nestedIndex;
|
|
}
|
|
static [entityKind] = "SQLiteTransaction";
|
|
rollback() {
|
|
throw new TransactionRollbackError;
|
|
}
|
|
}
|
|
|
|
// ../eve/node_modules/drizzle-orm/logger.js
|
|
class ConsoleLogWriter {
|
|
static [entityKind] = "ConsoleLogWriter";
|
|
write(message) {
|
|
console.log(message);
|
|
}
|
|
}
|
|
|
|
class DefaultLogger {
|
|
static [entityKind] = "DefaultLogger";
|
|
writer;
|
|
constructor(config) {
|
|
this.writer = config?.writer ?? new ConsoleLogWriter;
|
|
}
|
|
logQuery(query, params) {
|
|
const stringifiedParams = params.map((p) => {
|
|
try {
|
|
return JSON.stringify(p);
|
|
} catch {
|
|
return String(p);
|
|
}
|
|
});
|
|
const paramsStr = stringifiedParams.length ? ` -- params: [${stringifiedParams.join(", ")}]` : "";
|
|
this.writer.write(`Query: ${query}${paramsStr}`);
|
|
}
|
|
}
|
|
|
|
class NoopLogger {
|
|
static [entityKind] = "NoopLogger";
|
|
logQuery() {}
|
|
}
|
|
|
|
// ../eve/dist/db/schema.js
|
|
var schema_exports = {};
|
|
__export(schema_exports, {
|
|
characters: () => characters,
|
|
charactersRelations: () => charactersRelations,
|
|
miningFleetParticipants: () => miningFleetParticipants,
|
|
miningFleetParticipantsRelations: () => miningFleetParticipantsRelations,
|
|
miningFleets: () => miningFleets,
|
|
miningFleetsRelations: () => miningFleetsRelations,
|
|
resumeCommands: () => resumeCommands,
|
|
shared: () => shared,
|
|
users: () => users,
|
|
usersRelations: () => usersRelations
|
|
});
|
|
var shared = {
|
|
createdAt: integer("created_at").notNull(),
|
|
updatedAt: integer("updated_at")
|
|
};
|
|
var users = sqliteTable("users", {
|
|
id: integer().primaryKey().unique().notNull(),
|
|
discordID: text("discord_id").unique().notNull(),
|
|
mainCharacter: integer("main_character"),
|
|
...shared
|
|
}, (table) => [index("idx_discord_id").on(table.discordID), index("idx_main_character").on(table.mainCharacter)]);
|
|
var usersRelations = relations(users, ({ one, many }) => ({
|
|
characters: many(characters),
|
|
main: one(characters, {
|
|
fields: [users.mainCharacter],
|
|
references: [characters.id]
|
|
})
|
|
}));
|
|
var characters = sqliteTable("characters", {
|
|
id: integer("id").primaryKey({ autoIncrement: true }),
|
|
eveID: integer("eve_id").notNull(),
|
|
userID: integer("user_id").notNull(),
|
|
name: text().notNull(),
|
|
accessToken: text("access_token").notNull(),
|
|
expiresAt: integer("expires_at").notNull(),
|
|
refreshToken: text("refresh_token").notNull(),
|
|
...shared
|
|
}, (table) => [index("idx_user_id").on(table.userID), index("idx_eve_id").on(table.eveID)]);
|
|
var charactersRelations = relations(characters, ({ one }) => ({ user: one(users, {
|
|
fields: [characters.userID],
|
|
references: [users.id]
|
|
}) }));
|
|
var resumeCommands = sqliteTable("resumecommands", {
|
|
id: text().primaryKey(),
|
|
command: text().notNull(),
|
|
params: text().notNull(),
|
|
context: text().notNull(),
|
|
...shared
|
|
});
|
|
var miningFleets = sqliteTable("mining_fleets", {
|
|
id: integer("id").primaryKey({ autoIncrement: true }),
|
|
name: text("name").notNull(),
|
|
description: text("description"),
|
|
creatorDiscordId: text("creator_discord_id").notNull(),
|
|
startTime: integer("start_time").notNull(),
|
|
endTime: integer("end_time"),
|
|
status: text("status", { enum: [
|
|
"configuring",
|
|
"active",
|
|
"ended",
|
|
"generating_report",
|
|
"completed",
|
|
"failed"
|
|
] }).notNull().default("configuring"),
|
|
taxRate: real("tax_rate").notNull().default(0),
|
|
publicMessageId: text("public_message_id").unique(),
|
|
publicChannelId: text("public_channel_id"),
|
|
reportData: text("report_data"),
|
|
creatorEphemeralMessageId: text("creator_ephemeral_message_id"),
|
|
...shared
|
|
}, (table) => [
|
|
index("idx_fleet_creator_discord_id").on(table.creatorDiscordId),
|
|
index("idx_fleet_status").on(table.status),
|
|
index("idx_fleet_public_message_id").on(table.publicMessageId)
|
|
]);
|
|
var miningFleetParticipants = sqliteTable("mining_fleet_participants", {
|
|
id: integer("id").primaryKey({ autoIncrement: true }),
|
|
fleetId: integer("fleet_id").notNull().references(() => miningFleets.id, { onDelete: "cascade" }),
|
|
characterId: integer("character_id").notNull().references(() => characters.id, { onDelete: "cascade" }),
|
|
discordId: text("discord_id").notNull(),
|
|
role: text("role", { enum: [
|
|
"miner",
|
|
"security",
|
|
"hauler"
|
|
] }).notNull(),
|
|
joinTime: integer("join_time").notNull(),
|
|
...shared
|
|
}, (table) => [
|
|
index("idx_participant_fleet_id").on(table.fleetId),
|
|
index("idx_participant_character_id").on(table.characterId),
|
|
index("idx_participant_discord_id").on(table.discordId)
|
|
]);
|
|
var miningFleetsRelations = relations(miningFleets, ({ many }) => ({ participants: many(miningFleetParticipants) }));
|
|
var miningFleetParticipantsRelations = relations(miningFleetParticipants, ({ one }) => ({
|
|
fleet: one(miningFleets, {
|
|
fields: [miningFleetParticipants.fleetId],
|
|
references: [miningFleets.id]
|
|
}),
|
|
character: one(characters, {
|
|
fields: [miningFleetParticipants.characterId],
|
|
references: [characters.id]
|
|
})
|
|
}));
|
|
|
|
// ../eve/dist/esi/options.js
|
|
var CLIENT_ID = process.env.EVE_CLIENT_ID || "";
|
|
var CLIENT_SECRET = process.env.EVE_CLIENT_SECRET || "";
|
|
var CALLBACK_URL = process.env.EVE_CALLBACK_URL || "";
|
|
var USER_AGENT = process.env.ESI_USER_AGENT || "";
|
|
var options = {
|
|
client_id: CLIENT_ID,
|
|
client_secret: CLIENT_SECRET,
|
|
callback_url: CALLBACK_URL,
|
|
user_agent: USER_AGENT
|
|
};
|
|
|
|
// ../eve/node_modules/jwt-decode/build/esm/index.js
|
|
class InvalidTokenError extends Error {
|
|
}
|
|
InvalidTokenError.prototype.name = "InvalidTokenError";
|
|
function b64DecodeUnicode(str) {
|
|
return decodeURIComponent(atob(str).replace(/(.)/g, (m, p) => {
|
|
let code = p.charCodeAt(0).toString(16).toUpperCase();
|
|
if (code.length < 2) {
|
|
code = "0" + code;
|
|
}
|
|
return "%" + code;
|
|
}));
|
|
}
|
|
function base64UrlDecode(str) {
|
|
let output = str.replace(/-/g, "+").replace(/_/g, "/");
|
|
switch (output.length % 4) {
|
|
case 0:
|
|
break;
|
|
case 2:
|
|
output += "==";
|
|
break;
|
|
case 3:
|
|
output += "=";
|
|
break;
|
|
default:
|
|
throw new Error("base64 string is not of the correct length");
|
|
}
|
|
try {
|
|
return b64DecodeUnicode(output);
|
|
} catch (err) {
|
|
return atob(output);
|
|
}
|
|
}
|
|
function jwtDecode(token, options2) {
|
|
if (typeof token !== "string") {
|
|
throw new InvalidTokenError("Invalid token specified: must be a string");
|
|
}
|
|
options2 || (options2 = {});
|
|
const pos = options2.header === true ? 0 : 1;
|
|
const part = token.split(".")[pos];
|
|
if (typeof part !== "string") {
|
|
throw new InvalidTokenError(`Invalid token specified: missing part #${pos + 1}`);
|
|
}
|
|
let decoded;
|
|
try {
|
|
decoded = base64UrlDecode(part);
|
|
} catch (e) {
|
|
throw new InvalidTokenError(`Invalid token specified: invalid base64 for part #${pos + 1} (${e.message})`);
|
|
}
|
|
try {
|
|
return JSON.parse(decoded);
|
|
} catch (e) {
|
|
throw new InvalidTokenError(`Invalid token specified: invalid json for part #${pos + 1} (${e.message})`);
|
|
}
|
|
}
|
|
// ../eve/node_modules/@oslojs/encoding/dist/base32.js
|
|
var EncodingPadding;
|
|
(function(EncodingPadding2) {
|
|
EncodingPadding2[EncodingPadding2["Include"] = 0] = "Include";
|
|
EncodingPadding2[EncodingPadding2["None"] = 1] = "None";
|
|
})(EncodingPadding || (EncodingPadding = {}));
|
|
var DecodingPadding;
|
|
(function(DecodingPadding2) {
|
|
DecodingPadding2[DecodingPadding2["Required"] = 0] = "Required";
|
|
DecodingPadding2[DecodingPadding2["Ignore"] = 1] = "Ignore";
|
|
})(DecodingPadding || (DecodingPadding = {}));
|
|
// ../eve/node_modules/@oslojs/encoding/dist/base64.js
|
|
function encodeBase64urlNoPadding(bytes) {
|
|
return encodeBase64_internal(bytes, base64urlAlphabet, EncodingPadding2.None);
|
|
}
|
|
function encodeBase64_internal(bytes, alphabet, padding) {
|
|
let result = "";
|
|
for (let i = 0;i < bytes.byteLength; i += 3) {
|
|
let buffer = 0;
|
|
let bufferBitSize = 0;
|
|
for (let j = 0;j < 3 && i + j < bytes.byteLength; j++) {
|
|
buffer = buffer << 8 | bytes[i + j];
|
|
bufferBitSize += 8;
|
|
}
|
|
for (let j = 0;j < 4; j++) {
|
|
if (bufferBitSize >= 6) {
|
|
result += alphabet[buffer >> bufferBitSize - 6 & 63];
|
|
bufferBitSize -= 6;
|
|
} else if (bufferBitSize > 0) {
|
|
result += alphabet[buffer << 6 - bufferBitSize & 63];
|
|
bufferBitSize = 0;
|
|
} else if (padding === EncodingPadding2.Include) {
|
|
result += "=";
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
var base64urlAlphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
|
|
var EncodingPadding2;
|
|
(function(EncodingPadding3) {
|
|
EncodingPadding3[EncodingPadding3["Include"] = 0] = "Include";
|
|
EncodingPadding3[EncodingPadding3["None"] = 1] = "None";
|
|
})(EncodingPadding2 || (EncodingPadding2 = {}));
|
|
var DecodingPadding2;
|
|
(function(DecodingPadding3) {
|
|
DecodingPadding3[DecodingPadding3["Required"] = 0] = "Required";
|
|
DecodingPadding3[DecodingPadding3["Ignore"] = 1] = "Ignore";
|
|
})(DecodingPadding2 || (DecodingPadding2 = {}));
|
|
// ../eve/dist/esi/auth.js
|
|
var import_jsonwebtoken = __toESM(require_jsonwebtoken(), 1);
|
|
var import_jwk_to_pem = __toESM(require_jwk_to_pem(), 1);
|
|
var auth_exports = {};
|
|
__export(auth_exports, {
|
|
characterIdFromToken: () => characterIdFromToken,
|
|
createAuthorizationURL: () => createAuthorizationURL,
|
|
refresh: () => refresh,
|
|
validateAuthorizationCode: () => validateAuthorizationCode,
|
|
validateToken: () => validateToken
|
|
});
|
|
function generateState() {
|
|
const randomValues = new Uint8Array(32);
|
|
crypto.getRandomValues(randomValues);
|
|
return encodeBase64urlNoPadding(randomValues);
|
|
}
|
|
async function createAuthorizationURL(scopes = "publicData") {
|
|
const state = generateState();
|
|
const url = new URL("https://login.eveonline.com/v2/oauth/authorize/");
|
|
url.searchParams.set("response_type", "code");
|
|
url.searchParams.set("redirect_uri", options.callback_url);
|
|
url.searchParams.set("client_id", options.client_id);
|
|
url.searchParams.set("state", state);
|
|
url.searchParams.set("scope", Array.isArray(scopes) ? scopes.join(" ") : scopes);
|
|
return {
|
|
url,
|
|
state
|
|
};
|
|
}
|
|
async function validateAuthorizationCode(code) {
|
|
try {
|
|
const response = await fetch("https://login.eveonline.com/v2/oauth/token", {
|
|
method: "POST",
|
|
headers: {
|
|
"Content-Type": "application/x-www-form-urlencoded",
|
|
Authorization: `Basic ${Buffer.from(`${options.client_id}:${options.client_secret}`).toString("base64")}`
|
|
},
|
|
body: new URLSearchParams({
|
|
grant_type: "authorization_code",
|
|
code
|
|
})
|
|
});
|
|
return await response.json();
|
|
} catch (error) {
|
|
console.error(`failed to validate EVE authorization code`, error);
|
|
throw `${error}`;
|
|
}
|
|
}
|
|
var eveAuthPublicKey;
|
|
async function validateToken(token) {
|
|
if (!eveAuthPublicKey)
|
|
try {
|
|
const eveJWKS = await (await fetch("https://login.eveonline.com/oauth/jwks")).json();
|
|
eveAuthPublicKey = import_jwk_to_pem.default(eveJWKS.keys[0]);
|
|
} catch (err) {
|
|
console.error(`failed to get EVE Auth public keys`, err);
|
|
}
|
|
try {
|
|
const decoded = import_jsonwebtoken.default.verify(token, eveAuthPublicKey);
|
|
return decoded;
|
|
} catch (err) {
|
|
console.error(`failed to validate EVE token`, err);
|
|
return null;
|
|
}
|
|
}
|
|
async function refresh({ refresh_token }, scopes) {
|
|
const params = {
|
|
grant_type: "refresh_token",
|
|
refresh_token,
|
|
scope: ""
|
|
};
|
|
if (scopes)
|
|
params["scope"] = Array.isArray(scopes) ? scopes.join(" ") : scopes;
|
|
const response = await fetch("https://login.eveonline.com/v2/oauth/token", {
|
|
method: "POST",
|
|
headers: {
|
|
"Content-Type": "application/x-www-form-urlencoded",
|
|
Authorization: `Basic ${Buffer.from(`${options.client_id}:${options.client_secret}`).toString("base64")}`
|
|
},
|
|
body: new URLSearchParams(params)
|
|
});
|
|
return await response.json();
|
|
}
|
|
function characterIdFromToken(token) {
|
|
const payload = jwtDecode(token);
|
|
return parseInt(payload.sub.split(":")[2]);
|
|
}
|
|
|
|
// ../eve/dist/db/models/character.model.js
|
|
var CharacterHelper = class CharacterHelper2 {
|
|
static hasValidToken(character) {
|
|
return /* @__PURE__ */ new Date < character.expiresAt;
|
|
}
|
|
static getScopes(character) {
|
|
const decoded = jwtDecode(character.accessToken);
|
|
return typeof decoded.scp === "string" ? [decoded.scp] : decoded.scp;
|
|
}
|
|
static hasOnlyPublicScope(character) {
|
|
return this.getScopes(character).length === 1 && this.hasScope(character, "publicData");
|
|
}
|
|
static getTokens(character) {
|
|
return {
|
|
access_token: character.accessToken,
|
|
refresh_token: character.refreshToken,
|
|
expires_in: (character.expiresAt.getTime() - Date.now()) / 1000
|
|
};
|
|
}
|
|
static hasScope(character, scope) {
|
|
return this.getScopes(character).includes(scope);
|
|
}
|
|
static hasAllScopes(character, scopes) {
|
|
const has = this.getScopes(character);
|
|
return scopes.every((scope) => has.includes(scope));
|
|
}
|
|
static find(id) {
|
|
const result = db.select().from(characters).where(eq(characters.id, id)).limit(1).get();
|
|
const c = this.createCharacters(result);
|
|
return c ? c[0] : undefined;
|
|
}
|
|
static findByUser(user) {
|
|
const result = db.select().from(characters).where(eq(characters.userID, user.id)).all();
|
|
return this.createCharacters(result);
|
|
}
|
|
static findByUserAndEveID(userID, eveID) {
|
|
const result = db.select().from(characters).where(and(eq(characters.userID, userID), eq(characters.eveID, eveID))).limit(1).get();
|
|
const c = this.createCharacters(result);
|
|
return c ? c[0] : undefined;
|
|
}
|
|
static findByName(userID, name) {
|
|
const result = db.select().from(characters).where(and(eq(characters.name, name), eq(characters.userID, userID))).limit(1).get();
|
|
const c = this.createCharacters(result);
|
|
return c ? c[0] : undefined;
|
|
}
|
|
static findAll() {
|
|
const result = db.select().from(characters).all();
|
|
return this.createCharacters(result);
|
|
}
|
|
static create(eveID, name, user, tokens) {
|
|
return this.save({
|
|
eveID,
|
|
userID: user.id,
|
|
accessToken: tokens.access_token,
|
|
expiresAt: /* @__PURE__ */ new Date(tokens.expires_in * 1000),
|
|
refreshToken: tokens.refresh_token,
|
|
name,
|
|
createdAt: /* @__PURE__ */ new Date
|
|
});
|
|
}
|
|
static createCharacters(query) {
|
|
if (!query)
|
|
return [];
|
|
if (Array.isArray(query))
|
|
return query.map((character) => {
|
|
return {
|
|
id: character.id,
|
|
eveID: character.eveID,
|
|
userID: character.userID,
|
|
accessToken: character.accessToken,
|
|
expiresAt: new Date(character.expiresAt),
|
|
refreshToken: character.refreshToken,
|
|
name: character.name,
|
|
createdAt: new Date(character.createdAt),
|
|
updatedAt: new Date(character.updatedAt)
|
|
};
|
|
});
|
|
else
|
|
return [{
|
|
id: query.id,
|
|
eveID: query.eveID,
|
|
userID: query.userID,
|
|
accessToken: query.accessToken,
|
|
expiresAt: new Date(query.expiresAt),
|
|
refreshToken: query.refreshToken,
|
|
name: query.name,
|
|
createdAt: new Date(query.createdAt),
|
|
updatedAt: new Date(query.updatedAt)
|
|
}];
|
|
}
|
|
static save(character) {
|
|
db.insert(characters).values({
|
|
id: character.id,
|
|
eveID: character.eveID,
|
|
userID: character.userID,
|
|
name: character.name,
|
|
accessToken: character.accessToken,
|
|
expiresAt: character.expiresAt.getTime(),
|
|
refreshToken: character.refreshToken,
|
|
createdAt: Date.now(),
|
|
updatedAt: Date.now()
|
|
}).onConflictDoUpdate({
|
|
target: characters.id,
|
|
set: {
|
|
eveID: character.eveID,
|
|
userID: character.userID,
|
|
name: character.name,
|
|
accessToken: character.accessToken,
|
|
expiresAt: character.expiresAt.getTime(),
|
|
refreshToken: character.refreshToken,
|
|
updatedAt: Date.now()
|
|
}
|
|
}).run();
|
|
return CharacterHelper2.findByUserAndEveID(character.userID, character.eveID);
|
|
}
|
|
static delete(character) {
|
|
db.delete(characters).where(eq(characters.id, character.id)).run();
|
|
}
|
|
static async refreshTokens(character, scopes) {
|
|
const tokens = await refresh({ refresh_token: character.refreshToken }, scopes);
|
|
const decoded = await validateToken(tokens.access_token);
|
|
if (!decoded) {
|
|
console.error(`Failed to validate token for character ${character.eveID}`);
|
|
return character;
|
|
}
|
|
character.accessToken = tokens.access_token;
|
|
character.expiresAt = new Date(Date.now() + tokens.expires_in * 1000);
|
|
character.refreshToken = tokens.refresh_token;
|
|
this.save(character);
|
|
return character;
|
|
}
|
|
};
|
|
|
|
// ../eve/dist/db/models/user.model.js
|
|
var UserHelper = class {
|
|
static find(id) {
|
|
const result = db.select({
|
|
id: users.id,
|
|
discordID: users.discordID,
|
|
createdAt: users.createdAt,
|
|
updatedAt: users.updatedAt,
|
|
mainCharacterID: users.mainCharacter,
|
|
characterIDsString: sql`json_group_array(characters.id)`
|
|
}).from(users).where(eq(users.id, id)).leftJoin(characters, eq(users.id, characters.userID)).get();
|
|
return this.createFromQuery(result);
|
|
}
|
|
static findByDiscordId(id) {
|
|
const result = db.select({
|
|
id: users.id,
|
|
discordID: users.discordID,
|
|
createdAt: users.createdAt,
|
|
updatedAt: users.updatedAt,
|
|
mainCharacterID: users.mainCharacter,
|
|
characterIDsString: sql`json_group_array(characters.id)`
|
|
}).from(users).where(eq(users.discordID, id)).leftJoin(characters, eq(users.id, characters.userID)).get();
|
|
return this.createFromQuery(result);
|
|
}
|
|
static findAll() {
|
|
const result = db.select({
|
|
id: users.id,
|
|
discordID: users.discordID,
|
|
createdAt: users.createdAt,
|
|
updatedAt: users.updatedAt,
|
|
mainCharacterID: users.mainCharacter,
|
|
characterIDsString: sql`json_group_array(characters.id)`
|
|
}).from(users).leftJoin(characters, eq(users.id, characters.userID)).all();
|
|
return this.createFromQuery(result);
|
|
}
|
|
static findByCharacterId(id) {
|
|
const result = db.select({
|
|
id: users.id,
|
|
discordID: users.discordID,
|
|
createdAt: users.createdAt,
|
|
updatedAt: users.updatedAt,
|
|
mainCharacterID: users.mainCharacter,
|
|
characterIDsString: sql`json_group_array(characters.id)`
|
|
}).from(users).leftJoin(characters, eq(users.id, characters.userID)).where(eq(characters.id, id)).all();
|
|
return this.createFromQuery(result);
|
|
}
|
|
static findByCharacterName(name) {
|
|
const result = db.select({
|
|
id: users.id,
|
|
discordID: users.discordID,
|
|
createdAt: users.createdAt,
|
|
updatedAt: users.updatedAt,
|
|
mainCharacterID: users.mainCharacter,
|
|
characterIDsString: sql`json_group_array(characters.id)`
|
|
}).from(users).leftJoin(characters, eq(users.id, characters.userID)).where(eq(characters.name, name)).all();
|
|
return this.createFromQuery(result);
|
|
}
|
|
static createFromQuery(query) {
|
|
if (!query)
|
|
return [];
|
|
if (Array.isArray(query))
|
|
return query.map((user) => {
|
|
return {
|
|
id: user.id,
|
|
discordID: user.discordID,
|
|
createdAt: new Date(user.createdAt),
|
|
updatedAt: new Date(user.updatedAt),
|
|
characterIDs: user.characterIDsString ? JSON.parse(user.characterIDsString ?? "[]").map((s) => Number(s)).sort() : [],
|
|
mainCharacterID: user.mainCharacterID
|
|
};
|
|
});
|
|
else
|
|
return {
|
|
id: query.id,
|
|
discordID: query.discordID,
|
|
createdAt: new Date(query.createdAt),
|
|
updatedAt: new Date(query.updatedAt),
|
|
characterIDs: query.characterIDsString ? JSON.parse(query.characterIDsString ?? "[]").map((s) => Number(s)).sort() : [],
|
|
mainCharacterID: query.mainCharacterID
|
|
};
|
|
}
|
|
static create(discordID) {
|
|
this.save({
|
|
discordID,
|
|
createdAt: /* @__PURE__ */ new Date,
|
|
updatedAt: /* @__PURE__ */ new Date
|
|
});
|
|
return this.findByDiscordId(discordID);
|
|
}
|
|
static save(user) {
|
|
db.insert(users).values({
|
|
id: user.id,
|
|
discordID: user.discordID,
|
|
mainCharacter: user.mainCharacterID,
|
|
createdAt: user.createdAt.getTime(),
|
|
updatedAt: user.updatedAt.getTime()
|
|
}).onConflictDoUpdate({
|
|
target: users.id,
|
|
set: {
|
|
discordID: user.discordID,
|
|
mainCharacter: user.mainCharacterID,
|
|
updatedAt: user.updatedAt.getTime()
|
|
}
|
|
}).run();
|
|
return user;
|
|
}
|
|
static delete(user) {
|
|
db.delete(users).where(eq(users.id, user.id)).run();
|
|
}
|
|
static getCharacter(user, index2) {
|
|
if (!user.characterIDs)
|
|
return;
|
|
if (index2 >= user.characterIDs.length)
|
|
return;
|
|
return CharacterHelper.find(user.characterIDs[index2]);
|
|
}
|
|
};
|
|
|
|
// ../eve/dist/db/models/resume-command.model.js
|
|
var ResumeCommand = class ResumeCommand2 {
|
|
id;
|
|
command;
|
|
params;
|
|
context;
|
|
created = /* @__PURE__ */ new Date;
|
|
constructor() {
|
|
this.created = /* @__PURE__ */ new Date;
|
|
}
|
|
static find(messageId) {
|
|
const result = db.select().from(resumeCommands).where(eq(resumeCommands.id, messageId)).get();
|
|
return this.createFromQuery(result);
|
|
}
|
|
static create(messageId, command, params = {}, context = {}) {
|
|
const resume = new ResumeCommand2;
|
|
resume.id = messageId;
|
|
resume.command = command;
|
|
resume.params = JSON.stringify(params);
|
|
resume.context = JSON.stringify(context);
|
|
return resume;
|
|
}
|
|
static createFromQuery(query) {
|
|
if (!query)
|
|
return null;
|
|
const resume = new ResumeCommand2;
|
|
resume.id = query.id;
|
|
resume.command = query.command;
|
|
resume.params = query.params;
|
|
resume.context = query.context;
|
|
resume.created = query.created;
|
|
return resume;
|
|
}
|
|
save() {
|
|
db.insert(resumeCommands).values({
|
|
id: this.id,
|
|
command: this.command,
|
|
params: this.params,
|
|
context: this.context,
|
|
createdAt: this.created.getTime()
|
|
}).onConflictDoUpdate({
|
|
target: resumeCommands.id,
|
|
set: {
|
|
command: this.command,
|
|
params: this.params,
|
|
context: this.context
|
|
}
|
|
}).run();
|
|
return this;
|
|
}
|
|
delete() {
|
|
db.delete(resumeCommands).where(eq(resumeCommands.id, this.id)).run();
|
|
}
|
|
static delete(messageId) {
|
|
db.delete(resumeCommands).where(eq(resumeCommands.id, messageId)).run();
|
|
}
|
|
};
|
|
|
|
// ../eve/dist/db/models/index.js
|
|
var models_exports = {};
|
|
__export(models_exports, {
|
|
CharacterHelper: () => CharacterHelper,
|
|
ResumeCommand: () => ResumeCommand,
|
|
UserHelper: () => UserHelper
|
|
});
|
|
|
|
// ../eve/node_modules/drizzle-orm/bun-sqlite/driver.js
|
|
import { Database } from "bun:sqlite";
|
|
|
|
// ../eve/node_modules/drizzle-orm/bun-sqlite/session.js
|
|
class SQLiteBunSession extends SQLiteSession {
|
|
constructor(client, dialect, schema, options2 = {}) {
|
|
super(dialect);
|
|
this.client = client;
|
|
this.schema = schema;
|
|
this.logger = options2.logger ?? new NoopLogger;
|
|
}
|
|
static [entityKind] = "SQLiteBunSession";
|
|
logger;
|
|
exec(query) {
|
|
this.client.exec(query);
|
|
}
|
|
prepareQuery(query, fields, executeMethod, isResponseInArrayMode, customResultMapper) {
|
|
const stmt = this.client.prepare(query.sql);
|
|
return new PreparedQuery(stmt, query, this.logger, fields, executeMethod, isResponseInArrayMode, customResultMapper);
|
|
}
|
|
transaction(transaction, config = {}) {
|
|
const tx = new SQLiteBunTransaction("sync", this.dialect, this, this.schema);
|
|
let result;
|
|
const nativeTx = this.client.transaction(() => {
|
|
result = transaction(tx);
|
|
});
|
|
nativeTx[config.behavior ?? "deferred"]();
|
|
return result;
|
|
}
|
|
}
|
|
|
|
class SQLiteBunTransaction extends SQLiteTransaction {
|
|
static [entityKind] = "SQLiteBunTransaction";
|
|
transaction(transaction) {
|
|
const savepointName = `sp${this.nestedIndex}`;
|
|
const tx = new SQLiteBunTransaction("sync", this.dialect, this.session, this.schema, this.nestedIndex + 1);
|
|
this.session.run(sql.raw(`savepoint ${savepointName}`));
|
|
try {
|
|
const result = transaction(tx);
|
|
this.session.run(sql.raw(`release savepoint ${savepointName}`));
|
|
return result;
|
|
} catch (err) {
|
|
this.session.run(sql.raw(`rollback to savepoint ${savepointName}`));
|
|
throw err;
|
|
}
|
|
}
|
|
}
|
|
|
|
class PreparedQuery extends SQLitePreparedQuery {
|
|
constructor(stmt, query, logger, fields, executeMethod, _isResponseInArrayMode, customResultMapper) {
|
|
super("sync", executeMethod, query);
|
|
this.stmt = stmt;
|
|
this.logger = logger;
|
|
this.fields = fields;
|
|
this._isResponseInArrayMode = _isResponseInArrayMode;
|
|
this.customResultMapper = customResultMapper;
|
|
}
|
|
static [entityKind] = "SQLiteBunPreparedQuery";
|
|
run(placeholderValues) {
|
|
const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
|
|
this.logger.logQuery(this.query.sql, params);
|
|
return this.stmt.run(...params);
|
|
}
|
|
all(placeholderValues) {
|
|
const { fields, query, logger, joinsNotNullableMap, stmt, customResultMapper } = this;
|
|
if (!fields && !customResultMapper) {
|
|
const params = fillPlaceholders(query.params, placeholderValues ?? {});
|
|
logger.logQuery(query.sql, params);
|
|
return stmt.all(...params);
|
|
}
|
|
const rows = this.values(placeholderValues);
|
|
if (customResultMapper) {
|
|
return customResultMapper(rows);
|
|
}
|
|
return rows.map((row) => mapResultRow(fields, row, joinsNotNullableMap));
|
|
}
|
|
get(placeholderValues) {
|
|
const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
|
|
this.logger.logQuery(this.query.sql, params);
|
|
const row = this.stmt.values(...params)[0];
|
|
if (!row) {
|
|
return;
|
|
}
|
|
const { fields, joinsNotNullableMap, customResultMapper } = this;
|
|
if (!fields && !customResultMapper) {
|
|
return row;
|
|
}
|
|
if (customResultMapper) {
|
|
return customResultMapper([row]);
|
|
}
|
|
return mapResultRow(fields, row, joinsNotNullableMap);
|
|
}
|
|
values(placeholderValues) {
|
|
const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
|
|
this.logger.logQuery(this.query.sql, params);
|
|
return this.stmt.values(...params);
|
|
}
|
|
isResponseInArrayMode() {
|
|
return this._isResponseInArrayMode;
|
|
}
|
|
}
|
|
|
|
// ../eve/node_modules/drizzle-orm/bun-sqlite/driver.js
|
|
class BunSQLiteDatabase extends BaseSQLiteDatabase {
|
|
static [entityKind] = "BunSQLiteDatabase";
|
|
}
|
|
function construct(client, config = {}) {
|
|
const dialect = new SQLiteSyncDialect({ casing: config.casing });
|
|
let logger;
|
|
if (config.logger === true) {
|
|
logger = new DefaultLogger;
|
|
} else if (config.logger !== false) {
|
|
logger = config.logger;
|
|
}
|
|
let schema;
|
|
if (config.schema) {
|
|
const tablesConfig = extractTablesRelationalConfig(config.schema, createTableRelationsHelpers);
|
|
schema = {
|
|
fullSchema: config.schema,
|
|
schema: tablesConfig.tables,
|
|
tableNamesMap: tablesConfig.tableNamesMap
|
|
};
|
|
}
|
|
const session = new SQLiteBunSession(client, dialect, schema, { logger });
|
|
const db2 = new BunSQLiteDatabase("sync", dialect, session, schema);
|
|
db2.$client = client;
|
|
return db2;
|
|
}
|
|
function drizzle(...params) {
|
|
if (params[0] === undefined || typeof params[0] === "string") {
|
|
const instance = params[0] === undefined ? new Database : new Database(params[0]);
|
|
return construct(instance, params[1]);
|
|
}
|
|
if (isConfig(params[0])) {
|
|
const { connection, client, ...drizzleConfig } = params[0];
|
|
if (client)
|
|
return construct(client, drizzleConfig);
|
|
if (typeof connection === "object") {
|
|
const { source, ...opts } = connection;
|
|
const options2 = Object.values(opts).filter((v) => v !== undefined).length ? opts : undefined;
|
|
const instance2 = new Database(source, options2);
|
|
return construct(instance2, drizzleConfig);
|
|
}
|
|
const instance = new Database(connection);
|
|
return construct(instance, drizzleConfig);
|
|
}
|
|
return construct(params[0], params[1]);
|
|
}
|
|
((drizzle2) => {
|
|
function mock(config) {
|
|
return construct({}, config);
|
|
}
|
|
drizzle2.mock = mock;
|
|
})(drizzle || (drizzle = {}));
|
|
|
|
// ../eve/dist/db/index.js
|
|
import { Database as Database2 } from "bun:sqlite";
|
|
import { join } from "path";
|
|
var DB_PATH = process.env.AUTH_DB_PATH || join(process.cwd(), "../../db/kitten.db");
|
|
console.log("Using DB_PATH:", DB_PATH);
|
|
var sqlite = new Database2(DB_PATH);
|
|
var db = drizzle(sqlite, { schema: {
|
|
users,
|
|
characters,
|
|
resumeCommands,
|
|
miningFleets,
|
|
miningFleetParticipants
|
|
} });
|
|
|
|
// ../eve/dist/esi/scopes.js
|
|
var ESI_LATEST_URL = "https://esi.evetech.net/latest";
|
|
function joinScopes(...scopes) {
|
|
return scopes.join(" ");
|
|
}
|
|
var SCOPES = /* @__PURE__ */ function(SCOPES$1) {
|
|
SCOPES$1["PUBLIC_DATA"] = "publicData";
|
|
SCOPES$1["CALENDAR_RESPOND_CALENDAR_EVENTS"] = "esi-calendar.respond_calendar_events.v1";
|
|
SCOPES$1["CALENDAR_READ_CALENDAR_EVENTS"] = "esi-calendar.read_calendar_events.v1";
|
|
SCOPES$1["LOCATION_READ_LOCATION"] = "esi-location.read_location.v1";
|
|
SCOPES$1["LOCATION_READ_SHIP_TYPE"] = "esi-location.read_ship_type.v1";
|
|
SCOPES$1["MAIL_ORGANIZE_MAIL"] = "esi-mail.organize_mail.v1";
|
|
SCOPES$1["MAIL_READ_MAIL"] = "esi-mail.read_mail.v1";
|
|
SCOPES$1["MAIL_SEND_MAIL"] = "esi-mail.send_mail.v1";
|
|
SCOPES$1["SKILLS_READ_SKILLS"] = "esi-skills.read_skills.v1";
|
|
SCOPES$1["SKILLS_READ_SKILLQUEUE"] = "esi-skills.read_skillqueue.v1";
|
|
SCOPES$1["WALLET_READ_CHARACTER_WALLET"] = "esi-wallet.read_character_wallet.v1";
|
|
SCOPES$1["WALLET_READ_CORPORATION_WALLET"] = "esi-wallet.read_corporation_wallet.v1";
|
|
SCOPES$1["SEARCH_SEARCH_STRUCTURES"] = "esi-search.search_structures.v1";
|
|
SCOPES$1["CLONES_READ_CLONES"] = "esi-clones.read_clones.v1";
|
|
SCOPES$1["CHARACTERS_READ_CONTACTS"] = "esi-characters.read_contacts.v1";
|
|
SCOPES$1["UNIVERSE_READ_STRUCTURES"] = "esi-universe.read_structures.v1";
|
|
SCOPES$1["KILLMAILS_READ_KILLMAILS"] = "esi-killmails.read_killmails.v1";
|
|
SCOPES$1["CORPORATIONS_READ_CORPORATION_MEMBERSHIP"] = "esi-corporations.read_corporation_membership.v1";
|
|
SCOPES$1["ASSETS_READ_ASSETS"] = "esi-assets.read_assets.v1";
|
|
SCOPES$1["PLANETS_MANAGE_PLANETS"] = "esi-planets.manage_planets.v1";
|
|
SCOPES$1["FLEETS_READ_FLEET"] = "esi-fleets.read_fleet.v1";
|
|
SCOPES$1["FLEETS_WRITE_FLEET"] = "esi-fleets.write_fleet.v1";
|
|
SCOPES$1["UI_OPEN_WINDOW"] = "esi-ui.open_window.v1";
|
|
SCOPES$1["UI_WRITE_WAYPOINT"] = "esi-ui.write_waypoint.v1";
|
|
SCOPES$1["CHARACTERS_WRITE_CONTACTS"] = "esi-characters.write_contacts.v1";
|
|
SCOPES$1["FITTINGS_READ_FITTINGS"] = "esi-fittings.read_fittings.v1";
|
|
SCOPES$1["FITTINGS_WRITE_FITTINGS"] = "esi-fittings.write_fittings.v1";
|
|
SCOPES$1["MARKETS_STRUCTURE_MARKETS"] = "esi-markets.structure_markets.v1";
|
|
SCOPES$1["CORPORATIONS_READ_STRUCTURES"] = "esi-corporations.read_structures.v1";
|
|
SCOPES$1["CHARACTERS_READ_LOYALTY"] = "esi-characters.read_loyalty.v1";
|
|
SCOPES$1["CHARACTERS_READ_OPPORTUNITIES"] = "esi-characters.read_opportunities.v1";
|
|
SCOPES$1["CHARACTERS_READ_CHAT_CHANNELS"] = "esi-characters.read_chat_channels.v1";
|
|
SCOPES$1["CHARACTERS_READ_MEDALS"] = "esi-characters.read_medals.v1";
|
|
SCOPES$1["CHARACTERS_READ_STANDINGS"] = "esi-characters.read_standings.v1";
|
|
SCOPES$1["CHARACTERS_READ_AGENTS_RESEARCH"] = "esi-characters.read_agents_research.v1";
|
|
SCOPES$1["INDUSTRY_READ_CHARACTER_JOBS"] = "esi-industry.read_character_jobs.v1";
|
|
SCOPES$1["MARKETS_READ_CHARACTER_ORDERS"] = "esi-markets.read_character_orders.v1";
|
|
SCOPES$1["CHARACTERS_READ_BLUEPRINTS"] = "esi-characters.read_blueprints.v1";
|
|
SCOPES$1["CHARACTERS_READ_CORPORATION_ROLES"] = "esi-characters.read_corporation_roles.v1";
|
|
SCOPES$1["LOCATION_READ_ONLINE"] = "esi-location.read_online.v1";
|
|
SCOPES$1["CONTRACTS_READ_CHARACTER_CONTRACTS"] = "esi-contracts.read_character_contracts.v1";
|
|
SCOPES$1["CLONES_READ_IMPLANTS"] = "esi-clones.read_implants.v1";
|
|
SCOPES$1["CHARACTERS_READ_FATIGUE"] = "esi-characters.read_fatigue.v1";
|
|
SCOPES$1["KILLMAILS_READ_CORPORATION_KILLMAILS"] = "esi-killmails.read_corporation_killmails.v1";
|
|
SCOPES$1["CORPORATIONS_TRACK_MEMBERS"] = "esi-corporations.track_members.v1";
|
|
SCOPES$1["WALLET_READ_CORPORATION_WALLETS"] = "esi-wallet.read_corporation_wallets.v1";
|
|
SCOPES$1["CHARACTERS_READ_NOTIFICATIONS"] = "esi-characters.read_notifications.v1";
|
|
SCOPES$1["CORPORATIONS_READ_DIVISIONS"] = "esi-corporations.read_divisions.v1";
|
|
SCOPES$1["CORPORATIONS_READ_CONTACTS"] = "esi-corporations.read_contacts.v1";
|
|
SCOPES$1["ASSETS_READ_CORPORATION_ASSETS"] = "esi-assets.read_corporation_assets.v1";
|
|
SCOPES$1["CORPORATIONS_READ_TITLES"] = "esi-corporations.read_titles.v1";
|
|
SCOPES$1["CORPORATIONS_READ_BLUEPRINTS"] = "esi-corporations.read_blueprints.v1";
|
|
SCOPES$1["CONTRACTS_READ_CORPORATION_CONTRACTS"] = "esi-contracts.read_corporation_contracts.v1";
|
|
SCOPES$1["CORPORATIONS_READ_STANDINGS"] = "esi-corporations.read_standings.v1";
|
|
SCOPES$1["CORPORATIONS_READ_STARBASES"] = "esi-corporations.read_starbases.v1";
|
|
SCOPES$1["INDUSTRY_READ_CORPORATION_JOBS"] = "esi-industry.read_corporation_jobs.v1";
|
|
SCOPES$1["MARKETS_READ_CORPORATION_ORDERS"] = "esi-markets.read_corporation_orders.v1";
|
|
SCOPES$1["CORPORATIONS_READ_CONTAINER_LOGS"] = "esi-corporations.read_container_logs.v1";
|
|
SCOPES$1["INDUSTRY_READ_CHARACTER_MINING"] = "esi-industry.read_character_mining.v1";
|
|
SCOPES$1["INDUSTRY_READ_CORPORATION_MINING"] = "esi-industry.read_corporation_mining.v1";
|
|
SCOPES$1["PLANETS_READ_CUSTOMS_OFFICES"] = "esi-planets.read_customs_offices.v1";
|
|
SCOPES$1["CORPORATIONS_READ_FACILITIES"] = "esi-corporations.read_facilities.v1";
|
|
SCOPES$1["CORPORATIONS_READ_MEDALS"] = "esi-corporations.read_medals.v1";
|
|
SCOPES$1["CHARACTERS_READ_TITLES"] = "esi-characters.read_titles.v1";
|
|
SCOPES$1["ALLIANCES_READ_CONTACTS"] = "esi-alliances.read_contacts.v1";
|
|
SCOPES$1["CHARACTERS_READ_FW_STATS"] = "esi-characters.read_fw_stats.v1";
|
|
SCOPES$1["CORPORATIONS_READ_FW_STATS"] = "esi-corporations.read_fw_stats.v1";
|
|
return SCOPES$1;
|
|
}({});
|
|
|
|
// ../eve/dist/esi/fetch.js
|
|
var cache = /* @__PURE__ */ new Map;
|
|
function cleanCache() {
|
|
const now = Date.now();
|
|
for (const [key, value] of cache)
|
|
if (value.expires < now)
|
|
cache.delete(key);
|
|
}
|
|
setInterval(cleanCache, 1000 * 60 * 15);
|
|
var defaultCacheDuration = 1000 * 60 * 30;
|
|
async function esiFetch(path, character, { method = "GET", body, noCache = false, cacheDuration = defaultCacheDuration } = {}) {
|
|
try {
|
|
const headers = {
|
|
"User-Agent": options.user_agent,
|
|
Accept: "application/json"
|
|
};
|
|
if (character) {
|
|
if (!CharacterHelper.hasValidToken(character)) {
|
|
await CharacterHelper.refreshTokens(character);
|
|
if (!CharacterHelper.hasValidToken(character))
|
|
throw new Error(`Failed to refresh token for character: ${character.eveID}`);
|
|
}
|
|
headers["Authorization"] = `Bearer ${character.accessToken}`;
|
|
}
|
|
const init = {
|
|
headers,
|
|
method: method || "GET",
|
|
body: body || undefined
|
|
};
|
|
const url = new URL(`${ESI_LATEST_URL}${path.startsWith("/") ? path : "/" + path}`);
|
|
url.searchParams.set("datasource", "tranquility");
|
|
if (!noCache && init.method === "GET") {
|
|
const cached = cache.get(url.href);
|
|
if (cached && cached?.expires > Date.now())
|
|
return cached.data;
|
|
}
|
|
const res = await fetch(url, init);
|
|
const data = await res.json();
|
|
if (!res.ok) {
|
|
console.error(`ESI request failure at ${path} | ${res.status}:${res.statusText} => ${JSON.stringify(data)}`);
|
|
return null;
|
|
}
|
|
if (init.method === "GET")
|
|
cache.set(url.href, {
|
|
expires: Math.max(res.headers.get("expires") && new Date(Number(res.headers.get("expires") || "")).getTime() || 0, Date.now() + cacheDuration),
|
|
data
|
|
});
|
|
return data;
|
|
} catch (err) {
|
|
console.error(`ESI request failure at ${path} | ${JSON.stringify(err)}`, err);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// ../eve/dist/esi/character.js
|
|
var character_exports = {};
|
|
__export(character_exports, {
|
|
getCharacterAffiliations: () => getCharacterAffiliations,
|
|
getCharacterAgentResearch: () => getCharacterAgentResearch,
|
|
getCharacterAssetLocations: () => getCharacterAssetLocations,
|
|
getCharacterAssetNames: () => getCharacterAssetNames,
|
|
getCharacterAssets: () => getCharacterAssets,
|
|
getCharacterBlueprints: () => getCharacterBlueprints,
|
|
getCharacterClones: () => getCharacterClones,
|
|
getCharacterContactNotifications: () => getCharacterContactNotifications,
|
|
getCharacterCorporationHistory: () => getCharacterCorporationHistory,
|
|
getCharacterCurrentShip: () => getCharacterCurrentShip,
|
|
getCharacterImplants: () => getCharacterImplants,
|
|
getCharacterJumpFatigue: () => getCharacterJumpFatigue,
|
|
getCharacterLocation: () => getCharacterLocation,
|
|
getCharacterMedals: () => getCharacterMedals,
|
|
getCharacterNotifications: () => getCharacterNotifications,
|
|
getCharacterOnline: () => getCharacterOnline,
|
|
getCharacterPortraits: () => getCharacterPortraits,
|
|
getCharacterPublicData: () => getCharacterPublicData,
|
|
getCharacterRoles: () => getCharacterRoles,
|
|
getCharacterStandings: () => getCharacterStandings,
|
|
getCharacterTitles: () => getCharacterTitles,
|
|
getCharacterWallet: () => getCharacterWallet,
|
|
getCharacterWalletJournal: () => getCharacterWalletJournal,
|
|
getCharacterWalletTransactions: () => getCharacterWalletTransactions,
|
|
getPortraitURL: () => getPortraitURL
|
|
});
|
|
function getCharacterPublicData(id) {
|
|
return esiFetch(`/characters/${id}/`);
|
|
}
|
|
function getCharacterAffiliations(ids) {
|
|
return esiFetch(`/characters/affiliation/`, undefined, {
|
|
method: "POST",
|
|
body: JSON.stringify(ids)
|
|
})[0];
|
|
}
|
|
function getCharacterPortraits(id) {
|
|
return esiFetch(`/characters/${id}/portrait/`);
|
|
}
|
|
function getCharacterCorporationHistory(id) {
|
|
return esiFetch(`/characters/${id}/corporationhistory/`);
|
|
}
|
|
function getPortraitURL(id) {
|
|
return `https://images.evetech.net/characters/${id}/portrait`;
|
|
}
|
|
function getCharacterRoles(character) {
|
|
if (!CharacterHelper.hasScope(character, "esi-characters.read_corporation_roles.v1"))
|
|
return null;
|
|
return esiFetch(`/characters/${character.eveID}/roles/`, character);
|
|
}
|
|
function getCharacterTitles(character) {
|
|
if (!CharacterHelper.hasScope(character, "esi-characters.read_titles.v1"))
|
|
return null;
|
|
return esiFetch(`/characters/${character.eveID}/titles/`, character);
|
|
}
|
|
function getCharacterStandings(character) {
|
|
if (!CharacterHelper.hasScope(character, "esi-characters.read_standings.v1"))
|
|
return null;
|
|
return esiFetch(`/characters/${character.eveID}/standings/`, character);
|
|
}
|
|
function getCharacterNotifications(character) {
|
|
if (!CharacterHelper.hasScope(character, "esi-characters.read_notifications.v1"))
|
|
return null;
|
|
return esiFetch(`/characters/${character.eveID}/notifications/`, character);
|
|
}
|
|
function getCharacterContactNotifications(character) {
|
|
if (!CharacterHelper.hasScope(character, "esi-characters.read_notifications.v1"))
|
|
return null;
|
|
return esiFetch(`/characters/${character.eveID}/notifications/contacts`, character);
|
|
}
|
|
function getCharacterMedals(character) {
|
|
if (!CharacterHelper.hasScope(character, "esi-characters.read_medals.v1"))
|
|
return null;
|
|
return esiFetch(`/characters/${character.eveID}/medals/`, character);
|
|
}
|
|
function getCharacterJumpFatigue(character) {
|
|
if (!CharacterHelper.hasScope(character, "esi-characters.read_fatigue.v1"))
|
|
return null;
|
|
return esiFetch(`/characters/${character.eveID}/fatigue/`, character);
|
|
}
|
|
function getCharacterBlueprints(character) {
|
|
if (!CharacterHelper.hasScope(character, "esi-characters.read_blueprints.v1"))
|
|
return null;
|
|
return esiFetch(`/characters/${character.eveID}/blueprints/`, character);
|
|
}
|
|
function getCharacterAgentResearch(character) {
|
|
if (!CharacterHelper.hasScope(character, "esi-characters.read_agents_research.v1"))
|
|
return null;
|
|
return esiFetch(`/characters/${character.eveID}/agents_research/`, character);
|
|
}
|
|
function getCharacterClones(character) {
|
|
if (!CharacterHelper.hasScope(character, "esi-clones.read_clones.v1"))
|
|
return null;
|
|
return esiFetch(`/characters/${character.eveID}/clones/`, character);
|
|
}
|
|
function getCharacterImplants(character) {
|
|
if (!CharacterHelper.hasScope(character, "esi-clones.read_implants.v1"))
|
|
return null;
|
|
return esiFetch(`/characters/${character.eveID}/implants/`, character);
|
|
}
|
|
function getCharacterAssets(character) {
|
|
if (!CharacterHelper.hasScope(character, "esi-assets.read_assets.v1"))
|
|
return null;
|
|
return esiFetch(`/characters/${character.eveID}/assets/`, character);
|
|
}
|
|
function getCharacterAssetLocations(character, ids) {
|
|
if (!CharacterHelper.hasScope(character, "esi-assets.read_assets.v1"))
|
|
return null;
|
|
return esiFetch(`/characters/${character.eveID}/assets/locations/`, character, {
|
|
method: "POST",
|
|
body: JSON.stringify(ids)
|
|
});
|
|
}
|
|
function getCharacterAssetNames(character, ids) {
|
|
if (!CharacterHelper.hasScope(character, "esi-assets.read_assets.v1"))
|
|
return null;
|
|
return esiFetch(`/characters/${character.eveID}/assets/names/`, character, {
|
|
method: "POST",
|
|
body: JSON.stringify(ids)
|
|
});
|
|
}
|
|
function getCharacterWallet(character) {
|
|
if (!CharacterHelper.hasScope(character, "esi-wallet.read_character_wallet.v1"))
|
|
return null;
|
|
return esiFetch(`/characters/${character.eveID}/wallet/`, character);
|
|
}
|
|
function getCharacterWalletTransactions(character, fromId) {
|
|
if (!CharacterHelper.hasScope(character, "esi-wallet.read_character_wallet.v1"))
|
|
return null;
|
|
return esiFetch(`/characters/${character.eveID}/wallet/transactions/`, character, {
|
|
method: "POST",
|
|
body: JSON.stringify(fromId)
|
|
});
|
|
}
|
|
function getCharacterWalletJournal(character, page = 1) {
|
|
if (!CharacterHelper.hasScope(character, "esi-wallet.read_character_wallet.v1"))
|
|
return null;
|
|
return esiFetch(`/characters/${character.eveID}/wallet/journal/?page=${page}`, character);
|
|
}
|
|
function getCharacterLocation(character) {
|
|
if (!CharacterHelper.hasScope(character, "esi-location.read_location.v1"))
|
|
return null;
|
|
return esiFetch(`/characters/${character.eveID}/location/`, character);
|
|
}
|
|
function getCharacterOnline(character) {
|
|
if (!CharacterHelper.hasScope(character, "esi-location.read_online.v1"))
|
|
return null;
|
|
return esiFetch(`/characters/${character.eveID}/online/`, character);
|
|
}
|
|
function getCharacterCurrentShip(character) {
|
|
if (!CharacterHelper.hasScope(character, "esi-location.read_ship_type.v1"))
|
|
return null;
|
|
return esiFetch(`/characters/${character.eveID}/ship/`, character);
|
|
}
|
|
|
|
// ../eve/dist/esi/corporation.js
|
|
var corporation_exports = {};
|
|
__export(corporation_exports, {
|
|
getCorporationAllianceHistory: () => getCorporationAllianceHistory,
|
|
getCorporationAssetLocations: () => getCorporationAssetLocations,
|
|
getCorporationAssetNames: () => getCorporationAssetNames,
|
|
getCorporationAssets: () => getCorporationAssets,
|
|
getCorporationData: () => getCorporationData,
|
|
getCorporationIcons: () => getCorporationIcons
|
|
});
|
|
async function getCorporationData(id) {
|
|
return await esiFetch(`/corporations/${id}/`);
|
|
}
|
|
async function getCorporationAllianceHistory(id) {
|
|
return await esiFetch(`/corporations/${id}/alliancehistory/`);
|
|
}
|
|
async function getCorporationIcons(id) {
|
|
return await esiFetch(`/corporations/${id}/icons/`);
|
|
}
|
|
async function getCorporationAssets(id, character) {
|
|
if (!CharacterHelper.hasScope(character, "esi-assets.read_corporation_assets.v1"))
|
|
return null;
|
|
return await esiFetch(`/corporations/${id}/assets/`, character);
|
|
}
|
|
async function getCorporationAssetLocations(id, character, ids) {
|
|
if (!CharacterHelper.hasScope(character, "esi-assets.read_corporation_assets.v1"))
|
|
return null;
|
|
return await esiFetch(`/corporations/${id}/assets/locations/`, character, {
|
|
method: "POST",
|
|
body: JSON.stringify(ids)
|
|
});
|
|
}
|
|
async function getCorporationAssetNames(id, character, ids) {
|
|
if (!CharacterHelper.hasScope(character, "esi-assets.read_corporation_assets.v1"))
|
|
return null;
|
|
return await esiFetch(`/corporations/${id}/assets/names/`, character, {
|
|
method: "POST",
|
|
body: JSON.stringify(ids)
|
|
});
|
|
}
|
|
|
|
// ../eve/dist/esi/alliance.js
|
|
var alliance_exports = {};
|
|
__export(alliance_exports, {
|
|
getAllianceCorporations: () => getAllianceCorporations,
|
|
getAllianceData: () => getAllianceData,
|
|
getAllianceIcons: () => getAllianceIcons
|
|
});
|
|
async function getAllianceData(id) {
|
|
return await esiFetch(`/alliances/${id}/`);
|
|
}
|
|
async function getAllianceCorporations(id) {
|
|
return await esiFetch(`/alliances/${id}/corporations/`);
|
|
}
|
|
async function getAllianceIcons(id) {
|
|
return await esiFetch(`/alliances/${id}/icons/`);
|
|
}
|
|
|
|
// ../eve/dist/esi/skills.js
|
|
function getCharacterSkillQueue(character) {
|
|
if (!CharacterHelper.hasScope(character, "esi-skills.read_skillqueue.v1"))
|
|
return null;
|
|
return esiFetch(`/characters/${character.eveID}/skillqueue`, character);
|
|
}
|
|
function calculateTrainingPercentage(queuedSkill) {
|
|
const trainingStartPosition = (queuedSkill.training_start_sp - queuedSkill.level_start_sp) / queuedSkill.level_end_sp;
|
|
const timePosition = ((/* @__PURE__ */ new Date()).getTime() - new Date(queuedSkill.start_date).getTime()) / (new Date(queuedSkill.finish_date).getTime() - new Date(queuedSkill.start_date).getTime());
|
|
return trainingStartPosition + (1 - trainingStartPosition) * timePosition;
|
|
}
|
|
|
|
// ../util/dist/jsonQuery.js
|
|
var import_stream_chain = __toESM(require_src(), 1);
|
|
var import_stream_json = __toESM(require_stream_json(), 1);
|
|
var import_StreamArray = __toESM(require_StreamArray(), 1);
|
|
var import_StreamObject = __toESM(require_StreamObject(), 1);
|
|
var import_node_cache = __toESM(require_node_cache2(), 1);
|
|
import * as fs$1 from "fs";
|
|
var cache2 = new import_node_cache.default({ stdTTL: 3600 });
|
|
function queryJsonObject(filePath, query, cacheKey, cacheExpiry) {
|
|
if (cacheKey) {
|
|
const cached = cache2.get(cacheKey);
|
|
if (cached)
|
|
return Promise.resolve(cached);
|
|
}
|
|
return new Promise((resolve, reject) => {
|
|
const pipeline = import_stream_chain.chain([
|
|
fs$1.createReadStream(filePath),
|
|
import_stream_json.parser(),
|
|
import_StreamObject.streamObject(),
|
|
(data) => query(data) ? data.value : null
|
|
]);
|
|
pipeline.on("data", (value) => {
|
|
if (value) {
|
|
if (cacheKey)
|
|
cache2.set(cacheKey, value, cacheExpiry || 3600);
|
|
resolve(value);
|
|
}
|
|
});
|
|
pipeline.on("end", () => {
|
|
resolve(null);
|
|
});
|
|
pipeline.on("error", (err) => {
|
|
reject(err);
|
|
});
|
|
});
|
|
}
|
|
|
|
// ../eve/dist/models/type.js
|
|
import { join as join2 } from "path";
|
|
async function getType(type_id) {
|
|
const data = await queryJsonObject(join2(process.cwd(), "../../data/reference-data/types.json"), (data$1) => data$1.key === String(type_id));
|
|
if (!data)
|
|
throw new Error(`Type ID ${type_id} not found in reference data`);
|
|
return data;
|
|
}
|
|
|
|
// ../util/dist/text.js
|
|
function formatNumberToShortForm(number, locale = "en-uS") {
|
|
let suffix = "";
|
|
let value = number;
|
|
if (Math.abs(number) >= 1e9) {
|
|
value = number / 1e9;
|
|
suffix = "b";
|
|
} else if (Math.abs(number) >= 1e6) {
|
|
value = number / 1e6;
|
|
suffix = "M";
|
|
} else if (Math.abs(number) >= 1000) {
|
|
value = number / 1000;
|
|
suffix = "k";
|
|
}
|
|
const formattedValue = new Intl.NumberFormat(locale, { maximumSignificantDigits: 4 }).format(value);
|
|
return `${formattedValue}${suffix}`;
|
|
}
|
|
|
|
// ../eve/dist/models/skill.js
|
|
import { join as join3 } from "path";
|
|
async function getSkill(type_id) {
|
|
const data = await queryJsonObject(join3(process.cwd(), "../../data/reference-data/skills.json"), (data$1) => data$1.key === String(type_id));
|
|
if (!data)
|
|
throw new Error(`Skill ID ${type_id} not found in reference data`);
|
|
return data;
|
|
}
|
|
|
|
// node_modules/brisa/jsx-runtime/index.js
|
|
var n = Symbol.for("isJSX");
|
|
function S(r) {
|
|
return i(null, r);
|
|
}
|
|
function i(r, { children: e, ...o }, s) {
|
|
let a = e;
|
|
if (Array.isArray(e) && !l(e))
|
|
a = e.map((t) => t?.[n] ? t : S({ children: t }));
|
|
return Object.assign([r, { ...o, key: s }, a], { [n]: true });
|
|
}
|
|
function l(r) {
|
|
return Array.isArray(r) && ((n in r) || m(r));
|
|
}
|
|
function m(r) {
|
|
return r?.[0] === "HTML" && typeof r[1]?.html === "string";
|
|
}
|
|
|
|
// src/components/stats/skill-queue.tsx
|
|
async function SkillQueueStat({ character }) {
|
|
const queue = await getCharacterSkillQueue(character);
|
|
const current = queue?.find((skill2) => skill2.queue_position === 0);
|
|
if (!current || !current.start_date) {
|
|
return i("div", {
|
|
class: "stat",
|
|
children: [i("div", {
|
|
class: "stat-figure text-secondary"
|
|
}, undefined, false, undefined, this), i("div", {
|
|
class: "stat-title",
|
|
children: "No Skills Training"
|
|
}, undefined, false, undefined, this)]
|
|
}, undefined, true, undefined, this);
|
|
}
|
|
const skill = await getSkill(current.skill_id);
|
|
const percentage = calculateTrainingPercentage(current) * 100;
|
|
return i("div", {
|
|
class: "stat",
|
|
children: [i("div", {
|
|
class: "stat-figure text-secondary"
|
|
}, undefined, false, undefined, this), i("div", {
|
|
class: "stat-title",
|
|
children: "Currently Training"
|
|
}, undefined, false, undefined, this), i("div", {
|
|
class: "stat-value",
|
|
children: [(await getType(skill.type_id)).name.en, " ", current.finished_level]
|
|
}, undefined, true, undefined, this), i("div", {
|
|
class: "stat-desc",
|
|
children: i("progress", {
|
|
class: "progress progress-primary w-full",
|
|
value: percentage,
|
|
max: "100"
|
|
}, undefined, false, undefined, this)
|
|
}, undefined, false, undefined, this)]
|
|
}, undefined, true, undefined, this);
|
|
}
|
|
SkillQueueStat.suspense = () => i("div", {
|
|
class: "stat",
|
|
children: [i("div", {
|
|
class: "stat-figure text-secondary"
|
|
}, undefined, false, undefined, null), i("div", {
|
|
class: "stat-title",
|
|
children: "Currently Training"
|
|
}, undefined, false, undefined, null), i("div", {
|
|
class: "flex w-52 flex-col gap-4",
|
|
children: [i("div", {
|
|
class: "skeleton h-16 w-full"
|
|
}, undefined, false, undefined, null), i("div", {
|
|
class: "skeleton h-4 w-full"
|
|
}, undefined, false, undefined, null)]
|
|
}, undefined, true, undefined, null)]
|
|
}, undefined, true, undefined, null);
|
|
|
|
// src/components/stats/wallet.tsx
|
|
async function WalletStat({ character }) {
|
|
const balance = await character_exports.getCharacterWallet(character) || 0;
|
|
const journal = await character_exports.getCharacterWalletJournal(character, 1);
|
|
const earliestTransaction = journal?.filter((transaction) => {
|
|
const date = new Date(transaction.date);
|
|
return date.getDate() === new Date().getDate();
|
|
}).sort((a, b) => new Date(a.date).getTime() - new Date(b.date).getTime())[0];
|
|
const balanceChange = balance - (earliestTransaction?.balance || balance);
|
|
const balanceChangePercentage = balanceChange / (earliestTransaction?.balance || balance) * 100;
|
|
const balanceChangeDirection = balanceChange > 0 ? "\u2197\uFE0E" : "\u2198\uFE0E";
|
|
const balanceChangeText = `${balanceChangeDirection} ${formatNumberToShortForm(Math.abs(balanceChange))} (${Math.abs(Number(balanceChangePercentage.toFixed(2)))}%)`;
|
|
return i("div", {
|
|
class: "stat",
|
|
children: [i("div", {
|
|
class: "stat-figure text-secondary"
|
|
}, undefined, false, undefined, this), i("div", {
|
|
class: "stat-title",
|
|
children: "Wallet"
|
|
}, undefined, false, undefined, this), i("div", {
|
|
class: "stat-value",
|
|
children: [formatNumberToShortForm(balance), " ISK"]
|
|
}, undefined, true, undefined, this), i("div", {
|
|
class: "stat-desc",
|
|
children: balanceChangeText
|
|
}, undefined, false, undefined, this)]
|
|
}, undefined, true, undefined, this);
|
|
}
|
|
WalletStat.suspense = () => i("div", {
|
|
class: "stat",
|
|
children: [i("div", {
|
|
class: "stat-figure text-secondary"
|
|
}, undefined, false, undefined, null), i("div", {
|
|
class: "stat-title",
|
|
children: "Wallet"
|
|
}, undefined, false, undefined, null), i("div", {
|
|
class: "flex w-52 flex-col gap-4",
|
|
children: [i("div", {
|
|
class: "skeleton h-16 w-full"
|
|
}, undefined, false, undefined, null), i("div", {
|
|
class: "skeleton h-4 w-full"
|
|
}, undefined, false, undefined, null)]
|
|
}, undefined, true, undefined, null)]
|
|
}, undefined, true, undefined, null);
|
|
|
|
// src/pages/index.tsx
|
|
function Homepage(props, request) {
|
|
const user = UserHelper.find(1);
|
|
const character = user.mainCharacterID && CharacterHelper.find(user.mainCharacterID);
|
|
return i(S, {
|
|
children: i("div", {
|
|
class: "bg-gray-900 py-24 sm:py-32",
|
|
children: i("div", {
|
|
class: "mx-auto max-w-7xl px-6 lg:px-8",
|
|
children: i("div", {
|
|
class: "mx-auto max-w-2xl lg:max-w-none",
|
|
children: i("div", {
|
|
class: "stats shadow",
|
|
children: [i("div", {
|
|
class: "stat",
|
|
children: [i("div", {
|
|
class: "stat-figure text-secondary",
|
|
children: i("svg", {
|
|
xmlns: "http://www.w3.org/2000/svg",
|
|
fill: "none",
|
|
viewBox: "0 0 24 24",
|
|
class: "inline-block h-8 w-8 stroke-current",
|
|
children: i("path", {
|
|
"stroke-linecap": "round",
|
|
"stroke-linejoin": "round",
|
|
"stroke-width": "2",
|
|
d: "M13 16h-1v-4h-1m1-4h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z"
|
|
}, undefined, false, undefined, this)
|
|
}, undefined, false, undefined, this)
|
|
}, undefined, false, undefined, this), i("div", {
|
|
class: "stat-title",
|
|
children: "Characters"
|
|
}, undefined, false, undefined, this), i("div", {
|
|
class: "stat-value",
|
|
children: user.characterIDs.length
|
|
}, undefined, false, undefined, this), i("div", {
|
|
class: "stat-desc",
|
|
children: "Jan 1st - Feb 1st"
|
|
}, undefined, false, undefined, this)]
|
|
}, undefined, true, undefined, this), character && i(SkillQueueStat, {
|
|
character
|
|
}, undefined, false, undefined, this), character && i(WalletStat, {
|
|
character
|
|
}, undefined, false, undefined, this), i("div", {
|
|
class: "stat",
|
|
children: [i("div", {
|
|
class: "stat-figure text-secondary",
|
|
children: i("svg", {
|
|
xmlns: "http://www.w3.org/2000/svg",
|
|
fill: "none",
|
|
viewBox: "0 0 24 24",
|
|
class: "inline-block h-8 w-8 stroke-current",
|
|
children: i("path", {
|
|
"stroke-linecap": "round",
|
|
"stroke-linejoin": "round",
|
|
"stroke-width": "2",
|
|
d: "M5 8h14M5 8a2 2 0 110-4h14a2 2 0 110 4M5 8v10a2 2 0 002 2h10a2 2 0 002-2V8m-9 4h4"
|
|
}, undefined, false, undefined, this)
|
|
}, undefined, false, undefined, this)
|
|
}, undefined, false, undefined, this), i("div", {
|
|
class: "stat-title",
|
|
children: "New Registers"
|
|
}, undefined, false, undefined, this), i("div", {
|
|
class: "stat-value",
|
|
children: "1,200"
|
|
}, undefined, false, undefined, this), i("div", {
|
|
class: "stat-desc",
|
|
children: "\u2198\uFE0E 90 (14%)"
|
|
}, undefined, false, undefined, this)]
|
|
}, undefined, true, undefined, this)]
|
|
}, undefined, true, undefined, this)
|
|
}, undefined, false, undefined, this)
|
|
}, undefined, false, undefined, this)
|
|
}, undefined, false, undefined, this)
|
|
}, undefined, false, undefined, this);
|
|
}
|
|
export {
|
|
Homepage as default
|
|
};
|
|
|
|
//# debugId=AA342C1D9D53B62B64756E2164756E21
|
|
//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["..\\..\\eve\\node_modules\\safe-buffer\\index.js", "..\\..\\eve\\node_modules\\jws\\lib\\data-stream.js", "..\\..\\eve\\node_modules\\ecdsa-sig-formatter\\src\\param-bytes-for-alg.js", "..\\..\\eve\\node_modules\\ecdsa-sig-formatter\\src\\ecdsa-sig-formatter.js", "..\\..\\eve\\node_modules\\buffer-equal-constant-time\\index.js", "..\\..\\eve\\node_modules\\jwa\\index.js", "..\\..\\eve\\node_modules\\jws\\lib\\tostring.js", "..\\..\\eve\\node_modules\\jws\\lib\\sign-stream.js", "..\\..\\eve\\node_modules\\jws\\lib\\verify-stream.js", "..\\..\\eve\\node_modules\\jws\\index.js", "..\\..\\eve\\node_modules\\jsonwebtoken\\decode.js", "..\\..\\eve\\node_modules\\jsonwebtoken\\lib\\JsonWebTokenError.js", "..\\..\\eve\\node_modules\\jsonwebtoken\\lib\\NotBeforeError.js", "..\\..\\eve\\node_modules\\jsonwebtoken\\lib\\TokenExpiredError.js", "..\\..\\eve\\node_modules\\ms\\index.js", "..\\..\\eve\\node_modules\\jsonwebtoken\\lib\\timespan.js", "..\\..\\eve\\node_modules\\semver\\internal\\constants.js", "..\\..\\eve\\node_modules\\semver\\internal\\debug.js", "..\\..\\eve\\node_modules\\semver\\internal\\re.js", "..\\..\\eve\\node_modules\\semver\\internal\\parse-options.js", "..\\..\\eve\\node_modules\\semver\\internal\\identifiers.js", "..\\..\\eve\\node_modules\\semver\\classes\\semver.js", "..\\..\\eve\\node_modules\\semver\\functions\\parse.js", "..\\..\\eve\\node_modules\\semver\\functions\\valid.js", "..\\..\\eve\\node_modules\\semver\\functions\\clean.js", "..\\..\\eve\\node_modules\\semver\\functions\\inc.js", "..\\..\\eve\\node_modules\\semver\\functions\\diff.js", "..\\..\\eve\\node_modules\\semver\\functions\\major.js", "..\\..\\eve\\node_modules\\semver\\functions\\minor.js", "..\\..\\eve\\node_modules\\semver\\functions\\patch.js", "..\\..\\eve\\node_modules\\semver\\functions\\prerelease.js", "..\\..\\eve\\node_modules\\semver\\functions\\compare.js", "..\\..\\eve\\node_modules\\semver\\functions\\rcompare.js", "..\\..\\eve\\node_modules\\semver\\functions\\compare-loose.js", "..\\..\\eve\\node_modules\\semver\\functions\\compare-build.js", "..\\..\\eve\\node_modules\\semver\\functions\\sort.js", "..\\..\\eve\\node_modules\\semver\\functions\\rsort.js", "..\\..\\eve\\node_modules\\semver\\functions\\gt.js", "..\\..\\eve\\node_modules\\semver\\functions\\lt.js", "..\\..\\eve\\node_modules\\semver\\functions\\eq.js", "..\\..\\eve\\node_modules\\semver\\functions\\neq.js", "..\\..\\eve\\node_modules\\semver\\functions\\gte.js", "..\\..\\eve\\node_modules\\semver\\functions\\lte.js", "..\\..\\eve\\node_modules\\semver\\functions\\cmp.js", "..\\..\\eve\\node_modules\\semver\\functions\\coerce.js", "..\\..\\eve\\node_modules\\semver\\internal\\lrucache.js", "..\\..\\eve\\node_modules\\semver\\classes\\range.js", "..\\..\\eve\\node_modules\\semver\\classes\\comparator.js", "..\\..\\eve\\node_modules\\semver\\functions\\satisfies.js", "..\\..\\eve\\node_modules\\semver\\ranges\\to-comparators.js", "..\\..\\eve\\node_modules\\semver\\ranges\\max-satisfying.js", "..\\..\\eve\\node_modules\\semver\\ranges\\min-satisfying.js", "..\\..\\eve\\node_modules\\semver\\ranges\\min-version.js", "..\\..\\eve\\node_modules\\semver\\ranges\\valid.js", "..\\..\\eve\\node_modules\\semver\\ranges\\outside.js", "..\\..\\eve\\node_modules\\semver\\ranges\\gtr.js", "..\\..\\eve\\node_modules\\semver\\ranges\\ltr.js", "..\\..\\eve\\node_modules\\semver\\ranges\\intersects.js", "..\\..\\eve\\node_modules\\semver\\ranges\\simplify.js", "..\\..\\eve\\node_modules\\semver\\ranges\\subset.js", "..\\..\\eve\\node_modules\\semver\\index.js", "..\\..\\eve\\node_modules\\jsonwebtoken\\lib\\asymmetricKeyDetailsSupported.js", "..\\..\\eve\\node_modules\\jsonwebtoken\\lib\\rsaPssKeyDetailsSupported.js", "..\\..\\eve\\node_modules\\jsonwebtoken\\lib\\validateAsymmetricKey.js", "..\\..\\eve\\node_modules\\jsonwebtoken\\lib\\psSupported.js", "..\\..\\eve\\node_modules\\jsonwebtoken\\verify.js", "..\\..\\eve\\node_modules\\lodash.includes\\index.js", "..\\..\\eve\\node_modules\\lodash.isboolean\\index.js", "..\\..\\eve\\node_modules\\lodash.isinteger\\index.js", "..\\..\\eve\\node_modules\\lodash.isnumber\\index.js", "..\\..\\eve\\node_modules\\lodash.isplainobject\\index.js", "..\\..\\eve\\node_modules\\lodash.isstring\\index.js", "..\\..\\eve\\node_modules\\lodash.once\\index.js", "..\\..\\eve\\node_modules\\jsonwebtoken\\sign.js", "..\\..\\eve\\node_modules\\jsonwebtoken\\index.js", "..\\..\\eve\\node_modules\\bn.js\\lib\\bn.js", "..\\..\\eve\\node_modules\\inherits\\inherits_browser.js", "..\\..\\eve\\node_modules\\inherits\\inherits.js", "..\\..\\eve\\node_modules\\safer-buffer\\safer.js", "..\\..\\eve\\node_modules\\asn1.js\\lib\\asn1\\base\\reporter.js", "..\\..\\eve\\node_modules\\asn1.js\\lib\\asn1\\base\\buffer.js", "..\\..\\eve\\node_modules\\minimalistic-assert\\index.js", "..\\..\\eve\\node_modules\\asn1.js\\lib\\asn1\\base\\node.js", "..\\..\\eve\\node_modules\\asn1.js\\lib\\asn1\\constants\\der.js", "..\\..\\eve\\node_modules\\asn1.js\\lib\\asn1\\encoders\\der.js", "..\\..\\eve\\node_modules\\asn1.js\\lib\\asn1\\encoders\\pem.js", "..\\..\\eve\\node_modules\\asn1.js\\lib\\asn1\\encoders\\index.js", "..\\..\\eve\\node_modules\\asn1.js\\lib\\asn1\\decoders\\der.js", "..\\..\\eve\\node_modules\\asn1.js\\lib\\asn1\\decoders\\pem.js", "..\\..\\eve\\node_modules\\asn1.js\\lib\\asn1\\decoders\\index.js", "..\\..\\eve\\node_modules\\asn1.js\\lib\\asn1\\api.js", "..\\..\\eve\\node_modules\\asn1.js\\lib\\asn1\\base\\index.js", "..\\..\\eve\\node_modules\\asn1.js\\lib\\asn1\\constants\\index.js", "..\\..\\eve\\node_modules\\asn1.js\\lib\\asn1.js", "..\\..\\eve\\node_modules\\minimalistic-crypto-utils\\lib\\utils.js", "..\\..\\eve\\node_modules\\elliptic\\lib\\elliptic\\utils.js", "..\\..\\eve\\node_modules\\brorand\\index.js", "..\\..\\eve\\node_modules\\elliptic\\lib\\elliptic\\curve\\base.js", "..\\..\\eve\\node_modules\\elliptic\\lib\\elliptic\\curve\\short.js", "..\\..\\eve\\node_modules\\elliptic\\lib\\elliptic\\curve\\mont.js", "..\\..\\eve\\node_modules\\elliptic\\lib\\elliptic\\curve\\edwards.js", "..\\..\\eve\\node_modules\\elliptic\\lib\\elliptic\\curve\\index.js", "..\\..\\eve\\node_modules\\hash.js\\lib\\hash\\utils.js", "..\\..\\eve\\node_modules\\hash.js\\lib\\hash\\common.js", "..\\..\\eve\\node_modules\\hash.js\\lib\\hash\\sha\\common.js", "..\\..\\eve\\node_modules\\hash.js\\lib\\hash\\sha\\1.js", "..\\..\\eve\\node_modules\\hash.js\\lib\\hash\\sha\\256.js", "..\\..\\eve\\node_modules\\hash.js\\lib\\hash\\sha\\224.js", "..\\..\\eve\\node_modules\\hash.js\\lib\\hash\\sha\\512.js", "..\\..\\eve\\node_modules\\hash.js\\lib\\hash\\sha\\384.js", "..\\..\\eve\\node_modules\\hash.js\\lib\\hash\\sha.js", "..\\..\\eve\\node_modules\\hash.js\\lib\\hash\\ripemd.js", "..\\..\\eve\\node_modules\\hash.js\\lib\\hash\\hmac.js", "..\\..\\eve\\node_modules\\hash.js\\lib\\hash.js", "..\\..\\eve\\node_modules\\elliptic\\lib\\elliptic\\precomputed\\secp256k1.js", "..\\..\\eve\\node_modules\\elliptic\\lib\\elliptic\\curves.js", "..\\..\\eve\\node_modules\\hmac-drbg\\lib\\hmac-drbg.js", "..\\..\\eve\\node_modules\\elliptic\\lib\\elliptic\\ec\\key.js", "..\\..\\eve\\node_modules\\elliptic\\lib\\elliptic\\ec\\signature.js", "..\\..\\eve\\node_modules\\elliptic\\lib\\elliptic\\ec\\index.js", "..\\..\\eve\\node_modules\\elliptic\\lib\\elliptic\\eddsa\\key.js", "..\\..\\eve\\node_modules\\elliptic\\lib\\elliptic\\eddsa\\signature.js", "..\\..\\eve\\node_modules\\elliptic\\lib\\elliptic\\eddsa\\index.js", "..\\..\\eve\\node_modules\\elliptic\\lib\\elliptic.js", "..\\..\\eve\\node_modules\\jwk-to-pem\\src\\b64-to-bn.js", "..\\..\\eve\\node_modules\\jwk-to-pem\\src\\asn1\\algorithm-identifier.js", "..\\..\\eve\\node_modules\\jwk-to-pem\\src\\asn1\\public-key-info.js", "..\\..\\eve\\node_modules\\jwk-to-pem\\src\\asn1\\version.js", "..\\..\\eve\\node_modules\\jwk-to-pem\\src\\asn1\\private-key-info.js", "..\\..\\eve\\node_modules\\jwk-to-pem\\src\\ec.js", "..\\..\\eve\\node_modules\\jwk-to-pem\\src\\rsa.js", "..\\..\\eve\\node_modules\\jwk-to-pem\\src\\jwk-to-pem.js", "..\\..\\util\\node_modules\\stream-chain\\src\\defs.js", "..\\..\\util\\node_modules\\stream-chain\\src\\gen.js", "..\\..\\util\\node_modules\\stream-chain\\src\\asStream.js", "..\\..\\util\\node_modules\\stream-chain\\src\\index.js", "..\\..\\util\\node_modules\\stream-json\\utils\\Utf8Stream.js", "..\\..\\util\\node_modules\\stream-json\\Parser.js", "..\\..\\util\\node_modules\\stream-json\\utils\\emit.js", "..\\..\\util\\node_modules\\stream-json\\index.js", "..\\..\\util\\node_modules\\stream-json\\Assembler.js", "..\\..\\util\\node_modules\\stream-json\\streamers\\StreamBase.js", "..\\..\\util\\node_modules\\stream-json\\node_modules\\stream-chain\\index.js", "..\\..\\util\\node_modules\\stream-json\\utils\\withParser.js", "..\\..\\util\\node_modules\\stream-json\\streamers\\StreamArray.js", "..\\..\\util\\node_modules\\stream-json\\streamers\\StreamObject.js", "..\\..\\util\\node_modules\\clone\\clone.js", "..\\..\\util\\node_modules\\node-cache\\lib\\node_cache.js", "..\\..\\util\\node_modules\\node-cache\\index.js", "..\\..\\eve\\dist\\_virtual\\rolldown_runtime.js", "..\\..\\eve\\node_modules\\drizzle-orm\\entity.js", "..\\..\\eve\\node_modules\\drizzle-orm\\column.js", "..\\..\\eve\\node_modules\\drizzle-orm\\column-builder.js", "..\\..\\eve\\node_modules\\drizzle-orm\\table.utils.js", "..\\..\\eve\\node_modules\\drizzle-orm\\tracing-utils.js", "..\\..\\eve\\node_modules\\drizzle-orm\\pg-core\\unique-constraint.js", "..\\..\\eve\\node_modules\\drizzle-orm\\pg-core\\columns\\common.js", "..\\..\\eve\\node_modules\\drizzle-orm\\pg-core\\columns\\enum.js", "..\\..\\eve\\node_modules\\drizzle-orm\\subquery.js", "..\\..\\eve\\node_modules\\drizzle-orm\\version.js", "..\\..\\eve\\node_modules\\drizzle-orm\\tracing.js", "..\\..\\eve\\node_modules\\drizzle-orm\\view-common.js", "..\\..\\eve\\node_modules\\drizzle-orm\\table.js", "..\\..\\eve\\node_modules\\drizzle-orm\\sql\\sql.js", "..\\..\\eve\\node_modules\\drizzle-orm\\alias.js", "..\\..\\eve\\node_modules\\drizzle-orm\\utils.js", "..\\..\\eve\\node_modules\\drizzle-orm\\sqlite-core\\foreign-keys.js", "..\\..\\eve\\node_modules\\drizzle-orm\\sqlite-core\\unique-constraint.js", "..\\..\\eve\\node_modules\\drizzle-orm\\sqlite-core\\columns\\common.js", "..\\..\\eve\\node_modules\\drizzle-orm\\sqlite-core\\columns\\blob.js", "..\\..\\eve\\node_modules\\drizzle-orm\\sqlite-core\\columns\\custom.js", "..\\..\\eve\\node_modules\\drizzle-orm\\sqlite-core\\columns\\integer.js", "..\\..\\eve\\node_modules\\drizzle-orm\\sqlite-core\\columns\\numeric.js", "..\\..\\eve\\node_modules\\drizzle-orm\\sqlite-core\\columns\\real.js", "..\\..\\eve\\node_modules\\drizzle-orm\\sqlite-core\\columns\\text.js", "..\\..\\eve\\node_modules\\drizzle-orm\\selection-proxy.js", "..\\..\\eve\\node_modules\\drizzle-orm\\query-promise.js", "..\\..\\eve\\node_modules\\drizzle-orm\\sqlite-core\\columns\\all.js", "..\\..\\eve\\node_modules\\drizzle-orm\\sqlite-core\\table.js", "..\\..\\eve\\node_modules\\drizzle-orm\\sqlite-core\\indexes.js", "..\\..\\eve\\node_modules\\drizzle-orm\\sqlite-core\\utils.js", "..\\..\\eve\\node_modules\\drizzle-orm\\sqlite-core\\query-builders\\delete.js", "..\\..\\eve\\node_modules\\drizzle-orm\\casing.js", "..\\..\\eve\\node_modules\\drizzle-orm\\errors.js", "..\\..\\eve\\node_modules\\drizzle-orm\\pg-core\\table.js", "..\\..\\eve\\node_modules\\drizzle-orm\\pg-core\\primary-keys.js", "..\\..\\eve\\node_modules\\drizzle-orm\\sql\\expressions\\conditions.js", "..\\..\\eve\\node_modules\\drizzle-orm\\sql\\expressions\\select.js", "..\\..\\eve\\node_modules\\drizzle-orm\\relations.js", "..\\..\\eve\\node_modules\\drizzle-orm\\sqlite-core\\view-base.js", "..\\..\\eve\\node_modules\\drizzle-orm\\sqlite-core\\dialect.js", "..\\..\\eve\\node_modules\\drizzle-orm\\query-builders\\query-builder.js", "..\\..\\eve\\node_modules\\drizzle-orm\\sqlite-core\\query-builders\\select.js", "..\\..\\eve\\node_modules\\drizzle-orm\\sqlite-core\\query-builders\\query-builder.js", "..\\..\\eve\\node_modules\\drizzle-orm\\sqlite-core\\query-builders\\insert.js", "..\\..\\eve\\node_modules\\drizzle-orm\\sqlite-core\\query-builders\\update.js", "..\\..\\eve\\node_modules\\drizzle-orm\\sqlite-core\\query-builders\\count.js", "..\\..\\eve\\node_modules\\drizzle-orm\\sqlite-core\\query-builders\\query.js", "..\\..\\eve\\node_modules\\drizzle-orm\\sqlite-core\\query-builders\\raw.js", "..\\..\\eve\\node_modules\\drizzle-orm\\sqlite-core\\db.js", "..\\..\\eve\\node_modules\\drizzle-orm\\cache\\core\\cache.js", "..\\..\\eve\\node_modules\\drizzle-orm\\sqlite-core\\session.js", "..\\..\\eve\\node_modules\\drizzle-orm\\logger.js", "..\\..\\eve\\dist\\db\\schema.js", "..\\..\\eve\\dist\\esi\\options.js", "..\\..\\eve\\node_modules\\jwt-decode\\build\\esm\\index.js", "..\\..\\eve\\node_modules\\@oslojs\\encoding\\dist\\base32.js", "..\\..\\eve\\node_modules\\@oslojs\\encoding\\dist\\base64.js", "..\\..\\eve\\dist\\esi\\auth.js", "..\\..\\eve\\dist\\db\\models\\character.model.js", "..\\..\\eve\\dist\\db\\models\\user.model.js", "..\\..\\eve\\dist\\db\\models\\resume-command.model.js", "..\\..\\eve\\dist\\db\\models\\index.js", "..\\..\\eve\\node_modules\\drizzle-orm\\bun-sqlite\\driver.js", "..\\..\\eve\\node_modules\\drizzle-orm\\bun-sqlite\\session.js", "..\\..\\eve\\dist\\db\\index.js", "..\\..\\eve\\dist\\esi\\scopes.js", "..\\..\\eve\\dist\\esi\\fetch.js", "..\\..\\eve\\dist\\esi\\character.js", "..\\..\\eve\\dist\\esi\\corporation.js", "..\\..\\eve\\dist\\esi\\alliance.js", "..\\..\\eve\\dist\\esi\\skills.js", "..\\..\\util\\dist\\jsonQuery.js", "..\\..\\eve\\dist\\models\\type.js", "..\\..\\util\\dist\\text.js", "..\\..\\eve\\dist\\models\\skill.js", "..\\node_modules\\brisa\\jsx-runtime\\index.js", "..\\src\\components\\stats\\skill-queue.tsx", "..\\src\\components\\stats\\wallet.tsx", "..\\src\\pages\\index.tsx"],
  "sourcesContent": [
    "/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */\n/* eslint-disable node/no-deprecated-api */\nvar buffer = require('buffer')\nvar Buffer = buffer.Buffer\n\n// alternative to using Object.keys for old browsers\nfunction copyProps (src, dst) {\n  for (var key in src) {\n    dst[key] = src[key]\n  }\n}\nif (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {\n  module.exports = buffer\n} else {\n  // Copy properties from require('buffer')\n  copyProps(buffer, exports)\n  exports.Buffer = SafeBuffer\n}\n\nfunction SafeBuffer (arg, encodingOrOffset, length) {\n  return Buffer(arg, encodingOrOffset, length)\n}\n\nSafeBuffer.prototype = Object.create(Buffer.prototype)\n\n// Copy static methods from Buffer\ncopyProps(Buffer, SafeBuffer)\n\nSafeBuffer.from = function (arg, encodingOrOffset, length) {\n  if (typeof arg === 'number') {\n    throw new TypeError('Argument must not be a number')\n  }\n  return Buffer(arg, encodingOrOffset, length)\n}\n\nSafeBuffer.alloc = function (size, fill, encoding) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  var buf = Buffer(size)\n  if (fill !== undefined) {\n    if (typeof encoding === 'string') {\n      buf.fill(fill, encoding)\n    } else {\n      buf.fill(fill)\n    }\n  } else {\n    buf.fill(0)\n  }\n  return buf\n}\n\nSafeBuffer.allocUnsafe = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return Buffer(size)\n}\n\nSafeBuffer.allocUnsafeSlow = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return buffer.SlowBuffer(size)\n}\n",
    "/*global module, process*/\nvar Buffer = require('safe-buffer').Buffer;\nvar Stream = require('stream');\nvar util = require('util');\n\nfunction DataStream(data) {\n  this.buffer = null;\n  this.writable = true;\n  this.readable = true;\n\n  // No input\n  if (!data) {\n    this.buffer = Buffer.alloc(0);\n    return this;\n  }\n\n  // Stream\n  if (typeof data.pipe === 'function') {\n    this.buffer = Buffer.alloc(0);\n    data.pipe(this);\n    return this;\n  }\n\n  // Buffer or String\n  // or Object (assumedly a passworded key)\n  if (data.length || typeof data === 'object') {\n    this.buffer = data;\n    this.writable = false;\n    process.nextTick(function () {\n      this.emit('end', data);\n      this.readable = false;\n      this.emit('close');\n    }.bind(this));\n    return this;\n  }\n\n  throw new TypeError('Unexpected data type ('+ typeof data + ')');\n}\nutil.inherits(DataStream, Stream);\n\nDataStream.prototype.write = function write(data) {\n  this.buffer = Buffer.concat([this.buffer, Buffer.from(data)]);\n  this.emit('data', data);\n};\n\nDataStream.prototype.end = function end(data) {\n  if (data)\n    this.write(data);\n  this.emit('end', data);\n  this.emit('close');\n  this.writable = false;\n  this.readable = false;\n};\n\nmodule.exports = DataStream;\n",
    "'use strict';\n\nfunction getParamSize(keySize) {\n\tvar result = ((keySize / 8) | 0) + (keySize % 8 === 0 ? 0 : 1);\n\treturn result;\n}\n\nvar paramBytesForAlg = {\n\tES256: getParamSize(256),\n\tES384: getParamSize(384),\n\tES512: getParamSize(521)\n};\n\nfunction getParamBytesForAlg(alg) {\n\tvar paramBytes = paramBytesForAlg[alg];\n\tif (paramBytes) {\n\t\treturn paramBytes;\n\t}\n\n\tthrow new Error('Unknown algorithm \"' + alg + '\"');\n}\n\nmodule.exports = getParamBytesForAlg;\n",
    "'use strict';\n\nvar Buffer = require('safe-buffer').Buffer;\n\nvar getParamBytesForAlg = require('./param-bytes-for-alg');\n\nvar MAX_OCTET = 0x80,\n\tCLASS_UNIVERSAL = 0,\n\tPRIMITIVE_BIT = 0x20,\n\tTAG_SEQ = 0x10,\n\tTAG_INT = 0x02,\n\tENCODED_TAG_SEQ = (TAG_SEQ | PRIMITIVE_BIT) | (CLASS_UNIVERSAL << 6),\n\tENCODED_TAG_INT = TAG_INT | (CLASS_UNIVERSAL << 6);\n\nfunction base64Url(base64) {\n\treturn base64\n\t\t.replace(/=/g, '')\n\t\t.replace(/\\+/g, '-')\n\t\t.replace(/\\//g, '_');\n}\n\nfunction signatureAsBuffer(signature) {\n\tif (Buffer.isBuffer(signature)) {\n\t\treturn signature;\n\t} else if ('string' === typeof signature) {\n\t\treturn Buffer.from(signature, 'base64');\n\t}\n\n\tthrow new TypeError('ECDSA signature must be a Base64 string or a Buffer');\n}\n\nfunction derToJose(signature, alg) {\n\tsignature = signatureAsBuffer(signature);\n\tvar paramBytes = getParamBytesForAlg(alg);\n\n\t// the DER encoded param should at most be the param size, plus a padding\n\t// zero, since due to being a signed integer\n\tvar maxEncodedParamLength = paramBytes + 1;\n\n\tvar inputLength = signature.length;\n\n\tvar offset = 0;\n\tif (signature[offset++] !== ENCODED_TAG_SEQ) {\n\t\tthrow new Error('Could not find expected \"seq\"');\n\t}\n\n\tvar seqLength = signature[offset++];\n\tif (seqLength === (MAX_OCTET | 1)) {\n\t\tseqLength = signature[offset++];\n\t}\n\n\tif (inputLength - offset < seqLength) {\n\t\tthrow new Error('\"seq\" specified length of \"' + seqLength + '\", only \"' + (inputLength - offset) + '\" remaining');\n\t}\n\n\tif (signature[offset++] !== ENCODED_TAG_INT) {\n\t\tthrow new Error('Could not find expected \"int\" for \"r\"');\n\t}\n\n\tvar rLength = signature[offset++];\n\n\tif (inputLength - offset - 2 < rLength) {\n\t\tthrow new Error('\"r\" specified length of \"' + rLength + '\", only \"' + (inputLength - offset - 2) + '\" available');\n\t}\n\n\tif (maxEncodedParamLength < rLength) {\n\t\tthrow new Error('\"r\" specified length of \"' + rLength + '\", max of \"' + maxEncodedParamLength + '\" is acceptable');\n\t}\n\n\tvar rOffset = offset;\n\toffset += rLength;\n\n\tif (signature[offset++] !== ENCODED_TAG_INT) {\n\t\tthrow new Error('Could not find expected \"int\" for \"s\"');\n\t}\n\n\tvar sLength = signature[offset++];\n\n\tif (inputLength - offset !== sLength) {\n\t\tthrow new Error('\"s\" specified length of \"' + sLength + '\", expected \"' + (inputLength - offset) + '\"');\n\t}\n\n\tif (maxEncodedParamLength < sLength) {\n\t\tthrow new Error('\"s\" specified length of \"' + sLength + '\", max of \"' + maxEncodedParamLength + '\" is acceptable');\n\t}\n\n\tvar sOffset = offset;\n\toffset += sLength;\n\n\tif (offset !== inputLength) {\n\t\tthrow new Error('Expected to consume entire buffer, but \"' + (inputLength - offset) + '\" bytes remain');\n\t}\n\n\tvar rPadding = paramBytes - rLength,\n\t\tsPadding = paramBytes - sLength;\n\n\tvar dst = Buffer.allocUnsafe(rPadding + rLength + sPadding + sLength);\n\n\tfor (offset = 0; offset < rPadding; ++offset) {\n\t\tdst[offset] = 0;\n\t}\n\tsignature.copy(dst, offset, rOffset + Math.max(-rPadding, 0), rOffset + rLength);\n\n\toffset = paramBytes;\n\n\tfor (var o = offset; offset < o + sPadding; ++offset) {\n\t\tdst[offset] = 0;\n\t}\n\tsignature.copy(dst, offset, sOffset + Math.max(-sPadding, 0), sOffset + sLength);\n\n\tdst = dst.toString('base64');\n\tdst = base64Url(dst);\n\n\treturn dst;\n}\n\nfunction countPadding(buf, start, stop) {\n\tvar padding = 0;\n\twhile (start + padding < stop && buf[start + padding] === 0) {\n\t\t++padding;\n\t}\n\n\tvar needsSign = buf[start + padding] >= MAX_OCTET;\n\tif (needsSign) {\n\t\t--padding;\n\t}\n\n\treturn padding;\n}\n\nfunction joseToDer(signature, alg) {\n\tsignature = signatureAsBuffer(signature);\n\tvar paramBytes = getParamBytesForAlg(alg);\n\n\tvar signatureBytes = signature.length;\n\tif (signatureBytes !== paramBytes * 2) {\n\t\tthrow new TypeError('\"' + alg + '\" signatures must be \"' + paramBytes * 2 + '\" bytes, saw \"' + signatureBytes + '\"');\n\t}\n\n\tvar rPadding = countPadding(signature, 0, paramBytes);\n\tvar sPadding = countPadding(signature, paramBytes, signature.length);\n\tvar rLength = paramBytes - rPadding;\n\tvar sLength = paramBytes - sPadding;\n\n\tvar rsBytes = 1 + 1 + rLength + 1 + 1 + sLength;\n\n\tvar shortLength = rsBytes < MAX_OCTET;\n\n\tvar dst = Buffer.allocUnsafe((shortLength ? 2 : 3) + rsBytes);\n\n\tvar offset = 0;\n\tdst[offset++] = ENCODED_TAG_SEQ;\n\tif (shortLength) {\n\t\t// Bit 8 has value \"0\"\n\t\t// bits 7-1 give the length.\n\t\tdst[offset++] = rsBytes;\n\t} else {\n\t\t// Bit 8 of first octet has value \"1\"\n\t\t// bits 7-1 give the number of additional length octets.\n\t\tdst[offset++] = MAX_OCTET\t| 1;\n\t\t// length, base 256\n\t\tdst[offset++] = rsBytes & 0xff;\n\t}\n\tdst[offset++] = ENCODED_TAG_INT;\n\tdst[offset++] = rLength;\n\tif (rPadding < 0) {\n\t\tdst[offset++] = 0;\n\t\toffset += signature.copy(dst, offset, 0, paramBytes);\n\t} else {\n\t\toffset += signature.copy(dst, offset, rPadding, paramBytes);\n\t}\n\tdst[offset++] = ENCODED_TAG_INT;\n\tdst[offset++] = sLength;\n\tif (sPadding < 0) {\n\t\tdst[offset++] = 0;\n\t\tsignature.copy(dst, offset, paramBytes);\n\t} else {\n\t\tsignature.copy(dst, offset, paramBytes + sPadding);\n\t}\n\n\treturn dst;\n}\n\nmodule.exports = {\n\tderToJose: derToJose,\n\tjoseToDer: joseToDer\n};\n",
    "/*jshint node:true */\n'use strict';\nvar Buffer = require('buffer').Buffer; // browserify\nvar SlowBuffer = require('buffer').SlowBuffer;\n\nmodule.exports = bufferEq;\n\nfunction bufferEq(a, b) {\n\n  // shortcutting on type is necessary for correctness\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n    return false;\n  }\n\n  // buffer sizes should be well-known information, so despite this\n  // shortcutting, it doesn't leak any information about the *contents* of the\n  // buffers.\n  if (a.length !== b.length) {\n    return false;\n  }\n\n  var c = 0;\n  for (var i = 0; i < a.length; i++) {\n    /*jshint bitwise:false */\n    c |= a[i] ^ b[i]; // XOR\n  }\n  return c === 0;\n}\n\nbufferEq.install = function() {\n  Buffer.prototype.equal = SlowBuffer.prototype.equal = function equal(that) {\n    return bufferEq(this, that);\n  };\n};\n\nvar origBufEqual = Buffer.prototype.equal;\nvar origSlowBufEqual = SlowBuffer.prototype.equal;\nbufferEq.restore = function() {\n  Buffer.prototype.equal = origBufEqual;\n  SlowBuffer.prototype.equal = origSlowBufEqual;\n};\n",
    "var Buffer = require('safe-buffer').Buffer;\nvar crypto = require('crypto');\nvar formatEcdsa = require('ecdsa-sig-formatter');\nvar util = require('util');\n\nvar MSG_INVALID_ALGORITHM = '\"%s\" is not a valid algorithm.\\n  Supported algorithms are:\\n  \"HS256\", \"HS384\", \"HS512\", \"RS256\", \"RS384\", \"RS512\", \"PS256\", \"PS384\", \"PS512\", \"ES256\", \"ES384\", \"ES512\" and \"none\".'\nvar MSG_INVALID_SECRET = 'secret must be a string or buffer';\nvar MSG_INVALID_VERIFIER_KEY = 'key must be a string or a buffer';\nvar MSG_INVALID_SIGNER_KEY = 'key must be a string, a buffer or an object';\n\nvar supportsKeyObjects = typeof crypto.createPublicKey === 'function';\nif (supportsKeyObjects) {\n  MSG_INVALID_VERIFIER_KEY += ' or a KeyObject';\n  MSG_INVALID_SECRET += 'or a KeyObject';\n}\n\nfunction checkIsPublicKey(key) {\n  if (Buffer.isBuffer(key)) {\n    return;\n  }\n\n  if (typeof key === 'string') {\n    return;\n  }\n\n  if (!supportsKeyObjects) {\n    throw typeError(MSG_INVALID_VERIFIER_KEY);\n  }\n\n  if (typeof key !== 'object') {\n    throw typeError(MSG_INVALID_VERIFIER_KEY);\n  }\n\n  if (typeof key.type !== 'string') {\n    throw typeError(MSG_INVALID_VERIFIER_KEY);\n  }\n\n  if (typeof key.asymmetricKeyType !== 'string') {\n    throw typeError(MSG_INVALID_VERIFIER_KEY);\n  }\n\n  if (typeof key.export !== 'function') {\n    throw typeError(MSG_INVALID_VERIFIER_KEY);\n  }\n};\n\nfunction checkIsPrivateKey(key) {\n  if (Buffer.isBuffer(key)) {\n    return;\n  }\n\n  if (typeof key === 'string') {\n    return;\n  }\n\n  if (typeof key === 'object') {\n    return;\n  }\n\n  throw typeError(MSG_INVALID_SIGNER_KEY);\n};\n\nfunction checkIsSecretKey(key) {\n  if (Buffer.isBuffer(key)) {\n    return;\n  }\n\n  if (typeof key === 'string') {\n    return key;\n  }\n\n  if (!supportsKeyObjects) {\n    throw typeError(MSG_INVALID_SECRET);\n  }\n\n  if (typeof key !== 'object') {\n    throw typeError(MSG_INVALID_SECRET);\n  }\n\n  if (key.type !== 'secret') {\n    throw typeError(MSG_INVALID_SECRET);\n  }\n\n  if (typeof key.export !== 'function') {\n    throw typeError(MSG_INVALID_SECRET);\n  }\n}\n\nfunction fromBase64(base64) {\n  return base64\n    .replace(/=/g, '')\n    .replace(/\\+/g, '-')\n    .replace(/\\//g, '_');\n}\n\nfunction toBase64(base64url) {\n  base64url = base64url.toString();\n\n  var padding = 4 - base64url.length % 4;\n  if (padding !== 4) {\n    for (var i = 0; i < padding; ++i) {\n      base64url += '=';\n    }\n  }\n\n  return base64url\n    .replace(/\\-/g, '+')\n    .replace(/_/g, '/');\n}\n\nfunction typeError(template) {\n  var args = [].slice.call(arguments, 1);\n  var errMsg = util.format.bind(util, template).apply(null, args);\n  return new TypeError(errMsg);\n}\n\nfunction bufferOrString(obj) {\n  return Buffer.isBuffer(obj) || typeof obj === 'string';\n}\n\nfunction normalizeInput(thing) {\n  if (!bufferOrString(thing))\n    thing = JSON.stringify(thing);\n  return thing;\n}\n\nfunction createHmacSigner(bits) {\n  return function sign(thing, secret) {\n    checkIsSecretKey(secret);\n    thing = normalizeInput(thing);\n    var hmac = crypto.createHmac('sha' + bits, secret);\n    var sig = (hmac.update(thing), hmac.digest('base64'))\n    return fromBase64(sig);\n  }\n}\n\nvar bufferEqual;\nvar timingSafeEqual = 'timingSafeEqual' in crypto ? function timingSafeEqual(a, b) {\n  if (a.byteLength !== b.byteLength) {\n    return false;\n  }\n\n  return crypto.timingSafeEqual(a, b)\n} : function timingSafeEqual(a, b) {\n  if (!bufferEqual) {\n    bufferEqual = require('buffer-equal-constant-time');\n  }\n\n  return bufferEqual(a, b)\n}\n\nfunction createHmacVerifier(bits) {\n  return function verify(thing, signature, secret) {\n    var computedSig = createHmacSigner(bits)(thing, secret);\n    return timingSafeEqual(Buffer.from(signature), Buffer.from(computedSig));\n  }\n}\n\nfunction createKeySigner(bits) {\n return function sign(thing, privateKey) {\n    checkIsPrivateKey(privateKey);\n    thing = normalizeInput(thing);\n    // Even though we are specifying \"RSA\" here, this works with ECDSA\n    // keys as well.\n    var signer = crypto.createSign('RSA-SHA' + bits);\n    var sig = (signer.update(thing), signer.sign(privateKey, 'base64'));\n    return fromBase64(sig);\n  }\n}\n\nfunction createKeyVerifier(bits) {\n  return function verify(thing, signature, publicKey) {\n    checkIsPublicKey(publicKey);\n    thing = normalizeInput(thing);\n    signature = toBase64(signature);\n    var verifier = crypto.createVerify('RSA-SHA' + bits);\n    verifier.update(thing);\n    return verifier.verify(publicKey, signature, 'base64');\n  }\n}\n\nfunction createPSSKeySigner(bits) {\n  return function sign(thing, privateKey) {\n    checkIsPrivateKey(privateKey);\n    thing = normalizeInput(thing);\n    var signer = crypto.createSign('RSA-SHA' + bits);\n    var sig = (signer.update(thing), signer.sign({\n      key: privateKey,\n      padding: crypto.constants.RSA_PKCS1_PSS_PADDING,\n      saltLength: crypto.constants.RSA_PSS_SALTLEN_DIGEST\n    }, 'base64'));\n    return fromBase64(sig);\n  }\n}\n\nfunction createPSSKeyVerifier(bits) {\n  return function verify(thing, signature, publicKey) {\n    checkIsPublicKey(publicKey);\n    thing = normalizeInput(thing);\n    signature = toBase64(signature);\n    var verifier = crypto.createVerify('RSA-SHA' + bits);\n    verifier.update(thing);\n    return verifier.verify({\n      key: publicKey,\n      padding: crypto.constants.RSA_PKCS1_PSS_PADDING,\n      saltLength: crypto.constants.RSA_PSS_SALTLEN_DIGEST\n    }, signature, 'base64');\n  }\n}\n\nfunction createECDSASigner(bits) {\n  var inner = createKeySigner(bits);\n  return function sign() {\n    var signature = inner.apply(null, arguments);\n    signature = formatEcdsa.derToJose(signature, 'ES' + bits);\n    return signature;\n  };\n}\n\nfunction createECDSAVerifer(bits) {\n  var inner = createKeyVerifier(bits);\n  return function verify(thing, signature, publicKey) {\n    signature = formatEcdsa.joseToDer(signature, 'ES' + bits).toString('base64');\n    var result = inner(thing, signature, publicKey);\n    return result;\n  };\n}\n\nfunction createNoneSigner() {\n  return function sign() {\n    return '';\n  }\n}\n\nfunction createNoneVerifier() {\n  return function verify(thing, signature) {\n    return signature === '';\n  }\n}\n\nmodule.exports = function jwa(algorithm) {\n  var signerFactories = {\n    hs: createHmacSigner,\n    rs: createKeySigner,\n    ps: createPSSKeySigner,\n    es: createECDSASigner,\n    none: createNoneSigner,\n  }\n  var verifierFactories = {\n    hs: createHmacVerifier,\n    rs: createKeyVerifier,\n    ps: createPSSKeyVerifier,\n    es: createECDSAVerifer,\n    none: createNoneVerifier,\n  }\n  var match = algorithm.match(/^(RS|PS|ES|HS)(256|384|512)$|^(none)$/i);\n  if (!match)\n    throw typeError(MSG_INVALID_ALGORITHM, algorithm);\n  var algo = (match[1] || match[3]).toLowerCase();\n  var bits = match[2];\n\n  return {\n    sign: signerFactories[algo](bits),\n    verify: verifierFactories[algo](bits),\n  }\n};\n",
    "/*global module*/\nvar Buffer = require('buffer').Buffer;\n\nmodule.exports = function toString(obj) {\n  if (typeof obj === 'string')\n    return obj;\n  if (typeof obj === 'number' || Buffer.isBuffer(obj))\n    return obj.toString();\n  return JSON.stringify(obj);\n};\n",
    "/*global module*/\nvar Buffer = require('safe-buffer').Buffer;\nvar DataStream = require('./data-stream');\nvar jwa = require('jwa');\nvar Stream = require('stream');\nvar toString = require('./tostring');\nvar util = require('util');\n\nfunction base64url(string, encoding) {\n  return Buffer\n    .from(string, encoding)\n    .toString('base64')\n    .replace(/=/g, '')\n    .replace(/\\+/g, '-')\n    .replace(/\\//g, '_');\n}\n\nfunction jwsSecuredInput(header, payload, encoding) {\n  encoding = encoding || 'utf8';\n  var encodedHeader = base64url(toString(header), 'binary');\n  var encodedPayload = base64url(toString(payload), encoding);\n  return util.format('%s.%s', encodedHeader, encodedPayload);\n}\n\nfunction jwsSign(opts) {\n  var header = opts.header;\n  var payload = opts.payload;\n  var secretOrKey = opts.secret || opts.privateKey;\n  var encoding = opts.encoding;\n  var algo = jwa(header.alg);\n  var securedInput = jwsSecuredInput(header, payload, encoding);\n  var signature = algo.sign(securedInput, secretOrKey);\n  return util.format('%s.%s', securedInput, signature);\n}\n\nfunction SignStream(opts) {\n  var secret = opts.secret||opts.privateKey||opts.key;\n  var secretStream = new DataStream(secret);\n  this.readable = true;\n  this.header = opts.header;\n  this.encoding = opts.encoding;\n  this.secret = this.privateKey = this.key = secretStream;\n  this.payload = new DataStream(opts.payload);\n  this.secret.once('close', function () {\n    if (!this.payload.writable && this.readable)\n      this.sign();\n  }.bind(this));\n\n  this.payload.once('close', function () {\n    if (!this.secret.writable && this.readable)\n      this.sign();\n  }.bind(this));\n}\nutil.inherits(SignStream, Stream);\n\nSignStream.prototype.sign = function sign() {\n  try {\n    var signature = jwsSign({\n      header: this.header,\n      payload: this.payload.buffer,\n      secret: this.secret.buffer,\n      encoding: this.encoding\n    });\n    this.emit('done', signature);\n    this.emit('data', signature);\n    this.emit('end');\n    this.readable = false;\n    return signature;\n  } catch (e) {\n    this.readable = false;\n    this.emit('error', e);\n    this.emit('close');\n  }\n};\n\nSignStream.sign = jwsSign;\n\nmodule.exports = SignStream;\n",
    "/*global module*/\nvar Buffer = require('safe-buffer').Buffer;\nvar DataStream = require('./data-stream');\nvar jwa = require('jwa');\nvar Stream = require('stream');\nvar toString = require('./tostring');\nvar util = require('util');\nvar JWS_REGEX = /^[a-zA-Z0-9\\-_]+?\\.[a-zA-Z0-9\\-_]+?\\.([a-zA-Z0-9\\-_]+)?$/;\n\nfunction isObject(thing) {\n  return Object.prototype.toString.call(thing) === '[object Object]';\n}\n\nfunction safeJsonParse(thing) {\n  if (isObject(thing))\n    return thing;\n  try { return JSON.parse(thing); }\n  catch (e) { return undefined; }\n}\n\nfunction headerFromJWS(jwsSig) {\n  var encodedHeader = jwsSig.split('.', 1)[0];\n  return safeJsonParse(Buffer.from(encodedHeader, 'base64').toString('binary'));\n}\n\nfunction securedInputFromJWS(jwsSig) {\n  return jwsSig.split('.', 2).join('.');\n}\n\nfunction signatureFromJWS(jwsSig) {\n  return jwsSig.split('.')[2];\n}\n\nfunction payloadFromJWS(jwsSig, encoding) {\n  encoding = encoding || 'utf8';\n  var payload = jwsSig.split('.')[1];\n  return Buffer.from(payload, 'base64').toString(encoding);\n}\n\nfunction isValidJws(string) {\n  return JWS_REGEX.test(string) && !!headerFromJWS(string);\n}\n\nfunction jwsVerify(jwsSig, algorithm, secretOrKey) {\n  if (!algorithm) {\n    var err = new Error(\"Missing algorithm parameter for jws.verify\");\n    err.code = \"MISSING_ALGORITHM\";\n    throw err;\n  }\n  jwsSig = toString(jwsSig);\n  var signature = signatureFromJWS(jwsSig);\n  var securedInput = securedInputFromJWS(jwsSig);\n  var algo = jwa(algorithm);\n  return algo.verify(securedInput, signature, secretOrKey);\n}\n\nfunction jwsDecode(jwsSig, opts) {\n  opts = opts || {};\n  jwsSig = toString(jwsSig);\n\n  if (!isValidJws(jwsSig))\n    return null;\n\n  var header = headerFromJWS(jwsSig);\n\n  if (!header)\n    return null;\n\n  var payload = payloadFromJWS(jwsSig);\n  if (header.typ === 'JWT' || opts.json)\n    payload = JSON.parse(payload, opts.encoding);\n\n  return {\n    header: header,\n    payload: payload,\n    signature: signatureFromJWS(jwsSig)\n  };\n}\n\nfunction VerifyStream(opts) {\n  opts = opts || {};\n  var secretOrKey = opts.secret||opts.publicKey||opts.key;\n  var secretStream = new DataStream(secretOrKey);\n  this.readable = true;\n  this.algorithm = opts.algorithm;\n  this.encoding = opts.encoding;\n  this.secret = this.publicKey = this.key = secretStream;\n  this.signature = new DataStream(opts.signature);\n  this.secret.once('close', function () {\n    if (!this.signature.writable && this.readable)\n      this.verify();\n  }.bind(this));\n\n  this.signature.once('close', function () {\n    if (!this.secret.writable && this.readable)\n      this.verify();\n  }.bind(this));\n}\nutil.inherits(VerifyStream, Stream);\nVerifyStream.prototype.verify = function verify() {\n  try {\n    var valid = jwsVerify(this.signature.buffer, this.algorithm, this.key.buffer);\n    var obj = jwsDecode(this.signature.buffer, this.encoding);\n    this.emit('done', valid, obj);\n    this.emit('data', valid);\n    this.emit('end');\n    this.readable = false;\n    return valid;\n  } catch (e) {\n    this.readable = false;\n    this.emit('error', e);\n    this.emit('close');\n  }\n};\n\nVerifyStream.decode = jwsDecode;\nVerifyStream.isValid = isValidJws;\nVerifyStream.verify = jwsVerify;\n\nmodule.exports = VerifyStream;\n",
    "/*global exports*/\nvar SignStream = require('./lib/sign-stream');\nvar VerifyStream = require('./lib/verify-stream');\n\nvar ALGORITHMS = [\n  'HS256', 'HS384', 'HS512',\n  'RS256', 'RS384', 'RS512',\n  'PS256', 'PS384', 'PS512',\n  'ES256', 'ES384', 'ES512'\n];\n\nexports.ALGORITHMS = ALGORITHMS;\nexports.sign = SignStream.sign;\nexports.verify = VerifyStream.verify;\nexports.decode = VerifyStream.decode;\nexports.isValid = VerifyStream.isValid;\nexports.createSign = function createSign(opts) {\n  return new SignStream(opts);\n};\nexports.createVerify = function createVerify(opts) {\n  return new VerifyStream(opts);\n};\n",
    "var jws = require('jws');\n\nmodule.exports = function (jwt, options) {\n  options = options || {};\n  var decoded = jws.decode(jwt, options);\n  if (!decoded) { return null; }\n  var payload = decoded.payload;\n\n  //try parse the payload\n  if(typeof payload === 'string') {\n    try {\n      var obj = JSON.parse(payload);\n      if(obj !== null && typeof obj === 'object') {\n        payload = obj;\n      }\n    } catch (e) { }\n  }\n\n  //return header if `complete` option is enabled.  header includes claims\n  //such as `kid` and `alg` used to select the key within a JWKS needed to\n  //verify the signature\n  if (options.complete === true) {\n    return {\n      header: decoded.header,\n      payload: payload,\n      signature: decoded.signature\n    };\n  }\n  return payload;\n};\n",
    "var JsonWebTokenError = function (message, error) {\n  Error.call(this, message);\n  if(Error.captureStackTrace) {\n    Error.captureStackTrace(this, this.constructor);\n  }\n  this.name = 'JsonWebTokenError';\n  this.message = message;\n  if (error) this.inner = error;\n};\n\nJsonWebTokenError.prototype = Object.create(Error.prototype);\nJsonWebTokenError.prototype.constructor = JsonWebTokenError;\n\nmodule.exports = JsonWebTokenError;\n",
    "var JsonWebTokenError = require('./JsonWebTokenError');\n\nvar NotBeforeError = function (message, date) {\n  JsonWebTokenError.call(this, message);\n  this.name = 'NotBeforeError';\n  this.date = date;\n};\n\nNotBeforeError.prototype = Object.create(JsonWebTokenError.prototype);\n\nNotBeforeError.prototype.constructor = NotBeforeError;\n\nmodule.exports = NotBeforeError;",
    "var JsonWebTokenError = require('./JsonWebTokenError');\n\nvar TokenExpiredError = function (message, expiredAt) {\n  JsonWebTokenError.call(this, message);\n  this.name = 'TokenExpiredError';\n  this.expiredAt = expiredAt;\n};\n\nTokenExpiredError.prototype = Object.create(JsonWebTokenError.prototype);\n\nTokenExpiredError.prototype.constructor = TokenExpiredError;\n\nmodule.exports = TokenExpiredError;",
    "/**\n * Helpers.\n */\n\nvar s = 1000;\nvar m = s * 60;\nvar h = m * 60;\nvar d = h * 24;\nvar w = d * 7;\nvar y = d * 365.25;\n\n/**\n * Parse or format the given `val`.\n *\n * Options:\n *\n *  - `long` verbose formatting [false]\n *\n * @param {String|Number} val\n * @param {Object} [options]\n * @throws {Error} throw an error if val is not a non-empty string or a number\n * @return {String|Number}\n * @api public\n */\n\nmodule.exports = function (val, options) {\n  options = options || {};\n  var type = typeof val;\n  if (type === 'string' && val.length > 0) {\n    return parse(val);\n  } else if (type === 'number' && isFinite(val)) {\n    return options.long ? fmtLong(val) : fmtShort(val);\n  }\n  throw new Error(\n    'val is not a non-empty string or a valid number. val=' +\n      JSON.stringify(val)\n  );\n};\n\n/**\n * Parse the given `str` and return milliseconds.\n *\n * @param {String} str\n * @return {Number}\n * @api private\n */\n\nfunction parse(str) {\n  str = String(str);\n  if (str.length > 100) {\n    return;\n  }\n  var match = /^(-?(?:\\d+)?\\.?\\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(\n    str\n  );\n  if (!match) {\n    return;\n  }\n  var n = parseFloat(match[1]);\n  var type = (match[2] || 'ms').toLowerCase();\n  switch (type) {\n    case 'years':\n    case 'year':\n    case 'yrs':\n    case 'yr':\n    case 'y':\n      return n * y;\n    case 'weeks':\n    case 'week':\n    case 'w':\n      return n * w;\n    case 'days':\n    case 'day':\n    case 'd':\n      return n * d;\n    case 'hours':\n    case 'hour':\n    case 'hrs':\n    case 'hr':\n    case 'h':\n      return n * h;\n    case 'minutes':\n    case 'minute':\n    case 'mins':\n    case 'min':\n    case 'm':\n      return n * m;\n    case 'seconds':\n    case 'second':\n    case 'secs':\n    case 'sec':\n    case 's':\n      return n * s;\n    case 'milliseconds':\n    case 'millisecond':\n    case 'msecs':\n    case 'msec':\n    case 'ms':\n      return n;\n    default:\n      return undefined;\n  }\n}\n\n/**\n * Short format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtShort(ms) {\n  var msAbs = Math.abs(ms);\n  if (msAbs >= d) {\n    return Math.round(ms / d) + 'd';\n  }\n  if (msAbs >= h) {\n    return Math.round(ms / h) + 'h';\n  }\n  if (msAbs >= m) {\n    return Math.round(ms / m) + 'm';\n  }\n  if (msAbs >= s) {\n    return Math.round(ms / s) + 's';\n  }\n  return ms + 'ms';\n}\n\n/**\n * Long format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtLong(ms) {\n  var msAbs = Math.abs(ms);\n  if (msAbs >= d) {\n    return plural(ms, msAbs, d, 'day');\n  }\n  if (msAbs >= h) {\n    return plural(ms, msAbs, h, 'hour');\n  }\n  if (msAbs >= m) {\n    return plural(ms, msAbs, m, 'minute');\n  }\n  if (msAbs >= s) {\n    return plural(ms, msAbs, s, 'second');\n  }\n  return ms + ' ms';\n}\n\n/**\n * Pluralization helper.\n */\n\nfunction plural(ms, msAbs, n, name) {\n  var isPlural = msAbs >= n * 1.5;\n  return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');\n}\n",
    "var ms = require('ms');\n\nmodule.exports = function (time, iat) {\n  var timestamp = iat || Math.floor(Date.now() / 1000);\n\n  if (typeof time === 'string') {\n    var milliseconds = ms(time);\n    if (typeof milliseconds === 'undefined') {\n      return;\n    }\n    return Math.floor(timestamp + milliseconds / 1000);\n  } else if (typeof time === 'number') {\n    return timestamp + time;\n  } else {\n    return;\n  }\n\n};",
    "'use strict'\n\n// Note: this is the semver.org version of the spec that it implements\n// Not necessarily the package version of this code.\nconst SEMVER_SPEC_VERSION = '2.0.0'\n\nconst MAX_LENGTH = 256\nconst MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER ||\n/* istanbul ignore next */ 9007199254740991\n\n// Max safe segment length for coercion.\nconst MAX_SAFE_COMPONENT_LENGTH = 16\n\n// Max safe length for a build identifier. The max length minus 6 characters for\n// the shortest version with a build 0.0.0+BUILD.\nconst MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6\n\nconst RELEASE_TYPES = [\n  'major',\n  'premajor',\n  'minor',\n  'preminor',\n  'patch',\n  'prepatch',\n  'prerelease',\n]\n\nmodule.exports = {\n  MAX_LENGTH,\n  MAX_SAFE_COMPONENT_LENGTH,\n  MAX_SAFE_BUILD_LENGTH,\n  MAX_SAFE_INTEGER,\n  RELEASE_TYPES,\n  SEMVER_SPEC_VERSION,\n  FLAG_INCLUDE_PRERELEASE: 0b001,\n  FLAG_LOOSE: 0b010,\n}\n",
    "'use strict'\n\nconst debug = (\n  typeof process === 'object' &&\n  process.env &&\n  process.env.NODE_DEBUG &&\n  /\\bsemver\\b/i.test(process.env.NODE_DEBUG)\n) ? (...args) => console.error('SEMVER', ...args)\n  : () => {}\n\nmodule.exports = debug\n",
    "'use strict'\n\nconst {\n  MAX_SAFE_COMPONENT_LENGTH,\n  MAX_SAFE_BUILD_LENGTH,\n  MAX_LENGTH,\n} = require('./constants')\nconst debug = require('./debug')\nexports = module.exports = {}\n\n// The actual regexps go on exports.re\nconst re = exports.re = []\nconst safeRe = exports.safeRe = []\nconst src = exports.src = []\nconst safeSrc = exports.safeSrc = []\nconst t = exports.t = {}\nlet R = 0\n\nconst LETTERDASHNUMBER = '[a-zA-Z0-9-]'\n\n// Replace some greedy regex tokens to prevent regex dos issues. These regex are\n// used internally via the safeRe object since all inputs in this library get\n// normalized first to trim and collapse all extra whitespace. The original\n// regexes are exported for userland consumption and lower level usage. A\n// future breaking change could export the safer regex only with a note that\n// all input should have extra whitespace removed.\nconst safeRegexReplacements = [\n  ['\\\\s', 1],\n  ['\\\\d', MAX_LENGTH],\n  [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH],\n]\n\nconst makeSafeRegex = (value) => {\n  for (const [token, max] of safeRegexReplacements) {\n    value = value\n      .split(`${token}*`).join(`${token}{0,${max}}`)\n      .split(`${token}+`).join(`${token}{1,${max}}`)\n  }\n  return value\n}\n\nconst createToken = (name, value, isGlobal) => {\n  const safe = makeSafeRegex(value)\n  const index = R++\n  debug(name, index, value)\n  t[name] = index\n  src[index] = value\n  safeSrc[index] = safe\n  re[index] = new RegExp(value, isGlobal ? 'g' : undefined)\n  safeRe[index] = new RegExp(safe, isGlobal ? 'g' : undefined)\n}\n\n// The following Regular Expressions can be used for tokenizing,\n// validating, and parsing SemVer version strings.\n\n// ## Numeric Identifier\n// A single `0`, or a non-zero digit followed by zero or more digits.\n\ncreateToken('NUMERICIDENTIFIER', '0|[1-9]\\\\d*')\ncreateToken('NUMERICIDENTIFIERLOOSE', '\\\\d+')\n\n// ## Non-numeric Identifier\n// Zero or more digits, followed by a letter or hyphen, and then zero or\n// more letters, digits, or hyphens.\n\ncreateToken('NONNUMERICIDENTIFIER', `\\\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`)\n\n// ## Main Version\n// Three dot-separated numeric identifiers.\n\ncreateToken('MAINVERSION', `(${src[t.NUMERICIDENTIFIER]})\\\\.` +\n                   `(${src[t.NUMERICIDENTIFIER]})\\\\.` +\n                   `(${src[t.NUMERICIDENTIFIER]})`)\n\ncreateToken('MAINVERSIONLOOSE', `(${src[t.NUMERICIDENTIFIERLOOSE]})\\\\.` +\n                        `(${src[t.NUMERICIDENTIFIERLOOSE]})\\\\.` +\n                        `(${src[t.NUMERICIDENTIFIERLOOSE]})`)\n\n// ## Pre-release Version Identifier\n// A numeric identifier, or a non-numeric identifier.\n// Non-numberic identifiers include numberic identifiers but can be longer.\n// Therefore non-numberic identifiers must go first.\n\ncreateToken('PRERELEASEIDENTIFIER', `(?:${src[t.NONNUMERICIDENTIFIER]\n}|${src[t.NUMERICIDENTIFIER]})`)\n\ncreateToken('PRERELEASEIDENTIFIERLOOSE', `(?:${src[t.NONNUMERICIDENTIFIER]\n}|${src[t.NUMERICIDENTIFIERLOOSE]})`)\n\n// ## Pre-release Version\n// Hyphen, followed by one or more dot-separated pre-release version\n// identifiers.\n\ncreateToken('PRERELEASE', `(?:-(${src[t.PRERELEASEIDENTIFIER]\n}(?:\\\\.${src[t.PRERELEASEIDENTIFIER]})*))`)\n\ncreateToken('PRERELEASELOOSE', `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]\n}(?:\\\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`)\n\n// ## Build Metadata Identifier\n// Any combination of digits, letters, or hyphens.\n\ncreateToken('BUILDIDENTIFIER', `${LETTERDASHNUMBER}+`)\n\n// ## Build Metadata\n// Plus sign, followed by one or more period-separated build metadata\n// identifiers.\n\ncreateToken('BUILD', `(?:\\\\+(${src[t.BUILDIDENTIFIER]\n}(?:\\\\.${src[t.BUILDIDENTIFIER]})*))`)\n\n// ## Full Version String\n// A main version, followed optionally by a pre-release version and\n// build metadata.\n\n// Note that the only major, minor, patch, and pre-release sections of\n// the version string are capturing groups.  The build metadata is not a\n// capturing group, because it should not ever be used in version\n// comparison.\n\ncreateToken('FULLPLAIN', `v?${src[t.MAINVERSION]\n}${src[t.PRERELEASE]}?${\n  src[t.BUILD]}?`)\n\ncreateToken('FULL', `^${src[t.FULLPLAIN]}$`)\n\n// like full, but allows v1.2.3 and =1.2.3, which people do sometimes.\n// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty\n// common in the npm registry.\ncreateToken('LOOSEPLAIN', `[v=\\\\s]*${src[t.MAINVERSIONLOOSE]\n}${src[t.PRERELEASELOOSE]}?${\n  src[t.BUILD]}?`)\n\ncreateToken('LOOSE', `^${src[t.LOOSEPLAIN]}$`)\n\ncreateToken('GTLT', '((?:<|>)?=?)')\n\n// Something like \"2.*\" or \"1.2.x\".\n// Note that \"x.x\" is a valid xRange identifer, meaning \"any version\"\n// Only the first item is strictly required.\ncreateToken('XRANGEIDENTIFIERLOOSE', `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\\\*`)\ncreateToken('XRANGEIDENTIFIER', `${src[t.NUMERICIDENTIFIER]}|x|X|\\\\*`)\n\ncreateToken('XRANGEPLAIN', `[v=\\\\s]*(${src[t.XRANGEIDENTIFIER]})` +\n                   `(?:\\\\.(${src[t.XRANGEIDENTIFIER]})` +\n                   `(?:\\\\.(${src[t.XRANGEIDENTIFIER]})` +\n                   `(?:${src[t.PRERELEASE]})?${\n                     src[t.BUILD]}?` +\n                   `)?)?`)\n\ncreateToken('XRANGEPLAINLOOSE', `[v=\\\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})` +\n                        `(?:\\\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +\n                        `(?:\\\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +\n                        `(?:${src[t.PRERELEASELOOSE]})?${\n                          src[t.BUILD]}?` +\n                        `)?)?`)\n\ncreateToken('XRANGE', `^${src[t.GTLT]}\\\\s*${src[t.XRANGEPLAIN]}$`)\ncreateToken('XRANGELOOSE', `^${src[t.GTLT]}\\\\s*${src[t.XRANGEPLAINLOOSE]}$`)\n\n// Coercion.\n// Extract anything that could conceivably be a part of a valid semver\ncreateToken('COERCEPLAIN', `${'(^|[^\\\\d])' +\n              '(\\\\d{1,'}${MAX_SAFE_COMPONENT_LENGTH}})` +\n              `(?:\\\\.(\\\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` +\n              `(?:\\\\.(\\\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`)\ncreateToken('COERCE', `${src[t.COERCEPLAIN]}(?:$|[^\\\\d])`)\ncreateToken('COERCEFULL', src[t.COERCEPLAIN] +\n              `(?:${src[t.PRERELEASE]})?` +\n              `(?:${src[t.BUILD]})?` +\n              `(?:$|[^\\\\d])`)\ncreateToken('COERCERTL', src[t.COERCE], true)\ncreateToken('COERCERTLFULL', src[t.COERCEFULL], true)\n\n// Tilde ranges.\n// Meaning is \"reasonably at or greater than\"\ncreateToken('LONETILDE', '(?:~>?)')\n\ncreateToken('TILDETRIM', `(\\\\s*)${src[t.LONETILDE]}\\\\s+`, true)\nexports.tildeTrimReplace = '$1~'\n\ncreateToken('TILDE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`)\ncreateToken('TILDELOOSE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`)\n\n// Caret ranges.\n// Meaning is \"at least and backwards compatible with\"\ncreateToken('LONECARET', '(?:\\\\^)')\n\ncreateToken('CARETTRIM', `(\\\\s*)${src[t.LONECARET]}\\\\s+`, true)\nexports.caretTrimReplace = '$1^'\n\ncreateToken('CARET', `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`)\ncreateToken('CARETLOOSE', `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`)\n\n// A simple gt/lt/eq thing, or just \"\" to indicate \"any version\"\ncreateToken('COMPARATORLOOSE', `^${src[t.GTLT]}\\\\s*(${src[t.LOOSEPLAIN]})$|^$`)\ncreateToken('COMPARATOR', `^${src[t.GTLT]}\\\\s*(${src[t.FULLPLAIN]})$|^$`)\n\n// An expression to strip any whitespace between the gtlt and the thing\n// it modifies, so that `> 1.2.3` ==> `>1.2.3`\ncreateToken('COMPARATORTRIM', `(\\\\s*)${src[t.GTLT]\n}\\\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true)\nexports.comparatorTrimReplace = '$1$2$3'\n\n// Something like `1.2.3 - 1.2.4`\n// Note that these all use the loose form, because they'll be\n// checked against either the strict or loose comparator form\n// later.\ncreateToken('HYPHENRANGE', `^\\\\s*(${src[t.XRANGEPLAIN]})` +\n                   `\\\\s+-\\\\s+` +\n                   `(${src[t.XRANGEPLAIN]})` +\n                   `\\\\s*$`)\n\ncreateToken('HYPHENRANGELOOSE', `^\\\\s*(${src[t.XRANGEPLAINLOOSE]})` +\n                        `\\\\s+-\\\\s+` +\n                        `(${src[t.XRANGEPLAINLOOSE]})` +\n                        `\\\\s*$`)\n\n// Star ranges basically just allow anything at all.\ncreateToken('STAR', '(<|>)?=?\\\\s*\\\\*')\n// >=0.0.0 is like a star\ncreateToken('GTE0', '^\\\\s*>=\\\\s*0\\\\.0\\\\.0\\\\s*$')\ncreateToken('GTE0PRE', '^\\\\s*>=\\\\s*0\\\\.0\\\\.0-0\\\\s*$')\n",
    "'use strict'\n\n// parse out just the options we care about\nconst looseOption = Object.freeze({ loose: true })\nconst emptyOpts = Object.freeze({ })\nconst parseOptions = options => {\n  if (!options) {\n    return emptyOpts\n  }\n\n  if (typeof options !== 'object') {\n    return looseOption\n  }\n\n  return options\n}\nmodule.exports = parseOptions\n",
    "'use strict'\n\nconst numeric = /^[0-9]+$/\nconst compareIdentifiers = (a, b) => {\n  const anum = numeric.test(a)\n  const bnum = numeric.test(b)\n\n  if (anum && bnum) {\n    a = +a\n    b = +b\n  }\n\n  return a === b ? 0\n    : (anum && !bnum) ? -1\n    : (bnum && !anum) ? 1\n    : a < b ? -1\n    : 1\n}\n\nconst rcompareIdentifiers = (a, b) => compareIdentifiers(b, a)\n\nmodule.exports = {\n  compareIdentifiers,\n  rcompareIdentifiers,\n}\n",
    "'use strict'\n\nconst debug = require('../internal/debug')\nconst { MAX_LENGTH, MAX_SAFE_INTEGER } = require('../internal/constants')\nconst { safeRe: re, t } = require('../internal/re')\n\nconst parseOptions = require('../internal/parse-options')\nconst { compareIdentifiers } = require('../internal/identifiers')\nclass SemVer {\n  constructor (version, options) {\n    options = parseOptions(options)\n\n    if (version instanceof SemVer) {\n      if (version.loose === !!options.loose &&\n        version.includePrerelease === !!options.includePrerelease) {\n        return version\n      } else {\n        version = version.version\n      }\n    } else if (typeof version !== 'string') {\n      throw new TypeError(`Invalid version. Must be a string. Got type \"${typeof version}\".`)\n    }\n\n    if (version.length > MAX_LENGTH) {\n      throw new TypeError(\n        `version is longer than ${MAX_LENGTH} characters`\n      )\n    }\n\n    debug('SemVer', version, options)\n    this.options = options\n    this.loose = !!options.loose\n    // this isn't actually relevant for versions, but keep it so that we\n    // don't run into trouble passing this.options around.\n    this.includePrerelease = !!options.includePrerelease\n\n    const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL])\n\n    if (!m) {\n      throw new TypeError(`Invalid Version: ${version}`)\n    }\n\n    this.raw = version\n\n    // these are actually numbers\n    this.major = +m[1]\n    this.minor = +m[2]\n    this.patch = +m[3]\n\n    if (this.major > MAX_SAFE_INTEGER || this.major < 0) {\n      throw new TypeError('Invalid major version')\n    }\n\n    if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {\n      throw new TypeError('Invalid minor version')\n    }\n\n    if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {\n      throw new TypeError('Invalid patch version')\n    }\n\n    // numberify any prerelease numeric ids\n    if (!m[4]) {\n      this.prerelease = []\n    } else {\n      this.prerelease = m[4].split('.').map((id) => {\n        if (/^[0-9]+$/.test(id)) {\n          const num = +id\n          if (num >= 0 && num < MAX_SAFE_INTEGER) {\n            return num\n          }\n        }\n        return id\n      })\n    }\n\n    this.build = m[5] ? m[5].split('.') : []\n    this.format()\n  }\n\n  format () {\n    this.version = `${this.major}.${this.minor}.${this.patch}`\n    if (this.prerelease.length) {\n      this.version += `-${this.prerelease.join('.')}`\n    }\n    return this.version\n  }\n\n  toString () {\n    return this.version\n  }\n\n  compare (other) {\n    debug('SemVer.compare', this.version, this.options, other)\n    if (!(other instanceof SemVer)) {\n      if (typeof other === 'string' && other === this.version) {\n        return 0\n      }\n      other = new SemVer(other, this.options)\n    }\n\n    if (other.version === this.version) {\n      return 0\n    }\n\n    return this.compareMain(other) || this.comparePre(other)\n  }\n\n  compareMain (other) {\n    if (!(other instanceof SemVer)) {\n      other = new SemVer(other, this.options)\n    }\n\n    return (\n      compareIdentifiers(this.major, other.major) ||\n      compareIdentifiers(this.minor, other.minor) ||\n      compareIdentifiers(this.patch, other.patch)\n    )\n  }\n\n  comparePre (other) {\n    if (!(other instanceof SemVer)) {\n      other = new SemVer(other, this.options)\n    }\n\n    // NOT having a prerelease is > having one\n    if (this.prerelease.length && !other.prerelease.length) {\n      return -1\n    } else if (!this.prerelease.length && other.prerelease.length) {\n      return 1\n    } else if (!this.prerelease.length && !other.prerelease.length) {\n      return 0\n    }\n\n    let i = 0\n    do {\n      const a = this.prerelease[i]\n      const b = other.prerelease[i]\n      debug('prerelease compare', i, a, b)\n      if (a === undefined && b === undefined) {\n        return 0\n      } else if (b === undefined) {\n        return 1\n      } else if (a === undefined) {\n        return -1\n      } else if (a === b) {\n        continue\n      } else {\n        return compareIdentifiers(a, b)\n      }\n    } while (++i)\n  }\n\n  compareBuild (other) {\n    if (!(other instanceof SemVer)) {\n      other = new SemVer(other, this.options)\n    }\n\n    let i = 0\n    do {\n      const a = this.build[i]\n      const b = other.build[i]\n      debug('build compare', i, a, b)\n      if (a === undefined && b === undefined) {\n        return 0\n      } else if (b === undefined) {\n        return 1\n      } else if (a === undefined) {\n        return -1\n      } else if (a === b) {\n        continue\n      } else {\n        return compareIdentifiers(a, b)\n      }\n    } while (++i)\n  }\n\n  // preminor will bump the version up to the next minor release, and immediately\n  // down to pre-release. premajor and prepatch work the same way.\n  inc (release, identifier, identifierBase) {\n    if (release.startsWith('pre')) {\n      if (!identifier && identifierBase === false) {\n        throw new Error('invalid increment argument: identifier is empty')\n      }\n      // Avoid an invalid semver results\n      if (identifier) {\n        const match = `-${identifier}`.match(this.options.loose ? re[t.PRERELEASELOOSE] : re[t.PRERELEASE])\n        if (!match || match[1] !== identifier) {\n          throw new Error(`invalid identifier: ${identifier}`)\n        }\n      }\n    }\n\n    switch (release) {\n      case 'premajor':\n        this.prerelease.length = 0\n        this.patch = 0\n        this.minor = 0\n        this.major++\n        this.inc('pre', identifier, identifierBase)\n        break\n      case 'preminor':\n        this.prerelease.length = 0\n        this.patch = 0\n        this.minor++\n        this.inc('pre', identifier, identifierBase)\n        break\n      case 'prepatch':\n        // If this is already a prerelease, it will bump to the next version\n        // drop any prereleases that might already exist, since they are not\n        // relevant at this point.\n        this.prerelease.length = 0\n        this.inc('patch', identifier, identifierBase)\n        this.inc('pre', identifier, identifierBase)\n        break\n      // If the input is a non-prerelease version, this acts the same as\n      // prepatch.\n      case 'prerelease':\n        if (this.prerelease.length === 0) {\n          this.inc('patch', identifier, identifierBase)\n        }\n        this.inc('pre', identifier, identifierBase)\n        break\n      case 'release':\n        if (this.prerelease.length === 0) {\n          throw new Error(`version ${this.raw} is not a prerelease`)\n        }\n        this.prerelease.length = 0\n        break\n\n      case 'major':\n        // If this is a pre-major version, bump up to the same major version.\n        // Otherwise increment major.\n        // 1.0.0-5 bumps to 1.0.0\n        // 1.1.0 bumps to 2.0.0\n        if (\n          this.minor !== 0 ||\n          this.patch !== 0 ||\n          this.prerelease.length === 0\n        ) {\n          this.major++\n        }\n        this.minor = 0\n        this.patch = 0\n        this.prerelease = []\n        break\n      case 'minor':\n        // If this is a pre-minor version, bump up to the same minor version.\n        // Otherwise increment minor.\n        // 1.2.0-5 bumps to 1.2.0\n        // 1.2.1 bumps to 1.3.0\n        if (this.patch !== 0 || this.prerelease.length === 0) {\n          this.minor++\n        }\n        this.patch = 0\n        this.prerelease = []\n        break\n      case 'patch':\n        // If this is not a pre-release version, it will increment the patch.\n        // If it is a pre-release it will bump up to the same patch version.\n        // 1.2.0-5 patches to 1.2.0\n        // 1.2.0 patches to 1.2.1\n        if (this.prerelease.length === 0) {\n          this.patch++\n        }\n        this.prerelease = []\n        break\n      // This probably shouldn't be used publicly.\n      // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.\n      case 'pre': {\n        const base = Number(identifierBase) ? 1 : 0\n\n        if (this.prerelease.length === 0) {\n          this.prerelease = [base]\n        } else {\n          let i = this.prerelease.length\n          while (--i >= 0) {\n            if (typeof this.prerelease[i] === 'number') {\n              this.prerelease[i]++\n              i = -2\n            }\n          }\n          if (i === -1) {\n            // didn't increment anything\n            if (identifier === this.prerelease.join('.') && identifierBase === false) {\n              throw new Error('invalid increment argument: identifier already exists')\n            }\n            this.prerelease.push(base)\n          }\n        }\n        if (identifier) {\n          // 1.2.0-beta.1 bumps to 1.2.0-beta.2,\n          // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0\n          let prerelease = [identifier, base]\n          if (identifierBase === false) {\n            prerelease = [identifier]\n          }\n          if (compareIdentifiers(this.prerelease[0], identifier) === 0) {\n            if (isNaN(this.prerelease[1])) {\n              this.prerelease = prerelease\n            }\n          } else {\n            this.prerelease = prerelease\n          }\n        }\n        break\n      }\n      default:\n        throw new Error(`invalid increment argument: ${release}`)\n    }\n    this.raw = this.format()\n    if (this.build.length) {\n      this.raw += `+${this.build.join('.')}`\n    }\n    return this\n  }\n}\n\nmodule.exports = SemVer\n",
    "'use strict'\n\nconst SemVer = require('../classes/semver')\nconst parse = (version, options, throwErrors = false) => {\n  if (version instanceof SemVer) {\n    return version\n  }\n  try {\n    return new SemVer(version, options)\n  } catch (er) {\n    if (!throwErrors) {\n      return null\n    }\n    throw er\n  }\n}\n\nmodule.exports = parse\n",
    "'use strict'\n\nconst parse = require('./parse')\nconst valid = (version, options) => {\n  const v = parse(version, options)\n  return v ? v.version : null\n}\nmodule.exports = valid\n",
    "'use strict'\n\nconst parse = require('./parse')\nconst clean = (version, options) => {\n  const s = parse(version.trim().replace(/^[=v]+/, ''), options)\n  return s ? s.version : null\n}\nmodule.exports = clean\n",
    "'use strict'\n\nconst SemVer = require('../classes/semver')\n\nconst inc = (version, release, options, identifier, identifierBase) => {\n  if (typeof (options) === 'string') {\n    identifierBase = identifier\n    identifier = options\n    options = undefined\n  }\n\n  try {\n    return new SemVer(\n      version instanceof SemVer ? version.version : version,\n      options\n    ).inc(release, identifier, identifierBase).version\n  } catch (er) {\n    return null\n  }\n}\nmodule.exports = inc\n",
    "'use strict'\n\nconst parse = require('./parse.js')\n\nconst diff = (version1, version2) => {\n  const v1 = parse(version1, null, true)\n  const v2 = parse(version2, null, true)\n  const comparison = v1.compare(v2)\n\n  if (comparison === 0) {\n    return null\n  }\n\n  const v1Higher = comparison > 0\n  const highVersion = v1Higher ? v1 : v2\n  const lowVersion = v1Higher ? v2 : v1\n  const highHasPre = !!highVersion.prerelease.length\n  const lowHasPre = !!lowVersion.prerelease.length\n\n  if (lowHasPre && !highHasPre) {\n    // Going from prerelease -> no prerelease requires some special casing\n\n    // If the low version has only a major, then it will always be a major\n    // Some examples:\n    // 1.0.0-1 -> 1.0.0\n    // 1.0.0-1 -> 1.1.1\n    // 1.0.0-1 -> 2.0.0\n    if (!lowVersion.patch && !lowVersion.minor) {\n      return 'major'\n    }\n\n    // If the main part has no difference\n    if (lowVersion.compareMain(highVersion) === 0) {\n      if (lowVersion.minor && !lowVersion.patch) {\n        return 'minor'\n      }\n      return 'patch'\n    }\n  }\n\n  // add the `pre` prefix if we are going to a prerelease version\n  const prefix = highHasPre ? 'pre' : ''\n\n  if (v1.major !== v2.major) {\n    return prefix + 'major'\n  }\n\n  if (v1.minor !== v2.minor) {\n    return prefix + 'minor'\n  }\n\n  if (v1.patch !== v2.patch) {\n    return prefix + 'patch'\n  }\n\n  // high and low are preleases\n  return 'prerelease'\n}\n\nmodule.exports = diff\n",
    "'use strict'\n\nconst SemVer = require('../classes/semver')\nconst major = (a, loose) => new SemVer(a, loose).major\nmodule.exports = major\n",
    "'use strict'\n\nconst SemVer = require('../classes/semver')\nconst minor = (a, loose) => new SemVer(a, loose).minor\nmodule.exports = minor\n",
    "'use strict'\n\nconst SemVer = require('../classes/semver')\nconst patch = (a, loose) => new SemVer(a, loose).patch\nmodule.exports = patch\n",
    "'use strict'\n\nconst parse = require('./parse')\nconst prerelease = (version, options) => {\n  const parsed = parse(version, options)\n  return (parsed && parsed.prerelease.length) ? parsed.prerelease : null\n}\nmodule.exports = prerelease\n",
    "'use strict'\n\nconst SemVer = require('../classes/semver')\nconst compare = (a, b, loose) =>\n  new SemVer(a, loose).compare(new SemVer(b, loose))\n\nmodule.exports = compare\n",
    "'use strict'\n\nconst compare = require('./compare')\nconst rcompare = (a, b, loose) => compare(b, a, loose)\nmodule.exports = rcompare\n",
    "'use strict'\n\nconst compare = require('./compare')\nconst compareLoose = (a, b) => compare(a, b, true)\nmodule.exports = compareLoose\n",
    "'use strict'\n\nconst SemVer = require('../classes/semver')\nconst compareBuild = (a, b, loose) => {\n  const versionA = new SemVer(a, loose)\n  const versionB = new SemVer(b, loose)\n  return versionA.compare(versionB) || versionA.compareBuild(versionB)\n}\nmodule.exports = compareBuild\n",
    "'use strict'\n\nconst compareBuild = require('./compare-build')\nconst sort = (list, loose) => list.sort((a, b) => compareBuild(a, b, loose))\nmodule.exports = sort\n",
    "'use strict'\n\nconst compareBuild = require('./compare-build')\nconst rsort = (list, loose) => list.sort((a, b) => compareBuild(b, a, loose))\nmodule.exports = rsort\n",
    "'use strict'\n\nconst compare = require('./compare')\nconst gt = (a, b, loose) => compare(a, b, loose) > 0\nmodule.exports = gt\n",
    "'use strict'\n\nconst compare = require('./compare')\nconst lt = (a, b, loose) => compare(a, b, loose) < 0\nmodule.exports = lt\n",
    "'use strict'\n\nconst compare = require('./compare')\nconst eq = (a, b, loose) => compare(a, b, loose) === 0\nmodule.exports = eq\n",
    "'use strict'\n\nconst compare = require('./compare')\nconst neq = (a, b, loose) => compare(a, b, loose) !== 0\nmodule.exports = neq\n",
    "'use strict'\n\nconst compare = require('./compare')\nconst gte = (a, b, loose) => compare(a, b, loose) >= 0\nmodule.exports = gte\n",
    "'use strict'\n\nconst compare = require('./compare')\nconst lte = (a, b, loose) => compare(a, b, loose) <= 0\nmodule.exports = lte\n",
    "'use strict'\n\nconst eq = require('./eq')\nconst neq = require('./neq')\nconst gt = require('./gt')\nconst gte = require('./gte')\nconst lt = require('./lt')\nconst lte = require('./lte')\n\nconst cmp = (a, op, b, loose) => {\n  switch (op) {\n    case '===':\n      if (typeof a === 'object') {\n        a = a.version\n      }\n      if (typeof b === 'object') {\n        b = b.version\n      }\n      return a === b\n\n    case '!==':\n      if (typeof a === 'object') {\n        a = a.version\n      }\n      if (typeof b === 'object') {\n        b = b.version\n      }\n      return a !== b\n\n    case '':\n    case '=':\n    case '==':\n      return eq(a, b, loose)\n\n    case '!=':\n      return neq(a, b, loose)\n\n    case '>':\n      return gt(a, b, loose)\n\n    case '>=':\n      return gte(a, b, loose)\n\n    case '<':\n      return lt(a, b, loose)\n\n    case '<=':\n      return lte(a, b, loose)\n\n    default:\n      throw new TypeError(`Invalid operator: ${op}`)\n  }\n}\nmodule.exports = cmp\n",
    "'use strict'\n\nconst SemVer = require('../classes/semver')\nconst parse = require('./parse')\nconst { safeRe: re, t } = require('../internal/re')\n\nconst coerce = (version, options) => {\n  if (version instanceof SemVer) {\n    return version\n  }\n\n  if (typeof version === 'number') {\n    version = String(version)\n  }\n\n  if (typeof version !== 'string') {\n    return null\n  }\n\n  options = options || {}\n\n  let match = null\n  if (!options.rtl) {\n    match = version.match(options.includePrerelease ? re[t.COERCEFULL] : re[t.COERCE])\n  } else {\n    // Find the right-most coercible string that does not share\n    // a terminus with a more left-ward coercible string.\n    // Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4'\n    // With includePrerelease option set, '1.2.3.4-rc' wants to coerce '2.3.4-rc', not '2.3.4'\n    //\n    // Walk through the string checking with a /g regexp\n    // Manually set the index so as to pick up overlapping matches.\n    // Stop when we get a match that ends at the string end, since no\n    // coercible string can be more right-ward without the same terminus.\n    const coerceRtlRegex = options.includePrerelease ? re[t.COERCERTLFULL] : re[t.COERCERTL]\n    let next\n    while ((next = coerceRtlRegex.exec(version)) &&\n        (!match || match.index + match[0].length !== version.length)\n    ) {\n      if (!match ||\n            next.index + next[0].length !== match.index + match[0].length) {\n        match = next\n      }\n      coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length\n    }\n    // leave it in a clean state\n    coerceRtlRegex.lastIndex = -1\n  }\n\n  if (match === null) {\n    return null\n  }\n\n  const major = match[2]\n  const minor = match[3] || '0'\n  const patch = match[4] || '0'\n  const prerelease = options.includePrerelease && match[5] ? `-${match[5]}` : ''\n  const build = options.includePrerelease && match[6] ? `+${match[6]}` : ''\n\n  return parse(`${major}.${minor}.${patch}${prerelease}${build}`, options)\n}\nmodule.exports = coerce\n",
    "'use strict'\n\nclass LRUCache {\n  constructor () {\n    this.max = 1000\n    this.map = new Map()\n  }\n\n  get (key) {\n    const value = this.map.get(key)\n    if (value === undefined) {\n      return undefined\n    } else {\n      // Remove the key from the map and add it to the end\n      this.map.delete(key)\n      this.map.set(key, value)\n      return value\n    }\n  }\n\n  delete (key) {\n    return this.map.delete(key)\n  }\n\n  set (key, value) {\n    const deleted = this.delete(key)\n\n    if (!deleted && value !== undefined) {\n      // If cache is full, delete the least recently used item\n      if (this.map.size >= this.max) {\n        const firstKey = this.map.keys().next().value\n        this.delete(firstKey)\n      }\n\n      this.map.set(key, value)\n    }\n\n    return this\n  }\n}\n\nmodule.exports = LRUCache\n",
    "'use strict'\n\nconst SPACE_CHARACTERS = /\\s+/g\n\n// hoisted class for cyclic dependency\nclass Range {\n  constructor (range, options) {\n    options = parseOptions(options)\n\n    if (range instanceof Range) {\n      if (\n        range.loose === !!options.loose &&\n        range.includePrerelease === !!options.includePrerelease\n      ) {\n        return range\n      } else {\n        return new Range(range.raw, options)\n      }\n    }\n\n    if (range instanceof Comparator) {\n      // just put it in the set and return\n      this.raw = range.value\n      this.set = [[range]]\n      this.formatted = undefined\n      return this\n    }\n\n    this.options = options\n    this.loose = !!options.loose\n    this.includePrerelease = !!options.includePrerelease\n\n    // First reduce all whitespace as much as possible so we do not have to rely\n    // on potentially slow regexes like \\s*. This is then stored and used for\n    // future error messages as well.\n    this.raw = range.trim().replace(SPACE_CHARACTERS, ' ')\n\n    // First, split on ||\n    this.set = this.raw\n      .split('||')\n      // map the range to a 2d array of comparators\n      .map(r => this.parseRange(r.trim()))\n      // throw out any comparator lists that are empty\n      // this generally means that it was not a valid range, which is allowed\n      // in loose mode, but will still throw if the WHOLE range is invalid.\n      .filter(c => c.length)\n\n    if (!this.set.length) {\n      throw new TypeError(`Invalid SemVer Range: ${this.raw}`)\n    }\n\n    // if we have any that are not the null set, throw out null sets.\n    if (this.set.length > 1) {\n      // keep the first one, in case they're all null sets\n      const first = this.set[0]\n      this.set = this.set.filter(c => !isNullSet(c[0]))\n      if (this.set.length === 0) {\n        this.set = [first]\n      } else if (this.set.length > 1) {\n        // if we have any that are *, then the range is just *\n        for (const c of this.set) {\n          if (c.length === 1 && isAny(c[0])) {\n            this.set = [c]\n            break\n          }\n        }\n      }\n    }\n\n    this.formatted = undefined\n  }\n\n  get range () {\n    if (this.formatted === undefined) {\n      this.formatted = ''\n      for (let i = 0; i < this.set.length; i++) {\n        if (i > 0) {\n          this.formatted += '||'\n        }\n        const comps = this.set[i]\n        for (let k = 0; k < comps.length; k++) {\n          if (k > 0) {\n            this.formatted += ' '\n          }\n          this.formatted += comps[k].toString().trim()\n        }\n      }\n    }\n    return this.formatted\n  }\n\n  format () {\n    return this.range\n  }\n\n  toString () {\n    return this.range\n  }\n\n  parseRange (range) {\n    // memoize range parsing for performance.\n    // this is a very hot path, and fully deterministic.\n    const memoOpts =\n      (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) |\n      (this.options.loose && FLAG_LOOSE)\n    const memoKey = memoOpts + ':' + range\n    const cached = cache.get(memoKey)\n    if (cached) {\n      return cached\n    }\n\n    const loose = this.options.loose\n    // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`\n    const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE]\n    range = range.replace(hr, hyphenReplace(this.options.includePrerelease))\n    debug('hyphen replace', range)\n\n    // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`\n    range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace)\n    debug('comparator trim', range)\n\n    // `~ 1.2.3` => `~1.2.3`\n    range = range.replace(re[t.TILDETRIM], tildeTrimReplace)\n    debug('tilde trim', range)\n\n    // `^ 1.2.3` => `^1.2.3`\n    range = range.replace(re[t.CARETTRIM], caretTrimReplace)\n    debug('caret trim', range)\n\n    // At this point, the range is completely trimmed and\n    // ready to be split into comparators.\n\n    let rangeList = range\n      .split(' ')\n      .map(comp => parseComparator(comp, this.options))\n      .join(' ')\n      .split(/\\s+/)\n      // >=0.0.0 is equivalent to *\n      .map(comp => replaceGTE0(comp, this.options))\n\n    if (loose) {\n      // in loose mode, throw out any that are not valid comparators\n      rangeList = rangeList.filter(comp => {\n        debug('loose invalid filter', comp, this.options)\n        return !!comp.match(re[t.COMPARATORLOOSE])\n      })\n    }\n    debug('range list', rangeList)\n\n    // if any comparators are the null set, then replace with JUST null set\n    // if more than one comparator, remove any * comparators\n    // also, don't include the same comparator more than once\n    const rangeMap = new Map()\n    const comparators = rangeList.map(comp => new Comparator(comp, this.options))\n    for (const comp of comparators) {\n      if (isNullSet(comp)) {\n        return [comp]\n      }\n      rangeMap.set(comp.value, comp)\n    }\n    if (rangeMap.size > 1 && rangeMap.has('')) {\n      rangeMap.delete('')\n    }\n\n    const result = [...rangeMap.values()]\n    cache.set(memoKey, result)\n    return result\n  }\n\n  intersects (range, options) {\n    if (!(range instanceof Range)) {\n      throw new TypeError('a Range is required')\n    }\n\n    return this.set.some((thisComparators) => {\n      return (\n        isSatisfiable(thisComparators, options) &&\n        range.set.some((rangeComparators) => {\n          return (\n            isSatisfiable(rangeComparators, options) &&\n            thisComparators.every((thisComparator) => {\n              return rangeComparators.every((rangeComparator) => {\n                return thisComparator.intersects(rangeComparator, options)\n              })\n            })\n          )\n        })\n      )\n    })\n  }\n\n  // if ANY of the sets match ALL of its comparators, then pass\n  test (version) {\n    if (!version) {\n      return false\n    }\n\n    if (typeof version === 'string') {\n      try {\n        version = new SemVer(version, this.options)\n      } catch (er) {\n        return false\n      }\n    }\n\n    for (let i = 0; i < this.set.length; i++) {\n      if (testSet(this.set[i], version, this.options)) {\n        return true\n      }\n    }\n    return false\n  }\n}\n\nmodule.exports = Range\n\nconst LRU = require('../internal/lrucache')\nconst cache = new LRU()\n\nconst parseOptions = require('../internal/parse-options')\nconst Comparator = require('./comparator')\nconst debug = require('../internal/debug')\nconst SemVer = require('./semver')\nconst {\n  safeRe: re,\n  t,\n  comparatorTrimReplace,\n  tildeTrimReplace,\n  caretTrimReplace,\n} = require('../internal/re')\nconst { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require('../internal/constants')\n\nconst isNullSet = c => c.value === '<0.0.0-0'\nconst isAny = c => c.value === ''\n\n// take a set of comparators and determine whether there\n// exists a version which can satisfy it\nconst isSatisfiable = (comparators, options) => {\n  let result = true\n  const remainingComparators = comparators.slice()\n  let testComparator = remainingComparators.pop()\n\n  while (result && remainingComparators.length) {\n    result = remainingComparators.every((otherComparator) => {\n      return testComparator.intersects(otherComparator, options)\n    })\n\n    testComparator = remainingComparators.pop()\n  }\n\n  return result\n}\n\n// comprised of xranges, tildes, stars, and gtlt's at this point.\n// already replaced the hyphen ranges\n// turn into a set of JUST comparators.\nconst parseComparator = (comp, options) => {\n  debug('comp', comp, options)\n  comp = replaceCarets(comp, options)\n  debug('caret', comp)\n  comp = replaceTildes(comp, options)\n  debug('tildes', comp)\n  comp = replaceXRanges(comp, options)\n  debug('xrange', comp)\n  comp = replaceStars(comp, options)\n  debug('stars', comp)\n  return comp\n}\n\nconst isX = id => !id || id.toLowerCase() === 'x' || id === '*'\n\n// ~, ~> --> * (any, kinda silly)\n// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0-0\n// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0-0\n// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0-0\n// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0-0\n// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0-0\n// ~0.0.1 --> >=0.0.1 <0.1.0-0\nconst replaceTildes = (comp, options) => {\n  return comp\n    .trim()\n    .split(/\\s+/)\n    .map((c) => replaceTilde(c, options))\n    .join(' ')\n}\n\nconst replaceTilde = (comp, options) => {\n  const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE]\n  return comp.replace(r, (_, M, m, p, pr) => {\n    debug('tilde', comp, _, M, m, p, pr)\n    let ret\n\n    if (isX(M)) {\n      ret = ''\n    } else if (isX(m)) {\n      ret = `>=${M}.0.0 <${+M + 1}.0.0-0`\n    } else if (isX(p)) {\n      // ~1.2 == >=1.2.0 <1.3.0-0\n      ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`\n    } else if (pr) {\n      debug('replaceTilde pr', pr)\n      ret = `>=${M}.${m}.${p}-${pr\n      } <${M}.${+m + 1}.0-0`\n    } else {\n      // ~1.2.3 == >=1.2.3 <1.3.0-0\n      ret = `>=${M}.${m}.${p\n      } <${M}.${+m + 1}.0-0`\n    }\n\n    debug('tilde return', ret)\n    return ret\n  })\n}\n\n// ^ --> * (any, kinda silly)\n// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0-0\n// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0-0\n// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0-0\n// ^1.2.3 --> >=1.2.3 <2.0.0-0\n// ^1.2.0 --> >=1.2.0 <2.0.0-0\n// ^0.0.1 --> >=0.0.1 <0.0.2-0\n// ^0.1.0 --> >=0.1.0 <0.2.0-0\nconst replaceCarets = (comp, options) => {\n  return comp\n    .trim()\n    .split(/\\s+/)\n    .map((c) => replaceCaret(c, options))\n    .join(' ')\n}\n\nconst replaceCaret = (comp, options) => {\n  debug('caret', comp, options)\n  const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET]\n  const z = options.includePrerelease ? '-0' : ''\n  return comp.replace(r, (_, M, m, p, pr) => {\n    debug('caret', comp, _, M, m, p, pr)\n    let ret\n\n    if (isX(M)) {\n      ret = ''\n    } else if (isX(m)) {\n      ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`\n    } else if (isX(p)) {\n      if (M === '0') {\n        ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`\n      } else {\n        ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`\n      }\n    } else if (pr) {\n      debug('replaceCaret pr', pr)\n      if (M === '0') {\n        if (m === '0') {\n          ret = `>=${M}.${m}.${p}-${pr\n          } <${M}.${m}.${+p + 1}-0`\n        } else {\n          ret = `>=${M}.${m}.${p}-${pr\n          } <${M}.${+m + 1}.0-0`\n        }\n      } else {\n        ret = `>=${M}.${m}.${p}-${pr\n        } <${+M + 1}.0.0-0`\n      }\n    } else {\n      debug('no pr')\n      if (M === '0') {\n        if (m === '0') {\n          ret = `>=${M}.${m}.${p\n          }${z} <${M}.${m}.${+p + 1}-0`\n        } else {\n          ret = `>=${M}.${m}.${p\n          }${z} <${M}.${+m + 1}.0-0`\n        }\n      } else {\n        ret = `>=${M}.${m}.${p\n        } <${+M + 1}.0.0-0`\n      }\n    }\n\n    debug('caret return', ret)\n    return ret\n  })\n}\n\nconst replaceXRanges = (comp, options) => {\n  debug('replaceXRanges', comp, options)\n  return comp\n    .split(/\\s+/)\n    .map((c) => replaceXRange(c, options))\n    .join(' ')\n}\n\nconst replaceXRange = (comp, options) => {\n  comp = comp.trim()\n  const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE]\n  return comp.replace(r, (ret, gtlt, M, m, p, pr) => {\n    debug('xRange', comp, ret, gtlt, M, m, p, pr)\n    const xM = isX(M)\n    const xm = xM || isX(m)\n    const xp = xm || isX(p)\n    const anyX = xp\n\n    if (gtlt === '=' && anyX) {\n      gtlt = ''\n    }\n\n    // if we're including prereleases in the match, then we need\n    // to fix this to -0, the lowest possible prerelease value\n    pr = options.includePrerelease ? '-0' : ''\n\n    if (xM) {\n      if (gtlt === '>' || gtlt === '<') {\n        // nothing is allowed\n        ret = '<0.0.0-0'\n      } else {\n        // nothing is forbidden\n        ret = '*'\n      }\n    } else if (gtlt && anyX) {\n      // we know patch is an x, because we have any x at all.\n      // replace X with 0\n      if (xm) {\n        m = 0\n      }\n      p = 0\n\n      if (gtlt === '>') {\n        // >1 => >=2.0.0\n        // >1.2 => >=1.3.0\n        gtlt = '>='\n        if (xm) {\n          M = +M + 1\n          m = 0\n          p = 0\n        } else {\n          m = +m + 1\n          p = 0\n        }\n      } else if (gtlt === '<=') {\n        // <=0.7.x is actually <0.8.0, since any 0.7.x should\n        // pass.  Similarly, <=7.x is actually <8.0.0, etc.\n        gtlt = '<'\n        if (xm) {\n          M = +M + 1\n        } else {\n          m = +m + 1\n        }\n      }\n\n      if (gtlt === '<') {\n        pr = '-0'\n      }\n\n      ret = `${gtlt + M}.${m}.${p}${pr}`\n    } else if (xm) {\n      ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`\n    } else if (xp) {\n      ret = `>=${M}.${m}.0${pr\n      } <${M}.${+m + 1}.0-0`\n    }\n\n    debug('xRange return', ret)\n\n    return ret\n  })\n}\n\n// Because * is AND-ed with everything else in the comparator,\n// and '' means \"any version\", just remove the *s entirely.\nconst replaceStars = (comp, options) => {\n  debug('replaceStars', comp, options)\n  // Looseness is ignored here.  star is always as loose as it gets!\n  return comp\n    .trim()\n    .replace(re[t.STAR], '')\n}\n\nconst replaceGTE0 = (comp, options) => {\n  debug('replaceGTE0', comp, options)\n  return comp\n    .trim()\n    .replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], '')\n}\n\n// This function is passed to string.replace(re[t.HYPHENRANGE])\n// M, m, patch, prerelease, build\n// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5\n// 1.2.3 - 3.4 => >=1.2.0 <3.5.0-0 Any 3.4.x will do\n// 1.2 - 3.4 => >=1.2.0 <3.5.0-0\n// TODO build?\nconst hyphenReplace = incPr => ($0,\n  from, fM, fm, fp, fpr, fb,\n  to, tM, tm, tp, tpr) => {\n  if (isX(fM)) {\n    from = ''\n  } else if (isX(fm)) {\n    from = `>=${fM}.0.0${incPr ? '-0' : ''}`\n  } else if (isX(fp)) {\n    from = `>=${fM}.${fm}.0${incPr ? '-0' : ''}`\n  } else if (fpr) {\n    from = `>=${from}`\n  } else {\n    from = `>=${from}${incPr ? '-0' : ''}`\n  }\n\n  if (isX(tM)) {\n    to = ''\n  } else if (isX(tm)) {\n    to = `<${+tM + 1}.0.0-0`\n  } else if (isX(tp)) {\n    to = `<${tM}.${+tm + 1}.0-0`\n  } else if (tpr) {\n    to = `<=${tM}.${tm}.${tp}-${tpr}`\n  } else if (incPr) {\n    to = `<${tM}.${tm}.${+tp + 1}-0`\n  } else {\n    to = `<=${to}`\n  }\n\n  return `${from} ${to}`.trim()\n}\n\nconst testSet = (set, version, options) => {\n  for (let i = 0; i < set.length; i++) {\n    if (!set[i].test(version)) {\n      return false\n    }\n  }\n\n  if (version.prerelease.length && !options.includePrerelease) {\n    // Find the set of versions that are allowed to have prereleases\n    // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0\n    // That should allow `1.2.3-pr.2` to pass.\n    // However, `1.2.4-alpha.notready` should NOT be allowed,\n    // even though it's within the range set by the comparators.\n    for (let i = 0; i < set.length; i++) {\n      debug(set[i].semver)\n      if (set[i].semver === Comparator.ANY) {\n        continue\n      }\n\n      if (set[i].semver.prerelease.length > 0) {\n        const allowed = set[i].semver\n        if (allowed.major === version.major &&\n            allowed.minor === version.minor &&\n            allowed.patch === version.patch) {\n          return true\n        }\n      }\n    }\n\n    // Version has a -pre, but it's not one of the ones we like.\n    return false\n  }\n\n  return true\n}\n",
    "'use strict'\n\nconst ANY = Symbol('SemVer ANY')\n// hoisted class for cyclic dependency\nclass Comparator {\n  static get ANY () {\n    return ANY\n  }\n\n  constructor (comp, options) {\n    options = parseOptions(options)\n\n    if (comp instanceof Comparator) {\n      if (comp.loose === !!options.loose) {\n        return comp\n      } else {\n        comp = comp.value\n      }\n    }\n\n    comp = comp.trim().split(/\\s+/).join(' ')\n    debug('comparator', comp, options)\n    this.options = options\n    this.loose = !!options.loose\n    this.parse(comp)\n\n    if (this.semver === ANY) {\n      this.value = ''\n    } else {\n      this.value = this.operator + this.semver.version\n    }\n\n    debug('comp', this)\n  }\n\n  parse (comp) {\n    const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR]\n    const m = comp.match(r)\n\n    if (!m) {\n      throw new TypeError(`Invalid comparator: ${comp}`)\n    }\n\n    this.operator = m[1] !== undefined ? m[1] : ''\n    if (this.operator === '=') {\n      this.operator = ''\n    }\n\n    // if it literally is just '>' or '' then allow anything.\n    if (!m[2]) {\n      this.semver = ANY\n    } else {\n      this.semver = new SemVer(m[2], this.options.loose)\n    }\n  }\n\n  toString () {\n    return this.value\n  }\n\n  test (version) {\n    debug('Comparator.test', version, this.options.loose)\n\n    if (this.semver === ANY || version === ANY) {\n      return true\n    }\n\n    if (typeof version === 'string') {\n      try {\n        version = new SemVer(version, this.options)\n      } catch (er) {\n        return false\n      }\n    }\n\n    return cmp(version, this.operator, this.semver, this.options)\n  }\n\n  intersects (comp, options) {\n    if (!(comp instanceof Comparator)) {\n      throw new TypeError('a Comparator is required')\n    }\n\n    if (this.operator === '') {\n      if (this.value === '') {\n        return true\n      }\n      return new Range(comp.value, options).test(this.value)\n    } else if (comp.operator === '') {\n      if (comp.value === '') {\n        return true\n      }\n      return new Range(this.value, options).test(comp.semver)\n    }\n\n    options = parseOptions(options)\n\n    // Special cases where nothing can possibly be lower\n    if (options.includePrerelease &&\n      (this.value === '<0.0.0-0' || comp.value === '<0.0.0-0')) {\n      return false\n    }\n    if (!options.includePrerelease &&\n      (this.value.startsWith('<0.0.0') || comp.value.startsWith('<0.0.0'))) {\n      return false\n    }\n\n    // Same direction increasing (> or >=)\n    if (this.operator.startsWith('>') && comp.operator.startsWith('>')) {\n      return true\n    }\n    // Same direction decreasing (< or <=)\n    if (this.operator.startsWith('<') && comp.operator.startsWith('<')) {\n      return true\n    }\n    // same SemVer and both sides are inclusive (<= or >=)\n    if (\n      (this.semver.version === comp.semver.version) &&\n      this.operator.includes('=') && comp.operator.includes('=')) {\n      return true\n    }\n    // opposite directions less than\n    if (cmp(this.semver, '<', comp.semver, options) &&\n      this.operator.startsWith('>') && comp.operator.startsWith('<')) {\n      return true\n    }\n    // opposite directions greater than\n    if (cmp(this.semver, '>', comp.semver, options) &&\n      this.operator.startsWith('<') && comp.operator.startsWith('>')) {\n      return true\n    }\n    return false\n  }\n}\n\nmodule.exports = Comparator\n\nconst parseOptions = require('../internal/parse-options')\nconst { safeRe: re, t } = require('../internal/re')\nconst cmp = require('../functions/cmp')\nconst debug = require('../internal/debug')\nconst SemVer = require('./semver')\nconst Range = require('./range')\n",
    "'use strict'\n\nconst Range = require('../classes/range')\nconst satisfies = (version, range, options) => {\n  try {\n    range = new Range(range, options)\n  } catch (er) {\n    return false\n  }\n  return range.test(version)\n}\nmodule.exports = satisfies\n",
    "'use strict'\n\nconst Range = require('../classes/range')\n\n// Mostly just for testing and legacy API reasons\nconst toComparators = (range, options) =>\n  new Range(range, options).set\n    .map(comp => comp.map(c => c.value).join(' ').trim().split(' '))\n\nmodule.exports = toComparators\n",
    "'use strict'\n\nconst SemVer = require('../classes/semver')\nconst Range = require('../classes/range')\n\nconst maxSatisfying = (versions, range, options) => {\n  let max = null\n  let maxSV = null\n  let rangeObj = null\n  try {\n    rangeObj = new Range(range, options)\n  } catch (er) {\n    return null\n  }\n  versions.forEach((v) => {\n    if (rangeObj.test(v)) {\n      // satisfies(v, range, options)\n      if (!max || maxSV.compare(v) === -1) {\n        // compare(max, v, true)\n        max = v\n        maxSV = new SemVer(max, options)\n      }\n    }\n  })\n  return max\n}\nmodule.exports = maxSatisfying\n",
    "'use strict'\n\nconst SemVer = require('../classes/semver')\nconst Range = require('../classes/range')\nconst minSatisfying = (versions, range, options) => {\n  let min = null\n  let minSV = null\n  let rangeObj = null\n  try {\n    rangeObj = new Range(range, options)\n  } catch (er) {\n    return null\n  }\n  versions.forEach((v) => {\n    if (rangeObj.test(v)) {\n      // satisfies(v, range, options)\n      if (!min || minSV.compare(v) === 1) {\n        // compare(min, v, true)\n        min = v\n        minSV = new SemVer(min, options)\n      }\n    }\n  })\n  return min\n}\nmodule.exports = minSatisfying\n",
    "'use strict'\n\nconst SemVer = require('../classes/semver')\nconst Range = require('../classes/range')\nconst gt = require('../functions/gt')\n\nconst minVersion = (range, loose) => {\n  range = new Range(range, loose)\n\n  let minver = new SemVer('0.0.0')\n  if (range.test(minver)) {\n    return minver\n  }\n\n  minver = new SemVer('0.0.0-0')\n  if (range.test(minver)) {\n    return minver\n  }\n\n  minver = null\n  for (let i = 0; i < range.set.length; ++i) {\n    const comparators = range.set[i]\n\n    let setMin = null\n    comparators.forEach((comparator) => {\n      // Clone to avoid manipulating the comparator's semver object.\n      const compver = new SemVer(comparator.semver.version)\n      switch (comparator.operator) {\n        case '>':\n          if (compver.prerelease.length === 0) {\n            compver.patch++\n          } else {\n            compver.prerelease.push(0)\n          }\n          compver.raw = compver.format()\n          /* fallthrough */\n        case '':\n        case '>=':\n          if (!setMin || gt(compver, setMin)) {\n            setMin = compver\n          }\n          break\n        case '<':\n        case '<=':\n          /* Ignore maximum versions */\n          break\n        /* istanbul ignore next */\n        default:\n          throw new Error(`Unexpected operation: ${comparator.operator}`)\n      }\n    })\n    if (setMin && (!minver || gt(minver, setMin))) {\n      minver = setMin\n    }\n  }\n\n  if (minver && range.test(minver)) {\n    return minver\n  }\n\n  return null\n}\nmodule.exports = minVersion\n",
    "'use strict'\n\nconst Range = require('../classes/range')\nconst validRange = (range, options) => {\n  try {\n    // Return '*' instead of '' so that truthiness works.\n    // This will throw if it's invalid anyway\n    return new Range(range, options).range || '*'\n  } catch (er) {\n    return null\n  }\n}\nmodule.exports = validRange\n",
    "'use strict'\n\nconst SemVer = require('../classes/semver')\nconst Comparator = require('../classes/comparator')\nconst { ANY } = Comparator\nconst Range = require('../classes/range')\nconst satisfies = require('../functions/satisfies')\nconst gt = require('../functions/gt')\nconst lt = require('../functions/lt')\nconst lte = require('../functions/lte')\nconst gte = require('../functions/gte')\n\nconst outside = (version, range, hilo, options) => {\n  version = new SemVer(version, options)\n  range = new Range(range, options)\n\n  let gtfn, ltefn, ltfn, comp, ecomp\n  switch (hilo) {\n    case '>':\n      gtfn = gt\n      ltefn = lte\n      ltfn = lt\n      comp = '>'\n      ecomp = '>='\n      break\n    case '<':\n      gtfn = lt\n      ltefn = gte\n      ltfn = gt\n      comp = '<'\n      ecomp = '<='\n      break\n    default:\n      throw new TypeError('Must provide a hilo val of \"<\" or \">\"')\n  }\n\n  // If it satisfies the range it is not outside\n  if (satisfies(version, range, options)) {\n    return false\n  }\n\n  // From now on, variable terms are as if we're in \"gtr\" mode.\n  // but note that everything is flipped for the \"ltr\" function.\n\n  for (let i = 0; i < range.set.length; ++i) {\n    const comparators = range.set[i]\n\n    let high = null\n    let low = null\n\n    comparators.forEach((comparator) => {\n      if (comparator.semver === ANY) {\n        comparator = new Comparator('>=0.0.0')\n      }\n      high = high || comparator\n      low = low || comparator\n      if (gtfn(comparator.semver, high.semver, options)) {\n        high = comparator\n      } else if (ltfn(comparator.semver, low.semver, options)) {\n        low = comparator\n      }\n    })\n\n    // If the edge version comparator has a operator then our version\n    // isn't outside it\n    if (high.operator === comp || high.operator === ecomp) {\n      return false\n    }\n\n    // If the lowest version comparator has an operator and our version\n    // is less than it then it isn't higher than the range\n    if ((!low.operator || low.operator === comp) &&\n        ltefn(version, low.semver)) {\n      return false\n    } else if (low.operator === ecomp && ltfn(version, low.semver)) {\n      return false\n    }\n  }\n  return true\n}\n\nmodule.exports = outside\n",
    "'use strict'\n\n// Determine if version is greater than all the versions possible in the range.\nconst outside = require('./outside')\nconst gtr = (version, range, options) => outside(version, range, '>', options)\nmodule.exports = gtr\n",
    "'use strict'\n\nconst outside = require('./outside')\n// Determine if version is less than all the versions possible in the range\nconst ltr = (version, range, options) => outside(version, range, '<', options)\nmodule.exports = ltr\n",
    "'use strict'\n\nconst Range = require('../classes/range')\nconst intersects = (r1, r2, options) => {\n  r1 = new Range(r1, options)\n  r2 = new Range(r2, options)\n  return r1.intersects(r2, options)\n}\nmodule.exports = intersects\n",
    "'use strict'\n\n// given a set of versions and a range, create a \"simplified\" range\n// that includes the same versions that the original range does\n// If the original range is shorter than the simplified one, return that.\nconst satisfies = require('../functions/satisfies.js')\nconst compare = require('../functions/compare.js')\nmodule.exports = (versions, range, options) => {\n  const set = []\n  let first = null\n  let prev = null\n  const v = versions.sort((a, b) => compare(a, b, options))\n  for (const version of v) {\n    const included = satisfies(version, range, options)\n    if (included) {\n      prev = version\n      if (!first) {\n        first = version\n      }\n    } else {\n      if (prev) {\n        set.push([first, prev])\n      }\n      prev = null\n      first = null\n    }\n  }\n  if (first) {\n    set.push([first, null])\n  }\n\n  const ranges = []\n  for (const [min, max] of set) {\n    if (min === max) {\n      ranges.push(min)\n    } else if (!max && min === v[0]) {\n      ranges.push('*')\n    } else if (!max) {\n      ranges.push(`>=${min}`)\n    } else if (min === v[0]) {\n      ranges.push(`<=${max}`)\n    } else {\n      ranges.push(`${min} - ${max}`)\n    }\n  }\n  const simplified = ranges.join(' || ')\n  const original = typeof range.raw === 'string' ? range.raw : String(range)\n  return simplified.length < original.length ? simplified : range\n}\n",
    "'use strict'\n\nconst Range = require('../classes/range.js')\nconst Comparator = require('../classes/comparator.js')\nconst { ANY } = Comparator\nconst satisfies = require('../functions/satisfies.js')\nconst compare = require('../functions/compare.js')\n\n// Complex range `r1 || r2 || ...` is a subset of `R1 || R2 || ...` iff:\n// - Every simple range `r1, r2, ...` is a null set, OR\n// - Every simple range `r1, r2, ...` which is not a null set is a subset of\n//   some `R1, R2, ...`\n//\n// Simple range `c1 c2 ...` is a subset of simple range `C1 C2 ...` iff:\n// - If c is only the ANY comparator\n//   - If C is only the ANY comparator, return true\n//   - Else if in prerelease mode, return false\n//   - else replace c with `[>=0.0.0]`\n// - If C is only the ANY comparator\n//   - if in prerelease mode, return true\n//   - else replace C with `[>=0.0.0]`\n// - Let EQ be the set of = comparators in c\n// - If EQ is more than one, return true (null set)\n// - Let GT be the highest > or >= comparator in c\n// - Let LT be the lowest < or <= comparator in c\n// - If GT and LT, and GT.semver > LT.semver, return true (null set)\n// - If any C is a = range, and GT or LT are set, return false\n// - If EQ\n//   - If GT, and EQ does not satisfy GT, return true (null set)\n//   - If LT, and EQ does not satisfy LT, return true (null set)\n//   - If EQ satisfies every C, return true\n//   - Else return false\n// - If GT\n//   - If GT.semver is lower than any > or >= comp in C, return false\n//   - If GT is >=, and GT.semver does not satisfy every C, return false\n//   - If GT.semver has a prerelease, and not in prerelease mode\n//     - If no C has a prerelease and the GT.semver tuple, return false\n// - If LT\n//   - If LT.semver is greater than any < or <= comp in C, return false\n//   - If LT is <=, and LT.semver does not satisfy every C, return false\n//   - If GT.semver has a prerelease, and not in prerelease mode\n//     - If no C has a prerelease and the LT.semver tuple, return false\n// - Else return true\n\nconst subset = (sub, dom, options = {}) => {\n  if (sub === dom) {\n    return true\n  }\n\n  sub = new Range(sub, options)\n  dom = new Range(dom, options)\n  let sawNonNull = false\n\n  OUTER: for (const simpleSub of sub.set) {\n    for (const simpleDom of dom.set) {\n      const isSub = simpleSubset(simpleSub, simpleDom, options)\n      sawNonNull = sawNonNull || isSub !== null\n      if (isSub) {\n        continue OUTER\n      }\n    }\n    // the null set is a subset of everything, but null simple ranges in\n    // a complex range should be ignored.  so if we saw a non-null range,\n    // then we know this isn't a subset, but if EVERY simple range was null,\n    // then it is a subset.\n    if (sawNonNull) {\n      return false\n    }\n  }\n  return true\n}\n\nconst minimumVersionWithPreRelease = [new Comparator('>=0.0.0-0')]\nconst minimumVersion = [new Comparator('>=0.0.0')]\n\nconst simpleSubset = (sub, dom, options) => {\n  if (sub === dom) {\n    return true\n  }\n\n  if (sub.length === 1 && sub[0].semver === ANY) {\n    if (dom.length === 1 && dom[0].semver === ANY) {\n      return true\n    } else if (options.includePrerelease) {\n      sub = minimumVersionWithPreRelease\n    } else {\n      sub = minimumVersion\n    }\n  }\n\n  if (dom.length === 1 && dom[0].semver === ANY) {\n    if (options.includePrerelease) {\n      return true\n    } else {\n      dom = minimumVersion\n    }\n  }\n\n  const eqSet = new Set()\n  let gt, lt\n  for (const c of sub) {\n    if (c.operator === '>' || c.operator === '>=') {\n      gt = higherGT(gt, c, options)\n    } else if (c.operator === '<' || c.operator === '<=') {\n      lt = lowerLT(lt, c, options)\n    } else {\n      eqSet.add(c.semver)\n    }\n  }\n\n  if (eqSet.size > 1) {\n    return null\n  }\n\n  let gtltComp\n  if (gt && lt) {\n    gtltComp = compare(gt.semver, lt.semver, options)\n    if (gtltComp > 0) {\n      return null\n    } else if (gtltComp === 0 && (gt.operator !== '>=' || lt.operator !== '<=')) {\n      return null\n    }\n  }\n\n  // will iterate one or zero times\n  for (const eq of eqSet) {\n    if (gt && !satisfies(eq, String(gt), options)) {\n      return null\n    }\n\n    if (lt && !satisfies(eq, String(lt), options)) {\n      return null\n    }\n\n    for (const c of dom) {\n      if (!satisfies(eq, String(c), options)) {\n        return false\n      }\n    }\n\n    return true\n  }\n\n  let higher, lower\n  let hasDomLT, hasDomGT\n  // if the subset has a prerelease, we need a comparator in the superset\n  // with the same tuple and a prerelease, or it's not a subset\n  let needDomLTPre = lt &&\n    !options.includePrerelease &&\n    lt.semver.prerelease.length ? lt.semver : false\n  let needDomGTPre = gt &&\n    !options.includePrerelease &&\n    gt.semver.prerelease.length ? gt.semver : false\n  // exception: <1.2.3-0 is the same as <1.2.3\n  if (needDomLTPre && needDomLTPre.prerelease.length === 1 &&\n      lt.operator === '<' && needDomLTPre.prerelease[0] === 0) {\n    needDomLTPre = false\n  }\n\n  for (const c of dom) {\n    hasDomGT = hasDomGT || c.operator === '>' || c.operator === '>='\n    hasDomLT = hasDomLT || c.operator === '<' || c.operator === '<='\n    if (gt) {\n      if (needDomGTPre) {\n        if (c.semver.prerelease && c.semver.prerelease.length &&\n            c.semver.major === needDomGTPre.major &&\n            c.semver.minor === needDomGTPre.minor &&\n            c.semver.patch === needDomGTPre.patch) {\n          needDomGTPre = false\n        }\n      }\n      if (c.operator === '>' || c.operator === '>=') {\n        higher = higherGT(gt, c, options)\n        if (higher === c && higher !== gt) {\n          return false\n        }\n      } else if (gt.operator === '>=' && !satisfies(gt.semver, String(c), options)) {\n        return false\n      }\n    }\n    if (lt) {\n      if (needDomLTPre) {\n        if (c.semver.prerelease && c.semver.prerelease.length &&\n            c.semver.major === needDomLTPre.major &&\n            c.semver.minor === needDomLTPre.minor &&\n            c.semver.patch === needDomLTPre.patch) {\n          needDomLTPre = false\n        }\n      }\n      if (c.operator === '<' || c.operator === '<=') {\n        lower = lowerLT(lt, c, options)\n        if (lower === c && lower !== lt) {\n          return false\n        }\n      } else if (lt.operator === '<=' && !satisfies(lt.semver, String(c), options)) {\n        return false\n      }\n    }\n    if (!c.operator && (lt || gt) && gtltComp !== 0) {\n      return false\n    }\n  }\n\n  // if there was a < or >, and nothing in the dom, then must be false\n  // UNLESS it was limited by another range in the other direction.\n  // Eg, >1.0.0 <1.0.1 is still a subset of <2.0.0\n  if (gt && hasDomLT && !lt && gtltComp !== 0) {\n    return false\n  }\n\n  if (lt && hasDomGT && !gt && gtltComp !== 0) {\n    return false\n  }\n\n  // we needed a prerelease range in a specific tuple, but didn't get one\n  // then this isn't a subset.  eg >=1.2.3-pre is not a subset of >=1.0.0,\n  // because it includes prereleases in the 1.2.3 tuple\n  if (needDomGTPre || needDomLTPre) {\n    return false\n  }\n\n  return true\n}\n\n// >=1.2.3 is lower than >1.2.3\nconst higherGT = (a, b, options) => {\n  if (!a) {\n    return b\n  }\n  const comp = compare(a.semver, b.semver, options)\n  return comp > 0 ? a\n    : comp < 0 ? b\n    : b.operator === '>' && a.operator === '>=' ? b\n    : a\n}\n\n// <=1.2.3 is higher than <1.2.3\nconst lowerLT = (a, b, options) => {\n  if (!a) {\n    return b\n  }\n  const comp = compare(a.semver, b.semver, options)\n  return comp < 0 ? a\n    : comp > 0 ? b\n    : b.operator === '<' && a.operator === '<=' ? b\n    : a\n}\n\nmodule.exports = subset\n",
    "'use strict'\n\n// just pre-load all the stuff that index.js lazily exports\nconst internalRe = require('./internal/re')\nconst constants = require('./internal/constants')\nconst SemVer = require('./classes/semver')\nconst identifiers = require('./internal/identifiers')\nconst parse = require('./functions/parse')\nconst valid = require('./functions/valid')\nconst clean = require('./functions/clean')\nconst inc = require('./functions/inc')\nconst diff = require('./functions/diff')\nconst major = require('./functions/major')\nconst minor = require('./functions/minor')\nconst patch = require('./functions/patch')\nconst prerelease = require('./functions/prerelease')\nconst compare = require('./functions/compare')\nconst rcompare = require('./functions/rcompare')\nconst compareLoose = require('./functions/compare-loose')\nconst compareBuild = require('./functions/compare-build')\nconst sort = require('./functions/sort')\nconst rsort = require('./functions/rsort')\nconst gt = require('./functions/gt')\nconst lt = require('./functions/lt')\nconst eq = require('./functions/eq')\nconst neq = require('./functions/neq')\nconst gte = require('./functions/gte')\nconst lte = require('./functions/lte')\nconst cmp = require('./functions/cmp')\nconst coerce = require('./functions/coerce')\nconst Comparator = require('./classes/comparator')\nconst Range = require('./classes/range')\nconst satisfies = require('./functions/satisfies')\nconst toComparators = require('./ranges/to-comparators')\nconst maxSatisfying = require('./ranges/max-satisfying')\nconst minSatisfying = require('./ranges/min-satisfying')\nconst minVersion = require('./ranges/min-version')\nconst validRange = require('./ranges/valid')\nconst outside = require('./ranges/outside')\nconst gtr = require('./ranges/gtr')\nconst ltr = require('./ranges/ltr')\nconst intersects = require('./ranges/intersects')\nconst simplifyRange = require('./ranges/simplify')\nconst subset = require('./ranges/subset')\nmodule.exports = {\n  parse,\n  valid,\n  clean,\n  inc,\n  diff,\n  major,\n  minor,\n  patch,\n  prerelease,\n  compare,\n  rcompare,\n  compareLoose,\n  compareBuild,\n  sort,\n  rsort,\n  gt,\n  lt,\n  eq,\n  neq,\n  gte,\n  lte,\n  cmp,\n  coerce,\n  Comparator,\n  Range,\n  satisfies,\n  toComparators,\n  maxSatisfying,\n  minSatisfying,\n  minVersion,\n  validRange,\n  outside,\n  gtr,\n  ltr,\n  intersects,\n  simplifyRange,\n  subset,\n  SemVer,\n  re: internalRe.re,\n  src: internalRe.src,\n  tokens: internalRe.t,\n  SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION,\n  RELEASE_TYPES: constants.RELEASE_TYPES,\n  compareIdentifiers: identifiers.compareIdentifiers,\n  rcompareIdentifiers: identifiers.rcompareIdentifiers,\n}\n",
    "const semver = require('semver');\n\nmodule.exports = semver.satisfies(process.version, '>=15.7.0');\n",
    "const semver = require('semver');\n\nmodule.exports = semver.satisfies(process.version, '>=16.9.0');\n",
    "const ASYMMETRIC_KEY_DETAILS_SUPPORTED = require('./asymmetricKeyDetailsSupported');\nconst RSA_PSS_KEY_DETAILS_SUPPORTED = require('./rsaPssKeyDetailsSupported');\n\nconst allowedAlgorithmsForKeys = {\n  'ec': ['ES256', 'ES384', 'ES512'],\n  'rsa': ['RS256', 'PS256', 'RS384', 'PS384', 'RS512', 'PS512'],\n  'rsa-pss': ['PS256', 'PS384', 'PS512']\n};\n\nconst allowedCurves = {\n  ES256: 'prime256v1',\n  ES384: 'secp384r1',\n  ES512: 'secp521r1',\n};\n\nmodule.exports = function(algorithm, key) {\n  if (!algorithm || !key) return;\n\n  const keyType = key.asymmetricKeyType;\n  if (!keyType) return;\n\n  const allowedAlgorithms = allowedAlgorithmsForKeys[keyType];\n\n  if (!allowedAlgorithms) {\n    throw new Error(`Unknown key type \"${keyType}\".`);\n  }\n\n  if (!allowedAlgorithms.includes(algorithm)) {\n    throw new Error(`\"alg\" parameter for \"${keyType}\" key type must be one of: ${allowedAlgorithms.join(', ')}.`)\n  }\n\n  /*\n   * Ignore the next block from test coverage because it gets executed\n   * conditionally depending on the Node version. Not ignoring it would\n   * prevent us from reaching the target % of coverage for versions of\n   * Node under 15.7.0.\n   */\n  /* istanbul ignore next */\n  if (ASYMMETRIC_KEY_DETAILS_SUPPORTED) {\n    switch (keyType) {\n    case 'ec':\n      const keyCurve = key.asymmetricKeyDetails.namedCurve;\n      const allowedCurve = allowedCurves[algorithm];\n\n      if (keyCurve !== allowedCurve) {\n        throw new Error(`\"alg\" parameter \"${algorithm}\" requires curve \"${allowedCurve}\".`);\n      }\n      break;\n\n    case 'rsa-pss':\n      if (RSA_PSS_KEY_DETAILS_SUPPORTED) {\n        const length = parseInt(algorithm.slice(-3), 10);\n        const { hashAlgorithm, mgf1HashAlgorithm, saltLength } = key.asymmetricKeyDetails;\n\n        if (hashAlgorithm !== `sha${length}` || mgf1HashAlgorithm !== hashAlgorithm) {\n          throw new Error(`Invalid key for this operation, its RSA-PSS parameters do not meet the requirements of \"alg\" ${algorithm}.`);\n        }\n\n        if (saltLength !== undefined && saltLength > length >> 3) {\n          throw new Error(`Invalid key for this operation, its RSA-PSS parameter saltLength does not meet the requirements of \"alg\" ${algorithm}.`)\n        }\n      }\n      break;\n    }\n  }\n}\n",
    "var semver = require('semver');\n\nmodule.exports = semver.satisfies(process.version, '^6.12.0 || >=8.0.0');\n",
    "const JsonWebTokenError = require('./lib/JsonWebTokenError');\nconst NotBeforeError = require('./lib/NotBeforeError');\nconst TokenExpiredError = require('./lib/TokenExpiredError');\nconst decode = require('./decode');\nconst timespan = require('./lib/timespan');\nconst validateAsymmetricKey = require('./lib/validateAsymmetricKey');\nconst PS_SUPPORTED = require('./lib/psSupported');\nconst jws = require('jws');\nconst {KeyObject, createSecretKey, createPublicKey} = require(\"crypto\");\n\nconst PUB_KEY_ALGS = ['RS256', 'RS384', 'RS512'];\nconst EC_KEY_ALGS = ['ES256', 'ES384', 'ES512'];\nconst RSA_KEY_ALGS = ['RS256', 'RS384', 'RS512'];\nconst HS_ALGS = ['HS256', 'HS384', 'HS512'];\n\nif (PS_SUPPORTED) {\n  PUB_KEY_ALGS.splice(PUB_KEY_ALGS.length, 0, 'PS256', 'PS384', 'PS512');\n  RSA_KEY_ALGS.splice(RSA_KEY_ALGS.length, 0, 'PS256', 'PS384', 'PS512');\n}\n\nmodule.exports = function (jwtString, secretOrPublicKey, options, callback) {\n  if ((typeof options === 'function') && !callback) {\n    callback = options;\n    options = {};\n  }\n\n  if (!options) {\n    options = {};\n  }\n\n  //clone this object since we are going to mutate it.\n  options = Object.assign({}, options);\n\n  let done;\n\n  if (callback) {\n    done = callback;\n  } else {\n    done = function(err, data) {\n      if (err) throw err;\n      return data;\n    };\n  }\n\n  if (options.clockTimestamp && typeof options.clockTimestamp !== 'number') {\n    return done(new JsonWebTokenError('clockTimestamp must be a number'));\n  }\n\n  if (options.nonce !== undefined && (typeof options.nonce !== 'string' || options.nonce.trim() === '')) {\n    return done(new JsonWebTokenError('nonce must be a non-empty string'));\n  }\n\n  if (options.allowInvalidAsymmetricKeyTypes !== undefined && typeof options.allowInvalidAsymmetricKeyTypes !== 'boolean') {\n    return done(new JsonWebTokenError('allowInvalidAsymmetricKeyTypes must be a boolean'));\n  }\n\n  const clockTimestamp = options.clockTimestamp || Math.floor(Date.now() / 1000);\n\n  if (!jwtString){\n    return done(new JsonWebTokenError('jwt must be provided'));\n  }\n\n  if (typeof jwtString !== 'string') {\n    return done(new JsonWebTokenError('jwt must be a string'));\n  }\n\n  const parts = jwtString.split('.');\n\n  if (parts.length !== 3){\n    return done(new JsonWebTokenError('jwt malformed'));\n  }\n\n  let decodedToken;\n\n  try {\n    decodedToken = decode(jwtString, { complete: true });\n  } catch(err) {\n    return done(err);\n  }\n\n  if (!decodedToken) {\n    return done(new JsonWebTokenError('invalid token'));\n  }\n\n  const header = decodedToken.header;\n  let getSecret;\n\n  if(typeof secretOrPublicKey === 'function') {\n    if(!callback) {\n      return done(new JsonWebTokenError('verify must be called asynchronous if secret or public key is provided as a callback'));\n    }\n\n    getSecret = secretOrPublicKey;\n  }\n  else {\n    getSecret = function(header, secretCallback) {\n      return secretCallback(null, secretOrPublicKey);\n    };\n  }\n\n  return getSecret(header, function(err, secretOrPublicKey) {\n    if(err) {\n      return done(new JsonWebTokenError('error in secret or public key callback: ' + err.message));\n    }\n\n    const hasSignature = parts[2].trim() !== '';\n\n    if (!hasSignature && secretOrPublicKey){\n      return done(new JsonWebTokenError('jwt signature is required'));\n    }\n\n    if (hasSignature && !secretOrPublicKey) {\n      return done(new JsonWebTokenError('secret or public key must be provided'));\n    }\n\n    if (!hasSignature && !options.algorithms) {\n      return done(new JsonWebTokenError('please specify \"none\" in \"algorithms\" to verify unsigned tokens'));\n    }\n\n    if (secretOrPublicKey != null && !(secretOrPublicKey instanceof KeyObject)) {\n      try {\n        secretOrPublicKey = createPublicKey(secretOrPublicKey);\n      } catch (_) {\n        try {\n          secretOrPublicKey = createSecretKey(typeof secretOrPublicKey === 'string' ? Buffer.from(secretOrPublicKey) : secretOrPublicKey);\n        } catch (_) {\n          return done(new JsonWebTokenError('secretOrPublicKey is not valid key material'))\n        }\n      }\n    }\n\n    if (!options.algorithms) {\n      if (secretOrPublicKey.type === 'secret') {\n        options.algorithms = HS_ALGS;\n      } else if (['rsa', 'rsa-pss'].includes(secretOrPublicKey.asymmetricKeyType)) {\n        options.algorithms = RSA_KEY_ALGS\n      } else if (secretOrPublicKey.asymmetricKeyType === 'ec') {\n        options.algorithms = EC_KEY_ALGS\n      } else {\n        options.algorithms = PUB_KEY_ALGS\n      }\n    }\n\n    if (options.algorithms.indexOf(decodedToken.header.alg) === -1) {\n      return done(new JsonWebTokenError('invalid algorithm'));\n    }\n\n    if (header.alg.startsWith('HS') && secretOrPublicKey.type !== 'secret') {\n      return done(new JsonWebTokenError((`secretOrPublicKey must be a symmetric key when using ${header.alg}`)))\n    } else if (/^(?:RS|PS|ES)/.test(header.alg) && secretOrPublicKey.type !== 'public') {\n      return done(new JsonWebTokenError((`secretOrPublicKey must be an asymmetric key when using ${header.alg}`)))\n    }\n\n    if (!options.allowInvalidAsymmetricKeyTypes) {\n      try {\n        validateAsymmetricKey(header.alg, secretOrPublicKey);\n      } catch (e) {\n        return done(e);\n      }\n    }\n\n    let valid;\n\n    try {\n      valid = jws.verify(jwtString, decodedToken.header.alg, secretOrPublicKey);\n    } catch (e) {\n      return done(e);\n    }\n\n    if (!valid) {\n      return done(new JsonWebTokenError('invalid signature'));\n    }\n\n    const payload = decodedToken.payload;\n\n    if (typeof payload.nbf !== 'undefined' && !options.ignoreNotBefore) {\n      if (typeof payload.nbf !== 'number') {\n        return done(new JsonWebTokenError('invalid nbf value'));\n      }\n      if (payload.nbf > clockTimestamp + (options.clockTolerance || 0)) {\n        return done(new NotBeforeError('jwt not active', new Date(payload.nbf * 1000)));\n      }\n    }\n\n    if (typeof payload.exp !== 'undefined' && !options.ignoreExpiration) {\n      if (typeof payload.exp !== 'number') {\n        return done(new JsonWebTokenError('invalid exp value'));\n      }\n      if (clockTimestamp >= payload.exp + (options.clockTolerance || 0)) {\n        return done(new TokenExpiredError('jwt expired', new Date(payload.exp * 1000)));\n      }\n    }\n\n    if (options.audience) {\n      const audiences = Array.isArray(options.audience) ? options.audience : [options.audience];\n      const target = Array.isArray(payload.aud) ? payload.aud : [payload.aud];\n\n      const match = target.some(function (targetAudience) {\n        return audiences.some(function (audience) {\n          return audience instanceof RegExp ? audience.test(targetAudience) : audience === targetAudience;\n        });\n      });\n\n      if (!match) {\n        return done(new JsonWebTokenError('jwt audience invalid. expected: ' + audiences.join(' or ')));\n      }\n    }\n\n    if (options.issuer) {\n      const invalid_issuer =\n              (typeof options.issuer === 'string' && payload.iss !== options.issuer) ||\n              (Array.isArray(options.issuer) && options.issuer.indexOf(payload.iss) === -1);\n\n      if (invalid_issuer) {\n        return done(new JsonWebTokenError('jwt issuer invalid. expected: ' + options.issuer));\n      }\n    }\n\n    if (options.subject) {\n      if (payload.sub !== options.subject) {\n        return done(new JsonWebTokenError('jwt subject invalid. expected: ' + options.subject));\n      }\n    }\n\n    if (options.jwtid) {\n      if (payload.jti !== options.jwtid) {\n        return done(new JsonWebTokenError('jwt jwtid invalid. expected: ' + options.jwtid));\n      }\n    }\n\n    if (options.nonce) {\n      if (payload.nonce !== options.nonce) {\n        return done(new JsonWebTokenError('jwt nonce invalid. expected: ' + options.nonce));\n      }\n    }\n\n    if (options.maxAge) {\n      if (typeof payload.iat !== 'number') {\n        return done(new JsonWebTokenError('iat required when maxAge is specified'));\n      }\n\n      const maxAgeTimestamp = timespan(options.maxAge, payload.iat);\n      if (typeof maxAgeTimestamp === 'undefined') {\n        return done(new JsonWebTokenError('\"maxAge\" should be a number of seconds or string representing a timespan eg: \"1d\", \"20h\", 60'));\n      }\n      if (clockTimestamp >= maxAgeTimestamp + (options.clockTolerance || 0)) {\n        return done(new TokenExpiredError('maxAge exceeded', new Date(maxAgeTimestamp * 1000)));\n      }\n    }\n\n    if (options.complete === true) {\n      const signature = decodedToken.signature;\n\n      return done(null, {\n        header: header,\n        payload: payload,\n        signature: signature\n      });\n    }\n\n    return done(null, payload);\n  });\n};\n",
    "/**\n * lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors <https://jquery.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Used as references for various `Number` constants. */\nvar INFINITY = 1 / 0,\n    MAX_SAFE_INTEGER = 9007199254740991,\n    MAX_INTEGER = 1.7976931348623157e+308,\n    NAN = 0 / 0;\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n    funcTag = '[object Function]',\n    genTag = '[object GeneratorFunction]',\n    stringTag = '[object String]',\n    symbolTag = '[object Symbol]';\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\n\n/** Used to detect bad signed hexadecimal string values. */\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n/** Used to detect binary string values. */\nvar reIsBinary = /^0b[01]+$/i;\n\n/** Used to detect octal string values. */\nvar reIsOctal = /^0o[0-7]+$/i;\n\n/** Used to detect unsigned integer values. */\nvar reIsUint = /^(?:0|[1-9]\\d*)$/;\n\n/** Built-in method references without a dependency on `root`. */\nvar freeParseInt = parseInt;\n\n/**\n * A specialized version of `_.map` for arrays without support for iteratee\n * shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the new mapped array.\n */\nfunction arrayMap(array, iteratee) {\n  var index = -1,\n      length = array ? array.length : 0,\n      result = Array(length);\n\n  while (++index < length) {\n    result[index] = iteratee(array[index], index, array);\n  }\n  return result;\n}\n\n/**\n * The base implementation of `_.findIndex` and `_.findLastIndex` without\n * support for iteratee shorthands.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {Function} predicate The function invoked per iteration.\n * @param {number} fromIndex The index to search from.\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\nfunction baseFindIndex(array, predicate, fromIndex, fromRight) {\n  var length = array.length,\n      index = fromIndex + (fromRight ? 1 : -1);\n\n  while ((fromRight ? index-- : ++index < length)) {\n    if (predicate(array[index], index, array)) {\n      return index;\n    }\n  }\n  return -1;\n}\n\n/**\n * The base implementation of `_.indexOf` without `fromIndex` bounds checks.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} value The value to search for.\n * @param {number} fromIndex The index to search from.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\nfunction baseIndexOf(array, value, fromIndex) {\n  if (value !== value) {\n    return baseFindIndex(array, baseIsNaN, fromIndex);\n  }\n  var index = fromIndex - 1,\n      length = array.length;\n\n  while (++index < length) {\n    if (array[index] === value) {\n      return index;\n    }\n  }\n  return -1;\n}\n\n/**\n * The base implementation of `_.isNaN` without support for number objects.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.\n */\nfunction baseIsNaN(value) {\n  return value !== value;\n}\n\n/**\n * The base implementation of `_.times` without support for iteratee shorthands\n * or max array length checks.\n *\n * @private\n * @param {number} n The number of times to invoke `iteratee`.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the array of results.\n */\nfunction baseTimes(n, iteratee) {\n  var index = -1,\n      result = Array(n);\n\n  while (++index < n) {\n    result[index] = iteratee(index);\n  }\n  return result;\n}\n\n/**\n * The base implementation of `_.values` and `_.valuesIn` which creates an\n * array of `object` property values corresponding to the property names\n * of `props`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Array} props The property names to get values for.\n * @returns {Object} Returns the array of property values.\n */\nfunction baseValues(object, props) {\n  return arrayMap(props, function(key) {\n    return object[key];\n  });\n}\n\n/**\n * Creates a unary function that invokes `func` with its argument transformed.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n */\nfunction overArg(func, transform) {\n  return function(arg) {\n    return func(transform(arg));\n  };\n}\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar propertyIsEnumerable = objectProto.propertyIsEnumerable;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeKeys = overArg(Object.keys, Object),\n    nativeMax = Math.max;\n\n/**\n * Creates an array of the enumerable property names of the array-like `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @param {boolean} inherited Specify returning inherited property names.\n * @returns {Array} Returns the array of property names.\n */\nfunction arrayLikeKeys(value, inherited) {\n  // Safari 8.1 makes `arguments.callee` enumerable in strict mode.\n  // Safari 9 makes `arguments.length` enumerable in strict mode.\n  var result = (isArray(value) || isArguments(value))\n    ? baseTimes(value.length, String)\n    : [];\n\n  var length = result.length,\n      skipIndexes = !!length;\n\n  for (var key in value) {\n    if ((inherited || hasOwnProperty.call(value, key)) &&\n        !(skipIndexes && (key == 'length' || isIndex(key, length)))) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\n/**\n * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction baseKeys(object) {\n  if (!isPrototype(object)) {\n    return nativeKeys(object);\n  }\n  var result = [];\n  for (var key in Object(object)) {\n    if (hasOwnProperty.call(object, key) && key != 'constructor') {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\n/**\n * Checks if `value` is a valid array-like index.\n *\n * @private\n * @param {*} value The value to check.\n * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n */\nfunction isIndex(value, length) {\n  length = length == null ? MAX_SAFE_INTEGER : length;\n  return !!length &&\n    (typeof value == 'number' || reIsUint.test(value)) &&\n    (value > -1 && value % 1 == 0 && value < length);\n}\n\n/**\n * Checks if `value` is likely a prototype object.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n */\nfunction isPrototype(value) {\n  var Ctor = value && value.constructor,\n      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;\n\n  return value === proto;\n}\n\n/**\n * Checks if `value` is in `collection`. If `collection` is a string, it's\n * checked for a substring of `value`, otherwise\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * is used for equality comparisons. If `fromIndex` is negative, it's used as\n * the offset from the end of `collection`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object|string} collection The collection to inspect.\n * @param {*} value The value to search for.\n * @param {number} [fromIndex=0] The index to search from.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.\n * @returns {boolean} Returns `true` if `value` is found, else `false`.\n * @example\n *\n * _.includes([1, 2, 3], 1);\n * // => true\n *\n * _.includes([1, 2, 3], 1, 2);\n * // => false\n *\n * _.includes({ 'a': 1, 'b': 2 }, 1);\n * // => true\n *\n * _.includes('abcd', 'bc');\n * // => true\n */\nfunction includes(collection, value, fromIndex, guard) {\n  collection = isArrayLike(collection) ? collection : values(collection);\n  fromIndex = (fromIndex && !guard) ? toInteger(fromIndex) : 0;\n\n  var length = collection.length;\n  if (fromIndex < 0) {\n    fromIndex = nativeMax(length + fromIndex, 0);\n  }\n  return isString(collection)\n    ? (fromIndex <= length && collection.indexOf(value, fromIndex) > -1)\n    : (!!length && baseIndexOf(collection, value, fromIndex) > -1);\n}\n\n/**\n * Checks if `value` is likely an `arguments` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n *  else `false`.\n * @example\n *\n * _.isArguments(function() { return arguments; }());\n * // => true\n *\n * _.isArguments([1, 2, 3]);\n * // => false\n */\nfunction isArguments(value) {\n  // Safari 8.1 makes `arguments.callee` enumerable in strict mode.\n  return isArrayLikeObject(value) && hasOwnProperty.call(value, 'callee') &&\n    (!propertyIsEnumerable.call(value, 'callee') || objectToString.call(value) == argsTag);\n}\n\n/**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(document.body.children);\n * // => false\n *\n * _.isArray('abc');\n * // => false\n *\n * _.isArray(_.noop);\n * // => false\n */\nvar isArray = Array.isArray;\n\n/**\n * Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n *\n * _.isArrayLike([1, 2, 3]);\n * // => true\n *\n * _.isArrayLike(document.body.children);\n * // => true\n *\n * _.isArrayLike('abc');\n * // => true\n *\n * _.isArrayLike(_.noop);\n * // => false\n */\nfunction isArrayLike(value) {\n  return value != null && isLength(value.length) && !isFunction(value);\n}\n\n/**\n * This method is like `_.isArrayLike` except that it also checks if `value`\n * is an object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array-like object,\n *  else `false`.\n * @example\n *\n * _.isArrayLikeObject([1, 2, 3]);\n * // => true\n *\n * _.isArrayLikeObject(document.body.children);\n * // => true\n *\n * _.isArrayLikeObject('abc');\n * // => false\n *\n * _.isArrayLikeObject(_.noop);\n * // => false\n */\nfunction isArrayLikeObject(value) {\n  return isObjectLike(value) && isArrayLike(value);\n}\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n  // The use of `Object#toString` avoids issues with the `typeof` operator\n  // in Safari 8-9 which returns 'object' for typed array and other constructors.\n  var tag = isObject(value) ? objectToString.call(value) : '';\n  return tag == funcTag || tag == genTag;\n}\n\n/**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n *\n * _.isLength(3);\n * // => true\n *\n * _.isLength(Number.MIN_VALUE);\n * // => false\n *\n * _.isLength(Infinity);\n * // => false\n *\n * _.isLength('3');\n * // => false\n */\nfunction isLength(value) {\n  return typeof value == 'number' &&\n    value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return !!value && typeof value == 'object';\n}\n\n/**\n * Checks if `value` is classified as a `String` primitive or object.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a string, else `false`.\n * @example\n *\n * _.isString('abc');\n * // => true\n *\n * _.isString(1);\n * // => false\n */\nfunction isString(value) {\n  return typeof value == 'string' ||\n    (!isArray(value) && isObjectLike(value) && objectToString.call(value) == stringTag);\n}\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n  return typeof value == 'symbol' ||\n    (isObjectLike(value) && objectToString.call(value) == symbolTag);\n}\n\n/**\n * Converts `value` to a finite number.\n *\n * @static\n * @memberOf _\n * @since 4.12.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {number} Returns the converted number.\n * @example\n *\n * _.toFinite(3.2);\n * // => 3.2\n *\n * _.toFinite(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toFinite(Infinity);\n * // => 1.7976931348623157e+308\n *\n * _.toFinite('3.2');\n * // => 3.2\n */\nfunction toFinite(value) {\n  if (!value) {\n    return value === 0 ? value : 0;\n  }\n  value = toNumber(value);\n  if (value === INFINITY || value === -INFINITY) {\n    var sign = (value < 0 ? -1 : 1);\n    return sign * MAX_INTEGER;\n  }\n  return value === value ? value : 0;\n}\n\n/**\n * Converts `value` to an integer.\n *\n * **Note:** This method is loosely based on\n * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {number} Returns the converted integer.\n * @example\n *\n * _.toInteger(3.2);\n * // => 3\n *\n * _.toInteger(Number.MIN_VALUE);\n * // => 0\n *\n * _.toInteger(Infinity);\n * // => 1.7976931348623157e+308\n *\n * _.toInteger('3.2');\n * // => 3\n */\nfunction toInteger(value) {\n  var result = toFinite(value),\n      remainder = result % 1;\n\n  return result === result ? (remainder ? result - remainder : result) : 0;\n}\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\nfunction toNumber(value) {\n  if (typeof value == 'number') {\n    return value;\n  }\n  if (isSymbol(value)) {\n    return NAN;\n  }\n  if (isObject(value)) {\n    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n    value = isObject(other) ? (other + '') : other;\n  }\n  if (typeof value != 'string') {\n    return value === 0 ? value : +value;\n  }\n  value = value.replace(reTrim, '');\n  var isBinary = reIsBinary.test(value);\n  return (isBinary || reIsOctal.test(value))\n    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n    : (reIsBadHex.test(value) ? NAN : +value);\n}\n\n/**\n * Creates an array of the own enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects. See the\n * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * for more details.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keys(new Foo);\n * // => ['a', 'b'] (iteration order is not guaranteed)\n *\n * _.keys('hi');\n * // => ['0', '1']\n */\nfunction keys(object) {\n  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);\n}\n\n/**\n * Creates an array of the own enumerable string keyed property values of `object`.\n *\n * **Note:** Non-object values are coerced to objects.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property values.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.values(new Foo);\n * // => [1, 2] (iteration order is not guaranteed)\n *\n * _.values('hi');\n * // => ['h', 'i']\n */\nfunction values(object) {\n  return object ? baseValues(object, keys(object)) : [];\n}\n\nmodule.exports = includes;\n",
    "/**\n * lodash 3.0.3 (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright 2012-2016 The Dojo Foundation <http://dojofoundation.org/>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright 2009-2016 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n * Available under MIT license <https://lodash.com/license>\n */\n\n/** `Object#toString` result references. */\nvar boolTag = '[object Boolean]';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = objectProto.toString;\n\n/**\n * Checks if `value` is classified as a boolean primitive or object.\n *\n * @static\n * @memberOf _\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.\n * @example\n *\n * _.isBoolean(false);\n * // => true\n *\n * _.isBoolean(null);\n * // => false\n */\nfunction isBoolean(value) {\n  return value === true || value === false ||\n    (isObjectLike(value) && objectToString.call(value) == boolTag);\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return !!value && typeof value == 'object';\n}\n\nmodule.exports = isBoolean;\n",
    "/**\n * lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors <https://jquery.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Used as references for various `Number` constants. */\nvar INFINITY = 1 / 0,\n    MAX_INTEGER = 1.7976931348623157e+308,\n    NAN = 0 / 0;\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\n\n/** Used to detect bad signed hexadecimal string values. */\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n/** Used to detect binary string values. */\nvar reIsBinary = /^0b[01]+$/i;\n\n/** Used to detect octal string values. */\nvar reIsOctal = /^0o[0-7]+$/i;\n\n/** Built-in method references without a dependency on `root`. */\nvar freeParseInt = parseInt;\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = objectProto.toString;\n\n/**\n * Checks if `value` is an integer.\n *\n * **Note:** This method is based on\n * [`Number.isInteger`](https://mdn.io/Number/isInteger).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an integer, else `false`.\n * @example\n *\n * _.isInteger(3);\n * // => true\n *\n * _.isInteger(Number.MIN_VALUE);\n * // => false\n *\n * _.isInteger(Infinity);\n * // => false\n *\n * _.isInteger('3');\n * // => false\n */\nfunction isInteger(value) {\n  return typeof value == 'number' && value == toInteger(value);\n}\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return !!value && typeof value == 'object';\n}\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n  return typeof value == 'symbol' ||\n    (isObjectLike(value) && objectToString.call(value) == symbolTag);\n}\n\n/**\n * Converts `value` to a finite number.\n *\n * @static\n * @memberOf _\n * @since 4.12.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {number} Returns the converted number.\n * @example\n *\n * _.toFinite(3.2);\n * // => 3.2\n *\n * _.toFinite(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toFinite(Infinity);\n * // => 1.7976931348623157e+308\n *\n * _.toFinite('3.2');\n * // => 3.2\n */\nfunction toFinite(value) {\n  if (!value) {\n    return value === 0 ? value : 0;\n  }\n  value = toNumber(value);\n  if (value === INFINITY || value === -INFINITY) {\n    var sign = (value < 0 ? -1 : 1);\n    return sign * MAX_INTEGER;\n  }\n  return value === value ? value : 0;\n}\n\n/**\n * Converts `value` to an integer.\n *\n * **Note:** This method is loosely based on\n * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {number} Returns the converted integer.\n * @example\n *\n * _.toInteger(3.2);\n * // => 3\n *\n * _.toInteger(Number.MIN_VALUE);\n * // => 0\n *\n * _.toInteger(Infinity);\n * // => 1.7976931348623157e+308\n *\n * _.toInteger('3.2');\n * // => 3\n */\nfunction toInteger(value) {\n  var result = toFinite(value),\n      remainder = result % 1;\n\n  return result === result ? (remainder ? result - remainder : result) : 0;\n}\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\nfunction toNumber(value) {\n  if (typeof value == 'number') {\n    return value;\n  }\n  if (isSymbol(value)) {\n    return NAN;\n  }\n  if (isObject(value)) {\n    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n    value = isObject(other) ? (other + '') : other;\n  }\n  if (typeof value != 'string') {\n    return value === 0 ? value : +value;\n  }\n  value = value.replace(reTrim, '');\n  var isBinary = reIsBinary.test(value);\n  return (isBinary || reIsOctal.test(value))\n    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n    : (reIsBadHex.test(value) ? NAN : +value);\n}\n\nmodule.exports = isInteger;\n",
    "/**\n * lodash 3.0.3 (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright 2012-2016 The Dojo Foundation <http://dojofoundation.org/>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright 2009-2016 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n * Available under MIT license <https://lodash.com/license>\n */\n\n/** `Object#toString` result references. */\nvar numberTag = '[object Number]';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = objectProto.toString;\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return !!value && typeof value == 'object';\n}\n\n/**\n * Checks if `value` is classified as a `Number` primitive or object.\n *\n * **Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are classified\n * as numbers, use the `_.isFinite` method.\n *\n * @static\n * @memberOf _\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.\n * @example\n *\n * _.isNumber(3);\n * // => true\n *\n * _.isNumber(Number.MIN_VALUE);\n * // => true\n *\n * _.isNumber(Infinity);\n * // => true\n *\n * _.isNumber('3');\n * // => false\n */\nfunction isNumber(value) {\n  return typeof value == 'number' ||\n    (isObjectLike(value) && objectToString.call(value) == numberTag);\n}\n\nmodule.exports = isNumber;\n",
    "/**\n * lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors <https://jquery.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** `Object#toString` result references. */\nvar objectTag = '[object Object]';\n\n/**\n * Checks if `value` is a host object in IE < 9.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a host object, else `false`.\n */\nfunction isHostObject(value) {\n  // Many host objects are `Object` objects that can coerce to strings\n  // despite having improperly defined `toString` methods.\n  var result = false;\n  if (value != null && typeof value.toString != 'function') {\n    try {\n      result = !!(value + '');\n    } catch (e) {}\n  }\n  return result;\n}\n\n/**\n * Creates a unary function that invokes `func` with its argument transformed.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n */\nfunction overArg(func, transform) {\n  return function(arg) {\n    return func(transform(arg));\n  };\n}\n\n/** Used for built-in method references. */\nvar funcProto = Function.prototype,\n    objectProto = Object.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Used to infer the `Object` constructor. */\nvar objectCtorString = funcToString.call(Object);\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar getPrototype = overArg(Object.getPrototypeOf, Object);\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return !!value && typeof value == 'object';\n}\n\n/**\n * Checks if `value` is a plain object, that is, an object created by the\n * `Object` constructor or one with a `[[Prototype]]` of `null`.\n *\n * @static\n * @memberOf _\n * @since 0.8.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n * }\n *\n * _.isPlainObject(new Foo);\n * // => false\n *\n * _.isPlainObject([1, 2, 3]);\n * // => false\n *\n * _.isPlainObject({ 'x': 0, 'y': 0 });\n * // => true\n *\n * _.isPlainObject(Object.create(null));\n * // => true\n */\nfunction isPlainObject(value) {\n  if (!isObjectLike(value) ||\n      objectToString.call(value) != objectTag || isHostObject(value)) {\n    return false;\n  }\n  var proto = getPrototype(value);\n  if (proto === null) {\n    return true;\n  }\n  var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;\n  return (typeof Ctor == 'function' &&\n    Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString);\n}\n\nmodule.exports = isPlainObject;\n",
    "/**\n * lodash 4.0.1 (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright 2012-2016 The Dojo Foundation <http://dojofoundation.org/>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright 2009-2016 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n * Available under MIT license <https://lodash.com/license>\n */\n\n/** `Object#toString` result references. */\nvar stringTag = '[object String]';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = objectProto.toString;\n\n/**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @type Function\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(document.body.children);\n * // => false\n *\n * _.isArray('abc');\n * // => false\n *\n * _.isArray(_.noop);\n * // => false\n */\nvar isArray = Array.isArray;\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return !!value && typeof value == 'object';\n}\n\n/**\n * Checks if `value` is classified as a `String` primitive or object.\n *\n * @static\n * @memberOf _\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.\n * @example\n *\n * _.isString('abc');\n * // => true\n *\n * _.isString(1);\n * // => false\n */\nfunction isString(value) {\n  return typeof value == 'string' ||\n    (!isArray(value) && isObjectLike(value) && objectToString.call(value) == stringTag);\n}\n\nmodule.exports = isString;\n",
    "/**\n * lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors <https://jquery.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Used as the `TypeError` message for \"Functions\" methods. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/** Used as references for various `Number` constants. */\nvar INFINITY = 1 / 0,\n    MAX_INTEGER = 1.7976931348623157e+308,\n    NAN = 0 / 0;\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\n\n/** Used to detect bad signed hexadecimal string values. */\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n/** Used to detect binary string values. */\nvar reIsBinary = /^0b[01]+$/i;\n\n/** Used to detect octal string values. */\nvar reIsOctal = /^0o[0-7]+$/i;\n\n/** Built-in method references without a dependency on `root`. */\nvar freeParseInt = parseInt;\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = objectProto.toString;\n\n/**\n * Creates a function that invokes `func`, with the `this` binding and arguments\n * of the created function, while it's called less than `n` times. Subsequent\n * calls to the created function return the result of the last `func` invocation.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Function\n * @param {number} n The number of calls at which `func` is no longer invoked.\n * @param {Function} func The function to restrict.\n * @returns {Function} Returns the new restricted function.\n * @example\n *\n * jQuery(element).on('click', _.before(5, addContactToList));\n * // => Allows adding up to 4 contacts to the list.\n */\nfunction before(n, func) {\n  var result;\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  n = toInteger(n);\n  return function() {\n    if (--n > 0) {\n      result = func.apply(this, arguments);\n    }\n    if (n <= 1) {\n      func = undefined;\n    }\n    return result;\n  };\n}\n\n/**\n * Creates a function that is restricted to invoking `func` once. Repeat calls\n * to the function return the value of the first invocation. The `func` is\n * invoked with the `this` binding and arguments of the created function.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to restrict.\n * @returns {Function} Returns the new restricted function.\n * @example\n *\n * var initialize = _.once(createApplication);\n * initialize();\n * initialize();\n * // => `createApplication` is invoked once\n */\nfunction once(func) {\n  return before(2, func);\n}\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return !!value && typeof value == 'object';\n}\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n  return typeof value == 'symbol' ||\n    (isObjectLike(value) && objectToString.call(value) == symbolTag);\n}\n\n/**\n * Converts `value` to a finite number.\n *\n * @static\n * @memberOf _\n * @since 4.12.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {number} Returns the converted number.\n * @example\n *\n * _.toFinite(3.2);\n * // => 3.2\n *\n * _.toFinite(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toFinite(Infinity);\n * // => 1.7976931348623157e+308\n *\n * _.toFinite('3.2');\n * // => 3.2\n */\nfunction toFinite(value) {\n  if (!value) {\n    return value === 0 ? value : 0;\n  }\n  value = toNumber(value);\n  if (value === INFINITY || value === -INFINITY) {\n    var sign = (value < 0 ? -1 : 1);\n    return sign * MAX_INTEGER;\n  }\n  return value === value ? value : 0;\n}\n\n/**\n * Converts `value` to an integer.\n *\n * **Note:** This method is loosely based on\n * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {number} Returns the converted integer.\n * @example\n *\n * _.toInteger(3.2);\n * // => 3\n *\n * _.toInteger(Number.MIN_VALUE);\n * // => 0\n *\n * _.toInteger(Infinity);\n * // => 1.7976931348623157e+308\n *\n * _.toInteger('3.2');\n * // => 3\n */\nfunction toInteger(value) {\n  var result = toFinite(value),\n      remainder = result % 1;\n\n  return result === result ? (remainder ? result - remainder : result) : 0;\n}\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\nfunction toNumber(value) {\n  if (typeof value == 'number') {\n    return value;\n  }\n  if (isSymbol(value)) {\n    return NAN;\n  }\n  if (isObject(value)) {\n    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n    value = isObject(other) ? (other + '') : other;\n  }\n  if (typeof value != 'string') {\n    return value === 0 ? value : +value;\n  }\n  value = value.replace(reTrim, '');\n  var isBinary = reIsBinary.test(value);\n  return (isBinary || reIsOctal.test(value))\n    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n    : (reIsBadHex.test(value) ? NAN : +value);\n}\n\nmodule.exports = once;\n",
    "const timespan = require('./lib/timespan');\nconst PS_SUPPORTED = require('./lib/psSupported');\nconst validateAsymmetricKey = require('./lib/validateAsymmetricKey');\nconst jws = require('jws');\nconst includes = require('lodash.includes');\nconst isBoolean = require('lodash.isboolean');\nconst isInteger = require('lodash.isinteger');\nconst isNumber = require('lodash.isnumber');\nconst isPlainObject = require('lodash.isplainobject');\nconst isString = require('lodash.isstring');\nconst once = require('lodash.once');\nconst { KeyObject, createSecretKey, createPrivateKey } = require('crypto')\n\nconst SUPPORTED_ALGS = ['RS256', 'RS384', 'RS512', 'ES256', 'ES384', 'ES512', 'HS256', 'HS384', 'HS512', 'none'];\nif (PS_SUPPORTED) {\n  SUPPORTED_ALGS.splice(3, 0, 'PS256', 'PS384', 'PS512');\n}\n\nconst sign_options_schema = {\n  expiresIn: { isValid: function(value) { return isInteger(value) || (isString(value) && value); }, message: '\"expiresIn\" should be a number of seconds or string representing a timespan' },\n  notBefore: { isValid: function(value) { return isInteger(value) || (isString(value) && value); }, message: '\"notBefore\" should be a number of seconds or string representing a timespan' },\n  audience: { isValid: function(value) { return isString(value) || Array.isArray(value); }, message: '\"audience\" must be a string or array' },\n  algorithm: { isValid: includes.bind(null, SUPPORTED_ALGS), message: '\"algorithm\" must be a valid string enum value' },\n  header: { isValid: isPlainObject, message: '\"header\" must be an object' },\n  encoding: { isValid: isString, message: '\"encoding\" must be a string' },\n  issuer: { isValid: isString, message: '\"issuer\" must be a string' },\n  subject: { isValid: isString, message: '\"subject\" must be a string' },\n  jwtid: { isValid: isString, message: '\"jwtid\" must be a string' },\n  noTimestamp: { isValid: isBoolean, message: '\"noTimestamp\" must be a boolean' },\n  keyid: { isValid: isString, message: '\"keyid\" must be a string' },\n  mutatePayload: { isValid: isBoolean, message: '\"mutatePayload\" must be a boolean' },\n  allowInsecureKeySizes: { isValid: isBoolean, message: '\"allowInsecureKeySizes\" must be a boolean'},\n  allowInvalidAsymmetricKeyTypes: { isValid: isBoolean, message: '\"allowInvalidAsymmetricKeyTypes\" must be a boolean'}\n};\n\nconst registered_claims_schema = {\n  iat: { isValid: isNumber, message: '\"iat\" should be a number of seconds' },\n  exp: { isValid: isNumber, message: '\"exp\" should be a number of seconds' },\n  nbf: { isValid: isNumber, message: '\"nbf\" should be a number of seconds' }\n};\n\nfunction validate(schema, allowUnknown, object, parameterName) {\n  if (!isPlainObject(object)) {\n    throw new Error('Expected \"' + parameterName + '\" to be a plain object.');\n  }\n  Object.keys(object)\n    .forEach(function(key) {\n      const validator = schema[key];\n      if (!validator) {\n        if (!allowUnknown) {\n          throw new Error('\"' + key + '\" is not allowed in \"' + parameterName + '\"');\n        }\n        return;\n      }\n      if (!validator.isValid(object[key])) {\n        throw new Error(validator.message);\n      }\n    });\n}\n\nfunction validateOptions(options) {\n  return validate(sign_options_schema, false, options, 'options');\n}\n\nfunction validatePayload(payload) {\n  return validate(registered_claims_schema, true, payload, 'payload');\n}\n\nconst options_to_payload = {\n  'audience': 'aud',\n  'issuer': 'iss',\n  'subject': 'sub',\n  'jwtid': 'jti'\n};\n\nconst options_for_objects = [\n  'expiresIn',\n  'notBefore',\n  'noTimestamp',\n  'audience',\n  'issuer',\n  'subject',\n  'jwtid',\n];\n\nmodule.exports = function (payload, secretOrPrivateKey, options, callback) {\n  if (typeof options === 'function') {\n    callback = options;\n    options = {};\n  } else {\n    options = options || {};\n  }\n\n  const isObjectPayload = typeof payload === 'object' &&\n                        !Buffer.isBuffer(payload);\n\n  const header = Object.assign({\n    alg: options.algorithm || 'HS256',\n    typ: isObjectPayload ? 'JWT' : undefined,\n    kid: options.keyid\n  }, options.header);\n\n  function failure(err) {\n    if (callback) {\n      return callback(err);\n    }\n    throw err;\n  }\n\n  if (!secretOrPrivateKey && options.algorithm !== 'none') {\n    return failure(new Error('secretOrPrivateKey must have a value'));\n  }\n\n  if (secretOrPrivateKey != null && !(secretOrPrivateKey instanceof KeyObject)) {\n    try {\n      secretOrPrivateKey = createPrivateKey(secretOrPrivateKey)\n    } catch (_) {\n      try {\n        secretOrPrivateKey = createSecretKey(typeof secretOrPrivateKey === 'string' ? Buffer.from(secretOrPrivateKey) : secretOrPrivateKey)\n      } catch (_) {\n        return failure(new Error('secretOrPrivateKey is not valid key material'));\n      }\n    }\n  }\n\n  if (header.alg.startsWith('HS') && secretOrPrivateKey.type !== 'secret') {\n    return failure(new Error((`secretOrPrivateKey must be a symmetric key when using ${header.alg}`)))\n  } else if (/^(?:RS|PS|ES)/.test(header.alg)) {\n    if (secretOrPrivateKey.type !== 'private') {\n      return failure(new Error((`secretOrPrivateKey must be an asymmetric key when using ${header.alg}`)))\n    }\n    if (!options.allowInsecureKeySizes &&\n      !header.alg.startsWith('ES') &&\n      secretOrPrivateKey.asymmetricKeyDetails !== undefined && //KeyObject.asymmetricKeyDetails is supported in Node 15+\n      secretOrPrivateKey.asymmetricKeyDetails.modulusLength < 2048) {\n      return failure(new Error(`secretOrPrivateKey has a minimum key size of 2048 bits for ${header.alg}`));\n    }\n  }\n\n  if (typeof payload === 'undefined') {\n    return failure(new Error('payload is required'));\n  } else if (isObjectPayload) {\n    try {\n      validatePayload(payload);\n    }\n    catch (error) {\n      return failure(error);\n    }\n    if (!options.mutatePayload) {\n      payload = Object.assign({},payload);\n    }\n  } else {\n    const invalid_options = options_for_objects.filter(function (opt) {\n      return typeof options[opt] !== 'undefined';\n    });\n\n    if (invalid_options.length > 0) {\n      return failure(new Error('invalid ' + invalid_options.join(',') + ' option for ' + (typeof payload ) + ' payload'));\n    }\n  }\n\n  if (typeof payload.exp !== 'undefined' && typeof options.expiresIn !== 'undefined') {\n    return failure(new Error('Bad \"options.expiresIn\" option the payload already has an \"exp\" property.'));\n  }\n\n  if (typeof payload.nbf !== 'undefined' && typeof options.notBefore !== 'undefined') {\n    return failure(new Error('Bad \"options.notBefore\" option the payload already has an \"nbf\" property.'));\n  }\n\n  try {\n    validateOptions(options);\n  }\n  catch (error) {\n    return failure(error);\n  }\n\n  if (!options.allowInvalidAsymmetricKeyTypes) {\n    try {\n      validateAsymmetricKey(header.alg, secretOrPrivateKey);\n    } catch (error) {\n      return failure(error);\n    }\n  }\n\n  const timestamp = payload.iat || Math.floor(Date.now() / 1000);\n\n  if (options.noTimestamp) {\n    delete payload.iat;\n  } else if (isObjectPayload) {\n    payload.iat = timestamp;\n  }\n\n  if (typeof options.notBefore !== 'undefined') {\n    try {\n      payload.nbf = timespan(options.notBefore, timestamp);\n    }\n    catch (err) {\n      return failure(err);\n    }\n    if (typeof payload.nbf === 'undefined') {\n      return failure(new Error('\"notBefore\" should be a number of seconds or string representing a timespan eg: \"1d\", \"20h\", 60'));\n    }\n  }\n\n  if (typeof options.expiresIn !== 'undefined' && typeof payload === 'object') {\n    try {\n      payload.exp = timespan(options.expiresIn, timestamp);\n    }\n    catch (err) {\n      return failure(err);\n    }\n    if (typeof payload.exp === 'undefined') {\n      return failure(new Error('\"expiresIn\" should be a number of seconds or string representing a timespan eg: \"1d\", \"20h\", 60'));\n    }\n  }\n\n  Object.keys(options_to_payload).forEach(function (key) {\n    const claim = options_to_payload[key];\n    if (typeof options[key] !== 'undefined') {\n      if (typeof payload[claim] !== 'undefined') {\n        return failure(new Error('Bad \"options.' + key + '\" option. The payload already has an \"' + claim + '\" property.'));\n      }\n      payload[claim] = options[key];\n    }\n  });\n\n  const encoding = options.encoding || 'utf8';\n\n  if (typeof callback === 'function') {\n    callback = callback && once(callback);\n\n    jws.createSign({\n      header: header,\n      privateKey: secretOrPrivateKey,\n      payload: payload,\n      encoding: encoding\n    }).once('error', callback)\n      .once('done', function (signature) {\n        // TODO: Remove in favor of the modulus length check before signing once node 15+ is the minimum supported version\n        if(!options.allowInsecureKeySizes && /^(?:RS|PS)/.test(header.alg) && signature.length < 256) {\n          return callback(new Error(`secretOrPrivateKey has a minimum key size of 2048 bits for ${header.alg}`))\n        }\n        callback(null, signature);\n      });\n  } else {\n    let signature = jws.sign({header: header, payload: payload, secret: secretOrPrivateKey, encoding: encoding});\n    // TODO: Remove in favor of the modulus length check before signing once node 15+ is the minimum supported version\n    if(!options.allowInsecureKeySizes && /^(?:RS|PS)/.test(header.alg) && signature.length < 256) {\n      throw new Error(`secretOrPrivateKey has a minimum key size of 2048 bits for ${header.alg}`)\n    }\n    return signature\n  }\n};\n",
    "module.exports = {\n  decode: require('./decode'),\n  verify: require('./verify'),\n  sign: require('./sign'),\n  JsonWebTokenError: require('./lib/JsonWebTokenError'),\n  NotBeforeError: require('./lib/NotBeforeError'),\n  TokenExpiredError: require('./lib/TokenExpiredError'),\n};\n",
    "(function (module, exports) {\n  'use strict';\n\n  // Utils\n  function assert (val, msg) {\n    if (!val) throw new Error(msg || 'Assertion failed');\n  }\n\n  // Could use `inherits` module, but don't want to move from single file\n  // architecture yet.\n  function inherits (ctor, superCtor) {\n    ctor.super_ = superCtor;\n    var TempCtor = function () {};\n    TempCtor.prototype = superCtor.prototype;\n    ctor.prototype = new TempCtor();\n    ctor.prototype.constructor = ctor;\n  }\n\n  // BN\n\n  function BN (number, base, endian) {\n    if (BN.isBN(number)) {\n      return number;\n    }\n\n    this.negative = 0;\n    this.words = null;\n    this.length = 0;\n\n    // Reduction context\n    this.red = null;\n\n    if (number !== null) {\n      if (base === 'le' || base === 'be') {\n        endian = base;\n        base = 10;\n      }\n\n      this._init(number || 0, base || 10, endian || 'be');\n    }\n  }\n  if (typeof module === 'object') {\n    module.exports = BN;\n  } else {\n    exports.BN = BN;\n  }\n\n  BN.BN = BN;\n  BN.wordSize = 26;\n\n  var Buffer;\n  try {\n    if (typeof window !== 'undefined' && typeof window.Buffer !== 'undefined') {\n      Buffer = window.Buffer;\n    } else {\n      Buffer = require('buffer').Buffer;\n    }\n  } catch (e) {\n  }\n\n  BN.isBN = function isBN (num) {\n    if (num instanceof BN) {\n      return true;\n    }\n\n    return num !== null && typeof num === 'object' &&\n      num.constructor.wordSize === BN.wordSize && Array.isArray(num.words);\n  };\n\n  BN.max = function max (left, right) {\n    if (left.cmp(right) > 0) return left;\n    return right;\n  };\n\n  BN.min = function min (left, right) {\n    if (left.cmp(right) < 0) return left;\n    return right;\n  };\n\n  BN.prototype._init = function init (number, base, endian) {\n    if (typeof number === 'number') {\n      return this._initNumber(number, base, endian);\n    }\n\n    if (typeof number === 'object') {\n      return this._initArray(number, base, endian);\n    }\n\n    if (base === 'hex') {\n      base = 16;\n    }\n    assert(base === (base | 0) && base >= 2 && base <= 36);\n\n    number = number.toString().replace(/\\s+/g, '');\n    var start = 0;\n    if (number[0] === '-') {\n      start++;\n      this.negative = 1;\n    }\n\n    if (start < number.length) {\n      if (base === 16) {\n        this._parseHex(number, start, endian);\n      } else {\n        this._parseBase(number, base, start);\n        if (endian === 'le') {\n          this._initArray(this.toArray(), base, endian);\n        }\n      }\n    }\n  };\n\n  BN.prototype._initNumber = function _initNumber (number, base, endian) {\n    if (number < 0) {\n      this.negative = 1;\n      number = -number;\n    }\n    if (number < 0x4000000) {\n      this.words = [ number & 0x3ffffff ];\n      this.length = 1;\n    } else if (number < 0x10000000000000) {\n      this.words = [\n        number & 0x3ffffff,\n        (number / 0x4000000) & 0x3ffffff\n      ];\n      this.length = 2;\n    } else {\n      assert(number < 0x20000000000000); // 2 ^ 53 (unsafe)\n      this.words = [\n        number & 0x3ffffff,\n        (number / 0x4000000) & 0x3ffffff,\n        1\n      ];\n      this.length = 3;\n    }\n\n    if (endian !== 'le') return;\n\n    // Reverse the bytes\n    this._initArray(this.toArray(), base, endian);\n  };\n\n  BN.prototype._initArray = function _initArray (number, base, endian) {\n    // Perhaps a Uint8Array\n    assert(typeof number.length === 'number');\n    if (number.length <= 0) {\n      this.words = [ 0 ];\n      this.length = 1;\n      return this;\n    }\n\n    this.length = Math.ceil(number.length / 3);\n    this.words = new Array(this.length);\n    for (var i = 0; i < this.length; i++) {\n      this.words[i] = 0;\n    }\n\n    var j, w;\n    var off = 0;\n    if (endian === 'be') {\n      for (i = number.length - 1, j = 0; i >= 0; i -= 3) {\n        w = number[i] | (number[i - 1] << 8) | (number[i - 2] << 16);\n        this.words[j] |= (w << off) & 0x3ffffff;\n        this.words[j + 1] = (w >>> (26 - off)) & 0x3ffffff;\n        off += 24;\n        if (off >= 26) {\n          off -= 26;\n          j++;\n        }\n      }\n    } else if (endian === 'le') {\n      for (i = 0, j = 0; i < number.length; i += 3) {\n        w = number[i] | (number[i + 1] << 8) | (number[i + 2] << 16);\n        this.words[j] |= (w << off) & 0x3ffffff;\n        this.words[j + 1] = (w >>> (26 - off)) & 0x3ffffff;\n        off += 24;\n        if (off >= 26) {\n          off -= 26;\n          j++;\n        }\n      }\n    }\n    return this.strip();\n  };\n\n  function parseHex4Bits (string, index) {\n    var c = string.charCodeAt(index);\n    // 'A' - 'F'\n    if (c >= 65 && c <= 70) {\n      return c - 55;\n    // 'a' - 'f'\n    } else if (c >= 97 && c <= 102) {\n      return c - 87;\n    // '0' - '9'\n    } else {\n      return (c - 48) & 0xf;\n    }\n  }\n\n  function parseHexByte (string, lowerBound, index) {\n    var r = parseHex4Bits(string, index);\n    if (index - 1 >= lowerBound) {\n      r |= parseHex4Bits(string, index - 1) << 4;\n    }\n    return r;\n  }\n\n  BN.prototype._parseHex = function _parseHex (number, start, endian) {\n    // Create possibly bigger array to ensure that it fits the number\n    this.length = Math.ceil((number.length - start) / 6);\n    this.words = new Array(this.length);\n    for (var i = 0; i < this.length; i++) {\n      this.words[i] = 0;\n    }\n\n    // 24-bits chunks\n    var off = 0;\n    var j = 0;\n\n    var w;\n    if (endian === 'be') {\n      for (i = number.length - 1; i >= start; i -= 2) {\n        w = parseHexByte(number, start, i) << off;\n        this.words[j] |= w & 0x3ffffff;\n        if (off >= 18) {\n          off -= 18;\n          j += 1;\n          this.words[j] |= w >>> 26;\n        } else {\n          off += 8;\n        }\n      }\n    } else {\n      var parseLength = number.length - start;\n      for (i = parseLength % 2 === 0 ? start + 1 : start; i < number.length; i += 2) {\n        w = parseHexByte(number, start, i) << off;\n        this.words[j] |= w & 0x3ffffff;\n        if (off >= 18) {\n          off -= 18;\n          j += 1;\n          this.words[j] |= w >>> 26;\n        } else {\n          off += 8;\n        }\n      }\n    }\n\n    this.strip();\n  };\n\n  function parseBase (str, start, end, mul) {\n    var r = 0;\n    var len = Math.min(str.length, end);\n    for (var i = start; i < len; i++) {\n      var c = str.charCodeAt(i) - 48;\n\n      r *= mul;\n\n      // 'a'\n      if (c >= 49) {\n        r += c - 49 + 0xa;\n\n      // 'A'\n      } else if (c >= 17) {\n        r += c - 17 + 0xa;\n\n      // '0' - '9'\n      } else {\n        r += c;\n      }\n    }\n    return r;\n  }\n\n  BN.prototype._parseBase = function _parseBase (number, base, start) {\n    // Initialize as zero\n    this.words = [ 0 ];\n    this.length = 1;\n\n    // Find length of limb in base\n    for (var limbLen = 0, limbPow = 1; limbPow <= 0x3ffffff; limbPow *= base) {\n      limbLen++;\n    }\n    limbLen--;\n    limbPow = (limbPow / base) | 0;\n\n    var total = number.length - start;\n    var mod = total % limbLen;\n    var end = Math.min(total, total - mod) + start;\n\n    var word = 0;\n    for (var i = start; i < end; i += limbLen) {\n      word = parseBase(number, i, i + limbLen, base);\n\n      this.imuln(limbPow);\n      if (this.words[0] + word < 0x4000000) {\n        this.words[0] += word;\n      } else {\n        this._iaddn(word);\n      }\n    }\n\n    if (mod !== 0) {\n      var pow = 1;\n      word = parseBase(number, i, number.length, base);\n\n      for (i = 0; i < mod; i++) {\n        pow *= base;\n      }\n\n      this.imuln(pow);\n      if (this.words[0] + word < 0x4000000) {\n        this.words[0] += word;\n      } else {\n        this._iaddn(word);\n      }\n    }\n\n    this.strip();\n  };\n\n  BN.prototype.copy = function copy (dest) {\n    dest.words = new Array(this.length);\n    for (var i = 0; i < this.length; i++) {\n      dest.words[i] = this.words[i];\n    }\n    dest.length = this.length;\n    dest.negative = this.negative;\n    dest.red = this.red;\n  };\n\n  BN.prototype.clone = function clone () {\n    var r = new BN(null);\n    this.copy(r);\n    return r;\n  };\n\n  BN.prototype._expand = function _expand (size) {\n    while (this.length < size) {\n      this.words[this.length++] = 0;\n    }\n    return this;\n  };\n\n  // Remove leading `0` from `this`\n  BN.prototype.strip = function strip () {\n    while (this.length > 1 && this.words[this.length - 1] === 0) {\n      this.length--;\n    }\n    return this._normSign();\n  };\n\n  BN.prototype._normSign = function _normSign () {\n    // -0 = 0\n    if (this.length === 1 && this.words[0] === 0) {\n      this.negative = 0;\n    }\n    return this;\n  };\n\n  BN.prototype.inspect = function inspect () {\n    return (this.red ? '<BN-R: ' : '<BN: ') + this.toString(16) + '>';\n  };\n\n  /*\n\n  var zeros = [];\n  var groupSizes = [];\n  var groupBases = [];\n\n  var s = '';\n  var i = -1;\n  while (++i < BN.wordSize) {\n    zeros[i] = s;\n    s += '0';\n  }\n  groupSizes[0] = 0;\n  groupSizes[1] = 0;\n  groupBases[0] = 0;\n  groupBases[1] = 0;\n  var base = 2 - 1;\n  while (++base < 36 + 1) {\n    var groupSize = 0;\n    var groupBase = 1;\n    while (groupBase < (1 << BN.wordSize) / base) {\n      groupBase *= base;\n      groupSize += 1;\n    }\n    groupSizes[base] = groupSize;\n    groupBases[base] = groupBase;\n  }\n\n  */\n\n  var zeros = [\n    '',\n    '0',\n    '00',\n    '000',\n    '0000',\n    '00000',\n    '000000',\n    '0000000',\n    '00000000',\n    '000000000',\n    '0000000000',\n    '00000000000',\n    '000000000000',\n    '0000000000000',\n    '00000000000000',\n    '000000000000000',\n    '0000000000000000',\n    '00000000000000000',\n    '000000000000000000',\n    '0000000000000000000',\n    '00000000000000000000',\n    '000000000000000000000',\n    '0000000000000000000000',\n    '00000000000000000000000',\n    '000000000000000000000000',\n    '0000000000000000000000000'\n  ];\n\n  var groupSizes = [\n    0, 0,\n    25, 16, 12, 11, 10, 9, 8,\n    8, 7, 7, 7, 7, 6, 6,\n    6, 6, 6, 6, 6, 5, 5,\n    5, 5, 5, 5, 5, 5, 5,\n    5, 5, 5, 5, 5, 5, 5\n  ];\n\n  var groupBases = [\n    0, 0,\n    33554432, 43046721, 16777216, 48828125, 60466176, 40353607, 16777216,\n    43046721, 10000000, 19487171, 35831808, 62748517, 7529536, 11390625,\n    16777216, 24137569, 34012224, 47045881, 64000000, 4084101, 5153632,\n    6436343, 7962624, 9765625, 11881376, 14348907, 17210368, 20511149,\n    24300000, 28629151, 33554432, 39135393, 45435424, 52521875, 60466176\n  ];\n\n  BN.prototype.toString = function toString (base, padding) {\n    base = base || 10;\n    padding = padding | 0 || 1;\n\n    var out;\n    if (base === 16 || base === 'hex') {\n      out = '';\n      var off = 0;\n      var carry = 0;\n      for (var i = 0; i < this.length; i++) {\n        var w = this.words[i];\n        var word = (((w << off) | carry) & 0xffffff).toString(16);\n        carry = (w >>> (24 - off)) & 0xffffff;\n        off += 2;\n        if (off >= 26) {\n          off -= 26;\n          i--;\n        }\n        if (carry !== 0 || i !== this.length - 1) {\n          out = zeros[6 - word.length] + word + out;\n        } else {\n          out = word + out;\n        }\n      }\n      if (carry !== 0) {\n        out = carry.toString(16) + out;\n      }\n      while (out.length % padding !== 0) {\n        out = '0' + out;\n      }\n      if (this.negative !== 0) {\n        out = '-' + out;\n      }\n      return out;\n    }\n\n    if (base === (base | 0) && base >= 2 && base <= 36) {\n      // var groupSize = Math.floor(BN.wordSize * Math.LN2 / Math.log(base));\n      var groupSize = groupSizes[base];\n      // var groupBase = Math.pow(base, groupSize);\n      var groupBase = groupBases[base];\n      out = '';\n      var c = this.clone();\n      c.negative = 0;\n      while (!c.isZero()) {\n        var r = c.modn(groupBase).toString(base);\n        c = c.idivn(groupBase);\n\n        if (!c.isZero()) {\n          out = zeros[groupSize - r.length] + r + out;\n        } else {\n          out = r + out;\n        }\n      }\n      if (this.isZero()) {\n        out = '0' + out;\n      }\n      while (out.length % padding !== 0) {\n        out = '0' + out;\n      }\n      if (this.negative !== 0) {\n        out = '-' + out;\n      }\n      return out;\n    }\n\n    assert(false, 'Base should be between 2 and 36');\n  };\n\n  BN.prototype.toNumber = function toNumber () {\n    var ret = this.words[0];\n    if (this.length === 2) {\n      ret += this.words[1] * 0x4000000;\n    } else if (this.length === 3 && this.words[2] === 0x01) {\n      // NOTE: at this stage it is known that the top bit is set\n      ret += 0x10000000000000 + (this.words[1] * 0x4000000);\n    } else if (this.length > 2) {\n      assert(false, 'Number can only safely store up to 53 bits');\n    }\n    return (this.negative !== 0) ? -ret : ret;\n  };\n\n  BN.prototype.toJSON = function toJSON () {\n    return this.toString(16);\n  };\n\n  BN.prototype.toBuffer = function toBuffer (endian, length) {\n    assert(typeof Buffer !== 'undefined');\n    return this.toArrayLike(Buffer, endian, length);\n  };\n\n  BN.prototype.toArray = function toArray (endian, length) {\n    return this.toArrayLike(Array, endian, length);\n  };\n\n  BN.prototype.toArrayLike = function toArrayLike (ArrayType, endian, length) {\n    var byteLength = this.byteLength();\n    var reqLength = length || Math.max(1, byteLength);\n    assert(byteLength <= reqLength, 'byte array longer than desired length');\n    assert(reqLength > 0, 'Requested array length <= 0');\n\n    this.strip();\n    var littleEndian = endian === 'le';\n    var res = new ArrayType(reqLength);\n\n    var b, i;\n    var q = this.clone();\n    if (!littleEndian) {\n      // Assume big-endian\n      for (i = 0; i < reqLength - byteLength; i++) {\n        res[i] = 0;\n      }\n\n      for (i = 0; !q.isZero(); i++) {\n        b = q.andln(0xff);\n        q.iushrn(8);\n\n        res[reqLength - i - 1] = b;\n      }\n    } else {\n      for (i = 0; !q.isZero(); i++) {\n        b = q.andln(0xff);\n        q.iushrn(8);\n\n        res[i] = b;\n      }\n\n      for (; i < reqLength; i++) {\n        res[i] = 0;\n      }\n    }\n\n    return res;\n  };\n\n  if (Math.clz32) {\n    BN.prototype._countBits = function _countBits (w) {\n      return 32 - Math.clz32(w);\n    };\n  } else {\n    BN.prototype._countBits = function _countBits (w) {\n      var t = w;\n      var r = 0;\n      if (t >= 0x1000) {\n        r += 13;\n        t >>>= 13;\n      }\n      if (t >= 0x40) {\n        r += 7;\n        t >>>= 7;\n      }\n      if (t >= 0x8) {\n        r += 4;\n        t >>>= 4;\n      }\n      if (t >= 0x02) {\n        r += 2;\n        t >>>= 2;\n      }\n      return r + t;\n    };\n  }\n\n  BN.prototype._zeroBits = function _zeroBits (w) {\n    // Short-cut\n    if (w === 0) return 26;\n\n    var t = w;\n    var r = 0;\n    if ((t & 0x1fff) === 0) {\n      r += 13;\n      t >>>= 13;\n    }\n    if ((t & 0x7f) === 0) {\n      r += 7;\n      t >>>= 7;\n    }\n    if ((t & 0xf) === 0) {\n      r += 4;\n      t >>>= 4;\n    }\n    if ((t & 0x3) === 0) {\n      r += 2;\n      t >>>= 2;\n    }\n    if ((t & 0x1) === 0) {\n      r++;\n    }\n    return r;\n  };\n\n  // Return number of used bits in a BN\n  BN.prototype.bitLength = function bitLength () {\n    var w = this.words[this.length - 1];\n    var hi = this._countBits(w);\n    return (this.length - 1) * 26 + hi;\n  };\n\n  function toBitArray (num) {\n    var w = new Array(num.bitLength());\n\n    for (var bit = 0; bit < w.length; bit++) {\n      var off = (bit / 26) | 0;\n      var wbit = bit % 26;\n\n      w[bit] = (num.words[off] & (1 << wbit)) >>> wbit;\n    }\n\n    return w;\n  }\n\n  // Number of trailing zero bits\n  BN.prototype.zeroBits = function zeroBits () {\n    if (this.isZero()) return 0;\n\n    var r = 0;\n    for (var i = 0; i < this.length; i++) {\n      var b = this._zeroBits(this.words[i]);\n      r += b;\n      if (b !== 26) break;\n    }\n    return r;\n  };\n\n  BN.prototype.byteLength = function byteLength () {\n    return Math.ceil(this.bitLength() / 8);\n  };\n\n  BN.prototype.toTwos = function toTwos (width) {\n    if (this.negative !== 0) {\n      return this.abs().inotn(width).iaddn(1);\n    }\n    return this.clone();\n  };\n\n  BN.prototype.fromTwos = function fromTwos (width) {\n    if (this.testn(width - 1)) {\n      return this.notn(width).iaddn(1).ineg();\n    }\n    return this.clone();\n  };\n\n  BN.prototype.isNeg = function isNeg () {\n    return this.negative !== 0;\n  };\n\n  // Return negative clone of `this`\n  BN.prototype.neg = function neg () {\n    return this.clone().ineg();\n  };\n\n  BN.prototype.ineg = function ineg () {\n    if (!this.isZero()) {\n      this.negative ^= 1;\n    }\n\n    return this;\n  };\n\n  // Or `num` with `this` in-place\n  BN.prototype.iuor = function iuor (num) {\n    while (this.length < num.length) {\n      this.words[this.length++] = 0;\n    }\n\n    for (var i = 0; i < num.length; i++) {\n      this.words[i] = this.words[i] | num.words[i];\n    }\n\n    return this.strip();\n  };\n\n  BN.prototype.ior = function ior (num) {\n    assert((this.negative | num.negative) === 0);\n    return this.iuor(num);\n  };\n\n  // Or `num` with `this`\n  BN.prototype.or = function or (num) {\n    if (this.length > num.length) return this.clone().ior(num);\n    return num.clone().ior(this);\n  };\n\n  BN.prototype.uor = function uor (num) {\n    if (this.length > num.length) return this.clone().iuor(num);\n    return num.clone().iuor(this);\n  };\n\n  // And `num` with `this` in-place\n  BN.prototype.iuand = function iuand (num) {\n    // b = min-length(num, this)\n    var b;\n    if (this.length > num.length) {\n      b = num;\n    } else {\n      b = this;\n    }\n\n    for (var i = 0; i < b.length; i++) {\n      this.words[i] = this.words[i] & num.words[i];\n    }\n\n    this.length = b.length;\n\n    return this.strip();\n  };\n\n  BN.prototype.iand = function iand (num) {\n    assert((this.negative | num.negative) === 0);\n    return this.iuand(num);\n  };\n\n  // And `num` with `this`\n  BN.prototype.and = function and (num) {\n    if (this.length > num.length) return this.clone().iand(num);\n    return num.clone().iand(this);\n  };\n\n  BN.prototype.uand = function uand (num) {\n    if (this.length > num.length) return this.clone().iuand(num);\n    return num.clone().iuand(this);\n  };\n\n  // Xor `num` with `this` in-place\n  BN.prototype.iuxor = function iuxor (num) {\n    // a.length > b.length\n    var a;\n    var b;\n    if (this.length > num.length) {\n      a = this;\n      b = num;\n    } else {\n      a = num;\n      b = this;\n    }\n\n    for (var i = 0; i < b.length; i++) {\n      this.words[i] = a.words[i] ^ b.words[i];\n    }\n\n    if (this !== a) {\n      for (; i < a.length; i++) {\n        this.words[i] = a.words[i];\n      }\n    }\n\n    this.length = a.length;\n\n    return this.strip();\n  };\n\n  BN.prototype.ixor = function ixor (num) {\n    assert((this.negative | num.negative) === 0);\n    return this.iuxor(num);\n  };\n\n  // Xor `num` with `this`\n  BN.prototype.xor = function xor (num) {\n    if (this.length > num.length) return this.clone().ixor(num);\n    return num.clone().ixor(this);\n  };\n\n  BN.prototype.uxor = function uxor (num) {\n    if (this.length > num.length) return this.clone().iuxor(num);\n    return num.clone().iuxor(this);\n  };\n\n  // Not ``this`` with ``width`` bitwidth\n  BN.prototype.inotn = function inotn (width) {\n    assert(typeof width === 'number' && width >= 0);\n\n    var bytesNeeded = Math.ceil(width / 26) | 0;\n    var bitsLeft = width % 26;\n\n    // Extend the buffer with leading zeroes\n    this._expand(bytesNeeded);\n\n    if (bitsLeft > 0) {\n      bytesNeeded--;\n    }\n\n    // Handle complete words\n    for (var i = 0; i < bytesNeeded; i++) {\n      this.words[i] = ~this.words[i] & 0x3ffffff;\n    }\n\n    // Handle the residue\n    if (bitsLeft > 0) {\n      this.words[i] = ~this.words[i] & (0x3ffffff >> (26 - bitsLeft));\n    }\n\n    // And remove leading zeroes\n    return this.strip();\n  };\n\n  BN.prototype.notn = function notn (width) {\n    return this.clone().inotn(width);\n  };\n\n  // Set `bit` of `this`\n  BN.prototype.setn = function setn (bit, val) {\n    assert(typeof bit === 'number' && bit >= 0);\n\n    var off = (bit / 26) | 0;\n    var wbit = bit % 26;\n\n    this._expand(off + 1);\n\n    if (val) {\n      this.words[off] = this.words[off] | (1 << wbit);\n    } else {\n      this.words[off] = this.words[off] & ~(1 << wbit);\n    }\n\n    return this.strip();\n  };\n\n  // Add `num` to `this` in-place\n  BN.prototype.iadd = function iadd (num) {\n    var r;\n\n    // negative + positive\n    if (this.negative !== 0 && num.negative === 0) {\n      this.negative = 0;\n      r = this.isub(num);\n      this.negative ^= 1;\n      return this._normSign();\n\n    // positive + negative\n    } else if (this.negative === 0 && num.negative !== 0) {\n      num.negative = 0;\n      r = this.isub(num);\n      num.negative = 1;\n      return r._normSign();\n    }\n\n    // a.length > b.length\n    var a, b;\n    if (this.length > num.length) {\n      a = this;\n      b = num;\n    } else {\n      a = num;\n      b = this;\n    }\n\n    var carry = 0;\n    for (var i = 0; i < b.length; i++) {\n      r = (a.words[i] | 0) + (b.words[i] | 0) + carry;\n      this.words[i] = r & 0x3ffffff;\n      carry = r >>> 26;\n    }\n    for (; carry !== 0 && i < a.length; i++) {\n      r = (a.words[i] | 0) + carry;\n      this.words[i] = r & 0x3ffffff;\n      carry = r >>> 26;\n    }\n\n    this.length = a.length;\n    if (carry !== 0) {\n      this.words[this.length] = carry;\n      this.length++;\n    // Copy the rest of the words\n    } else if (a !== this) {\n      for (; i < a.length; i++) {\n        this.words[i] = a.words[i];\n      }\n    }\n\n    return this;\n  };\n\n  // Add `num` to `this`\n  BN.prototype.add = function add (num) {\n    var res;\n    if (num.negative !== 0 && this.negative === 0) {\n      num.negative = 0;\n      res = this.sub(num);\n      num.negative ^= 1;\n      return res;\n    } else if (num.negative === 0 && this.negative !== 0) {\n      this.negative = 0;\n      res = num.sub(this);\n      this.negative = 1;\n      return res;\n    }\n\n    if (this.length > num.length) return this.clone().iadd(num);\n\n    return num.clone().iadd(this);\n  };\n\n  // Subtract `num` from `this` in-place\n  BN.prototype.isub = function isub (num) {\n    // this - (-num) = this + num\n    if (num.negative !== 0) {\n      num.negative = 0;\n      var r = this.iadd(num);\n      num.negative = 1;\n      return r._normSign();\n\n    // -this - num = -(this + num)\n    } else if (this.negative !== 0) {\n      this.negative = 0;\n      this.iadd(num);\n      this.negative = 1;\n      return this._normSign();\n    }\n\n    // At this point both numbers are positive\n    var cmp = this.cmp(num);\n\n    // Optimization - zeroify\n    if (cmp === 0) {\n      this.negative = 0;\n      this.length = 1;\n      this.words[0] = 0;\n      return this;\n    }\n\n    // a > b\n    var a, b;\n    if (cmp > 0) {\n      a = this;\n      b = num;\n    } else {\n      a = num;\n      b = this;\n    }\n\n    var carry = 0;\n    for (var i = 0; i < b.length; i++) {\n      r = (a.words[i] | 0) - (b.words[i] | 0) + carry;\n      carry = r >> 26;\n      this.words[i] = r & 0x3ffffff;\n    }\n    for (; carry !== 0 && i < a.length; i++) {\n      r = (a.words[i] | 0) + carry;\n      carry = r >> 26;\n      this.words[i] = r & 0x3ffffff;\n    }\n\n    // Copy rest of the words\n    if (carry === 0 && i < a.length && a !== this) {\n      for (; i < a.length; i++) {\n        this.words[i] = a.words[i];\n      }\n    }\n\n    this.length = Math.max(this.length, i);\n\n    if (a !== this) {\n      this.negative = 1;\n    }\n\n    return this.strip();\n  };\n\n  // Subtract `num` from `this`\n  BN.prototype.sub = function sub (num) {\n    return this.clone().isub(num);\n  };\n\n  function smallMulTo (self, num, out) {\n    out.negative = num.negative ^ self.negative;\n    var len = (self.length + num.length) | 0;\n    out.length = len;\n    len = (len - 1) | 0;\n\n    // Peel one iteration (compiler can't do it, because of code complexity)\n    var a = self.words[0] | 0;\n    var b = num.words[0] | 0;\n    var r = a * b;\n\n    var lo = r & 0x3ffffff;\n    var carry = (r / 0x4000000) | 0;\n    out.words[0] = lo;\n\n    for (var k = 1; k < len; k++) {\n      // Sum all words with the same `i + j = k` and accumulate `ncarry`,\n      // note that ncarry could be >= 0x3ffffff\n      var ncarry = carry >>> 26;\n      var rword = carry & 0x3ffffff;\n      var maxJ = Math.min(k, num.length - 1);\n      for (var j = Math.max(0, k - self.length + 1); j <= maxJ; j++) {\n        var i = (k - j) | 0;\n        a = self.words[i] | 0;\n        b = num.words[j] | 0;\n        r = a * b + rword;\n        ncarry += (r / 0x4000000) | 0;\n        rword = r & 0x3ffffff;\n      }\n      out.words[k] = rword | 0;\n      carry = ncarry | 0;\n    }\n    if (carry !== 0) {\n      out.words[k] = carry | 0;\n    } else {\n      out.length--;\n    }\n\n    return out.strip();\n  }\n\n  // TODO(indutny): it may be reasonable to omit it for users who don't need\n  // to work with 256-bit numbers, otherwise it gives 20% improvement for 256-bit\n  // multiplication (like elliptic secp256k1).\n  var comb10MulTo = function comb10MulTo (self, num, out) {\n    var a = self.words;\n    var b = num.words;\n    var o = out.words;\n    var c = 0;\n    var lo;\n    var mid;\n    var hi;\n    var a0 = a[0] | 0;\n    var al0 = a0 & 0x1fff;\n    var ah0 = a0 >>> 13;\n    var a1 = a[1] | 0;\n    var al1 = a1 & 0x1fff;\n    var ah1 = a1 >>> 13;\n    var a2 = a[2] | 0;\n    var al2 = a2 & 0x1fff;\n    var ah2 = a2 >>> 13;\n    var a3 = a[3] | 0;\n    var al3 = a3 & 0x1fff;\n    var ah3 = a3 >>> 13;\n    var a4 = a[4] | 0;\n    var al4 = a4 & 0x1fff;\n    var ah4 = a4 >>> 13;\n    var a5 = a[5] | 0;\n    var al5 = a5 & 0x1fff;\n    var ah5 = a5 >>> 13;\n    var a6 = a[6] | 0;\n    var al6 = a6 & 0x1fff;\n    var ah6 = a6 >>> 13;\n    var a7 = a[7] | 0;\n    var al7 = a7 & 0x1fff;\n    var ah7 = a7 >>> 13;\n    var a8 = a[8] | 0;\n    var al8 = a8 & 0x1fff;\n    var ah8 = a8 >>> 13;\n    var a9 = a[9] | 0;\n    var al9 = a9 & 0x1fff;\n    var ah9 = a9 >>> 13;\n    var b0 = b[0] | 0;\n    var bl0 = b0 & 0x1fff;\n    var bh0 = b0 >>> 13;\n    var b1 = b[1] | 0;\n    var bl1 = b1 & 0x1fff;\n    var bh1 = b1 >>> 13;\n    var b2 = b[2] | 0;\n    var bl2 = b2 & 0x1fff;\n    var bh2 = b2 >>> 13;\n    var b3 = b[3] | 0;\n    var bl3 = b3 & 0x1fff;\n    var bh3 = b3 >>> 13;\n    var b4 = b[4] | 0;\n    var bl4 = b4 & 0x1fff;\n    var bh4 = b4 >>> 13;\n    var b5 = b[5] | 0;\n    var bl5 = b5 & 0x1fff;\n    var bh5 = b5 >>> 13;\n    var b6 = b[6] | 0;\n    var bl6 = b6 & 0x1fff;\n    var bh6 = b6 >>> 13;\n    var b7 = b[7] | 0;\n    var bl7 = b7 & 0x1fff;\n    var bh7 = b7 >>> 13;\n    var b8 = b[8] | 0;\n    var bl8 = b8 & 0x1fff;\n    var bh8 = b8 >>> 13;\n    var b9 = b[9] | 0;\n    var bl9 = b9 & 0x1fff;\n    var bh9 = b9 >>> 13;\n\n    out.negative = self.negative ^ num.negative;\n    out.length = 19;\n    /* k = 0 */\n    lo = Math.imul(al0, bl0);\n    mid = Math.imul(al0, bh0);\n    mid = (mid + Math.imul(ah0, bl0)) | 0;\n    hi = Math.imul(ah0, bh0);\n    var w0 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w0 >>> 26)) | 0;\n    w0 &= 0x3ffffff;\n    /* k = 1 */\n    lo = Math.imul(al1, bl0);\n    mid = Math.imul(al1, bh0);\n    mid = (mid + Math.imul(ah1, bl0)) | 0;\n    hi = Math.imul(ah1, bh0);\n    lo = (lo + Math.imul(al0, bl1)) | 0;\n    mid = (mid + Math.imul(al0, bh1)) | 0;\n    mid = (mid + Math.imul(ah0, bl1)) | 0;\n    hi = (hi + Math.imul(ah0, bh1)) | 0;\n    var w1 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w1 >>> 26)) | 0;\n    w1 &= 0x3ffffff;\n    /* k = 2 */\n    lo = Math.imul(al2, bl0);\n    mid = Math.imul(al2, bh0);\n    mid = (mid + Math.imul(ah2, bl0)) | 0;\n    hi = Math.imul(ah2, bh0);\n    lo = (lo + Math.imul(al1, bl1)) | 0;\n    mid = (mid + Math.imul(al1, bh1)) | 0;\n    mid = (mid + Math.imul(ah1, bl1)) | 0;\n    hi = (hi + Math.imul(ah1, bh1)) | 0;\n    lo = (lo + Math.imul(al0, bl2)) | 0;\n    mid = (mid + Math.imul(al0, bh2)) | 0;\n    mid = (mid + Math.imul(ah0, bl2)) | 0;\n    hi = (hi + Math.imul(ah0, bh2)) | 0;\n    var w2 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w2 >>> 26)) | 0;\n    w2 &= 0x3ffffff;\n    /* k = 3 */\n    lo = Math.imul(al3, bl0);\n    mid = Math.imul(al3, bh0);\n    mid = (mid + Math.imul(ah3, bl0)) | 0;\n    hi = Math.imul(ah3, bh0);\n    lo = (lo + Math.imul(al2, bl1)) | 0;\n    mid = (mid + Math.imul(al2, bh1)) | 0;\n    mid = (mid + Math.imul(ah2, bl1)) | 0;\n    hi = (hi + Math.imul(ah2, bh1)) | 0;\n    lo = (lo + Math.imul(al1, bl2)) | 0;\n    mid = (mid + Math.imul(al1, bh2)) | 0;\n    mid = (mid + Math.imul(ah1, bl2)) | 0;\n    hi = (hi + Math.imul(ah1, bh2)) | 0;\n    lo = (lo + Math.imul(al0, bl3)) | 0;\n    mid = (mid + Math.imul(al0, bh3)) | 0;\n    mid = (mid + Math.imul(ah0, bl3)) | 0;\n    hi = (hi + Math.imul(ah0, bh3)) | 0;\n    var w3 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w3 >>> 26)) | 0;\n    w3 &= 0x3ffffff;\n    /* k = 4 */\n    lo = Math.imul(al4, bl0);\n    mid = Math.imul(al4, bh0);\n    mid = (mid + Math.imul(ah4, bl0)) | 0;\n    hi = Math.imul(ah4, bh0);\n    lo = (lo + Math.imul(al3, bl1)) | 0;\n    mid = (mid + Math.imul(al3, bh1)) | 0;\n    mid = (mid + Math.imul(ah3, bl1)) | 0;\n    hi = (hi + Math.imul(ah3, bh1)) | 0;\n    lo = (lo + Math.imul(al2, bl2)) | 0;\n    mid = (mid + Math.imul(al2, bh2)) | 0;\n    mid = (mid + Math.imul(ah2, bl2)) | 0;\n    hi = (hi + Math.imul(ah2, bh2)) | 0;\n    lo = (lo + Math.imul(al1, bl3)) | 0;\n    mid = (mid + Math.imul(al1, bh3)) | 0;\n    mid = (mid + Math.imul(ah1, bl3)) | 0;\n    hi = (hi + Math.imul(ah1, bh3)) | 0;\n    lo = (lo + Math.imul(al0, bl4)) | 0;\n    mid = (mid + Math.imul(al0, bh4)) | 0;\n    mid = (mid + Math.imul(ah0, bl4)) | 0;\n    hi = (hi + Math.imul(ah0, bh4)) | 0;\n    var w4 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w4 >>> 26)) | 0;\n    w4 &= 0x3ffffff;\n    /* k = 5 */\n    lo = Math.imul(al5, bl0);\n    mid = Math.imul(al5, bh0);\n    mid = (mid + Math.imul(ah5, bl0)) | 0;\n    hi = Math.imul(ah5, bh0);\n    lo = (lo + Math.imul(al4, bl1)) | 0;\n    mid = (mid + Math.imul(al4, bh1)) | 0;\n    mid = (mid + Math.imul(ah4, bl1)) | 0;\n    hi = (hi + Math.imul(ah4, bh1)) | 0;\n    lo = (lo + Math.imul(al3, bl2)) | 0;\n    mid = (mid + Math.imul(al3, bh2)) | 0;\n    mid = (mid + Math.imul(ah3, bl2)) | 0;\n    hi = (hi + Math.imul(ah3, bh2)) | 0;\n    lo = (lo + Math.imul(al2, bl3)) | 0;\n    mid = (mid + Math.imul(al2, bh3)) | 0;\n    mid = (mid + Math.imul(ah2, bl3)) | 0;\n    hi = (hi + Math.imul(ah2, bh3)) | 0;\n    lo = (lo + Math.imul(al1, bl4)) | 0;\n    mid = (mid + Math.imul(al1, bh4)) | 0;\n    mid = (mid + Math.imul(ah1, bl4)) | 0;\n    hi = (hi + Math.imul(ah1, bh4)) | 0;\n    lo = (lo + Math.imul(al0, bl5)) | 0;\n    mid = (mid + Math.imul(al0, bh5)) | 0;\n    mid = (mid + Math.imul(ah0, bl5)) | 0;\n    hi = (hi + Math.imul(ah0, bh5)) | 0;\n    var w5 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w5 >>> 26)) | 0;\n    w5 &= 0x3ffffff;\n    /* k = 6 */\n    lo = Math.imul(al6, bl0);\n    mid = Math.imul(al6, bh0);\n    mid = (mid + Math.imul(ah6, bl0)) | 0;\n    hi = Math.imul(ah6, bh0);\n    lo = (lo + Math.imul(al5, bl1)) | 0;\n    mid = (mid + Math.imul(al5, bh1)) | 0;\n    mid = (mid + Math.imul(ah5, bl1)) | 0;\n    hi = (hi + Math.imul(ah5, bh1)) | 0;\n    lo = (lo + Math.imul(al4, bl2)) | 0;\n    mid = (mid + Math.imul(al4, bh2)) | 0;\n    mid = (mid + Math.imul(ah4, bl2)) | 0;\n    hi = (hi + Math.imul(ah4, bh2)) | 0;\n    lo = (lo + Math.imul(al3, bl3)) | 0;\n    mid = (mid + Math.imul(al3, bh3)) | 0;\n    mid = (mid + Math.imul(ah3, bl3)) | 0;\n    hi = (hi + Math.imul(ah3, bh3)) | 0;\n    lo = (lo + Math.imul(al2, bl4)) | 0;\n    mid = (mid + Math.imul(al2, bh4)) | 0;\n    mid = (mid + Math.imul(ah2, bl4)) | 0;\n    hi = (hi + Math.imul(ah2, bh4)) | 0;\n    lo = (lo + Math.imul(al1, bl5)) | 0;\n    mid = (mid + Math.imul(al1, bh5)) | 0;\n    mid = (mid + Math.imul(ah1, bl5)) | 0;\n    hi = (hi + Math.imul(ah1, bh5)) | 0;\n    lo = (lo + Math.imul(al0, bl6)) | 0;\n    mid = (mid + Math.imul(al0, bh6)) | 0;\n    mid = (mid + Math.imul(ah0, bl6)) | 0;\n    hi = (hi + Math.imul(ah0, bh6)) | 0;\n    var w6 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w6 >>> 26)) | 0;\n    w6 &= 0x3ffffff;\n    /* k = 7 */\n    lo = Math.imul(al7, bl0);\n    mid = Math.imul(al7, bh0);\n    mid = (mid + Math.imul(ah7, bl0)) | 0;\n    hi = Math.imul(ah7, bh0);\n    lo = (lo + Math.imul(al6, bl1)) | 0;\n    mid = (mid + Math.imul(al6, bh1)) | 0;\n    mid = (mid + Math.imul(ah6, bl1)) | 0;\n    hi = (hi + Math.imul(ah6, bh1)) | 0;\n    lo = (lo + Math.imul(al5, bl2)) | 0;\n    mid = (mid + Math.imul(al5, bh2)) | 0;\n    mid = (mid + Math.imul(ah5, bl2)) | 0;\n    hi = (hi + Math.imul(ah5, bh2)) | 0;\n    lo = (lo + Math.imul(al4, bl3)) | 0;\n    mid = (mid + Math.imul(al4, bh3)) | 0;\n    mid = (mid + Math.imul(ah4, bl3)) | 0;\n    hi = (hi + Math.imul(ah4, bh3)) | 0;\n    lo = (lo + Math.imul(al3, bl4)) | 0;\n    mid = (mid + Math.imul(al3, bh4)) | 0;\n    mid = (mid + Math.imul(ah3, bl4)) | 0;\n    hi = (hi + Math.imul(ah3, bh4)) | 0;\n    lo = (lo + Math.imul(al2, bl5)) | 0;\n    mid = (mid + Math.imul(al2, bh5)) | 0;\n    mid = (mid + Math.imul(ah2, bl5)) | 0;\n    hi = (hi + Math.imul(ah2, bh5)) | 0;\n    lo = (lo + Math.imul(al1, bl6)) | 0;\n    mid = (mid + Math.imul(al1, bh6)) | 0;\n    mid = (mid + Math.imul(ah1, bl6)) | 0;\n    hi = (hi + Math.imul(ah1, bh6)) | 0;\n    lo = (lo + Math.imul(al0, bl7)) | 0;\n    mid = (mid + Math.imul(al0, bh7)) | 0;\n    mid = (mid + Math.imul(ah0, bl7)) | 0;\n    hi = (hi + Math.imul(ah0, bh7)) | 0;\n    var w7 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w7 >>> 26)) | 0;\n    w7 &= 0x3ffffff;\n    /* k = 8 */\n    lo = Math.imul(al8, bl0);\n    mid = Math.imul(al8, bh0);\n    mid = (mid + Math.imul(ah8, bl0)) | 0;\n    hi = Math.imul(ah8, bh0);\n    lo = (lo + Math.imul(al7, bl1)) | 0;\n    mid = (mid + Math.imul(al7, bh1)) | 0;\n    mid = (mid + Math.imul(ah7, bl1)) | 0;\n    hi = (hi + Math.imul(ah7, bh1)) | 0;\n    lo = (lo + Math.imul(al6, bl2)) | 0;\n    mid = (mid + Math.imul(al6, bh2)) | 0;\n    mid = (mid + Math.imul(ah6, bl2)) | 0;\n    hi = (hi + Math.imul(ah6, bh2)) | 0;\n    lo = (lo + Math.imul(al5, bl3)) | 0;\n    mid = (mid + Math.imul(al5, bh3)) | 0;\n    mid = (mid + Math.imul(ah5, bl3)) | 0;\n    hi = (hi + Math.imul(ah5, bh3)) | 0;\n    lo = (lo + Math.imul(al4, bl4)) | 0;\n    mid = (mid + Math.imul(al4, bh4)) | 0;\n    mid = (mid + Math.imul(ah4, bl4)) | 0;\n    hi = (hi + Math.imul(ah4, bh4)) | 0;\n    lo = (lo + Math.imul(al3, bl5)) | 0;\n    mid = (mid + Math.imul(al3, bh5)) | 0;\n    mid = (mid + Math.imul(ah3, bl5)) | 0;\n    hi = (hi + Math.imul(ah3, bh5)) | 0;\n    lo = (lo + Math.imul(al2, bl6)) | 0;\n    mid = (mid + Math.imul(al2, bh6)) | 0;\n    mid = (mid + Math.imul(ah2, bl6)) | 0;\n    hi = (hi + Math.imul(ah2, bh6)) | 0;\n    lo = (lo + Math.imul(al1, bl7)) | 0;\n    mid = (mid + Math.imul(al1, bh7)) | 0;\n    mid = (mid + Math.imul(ah1, bl7)) | 0;\n    hi = (hi + Math.imul(ah1, bh7)) | 0;\n    lo = (lo + Math.imul(al0, bl8)) | 0;\n    mid = (mid + Math.imul(al0, bh8)) | 0;\n    mid = (mid + Math.imul(ah0, bl8)) | 0;\n    hi = (hi + Math.imul(ah0, bh8)) | 0;\n    var w8 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w8 >>> 26)) | 0;\n    w8 &= 0x3ffffff;\n    /* k = 9 */\n    lo = Math.imul(al9, bl0);\n    mid = Math.imul(al9, bh0);\n    mid = (mid + Math.imul(ah9, bl0)) | 0;\n    hi = Math.imul(ah9, bh0);\n    lo = (lo + Math.imul(al8, bl1)) | 0;\n    mid = (mid + Math.imul(al8, bh1)) | 0;\n    mid = (mid + Math.imul(ah8, bl1)) | 0;\n    hi = (hi + Math.imul(ah8, bh1)) | 0;\n    lo = (lo + Math.imul(al7, bl2)) | 0;\n    mid = (mid + Math.imul(al7, bh2)) | 0;\n    mid = (mid + Math.imul(ah7, bl2)) | 0;\n    hi = (hi + Math.imul(ah7, bh2)) | 0;\n    lo = (lo + Math.imul(al6, bl3)) | 0;\n    mid = (mid + Math.imul(al6, bh3)) | 0;\n    mid = (mid + Math.imul(ah6, bl3)) | 0;\n    hi = (hi + Math.imul(ah6, bh3)) | 0;\n    lo = (lo + Math.imul(al5, bl4)) | 0;\n    mid = (mid + Math.imul(al5, bh4)) | 0;\n    mid = (mid + Math.imul(ah5, bl4)) | 0;\n    hi = (hi + Math.imul(ah5, bh4)) | 0;\n    lo = (lo + Math.imul(al4, bl5)) | 0;\n    mid = (mid + Math.imul(al4, bh5)) | 0;\n    mid = (mid + Math.imul(ah4, bl5)) | 0;\n    hi = (hi + Math.imul(ah4, bh5)) | 0;\n    lo = (lo + Math.imul(al3, bl6)) | 0;\n    mid = (mid + Math.imul(al3, bh6)) | 0;\n    mid = (mid + Math.imul(ah3, bl6)) | 0;\n    hi = (hi + Math.imul(ah3, bh6)) | 0;\n    lo = (lo + Math.imul(al2, bl7)) | 0;\n    mid = (mid + Math.imul(al2, bh7)) | 0;\n    mid = (mid + Math.imul(ah2, bl7)) | 0;\n    hi = (hi + Math.imul(ah2, bh7)) | 0;\n    lo = (lo + Math.imul(al1, bl8)) | 0;\n    mid = (mid + Math.imul(al1, bh8)) | 0;\n    mid = (mid + Math.imul(ah1, bl8)) | 0;\n    hi = (hi + Math.imul(ah1, bh8)) | 0;\n    lo = (lo + Math.imul(al0, bl9)) | 0;\n    mid = (mid + Math.imul(al0, bh9)) | 0;\n    mid = (mid + Math.imul(ah0, bl9)) | 0;\n    hi = (hi + Math.imul(ah0, bh9)) | 0;\n    var w9 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w9 >>> 26)) | 0;\n    w9 &= 0x3ffffff;\n    /* k = 10 */\n    lo = Math.imul(al9, bl1);\n    mid = Math.imul(al9, bh1);\n    mid = (mid + Math.imul(ah9, bl1)) | 0;\n    hi = Math.imul(ah9, bh1);\n    lo = (lo + Math.imul(al8, bl2)) | 0;\n    mid = (mid + Math.imul(al8, bh2)) | 0;\n    mid = (mid + Math.imul(ah8, bl2)) | 0;\n    hi = (hi + Math.imul(ah8, bh2)) | 0;\n    lo = (lo + Math.imul(al7, bl3)) | 0;\n    mid = (mid + Math.imul(al7, bh3)) | 0;\n    mid = (mid + Math.imul(ah7, bl3)) | 0;\n    hi = (hi + Math.imul(ah7, bh3)) | 0;\n    lo = (lo + Math.imul(al6, bl4)) | 0;\n    mid = (mid + Math.imul(al6, bh4)) | 0;\n    mid = (mid + Math.imul(ah6, bl4)) | 0;\n    hi = (hi + Math.imul(ah6, bh4)) | 0;\n    lo = (lo + Math.imul(al5, bl5)) | 0;\n    mid = (mid + Math.imul(al5, bh5)) | 0;\n    mid = (mid + Math.imul(ah5, bl5)) | 0;\n    hi = (hi + Math.imul(ah5, bh5)) | 0;\n    lo = (lo + Math.imul(al4, bl6)) | 0;\n    mid = (mid + Math.imul(al4, bh6)) | 0;\n    mid = (mid + Math.imul(ah4, bl6)) | 0;\n    hi = (hi + Math.imul(ah4, bh6)) | 0;\n    lo = (lo + Math.imul(al3, bl7)) | 0;\n    mid = (mid + Math.imul(al3, bh7)) | 0;\n    mid = (mid + Math.imul(ah3, bl7)) | 0;\n    hi = (hi + Math.imul(ah3, bh7)) | 0;\n    lo = (lo + Math.imul(al2, bl8)) | 0;\n    mid = (mid + Math.imul(al2, bh8)) | 0;\n    mid = (mid + Math.imul(ah2, bl8)) | 0;\n    hi = (hi + Math.imul(ah2, bh8)) | 0;\n    lo = (lo + Math.imul(al1, bl9)) | 0;\n    mid = (mid + Math.imul(al1, bh9)) | 0;\n    mid = (mid + Math.imul(ah1, bl9)) | 0;\n    hi = (hi + Math.imul(ah1, bh9)) | 0;\n    var w10 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w10 >>> 26)) | 0;\n    w10 &= 0x3ffffff;\n    /* k = 11 */\n    lo = Math.imul(al9, bl2);\n    mid = Math.imul(al9, bh2);\n    mid = (mid + Math.imul(ah9, bl2)) | 0;\n    hi = Math.imul(ah9, bh2);\n    lo = (lo + Math.imul(al8, bl3)) | 0;\n    mid = (mid + Math.imul(al8, bh3)) | 0;\n    mid = (mid + Math.imul(ah8, bl3)) | 0;\n    hi = (hi + Math.imul(ah8, bh3)) | 0;\n    lo = (lo + Math.imul(al7, bl4)) | 0;\n    mid = (mid + Math.imul(al7, bh4)) | 0;\n    mid = (mid + Math.imul(ah7, bl4)) | 0;\n    hi = (hi + Math.imul(ah7, bh4)) | 0;\n    lo = (lo + Math.imul(al6, bl5)) | 0;\n    mid = (mid + Math.imul(al6, bh5)) | 0;\n    mid = (mid + Math.imul(ah6, bl5)) | 0;\n    hi = (hi + Math.imul(ah6, bh5)) | 0;\n    lo = (lo + Math.imul(al5, bl6)) | 0;\n    mid = (mid + Math.imul(al5, bh6)) | 0;\n    mid = (mid + Math.imul(ah5, bl6)) | 0;\n    hi = (hi + Math.imul(ah5, bh6)) | 0;\n    lo = (lo + Math.imul(al4, bl7)) | 0;\n    mid = (mid + Math.imul(al4, bh7)) | 0;\n    mid = (mid + Math.imul(ah4, bl7)) | 0;\n    hi = (hi + Math.imul(ah4, bh7)) | 0;\n    lo = (lo + Math.imul(al3, bl8)) | 0;\n    mid = (mid + Math.imul(al3, bh8)) | 0;\n    mid = (mid + Math.imul(ah3, bl8)) | 0;\n    hi = (hi + Math.imul(ah3, bh8)) | 0;\n    lo = (lo + Math.imul(al2, bl9)) | 0;\n    mid = (mid + Math.imul(al2, bh9)) | 0;\n    mid = (mid + Math.imul(ah2, bl9)) | 0;\n    hi = (hi + Math.imul(ah2, bh9)) | 0;\n    var w11 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w11 >>> 26)) | 0;\n    w11 &= 0x3ffffff;\n    /* k = 12 */\n    lo = Math.imul(al9, bl3);\n    mid = Math.imul(al9, bh3);\n    mid = (mid + Math.imul(ah9, bl3)) | 0;\n    hi = Math.imul(ah9, bh3);\n    lo = (lo + Math.imul(al8, bl4)) | 0;\n    mid = (mid + Math.imul(al8, bh4)) | 0;\n    mid = (mid + Math.imul(ah8, bl4)) | 0;\n    hi = (hi + Math.imul(ah8, bh4)) | 0;\n    lo = (lo + Math.imul(al7, bl5)) | 0;\n    mid = (mid + Math.imul(al7, bh5)) | 0;\n    mid = (mid + Math.imul(ah7, bl5)) | 0;\n    hi = (hi + Math.imul(ah7, bh5)) | 0;\n    lo = (lo + Math.imul(al6, bl6)) | 0;\n    mid = (mid + Math.imul(al6, bh6)) | 0;\n    mid = (mid + Math.imul(ah6, bl6)) | 0;\n    hi = (hi + Math.imul(ah6, bh6)) | 0;\n    lo = (lo + Math.imul(al5, bl7)) | 0;\n    mid = (mid + Math.imul(al5, bh7)) | 0;\n    mid = (mid + Math.imul(ah5, bl7)) | 0;\n    hi = (hi + Math.imul(ah5, bh7)) | 0;\n    lo = (lo + Math.imul(al4, bl8)) | 0;\n    mid = (mid + Math.imul(al4, bh8)) | 0;\n    mid = (mid + Math.imul(ah4, bl8)) | 0;\n    hi = (hi + Math.imul(ah4, bh8)) | 0;\n    lo = (lo + Math.imul(al3, bl9)) | 0;\n    mid = (mid + Math.imul(al3, bh9)) | 0;\n    mid = (mid + Math.imul(ah3, bl9)) | 0;\n    hi = (hi + Math.imul(ah3, bh9)) | 0;\n    var w12 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w12 >>> 26)) | 0;\n    w12 &= 0x3ffffff;\n    /* k = 13 */\n    lo = Math.imul(al9, bl4);\n    mid = Math.imul(al9, bh4);\n    mid = (mid + Math.imul(ah9, bl4)) | 0;\n    hi = Math.imul(ah9, bh4);\n    lo = (lo + Math.imul(al8, bl5)) | 0;\n    mid = (mid + Math.imul(al8, bh5)) | 0;\n    mid = (mid + Math.imul(ah8, bl5)) | 0;\n    hi = (hi + Math.imul(ah8, bh5)) | 0;\n    lo = (lo + Math.imul(al7, bl6)) | 0;\n    mid = (mid + Math.imul(al7, bh6)) | 0;\n    mid = (mid + Math.imul(ah7, bl6)) | 0;\n    hi = (hi + Math.imul(ah7, bh6)) | 0;\n    lo = (lo + Math.imul(al6, bl7)) | 0;\n    mid = (mid + Math.imul(al6, bh7)) | 0;\n    mid = (mid + Math.imul(ah6, bl7)) | 0;\n    hi = (hi + Math.imul(ah6, bh7)) | 0;\n    lo = (lo + Math.imul(al5, bl8)) | 0;\n    mid = (mid + Math.imul(al5, bh8)) | 0;\n    mid = (mid + Math.imul(ah5, bl8)) | 0;\n    hi = (hi + Math.imul(ah5, bh8)) | 0;\n    lo = (lo + Math.imul(al4, bl9)) | 0;\n    mid = (mid + Math.imul(al4, bh9)) | 0;\n    mid = (mid + Math.imul(ah4, bl9)) | 0;\n    hi = (hi + Math.imul(ah4, bh9)) | 0;\n    var w13 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w13 >>> 26)) | 0;\n    w13 &= 0x3ffffff;\n    /* k = 14 */\n    lo = Math.imul(al9, bl5);\n    mid = Math.imul(al9, bh5);\n    mid = (mid + Math.imul(ah9, bl5)) | 0;\n    hi = Math.imul(ah9, bh5);\n    lo = (lo + Math.imul(al8, bl6)) | 0;\n    mid = (mid + Math.imul(al8, bh6)) | 0;\n    mid = (mid + Math.imul(ah8, bl6)) | 0;\n    hi = (hi + Math.imul(ah8, bh6)) | 0;\n    lo = (lo + Math.imul(al7, bl7)) | 0;\n    mid = (mid + Math.imul(al7, bh7)) | 0;\n    mid = (mid + Math.imul(ah7, bl7)) | 0;\n    hi = (hi + Math.imul(ah7, bh7)) | 0;\n    lo = (lo + Math.imul(al6, bl8)) | 0;\n    mid = (mid + Math.imul(al6, bh8)) | 0;\n    mid = (mid + Math.imul(ah6, bl8)) | 0;\n    hi = (hi + Math.imul(ah6, bh8)) | 0;\n    lo = (lo + Math.imul(al5, bl9)) | 0;\n    mid = (mid + Math.imul(al5, bh9)) | 0;\n    mid = (mid + Math.imul(ah5, bl9)) | 0;\n    hi = (hi + Math.imul(ah5, bh9)) | 0;\n    var w14 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w14 >>> 26)) | 0;\n    w14 &= 0x3ffffff;\n    /* k = 15 */\n    lo = Math.imul(al9, bl6);\n    mid = Math.imul(al9, bh6);\n    mid = (mid + Math.imul(ah9, bl6)) | 0;\n    hi = Math.imul(ah9, bh6);\n    lo = (lo + Math.imul(al8, bl7)) | 0;\n    mid = (mid + Math.imul(al8, bh7)) | 0;\n    mid = (mid + Math.imul(ah8, bl7)) | 0;\n    hi = (hi + Math.imul(ah8, bh7)) | 0;\n    lo = (lo + Math.imul(al7, bl8)) | 0;\n    mid = (mid + Math.imul(al7, bh8)) | 0;\n    mid = (mid + Math.imul(ah7, bl8)) | 0;\n    hi = (hi + Math.imul(ah7, bh8)) | 0;\n    lo = (lo + Math.imul(al6, bl9)) | 0;\n    mid = (mid + Math.imul(al6, bh9)) | 0;\n    mid = (mid + Math.imul(ah6, bl9)) | 0;\n    hi = (hi + Math.imul(ah6, bh9)) | 0;\n    var w15 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w15 >>> 26)) | 0;\n    w15 &= 0x3ffffff;\n    /* k = 16 */\n    lo = Math.imul(al9, bl7);\n    mid = Math.imul(al9, bh7);\n    mid = (mid + Math.imul(ah9, bl7)) | 0;\n    hi = Math.imul(ah9, bh7);\n    lo = (lo + Math.imul(al8, bl8)) | 0;\n    mid = (mid + Math.imul(al8, bh8)) | 0;\n    mid = (mid + Math.imul(ah8, bl8)) | 0;\n    hi = (hi + Math.imul(ah8, bh8)) | 0;\n    lo = (lo + Math.imul(al7, bl9)) | 0;\n    mid = (mid + Math.imul(al7, bh9)) | 0;\n    mid = (mid + Math.imul(ah7, bl9)) | 0;\n    hi = (hi + Math.imul(ah7, bh9)) | 0;\n    var w16 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w16 >>> 26)) | 0;\n    w16 &= 0x3ffffff;\n    /* k = 17 */\n    lo = Math.imul(al9, bl8);\n    mid = Math.imul(al9, bh8);\n    mid = (mid + Math.imul(ah9, bl8)) | 0;\n    hi = Math.imul(ah9, bh8);\n    lo = (lo + Math.imul(al8, bl9)) | 0;\n    mid = (mid + Math.imul(al8, bh9)) | 0;\n    mid = (mid + Math.imul(ah8, bl9)) | 0;\n    hi = (hi + Math.imul(ah8, bh9)) | 0;\n    var w17 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w17 >>> 26)) | 0;\n    w17 &= 0x3ffffff;\n    /* k = 18 */\n    lo = Math.imul(al9, bl9);\n    mid = Math.imul(al9, bh9);\n    mid = (mid + Math.imul(ah9, bl9)) | 0;\n    hi = Math.imul(ah9, bh9);\n    var w18 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w18 >>> 26)) | 0;\n    w18 &= 0x3ffffff;\n    o[0] = w0;\n    o[1] = w1;\n    o[2] = w2;\n    o[3] = w3;\n    o[4] = w4;\n    o[5] = w5;\n    o[6] = w6;\n    o[7] = w7;\n    o[8] = w8;\n    o[9] = w9;\n    o[10] = w10;\n    o[11] = w11;\n    o[12] = w12;\n    o[13] = w13;\n    o[14] = w14;\n    o[15] = w15;\n    o[16] = w16;\n    o[17] = w17;\n    o[18] = w18;\n    if (c !== 0) {\n      o[19] = c;\n      out.length++;\n    }\n    return out;\n  };\n\n  // Polyfill comb\n  if (!Math.imul) {\n    comb10MulTo = smallMulTo;\n  }\n\n  function bigMulTo (self, num, out) {\n    out.negative = num.negative ^ self.negative;\n    out.length = self.length + num.length;\n\n    var carry = 0;\n    var hncarry = 0;\n    for (var k = 0; k < out.length - 1; k++) {\n      // Sum all words with the same `i + j = k` and accumulate `ncarry`,\n      // note that ncarry could be >= 0x3ffffff\n      var ncarry = hncarry;\n      hncarry = 0;\n      var rword = carry & 0x3ffffff;\n      var maxJ = Math.min(k, num.length - 1);\n      for (var j = Math.max(0, k - self.length + 1); j <= maxJ; j++) {\n        var i = k - j;\n        var a = self.words[i] | 0;\n        var b = num.words[j] | 0;\n        var r = a * b;\n\n        var lo = r & 0x3ffffff;\n        ncarry = (ncarry + ((r / 0x4000000) | 0)) | 0;\n        lo = (lo + rword) | 0;\n        rword = lo & 0x3ffffff;\n        ncarry = (ncarry + (lo >>> 26)) | 0;\n\n        hncarry += ncarry >>> 26;\n        ncarry &= 0x3ffffff;\n      }\n      out.words[k] = rword;\n      carry = ncarry;\n      ncarry = hncarry;\n    }\n    if (carry !== 0) {\n      out.words[k] = carry;\n    } else {\n      out.length--;\n    }\n\n    return out.strip();\n  }\n\n  function jumboMulTo (self, num, out) {\n    var fftm = new FFTM();\n    return fftm.mulp(self, num, out);\n  }\n\n  BN.prototype.mulTo = function mulTo (num, out) {\n    var res;\n    var len = this.length + num.length;\n    if (this.length === 10 && num.length === 10) {\n      res = comb10MulTo(this, num, out);\n    } else if (len < 63) {\n      res = smallMulTo(this, num, out);\n    } else if (len < 1024) {\n      res = bigMulTo(this, num, out);\n    } else {\n      res = jumboMulTo(this, num, out);\n    }\n\n    return res;\n  };\n\n  // Cooley-Tukey algorithm for FFT\n  // slightly revisited to rely on looping instead of recursion\n\n  function FFTM (x, y) {\n    this.x = x;\n    this.y = y;\n  }\n\n  FFTM.prototype.makeRBT = function makeRBT (N) {\n    var t = new Array(N);\n    var l = BN.prototype._countBits(N) - 1;\n    for (var i = 0; i < N; i++) {\n      t[i] = this.revBin(i, l, N);\n    }\n\n    return t;\n  };\n\n  // Returns binary-reversed representation of `x`\n  FFTM.prototype.revBin = function revBin (x, l, N) {\n    if (x === 0 || x === N - 1) return x;\n\n    var rb = 0;\n    for (var i = 0; i < l; i++) {\n      rb |= (x & 1) << (l - i - 1);\n      x >>= 1;\n    }\n\n    return rb;\n  };\n\n  // Performs \"tweedling\" phase, therefore 'emulating'\n  // behaviour of the recursive algorithm\n  FFTM.prototype.permute = function permute (rbt, rws, iws, rtws, itws, N) {\n    for (var i = 0; i < N; i++) {\n      rtws[i] = rws[rbt[i]];\n      itws[i] = iws[rbt[i]];\n    }\n  };\n\n  FFTM.prototype.transform = function transform (rws, iws, rtws, itws, N, rbt) {\n    this.permute(rbt, rws, iws, rtws, itws, N);\n\n    for (var s = 1; s < N; s <<= 1) {\n      var l = s << 1;\n\n      var rtwdf = Math.cos(2 * Math.PI / l);\n      var itwdf = Math.sin(2 * Math.PI / l);\n\n      for (var p = 0; p < N; p += l) {\n        var rtwdf_ = rtwdf;\n        var itwdf_ = itwdf;\n\n        for (var j = 0; j < s; j++) {\n          var re = rtws[p + j];\n          var ie = itws[p + j];\n\n          var ro = rtws[p + j + s];\n          var io = itws[p + j + s];\n\n          var rx = rtwdf_ * ro - itwdf_ * io;\n\n          io = rtwdf_ * io + itwdf_ * ro;\n          ro = rx;\n\n          rtws[p + j] = re + ro;\n          itws[p + j] = ie + io;\n\n          rtws[p + j + s] = re - ro;\n          itws[p + j + s] = ie - io;\n\n          /* jshint maxdepth : false */\n          if (j !== l) {\n            rx = rtwdf * rtwdf_ - itwdf * itwdf_;\n\n            itwdf_ = rtwdf * itwdf_ + itwdf * rtwdf_;\n            rtwdf_ = rx;\n          }\n        }\n      }\n    }\n  };\n\n  FFTM.prototype.guessLen13b = function guessLen13b (n, m) {\n    var N = Math.max(m, n) | 1;\n    var odd = N & 1;\n    var i = 0;\n    for (N = N / 2 | 0; N; N = N >>> 1) {\n      i++;\n    }\n\n    return 1 << i + 1 + odd;\n  };\n\n  FFTM.prototype.conjugate = function conjugate (rws, iws, N) {\n    if (N <= 1) return;\n\n    for (var i = 0; i < N / 2; i++) {\n      var t = rws[i];\n\n      rws[i] = rws[N - i - 1];\n      rws[N - i - 1] = t;\n\n      t = iws[i];\n\n      iws[i] = -iws[N - i - 1];\n      iws[N - i - 1] = -t;\n    }\n  };\n\n  FFTM.prototype.normalize13b = function normalize13b (ws, N) {\n    var carry = 0;\n    for (var i = 0; i < N / 2; i++) {\n      var w = Math.round(ws[2 * i + 1] / N) * 0x2000 +\n        Math.round(ws[2 * i] / N) +\n        carry;\n\n      ws[i] = w & 0x3ffffff;\n\n      if (w < 0x4000000) {\n        carry = 0;\n      } else {\n        carry = w / 0x4000000 | 0;\n      }\n    }\n\n    return ws;\n  };\n\n  FFTM.prototype.convert13b = function convert13b (ws, len, rws, N) {\n    var carry = 0;\n    for (var i = 0; i < len; i++) {\n      carry = carry + (ws[i] | 0);\n\n      rws[2 * i] = carry & 0x1fff; carry = carry >>> 13;\n      rws[2 * i + 1] = carry & 0x1fff; carry = carry >>> 13;\n    }\n\n    // Pad with zeroes\n    for (i = 2 * len; i < N; ++i) {\n      rws[i] = 0;\n    }\n\n    assert(carry === 0);\n    assert((carry & ~0x1fff) === 0);\n  };\n\n  FFTM.prototype.stub = function stub (N) {\n    var ph = new Array(N);\n    for (var i = 0; i < N; i++) {\n      ph[i] = 0;\n    }\n\n    return ph;\n  };\n\n  FFTM.prototype.mulp = function mulp (x, y, out) {\n    var N = 2 * this.guessLen13b(x.length, y.length);\n\n    var rbt = this.makeRBT(N);\n\n    var _ = this.stub(N);\n\n    var rws = new Array(N);\n    var rwst = new Array(N);\n    var iwst = new Array(N);\n\n    var nrws = new Array(N);\n    var nrwst = new Array(N);\n    var niwst = new Array(N);\n\n    var rmws = out.words;\n    rmws.length = N;\n\n    this.convert13b(x.words, x.length, rws, N);\n    this.convert13b(y.words, y.length, nrws, N);\n\n    this.transform(rws, _, rwst, iwst, N, rbt);\n    this.transform(nrws, _, nrwst, niwst, N, rbt);\n\n    for (var i = 0; i < N; i++) {\n      var rx = rwst[i] * nrwst[i] - iwst[i] * niwst[i];\n      iwst[i] = rwst[i] * niwst[i] + iwst[i] * nrwst[i];\n      rwst[i] = rx;\n    }\n\n    this.conjugate(rwst, iwst, N);\n    this.transform(rwst, iwst, rmws, _, N, rbt);\n    this.conjugate(rmws, _, N);\n    this.normalize13b(rmws, N);\n\n    out.negative = x.negative ^ y.negative;\n    out.length = x.length + y.length;\n    return out.strip();\n  };\n\n  // Multiply `this` by `num`\n  BN.prototype.mul = function mul (num) {\n    var out = new BN(null);\n    out.words = new Array(this.length + num.length);\n    return this.mulTo(num, out);\n  };\n\n  // Multiply employing FFT\n  BN.prototype.mulf = function mulf (num) {\n    var out = new BN(null);\n    out.words = new Array(this.length + num.length);\n    return jumboMulTo(this, num, out);\n  };\n\n  // In-place Multiplication\n  BN.prototype.imul = function imul (num) {\n    return this.clone().mulTo(num, this);\n  };\n\n  BN.prototype.imuln = function imuln (num) {\n    assert(typeof num === 'number');\n    assert(num < 0x4000000);\n\n    // Carry\n    var carry = 0;\n    for (var i = 0; i < this.length; i++) {\n      var w = (this.words[i] | 0) * num;\n      var lo = (w & 0x3ffffff) + (carry & 0x3ffffff);\n      carry >>= 26;\n      carry += (w / 0x4000000) | 0;\n      // NOTE: lo is 27bit maximum\n      carry += lo >>> 26;\n      this.words[i] = lo & 0x3ffffff;\n    }\n\n    if (carry !== 0) {\n      this.words[i] = carry;\n      this.length++;\n    }\n    this.length = num === 0 ? 1 : this.length;\n\n    return this;\n  };\n\n  BN.prototype.muln = function muln (num) {\n    return this.clone().imuln(num);\n  };\n\n  // `this` * `this`\n  BN.prototype.sqr = function sqr () {\n    return this.mul(this);\n  };\n\n  // `this` * `this` in-place\n  BN.prototype.isqr = function isqr () {\n    return this.imul(this.clone());\n  };\n\n  // Math.pow(`this`, `num`)\n  BN.prototype.pow = function pow (num) {\n    var w = toBitArray(num);\n    if (w.length === 0) return new BN(1);\n\n    // Skip leading zeroes\n    var res = this;\n    for (var i = 0; i < w.length; i++, res = res.sqr()) {\n      if (w[i] !== 0) break;\n    }\n\n    if (++i < w.length) {\n      for (var q = res.sqr(); i < w.length; i++, q = q.sqr()) {\n        if (w[i] === 0) continue;\n\n        res = res.mul(q);\n      }\n    }\n\n    return res;\n  };\n\n  // Shift-left in-place\n  BN.prototype.iushln = function iushln (bits) {\n    assert(typeof bits === 'number' && bits >= 0);\n    var r = bits % 26;\n    var s = (bits - r) / 26;\n    var carryMask = (0x3ffffff >>> (26 - r)) << (26 - r);\n    var i;\n\n    if (r !== 0) {\n      var carry = 0;\n\n      for (i = 0; i < this.length; i++) {\n        var newCarry = this.words[i] & carryMask;\n        var c = ((this.words[i] | 0) - newCarry) << r;\n        this.words[i] = c | carry;\n        carry = newCarry >>> (26 - r);\n      }\n\n      if (carry) {\n        this.words[i] = carry;\n        this.length++;\n      }\n    }\n\n    if (s !== 0) {\n      for (i = this.length - 1; i >= 0; i--) {\n        this.words[i + s] = this.words[i];\n      }\n\n      for (i = 0; i < s; i++) {\n        this.words[i] = 0;\n      }\n\n      this.length += s;\n    }\n\n    return this.strip();\n  };\n\n  BN.prototype.ishln = function ishln (bits) {\n    // TODO(indutny): implement me\n    assert(this.negative === 0);\n    return this.iushln(bits);\n  };\n\n  // Shift-right in-place\n  // NOTE: `hint` is a lowest bit before trailing zeroes\n  // NOTE: if `extended` is present - it will be filled with destroyed bits\n  BN.prototype.iushrn = function iushrn (bits, hint, extended) {\n    assert(typeof bits === 'number' && bits >= 0);\n    var h;\n    if (hint) {\n      h = (hint - (hint % 26)) / 26;\n    } else {\n      h = 0;\n    }\n\n    var r = bits % 26;\n    var s = Math.min((bits - r) / 26, this.length);\n    var mask = 0x3ffffff ^ ((0x3ffffff >>> r) << r);\n    var maskedWords = extended;\n\n    h -= s;\n    h = Math.max(0, h);\n\n    // Extended mode, copy masked part\n    if (maskedWords) {\n      for (var i = 0; i < s; i++) {\n        maskedWords.words[i] = this.words[i];\n      }\n      maskedWords.length = s;\n    }\n\n    if (s === 0) {\n      // No-op, we should not move anything at all\n    } else if (this.length > s) {\n      this.length -= s;\n      for (i = 0; i < this.length; i++) {\n        this.words[i] = this.words[i + s];\n      }\n    } else {\n      this.words[0] = 0;\n      this.length = 1;\n    }\n\n    var carry = 0;\n    for (i = this.length - 1; i >= 0 && (carry !== 0 || i >= h); i--) {\n      var word = this.words[i] | 0;\n      this.words[i] = (carry << (26 - r)) | (word >>> r);\n      carry = word & mask;\n    }\n\n    // Push carried bits as a mask\n    if (maskedWords && carry !== 0) {\n      maskedWords.words[maskedWords.length++] = carry;\n    }\n\n    if (this.length === 0) {\n      this.words[0] = 0;\n      this.length = 1;\n    }\n\n    return this.strip();\n  };\n\n  BN.prototype.ishrn = function ishrn (bits, hint, extended) {\n    // TODO(indutny): implement me\n    assert(this.negative === 0);\n    return this.iushrn(bits, hint, extended);\n  };\n\n  // Shift-left\n  BN.prototype.shln = function shln (bits) {\n    return this.clone().ishln(bits);\n  };\n\n  BN.prototype.ushln = function ushln (bits) {\n    return this.clone().iushln(bits);\n  };\n\n  // Shift-right\n  BN.prototype.shrn = function shrn (bits) {\n    return this.clone().ishrn(bits);\n  };\n\n  BN.prototype.ushrn = function ushrn (bits) {\n    return this.clone().iushrn(bits);\n  };\n\n  // Test if n bit is set\n  BN.prototype.testn = function testn (bit) {\n    assert(typeof bit === 'number' && bit >= 0);\n    var r = bit % 26;\n    var s = (bit - r) / 26;\n    var q = 1 << r;\n\n    // Fast case: bit is much higher than all existing words\n    if (this.length <= s) return false;\n\n    // Check bit and return\n    var w = this.words[s];\n\n    return !!(w & q);\n  };\n\n  // Return only lowers bits of number (in-place)\n  BN.prototype.imaskn = function imaskn (bits) {\n    assert(typeof bits === 'number' && bits >= 0);\n    var r = bits % 26;\n    var s = (bits - r) / 26;\n\n    assert(this.negative === 0, 'imaskn works only with positive numbers');\n\n    if (this.length <= s) {\n      return this;\n    }\n\n    if (r !== 0) {\n      s++;\n    }\n    this.length = Math.min(s, this.length);\n\n    if (r !== 0) {\n      var mask = 0x3ffffff ^ ((0x3ffffff >>> r) << r);\n      this.words[this.length - 1] &= mask;\n    }\n\n    return this.strip();\n  };\n\n  // Return only lowers bits of number\n  BN.prototype.maskn = function maskn (bits) {\n    return this.clone().imaskn(bits);\n  };\n\n  // Add plain number `num` to `this`\n  BN.prototype.iaddn = function iaddn (num) {\n    assert(typeof num === 'number');\n    assert(num < 0x4000000);\n    if (num < 0) return this.isubn(-num);\n\n    // Possible sign change\n    if (this.negative !== 0) {\n      if (this.length === 1 && (this.words[0] | 0) < num) {\n        this.words[0] = num - (this.words[0] | 0);\n        this.negative = 0;\n        return this;\n      }\n\n      this.negative = 0;\n      this.isubn(num);\n      this.negative = 1;\n      return this;\n    }\n\n    // Add without checks\n    return this._iaddn(num);\n  };\n\n  BN.prototype._iaddn = function _iaddn (num) {\n    this.words[0] += num;\n\n    // Carry\n    for (var i = 0; i < this.length && this.words[i] >= 0x4000000; i++) {\n      this.words[i] -= 0x4000000;\n      if (i === this.length - 1) {\n        this.words[i + 1] = 1;\n      } else {\n        this.words[i + 1]++;\n      }\n    }\n    this.length = Math.max(this.length, i + 1);\n\n    return this;\n  };\n\n  // Subtract plain number `num` from `this`\n  BN.prototype.isubn = function isubn (num) {\n    assert(typeof num === 'number');\n    assert(num < 0x4000000);\n    if (num < 0) return this.iaddn(-num);\n\n    if (this.negative !== 0) {\n      this.negative = 0;\n      this.iaddn(num);\n      this.negative = 1;\n      return this;\n    }\n\n    this.words[0] -= num;\n\n    if (this.length === 1 && this.words[0] < 0) {\n      this.words[0] = -this.words[0];\n      this.negative = 1;\n    } else {\n      // Carry\n      for (var i = 0; i < this.length && this.words[i] < 0; i++) {\n        this.words[i] += 0x4000000;\n        this.words[i + 1] -= 1;\n      }\n    }\n\n    return this.strip();\n  };\n\n  BN.prototype.addn = function addn (num) {\n    return this.clone().iaddn(num);\n  };\n\n  BN.prototype.subn = function subn (num) {\n    return this.clone().isubn(num);\n  };\n\n  BN.prototype.iabs = function iabs () {\n    this.negative = 0;\n\n    return this;\n  };\n\n  BN.prototype.abs = function abs () {\n    return this.clone().iabs();\n  };\n\n  BN.prototype._ishlnsubmul = function _ishlnsubmul (num, mul, shift) {\n    var len = num.length + shift;\n    var i;\n\n    this._expand(len);\n\n    var w;\n    var carry = 0;\n    for (i = 0; i < num.length; i++) {\n      w = (this.words[i + shift] | 0) + carry;\n      var right = (num.words[i] | 0) * mul;\n      w -= right & 0x3ffffff;\n      carry = (w >> 26) - ((right / 0x4000000) | 0);\n      this.words[i + shift] = w & 0x3ffffff;\n    }\n    for (; i < this.length - shift; i++) {\n      w = (this.words[i + shift] | 0) + carry;\n      carry = w >> 26;\n      this.words[i + shift] = w & 0x3ffffff;\n    }\n\n    if (carry === 0) return this.strip();\n\n    // Subtraction overflow\n    assert(carry === -1);\n    carry = 0;\n    for (i = 0; i < this.length; i++) {\n      w = -(this.words[i] | 0) + carry;\n      carry = w >> 26;\n      this.words[i] = w & 0x3ffffff;\n    }\n    this.negative = 1;\n\n    return this.strip();\n  };\n\n  BN.prototype._wordDiv = function _wordDiv (num, mode) {\n    var shift = this.length - num.length;\n\n    var a = this.clone();\n    var b = num;\n\n    // Normalize\n    var bhi = b.words[b.length - 1] | 0;\n    var bhiBits = this._countBits(bhi);\n    shift = 26 - bhiBits;\n    if (shift !== 0) {\n      b = b.ushln(shift);\n      a.iushln(shift);\n      bhi = b.words[b.length - 1] | 0;\n    }\n\n    // Initialize quotient\n    var m = a.length - b.length;\n    var q;\n\n    if (mode !== 'mod') {\n      q = new BN(null);\n      q.length = m + 1;\n      q.words = new Array(q.length);\n      for (var i = 0; i < q.length; i++) {\n        q.words[i] = 0;\n      }\n    }\n\n    var diff = a.clone()._ishlnsubmul(b, 1, m);\n    if (diff.negative === 0) {\n      a = diff;\n      if (q) {\n        q.words[m] = 1;\n      }\n    }\n\n    for (var j = m - 1; j >= 0; j--) {\n      var qj = (a.words[b.length + j] | 0) * 0x4000000 +\n        (a.words[b.length + j - 1] | 0);\n\n      // NOTE: (qj / bhi) is (0x3ffffff * 0x4000000 + 0x3ffffff) / 0x2000000 max\n      // (0x7ffffff)\n      qj = Math.min((qj / bhi) | 0, 0x3ffffff);\n\n      a._ishlnsubmul(b, qj, j);\n      while (a.negative !== 0) {\n        qj--;\n        a.negative = 0;\n        a._ishlnsubmul(b, 1, j);\n        if (!a.isZero()) {\n          a.negative ^= 1;\n        }\n      }\n      if (q) {\n        q.words[j] = qj;\n      }\n    }\n    if (q) {\n      q.strip();\n    }\n    a.strip();\n\n    // Denormalize\n    if (mode !== 'div' && shift !== 0) {\n      a.iushrn(shift);\n    }\n\n    return {\n      div: q || null,\n      mod: a\n    };\n  };\n\n  // NOTE: 1) `mode` can be set to `mod` to request mod only,\n  //       to `div` to request div only, or be absent to\n  //       request both div & mod\n  //       2) `positive` is true if unsigned mod is requested\n  BN.prototype.divmod = function divmod (num, mode, positive) {\n    assert(!num.isZero());\n\n    if (this.isZero()) {\n      return {\n        div: new BN(0),\n        mod: new BN(0)\n      };\n    }\n\n    var div, mod, res;\n    if (this.negative !== 0 && num.negative === 0) {\n      res = this.neg().divmod(num, mode);\n\n      if (mode !== 'mod') {\n        div = res.div.neg();\n      }\n\n      if (mode !== 'div') {\n        mod = res.mod.neg();\n        if (positive && mod.negative !== 0) {\n          mod.iadd(num);\n        }\n      }\n\n      return {\n        div: div,\n        mod: mod\n      };\n    }\n\n    if (this.negative === 0 && num.negative !== 0) {\n      res = this.divmod(num.neg(), mode);\n\n      if (mode !== 'mod') {\n        div = res.div.neg();\n      }\n\n      return {\n        div: div,\n        mod: res.mod\n      };\n    }\n\n    if ((this.negative & num.negative) !== 0) {\n      res = this.neg().divmod(num.neg(), mode);\n\n      if (mode !== 'div') {\n        mod = res.mod.neg();\n        if (positive && mod.negative !== 0) {\n          mod.isub(num);\n        }\n      }\n\n      return {\n        div: res.div,\n        mod: mod\n      };\n    }\n\n    // Both numbers are positive at this point\n\n    // Strip both numbers to approximate shift value\n    if (num.length > this.length || this.cmp(num) < 0) {\n      return {\n        div: new BN(0),\n        mod: this\n      };\n    }\n\n    // Very short reduction\n    if (num.length === 1) {\n      if (mode === 'div') {\n        return {\n          div: this.divn(num.words[0]),\n          mod: null\n        };\n      }\n\n      if (mode === 'mod') {\n        return {\n          div: null,\n          mod: new BN(this.modn(num.words[0]))\n        };\n      }\n\n      return {\n        div: this.divn(num.words[0]),\n        mod: new BN(this.modn(num.words[0]))\n      };\n    }\n\n    return this._wordDiv(num, mode);\n  };\n\n  // Find `this` / `num`\n  BN.prototype.div = function div (num) {\n    return this.divmod(num, 'div', false).div;\n  };\n\n  // Find `this` % `num`\n  BN.prototype.mod = function mod (num) {\n    return this.divmod(num, 'mod', false).mod;\n  };\n\n  BN.prototype.umod = function umod (num) {\n    return this.divmod(num, 'mod', true).mod;\n  };\n\n  // Find Round(`this` / `num`)\n  BN.prototype.divRound = function divRound (num) {\n    var dm = this.divmod(num);\n\n    // Fast case - exact division\n    if (dm.mod.isZero()) return dm.div;\n\n    var mod = dm.div.negative !== 0 ? dm.mod.isub(num) : dm.mod;\n\n    var half = num.ushrn(1);\n    var r2 = num.andln(1);\n    var cmp = mod.cmp(half);\n\n    // Round down\n    if (cmp < 0 || r2 === 1 && cmp === 0) return dm.div;\n\n    // Round up\n    return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1);\n  };\n\n  BN.prototype.modn = function modn (num) {\n    assert(num <= 0x3ffffff);\n    var p = (1 << 26) % num;\n\n    var acc = 0;\n    for (var i = this.length - 1; i >= 0; i--) {\n      acc = (p * acc + (this.words[i] | 0)) % num;\n    }\n\n    return acc;\n  };\n\n  // In-place division by number\n  BN.prototype.idivn = function idivn (num) {\n    assert(num <= 0x3ffffff);\n\n    var carry = 0;\n    for (var i = this.length - 1; i >= 0; i--) {\n      var w = (this.words[i] | 0) + carry * 0x4000000;\n      this.words[i] = (w / num) | 0;\n      carry = w % num;\n    }\n\n    return this.strip();\n  };\n\n  BN.prototype.divn = function divn (num) {\n    return this.clone().idivn(num);\n  };\n\n  BN.prototype.egcd = function egcd (p) {\n    assert(p.negative === 0);\n    assert(!p.isZero());\n\n    var x = this;\n    var y = p.clone();\n\n    if (x.negative !== 0) {\n      x = x.umod(p);\n    } else {\n      x = x.clone();\n    }\n\n    // A * x + B * y = x\n    var A = new BN(1);\n    var B = new BN(0);\n\n    // C * x + D * y = y\n    var C = new BN(0);\n    var D = new BN(1);\n\n    var g = 0;\n\n    while (x.isEven() && y.isEven()) {\n      x.iushrn(1);\n      y.iushrn(1);\n      ++g;\n    }\n\n    var yp = y.clone();\n    var xp = x.clone();\n\n    while (!x.isZero()) {\n      for (var i = 0, im = 1; (x.words[0] & im) === 0 && i < 26; ++i, im <<= 1);\n      if (i > 0) {\n        x.iushrn(i);\n        while (i-- > 0) {\n          if (A.isOdd() || B.isOdd()) {\n            A.iadd(yp);\n            B.isub(xp);\n          }\n\n          A.iushrn(1);\n          B.iushrn(1);\n        }\n      }\n\n      for (var j = 0, jm = 1; (y.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1);\n      if (j > 0) {\n        y.iushrn(j);\n        while (j-- > 0) {\n          if (C.isOdd() || D.isOdd()) {\n            C.iadd(yp);\n            D.isub(xp);\n          }\n\n          C.iushrn(1);\n          D.iushrn(1);\n        }\n      }\n\n      if (x.cmp(y) >= 0) {\n        x.isub(y);\n        A.isub(C);\n        B.isub(D);\n      } else {\n        y.isub(x);\n        C.isub(A);\n        D.isub(B);\n      }\n    }\n\n    return {\n      a: C,\n      b: D,\n      gcd: y.iushln(g)\n    };\n  };\n\n  // This is reduced incarnation of the binary EEA\n  // above, designated to invert members of the\n  // _prime_ fields F(p) at a maximal speed\n  BN.prototype._invmp = function _invmp (p) {\n    assert(p.negative === 0);\n    assert(!p.isZero());\n\n    var a = this;\n    var b = p.clone();\n\n    if (a.negative !== 0) {\n      a = a.umod(p);\n    } else {\n      a = a.clone();\n    }\n\n    var x1 = new BN(1);\n    var x2 = new BN(0);\n\n    var delta = b.clone();\n\n    while (a.cmpn(1) > 0 && b.cmpn(1) > 0) {\n      for (var i = 0, im = 1; (a.words[0] & im) === 0 && i < 26; ++i, im <<= 1);\n      if (i > 0) {\n        a.iushrn(i);\n        while (i-- > 0) {\n          if (x1.isOdd()) {\n            x1.iadd(delta);\n          }\n\n          x1.iushrn(1);\n        }\n      }\n\n      for (var j = 0, jm = 1; (b.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1);\n      if (j > 0) {\n        b.iushrn(j);\n        while (j-- > 0) {\n          if (x2.isOdd()) {\n            x2.iadd(delta);\n          }\n\n          x2.iushrn(1);\n        }\n      }\n\n      if (a.cmp(b) >= 0) {\n        a.isub(b);\n        x1.isub(x2);\n      } else {\n        b.isub(a);\n        x2.isub(x1);\n      }\n    }\n\n    var res;\n    if (a.cmpn(1) === 0) {\n      res = x1;\n    } else {\n      res = x2;\n    }\n\n    if (res.cmpn(0) < 0) {\n      res.iadd(p);\n    }\n\n    return res;\n  };\n\n  BN.prototype.gcd = function gcd (num) {\n    if (this.isZero()) return num.abs();\n    if (num.isZero()) return this.abs();\n\n    var a = this.clone();\n    var b = num.clone();\n    a.negative = 0;\n    b.negative = 0;\n\n    // Remove common factor of two\n    for (var shift = 0; a.isEven() && b.isEven(); shift++) {\n      a.iushrn(1);\n      b.iushrn(1);\n    }\n\n    do {\n      while (a.isEven()) {\n        a.iushrn(1);\n      }\n      while (b.isEven()) {\n        b.iushrn(1);\n      }\n\n      var r = a.cmp(b);\n      if (r < 0) {\n        // Swap `a` and `b` to make `a` always bigger than `b`\n        var t = a;\n        a = b;\n        b = t;\n      } else if (r === 0 || b.cmpn(1) === 0) {\n        break;\n      }\n\n      a.isub(b);\n    } while (true);\n\n    return b.iushln(shift);\n  };\n\n  // Invert number in the field F(num)\n  BN.prototype.invm = function invm (num) {\n    return this.egcd(num).a.umod(num);\n  };\n\n  BN.prototype.isEven = function isEven () {\n    return (this.words[0] & 1) === 0;\n  };\n\n  BN.prototype.isOdd = function isOdd () {\n    return (this.words[0] & 1) === 1;\n  };\n\n  // And first word and num\n  BN.prototype.andln = function andln (num) {\n    return this.words[0] & num;\n  };\n\n  // Increment at the bit position in-line\n  BN.prototype.bincn = function bincn (bit) {\n    assert(typeof bit === 'number');\n    var r = bit % 26;\n    var s = (bit - r) / 26;\n    var q = 1 << r;\n\n    // Fast case: bit is much higher than all existing words\n    if (this.length <= s) {\n      this._expand(s + 1);\n      this.words[s] |= q;\n      return this;\n    }\n\n    // Add bit and propagate, if needed\n    var carry = q;\n    for (var i = s; carry !== 0 && i < this.length; i++) {\n      var w = this.words[i] | 0;\n      w += carry;\n      carry = w >>> 26;\n      w &= 0x3ffffff;\n      this.words[i] = w;\n    }\n    if (carry !== 0) {\n      this.words[i] = carry;\n      this.length++;\n    }\n    return this;\n  };\n\n  BN.prototype.isZero = function isZero () {\n    return this.length === 1 && this.words[0] === 0;\n  };\n\n  BN.prototype.cmpn = function cmpn (num) {\n    var negative = num < 0;\n\n    if (this.negative !== 0 && !negative) return -1;\n    if (this.negative === 0 && negative) return 1;\n\n    this.strip();\n\n    var res;\n    if (this.length > 1) {\n      res = 1;\n    } else {\n      if (negative) {\n        num = -num;\n      }\n\n      assert(num <= 0x3ffffff, 'Number is too big');\n\n      var w = this.words[0] | 0;\n      res = w === num ? 0 : w < num ? -1 : 1;\n    }\n    if (this.negative !== 0) return -res | 0;\n    return res;\n  };\n\n  // Compare two numbers and return:\n  // 1 - if `this` > `num`\n  // 0 - if `this` == `num`\n  // -1 - if `this` < `num`\n  BN.prototype.cmp = function cmp (num) {\n    if (this.negative !== 0 && num.negative === 0) return -1;\n    if (this.negative === 0 && num.negative !== 0) return 1;\n\n    var res = this.ucmp(num);\n    if (this.negative !== 0) return -res | 0;\n    return res;\n  };\n\n  // Unsigned comparison\n  BN.prototype.ucmp = function ucmp (num) {\n    // At this point both numbers have the same sign\n    if (this.length > num.length) return 1;\n    if (this.length < num.length) return -1;\n\n    var res = 0;\n    for (var i = this.length - 1; i >= 0; i--) {\n      var a = this.words[i] | 0;\n      var b = num.words[i] | 0;\n\n      if (a === b) continue;\n      if (a < b) {\n        res = -1;\n      } else if (a > b) {\n        res = 1;\n      }\n      break;\n    }\n    return res;\n  };\n\n  BN.prototype.gtn = function gtn (num) {\n    return this.cmpn(num) === 1;\n  };\n\n  BN.prototype.gt = function gt (num) {\n    return this.cmp(num) === 1;\n  };\n\n  BN.prototype.gten = function gten (num) {\n    return this.cmpn(num) >= 0;\n  };\n\n  BN.prototype.gte = function gte (num) {\n    return this.cmp(num) >= 0;\n  };\n\n  BN.prototype.ltn = function ltn (num) {\n    return this.cmpn(num) === -1;\n  };\n\n  BN.prototype.lt = function lt (num) {\n    return this.cmp(num) === -1;\n  };\n\n  BN.prototype.lten = function lten (num) {\n    return this.cmpn(num) <= 0;\n  };\n\n  BN.prototype.lte = function lte (num) {\n    return this.cmp(num) <= 0;\n  };\n\n  BN.prototype.eqn = function eqn (num) {\n    return this.cmpn(num) === 0;\n  };\n\n  BN.prototype.eq = function eq (num) {\n    return this.cmp(num) === 0;\n  };\n\n  //\n  // A reduce context, could be using montgomery or something better, depending\n  // on the `m` itself.\n  //\n  BN.red = function red (num) {\n    return new Red(num);\n  };\n\n  BN.prototype.toRed = function toRed (ctx) {\n    assert(!this.red, 'Already a number in reduction context');\n    assert(this.negative === 0, 'red works only with positives');\n    return ctx.convertTo(this)._forceRed(ctx);\n  };\n\n  BN.prototype.fromRed = function fromRed () {\n    assert(this.red, 'fromRed works only with numbers in reduction context');\n    return this.red.convertFrom(this);\n  };\n\n  BN.prototype._forceRed = function _forceRed (ctx) {\n    this.red = ctx;\n    return this;\n  };\n\n  BN.prototype.forceRed = function forceRed (ctx) {\n    assert(!this.red, 'Already a number in reduction context');\n    return this._forceRed(ctx);\n  };\n\n  BN.prototype.redAdd = function redAdd (num) {\n    assert(this.red, 'redAdd works only with red numbers');\n    return this.red.add(this, num);\n  };\n\n  BN.prototype.redIAdd = function redIAdd (num) {\n    assert(this.red, 'redIAdd works only with red numbers');\n    return this.red.iadd(this, num);\n  };\n\n  BN.prototype.redSub = function redSub (num) {\n    assert(this.red, 'redSub works only with red numbers');\n    return this.red.sub(this, num);\n  };\n\n  BN.prototype.redISub = function redISub (num) {\n    assert(this.red, 'redISub works only with red numbers');\n    return this.red.isub(this, num);\n  };\n\n  BN.prototype.redShl = function redShl (num) {\n    assert(this.red, 'redShl works only with red numbers');\n    return this.red.shl(this, num);\n  };\n\n  BN.prototype.redMul = function redMul (num) {\n    assert(this.red, 'redMul works only with red numbers');\n    this.red._verify2(this, num);\n    return this.red.mul(this, num);\n  };\n\n  BN.prototype.redIMul = function redIMul (num) {\n    assert(this.red, 'redMul works only with red numbers');\n    this.red._verify2(this, num);\n    return this.red.imul(this, num);\n  };\n\n  BN.prototype.redSqr = function redSqr () {\n    assert(this.red, 'redSqr works only with red numbers');\n    this.red._verify1(this);\n    return this.red.sqr(this);\n  };\n\n  BN.prototype.redISqr = function redISqr () {\n    assert(this.red, 'redISqr works only with red numbers');\n    this.red._verify1(this);\n    return this.red.isqr(this);\n  };\n\n  // Square root over p\n  BN.prototype.redSqrt = function redSqrt () {\n    assert(this.red, 'redSqrt works only with red numbers');\n    this.red._verify1(this);\n    return this.red.sqrt(this);\n  };\n\n  BN.prototype.redInvm = function redInvm () {\n    assert(this.red, 'redInvm works only with red numbers');\n    this.red._verify1(this);\n    return this.red.invm(this);\n  };\n\n  // Return negative clone of `this` % `red modulo`\n  BN.prototype.redNeg = function redNeg () {\n    assert(this.red, 'redNeg works only with red numbers');\n    this.red._verify1(this);\n    return this.red.neg(this);\n  };\n\n  BN.prototype.redPow = function redPow (num) {\n    assert(this.red && !num.red, 'redPow(normalNum)');\n    this.red._verify1(this);\n    return this.red.pow(this, num);\n  };\n\n  // Prime numbers with efficient reduction\n  var primes = {\n    k256: null,\n    p224: null,\n    p192: null,\n    p25519: null\n  };\n\n  // Pseudo-Mersenne prime\n  function MPrime (name, p) {\n    // P = 2 ^ N - K\n    this.name = name;\n    this.p = new BN(p, 16);\n    this.n = this.p.bitLength();\n    this.k = new BN(1).iushln(this.n).isub(this.p);\n\n    this.tmp = this._tmp();\n  }\n\n  MPrime.prototype._tmp = function _tmp () {\n    var tmp = new BN(null);\n    tmp.words = new Array(Math.ceil(this.n / 13));\n    return tmp;\n  };\n\n  MPrime.prototype.ireduce = function ireduce (num) {\n    // Assumes that `num` is less than `P^2`\n    // num = HI * (2 ^ N - K) + HI * K + LO = HI * K + LO (mod P)\n    var r = num;\n    var rlen;\n\n    do {\n      this.split(r, this.tmp);\n      r = this.imulK(r);\n      r = r.iadd(this.tmp);\n      rlen = r.bitLength();\n    } while (rlen > this.n);\n\n    var cmp = rlen < this.n ? -1 : r.ucmp(this.p);\n    if (cmp === 0) {\n      r.words[0] = 0;\n      r.length = 1;\n    } else if (cmp > 0) {\n      r.isub(this.p);\n    } else {\n      if (r.strip !== undefined) {\n        // r is BN v4 instance\n        r.strip();\n      } else {\n        // r is BN v5 instance\n        r._strip();\n      }\n    }\n\n    return r;\n  };\n\n  MPrime.prototype.split = function split (input, out) {\n    input.iushrn(this.n, 0, out);\n  };\n\n  MPrime.prototype.imulK = function imulK (num) {\n    return num.imul(this.k);\n  };\n\n  function K256 () {\n    MPrime.call(\n      this,\n      'k256',\n      'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f');\n  }\n  inherits(K256, MPrime);\n\n  K256.prototype.split = function split (input, output) {\n    // 256 = 9 * 26 + 22\n    var mask = 0x3fffff;\n\n    var outLen = Math.min(input.length, 9);\n    for (var i = 0; i < outLen; i++) {\n      output.words[i] = input.words[i];\n    }\n    output.length = outLen;\n\n    if (input.length <= 9) {\n      input.words[0] = 0;\n      input.length = 1;\n      return;\n    }\n\n    // Shift by 9 limbs\n    var prev = input.words[9];\n    output.words[output.length++] = prev & mask;\n\n    for (i = 10; i < input.length; i++) {\n      var next = input.words[i] | 0;\n      input.words[i - 10] = ((next & mask) << 4) | (prev >>> 22);\n      prev = next;\n    }\n    prev >>>= 22;\n    input.words[i - 10] = prev;\n    if (prev === 0 && input.length > 10) {\n      input.length -= 10;\n    } else {\n      input.length -= 9;\n    }\n  };\n\n  K256.prototype.imulK = function imulK (num) {\n    // K = 0x1000003d1 = [ 0x40, 0x3d1 ]\n    num.words[num.length] = 0;\n    num.words[num.length + 1] = 0;\n    num.length += 2;\n\n    // bounded at: 0x40 * 0x3ffffff + 0x3d0 = 0x100000390\n    var lo = 0;\n    for (var i = 0; i < num.length; i++) {\n      var w = num.words[i] | 0;\n      lo += w * 0x3d1;\n      num.words[i] = lo & 0x3ffffff;\n      lo = w * 0x40 + ((lo / 0x4000000) | 0);\n    }\n\n    // Fast length reduction\n    if (num.words[num.length - 1] === 0) {\n      num.length--;\n      if (num.words[num.length - 1] === 0) {\n        num.length--;\n      }\n    }\n    return num;\n  };\n\n  function P224 () {\n    MPrime.call(\n      this,\n      'p224',\n      'ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001');\n  }\n  inherits(P224, MPrime);\n\n  function P192 () {\n    MPrime.call(\n      this,\n      'p192',\n      'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff');\n  }\n  inherits(P192, MPrime);\n\n  function P25519 () {\n    // 2 ^ 255 - 19\n    MPrime.call(\n      this,\n      '25519',\n      '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed');\n  }\n  inherits(P25519, MPrime);\n\n  P25519.prototype.imulK = function imulK (num) {\n    // K = 0x13\n    var carry = 0;\n    for (var i = 0; i < num.length; i++) {\n      var hi = (num.words[i] | 0) * 0x13 + carry;\n      var lo = hi & 0x3ffffff;\n      hi >>>= 26;\n\n      num.words[i] = lo;\n      carry = hi;\n    }\n    if (carry !== 0) {\n      num.words[num.length++] = carry;\n    }\n    return num;\n  };\n\n  // Exported mostly for testing purposes, use plain name instead\n  BN._prime = function prime (name) {\n    // Cached version of prime\n    if (primes[name]) return primes[name];\n\n    var prime;\n    if (name === 'k256') {\n      prime = new K256();\n    } else if (name === 'p224') {\n      prime = new P224();\n    } else if (name === 'p192') {\n      prime = new P192();\n    } else if (name === 'p25519') {\n      prime = new P25519();\n    } else {\n      throw new Error('Unknown prime ' + name);\n    }\n    primes[name] = prime;\n\n    return prime;\n  };\n\n  //\n  // Base reduction engine\n  //\n  function Red (m) {\n    if (typeof m === 'string') {\n      var prime = BN._prime(m);\n      this.m = prime.p;\n      this.prime = prime;\n    } else {\n      assert(m.gtn(1), 'modulus must be greater than 1');\n      this.m = m;\n      this.prime = null;\n    }\n  }\n\n  Red.prototype._verify1 = function _verify1 (a) {\n    assert(a.negative === 0, 'red works only with positives');\n    assert(a.red, 'red works only with red numbers');\n  };\n\n  Red.prototype._verify2 = function _verify2 (a, b) {\n    assert((a.negative | b.negative) === 0, 'red works only with positives');\n    assert(a.red && a.red === b.red,\n      'red works only with red numbers');\n  };\n\n  Red.prototype.imod = function imod (a) {\n    if (this.prime) return this.prime.ireduce(a)._forceRed(this);\n    return a.umod(this.m)._forceRed(this);\n  };\n\n  Red.prototype.neg = function neg (a) {\n    if (a.isZero()) {\n      return a.clone();\n    }\n\n    return this.m.sub(a)._forceRed(this);\n  };\n\n  Red.prototype.add = function add (a, b) {\n    this._verify2(a, b);\n\n    var res = a.add(b);\n    if (res.cmp(this.m) >= 0) {\n      res.isub(this.m);\n    }\n    return res._forceRed(this);\n  };\n\n  Red.prototype.iadd = function iadd (a, b) {\n    this._verify2(a, b);\n\n    var res = a.iadd(b);\n    if (res.cmp(this.m) >= 0) {\n      res.isub(this.m);\n    }\n    return res;\n  };\n\n  Red.prototype.sub = function sub (a, b) {\n    this._verify2(a, b);\n\n    var res = a.sub(b);\n    if (res.cmpn(0) < 0) {\n      res.iadd(this.m);\n    }\n    return res._forceRed(this);\n  };\n\n  Red.prototype.isub = function isub (a, b) {\n    this._verify2(a, b);\n\n    var res = a.isub(b);\n    if (res.cmpn(0) < 0) {\n      res.iadd(this.m);\n    }\n    return res;\n  };\n\n  Red.prototype.shl = function shl (a, num) {\n    this._verify1(a);\n    return this.imod(a.ushln(num));\n  };\n\n  Red.prototype.imul = function imul (a, b) {\n    this._verify2(a, b);\n    return this.imod(a.imul(b));\n  };\n\n  Red.prototype.mul = function mul (a, b) {\n    this._verify2(a, b);\n    return this.imod(a.mul(b));\n  };\n\n  Red.prototype.isqr = function isqr (a) {\n    return this.imul(a, a.clone());\n  };\n\n  Red.prototype.sqr = function sqr (a) {\n    return this.mul(a, a);\n  };\n\n  Red.prototype.sqrt = function sqrt (a) {\n    if (a.isZero()) return a.clone();\n\n    var mod3 = this.m.andln(3);\n    assert(mod3 % 2 === 1);\n\n    // Fast case\n    if (mod3 === 3) {\n      var pow = this.m.add(new BN(1)).iushrn(2);\n      return this.pow(a, pow);\n    }\n\n    // Tonelli-Shanks algorithm (Totally unoptimized and slow)\n    //\n    // Find Q and S, that Q * 2 ^ S = (P - 1)\n    var q = this.m.subn(1);\n    var s = 0;\n    while (!q.isZero() && q.andln(1) === 0) {\n      s++;\n      q.iushrn(1);\n    }\n    assert(!q.isZero());\n\n    var one = new BN(1).toRed(this);\n    var nOne = one.redNeg();\n\n    // Find quadratic non-residue\n    // NOTE: Max is such because of generalized Riemann hypothesis.\n    var lpow = this.m.subn(1).iushrn(1);\n    var z = this.m.bitLength();\n    z = new BN(2 * z * z).toRed(this);\n\n    while (this.pow(z, lpow).cmp(nOne) !== 0) {\n      z.redIAdd(nOne);\n    }\n\n    var c = this.pow(z, q);\n    var r = this.pow(a, q.addn(1).iushrn(1));\n    var t = this.pow(a, q);\n    var m = s;\n    while (t.cmp(one) !== 0) {\n      var tmp = t;\n      for (var i = 0; tmp.cmp(one) !== 0; i++) {\n        tmp = tmp.redSqr();\n      }\n      assert(i < m);\n      var b = this.pow(c, new BN(1).iushln(m - i - 1));\n\n      r = r.redMul(b);\n      c = b.redSqr();\n      t = t.redMul(c);\n      m = i;\n    }\n\n    return r;\n  };\n\n  Red.prototype.invm = function invm (a) {\n    var inv = a._invmp(this.m);\n    if (inv.negative !== 0) {\n      inv.negative = 0;\n      return this.imod(inv).redNeg();\n    } else {\n      return this.imod(inv);\n    }\n  };\n\n  Red.prototype.pow = function pow (a, num) {\n    if (num.isZero()) return new BN(1).toRed(this);\n    if (num.cmpn(1) === 0) return a.clone();\n\n    var windowSize = 4;\n    var wnd = new Array(1 << windowSize);\n    wnd[0] = new BN(1).toRed(this);\n    wnd[1] = a;\n    for (var i = 2; i < wnd.length; i++) {\n      wnd[i] = this.mul(wnd[i - 1], a);\n    }\n\n    var res = wnd[0];\n    var current = 0;\n    var currentLen = 0;\n    var start = num.bitLength() % 26;\n    if (start === 0) {\n      start = 26;\n    }\n\n    for (i = num.length - 1; i >= 0; i--) {\n      var word = num.words[i];\n      for (var j = start - 1; j >= 0; j--) {\n        var bit = (word >> j) & 1;\n        if (res !== wnd[0]) {\n          res = this.sqr(res);\n        }\n\n        if (bit === 0 && current === 0) {\n          currentLen = 0;\n          continue;\n        }\n\n        current <<= 1;\n        current |= bit;\n        currentLen++;\n        if (currentLen !== windowSize && (i !== 0 || j !== 0)) continue;\n\n        res = this.mul(res, wnd[current]);\n        currentLen = 0;\n        current = 0;\n      }\n      start = 26;\n    }\n\n    return res;\n  };\n\n  Red.prototype.convertTo = function convertTo (num) {\n    var r = num.umod(this.m);\n\n    return r === num ? r.clone() : r;\n  };\n\n  Red.prototype.convertFrom = function convertFrom (num) {\n    var res = num.clone();\n    res.red = null;\n    return res;\n  };\n\n  //\n  // Montgomery method engine\n  //\n\n  BN.mont = function mont (num) {\n    return new Mont(num);\n  };\n\n  function Mont (m) {\n    Red.call(this, m);\n\n    this.shift = this.m.bitLength();\n    if (this.shift % 26 !== 0) {\n      this.shift += 26 - (this.shift % 26);\n    }\n\n    this.r = new BN(1).iushln(this.shift);\n    this.r2 = this.imod(this.r.sqr());\n    this.rinv = this.r._invmp(this.m);\n\n    this.minv = this.rinv.mul(this.r).isubn(1).div(this.m);\n    this.minv = this.minv.umod(this.r);\n    this.minv = this.r.sub(this.minv);\n  }\n  inherits(Mont, Red);\n\n  Mont.prototype.convertTo = function convertTo (num) {\n    return this.imod(num.ushln(this.shift));\n  };\n\n  Mont.prototype.convertFrom = function convertFrom (num) {\n    var r = this.imod(num.mul(this.rinv));\n    r.red = null;\n    return r;\n  };\n\n  Mont.prototype.imul = function imul (a, b) {\n    if (a.isZero() || b.isZero()) {\n      a.words[0] = 0;\n      a.length = 1;\n      return a;\n    }\n\n    var t = a.imul(b);\n    var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);\n    var u = t.isub(c).iushrn(this.shift);\n    var res = u;\n\n    if (u.cmp(this.m) >= 0) {\n      res = u.isub(this.m);\n    } else if (u.cmpn(0) < 0) {\n      res = u.iadd(this.m);\n    }\n\n    return res._forceRed(this);\n  };\n\n  Mont.prototype.mul = function mul (a, b) {\n    if (a.isZero() || b.isZero()) return new BN(0)._forceRed(this);\n\n    var t = a.mul(b);\n    var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);\n    var u = t.isub(c).iushrn(this.shift);\n    var res = u;\n    if (u.cmp(this.m) >= 0) {\n      res = u.isub(this.m);\n    } else if (u.cmpn(0) < 0) {\n      res = u.iadd(this.m);\n    }\n\n    return res._forceRed(this);\n  };\n\n  Mont.prototype.invm = function invm (a) {\n    // (AR)^-1 * R^2 = (A^-1 * R^-1) * R^2 = A^-1 * R\n    var res = this.imod(a._invmp(this.m).mul(this.r2));\n    return res._forceRed(this);\n  };\n})(typeof module === 'undefined' || module, this);\n",
    "if (typeof Object.create === 'function') {\n  // implementation from standard node.js 'util' module\n  module.exports = function inherits(ctor, superCtor) {\n    if (superCtor) {\n      ctor.super_ = superCtor\n      ctor.prototype = Object.create(superCtor.prototype, {\n        constructor: {\n          value: ctor,\n          enumerable: false,\n          writable: true,\n          configurable: true\n        }\n      })\n    }\n  };\n} else {\n  // old school shim for old browsers\n  module.exports = function inherits(ctor, superCtor) {\n    if (superCtor) {\n      ctor.super_ = superCtor\n      var TempCtor = function () {}\n      TempCtor.prototype = superCtor.prototype\n      ctor.prototype = new TempCtor()\n      ctor.prototype.constructor = ctor\n    }\n  }\n}\n",
    "try {\n  var util = require('util');\n  /* istanbul ignore next */\n  if (typeof util.inherits !== 'function') throw '';\n  module.exports = util.inherits;\n} catch (e) {\n  /* istanbul ignore next */\n  module.exports = require('./inherits_browser.js');\n}\n",
    "/* eslint-disable node/no-deprecated-api */\n\n'use strict'\n\nvar buffer = require('buffer')\nvar Buffer = buffer.Buffer\n\nvar safer = {}\n\nvar key\n\nfor (key in buffer) {\n  if (!buffer.hasOwnProperty(key)) continue\n  if (key === 'SlowBuffer' || key === 'Buffer') continue\n  safer[key] = buffer[key]\n}\n\nvar Safer = safer.Buffer = {}\nfor (key in Buffer) {\n  if (!Buffer.hasOwnProperty(key)) continue\n  if (key === 'allocUnsafe' || key === 'allocUnsafeSlow') continue\n  Safer[key] = Buffer[key]\n}\n\nsafer.Buffer.prototype = Buffer.prototype\n\nif (!Safer.from || Safer.from === Uint8Array.from) {\n  Safer.from = function (value, encodingOrOffset, length) {\n    if (typeof value === 'number') {\n      throw new TypeError('The \"value\" argument must not be of type number. Received type ' + typeof value)\n    }\n    if (value && typeof value.length === 'undefined') {\n      throw new TypeError('The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type ' + typeof value)\n    }\n    return Buffer(value, encodingOrOffset, length)\n  }\n}\n\nif (!Safer.alloc) {\n  Safer.alloc = function (size, fill, encoding) {\n    if (typeof size !== 'number') {\n      throw new TypeError('The \"size\" argument must be of type number. Received type ' + typeof size)\n    }\n    if (size < 0 || size >= 2 * (1 << 30)) {\n      throw new RangeError('The value \"' + size + '\" is invalid for option \"size\"')\n    }\n    var buf = Buffer(size)\n    if (!fill || fill.length === 0) {\n      buf.fill(0)\n    } else if (typeof encoding === 'string') {\n      buf.fill(fill, encoding)\n    } else {\n      buf.fill(fill)\n    }\n    return buf\n  }\n}\n\nif (!safer.kStringMaxLength) {\n  try {\n    safer.kStringMaxLength = process.binding('buffer').kStringMaxLength\n  } catch (e) {\n    // we can't determine kStringMaxLength in environments where process.binding\n    // is unsupported, so let's not set it\n  }\n}\n\nif (!safer.constants) {\n  safer.constants = {\n    MAX_LENGTH: safer.kMaxLength\n  }\n  if (safer.kStringMaxLength) {\n    safer.constants.MAX_STRING_LENGTH = safer.kStringMaxLength\n  }\n}\n\nmodule.exports = safer\n",
    "'use strict';\n\nconst inherits = require('inherits');\n\nfunction Reporter(options) {\n  this._reporterState = {\n    obj: null,\n    path: [],\n    options: options || {},\n    errors: []\n  };\n}\nexports.Reporter = Reporter;\n\nReporter.prototype.isError = function isError(obj) {\n  return obj instanceof ReporterError;\n};\n\nReporter.prototype.save = function save() {\n  const state = this._reporterState;\n\n  return { obj: state.obj, pathLen: state.path.length };\n};\n\nReporter.prototype.restore = function restore(data) {\n  const state = this._reporterState;\n\n  state.obj = data.obj;\n  state.path = state.path.slice(0, data.pathLen);\n};\n\nReporter.prototype.enterKey = function enterKey(key) {\n  return this._reporterState.path.push(key);\n};\n\nReporter.prototype.exitKey = function exitKey(index) {\n  const state = this._reporterState;\n\n  state.path = state.path.slice(0, index - 1);\n};\n\nReporter.prototype.leaveKey = function leaveKey(index, key, value) {\n  const state = this._reporterState;\n\n  this.exitKey(index);\n  if (state.obj !== null)\n    state.obj[key] = value;\n};\n\nReporter.prototype.path = function path() {\n  return this._reporterState.path.join('/');\n};\n\nReporter.prototype.enterObject = function enterObject() {\n  const state = this._reporterState;\n\n  const prev = state.obj;\n  state.obj = {};\n  return prev;\n};\n\nReporter.prototype.leaveObject = function leaveObject(prev) {\n  const state = this._reporterState;\n\n  const now = state.obj;\n  state.obj = prev;\n  return now;\n};\n\nReporter.prototype.error = function error(msg) {\n  let err;\n  const state = this._reporterState;\n\n  const inherited = msg instanceof ReporterError;\n  if (inherited) {\n    err = msg;\n  } else {\n    err = new ReporterError(state.path.map(function(elem) {\n      return '[' + JSON.stringify(elem) + ']';\n    }).join(''), msg.message || msg, msg.stack);\n  }\n\n  if (!state.options.partial)\n    throw err;\n\n  if (!inherited)\n    state.errors.push(err);\n\n  return err;\n};\n\nReporter.prototype.wrapResult = function wrapResult(result) {\n  const state = this._reporterState;\n  if (!state.options.partial)\n    return result;\n\n  return {\n    result: this.isError(result) ? null : result,\n    errors: state.errors\n  };\n};\n\nfunction ReporterError(path, msg) {\n  this.path = path;\n  this.rethrow(msg);\n}\ninherits(ReporterError, Error);\n\nReporterError.prototype.rethrow = function rethrow(msg) {\n  this.message = msg + ' at: ' + (this.path || '(shallow)');\n  if (Error.captureStackTrace)\n    Error.captureStackTrace(this, ReporterError);\n\n  if (!this.stack) {\n    try {\n      // IE only adds stack when thrown\n      throw new Error(this.message);\n    } catch (e) {\n      this.stack = e.stack;\n    }\n  }\n  return this;\n};\n",
    "'use strict';\n\nconst inherits = require('inherits');\nconst Reporter = require('../base/reporter').Reporter;\nconst Buffer = require('safer-buffer').Buffer;\n\nfunction DecoderBuffer(base, options) {\n  Reporter.call(this, options);\n  if (!Buffer.isBuffer(base)) {\n    this.error('Input not Buffer');\n    return;\n  }\n\n  this.base = base;\n  this.offset = 0;\n  this.length = base.length;\n}\ninherits(DecoderBuffer, Reporter);\nexports.DecoderBuffer = DecoderBuffer;\n\nDecoderBuffer.isDecoderBuffer = function isDecoderBuffer(data) {\n  if (data instanceof DecoderBuffer) {\n    return true;\n  }\n\n  // Or accept compatible API\n  const isCompatible = typeof data === 'object' &&\n    Buffer.isBuffer(data.base) &&\n    data.constructor.name === 'DecoderBuffer' &&\n    typeof data.offset === 'number' &&\n    typeof data.length === 'number' &&\n    typeof data.save === 'function' &&\n    typeof data.restore === 'function' &&\n    typeof data.isEmpty === 'function' &&\n    typeof data.readUInt8 === 'function' &&\n    typeof data.skip === 'function' &&\n    typeof data.raw === 'function';\n\n  return isCompatible;\n};\n\nDecoderBuffer.prototype.save = function save() {\n  return { offset: this.offset, reporter: Reporter.prototype.save.call(this) };\n};\n\nDecoderBuffer.prototype.restore = function restore(save) {\n  // Return skipped data\n  const res = new DecoderBuffer(this.base);\n  res.offset = save.offset;\n  res.length = this.offset;\n\n  this.offset = save.offset;\n  Reporter.prototype.restore.call(this, save.reporter);\n\n  return res;\n};\n\nDecoderBuffer.prototype.isEmpty = function isEmpty() {\n  return this.offset === this.length;\n};\n\nDecoderBuffer.prototype.readUInt8 = function readUInt8(fail) {\n  if (this.offset + 1 <= this.length)\n    return this.base.readUInt8(this.offset++, true);\n  else\n    return this.error(fail || 'DecoderBuffer overrun');\n};\n\nDecoderBuffer.prototype.skip = function skip(bytes, fail) {\n  if (!(this.offset + bytes <= this.length))\n    return this.error(fail || 'DecoderBuffer overrun');\n\n  const res = new DecoderBuffer(this.base);\n\n  // Share reporter state\n  res._reporterState = this._reporterState;\n\n  res.offset = this.offset;\n  res.length = this.offset + bytes;\n  this.offset += bytes;\n  return res;\n};\n\nDecoderBuffer.prototype.raw = function raw(save) {\n  return this.base.slice(save ? save.offset : this.offset, this.length);\n};\n\nfunction EncoderBuffer(value, reporter) {\n  if (Array.isArray(value)) {\n    this.length = 0;\n    this.value = value.map(function(item) {\n      if (!EncoderBuffer.isEncoderBuffer(item))\n        item = new EncoderBuffer(item, reporter);\n      this.length += item.length;\n      return item;\n    }, this);\n  } else if (typeof value === 'number') {\n    if (!(0 <= value && value <= 0xff))\n      return reporter.error('non-byte EncoderBuffer value');\n    this.value = value;\n    this.length = 1;\n  } else if (typeof value === 'string') {\n    this.value = value;\n    this.length = Buffer.byteLength(value);\n  } else if (Buffer.isBuffer(value)) {\n    this.value = value;\n    this.length = value.length;\n  } else {\n    return reporter.error('Unsupported type: ' + typeof value);\n  }\n}\nexports.EncoderBuffer = EncoderBuffer;\n\nEncoderBuffer.isEncoderBuffer = function isEncoderBuffer(data) {\n  if (data instanceof EncoderBuffer) {\n    return true;\n  }\n\n  // Or accept compatible API\n  const isCompatible = typeof data === 'object' &&\n    data.constructor.name === 'EncoderBuffer' &&\n    typeof data.length === 'number' &&\n    typeof data.join === 'function';\n\n  return isCompatible;\n};\n\nEncoderBuffer.prototype.join = function join(out, offset) {\n  if (!out)\n    out = Buffer.alloc(this.length);\n  if (!offset)\n    offset = 0;\n\n  if (this.length === 0)\n    return out;\n\n  if (Array.isArray(this.value)) {\n    this.value.forEach(function(item) {\n      item.join(out, offset);\n      offset += item.length;\n    });\n  } else {\n    if (typeof this.value === 'number')\n      out[offset] = this.value;\n    else if (typeof this.value === 'string')\n      out.write(this.value, offset);\n    else if (Buffer.isBuffer(this.value))\n      this.value.copy(out, offset);\n    offset += this.length;\n  }\n\n  return out;\n};\n",
    "module.exports = assert;\n\nfunction assert(val, msg) {\n  if (!val)\n    throw new Error(msg || 'Assertion failed');\n}\n\nassert.equal = function assertEqual(l, r, msg) {\n  if (l != r)\n    throw new Error(msg || ('Assertion failed: ' + l + ' != ' + r));\n};\n",
    "'use strict';\n\nconst Reporter = require('../base/reporter').Reporter;\nconst EncoderBuffer = require('../base/buffer').EncoderBuffer;\nconst DecoderBuffer = require('../base/buffer').DecoderBuffer;\nconst assert = require('minimalistic-assert');\n\n// Supported tags\nconst tags = [\n  'seq', 'seqof', 'set', 'setof', 'objid', 'bool',\n  'gentime', 'utctime', 'null_', 'enum', 'int', 'objDesc',\n  'bitstr', 'bmpstr', 'charstr', 'genstr', 'graphstr', 'ia5str', 'iso646str',\n  'numstr', 'octstr', 'printstr', 't61str', 'unistr', 'utf8str', 'videostr'\n];\n\n// Public methods list\nconst methods = [\n  'key', 'obj', 'use', 'optional', 'explicit', 'implicit', 'def', 'choice',\n  'any', 'contains'\n].concat(tags);\n\n// Overrided methods list\nconst overrided = [\n  '_peekTag', '_decodeTag', '_use',\n  '_decodeStr', '_decodeObjid', '_decodeTime',\n  '_decodeNull', '_decodeInt', '_decodeBool', '_decodeList',\n\n  '_encodeComposite', '_encodeStr', '_encodeObjid', '_encodeTime',\n  '_encodeNull', '_encodeInt', '_encodeBool'\n];\n\nfunction Node(enc, parent, name) {\n  const state = {};\n  this._baseState = state;\n\n  state.name = name;\n  state.enc = enc;\n\n  state.parent = parent || null;\n  state.children = null;\n\n  // State\n  state.tag = null;\n  state.args = null;\n  state.reverseArgs = null;\n  state.choice = null;\n  state.optional = false;\n  state.any = false;\n  state.obj = false;\n  state.use = null;\n  state.useDecoder = null;\n  state.key = null;\n  state['default'] = null;\n  state.explicit = null;\n  state.implicit = null;\n  state.contains = null;\n\n  // Should create new instance on each method\n  if (!state.parent) {\n    state.children = [];\n    this._wrap();\n  }\n}\nmodule.exports = Node;\n\nconst stateProps = [\n  'enc', 'parent', 'children', 'tag', 'args', 'reverseArgs', 'choice',\n  'optional', 'any', 'obj', 'use', 'alteredUse', 'key', 'default', 'explicit',\n  'implicit', 'contains'\n];\n\nNode.prototype.clone = function clone() {\n  const state = this._baseState;\n  const cstate = {};\n  stateProps.forEach(function(prop) {\n    cstate[prop] = state[prop];\n  });\n  const res = new this.constructor(cstate.parent);\n  res._baseState = cstate;\n  return res;\n};\n\nNode.prototype._wrap = function wrap() {\n  const state = this._baseState;\n  methods.forEach(function(method) {\n    this[method] = function _wrappedMethod() {\n      const clone = new this.constructor(this);\n      state.children.push(clone);\n      return clone[method].apply(clone, arguments);\n    };\n  }, this);\n};\n\nNode.prototype._init = function init(body) {\n  const state = this._baseState;\n\n  assert(state.parent === null);\n  body.call(this);\n\n  // Filter children\n  state.children = state.children.filter(function(child) {\n    return child._baseState.parent === this;\n  }, this);\n  assert.equal(state.children.length, 1, 'Root node can have only one child');\n};\n\nNode.prototype._useArgs = function useArgs(args) {\n  const state = this._baseState;\n\n  // Filter children and args\n  const children = args.filter(function(arg) {\n    return arg instanceof this.constructor;\n  }, this);\n  args = args.filter(function(arg) {\n    return !(arg instanceof this.constructor);\n  }, this);\n\n  if (children.length !== 0) {\n    assert(state.children === null);\n    state.children = children;\n\n    // Replace parent to maintain backward link\n    children.forEach(function(child) {\n      child._baseState.parent = this;\n    }, this);\n  }\n  if (args.length !== 0) {\n    assert(state.args === null);\n    state.args = args;\n    state.reverseArgs = args.map(function(arg) {\n      if (typeof arg !== 'object' || arg.constructor !== Object)\n        return arg;\n\n      const res = {};\n      Object.keys(arg).forEach(function(key) {\n        if (key == (key | 0))\n          key |= 0;\n        const value = arg[key];\n        res[value] = key;\n      });\n      return res;\n    });\n  }\n};\n\n//\n// Overrided methods\n//\n\noverrided.forEach(function(method) {\n  Node.prototype[method] = function _overrided() {\n    const state = this._baseState;\n    throw new Error(method + ' not implemented for encoding: ' + state.enc);\n  };\n});\n\n//\n// Public methods\n//\n\ntags.forEach(function(tag) {\n  Node.prototype[tag] = function _tagMethod() {\n    const state = this._baseState;\n    const args = Array.prototype.slice.call(arguments);\n\n    assert(state.tag === null);\n    state.tag = tag;\n\n    this._useArgs(args);\n\n    return this;\n  };\n});\n\nNode.prototype.use = function use(item) {\n  assert(item);\n  const state = this._baseState;\n\n  assert(state.use === null);\n  state.use = item;\n\n  return this;\n};\n\nNode.prototype.optional = function optional() {\n  const state = this._baseState;\n\n  state.optional = true;\n\n  return this;\n};\n\nNode.prototype.def = function def(val) {\n  const state = this._baseState;\n\n  assert(state['default'] === null);\n  state['default'] = val;\n  state.optional = true;\n\n  return this;\n};\n\nNode.prototype.explicit = function explicit(num) {\n  const state = this._baseState;\n\n  assert(state.explicit === null && state.implicit === null);\n  state.explicit = num;\n\n  return this;\n};\n\nNode.prototype.implicit = function implicit(num) {\n  const state = this._baseState;\n\n  assert(state.explicit === null && state.implicit === null);\n  state.implicit = num;\n\n  return this;\n};\n\nNode.prototype.obj = function obj() {\n  const state = this._baseState;\n  const args = Array.prototype.slice.call(arguments);\n\n  state.obj = true;\n\n  if (args.length !== 0)\n    this._useArgs(args);\n\n  return this;\n};\n\nNode.prototype.key = function key(newKey) {\n  const state = this._baseState;\n\n  assert(state.key === null);\n  state.key = newKey;\n\n  return this;\n};\n\nNode.prototype.any = function any() {\n  const state = this._baseState;\n\n  state.any = true;\n\n  return this;\n};\n\nNode.prototype.choice = function choice(obj) {\n  const state = this._baseState;\n\n  assert(state.choice === null);\n  state.choice = obj;\n  this._useArgs(Object.keys(obj).map(function(key) {\n    return obj[key];\n  }));\n\n  return this;\n};\n\nNode.prototype.contains = function contains(item) {\n  const state = this._baseState;\n\n  assert(state.use === null);\n  state.contains = item;\n\n  return this;\n};\n\n//\n// Decoding\n//\n\nNode.prototype._decode = function decode(input, options) {\n  const state = this._baseState;\n\n  // Decode root node\n  if (state.parent === null)\n    return input.wrapResult(state.children[0]._decode(input, options));\n\n  let result = state['default'];\n  let present = true;\n\n  let prevKey = null;\n  if (state.key !== null)\n    prevKey = input.enterKey(state.key);\n\n  // Check if tag is there\n  if (state.optional) {\n    let tag = null;\n    if (state.explicit !== null)\n      tag = state.explicit;\n    else if (state.implicit !== null)\n      tag = state.implicit;\n    else if (state.tag !== null)\n      tag = state.tag;\n\n    if (tag === null && !state.any) {\n      // Trial and Error\n      const save = input.save();\n      try {\n        if (state.choice === null)\n          this._decodeGeneric(state.tag, input, options);\n        else\n          this._decodeChoice(input, options);\n        present = true;\n      } catch (e) {\n        present = false;\n      }\n      input.restore(save);\n    } else {\n      present = this._peekTag(input, tag, state.any);\n\n      if (input.isError(present))\n        return present;\n    }\n  }\n\n  // Push object on stack\n  let prevObj;\n  if (state.obj && present)\n    prevObj = input.enterObject();\n\n  if (present) {\n    // Unwrap explicit values\n    if (state.explicit !== null) {\n      const explicit = this._decodeTag(input, state.explicit);\n      if (input.isError(explicit))\n        return explicit;\n      input = explicit;\n    }\n\n    const start = input.offset;\n\n    // Unwrap implicit and normal values\n    if (state.use === null && state.choice === null) {\n      let save;\n      if (state.any)\n        save = input.save();\n      const body = this._decodeTag(\n        input,\n        state.implicit !== null ? state.implicit : state.tag,\n        state.any\n      );\n      if (input.isError(body))\n        return body;\n\n      if (state.any)\n        result = input.raw(save);\n      else\n        input = body;\n    }\n\n    if (options && options.track && state.tag !== null)\n      options.track(input.path(), start, input.length, 'tagged');\n\n    if (options && options.track && state.tag !== null)\n      options.track(input.path(), input.offset, input.length, 'content');\n\n    // Select proper method for tag\n    if (state.any) {\n      // no-op\n    } else if (state.choice === null) {\n      result = this._decodeGeneric(state.tag, input, options);\n    } else {\n      result = this._decodeChoice(input, options);\n    }\n\n    if (input.isError(result))\n      return result;\n\n    // Decode children\n    if (!state.any && state.choice === null && state.children !== null) {\n      state.children.forEach(function decodeChildren(child) {\n        // NOTE: We are ignoring errors here, to let parser continue with other\n        // parts of encoded data\n        child._decode(input, options);\n      });\n    }\n\n    // Decode contained/encoded by schema, only in bit or octet strings\n    if (state.contains && (state.tag === 'octstr' || state.tag === 'bitstr')) {\n      const data = new DecoderBuffer(result);\n      result = this._getUse(state.contains, input._reporterState.obj)\n        ._decode(data, options);\n    }\n  }\n\n  // Pop object\n  if (state.obj && present)\n    result = input.leaveObject(prevObj);\n\n  // Set key\n  if (state.key !== null && (result !== null || present === true))\n    input.leaveKey(prevKey, state.key, result);\n  else if (prevKey !== null)\n    input.exitKey(prevKey);\n\n  return result;\n};\n\nNode.prototype._decodeGeneric = function decodeGeneric(tag, input, options) {\n  const state = this._baseState;\n\n  if (tag === 'seq' || tag === 'set')\n    return null;\n  if (tag === 'seqof' || tag === 'setof')\n    return this._decodeList(input, tag, state.args[0], options);\n  else if (/str$/.test(tag))\n    return this._decodeStr(input, tag, options);\n  else if (tag === 'objid' && state.args)\n    return this._decodeObjid(input, state.args[0], state.args[1], options);\n  else if (tag === 'objid')\n    return this._decodeObjid(input, null, null, options);\n  else if (tag === 'gentime' || tag === 'utctime')\n    return this._decodeTime(input, tag, options);\n  else if (tag === 'null_')\n    return this._decodeNull(input, options);\n  else if (tag === 'bool')\n    return this._decodeBool(input, options);\n  else if (tag === 'objDesc')\n    return this._decodeStr(input, tag, options);\n  else if (tag === 'int' || tag === 'enum')\n    return this._decodeInt(input, state.args && state.args[0], options);\n\n  if (state.use !== null) {\n    return this._getUse(state.use, input._reporterState.obj)\n      ._decode(input, options);\n  } else {\n    return input.error('unknown tag: ' + tag);\n  }\n};\n\nNode.prototype._getUse = function _getUse(entity, obj) {\n\n  const state = this._baseState;\n  // Create altered use decoder if implicit is set\n  state.useDecoder = this._use(entity, obj);\n  assert(state.useDecoder._baseState.parent === null);\n  state.useDecoder = state.useDecoder._baseState.children[0];\n  if (state.implicit !== state.useDecoder._baseState.implicit) {\n    state.useDecoder = state.useDecoder.clone();\n    state.useDecoder._baseState.implicit = state.implicit;\n  }\n  return state.useDecoder;\n};\n\nNode.prototype._decodeChoice = function decodeChoice(input, options) {\n  const state = this._baseState;\n  let result = null;\n  let match = false;\n\n  Object.keys(state.choice).some(function(key) {\n    const save = input.save();\n    const node = state.choice[key];\n    try {\n      const value = node._decode(input, options);\n      if (input.isError(value))\n        return false;\n\n      result = { type: key, value: value };\n      match = true;\n    } catch (e) {\n      input.restore(save);\n      return false;\n    }\n    return true;\n  }, this);\n\n  if (!match)\n    return input.error('Choice not matched');\n\n  return result;\n};\n\n//\n// Encoding\n//\n\nNode.prototype._createEncoderBuffer = function createEncoderBuffer(data) {\n  return new EncoderBuffer(data, this.reporter);\n};\n\nNode.prototype._encode = function encode(data, reporter, parent) {\n  const state = this._baseState;\n  if (state['default'] !== null && state['default'] === data)\n    return;\n\n  const result = this._encodeValue(data, reporter, parent);\n  if (result === undefined)\n    return;\n\n  if (this._skipDefault(result, reporter, parent))\n    return;\n\n  return result;\n};\n\nNode.prototype._encodeValue = function encode(data, reporter, parent) {\n  const state = this._baseState;\n\n  // Decode root node\n  if (state.parent === null)\n    return state.children[0]._encode(data, reporter || new Reporter());\n\n  let result = null;\n\n  // Set reporter to share it with a child class\n  this.reporter = reporter;\n\n  // Check if data is there\n  if (state.optional && data === undefined) {\n    if (state['default'] !== null)\n      data = state['default'];\n    else\n      return;\n  }\n\n  // Encode children first\n  let content = null;\n  let primitive = false;\n  if (state.any) {\n    // Anything that was given is translated to buffer\n    result = this._createEncoderBuffer(data);\n  } else if (state.choice) {\n    result = this._encodeChoice(data, reporter);\n  } else if (state.contains) {\n    content = this._getUse(state.contains, parent)._encode(data, reporter);\n    primitive = true;\n  } else if (state.children) {\n    content = state.children.map(function(child) {\n      if (child._baseState.tag === 'null_')\n        return child._encode(null, reporter, data);\n\n      if (child._baseState.key === null)\n        return reporter.error('Child should have a key');\n      const prevKey = reporter.enterKey(child._baseState.key);\n\n      if (typeof data !== 'object')\n        return reporter.error('Child expected, but input is not object');\n\n      const res = child._encode(data[child._baseState.key], reporter, data);\n      reporter.leaveKey(prevKey);\n\n      return res;\n    }, this).filter(function(child) {\n      return child;\n    });\n    content = this._createEncoderBuffer(content);\n  } else {\n    if (state.tag === 'seqof' || state.tag === 'setof') {\n      // TODO(indutny): this should be thrown on DSL level\n      if (!(state.args && state.args.length === 1))\n        return reporter.error('Too many args for : ' + state.tag);\n\n      if (!Array.isArray(data))\n        return reporter.error('seqof/setof, but data is not Array');\n\n      const child = this.clone();\n      child._baseState.implicit = null;\n      content = this._createEncoderBuffer(data.map(function(item) {\n        const state = this._baseState;\n\n        return this._getUse(state.args[0], data)._encode(item, reporter);\n      }, child));\n    } else if (state.use !== null) {\n      result = this._getUse(state.use, parent)._encode(data, reporter);\n    } else {\n      content = this._encodePrimitive(state.tag, data);\n      primitive = true;\n    }\n  }\n\n  // Encode data itself\n  if (!state.any && state.choice === null) {\n    const tag = state.implicit !== null ? state.implicit : state.tag;\n    const cls = state.implicit === null ? 'universal' : 'context';\n\n    if (tag === null) {\n      if (state.use === null)\n        reporter.error('Tag could be omitted only for .use()');\n    } else {\n      if (state.use === null)\n        result = this._encodeComposite(tag, primitive, cls, content);\n    }\n  }\n\n  // Wrap in explicit\n  if (state.explicit !== null)\n    result = this._encodeComposite(state.explicit, false, 'context', result);\n\n  return result;\n};\n\nNode.prototype._encodeChoice = function encodeChoice(data, reporter) {\n  const state = this._baseState;\n\n  const node = state.choice[data.type];\n  if (!node) {\n    assert(\n      false,\n      data.type + ' not found in ' +\n            JSON.stringify(Object.keys(state.choice)));\n  }\n  return node._encode(data.value, reporter);\n};\n\nNode.prototype._encodePrimitive = function encodePrimitive(tag, data) {\n  const state = this._baseState;\n\n  if (/str$/.test(tag))\n    return this._encodeStr(data, tag);\n  else if (tag === 'objid' && state.args)\n    return this._encodeObjid(data, state.reverseArgs[0], state.args[1]);\n  else if (tag === 'objid')\n    return this._encodeObjid(data, null, null);\n  else if (tag === 'gentime' || tag === 'utctime')\n    return this._encodeTime(data, tag);\n  else if (tag === 'null_')\n    return this._encodeNull();\n  else if (tag === 'int' || tag === 'enum')\n    return this._encodeInt(data, state.args && state.reverseArgs[0]);\n  else if (tag === 'bool')\n    return this._encodeBool(data);\n  else if (tag === 'objDesc')\n    return this._encodeStr(data, tag);\n  else\n    throw new Error('Unsupported tag: ' + tag);\n};\n\nNode.prototype._isNumstr = function isNumstr(str) {\n  return /^[0-9 ]*$/.test(str);\n};\n\nNode.prototype._isPrintstr = function isPrintstr(str) {\n  return /^[A-Za-z0-9 '()+,-./:=?]*$/.test(str);\n};\n",
    "'use strict';\n\n// Helper\nfunction reverse(map) {\n  const res = {};\n\n  Object.keys(map).forEach(function(key) {\n    // Convert key to integer if it is stringified\n    if ((key | 0) == key)\n      key = key | 0;\n\n    const value = map[key];\n    res[value] = key;\n  });\n\n  return res;\n}\n\nexports.tagClass = {\n  0: 'universal',\n  1: 'application',\n  2: 'context',\n  3: 'private'\n};\nexports.tagClassByName = reverse(exports.tagClass);\n\nexports.tag = {\n  0x00: 'end',\n  0x01: 'bool',\n  0x02: 'int',\n  0x03: 'bitstr',\n  0x04: 'octstr',\n  0x05: 'null_',\n  0x06: 'objid',\n  0x07: 'objDesc',\n  0x08: 'external',\n  0x09: 'real',\n  0x0a: 'enum',\n  0x0b: 'embed',\n  0x0c: 'utf8str',\n  0x0d: 'relativeOid',\n  0x10: 'seq',\n  0x11: 'set',\n  0x12: 'numstr',\n  0x13: 'printstr',\n  0x14: 't61str',\n  0x15: 'videostr',\n  0x16: 'ia5str',\n  0x17: 'utctime',\n  0x18: 'gentime',\n  0x19: 'graphstr',\n  0x1a: 'iso646str',\n  0x1b: 'genstr',\n  0x1c: 'unistr',\n  0x1d: 'charstr',\n  0x1e: 'bmpstr'\n};\nexports.tagByName = reverse(exports.tag);\n",
    "'use strict';\n\nconst inherits = require('inherits');\nconst Buffer = require('safer-buffer').Buffer;\nconst Node = require('../base/node');\n\n// Import DER constants\nconst der = require('../constants/der');\n\nfunction DEREncoder(entity) {\n  this.enc = 'der';\n  this.name = entity.name;\n  this.entity = entity;\n\n  // Construct base tree\n  this.tree = new DERNode();\n  this.tree._init(entity.body);\n}\nmodule.exports = DEREncoder;\n\nDEREncoder.prototype.encode = function encode(data, reporter) {\n  return this.tree._encode(data, reporter).join();\n};\n\n// Tree methods\n\nfunction DERNode(parent) {\n  Node.call(this, 'der', parent);\n}\ninherits(DERNode, Node);\n\nDERNode.prototype._encodeComposite = function encodeComposite(tag,\n  primitive,\n  cls,\n  content) {\n  const encodedTag = encodeTag(tag, primitive, cls, this.reporter);\n\n  // Short form\n  if (content.length < 0x80) {\n    const header = Buffer.alloc(2);\n    header[0] = encodedTag;\n    header[1] = content.length;\n    return this._createEncoderBuffer([ header, content ]);\n  }\n\n  // Long form\n  // Count octets required to store length\n  let lenOctets = 1;\n  for (let i = content.length; i >= 0x100; i >>= 8)\n    lenOctets++;\n\n  const header = Buffer.alloc(1 + 1 + lenOctets);\n  header[0] = encodedTag;\n  header[1] = 0x80 | lenOctets;\n\n  for (let i = 1 + lenOctets, j = content.length; j > 0; i--, j >>= 8)\n    header[i] = j & 0xff;\n\n  return this._createEncoderBuffer([ header, content ]);\n};\n\nDERNode.prototype._encodeStr = function encodeStr(str, tag) {\n  if (tag === 'bitstr') {\n    return this._createEncoderBuffer([ str.unused | 0, str.data ]);\n  } else if (tag === 'bmpstr') {\n    const buf = Buffer.alloc(str.length * 2);\n    for (let i = 0; i < str.length; i++) {\n      buf.writeUInt16BE(str.charCodeAt(i), i * 2);\n    }\n    return this._createEncoderBuffer(buf);\n  } else if (tag === 'numstr') {\n    if (!this._isNumstr(str)) {\n      return this.reporter.error('Encoding of string type: numstr supports ' +\n                                 'only digits and space');\n    }\n    return this._createEncoderBuffer(str);\n  } else if (tag === 'printstr') {\n    if (!this._isPrintstr(str)) {\n      return this.reporter.error('Encoding of string type: printstr supports ' +\n                                 'only latin upper and lower case letters, ' +\n                                 'digits, space, apostrophe, left and rigth ' +\n                                 'parenthesis, plus sign, comma, hyphen, ' +\n                                 'dot, slash, colon, equal sign, ' +\n                                 'question mark');\n    }\n    return this._createEncoderBuffer(str);\n  } else if (/str$/.test(tag)) {\n    return this._createEncoderBuffer(str);\n  } else if (tag === 'objDesc') {\n    return this._createEncoderBuffer(str);\n  } else {\n    return this.reporter.error('Encoding of string type: ' + tag +\n                               ' unsupported');\n  }\n};\n\nDERNode.prototype._encodeObjid = function encodeObjid(id, values, relative) {\n  if (typeof id === 'string') {\n    if (!values)\n      return this.reporter.error('string objid given, but no values map found');\n    if (!values.hasOwnProperty(id))\n      return this.reporter.error('objid not found in values map');\n    id = values[id].split(/[\\s.]+/g);\n    for (let i = 0; i < id.length; i++)\n      id[i] |= 0;\n  } else if (Array.isArray(id)) {\n    id = id.slice();\n    for (let i = 0; i < id.length; i++)\n      id[i] |= 0;\n  }\n\n  if (!Array.isArray(id)) {\n    return this.reporter.error('objid() should be either array or string, ' +\n                               'got: ' + JSON.stringify(id));\n  }\n\n  if (!relative) {\n    if (id[1] >= 40)\n      return this.reporter.error('Second objid identifier OOB');\n    id.splice(0, 2, id[0] * 40 + id[1]);\n  }\n\n  // Count number of octets\n  let size = 0;\n  for (let i = 0; i < id.length; i++) {\n    let ident = id[i];\n    for (size++; ident >= 0x80; ident >>= 7)\n      size++;\n  }\n\n  const objid = Buffer.alloc(size);\n  let offset = objid.length - 1;\n  for (let i = id.length - 1; i >= 0; i--) {\n    let ident = id[i];\n    objid[offset--] = ident & 0x7f;\n    while ((ident >>= 7) > 0)\n      objid[offset--] = 0x80 | (ident & 0x7f);\n  }\n\n  return this._createEncoderBuffer(objid);\n};\n\nfunction two(num) {\n  if (num < 10)\n    return '0' + num;\n  else\n    return num;\n}\n\nDERNode.prototype._encodeTime = function encodeTime(time, tag) {\n  let str;\n  const date = new Date(time);\n\n  if (tag === 'gentime') {\n    str = [\n      two(date.getUTCFullYear()),\n      two(date.getUTCMonth() + 1),\n      two(date.getUTCDate()),\n      two(date.getUTCHours()),\n      two(date.getUTCMinutes()),\n      two(date.getUTCSeconds()),\n      'Z'\n    ].join('');\n  } else if (tag === 'utctime') {\n    str = [\n      two(date.getUTCFullYear() % 100),\n      two(date.getUTCMonth() + 1),\n      two(date.getUTCDate()),\n      two(date.getUTCHours()),\n      two(date.getUTCMinutes()),\n      two(date.getUTCSeconds()),\n      'Z'\n    ].join('');\n  } else {\n    this.reporter.error('Encoding ' + tag + ' time is not supported yet');\n  }\n\n  return this._encodeStr(str, 'octstr');\n};\n\nDERNode.prototype._encodeNull = function encodeNull() {\n  return this._createEncoderBuffer('');\n};\n\nDERNode.prototype._encodeInt = function encodeInt(num, values) {\n  if (typeof num === 'string') {\n    if (!values)\n      return this.reporter.error('String int or enum given, but no values map');\n    if (!values.hasOwnProperty(num)) {\n      return this.reporter.error('Values map doesn\\'t contain: ' +\n                                 JSON.stringify(num));\n    }\n    num = values[num];\n  }\n\n  // Bignum, assume big endian\n  if (typeof num !== 'number' && !Buffer.isBuffer(num)) {\n    const numArray = num.toArray();\n    if (!num.sign && numArray[0] & 0x80) {\n      numArray.unshift(0);\n    }\n    num = Buffer.from(numArray);\n  }\n\n  if (Buffer.isBuffer(num)) {\n    let size = num.length;\n    if (num.length === 0)\n      size++;\n\n    const out = Buffer.alloc(size);\n    num.copy(out);\n    if (num.length === 0)\n      out[0] = 0;\n    return this._createEncoderBuffer(out);\n  }\n\n  if (num < 0x80)\n    return this._createEncoderBuffer(num);\n\n  if (num < 0x100)\n    return this._createEncoderBuffer([0, num]);\n\n  let size = 1;\n  for (let i = num; i >= 0x100; i >>= 8)\n    size++;\n\n  const out = new Array(size);\n  for (let i = out.length - 1; i >= 0; i--) {\n    out[i] = num & 0xff;\n    num >>= 8;\n  }\n  if(out[0] & 0x80) {\n    out.unshift(0);\n  }\n\n  return this._createEncoderBuffer(Buffer.from(out));\n};\n\nDERNode.prototype._encodeBool = function encodeBool(value) {\n  return this._createEncoderBuffer(value ? 0xff : 0);\n};\n\nDERNode.prototype._use = function use(entity, obj) {\n  if (typeof entity === 'function')\n    entity = entity(obj);\n  return entity._getEncoder('der').tree;\n};\n\nDERNode.prototype._skipDefault = function skipDefault(dataBuffer, reporter, parent) {\n  const state = this._baseState;\n  let i;\n  if (state['default'] === null)\n    return false;\n\n  const data = dataBuffer.join();\n  if (state.defaultBuffer === undefined)\n    state.defaultBuffer = this._encodeValue(state['default'], reporter, parent).join();\n\n  if (data.length !== state.defaultBuffer.length)\n    return false;\n\n  for (i=0; i < data.length; i++)\n    if (data[i] !== state.defaultBuffer[i])\n      return false;\n\n  return true;\n};\n\n// Utility methods\n\nfunction encodeTag(tag, primitive, cls, reporter) {\n  let res;\n\n  if (tag === 'seqof')\n    tag = 'seq';\n  else if (tag === 'setof')\n    tag = 'set';\n\n  if (der.tagByName.hasOwnProperty(tag))\n    res = der.tagByName[tag];\n  else if (typeof tag === 'number' && (tag | 0) === tag)\n    res = tag;\n  else\n    return reporter.error('Unknown tag: ' + tag);\n\n  if (res >= 0x1f)\n    return reporter.error('Multi-octet tag encoding unsupported');\n\n  if (!primitive)\n    res |= 0x20;\n\n  res |= (der.tagClassByName[cls || 'universal'] << 6);\n\n  return res;\n}\n",
    "'use strict';\n\nconst inherits = require('inherits');\n\nconst DEREncoder = require('./der');\n\nfunction PEMEncoder(entity) {\n  DEREncoder.call(this, entity);\n  this.enc = 'pem';\n}\ninherits(PEMEncoder, DEREncoder);\nmodule.exports = PEMEncoder;\n\nPEMEncoder.prototype.encode = function encode(data, options) {\n  const buf = DEREncoder.prototype.encode.call(this, data);\n\n  const p = buf.toString('base64');\n  const out = [ '-----BEGIN ' + options.label + '-----' ];\n  for (let i = 0; i < p.length; i += 64)\n    out.push(p.slice(i, i + 64));\n  out.push('-----END ' + options.label + '-----');\n  return out.join('\\n');\n};\n",
    "'use strict';\n\nconst encoders = exports;\n\nencoders.der = require('./der');\nencoders.pem = require('./pem');\n",
    "'use strict';\n\nconst inherits = require('inherits');\n\nconst bignum = require('bn.js');\nconst DecoderBuffer = require('../base/buffer').DecoderBuffer;\nconst Node = require('../base/node');\n\n// Import DER constants\nconst der = require('../constants/der');\n\nfunction DERDecoder(entity) {\n  this.enc = 'der';\n  this.name = entity.name;\n  this.entity = entity;\n\n  // Construct base tree\n  this.tree = new DERNode();\n  this.tree._init(entity.body);\n}\nmodule.exports = DERDecoder;\n\nDERDecoder.prototype.decode = function decode(data, options) {\n  if (!DecoderBuffer.isDecoderBuffer(data)) {\n    data = new DecoderBuffer(data, options);\n  }\n\n  return this.tree._decode(data, options);\n};\n\n// Tree methods\n\nfunction DERNode(parent) {\n  Node.call(this, 'der', parent);\n}\ninherits(DERNode, Node);\n\nDERNode.prototype._peekTag = function peekTag(buffer, tag, any) {\n  if (buffer.isEmpty())\n    return false;\n\n  const state = buffer.save();\n  const decodedTag = derDecodeTag(buffer, 'Failed to peek tag: \"' + tag + '\"');\n  if (buffer.isError(decodedTag))\n    return decodedTag;\n\n  buffer.restore(state);\n\n  return decodedTag.tag === tag || decodedTag.tagStr === tag ||\n    (decodedTag.tagStr + 'of') === tag || any;\n};\n\nDERNode.prototype._decodeTag = function decodeTag(buffer, tag, any) {\n  const decodedTag = derDecodeTag(buffer,\n    'Failed to decode tag of \"' + tag + '\"');\n  if (buffer.isError(decodedTag))\n    return decodedTag;\n\n  let len = derDecodeLen(buffer,\n    decodedTag.primitive,\n    'Failed to get length of \"' + tag + '\"');\n\n  // Failure\n  if (buffer.isError(len))\n    return len;\n\n  if (!any &&\n      decodedTag.tag !== tag &&\n      decodedTag.tagStr !== tag &&\n      decodedTag.tagStr + 'of' !== tag) {\n    return buffer.error('Failed to match tag: \"' + tag + '\"');\n  }\n\n  if (decodedTag.primitive || len !== null)\n    return buffer.skip(len, 'Failed to match body of: \"' + tag + '\"');\n\n  // Indefinite length... find END tag\n  const state = buffer.save();\n  const res = this._skipUntilEnd(\n    buffer,\n    'Failed to skip indefinite length body: \"' + this.tag + '\"');\n  if (buffer.isError(res))\n    return res;\n\n  len = buffer.offset - state.offset;\n  buffer.restore(state);\n  return buffer.skip(len, 'Failed to match body of: \"' + tag + '\"');\n};\n\nDERNode.prototype._skipUntilEnd = function skipUntilEnd(buffer, fail) {\n  for (;;) {\n    const tag = derDecodeTag(buffer, fail);\n    if (buffer.isError(tag))\n      return tag;\n    const len = derDecodeLen(buffer, tag.primitive, fail);\n    if (buffer.isError(len))\n      return len;\n\n    let res;\n    if (tag.primitive || len !== null)\n      res = buffer.skip(len);\n    else\n      res = this._skipUntilEnd(buffer, fail);\n\n    // Failure\n    if (buffer.isError(res))\n      return res;\n\n    if (tag.tagStr === 'end')\n      break;\n  }\n};\n\nDERNode.prototype._decodeList = function decodeList(buffer, tag, decoder,\n  options) {\n  const result = [];\n  while (!buffer.isEmpty()) {\n    const possibleEnd = this._peekTag(buffer, 'end');\n    if (buffer.isError(possibleEnd))\n      return possibleEnd;\n\n    const res = decoder.decode(buffer, 'der', options);\n    if (buffer.isError(res) && possibleEnd)\n      break;\n    result.push(res);\n  }\n  return result;\n};\n\nDERNode.prototype._decodeStr = function decodeStr(buffer, tag) {\n  if (tag === 'bitstr') {\n    const unused = buffer.readUInt8();\n    if (buffer.isError(unused))\n      return unused;\n    return { unused: unused, data: buffer.raw() };\n  } else if (tag === 'bmpstr') {\n    const raw = buffer.raw();\n    if (raw.length % 2 === 1)\n      return buffer.error('Decoding of string type: bmpstr length mismatch');\n\n    let str = '';\n    for (let i = 0; i < raw.length / 2; i++) {\n      str += String.fromCharCode(raw.readUInt16BE(i * 2));\n    }\n    return str;\n  } else if (tag === 'numstr') {\n    const numstr = buffer.raw().toString('ascii');\n    if (!this._isNumstr(numstr)) {\n      return buffer.error('Decoding of string type: ' +\n                          'numstr unsupported characters');\n    }\n    return numstr;\n  } else if (tag === 'octstr') {\n    return buffer.raw();\n  } else if (tag === 'objDesc') {\n    return buffer.raw();\n  } else if (tag === 'printstr') {\n    const printstr = buffer.raw().toString('ascii');\n    if (!this._isPrintstr(printstr)) {\n      return buffer.error('Decoding of string type: ' +\n                          'printstr unsupported characters');\n    }\n    return printstr;\n  } else if (/str$/.test(tag)) {\n    return buffer.raw().toString();\n  } else {\n    return buffer.error('Decoding of string type: ' + tag + ' unsupported');\n  }\n};\n\nDERNode.prototype._decodeObjid = function decodeObjid(buffer, values, relative) {\n  let result;\n  const identifiers = [];\n  let ident = 0;\n  let subident = 0;\n  while (!buffer.isEmpty()) {\n    subident = buffer.readUInt8();\n    ident <<= 7;\n    ident |= subident & 0x7f;\n    if ((subident & 0x80) === 0) {\n      identifiers.push(ident);\n      ident = 0;\n    }\n  }\n  if (subident & 0x80)\n    identifiers.push(ident);\n\n  const first = (identifiers[0] / 40) | 0;\n  const second = identifiers[0] % 40;\n\n  if (relative)\n    result = identifiers;\n  else\n    result = [first, second].concat(identifiers.slice(1));\n\n  if (values) {\n    let tmp = values[result.join(' ')];\n    if (tmp === undefined)\n      tmp = values[result.join('.')];\n    if (tmp !== undefined)\n      result = tmp;\n  }\n\n  return result;\n};\n\nDERNode.prototype._decodeTime = function decodeTime(buffer, tag) {\n  const str = buffer.raw().toString();\n\n  let year;\n  let mon;\n  let day;\n  let hour;\n  let min;\n  let sec;\n  if (tag === 'gentime') {\n    year = str.slice(0, 4) | 0;\n    mon = str.slice(4, 6) | 0;\n    day = str.slice(6, 8) | 0;\n    hour = str.slice(8, 10) | 0;\n    min = str.slice(10, 12) | 0;\n    sec = str.slice(12, 14) | 0;\n  } else if (tag === 'utctime') {\n    year = str.slice(0, 2) | 0;\n    mon = str.slice(2, 4) | 0;\n    day = str.slice(4, 6) | 0;\n    hour = str.slice(6, 8) | 0;\n    min = str.slice(8, 10) | 0;\n    sec = str.slice(10, 12) | 0;\n    if (year < 70)\n      year = 2000 + year;\n    else\n      year = 1900 + year;\n  } else {\n    return buffer.error('Decoding ' + tag + ' time is not supported yet');\n  }\n\n  return Date.UTC(year, mon - 1, day, hour, min, sec, 0);\n};\n\nDERNode.prototype._decodeNull = function decodeNull() {\n  return null;\n};\n\nDERNode.prototype._decodeBool = function decodeBool(buffer) {\n  const res = buffer.readUInt8();\n  if (buffer.isError(res))\n    return res;\n  else\n    return res !== 0;\n};\n\nDERNode.prototype._decodeInt = function decodeInt(buffer, values) {\n  // Bigint, return as it is (assume big endian)\n  const raw = buffer.raw();\n  let res = new bignum(raw);\n\n  if (values)\n    res = values[res.toString(10)] || res;\n\n  return res;\n};\n\nDERNode.prototype._use = function use(entity, obj) {\n  if (typeof entity === 'function')\n    entity = entity(obj);\n  return entity._getDecoder('der').tree;\n};\n\n// Utility methods\n\nfunction derDecodeTag(buf, fail) {\n  let tag = buf.readUInt8(fail);\n  if (buf.isError(tag))\n    return tag;\n\n  const cls = der.tagClass[tag >> 6];\n  const primitive = (tag & 0x20) === 0;\n\n  // Multi-octet tag - load\n  if ((tag & 0x1f) === 0x1f) {\n    let oct = tag;\n    tag = 0;\n    while ((oct & 0x80) === 0x80) {\n      oct = buf.readUInt8(fail);\n      if (buf.isError(oct))\n        return oct;\n\n      tag <<= 7;\n      tag |= oct & 0x7f;\n    }\n  } else {\n    tag &= 0x1f;\n  }\n  const tagStr = der.tag[tag];\n\n  return {\n    cls: cls,\n    primitive: primitive,\n    tag: tag,\n    tagStr: tagStr\n  };\n}\n\nfunction derDecodeLen(buf, primitive, fail) {\n  let len = buf.readUInt8(fail);\n  if (buf.isError(len))\n    return len;\n\n  // Indefinite form\n  if (!primitive && len === 0x80)\n    return null;\n\n  // Definite form\n  if ((len & 0x80) === 0) {\n    // Short form\n    return len;\n  }\n\n  // Long form\n  const num = len & 0x7f;\n  if (num > 4)\n    return buf.error('length octect is too long');\n\n  len = 0;\n  for (let i = 0; i < num; i++) {\n    len <<= 8;\n    const j = buf.readUInt8(fail);\n    if (buf.isError(j))\n      return j;\n    len |= j;\n  }\n\n  return len;\n}\n",
    "'use strict';\n\nconst inherits = require('inherits');\nconst Buffer = require('safer-buffer').Buffer;\n\nconst DERDecoder = require('./der');\n\nfunction PEMDecoder(entity) {\n  DERDecoder.call(this, entity);\n  this.enc = 'pem';\n}\ninherits(PEMDecoder, DERDecoder);\nmodule.exports = PEMDecoder;\n\nPEMDecoder.prototype.decode = function decode(data, options) {\n  const lines = data.toString().split(/[\\r\\n]+/g);\n\n  const label = options.label.toUpperCase();\n\n  const re = /^-----(BEGIN|END) ([^-]+)-----$/;\n  let start = -1;\n  let end = -1;\n  for (let i = 0; i < lines.length; i++) {\n    const match = lines[i].match(re);\n    if (match === null)\n      continue;\n\n    if (match[2] !== label)\n      continue;\n\n    if (start === -1) {\n      if (match[1] !== 'BEGIN')\n        break;\n      start = i;\n    } else {\n      if (match[1] !== 'END')\n        break;\n      end = i;\n      break;\n    }\n  }\n  if (start === -1 || end === -1)\n    throw new Error('PEM section not found for: ' + label);\n\n  const base64 = lines.slice(start + 1, end).join('');\n  // Remove excessive symbols\n  base64.replace(/[^a-z0-9+/=]+/gi, '');\n\n  const input = Buffer.from(base64, 'base64');\n  return DERDecoder.prototype.decode.call(this, input, options);\n};\n",
    "'use strict';\n\nconst decoders = exports;\n\ndecoders.der = require('./der');\ndecoders.pem = require('./pem');\n",
    "'use strict';\n\nconst encoders = require('./encoders');\nconst decoders = require('./decoders');\nconst inherits = require('inherits');\n\nconst api = exports;\n\napi.define = function define(name, body) {\n  return new Entity(name, body);\n};\n\nfunction Entity(name, body) {\n  this.name = name;\n  this.body = body;\n\n  this.decoders = {};\n  this.encoders = {};\n}\n\nEntity.prototype._createNamed = function createNamed(Base) {\n  const name = this.name;\n\n  function Generated(entity) {\n    this._initNamed(entity, name);\n  }\n  inherits(Generated, Base);\n  Generated.prototype._initNamed = function _initNamed(entity, name) {\n    Base.call(this, entity, name);\n  };\n\n  return new Generated(this);\n};\n\nEntity.prototype._getDecoder = function _getDecoder(enc) {\n  enc = enc || 'der';\n  // Lazily create decoder\n  if (!this.decoders.hasOwnProperty(enc))\n    this.decoders[enc] = this._createNamed(decoders[enc]);\n  return this.decoders[enc];\n};\n\nEntity.prototype.decode = function decode(data, enc, options) {\n  return this._getDecoder(enc).decode(data, options);\n};\n\nEntity.prototype._getEncoder = function _getEncoder(enc) {\n  enc = enc || 'der';\n  // Lazily create encoder\n  if (!this.encoders.hasOwnProperty(enc))\n    this.encoders[enc] = this._createNamed(encoders[enc]);\n  return this.encoders[enc];\n};\n\nEntity.prototype.encode = function encode(data, enc, /* internal */ reporter) {\n  return this._getEncoder(enc).encode(data, reporter);\n};\n",
    "'use strict';\n\nconst base = exports;\n\nbase.Reporter = require('./reporter').Reporter;\nbase.DecoderBuffer = require('./buffer').DecoderBuffer;\nbase.EncoderBuffer = require('./buffer').EncoderBuffer;\nbase.Node = require('./node');\n",
    "'use strict';\n\nconst constants = exports;\n\n// Helper\nconstants._reverse = function reverse(map) {\n  const res = {};\n\n  Object.keys(map).forEach(function(key) {\n    // Convert key to integer if it is stringified\n    if ((key | 0) == key)\n      key = key | 0;\n\n    const value = map[key];\n    res[value] = key;\n  });\n\n  return res;\n};\n\nconstants.der = require('./der');\n",
    "'use strict';\n\nconst asn1 = exports;\n\nasn1.bignum = require('bn.js');\n\nasn1.define = require('./asn1/api').define;\nasn1.base = require('./asn1/base');\nasn1.constants = require('./asn1/constants');\nasn1.decoders = require('./asn1/decoders');\nasn1.encoders = require('./asn1/encoders');\n",
    "'use strict';\n\nvar utils = exports;\n\nfunction toArray(msg, enc) {\n  if (Array.isArray(msg))\n    return msg.slice();\n  if (!msg)\n    return [];\n  var res = [];\n  if (typeof msg !== 'string') {\n    for (var i = 0; i < msg.length; i++)\n      res[i] = msg[i] | 0;\n    return res;\n  }\n  if (enc === 'hex') {\n    msg = msg.replace(/[^a-z0-9]+/ig, '');\n    if (msg.length % 2 !== 0)\n      msg = '0' + msg;\n    for (var i = 0; i < msg.length; i += 2)\n      res.push(parseInt(msg[i] + msg[i + 1], 16));\n  } else {\n    for (var i = 0; i < msg.length; i++) {\n      var c = msg.charCodeAt(i);\n      var hi = c >> 8;\n      var lo = c & 0xff;\n      if (hi)\n        res.push(hi, lo);\n      else\n        res.push(lo);\n    }\n  }\n  return res;\n}\nutils.toArray = toArray;\n\nfunction zero2(word) {\n  if (word.length === 1)\n    return '0' + word;\n  else\n    return word;\n}\nutils.zero2 = zero2;\n\nfunction toHex(msg) {\n  var res = '';\n  for (var i = 0; i < msg.length; i++)\n    res += zero2(msg[i].toString(16));\n  return res;\n}\nutils.toHex = toHex;\n\nutils.encode = function encode(arr, enc) {\n  if (enc === 'hex')\n    return toHex(arr);\n  else\n    return arr;\n};\n",
    "'use strict';\n\nvar utils = exports;\nvar BN = require('bn.js');\nvar minAssert = require('minimalistic-assert');\nvar minUtils = require('minimalistic-crypto-utils');\n\nutils.assert = minAssert;\nutils.toArray = minUtils.toArray;\nutils.zero2 = minUtils.zero2;\nutils.toHex = minUtils.toHex;\nutils.encode = minUtils.encode;\n\n// Represent num in a w-NAF form\nfunction getNAF(num, w, bits) {\n  var naf = new Array(Math.max(num.bitLength(), bits) + 1);\n  var i;\n  for (i = 0; i < naf.length; i += 1) {\n    naf[i] = 0;\n  }\n\n  var ws = 1 << (w + 1);\n  var k = num.clone();\n\n  for (i = 0; i < naf.length; i++) {\n    var z;\n    var mod = k.andln(ws - 1);\n    if (k.isOdd()) {\n      if (mod > (ws >> 1) - 1)\n        z = (ws >> 1) - mod;\n      else\n        z = mod;\n      k.isubn(z);\n    } else {\n      z = 0;\n    }\n\n    naf[i] = z;\n    k.iushrn(1);\n  }\n\n  return naf;\n}\nutils.getNAF = getNAF;\n\n// Represent k1, k2 in a Joint Sparse Form\nfunction getJSF(k1, k2) {\n  var jsf = [\n    [],\n    [],\n  ];\n\n  k1 = k1.clone();\n  k2 = k2.clone();\n  var d1 = 0;\n  var d2 = 0;\n  var m8;\n  while (k1.cmpn(-d1) > 0 || k2.cmpn(-d2) > 0) {\n    // First phase\n    var m14 = (k1.andln(3) + d1) & 3;\n    var m24 = (k2.andln(3) + d2) & 3;\n    if (m14 === 3)\n      m14 = -1;\n    if (m24 === 3)\n      m24 = -1;\n    var u1;\n    if ((m14 & 1) === 0) {\n      u1 = 0;\n    } else {\n      m8 = (k1.andln(7) + d1) & 7;\n      if ((m8 === 3 || m8 === 5) && m24 === 2)\n        u1 = -m14;\n      else\n        u1 = m14;\n    }\n    jsf[0].push(u1);\n\n    var u2;\n    if ((m24 & 1) === 0) {\n      u2 = 0;\n    } else {\n      m8 = (k2.andln(7) + d2) & 7;\n      if ((m8 === 3 || m8 === 5) && m14 === 2)\n        u2 = -m24;\n      else\n        u2 = m24;\n    }\n    jsf[1].push(u2);\n\n    // Second phase\n    if (2 * d1 === u1 + 1)\n      d1 = 1 - d1;\n    if (2 * d2 === u2 + 1)\n      d2 = 1 - d2;\n    k1.iushrn(1);\n    k2.iushrn(1);\n  }\n\n  return jsf;\n}\nutils.getJSF = getJSF;\n\nfunction cachedProperty(obj, name, computer) {\n  var key = '_' + name;\n  obj.prototype[name] = function cachedProperty() {\n    return this[key] !== undefined ? this[key] :\n      this[key] = computer.call(this);\n  };\n}\nutils.cachedProperty = cachedProperty;\n\nfunction parseBytes(bytes) {\n  return typeof bytes === 'string' ? utils.toArray(bytes, 'hex') :\n    bytes;\n}\nutils.parseBytes = parseBytes;\n\nfunction intFromLE(bytes) {\n  return new BN(bytes, 'hex', 'le');\n}\nutils.intFromLE = intFromLE;\n\n",
    "var r;\n\nmodule.exports = function rand(len) {\n  if (!r)\n    r = new Rand(null);\n\n  return r.generate(len);\n};\n\nfunction Rand(rand) {\n  this.rand = rand;\n}\nmodule.exports.Rand = Rand;\n\nRand.prototype.generate = function generate(len) {\n  return this._rand(len);\n};\n\n// Emulate crypto API using randy\nRand.prototype._rand = function _rand(n) {\n  if (this.rand.getBytes)\n    return this.rand.getBytes(n);\n\n  var res = new Uint8Array(n);\n  for (var i = 0; i < res.length; i++)\n    res[i] = this.rand.getByte();\n  return res;\n};\n\nif (typeof self === 'object') {\n  if (self.crypto && self.crypto.getRandomValues) {\n    // Modern browsers\n    Rand.prototype._rand = function _rand(n) {\n      var arr = new Uint8Array(n);\n      self.crypto.getRandomValues(arr);\n      return arr;\n    };\n  } else if (self.msCrypto && self.msCrypto.getRandomValues) {\n    // IE\n    Rand.prototype._rand = function _rand(n) {\n      var arr = new Uint8Array(n);\n      self.msCrypto.getRandomValues(arr);\n      return arr;\n    };\n\n  // Safari's WebWorkers do not have `crypto`\n  } else if (typeof window === 'object') {\n    // Old junk\n    Rand.prototype._rand = function() {\n      throw new Error('Not implemented yet');\n    };\n  }\n} else {\n  // Node.js or Web worker with no crypto support\n  try {\n    var crypto = require('crypto');\n    if (typeof crypto.randomBytes !== 'function')\n      throw new Error('Not supported');\n\n    Rand.prototype._rand = function _rand(n) {\n      return crypto.randomBytes(n);\n    };\n  } catch (e) {\n  }\n}\n",
    "'use strict';\n\nvar BN = require('bn.js');\nvar utils = require('../utils');\nvar getNAF = utils.getNAF;\nvar getJSF = utils.getJSF;\nvar assert = utils.assert;\n\nfunction BaseCurve(type, conf) {\n  this.type = type;\n  this.p = new BN(conf.p, 16);\n\n  // Use Montgomery, when there is no fast reduction for the prime\n  this.red = conf.prime ? BN.red(conf.prime) : BN.mont(this.p);\n\n  // Useful for many curves\n  this.zero = new BN(0).toRed(this.red);\n  this.one = new BN(1).toRed(this.red);\n  this.two = new BN(2).toRed(this.red);\n\n  // Curve configuration, optional\n  this.n = conf.n && new BN(conf.n, 16);\n  this.g = conf.g && this.pointFromJSON(conf.g, conf.gRed);\n\n  // Temporary arrays\n  this._wnafT1 = new Array(4);\n  this._wnafT2 = new Array(4);\n  this._wnafT3 = new Array(4);\n  this._wnafT4 = new Array(4);\n\n  this._bitLength = this.n ? this.n.bitLength() : 0;\n\n  // Generalized Greg Maxwell's trick\n  var adjustCount = this.n && this.p.div(this.n);\n  if (!adjustCount || adjustCount.cmpn(100) > 0) {\n    this.redN = null;\n  } else {\n    this._maxwellTrick = true;\n    this.redN = this.n.toRed(this.red);\n  }\n}\nmodule.exports = BaseCurve;\n\nBaseCurve.prototype.point = function point() {\n  throw new Error('Not implemented');\n};\n\nBaseCurve.prototype.validate = function validate() {\n  throw new Error('Not implemented');\n};\n\nBaseCurve.prototype._fixedNafMul = function _fixedNafMul(p, k) {\n  assert(p.precomputed);\n  var doubles = p._getDoubles();\n\n  var naf = getNAF(k, 1, this._bitLength);\n  var I = (1 << (doubles.step + 1)) - (doubles.step % 2 === 0 ? 2 : 1);\n  I /= 3;\n\n  // Translate into more windowed form\n  var repr = [];\n  var j;\n  var nafW;\n  for (j = 0; j < naf.length; j += doubles.step) {\n    nafW = 0;\n    for (var l = j + doubles.step - 1; l >= j; l--)\n      nafW = (nafW << 1) + naf[l];\n    repr.push(nafW);\n  }\n\n  var a = this.jpoint(null, null, null);\n  var b = this.jpoint(null, null, null);\n  for (var i = I; i > 0; i--) {\n    for (j = 0; j < repr.length; j++) {\n      nafW = repr[j];\n      if (nafW === i)\n        b = b.mixedAdd(doubles.points[j]);\n      else if (nafW === -i)\n        b = b.mixedAdd(doubles.points[j].neg());\n    }\n    a = a.add(b);\n  }\n  return a.toP();\n};\n\nBaseCurve.prototype._wnafMul = function _wnafMul(p, k) {\n  var w = 4;\n\n  // Precompute window\n  var nafPoints = p._getNAFPoints(w);\n  w = nafPoints.wnd;\n  var wnd = nafPoints.points;\n\n  // Get NAF form\n  var naf = getNAF(k, w, this._bitLength);\n\n  // Add `this`*(N+1) for every w-NAF index\n  var acc = this.jpoint(null, null, null);\n  for (var i = naf.length - 1; i >= 0; i--) {\n    // Count zeroes\n    for (var l = 0; i >= 0 && naf[i] === 0; i--)\n      l++;\n    if (i >= 0)\n      l++;\n    acc = acc.dblp(l);\n\n    if (i < 0)\n      break;\n    var z = naf[i];\n    assert(z !== 0);\n    if (p.type === 'affine') {\n      // J +- P\n      if (z > 0)\n        acc = acc.mixedAdd(wnd[(z - 1) >> 1]);\n      else\n        acc = acc.mixedAdd(wnd[(-z - 1) >> 1].neg());\n    } else {\n      // J +- J\n      if (z > 0)\n        acc = acc.add(wnd[(z - 1) >> 1]);\n      else\n        acc = acc.add(wnd[(-z - 1) >> 1].neg());\n    }\n  }\n  return p.type === 'affine' ? acc.toP() : acc;\n};\n\nBaseCurve.prototype._wnafMulAdd = function _wnafMulAdd(defW,\n  points,\n  coeffs,\n  len,\n  jacobianResult) {\n  var wndWidth = this._wnafT1;\n  var wnd = this._wnafT2;\n  var naf = this._wnafT3;\n\n  // Fill all arrays\n  var max = 0;\n  var i;\n  var j;\n  var p;\n  for (i = 0; i < len; i++) {\n    p = points[i];\n    var nafPoints = p._getNAFPoints(defW);\n    wndWidth[i] = nafPoints.wnd;\n    wnd[i] = nafPoints.points;\n  }\n\n  // Comb small window NAFs\n  for (i = len - 1; i >= 1; i -= 2) {\n    var a = i - 1;\n    var b = i;\n    if (wndWidth[a] !== 1 || wndWidth[b] !== 1) {\n      naf[a] = getNAF(coeffs[a], wndWidth[a], this._bitLength);\n      naf[b] = getNAF(coeffs[b], wndWidth[b], this._bitLength);\n      max = Math.max(naf[a].length, max);\n      max = Math.max(naf[b].length, max);\n      continue;\n    }\n\n    var comb = [\n      points[a], /* 1 */\n      null, /* 3 */\n      null, /* 5 */\n      points[b], /* 7 */\n    ];\n\n    // Try to avoid Projective points, if possible\n    if (points[a].y.cmp(points[b].y) === 0) {\n      comb[1] = points[a].add(points[b]);\n      comb[2] = points[a].toJ().mixedAdd(points[b].neg());\n    } else if (points[a].y.cmp(points[b].y.redNeg()) === 0) {\n      comb[1] = points[a].toJ().mixedAdd(points[b]);\n      comb[2] = points[a].add(points[b].neg());\n    } else {\n      comb[1] = points[a].toJ().mixedAdd(points[b]);\n      comb[2] = points[a].toJ().mixedAdd(points[b].neg());\n    }\n\n    var index = [\n      -3, /* -1 -1 */\n      -1, /* -1 0 */\n      -5, /* -1 1 */\n      -7, /* 0 -1 */\n      0, /* 0 0 */\n      7, /* 0 1 */\n      5, /* 1 -1 */\n      1, /* 1 0 */\n      3,  /* 1 1 */\n    ];\n\n    var jsf = getJSF(coeffs[a], coeffs[b]);\n    max = Math.max(jsf[0].length, max);\n    naf[a] = new Array(max);\n    naf[b] = new Array(max);\n    for (j = 0; j < max; j++) {\n      var ja = jsf[0][j] | 0;\n      var jb = jsf[1][j] | 0;\n\n      naf[a][j] = index[(ja + 1) * 3 + (jb + 1)];\n      naf[b][j] = 0;\n      wnd[a] = comb;\n    }\n  }\n\n  var acc = this.jpoint(null, null, null);\n  var tmp = this._wnafT4;\n  for (i = max; i >= 0; i--) {\n    var k = 0;\n\n    while (i >= 0) {\n      var zero = true;\n      for (j = 0; j < len; j++) {\n        tmp[j] = naf[j][i] | 0;\n        if (tmp[j] !== 0)\n          zero = false;\n      }\n      if (!zero)\n        break;\n      k++;\n      i--;\n    }\n    if (i >= 0)\n      k++;\n    acc = acc.dblp(k);\n    if (i < 0)\n      break;\n\n    for (j = 0; j < len; j++) {\n      var z = tmp[j];\n      p;\n      if (z === 0)\n        continue;\n      else if (z > 0)\n        p = wnd[j][(z - 1) >> 1];\n      else if (z < 0)\n        p = wnd[j][(-z - 1) >> 1].neg();\n\n      if (p.type === 'affine')\n        acc = acc.mixedAdd(p);\n      else\n        acc = acc.add(p);\n    }\n  }\n  // Zeroify references\n  for (i = 0; i < len; i++)\n    wnd[i] = null;\n\n  if (jacobianResult)\n    return acc;\n  else\n    return acc.toP();\n};\n\nfunction BasePoint(curve, type) {\n  this.curve = curve;\n  this.type = type;\n  this.precomputed = null;\n}\nBaseCurve.BasePoint = BasePoint;\n\nBasePoint.prototype.eq = function eq(/*other*/) {\n  throw new Error('Not implemented');\n};\n\nBasePoint.prototype.validate = function validate() {\n  return this.curve.validate(this);\n};\n\nBaseCurve.prototype.decodePoint = function decodePoint(bytes, enc) {\n  bytes = utils.toArray(bytes, enc);\n\n  var len = this.p.byteLength();\n\n  // uncompressed, hybrid-odd, hybrid-even\n  if ((bytes[0] === 0x04 || bytes[0] === 0x06 || bytes[0] === 0x07) &&\n      bytes.length - 1 === 2 * len) {\n    if (bytes[0] === 0x06)\n      assert(bytes[bytes.length - 1] % 2 === 0);\n    else if (bytes[0] === 0x07)\n      assert(bytes[bytes.length - 1] % 2 === 1);\n\n    var res =  this.point(bytes.slice(1, 1 + len),\n      bytes.slice(1 + len, 1 + 2 * len));\n\n    return res;\n  } else if ((bytes[0] === 0x02 || bytes[0] === 0x03) &&\n              bytes.length - 1 === len) {\n    return this.pointFromX(bytes.slice(1, 1 + len), bytes[0] === 0x03);\n  }\n  throw new Error('Unknown point format');\n};\n\nBasePoint.prototype.encodeCompressed = function encodeCompressed(enc) {\n  return this.encode(enc, true);\n};\n\nBasePoint.prototype._encode = function _encode(compact) {\n  var len = this.curve.p.byteLength();\n  var x = this.getX().toArray('be', len);\n\n  if (compact)\n    return [ this.getY().isEven() ? 0x02 : 0x03 ].concat(x);\n\n  return [ 0x04 ].concat(x, this.getY().toArray('be', len));\n};\n\nBasePoint.prototype.encode = function encode(enc, compact) {\n  return utils.encode(this._encode(compact), enc);\n};\n\nBasePoint.prototype.precompute = function precompute(power) {\n  if (this.precomputed)\n    return this;\n\n  var precomputed = {\n    doubles: null,\n    naf: null,\n    beta: null,\n  };\n  precomputed.naf = this._getNAFPoints(8);\n  precomputed.doubles = this._getDoubles(4, power);\n  precomputed.beta = this._getBeta();\n  this.precomputed = precomputed;\n\n  return this;\n};\n\nBasePoint.prototype._hasDoubles = function _hasDoubles(k) {\n  if (!this.precomputed)\n    return false;\n\n  var doubles = this.precomputed.doubles;\n  if (!doubles)\n    return false;\n\n  return doubles.points.length >= Math.ceil((k.bitLength() + 1) / doubles.step);\n};\n\nBasePoint.prototype._getDoubles = function _getDoubles(step, power) {\n  if (this.precomputed && this.precomputed.doubles)\n    return this.precomputed.doubles;\n\n  var doubles = [ this ];\n  var acc = this;\n  for (var i = 0; i < power; i += step) {\n    for (var j = 0; j < step; j++)\n      acc = acc.dbl();\n    doubles.push(acc);\n  }\n  return {\n    step: step,\n    points: doubles,\n  };\n};\n\nBasePoint.prototype._getNAFPoints = function _getNAFPoints(wnd) {\n  if (this.precomputed && this.precomputed.naf)\n    return this.precomputed.naf;\n\n  var res = [ this ];\n  var max = (1 << wnd) - 1;\n  var dbl = max === 1 ? null : this.dbl();\n  for (var i = 1; i < max; i++)\n    res[i] = res[i - 1].add(dbl);\n  return {\n    wnd: wnd,\n    points: res,\n  };\n};\n\nBasePoint.prototype._getBeta = function _getBeta() {\n  return null;\n};\n\nBasePoint.prototype.dblp = function dblp(k) {\n  var r = this;\n  for (var i = 0; i < k; i++)\n    r = r.dbl();\n  return r;\n};\n",
    "'use strict';\n\nvar utils = require('../utils');\nvar BN = require('bn.js');\nvar inherits = require('inherits');\nvar Base = require('./base');\n\nvar assert = utils.assert;\n\nfunction ShortCurve(conf) {\n  Base.call(this, 'short', conf);\n\n  this.a = new BN(conf.a, 16).toRed(this.red);\n  this.b = new BN(conf.b, 16).toRed(this.red);\n  this.tinv = this.two.redInvm();\n\n  this.zeroA = this.a.fromRed().cmpn(0) === 0;\n  this.threeA = this.a.fromRed().sub(this.p).cmpn(-3) === 0;\n\n  // If the curve is endomorphic, precalculate beta and lambda\n  this.endo = this._getEndomorphism(conf);\n  this._endoWnafT1 = new Array(4);\n  this._endoWnafT2 = new Array(4);\n}\ninherits(ShortCurve, Base);\nmodule.exports = ShortCurve;\n\nShortCurve.prototype._getEndomorphism = function _getEndomorphism(conf) {\n  // No efficient endomorphism\n  if (!this.zeroA || !this.g || !this.n || this.p.modn(3) !== 1)\n    return;\n\n  // Compute beta and lambda, that lambda * P = (beta * Px; Py)\n  var beta;\n  var lambda;\n  if (conf.beta) {\n    beta = new BN(conf.beta, 16).toRed(this.red);\n  } else {\n    var betas = this._getEndoRoots(this.p);\n    // Choose the smallest beta\n    beta = betas[0].cmp(betas[1]) < 0 ? betas[0] : betas[1];\n    beta = beta.toRed(this.red);\n  }\n  if (conf.lambda) {\n    lambda = new BN(conf.lambda, 16);\n  } else {\n    // Choose the lambda that is matching selected beta\n    var lambdas = this._getEndoRoots(this.n);\n    if (this.g.mul(lambdas[0]).x.cmp(this.g.x.redMul(beta)) === 0) {\n      lambda = lambdas[0];\n    } else {\n      lambda = lambdas[1];\n      assert(this.g.mul(lambda).x.cmp(this.g.x.redMul(beta)) === 0);\n    }\n  }\n\n  // Get basis vectors, used for balanced length-two representation\n  var basis;\n  if (conf.basis) {\n    basis = conf.basis.map(function(vec) {\n      return {\n        a: new BN(vec.a, 16),\n        b: new BN(vec.b, 16),\n      };\n    });\n  } else {\n    basis = this._getEndoBasis(lambda);\n  }\n\n  return {\n    beta: beta,\n    lambda: lambda,\n    basis: basis,\n  };\n};\n\nShortCurve.prototype._getEndoRoots = function _getEndoRoots(num) {\n  // Find roots of for x^2 + x + 1 in F\n  // Root = (-1 +- Sqrt(-3)) / 2\n  //\n  var red = num === this.p ? this.red : BN.mont(num);\n  var tinv = new BN(2).toRed(red).redInvm();\n  var ntinv = tinv.redNeg();\n\n  var s = new BN(3).toRed(red).redNeg().redSqrt().redMul(tinv);\n\n  var l1 = ntinv.redAdd(s).fromRed();\n  var l2 = ntinv.redSub(s).fromRed();\n  return [ l1, l2 ];\n};\n\nShortCurve.prototype._getEndoBasis = function _getEndoBasis(lambda) {\n  // aprxSqrt >= sqrt(this.n)\n  var aprxSqrt = this.n.ushrn(Math.floor(this.n.bitLength() / 2));\n\n  // 3.74\n  // Run EGCD, until r(L + 1) < aprxSqrt\n  var u = lambda;\n  var v = this.n.clone();\n  var x1 = new BN(1);\n  var y1 = new BN(0);\n  var x2 = new BN(0);\n  var y2 = new BN(1);\n\n  // NOTE: all vectors are roots of: a + b * lambda = 0 (mod n)\n  var a0;\n  var b0;\n  // First vector\n  var a1;\n  var b1;\n  // Second vector\n  var a2;\n  var b2;\n\n  var prevR;\n  var i = 0;\n  var r;\n  var x;\n  while (u.cmpn(0) !== 0) {\n    var q = v.div(u);\n    r = v.sub(q.mul(u));\n    x = x2.sub(q.mul(x1));\n    var y = y2.sub(q.mul(y1));\n\n    if (!a1 && r.cmp(aprxSqrt) < 0) {\n      a0 = prevR.neg();\n      b0 = x1;\n      a1 = r.neg();\n      b1 = x;\n    } else if (a1 && ++i === 2) {\n      break;\n    }\n    prevR = r;\n\n    v = u;\n    u = r;\n    x2 = x1;\n    x1 = x;\n    y2 = y1;\n    y1 = y;\n  }\n  a2 = r.neg();\n  b2 = x;\n\n  var len1 = a1.sqr().add(b1.sqr());\n  var len2 = a2.sqr().add(b2.sqr());\n  if (len2.cmp(len1) >= 0) {\n    a2 = a0;\n    b2 = b0;\n  }\n\n  // Normalize signs\n  if (a1.negative) {\n    a1 = a1.neg();\n    b1 = b1.neg();\n  }\n  if (a2.negative) {\n    a2 = a2.neg();\n    b2 = b2.neg();\n  }\n\n  return [\n    { a: a1, b: b1 },\n    { a: a2, b: b2 },\n  ];\n};\n\nShortCurve.prototype._endoSplit = function _endoSplit(k) {\n  var basis = this.endo.basis;\n  var v1 = basis[0];\n  var v2 = basis[1];\n\n  var c1 = v2.b.mul(k).divRound(this.n);\n  var c2 = v1.b.neg().mul(k).divRound(this.n);\n\n  var p1 = c1.mul(v1.a);\n  var p2 = c2.mul(v2.a);\n  var q1 = c1.mul(v1.b);\n  var q2 = c2.mul(v2.b);\n\n  // Calculate answer\n  var k1 = k.sub(p1).sub(p2);\n  var k2 = q1.add(q2).neg();\n  return { k1: k1, k2: k2 };\n};\n\nShortCurve.prototype.pointFromX = function pointFromX(x, odd) {\n  x = new BN(x, 16);\n  if (!x.red)\n    x = x.toRed(this.red);\n\n  var y2 = x.redSqr().redMul(x).redIAdd(x.redMul(this.a)).redIAdd(this.b);\n  var y = y2.redSqrt();\n  if (y.redSqr().redSub(y2).cmp(this.zero) !== 0)\n    throw new Error('invalid point');\n\n  // XXX Is there any way to tell if the number is odd without converting it\n  // to non-red form?\n  var isOdd = y.fromRed().isOdd();\n  if (odd && !isOdd || !odd && isOdd)\n    y = y.redNeg();\n\n  return this.point(x, y);\n};\n\nShortCurve.prototype.validate = function validate(point) {\n  if (point.inf)\n    return true;\n\n  var x = point.x;\n  var y = point.y;\n\n  var ax = this.a.redMul(x);\n  var rhs = x.redSqr().redMul(x).redIAdd(ax).redIAdd(this.b);\n  return y.redSqr().redISub(rhs).cmpn(0) === 0;\n};\n\nShortCurve.prototype._endoWnafMulAdd =\n    function _endoWnafMulAdd(points, coeffs, jacobianResult) {\n      var npoints = this._endoWnafT1;\n      var ncoeffs = this._endoWnafT2;\n      for (var i = 0; i < points.length; i++) {\n        var split = this._endoSplit(coeffs[i]);\n        var p = points[i];\n        var beta = p._getBeta();\n\n        if (split.k1.negative) {\n          split.k1.ineg();\n          p = p.neg(true);\n        }\n        if (split.k2.negative) {\n          split.k2.ineg();\n          beta = beta.neg(true);\n        }\n\n        npoints[i * 2] = p;\n        npoints[i * 2 + 1] = beta;\n        ncoeffs[i * 2] = split.k1;\n        ncoeffs[i * 2 + 1] = split.k2;\n      }\n      var res = this._wnafMulAdd(1, npoints, ncoeffs, i * 2, jacobianResult);\n\n      // Clean-up references to points and coefficients\n      for (var j = 0; j < i * 2; j++) {\n        npoints[j] = null;\n        ncoeffs[j] = null;\n      }\n      return res;\n    };\n\nfunction Point(curve, x, y, isRed) {\n  Base.BasePoint.call(this, curve, 'affine');\n  if (x === null && y === null) {\n    this.x = null;\n    this.y = null;\n    this.inf = true;\n  } else {\n    this.x = new BN(x, 16);\n    this.y = new BN(y, 16);\n    // Force redgomery representation when loading from JSON\n    if (isRed) {\n      this.x.forceRed(this.curve.red);\n      this.y.forceRed(this.curve.red);\n    }\n    if (!this.x.red)\n      this.x = this.x.toRed(this.curve.red);\n    if (!this.y.red)\n      this.y = this.y.toRed(this.curve.red);\n    this.inf = false;\n  }\n}\ninherits(Point, Base.BasePoint);\n\nShortCurve.prototype.point = function point(x, y, isRed) {\n  return new Point(this, x, y, isRed);\n};\n\nShortCurve.prototype.pointFromJSON = function pointFromJSON(obj, red) {\n  return Point.fromJSON(this, obj, red);\n};\n\nPoint.prototype._getBeta = function _getBeta() {\n  if (!this.curve.endo)\n    return;\n\n  var pre = this.precomputed;\n  if (pre && pre.beta)\n    return pre.beta;\n\n  var beta = this.curve.point(this.x.redMul(this.curve.endo.beta), this.y);\n  if (pre) {\n    var curve = this.curve;\n    var endoMul = function(p) {\n      return curve.point(p.x.redMul(curve.endo.beta), p.y);\n    };\n    pre.beta = beta;\n    beta.precomputed = {\n      beta: null,\n      naf: pre.naf && {\n        wnd: pre.naf.wnd,\n        points: pre.naf.points.map(endoMul),\n      },\n      doubles: pre.doubles && {\n        step: pre.doubles.step,\n        points: pre.doubles.points.map(endoMul),\n      },\n    };\n  }\n  return beta;\n};\n\nPoint.prototype.toJSON = function toJSON() {\n  if (!this.precomputed)\n    return [ this.x, this.y ];\n\n  return [ this.x, this.y, this.precomputed && {\n    doubles: this.precomputed.doubles && {\n      step: this.precomputed.doubles.step,\n      points: this.precomputed.doubles.points.slice(1),\n    },\n    naf: this.precomputed.naf && {\n      wnd: this.precomputed.naf.wnd,\n      points: this.precomputed.naf.points.slice(1),\n    },\n  } ];\n};\n\nPoint.fromJSON = function fromJSON(curve, obj, red) {\n  if (typeof obj === 'string')\n    obj = JSON.parse(obj);\n  var res = curve.point(obj[0], obj[1], red);\n  if (!obj[2])\n    return res;\n\n  function obj2point(obj) {\n    return curve.point(obj[0], obj[1], red);\n  }\n\n  var pre = obj[2];\n  res.precomputed = {\n    beta: null,\n    doubles: pre.doubles && {\n      step: pre.doubles.step,\n      points: [ res ].concat(pre.doubles.points.map(obj2point)),\n    },\n    naf: pre.naf && {\n      wnd: pre.naf.wnd,\n      points: [ res ].concat(pre.naf.points.map(obj2point)),\n    },\n  };\n  return res;\n};\n\nPoint.prototype.inspect = function inspect() {\n  if (this.isInfinity())\n    return '<EC Point Infinity>';\n  return '<EC Point x: ' + this.x.fromRed().toString(16, 2) +\n      ' y: ' + this.y.fromRed().toString(16, 2) + '>';\n};\n\nPoint.prototype.isInfinity = function isInfinity() {\n  return this.inf;\n};\n\nPoint.prototype.add = function add(p) {\n  // O + P = P\n  if (this.inf)\n    return p;\n\n  // P + O = P\n  if (p.inf)\n    return this;\n\n  // P + P = 2P\n  if (this.eq(p))\n    return this.dbl();\n\n  // P + (-P) = O\n  if (this.neg().eq(p))\n    return this.curve.point(null, null);\n\n  // P + Q = O\n  if (this.x.cmp(p.x) === 0)\n    return this.curve.point(null, null);\n\n  var c = this.y.redSub(p.y);\n  if (c.cmpn(0) !== 0)\n    c = c.redMul(this.x.redSub(p.x).redInvm());\n  var nx = c.redSqr().redISub(this.x).redISub(p.x);\n  var ny = c.redMul(this.x.redSub(nx)).redISub(this.y);\n  return this.curve.point(nx, ny);\n};\n\nPoint.prototype.dbl = function dbl() {\n  if (this.inf)\n    return this;\n\n  // 2P = O\n  var ys1 = this.y.redAdd(this.y);\n  if (ys1.cmpn(0) === 0)\n    return this.curve.point(null, null);\n\n  var a = this.curve.a;\n\n  var x2 = this.x.redSqr();\n  var dyinv = ys1.redInvm();\n  var c = x2.redAdd(x2).redIAdd(x2).redIAdd(a).redMul(dyinv);\n\n  var nx = c.redSqr().redISub(this.x.redAdd(this.x));\n  var ny = c.redMul(this.x.redSub(nx)).redISub(this.y);\n  return this.curve.point(nx, ny);\n};\n\nPoint.prototype.getX = function getX() {\n  return this.x.fromRed();\n};\n\nPoint.prototype.getY = function getY() {\n  return this.y.fromRed();\n};\n\nPoint.prototype.mul = function mul(k) {\n  k = new BN(k, 16);\n  if (this.isInfinity())\n    return this;\n  else if (this._hasDoubles(k))\n    return this.curve._fixedNafMul(this, k);\n  else if (this.curve.endo)\n    return this.curve._endoWnafMulAdd([ this ], [ k ]);\n  else\n    return this.curve._wnafMul(this, k);\n};\n\nPoint.prototype.mulAdd = function mulAdd(k1, p2, k2) {\n  var points = [ this, p2 ];\n  var coeffs = [ k1, k2 ];\n  if (this.curve.endo)\n    return this.curve._endoWnafMulAdd(points, coeffs);\n  else\n    return this.curve._wnafMulAdd(1, points, coeffs, 2);\n};\n\nPoint.prototype.jmulAdd = function jmulAdd(k1, p2, k2) {\n  var points = [ this, p2 ];\n  var coeffs = [ k1, k2 ];\n  if (this.curve.endo)\n    return this.curve._endoWnafMulAdd(points, coeffs, true);\n  else\n    return this.curve._wnafMulAdd(1, points, coeffs, 2, true);\n};\n\nPoint.prototype.eq = function eq(p) {\n  return this === p ||\n         this.inf === p.inf &&\n             (this.inf || this.x.cmp(p.x) === 0 && this.y.cmp(p.y) === 0);\n};\n\nPoint.prototype.neg = function neg(_precompute) {\n  if (this.inf)\n    return this;\n\n  var res = this.curve.point(this.x, this.y.redNeg());\n  if (_precompute && this.precomputed) {\n    var pre = this.precomputed;\n    var negate = function(p) {\n      return p.neg();\n    };\n    res.precomputed = {\n      naf: pre.naf && {\n        wnd: pre.naf.wnd,\n        points: pre.naf.points.map(negate),\n      },\n      doubles: pre.doubles && {\n        step: pre.doubles.step,\n        points: pre.doubles.points.map(negate),\n      },\n    };\n  }\n  return res;\n};\n\nPoint.prototype.toJ = function toJ() {\n  if (this.inf)\n    return this.curve.jpoint(null, null, null);\n\n  var res = this.curve.jpoint(this.x, this.y, this.curve.one);\n  return res;\n};\n\nfunction JPoint(curve, x, y, z) {\n  Base.BasePoint.call(this, curve, 'jacobian');\n  if (x === null && y === null && z === null) {\n    this.x = this.curve.one;\n    this.y = this.curve.one;\n    this.z = new BN(0);\n  } else {\n    this.x = new BN(x, 16);\n    this.y = new BN(y, 16);\n    this.z = new BN(z, 16);\n  }\n  if (!this.x.red)\n    this.x = this.x.toRed(this.curve.red);\n  if (!this.y.red)\n    this.y = this.y.toRed(this.curve.red);\n  if (!this.z.red)\n    this.z = this.z.toRed(this.curve.red);\n\n  this.zOne = this.z === this.curve.one;\n}\ninherits(JPoint, Base.BasePoint);\n\nShortCurve.prototype.jpoint = function jpoint(x, y, z) {\n  return new JPoint(this, x, y, z);\n};\n\nJPoint.prototype.toP = function toP() {\n  if (this.isInfinity())\n    return this.curve.point(null, null);\n\n  var zinv = this.z.redInvm();\n  var zinv2 = zinv.redSqr();\n  var ax = this.x.redMul(zinv2);\n  var ay = this.y.redMul(zinv2).redMul(zinv);\n\n  return this.curve.point(ax, ay);\n};\n\nJPoint.prototype.neg = function neg() {\n  return this.curve.jpoint(this.x, this.y.redNeg(), this.z);\n};\n\nJPoint.prototype.add = function add(p) {\n  // O + P = P\n  if (this.isInfinity())\n    return p;\n\n  // P + O = P\n  if (p.isInfinity())\n    return this;\n\n  // 12M + 4S + 7A\n  var pz2 = p.z.redSqr();\n  var z2 = this.z.redSqr();\n  var u1 = this.x.redMul(pz2);\n  var u2 = p.x.redMul(z2);\n  var s1 = this.y.redMul(pz2.redMul(p.z));\n  var s2 = p.y.redMul(z2.redMul(this.z));\n\n  var h = u1.redSub(u2);\n  var r = s1.redSub(s2);\n  if (h.cmpn(0) === 0) {\n    if (r.cmpn(0) !== 0)\n      return this.curve.jpoint(null, null, null);\n    else\n      return this.dbl();\n  }\n\n  var h2 = h.redSqr();\n  var h3 = h2.redMul(h);\n  var v = u1.redMul(h2);\n\n  var nx = r.redSqr().redIAdd(h3).redISub(v).redISub(v);\n  var ny = r.redMul(v.redISub(nx)).redISub(s1.redMul(h3));\n  var nz = this.z.redMul(p.z).redMul(h);\n\n  return this.curve.jpoint(nx, ny, nz);\n};\n\nJPoint.prototype.mixedAdd = function mixedAdd(p) {\n  // O + P = P\n  if (this.isInfinity())\n    return p.toJ();\n\n  // P + O = P\n  if (p.isInfinity())\n    return this;\n\n  // 8M + 3S + 7A\n  var z2 = this.z.redSqr();\n  var u1 = this.x;\n  var u2 = p.x.redMul(z2);\n  var s1 = this.y;\n  var s2 = p.y.redMul(z2).redMul(this.z);\n\n  var h = u1.redSub(u2);\n  var r = s1.redSub(s2);\n  if (h.cmpn(0) === 0) {\n    if (r.cmpn(0) !== 0)\n      return this.curve.jpoint(null, null, null);\n    else\n      return this.dbl();\n  }\n\n  var h2 = h.redSqr();\n  var h3 = h2.redMul(h);\n  var v = u1.redMul(h2);\n\n  var nx = r.redSqr().redIAdd(h3).redISub(v).redISub(v);\n  var ny = r.redMul(v.redISub(nx)).redISub(s1.redMul(h3));\n  var nz = this.z.redMul(h);\n\n  return this.curve.jpoint(nx, ny, nz);\n};\n\nJPoint.prototype.dblp = function dblp(pow) {\n  if (pow === 0)\n    return this;\n  if (this.isInfinity())\n    return this;\n  if (!pow)\n    return this.dbl();\n\n  var i;\n  if (this.curve.zeroA || this.curve.threeA) {\n    var r = this;\n    for (i = 0; i < pow; i++)\n      r = r.dbl();\n    return r;\n  }\n\n  // 1M + 2S + 1A + N * (4S + 5M + 8A)\n  // N = 1 => 6M + 6S + 9A\n  var a = this.curve.a;\n  var tinv = this.curve.tinv;\n\n  var jx = this.x;\n  var jy = this.y;\n  var jz = this.z;\n  var jz4 = jz.redSqr().redSqr();\n\n  // Reuse results\n  var jyd = jy.redAdd(jy);\n  for (i = 0; i < pow; i++) {\n    var jx2 = jx.redSqr();\n    var jyd2 = jyd.redSqr();\n    var jyd4 = jyd2.redSqr();\n    var c = jx2.redAdd(jx2).redIAdd(jx2).redIAdd(a.redMul(jz4));\n\n    var t1 = jx.redMul(jyd2);\n    var nx = c.redSqr().redISub(t1.redAdd(t1));\n    var t2 = t1.redISub(nx);\n    var dny = c.redMul(t2);\n    dny = dny.redIAdd(dny).redISub(jyd4);\n    var nz = jyd.redMul(jz);\n    if (i + 1 < pow)\n      jz4 = jz4.redMul(jyd4);\n\n    jx = nx;\n    jz = nz;\n    jyd = dny;\n  }\n\n  return this.curve.jpoint(jx, jyd.redMul(tinv), jz);\n};\n\nJPoint.prototype.dbl = function dbl() {\n  if (this.isInfinity())\n    return this;\n\n  if (this.curve.zeroA)\n    return this._zeroDbl();\n  else if (this.curve.threeA)\n    return this._threeDbl();\n  else\n    return this._dbl();\n};\n\nJPoint.prototype._zeroDbl = function _zeroDbl() {\n  var nx;\n  var ny;\n  var nz;\n  // Z = 1\n  if (this.zOne) {\n    // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html\n    //     #doubling-mdbl-2007-bl\n    // 1M + 5S + 14A\n\n    // XX = X1^2\n    var xx = this.x.redSqr();\n    // YY = Y1^2\n    var yy = this.y.redSqr();\n    // YYYY = YY^2\n    var yyyy = yy.redSqr();\n    // S = 2 * ((X1 + YY)^2 - XX - YYYY)\n    var s = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);\n    s = s.redIAdd(s);\n    // M = 3 * XX + a; a = 0\n    var m = xx.redAdd(xx).redIAdd(xx);\n    // T = M ^ 2 - 2*S\n    var t = m.redSqr().redISub(s).redISub(s);\n\n    // 8 * YYYY\n    var yyyy8 = yyyy.redIAdd(yyyy);\n    yyyy8 = yyyy8.redIAdd(yyyy8);\n    yyyy8 = yyyy8.redIAdd(yyyy8);\n\n    // X3 = T\n    nx = t;\n    // Y3 = M * (S - T) - 8 * YYYY\n    ny = m.redMul(s.redISub(t)).redISub(yyyy8);\n    // Z3 = 2*Y1\n    nz = this.y.redAdd(this.y);\n  } else {\n    // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html\n    //     #doubling-dbl-2009-l\n    // 2M + 5S + 13A\n\n    // A = X1^2\n    var a = this.x.redSqr();\n    // B = Y1^2\n    var b = this.y.redSqr();\n    // C = B^2\n    var c = b.redSqr();\n    // D = 2 * ((X1 + B)^2 - A - C)\n    var d = this.x.redAdd(b).redSqr().redISub(a).redISub(c);\n    d = d.redIAdd(d);\n    // E = 3 * A\n    var e = a.redAdd(a).redIAdd(a);\n    // F = E^2\n    var f = e.redSqr();\n\n    // 8 * C\n    var c8 = c.redIAdd(c);\n    c8 = c8.redIAdd(c8);\n    c8 = c8.redIAdd(c8);\n\n    // X3 = F - 2 * D\n    nx = f.redISub(d).redISub(d);\n    // Y3 = E * (D - X3) - 8 * C\n    ny = e.redMul(d.redISub(nx)).redISub(c8);\n    // Z3 = 2 * Y1 * Z1\n    nz = this.y.redMul(this.z);\n    nz = nz.redIAdd(nz);\n  }\n\n  return this.curve.jpoint(nx, ny, nz);\n};\n\nJPoint.prototype._threeDbl = function _threeDbl() {\n  var nx;\n  var ny;\n  var nz;\n  // Z = 1\n  if (this.zOne) {\n    // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-3.html\n    //     #doubling-mdbl-2007-bl\n    // 1M + 5S + 15A\n\n    // XX = X1^2\n    var xx = this.x.redSqr();\n    // YY = Y1^2\n    var yy = this.y.redSqr();\n    // YYYY = YY^2\n    var yyyy = yy.redSqr();\n    // S = 2 * ((X1 + YY)^2 - XX - YYYY)\n    var s = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);\n    s = s.redIAdd(s);\n    // M = 3 * XX + a\n    var m = xx.redAdd(xx).redIAdd(xx).redIAdd(this.curve.a);\n    // T = M^2 - 2 * S\n    var t = m.redSqr().redISub(s).redISub(s);\n    // X3 = T\n    nx = t;\n    // Y3 = M * (S - T) - 8 * YYYY\n    var yyyy8 = yyyy.redIAdd(yyyy);\n    yyyy8 = yyyy8.redIAdd(yyyy8);\n    yyyy8 = yyyy8.redIAdd(yyyy8);\n    ny = m.redMul(s.redISub(t)).redISub(yyyy8);\n    // Z3 = 2 * Y1\n    nz = this.y.redAdd(this.y);\n  } else {\n    // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-3.html#doubling-dbl-2001-b\n    // 3M + 5S\n\n    // delta = Z1^2\n    var delta = this.z.redSqr();\n    // gamma = Y1^2\n    var gamma = this.y.redSqr();\n    // beta = X1 * gamma\n    var beta = this.x.redMul(gamma);\n    // alpha = 3 * (X1 - delta) * (X1 + delta)\n    var alpha = this.x.redSub(delta).redMul(this.x.redAdd(delta));\n    alpha = alpha.redAdd(alpha).redIAdd(alpha);\n    // X3 = alpha^2 - 8 * beta\n    var beta4 = beta.redIAdd(beta);\n    beta4 = beta4.redIAdd(beta4);\n    var beta8 = beta4.redAdd(beta4);\n    nx = alpha.redSqr().redISub(beta8);\n    // Z3 = (Y1 + Z1)^2 - gamma - delta\n    nz = this.y.redAdd(this.z).redSqr().redISub(gamma).redISub(delta);\n    // Y3 = alpha * (4 * beta - X3) - 8 * gamma^2\n    var ggamma8 = gamma.redSqr();\n    ggamma8 = ggamma8.redIAdd(ggamma8);\n    ggamma8 = ggamma8.redIAdd(ggamma8);\n    ggamma8 = ggamma8.redIAdd(ggamma8);\n    ny = alpha.redMul(beta4.redISub(nx)).redISub(ggamma8);\n  }\n\n  return this.curve.jpoint(nx, ny, nz);\n};\n\nJPoint.prototype._dbl = function _dbl() {\n  var a = this.curve.a;\n\n  // 4M + 6S + 10A\n  var jx = this.x;\n  var jy = this.y;\n  var jz = this.z;\n  var jz4 = jz.redSqr().redSqr();\n\n  var jx2 = jx.redSqr();\n  var jy2 = jy.redSqr();\n\n  var c = jx2.redAdd(jx2).redIAdd(jx2).redIAdd(a.redMul(jz4));\n\n  var jxd4 = jx.redAdd(jx);\n  jxd4 = jxd4.redIAdd(jxd4);\n  var t1 = jxd4.redMul(jy2);\n  var nx = c.redSqr().redISub(t1.redAdd(t1));\n  var t2 = t1.redISub(nx);\n\n  var jyd8 = jy2.redSqr();\n  jyd8 = jyd8.redIAdd(jyd8);\n  jyd8 = jyd8.redIAdd(jyd8);\n  jyd8 = jyd8.redIAdd(jyd8);\n  var ny = c.redMul(t2).redISub(jyd8);\n  var nz = jy.redAdd(jy).redMul(jz);\n\n  return this.curve.jpoint(nx, ny, nz);\n};\n\nJPoint.prototype.trpl = function trpl() {\n  if (!this.curve.zeroA)\n    return this.dbl().add(this);\n\n  // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html#tripling-tpl-2007-bl\n  // 5M + 10S + ...\n\n  // XX = X1^2\n  var xx = this.x.redSqr();\n  // YY = Y1^2\n  var yy = this.y.redSqr();\n  // ZZ = Z1^2\n  var zz = this.z.redSqr();\n  // YYYY = YY^2\n  var yyyy = yy.redSqr();\n  // M = 3 * XX + a * ZZ2; a = 0\n  var m = xx.redAdd(xx).redIAdd(xx);\n  // MM = M^2\n  var mm = m.redSqr();\n  // E = 6 * ((X1 + YY)^2 - XX - YYYY) - MM\n  var e = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);\n  e = e.redIAdd(e);\n  e = e.redAdd(e).redIAdd(e);\n  e = e.redISub(mm);\n  // EE = E^2\n  var ee = e.redSqr();\n  // T = 16*YYYY\n  var t = yyyy.redIAdd(yyyy);\n  t = t.redIAdd(t);\n  t = t.redIAdd(t);\n  t = t.redIAdd(t);\n  // U = (M + E)^2 - MM - EE - T\n  var u = m.redIAdd(e).redSqr().redISub(mm).redISub(ee).redISub(t);\n  // X3 = 4 * (X1 * EE - 4 * YY * U)\n  var yyu4 = yy.redMul(u);\n  yyu4 = yyu4.redIAdd(yyu4);\n  yyu4 = yyu4.redIAdd(yyu4);\n  var nx = this.x.redMul(ee).redISub(yyu4);\n  nx = nx.redIAdd(nx);\n  nx = nx.redIAdd(nx);\n  // Y3 = 8 * Y1 * (U * (T - U) - E * EE)\n  var ny = this.y.redMul(u.redMul(t.redISub(u)).redISub(e.redMul(ee)));\n  ny = ny.redIAdd(ny);\n  ny = ny.redIAdd(ny);\n  ny = ny.redIAdd(ny);\n  // Z3 = (Z1 + E)^2 - ZZ - EE\n  var nz = this.z.redAdd(e).redSqr().redISub(zz).redISub(ee);\n\n  return this.curve.jpoint(nx, ny, nz);\n};\n\nJPoint.prototype.mul = function mul(k, kbase) {\n  k = new BN(k, kbase);\n\n  return this.curve._wnafMul(this, k);\n};\n\nJPoint.prototype.eq = function eq(p) {\n  if (p.type === 'affine')\n    return this.eq(p.toJ());\n\n  if (this === p)\n    return true;\n\n  // x1 * z2^2 == x2 * z1^2\n  var z2 = this.z.redSqr();\n  var pz2 = p.z.redSqr();\n  if (this.x.redMul(pz2).redISub(p.x.redMul(z2)).cmpn(0) !== 0)\n    return false;\n\n  // y1 * z2^3 == y2 * z1^3\n  var z3 = z2.redMul(this.z);\n  var pz3 = pz2.redMul(p.z);\n  return this.y.redMul(pz3).redISub(p.y.redMul(z3)).cmpn(0) === 0;\n};\n\nJPoint.prototype.eqXToP = function eqXToP(x) {\n  var zs = this.z.redSqr();\n  var rx = x.toRed(this.curve.red).redMul(zs);\n  if (this.x.cmp(rx) === 0)\n    return true;\n\n  var xc = x.clone();\n  var t = this.curve.redN.redMul(zs);\n  for (;;) {\n    xc.iadd(this.curve.n);\n    if (xc.cmp(this.curve.p) >= 0)\n      return false;\n\n    rx.redIAdd(t);\n    if (this.x.cmp(rx) === 0)\n      return true;\n  }\n};\n\nJPoint.prototype.inspect = function inspect() {\n  if (this.isInfinity())\n    return '<EC JPoint Infinity>';\n  return '<EC JPoint x: ' + this.x.toString(16, 2) +\n      ' y: ' + this.y.toString(16, 2) +\n      ' z: ' + this.z.toString(16, 2) + '>';\n};\n\nJPoint.prototype.isInfinity = function isInfinity() {\n  // XXX This code assumes that zero is always zero in red\n  return this.z.cmpn(0) === 0;\n};\n",
    "'use strict';\n\nvar BN = require('bn.js');\nvar inherits = require('inherits');\nvar Base = require('./base');\n\nvar utils = require('../utils');\n\nfunction MontCurve(conf) {\n  Base.call(this, 'mont', conf);\n\n  this.a = new BN(conf.a, 16).toRed(this.red);\n  this.b = new BN(conf.b, 16).toRed(this.red);\n  this.i4 = new BN(4).toRed(this.red).redInvm();\n  this.two = new BN(2).toRed(this.red);\n  this.a24 = this.i4.redMul(this.a.redAdd(this.two));\n}\ninherits(MontCurve, Base);\nmodule.exports = MontCurve;\n\nMontCurve.prototype.validate = function validate(point) {\n  var x = point.normalize().x;\n  var x2 = x.redSqr();\n  var rhs = x2.redMul(x).redAdd(x2.redMul(this.a)).redAdd(x);\n  var y = rhs.redSqrt();\n\n  return y.redSqr().cmp(rhs) === 0;\n};\n\nfunction Point(curve, x, z) {\n  Base.BasePoint.call(this, curve, 'projective');\n  if (x === null && z === null) {\n    this.x = this.curve.one;\n    this.z = this.curve.zero;\n  } else {\n    this.x = new BN(x, 16);\n    this.z = new BN(z, 16);\n    if (!this.x.red)\n      this.x = this.x.toRed(this.curve.red);\n    if (!this.z.red)\n      this.z = this.z.toRed(this.curve.red);\n  }\n}\ninherits(Point, Base.BasePoint);\n\nMontCurve.prototype.decodePoint = function decodePoint(bytes, enc) {\n  return this.point(utils.toArray(bytes, enc), 1);\n};\n\nMontCurve.prototype.point = function point(x, z) {\n  return new Point(this, x, z);\n};\n\nMontCurve.prototype.pointFromJSON = function pointFromJSON(obj) {\n  return Point.fromJSON(this, obj);\n};\n\nPoint.prototype.precompute = function precompute() {\n  // No-op\n};\n\nPoint.prototype._encode = function _encode() {\n  return this.getX().toArray('be', this.curve.p.byteLength());\n};\n\nPoint.fromJSON = function fromJSON(curve, obj) {\n  return new Point(curve, obj[0], obj[1] || curve.one);\n};\n\nPoint.prototype.inspect = function inspect() {\n  if (this.isInfinity())\n    return '<EC Point Infinity>';\n  return '<EC Point x: ' + this.x.fromRed().toString(16, 2) +\n      ' z: ' + this.z.fromRed().toString(16, 2) + '>';\n};\n\nPoint.prototype.isInfinity = function isInfinity() {\n  // XXX This code assumes that zero is always zero in red\n  return this.z.cmpn(0) === 0;\n};\n\nPoint.prototype.dbl = function dbl() {\n  // http://hyperelliptic.org/EFD/g1p/auto-montgom-xz.html#doubling-dbl-1987-m-3\n  // 2M + 2S + 4A\n\n  // A = X1 + Z1\n  var a = this.x.redAdd(this.z);\n  // AA = A^2\n  var aa = a.redSqr();\n  // B = X1 - Z1\n  var b = this.x.redSub(this.z);\n  // BB = B^2\n  var bb = b.redSqr();\n  // C = AA - BB\n  var c = aa.redSub(bb);\n  // X3 = AA * BB\n  var nx = aa.redMul(bb);\n  // Z3 = C * (BB + A24 * C)\n  var nz = c.redMul(bb.redAdd(this.curve.a24.redMul(c)));\n  return this.curve.point(nx, nz);\n};\n\nPoint.prototype.add = function add() {\n  throw new Error('Not supported on Montgomery curve');\n};\n\nPoint.prototype.diffAdd = function diffAdd(p, diff) {\n  // http://hyperelliptic.org/EFD/g1p/auto-montgom-xz.html#diffadd-dadd-1987-m-3\n  // 4M + 2S + 6A\n\n  // A = X2 + Z2\n  var a = this.x.redAdd(this.z);\n  // B = X2 - Z2\n  var b = this.x.redSub(this.z);\n  // C = X3 + Z3\n  var c = p.x.redAdd(p.z);\n  // D = X3 - Z3\n  var d = p.x.redSub(p.z);\n  // DA = D * A\n  var da = d.redMul(a);\n  // CB = C * B\n  var cb = c.redMul(b);\n  // X5 = Z1 * (DA + CB)^2\n  var nx = diff.z.redMul(da.redAdd(cb).redSqr());\n  // Z5 = X1 * (DA - CB)^2\n  var nz = diff.x.redMul(da.redISub(cb).redSqr());\n  return this.curve.point(nx, nz);\n};\n\nPoint.prototype.mul = function mul(k) {\n  var t = k.clone();\n  var a = this; // (N / 2) * Q + Q\n  var b = this.curve.point(null, null); // (N / 2) * Q\n  var c = this; // Q\n\n  for (var bits = []; t.cmpn(0) !== 0; t.iushrn(1))\n    bits.push(t.andln(1));\n\n  for (var i = bits.length - 1; i >= 0; i--) {\n    if (bits[i] === 0) {\n      // N * Q + Q = ((N / 2) * Q + Q)) + (N / 2) * Q\n      a = a.diffAdd(b, c);\n      // N * Q = 2 * ((N / 2) * Q + Q))\n      b = b.dbl();\n    } else {\n      // N * Q = ((N / 2) * Q + Q) + ((N / 2) * Q)\n      b = a.diffAdd(b, c);\n      // N * Q + Q = 2 * ((N / 2) * Q + Q)\n      a = a.dbl();\n    }\n  }\n  return b;\n};\n\nPoint.prototype.mulAdd = function mulAdd() {\n  throw new Error('Not supported on Montgomery curve');\n};\n\nPoint.prototype.jumlAdd = function jumlAdd() {\n  throw new Error('Not supported on Montgomery curve');\n};\n\nPoint.prototype.eq = function eq(other) {\n  return this.getX().cmp(other.getX()) === 0;\n};\n\nPoint.prototype.normalize = function normalize() {\n  this.x = this.x.redMul(this.z.redInvm());\n  this.z = this.curve.one;\n  return this;\n};\n\nPoint.prototype.getX = function getX() {\n  // Normalize coordinates\n  this.normalize();\n\n  return this.x.fromRed();\n};\n",
    "'use strict';\n\nvar utils = require('../utils');\nvar BN = require('bn.js');\nvar inherits = require('inherits');\nvar Base = require('./base');\n\nvar assert = utils.assert;\n\nfunction EdwardsCurve(conf) {\n  // NOTE: Important as we are creating point in Base.call()\n  this.twisted = (conf.a | 0) !== 1;\n  this.mOneA = this.twisted && (conf.a | 0) === -1;\n  this.extended = this.mOneA;\n\n  Base.call(this, 'edwards', conf);\n\n  this.a = new BN(conf.a, 16).umod(this.red.m);\n  this.a = this.a.toRed(this.red);\n  this.c = new BN(conf.c, 16).toRed(this.red);\n  this.c2 = this.c.redSqr();\n  this.d = new BN(conf.d, 16).toRed(this.red);\n  this.dd = this.d.redAdd(this.d);\n\n  assert(!this.twisted || this.c.fromRed().cmpn(1) === 0);\n  this.oneC = (conf.c | 0) === 1;\n}\ninherits(EdwardsCurve, Base);\nmodule.exports = EdwardsCurve;\n\nEdwardsCurve.prototype._mulA = function _mulA(num) {\n  if (this.mOneA)\n    return num.redNeg();\n  else\n    return this.a.redMul(num);\n};\n\nEdwardsCurve.prototype._mulC = function _mulC(num) {\n  if (this.oneC)\n    return num;\n  else\n    return this.c.redMul(num);\n};\n\n// Just for compatibility with Short curve\nEdwardsCurve.prototype.jpoint = function jpoint(x, y, z, t) {\n  return this.point(x, y, z, t);\n};\n\nEdwardsCurve.prototype.pointFromX = function pointFromX(x, odd) {\n  x = new BN(x, 16);\n  if (!x.red)\n    x = x.toRed(this.red);\n\n  var x2 = x.redSqr();\n  var rhs = this.c2.redSub(this.a.redMul(x2));\n  var lhs = this.one.redSub(this.c2.redMul(this.d).redMul(x2));\n\n  var y2 = rhs.redMul(lhs.redInvm());\n  var y = y2.redSqrt();\n  if (y.redSqr().redSub(y2).cmp(this.zero) !== 0)\n    throw new Error('invalid point');\n\n  var isOdd = y.fromRed().isOdd();\n  if (odd && !isOdd || !odd && isOdd)\n    y = y.redNeg();\n\n  return this.point(x, y);\n};\n\nEdwardsCurve.prototype.pointFromY = function pointFromY(y, odd) {\n  y = new BN(y, 16);\n  if (!y.red)\n    y = y.toRed(this.red);\n\n  // x^2 = (y^2 - c^2) / (c^2 d y^2 - a)\n  var y2 = y.redSqr();\n  var lhs = y2.redSub(this.c2);\n  var rhs = y2.redMul(this.d).redMul(this.c2).redSub(this.a);\n  var x2 = lhs.redMul(rhs.redInvm());\n\n  if (x2.cmp(this.zero) === 0) {\n    if (odd)\n      throw new Error('invalid point');\n    else\n      return this.point(this.zero, y);\n  }\n\n  var x = x2.redSqrt();\n  if (x.redSqr().redSub(x2).cmp(this.zero) !== 0)\n    throw new Error('invalid point');\n\n  if (x.fromRed().isOdd() !== odd)\n    x = x.redNeg();\n\n  return this.point(x, y);\n};\n\nEdwardsCurve.prototype.validate = function validate(point) {\n  if (point.isInfinity())\n    return true;\n\n  // Curve: A * X^2 + Y^2 = C^2 * (1 + D * X^2 * Y^2)\n  point.normalize();\n\n  var x2 = point.x.redSqr();\n  var y2 = point.y.redSqr();\n  var lhs = x2.redMul(this.a).redAdd(y2);\n  var rhs = this.c2.redMul(this.one.redAdd(this.d.redMul(x2).redMul(y2)));\n\n  return lhs.cmp(rhs) === 0;\n};\n\nfunction Point(curve, x, y, z, t) {\n  Base.BasePoint.call(this, curve, 'projective');\n  if (x === null && y === null && z === null) {\n    this.x = this.curve.zero;\n    this.y = this.curve.one;\n    this.z = this.curve.one;\n    this.t = this.curve.zero;\n    this.zOne = true;\n  } else {\n    this.x = new BN(x, 16);\n    this.y = new BN(y, 16);\n    this.z = z ? new BN(z, 16) : this.curve.one;\n    this.t = t && new BN(t, 16);\n    if (!this.x.red)\n      this.x = this.x.toRed(this.curve.red);\n    if (!this.y.red)\n      this.y = this.y.toRed(this.curve.red);\n    if (!this.z.red)\n      this.z = this.z.toRed(this.curve.red);\n    if (this.t && !this.t.red)\n      this.t = this.t.toRed(this.curve.red);\n    this.zOne = this.z === this.curve.one;\n\n    // Use extended coordinates\n    if (this.curve.extended && !this.t) {\n      this.t = this.x.redMul(this.y);\n      if (!this.zOne)\n        this.t = this.t.redMul(this.z.redInvm());\n    }\n  }\n}\ninherits(Point, Base.BasePoint);\n\nEdwardsCurve.prototype.pointFromJSON = function pointFromJSON(obj) {\n  return Point.fromJSON(this, obj);\n};\n\nEdwardsCurve.prototype.point = function point(x, y, z, t) {\n  return new Point(this, x, y, z, t);\n};\n\nPoint.fromJSON = function fromJSON(curve, obj) {\n  return new Point(curve, obj[0], obj[1], obj[2]);\n};\n\nPoint.prototype.inspect = function inspect() {\n  if (this.isInfinity())\n    return '<EC Point Infinity>';\n  return '<EC Point x: ' + this.x.fromRed().toString(16, 2) +\n      ' y: ' + this.y.fromRed().toString(16, 2) +\n      ' z: ' + this.z.fromRed().toString(16, 2) + '>';\n};\n\nPoint.prototype.isInfinity = function isInfinity() {\n  // XXX This code assumes that zero is always zero in red\n  return this.x.cmpn(0) === 0 &&\n    (this.y.cmp(this.z) === 0 ||\n    (this.zOne && this.y.cmp(this.curve.c) === 0));\n};\n\nPoint.prototype._extDbl = function _extDbl() {\n  // hyperelliptic.org/EFD/g1p/auto-twisted-extended-1.html\n  //     #doubling-dbl-2008-hwcd\n  // 4M + 4S\n\n  // A = X1^2\n  var a = this.x.redSqr();\n  // B = Y1^2\n  var b = this.y.redSqr();\n  // C = 2 * Z1^2\n  var c = this.z.redSqr();\n  c = c.redIAdd(c);\n  // D = a * A\n  var d = this.curve._mulA(a);\n  // E = (X1 + Y1)^2 - A - B\n  var e = this.x.redAdd(this.y).redSqr().redISub(a).redISub(b);\n  // G = D + B\n  var g = d.redAdd(b);\n  // F = G - C\n  var f = g.redSub(c);\n  // H = D - B\n  var h = d.redSub(b);\n  // X3 = E * F\n  var nx = e.redMul(f);\n  // Y3 = G * H\n  var ny = g.redMul(h);\n  // T3 = E * H\n  var nt = e.redMul(h);\n  // Z3 = F * G\n  var nz = f.redMul(g);\n  return this.curve.point(nx, ny, nz, nt);\n};\n\nPoint.prototype._projDbl = function _projDbl() {\n  // hyperelliptic.org/EFD/g1p/auto-twisted-projective.html\n  //     #doubling-dbl-2008-bbjlp\n  //     #doubling-dbl-2007-bl\n  // and others\n  // Generally 3M + 4S or 2M + 4S\n\n  // B = (X1 + Y1)^2\n  var b = this.x.redAdd(this.y).redSqr();\n  // C = X1^2\n  var c = this.x.redSqr();\n  // D = Y1^2\n  var d = this.y.redSqr();\n\n  var nx;\n  var ny;\n  var nz;\n  var e;\n  var h;\n  var j;\n  if (this.curve.twisted) {\n    // E = a * C\n    e = this.curve._mulA(c);\n    // F = E + D\n    var f = e.redAdd(d);\n    if (this.zOne) {\n      // X3 = (B - C - D) * (F - 2)\n      nx = b.redSub(c).redSub(d).redMul(f.redSub(this.curve.two));\n      // Y3 = F * (E - D)\n      ny = f.redMul(e.redSub(d));\n      // Z3 = F^2 - 2 * F\n      nz = f.redSqr().redSub(f).redSub(f);\n    } else {\n      // H = Z1^2\n      h = this.z.redSqr();\n      // J = F - 2 * H\n      j = f.redSub(h).redISub(h);\n      // X3 = (B-C-D)*J\n      nx = b.redSub(c).redISub(d).redMul(j);\n      // Y3 = F * (E - D)\n      ny = f.redMul(e.redSub(d));\n      // Z3 = F * J\n      nz = f.redMul(j);\n    }\n  } else {\n    // E = C + D\n    e = c.redAdd(d);\n    // H = (c * Z1)^2\n    h = this.curve._mulC(this.z).redSqr();\n    // J = E - 2 * H\n    j = e.redSub(h).redSub(h);\n    // X3 = c * (B - E) * J\n    nx = this.curve._mulC(b.redISub(e)).redMul(j);\n    // Y3 = c * E * (C - D)\n    ny = this.curve._mulC(e).redMul(c.redISub(d));\n    // Z3 = E * J\n    nz = e.redMul(j);\n  }\n  return this.curve.point(nx, ny, nz);\n};\n\nPoint.prototype.dbl = function dbl() {\n  if (this.isInfinity())\n    return this;\n\n  // Double in extended coordinates\n  if (this.curve.extended)\n    return this._extDbl();\n  else\n    return this._projDbl();\n};\n\nPoint.prototype._extAdd = function _extAdd(p) {\n  // hyperelliptic.org/EFD/g1p/auto-twisted-extended-1.html\n  //     #addition-add-2008-hwcd-3\n  // 8M\n\n  // A = (Y1 - X1) * (Y2 - X2)\n  var a = this.y.redSub(this.x).redMul(p.y.redSub(p.x));\n  // B = (Y1 + X1) * (Y2 + X2)\n  var b = this.y.redAdd(this.x).redMul(p.y.redAdd(p.x));\n  // C = T1 * k * T2\n  var c = this.t.redMul(this.curve.dd).redMul(p.t);\n  // D = Z1 * 2 * Z2\n  var d = this.z.redMul(p.z.redAdd(p.z));\n  // E = B - A\n  var e = b.redSub(a);\n  // F = D - C\n  var f = d.redSub(c);\n  // G = D + C\n  var g = d.redAdd(c);\n  // H = B + A\n  var h = b.redAdd(a);\n  // X3 = E * F\n  var nx = e.redMul(f);\n  // Y3 = G * H\n  var ny = g.redMul(h);\n  // T3 = E * H\n  var nt = e.redMul(h);\n  // Z3 = F * G\n  var nz = f.redMul(g);\n  return this.curve.point(nx, ny, nz, nt);\n};\n\nPoint.prototype._projAdd = function _projAdd(p) {\n  // hyperelliptic.org/EFD/g1p/auto-twisted-projective.html\n  //     #addition-add-2008-bbjlp\n  //     #addition-add-2007-bl\n  // 10M + 1S\n\n  // A = Z1 * Z2\n  var a = this.z.redMul(p.z);\n  // B = A^2\n  var b = a.redSqr();\n  // C = X1 * X2\n  var c = this.x.redMul(p.x);\n  // D = Y1 * Y2\n  var d = this.y.redMul(p.y);\n  // E = d * C * D\n  var e = this.curve.d.redMul(c).redMul(d);\n  // F = B - E\n  var f = b.redSub(e);\n  // G = B + E\n  var g = b.redAdd(e);\n  // X3 = A * F * ((X1 + Y1) * (X2 + Y2) - C - D)\n  var tmp = this.x.redAdd(this.y).redMul(p.x.redAdd(p.y)).redISub(c).redISub(d);\n  var nx = a.redMul(f).redMul(tmp);\n  var ny;\n  var nz;\n  if (this.curve.twisted) {\n    // Y3 = A * G * (D - a * C)\n    ny = a.redMul(g).redMul(d.redSub(this.curve._mulA(c)));\n    // Z3 = F * G\n    nz = f.redMul(g);\n  } else {\n    // Y3 = A * G * (D - C)\n    ny = a.redMul(g).redMul(d.redSub(c));\n    // Z3 = c * F * G\n    nz = this.curve._mulC(f).redMul(g);\n  }\n  return this.curve.point(nx, ny, nz);\n};\n\nPoint.prototype.add = function add(p) {\n  if (this.isInfinity())\n    return p;\n  if (p.isInfinity())\n    return this;\n\n  if (this.curve.extended)\n    return this._extAdd(p);\n  else\n    return this._projAdd(p);\n};\n\nPoint.prototype.mul = function mul(k) {\n  if (this._hasDoubles(k))\n    return this.curve._fixedNafMul(this, k);\n  else\n    return this.curve._wnafMul(this, k);\n};\n\nPoint.prototype.mulAdd = function mulAdd(k1, p, k2) {\n  return this.curve._wnafMulAdd(1, [ this, p ], [ k1, k2 ], 2, false);\n};\n\nPoint.prototype.jmulAdd = function jmulAdd(k1, p, k2) {\n  return this.curve._wnafMulAdd(1, [ this, p ], [ k1, k2 ], 2, true);\n};\n\nPoint.prototype.normalize = function normalize() {\n  if (this.zOne)\n    return this;\n\n  // Normalize coordinates\n  var zi = this.z.redInvm();\n  this.x = this.x.redMul(zi);\n  this.y = this.y.redMul(zi);\n  if (this.t)\n    this.t = this.t.redMul(zi);\n  this.z = this.curve.one;\n  this.zOne = true;\n  return this;\n};\n\nPoint.prototype.neg = function neg() {\n  return this.curve.point(this.x.redNeg(),\n    this.y,\n    this.z,\n    this.t && this.t.redNeg());\n};\n\nPoint.prototype.getX = function getX() {\n  this.normalize();\n  return this.x.fromRed();\n};\n\nPoint.prototype.getY = function getY() {\n  this.normalize();\n  return this.y.fromRed();\n};\n\nPoint.prototype.eq = function eq(other) {\n  return this === other ||\n         this.getX().cmp(other.getX()) === 0 &&\n         this.getY().cmp(other.getY()) === 0;\n};\n\nPoint.prototype.eqXToP = function eqXToP(x) {\n  var rx = x.toRed(this.curve.red).redMul(this.z);\n  if (this.x.cmp(rx) === 0)\n    return true;\n\n  var xc = x.clone();\n  var t = this.curve.redN.redMul(this.z);\n  for (;;) {\n    xc.iadd(this.curve.n);\n    if (xc.cmp(this.curve.p) >= 0)\n      return false;\n\n    rx.redIAdd(t);\n    if (this.x.cmp(rx) === 0)\n      return true;\n  }\n};\n\n// Compatibility with BaseCurve\nPoint.prototype.toP = Point.prototype.normalize;\nPoint.prototype.mixedAdd = Point.prototype.add;\n",
    "'use strict';\n\nvar curve = exports;\n\ncurve.base = require('./base');\ncurve.short = require('./short');\ncurve.mont = require('./mont');\ncurve.edwards = require('./edwards');\n",
    "'use strict';\n\nvar assert = require('minimalistic-assert');\nvar inherits = require('inherits');\n\nexports.inherits = inherits;\n\nfunction isSurrogatePair(msg, i) {\n  if ((msg.charCodeAt(i) & 0xFC00) !== 0xD800) {\n    return false;\n  }\n  if (i < 0 || i + 1 >= msg.length) {\n    return false;\n  }\n  return (msg.charCodeAt(i + 1) & 0xFC00) === 0xDC00;\n}\n\nfunction toArray(msg, enc) {\n  if (Array.isArray(msg))\n    return msg.slice();\n  if (!msg)\n    return [];\n  var res = [];\n  if (typeof msg === 'string') {\n    if (!enc) {\n      // Inspired by stringToUtf8ByteArray() in closure-library by Google\n      // https://github.com/google/closure-library/blob/8598d87242af59aac233270742c8984e2b2bdbe0/closure/goog/crypt/crypt.js#L117-L143\n      // Apache License 2.0\n      // https://github.com/google/closure-library/blob/master/LICENSE\n      var p = 0;\n      for (var i = 0; i < msg.length; i++) {\n        var c = msg.charCodeAt(i);\n        if (c < 128) {\n          res[p++] = c;\n        } else if (c < 2048) {\n          res[p++] = (c >> 6) | 192;\n          res[p++] = (c & 63) | 128;\n        } else if (isSurrogatePair(msg, i)) {\n          c = 0x10000 + ((c & 0x03FF) << 10) + (msg.charCodeAt(++i) & 0x03FF);\n          res[p++] = (c >> 18) | 240;\n          res[p++] = ((c >> 12) & 63) | 128;\n          res[p++] = ((c >> 6) & 63) | 128;\n          res[p++] = (c & 63) | 128;\n        } else {\n          res[p++] = (c >> 12) | 224;\n          res[p++] = ((c >> 6) & 63) | 128;\n          res[p++] = (c & 63) | 128;\n        }\n      }\n    } else if (enc === 'hex') {\n      msg = msg.replace(/[^a-z0-9]+/ig, '');\n      if (msg.length % 2 !== 0)\n        msg = '0' + msg;\n      for (i = 0; i < msg.length; i += 2)\n        res.push(parseInt(msg[i] + msg[i + 1], 16));\n    }\n  } else {\n    for (i = 0; i < msg.length; i++)\n      res[i] = msg[i] | 0;\n  }\n  return res;\n}\nexports.toArray = toArray;\n\nfunction toHex(msg) {\n  var res = '';\n  for (var i = 0; i < msg.length; i++)\n    res += zero2(msg[i].toString(16));\n  return res;\n}\nexports.toHex = toHex;\n\nfunction htonl(w) {\n  var res = (w >>> 24) |\n            ((w >>> 8) & 0xff00) |\n            ((w << 8) & 0xff0000) |\n            ((w & 0xff) << 24);\n  return res >>> 0;\n}\nexports.htonl = htonl;\n\nfunction toHex32(msg, endian) {\n  var res = '';\n  for (var i = 0; i < msg.length; i++) {\n    var w = msg[i];\n    if (endian === 'little')\n      w = htonl(w);\n    res += zero8(w.toString(16));\n  }\n  return res;\n}\nexports.toHex32 = toHex32;\n\nfunction zero2(word) {\n  if (word.length === 1)\n    return '0' + word;\n  else\n    return word;\n}\nexports.zero2 = zero2;\n\nfunction zero8(word) {\n  if (word.length === 7)\n    return '0' + word;\n  else if (word.length === 6)\n    return '00' + word;\n  else if (word.length === 5)\n    return '000' + word;\n  else if (word.length === 4)\n    return '0000' + word;\n  else if (word.length === 3)\n    return '00000' + word;\n  else if (word.length === 2)\n    return '000000' + word;\n  else if (word.length === 1)\n    return '0000000' + word;\n  else\n    return word;\n}\nexports.zero8 = zero8;\n\nfunction join32(msg, start, end, endian) {\n  var len = end - start;\n  assert(len % 4 === 0);\n  var res = new Array(len / 4);\n  for (var i = 0, k = start; i < res.length; i++, k += 4) {\n    var w;\n    if (endian === 'big')\n      w = (msg[k] << 24) | (msg[k + 1] << 16) | (msg[k + 2] << 8) | msg[k + 3];\n    else\n      w = (msg[k + 3] << 24) | (msg[k + 2] << 16) | (msg[k + 1] << 8) | msg[k];\n    res[i] = w >>> 0;\n  }\n  return res;\n}\nexports.join32 = join32;\n\nfunction split32(msg, endian) {\n  var res = new Array(msg.length * 4);\n  for (var i = 0, k = 0; i < msg.length; i++, k += 4) {\n    var m = msg[i];\n    if (endian === 'big') {\n      res[k] = m >>> 24;\n      res[k + 1] = (m >>> 16) & 0xff;\n      res[k + 2] = (m >>> 8) & 0xff;\n      res[k + 3] = m & 0xff;\n    } else {\n      res[k + 3] = m >>> 24;\n      res[k + 2] = (m >>> 16) & 0xff;\n      res[k + 1] = (m >>> 8) & 0xff;\n      res[k] = m & 0xff;\n    }\n  }\n  return res;\n}\nexports.split32 = split32;\n\nfunction rotr32(w, b) {\n  return (w >>> b) | (w << (32 - b));\n}\nexports.rotr32 = rotr32;\n\nfunction rotl32(w, b) {\n  return (w << b) | (w >>> (32 - b));\n}\nexports.rotl32 = rotl32;\n\nfunction sum32(a, b) {\n  return (a + b) >>> 0;\n}\nexports.sum32 = sum32;\n\nfunction sum32_3(a, b, c) {\n  return (a + b + c) >>> 0;\n}\nexports.sum32_3 = sum32_3;\n\nfunction sum32_4(a, b, c, d) {\n  return (a + b + c + d) >>> 0;\n}\nexports.sum32_4 = sum32_4;\n\nfunction sum32_5(a, b, c, d, e) {\n  return (a + b + c + d + e) >>> 0;\n}\nexports.sum32_5 = sum32_5;\n\nfunction sum64(buf, pos, ah, al) {\n  var bh = buf[pos];\n  var bl = buf[pos + 1];\n\n  var lo = (al + bl) >>> 0;\n  var hi = (lo < al ? 1 : 0) + ah + bh;\n  buf[pos] = hi >>> 0;\n  buf[pos + 1] = lo;\n}\nexports.sum64 = sum64;\n\nfunction sum64_hi(ah, al, bh, bl) {\n  var lo = (al + bl) >>> 0;\n  var hi = (lo < al ? 1 : 0) + ah + bh;\n  return hi >>> 0;\n}\nexports.sum64_hi = sum64_hi;\n\nfunction sum64_lo(ah, al, bh, bl) {\n  var lo = al + bl;\n  return lo >>> 0;\n}\nexports.sum64_lo = sum64_lo;\n\nfunction sum64_4_hi(ah, al, bh, bl, ch, cl, dh, dl) {\n  var carry = 0;\n  var lo = al;\n  lo = (lo + bl) >>> 0;\n  carry += lo < al ? 1 : 0;\n  lo = (lo + cl) >>> 0;\n  carry += lo < cl ? 1 : 0;\n  lo = (lo + dl) >>> 0;\n  carry += lo < dl ? 1 : 0;\n\n  var hi = ah + bh + ch + dh + carry;\n  return hi >>> 0;\n}\nexports.sum64_4_hi = sum64_4_hi;\n\nfunction sum64_4_lo(ah, al, bh, bl, ch, cl, dh, dl) {\n  var lo = al + bl + cl + dl;\n  return lo >>> 0;\n}\nexports.sum64_4_lo = sum64_4_lo;\n\nfunction sum64_5_hi(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {\n  var carry = 0;\n  var lo = al;\n  lo = (lo + bl) >>> 0;\n  carry += lo < al ? 1 : 0;\n  lo = (lo + cl) >>> 0;\n  carry += lo < cl ? 1 : 0;\n  lo = (lo + dl) >>> 0;\n  carry += lo < dl ? 1 : 0;\n  lo = (lo + el) >>> 0;\n  carry += lo < el ? 1 : 0;\n\n  var hi = ah + bh + ch + dh + eh + carry;\n  return hi >>> 0;\n}\nexports.sum64_5_hi = sum64_5_hi;\n\nfunction sum64_5_lo(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {\n  var lo = al + bl + cl + dl + el;\n\n  return lo >>> 0;\n}\nexports.sum64_5_lo = sum64_5_lo;\n\nfunction rotr64_hi(ah, al, num) {\n  var r = (al << (32 - num)) | (ah >>> num);\n  return r >>> 0;\n}\nexports.rotr64_hi = rotr64_hi;\n\nfunction rotr64_lo(ah, al, num) {\n  var r = (ah << (32 - num)) | (al >>> num);\n  return r >>> 0;\n}\nexports.rotr64_lo = rotr64_lo;\n\nfunction shr64_hi(ah, al, num) {\n  return ah >>> num;\n}\nexports.shr64_hi = shr64_hi;\n\nfunction shr64_lo(ah, al, num) {\n  var r = (ah << (32 - num)) | (al >>> num);\n  return r >>> 0;\n}\nexports.shr64_lo = shr64_lo;\n",
    "'use strict';\n\nvar utils = require('./utils');\nvar assert = require('minimalistic-assert');\n\nfunction BlockHash() {\n  this.pending = null;\n  this.pendingTotal = 0;\n  this.blockSize = this.constructor.blockSize;\n  this.outSize = this.constructor.outSize;\n  this.hmacStrength = this.constructor.hmacStrength;\n  this.padLength = this.constructor.padLength / 8;\n  this.endian = 'big';\n\n  this._delta8 = this.blockSize / 8;\n  this._delta32 = this.blockSize / 32;\n}\nexports.BlockHash = BlockHash;\n\nBlockHash.prototype.update = function update(msg, enc) {\n  // Convert message to array, pad it, and join into 32bit blocks\n  msg = utils.toArray(msg, enc);\n  if (!this.pending)\n    this.pending = msg;\n  else\n    this.pending = this.pending.concat(msg);\n  this.pendingTotal += msg.length;\n\n  // Enough data, try updating\n  if (this.pending.length >= this._delta8) {\n    msg = this.pending;\n\n    // Process pending data in blocks\n    var r = msg.length % this._delta8;\n    this.pending = msg.slice(msg.length - r, msg.length);\n    if (this.pending.length === 0)\n      this.pending = null;\n\n    msg = utils.join32(msg, 0, msg.length - r, this.endian);\n    for (var i = 0; i < msg.length; i += this._delta32)\n      this._update(msg, i, i + this._delta32);\n  }\n\n  return this;\n};\n\nBlockHash.prototype.digest = function digest(enc) {\n  this.update(this._pad());\n  assert(this.pending === null);\n\n  return this._digest(enc);\n};\n\nBlockHash.prototype._pad = function pad() {\n  var len = this.pendingTotal;\n  var bytes = this._delta8;\n  var k = bytes - ((len + this.padLength) % bytes);\n  var res = new Array(k + this.padLength);\n  res[0] = 0x80;\n  for (var i = 1; i < k; i++)\n    res[i] = 0;\n\n  // Append length\n  len <<= 3;\n  if (this.endian === 'big') {\n    for (var t = 8; t < this.padLength; t++)\n      res[i++] = 0;\n\n    res[i++] = 0;\n    res[i++] = 0;\n    res[i++] = 0;\n    res[i++] = 0;\n    res[i++] = (len >>> 24) & 0xff;\n    res[i++] = (len >>> 16) & 0xff;\n    res[i++] = (len >>> 8) & 0xff;\n    res[i++] = len & 0xff;\n  } else {\n    res[i++] = len & 0xff;\n    res[i++] = (len >>> 8) & 0xff;\n    res[i++] = (len >>> 16) & 0xff;\n    res[i++] = (len >>> 24) & 0xff;\n    res[i++] = 0;\n    res[i++] = 0;\n    res[i++] = 0;\n    res[i++] = 0;\n\n    for (t = 8; t < this.padLength; t++)\n      res[i++] = 0;\n  }\n\n  return res;\n};\n",
    "'use strict';\n\nvar utils = require('../utils');\nvar rotr32 = utils.rotr32;\n\nfunction ft_1(s, x, y, z) {\n  if (s === 0)\n    return ch32(x, y, z);\n  if (s === 1 || s === 3)\n    return p32(x, y, z);\n  if (s === 2)\n    return maj32(x, y, z);\n}\nexports.ft_1 = ft_1;\n\nfunction ch32(x, y, z) {\n  return (x & y) ^ ((~x) & z);\n}\nexports.ch32 = ch32;\n\nfunction maj32(x, y, z) {\n  return (x & y) ^ (x & z) ^ (y & z);\n}\nexports.maj32 = maj32;\n\nfunction p32(x, y, z) {\n  return x ^ y ^ z;\n}\nexports.p32 = p32;\n\nfunction s0_256(x) {\n  return rotr32(x, 2) ^ rotr32(x, 13) ^ rotr32(x, 22);\n}\nexports.s0_256 = s0_256;\n\nfunction s1_256(x) {\n  return rotr32(x, 6) ^ rotr32(x, 11) ^ rotr32(x, 25);\n}\nexports.s1_256 = s1_256;\n\nfunction g0_256(x) {\n  return rotr32(x, 7) ^ rotr32(x, 18) ^ (x >>> 3);\n}\nexports.g0_256 = g0_256;\n\nfunction g1_256(x) {\n  return rotr32(x, 17) ^ rotr32(x, 19) ^ (x >>> 10);\n}\nexports.g1_256 = g1_256;\n",
    "'use strict';\n\nvar utils = require('../utils');\nvar common = require('../common');\nvar shaCommon = require('./common');\n\nvar rotl32 = utils.rotl32;\nvar sum32 = utils.sum32;\nvar sum32_5 = utils.sum32_5;\nvar ft_1 = shaCommon.ft_1;\nvar BlockHash = common.BlockHash;\n\nvar sha1_K = [\n  0x5A827999, 0x6ED9EBA1,\n  0x8F1BBCDC, 0xCA62C1D6\n];\n\nfunction SHA1() {\n  if (!(this instanceof SHA1))\n    return new SHA1();\n\n  BlockHash.call(this);\n  this.h = [\n    0x67452301, 0xefcdab89, 0x98badcfe,\n    0x10325476, 0xc3d2e1f0 ];\n  this.W = new Array(80);\n}\n\nutils.inherits(SHA1, BlockHash);\nmodule.exports = SHA1;\n\nSHA1.blockSize = 512;\nSHA1.outSize = 160;\nSHA1.hmacStrength = 80;\nSHA1.padLength = 64;\n\nSHA1.prototype._update = function _update(msg, start) {\n  var W = this.W;\n\n  for (var i = 0; i < 16; i++)\n    W[i] = msg[start + i];\n\n  for(; i < W.length; i++)\n    W[i] = rotl32(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16], 1);\n\n  var a = this.h[0];\n  var b = this.h[1];\n  var c = this.h[2];\n  var d = this.h[3];\n  var e = this.h[4];\n\n  for (i = 0; i < W.length; i++) {\n    var s = ~~(i / 20);\n    var t = sum32_5(rotl32(a, 5), ft_1(s, b, c, d), e, W[i], sha1_K[s]);\n    e = d;\n    d = c;\n    c = rotl32(b, 30);\n    b = a;\n    a = t;\n  }\n\n  this.h[0] = sum32(this.h[0], a);\n  this.h[1] = sum32(this.h[1], b);\n  this.h[2] = sum32(this.h[2], c);\n  this.h[3] = sum32(this.h[3], d);\n  this.h[4] = sum32(this.h[4], e);\n};\n\nSHA1.prototype._digest = function digest(enc) {\n  if (enc === 'hex')\n    return utils.toHex32(this.h, 'big');\n  else\n    return utils.split32(this.h, 'big');\n};\n",
    "'use strict';\n\nvar utils = require('../utils');\nvar common = require('../common');\nvar shaCommon = require('./common');\nvar assert = require('minimalistic-assert');\n\nvar sum32 = utils.sum32;\nvar sum32_4 = utils.sum32_4;\nvar sum32_5 = utils.sum32_5;\nvar ch32 = shaCommon.ch32;\nvar maj32 = shaCommon.maj32;\nvar s0_256 = shaCommon.s0_256;\nvar s1_256 = shaCommon.s1_256;\nvar g0_256 = shaCommon.g0_256;\nvar g1_256 = shaCommon.g1_256;\n\nvar BlockHash = common.BlockHash;\n\nvar sha256_K = [\n  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,\n  0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,\n  0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,\n  0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,\n  0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,\n  0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,\n  0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,\n  0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,\n  0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,\n  0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,\n  0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,\n  0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,\n  0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,\n  0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,\n  0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,\n  0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2\n];\n\nfunction SHA256() {\n  if (!(this instanceof SHA256))\n    return new SHA256();\n\n  BlockHash.call(this);\n  this.h = [\n    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,\n    0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19\n  ];\n  this.k = sha256_K;\n  this.W = new Array(64);\n}\nutils.inherits(SHA256, BlockHash);\nmodule.exports = SHA256;\n\nSHA256.blockSize = 512;\nSHA256.outSize = 256;\nSHA256.hmacStrength = 192;\nSHA256.padLength = 64;\n\nSHA256.prototype._update = function _update(msg, start) {\n  var W = this.W;\n\n  for (var i = 0; i < 16; i++)\n    W[i] = msg[start + i];\n  for (; i < W.length; i++)\n    W[i] = sum32_4(g1_256(W[i - 2]), W[i - 7], g0_256(W[i - 15]), W[i - 16]);\n\n  var a = this.h[0];\n  var b = this.h[1];\n  var c = this.h[2];\n  var d = this.h[3];\n  var e = this.h[4];\n  var f = this.h[5];\n  var g = this.h[6];\n  var h = this.h[7];\n\n  assert(this.k.length === W.length);\n  for (i = 0; i < W.length; i++) {\n    var T1 = sum32_5(h, s1_256(e), ch32(e, f, g), this.k[i], W[i]);\n    var T2 = sum32(s0_256(a), maj32(a, b, c));\n    h = g;\n    g = f;\n    f = e;\n    e = sum32(d, T1);\n    d = c;\n    c = b;\n    b = a;\n    a = sum32(T1, T2);\n  }\n\n  this.h[0] = sum32(this.h[0], a);\n  this.h[1] = sum32(this.h[1], b);\n  this.h[2] = sum32(this.h[2], c);\n  this.h[3] = sum32(this.h[3], d);\n  this.h[4] = sum32(this.h[4], e);\n  this.h[5] = sum32(this.h[5], f);\n  this.h[6] = sum32(this.h[6], g);\n  this.h[7] = sum32(this.h[7], h);\n};\n\nSHA256.prototype._digest = function digest(enc) {\n  if (enc === 'hex')\n    return utils.toHex32(this.h, 'big');\n  else\n    return utils.split32(this.h, 'big');\n};\n",
    "'use strict';\n\nvar utils = require('../utils');\nvar SHA256 = require('./256');\n\nfunction SHA224() {\n  if (!(this instanceof SHA224))\n    return new SHA224();\n\n  SHA256.call(this);\n  this.h = [\n    0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939,\n    0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4 ];\n}\nutils.inherits(SHA224, SHA256);\nmodule.exports = SHA224;\n\nSHA224.blockSize = 512;\nSHA224.outSize = 224;\nSHA224.hmacStrength = 192;\nSHA224.padLength = 64;\n\nSHA224.prototype._digest = function digest(enc) {\n  // Just truncate output\n  if (enc === 'hex')\n    return utils.toHex32(this.h.slice(0, 7), 'big');\n  else\n    return utils.split32(this.h.slice(0, 7), 'big');\n};\n\n",
    "'use strict';\n\nvar utils = require('../utils');\nvar common = require('../common');\nvar assert = require('minimalistic-assert');\n\nvar rotr64_hi = utils.rotr64_hi;\nvar rotr64_lo = utils.rotr64_lo;\nvar shr64_hi = utils.shr64_hi;\nvar shr64_lo = utils.shr64_lo;\nvar sum64 = utils.sum64;\nvar sum64_hi = utils.sum64_hi;\nvar sum64_lo = utils.sum64_lo;\nvar sum64_4_hi = utils.sum64_4_hi;\nvar sum64_4_lo = utils.sum64_4_lo;\nvar sum64_5_hi = utils.sum64_5_hi;\nvar sum64_5_lo = utils.sum64_5_lo;\n\nvar BlockHash = common.BlockHash;\n\nvar sha512_K = [\n  0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd,\n  0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc,\n  0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019,\n  0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118,\n  0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe,\n  0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2,\n  0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1,\n  0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694,\n  0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3,\n  0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65,\n  0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483,\n  0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5,\n  0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210,\n  0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4,\n  0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725,\n  0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70,\n  0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926,\n  0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df,\n  0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8,\n  0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b,\n  0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001,\n  0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30,\n  0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910,\n  0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8,\n  0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53,\n  0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8,\n  0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb,\n  0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3,\n  0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60,\n  0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec,\n  0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9,\n  0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b,\n  0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207,\n  0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178,\n  0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6,\n  0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b,\n  0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493,\n  0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c,\n  0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a,\n  0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817\n];\n\nfunction SHA512() {\n  if (!(this instanceof SHA512))\n    return new SHA512();\n\n  BlockHash.call(this);\n  this.h = [\n    0x6a09e667, 0xf3bcc908,\n    0xbb67ae85, 0x84caa73b,\n    0x3c6ef372, 0xfe94f82b,\n    0xa54ff53a, 0x5f1d36f1,\n    0x510e527f, 0xade682d1,\n    0x9b05688c, 0x2b3e6c1f,\n    0x1f83d9ab, 0xfb41bd6b,\n    0x5be0cd19, 0x137e2179 ];\n  this.k = sha512_K;\n  this.W = new Array(160);\n}\nutils.inherits(SHA512, BlockHash);\nmodule.exports = SHA512;\n\nSHA512.blockSize = 1024;\nSHA512.outSize = 512;\nSHA512.hmacStrength = 192;\nSHA512.padLength = 128;\n\nSHA512.prototype._prepareBlock = function _prepareBlock(msg, start) {\n  var W = this.W;\n\n  // 32 x 32bit words\n  for (var i = 0; i < 32; i++)\n    W[i] = msg[start + i];\n  for (; i < W.length; i += 2) {\n    var c0_hi = g1_512_hi(W[i - 4], W[i - 3]);  // i - 2\n    var c0_lo = g1_512_lo(W[i - 4], W[i - 3]);\n    var c1_hi = W[i - 14];  // i - 7\n    var c1_lo = W[i - 13];\n    var c2_hi = g0_512_hi(W[i - 30], W[i - 29]);  // i - 15\n    var c2_lo = g0_512_lo(W[i - 30], W[i - 29]);\n    var c3_hi = W[i - 32];  // i - 16\n    var c3_lo = W[i - 31];\n\n    W[i] = sum64_4_hi(\n      c0_hi, c0_lo,\n      c1_hi, c1_lo,\n      c2_hi, c2_lo,\n      c3_hi, c3_lo);\n    W[i + 1] = sum64_4_lo(\n      c0_hi, c0_lo,\n      c1_hi, c1_lo,\n      c2_hi, c2_lo,\n      c3_hi, c3_lo);\n  }\n};\n\nSHA512.prototype._update = function _update(msg, start) {\n  this._prepareBlock(msg, start);\n\n  var W = this.W;\n\n  var ah = this.h[0];\n  var al = this.h[1];\n  var bh = this.h[2];\n  var bl = this.h[3];\n  var ch = this.h[4];\n  var cl = this.h[5];\n  var dh = this.h[6];\n  var dl = this.h[7];\n  var eh = this.h[8];\n  var el = this.h[9];\n  var fh = this.h[10];\n  var fl = this.h[11];\n  var gh = this.h[12];\n  var gl = this.h[13];\n  var hh = this.h[14];\n  var hl = this.h[15];\n\n  assert(this.k.length === W.length);\n  for (var i = 0; i < W.length; i += 2) {\n    var c0_hi = hh;\n    var c0_lo = hl;\n    var c1_hi = s1_512_hi(eh, el);\n    var c1_lo = s1_512_lo(eh, el);\n    var c2_hi = ch64_hi(eh, el, fh, fl, gh, gl);\n    var c2_lo = ch64_lo(eh, el, fh, fl, gh, gl);\n    var c3_hi = this.k[i];\n    var c3_lo = this.k[i + 1];\n    var c4_hi = W[i];\n    var c4_lo = W[i + 1];\n\n    var T1_hi = sum64_5_hi(\n      c0_hi, c0_lo,\n      c1_hi, c1_lo,\n      c2_hi, c2_lo,\n      c3_hi, c3_lo,\n      c4_hi, c4_lo);\n    var T1_lo = sum64_5_lo(\n      c0_hi, c0_lo,\n      c1_hi, c1_lo,\n      c2_hi, c2_lo,\n      c3_hi, c3_lo,\n      c4_hi, c4_lo);\n\n    c0_hi = s0_512_hi(ah, al);\n    c0_lo = s0_512_lo(ah, al);\n    c1_hi = maj64_hi(ah, al, bh, bl, ch, cl);\n    c1_lo = maj64_lo(ah, al, bh, bl, ch, cl);\n\n    var T2_hi = sum64_hi(c0_hi, c0_lo, c1_hi, c1_lo);\n    var T2_lo = sum64_lo(c0_hi, c0_lo, c1_hi, c1_lo);\n\n    hh = gh;\n    hl = gl;\n\n    gh = fh;\n    gl = fl;\n\n    fh = eh;\n    fl = el;\n\n    eh = sum64_hi(dh, dl, T1_hi, T1_lo);\n    el = sum64_lo(dl, dl, T1_hi, T1_lo);\n\n    dh = ch;\n    dl = cl;\n\n    ch = bh;\n    cl = bl;\n\n    bh = ah;\n    bl = al;\n\n    ah = sum64_hi(T1_hi, T1_lo, T2_hi, T2_lo);\n    al = sum64_lo(T1_hi, T1_lo, T2_hi, T2_lo);\n  }\n\n  sum64(this.h, 0, ah, al);\n  sum64(this.h, 2, bh, bl);\n  sum64(this.h, 4, ch, cl);\n  sum64(this.h, 6, dh, dl);\n  sum64(this.h, 8, eh, el);\n  sum64(this.h, 10, fh, fl);\n  sum64(this.h, 12, gh, gl);\n  sum64(this.h, 14, hh, hl);\n};\n\nSHA512.prototype._digest = function digest(enc) {\n  if (enc === 'hex')\n    return utils.toHex32(this.h, 'big');\n  else\n    return utils.split32(this.h, 'big');\n};\n\nfunction ch64_hi(xh, xl, yh, yl, zh) {\n  var r = (xh & yh) ^ ((~xh) & zh);\n  if (r < 0)\n    r += 0x100000000;\n  return r;\n}\n\nfunction ch64_lo(xh, xl, yh, yl, zh, zl) {\n  var r = (xl & yl) ^ ((~xl) & zl);\n  if (r < 0)\n    r += 0x100000000;\n  return r;\n}\n\nfunction maj64_hi(xh, xl, yh, yl, zh) {\n  var r = (xh & yh) ^ (xh & zh) ^ (yh & zh);\n  if (r < 0)\n    r += 0x100000000;\n  return r;\n}\n\nfunction maj64_lo(xh, xl, yh, yl, zh, zl) {\n  var r = (xl & yl) ^ (xl & zl) ^ (yl & zl);\n  if (r < 0)\n    r += 0x100000000;\n  return r;\n}\n\nfunction s0_512_hi(xh, xl) {\n  var c0_hi = rotr64_hi(xh, xl, 28);\n  var c1_hi = rotr64_hi(xl, xh, 2);  // 34\n  var c2_hi = rotr64_hi(xl, xh, 7);  // 39\n\n  var r = c0_hi ^ c1_hi ^ c2_hi;\n  if (r < 0)\n    r += 0x100000000;\n  return r;\n}\n\nfunction s0_512_lo(xh, xl) {\n  var c0_lo = rotr64_lo(xh, xl, 28);\n  var c1_lo = rotr64_lo(xl, xh, 2);  // 34\n  var c2_lo = rotr64_lo(xl, xh, 7);  // 39\n\n  var r = c0_lo ^ c1_lo ^ c2_lo;\n  if (r < 0)\n    r += 0x100000000;\n  return r;\n}\n\nfunction s1_512_hi(xh, xl) {\n  var c0_hi = rotr64_hi(xh, xl, 14);\n  var c1_hi = rotr64_hi(xh, xl, 18);\n  var c2_hi = rotr64_hi(xl, xh, 9);  // 41\n\n  var r = c0_hi ^ c1_hi ^ c2_hi;\n  if (r < 0)\n    r += 0x100000000;\n  return r;\n}\n\nfunction s1_512_lo(xh, xl) {\n  var c0_lo = rotr64_lo(xh, xl, 14);\n  var c1_lo = rotr64_lo(xh, xl, 18);\n  var c2_lo = rotr64_lo(xl, xh, 9);  // 41\n\n  var r = c0_lo ^ c1_lo ^ c2_lo;\n  if (r < 0)\n    r += 0x100000000;\n  return r;\n}\n\nfunction g0_512_hi(xh, xl) {\n  var c0_hi = rotr64_hi(xh, xl, 1);\n  var c1_hi = rotr64_hi(xh, xl, 8);\n  var c2_hi = shr64_hi(xh, xl, 7);\n\n  var r = c0_hi ^ c1_hi ^ c2_hi;\n  if (r < 0)\n    r += 0x100000000;\n  return r;\n}\n\nfunction g0_512_lo(xh, xl) {\n  var c0_lo = rotr64_lo(xh, xl, 1);\n  var c1_lo = rotr64_lo(xh, xl, 8);\n  var c2_lo = shr64_lo(xh, xl, 7);\n\n  var r = c0_lo ^ c1_lo ^ c2_lo;\n  if (r < 0)\n    r += 0x100000000;\n  return r;\n}\n\nfunction g1_512_hi(xh, xl) {\n  var c0_hi = rotr64_hi(xh, xl, 19);\n  var c1_hi = rotr64_hi(xl, xh, 29);  // 61\n  var c2_hi = shr64_hi(xh, xl, 6);\n\n  var r = c0_hi ^ c1_hi ^ c2_hi;\n  if (r < 0)\n    r += 0x100000000;\n  return r;\n}\n\nfunction g1_512_lo(xh, xl) {\n  var c0_lo = rotr64_lo(xh, xl, 19);\n  var c1_lo = rotr64_lo(xl, xh, 29);  // 61\n  var c2_lo = shr64_lo(xh, xl, 6);\n\n  var r = c0_lo ^ c1_lo ^ c2_lo;\n  if (r < 0)\n    r += 0x100000000;\n  return r;\n}\n",
    "'use strict';\n\nvar utils = require('../utils');\n\nvar SHA512 = require('./512');\n\nfunction SHA384() {\n  if (!(this instanceof SHA384))\n    return new SHA384();\n\n  SHA512.call(this);\n  this.h = [\n    0xcbbb9d5d, 0xc1059ed8,\n    0x629a292a, 0x367cd507,\n    0x9159015a, 0x3070dd17,\n    0x152fecd8, 0xf70e5939,\n    0x67332667, 0xffc00b31,\n    0x8eb44a87, 0x68581511,\n    0xdb0c2e0d, 0x64f98fa7,\n    0x47b5481d, 0xbefa4fa4 ];\n}\nutils.inherits(SHA384, SHA512);\nmodule.exports = SHA384;\n\nSHA384.blockSize = 1024;\nSHA384.outSize = 384;\nSHA384.hmacStrength = 192;\nSHA384.padLength = 128;\n\nSHA384.prototype._digest = function digest(enc) {\n  if (enc === 'hex')\n    return utils.toHex32(this.h.slice(0, 12), 'big');\n  else\n    return utils.split32(this.h.slice(0, 12), 'big');\n};\n",
    "'use strict';\n\nexports.sha1 = require('./sha/1');\nexports.sha224 = require('./sha/224');\nexports.sha256 = require('./sha/256');\nexports.sha384 = require('./sha/384');\nexports.sha512 = require('./sha/512');\n",
    "'use strict';\n\nvar utils = require('./utils');\nvar common = require('./common');\n\nvar rotl32 = utils.rotl32;\nvar sum32 = utils.sum32;\nvar sum32_3 = utils.sum32_3;\nvar sum32_4 = utils.sum32_4;\nvar BlockHash = common.BlockHash;\n\nfunction RIPEMD160() {\n  if (!(this instanceof RIPEMD160))\n    return new RIPEMD160();\n\n  BlockHash.call(this);\n\n  this.h = [ 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0 ];\n  this.endian = 'little';\n}\nutils.inherits(RIPEMD160, BlockHash);\nexports.ripemd160 = RIPEMD160;\n\nRIPEMD160.blockSize = 512;\nRIPEMD160.outSize = 160;\nRIPEMD160.hmacStrength = 192;\nRIPEMD160.padLength = 64;\n\nRIPEMD160.prototype._update = function update(msg, start) {\n  var A = this.h[0];\n  var B = this.h[1];\n  var C = this.h[2];\n  var D = this.h[3];\n  var E = this.h[4];\n  var Ah = A;\n  var Bh = B;\n  var Ch = C;\n  var Dh = D;\n  var Eh = E;\n  for (var j = 0; j < 80; j++) {\n    var T = sum32(\n      rotl32(\n        sum32_4(A, f(j, B, C, D), msg[r[j] + start], K(j)),\n        s[j]),\n      E);\n    A = E;\n    E = D;\n    D = rotl32(C, 10);\n    C = B;\n    B = T;\n    T = sum32(\n      rotl32(\n        sum32_4(Ah, f(79 - j, Bh, Ch, Dh), msg[rh[j] + start], Kh(j)),\n        sh[j]),\n      Eh);\n    Ah = Eh;\n    Eh = Dh;\n    Dh = rotl32(Ch, 10);\n    Ch = Bh;\n    Bh = T;\n  }\n  T = sum32_3(this.h[1], C, Dh);\n  this.h[1] = sum32_3(this.h[2], D, Eh);\n  this.h[2] = sum32_3(this.h[3], E, Ah);\n  this.h[3] = sum32_3(this.h[4], A, Bh);\n  this.h[4] = sum32_3(this.h[0], B, Ch);\n  this.h[0] = T;\n};\n\nRIPEMD160.prototype._digest = function digest(enc) {\n  if (enc === 'hex')\n    return utils.toHex32(this.h, 'little');\n  else\n    return utils.split32(this.h, 'little');\n};\n\nfunction f(j, x, y, z) {\n  if (j <= 15)\n    return x ^ y ^ z;\n  else if (j <= 31)\n    return (x & y) | ((~x) & z);\n  else if (j <= 47)\n    return (x | (~y)) ^ z;\n  else if (j <= 63)\n    return (x & z) | (y & (~z));\n  else\n    return x ^ (y | (~z));\n}\n\nfunction K(j) {\n  if (j <= 15)\n    return 0x00000000;\n  else if (j <= 31)\n    return 0x5a827999;\n  else if (j <= 47)\n    return 0x6ed9eba1;\n  else if (j <= 63)\n    return 0x8f1bbcdc;\n  else\n    return 0xa953fd4e;\n}\n\nfunction Kh(j) {\n  if (j <= 15)\n    return 0x50a28be6;\n  else if (j <= 31)\n    return 0x5c4dd124;\n  else if (j <= 47)\n    return 0x6d703ef3;\n  else if (j <= 63)\n    return 0x7a6d76e9;\n  else\n    return 0x00000000;\n}\n\nvar r = [\n  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,\n  7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,\n  3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12,\n  1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2,\n  4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13\n];\n\nvar rh = [\n  5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12,\n  6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2,\n  15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13,\n  8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14,\n  12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11\n];\n\nvar s = [\n  11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8,\n  7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12,\n  11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5,\n  11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12,\n  9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6\n];\n\nvar sh = [\n  8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6,\n  9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11,\n  9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5,\n  15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8,\n  8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11\n];\n",
    "'use strict';\n\nvar utils = require('./utils');\nvar assert = require('minimalistic-assert');\n\nfunction Hmac(hash, key, enc) {\n  if (!(this instanceof Hmac))\n    return new Hmac(hash, key, enc);\n  this.Hash = hash;\n  this.blockSize = hash.blockSize / 8;\n  this.outSize = hash.outSize / 8;\n  this.inner = null;\n  this.outer = null;\n\n  this._init(utils.toArray(key, enc));\n}\nmodule.exports = Hmac;\n\nHmac.prototype._init = function init(key) {\n  // Shorten key, if needed\n  if (key.length > this.blockSize)\n    key = new this.Hash().update(key).digest();\n  assert(key.length <= this.blockSize);\n\n  // Add padding to key\n  for (var i = key.length; i < this.blockSize; i++)\n    key.push(0);\n\n  for (i = 0; i < key.length; i++)\n    key[i] ^= 0x36;\n  this.inner = new this.Hash().update(key);\n\n  // 0x36 ^ 0x5c = 0x6a\n  for (i = 0; i < key.length; i++)\n    key[i] ^= 0x6a;\n  this.outer = new this.Hash().update(key);\n};\n\nHmac.prototype.update = function update(msg, enc) {\n  this.inner.update(msg, enc);\n  return this;\n};\n\nHmac.prototype.digest = function digest(enc) {\n  this.outer.update(this.inner.digest());\n  return this.outer.digest(enc);\n};\n",
    "var hash = exports;\n\nhash.utils = require('./hash/utils');\nhash.common = require('./hash/common');\nhash.sha = require('./hash/sha');\nhash.ripemd = require('./hash/ripemd');\nhash.hmac = require('./hash/hmac');\n\n// Proxy hash functions to the main object\nhash.sha1 = hash.sha.sha1;\nhash.sha256 = hash.sha.sha256;\nhash.sha224 = hash.sha.sha224;\nhash.sha384 = hash.sha.sha384;\nhash.sha512 = hash.sha.sha512;\nhash.ripemd160 = hash.ripemd.ripemd160;\n",
    "module.exports = {\n  doubles: {\n    step: 4,\n    points: [\n      [\n        'e60fce93b59e9ec53011aabc21c23e97b2a31369b87a5ae9c44ee89e2a6dec0a',\n        'f7e3507399e595929db99f34f57937101296891e44d23f0be1f32cce69616821',\n      ],\n      [\n        '8282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508',\n        '11f8a8098557dfe45e8256e830b60ace62d613ac2f7b17bed31b6eaff6e26caf',\n      ],\n      [\n        '175e159f728b865a72f99cc6c6fc846de0b93833fd2222ed73fce5b551e5b739',\n        'd3506e0d9e3c79eba4ef97a51ff71f5eacb5955add24345c6efa6ffee9fed695',\n      ],\n      [\n        '363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640',\n        '4e273adfc732221953b445397f3363145b9a89008199ecb62003c7f3bee9de9',\n      ],\n      [\n        '8b4b5f165df3c2be8c6244b5b745638843e4a781a15bcd1b69f79a55dffdf80c',\n        '4aad0a6f68d308b4b3fbd7813ab0da04f9e336546162ee56b3eff0c65fd4fd36',\n      ],\n      [\n        '723cbaa6e5db996d6bf771c00bd548c7b700dbffa6c0e77bcb6115925232fcda',\n        '96e867b5595cc498a921137488824d6e2660a0653779494801dc069d9eb39f5f',\n      ],\n      [\n        'eebfa4d493bebf98ba5feec812c2d3b50947961237a919839a533eca0e7dd7fa',\n        '5d9a8ca3970ef0f269ee7edaf178089d9ae4cdc3a711f712ddfd4fdae1de8999',\n      ],\n      [\n        '100f44da696e71672791d0a09b7bde459f1215a29b3c03bfefd7835b39a48db0',\n        'cdd9e13192a00b772ec8f3300c090666b7ff4a18ff5195ac0fbd5cd62bc65a09',\n      ],\n      [\n        'e1031be262c7ed1b1dc9227a4a04c017a77f8d4464f3b3852c8acde6e534fd2d',\n        '9d7061928940405e6bb6a4176597535af292dd419e1ced79a44f18f29456a00d',\n      ],\n      [\n        'feea6cae46d55b530ac2839f143bd7ec5cf8b266a41d6af52d5e688d9094696d',\n        'e57c6b6c97dce1bab06e4e12bf3ecd5c981c8957cc41442d3155debf18090088',\n      ],\n      [\n        'da67a91d91049cdcb367be4be6ffca3cfeed657d808583de33fa978bc1ec6cb1',\n        '9bacaa35481642bc41f463f7ec9780e5dec7adc508f740a17e9ea8e27a68be1d',\n      ],\n      [\n        '53904faa0b334cdda6e000935ef22151ec08d0f7bb11069f57545ccc1a37b7c0',\n        '5bc087d0bc80106d88c9eccac20d3c1c13999981e14434699dcb096b022771c8',\n      ],\n      [\n        '8e7bcd0bd35983a7719cca7764ca906779b53a043a9b8bcaeff959f43ad86047',\n        '10b7770b2a3da4b3940310420ca9514579e88e2e47fd68b3ea10047e8460372a',\n      ],\n      [\n        '385eed34c1cdff21e6d0818689b81bde71a7f4f18397e6690a841e1599c43862',\n        '283bebc3e8ea23f56701de19e9ebf4576b304eec2086dc8cc0458fe5542e5453',\n      ],\n      [\n        '6f9d9b803ecf191637c73a4413dfa180fddf84a5947fbc9c606ed86c3fac3a7',\n        '7c80c68e603059ba69b8e2a30e45c4d47ea4dd2f5c281002d86890603a842160',\n      ],\n      [\n        '3322d401243c4e2582a2147c104d6ecbf774d163db0f5e5313b7e0e742d0e6bd',\n        '56e70797e9664ef5bfb019bc4ddaf9b72805f63ea2873af624f3a2e96c28b2a0',\n      ],\n      [\n        '85672c7d2de0b7da2bd1770d89665868741b3f9af7643397721d74d28134ab83',\n        '7c481b9b5b43b2eb6374049bfa62c2e5e77f17fcc5298f44c8e3094f790313a6',\n      ],\n      [\n        '948bf809b1988a46b06c9f1919413b10f9226c60f668832ffd959af60c82a0a',\n        '53a562856dcb6646dc6b74c5d1c3418c6d4dff08c97cd2bed4cb7f88d8c8e589',\n      ],\n      [\n        '6260ce7f461801c34f067ce0f02873a8f1b0e44dfc69752accecd819f38fd8e8',\n        'bc2da82b6fa5b571a7f09049776a1ef7ecd292238051c198c1a84e95b2b4ae17',\n      ],\n      [\n        'e5037de0afc1d8d43d8348414bbf4103043ec8f575bfdc432953cc8d2037fa2d',\n        '4571534baa94d3b5f9f98d09fb990bddbd5f5b03ec481f10e0e5dc841d755bda',\n      ],\n      [\n        'e06372b0f4a207adf5ea905e8f1771b4e7e8dbd1c6a6c5b725866a0ae4fce725',\n        '7a908974bce18cfe12a27bb2ad5a488cd7484a7787104870b27034f94eee31dd',\n      ],\n      [\n        '213c7a715cd5d45358d0bbf9dc0ce02204b10bdde2a3f58540ad6908d0559754',\n        '4b6dad0b5ae462507013ad06245ba190bb4850f5f36a7eeddff2c27534b458f2',\n      ],\n      [\n        '4e7c272a7af4b34e8dbb9352a5419a87e2838c70adc62cddf0cc3a3b08fbd53c',\n        '17749c766c9d0b18e16fd09f6def681b530b9614bff7dd33e0b3941817dcaae6',\n      ],\n      [\n        'fea74e3dbe778b1b10f238ad61686aa5c76e3db2be43057632427e2840fb27b6',\n        '6e0568db9b0b13297cf674deccb6af93126b596b973f7b77701d3db7f23cb96f',\n      ],\n      [\n        '76e64113f677cf0e10a2570d599968d31544e179b760432952c02a4417bdde39',\n        'c90ddf8dee4e95cf577066d70681f0d35e2a33d2b56d2032b4b1752d1901ac01',\n      ],\n      [\n        'c738c56b03b2abe1e8281baa743f8f9a8f7cc643df26cbee3ab150242bcbb891',\n        '893fb578951ad2537f718f2eacbfbbbb82314eef7880cfe917e735d9699a84c3',\n      ],\n      [\n        'd895626548b65b81e264c7637c972877d1d72e5f3a925014372e9f6588f6c14b',\n        'febfaa38f2bc7eae728ec60818c340eb03428d632bb067e179363ed75d7d991f',\n      ],\n      [\n        'b8da94032a957518eb0f6433571e8761ceffc73693e84edd49150a564f676e03',\n        '2804dfa44805a1e4d7c99cc9762808b092cc584d95ff3b511488e4e74efdf6e7',\n      ],\n      [\n        'e80fea14441fb33a7d8adab9475d7fab2019effb5156a792f1a11778e3c0df5d',\n        'eed1de7f638e00771e89768ca3ca94472d155e80af322ea9fcb4291b6ac9ec78',\n      ],\n      [\n        'a301697bdfcd704313ba48e51d567543f2a182031efd6915ddc07bbcc4e16070',\n        '7370f91cfb67e4f5081809fa25d40f9b1735dbf7c0a11a130c0d1a041e177ea1',\n      ],\n      [\n        '90ad85b389d6b936463f9d0512678de208cc330b11307fffab7ac63e3fb04ed4',\n        'e507a3620a38261affdcbd9427222b839aefabe1582894d991d4d48cb6ef150',\n      ],\n      [\n        '8f68b9d2f63b5f339239c1ad981f162ee88c5678723ea3351b7b444c9ec4c0da',\n        '662a9f2dba063986de1d90c2b6be215dbbea2cfe95510bfdf23cbf79501fff82',\n      ],\n      [\n        'e4f3fb0176af85d65ff99ff9198c36091f48e86503681e3e6686fd5053231e11',\n        '1e63633ad0ef4f1c1661a6d0ea02b7286cc7e74ec951d1c9822c38576feb73bc',\n      ],\n      [\n        '8c00fa9b18ebf331eb961537a45a4266c7034f2f0d4e1d0716fb6eae20eae29e',\n        'efa47267fea521a1a9dc343a3736c974c2fadafa81e36c54e7d2a4c66702414b',\n      ],\n      [\n        'e7a26ce69dd4829f3e10cec0a9e98ed3143d084f308b92c0997fddfc60cb3e41',\n        '2a758e300fa7984b471b006a1aafbb18d0a6b2c0420e83e20e8a9421cf2cfd51',\n      ],\n      [\n        'b6459e0ee3662ec8d23540c223bcbdc571cbcb967d79424f3cf29eb3de6b80ef',\n        '67c876d06f3e06de1dadf16e5661db3c4b3ae6d48e35b2ff30bf0b61a71ba45',\n      ],\n      [\n        'd68a80c8280bb840793234aa118f06231d6f1fc67e73c5a5deda0f5b496943e8',\n        'db8ba9fff4b586d00c4b1f9177b0e28b5b0e7b8f7845295a294c84266b133120',\n      ],\n      [\n        '324aed7df65c804252dc0270907a30b09612aeb973449cea4095980fc28d3d5d',\n        '648a365774b61f2ff130c0c35aec1f4f19213b0c7e332843967224af96ab7c84',\n      ],\n      [\n        '4df9c14919cde61f6d51dfdbe5fee5dceec4143ba8d1ca888e8bd373fd054c96',\n        '35ec51092d8728050974c23a1d85d4b5d506cdc288490192ebac06cad10d5d',\n      ],\n      [\n        '9c3919a84a474870faed8a9c1cc66021523489054d7f0308cbfc99c8ac1f98cd',\n        'ddb84f0f4a4ddd57584f044bf260e641905326f76c64c8e6be7e5e03d4fc599d',\n      ],\n      [\n        '6057170b1dd12fdf8de05f281d8e06bb91e1493a8b91d4cc5a21382120a959e5',\n        '9a1af0b26a6a4807add9a2daf71df262465152bc3ee24c65e899be932385a2a8',\n      ],\n      [\n        'a576df8e23a08411421439a4518da31880cef0fba7d4df12b1a6973eecb94266',\n        '40a6bf20e76640b2c92b97afe58cd82c432e10a7f514d9f3ee8be11ae1b28ec8',\n      ],\n      [\n        '7778a78c28dec3e30a05fe9629de8c38bb30d1f5cf9a3a208f763889be58ad71',\n        '34626d9ab5a5b22ff7098e12f2ff580087b38411ff24ac563b513fc1fd9f43ac',\n      ],\n      [\n        '928955ee637a84463729fd30e7afd2ed5f96274e5ad7e5cb09eda9c06d903ac',\n        'c25621003d3f42a827b78a13093a95eeac3d26efa8a8d83fc5180e935bcd091f',\n      ],\n      [\n        '85d0fef3ec6db109399064f3a0e3b2855645b4a907ad354527aae75163d82751',\n        '1f03648413a38c0be29d496e582cf5663e8751e96877331582c237a24eb1f962',\n      ],\n      [\n        'ff2b0dce97eece97c1c9b6041798b85dfdfb6d8882da20308f5404824526087e',\n        '493d13fef524ba188af4c4dc54d07936c7b7ed6fb90e2ceb2c951e01f0c29907',\n      ],\n      [\n        '827fbbe4b1e880ea9ed2b2e6301b212b57f1ee148cd6dd28780e5e2cf856e241',\n        'c60f9c923c727b0b71bef2c67d1d12687ff7a63186903166d605b68baec293ec',\n      ],\n      [\n        'eaa649f21f51bdbae7be4ae34ce6e5217a58fdce7f47f9aa7f3b58fa2120e2b3',\n        'be3279ed5bbbb03ac69a80f89879aa5a01a6b965f13f7e59d47a5305ba5ad93d',\n      ],\n      [\n        'e4a42d43c5cf169d9391df6decf42ee541b6d8f0c9a137401e23632dda34d24f',\n        '4d9f92e716d1c73526fc99ccfb8ad34ce886eedfa8d8e4f13a7f7131deba9414',\n      ],\n      [\n        '1ec80fef360cbdd954160fadab352b6b92b53576a88fea4947173b9d4300bf19',\n        'aeefe93756b5340d2f3a4958a7abbf5e0146e77f6295a07b671cdc1cc107cefd',\n      ],\n      [\n        '146a778c04670c2f91b00af4680dfa8bce3490717d58ba889ddb5928366642be',\n        'b318e0ec3354028add669827f9d4b2870aaa971d2f7e5ed1d0b297483d83efd0',\n      ],\n      [\n        'fa50c0f61d22e5f07e3acebb1aa07b128d0012209a28b9776d76a8793180eef9',\n        '6b84c6922397eba9b72cd2872281a68a5e683293a57a213b38cd8d7d3f4f2811',\n      ],\n      [\n        'da1d61d0ca721a11b1a5bf6b7d88e8421a288ab5d5bba5220e53d32b5f067ec2',\n        '8157f55a7c99306c79c0766161c91e2966a73899d279b48a655fba0f1ad836f1',\n      ],\n      [\n        'a8e282ff0c9706907215ff98e8fd416615311de0446f1e062a73b0610d064e13',\n        '7f97355b8db81c09abfb7f3c5b2515888b679a3e50dd6bd6cef7c73111f4cc0c',\n      ],\n      [\n        '174a53b9c9a285872d39e56e6913cab15d59b1fa512508c022f382de8319497c',\n        'ccc9dc37abfc9c1657b4155f2c47f9e6646b3a1d8cb9854383da13ac079afa73',\n      ],\n      [\n        '959396981943785c3d3e57edf5018cdbe039e730e4918b3d884fdff09475b7ba',\n        '2e7e552888c331dd8ba0386a4b9cd6849c653f64c8709385e9b8abf87524f2fd',\n      ],\n      [\n        'd2a63a50ae401e56d645a1153b109a8fcca0a43d561fba2dbb51340c9d82b151',\n        'e82d86fb6443fcb7565aee58b2948220a70f750af484ca52d4142174dcf89405',\n      ],\n      [\n        '64587e2335471eb890ee7896d7cfdc866bacbdbd3839317b3436f9b45617e073',\n        'd99fcdd5bf6902e2ae96dd6447c299a185b90a39133aeab358299e5e9faf6589',\n      ],\n      [\n        '8481bde0e4e4d885b3a546d3e549de042f0aa6cea250e7fd358d6c86dd45e458',\n        '38ee7b8cba5404dd84a25bf39cecb2ca900a79c42b262e556d64b1b59779057e',\n      ],\n      [\n        '13464a57a78102aa62b6979ae817f4637ffcfed3c4b1ce30bcd6303f6caf666b',\n        '69be159004614580ef7e433453ccb0ca48f300a81d0942e13f495a907f6ecc27',\n      ],\n      [\n        'bc4a9df5b713fe2e9aef430bcc1dc97a0cd9ccede2f28588cada3a0d2d83f366',\n        'd3a81ca6e785c06383937adf4b798caa6e8a9fbfa547b16d758d666581f33c1',\n      ],\n      [\n        '8c28a97bf8298bc0d23d8c749452a32e694b65e30a9472a3954ab30fe5324caa',\n        '40a30463a3305193378fedf31f7cc0eb7ae784f0451cb9459e71dc73cbef9482',\n      ],\n      [\n        '8ea9666139527a8c1dd94ce4f071fd23c8b350c5a4bb33748c4ba111faccae0',\n        '620efabbc8ee2782e24e7c0cfb95c5d735b783be9cf0f8e955af34a30e62b945',\n      ],\n      [\n        'dd3625faef5ba06074669716bbd3788d89bdde815959968092f76cc4eb9a9787',\n        '7a188fa3520e30d461da2501045731ca941461982883395937f68d00c644a573',\n      ],\n      [\n        'f710d79d9eb962297e4f6232b40e8f7feb2bc63814614d692c12de752408221e',\n        'ea98e67232d3b3295d3b535532115ccac8612c721851617526ae47a9c77bfc82',\n      ],\n    ],\n  },\n  naf: {\n    wnd: 7,\n    points: [\n      [\n        'f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9',\n        '388f7b0f632de8140fe337e62a37f3566500a99934c2231b6cb9fd7584b8e672',\n      ],\n      [\n        '2f8bde4d1a07209355b4a7250a5c5128e88b84bddc619ab7cba8d569b240efe4',\n        'd8ac222636e5e3d6d4dba9dda6c9c426f788271bab0d6840dca87d3aa6ac62d6',\n      ],\n      [\n        '5cbdf0646e5db4eaa398f365f2ea7a0e3d419b7e0330e39ce92bddedcac4f9bc',\n        '6aebca40ba255960a3178d6d861a54dba813d0b813fde7b5a5082628087264da',\n      ],\n      [\n        'acd484e2f0c7f65309ad178a9f559abde09796974c57e714c35f110dfc27ccbe',\n        'cc338921b0a7d9fd64380971763b61e9add888a4375f8e0f05cc262ac64f9c37',\n      ],\n      [\n        '774ae7f858a9411e5ef4246b70c65aac5649980be5c17891bbec17895da008cb',\n        'd984a032eb6b5e190243dd56d7b7b365372db1e2dff9d6a8301d74c9c953c61b',\n      ],\n      [\n        'f28773c2d975288bc7d1d205c3748651b075fbc6610e58cddeeddf8f19405aa8',\n        'ab0902e8d880a89758212eb65cdaf473a1a06da521fa91f29b5cb52db03ed81',\n      ],\n      [\n        'd7924d4f7d43ea965a465ae3095ff41131e5946f3c85f79e44adbcf8e27e080e',\n        '581e2872a86c72a683842ec228cc6defea40af2bd896d3a5c504dc9ff6a26b58',\n      ],\n      [\n        'defdea4cdb677750a420fee807eacf21eb9898ae79b9768766e4faa04a2d4a34',\n        '4211ab0694635168e997b0ead2a93daeced1f4a04a95c0f6cfb199f69e56eb77',\n      ],\n      [\n        '2b4ea0a797a443d293ef5cff444f4979f06acfebd7e86d277475656138385b6c',\n        '85e89bc037945d93b343083b5a1c86131a01f60c50269763b570c854e5c09b7a',\n      ],\n      [\n        '352bbf4a4cdd12564f93fa332ce333301d9ad40271f8107181340aef25be59d5',\n        '321eb4075348f534d59c18259dda3e1f4a1b3b2e71b1039c67bd3d8bcf81998c',\n      ],\n      [\n        '2fa2104d6b38d11b0230010559879124e42ab8dfeff5ff29dc9cdadd4ecacc3f',\n        '2de1068295dd865b64569335bd5dd80181d70ecfc882648423ba76b532b7d67',\n      ],\n      [\n        '9248279b09b4d68dab21a9b066edda83263c3d84e09572e269ca0cd7f5453714',\n        '73016f7bf234aade5d1aa71bdea2b1ff3fc0de2a887912ffe54a32ce97cb3402',\n      ],\n      [\n        'daed4f2be3a8bf278e70132fb0beb7522f570e144bf615c07e996d443dee8729',\n        'a69dce4a7d6c98e8d4a1aca87ef8d7003f83c230f3afa726ab40e52290be1c55',\n      ],\n      [\n        'c44d12c7065d812e8acf28d7cbb19f9011ecd9e9fdf281b0e6a3b5e87d22e7db',\n        '2119a460ce326cdc76c45926c982fdac0e106e861edf61c5a039063f0e0e6482',\n      ],\n      [\n        '6a245bf6dc698504c89a20cfded60853152b695336c28063b61c65cbd269e6b4',\n        'e022cf42c2bd4a708b3f5126f16a24ad8b33ba48d0423b6efd5e6348100d8a82',\n      ],\n      [\n        '1697ffa6fd9de627c077e3d2fe541084ce13300b0bec1146f95ae57f0d0bd6a5',\n        'b9c398f186806f5d27561506e4557433a2cf15009e498ae7adee9d63d01b2396',\n      ],\n      [\n        '605bdb019981718b986d0f07e834cb0d9deb8360ffb7f61df982345ef27a7479',\n        '2972d2de4f8d20681a78d93ec96fe23c26bfae84fb14db43b01e1e9056b8c49',\n      ],\n      [\n        '62d14dab4150bf497402fdc45a215e10dcb01c354959b10cfe31c7e9d87ff33d',\n        '80fc06bd8cc5b01098088a1950eed0db01aa132967ab472235f5642483b25eaf',\n      ],\n      [\n        '80c60ad0040f27dade5b4b06c408e56b2c50e9f56b9b8b425e555c2f86308b6f',\n        '1c38303f1cc5c30f26e66bad7fe72f70a65eed4cbe7024eb1aa01f56430bd57a',\n      ],\n      [\n        '7a9375ad6167ad54aa74c6348cc54d344cc5dc9487d847049d5eabb0fa03c8fb',\n        'd0e3fa9eca8726909559e0d79269046bdc59ea10c70ce2b02d499ec224dc7f7',\n      ],\n      [\n        'd528ecd9b696b54c907a9ed045447a79bb408ec39b68df504bb51f459bc3ffc9',\n        'eecf41253136e5f99966f21881fd656ebc4345405c520dbc063465b521409933',\n      ],\n      [\n        '49370a4b5f43412ea25f514e8ecdad05266115e4a7ecb1387231808f8b45963',\n        '758f3f41afd6ed428b3081b0512fd62a54c3f3afbb5b6764b653052a12949c9a',\n      ],\n      [\n        '77f230936ee88cbbd73df930d64702ef881d811e0e1498e2f1c13eb1fc345d74',\n        '958ef42a7886b6400a08266e9ba1b37896c95330d97077cbbe8eb3c7671c60d6',\n      ],\n      [\n        'f2dac991cc4ce4b9ea44887e5c7c0bce58c80074ab9d4dbaeb28531b7739f530',\n        'e0dedc9b3b2f8dad4da1f32dec2531df9eb5fbeb0598e4fd1a117dba703a3c37',\n      ],\n      [\n        '463b3d9f662621fb1b4be8fbbe2520125a216cdfc9dae3debcba4850c690d45b',\n        '5ed430d78c296c3543114306dd8622d7c622e27c970a1de31cb377b01af7307e',\n      ],\n      [\n        'f16f804244e46e2a09232d4aff3b59976b98fac14328a2d1a32496b49998f247',\n        'cedabd9b82203f7e13d206fcdf4e33d92a6c53c26e5cce26d6579962c4e31df6',\n      ],\n      [\n        'caf754272dc84563b0352b7a14311af55d245315ace27c65369e15f7151d41d1',\n        'cb474660ef35f5f2a41b643fa5e460575f4fa9b7962232a5c32f908318a04476',\n      ],\n      [\n        '2600ca4b282cb986f85d0f1709979d8b44a09c07cb86d7c124497bc86f082120',\n        '4119b88753c15bd6a693b03fcddbb45d5ac6be74ab5f0ef44b0be9475a7e4b40',\n      ],\n      [\n        '7635ca72d7e8432c338ec53cd12220bc01c48685e24f7dc8c602a7746998e435',\n        '91b649609489d613d1d5e590f78e6d74ecfc061d57048bad9e76f302c5b9c61',\n      ],\n      [\n        '754e3239f325570cdbbf4a87deee8a66b7f2b33479d468fbc1a50743bf56cc18',\n        '673fb86e5bda30fb3cd0ed304ea49a023ee33d0197a695d0c5d98093c536683',\n      ],\n      [\n        'e3e6bd1071a1e96aff57859c82d570f0330800661d1c952f9fe2694691d9b9e8',\n        '59c9e0bba394e76f40c0aa58379a3cb6a5a2283993e90c4167002af4920e37f5',\n      ],\n      [\n        '186b483d056a033826ae73d88f732985c4ccb1f32ba35f4b4cc47fdcf04aa6eb',\n        '3b952d32c67cf77e2e17446e204180ab21fb8090895138b4a4a797f86e80888b',\n      ],\n      [\n        'df9d70a6b9876ce544c98561f4be4f725442e6d2b737d9c91a8321724ce0963f',\n        '55eb2dafd84d6ccd5f862b785dc39d4ab157222720ef9da217b8c45cf2ba2417',\n      ],\n      [\n        '5edd5cc23c51e87a497ca815d5dce0f8ab52554f849ed8995de64c5f34ce7143',\n        'efae9c8dbc14130661e8cec030c89ad0c13c66c0d17a2905cdc706ab7399a868',\n      ],\n      [\n        '290798c2b6476830da12fe02287e9e777aa3fba1c355b17a722d362f84614fba',\n        'e38da76dcd440621988d00bcf79af25d5b29c094db2a23146d003afd41943e7a',\n      ],\n      [\n        'af3c423a95d9f5b3054754efa150ac39cd29552fe360257362dfdecef4053b45',\n        'f98a3fd831eb2b749a93b0e6f35cfb40c8cd5aa667a15581bc2feded498fd9c6',\n      ],\n      [\n        '766dbb24d134e745cccaa28c99bf274906bb66b26dcf98df8d2fed50d884249a',\n        '744b1152eacbe5e38dcc887980da38b897584a65fa06cedd2c924f97cbac5996',\n      ],\n      [\n        '59dbf46f8c94759ba21277c33784f41645f7b44f6c596a58ce92e666191abe3e',\n        'c534ad44175fbc300f4ea6ce648309a042ce739a7919798cd85e216c4a307f6e',\n      ],\n      [\n        'f13ada95103c4537305e691e74e9a4a8dd647e711a95e73cb62dc6018cfd87b8',\n        'e13817b44ee14de663bf4bc808341f326949e21a6a75c2570778419bdaf5733d',\n      ],\n      [\n        '7754b4fa0e8aced06d4167a2c59cca4cda1869c06ebadfb6488550015a88522c',\n        '30e93e864e669d82224b967c3020b8fa8d1e4e350b6cbcc537a48b57841163a2',\n      ],\n      [\n        '948dcadf5990e048aa3874d46abef9d701858f95de8041d2a6828c99e2262519',\n        'e491a42537f6e597d5d28a3224b1bc25df9154efbd2ef1d2cbba2cae5347d57e',\n      ],\n      [\n        '7962414450c76c1689c7b48f8202ec37fb224cf5ac0bfa1570328a8a3d7c77ab',\n        '100b610ec4ffb4760d5c1fc133ef6f6b12507a051f04ac5760afa5b29db83437',\n      ],\n      [\n        '3514087834964b54b15b160644d915485a16977225b8847bb0dd085137ec47ca',\n        'ef0afbb2056205448e1652c48e8127fc6039e77c15c2378b7e7d15a0de293311',\n      ],\n      [\n        'd3cc30ad6b483e4bc79ce2c9dd8bc54993e947eb8df787b442943d3f7b527eaf',\n        '8b378a22d827278d89c5e9be8f9508ae3c2ad46290358630afb34db04eede0a4',\n      ],\n      [\n        '1624d84780732860ce1c78fcbfefe08b2b29823db913f6493975ba0ff4847610',\n        '68651cf9b6da903e0914448c6cd9d4ca896878f5282be4c8cc06e2a404078575',\n      ],\n      [\n        '733ce80da955a8a26902c95633e62a985192474b5af207da6df7b4fd5fc61cd4',\n        'f5435a2bd2badf7d485a4d8b8db9fcce3e1ef8e0201e4578c54673bc1dc5ea1d',\n      ],\n      [\n        '15d9441254945064cf1a1c33bbd3b49f8966c5092171e699ef258dfab81c045c',\n        'd56eb30b69463e7234f5137b73b84177434800bacebfc685fc37bbe9efe4070d',\n      ],\n      [\n        'a1d0fcf2ec9de675b612136e5ce70d271c21417c9d2b8aaaac138599d0717940',\n        'edd77f50bcb5a3cab2e90737309667f2641462a54070f3d519212d39c197a629',\n      ],\n      [\n        'e22fbe15c0af8ccc5780c0735f84dbe9a790badee8245c06c7ca37331cb36980',\n        'a855babad5cd60c88b430a69f53a1a7a38289154964799be43d06d77d31da06',\n      ],\n      [\n        '311091dd9860e8e20ee13473c1155f5f69635e394704eaa74009452246cfa9b3',\n        '66db656f87d1f04fffd1f04788c06830871ec5a64feee685bd80f0b1286d8374',\n      ],\n      [\n        '34c1fd04d301be89b31c0442d3e6ac24883928b45a9340781867d4232ec2dbdf',\n        '9414685e97b1b5954bd46f730174136d57f1ceeb487443dc5321857ba73abee',\n      ],\n      [\n        'f219ea5d6b54701c1c14de5b557eb42a8d13f3abbcd08affcc2a5e6b049b8d63',\n        '4cb95957e83d40b0f73af4544cccf6b1f4b08d3c07b27fb8d8c2962a400766d1',\n      ],\n      [\n        'd7b8740f74a8fbaab1f683db8f45de26543a5490bca627087236912469a0b448',\n        'fa77968128d9c92ee1010f337ad4717eff15db5ed3c049b3411e0315eaa4593b',\n      ],\n      [\n        '32d31c222f8f6f0ef86f7c98d3a3335ead5bcd32abdd94289fe4d3091aa824bf',\n        '5f3032f5892156e39ccd3d7915b9e1da2e6dac9e6f26e961118d14b8462e1661',\n      ],\n      [\n        '7461f371914ab32671045a155d9831ea8793d77cd59592c4340f86cbc18347b5',\n        '8ec0ba238b96bec0cbdddcae0aa442542eee1ff50c986ea6b39847b3cc092ff6',\n      ],\n      [\n        'ee079adb1df1860074356a25aa38206a6d716b2c3e67453d287698bad7b2b2d6',\n        '8dc2412aafe3be5c4c5f37e0ecc5f9f6a446989af04c4e25ebaac479ec1c8c1e',\n      ],\n      [\n        '16ec93e447ec83f0467b18302ee620f7e65de331874c9dc72bfd8616ba9da6b5',\n        '5e4631150e62fb40d0e8c2a7ca5804a39d58186a50e497139626778e25b0674d',\n      ],\n      [\n        'eaa5f980c245f6f038978290afa70b6bd8855897f98b6aa485b96065d537bd99',\n        'f65f5d3e292c2e0819a528391c994624d784869d7e6ea67fb18041024edc07dc',\n      ],\n      [\n        '78c9407544ac132692ee1910a02439958ae04877151342ea96c4b6b35a49f51',\n        'f3e0319169eb9b85d5404795539a5e68fa1fbd583c064d2462b675f194a3ddb4',\n      ],\n      [\n        '494f4be219a1a77016dcd838431aea0001cdc8ae7a6fc688726578d9702857a5',\n        '42242a969283a5f339ba7f075e36ba2af925ce30d767ed6e55f4b031880d562c',\n      ],\n      [\n        'a598a8030da6d86c6bc7f2f5144ea549d28211ea58faa70ebf4c1e665c1fe9b5',\n        '204b5d6f84822c307e4b4a7140737aec23fc63b65b35f86a10026dbd2d864e6b',\n      ],\n      [\n        'c41916365abb2b5d09192f5f2dbeafec208f020f12570a184dbadc3e58595997',\n        '4f14351d0087efa49d245b328984989d5caf9450f34bfc0ed16e96b58fa9913',\n      ],\n      [\n        '841d6063a586fa475a724604da03bc5b92a2e0d2e0a36acfe4c73a5514742881',\n        '73867f59c0659e81904f9a1c7543698e62562d6744c169ce7a36de01a8d6154',\n      ],\n      [\n        '5e95bb399a6971d376026947f89bde2f282b33810928be4ded112ac4d70e20d5',\n        '39f23f366809085beebfc71181313775a99c9aed7d8ba38b161384c746012865',\n      ],\n      [\n        '36e4641a53948fd476c39f8a99fd974e5ec07564b5315d8bf99471bca0ef2f66',\n        'd2424b1b1abe4eb8164227b085c9aa9456ea13493fd563e06fd51cf5694c78fc',\n      ],\n      [\n        '336581ea7bfbbb290c191a2f507a41cf5643842170e914faeab27c2c579f726',\n        'ead12168595fe1be99252129b6e56b3391f7ab1410cd1e0ef3dcdcabd2fda224',\n      ],\n      [\n        '8ab89816dadfd6b6a1f2634fcf00ec8403781025ed6890c4849742706bd43ede',\n        '6fdcef09f2f6d0a044e654aef624136f503d459c3e89845858a47a9129cdd24e',\n      ],\n      [\n        '1e33f1a746c9c5778133344d9299fcaa20b0938e8acff2544bb40284b8c5fb94',\n        '60660257dd11b3aa9c8ed618d24edff2306d320f1d03010e33a7d2057f3b3b6',\n      ],\n      [\n        '85b7c1dcb3cec1b7ee7f30ded79dd20a0ed1f4cc18cbcfcfa410361fd8f08f31',\n        '3d98a9cdd026dd43f39048f25a8847f4fcafad1895d7a633c6fed3c35e999511',\n      ],\n      [\n        '29df9fbd8d9e46509275f4b125d6d45d7fbe9a3b878a7af872a2800661ac5f51',\n        'b4c4fe99c775a606e2d8862179139ffda61dc861c019e55cd2876eb2a27d84b',\n      ],\n      [\n        'a0b1cae06b0a847a3fea6e671aaf8adfdfe58ca2f768105c8082b2e449fce252',\n        'ae434102edde0958ec4b19d917a6a28e6b72da1834aff0e650f049503a296cf2',\n      ],\n      [\n        '4e8ceafb9b3e9a136dc7ff67e840295b499dfb3b2133e4ba113f2e4c0e121e5',\n        'cf2174118c8b6d7a4b48f6d534ce5c79422c086a63460502b827ce62a326683c',\n      ],\n      [\n        'd24a44e047e19b6f5afb81c7ca2f69080a5076689a010919f42725c2b789a33b',\n        '6fb8d5591b466f8fc63db50f1c0f1c69013f996887b8244d2cdec417afea8fa3',\n      ],\n      [\n        'ea01606a7a6c9cdd249fdfcfacb99584001edd28abbab77b5104e98e8e3b35d4',\n        '322af4908c7312b0cfbfe369f7a7b3cdb7d4494bc2823700cfd652188a3ea98d',\n      ],\n      [\n        'af8addbf2b661c8a6c6328655eb96651252007d8c5ea31be4ad196de8ce2131f',\n        '6749e67c029b85f52a034eafd096836b2520818680e26ac8f3dfbcdb71749700',\n      ],\n      [\n        'e3ae1974566ca06cc516d47e0fb165a674a3dabcfca15e722f0e3450f45889',\n        '2aeabe7e4531510116217f07bf4d07300de97e4874f81f533420a72eeb0bd6a4',\n      ],\n      [\n        '591ee355313d99721cf6993ffed1e3e301993ff3ed258802075ea8ced397e246',\n        'b0ea558a113c30bea60fc4775460c7901ff0b053d25ca2bdeee98f1a4be5d196',\n      ],\n      [\n        '11396d55fda54c49f19aa97318d8da61fa8584e47b084945077cf03255b52984',\n        '998c74a8cd45ac01289d5833a7beb4744ff536b01b257be4c5767bea93ea57a4',\n      ],\n      [\n        '3c5d2a1ba39c5a1790000738c9e0c40b8dcdfd5468754b6405540157e017aa7a',\n        'b2284279995a34e2f9d4de7396fc18b80f9b8b9fdd270f6661f79ca4c81bd257',\n      ],\n      [\n        'cc8704b8a60a0defa3a99a7299f2e9c3fbc395afb04ac078425ef8a1793cc030',\n        'bdd46039feed17881d1e0862db347f8cf395b74fc4bcdc4e940b74e3ac1f1b13',\n      ],\n      [\n        'c533e4f7ea8555aacd9777ac5cad29b97dd4defccc53ee7ea204119b2889b197',\n        '6f0a256bc5efdf429a2fb6242f1a43a2d9b925bb4a4b3a26bb8e0f45eb596096',\n      ],\n      [\n        'c14f8f2ccb27d6f109f6d08d03cc96a69ba8c34eec07bbcf566d48e33da6593',\n        'c359d6923bb398f7fd4473e16fe1c28475b740dd098075e6c0e8649113dc3a38',\n      ],\n      [\n        'a6cbc3046bc6a450bac24789fa17115a4c9739ed75f8f21ce441f72e0b90e6ef',\n        '21ae7f4680e889bb130619e2c0f95a360ceb573c70603139862afd617fa9b9f',\n      ],\n      [\n        '347d6d9a02c48927ebfb86c1359b1caf130a3c0267d11ce6344b39f99d43cc38',\n        '60ea7f61a353524d1c987f6ecec92f086d565ab687870cb12689ff1e31c74448',\n      ],\n      [\n        'da6545d2181db8d983f7dcb375ef5866d47c67b1bf31c8cf855ef7437b72656a',\n        '49b96715ab6878a79e78f07ce5680c5d6673051b4935bd897fea824b77dc208a',\n      ],\n      [\n        'c40747cc9d012cb1a13b8148309c6de7ec25d6945d657146b9d5994b8feb1111',\n        '5ca560753be2a12fc6de6caf2cb489565db936156b9514e1bb5e83037e0fa2d4',\n      ],\n      [\n        '4e42c8ec82c99798ccf3a610be870e78338c7f713348bd34c8203ef4037f3502',\n        '7571d74ee5e0fb92a7a8b33a07783341a5492144cc54bcc40a94473693606437',\n      ],\n      [\n        '3775ab7089bc6af823aba2e1af70b236d251cadb0c86743287522a1b3b0dedea',\n        'be52d107bcfa09d8bcb9736a828cfa7fac8db17bf7a76a2c42ad961409018cf7',\n      ],\n      [\n        'cee31cbf7e34ec379d94fb814d3d775ad954595d1314ba8846959e3e82f74e26',\n        '8fd64a14c06b589c26b947ae2bcf6bfa0149ef0be14ed4d80f448a01c43b1c6d',\n      ],\n      [\n        'b4f9eaea09b6917619f6ea6a4eb5464efddb58fd45b1ebefcdc1a01d08b47986',\n        '39e5c9925b5a54b07433a4f18c61726f8bb131c012ca542eb24a8ac07200682a',\n      ],\n      [\n        'd4263dfc3d2df923a0179a48966d30ce84e2515afc3dccc1b77907792ebcc60e',\n        '62dfaf07a0f78feb30e30d6295853ce189e127760ad6cf7fae164e122a208d54',\n      ],\n      [\n        '48457524820fa65a4f8d35eb6930857c0032acc0a4a2de422233eeda897612c4',\n        '25a748ab367979d98733c38a1fa1c2e7dc6cc07db2d60a9ae7a76aaa49bd0f77',\n      ],\n      [\n        'dfeeef1881101f2cb11644f3a2afdfc2045e19919152923f367a1767c11cceda',\n        'ecfb7056cf1de042f9420bab396793c0c390bde74b4bbdff16a83ae09a9a7517',\n      ],\n      [\n        '6d7ef6b17543f8373c573f44e1f389835d89bcbc6062ced36c82df83b8fae859',\n        'cd450ec335438986dfefa10c57fea9bcc521a0959b2d80bbf74b190dca712d10',\n      ],\n      [\n        'e75605d59102a5a2684500d3b991f2e3f3c88b93225547035af25af66e04541f',\n        'f5c54754a8f71ee540b9b48728473e314f729ac5308b06938360990e2bfad125',\n      ],\n      [\n        'eb98660f4c4dfaa06a2be453d5020bc99a0c2e60abe388457dd43fefb1ed620c',\n        '6cb9a8876d9cb8520609af3add26cd20a0a7cd8a9411131ce85f44100099223e',\n      ],\n      [\n        '13e87b027d8514d35939f2e6892b19922154596941888336dc3563e3b8dba942',\n        'fef5a3c68059a6dec5d624114bf1e91aac2b9da568d6abeb2570d55646b8adf1',\n      ],\n      [\n        'ee163026e9fd6fe017c38f06a5be6fc125424b371ce2708e7bf4491691e5764a',\n        '1acb250f255dd61c43d94ccc670d0f58f49ae3fa15b96623e5430da0ad6c62b2',\n      ],\n      [\n        'b268f5ef9ad51e4d78de3a750c2dc89b1e626d43505867999932e5db33af3d80',\n        '5f310d4b3c99b9ebb19f77d41c1dee018cf0d34fd4191614003e945a1216e423',\n      ],\n      [\n        'ff07f3118a9df035e9fad85eb6c7bfe42b02f01ca99ceea3bf7ffdba93c4750d',\n        '438136d603e858a3a5c440c38eccbaddc1d2942114e2eddd4740d098ced1f0d8',\n      ],\n      [\n        '8d8b9855c7c052a34146fd20ffb658bea4b9f69e0d825ebec16e8c3ce2b526a1',\n        'cdb559eedc2d79f926baf44fb84ea4d44bcf50fee51d7ceb30e2e7f463036758',\n      ],\n      [\n        '52db0b5384dfbf05bfa9d472d7ae26dfe4b851ceca91b1eba54263180da32b63',\n        'c3b997d050ee5d423ebaf66a6db9f57b3180c902875679de924b69d84a7b375',\n      ],\n      [\n        'e62f9490d3d51da6395efd24e80919cc7d0f29c3f3fa48c6fff543becbd43352',\n        '6d89ad7ba4876b0b22c2ca280c682862f342c8591f1daf5170e07bfd9ccafa7d',\n      ],\n      [\n        '7f30ea2476b399b4957509c88f77d0191afa2ff5cb7b14fd6d8e7d65aaab1193',\n        'ca5ef7d4b231c94c3b15389a5f6311e9daff7bb67b103e9880ef4bff637acaec',\n      ],\n      [\n        '5098ff1e1d9f14fb46a210fada6c903fef0fb7b4a1dd1d9ac60a0361800b7a00',\n        '9731141d81fc8f8084d37c6e7542006b3ee1b40d60dfe5362a5b132fd17ddc0',\n      ],\n      [\n        '32b78c7de9ee512a72895be6b9cbefa6e2f3c4ccce445c96b9f2c81e2778ad58',\n        'ee1849f513df71e32efc3896ee28260c73bb80547ae2275ba497237794c8753c',\n      ],\n      [\n        'e2cb74fddc8e9fbcd076eef2a7c72b0ce37d50f08269dfc074b581550547a4f7',\n        'd3aa2ed71c9dd2247a62df062736eb0baddea9e36122d2be8641abcb005cc4a4',\n      ],\n      [\n        '8438447566d4d7bedadc299496ab357426009a35f235cb141be0d99cd10ae3a8',\n        'c4e1020916980a4da5d01ac5e6ad330734ef0d7906631c4f2390426b2edd791f',\n      ],\n      [\n        '4162d488b89402039b584c6fc6c308870587d9c46f660b878ab65c82c711d67e',\n        '67163e903236289f776f22c25fb8a3afc1732f2b84b4e95dbda47ae5a0852649',\n      ],\n      [\n        '3fad3fa84caf0f34f0f89bfd2dcf54fc175d767aec3e50684f3ba4a4bf5f683d',\n        'cd1bc7cb6cc407bb2f0ca647c718a730cf71872e7d0d2a53fa20efcdfe61826',\n      ],\n      [\n        '674f2600a3007a00568c1a7ce05d0816c1fb84bf1370798f1c69532faeb1a86b',\n        '299d21f9413f33b3edf43b257004580b70db57da0b182259e09eecc69e0d38a5',\n      ],\n      [\n        'd32f4da54ade74abb81b815ad1fb3b263d82d6c692714bcff87d29bd5ee9f08f',\n        'f9429e738b8e53b968e99016c059707782e14f4535359d582fc416910b3eea87',\n      ],\n      [\n        '30e4e670435385556e593657135845d36fbb6931f72b08cb1ed954f1e3ce3ff6',\n        '462f9bce619898638499350113bbc9b10a878d35da70740dc695a559eb88db7b',\n      ],\n      [\n        'be2062003c51cc3004682904330e4dee7f3dcd10b01e580bf1971b04d4cad297',\n        '62188bc49d61e5428573d48a74e1c655b1c61090905682a0d5558ed72dccb9bc',\n      ],\n      [\n        '93144423ace3451ed29e0fb9ac2af211cb6e84a601df5993c419859fff5df04a',\n        '7c10dfb164c3425f5c71a3f9d7992038f1065224f72bb9d1d902a6d13037b47c',\n      ],\n      [\n        'b015f8044f5fcbdcf21ca26d6c34fb8197829205c7b7d2a7cb66418c157b112c',\n        'ab8c1e086d04e813744a655b2df8d5f83b3cdc6faa3088c1d3aea1454e3a1d5f',\n      ],\n      [\n        'd5e9e1da649d97d89e4868117a465a3a4f8a18de57a140d36b3f2af341a21b52',\n        '4cb04437f391ed73111a13cc1d4dd0db1693465c2240480d8955e8592f27447a',\n      ],\n      [\n        'd3ae41047dd7ca065dbf8ed77b992439983005cd72e16d6f996a5316d36966bb',\n        'bd1aeb21ad22ebb22a10f0303417c6d964f8cdd7df0aca614b10dc14d125ac46',\n      ],\n      [\n        '463e2763d885f958fc66cdd22800f0a487197d0a82e377b49f80af87c897b065',\n        'bfefacdb0e5d0fd7df3a311a94de062b26b80c61fbc97508b79992671ef7ca7f',\n      ],\n      [\n        '7985fdfd127c0567c6f53ec1bb63ec3158e597c40bfe747c83cddfc910641917',\n        '603c12daf3d9862ef2b25fe1de289aed24ed291e0ec6708703a5bd567f32ed03',\n      ],\n      [\n        '74a1ad6b5f76e39db2dd249410eac7f99e74c59cb83d2d0ed5ff1543da7703e9',\n        'cc6157ef18c9c63cd6193d83631bbea0093e0968942e8c33d5737fd790e0db08',\n      ],\n      [\n        '30682a50703375f602d416664ba19b7fc9bab42c72747463a71d0896b22f6da3',\n        '553e04f6b018b4fa6c8f39e7f311d3176290d0e0f19ca73f17714d9977a22ff8',\n      ],\n      [\n        '9e2158f0d7c0d5f26c3791efefa79597654e7a2b2464f52b1ee6c1347769ef57',\n        '712fcdd1b9053f09003a3481fa7762e9ffd7c8ef35a38509e2fbf2629008373',\n      ],\n      [\n        '176e26989a43c9cfeba4029c202538c28172e566e3c4fce7322857f3be327d66',\n        'ed8cc9d04b29eb877d270b4878dc43c19aefd31f4eee09ee7b47834c1fa4b1c3',\n      ],\n      [\n        '75d46efea3771e6e68abb89a13ad747ecf1892393dfc4f1b7004788c50374da8',\n        '9852390a99507679fd0b86fd2b39a868d7efc22151346e1a3ca4726586a6bed8',\n      ],\n      [\n        '809a20c67d64900ffb698c4c825f6d5f2310fb0451c869345b7319f645605721',\n        '9e994980d9917e22b76b061927fa04143d096ccc54963e6a5ebfa5f3f8e286c1',\n      ],\n      [\n        '1b38903a43f7f114ed4500b4eac7083fdefece1cf29c63528d563446f972c180',\n        '4036edc931a60ae889353f77fd53de4a2708b26b6f5da72ad3394119daf408f9',\n      ],\n    ],\n  },\n};\n",
    "'use strict';\n\nvar curves = exports;\n\nvar hash = require('hash.js');\nvar curve = require('./curve');\nvar utils = require('./utils');\n\nvar assert = utils.assert;\n\nfunction PresetCurve(options) {\n  if (options.type === 'short')\n    this.curve = new curve.short(options);\n  else if (options.type === 'edwards')\n    this.curve = new curve.edwards(options);\n  else\n    this.curve = new curve.mont(options);\n  this.g = this.curve.g;\n  this.n = this.curve.n;\n  this.hash = options.hash;\n\n  assert(this.g.validate(), 'Invalid curve');\n  assert(this.g.mul(this.n).isInfinity(), 'Invalid curve, G*N != O');\n}\ncurves.PresetCurve = PresetCurve;\n\nfunction defineCurve(name, options) {\n  Object.defineProperty(curves, name, {\n    configurable: true,\n    enumerable: true,\n    get: function() {\n      var curve = new PresetCurve(options);\n      Object.defineProperty(curves, name, {\n        configurable: true,\n        enumerable: true,\n        value: curve,\n      });\n      return curve;\n    },\n  });\n}\n\ndefineCurve('p192', {\n  type: 'short',\n  prime: 'p192',\n  p: 'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff',\n  a: 'ffffffff ffffffff ffffffff fffffffe ffffffff fffffffc',\n  b: '64210519 e59c80e7 0fa7e9ab 72243049 feb8deec c146b9b1',\n  n: 'ffffffff ffffffff ffffffff 99def836 146bc9b1 b4d22831',\n  hash: hash.sha256,\n  gRed: false,\n  g: [\n    '188da80e b03090f6 7cbf20eb 43a18800 f4ff0afd 82ff1012',\n    '07192b95 ffc8da78 631011ed 6b24cdd5 73f977a1 1e794811',\n  ],\n});\n\ndefineCurve('p224', {\n  type: 'short',\n  prime: 'p224',\n  p: 'ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001',\n  a: 'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff fffffffe',\n  b: 'b4050a85 0c04b3ab f5413256 5044b0b7 d7bfd8ba 270b3943 2355ffb4',\n  n: 'ffffffff ffffffff ffffffff ffff16a2 e0b8f03e 13dd2945 5c5c2a3d',\n  hash: hash.sha256,\n  gRed: false,\n  g: [\n    'b70e0cbd 6bb4bf7f 321390b9 4a03c1d3 56c21122 343280d6 115c1d21',\n    'bd376388 b5f723fb 4c22dfe6 cd4375a0 5a074764 44d58199 85007e34',\n  ],\n});\n\ndefineCurve('p256', {\n  type: 'short',\n  prime: null,\n  p: 'ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff ffffffff',\n  a: 'ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff fffffffc',\n  b: '5ac635d8 aa3a93e7 b3ebbd55 769886bc 651d06b0 cc53b0f6 3bce3c3e 27d2604b',\n  n: 'ffffffff 00000000 ffffffff ffffffff bce6faad a7179e84 f3b9cac2 fc632551',\n  hash: hash.sha256,\n  gRed: false,\n  g: [\n    '6b17d1f2 e12c4247 f8bce6e5 63a440f2 77037d81 2deb33a0 f4a13945 d898c296',\n    '4fe342e2 fe1a7f9b 8ee7eb4a 7c0f9e16 2bce3357 6b315ece cbb64068 37bf51f5',\n  ],\n});\n\ndefineCurve('p384', {\n  type: 'short',\n  prime: null,\n  p: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' +\n     'fffffffe ffffffff 00000000 00000000 ffffffff',\n  a: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' +\n     'fffffffe ffffffff 00000000 00000000 fffffffc',\n  b: 'b3312fa7 e23ee7e4 988e056b e3f82d19 181d9c6e fe814112 0314088f ' +\n     '5013875a c656398d 8a2ed19d 2a85c8ed d3ec2aef',\n  n: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff c7634d81 ' +\n     'f4372ddf 581a0db2 48b0a77a ecec196a ccc52973',\n  hash: hash.sha384,\n  gRed: false,\n  g: [\n    'aa87ca22 be8b0537 8eb1c71e f320ad74 6e1d3b62 8ba79b98 59f741e0 82542a38 ' +\n    '5502f25d bf55296c 3a545e38 72760ab7',\n    '3617de4a 96262c6f 5d9e98bf 9292dc29 f8f41dbd 289a147c e9da3113 b5f0b8c0 ' +\n    '0a60b1ce 1d7e819d 7a431d7c 90ea0e5f',\n  ],\n});\n\ndefineCurve('p521', {\n  type: 'short',\n  prime: null,\n  p: '000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ' +\n     'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' +\n     'ffffffff ffffffff ffffffff ffffffff ffffffff',\n  a: '000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ' +\n     'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' +\n     'ffffffff ffffffff ffffffff ffffffff fffffffc',\n  b: '00000051 953eb961 8e1c9a1f 929a21a0 b68540ee a2da725b ' +\n     '99b315f3 b8b48991 8ef109e1 56193951 ec7e937b 1652c0bd ' +\n     '3bb1bf07 3573df88 3d2c34f1 ef451fd4 6b503f00',\n  n: '000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ' +\n     'ffffffff ffffffff fffffffa 51868783 bf2f966b 7fcc0148 ' +\n     'f709a5d0 3bb5c9b8 899c47ae bb6fb71e 91386409',\n  hash: hash.sha512,\n  gRed: false,\n  g: [\n    '000000c6 858e06b7 0404e9cd 9e3ecb66 2395b442 9c648139 ' +\n    '053fb521 f828af60 6b4d3dba a14b5e77 efe75928 fe1dc127 ' +\n    'a2ffa8de 3348b3c1 856a429b f97e7e31 c2e5bd66',\n    '00000118 39296a78 9a3bc004 5c8a5fb4 2c7d1bd9 98f54449 ' +\n    '579b4468 17afbd17 273e662c 97ee7299 5ef42640 c550b901 ' +\n    '3fad0761 353c7086 a272c240 88be9476 9fd16650',\n  ],\n});\n\ndefineCurve('curve25519', {\n  type: 'mont',\n  prime: 'p25519',\n  p: '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed',\n  a: '76d06',\n  b: '1',\n  n: '1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed',\n  hash: hash.sha256,\n  gRed: false,\n  g: [\n    '9',\n  ],\n});\n\ndefineCurve('ed25519', {\n  type: 'edwards',\n  prime: 'p25519',\n  p: '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed',\n  a: '-1',\n  c: '1',\n  // -121665 * (121666^(-1)) (mod P)\n  d: '52036cee2b6ffe73 8cc740797779e898 00700a4d4141d8ab 75eb4dca135978a3',\n  n: '1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed',\n  hash: hash.sha256,\n  gRed: false,\n  g: [\n    '216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51a',\n\n    // 4/5\n    '6666666666666666666666666666666666666666666666666666666666666658',\n  ],\n});\n\nvar pre;\ntry {\n  pre = require('./precomputed/secp256k1');\n} catch (e) {\n  pre = undefined;\n}\n\ndefineCurve('secp256k1', {\n  type: 'short',\n  prime: 'k256',\n  p: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f',\n  a: '0',\n  b: '7',\n  n: 'ffffffff ffffffff ffffffff fffffffe baaedce6 af48a03b bfd25e8c d0364141',\n  h: '1',\n  hash: hash.sha256,\n\n  // Precomputed endomorphism\n  beta: '7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee',\n  lambda: '5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72',\n  basis: [\n    {\n      a: '3086d221a7d46bcde86c90e49284eb15',\n      b: '-e4437ed6010e88286f547fa90abfe4c3',\n    },\n    {\n      a: '114ca50f7a8e2f3f657c1108d9d44cfd8',\n      b: '3086d221a7d46bcde86c90e49284eb15',\n    },\n  ],\n\n  gRed: false,\n  g: [\n    '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798',\n    '483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8',\n    pre,\n  ],\n});\n",
    "'use strict';\n\nvar hash = require('hash.js');\nvar utils = require('minimalistic-crypto-utils');\nvar assert = require('minimalistic-assert');\n\nfunction HmacDRBG(options) {\n  if (!(this instanceof HmacDRBG))\n    return new HmacDRBG(options);\n  this.hash = options.hash;\n  this.predResist = !!options.predResist;\n\n  this.outLen = this.hash.outSize;\n  this.minEntropy = options.minEntropy || this.hash.hmacStrength;\n\n  this._reseed = null;\n  this.reseedInterval = null;\n  this.K = null;\n  this.V = null;\n\n  var entropy = utils.toArray(options.entropy, options.entropyEnc || 'hex');\n  var nonce = utils.toArray(options.nonce, options.nonceEnc || 'hex');\n  var pers = utils.toArray(options.pers, options.persEnc || 'hex');\n  assert(entropy.length >= (this.minEntropy / 8),\n         'Not enough entropy. Minimum is: ' + this.minEntropy + ' bits');\n  this._init(entropy, nonce, pers);\n}\nmodule.exports = HmacDRBG;\n\nHmacDRBG.prototype._init = function init(entropy, nonce, pers) {\n  var seed = entropy.concat(nonce).concat(pers);\n\n  this.K = new Array(this.outLen / 8);\n  this.V = new Array(this.outLen / 8);\n  for (var i = 0; i < this.V.length; i++) {\n    this.K[i] = 0x00;\n    this.V[i] = 0x01;\n  }\n\n  this._update(seed);\n  this._reseed = 1;\n  this.reseedInterval = 0x1000000000000;  // 2^48\n};\n\nHmacDRBG.prototype._hmac = function hmac() {\n  return new hash.hmac(this.hash, this.K);\n};\n\nHmacDRBG.prototype._update = function update(seed) {\n  var kmac = this._hmac()\n                 .update(this.V)\n                 .update([ 0x00 ]);\n  if (seed)\n    kmac = kmac.update(seed);\n  this.K = kmac.digest();\n  this.V = this._hmac().update(this.V).digest();\n  if (!seed)\n    return;\n\n  this.K = this._hmac()\n               .update(this.V)\n               .update([ 0x01 ])\n               .update(seed)\n               .digest();\n  this.V = this._hmac().update(this.V).digest();\n};\n\nHmacDRBG.prototype.reseed = function reseed(entropy, entropyEnc, add, addEnc) {\n  // Optional entropy enc\n  if (typeof entropyEnc !== 'string') {\n    addEnc = add;\n    add = entropyEnc;\n    entropyEnc = null;\n  }\n\n  entropy = utils.toArray(entropy, entropyEnc);\n  add = utils.toArray(add, addEnc);\n\n  assert(entropy.length >= (this.minEntropy / 8),\n         'Not enough entropy. Minimum is: ' + this.minEntropy + ' bits');\n\n  this._update(entropy.concat(add || []));\n  this._reseed = 1;\n};\n\nHmacDRBG.prototype.generate = function generate(len, enc, add, addEnc) {\n  if (this._reseed > this.reseedInterval)\n    throw new Error('Reseed is required');\n\n  // Optional encoding\n  if (typeof enc !== 'string') {\n    addEnc = add;\n    add = enc;\n    enc = null;\n  }\n\n  // Optional additional data\n  if (add) {\n    add = utils.toArray(add, addEnc || 'hex');\n    this._update(add);\n  }\n\n  var temp = [];\n  while (temp.length < len) {\n    this.V = this._hmac().update(this.V).digest();\n    temp = temp.concat(this.V);\n  }\n\n  var res = temp.slice(0, len);\n  this._update(add);\n  this._reseed++;\n  return utils.encode(res, enc);\n};\n",
    "'use strict';\n\nvar BN = require('bn.js');\nvar utils = require('../utils');\nvar assert = utils.assert;\n\nfunction KeyPair(ec, options) {\n  this.ec = ec;\n  this.priv = null;\n  this.pub = null;\n\n  // KeyPair(ec, { priv: ..., pub: ... })\n  if (options.priv)\n    this._importPrivate(options.priv, options.privEnc);\n  if (options.pub)\n    this._importPublic(options.pub, options.pubEnc);\n}\nmodule.exports = KeyPair;\n\nKeyPair.fromPublic = function fromPublic(ec, pub, enc) {\n  if (pub instanceof KeyPair)\n    return pub;\n\n  return new KeyPair(ec, {\n    pub: pub,\n    pubEnc: enc,\n  });\n};\n\nKeyPair.fromPrivate = function fromPrivate(ec, priv, enc) {\n  if (priv instanceof KeyPair)\n    return priv;\n\n  return new KeyPair(ec, {\n    priv: priv,\n    privEnc: enc,\n  });\n};\n\nKeyPair.prototype.validate = function validate() {\n  var pub = this.getPublic();\n\n  if (pub.isInfinity())\n    return { result: false, reason: 'Invalid public key' };\n  if (!pub.validate())\n    return { result: false, reason: 'Public key is not a point' };\n  if (!pub.mul(this.ec.curve.n).isInfinity())\n    return { result: false, reason: 'Public key * N != O' };\n\n  return { result: true, reason: null };\n};\n\nKeyPair.prototype.getPublic = function getPublic(compact, enc) {\n  // compact is optional argument\n  if (typeof compact === 'string') {\n    enc = compact;\n    compact = null;\n  }\n\n  if (!this.pub)\n    this.pub = this.ec.g.mul(this.priv);\n\n  if (!enc)\n    return this.pub;\n\n  return this.pub.encode(enc, compact);\n};\n\nKeyPair.prototype.getPrivate = function getPrivate(enc) {\n  if (enc === 'hex')\n    return this.priv.toString(16, 2);\n  else\n    return this.priv;\n};\n\nKeyPair.prototype._importPrivate = function _importPrivate(key, enc) {\n  this.priv = new BN(key, enc || 16);\n\n  // Ensure that the priv won't be bigger than n, otherwise we may fail\n  // in fixed multiplication method\n  this.priv = this.priv.umod(this.ec.curve.n);\n};\n\nKeyPair.prototype._importPublic = function _importPublic(key, enc) {\n  if (key.x || key.y) {\n    // Montgomery points only have an `x` coordinate.\n    // Weierstrass/Edwards points on the other hand have both `x` and\n    // `y` coordinates.\n    if (this.ec.curve.type === 'mont') {\n      assert(key.x, 'Need x coordinate');\n    } else if (this.ec.curve.type === 'short' ||\n               this.ec.curve.type === 'edwards') {\n      assert(key.x && key.y, 'Need both x and y coordinate');\n    }\n    this.pub = this.ec.curve.point(key.x, key.y);\n    return;\n  }\n  this.pub = this.ec.curve.decodePoint(key, enc);\n};\n\n// ECDH\nKeyPair.prototype.derive = function derive(pub) {\n  if(!pub.validate()) {\n    assert(pub.validate(), 'public point not validated');\n  }\n  return pub.mul(this.priv).getX();\n};\n\n// ECDSA\nKeyPair.prototype.sign = function sign(msg, enc, options) {\n  return this.ec.sign(msg, this, enc, options);\n};\n\nKeyPair.prototype.verify = function verify(msg, signature, options) {\n  return this.ec.verify(msg, signature, this, undefined, options);\n};\n\nKeyPair.prototype.inspect = function inspect() {\n  return '<Key priv: ' + (this.priv && this.priv.toString(16, 2)) +\n         ' pub: ' + (this.pub && this.pub.inspect()) + ' >';\n};\n",
    "'use strict';\n\nvar BN = require('bn.js');\n\nvar utils = require('../utils');\nvar assert = utils.assert;\n\nfunction Signature(options, enc) {\n  if (options instanceof Signature)\n    return options;\n\n  if (this._importDER(options, enc))\n    return;\n\n  assert(options.r && options.s, 'Signature without r or s');\n  this.r = new BN(options.r, 16);\n  this.s = new BN(options.s, 16);\n  if (options.recoveryParam === undefined)\n    this.recoveryParam = null;\n  else\n    this.recoveryParam = options.recoveryParam;\n}\nmodule.exports = Signature;\n\nfunction Position() {\n  this.place = 0;\n}\n\nfunction getLength(buf, p) {\n  var initial = buf[p.place++];\n  if (!(initial & 0x80)) {\n    return initial;\n  }\n  var octetLen = initial & 0xf;\n\n  // Indefinite length or overflow\n  if (octetLen === 0 || octetLen > 4) {\n    return false;\n  }\n\n  if(buf[p.place] === 0x00) {\n    return false;\n  }\n\n  var val = 0;\n  for (var i = 0, off = p.place; i < octetLen; i++, off++) {\n    val <<= 8;\n    val |= buf[off];\n    val >>>= 0;\n  }\n\n  // Leading zeroes\n  if (val <= 0x7f) {\n    return false;\n  }\n\n  p.place = off;\n  return val;\n}\n\nfunction rmPadding(buf) {\n  var i = 0;\n  var len = buf.length - 1;\n  while (!buf[i] && !(buf[i + 1] & 0x80) && i < len) {\n    i++;\n  }\n  if (i === 0) {\n    return buf;\n  }\n  return buf.slice(i);\n}\n\nSignature.prototype._importDER = function _importDER(data, enc) {\n  data = utils.toArray(data, enc);\n  var p = new Position();\n  if (data[p.place++] !== 0x30) {\n    return false;\n  }\n  var len = getLength(data, p);\n  if (len === false) {\n    return false;\n  }\n  if ((len + p.place) !== data.length) {\n    return false;\n  }\n  if (data[p.place++] !== 0x02) {\n    return false;\n  }\n  var rlen = getLength(data, p);\n  if (rlen === false) {\n    return false;\n  }\n  if ((data[p.place] & 128) !== 0) {\n    return false;\n  }\n  var r = data.slice(p.place, rlen + p.place);\n  p.place += rlen;\n  if (data[p.place++] !== 0x02) {\n    return false;\n  }\n  var slen = getLength(data, p);\n  if (slen === false) {\n    return false;\n  }\n  if (data.length !== slen + p.place) {\n    return false;\n  }\n  if ((data[p.place] & 128) !== 0) {\n    return false;\n  }\n  var s = data.slice(p.place, slen + p.place);\n  if (r[0] === 0) {\n    if (r[1] & 0x80) {\n      r = r.slice(1);\n    } else {\n      // Leading zeroes\n      return false;\n    }\n  }\n  if (s[0] === 0) {\n    if (s[1] & 0x80) {\n      s = s.slice(1);\n    } else {\n      // Leading zeroes\n      return false;\n    }\n  }\n\n  this.r = new BN(r);\n  this.s = new BN(s);\n  this.recoveryParam = null;\n\n  return true;\n};\n\nfunction constructLength(arr, len) {\n  if (len < 0x80) {\n    arr.push(len);\n    return;\n  }\n  var octets = 1 + (Math.log(len) / Math.LN2 >>> 3);\n  arr.push(octets | 0x80);\n  while (--octets) {\n    arr.push((len >>> (octets << 3)) & 0xff);\n  }\n  arr.push(len);\n}\n\nSignature.prototype.toDER = function toDER(enc) {\n  var r = this.r.toArray();\n  var s = this.s.toArray();\n\n  // Pad values\n  if (r[0] & 0x80)\n    r = [ 0 ].concat(r);\n  // Pad values\n  if (s[0] & 0x80)\n    s = [ 0 ].concat(s);\n\n  r = rmPadding(r);\n  s = rmPadding(s);\n\n  while (!s[0] && !(s[1] & 0x80)) {\n    s = s.slice(1);\n  }\n  var arr = [ 0x02 ];\n  constructLength(arr, r.length);\n  arr = arr.concat(r);\n  arr.push(0x02);\n  constructLength(arr, s.length);\n  var backHalf = arr.concat(s);\n  var res = [ 0x30 ];\n  constructLength(res, backHalf.length);\n  res = res.concat(backHalf);\n  return utils.encode(res, enc);\n};\n",
    "'use strict';\n\nvar BN = require('bn.js');\nvar HmacDRBG = require('hmac-drbg');\nvar utils = require('../utils');\nvar curves = require('../curves');\nvar rand = require('brorand');\nvar assert = utils.assert;\n\nvar KeyPair = require('./key');\nvar Signature = require('./signature');\n\nfunction EC(options) {\n  if (!(this instanceof EC))\n    return new EC(options);\n\n  // Shortcut `elliptic.ec(curve-name)`\n  if (typeof options === 'string') {\n    assert(Object.prototype.hasOwnProperty.call(curves, options),\n      'Unknown curve ' + options);\n\n    options = curves[options];\n  }\n\n  // Shortcut for `elliptic.ec(elliptic.curves.curveName)`\n  if (options instanceof curves.PresetCurve)\n    options = { curve: options };\n\n  this.curve = options.curve.curve;\n  this.n = this.curve.n;\n  this.nh = this.n.ushrn(1);\n  this.g = this.curve.g;\n\n  // Point on curve\n  this.g = options.curve.g;\n  this.g.precompute(options.curve.n.bitLength() + 1);\n\n  // Hash for function for DRBG\n  this.hash = options.hash || options.curve.hash;\n}\nmodule.exports = EC;\n\nEC.prototype.keyPair = function keyPair(options) {\n  return new KeyPair(this, options);\n};\n\nEC.prototype.keyFromPrivate = function keyFromPrivate(priv, enc) {\n  return KeyPair.fromPrivate(this, priv, enc);\n};\n\nEC.prototype.keyFromPublic = function keyFromPublic(pub, enc) {\n  return KeyPair.fromPublic(this, pub, enc);\n};\n\nEC.prototype.genKeyPair = function genKeyPair(options) {\n  if (!options)\n    options = {};\n\n  // Instantiate Hmac_DRBG\n  var drbg = new HmacDRBG({\n    hash: this.hash,\n    pers: options.pers,\n    persEnc: options.persEnc || 'utf8',\n    entropy: options.entropy || rand(this.hash.hmacStrength),\n    entropyEnc: options.entropy && options.entropyEnc || 'utf8',\n    nonce: this.n.toArray(),\n  });\n\n  var bytes = this.n.byteLength();\n  var ns2 = this.n.sub(new BN(2));\n  for (;;) {\n    var priv = new BN(drbg.generate(bytes));\n    if (priv.cmp(ns2) > 0)\n      continue;\n\n    priv.iaddn(1);\n    return this.keyFromPrivate(priv);\n  }\n};\n\nEC.prototype._truncateToN = function _truncateToN(msg, truncOnly, bitLength) {\n  var byteLength;\n  if (BN.isBN(msg) || typeof msg === 'number') {\n    msg = new BN(msg, 16);\n    byteLength = msg.byteLength();\n  } else if (typeof msg === 'object') {\n    // BN assumes an array-like input and asserts length\n    byteLength = msg.length;\n    msg = new BN(msg, 16);\n  } else {\n    // BN converts the value to string\n    var str = msg.toString();\n    // HEX encoding\n    byteLength = (str.length + 1) >>> 1;\n    msg = new BN(str, 16);\n  }\n  // Allow overriding\n  if (typeof bitLength !== 'number') {\n    bitLength = byteLength * 8;\n  }\n  var delta = bitLength - this.n.bitLength();\n  if (delta > 0)\n    msg = msg.ushrn(delta);\n  if (!truncOnly && msg.cmp(this.n) >= 0)\n    return msg.sub(this.n);\n  else\n    return msg;\n};\n\nEC.prototype.sign = function sign(msg, key, enc, options) {\n  if (typeof enc === 'object') {\n    options = enc;\n    enc = null;\n  }\n  if (!options)\n    options = {};\n\n  if (typeof msg !== 'string' && typeof msg !== 'number' && !BN.isBN(msg)) {\n    assert(typeof msg === 'object' && msg && typeof msg.length === 'number',\n      'Expected message to be an array-like, a hex string, or a BN instance');\n    assert((msg.length >>> 0) === msg.length); // non-negative 32-bit integer\n    for (var i = 0; i < msg.length; i++) assert((msg[i] & 255) === msg[i]);\n  }\n\n  key = this.keyFromPrivate(key, enc);\n  msg = this._truncateToN(msg, false, options.msgBitLength);\n\n  // Would fail further checks, but let's make the error message clear\n  assert(!msg.isNeg(), 'Can not sign a negative message');\n\n  // Zero-extend key to provide enough entropy\n  var bytes = this.n.byteLength();\n  var bkey = key.getPrivate().toArray('be', bytes);\n\n  // Zero-extend nonce to have the same byte size as N\n  var nonce = msg.toArray('be', bytes);\n\n  // Recheck nonce to be bijective to msg\n  assert((new BN(nonce)).eq(msg), 'Can not sign message');\n\n  // Instantiate Hmac_DRBG\n  var drbg = new HmacDRBG({\n    hash: this.hash,\n    entropy: bkey,\n    nonce: nonce,\n    pers: options.pers,\n    persEnc: options.persEnc || 'utf8',\n  });\n\n  // Number of bytes to generate\n  var ns1 = this.n.sub(new BN(1));\n\n  for (var iter = 0; ; iter++) {\n    var k = options.k ?\n      options.k(iter) :\n      new BN(drbg.generate(this.n.byteLength()));\n    k = this._truncateToN(k, true);\n    if (k.cmpn(1) <= 0 || k.cmp(ns1) >= 0)\n      continue;\n\n    var kp = this.g.mul(k);\n    if (kp.isInfinity())\n      continue;\n\n    var kpX = kp.getX();\n    var r = kpX.umod(this.n);\n    if (r.cmpn(0) === 0)\n      continue;\n\n    var s = k.invm(this.n).mul(r.mul(key.getPrivate()).iadd(msg));\n    s = s.umod(this.n);\n    if (s.cmpn(0) === 0)\n      continue;\n\n    var recoveryParam = (kp.getY().isOdd() ? 1 : 0) |\n                        (kpX.cmp(r) !== 0 ? 2 : 0);\n\n    // Use complement of `s`, if it is > `n / 2`\n    if (options.canonical && s.cmp(this.nh) > 0) {\n      s = this.n.sub(s);\n      recoveryParam ^= 1;\n    }\n\n    return new Signature({ r: r, s: s, recoveryParam: recoveryParam });\n  }\n};\n\nEC.prototype.verify = function verify(msg, signature, key, enc, options) {\n  if (!options)\n    options = {};\n\n  msg = this._truncateToN(msg, false, options.msgBitLength);\n  key = this.keyFromPublic(key, enc);\n  signature = new Signature(signature, 'hex');\n\n  // Perform primitive values validation\n  var r = signature.r;\n  var s = signature.s;\n  if (r.cmpn(1) < 0 || r.cmp(this.n) >= 0)\n    return false;\n  if (s.cmpn(1) < 0 || s.cmp(this.n) >= 0)\n    return false;\n\n  // Validate signature\n  var sinv = s.invm(this.n);\n  var u1 = sinv.mul(msg).umod(this.n);\n  var u2 = sinv.mul(r).umod(this.n);\n  var p;\n\n  if (!this.curve._maxwellTrick) {\n    p = this.g.mulAdd(u1, key.getPublic(), u2);\n    if (p.isInfinity())\n      return false;\n\n    return p.getX().umod(this.n).cmp(r) === 0;\n  }\n\n  // NOTE: Greg Maxwell's trick, inspired by:\n  // https://git.io/vad3K\n\n  p = this.g.jmulAdd(u1, key.getPublic(), u2);\n  if (p.isInfinity())\n    return false;\n\n  // Compare `p.x` of Jacobian point with `r`,\n  // this will do `p.x == r * p.z^2` instead of multiplying `p.x` by the\n  // inverse of `p.z^2`\n  return p.eqXToP(r);\n};\n\nEC.prototype.recoverPubKey = function(msg, signature, j, enc) {\n  assert((3 & j) === j, 'The recovery param is more than two bits');\n  signature = new Signature(signature, enc);\n\n  var n = this.n;\n  var e = new BN(msg);\n  var r = signature.r;\n  var s = signature.s;\n\n  // A set LSB signifies that the y-coordinate is odd\n  var isYOdd = j & 1;\n  var isSecondKey = j >> 1;\n  if (r.cmp(this.curve.p.umod(this.curve.n)) >= 0 && isSecondKey)\n    throw new Error('Unable to find sencond key candinate');\n\n  // 1.1. Let x = r + jn.\n  if (isSecondKey)\n    r = this.curve.pointFromX(r.add(this.curve.n), isYOdd);\n  else\n    r = this.curve.pointFromX(r, isYOdd);\n\n  var rInv = signature.r.invm(n);\n  var s1 = n.sub(e).mul(rInv).umod(n);\n  var s2 = s.mul(rInv).umod(n);\n\n  // 1.6.1 Compute Q = r^-1 (sR -  eG)\n  //               Q = r^-1 (sR + -eG)\n  return this.g.mulAdd(s1, r, s2);\n};\n\nEC.prototype.getKeyRecoveryParam = function(e, signature, Q, enc) {\n  signature = new Signature(signature, enc);\n  if (signature.recoveryParam !== null)\n    return signature.recoveryParam;\n\n  for (var i = 0; i < 4; i++) {\n    var Qprime;\n    try {\n      Qprime = this.recoverPubKey(e, signature, i);\n    } catch (e) {\n      continue;\n    }\n\n    if (Qprime.eq(Q))\n      return i;\n  }\n  throw new Error('Unable to find valid recovery factor');\n};\n",
    "'use strict';\n\nvar utils = require('../utils');\nvar assert = utils.assert;\nvar parseBytes = utils.parseBytes;\nvar cachedProperty = utils.cachedProperty;\n\n/**\n* @param {EDDSA} eddsa - instance\n* @param {Object} params - public/private key parameters\n*\n* @param {Array<Byte>} [params.secret] - secret seed bytes\n* @param {Point} [params.pub] - public key point (aka `A` in eddsa terms)\n* @param {Array<Byte>} [params.pub] - public key point encoded as bytes\n*\n*/\nfunction KeyPair(eddsa, params) {\n  this.eddsa = eddsa;\n  this._secret = parseBytes(params.secret);\n  if (eddsa.isPoint(params.pub))\n    this._pub = params.pub;\n  else\n    this._pubBytes = parseBytes(params.pub);\n}\n\nKeyPair.fromPublic = function fromPublic(eddsa, pub) {\n  if (pub instanceof KeyPair)\n    return pub;\n  return new KeyPair(eddsa, { pub: pub });\n};\n\nKeyPair.fromSecret = function fromSecret(eddsa, secret) {\n  if (secret instanceof KeyPair)\n    return secret;\n  return new KeyPair(eddsa, { secret: secret });\n};\n\nKeyPair.prototype.secret = function secret() {\n  return this._secret;\n};\n\ncachedProperty(KeyPair, 'pubBytes', function pubBytes() {\n  return this.eddsa.encodePoint(this.pub());\n});\n\ncachedProperty(KeyPair, 'pub', function pub() {\n  if (this._pubBytes)\n    return this.eddsa.decodePoint(this._pubBytes);\n  return this.eddsa.g.mul(this.priv());\n});\n\ncachedProperty(KeyPair, 'privBytes', function privBytes() {\n  var eddsa = this.eddsa;\n  var hash = this.hash();\n  var lastIx = eddsa.encodingLength - 1;\n\n  var a = hash.slice(0, eddsa.encodingLength);\n  a[0] &= 248;\n  a[lastIx] &= 127;\n  a[lastIx] |= 64;\n\n  return a;\n});\n\ncachedProperty(KeyPair, 'priv', function priv() {\n  return this.eddsa.decodeInt(this.privBytes());\n});\n\ncachedProperty(KeyPair, 'hash', function hash() {\n  return this.eddsa.hash().update(this.secret()).digest();\n});\n\ncachedProperty(KeyPair, 'messagePrefix', function messagePrefix() {\n  return this.hash().slice(this.eddsa.encodingLength);\n});\n\nKeyPair.prototype.sign = function sign(message) {\n  assert(this._secret, 'KeyPair can only verify');\n  return this.eddsa.sign(message, this);\n};\n\nKeyPair.prototype.verify = function verify(message, sig) {\n  return this.eddsa.verify(message, sig, this);\n};\n\nKeyPair.prototype.getSecret = function getSecret(enc) {\n  assert(this._secret, 'KeyPair is public only');\n  return utils.encode(this.secret(), enc);\n};\n\nKeyPair.prototype.getPublic = function getPublic(enc) {\n  return utils.encode(this.pubBytes(), enc);\n};\n\nmodule.exports = KeyPair;\n",
    "'use strict';\n\nvar BN = require('bn.js');\nvar utils = require('../utils');\nvar assert = utils.assert;\nvar cachedProperty = utils.cachedProperty;\nvar parseBytes = utils.parseBytes;\n\n/**\n* @param {EDDSA} eddsa - eddsa instance\n* @param {Array<Bytes>|Object} sig -\n* @param {Array<Bytes>|Point} [sig.R] - R point as Point or bytes\n* @param {Array<Bytes>|bn} [sig.S] - S scalar as bn or bytes\n* @param {Array<Bytes>} [sig.Rencoded] - R point encoded\n* @param {Array<Bytes>} [sig.Sencoded] - S scalar encoded\n*/\nfunction Signature(eddsa, sig) {\n  this.eddsa = eddsa;\n\n  if (typeof sig !== 'object')\n    sig = parseBytes(sig);\n\n  if (Array.isArray(sig)) {\n    assert(sig.length === eddsa.encodingLength * 2, 'Signature has invalid size');\n    sig = {\n      R: sig.slice(0, eddsa.encodingLength),\n      S: sig.slice(eddsa.encodingLength),\n    };\n  }\n\n  assert(sig.R && sig.S, 'Signature without R or S');\n\n  if (eddsa.isPoint(sig.R))\n    this._R = sig.R;\n  if (sig.S instanceof BN)\n    this._S = sig.S;\n\n  this._Rencoded = Array.isArray(sig.R) ? sig.R : sig.Rencoded;\n  this._Sencoded = Array.isArray(sig.S) ? sig.S : sig.Sencoded;\n}\n\ncachedProperty(Signature, 'S', function S() {\n  return this.eddsa.decodeInt(this.Sencoded());\n});\n\ncachedProperty(Signature, 'R', function R() {\n  return this.eddsa.decodePoint(this.Rencoded());\n});\n\ncachedProperty(Signature, 'Rencoded', function Rencoded() {\n  return this.eddsa.encodePoint(this.R());\n});\n\ncachedProperty(Signature, 'Sencoded', function Sencoded() {\n  return this.eddsa.encodeInt(this.S());\n});\n\nSignature.prototype.toBytes = function toBytes() {\n  return this.Rencoded().concat(this.Sencoded());\n};\n\nSignature.prototype.toHex = function toHex() {\n  return utils.encode(this.toBytes(), 'hex').toUpperCase();\n};\n\nmodule.exports = Signature;\n",
    "'use strict';\n\nvar hash = require('hash.js');\nvar curves = require('../curves');\nvar utils = require('../utils');\nvar assert = utils.assert;\nvar parseBytes = utils.parseBytes;\nvar KeyPair = require('./key');\nvar Signature = require('./signature');\n\nfunction EDDSA(curve) {\n  assert(curve === 'ed25519', 'only tested with ed25519 so far');\n\n  if (!(this instanceof EDDSA))\n    return new EDDSA(curve);\n\n  curve = curves[curve].curve;\n  this.curve = curve;\n  this.g = curve.g;\n  this.g.precompute(curve.n.bitLength() + 1);\n\n  this.pointClass = curve.point().constructor;\n  this.encodingLength = Math.ceil(curve.n.bitLength() / 8);\n  this.hash = hash.sha512;\n}\n\nmodule.exports = EDDSA;\n\n/**\n* @param {Array|String} message - message bytes\n* @param {Array|String|KeyPair} secret - secret bytes or a keypair\n* @returns {Signature} - signature\n*/\nEDDSA.prototype.sign = function sign(message, secret) {\n  message = parseBytes(message);\n  var key = this.keyFromSecret(secret);\n  var r = this.hashInt(key.messagePrefix(), message);\n  var R = this.g.mul(r);\n  var Rencoded = this.encodePoint(R);\n  var s_ = this.hashInt(Rencoded, key.pubBytes(), message)\n    .mul(key.priv());\n  var S = r.add(s_).umod(this.curve.n);\n  return this.makeSignature({ R: R, S: S, Rencoded: Rencoded });\n};\n\n/**\n* @param {Array} message - message bytes\n* @param {Array|String|Signature} sig - sig bytes\n* @param {Array|String|Point|KeyPair} pub - public key\n* @returns {Boolean} - true if public key matches sig of message\n*/\nEDDSA.prototype.verify = function verify(message, sig, pub) {\n  message = parseBytes(message);\n  sig = this.makeSignature(sig);\n  if (sig.S().gte(sig.eddsa.curve.n) || sig.S().isNeg()) {\n    return false;\n  }\n  var key = this.keyFromPublic(pub);\n  var h = this.hashInt(sig.Rencoded(), key.pubBytes(), message);\n  var SG = this.g.mul(sig.S());\n  var RplusAh = sig.R().add(key.pub().mul(h));\n  return RplusAh.eq(SG);\n};\n\nEDDSA.prototype.hashInt = function hashInt() {\n  var hash = this.hash();\n  for (var i = 0; i < arguments.length; i++)\n    hash.update(arguments[i]);\n  return utils.intFromLE(hash.digest()).umod(this.curve.n);\n};\n\nEDDSA.prototype.keyFromPublic = function keyFromPublic(pub) {\n  return KeyPair.fromPublic(this, pub);\n};\n\nEDDSA.prototype.keyFromSecret = function keyFromSecret(secret) {\n  return KeyPair.fromSecret(this, secret);\n};\n\nEDDSA.prototype.makeSignature = function makeSignature(sig) {\n  if (sig instanceof Signature)\n    return sig;\n  return new Signature(this, sig);\n};\n\n/**\n* * https://tools.ietf.org/html/draft-josefsson-eddsa-ed25519-03#section-5.2\n*\n* EDDSA defines methods for encoding and decoding points and integers. These are\n* helper convenience methods, that pass along to utility functions implied\n* parameters.\n*\n*/\nEDDSA.prototype.encodePoint = function encodePoint(point) {\n  var enc = point.getY().toArray('le', this.encodingLength);\n  enc[this.encodingLength - 1] |= point.getX().isOdd() ? 0x80 : 0;\n  return enc;\n};\n\nEDDSA.prototype.decodePoint = function decodePoint(bytes) {\n  bytes = utils.parseBytes(bytes);\n\n  var lastIx = bytes.length - 1;\n  var normed = bytes.slice(0, lastIx).concat(bytes[lastIx] & ~0x80);\n  var xIsOdd = (bytes[lastIx] & 0x80) !== 0;\n\n  var y = utils.intFromLE(normed);\n  return this.curve.pointFromY(y, xIsOdd);\n};\n\nEDDSA.prototype.encodeInt = function encodeInt(num) {\n  return num.toArray('le', this.encodingLength);\n};\n\nEDDSA.prototype.decodeInt = function decodeInt(bytes) {\n  return utils.intFromLE(bytes);\n};\n\nEDDSA.prototype.isPoint = function isPoint(val) {\n  return val instanceof this.pointClass;\n};\n",
    "'use strict';\n\nvar elliptic = exports;\n\nelliptic.version = require('../package.json').version;\nelliptic.utils = require('./elliptic/utils');\nelliptic.rand = require('brorand');\nelliptic.curve = require('./elliptic/curve');\nelliptic.curves = require('./elliptic/curves');\n\n// Protocols\nelliptic.ec = require('./elliptic/ec');\nelliptic.eddsa = require('./elliptic/eddsa');\n",
    "'use strict';\n\nvar BN = require('asn1.js').bignum,\n\tBuffer = require('safe-buffer').Buffer;\n\nmodule.exports = function base64ToBigNum(val, zero) {\n\tvar buf = Buffer.from(val, 'base64');\n\tvar bn = val = new BN(buf, 10, 'be').iabs();\n\tif (zero) {\n\t\tbuf.fill(0);\n\t}\n\treturn bn;\n};\n",
    "'use strict';\n\nmodule.exports = require('asn1.js').define('AlgorithmIdentifer', /* @this */ function() {\n\tthis.seq().obj(\n\t\tthis.key('algorithm').objid(),\n\t\tthis.key('parameters').optional().any()\n\t);\n});\n",
    "'use strict';\n\nvar AlgorithmIdentifier = require('./algorithm-identifier');\n\nmodule.exports = require('asn1.js').define('PublicKeyInfo', /* @this */ function() {\n\tthis.seq().obj(\n\t\tthis.key('algorithm').use(AlgorithmIdentifier),\n\t\tthis.key('PublicKey').bitstr()\n\t);\n});\n",
    "'use strict';\n\nmodule.exports = require('asn1.js').define('Version', /* @this */ function() {\n\tthis.int();\n});\n",
    "'use strict';\n\nvar AlgorithmIdentifier = require('./algorithm-identifier');\nvar Version = require('./version');\n\nmodule.exports = require('asn1.js').define('PrivateKeyInfo', /* @this */ function() {\n\tthis.seq().obj(\n\t\tthis.key('version').use(Version),\n\t\tthis.key('privateKeyAlgorithm').use(AlgorithmIdentifier),\n\t\tthis.key('privateKey').octstr(),\n\t\tthis.key('attributes').optional().any()\n\t);\n});\n",
    "'use strict';\n\nvar asn1 = require('asn1.js'),\n\tBuffer = require('safe-buffer').Buffer,\n\tEC = require('elliptic').ec;\n\nvar b64ToBn = require('./b64-to-bn');\n\nvar PublicKeyInfo = require('./asn1/public-key-info'),\n\tPrivateKeyInfo = require('./asn1/private-key-info'),\n\tVersion = require('./asn1/version');\n\nvar ECParameters = asn1.define('ECParameters', /* @this */ function() {\n\tthis.choice({\n\t\tnamedCurve: this.objid()\n\t});\n});\n\nvar ecPrivkeyVer1 = 1;\n\nvar ECPrivateKey = asn1.define('ECPrivateKey', /* @this */ function() {\n\tthis.seq().obj(\n\t\tthis.key('version').use(Version),\n\t\tthis.key('privateKey').octstr(),\n\t\tthis.key('parameters').explicit(0).optional().any(),\n\t\tthis.key('publicKey').explicit(1).optional().bitstr()\n\t);\n});\n\nvar curves = {\n\t'P-256': 'p256',\n\t'P-384': 'p384',\n\t'P-521': 'p521'\n};\n\nvar oids = {\n\t'P-256': [1, 2, 840, 10045, 3, 1, 7],\n\t'P-384': [1, 3, 132, 0, 34],\n\t'P-521': [1, 3, 132, 0, 35]\n};\nvar parameters = {};\nvar algorithms = {};\nObject.keys(oids).forEach(function(crv) {\n\tparameters[crv] = ECParameters.encode({\n\t\ttype: 'namedCurve',\n\t\tvalue: oids[crv]\n\t}, 'der');\n\talgorithms[crv] = {\n\t\talgorithm:  [1, 2, 840, 10045, 2, 1],\n\t\tparameters: parameters[crv]\n\t};\n});\noids = null;\n\nfunction ecJwkToBuffer(jwk, opts) {\n\tif ('string' !== typeof jwk.crv) {\n\t\tthrow new TypeError('Expected \"jwk.crv\" to be a String');\n\t}\n\n\tvar hasD = 'string' === typeof jwk.d;\n\tvar xyTypes = hasD\n\t\t? ['undefined', 'string']\n\t\t: ['string'];\n\n\tif (-1 === xyTypes.indexOf(typeof jwk.x)) {\n\t\tthrow new TypeError('Expected \"jwk.x\" to be a String');\n\t}\n\n\tif (-1 === xyTypes.indexOf(typeof jwk.y)) {\n\t\tthrow new TypeError('Expected \"jwk.y\" to be a String');\n\t}\n\n\tif (opts.private && !hasD) {\n\t\tthrow new TypeError('Expected \"jwk.d\" to be a String');\n\t}\n\n\tvar curveName = curves[jwk.crv];\n\tif (!curveName) {\n\t\tthrow new Error('Unsupported curve \"' + jwk.crv + '\"');\n\t}\n\n\tvar curve = new EC(curveName);\n\n\tvar key = {};\n\n\tvar hasPub = jwk.x && jwk.y;\n\tif (hasPub) {\n\t\tkey.pub = {\n\t\t\tx: b64ToBn(jwk.x, false),\n\t\t\ty: b64ToBn(jwk.y, false)\n\t\t};\n\t}\n\n\tif (opts.private || !hasPub) {\n\t\tkey.priv = b64ToBn(jwk.d, true);\n\t}\n\n\tkey = curve.keyPair(key);\n\n\tvar keyValidation = key.validate();\n\tif (!keyValidation.result) {\n\t\tthrow new Error('Invalid key for curve: \"' + keyValidation.reason + '\"');\n\t}\n\n\tvar result = keyToPem(jwk.crv, key, opts);\n\n\treturn result;\n}\n\nfunction keyToPem(crv, key, opts) {\n\tvar compact = false;\n\tvar publicKey = key.getPublic(compact, 'hex');\n\tpublicKey = Buffer.from(publicKey, 'hex');\n\tpublicKey = {\n\t\tunused: 0,\n\t\tdata: publicKey\n\t};\n\n\tvar result;\n\tif (opts.private) {\n\t\tvar privateKey = key.getPrivate('hex');\n\t\tprivateKey = Buffer.from(privateKey, 'hex');\n\n\t\tresult = PrivateKeyInfo.encode({\n\t\t\tversion: 0,\n\t\t\tprivateKeyAlgorithm: algorithms[crv],\n\t\t\tprivateKey: ECPrivateKey.encode({\n\t\t\t\tversion: ecPrivkeyVer1,\n\t\t\t\tprivateKey: privateKey,\n\t\t\t\tparameters: parameters[crv],\n\t\t\t\tpublicKey: publicKey\n\t\t\t}, 'der')\n\t\t}, 'pem', {\n\t\t\tlabel: 'PRIVATE KEY'\n\t\t});\n\n\t\tprivateKey.fill(0);\n\t} else {\n\t\tresult = PublicKeyInfo.encode({\n\t\t\talgorithm: algorithms[crv],\n\t\t\tPublicKey: publicKey\n\t\t}, 'pem', {\n\t\t\tlabel: 'PUBLIC KEY'\n\t\t});\n\t}\n\n\t// This is in an if incase asn1.js adds a trailing \\n\n\t// istanbul ignore else\n\tif ('\\n' !== result.slice(-1)) {\n\t\tresult += '\\n';\n\t}\n\n\treturn result;\n}\n\nmodule.exports = ecJwkToBuffer;\n",
    "'use strict';\n\nvar asn1 = require('asn1.js');\n\nvar b64ToBn = require('./b64-to-bn');\n\nvar PublicKeyInfo = require('./asn1/public-key-info'),\n\tPrivateKeyInfo = require('./asn1/private-key-info'),\n\tVersion = require('./asn1/version');\n\nvar RSAPrivateKey = asn1.define('RSAPrivateKey', /* @this */ function() {\n\tthis.seq().obj(\n\t\tthis.key('version').use(Version),\n\t\tthis.key('modulus').int(),\n\t\tthis.key('publicExponent').int(),\n\t\tthis.key('privateExponent').int(),\n\t\tthis.key('prime1').int(),\n\t\tthis.key('prime2').int(),\n\t\tthis.key('exponent1').int(),\n\t\tthis.key('exponent2').int(),\n\t\tthis.key('coefficient').int()\n\t);\n});\n\nvar RSAPublicKey = asn1.define('RSAPublicKey', /* @this */ function() {\n\tthis.seq().obj(\n\t\tthis.key('modulus').int(),\n\t\tthis.key('publicExponent').int()\n\t);\n});\n\nvar algorithm = {\n\talgorithm: [1, 2, 840, 113549, 1, 1, 1],\n\tparameters: [5, 0]\n};\n\nfunction rsaJwkToBuffer(jwk, opts) {\n\tif ('string' !== typeof jwk.e) {\n\t\tthrow new TypeError('Expected \"jwk.e\" to be a String');\n\t}\n\n\tif ('string' !== typeof jwk.n) {\n\t\tthrow new TypeError('Expected \"jwk.n\" to be a String');\n\t}\n\n\tif (opts.private) {\n\t\tif ('string' !== typeof jwk.d) {\n\t\t\tthrow new TypeError('Expected \"jwk.d\" to be a String');\n\t\t}\n\n\t\tif ('string' !== typeof jwk.p) {\n\t\t\tthrow new TypeError('Expected \"jwk.p\" to be a String');\n\t\t}\n\n\t\tif ('string' !== typeof jwk.q) {\n\t\t\tthrow new TypeError('Expected \"jwk.q\" to be a String');\n\t\t}\n\n\t\tif ('string' !== typeof jwk.dp) {\n\t\t\tthrow new TypeError('Expected \"jwk.dp\" to be a String');\n\t\t}\n\n\t\tif ('string' !== typeof jwk.dq) {\n\t\t\tthrow new TypeError('Expected \"jwk.dq\" to be a String');\n\t\t}\n\n\t\tif ('string' !== typeof jwk.qi) {\n\t\t\tthrow new TypeError('Expected \"jwk.qi\" to be a String');\n\t\t}\n\t}\n\n\tvar pem;\n\tif (opts.private) {\n\t\tpem = PrivateKeyInfo.encode({\n\t\t\tversion: 0,\n\t\t\tprivateKeyAlgorithm: algorithm,\n\t\t\tprivateKey: RSAPrivateKey.encode({\n\t\t\t\tversion: 0,\n\t\t\t\tmodulus: b64ToBn(jwk.n, false),\n\t\t\t\tpublicExponent: b64ToBn(jwk.e, false),\n\t\t\t\tprivateExponent: b64ToBn(jwk.d, true),\n\t\t\t\tprime1: b64ToBn(jwk.p, true),\n\t\t\t\tprime2: b64ToBn(jwk.q, true),\n\t\t\t\texponent1: b64ToBn(jwk.dp, true),\n\t\t\t\texponent2: b64ToBn(jwk.dq, true),\n\t\t\t\tcoefficient: b64ToBn(jwk.qi, true)\n\t\t\t}, 'der')\n\t\t}, 'pem', {\n\t\t\tlabel: 'PRIVATE KEY'\n\t\t});\n\t} else {\n\t\tpem = PublicKeyInfo.encode({\n\t\t\talgorithm: algorithm,\n\t\t\tPublicKey: {\n\t\t\t\tunused: 0,\n\t\t\t\tdata: RSAPublicKey.encode({\n\t\t\t\t\tmodulus: b64ToBn(jwk.n, false),\n\t\t\t\t\tpublicExponent: b64ToBn(jwk.e, false)\n\t\t\t\t}, 'der')\n\t\t\t}\n\t\t}, 'pem', {\n\t\t\tlabel: 'PUBLIC KEY'\n\t\t});\n\t}\n\n\t// This is in an if incase asn1.js adds a trailing \\n\n\t// istanbul ignore else\n\tif ('\\n' !== pem.slice(-1)) {\n\t\tpem += '\\n';\n\t}\n\n\treturn pem;\n}\n\nmodule.exports = rsaJwkToBuffer;\n",
    "'use strict';\n\nvar ec = require('./ec'),\n\trsa = require('./rsa');\n\n/**\n *\n * @param {{kty:'EC', crv:string, d:string, x?:string, y?:string} | {kty:'EC', crv:string, x:string, y:string} | {kty:'RSA', e:string, n:string, d?:string, p?:string, q?:string, dp?:string, dq?:string, qi?:string}} jwk\n * @param {{private:boolean}=} opts\n * @returns {string}\n */\nfunction jwkToBuffer(jwk, opts) {\n\tif ('object' !== typeof jwk || null === jwk) {\n\t\tthrow new TypeError('Expected \"jwk\" to be an Object');\n\t}\n\n\tvar kty = jwk.kty;\n\tif ('string' !== typeof kty) {\n\t\tthrow new TypeError('Expected \"jwk.kty\" to be a String');\n\t}\n\n\topts = opts || {};\n\topts.private = opts.private === true;\n\n\tswitch (kty) {\n\t\tcase 'EC': {\n\t\t\treturn ec(jwk, opts);\n\t\t}\n\t\tcase 'RSA': {\n\t\t\treturn rsa(jwk, opts);\n\t\t}\n\t\tdefault: {\n\t\t\tthrow new Error('Unsupported key type \"' + kty + '\"');\n\t\t}\n\t}\n}\n\nmodule.exports = jwkToBuffer;\n",
    "// @ts-self-types=\"./defs.d.ts\"\n\n'use strict';\n\nconst none = Symbol.for('object-stream.none');\nconst stop = Symbol.for('object-stream.stop');\n\nconst finalSymbol = Symbol.for('object-stream.final');\nconst manySymbol = Symbol.for('object-stream.many');\nconst flushSymbol = Symbol.for('object-stream.flush');\nconst fListSymbol = Symbol.for('object-stream.fList');\n\nconst finalValue = value => ({[finalSymbol]: 1, value});\nconst many = values => ({[manySymbol]: 1, values});\n\nconst isFinalValue = o => o && o[finalSymbol] === 1;\nconst isMany = o => o && o[manySymbol] === 1;\nconst isFlushable = o => o && o[flushSymbol] === 1;\nconst isFunctionList = o => o && o[fListSymbol] === 1;\n\nconst getFinalValue = o => o.value;\nconst getManyValues = o => o.values;\nconst getFunctionList = o => o.fList;\n\nconst flushable = (write, final = null) => {\n  const fn = final ? value => (value === none ? final() : write(value)) : write;\n  fn[flushSymbol] = 1;\n  return fn;\n};\n\nconst setFunctionList = (o, fns) => {\n  o.fList = fns;\n  o[fListSymbol] = 1;\n  return o;\n};\n\nconst clearFunctionList = o => {\n  delete o.fList;\n  delete o[fListSymbol];\n  return o;\n};\n\nclass Stop extends Error {}\n\nconst toMany = value =>\n  value === none ? many([]) : value && value[manySymbol] === 1 ? value : many([value]);\n\nconst normalizeMany = o => {\n  if (o?.[manySymbol] === 1) {\n    switch (o.values.length) {\n      case 0:\n        return none;\n      case 1:\n        return o.values[0];\n    }\n  }\n  return o;\n};\n\nconst combineMany = (a, b) => {\n  const values = a === none ? [] : a?.[manySymbol] === 1 ? a.values.slice() : [a];\n  if (b === none) {\n    // do nothing\n  } else if (b?.[manySymbol] === 1) {\n    values.push(...b.values);\n  } else {\n    values.push(b);\n  }\n  return many(values);\n};\n\nconst combineManyMut = (a, b) => {\n  const values = a === none ? [] : a?.[manySymbol] === 1 ? a.values : [a];\n  if (b === none) {\n    // do nothing\n  } else if (b?.[manySymbol] === 1) {\n    values.push(...b.values);\n  } else {\n    values.push(b);\n  }\n  return many(values);\n};\n\n// old aliases\nconst final = finalValue;\n\nmodule.exports.none = none;\nmodule.exports.stop = stop;\nmodule.exports.Stop = Stop;\n\nmodule.exports.finalSymbol = finalSymbol;\nmodule.exports.finalValue = finalValue;\nmodule.exports.final = final;\nmodule.exports.isFinalValue = isFinalValue;\nmodule.exports.getFinalValue = getFinalValue;\n\nmodule.exports.manySymbol = manySymbol;\nmodule.exports.many = many;\nmodule.exports.isMany = isMany;\nmodule.exports.getManyValues = getManyValues;\nmodule.exports.getFunctionList = getFunctionList;\n\nmodule.exports.flushSymbol = flushSymbol;\nmodule.exports.flushable = flushable;\nmodule.exports.isFlushable = isFlushable;\n\nmodule.exports.fListSymbol = fListSymbol;\nmodule.exports.isFunctionList = isFunctionList;\nmodule.exports.getFunctionList = getFunctionList;\nmodule.exports.setFunctionList = setFunctionList;\nmodule.exports.clearFunctionList = clearFunctionList;\n\nmodule.exports.toMany = toMany;\nmodule.exports.normalizeMany = normalizeMany;\nmodule.exports.combineMany = combineMany;\nmodule.exports.combineManyMut = combineManyMut;\n",
    "// @ts-self-types=\"./gen.d.ts\"\n\n'use strict';\n\nconst defs = require('./defs');\n\nconst next = async function* (value, fns, index) {\n  for (let i = index; i <= fns.length; ++i) {\n    if (value && typeof value.then == 'function') {\n      // thenable\n      value = await value;\n    }\n    if (value === defs.none) break;\n    if (value === defs.stop) throw new defs.Stop();\n    if (defs.isFinalValue(value)) {\n      yield defs.getFinalValue(value);\n      break;\n    }\n    if (defs.isMany(value)) {\n      const values = defs.getManyValues(value);\n      if (i == fns.length) {\n        yield* values;\n      } else {\n        for (let j = 0; j < values.length; ++j) {\n          yield* next(values[j], fns, i);\n        }\n      }\n      break;\n    }\n    if (value && typeof value.next == 'function') {\n      // generator\n      for (;;) {\n        let data = value.next();\n        if (data && typeof data.then == 'function') {\n          data = await data;\n        }\n        if (data.done) break;\n        if (i == fns.length) {\n          yield data.value;\n        } else {\n          yield* next(data.value, fns, i);\n        }\n      }\n      break;\n    }\n    if (i == fns.length) {\n      yield value;\n      break;\n    }\n    const f = fns[i];\n    value = f(value);\n  }\n};\n\nconst gen = (...fns) => {\n  fns = fns\n    .filter(fn => fn)\n    .flat(Infinity)\n    .map(fn => (defs.isFunctionList(fn) ? defs.getFunctionList(fn) : fn))\n    .flat(Infinity);\n  if (!fns.length) {\n    fns = [x => x];\n  }\n  let flushed = false;\n  let g = async function* (value) {\n    if (flushed) throw Error('Call to a flushed pipe.');\n    if (value !== defs.none) {\n      yield* next(value, fns, 0);\n    } else {\n      flushed = true;\n      for (let i = 0; i < fns.length; ++i) {\n        const f = fns[i];\n        if (defs.isFlushable(f)) {\n          yield* next(f(defs.none), fns, i + 1);\n        }\n      }\n    }\n  };\n  const needToFlush = fns.some(fn => defs.isFlushable(fn));\n  if (needToFlush) g = defs.flushable(g);\n  return defs.setFunctionList(g, fns);\n};\n\nmodule.exports = gen;\n\nmodule.exports.next = next;\n",
    "// @ts-self-types=\"./asStream.d.ts\"\n\n'use strict';\n\nconst {Duplex} = require('node:stream');\nconst defs = require('./defs');\n\nconst asStream = (fn, options) => {\n  if (typeof fn != 'function')\n    throw TypeError(\n      'Only a function is accepted as the first argument'\n    );\n\n  // pump variables\n  let paused = Promise.resolve(),\n    resolvePaused = null;\n  const queue = [];\n\n  // pause/resume\n  const resume = () => {\n    if (!resolvePaused) return;\n    resolvePaused();\n    resolvePaused = null;\n    paused = Promise.resolve();\n  };\n  const pause = () => {\n    if (resolvePaused) return;\n    paused = new Promise(resolve => (resolvePaused = resolve));\n  };\n\n  let stream = null; // will be assigned later\n\n  // data processing\n  const pushResults = values => {\n    if (values && typeof values.next == 'function') {\n      // generator\n      queue.push(values);\n      return;\n    }\n    // array\n    queue.push(values[Symbol.iterator]());\n  };\n  const pump = async () => {\n    while (queue.length) {\n      await paused;\n      const gen = queue[queue.length - 1];\n      let result = gen.next();\n      if (result && typeof result.then == 'function') {\n        result = await result;\n      }\n      if (result.done) {\n        queue.pop();\n        continue;\n      }\n      let value = result.value;\n      if (value && typeof value.then == 'function') {\n        value = await value;\n      }\n      await sanitize(value);\n    }\n  };\n  const sanitize = async value => {\n    if (value === undefined || value === null || value === defs.none) return;\n    if (value === defs.stop) throw new defs.Stop();\n\n    if (defs.isMany(value)) {\n      pushResults(defs.getManyValues(value));\n      return pump();\n    }\n\n    if (defs.isFinalValue(value)) {\n      // a final value is not supported, it is treated as a regular value\n      value = defs.getFinalValue(value);\n      return processValue(value);\n    }\n\n    if (!stream.push(value)) {\n      pause();\n    }\n  };\n  const processChunk = async (chunk, encoding) => {\n    try {\n      const value = fn(chunk, encoding);\n      await processValue(value);\n    } catch (error) {\n      if (error instanceof defs.Stop) {\n        stream.push(null);\n        stream.destroy();\n        return;\n      }\n      throw error;\n    }\n  };\n  const processValue = async value => {\n    if (value && typeof value.then == 'function') {\n      // thenable\n      return value.then(value => processValue(value));\n    }\n    if (value && typeof value.next == 'function') {\n      // generator\n      pushResults(value);\n      return pump();\n    }\n    return sanitize(value);\n  };\n\n  stream = new Duplex(\n    Object.assign({writableObjectMode: true, readableObjectMode: true}, options, {\n      write(chunk, encoding, callback) {\n        processChunk(chunk, encoding).then(\n          () => callback(null),\n          error => callback(error)\n        );\n      },\n      final(callback) {\n        if (!defs.isFlushable(fn)) {\n          stream.push(null);\n          callback(null);\n          return;\n        }\n        processChunk(defs.none, null).then(\n          () => (stream.push(null), callback(null)),\n          error => callback(error)\n        );\n      },\n      read() {\n        resume();\n      }\n    })\n  );\n\n  return stream;\n};\n\nmodule.exports = asStream;\n",
    "// @ts-self-types=\"./index.d.ts\"\n\n'use strict';\n\nconst {Readable, Writable, Duplex} = require('node:stream');\nconst defs = require('./defs');\nconst gen = require('./gen');\nconst asStream = require('./asStream');\n\n// is*NodeStream functions taken from https://github.com/nodejs/node/blob/master/lib/internal/streams/utils.js\nconst isReadableNodeStream = obj =>\n  obj &&\n  typeof obj.pipe === 'function' &&\n  typeof obj.on === 'function' &&\n  (!obj._writableState ||\n    (typeof obj._readableState === 'object' ? obj._readableState.readable : null) !== false) && // Duplex\n  (!obj._writableState || obj._readableState); // Writable has .pipe.\n\nconst isWritableNodeStream = obj =>\n  obj &&\n  typeof obj.write === 'function' &&\n  typeof obj.on === 'function' &&\n  (!obj._readableState ||\n    (typeof obj._writableState === 'object' ? obj._writableState.writable : null) !== false); // Duplex\n\nconst isDuplexNodeStream = obj =>\n  obj &&\n  typeof obj.pipe === 'function' &&\n  obj._readableState &&\n  typeof obj.on === 'function' &&\n  typeof obj.write === 'function';\n\nconst isReadableWebStream = obj =>\n  obj && globalThis.ReadableStream && obj instanceof globalThis.ReadableStream;\n\nconst isWritableWebStream = obj =>\n  obj && globalThis.WritableStream && obj instanceof globalThis.WritableStream;\n\nconst isDuplexWebStream = obj =>\n  obj &&\n  globalThis.ReadableStream &&\n  obj.readable instanceof globalThis.ReadableStream &&\n  globalThis.WritableStream &&\n  obj.writable instanceof globalThis.WritableStream;\n\nconst groupFunctions = (output, fn, index, fns) => {\n  if (\n    isDuplexNodeStream(fn) ||\n    (!index && isReadableNodeStream(fn)) ||\n    (index === fns.length - 1 && isWritableNodeStream(fn))\n  ) {\n    output.push(fn);\n    return output;\n  }\n  if (isDuplexWebStream(fn)) {\n    output.push(Duplex.fromWeb(fn, {objectMode: true}));\n    return output;\n  }\n  if (!index && isReadableWebStream(fn)) {\n    output.push(Readable.fromWeb(fn, {objectMode: true}));\n    return output;\n  }\n  if (index === fns.length - 1 && isWritableWebStream(fn)) {\n    output.push(Writable.fromWeb(fn, {objectMode: true}));\n    return output;\n  }\n  if (typeof fn != 'function')\n    throw TypeError('Item #' + index + ' is not a proper stream, nor a function.');\n  if (!output.length) output.push([]);\n  const last = output[output.length - 1];\n  if (Array.isArray(last)) {\n    last.push(fn);\n  } else {\n    output.push([fn]);\n  }\n  return output;\n};\n\nconst produceStreams = item => {\n  if (Array.isArray(item)) {\n    if (!item.length) return null;\n    if (item.length == 1) return item[0] && chain.asStream(item[0]);\n    return chain.asStream(chain.gen(...item));\n  }\n  return item;\n};\n\nconst wrapFunctions = (fn, index, fns) => {\n  if (\n    isDuplexNodeStream(fn) ||\n    (!index && isReadableNodeStream(fn)) ||\n    (index === fns.length - 1 && isWritableNodeStream(fn))\n  ) {\n    return fn; // an acceptable stream\n  }\n  if (isDuplexWebStream(fn)) {\n    return Duplex.fromWeb(fn, {objectMode: true});\n  }\n  if (!index && isReadableWebStream(fn)) {\n    return Readable.fromWeb(fn, {objectMode: true});\n  }\n  if (index === fns.length - 1 && isWritableWebStream(fn)) {\n    return Writable.fromWeb(fn, {objectMode: true});\n  }\n  if (typeof fn == 'function') return chain.asStream(fn); // a function\n  throw TypeError('Item #' + index + ' is not a proper stream, nor a function.');\n};\n\n// default implementation of required stream methods\n\nconst write = (input, chunk, encoding, callback) => {\n  let error = null;\n  try {\n    input.write(chunk, encoding, e => callback(e || error));\n  } catch (e) {\n    error = e;\n  }\n};\n\nconst final = (input, callback) => {\n  let error = null;\n  try {\n    input.end(null, null, e => callback(e || error));\n  } catch (e) {\n    error = e;\n  }\n};\n\nconst read = output => {\n  output.resume();\n};\n\n// the chain creator\n\nconst chain = (fns, options) => {\n  if (!Array.isArray(fns) || !fns.length) {\n    throw TypeError(\"Chain's first argument should be a non-empty array.\");\n  }\n\n  fns = fns.flat(Infinity).filter(fn => fn);\n\n  const streams = (\n      options && options.noGrouping\n        ? fns.map(wrapFunctions)\n        : fns\n            .map(fn => (defs.isFunctionList(fn) ? defs.getFunctionList(fn) : fn))\n            .flat(Infinity)\n            .reduce(groupFunctions, [])\n            .map(produceStreams)\n    ).filter(s => s),\n    input = streams[0],\n    output = streams.reduce((output, item) => (output && output.pipe(item)) || item);\n\n  let stream = null; // will be assigned later\n\n  let writeMethod = (chunk, encoding, callback) => write(input, chunk, encoding, callback),\n    finalMethod = callback => final(input, callback),\n    readMethod = () => read(output);\n\n  if (!isWritableNodeStream(input)) {\n    writeMethod = (_1, _2, callback) => callback(null);\n    finalMethod = callback => callback(null);\n    input.on('end', () => stream.end());\n  }\n\n  if (isReadableNodeStream(output)) {\n    output.on('data', chunk => !stream.push(chunk) && output.pause());\n    output.on('end', () => stream.push(null));\n  } else {\n    readMethod = () => {}; // nop\n    output.on('finish', () => stream.push(null));\n  }\n\n  stream = new Duplex(\n    Object.assign({writableObjectMode: true, readableObjectMode: true}, options, {\n      readable: isReadableNodeStream(output),\n      writable: isWritableNodeStream(input),\n      write: writeMethod,\n      final: finalMethod,\n      read: readMethod\n    })\n  );\n  stream.streams = streams;\n  stream.input = input;\n  stream.output = output;\n\n  if (!isReadableNodeStream(output)) {\n    stream.resume();\n  }\n\n  // connect events\n  if (!options || !options.skipEvents) {\n    streams.forEach(item => item.on('error', error => stream.emit('error', error)));\n  }\n\n  return stream;\n};\n\nconst dataSource = fn => {\n  if (typeof fn == 'function') return fn;\n  if (fn) {\n    if (typeof fn[Symbol.asyncIterator] == 'function') return fn[Symbol.asyncIterator].bind(fn);\n    if (typeof fn[Symbol.iterator] == 'function') return fn[Symbol.iterator].bind(fn);\n  }\n  throw new TypeError('The argument should be a function or an iterable object.');\n};\n\nmodule.exports = chain;\n\n// from defs.js\nmodule.exports.none = defs.none;\nmodule.exports.stop = defs.stop;\nmodule.exports.Stop = defs.Stop;\n\nmodule.exports.finalSymbol = defs.finalSymbol;\nmodule.exports.finalValue = defs.finalValue;\nmodule.exports.final = defs.final;\nmodule.exports.isFinalValue = defs.isFinalValue;\nmodule.exports.getFinalValue = defs.getFinalValue;\n\nmodule.exports.manySymbol = defs.manySymbol;\nmodule.exports.many = defs.many;\nmodule.exports.isMany = defs.isMany;\nmodule.exports.getManyValues = defs.getManyValues;\nmodule.exports.getFunctionList = defs.getFunctionList;\n\nmodule.exports.flushSymbol = defs.flushSymbol;\nmodule.exports.flushable = defs.flushable;\nmodule.exports.isFlushable = defs.isFlushable;\n\nmodule.exports.fListSymbol = defs.fListSymbol;\nmodule.exports.isFunctionList = defs.isFunctionList;\nmodule.exports.getFunctionList = defs.getFunctionList;\nmodule.exports.setFunctionList = defs.setFunctionList;\nmodule.exports.clearFunctionList = defs.clearFunctionList;\n\nmodule.exports.toMany = defs.toMany;\nmodule.exports.normalizeMany = defs.normalizeMany;\nmodule.exports.combineMany = defs.combineMany;\nmodule.exports.combineManyMut = defs.combineManyMut;\n\nmodule.exports.chain = chain;          // for compatibility with 2.x\nmodule.exports.chainUnchecked = chain; // for TypeScript to bypass type checks\nmodule.exports.gen = gen;\nmodule.exports.asStream = asStream;\n\nmodule.exports.dataSource = dataSource;\n",
    "'use strict';\n\nconst {Transform} = require('stream');\nconst {StringDecoder} = require('string_decoder');\n\nclass Utf8Stream extends Transform {\n  constructor(options) {\n    super(Object.assign({}, options, {writableObjectMode: false}));\n    this._buffer = '';\n  }\n\n  _transform(chunk, encoding, callback) {\n    if (typeof chunk == 'string') {\n      this._transform = this._transformString;\n    } else {\n      this._stringDecoder = new StringDecoder();\n      this._transform = this._transformBuffer;\n    }\n    this._transform(chunk, encoding, callback);\n  }\n\n  _transformBuffer(chunk, _, callback) {\n    this._buffer += this._stringDecoder.write(chunk);\n    this._processBuffer(callback);\n  }\n\n  _transformString(chunk, _, callback) {\n    this._buffer += chunk.toString();\n    this._processBuffer(callback);\n  }\n\n  _processBuffer(callback) {\n    if (this._buffer) {\n      this.push(this._buffer, 'utf8');\n      this._buffer = '';\n    }\n    callback(null);\n  }\n\n  _flushInput() {\n    // meant to be called from _flush()\n    if (this._stringDecoder) {\n      this._buffer += this._stringDecoder.end();\n    }\n  }\n\n  _flush(callback) {\n    this._flushInput();\n    this._processBuffer(callback);\n  }\n}\n\nmodule.exports = Utf8Stream;\n",
    "'use strict';\n\nconst Utf8Stream = require('./utils/Utf8Stream');\n\nconst patterns = {\n  value1: /^(?:[\\\"\\{\\[\\]\\-\\d]|true\\b|false\\b|null\\b|\\s{1,256})/,\n  string: /^(?:[^\\x00-\\x1f\\\"\\\\]{1,256}|\\\\[bfnrt\\\"\\\\\\/]|\\\\u[\\da-fA-F]{4}|\\\")/,\n  key1: /^(?:[\\\"\\}]|\\s{1,256})/,\n  colon: /^(?:\\:|\\s{1,256})/,\n  comma: /^(?:[\\,\\]\\}]|\\s{1,256})/,\n  ws: /^\\s{1,256}/,\n  numberStart: /^\\d/,\n  numberDigit: /^\\d{0,256}/,\n  numberFraction: /^[\\.eE]/,\n  numberExponent: /^[eE]/,\n  numberExpSign: /^[-+]/\n};\nconst MAX_PATTERN_SIZE = 16;\n\nlet noSticky = true;\ntry {\n  new RegExp('.', 'y');\n  noSticky = false;\n} catch (e) {\n  // suppress\n}\n\n!noSticky &&\n  Object.keys(patterns).forEach(key => {\n    let src = patterns[key].source.slice(1); // lop off ^\n    if (src.slice(0, 3) === '(?:' && src.slice(-1) === ')') {\n      src = src.slice(3, -1);\n    }\n    patterns[key] = new RegExp(src, 'y');\n  });\n\npatterns.numberFracStart = patterns.numberExpStart = patterns.numberStart;\npatterns.numberFracDigit = patterns.numberExpDigit = patterns.numberDigit;\n\nconst values = {true: true, false: false, null: null},\n  expected = {object: 'objectStop', array: 'arrayStop', '': 'done'};\n\n// long hexadecimal codes: \\uXXXX\nconst fromHex = s => String.fromCharCode(parseInt(s.slice(2), 16));\n\n// short codes: \\b \\f \\n \\r \\t \\\" \\\\ \\/\nconst codes = {b: '\\b', f: '\\f', n: '\\n', r: '\\r', t: '\\t', '\"': '\"', '\\\\': '\\\\', '/': '/'};\n\nclass Parser extends Utf8Stream {\n  static make(options) {\n    return new Parser(options);\n  }\n\n  constructor(options) {\n    super(Object.assign({}, options, {readableObjectMode: true}));\n\n    this._packKeys = this._packStrings = this._packNumbers = this._streamKeys = this._streamStrings = this._streamNumbers = true;\n    if (options) {\n      'packValues' in options && (this._packKeys = this._packStrings = this._packNumbers = options.packValues);\n      'packKeys' in options && (this._packKeys = options.packKeys);\n      'packStrings' in options && (this._packStrings = options.packStrings);\n      'packNumbers' in options && (this._packNumbers = options.packNumbers);\n      'streamValues' in options && (this._streamKeys = this._streamStrings = this._streamNumbers = options.streamValues);\n      'streamKeys' in options && (this._streamKeys = options.streamKeys);\n      'streamStrings' in options && (this._streamStrings = options.streamStrings);\n      'streamNumbers' in options && (this._streamNumbers = options.streamNumbers);\n      this._jsonStreaming = options.jsonStreaming;\n    }\n    !this._packKeys && (this._streamKeys = true);\n    !this._packStrings && (this._streamStrings = true);\n    !this._packNumbers && (this._streamNumbers = true);\n\n    this._done = false;\n    this._expect = this._jsonStreaming ? 'done' : 'value';\n    this._stack = [];\n    this._parent = '';\n    this._open_number = false;\n    this._accumulator = '';\n  }\n\n  _flush(callback) {\n    this._done = true;\n    super._flush(error => {\n      if (error) return callback(error);\n      if (this._open_number) {\n        if (this._streamNumbers) {\n          this.push({name: 'endNumber'});\n        }\n        this._open_number = false;\n        if (this._packNumbers) {\n          this.push({name: 'numberValue', value: this._accumulator});\n          this._accumulator = '';\n        }\n      }\n      callback(null);\n    });\n  }\n\n  _processBuffer(callback) {\n    let match,\n      value,\n      index = 0;\n    main: for (;;) {\n      switch (this._expect) {\n        case 'value1':\n        case 'value':\n          patterns.value1.lastIndex = index;\n          match = patterns.value1.exec(this._buffer);\n          if (!match) {\n            if (this._done || index + MAX_PATTERN_SIZE < this._buffer.length) {\n              if (index < this._buffer.length) return callback(new Error('Parser cannot parse input: expected a value'));\n              return callback(new Error('Parser has expected a value'));\n            }\n            break main; // wait for more input\n          }\n          value = match[0];\n          switch (value) {\n            case '\"':\n              this._streamStrings && this.push({name: 'startString'});\n              this._expect = 'string';\n              break;\n            case '{':\n              this.push({name: 'startObject'});\n              this._stack.push(this._parent);\n              this._parent = 'object';\n              this._expect = 'key1';\n              break;\n            case '[':\n              this.push({name: 'startArray'});\n              this._stack.push(this._parent);\n              this._parent = 'array';\n              this._expect = 'value1';\n              break;\n            case ']':\n              if (this._expect !== 'value1') return callback(new Error(\"Parser cannot parse input: unexpected token ']'\"));\n              if (this._open_number) {\n                this._streamNumbers && this.push({name: 'endNumber'});\n                this._open_number = false;\n                if (this._packNumbers) {\n                  this.push({name: 'numberValue', value: this._accumulator});\n                  this._accumulator = '';\n                }\n              }\n              this.push({name: 'endArray'});\n              this._parent = this._stack.pop();\n              this._expect = expected[this._parent];\n              break;\n            case '-':\n              this._open_number = true;\n              if (this._streamNumbers) {\n                this.push({name: 'startNumber'});\n                this.push({name: 'numberChunk', value: '-'});\n              }\n              this._packNumbers && (this._accumulator = '-');\n              this._expect = 'numberStart';\n              break;\n            case '0':\n              this._open_number = true;\n              if (this._streamNumbers) {\n                this.push({name: 'startNumber'});\n                this.push({name: 'numberChunk', value: '0'});\n              }\n              this._packNumbers && (this._accumulator = '0');\n              this._expect = 'numberFraction';\n              break;\n            case '1':\n            case '2':\n            case '3':\n            case '4':\n            case '5':\n            case '6':\n            case '7':\n            case '8':\n            case '9':\n              this._open_number = true;\n              if (this._streamNumbers) {\n                this.push({name: 'startNumber'});\n                this.push({name: 'numberChunk', value: value});\n              }\n              this._packNumbers && (this._accumulator = value);\n              this._expect = 'numberDigit';\n              break;\n            case 'true':\n            case 'false':\n            case 'null':\n              if (this._buffer.length - index === value.length && !this._done) break main; // wait for more input\n              this.push({name: value + 'Value', value: values[value]});\n              this._expect = expected[this._parent];\n              break;\n            // default: // ws\n          }\n          if (noSticky) {\n            this._buffer = this._buffer.slice(value.length);\n          } else {\n            index += value.length;\n          }\n          break;\n        case 'keyVal':\n        case 'string':\n          patterns.string.lastIndex = index;\n          match = patterns.string.exec(this._buffer);\n          if (!match) {\n            if (index < this._buffer.length && (this._done || this._buffer.length - index >= 6))\n              return callback(new Error('Parser cannot parse input: escaped characters'));\n            if (this._done) return callback(new Error('Parser has expected a string value'));\n            break main; // wait for more input\n          }\n          value = match[0];\n          if (value === '\"') {\n            if (this._expect === 'keyVal') {\n              this._streamKeys && this.push({name: 'endKey'});\n              if (this._packKeys) {\n                this.push({name: 'keyValue', value: this._accumulator});\n                this._accumulator = '';\n              }\n              this._expect = 'colon';\n            } else {\n              this._streamStrings && this.push({name: 'endString'});\n              if (this._packStrings) {\n                this.push({name: 'stringValue', value: this._accumulator});\n                this._accumulator = '';\n              }\n              this._expect = expected[this._parent];\n            }\n          } else if (value.length > 1 && value.charAt(0) === '\\\\') {\n            const t = value.length == 2 ? codes[value.charAt(1)] : fromHex(value);\n            if (this._expect === 'keyVal' ? this._streamKeys : this._streamStrings) {\n              this.push({name: 'stringChunk', value: t});\n            }\n            if (this._expect === 'keyVal' ? this._packKeys : this._packStrings) {\n              this._accumulator += t;\n            }\n          } else {\n            if (this._expect === 'keyVal' ? this._streamKeys : this._streamStrings) {\n              this.push({name: 'stringChunk', value: value});\n            }\n            if (this._expect === 'keyVal' ? this._packKeys : this._packStrings) {\n              this._accumulator += value;\n            }\n          }\n          if (noSticky) {\n            this._buffer = this._buffer.slice(value.length);\n          } else {\n            index += value.length;\n          }\n          break;\n        case 'key1':\n        case 'key':\n          patterns.key1.lastIndex = index;\n          match = patterns.key1.exec(this._buffer);\n          if (!match) {\n            if (index < this._buffer.length || this._done) return callback(new Error('Parser cannot parse input: expected an object key'));\n            break main; // wait for more input\n          }\n          value = match[0];\n          if (value === '\"') {\n            this._streamKeys && this.push({name: 'startKey'});\n            this._expect = 'keyVal';\n          } else if (value === '}') {\n            if (this._expect !== 'key1') return callback(new Error(\"Parser cannot parse input: unexpected token '}'\"));\n            this.push({name: 'endObject'});\n            this._parent = this._stack.pop();\n            this._expect = expected[this._parent];\n          }\n          if (noSticky) {\n            this._buffer = this._buffer.slice(value.length);\n          } else {\n            index += value.length;\n          }\n          break;\n        case 'colon':\n          patterns.colon.lastIndex = index;\n          match = patterns.colon.exec(this._buffer);\n          if (!match) {\n            if (index < this._buffer.length || this._done) return callback(new Error(\"Parser cannot parse input: expected ':'\"));\n            break main; // wait for more input\n          }\n          value = match[0];\n          value === ':' && (this._expect = 'value');\n          if (noSticky) {\n            this._buffer = this._buffer.slice(value.length);\n          } else {\n            index += value.length;\n          }\n          break;\n        case 'arrayStop':\n        case 'objectStop':\n          patterns.comma.lastIndex = index;\n          match = patterns.comma.exec(this._buffer);\n          if (!match) {\n            if (index < this._buffer.length || this._done) return callback(new Error(\"Parser cannot parse input: expected ','\"));\n            break main; // wait for more input\n          }\n          if (this._open_number) {\n            this._streamNumbers && this.push({name: 'endNumber'});\n            this._open_number = false;\n            if (this._packNumbers) {\n              this.push({name: 'numberValue', value: this._accumulator});\n              this._accumulator = '';\n            }\n          }\n          value = match[0];\n          if (value === ',') {\n            this._expect = this._expect === 'arrayStop' ? 'value' : 'key';\n          } else if (value === '}' || value === ']') {\n            if (value === '}' ? this._expect === 'arrayStop' : this._expect !== 'arrayStop') {\n              return callback(new Error(\"Parser cannot parse input: expected '\" + (this._expect === 'arrayStop' ? ']' : '}') + \"'\"));\n            }\n            this.push({name: value === '}' ? 'endObject' : 'endArray'});\n            this._parent = this._stack.pop();\n            this._expect = expected[this._parent];\n          }\n          if (noSticky) {\n            this._buffer = this._buffer.slice(value.length);\n          } else {\n            index += value.length;\n          }\n          break;\n        // number chunks\n        case 'numberStart': // [0-9]\n          patterns.numberStart.lastIndex = index;\n          match = patterns.numberStart.exec(this._buffer);\n          if (!match) {\n            if (index < this._buffer.length || this._done) return callback(new Error('Parser cannot parse input: expected a starting digit'));\n            break main; // wait for more input\n          }\n          value = match[0];\n          this._streamNumbers && this.push({name: 'numberChunk', value: value});\n          this._packNumbers && (this._accumulator += value);\n          this._expect = value === '0' ? 'numberFraction' : 'numberDigit';\n          if (noSticky) {\n            this._buffer = this._buffer.slice(value.length);\n          } else {\n            index += value.length;\n          }\n          break;\n        case 'numberDigit': // [0-9]*\n          patterns.numberDigit.lastIndex = index;\n          match = patterns.numberDigit.exec(this._buffer);\n          if (!match) {\n            if (index < this._buffer.length || this._done) return callback(new Error('Parser cannot parse input: expected a digit'));\n            break main; // wait for more input\n          }\n          value = match[0];\n          if (value) {\n            this._streamNumbers && this.push({name: 'numberChunk', value: value});\n            this._packNumbers && (this._accumulator += value);\n            if (noSticky) {\n              this._buffer = this._buffer.slice(value.length);\n            } else {\n              index += value.length;\n            }\n          } else {\n            if (index < this._buffer.length) {\n              this._expect = 'numberFraction';\n              break;\n            }\n            if (this._done) {\n              this._expect = expected[this._parent];\n              break;\n            }\n            break main; // wait for more input\n          }\n          break;\n        case 'numberFraction': // [\\.eE]?\n          patterns.numberFraction.lastIndex = index;\n          match = patterns.numberFraction.exec(this._buffer);\n          if (!match) {\n            if (index < this._buffer.length || this._done) {\n              this._expect = expected[this._parent];\n              break;\n            }\n            break main; // wait for more input\n          }\n          value = match[0];\n          this._streamNumbers && this.push({name: 'numberChunk', value: value});\n          this._packNumbers && (this._accumulator += value);\n          this._expect = value === '.' ? 'numberFracStart' : 'numberExpSign';\n          if (noSticky) {\n            this._buffer = this._buffer.slice(value.length);\n          } else {\n            index += value.length;\n          }\n          break;\n        case 'numberFracStart': // [0-9]\n          patterns.numberFracStart.lastIndex = index;\n          match = patterns.numberFracStart.exec(this._buffer);\n          if (!match) {\n            if (index < this._buffer.length || this._done) return callback(new Error('Parser cannot parse input: expected a fractional part of a number'));\n            break main; // wait for more input\n          }\n          value = match[0];\n          this._streamNumbers && this.push({name: 'numberChunk', value: value});\n          this._packNumbers && (this._accumulator += value);\n          this._expect = 'numberFracDigit';\n          if (noSticky) {\n            this._buffer = this._buffer.slice(value.length);\n          } else {\n            index += value.length;\n          }\n          break;\n        case 'numberFracDigit': // [0-9]*\n          patterns.numberFracDigit.lastIndex = index;\n          match = patterns.numberFracDigit.exec(this._buffer);\n          value = match[0];\n          if (value) {\n            this._streamNumbers && this.push({name: 'numberChunk', value: value});\n            this._packNumbers && (this._accumulator += value);\n            if (noSticky) {\n              this._buffer = this._buffer.slice(value.length);\n            } else {\n              index += value.length;\n            }\n          } else {\n            if (index < this._buffer.length) {\n              this._expect = 'numberExponent';\n              break;\n            }\n            if (this._done) {\n              this._expect = expected[this._parent];\n              break;\n            }\n            break main; // wait for more input\n          }\n          break;\n        case 'numberExponent': // [eE]?\n          patterns.numberExponent.lastIndex = index;\n          match = patterns.numberExponent.exec(this._buffer);\n          if (!match) {\n            if (index < this._buffer.length) {\n              this._expect = expected[this._parent];\n              break;\n            }\n            if (this._done) {\n              this._expect = 'done';\n              break;\n            }\n            break main; // wait for more input\n          }\n          value = match[0];\n          this._streamNumbers && this.push({name: 'numberChunk', value: value});\n          this._packNumbers && (this._accumulator += value);\n          this._expect = 'numberExpSign';\n          if (noSticky) {\n            this._buffer = this._buffer.slice(value.length);\n          } else {\n            index += value.length;\n          }\n          break;\n        case 'numberExpSign': // [-+]?\n          patterns.numberExpSign.lastIndex = index;\n          match = patterns.numberExpSign.exec(this._buffer);\n          if (!match) {\n            if (index < this._buffer.length) {\n              this._expect = 'numberExpStart';\n              break;\n            }\n            if (this._done) return callback(new Error('Parser has expected an exponent value of a number'));\n            break main; // wait for more input\n          }\n          value = match[0];\n          this._streamNumbers && this.push({name: 'numberChunk', value: value});\n          this._packNumbers && (this._accumulator += value);\n          this._expect = 'numberExpStart';\n          if (noSticky) {\n            this._buffer = this._buffer.slice(value.length);\n          } else {\n            index += value.length;\n          }\n          break;\n        case 'numberExpStart': // [0-9]\n          patterns.numberExpStart.lastIndex = index;\n          match = patterns.numberExpStart.exec(this._buffer);\n          if (!match) {\n            if (index < this._buffer.length || this._done) return callback(new Error('Parser cannot parse input: expected an exponent part of a number'));\n            break main; // wait for more input\n          }\n          value = match[0];\n          this._streamNumbers && this.push({name: 'numberChunk', value: value});\n          this._packNumbers && (this._accumulator += value);\n          this._expect = 'numberExpDigit';\n          if (noSticky) {\n            this._buffer = this._buffer.slice(value.length);\n          } else {\n            index += value.length;\n          }\n          break;\n        case 'numberExpDigit': // [0-9]*\n          patterns.numberExpDigit.lastIndex = index;\n          match = patterns.numberExpDigit.exec(this._buffer);\n          value = match[0];\n          if (value) {\n            this._streamNumbers && this.push({name: 'numberChunk', value: value});\n            this._packNumbers && (this._accumulator += value);\n            if (noSticky) {\n              this._buffer = this._buffer.slice(value.length);\n            } else {\n              index += value.length;\n            }\n          } else {\n            if (index < this._buffer.length || this._done) {\n              this._expect = expected[this._parent];\n              break;\n            }\n            break main; // wait for more input\n          }\n          break;\n        case 'done':\n          patterns.ws.lastIndex = index;\n          match = patterns.ws.exec(this._buffer);\n          if (!match) {\n            if (index < this._buffer.length) {\n              if (this._jsonStreaming) {\n                this._expect = 'value';\n                break;\n              }\n              return callback(new Error('Parser cannot parse input: unexpected characters'));\n            }\n            break main; // wait for more input\n          }\n          value = match[0];\n          if (this._open_number) {\n            this._streamNumbers && this.push({name: 'endNumber'});\n            this._open_number = false;\n            if (this._packNumbers) {\n              this.push({name: 'numberValue', value: this._accumulator});\n              this._accumulator = '';\n            }\n          }\n          if (noSticky) {\n            this._buffer = this._buffer.slice(value.length);\n          } else {\n            index += value.length;\n          }\n          break;\n      }\n    }\n    !noSticky && (this._buffer = this._buffer.slice(index));\n    callback(null);\n  }\n}\nParser.parser = Parser.make;\nParser.make.Constructor = Parser;\n\nmodule.exports = Parser;\n",
    "'use strict';\n\nconst emit = stream => stream.on('data', item => stream.emit(item.name, item.value));\n\nmodule.exports = emit;\n",
    "'use strict';\n\nconst Parser = require('./Parser');\nconst emit = require('./utils/emit');\n\nconst make = options => emit(new Parser(options));\n\nmake.Parser = Parser;\nmake.parser = Parser.parser;\n\nmodule.exports = make;\n",
    "'use strict';\n\nconst EventEmitter = require('events');\n\nconst startObject = Ctr =>\n  function () {\n    if (this.done) {\n      this.done = false;\n    } else {\n      this.stack.push(this.current, this.key);\n    }\n    this.current = new Ctr();\n    this.key = null;\n  };\n\nclass Assembler extends EventEmitter {\n  static connectTo(stream, options) {\n    return new Assembler(options).connectTo(stream);\n  }\n\n  constructor(options) {\n    super();\n    this.stack = [];\n    this.current = this.key = null;\n    this.done = true;\n    if (options) {\n      this.reviver = typeof options.reviver == 'function' && options.reviver;\n      if (this.reviver) {\n        this.stringValue = this._saveValue = this._saveValueWithReviver;\n      }\n      if (options.numberAsString) {\n        this.numberValue = this.stringValue;\n      }\n    }\n  }\n\n  connectTo(stream) {\n    stream.on('data', chunk => {\n      if (this[chunk.name]) {\n        this[chunk.name](chunk.value);\n        if (this.done) this.emit('done', this);\n      }\n    });\n    return this;\n  }\n\n  get depth() {\n    return (this.stack.length >> 1) + (this.done ? 0 : 1);\n  }\n\n  get path() {\n    const path = [];\n    for (let i = 0; i < this.stack.length; i += 2) {\n      const key = this.stack[i + 1];\n      path.push(key === null ? this.stack[i].length : key);\n    }\n    return path;\n  }\n\n  dropToLevel(level) {\n    if (level < this.depth) {\n      if (level) {\n        const index = (level - 1) << 1;\n        this.current = this.stack[index];\n        this.key = this.stack[index + 1];\n        this.stack.splice(index);\n      } else {\n        this.stack = [];\n        this.current = this.key = null;\n        this.done = true;\n      }\n    }\n    return this;\n  }\n\n  consume(chunk) {\n    this[chunk.name] && this[chunk.name](chunk.value);\n    return this;\n  }\n\n  keyValue(value) {\n    this.key = value;\n  }\n\n  //stringValue() - aliased below to _saveValue()\n\n  numberValue(value) {\n    this._saveValue(parseFloat(value));\n  }\n  nullValue() {\n    this._saveValue(null);\n  }\n  trueValue() {\n    this._saveValue(true);\n  }\n  falseValue() {\n    this._saveValue(false);\n  }\n\n  //startObject() - assigned below\n\n  endObject() {\n    if (this.stack.length) {\n      const value = this.current;\n      this.key = this.stack.pop();\n      this.current = this.stack.pop();\n      this._saveValue(value);\n    } else {\n      this.done = true;\n    }\n  }\n\n  //startArray() - assigned below\n  //endArray() - aliased below to endObject()\n\n  _saveValue(value) {\n    if (this.done) {\n      this.current = value;\n    } else {\n      if (this.current instanceof Array) {\n        this.current.push(value);\n      } else {\n        this.current[this.key] = value;\n        this.key = null;\n      }\n    }\n  }\n  _saveValueWithReviver(value) {\n    if (this.done) {\n      this.current = this.reviver('', value);\n    } else {\n      if (this.current instanceof Array) {\n        value = this.reviver('' + this.current.length, value);\n        this.current.push(value);\n        if (value === undefined) {\n          delete this.current[this.current.length - 1];\n        }\n      } else {\n        value = this.reviver(this.key, value);\n        if (value !== undefined) {\n          this.current[this.key] = value;\n        }\n        this.key = null;\n      }\n    }\n  }\n}\n\nAssembler.prototype.stringValue = Assembler.prototype._saveValue;\nAssembler.prototype.startObject = startObject(Object);\nAssembler.prototype.startArray = startObject(Array);\nAssembler.prototype.endArray = Assembler.prototype.endObject;\n\nmodule.exports = Assembler;\n",
    "'use strict';\n\nconst {Transform} = require('stream');\nconst Assembler = require('../Assembler');\n\nclass Counter {\n  constructor(initialDepth) {\n    this.depth = initialDepth;\n  }\n  startObject() {\n    ++this.depth;\n  }\n  endObject() {\n    --this.depth;\n  }\n  startArray() {\n    ++this.depth;\n  }\n  endArray() {\n    --this.depth;\n  }\n}\n\nclass StreamBase extends Transform {\n  constructor(options) {\n    super(Object.assign({}, options, {writableObjectMode: true, readableObjectMode: true}));\n    if (options) {\n      this.objectFilter = options.objectFilter;\n      this.includeUndecided = options.includeUndecided;\n    }\n    if (typeof this.objectFilter != 'function') {\n      this._filter = this._transform;\n    }\n    this._transform = this._wait || this._filter;\n    this._assembler = new Assembler(options);\n  }\n\n  _transform(chunk, encoding, callback) {\n    if (this._assembler[chunk.name]) {\n      this._assembler[chunk.name](chunk.value);\n      if (this._assembler.depth === this._level) {\n        this._push();\n      }\n    }\n    callback(null);\n  }\n\n  _filter(chunk, encoding, callback) {\n    if (this._assembler[chunk.name]) {\n      this._assembler[chunk.name](chunk.value);\n      const result = this.objectFilter(this._assembler);\n      if (result) {\n        if (this._assembler.depth === this._level) {\n          this._push();\n          this._transform = this._filter;\n        }\n        this._transform = this._accept;\n        return callback(null);\n      }\n      if (result === false) {\n        this._saved_assembler = this._assembler;\n        this._assembler = new Counter(this._saved_assembler.depth);\n        this._saved_assembler.dropToLevel(this._level);\n        if (this._assembler.depth === this._level) {\n          this._assembler = this._saved_assembler;\n          this._transform = this._filter;\n        }\n        this._transform = this._reject;\n        return callback(null);\n      }\n      if (this._assembler.depth === this._level) {\n        this._push(!this.includeUndecided);\n      }\n    }\n    callback(null);\n  }\n\n  _accept(chunk, encoding, callback) {\n    if (this._assembler[chunk.name]) {\n      this._assembler[chunk.name](chunk.value);\n      if (this._assembler.depth === this._level) {\n        this._push();\n        this._transform = this._filter;\n      }\n    }\n    callback(null);\n  }\n\n  _reject(chunk, encoding, callback) {\n    if (this._assembler[chunk.name]) {\n      this._assembler[chunk.name](chunk.value);\n      if (this._assembler.depth === this._level) {\n        this._assembler = this._saved_assembler;\n        this._transform = this._filter;\n      }\n    }\n    callback(null);\n  }\n}\n\nmodule.exports = StreamBase;\n",
    "'use strict';\n\nconst {Readable, Writable, Duplex, Transform} = require('stream');\n\nconst none = Symbol.for('object-stream.none');\nconst finalSymbol = Symbol.for('object-stream.final');\nconst manySymbol = Symbol.for('object-stream.many');\n\nconst final = value => ({[finalSymbol]: value});\nconst many = values => ({[manySymbol]: values});\n\nconst isFinal = o => o && typeof o == 'object' && finalSymbol in o;\nconst isMany = o => o && typeof o == 'object' && manySymbol in o;\n\nconst getFinalValue = o => o[finalSymbol];\nconst getManyValues = o => o[manySymbol];\n\nconst runAsyncGenerator = async (gen, stream) => {\n  for (;;) {\n    let data = gen.next();\n    if (data && typeof data.then == 'function') {\n      data = await data;\n    }\n    if (data.done) break;\n    let value = data.value;\n    if (value && typeof value.then == 'function') {\n      value = await value;\n    }\n    Chain.sanitize(value, stream);\n  }\n};\n\nconst wrapFunction = fn =>\n  new Transform({\n    writableObjectMode: true,\n    readableObjectMode: true,\n    transform(chunk, encoding, callback) {\n      try {\n        const result = fn.call(this, chunk, encoding);\n        if (result && typeof result.then == 'function') {\n          // thenable\n          result.then(\n            result => (Chain.sanitize(result, this), callback(null)),\n            error => callback(error)\n          );\n          return;\n        }\n        if (result && typeof result.next == 'function') {\n          // generator\n          runAsyncGenerator(result, this).then(\n            () => callback(null),\n            error => callback(error)\n          );\n          return;\n        }\n        Chain.sanitize(result, this);\n        callback(null);\n      } catch (error) {\n        callback(error);\n      }\n    }\n  });\n\nconst wrapArray = fns =>\n  new Transform({\n    writableObjectMode: true,\n    readableObjectMode: true,\n    transform(chunk, encoding, callback) {\n      try {\n        let value = chunk;\n        for (let i = 0; i < fns.length; ++i) {\n          const result = fns[i].call(this, value, encoding);\n          if (result === Chain.none) {\n            callback(null);\n            return;\n          }\n          if (Chain.isFinal(result)) {\n            value = Chain.getFinalValue(result);\n            break;\n          }\n          value = result;\n        }\n        Chain.sanitize(value, this);\n        callback(null);\n      } catch (error) {\n        callback(error);\n      }\n    }\n  });\n\n// is*NodeStream functions taken from https://github.com/nodejs/node/blob/master/lib/internal/streams/utils.js\nconst isReadableNodeStream = obj =>\n  obj &&\n  typeof obj.pipe === 'function' &&\n  typeof obj.on === 'function' &&\n  (!obj._writableState || (typeof obj._readableState === 'object' ? obj._readableState.readable : null) !== false) && // Duplex\n  (!obj._writableState || obj._readableState); // Writable has .pipe.\n\nconst isWritableNodeStream = obj =>\n  obj &&\n  typeof obj.write === 'function' &&\n  typeof obj.on === 'function' &&\n  (!obj._readableState || (typeof obj._writableState === 'object' ? obj._writableState.writable : null) !== false); // Duplex\n\nconst isDuplexNodeStream = obj =>\n  obj && typeof obj.pipe === 'function' && obj._readableState && typeof obj.on === 'function' && typeof obj.write === 'function';\n\nclass Chain extends Duplex {\n  constructor(fns, options) {\n    super(options || {writableObjectMode: true, readableObjectMode: true});\n\n    if (!(fns instanceof Array) || !fns.length) {\n      throw Error(\"Chain's argument should be a non-empty array.\");\n    }\n\n    this.streams = fns\n      .filter(fn => fn)\n      .map((fn, index, fns) => {\n        if (typeof fn === 'function' || fn instanceof Array) return Chain.convertToTransform(fn);\n        if (isDuplexNodeStream(fn) || (!index && isReadableNodeStream(fn)) || (index === fns.length - 1 && isWritableNodeStream(fn))) {\n          return fn;\n        }\n        throw Error('Arguments should be functions, arrays or streams.');\n      })\n      .filter(s => s);\n    this.input = this.streams[0];\n    this.output = this.streams.reduce((output, stream) => (output && output.pipe(stream)) || stream);\n\n    if (!isWritableNodeStream(this.input)) {\n      this._write = (_1, _2, callback) => callback(null);\n      this._final = callback => callback(null); // unavailable in Node 6\n      this.input.on('end', () => this.end());\n    }\n\n    if (isReadableNodeStream(this.output)) {\n      this.output.on('data', chunk => !this.push(chunk) && this.output.pause());\n      this.output.on('end', () => this.push(null));\n    } else {\n      this._read = () => {}; // nop\n      this.resume();\n      this.output.on('finish', () => this.push(null));\n    }\n\n    // connect events\n    if (!options || !options.skipEvents) {\n      this.streams.forEach(stream => stream.on('error', error => this.emit('error', error)));\n    }\n  }\n  _write(chunk, encoding, callback) {\n    let error = null;\n    try {\n      this.input.write(chunk, encoding, e => callback(e || error));\n    } catch (e) {\n      error = e;\n    }\n  }\n  _final(callback) {\n    let error = null;\n    try {\n      this.input.end(null, null, e => callback(e || error));\n    } catch (e) {\n      error = e;\n    }\n  }\n  _read() {\n    this.output.resume();\n  }\n  static make(fns, options) {\n    return new Chain(fns, options);\n  }\n  static sanitize(result, stream) {\n    if (Chain.isFinal(result)) {\n      result = Chain.getFinalValue(result);\n    } else if (Chain.isMany(result)) {\n      result = Chain.getManyValues(result);\n    }\n    if (result !== undefined && result !== null && result !== Chain.none) {\n      if (result instanceof Array) {\n        result.forEach(value => value !== undefined && value !== null && stream.push(value));\n      } else {\n        stream.push(result);\n      }\n    }\n  }\n  static convertToTransform(fn) {\n    if (typeof fn === 'function') return wrapFunction(fn);\n    if (fn instanceof Array) return fn.length ? wrapArray(fn) : null;\n    return null;\n  }\n}\n\nChain.none = none;\nChain.final = final;\nChain.isFinal = isFinal;\nChain.getFinalValue = getFinalValue;\nChain.many = many;\nChain.isMany = isMany;\nChain.getManyValues = getManyValues;\n\nChain.chain = Chain.make;\nChain.make.Constructor = Chain;\n\nmodule.exports = Chain;\n",
    "'use strict';\n\nconst {chain} = require('stream-chain');\n\nconst Parser = require('../Parser');\n\nconst withParser = (fn, options) =>\n  chain([new Parser(options), fn(options)], Object.assign({}, options, {writableObjectMode: false, readableObjectMode: true}));\n\nmodule.exports = withParser;\n",
    "'use strict';\n\nconst StreamBase = require('./StreamBase');\nconst withParser = require('../utils/withParser');\n\nclass StreamArray extends StreamBase {\n  static make(options) {\n    return new StreamArray(options);\n  }\n\n  static withParser(options) {\n    return withParser(StreamArray.make, options);\n  }\n\n  constructor(options) {\n    super(options);\n    this._level = 1;\n    this._counter = 0;\n  }\n\n  _wait(chunk, _, callback) {\n    // first chunk should open an array\n    if (chunk.name !== 'startArray') {\n      return callback(new Error('Top-level object should be an array.'));\n    }\n    this._transform = this._filter;\n    return this._transform(chunk, _, callback);\n  }\n\n  _push(discard) {\n    if (this._assembler.current.length) {\n      if (discard) {\n        ++this._counter;\n        this._assembler.current.pop();\n      } else {\n        this.push({key: this._counter++, value: this._assembler.current.pop()});\n      }\n    }\n  }\n}\nStreamArray.streamArray = StreamArray.make;\nStreamArray.make.Constructor = StreamArray;\n\nmodule.exports = StreamArray;\n",
    "'use strict';\n\nconst StreamBase = require('./StreamBase');\nconst withParser = require('../utils/withParser');\n\nclass StreamObject extends StreamBase {\n  static make(options) {\n    return new StreamObject(options);\n  }\n\n  static withParser(options) {\n    return withParser(StreamObject.make, options);\n  }\n\n  constructor(options) {\n    super(options);\n    this._level = 1;\n    this._lastKey = null;\n  }\n\n  _wait(chunk, _, callback) {\n    // first chunk should open an array\n    if (chunk.name !== 'startObject') {\n      return callback(new Error('Top-level object should be an object.'));\n    }\n    this._transform = this._filter;\n    return this._transform(chunk, _, callback);\n  }\n\n  _push(discard) {\n    if (this._lastKey === null) {\n      this._lastKey = this._assembler.key;\n    } else {\n      !discard && this.push({key: this._lastKey, value: this._assembler.current[this._lastKey]});\n      this._assembler.current = {};\n      this._lastKey = null;\n    }\n  }\n}\nStreamObject.streamObject = StreamObject.make;\nStreamObject.make.Constructor = StreamObject;\n\nmodule.exports = StreamObject;\n",
    "var clone = (function() {\n'use strict';\n\nfunction _instanceof(obj, type) {\n  return type != null && obj instanceof type;\n}\n\nvar nativeMap;\ntry {\n  nativeMap = Map;\n} catch(_) {\n  // maybe a reference error because no `Map`. Give it a dummy value that no\n  // value will ever be an instanceof.\n  nativeMap = function() {};\n}\n\nvar nativeSet;\ntry {\n  nativeSet = Set;\n} catch(_) {\n  nativeSet = function() {};\n}\n\nvar nativePromise;\ntry {\n  nativePromise = Promise;\n} catch(_) {\n  nativePromise = function() {};\n}\n\n/**\n * Clones (copies) an Object using deep copying.\n *\n * This function supports circular references by default, but if you are certain\n * there are no circular references in your object, you can save some CPU time\n * by calling clone(obj, false).\n *\n * Caution: if `circular` is false and `parent` contains circular references,\n * your program may enter an infinite loop and crash.\n *\n * @param `parent` - the object to be cloned\n * @param `circular` - set to true if the object to be cloned may contain\n *    circular references. (optional - true by default)\n * @param `depth` - set to a number if the object is only to be cloned to\n *    a particular depth. (optional - defaults to Infinity)\n * @param `prototype` - sets the prototype to be used when cloning an object.\n *    (optional - defaults to parent prototype).\n * @param `includeNonEnumerable` - set to true if the non-enumerable properties\n *    should be cloned as well. Non-enumerable properties on the prototype\n *    chain will be ignored. (optional - false by default)\n*/\nfunction clone(parent, circular, depth, prototype, includeNonEnumerable) {\n  if (typeof circular === 'object') {\n    depth = circular.depth;\n    prototype = circular.prototype;\n    includeNonEnumerable = circular.includeNonEnumerable;\n    circular = circular.circular;\n  }\n  // maintain two arrays for circular references, where corresponding parents\n  // and children have the same index\n  var allParents = [];\n  var allChildren = [];\n\n  var useBuffer = typeof Buffer != 'undefined';\n\n  if (typeof circular == 'undefined')\n    circular = true;\n\n  if (typeof depth == 'undefined')\n    depth = Infinity;\n\n  // recurse this function so we don't reset allParents and allChildren\n  function _clone(parent, depth) {\n    // cloning null always returns null\n    if (parent === null)\n      return null;\n\n    if (depth === 0)\n      return parent;\n\n    var child;\n    var proto;\n    if (typeof parent != 'object') {\n      return parent;\n    }\n\n    if (_instanceof(parent, nativeMap)) {\n      child = new nativeMap();\n    } else if (_instanceof(parent, nativeSet)) {\n      child = new nativeSet();\n    } else if (_instanceof(parent, nativePromise)) {\n      child = new nativePromise(function (resolve, reject) {\n        parent.then(function(value) {\n          resolve(_clone(value, depth - 1));\n        }, function(err) {\n          reject(_clone(err, depth - 1));\n        });\n      });\n    } else if (clone.__isArray(parent)) {\n      child = [];\n    } else if (clone.__isRegExp(parent)) {\n      child = new RegExp(parent.source, __getRegExpFlags(parent));\n      if (parent.lastIndex) child.lastIndex = parent.lastIndex;\n    } else if (clone.__isDate(parent)) {\n      child = new Date(parent.getTime());\n    } else if (useBuffer && Buffer.isBuffer(parent)) {\n      if (Buffer.allocUnsafe) {\n        // Node.js >= 4.5.0\n        child = Buffer.allocUnsafe(parent.length);\n      } else {\n        // Older Node.js versions\n        child = new Buffer(parent.length);\n      }\n      parent.copy(child);\n      return child;\n    } else if (_instanceof(parent, Error)) {\n      child = Object.create(parent);\n    } else {\n      if (typeof prototype == 'undefined') {\n        proto = Object.getPrototypeOf(parent);\n        child = Object.create(proto);\n      }\n      else {\n        child = Object.create(prototype);\n        proto = prototype;\n      }\n    }\n\n    if (circular) {\n      var index = allParents.indexOf(parent);\n\n      if (index != -1) {\n        return allChildren[index];\n      }\n      allParents.push(parent);\n      allChildren.push(child);\n    }\n\n    if (_instanceof(parent, nativeMap)) {\n      parent.forEach(function(value, key) {\n        var keyChild = _clone(key, depth - 1);\n        var valueChild = _clone(value, depth - 1);\n        child.set(keyChild, valueChild);\n      });\n    }\n    if (_instanceof(parent, nativeSet)) {\n      parent.forEach(function(value) {\n        var entryChild = _clone(value, depth - 1);\n        child.add(entryChild);\n      });\n    }\n\n    for (var i in parent) {\n      var attrs;\n      if (proto) {\n        attrs = Object.getOwnPropertyDescriptor(proto, i);\n      }\n\n      if (attrs && attrs.set == null) {\n        continue;\n      }\n      child[i] = _clone(parent[i], depth - 1);\n    }\n\n    if (Object.getOwnPropertySymbols) {\n      var symbols = Object.getOwnPropertySymbols(parent);\n      for (var i = 0; i < symbols.length; i++) {\n        // Don't need to worry about cloning a symbol because it is a primitive,\n        // like a number or string.\n        var symbol = symbols[i];\n        var descriptor = Object.getOwnPropertyDescriptor(parent, symbol);\n        if (descriptor && !descriptor.enumerable && !includeNonEnumerable) {\n          continue;\n        }\n        child[symbol] = _clone(parent[symbol], depth - 1);\n        if (!descriptor.enumerable) {\n          Object.defineProperty(child, symbol, {\n            enumerable: false\n          });\n        }\n      }\n    }\n\n    if (includeNonEnumerable) {\n      var allPropertyNames = Object.getOwnPropertyNames(parent);\n      for (var i = 0; i < allPropertyNames.length; i++) {\n        var propertyName = allPropertyNames[i];\n        var descriptor = Object.getOwnPropertyDescriptor(parent, propertyName);\n        if (descriptor && descriptor.enumerable) {\n          continue;\n        }\n        child[propertyName] = _clone(parent[propertyName], depth - 1);\n        Object.defineProperty(child, propertyName, {\n          enumerable: false\n        });\n      }\n    }\n\n    return child;\n  }\n\n  return _clone(parent, depth);\n}\n\n/**\n * Simple flat clone using prototype, accepts only objects, usefull for property\n * override on FLAT configuration object (no nested props).\n *\n * USE WITH CAUTION! This may not behave as you wish if you do not know how this\n * works.\n */\nclone.clonePrototype = function clonePrototype(parent) {\n  if (parent === null)\n    return null;\n\n  var c = function () {};\n  c.prototype = parent;\n  return new c();\n};\n\n// private utility functions\n\nfunction __objToStr(o) {\n  return Object.prototype.toString.call(o);\n}\nclone.__objToStr = __objToStr;\n\nfunction __isDate(o) {\n  return typeof o === 'object' && __objToStr(o) === '[object Date]';\n}\nclone.__isDate = __isDate;\n\nfunction __isArray(o) {\n  return typeof o === 'object' && __objToStr(o) === '[object Array]';\n}\nclone.__isArray = __isArray;\n\nfunction __isRegExp(o) {\n  return typeof o === 'object' && __objToStr(o) === '[object RegExp]';\n}\nclone.__isRegExp = __isRegExp;\n\nfunction __getRegExpFlags(re) {\n  var flags = '';\n  if (re.global) flags += 'g';\n  if (re.ignoreCase) flags += 'i';\n  if (re.multiline) flags += 'm';\n  return flags;\n}\nclone.__getRegExpFlags = __getRegExpFlags;\n\nreturn clone;\n})();\n\nif (typeof module === 'object' && module.exports) {\n  module.exports = clone;\n}\n",
    "/*\n * node-cache 5.1.2 ( 2020-07-01 )\n * https://github.com/node-cache/node-cache\n *\n * Released under the MIT license\n * https://github.com/node-cache/node-cache/blob/master/LICENSE\n *\n * Maintained by  (  )\n*/\n(function() {\n  var EventEmitter, NodeCache, clone,\n    splice = [].splice,\n    boundMethodCheck = function(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new Error('Bound instance method accessed before binding'); } },\n    indexOf = [].indexOf;\n\n  clone = require(\"clone\");\n\n  EventEmitter = require('events').EventEmitter;\n\n  // generate superclass\n  module.exports = NodeCache = (function() {\n    class NodeCache extends EventEmitter {\n      constructor(options = {}) {\n        super();\n        // ## get\n\n        // get a cached key and change the stats\n\n        // **Parameters:**\n\n        // * `key` ( String | Number ): cache key\n\n        // **Example:**\n\n        //\tmyCache.get \"myKey\", ( err, val )\n\n        this.get = this.get.bind(this);\n        // ## mget\n\n        // get multiple cached keys at once and change the stats\n\n        // **Parameters:**\n\n        // * `keys` ( String|Number[] ): an array of keys\n\n        // **Example:**\n\n        //\tmyCache.mget [ \"foo\", \"bar\" ]\n\n        this.mget = this.mget.bind(this);\n        // ## set\n\n        // set a cached key and change the stats\n\n        // **Parameters:**\n\n        // * `key` ( String | Number ): cache key\n        // * `value` ( Any ): A element to cache. If the option `option.forceString` is `true` the module trys to translate it to a serialized JSON\n        // * `[ ttl ]` ( Number | String ): ( optional ) The time to live in seconds.\n\n        // **Example:**\n\n        //\tmyCache.set \"myKey\", \"my_String Value\"\n\n        //\tmyCache.set \"myKey\", \"my_String Value\", 10\n\n        this.set = this.set.bind(this);\n        \n        // ## mset\n\n        // set multiple keys at once\n\n        // **Parameters:**\n\n        // * `keyValueSet` ( Object[] ): an array of object which includes key,value and ttl\n\n        // **Example:**\n\n        //\tmyCache.mset(\n        //\t\t[\n        //\t\t\t{\n        //\t\t\t\tkey: \"myKey\",\n        //\t\t\t\tval: \"myValue\",\n        //\t\t\t\tttl: [ttl in seconds]\n        //\t\t\t}\n        //\t\t])\n\n        this.mset = this.mset.bind(this);\n        // ## del\n\n        // remove keys\n\n        // **Parameters:**\n\n        // * `keys` ( String | Number | String|Number[] ): cache key to delete or a array of cache keys\n\n        // **Return**\n\n        // ( Number ): Number of deleted keys\n\n        // **Example:**\n\n        //\tmyCache.del( \"myKey\" )\n\n        this.del = this.del.bind(this);\n        // ## take\n\n        // get the cached value and remove the key from the cache.\n        // Equivalent to calling `get(key)` + `del(key)`.\n        // Useful for implementing `single use` mechanism such as OTP, where once a value is read it will become obsolete.\n\n        // **Parameters:**\n\n        // * `key` ( String | Number ): cache key\n\n        // **Example:**\n\n        //\tmyCache.take \"myKey\", ( err, val )\n\n        this.take = this.take.bind(this);\n        // ## ttl\n\n        // reset or redefine the ttl of a key. `ttl` = 0 means infinite lifetime.\n        // If `ttl` is not passed the default ttl is used.\n        // If `ttl` < 0 the key will be deleted.\n\n        // **Parameters:**\n\n        // * `key` ( String | Number ): cache key to reset the ttl value\n        // * `ttl` ( Number ): ( optional -> options.stdTTL || 0 ) The time to live in seconds\n\n        // **Return**\n\n        // ( Boolen ): key found and ttl set\n\n        // **Example:**\n\n        //\tmyCache.ttl( \"myKey\" ) // will set ttl to default ttl\n\n        //\tmyCache.ttl( \"myKey\", 1000 )\n\n        this.ttl = this.ttl.bind(this);\n        // ## getTtl\n\n        // receive the ttl of a key.\n\n        // **Parameters:**\n\n        // * `key` ( String | Number ): cache key to check the ttl value\n\n        // **Return**\n\n        // ( Number|undefined ): The timestamp in ms when the key will expire, 0 if it will never expire or undefined if it not exists\n\n        // **Example:**\n\n        //\tmyCache.getTtl( \"myKey\" )\n\n        this.getTtl = this.getTtl.bind(this);\n        // ## keys\n\n        // list all keys within this cache\n\n        // **Return**\n\n        // ( Array ): An array of all keys\n\n        // **Example:**\n\n        //     _keys = myCache.keys()\n\n        //     # [ \"foo\", \"bar\", \"fizz\", \"buzz\", \"anotherKeys\" ]\n\n        this.keys = this.keys.bind(this);\n        // ## has\n\n        // Check if a key is cached\n\n        // **Parameters:**\n\n        // * `key` ( String | Number ): cache key to check the ttl value\n\n        // **Return**\n\n        // ( Boolean ): A boolean that indicates if the key is cached\n\n        // **Example:**\n\n        //     _exists = myCache.has('myKey')\n\n        //     # true\n\n        this.has = this.has.bind(this);\n        // ## getStats\n\n        // get the stats\n\n        // **Parameters:**\n\n        // -\n\n        // **Return**\n\n        // ( Object ): Stats data\n\n        // **Example:**\n\n        //     myCache.getStats()\n        //     # {\n        //     # hits: 0,\n        //     # misses: 0,\n        //     # keys: 0,\n        //     # ksize: 0,\n        //     # vsize: 0\n        //     # }\n\n        this.getStats = this.getStats.bind(this);\n        // ## flushAll\n\n        // flush the whole data and reset the stats\n\n        // **Example:**\n\n        //     myCache.flushAll()\n\n        //     myCache.getStats()\n        //     # {\n        //     # hits: 0,\n        //     # misses: 0,\n        //     # keys: 0,\n        //     # ksize: 0,\n        //     # vsize: 0\n        //     # }\n\n        this.flushAll = this.flushAll.bind(this);\n        \n        // ## flushStats\n\n        // flush the stats and reset all counters to 0\n\n        // **Example:**\n\n        //     myCache.flushStats()\n\n        //     myCache.getStats()\n        //     # {\n        //     # hits: 0,\n        //     # misses: 0,\n        //     # keys: 0,\n        //     # ksize: 0,\n        //     # vsize: 0\n        //     # }\n\n        this.flushStats = this.flushStats.bind(this);\n        // ## close\n\n        // This will clear the interval timeout which is set on checkperiod option.\n\n        // **Example:**\n\n        //     myCache.close()\n\n        this.close = this.close.bind(this);\n        // ## _checkData\n\n        // internal housekeeping method.\n        // Check all the cached data and delete the invalid values\n        this._checkData = this._checkData.bind(this);\n        // ## _check\n\n        // internal method the check the value. If it's not valid any more delete it\n        this._check = this._check.bind(this);\n        // ## _isInvalidKey\n\n        // internal method to check if the type of a key is either `number` or `string`\n        this._isInvalidKey = this._isInvalidKey.bind(this);\n        // ## _wrap\n\n        // internal method to wrap a value in an object with some metadata\n        this._wrap = this._wrap.bind(this);\n        // ## _getValLength\n\n        // internal method to calculate the value length\n        this._getValLength = this._getValLength.bind(this);\n        // ## _error\n\n        // internal method to handle an error message\n        this._error = this._error.bind(this);\n        // ## _initErrors\n\n        // internal method to generate error message templates\n        this._initErrors = this._initErrors.bind(this);\n        this.options = options;\n        this._initErrors();\n        // container for cached data\n        this.data = {};\n        // module options\n        this.options = Object.assign({\n          // convert all elements to string\n          forceString: false,\n          // used standard size for calculating value size\n          objectValueSize: 80,\n          promiseValueSize: 80,\n          arrayValueSize: 40,\n          // standard time to live in seconds. 0 = infinity;\n          stdTTL: 0,\n          // time in seconds to check all data and delete expired keys\n          checkperiod: 600,\n          // en/disable cloning of variables. If `true` you'll get a copy of the cached variable. If `false` you'll save and get just the reference\n          useClones: true,\n          // whether values should be deleted automatically at expiration\n          deleteOnExpire: true,\n          // enable legacy callbacks\n          enableLegacyCallbacks: false,\n          // max amount of keys that are being stored\n          maxKeys: -1\n        }, this.options);\n        // generate functions with callbacks (legacy)\n        if (this.options.enableLegacyCallbacks) {\n          console.warn(\"WARNING! node-cache legacy callback support will drop in v6.x\");\n          [\"get\", \"mget\", \"set\", \"del\", \"ttl\", \"getTtl\", \"keys\", \"has\"].forEach((methodKey) => {\n            var oldMethod;\n            // reference real function\n            oldMethod = this[methodKey];\n            this[methodKey] = function(...args) {\n              var cb, err, ref, res;\n              ref = args, [...args] = ref, [cb] = splice.call(args, -1);\n              // return a callback if cb is defined and a function\n              if (typeof cb === \"function\") {\n                try {\n                  res = oldMethod(...args);\n                  cb(null, res);\n                } catch (error1) {\n                  err = error1;\n                  cb(err);\n                }\n              } else {\n                return oldMethod(...args, cb);\n              }\n            };\n          });\n        }\n        // statistics container\n        this.stats = {\n          hits: 0,\n          misses: 0,\n          keys: 0,\n          ksize: 0,\n          vsize: 0\n        };\n        // pre allocate valid keytypes array\n        this.validKeyTypes = [\"string\", \"number\"];\n        // initalize checking period\n        this._checkData();\n        return;\n      }\n\n      get(key) {\n        var _ret, err;\n        boundMethodCheck(this, NodeCache);\n        // handle invalid key types\n        if ((err = this._isInvalidKey(key)) != null) {\n          throw err;\n        }\n        // get data and incremet stats\n        if ((this.data[key] != null) && this._check(key, this.data[key])) {\n          this.stats.hits++;\n          _ret = this._unwrap(this.data[key]);\n          // return data\n          return _ret;\n        } else {\n          // if not found return undefined\n          this.stats.misses++;\n          return void 0;\n        }\n      }\n\n      mget(keys) {\n        var _err, err, i, key, len, oRet;\n        boundMethodCheck(this, NodeCache);\n        // convert a string to an array of one key\n        if (!Array.isArray(keys)) {\n          _err = this._error(\"EKEYSTYPE\");\n          throw _err;\n        }\n        // define return\n        oRet = {};\n        for (i = 0, len = keys.length; i < len; i++) {\n          key = keys[i];\n          // handle invalid key types\n          if ((err = this._isInvalidKey(key)) != null) {\n            throw err;\n          }\n          // get data and increment stats\n          if ((this.data[key] != null) && this._check(key, this.data[key])) {\n            this.stats.hits++;\n            oRet[key] = this._unwrap(this.data[key]);\n          } else {\n            // if not found return a error\n            this.stats.misses++;\n          }\n        }\n        // return all found keys\n        return oRet;\n      }\n\n      set(key, value, ttl) {\n        var _err, err, existent;\n        boundMethodCheck(this, NodeCache);\n        // check if cache is overflowing\n        if (this.options.maxKeys > -1 && this.stats.keys >= this.options.maxKeys) {\n          _err = this._error(\"ECACHEFULL\");\n          throw _err;\n        }\n        // force the data to string\n        if (this.options.forceString && !typeof value === \"string\") {\n          value = JSON.stringify(value);\n        }\n        // set default ttl if not passed\n        if (ttl == null) {\n          ttl = this.options.stdTTL;\n        }\n        // handle invalid key types\n        if ((err = this._isInvalidKey(key)) != null) {\n          throw err;\n        }\n        // internal helper variables\n        existent = false;\n        // remove existing data from stats\n        if (this.data[key]) {\n          existent = true;\n          this.stats.vsize -= this._getValLength(this._unwrap(this.data[key], false));\n        }\n        // set the value\n        this.data[key] = this._wrap(value, ttl);\n        this.stats.vsize += this._getValLength(value);\n        // only add the keys and key-size if the key is new\n        if (!existent) {\n          this.stats.ksize += this._getKeyLength(key);\n          this.stats.keys++;\n        }\n        this.emit(\"set\", key, value);\n        // return true\n        return true;\n      }\n\n      mset(keyValueSet) {\n        var _err, err, i, j, key, keyValuePair, len, len1, ttl, val;\n        boundMethodCheck(this, NodeCache);\n        // check if cache is overflowing\n        if (this.options.maxKeys > -1 && this.stats.keys + keyValueSet.length >= this.options.maxKeys) {\n          _err = this._error(\"ECACHEFULL\");\n          throw _err;\n        }\n\n// loop over keyValueSet to validate key and ttl\n        for (i = 0, len = keyValueSet.length; i < len; i++) {\n          keyValuePair = keyValueSet[i];\n          ({key, val, ttl} = keyValuePair);\n          // check if there is ttl and it's a number\n          if (ttl && typeof ttl !== \"number\") {\n            _err = this._error(\"ETTLTYPE\");\n            throw _err;\n          }\n          // handle invalid key types\n          if ((err = this._isInvalidKey(key)) != null) {\n            throw err;\n          }\n        }\n        for (j = 0, len1 = keyValueSet.length; j < len1; j++) {\n          keyValuePair = keyValueSet[j];\n          ({key, val, ttl} = keyValuePair);\n          this.set(key, val, ttl);\n        }\n        return true;\n      }\n\n      del(keys) {\n        var delCount, err, i, key, len, oldVal;\n        boundMethodCheck(this, NodeCache);\n        // convert keys to an array of itself\n        if (!Array.isArray(keys)) {\n          keys = [keys];\n        }\n        delCount = 0;\n        for (i = 0, len = keys.length; i < len; i++) {\n          key = keys[i];\n          // handle invalid key types\n          if ((err = this._isInvalidKey(key)) != null) {\n            throw err;\n          }\n          // only delete if existent\n          if (this.data[key] != null) {\n            // calc the stats\n            this.stats.vsize -= this._getValLength(this._unwrap(this.data[key], false));\n            this.stats.ksize -= this._getKeyLength(key);\n            this.stats.keys--;\n            delCount++;\n            // delete the value\n            oldVal = this.data[key];\n            delete this.data[key];\n            // return true\n            this.emit(\"del\", key, oldVal.v);\n          }\n        }\n        return delCount;\n      }\n\n      take(key) {\n        var _ret;\n        boundMethodCheck(this, NodeCache);\n        _ret = this.get(key);\n        if ((_ret != null)) {\n          this.del(key);\n        }\n        return _ret;\n      }\n\n      ttl(key, ttl) {\n        var err;\n        boundMethodCheck(this, NodeCache);\n        ttl || (ttl = this.options.stdTTL);\n        if (!key) {\n          return false;\n        }\n        // handle invalid key types\n        if ((err = this._isInvalidKey(key)) != null) {\n          throw err;\n        }\n        // check for existent data and update the ttl value\n        if ((this.data[key] != null) && this._check(key, this.data[key])) {\n          // if ttl < 0 delete the key. otherwise reset the value\n          if (ttl >= 0) {\n            this.data[key] = this._wrap(this.data[key].v, ttl, false);\n          } else {\n            this.del(key);\n          }\n          return true;\n        } else {\n          // return false if key has not been found\n          return false;\n        }\n      }\n\n      getTtl(key) {\n        var _ttl, err;\n        boundMethodCheck(this, NodeCache);\n        if (!key) {\n          return void 0;\n        }\n        // handle invalid key types\n        if ((err = this._isInvalidKey(key)) != null) {\n          throw err;\n        }\n        // check for existant data and update the ttl value\n        if ((this.data[key] != null) && this._check(key, this.data[key])) {\n          _ttl = this.data[key].t;\n          return _ttl;\n        } else {\n          // return undefined if key has not been found\n          return void 0;\n        }\n      }\n\n      keys() {\n        var _keys;\n        boundMethodCheck(this, NodeCache);\n        _keys = Object.keys(this.data);\n        return _keys;\n      }\n\n      has(key) {\n        var _exists;\n        boundMethodCheck(this, NodeCache);\n        _exists = (this.data[key] != null) && this._check(key, this.data[key]);\n        return _exists;\n      }\n\n      getStats() {\n        boundMethodCheck(this, NodeCache);\n        return this.stats;\n      }\n\n      flushAll(_startPeriod = true) {\n        boundMethodCheck(this, NodeCache);\n        // parameter just for testing\n\n        // set data empty\n        this.data = {};\n        // reset stats\n        this.stats = {\n          hits: 0,\n          misses: 0,\n          keys: 0,\n          ksize: 0,\n          vsize: 0\n        };\n        // reset check period\n        this._killCheckPeriod();\n        this._checkData(_startPeriod);\n        this.emit(\"flush\");\n      }\n\n      flushStats() {\n        boundMethodCheck(this, NodeCache);\n        // reset stats\n        this.stats = {\n          hits: 0,\n          misses: 0,\n          keys: 0,\n          ksize: 0,\n          vsize: 0\n        };\n        this.emit(\"flush_stats\");\n      }\n\n      close() {\n        boundMethodCheck(this, NodeCache);\n        this._killCheckPeriod();\n      }\n\n      _checkData(startPeriod = true) {\n        var key, ref, value;\n        boundMethodCheck(this, NodeCache);\n        ref = this.data;\n        // run the housekeeping method\n        for (key in ref) {\n          value = ref[key];\n          this._check(key, value);\n        }\n        if (startPeriod && this.options.checkperiod > 0) {\n          this.checkTimeout = setTimeout(this._checkData, this.options.checkperiod * 1000, startPeriod);\n          if ((this.checkTimeout != null) && (this.checkTimeout.unref != null)) {\n            this.checkTimeout.unref();\n          }\n        }\n      }\n\n      // ## _killCheckPeriod\n\n      // stop the checkdata period. Only needed to abort the script in testing mode.\n      _killCheckPeriod() {\n        if (this.checkTimeout != null) {\n          return clearTimeout(this.checkTimeout);\n        }\n      }\n\n      _check(key, data) {\n        var _retval;\n        boundMethodCheck(this, NodeCache);\n        _retval = true;\n        // data is invalid if the ttl is too old and is not 0\n        // console.log data.t < Date.now(), data.t, Date.now()\n        if (data.t !== 0 && data.t < Date.now()) {\n          if (this.options.deleteOnExpire) {\n            _retval = false;\n            this.del(key);\n          }\n          this.emit(\"expired\", key, this._unwrap(data));\n        }\n        return _retval;\n      }\n\n      _isInvalidKey(key) {\n        var ref;\n        boundMethodCheck(this, NodeCache);\n        if (ref = typeof key, indexOf.call(this.validKeyTypes, ref) < 0) {\n          return this._error(\"EKEYTYPE\", {\n            type: typeof key\n          });\n        }\n      }\n\n      _wrap(value, ttl, asClone = true) {\n        var livetime, now, oReturn, ttlMultiplicator;\n        boundMethodCheck(this, NodeCache);\n        if (!this.options.useClones) {\n          asClone = false;\n        }\n        // define the time to live\n        now = Date.now();\n        livetime = 0;\n        ttlMultiplicator = 1000;\n        // use given ttl\n        if (ttl === 0) {\n          livetime = 0;\n        } else if (ttl) {\n          livetime = now + (ttl * ttlMultiplicator);\n        } else {\n          // use standard ttl\n          if (this.options.stdTTL === 0) {\n            livetime = this.options.stdTTL;\n          } else {\n            livetime = now + (this.options.stdTTL * ttlMultiplicator);\n          }\n        }\n        // return the wrapped value\n        return oReturn = {\n          t: livetime,\n          v: asClone ? clone(value) : value\n        };\n      }\n\n      // ## _unwrap\n\n      // internal method to extract get the value out of the wrapped value\n      _unwrap(value, asClone = true) {\n        if (!this.options.useClones) {\n          asClone = false;\n        }\n        if (value.v != null) {\n          if (asClone) {\n            return clone(value.v);\n          } else {\n            return value.v;\n          }\n        }\n        return null;\n      }\n\n      // ## _getKeyLength\n\n      // internal method the calculate the key length\n      _getKeyLength(key) {\n        return key.toString().length;\n      }\n\n      _getValLength(value) {\n        boundMethodCheck(this, NodeCache);\n        if (typeof value === \"string\") {\n          // if the value is a String get the real length\n          return value.length;\n        } else if (this.options.forceString) {\n          // force string if it's defined and not passed\n          return JSON.stringify(value).length;\n        } else if (Array.isArray(value)) {\n          // if the data is an Array multiply each element with a defined default length\n          return this.options.arrayValueSize * value.length;\n        } else if (typeof value === \"number\") {\n          return 8;\n        } else if (typeof (value != null ? value.then : void 0) === \"function\") {\n          // if the data is a Promise, use defined default\n          // (can't calculate actual/resolved value size synchronously)\n          return this.options.promiseValueSize;\n        } else if (typeof Buffer !== \"undefined\" && Buffer !== null ? Buffer.isBuffer(value) : void 0) {\n          return value.length;\n        } else if ((value != null) && typeof value === \"object\") {\n          // if the data is an Object multiply each element with a defined default length\n          return this.options.objectValueSize * Object.keys(value).length;\n        } else if (typeof value === \"boolean\") {\n          return 8;\n        } else {\n          // default fallback\n          return 0;\n        }\n      }\n\n      _error(type, data = {}) {\n        var error;\n        boundMethodCheck(this, NodeCache);\n        // generate the error object\n        error = new Error();\n        error.name = type;\n        error.errorcode = type;\n        error.message = this.ERRORS[type] != null ? this.ERRORS[type](data) : \"-\";\n        error.data = data;\n        // return the error object\n        return error;\n      }\n\n      _initErrors() {\n        var _errMsg, _errT, ref;\n        boundMethodCheck(this, NodeCache);\n        this.ERRORS = {};\n        ref = this._ERRORS;\n        for (_errT in ref) {\n          _errMsg = ref[_errT];\n          this.ERRORS[_errT] = this.createErrorMessage(_errMsg);\n        }\n      }\n\n      createErrorMessage(errMsg) {\n        return function(args) {\n          return errMsg.replace(\"__key\", args.type);\n        };\n      }\n\n    };\n\n    NodeCache.prototype._ERRORS = {\n      \"ENOTFOUND\": \"Key `__key` not found\",\n      \"ECACHEFULL\": \"Cache max keys amount exceeded\",\n      \"EKEYTYPE\": \"The key argument has to be of type `string` or `number`. Found: `__key`\",\n      \"EKEYSTYPE\": \"The keys argument has to be an array.\",\n      \"ETTLTYPE\": \"The ttl argument has to be a number.\"\n    };\n\n    return NodeCache;\n\n  }).call(this);\n\n}).call(this);\n",
    "/*\n * node-cache 5.1.2 ( 2020-07-01 )\n * https://github.com/node-cache/node-cache\n *\n * Released under the MIT license\n * https://github.com/node-cache/node-cache/blob/master/LICENSE\n *\n * Maintained by  (  )\n*/\n(function() {\n  var exports;\n\n  exports = module.exports = require('./lib/node_cache');\n\n  exports.version = '5.1.2';\n\n}).call(this);\n",
    "//#region rolldown:runtime\nvar __defProp = Object.defineProperty;\nvar __export = (target, all) => {\n\tfor (var name in all) __defProp(target, name, {\n\t\tget: all[name],\n\t\tenumerable: true\n\t});\n};\n\n//#endregion\nexport { __export };",
    "const entityKind = Symbol.for(\"drizzle:entityKind\");\nconst hasOwnEntityKind = Symbol.for(\"drizzle:hasOwnEntityKind\");\nfunction is(value, type) {\n  if (!value || typeof value !== \"object\") {\n    return false;\n  }\n  if (value instanceof type) {\n    return true;\n  }\n  if (!Object.prototype.hasOwnProperty.call(type, entityKind)) {\n    throw new Error(\n      `Class \"${type.name ?? \"<unknown>\"}\" doesn't look like a Drizzle entity. If this is incorrect and the class is provided by Drizzle, please report this as a bug.`\n    );\n  }\n  let cls = Object.getPrototypeOf(value).constructor;\n  if (cls) {\n    while (cls) {\n      if (entityKind in cls && cls[entityKind] === type[entityKind]) {\n        return true;\n      }\n      cls = Object.getPrototypeOf(cls);\n    }\n  }\n  return false;\n}\nexport {\n  entityKind,\n  hasOwnEntityKind,\n  is\n};\n//# sourceMappingURL=entity.js.map",
    "import { entityKind } from \"./entity.js\";\nclass Column {\n  constructor(table, config) {\n    this.table = table;\n    this.config = config;\n    this.name = config.name;\n    this.keyAsName = config.keyAsName;\n    this.notNull = config.notNull;\n    this.default = config.default;\n    this.defaultFn = config.defaultFn;\n    this.onUpdateFn = config.onUpdateFn;\n    this.hasDefault = config.hasDefault;\n    this.primary = config.primaryKey;\n    this.isUnique = config.isUnique;\n    this.uniqueName = config.uniqueName;\n    this.uniqueType = config.uniqueType;\n    this.dataType = config.dataType;\n    this.columnType = config.columnType;\n    this.generated = config.generated;\n    this.generatedIdentity = config.generatedIdentity;\n  }\n  static [entityKind] = \"Column\";\n  name;\n  keyAsName;\n  primary;\n  notNull;\n  default;\n  defaultFn;\n  onUpdateFn;\n  hasDefault;\n  isUnique;\n  uniqueName;\n  uniqueType;\n  dataType;\n  columnType;\n  enumValues = void 0;\n  generated = void 0;\n  generatedIdentity = void 0;\n  config;\n  mapFromDriverValue(value) {\n    return value;\n  }\n  mapToDriverValue(value) {\n    return value;\n  }\n  // ** @internal */\n  shouldDisableInsert() {\n    return this.config.generated !== void 0 && this.config.generated.type !== \"byDefault\";\n  }\n}\nexport {\n  Column\n};\n//# sourceMappingURL=column.js.map",
    "import { entityKind } from \"./entity.js\";\nclass ColumnBuilder {\n  static [entityKind] = \"ColumnBuilder\";\n  config;\n  constructor(name, dataType, columnType) {\n    this.config = {\n      name,\n      keyAsName: name === \"\",\n      notNull: false,\n      default: void 0,\n      hasDefault: false,\n      primaryKey: false,\n      isUnique: false,\n      uniqueName: void 0,\n      uniqueType: void 0,\n      dataType,\n      columnType,\n      generated: void 0\n    };\n  }\n  /**\n   * Changes the data type of the column. Commonly used with `json` columns. Also, useful for branded types.\n   *\n   * @example\n   * ```ts\n   * const users = pgTable('users', {\n   * \tid: integer('id').$type<UserId>().primaryKey(),\n   * \tdetails: json('details').$type<UserDetails>().notNull(),\n   * });\n   * ```\n   */\n  $type() {\n    return this;\n  }\n  /**\n   * Adds a `not null` clause to the column definition.\n   *\n   * Affects the `select` model of the table - columns *without* `not null` will be nullable on select.\n   */\n  notNull() {\n    this.config.notNull = true;\n    return this;\n  }\n  /**\n   * Adds a `default <value>` clause to the column definition.\n   *\n   * Affects the `insert` model of the table - columns *with* `default` are optional on insert.\n   *\n   * If you need to set a dynamic default value, use {@link $defaultFn} instead.\n   */\n  default(value) {\n    this.config.default = value;\n    this.config.hasDefault = true;\n    return this;\n  }\n  /**\n   * Adds a dynamic default value to the column.\n   * The function will be called when the row is inserted, and the returned value will be used as the column value.\n   *\n   * **Note:** This value does not affect the `drizzle-kit` behavior, it is only used at runtime in `drizzle-orm`.\n   */\n  $defaultFn(fn) {\n    this.config.defaultFn = fn;\n    this.config.hasDefault = true;\n    return this;\n  }\n  /**\n   * Alias for {@link $defaultFn}.\n   */\n  $default = this.$defaultFn;\n  /**\n   * Adds a dynamic update value to the column.\n   * The function will be called when the row is updated, and the returned value will be used as the column value if none is provided.\n   * If no `default` (or `$defaultFn`) value is provided, the function will be called when the row is inserted as well, and the returned value will be used as the column value.\n   *\n   * **Note:** This value does not affect the `drizzle-kit` behavior, it is only used at runtime in `drizzle-orm`.\n   */\n  $onUpdateFn(fn) {\n    this.config.onUpdateFn = fn;\n    this.config.hasDefault = true;\n    return this;\n  }\n  /**\n   * Alias for {@link $onUpdateFn}.\n   */\n  $onUpdate = this.$onUpdateFn;\n  /**\n   * Adds a `primary key` clause to the column definition. This implicitly makes the column `not null`.\n   *\n   * In SQLite, `integer primary key` implicitly makes the column auto-incrementing.\n   */\n  primaryKey() {\n    this.config.primaryKey = true;\n    this.config.notNull = true;\n    return this;\n  }\n  /** @internal Sets the name of the column to the key within the table definition if a name was not given. */\n  setName(name) {\n    if (this.config.name !== \"\") return;\n    this.config.name = name;\n  }\n}\nexport {\n  ColumnBuilder\n};\n//# sourceMappingURL=column-builder.js.map",
    "const TableName = Symbol.for(\"drizzle:Name\");\nexport {\n  TableName\n};\n//# sourceMappingURL=table.utils.js.map",
    "function iife(fn, ...args) {\n  return fn(...args);\n}\nexport {\n  iife\n};\n//# sourceMappingURL=tracing-utils.js.map",
    "import { entityKind } from \"../entity.js\";\nimport { TableName } from \"../table.utils.js\";\nfunction unique(name) {\n  return new UniqueOnConstraintBuilder(name);\n}\nfunction uniqueKeyName(table, columns) {\n  return `${table[TableName]}_${columns.join(\"_\")}_unique`;\n}\nclass UniqueConstraintBuilder {\n  constructor(columns, name) {\n    this.name = name;\n    this.columns = columns;\n  }\n  static [entityKind] = \"PgUniqueConstraintBuilder\";\n  /** @internal */\n  columns;\n  /** @internal */\n  nullsNotDistinctConfig = false;\n  nullsNotDistinct() {\n    this.nullsNotDistinctConfig = true;\n    return this;\n  }\n  /** @internal */\n  build(table) {\n    return new UniqueConstraint(table, this.columns, this.nullsNotDistinctConfig, this.name);\n  }\n}\nclass UniqueOnConstraintBuilder {\n  static [entityKind] = \"PgUniqueOnConstraintBuilder\";\n  /** @internal */\n  name;\n  constructor(name) {\n    this.name = name;\n  }\n  on(...columns) {\n    return new UniqueConstraintBuilder(columns, this.name);\n  }\n}\nclass UniqueConstraint {\n  constructor(table, columns, nullsNotDistinct, name) {\n    this.table = table;\n    this.columns = columns;\n    this.name = name ?? uniqueKeyName(this.table, this.columns.map((column) => column.name));\n    this.nullsNotDistinct = nullsNotDistinct;\n  }\n  static [entityKind] = \"PgUniqueConstraint\";\n  columns;\n  name;\n  nullsNotDistinct = false;\n  getName() {\n    return this.name;\n  }\n}\nexport {\n  UniqueConstraint,\n  UniqueConstraintBuilder,\n  UniqueOnConstraintBuilder,\n  unique,\n  uniqueKeyName\n};\n//# sourceMappingURL=unique-constraint.js.map",
    "import { ColumnBuilder } from \"../../column-builder.js\";\nimport { Column } from \"../../column.js\";\nimport { entityKind, is } from \"../../entity.js\";\nimport { ForeignKeyBuilder } from \"../foreign-keys.js\";\nimport { iife } from \"../../tracing-utils.js\";\nimport { uniqueKeyName } from \"../unique-constraint.js\";\nimport { makePgArray, parsePgArray } from \"../utils/array.js\";\nclass PgColumnBuilder extends ColumnBuilder {\n  foreignKeyConfigs = [];\n  static [entityKind] = \"PgColumnBuilder\";\n  array(size) {\n    return new PgArrayBuilder(this.config.name, this, size);\n  }\n  references(ref, actions = {}) {\n    this.foreignKeyConfigs.push({ ref, actions });\n    return this;\n  }\n  unique(name, config) {\n    this.config.isUnique = true;\n    this.config.uniqueName = name;\n    this.config.uniqueType = config?.nulls;\n    return this;\n  }\n  generatedAlwaysAs(as) {\n    this.config.generated = {\n      as,\n      type: \"always\",\n      mode: \"stored\"\n    };\n    return this;\n  }\n  /** @internal */\n  buildForeignKeys(column, table) {\n    return this.foreignKeyConfigs.map(({ ref, actions }) => {\n      return iife(\n        (ref2, actions2) => {\n          const builder = new ForeignKeyBuilder(() => {\n            const foreignColumn = ref2();\n            return { columns: [column], foreignColumns: [foreignColumn] };\n          });\n          if (actions2.onUpdate) {\n            builder.onUpdate(actions2.onUpdate);\n          }\n          if (actions2.onDelete) {\n            builder.onDelete(actions2.onDelete);\n          }\n          return builder.build(table);\n        },\n        ref,\n        actions\n      );\n    });\n  }\n  /** @internal */\n  buildExtraConfigColumn(table) {\n    return new ExtraConfigColumn(table, this.config);\n  }\n}\nclass PgColumn extends Column {\n  constructor(table, config) {\n    if (!config.uniqueName) {\n      config.uniqueName = uniqueKeyName(table, [config.name]);\n    }\n    super(table, config);\n    this.table = table;\n  }\n  static [entityKind] = \"PgColumn\";\n}\nclass ExtraConfigColumn extends PgColumn {\n  static [entityKind] = \"ExtraConfigColumn\";\n  getSQLType() {\n    return this.getSQLType();\n  }\n  indexConfig = {\n    order: this.config.order ?? \"asc\",\n    nulls: this.config.nulls ?? \"last\",\n    opClass: this.config.opClass\n  };\n  defaultConfig = {\n    order: \"asc\",\n    nulls: \"last\",\n    opClass: void 0\n  };\n  asc() {\n    this.indexConfig.order = \"asc\";\n    return this;\n  }\n  desc() {\n    this.indexConfig.order = \"desc\";\n    return this;\n  }\n  nullsFirst() {\n    this.indexConfig.nulls = \"first\";\n    return this;\n  }\n  nullsLast() {\n    this.indexConfig.nulls = \"last\";\n    return this;\n  }\n  /**\n   * ### PostgreSQL documentation quote\n   *\n   * > An operator class with optional parameters can be specified for each column of an index.\n   * The operator class identifies the operators to be used by the index for that column.\n   * For example, a B-tree index on four-byte integers would use the int4_ops class;\n   * this operator class includes comparison functions for four-byte integers.\n   * In practice the default operator class for the column's data type is usually sufficient.\n   * The main point of having operator classes is that for some data types, there could be more than one meaningful ordering.\n   * For example, we might want to sort a complex-number data type either by absolute value or by real part.\n   * We could do this by defining two operator classes for the data type and then selecting the proper class when creating an index.\n   * More information about operator classes check:\n   *\n   * ### Useful links\n   * https://www.postgresql.org/docs/current/sql-createindex.html\n   *\n   * https://www.postgresql.org/docs/current/indexes-opclass.html\n   *\n   * https://www.postgresql.org/docs/current/xindex.html\n   *\n   * ### Additional types\n   * If you have the `pg_vector` extension installed in your database, you can use the\n   * `vector_l2_ops`, `vector_ip_ops`, `vector_cosine_ops`, `vector_l1_ops`, `bit_hamming_ops`, `bit_jaccard_ops`, `halfvec_l2_ops`, `sparsevec_l2_ops` options, which are predefined types.\n   *\n   * **You can always specify any string you want in the operator class, in case Drizzle doesn't have it natively in its types**\n   *\n   * @param opClass\n   * @returns\n   */\n  op(opClass) {\n    this.indexConfig.opClass = opClass;\n    return this;\n  }\n}\nclass IndexedColumn {\n  static [entityKind] = \"IndexedColumn\";\n  constructor(name, keyAsName, type, indexConfig) {\n    this.name = name;\n    this.keyAsName = keyAsName;\n    this.type = type;\n    this.indexConfig = indexConfig;\n  }\n  name;\n  keyAsName;\n  type;\n  indexConfig;\n}\nclass PgArrayBuilder extends PgColumnBuilder {\n  static [entityKind] = \"PgArrayBuilder\";\n  constructor(name, baseBuilder, size) {\n    super(name, \"array\", \"PgArray\");\n    this.config.baseBuilder = baseBuilder;\n    this.config.size = size;\n  }\n  /** @internal */\n  build(table) {\n    const baseColumn = this.config.baseBuilder.build(table);\n    return new PgArray(\n      table,\n      this.config,\n      baseColumn\n    );\n  }\n}\nclass PgArray extends PgColumn {\n  constructor(table, config, baseColumn, range) {\n    super(table, config);\n    this.baseColumn = baseColumn;\n    this.range = range;\n    this.size = config.size;\n  }\n  size;\n  static [entityKind] = \"PgArray\";\n  getSQLType() {\n    return `${this.baseColumn.getSQLType()}[${typeof this.size === \"number\" ? this.size : \"\"}]`;\n  }\n  mapFromDriverValue(value) {\n    if (typeof value === \"string\") {\n      value = parsePgArray(value);\n    }\n    return value.map((v) => this.baseColumn.mapFromDriverValue(v));\n  }\n  mapToDriverValue(value, isNestedArray = false) {\n    const a = value.map(\n      (v) => v === null ? null : is(this.baseColumn, PgArray) ? this.baseColumn.mapToDriverValue(v, true) : this.baseColumn.mapToDriverValue(v)\n    );\n    if (isNestedArray) return a;\n    return makePgArray(a);\n  }\n}\nexport {\n  ExtraConfigColumn,\n  IndexedColumn,\n  PgArray,\n  PgArrayBuilder,\n  PgColumn,\n  PgColumnBuilder\n};\n//# sourceMappingURL=common.js.map",
    "import { entityKind } from \"../../entity.js\";\nimport { PgColumn, PgColumnBuilder } from \"./common.js\";\nclass PgEnumObjectColumnBuilder extends PgColumnBuilder {\n  static [entityKind] = \"PgEnumObjectColumnBuilder\";\n  constructor(name, enumInstance) {\n    super(name, \"string\", \"PgEnumObjectColumn\");\n    this.config.enum = enumInstance;\n  }\n  /** @internal */\n  build(table) {\n    return new PgEnumObjectColumn(\n      table,\n      this.config\n    );\n  }\n}\nclass PgEnumObjectColumn extends PgColumn {\n  static [entityKind] = \"PgEnumObjectColumn\";\n  enum;\n  enumValues = this.config.enum.enumValues;\n  constructor(table, config) {\n    super(table, config);\n    this.enum = config.enum;\n  }\n  getSQLType() {\n    return this.enum.enumName;\n  }\n}\nconst isPgEnumSym = Symbol.for(\"drizzle:isPgEnum\");\nfunction isPgEnum(obj) {\n  return !!obj && typeof obj === \"function\" && isPgEnumSym in obj && obj[isPgEnumSym] === true;\n}\nclass PgEnumColumnBuilder extends PgColumnBuilder {\n  static [entityKind] = \"PgEnumColumnBuilder\";\n  constructor(name, enumInstance) {\n    super(name, \"string\", \"PgEnumColumn\");\n    this.config.enum = enumInstance;\n  }\n  /** @internal */\n  build(table) {\n    return new PgEnumColumn(\n      table,\n      this.config\n    );\n  }\n}\nclass PgEnumColumn extends PgColumn {\n  static [entityKind] = \"PgEnumColumn\";\n  enum = this.config.enum;\n  enumValues = this.config.enum.enumValues;\n  constructor(table, config) {\n    super(table, config);\n    this.enum = config.enum;\n  }\n  getSQLType() {\n    return this.enum.enumName;\n  }\n}\nfunction pgEnum(enumName, input) {\n  return Array.isArray(input) ? pgEnumWithSchema(enumName, [...input], void 0) : pgEnumObjectWithSchema(enumName, input, void 0);\n}\nfunction pgEnumWithSchema(enumName, values, schema) {\n  const enumInstance = Object.assign(\n    (name) => new PgEnumColumnBuilder(name ?? \"\", enumInstance),\n    {\n      enumName,\n      enumValues: values,\n      schema,\n      [isPgEnumSym]: true\n    }\n  );\n  return enumInstance;\n}\nfunction pgEnumObjectWithSchema(enumName, values, schema) {\n  const enumInstance = Object.assign(\n    (name) => new PgEnumObjectColumnBuilder(name ?? \"\", enumInstance),\n    {\n      enumName,\n      enumValues: Object.values(values),\n      schema,\n      [isPgEnumSym]: true\n    }\n  );\n  return enumInstance;\n}\nexport {\n  PgEnumColumn,\n  PgEnumColumnBuilder,\n  PgEnumObjectColumn,\n  PgEnumObjectColumnBuilder,\n  isPgEnum,\n  pgEnum,\n  pgEnumObjectWithSchema,\n  pgEnumWithSchema\n};\n//# sourceMappingURL=enum.js.map",
    "import { entityKind } from \"./entity.js\";\nclass Subquery {\n  static [entityKind] = \"Subquery\";\n  constructor(sql, fields, alias, isWith = false, usedTables = []) {\n    this._ = {\n      brand: \"Subquery\",\n      sql,\n      selectedFields: fields,\n      alias,\n      isWith,\n      usedTables\n    };\n  }\n  // getSQL(): SQL<unknown> {\n  // \treturn new SQL([this]);\n  // }\n}\nclass WithSubquery extends Subquery {\n  static [entityKind] = \"WithSubquery\";\n}\nexport {\n  Subquery,\n  WithSubquery\n};\n//# sourceMappingURL=subquery.js.map",
    "// package.json\nvar version = \"0.44.5\";\n\n// src/version.ts\nvar compatibilityVersion = 10;\nexport {\n  compatibilityVersion,\n  version as npmVersion\n};\n",
    "import { iife } from \"./tracing-utils.js\";\nimport { npmVersion } from \"./version.js\";\nlet otel;\nlet rawTracer;\nconst tracer = {\n  startActiveSpan(name, fn) {\n    if (!otel) {\n      return fn();\n    }\n    if (!rawTracer) {\n      rawTracer = otel.trace.getTracer(\"drizzle-orm\", npmVersion);\n    }\n    return iife(\n      (otel2, rawTracer2) => rawTracer2.startActiveSpan(\n        name,\n        (span) => {\n          try {\n            return fn(span);\n          } catch (e) {\n            span.setStatus({\n              code: otel2.SpanStatusCode.ERROR,\n              message: e instanceof Error ? e.message : \"Unknown error\"\n              // eslint-disable-line no-instanceof/no-instanceof\n            });\n            throw e;\n          } finally {\n            span.end();\n          }\n        }\n      ),\n      otel,\n      rawTracer\n    );\n  }\n};\nexport {\n  tracer\n};\n//# sourceMappingURL=tracing.js.map",
    "const ViewBaseConfig = Symbol.for(\"drizzle:ViewBaseConfig\");\nexport {\n  ViewBaseConfig\n};\n//# sourceMappingURL=view-common.js.map",
    "import { entityKind } from \"./entity.js\";\nimport { TableName } from \"./table.utils.js\";\nconst Schema = Symbol.for(\"drizzle:Schema\");\nconst Columns = Symbol.for(\"drizzle:Columns\");\nconst ExtraConfigColumns = Symbol.for(\"drizzle:ExtraConfigColumns\");\nconst OriginalName = Symbol.for(\"drizzle:OriginalName\");\nconst BaseName = Symbol.for(\"drizzle:BaseName\");\nconst IsAlias = Symbol.for(\"drizzle:IsAlias\");\nconst ExtraConfigBuilder = Symbol.for(\"drizzle:ExtraConfigBuilder\");\nconst IsDrizzleTable = Symbol.for(\"drizzle:IsDrizzleTable\");\nclass Table {\n  static [entityKind] = \"Table\";\n  /** @internal */\n  static Symbol = {\n    Name: TableName,\n    Schema,\n    OriginalName,\n    Columns,\n    ExtraConfigColumns,\n    BaseName,\n    IsAlias,\n    ExtraConfigBuilder\n  };\n  /**\n   * @internal\n   * Can be changed if the table is aliased.\n   */\n  [TableName];\n  /**\n   * @internal\n   * Used to store the original name of the table, before any aliasing.\n   */\n  [OriginalName];\n  /** @internal */\n  [Schema];\n  /** @internal */\n  [Columns];\n  /** @internal */\n  [ExtraConfigColumns];\n  /**\n   *  @internal\n   * Used to store the table name before the transformation via the `tableCreator` functions.\n   */\n  [BaseName];\n  /** @internal */\n  [IsAlias] = false;\n  /** @internal */\n  [IsDrizzleTable] = true;\n  /** @internal */\n  [ExtraConfigBuilder] = void 0;\n  constructor(name, schema, baseName) {\n    this[TableName] = this[OriginalName] = name;\n    this[Schema] = schema;\n    this[BaseName] = baseName;\n  }\n}\nfunction isTable(table) {\n  return typeof table === \"object\" && table !== null && IsDrizzleTable in table;\n}\nfunction getTableName(table) {\n  return table[TableName];\n}\nfunction getTableUniqueName(table) {\n  return `${table[Schema] ?? \"public\"}.${table[TableName]}`;\n}\nexport {\n  BaseName,\n  Columns,\n  ExtraConfigBuilder,\n  ExtraConfigColumns,\n  IsAlias,\n  OriginalName,\n  Schema,\n  Table,\n  getTableName,\n  getTableUniqueName,\n  isTable\n};\n//# sourceMappingURL=table.js.map",
    "import { entityKind, is } from \"../entity.js\";\nimport { isPgEnum } from \"../pg-core/columns/enum.js\";\nimport { Subquery } from \"../subquery.js\";\nimport { tracer } from \"../tracing.js\";\nimport { ViewBaseConfig } from \"../view-common.js\";\nimport { Column } from \"../column.js\";\nimport { IsAlias, Table } from \"../table.js\";\nclass FakePrimitiveParam {\n  static [entityKind] = \"FakePrimitiveParam\";\n}\nfunction isSQLWrapper(value) {\n  return value !== null && value !== void 0 && typeof value.getSQL === \"function\";\n}\nfunction mergeQueries(queries) {\n  const result = { sql: \"\", params: [] };\n  for (const query of queries) {\n    result.sql += query.sql;\n    result.params.push(...query.params);\n    if (query.typings?.length) {\n      if (!result.typings) {\n        result.typings = [];\n      }\n      result.typings.push(...query.typings);\n    }\n  }\n  return result;\n}\nclass StringChunk {\n  static [entityKind] = \"StringChunk\";\n  value;\n  constructor(value) {\n    this.value = Array.isArray(value) ? value : [value];\n  }\n  getSQL() {\n    return new SQL([this]);\n  }\n}\nclass SQL {\n  constructor(queryChunks) {\n    this.queryChunks = queryChunks;\n    for (const chunk of queryChunks) {\n      if (is(chunk, Table)) {\n        const schemaName = chunk[Table.Symbol.Schema];\n        this.usedTables.push(\n          schemaName === void 0 ? chunk[Table.Symbol.Name] : schemaName + \".\" + chunk[Table.Symbol.Name]\n        );\n      }\n    }\n  }\n  static [entityKind] = \"SQL\";\n  /** @internal */\n  decoder = noopDecoder;\n  shouldInlineParams = false;\n  /** @internal */\n  usedTables = [];\n  append(query) {\n    this.queryChunks.push(...query.queryChunks);\n    return this;\n  }\n  toQuery(config) {\n    return tracer.startActiveSpan(\"drizzle.buildSQL\", (span) => {\n      const query = this.buildQueryFromSourceParams(this.queryChunks, config);\n      span?.setAttributes({\n        \"drizzle.query.text\": query.sql,\n        \"drizzle.query.params\": JSON.stringify(query.params)\n      });\n      return query;\n    });\n  }\n  buildQueryFromSourceParams(chunks, _config) {\n    const config = Object.assign({}, _config, {\n      inlineParams: _config.inlineParams || this.shouldInlineParams,\n      paramStartIndex: _config.paramStartIndex || { value: 0 }\n    });\n    const {\n      casing,\n      escapeName,\n      escapeParam,\n      prepareTyping,\n      inlineParams,\n      paramStartIndex\n    } = config;\n    return mergeQueries(chunks.map((chunk) => {\n      if (is(chunk, StringChunk)) {\n        return { sql: chunk.value.join(\"\"), params: [] };\n      }\n      if (is(chunk, Name)) {\n        return { sql: escapeName(chunk.value), params: [] };\n      }\n      if (chunk === void 0) {\n        return { sql: \"\", params: [] };\n      }\n      if (Array.isArray(chunk)) {\n        const result = [new StringChunk(\"(\")];\n        for (const [i, p] of chunk.entries()) {\n          result.push(p);\n          if (i < chunk.length - 1) {\n            result.push(new StringChunk(\", \"));\n          }\n        }\n        result.push(new StringChunk(\")\"));\n        return this.buildQueryFromSourceParams(result, config);\n      }\n      if (is(chunk, SQL)) {\n        return this.buildQueryFromSourceParams(chunk.queryChunks, {\n          ...config,\n          inlineParams: inlineParams || chunk.shouldInlineParams\n        });\n      }\n      if (is(chunk, Table)) {\n        const schemaName = chunk[Table.Symbol.Schema];\n        const tableName = chunk[Table.Symbol.Name];\n        return {\n          sql: schemaName === void 0 || chunk[IsAlias] ? escapeName(tableName) : escapeName(schemaName) + \".\" + escapeName(tableName),\n          params: []\n        };\n      }\n      if (is(chunk, Column)) {\n        const columnName = casing.getColumnCasing(chunk);\n        if (_config.invokeSource === \"indexes\") {\n          return { sql: escapeName(columnName), params: [] };\n        }\n        const schemaName = chunk.table[Table.Symbol.Schema];\n        return {\n          sql: chunk.table[IsAlias] || schemaName === void 0 ? escapeName(chunk.table[Table.Symbol.Name]) + \".\" + escapeName(columnName) : escapeName(schemaName) + \".\" + escapeName(chunk.table[Table.Symbol.Name]) + \".\" + escapeName(columnName),\n          params: []\n        };\n      }\n      if (is(chunk, View)) {\n        const schemaName = chunk[ViewBaseConfig].schema;\n        const viewName = chunk[ViewBaseConfig].name;\n        return {\n          sql: schemaName === void 0 || chunk[ViewBaseConfig].isAlias ? escapeName(viewName) : escapeName(schemaName) + \".\" + escapeName(viewName),\n          params: []\n        };\n      }\n      if (is(chunk, Param)) {\n        if (is(chunk.value, Placeholder)) {\n          return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: [\"none\"] };\n        }\n        const mappedValue = chunk.value === null ? null : chunk.encoder.mapToDriverValue(chunk.value);\n        if (is(mappedValue, SQL)) {\n          return this.buildQueryFromSourceParams([mappedValue], config);\n        }\n        if (inlineParams) {\n          return { sql: this.mapInlineParam(mappedValue, config), params: [] };\n        }\n        let typings = [\"none\"];\n        if (prepareTyping) {\n          typings = [prepareTyping(chunk.encoder)];\n        }\n        return { sql: escapeParam(paramStartIndex.value++, mappedValue), params: [mappedValue], typings };\n      }\n      if (is(chunk, Placeholder)) {\n        return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: [\"none\"] };\n      }\n      if (is(chunk, SQL.Aliased) && chunk.fieldAlias !== void 0) {\n        return { sql: escapeName(chunk.fieldAlias), params: [] };\n      }\n      if (is(chunk, Subquery)) {\n        if (chunk._.isWith) {\n          return { sql: escapeName(chunk._.alias), params: [] };\n        }\n        return this.buildQueryFromSourceParams([\n          new StringChunk(\"(\"),\n          chunk._.sql,\n          new StringChunk(\") \"),\n          new Name(chunk._.alias)\n        ], config);\n      }\n      if (isPgEnum(chunk)) {\n        if (chunk.schema) {\n          return { sql: escapeName(chunk.schema) + \".\" + escapeName(chunk.enumName), params: [] };\n        }\n        return { sql: escapeName(chunk.enumName), params: [] };\n      }\n      if (isSQLWrapper(chunk)) {\n        if (chunk.shouldOmitSQLParens?.()) {\n          return this.buildQueryFromSourceParams([chunk.getSQL()], config);\n        }\n        return this.buildQueryFromSourceParams([\n          new StringChunk(\"(\"),\n          chunk.getSQL(),\n          new StringChunk(\")\")\n        ], config);\n      }\n      if (inlineParams) {\n        return { sql: this.mapInlineParam(chunk, config), params: [] };\n      }\n      return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: [\"none\"] };\n    }));\n  }\n  mapInlineParam(chunk, { escapeString }) {\n    if (chunk === null) {\n      return \"null\";\n    }\n    if (typeof chunk === \"number\" || typeof chunk === \"boolean\") {\n      return chunk.toString();\n    }\n    if (typeof chunk === \"string\") {\n      return escapeString(chunk);\n    }\n    if (typeof chunk === \"object\") {\n      const mappedValueAsString = chunk.toString();\n      if (mappedValueAsString === \"[object Object]\") {\n        return escapeString(JSON.stringify(chunk));\n      }\n      return escapeString(mappedValueAsString);\n    }\n    throw new Error(\"Unexpected param value: \" + chunk);\n  }\n  getSQL() {\n    return this;\n  }\n  as(alias) {\n    if (alias === void 0) {\n      return this;\n    }\n    return new SQL.Aliased(this, alias);\n  }\n  mapWith(decoder) {\n    this.decoder = typeof decoder === \"function\" ? { mapFromDriverValue: decoder } : decoder;\n    return this;\n  }\n  inlineParams() {\n    this.shouldInlineParams = true;\n    return this;\n  }\n  /**\n   * This method is used to conditionally include a part of the query.\n   *\n   * @param condition - Condition to check\n   * @returns itself if the condition is `true`, otherwise `undefined`\n   */\n  if(condition) {\n    return condition ? this : void 0;\n  }\n}\nclass Name {\n  constructor(value) {\n    this.value = value;\n  }\n  static [entityKind] = \"Name\";\n  brand;\n  getSQL() {\n    return new SQL([this]);\n  }\n}\nfunction name(value) {\n  return new Name(value);\n}\nfunction isDriverValueEncoder(value) {\n  return typeof value === \"object\" && value !== null && \"mapToDriverValue\" in value && typeof value.mapToDriverValue === \"function\";\n}\nconst noopDecoder = {\n  mapFromDriverValue: (value) => value\n};\nconst noopEncoder = {\n  mapToDriverValue: (value) => value\n};\nconst noopMapper = {\n  ...noopDecoder,\n  ...noopEncoder\n};\nclass Param {\n  /**\n   * @param value - Parameter value\n   * @param encoder - Encoder to convert the value to a driver parameter\n   */\n  constructor(value, encoder = noopEncoder) {\n    this.value = value;\n    this.encoder = encoder;\n  }\n  static [entityKind] = \"Param\";\n  brand;\n  getSQL() {\n    return new SQL([this]);\n  }\n}\nfunction param(value, encoder) {\n  return new Param(value, encoder);\n}\nfunction sql(strings, ...params) {\n  const queryChunks = [];\n  if (params.length > 0 || strings.length > 0 && strings[0] !== \"\") {\n    queryChunks.push(new StringChunk(strings[0]));\n  }\n  for (const [paramIndex, param2] of params.entries()) {\n    queryChunks.push(param2, new StringChunk(strings[paramIndex + 1]));\n  }\n  return new SQL(queryChunks);\n}\n((sql2) => {\n  function empty() {\n    return new SQL([]);\n  }\n  sql2.empty = empty;\n  function fromList(list) {\n    return new SQL(list);\n  }\n  sql2.fromList = fromList;\n  function raw(str) {\n    return new SQL([new StringChunk(str)]);\n  }\n  sql2.raw = raw;\n  function join(chunks, separator) {\n    const result = [];\n    for (const [i, chunk] of chunks.entries()) {\n      if (i > 0 && separator !== void 0) {\n        result.push(separator);\n      }\n      result.push(chunk);\n    }\n    return new SQL(result);\n  }\n  sql2.join = join;\n  function identifier(value) {\n    return new Name(value);\n  }\n  sql2.identifier = identifier;\n  function placeholder2(name2) {\n    return new Placeholder(name2);\n  }\n  sql2.placeholder = placeholder2;\n  function param2(value, encoder) {\n    return new Param(value, encoder);\n  }\n  sql2.param = param2;\n})(sql || (sql = {}));\n((SQL2) => {\n  class Aliased {\n    constructor(sql2, fieldAlias) {\n      this.sql = sql2;\n      this.fieldAlias = fieldAlias;\n    }\n    static [entityKind] = \"SQL.Aliased\";\n    /** @internal */\n    isSelectionField = false;\n    getSQL() {\n      return this.sql;\n    }\n    /** @internal */\n    clone() {\n      return new Aliased(this.sql, this.fieldAlias);\n    }\n  }\n  SQL2.Aliased = Aliased;\n})(SQL || (SQL = {}));\nclass Placeholder {\n  constructor(name2) {\n    this.name = name2;\n  }\n  static [entityKind] = \"Placeholder\";\n  getSQL() {\n    return new SQL([this]);\n  }\n}\nfunction placeholder(name2) {\n  return new Placeholder(name2);\n}\nfunction fillPlaceholders(params, values) {\n  return params.map((p) => {\n    if (is(p, Placeholder)) {\n      if (!(p.name in values)) {\n        throw new Error(`No value for placeholder \"${p.name}\" was provided`);\n      }\n      return values[p.name];\n    }\n    if (is(p, Param) && is(p.value, Placeholder)) {\n      if (!(p.value.name in values)) {\n        throw new Error(`No value for placeholder \"${p.value.name}\" was provided`);\n      }\n      return p.encoder.mapToDriverValue(values[p.value.name]);\n    }\n    return p;\n  });\n}\nconst IsDrizzleView = Symbol.for(\"drizzle:IsDrizzleView\");\nclass View {\n  static [entityKind] = \"View\";\n  /** @internal */\n  [ViewBaseConfig];\n  /** @internal */\n  [IsDrizzleView] = true;\n  constructor({ name: name2, schema, selectedFields, query }) {\n    this[ViewBaseConfig] = {\n      name: name2,\n      originalName: name2,\n      schema,\n      selectedFields,\n      query,\n      isExisting: !query,\n      isAlias: false\n    };\n  }\n  getSQL() {\n    return new SQL([this]);\n  }\n}\nfunction isView(view) {\n  return typeof view === \"object\" && view !== null && IsDrizzleView in view;\n}\nfunction getViewName(view) {\n  return view[ViewBaseConfig].name;\n}\nColumn.prototype.getSQL = function() {\n  return new SQL([this]);\n};\nTable.prototype.getSQL = function() {\n  return new SQL([this]);\n};\nSubquery.prototype.getSQL = function() {\n  return new SQL([this]);\n};\nexport {\n  FakePrimitiveParam,\n  Name,\n  Param,\n  Placeholder,\n  SQL,\n  StringChunk,\n  View,\n  fillPlaceholders,\n  getViewName,\n  isDriverValueEncoder,\n  isSQLWrapper,\n  isView,\n  name,\n  noopDecoder,\n  noopEncoder,\n  noopMapper,\n  param,\n  placeholder,\n  sql\n};\n//# sourceMappingURL=sql.js.map",
    "import { Column } from \"./column.js\";\nimport { entityKind, is } from \"./entity.js\";\nimport { SQL, sql } from \"./sql/sql.js\";\nimport { Table } from \"./table.js\";\nimport { ViewBaseConfig } from \"./view-common.js\";\nclass ColumnAliasProxyHandler {\n  constructor(table) {\n    this.table = table;\n  }\n  static [entityKind] = \"ColumnAliasProxyHandler\";\n  get(columnObj, prop) {\n    if (prop === \"table\") {\n      return this.table;\n    }\n    return columnObj[prop];\n  }\n}\nclass TableAliasProxyHandler {\n  constructor(alias, replaceOriginalName) {\n    this.alias = alias;\n    this.replaceOriginalName = replaceOriginalName;\n  }\n  static [entityKind] = \"TableAliasProxyHandler\";\n  get(target, prop) {\n    if (prop === Table.Symbol.IsAlias) {\n      return true;\n    }\n    if (prop === Table.Symbol.Name) {\n      return this.alias;\n    }\n    if (this.replaceOriginalName && prop === Table.Symbol.OriginalName) {\n      return this.alias;\n    }\n    if (prop === ViewBaseConfig) {\n      return {\n        ...target[ViewBaseConfig],\n        name: this.alias,\n        isAlias: true\n      };\n    }\n    if (prop === Table.Symbol.Columns) {\n      const columns = target[Table.Symbol.Columns];\n      if (!columns) {\n        return columns;\n      }\n      const proxiedColumns = {};\n      Object.keys(columns).map((key) => {\n        proxiedColumns[key] = new Proxy(\n          columns[key],\n          new ColumnAliasProxyHandler(new Proxy(target, this))\n        );\n      });\n      return proxiedColumns;\n    }\n    const value = target[prop];\n    if (is(value, Column)) {\n      return new Proxy(value, new ColumnAliasProxyHandler(new Proxy(target, this)));\n    }\n    return value;\n  }\n}\nclass RelationTableAliasProxyHandler {\n  constructor(alias) {\n    this.alias = alias;\n  }\n  static [entityKind] = \"RelationTableAliasProxyHandler\";\n  get(target, prop) {\n    if (prop === \"sourceTable\") {\n      return aliasedTable(target.sourceTable, this.alias);\n    }\n    return target[prop];\n  }\n}\nfunction aliasedTable(table, tableAlias) {\n  return new Proxy(table, new TableAliasProxyHandler(tableAlias, false));\n}\nfunction aliasedRelation(relation, tableAlias) {\n  return new Proxy(relation, new RelationTableAliasProxyHandler(tableAlias));\n}\nfunction aliasedTableColumn(column, tableAlias) {\n  return new Proxy(\n    column,\n    new ColumnAliasProxyHandler(new Proxy(column.table, new TableAliasProxyHandler(tableAlias, false)))\n  );\n}\nfunction mapColumnsInAliasedSQLToAlias(query, alias) {\n  return new SQL.Aliased(mapColumnsInSQLToAlias(query.sql, alias), query.fieldAlias);\n}\nfunction mapColumnsInSQLToAlias(query, alias) {\n  return sql.join(query.queryChunks.map((c) => {\n    if (is(c, Column)) {\n      return aliasedTableColumn(c, alias);\n    }\n    if (is(c, SQL)) {\n      return mapColumnsInSQLToAlias(c, alias);\n    }\n    if (is(c, SQL.Aliased)) {\n      return mapColumnsInAliasedSQLToAlias(c, alias);\n    }\n    return c;\n  }));\n}\nexport {\n  ColumnAliasProxyHandler,\n  RelationTableAliasProxyHandler,\n  TableAliasProxyHandler,\n  aliasedRelation,\n  aliasedTable,\n  aliasedTableColumn,\n  mapColumnsInAliasedSQLToAlias,\n  mapColumnsInSQLToAlias\n};\n//# sourceMappingURL=alias.js.map",
    "import { Column } from \"./column.js\";\nimport { is } from \"./entity.js\";\nimport { Param, SQL, View } from \"./sql/sql.js\";\nimport { Subquery } from \"./subquery.js\";\nimport { getTableName, Table } from \"./table.js\";\nimport { ViewBaseConfig } from \"./view-common.js\";\nfunction mapResultRow(columns, row, joinsNotNullableMap) {\n  const nullifyMap = {};\n  const result = columns.reduce(\n    (result2, { path, field }, columnIndex) => {\n      let decoder;\n      if (is(field, Column)) {\n        decoder = field;\n      } else if (is(field, SQL)) {\n        decoder = field.decoder;\n      } else {\n        decoder = field.sql.decoder;\n      }\n      let node = result2;\n      for (const [pathChunkIndex, pathChunk] of path.entries()) {\n        if (pathChunkIndex < path.length - 1) {\n          if (!(pathChunk in node)) {\n            node[pathChunk] = {};\n          }\n          node = node[pathChunk];\n        } else {\n          const rawValue = row[columnIndex];\n          const value = node[pathChunk] = rawValue === null ? null : decoder.mapFromDriverValue(rawValue);\n          if (joinsNotNullableMap && is(field, Column) && path.length === 2) {\n            const objectName = path[0];\n            if (!(objectName in nullifyMap)) {\n              nullifyMap[objectName] = value === null ? getTableName(field.table) : false;\n            } else if (typeof nullifyMap[objectName] === \"string\" && nullifyMap[objectName] !== getTableName(field.table)) {\n              nullifyMap[objectName] = false;\n            }\n          }\n        }\n      }\n      return result2;\n    },\n    {}\n  );\n  if (joinsNotNullableMap && Object.keys(nullifyMap).length > 0) {\n    for (const [objectName, tableName] of Object.entries(nullifyMap)) {\n      if (typeof tableName === \"string\" && !joinsNotNullableMap[tableName]) {\n        result[objectName] = null;\n      }\n    }\n  }\n  return result;\n}\nfunction orderSelectedFields(fields, pathPrefix) {\n  return Object.entries(fields).reduce((result, [name, field]) => {\n    if (typeof name !== \"string\") {\n      return result;\n    }\n    const newPath = pathPrefix ? [...pathPrefix, name] : [name];\n    if (is(field, Column) || is(field, SQL) || is(field, SQL.Aliased)) {\n      result.push({ path: newPath, field });\n    } else if (is(field, Table)) {\n      result.push(...orderSelectedFields(field[Table.Symbol.Columns], newPath));\n    } else {\n      result.push(...orderSelectedFields(field, newPath));\n    }\n    return result;\n  }, []);\n}\nfunction haveSameKeys(left, right) {\n  const leftKeys = Object.keys(left);\n  const rightKeys = Object.keys(right);\n  if (leftKeys.length !== rightKeys.length) {\n    return false;\n  }\n  for (const [index, key] of leftKeys.entries()) {\n    if (key !== rightKeys[index]) {\n      return false;\n    }\n  }\n  return true;\n}\nfunction mapUpdateSet(table, values) {\n  const entries = Object.entries(values).filter(([, value]) => value !== void 0).map(([key, value]) => {\n    if (is(value, SQL) || is(value, Column)) {\n      return [key, value];\n    } else {\n      return [key, new Param(value, table[Table.Symbol.Columns][key])];\n    }\n  });\n  if (entries.length === 0) {\n    throw new Error(\"No values to set\");\n  }\n  return Object.fromEntries(entries);\n}\nfunction applyMixins(baseClass, extendedClasses) {\n  for (const extendedClass of extendedClasses) {\n    for (const name of Object.getOwnPropertyNames(extendedClass.prototype)) {\n      if (name === \"constructor\") continue;\n      Object.defineProperty(\n        baseClass.prototype,\n        name,\n        Object.getOwnPropertyDescriptor(extendedClass.prototype, name) || /* @__PURE__ */ Object.create(null)\n      );\n    }\n  }\n}\nfunction getTableColumns(table) {\n  return table[Table.Symbol.Columns];\n}\nfunction getViewSelectedFields(view) {\n  return view[ViewBaseConfig].selectedFields;\n}\nfunction getTableLikeName(table) {\n  return is(table, Subquery) ? table._.alias : is(table, View) ? table[ViewBaseConfig].name : is(table, SQL) ? void 0 : table[Table.Symbol.IsAlias] ? table[Table.Symbol.Name] : table[Table.Symbol.BaseName];\n}\nfunction getColumnNameAndConfig(a, b) {\n  return {\n    name: typeof a === \"string\" && a.length > 0 ? a : \"\",\n    config: typeof a === \"object\" ? a : b\n  };\n}\nconst _ = {};\nconst __ = {};\nfunction isConfig(data) {\n  if (typeof data !== \"object\" || data === null) return false;\n  if (data.constructor.name !== \"Object\") return false;\n  if (\"logger\" in data) {\n    const type = typeof data[\"logger\"];\n    if (type !== \"boolean\" && (type !== \"object\" || typeof data[\"logger\"][\"logQuery\"] !== \"function\") && type !== \"undefined\") return false;\n    return true;\n  }\n  if (\"schema\" in data) {\n    const type = typeof data[\"schema\"];\n    if (type !== \"object\" && type !== \"undefined\") return false;\n    return true;\n  }\n  if (\"casing\" in data) {\n    const type = typeof data[\"casing\"];\n    if (type !== \"string\" && type !== \"undefined\") return false;\n    return true;\n  }\n  if (\"mode\" in data) {\n    if (data[\"mode\"] !== \"default\" || data[\"mode\"] !== \"planetscale\" || data[\"mode\"] !== void 0) return false;\n    return true;\n  }\n  if (\"connection\" in data) {\n    const type = typeof data[\"connection\"];\n    if (type !== \"string\" && type !== \"object\" && type !== \"undefined\") return false;\n    return true;\n  }\n  if (\"client\" in data) {\n    const type = typeof data[\"client\"];\n    if (type !== \"object\" && type !== \"function\" && type !== \"undefined\") return false;\n    return true;\n  }\n  if (Object.keys(data).length === 0) return true;\n  return false;\n}\nconst textDecoder = typeof TextDecoder === \"undefined\" ? null : new TextDecoder();\nexport {\n  applyMixins,\n  getColumnNameAndConfig,\n  getTableColumns,\n  getTableLikeName,\n  getViewSelectedFields,\n  haveSameKeys,\n  isConfig,\n  mapResultRow,\n  mapUpdateSet,\n  orderSelectedFields,\n  textDecoder\n};\n//# sourceMappingURL=utils.js.map",
    "import { entityKind } from \"../entity.js\";\nimport { TableName } from \"../table.utils.js\";\nclass ForeignKeyBuilder {\n  static [entityKind] = \"SQLiteForeignKeyBuilder\";\n  /** @internal */\n  reference;\n  /** @internal */\n  _onUpdate;\n  /** @internal */\n  _onDelete;\n  constructor(config, actions) {\n    this.reference = () => {\n      const { name, columns, foreignColumns } = config();\n      return { name, columns, foreignTable: foreignColumns[0].table, foreignColumns };\n    };\n    if (actions) {\n      this._onUpdate = actions.onUpdate;\n      this._onDelete = actions.onDelete;\n    }\n  }\n  onUpdate(action) {\n    this._onUpdate = action;\n    return this;\n  }\n  onDelete(action) {\n    this._onDelete = action;\n    return this;\n  }\n  /** @internal */\n  build(table) {\n    return new ForeignKey(table, this);\n  }\n}\nclass ForeignKey {\n  constructor(table, builder) {\n    this.table = table;\n    this.reference = builder.reference;\n    this.onUpdate = builder._onUpdate;\n    this.onDelete = builder._onDelete;\n  }\n  static [entityKind] = \"SQLiteForeignKey\";\n  reference;\n  onUpdate;\n  onDelete;\n  getName() {\n    const { name, columns, foreignColumns } = this.reference();\n    const columnNames = columns.map((column) => column.name);\n    const foreignColumnNames = foreignColumns.map((column) => column.name);\n    const chunks = [\n      this.table[TableName],\n      ...columnNames,\n      foreignColumns[0].table[TableName],\n      ...foreignColumnNames\n    ];\n    return name ?? `${chunks.join(\"_\")}_fk`;\n  }\n}\nfunction foreignKey(config) {\n  function mappedConfig() {\n    if (typeof config === \"function\") {\n      const { name, columns, foreignColumns } = config();\n      return {\n        name,\n        columns,\n        foreignColumns\n      };\n    }\n    return config;\n  }\n  return new ForeignKeyBuilder(mappedConfig);\n}\nexport {\n  ForeignKey,\n  ForeignKeyBuilder,\n  foreignKey\n};\n//# sourceMappingURL=foreign-keys.js.map",
    "import { entityKind } from \"../entity.js\";\nimport { TableName } from \"../table.utils.js\";\nfunction uniqueKeyName(table, columns) {\n  return `${table[TableName]}_${columns.join(\"_\")}_unique`;\n}\nfunction unique(name) {\n  return new UniqueOnConstraintBuilder(name);\n}\nclass UniqueConstraintBuilder {\n  constructor(columns, name) {\n    this.name = name;\n    this.columns = columns;\n  }\n  static [entityKind] = \"SQLiteUniqueConstraintBuilder\";\n  /** @internal */\n  columns;\n  /** @internal */\n  build(table) {\n    return new UniqueConstraint(table, this.columns, this.name);\n  }\n}\nclass UniqueOnConstraintBuilder {\n  static [entityKind] = \"SQLiteUniqueOnConstraintBuilder\";\n  /** @internal */\n  name;\n  constructor(name) {\n    this.name = name;\n  }\n  on(...columns) {\n    return new UniqueConstraintBuilder(columns, this.name);\n  }\n}\nclass UniqueConstraint {\n  constructor(table, columns, name) {\n    this.table = table;\n    this.columns = columns;\n    this.name = name ?? uniqueKeyName(this.table, this.columns.map((column) => column.name));\n  }\n  static [entityKind] = \"SQLiteUniqueConstraint\";\n  columns;\n  name;\n  getName() {\n    return this.name;\n  }\n}\nexport {\n  UniqueConstraint,\n  UniqueConstraintBuilder,\n  UniqueOnConstraintBuilder,\n  unique,\n  uniqueKeyName\n};\n//# sourceMappingURL=unique-constraint.js.map",
    "import { ColumnBuilder } from \"../../column-builder.js\";\nimport { Column } from \"../../column.js\";\nimport { entityKind } from \"../../entity.js\";\nimport { ForeignKeyBuilder } from \"../foreign-keys.js\";\nimport { uniqueKeyName } from \"../unique-constraint.js\";\nclass SQLiteColumnBuilder extends ColumnBuilder {\n  static [entityKind] = \"SQLiteColumnBuilder\";\n  foreignKeyConfigs = [];\n  references(ref, actions = {}) {\n    this.foreignKeyConfigs.push({ ref, actions });\n    return this;\n  }\n  unique(name) {\n    this.config.isUnique = true;\n    this.config.uniqueName = name;\n    return this;\n  }\n  generatedAlwaysAs(as, config) {\n    this.config.generated = {\n      as,\n      type: \"always\",\n      mode: config?.mode ?? \"virtual\"\n    };\n    return this;\n  }\n  /** @internal */\n  buildForeignKeys(column, table) {\n    return this.foreignKeyConfigs.map(({ ref, actions }) => {\n      return ((ref2, actions2) => {\n        const builder = new ForeignKeyBuilder(() => {\n          const foreignColumn = ref2();\n          return { columns: [column], foreignColumns: [foreignColumn] };\n        });\n        if (actions2.onUpdate) {\n          builder.onUpdate(actions2.onUpdate);\n        }\n        if (actions2.onDelete) {\n          builder.onDelete(actions2.onDelete);\n        }\n        return builder.build(table);\n      })(ref, actions);\n    });\n  }\n}\nclass SQLiteColumn extends Column {\n  constructor(table, config) {\n    if (!config.uniqueName) {\n      config.uniqueName = uniqueKeyName(table, [config.name]);\n    }\n    super(table, config);\n    this.table = table;\n  }\n  static [entityKind] = \"SQLiteColumn\";\n}\nexport {\n  SQLiteColumn,\n  SQLiteColumnBuilder\n};\n//# sourceMappingURL=common.js.map",
    "import { entityKind } from \"../../entity.js\";\nimport { getColumnNameAndConfig, textDecoder } from \"../../utils.js\";\nimport { SQLiteColumn, SQLiteColumnBuilder } from \"./common.js\";\nclass SQLiteBigIntBuilder extends SQLiteColumnBuilder {\n  static [entityKind] = \"SQLiteBigIntBuilder\";\n  constructor(name) {\n    super(name, \"bigint\", \"SQLiteBigInt\");\n  }\n  /** @internal */\n  build(table) {\n    return new SQLiteBigInt(table, this.config);\n  }\n}\nclass SQLiteBigInt extends SQLiteColumn {\n  static [entityKind] = \"SQLiteBigInt\";\n  getSQLType() {\n    return \"blob\";\n  }\n  mapFromDriverValue(value) {\n    if (typeof Buffer !== \"undefined\" && Buffer.from) {\n      const buf = Buffer.isBuffer(value) ? value : value instanceof ArrayBuffer ? Buffer.from(value) : value.buffer ? Buffer.from(value.buffer, value.byteOffset, value.byteLength) : Buffer.from(value);\n      return BigInt(buf.toString(\"utf8\"));\n    }\n    return BigInt(textDecoder.decode(value));\n  }\n  mapToDriverValue(value) {\n    return Buffer.from(value.toString());\n  }\n}\nclass SQLiteBlobJsonBuilder extends SQLiteColumnBuilder {\n  static [entityKind] = \"SQLiteBlobJsonBuilder\";\n  constructor(name) {\n    super(name, \"json\", \"SQLiteBlobJson\");\n  }\n  /** @internal */\n  build(table) {\n    return new SQLiteBlobJson(\n      table,\n      this.config\n    );\n  }\n}\nclass SQLiteBlobJson extends SQLiteColumn {\n  static [entityKind] = \"SQLiteBlobJson\";\n  getSQLType() {\n    return \"blob\";\n  }\n  mapFromDriverValue(value) {\n    if (typeof Buffer !== \"undefined\" && Buffer.from) {\n      const buf = Buffer.isBuffer(value) ? value : value instanceof ArrayBuffer ? Buffer.from(value) : value.buffer ? Buffer.from(value.buffer, value.byteOffset, value.byteLength) : Buffer.from(value);\n      return JSON.parse(buf.toString(\"utf8\"));\n    }\n    return JSON.parse(textDecoder.decode(value));\n  }\n  mapToDriverValue(value) {\n    return Buffer.from(JSON.stringify(value));\n  }\n}\nclass SQLiteBlobBufferBuilder extends SQLiteColumnBuilder {\n  static [entityKind] = \"SQLiteBlobBufferBuilder\";\n  constructor(name) {\n    super(name, \"buffer\", \"SQLiteBlobBuffer\");\n  }\n  /** @internal */\n  build(table) {\n    return new SQLiteBlobBuffer(table, this.config);\n  }\n}\nclass SQLiteBlobBuffer extends SQLiteColumn {\n  static [entityKind] = \"SQLiteBlobBuffer\";\n  mapFromDriverValue(value) {\n    if (Buffer.isBuffer(value)) {\n      return value;\n    }\n    return Buffer.from(value);\n  }\n  getSQLType() {\n    return \"blob\";\n  }\n}\nfunction blob(a, b) {\n  const { name, config } = getColumnNameAndConfig(a, b);\n  if (config?.mode === \"json\") {\n    return new SQLiteBlobJsonBuilder(name);\n  }\n  if (config?.mode === \"bigint\") {\n    return new SQLiteBigIntBuilder(name);\n  }\n  return new SQLiteBlobBufferBuilder(name);\n}\nexport {\n  SQLiteBigInt,\n  SQLiteBigIntBuilder,\n  SQLiteBlobBuffer,\n  SQLiteBlobBufferBuilder,\n  SQLiteBlobJson,\n  SQLiteBlobJsonBuilder,\n  blob\n};\n//# sourceMappingURL=blob.js.map",
    "import { entityKind } from \"../../entity.js\";\nimport { getColumnNameAndConfig } from \"../../utils.js\";\nimport { SQLiteColumn, SQLiteColumnBuilder } from \"./common.js\";\nclass SQLiteCustomColumnBuilder extends SQLiteColumnBuilder {\n  static [entityKind] = \"SQLiteCustomColumnBuilder\";\n  constructor(name, fieldConfig, customTypeParams) {\n    super(name, \"custom\", \"SQLiteCustomColumn\");\n    this.config.fieldConfig = fieldConfig;\n    this.config.customTypeParams = customTypeParams;\n  }\n  /** @internal */\n  build(table) {\n    return new SQLiteCustomColumn(\n      table,\n      this.config\n    );\n  }\n}\nclass SQLiteCustomColumn extends SQLiteColumn {\n  static [entityKind] = \"SQLiteCustomColumn\";\n  sqlName;\n  mapTo;\n  mapFrom;\n  constructor(table, config) {\n    super(table, config);\n    this.sqlName = config.customTypeParams.dataType(config.fieldConfig);\n    this.mapTo = config.customTypeParams.toDriver;\n    this.mapFrom = config.customTypeParams.fromDriver;\n  }\n  getSQLType() {\n    return this.sqlName;\n  }\n  mapFromDriverValue(value) {\n    return typeof this.mapFrom === \"function\" ? this.mapFrom(value) : value;\n  }\n  mapToDriverValue(value) {\n    return typeof this.mapTo === \"function\" ? this.mapTo(value) : value;\n  }\n}\nfunction customType(customTypeParams) {\n  return (a, b) => {\n    const { name, config } = getColumnNameAndConfig(a, b);\n    return new SQLiteCustomColumnBuilder(\n      name,\n      config,\n      customTypeParams\n    );\n  };\n}\nexport {\n  SQLiteCustomColumn,\n  SQLiteCustomColumnBuilder,\n  customType\n};\n//# sourceMappingURL=custom.js.map",
    "import { entityKind } from \"../../entity.js\";\nimport { sql } from \"../../sql/sql.js\";\nimport { getColumnNameAndConfig } from \"../../utils.js\";\nimport { SQLiteColumn, SQLiteColumnBuilder } from \"./common.js\";\nclass SQLiteBaseIntegerBuilder extends SQLiteColumnBuilder {\n  static [entityKind] = \"SQLiteBaseIntegerBuilder\";\n  constructor(name, dataType, columnType) {\n    super(name, dataType, columnType);\n    this.config.autoIncrement = false;\n  }\n  primaryKey(config) {\n    if (config?.autoIncrement) {\n      this.config.autoIncrement = true;\n    }\n    this.config.hasDefault = true;\n    return super.primaryKey();\n  }\n}\nclass SQLiteBaseInteger extends SQLiteColumn {\n  static [entityKind] = \"SQLiteBaseInteger\";\n  autoIncrement = this.config.autoIncrement;\n  getSQLType() {\n    return \"integer\";\n  }\n}\nclass SQLiteIntegerBuilder extends SQLiteBaseIntegerBuilder {\n  static [entityKind] = \"SQLiteIntegerBuilder\";\n  constructor(name) {\n    super(name, \"number\", \"SQLiteInteger\");\n  }\n  build(table) {\n    return new SQLiteInteger(\n      table,\n      this.config\n    );\n  }\n}\nclass SQLiteInteger extends SQLiteBaseInteger {\n  static [entityKind] = \"SQLiteInteger\";\n}\nclass SQLiteTimestampBuilder extends SQLiteBaseIntegerBuilder {\n  static [entityKind] = \"SQLiteTimestampBuilder\";\n  constructor(name, mode) {\n    super(name, \"date\", \"SQLiteTimestamp\");\n    this.config.mode = mode;\n  }\n  /**\n   * @deprecated Use `default()` with your own expression instead.\n   *\n   * Adds `DEFAULT (cast((julianday('now') - 2440587.5)*86400000 as integer))` to the column, which is the current epoch timestamp in milliseconds.\n   */\n  defaultNow() {\n    return this.default(sql`(cast((julianday('now') - 2440587.5)*86400000 as integer))`);\n  }\n  build(table) {\n    return new SQLiteTimestamp(\n      table,\n      this.config\n    );\n  }\n}\nclass SQLiteTimestamp extends SQLiteBaseInteger {\n  static [entityKind] = \"SQLiteTimestamp\";\n  mode = this.config.mode;\n  mapFromDriverValue(value) {\n    if (this.config.mode === \"timestamp\") {\n      return new Date(value * 1e3);\n    }\n    return new Date(value);\n  }\n  mapToDriverValue(value) {\n    const unix = value.getTime();\n    if (this.config.mode === \"timestamp\") {\n      return Math.floor(unix / 1e3);\n    }\n    return unix;\n  }\n}\nclass SQLiteBooleanBuilder extends SQLiteBaseIntegerBuilder {\n  static [entityKind] = \"SQLiteBooleanBuilder\";\n  constructor(name, mode) {\n    super(name, \"boolean\", \"SQLiteBoolean\");\n    this.config.mode = mode;\n  }\n  build(table) {\n    return new SQLiteBoolean(\n      table,\n      this.config\n    );\n  }\n}\nclass SQLiteBoolean extends SQLiteBaseInteger {\n  static [entityKind] = \"SQLiteBoolean\";\n  mode = this.config.mode;\n  mapFromDriverValue(value) {\n    return Number(value) === 1;\n  }\n  mapToDriverValue(value) {\n    return value ? 1 : 0;\n  }\n}\nfunction integer(a, b) {\n  const { name, config } = getColumnNameAndConfig(a, b);\n  if (config?.mode === \"timestamp\" || config?.mode === \"timestamp_ms\") {\n    return new SQLiteTimestampBuilder(name, config.mode);\n  }\n  if (config?.mode === \"boolean\") {\n    return new SQLiteBooleanBuilder(name, config.mode);\n  }\n  return new SQLiteIntegerBuilder(name);\n}\nconst int = integer;\nexport {\n  SQLiteBaseInteger,\n  SQLiteBaseIntegerBuilder,\n  SQLiteBoolean,\n  SQLiteBooleanBuilder,\n  SQLiteInteger,\n  SQLiteIntegerBuilder,\n  SQLiteTimestamp,\n  SQLiteTimestampBuilder,\n  int,\n  integer\n};\n//# sourceMappingURL=integer.js.map",
    "import { entityKind } from \"../../entity.js\";\nimport { getColumnNameAndConfig } from \"../../utils.js\";\nimport { SQLiteColumn, SQLiteColumnBuilder } from \"./common.js\";\nclass SQLiteNumericBuilder extends SQLiteColumnBuilder {\n  static [entityKind] = \"SQLiteNumericBuilder\";\n  constructor(name) {\n    super(name, \"string\", \"SQLiteNumeric\");\n  }\n  /** @internal */\n  build(table) {\n    return new SQLiteNumeric(\n      table,\n      this.config\n    );\n  }\n}\nclass SQLiteNumeric extends SQLiteColumn {\n  static [entityKind] = \"SQLiteNumeric\";\n  mapFromDriverValue(value) {\n    if (typeof value === \"string\") return value;\n    return String(value);\n  }\n  getSQLType() {\n    return \"numeric\";\n  }\n}\nclass SQLiteNumericNumberBuilder extends SQLiteColumnBuilder {\n  static [entityKind] = \"SQLiteNumericNumberBuilder\";\n  constructor(name) {\n    super(name, \"number\", \"SQLiteNumericNumber\");\n  }\n  /** @internal */\n  build(table) {\n    return new SQLiteNumericNumber(\n      table,\n      this.config\n    );\n  }\n}\nclass SQLiteNumericNumber extends SQLiteColumn {\n  static [entityKind] = \"SQLiteNumericNumber\";\n  mapFromDriverValue(value) {\n    if (typeof value === \"number\") return value;\n    return Number(value);\n  }\n  mapToDriverValue = String;\n  getSQLType() {\n    return \"numeric\";\n  }\n}\nclass SQLiteNumericBigIntBuilder extends SQLiteColumnBuilder {\n  static [entityKind] = \"SQLiteNumericBigIntBuilder\";\n  constructor(name) {\n    super(name, \"bigint\", \"SQLiteNumericBigInt\");\n  }\n  /** @internal */\n  build(table) {\n    return new SQLiteNumericBigInt(\n      table,\n      this.config\n    );\n  }\n}\nclass SQLiteNumericBigInt extends SQLiteColumn {\n  static [entityKind] = \"SQLiteNumericBigInt\";\n  mapFromDriverValue = BigInt;\n  mapToDriverValue = String;\n  getSQLType() {\n    return \"numeric\";\n  }\n}\nfunction numeric(a, b) {\n  const { name, config } = getColumnNameAndConfig(a, b);\n  const mode = config?.mode;\n  return mode === \"number\" ? new SQLiteNumericNumberBuilder(name) : mode === \"bigint\" ? new SQLiteNumericBigIntBuilder(name) : new SQLiteNumericBuilder(name);\n}\nexport {\n  SQLiteNumeric,\n  SQLiteNumericBigInt,\n  SQLiteNumericBigIntBuilder,\n  SQLiteNumericBuilder,\n  SQLiteNumericNumber,\n  SQLiteNumericNumberBuilder,\n  numeric\n};\n//# sourceMappingURL=numeric.js.map",
    "import { entityKind } from \"../../entity.js\";\nimport { SQLiteColumn, SQLiteColumnBuilder } from \"./common.js\";\nclass SQLiteRealBuilder extends SQLiteColumnBuilder {\n  static [entityKind] = \"SQLiteRealBuilder\";\n  constructor(name) {\n    super(name, \"number\", \"SQLiteReal\");\n  }\n  /** @internal */\n  build(table) {\n    return new SQLiteReal(table, this.config);\n  }\n}\nclass SQLiteReal extends SQLiteColumn {\n  static [entityKind] = \"SQLiteReal\";\n  getSQLType() {\n    return \"real\";\n  }\n}\nfunction real(name) {\n  return new SQLiteRealBuilder(name ?? \"\");\n}\nexport {\n  SQLiteReal,\n  SQLiteRealBuilder,\n  real\n};\n//# sourceMappingURL=real.js.map",
    "import { entityKind } from \"../../entity.js\";\nimport { getColumnNameAndConfig } from \"../../utils.js\";\nimport { SQLiteColumn, SQLiteColumnBuilder } from \"./common.js\";\nclass SQLiteTextBuilder extends SQLiteColumnBuilder {\n  static [entityKind] = \"SQLiteTextBuilder\";\n  constructor(name, config) {\n    super(name, \"string\", \"SQLiteText\");\n    this.config.enumValues = config.enum;\n    this.config.length = config.length;\n  }\n  /** @internal */\n  build(table) {\n    return new SQLiteText(\n      table,\n      this.config\n    );\n  }\n}\nclass SQLiteText extends SQLiteColumn {\n  static [entityKind] = \"SQLiteText\";\n  enumValues = this.config.enumValues;\n  length = this.config.length;\n  constructor(table, config) {\n    super(table, config);\n  }\n  getSQLType() {\n    return `text${this.config.length ? `(${this.config.length})` : \"\"}`;\n  }\n}\nclass SQLiteTextJsonBuilder extends SQLiteColumnBuilder {\n  static [entityKind] = \"SQLiteTextJsonBuilder\";\n  constructor(name) {\n    super(name, \"json\", \"SQLiteTextJson\");\n  }\n  /** @internal */\n  build(table) {\n    return new SQLiteTextJson(\n      table,\n      this.config\n    );\n  }\n}\nclass SQLiteTextJson extends SQLiteColumn {\n  static [entityKind] = \"SQLiteTextJson\";\n  getSQLType() {\n    return \"text\";\n  }\n  mapFromDriverValue(value) {\n    return JSON.parse(value);\n  }\n  mapToDriverValue(value) {\n    return JSON.stringify(value);\n  }\n}\nfunction text(a, b = {}) {\n  const { name, config } = getColumnNameAndConfig(a, b);\n  if (config.mode === \"json\") {\n    return new SQLiteTextJsonBuilder(name);\n  }\n  return new SQLiteTextBuilder(name, config);\n}\nexport {\n  SQLiteText,\n  SQLiteTextBuilder,\n  SQLiteTextJson,\n  SQLiteTextJsonBuilder,\n  text\n};\n//# sourceMappingURL=text.js.map",
    "import { ColumnAliasProxyHandler, TableAliasProxyHandler } from \"./alias.js\";\nimport { Column } from \"./column.js\";\nimport { entityKind, is } from \"./entity.js\";\nimport { SQL, View } from \"./sql/sql.js\";\nimport { Subquery } from \"./subquery.js\";\nimport { ViewBaseConfig } from \"./view-common.js\";\nclass SelectionProxyHandler {\n  static [entityKind] = \"SelectionProxyHandler\";\n  config;\n  constructor(config) {\n    this.config = { ...config };\n  }\n  get(subquery, prop) {\n    if (prop === \"_\") {\n      return {\n        ...subquery[\"_\"],\n        selectedFields: new Proxy(\n          subquery._.selectedFields,\n          this\n        )\n      };\n    }\n    if (prop === ViewBaseConfig) {\n      return {\n        ...subquery[ViewBaseConfig],\n        selectedFields: new Proxy(\n          subquery[ViewBaseConfig].selectedFields,\n          this\n        )\n      };\n    }\n    if (typeof prop === \"symbol\") {\n      return subquery[prop];\n    }\n    const columns = is(subquery, Subquery) ? subquery._.selectedFields : is(subquery, View) ? subquery[ViewBaseConfig].selectedFields : subquery;\n    const value = columns[prop];\n    if (is(value, SQL.Aliased)) {\n      if (this.config.sqlAliasedBehavior === \"sql\" && !value.isSelectionField) {\n        return value.sql;\n      }\n      const newValue = value.clone();\n      newValue.isSelectionField = true;\n      return newValue;\n    }\n    if (is(value, SQL)) {\n      if (this.config.sqlBehavior === \"sql\") {\n        return value;\n      }\n      throw new Error(\n        `You tried to reference \"${prop}\" field from a subquery, which is a raw SQL field, but it doesn't have an alias declared. Please add an alias to the field using \".as('alias')\" method.`\n      );\n    }\n    if (is(value, Column)) {\n      if (this.config.alias) {\n        return new Proxy(\n          value,\n          new ColumnAliasProxyHandler(\n            new Proxy(\n              value.table,\n              new TableAliasProxyHandler(this.config.alias, this.config.replaceOriginalName ?? false)\n            )\n          )\n        );\n      }\n      return value;\n    }\n    if (typeof value !== \"object\" || value === null) {\n      return value;\n    }\n    return new Proxy(value, new SelectionProxyHandler(this.config));\n  }\n}\nexport {\n  SelectionProxyHandler\n};\n//# sourceMappingURL=selection-proxy.js.map",
    "import { entityKind } from \"./entity.js\";\nclass QueryPromise {\n  static [entityKind] = \"QueryPromise\";\n  [Symbol.toStringTag] = \"QueryPromise\";\n  catch(onRejected) {\n    return this.then(void 0, onRejected);\n  }\n  finally(onFinally) {\n    return this.then(\n      (value) => {\n        onFinally?.();\n        return value;\n      },\n      (reason) => {\n        onFinally?.();\n        throw reason;\n      }\n    );\n  }\n  then(onFulfilled, onRejected) {\n    return this.execute().then(onFulfilled, onRejected);\n  }\n}\nexport {\n  QueryPromise\n};\n//# sourceMappingURL=query-promise.js.map",
    "import { blob } from \"./blob.js\";\nimport { customType } from \"./custom.js\";\nimport { integer } from \"./integer.js\";\nimport { numeric } from \"./numeric.js\";\nimport { real } from \"./real.js\";\nimport { text } from \"./text.js\";\nfunction getSQLiteColumnBuilders() {\n  return {\n    blob,\n    customType,\n    integer,\n    numeric,\n    real,\n    text\n  };\n}\nexport {\n  getSQLiteColumnBuilders\n};\n//# sourceMappingURL=all.js.map",
    "import { entityKind } from \"../entity.js\";\nimport { Table } from \"../table.js\";\nimport { getSQLiteColumnBuilders } from \"./columns/all.js\";\nconst InlineForeignKeys = Symbol.for(\"drizzle:SQLiteInlineForeignKeys\");\nclass SQLiteTable extends Table {\n  static [entityKind] = \"SQLiteTable\";\n  /** @internal */\n  static Symbol = Object.assign({}, Table.Symbol, {\n    InlineForeignKeys\n  });\n  /** @internal */\n  [Table.Symbol.Columns];\n  /** @internal */\n  [InlineForeignKeys] = [];\n  /** @internal */\n  [Table.Symbol.ExtraConfigBuilder] = void 0;\n}\nfunction sqliteTableBase(name, columns, extraConfig, schema, baseName = name) {\n  const rawTable = new SQLiteTable(name, schema, baseName);\n  const parsedColumns = typeof columns === \"function\" ? columns(getSQLiteColumnBuilders()) : columns;\n  const builtColumns = Object.fromEntries(\n    Object.entries(parsedColumns).map(([name2, colBuilderBase]) => {\n      const colBuilder = colBuilderBase;\n      colBuilder.setName(name2);\n      const column = colBuilder.build(rawTable);\n      rawTable[InlineForeignKeys].push(...colBuilder.buildForeignKeys(column, rawTable));\n      return [name2, column];\n    })\n  );\n  const table = Object.assign(rawTable, builtColumns);\n  table[Table.Symbol.Columns] = builtColumns;\n  table[Table.Symbol.ExtraConfigColumns] = builtColumns;\n  if (extraConfig) {\n    table[SQLiteTable.Symbol.ExtraConfigBuilder] = extraConfig;\n  }\n  return table;\n}\nconst sqliteTable = (name, columns, extraConfig) => {\n  return sqliteTableBase(name, columns, extraConfig);\n};\nfunction sqliteTableCreator(customizeTableName) {\n  return (name, columns, extraConfig) => {\n    return sqliteTableBase(customizeTableName(name), columns, extraConfig, void 0, name);\n  };\n}\nexport {\n  InlineForeignKeys,\n  SQLiteTable,\n  sqliteTable,\n  sqliteTableCreator\n};\n//# sourceMappingURL=table.js.map",
    "import { entityKind } from \"../entity.js\";\nclass IndexBuilderOn {\n  constructor(name, unique) {\n    this.name = name;\n    this.unique = unique;\n  }\n  static [entityKind] = \"SQLiteIndexBuilderOn\";\n  on(...columns) {\n    return new IndexBuilder(this.name, columns, this.unique);\n  }\n}\nclass IndexBuilder {\n  static [entityKind] = \"SQLiteIndexBuilder\";\n  /** @internal */\n  config;\n  constructor(name, columns, unique) {\n    this.config = {\n      name,\n      columns,\n      unique,\n      where: void 0\n    };\n  }\n  /**\n   * Condition for partial index.\n   */\n  where(condition) {\n    this.config.where = condition;\n    return this;\n  }\n  /** @internal */\n  build(table) {\n    return new Index(this.config, table);\n  }\n}\nclass Index {\n  static [entityKind] = \"SQLiteIndex\";\n  config;\n  constructor(config, table) {\n    this.config = { ...config, table };\n  }\n}\nfunction index(name) {\n  return new IndexBuilderOn(name, false);\n}\nfunction uniqueIndex(name) {\n  return new IndexBuilderOn(name, true);\n}\nexport {\n  Index,\n  IndexBuilder,\n  IndexBuilderOn,\n  index,\n  uniqueIndex\n};\n//# sourceMappingURL=indexes.js.map",
    "import { is } from \"../entity.js\";\nimport { SQL } from \"../sql/sql.js\";\nimport { Subquery } from \"../subquery.js\";\nimport { Table } from \"../table.js\";\nimport { ViewBaseConfig } from \"../view-common.js\";\nimport { CheckBuilder } from \"./checks.js\";\nimport { ForeignKeyBuilder } from \"./foreign-keys.js\";\nimport { IndexBuilder } from \"./indexes.js\";\nimport { PrimaryKeyBuilder } from \"./primary-keys.js\";\nimport { SQLiteTable } from \"./table.js\";\nimport { UniqueConstraintBuilder } from \"./unique-constraint.js\";\nfunction getTableConfig(table) {\n  const columns = Object.values(table[SQLiteTable.Symbol.Columns]);\n  const indexes = [];\n  const checks = [];\n  const primaryKeys = [];\n  const uniqueConstraints = [];\n  const foreignKeys = Object.values(table[SQLiteTable.Symbol.InlineForeignKeys]);\n  const name = table[Table.Symbol.Name];\n  const extraConfigBuilder = table[SQLiteTable.Symbol.ExtraConfigBuilder];\n  if (extraConfigBuilder !== void 0) {\n    const extraConfig = extraConfigBuilder(table[SQLiteTable.Symbol.Columns]);\n    const extraValues = Array.isArray(extraConfig) ? extraConfig.flat(1) : Object.values(extraConfig);\n    for (const builder of Object.values(extraValues)) {\n      if (is(builder, IndexBuilder)) {\n        indexes.push(builder.build(table));\n      } else if (is(builder, CheckBuilder)) {\n        checks.push(builder.build(table));\n      } else if (is(builder, UniqueConstraintBuilder)) {\n        uniqueConstraints.push(builder.build(table));\n      } else if (is(builder, PrimaryKeyBuilder)) {\n        primaryKeys.push(builder.build(table));\n      } else if (is(builder, ForeignKeyBuilder)) {\n        foreignKeys.push(builder.build(table));\n      }\n    }\n  }\n  return {\n    columns,\n    indexes,\n    foreignKeys,\n    checks,\n    primaryKeys,\n    uniqueConstraints,\n    name\n  };\n}\nfunction extractUsedTable(table) {\n  if (is(table, SQLiteTable)) {\n    return [`${table[Table.Symbol.BaseName]}`];\n  }\n  if (is(table, Subquery)) {\n    return table._.usedTables ?? [];\n  }\n  if (is(table, SQL)) {\n    return table.usedTables ?? [];\n  }\n  return [];\n}\nfunction getViewConfig(view) {\n  return {\n    ...view[ViewBaseConfig]\n    // ...view[SQLiteViewConfig],\n  };\n}\nexport {\n  extractUsedTable,\n  getTableConfig,\n  getViewConfig\n};\n//# sourceMappingURL=utils.js.map",
    "import { entityKind } from \"../../entity.js\";\nimport { QueryPromise } from \"../../query-promise.js\";\nimport { SelectionProxyHandler } from \"../../selection-proxy.js\";\nimport { SQLiteTable } from \"../table.js\";\nimport { Table } from \"../../table.js\";\nimport { orderSelectedFields } from \"../../utils.js\";\nimport { extractUsedTable } from \"../utils.js\";\nclass SQLiteDeleteBase extends QueryPromise {\n  constructor(table, session, dialect, withList) {\n    super();\n    this.table = table;\n    this.session = session;\n    this.dialect = dialect;\n    this.config = { table, withList };\n  }\n  static [entityKind] = \"SQLiteDelete\";\n  /** @internal */\n  config;\n  /**\n   * Adds a `where` clause to the query.\n   *\n   * Calling this method will delete only those rows that fulfill a specified condition.\n   *\n   * See docs: {@link https://orm.drizzle.team/docs/delete}\n   *\n   * @param where the `where` clause.\n   *\n   * @example\n   * You can use conditional operators and `sql function` to filter the rows to be deleted.\n   *\n   * ```ts\n   * // Delete all cars with green color\n   * db.delete(cars).where(eq(cars.color, 'green'));\n   * // or\n   * db.delete(cars).where(sql`${cars.color} = 'green'`)\n   * ```\n   *\n   * You can logically combine conditional operators with `and()` and `or()` operators:\n   *\n   * ```ts\n   * // Delete all BMW cars with a green color\n   * db.delete(cars).where(and(eq(cars.color, 'green'), eq(cars.brand, 'BMW')));\n   *\n   * // Delete all cars with the green or blue color\n   * db.delete(cars).where(or(eq(cars.color, 'green'), eq(cars.color, 'blue')));\n   * ```\n   */\n  where(where) {\n    this.config.where = where;\n    return this;\n  }\n  orderBy(...columns) {\n    if (typeof columns[0] === \"function\") {\n      const orderBy = columns[0](\n        new Proxy(\n          this.config.table[Table.Symbol.Columns],\n          new SelectionProxyHandler({ sqlAliasedBehavior: \"alias\", sqlBehavior: \"sql\" })\n        )\n      );\n      const orderByArray = Array.isArray(orderBy) ? orderBy : [orderBy];\n      this.config.orderBy = orderByArray;\n    } else {\n      const orderByArray = columns;\n      this.config.orderBy = orderByArray;\n    }\n    return this;\n  }\n  limit(limit) {\n    this.config.limit = limit;\n    return this;\n  }\n  returning(fields = this.table[SQLiteTable.Symbol.Columns]) {\n    this.config.returning = orderSelectedFields(fields);\n    return this;\n  }\n  /** @internal */\n  getSQL() {\n    return this.dialect.buildDeleteQuery(this.config);\n  }\n  toSQL() {\n    const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());\n    return rest;\n  }\n  /** @internal */\n  _prepare(isOneTimeQuery = true) {\n    return this.session[isOneTimeQuery ? \"prepareOneTimeQuery\" : \"prepareQuery\"](\n      this.dialect.sqlToQuery(this.getSQL()),\n      this.config.returning,\n      this.config.returning ? \"all\" : \"run\",\n      true,\n      void 0,\n      {\n        type: \"delete\",\n        tables: extractUsedTable(this.config.table)\n      }\n    );\n  }\n  prepare() {\n    return this._prepare(false);\n  }\n  run = (placeholderValues) => {\n    return this._prepare().run(placeholderValues);\n  };\n  all = (placeholderValues) => {\n    return this._prepare().all(placeholderValues);\n  };\n  get = (placeholderValues) => {\n    return this._prepare().get(placeholderValues);\n  };\n  values = (placeholderValues) => {\n    return this._prepare().values(placeholderValues);\n  };\n  async execute(placeholderValues) {\n    return this._prepare().execute(placeholderValues);\n  }\n  $dynamic() {\n    return this;\n  }\n}\nexport {\n  SQLiteDeleteBase\n};\n//# sourceMappingURL=delete.js.map",
    "import { entityKind } from \"./entity.js\";\nimport { Table } from \"./table.js\";\nfunction toSnakeCase(input) {\n  const words = input.replace(/['\\u2019]/g, \"\").match(/[\\da-z]+|[A-Z]+(?![a-z])|[A-Z][\\da-z]+/g) ?? [];\n  return words.map((word) => word.toLowerCase()).join(\"_\");\n}\nfunction toCamelCase(input) {\n  const words = input.replace(/['\\u2019]/g, \"\").match(/[\\da-z]+|[A-Z]+(?![a-z])|[A-Z][\\da-z]+/g) ?? [];\n  return words.reduce((acc, word, i) => {\n    const formattedWord = i === 0 ? word.toLowerCase() : `${word[0].toUpperCase()}${word.slice(1)}`;\n    return acc + formattedWord;\n  }, \"\");\n}\nfunction noopCase(input) {\n  return input;\n}\nclass CasingCache {\n  static [entityKind] = \"CasingCache\";\n  /** @internal */\n  cache = {};\n  cachedTables = {};\n  convert;\n  constructor(casing) {\n    this.convert = casing === \"snake_case\" ? toSnakeCase : casing === \"camelCase\" ? toCamelCase : noopCase;\n  }\n  getColumnCasing(column) {\n    if (!column.keyAsName) return column.name;\n    const schema = column.table[Table.Symbol.Schema] ?? \"public\";\n    const tableName = column.table[Table.Symbol.OriginalName];\n    const key = `${schema}.${tableName}.${column.name}`;\n    if (!this.cache[key]) {\n      this.cacheTable(column.table);\n    }\n    return this.cache[key];\n  }\n  cacheTable(table) {\n    const schema = table[Table.Symbol.Schema] ?? \"public\";\n    const tableName = table[Table.Symbol.OriginalName];\n    const tableKey = `${schema}.${tableName}`;\n    if (!this.cachedTables[tableKey]) {\n      for (const column of Object.values(table[Table.Symbol.Columns])) {\n        const columnKey = `${tableKey}.${column.name}`;\n        this.cache[columnKey] = this.convert(column.name);\n      }\n      this.cachedTables[tableKey] = true;\n    }\n  }\n  clearCache() {\n    this.cache = {};\n    this.cachedTables = {};\n  }\n}\nexport {\n  CasingCache,\n  toCamelCase,\n  toSnakeCase\n};\n//# sourceMappingURL=casing.js.map",
    "import { entityKind } from \"./entity.js\";\nclass DrizzleError extends Error {\n  static [entityKind] = \"DrizzleError\";\n  constructor({ message, cause }) {\n    super(message);\n    this.name = \"DrizzleError\";\n    this.cause = cause;\n  }\n}\nclass DrizzleQueryError extends Error {\n  constructor(query, params, cause) {\n    super(`Failed query: ${query}\nparams: ${params}`);\n    this.query = query;\n    this.params = params;\n    this.cause = cause;\n    Error.captureStackTrace(this, DrizzleQueryError);\n    if (cause) this.cause = cause;\n  }\n}\nclass TransactionRollbackError extends DrizzleError {\n  static [entityKind] = \"TransactionRollbackError\";\n  constructor() {\n    super({ message: \"Rollback\" });\n  }\n}\nexport {\n  DrizzleError,\n  DrizzleQueryError,\n  TransactionRollbackError\n};\n//# sourceMappingURL=errors.js.map",
    "import { entityKind } from \"../entity.js\";\nimport { Table } from \"../table.js\";\nimport { getPgColumnBuilders } from \"./columns/all.js\";\nconst InlineForeignKeys = Symbol.for(\"drizzle:PgInlineForeignKeys\");\nconst EnableRLS = Symbol.for(\"drizzle:EnableRLS\");\nclass PgTable extends Table {\n  static [entityKind] = \"PgTable\";\n  /** @internal */\n  static Symbol = Object.assign({}, Table.Symbol, {\n    InlineForeignKeys,\n    EnableRLS\n  });\n  /**@internal */\n  [InlineForeignKeys] = [];\n  /** @internal */\n  [EnableRLS] = false;\n  /** @internal */\n  [Table.Symbol.ExtraConfigBuilder] = void 0;\n  /** @internal */\n  [Table.Symbol.ExtraConfigColumns] = {};\n}\nfunction pgTableWithSchema(name, columns, extraConfig, schema, baseName = name) {\n  const rawTable = new PgTable(name, schema, baseName);\n  const parsedColumns = typeof columns === \"function\" ? columns(getPgColumnBuilders()) : columns;\n  const builtColumns = Object.fromEntries(\n    Object.entries(parsedColumns).map(([name2, colBuilderBase]) => {\n      const colBuilder = colBuilderBase;\n      colBuilder.setName(name2);\n      const column = colBuilder.build(rawTable);\n      rawTable[InlineForeignKeys].push(...colBuilder.buildForeignKeys(column, rawTable));\n      return [name2, column];\n    })\n  );\n  const builtColumnsForExtraConfig = Object.fromEntries(\n    Object.entries(parsedColumns).map(([name2, colBuilderBase]) => {\n      const colBuilder = colBuilderBase;\n      colBuilder.setName(name2);\n      const column = colBuilder.buildExtraConfigColumn(rawTable);\n      return [name2, column];\n    })\n  );\n  const table = Object.assign(rawTable, builtColumns);\n  table[Table.Symbol.Columns] = builtColumns;\n  table[Table.Symbol.ExtraConfigColumns] = builtColumnsForExtraConfig;\n  if (extraConfig) {\n    table[PgTable.Symbol.ExtraConfigBuilder] = extraConfig;\n  }\n  return Object.assign(table, {\n    enableRLS: () => {\n      table[PgTable.Symbol.EnableRLS] = true;\n      return table;\n    }\n  });\n}\nconst pgTable = (name, columns, extraConfig) => {\n  return pgTableWithSchema(name, columns, extraConfig, void 0);\n};\nfunction pgTableCreator(customizeTableName) {\n  return (name, columns, extraConfig) => {\n    return pgTableWithSchema(customizeTableName(name), columns, extraConfig, void 0, name);\n  };\n}\nexport {\n  EnableRLS,\n  InlineForeignKeys,\n  PgTable,\n  pgTable,\n  pgTableCreator,\n  pgTableWithSchema\n};\n//# sourceMappingURL=table.js.map",
    "import { entityKind } from \"../entity.js\";\nimport { PgTable } from \"./table.js\";\nfunction primaryKey(...config) {\n  if (config[0].columns) {\n    return new PrimaryKeyBuilder(config[0].columns, config[0].name);\n  }\n  return new PrimaryKeyBuilder(config);\n}\nclass PrimaryKeyBuilder {\n  static [entityKind] = \"PgPrimaryKeyBuilder\";\n  /** @internal */\n  columns;\n  /** @internal */\n  name;\n  constructor(columns, name) {\n    this.columns = columns;\n    this.name = name;\n  }\n  /** @internal */\n  build(table) {\n    return new PrimaryKey(table, this.columns, this.name);\n  }\n}\nclass PrimaryKey {\n  constructor(table, columns, name) {\n    this.table = table;\n    this.columns = columns;\n    this.name = name;\n  }\n  static [entityKind] = \"PgPrimaryKey\";\n  columns;\n  name;\n  getName() {\n    return this.name ?? `${this.table[PgTable.Symbol.Name]}_${this.columns.map((column) => column.name).join(\"_\")}_pk`;\n  }\n}\nexport {\n  PrimaryKey,\n  PrimaryKeyBuilder,\n  primaryKey\n};\n//# sourceMappingURL=primary-keys.js.map",
    "import { Column } from \"../../column.js\";\nimport { is } from \"../../entity.js\";\nimport { Table } from \"../../table.js\";\nimport {\n  isDriverValueEncoder,\n  isSQLWrapper,\n  Param,\n  Placeholder,\n  SQL,\n  sql,\n  StringChunk,\n  View\n} from \"../sql.js\";\nfunction bindIfParam(value, column) {\n  if (isDriverValueEncoder(column) && !isSQLWrapper(value) && !is(value, Param) && !is(value, Placeholder) && !is(value, Column) && !is(value, Table) && !is(value, View)) {\n    return new Param(value, column);\n  }\n  return value;\n}\nconst eq = (left, right) => {\n  return sql`${left} = ${bindIfParam(right, left)}`;\n};\nconst ne = (left, right) => {\n  return sql`${left} <> ${bindIfParam(right, left)}`;\n};\nfunction and(...unfilteredConditions) {\n  const conditions = unfilteredConditions.filter(\n    (c) => c !== void 0\n  );\n  if (conditions.length === 0) {\n    return void 0;\n  }\n  if (conditions.length === 1) {\n    return new SQL(conditions);\n  }\n  return new SQL([\n    new StringChunk(\"(\"),\n    sql.join(conditions, new StringChunk(\" and \")),\n    new StringChunk(\")\")\n  ]);\n}\nfunction or(...unfilteredConditions) {\n  const conditions = unfilteredConditions.filter(\n    (c) => c !== void 0\n  );\n  if (conditions.length === 0) {\n    return void 0;\n  }\n  if (conditions.length === 1) {\n    return new SQL(conditions);\n  }\n  return new SQL([\n    new StringChunk(\"(\"),\n    sql.join(conditions, new StringChunk(\" or \")),\n    new StringChunk(\")\")\n  ]);\n}\nfunction not(condition) {\n  return sql`not ${condition}`;\n}\nconst gt = (left, right) => {\n  return sql`${left} > ${bindIfParam(right, left)}`;\n};\nconst gte = (left, right) => {\n  return sql`${left} >= ${bindIfParam(right, left)}`;\n};\nconst lt = (left, right) => {\n  return sql`${left} < ${bindIfParam(right, left)}`;\n};\nconst lte = (left, right) => {\n  return sql`${left} <= ${bindIfParam(right, left)}`;\n};\nfunction inArray(column, values) {\n  if (Array.isArray(values)) {\n    if (values.length === 0) {\n      return sql`false`;\n    }\n    return sql`${column} in ${values.map((v) => bindIfParam(v, column))}`;\n  }\n  return sql`${column} in ${bindIfParam(values, column)}`;\n}\nfunction notInArray(column, values) {\n  if (Array.isArray(values)) {\n    if (values.length === 0) {\n      return sql`true`;\n    }\n    return sql`${column} not in ${values.map((v) => bindIfParam(v, column))}`;\n  }\n  return sql`${column} not in ${bindIfParam(values, column)}`;\n}\nfunction isNull(value) {\n  return sql`${value} is null`;\n}\nfunction isNotNull(value) {\n  return sql`${value} is not null`;\n}\nfunction exists(subquery) {\n  return sql`exists ${subquery}`;\n}\nfunction notExists(subquery) {\n  return sql`not exists ${subquery}`;\n}\nfunction between(column, min, max) {\n  return sql`${column} between ${bindIfParam(min, column)} and ${bindIfParam(\n    max,\n    column\n  )}`;\n}\nfunction notBetween(column, min, max) {\n  return sql`${column} not between ${bindIfParam(\n    min,\n    column\n  )} and ${bindIfParam(max, column)}`;\n}\nfunction like(column, value) {\n  return sql`${column} like ${value}`;\n}\nfunction notLike(column, value) {\n  return sql`${column} not like ${value}`;\n}\nfunction ilike(column, value) {\n  return sql`${column} ilike ${value}`;\n}\nfunction notIlike(column, value) {\n  return sql`${column} not ilike ${value}`;\n}\nfunction arrayContains(column, values) {\n  if (Array.isArray(values)) {\n    if (values.length === 0) {\n      throw new Error(\"arrayContains requires at least one value\");\n    }\n    const array = sql`${bindIfParam(values, column)}`;\n    return sql`${column} @> ${array}`;\n  }\n  return sql`${column} @> ${bindIfParam(values, column)}`;\n}\nfunction arrayContained(column, values) {\n  if (Array.isArray(values)) {\n    if (values.length === 0) {\n      throw new Error(\"arrayContained requires at least one value\");\n    }\n    const array = sql`${bindIfParam(values, column)}`;\n    return sql`${column} <@ ${array}`;\n  }\n  return sql`${column} <@ ${bindIfParam(values, column)}`;\n}\nfunction arrayOverlaps(column, values) {\n  if (Array.isArray(values)) {\n    if (values.length === 0) {\n      throw new Error(\"arrayOverlaps requires at least one value\");\n    }\n    const array = sql`${bindIfParam(values, column)}`;\n    return sql`${column} && ${array}`;\n  }\n  return sql`${column} && ${bindIfParam(values, column)}`;\n}\nexport {\n  and,\n  arrayContained,\n  arrayContains,\n  arrayOverlaps,\n  between,\n  bindIfParam,\n  eq,\n  exists,\n  gt,\n  gte,\n  ilike,\n  inArray,\n  isNotNull,\n  isNull,\n  like,\n  lt,\n  lte,\n  ne,\n  not,\n  notBetween,\n  notExists,\n  notIlike,\n  notInArray,\n  notLike,\n  or\n};\n//# sourceMappingURL=conditions.js.map",
    "import { sql } from \"../sql.js\";\nfunction asc(column) {\n  return sql`${column} asc`;\n}\nfunction desc(column) {\n  return sql`${column} desc`;\n}\nexport {\n  asc,\n  desc\n};\n//# sourceMappingURL=select.js.map",
    "import { getTableUniqueName, Table } from \"./table.js\";\nimport { Column } from \"./column.js\";\nimport { entityKind, is } from \"./entity.js\";\nimport { PrimaryKeyBuilder } from \"./pg-core/primary-keys.js\";\nimport {\n  and,\n  asc,\n  between,\n  desc,\n  eq,\n  exists,\n  gt,\n  gte,\n  ilike,\n  inArray,\n  isNotNull,\n  isNull,\n  like,\n  lt,\n  lte,\n  ne,\n  not,\n  notBetween,\n  notExists,\n  notIlike,\n  notInArray,\n  notLike,\n  or\n} from \"./sql/expressions/index.js\";\nimport { SQL, sql } from \"./sql/sql.js\";\nclass Relation {\n  constructor(sourceTable, referencedTable, relationName) {\n    this.sourceTable = sourceTable;\n    this.referencedTable = referencedTable;\n    this.relationName = relationName;\n    this.referencedTableName = referencedTable[Table.Symbol.Name];\n  }\n  static [entityKind] = \"Relation\";\n  referencedTableName;\n  fieldName;\n}\nclass Relations {\n  constructor(table, config) {\n    this.table = table;\n    this.config = config;\n  }\n  static [entityKind] = \"Relations\";\n}\nclass One extends Relation {\n  constructor(sourceTable, referencedTable, config, isNullable) {\n    super(sourceTable, referencedTable, config?.relationName);\n    this.config = config;\n    this.isNullable = isNullable;\n  }\n  static [entityKind] = \"One\";\n  withFieldName(fieldName) {\n    const relation = new One(\n      this.sourceTable,\n      this.referencedTable,\n      this.config,\n      this.isNullable\n    );\n    relation.fieldName = fieldName;\n    return relation;\n  }\n}\nclass Many extends Relation {\n  constructor(sourceTable, referencedTable, config) {\n    super(sourceTable, referencedTable, config?.relationName);\n    this.config = config;\n  }\n  static [entityKind] = \"Many\";\n  withFieldName(fieldName) {\n    const relation = new Many(\n      this.sourceTable,\n      this.referencedTable,\n      this.config\n    );\n    relation.fieldName = fieldName;\n    return relation;\n  }\n}\nfunction getOperators() {\n  return {\n    and,\n    between,\n    eq,\n    exists,\n    gt,\n    gte,\n    ilike,\n    inArray,\n    isNull,\n    isNotNull,\n    like,\n    lt,\n    lte,\n    ne,\n    not,\n    notBetween,\n    notExists,\n    notLike,\n    notIlike,\n    notInArray,\n    or,\n    sql\n  };\n}\nfunction getOrderByOperators() {\n  return {\n    sql,\n    asc,\n    desc\n  };\n}\nfunction extractTablesRelationalConfig(schema, configHelpers) {\n  if (Object.keys(schema).length === 1 && \"default\" in schema && !is(schema[\"default\"], Table)) {\n    schema = schema[\"default\"];\n  }\n  const tableNamesMap = {};\n  const relationsBuffer = {};\n  const tablesConfig = {};\n  for (const [key, value] of Object.entries(schema)) {\n    if (is(value, Table)) {\n      const dbName = getTableUniqueName(value);\n      const bufferedRelations = relationsBuffer[dbName];\n      tableNamesMap[dbName] = key;\n      tablesConfig[key] = {\n        tsName: key,\n        dbName: value[Table.Symbol.Name],\n        schema: value[Table.Symbol.Schema],\n        columns: value[Table.Symbol.Columns],\n        relations: bufferedRelations?.relations ?? {},\n        primaryKey: bufferedRelations?.primaryKey ?? []\n      };\n      for (const column of Object.values(\n        value[Table.Symbol.Columns]\n      )) {\n        if (column.primary) {\n          tablesConfig[key].primaryKey.push(column);\n        }\n      }\n      const extraConfig = value[Table.Symbol.ExtraConfigBuilder]?.(value[Table.Symbol.ExtraConfigColumns]);\n      if (extraConfig) {\n        for (const configEntry of Object.values(extraConfig)) {\n          if (is(configEntry, PrimaryKeyBuilder)) {\n            tablesConfig[key].primaryKey.push(...configEntry.columns);\n          }\n        }\n      }\n    } else if (is(value, Relations)) {\n      const dbName = getTableUniqueName(value.table);\n      const tableName = tableNamesMap[dbName];\n      const relations2 = value.config(\n        configHelpers(value.table)\n      );\n      let primaryKey;\n      for (const [relationName, relation] of Object.entries(relations2)) {\n        if (tableName) {\n          const tableConfig = tablesConfig[tableName];\n          tableConfig.relations[relationName] = relation;\n          if (primaryKey) {\n            tableConfig.primaryKey.push(...primaryKey);\n          }\n        } else {\n          if (!(dbName in relationsBuffer)) {\n            relationsBuffer[dbName] = {\n              relations: {},\n              primaryKey\n            };\n          }\n          relationsBuffer[dbName].relations[relationName] = relation;\n        }\n      }\n    }\n  }\n  return { tables: tablesConfig, tableNamesMap };\n}\nfunction relations(table, relations2) {\n  return new Relations(\n    table,\n    (helpers) => Object.fromEntries(\n      Object.entries(relations2(helpers)).map(([key, value]) => [\n        key,\n        value.withFieldName(key)\n      ])\n    )\n  );\n}\nfunction createOne(sourceTable) {\n  return function one(table, config) {\n    return new One(\n      sourceTable,\n      table,\n      config,\n      config?.fields.reduce((res, f) => res && f.notNull, true) ?? false\n    );\n  };\n}\nfunction createMany(sourceTable) {\n  return function many(referencedTable, config) {\n    return new Many(sourceTable, referencedTable, config);\n  };\n}\nfunction normalizeRelation(schema, tableNamesMap, relation) {\n  if (is(relation, One) && relation.config) {\n    return {\n      fields: relation.config.fields,\n      references: relation.config.references\n    };\n  }\n  const referencedTableTsName = tableNamesMap[getTableUniqueName(relation.referencedTable)];\n  if (!referencedTableTsName) {\n    throw new Error(\n      `Table \"${relation.referencedTable[Table.Symbol.Name]}\" not found in schema`\n    );\n  }\n  const referencedTableConfig = schema[referencedTableTsName];\n  if (!referencedTableConfig) {\n    throw new Error(`Table \"${referencedTableTsName}\" not found in schema`);\n  }\n  const sourceTable = relation.sourceTable;\n  const sourceTableTsName = tableNamesMap[getTableUniqueName(sourceTable)];\n  if (!sourceTableTsName) {\n    throw new Error(\n      `Table \"${sourceTable[Table.Symbol.Name]}\" not found in schema`\n    );\n  }\n  const reverseRelations = [];\n  for (const referencedTableRelation of Object.values(\n    referencedTableConfig.relations\n  )) {\n    if (relation.relationName && relation !== referencedTableRelation && referencedTableRelation.relationName === relation.relationName || !relation.relationName && referencedTableRelation.referencedTable === relation.sourceTable) {\n      reverseRelations.push(referencedTableRelation);\n    }\n  }\n  if (reverseRelations.length > 1) {\n    throw relation.relationName ? new Error(\n      `There are multiple relations with name \"${relation.relationName}\" in table \"${referencedTableTsName}\"`\n    ) : new Error(\n      `There are multiple relations between \"${referencedTableTsName}\" and \"${relation.sourceTable[Table.Symbol.Name]}\". Please specify relation name`\n    );\n  }\n  if (reverseRelations[0] && is(reverseRelations[0], One) && reverseRelations[0].config) {\n    return {\n      fields: reverseRelations[0].config.references,\n      references: reverseRelations[0].config.fields\n    };\n  }\n  throw new Error(\n    `There is not enough information to infer relation \"${sourceTableTsName}.${relation.fieldName}\"`\n  );\n}\nfunction createTableRelationsHelpers(sourceTable) {\n  return {\n    one: createOne(sourceTable),\n    many: createMany(sourceTable)\n  };\n}\nfunction mapRelationalRow(tablesConfig, tableConfig, row, buildQueryResultSelection, mapColumnValue = (value) => value) {\n  const result = {};\n  for (const [\n    selectionItemIndex,\n    selectionItem\n  ] of buildQueryResultSelection.entries()) {\n    if (selectionItem.isJson) {\n      const relation = tableConfig.relations[selectionItem.tsKey];\n      const rawSubRows = row[selectionItemIndex];\n      const subRows = typeof rawSubRows === \"string\" ? JSON.parse(rawSubRows) : rawSubRows;\n      result[selectionItem.tsKey] = is(relation, One) ? subRows && mapRelationalRow(\n        tablesConfig,\n        tablesConfig[selectionItem.relationTableTsKey],\n        subRows,\n        selectionItem.selection,\n        mapColumnValue\n      ) : subRows.map(\n        (subRow) => mapRelationalRow(\n          tablesConfig,\n          tablesConfig[selectionItem.relationTableTsKey],\n          subRow,\n          selectionItem.selection,\n          mapColumnValue\n        )\n      );\n    } else {\n      const value = mapColumnValue(row[selectionItemIndex]);\n      const field = selectionItem.field;\n      let decoder;\n      if (is(field, Column)) {\n        decoder = field;\n      } else if (is(field, SQL)) {\n        decoder = field.decoder;\n      } else {\n        decoder = field.sql.decoder;\n      }\n      result[selectionItem.tsKey] = value === null ? null : decoder.mapFromDriverValue(value);\n    }\n  }\n  return result;\n}\nexport {\n  Many,\n  One,\n  Relation,\n  Relations,\n  createMany,\n  createOne,\n  createTableRelationsHelpers,\n  extractTablesRelationalConfig,\n  getOperators,\n  getOrderByOperators,\n  mapRelationalRow,\n  normalizeRelation,\n  relations\n};\n//# sourceMappingURL=relations.js.map",
    "import { entityKind } from \"../entity.js\";\nimport { View } from \"../sql/sql.js\";\nclass SQLiteViewBase extends View {\n  static [entityKind] = \"SQLiteViewBase\";\n}\nexport {\n  SQLiteViewBase\n};\n//# sourceMappingURL=view-base.js.map",
    "import { aliasedTable, aliasedTableColumn, mapColumnsInAliasedSQLToAlias, mapColumnsInSQLToAlias } from \"../alias.js\";\nimport { CasingCache } from \"../casing.js\";\nimport { Column } from \"../column.js\";\nimport { entityKind, is } from \"../entity.js\";\nimport { DrizzleError } from \"../errors.js\";\nimport {\n  getOperators,\n  getOrderByOperators,\n  Many,\n  normalizeRelation,\n  One\n} from \"../relations.js\";\nimport { and, eq } from \"../sql/index.js\";\nimport { Param, SQL, sql } from \"../sql/sql.js\";\nimport { SQLiteColumn } from \"./columns/index.js\";\nimport { SQLiteTable } from \"./table.js\";\nimport { Subquery } from \"../subquery.js\";\nimport { getTableName, getTableUniqueName, Table } from \"../table.js\";\nimport { orderSelectedFields } from \"../utils.js\";\nimport { ViewBaseConfig } from \"../view-common.js\";\nimport { SQLiteViewBase } from \"./view-base.js\";\nclass SQLiteDialect {\n  static [entityKind] = \"SQLiteDialect\";\n  /** @internal */\n  casing;\n  constructor(config) {\n    this.casing = new CasingCache(config?.casing);\n  }\n  escapeName(name) {\n    return `\"${name}\"`;\n  }\n  escapeParam(_num) {\n    return \"?\";\n  }\n  escapeString(str) {\n    return `'${str.replace(/'/g, \"''\")}'`;\n  }\n  buildWithCTE(queries) {\n    if (!queries?.length) return void 0;\n    const withSqlChunks = [sql`with `];\n    for (const [i, w] of queries.entries()) {\n      withSqlChunks.push(sql`${sql.identifier(w._.alias)} as (${w._.sql})`);\n      if (i < queries.length - 1) {\n        withSqlChunks.push(sql`, `);\n      }\n    }\n    withSqlChunks.push(sql` `);\n    return sql.join(withSqlChunks);\n  }\n  buildDeleteQuery({ table, where, returning, withList, limit, orderBy }) {\n    const withSql = this.buildWithCTE(withList);\n    const returningSql = returning ? sql` returning ${this.buildSelection(returning, { isSingleTable: true })}` : void 0;\n    const whereSql = where ? sql` where ${where}` : void 0;\n    const orderBySql = this.buildOrderBy(orderBy);\n    const limitSql = this.buildLimit(limit);\n    return sql`${withSql}delete from ${table}${whereSql}${returningSql}${orderBySql}${limitSql}`;\n  }\n  buildUpdateSet(table, set) {\n    const tableColumns = table[Table.Symbol.Columns];\n    const columnNames = Object.keys(tableColumns).filter(\n      (colName) => set[colName] !== void 0 || tableColumns[colName]?.onUpdateFn !== void 0\n    );\n    const setSize = columnNames.length;\n    return sql.join(columnNames.flatMap((colName, i) => {\n      const col = tableColumns[colName];\n      const value = set[colName] ?? sql.param(col.onUpdateFn(), col);\n      const res = sql`${sql.identifier(this.casing.getColumnCasing(col))} = ${value}`;\n      if (i < setSize - 1) {\n        return [res, sql.raw(\", \")];\n      }\n      return [res];\n    }));\n  }\n  buildUpdateQuery({ table, set, where, returning, withList, joins, from, limit, orderBy }) {\n    const withSql = this.buildWithCTE(withList);\n    const setSql = this.buildUpdateSet(table, set);\n    const fromSql = from && sql.join([sql.raw(\" from \"), this.buildFromTable(from)]);\n    const joinsSql = this.buildJoins(joins);\n    const returningSql = returning ? sql` returning ${this.buildSelection(returning, { isSingleTable: true })}` : void 0;\n    const whereSql = where ? sql` where ${where}` : void 0;\n    const orderBySql = this.buildOrderBy(orderBy);\n    const limitSql = this.buildLimit(limit);\n    return sql`${withSql}update ${table} set ${setSql}${fromSql}${joinsSql}${whereSql}${returningSql}${orderBySql}${limitSql}`;\n  }\n  /**\n   * Builds selection SQL with provided fields/expressions\n   *\n   * Examples:\n   *\n   * `select <selection> from`\n   *\n   * `insert ... returning <selection>`\n   *\n   * If `isSingleTable` is true, then columns won't be prefixed with table name\n   */\n  buildSelection(fields, { isSingleTable = false } = {}) {\n    const columnsLen = fields.length;\n    const chunks = fields.flatMap(({ field }, i) => {\n      const chunk = [];\n      if (is(field, SQL.Aliased) && field.isSelectionField) {\n        chunk.push(sql.identifier(field.fieldAlias));\n      } else if (is(field, SQL.Aliased) || is(field, SQL)) {\n        const query = is(field, SQL.Aliased) ? field.sql : field;\n        if (isSingleTable) {\n          chunk.push(\n            new SQL(\n              query.queryChunks.map((c) => {\n                if (is(c, Column)) {\n                  return sql.identifier(this.casing.getColumnCasing(c));\n                }\n                return c;\n              })\n            )\n          );\n        } else {\n          chunk.push(query);\n        }\n        if (is(field, SQL.Aliased)) {\n          chunk.push(sql` as ${sql.identifier(field.fieldAlias)}`);\n        }\n      } else if (is(field, Column)) {\n        const tableName = field.table[Table.Symbol.Name];\n        if (field.columnType === \"SQLiteNumericBigInt\") {\n          if (isSingleTable) {\n            chunk.push(sql`cast(${sql.identifier(this.casing.getColumnCasing(field))} as text)`);\n          } else {\n            chunk.push(\n              sql`cast(${sql.identifier(tableName)}.${sql.identifier(this.casing.getColumnCasing(field))} as text)`\n            );\n          }\n        } else {\n          if (isSingleTable) {\n            chunk.push(sql.identifier(this.casing.getColumnCasing(field)));\n          } else {\n            chunk.push(sql`${sql.identifier(tableName)}.${sql.identifier(this.casing.getColumnCasing(field))}`);\n          }\n        }\n      }\n      if (i < columnsLen - 1) {\n        chunk.push(sql`, `);\n      }\n      return chunk;\n    });\n    return sql.join(chunks);\n  }\n  buildJoins(joins) {\n    if (!joins || joins.length === 0) {\n      return void 0;\n    }\n    const joinsArray = [];\n    if (joins) {\n      for (const [index, joinMeta] of joins.entries()) {\n        if (index === 0) {\n          joinsArray.push(sql` `);\n        }\n        const table = joinMeta.table;\n        const onSql = joinMeta.on ? sql` on ${joinMeta.on}` : void 0;\n        if (is(table, SQLiteTable)) {\n          const tableName = table[SQLiteTable.Symbol.Name];\n          const tableSchema = table[SQLiteTable.Symbol.Schema];\n          const origTableName = table[SQLiteTable.Symbol.OriginalName];\n          const alias = tableName === origTableName ? void 0 : joinMeta.alias;\n          joinsArray.push(\n            sql`${sql.raw(joinMeta.joinType)} join ${tableSchema ? sql`${sql.identifier(tableSchema)}.` : void 0}${sql.identifier(origTableName)}${alias && sql` ${sql.identifier(alias)}`}${onSql}`\n          );\n        } else {\n          joinsArray.push(\n            sql`${sql.raw(joinMeta.joinType)} join ${table}${onSql}`\n          );\n        }\n        if (index < joins.length - 1) {\n          joinsArray.push(sql` `);\n        }\n      }\n    }\n    return sql.join(joinsArray);\n  }\n  buildLimit(limit) {\n    return typeof limit === \"object\" || typeof limit === \"number\" && limit >= 0 ? sql` limit ${limit}` : void 0;\n  }\n  buildOrderBy(orderBy) {\n    const orderByList = [];\n    if (orderBy) {\n      for (const [index, orderByValue] of orderBy.entries()) {\n        orderByList.push(orderByValue);\n        if (index < orderBy.length - 1) {\n          orderByList.push(sql`, `);\n        }\n      }\n    }\n    return orderByList.length > 0 ? sql` order by ${sql.join(orderByList)}` : void 0;\n  }\n  buildFromTable(table) {\n    if (is(table, Table) && table[Table.Symbol.IsAlias]) {\n      return sql`${sql`${sql.identifier(table[Table.Symbol.Schema] ?? \"\")}.`.if(table[Table.Symbol.Schema])}${sql.identifier(table[Table.Symbol.OriginalName])} ${sql.identifier(table[Table.Symbol.Name])}`;\n    }\n    return table;\n  }\n  buildSelectQuery({\n    withList,\n    fields,\n    fieldsFlat,\n    where,\n    having,\n    table,\n    joins,\n    orderBy,\n    groupBy,\n    limit,\n    offset,\n    distinct,\n    setOperators\n  }) {\n    const fieldsList = fieldsFlat ?? orderSelectedFields(fields);\n    for (const f of fieldsList) {\n      if (is(f.field, Column) && getTableName(f.field.table) !== (is(table, Subquery) ? table._.alias : is(table, SQLiteViewBase) ? table[ViewBaseConfig].name : is(table, SQL) ? void 0 : getTableName(table)) && !((table2) => joins?.some(\n        ({ alias }) => alias === (table2[Table.Symbol.IsAlias] ? getTableName(table2) : table2[Table.Symbol.BaseName])\n      ))(f.field.table)) {\n        const tableName = getTableName(f.field.table);\n        throw new Error(\n          `Your \"${f.path.join(\"->\")}\" field references a column \"${tableName}\".\"${f.field.name}\", but the table \"${tableName}\" is not part of the query! Did you forget to join it?`\n        );\n      }\n    }\n    const isSingleTable = !joins || joins.length === 0;\n    const withSql = this.buildWithCTE(withList);\n    const distinctSql = distinct ? sql` distinct` : void 0;\n    const selection = this.buildSelection(fieldsList, { isSingleTable });\n    const tableSql = this.buildFromTable(table);\n    const joinsSql = this.buildJoins(joins);\n    const whereSql = where ? sql` where ${where}` : void 0;\n    const havingSql = having ? sql` having ${having}` : void 0;\n    const groupByList = [];\n    if (groupBy) {\n      for (const [index, groupByValue] of groupBy.entries()) {\n        groupByList.push(groupByValue);\n        if (index < groupBy.length - 1) {\n          groupByList.push(sql`, `);\n        }\n      }\n    }\n    const groupBySql = groupByList.length > 0 ? sql` group by ${sql.join(groupByList)}` : void 0;\n    const orderBySql = this.buildOrderBy(orderBy);\n    const limitSql = this.buildLimit(limit);\n    const offsetSql = offset ? sql` offset ${offset}` : void 0;\n    const finalQuery = sql`${withSql}select${distinctSql} ${selection} from ${tableSql}${joinsSql}${whereSql}${groupBySql}${havingSql}${orderBySql}${limitSql}${offsetSql}`;\n    if (setOperators.length > 0) {\n      return this.buildSetOperations(finalQuery, setOperators);\n    }\n    return finalQuery;\n  }\n  buildSetOperations(leftSelect, setOperators) {\n    const [setOperator, ...rest] = setOperators;\n    if (!setOperator) {\n      throw new Error(\"Cannot pass undefined values to any set operator\");\n    }\n    if (rest.length === 0) {\n      return this.buildSetOperationQuery({ leftSelect, setOperator });\n    }\n    return this.buildSetOperations(\n      this.buildSetOperationQuery({ leftSelect, setOperator }),\n      rest\n    );\n  }\n  buildSetOperationQuery({\n    leftSelect,\n    setOperator: { type, isAll, rightSelect, limit, orderBy, offset }\n  }) {\n    const leftChunk = sql`${leftSelect.getSQL()} `;\n    const rightChunk = sql`${rightSelect.getSQL()}`;\n    let orderBySql;\n    if (orderBy && orderBy.length > 0) {\n      const orderByValues = [];\n      for (const singleOrderBy of orderBy) {\n        if (is(singleOrderBy, SQLiteColumn)) {\n          orderByValues.push(sql.identifier(singleOrderBy.name));\n        } else if (is(singleOrderBy, SQL)) {\n          for (let i = 0; i < singleOrderBy.queryChunks.length; i++) {\n            const chunk = singleOrderBy.queryChunks[i];\n            if (is(chunk, SQLiteColumn)) {\n              singleOrderBy.queryChunks[i] = sql.identifier(this.casing.getColumnCasing(chunk));\n            }\n          }\n          orderByValues.push(sql`${singleOrderBy}`);\n        } else {\n          orderByValues.push(sql`${singleOrderBy}`);\n        }\n      }\n      orderBySql = sql` order by ${sql.join(orderByValues, sql`, `)}`;\n    }\n    const limitSql = typeof limit === \"object\" || typeof limit === \"number\" && limit >= 0 ? sql` limit ${limit}` : void 0;\n    const operatorChunk = sql.raw(`${type} ${isAll ? \"all \" : \"\"}`);\n    const offsetSql = offset ? sql` offset ${offset}` : void 0;\n    return sql`${leftChunk}${operatorChunk}${rightChunk}${orderBySql}${limitSql}${offsetSql}`;\n  }\n  buildInsertQuery({ table, values: valuesOrSelect, onConflict, returning, withList, select }) {\n    const valuesSqlList = [];\n    const columns = table[Table.Symbol.Columns];\n    const colEntries = Object.entries(columns).filter(\n      ([_, col]) => !col.shouldDisableInsert()\n    );\n    const insertOrder = colEntries.map(([, column]) => sql.identifier(this.casing.getColumnCasing(column)));\n    if (select) {\n      const select2 = valuesOrSelect;\n      if (is(select2, SQL)) {\n        valuesSqlList.push(select2);\n      } else {\n        valuesSqlList.push(select2.getSQL());\n      }\n    } else {\n      const values = valuesOrSelect;\n      valuesSqlList.push(sql.raw(\"values \"));\n      for (const [valueIndex, value] of values.entries()) {\n        const valueList = [];\n        for (const [fieldName, col] of colEntries) {\n          const colValue = value[fieldName];\n          if (colValue === void 0 || is(colValue, Param) && colValue.value === void 0) {\n            let defaultValue;\n            if (col.default !== null && col.default !== void 0) {\n              defaultValue = is(col.default, SQL) ? col.default : sql.param(col.default, col);\n            } else if (col.defaultFn !== void 0) {\n              const defaultFnResult = col.defaultFn();\n              defaultValue = is(defaultFnResult, SQL) ? defaultFnResult : sql.param(defaultFnResult, col);\n            } else if (!col.default && col.onUpdateFn !== void 0) {\n              const onUpdateFnResult = col.onUpdateFn();\n              defaultValue = is(onUpdateFnResult, SQL) ? onUpdateFnResult : sql.param(onUpdateFnResult, col);\n            } else {\n              defaultValue = sql`null`;\n            }\n            valueList.push(defaultValue);\n          } else {\n            valueList.push(colValue);\n          }\n        }\n        valuesSqlList.push(valueList);\n        if (valueIndex < values.length - 1) {\n          valuesSqlList.push(sql`, `);\n        }\n      }\n    }\n    const withSql = this.buildWithCTE(withList);\n    const valuesSql = sql.join(valuesSqlList);\n    const returningSql = returning ? sql` returning ${this.buildSelection(returning, { isSingleTable: true })}` : void 0;\n    const onConflictSql = onConflict?.length ? sql.join(onConflict) : void 0;\n    return sql`${withSql}insert into ${table} ${insertOrder} ${valuesSql}${onConflictSql}${returningSql}`;\n  }\n  sqlToQuery(sql2, invokeSource) {\n    return sql2.toQuery({\n      casing: this.casing,\n      escapeName: this.escapeName,\n      escapeParam: this.escapeParam,\n      escapeString: this.escapeString,\n      invokeSource\n    });\n  }\n  buildRelationalQuery({\n    fullSchema,\n    schema,\n    tableNamesMap,\n    table,\n    tableConfig,\n    queryConfig: config,\n    tableAlias,\n    nestedQueryRelation,\n    joinOn\n  }) {\n    let selection = [];\n    let limit, offset, orderBy = [], where;\n    const joins = [];\n    if (config === true) {\n      const selectionEntries = Object.entries(tableConfig.columns);\n      selection = selectionEntries.map(([key, value]) => ({\n        dbKey: value.name,\n        tsKey: key,\n        field: aliasedTableColumn(value, tableAlias),\n        relationTableTsKey: void 0,\n        isJson: false,\n        selection: []\n      }));\n    } else {\n      const aliasedColumns = Object.fromEntries(\n        Object.entries(tableConfig.columns).map(([key, value]) => [key, aliasedTableColumn(value, tableAlias)])\n      );\n      if (config.where) {\n        const whereSql = typeof config.where === \"function\" ? config.where(aliasedColumns, getOperators()) : config.where;\n        where = whereSql && mapColumnsInSQLToAlias(whereSql, tableAlias);\n      }\n      const fieldsSelection = [];\n      let selectedColumns = [];\n      if (config.columns) {\n        let isIncludeMode = false;\n        for (const [field, value] of Object.entries(config.columns)) {\n          if (value === void 0) {\n            continue;\n          }\n          if (field in tableConfig.columns) {\n            if (!isIncludeMode && value === true) {\n              isIncludeMode = true;\n            }\n            selectedColumns.push(field);\n          }\n        }\n        if (selectedColumns.length > 0) {\n          selectedColumns = isIncludeMode ? selectedColumns.filter((c) => config.columns?.[c] === true) : Object.keys(tableConfig.columns).filter((key) => !selectedColumns.includes(key));\n        }\n      } else {\n        selectedColumns = Object.keys(tableConfig.columns);\n      }\n      for (const field of selectedColumns) {\n        const column = tableConfig.columns[field];\n        fieldsSelection.push({ tsKey: field, value: column });\n      }\n      let selectedRelations = [];\n      if (config.with) {\n        selectedRelations = Object.entries(config.with).filter((entry) => !!entry[1]).map(([tsKey, queryConfig]) => ({ tsKey, queryConfig, relation: tableConfig.relations[tsKey] }));\n      }\n      let extras;\n      if (config.extras) {\n        extras = typeof config.extras === \"function\" ? config.extras(aliasedColumns, { sql }) : config.extras;\n        for (const [tsKey, value] of Object.entries(extras)) {\n          fieldsSelection.push({\n            tsKey,\n            value: mapColumnsInAliasedSQLToAlias(value, tableAlias)\n          });\n        }\n      }\n      for (const { tsKey, value } of fieldsSelection) {\n        selection.push({\n          dbKey: is(value, SQL.Aliased) ? value.fieldAlias : tableConfig.columns[tsKey].name,\n          tsKey,\n          field: is(value, Column) ? aliasedTableColumn(value, tableAlias) : value,\n          relationTableTsKey: void 0,\n          isJson: false,\n          selection: []\n        });\n      }\n      let orderByOrig = typeof config.orderBy === \"function\" ? config.orderBy(aliasedColumns, getOrderByOperators()) : config.orderBy ?? [];\n      if (!Array.isArray(orderByOrig)) {\n        orderByOrig = [orderByOrig];\n      }\n      orderBy = orderByOrig.map((orderByValue) => {\n        if (is(orderByValue, Column)) {\n          return aliasedTableColumn(orderByValue, tableAlias);\n        }\n        return mapColumnsInSQLToAlias(orderByValue, tableAlias);\n      });\n      limit = config.limit;\n      offset = config.offset;\n      for (const {\n        tsKey: selectedRelationTsKey,\n        queryConfig: selectedRelationConfigValue,\n        relation\n      } of selectedRelations) {\n        const normalizedRelation = normalizeRelation(schema, tableNamesMap, relation);\n        const relationTableName = getTableUniqueName(relation.referencedTable);\n        const relationTableTsName = tableNamesMap[relationTableName];\n        const relationTableAlias = `${tableAlias}_${selectedRelationTsKey}`;\n        const joinOn2 = and(\n          ...normalizedRelation.fields.map(\n            (field2, i) => eq(\n              aliasedTableColumn(normalizedRelation.references[i], relationTableAlias),\n              aliasedTableColumn(field2, tableAlias)\n            )\n          )\n        );\n        const builtRelation = this.buildRelationalQuery({\n          fullSchema,\n          schema,\n          tableNamesMap,\n          table: fullSchema[relationTableTsName],\n          tableConfig: schema[relationTableTsName],\n          queryConfig: is(relation, One) ? selectedRelationConfigValue === true ? { limit: 1 } : { ...selectedRelationConfigValue, limit: 1 } : selectedRelationConfigValue,\n          tableAlias: relationTableAlias,\n          joinOn: joinOn2,\n          nestedQueryRelation: relation\n        });\n        const field = sql`(${builtRelation.sql})`.as(selectedRelationTsKey);\n        selection.push({\n          dbKey: selectedRelationTsKey,\n          tsKey: selectedRelationTsKey,\n          field,\n          relationTableTsKey: relationTableTsName,\n          isJson: true,\n          selection: builtRelation.selection\n        });\n      }\n    }\n    if (selection.length === 0) {\n      throw new DrizzleError({\n        message: `No fields selected for table \"${tableConfig.tsName}\" (\"${tableAlias}\"). You need to have at least one item in \"columns\", \"with\" or \"extras\". If you need to select all columns, omit the \"columns\" key or set it to undefined.`\n      });\n    }\n    let result;\n    where = and(joinOn, where);\n    if (nestedQueryRelation) {\n      let field = sql`json_array(${sql.join(\n        selection.map(\n          ({ field: field2 }) => is(field2, SQLiteColumn) ? sql.identifier(this.casing.getColumnCasing(field2)) : is(field2, SQL.Aliased) ? field2.sql : field2\n        ),\n        sql`, `\n      )})`;\n      if (is(nestedQueryRelation, Many)) {\n        field = sql`coalesce(json_group_array(${field}), json_array())`;\n      }\n      const nestedSelection = [{\n        dbKey: \"data\",\n        tsKey: \"data\",\n        field: field.as(\"data\"),\n        isJson: true,\n        relationTableTsKey: tableConfig.tsName,\n        selection\n      }];\n      const needsSubquery = limit !== void 0 || offset !== void 0 || orderBy.length > 0;\n      if (needsSubquery) {\n        result = this.buildSelectQuery({\n          table: aliasedTable(table, tableAlias),\n          fields: {},\n          fieldsFlat: [\n            {\n              path: [],\n              field: sql.raw(\"*\")\n            }\n          ],\n          where,\n          limit,\n          offset,\n          orderBy,\n          setOperators: []\n        });\n        where = void 0;\n        limit = void 0;\n        offset = void 0;\n        orderBy = void 0;\n      } else {\n        result = aliasedTable(table, tableAlias);\n      }\n      result = this.buildSelectQuery({\n        table: is(result, SQLiteTable) ? result : new Subquery(result, {}, tableAlias),\n        fields: {},\n        fieldsFlat: nestedSelection.map(({ field: field2 }) => ({\n          path: [],\n          field: is(field2, Column) ? aliasedTableColumn(field2, tableAlias) : field2\n        })),\n        joins,\n        where,\n        limit,\n        offset,\n        orderBy,\n        setOperators: []\n      });\n    } else {\n      result = this.buildSelectQuery({\n        table: aliasedTable(table, tableAlias),\n        fields: {},\n        fieldsFlat: selection.map(({ field }) => ({\n          path: [],\n          field: is(field, Column) ? aliasedTableColumn(field, tableAlias) : field\n        })),\n        joins,\n        where,\n        limit,\n        offset,\n        orderBy,\n        setOperators: []\n      });\n    }\n    return {\n      tableTsKey: tableConfig.tsName,\n      sql: result,\n      selection\n    };\n  }\n}\nclass SQLiteSyncDialect extends SQLiteDialect {\n  static [entityKind] = \"SQLiteSyncDialect\";\n  migrate(migrations, session, config) {\n    const migrationsTable = config === void 0 ? \"__drizzle_migrations\" : typeof config === \"string\" ? \"__drizzle_migrations\" : config.migrationsTable ?? \"__drizzle_migrations\";\n    const migrationTableCreate = sql`\n\t\t\tCREATE TABLE IF NOT EXISTS ${sql.identifier(migrationsTable)} (\n\t\t\t\tid SERIAL PRIMARY KEY,\n\t\t\t\thash text NOT NULL,\n\t\t\t\tcreated_at numeric\n\t\t\t)\n\t\t`;\n    session.run(migrationTableCreate);\n    const dbMigrations = session.values(\n      sql`SELECT id, hash, created_at FROM ${sql.identifier(migrationsTable)} ORDER BY created_at DESC LIMIT 1`\n    );\n    const lastDbMigration = dbMigrations[0] ?? void 0;\n    session.run(sql`BEGIN`);\n    try {\n      for (const migration of migrations) {\n        if (!lastDbMigration || Number(lastDbMigration[2]) < migration.folderMillis) {\n          for (const stmt of migration.sql) {\n            session.run(sql.raw(stmt));\n          }\n          session.run(\n            sql`INSERT INTO ${sql.identifier(migrationsTable)} (\"hash\", \"created_at\") VALUES(${migration.hash}, ${migration.folderMillis})`\n          );\n        }\n      }\n      session.run(sql`COMMIT`);\n    } catch (e) {\n      session.run(sql`ROLLBACK`);\n      throw e;\n    }\n  }\n}\nclass SQLiteAsyncDialect extends SQLiteDialect {\n  static [entityKind] = \"SQLiteAsyncDialect\";\n  async migrate(migrations, session, config) {\n    const migrationsTable = config === void 0 ? \"__drizzle_migrations\" : typeof config === \"string\" ? \"__drizzle_migrations\" : config.migrationsTable ?? \"__drizzle_migrations\";\n    const migrationTableCreate = sql`\n\t\t\tCREATE TABLE IF NOT EXISTS ${sql.identifier(migrationsTable)} (\n\t\t\t\tid SERIAL PRIMARY KEY,\n\t\t\t\thash text NOT NULL,\n\t\t\t\tcreated_at numeric\n\t\t\t)\n\t\t`;\n    await session.run(migrationTableCreate);\n    const dbMigrations = await session.values(\n      sql`SELECT id, hash, created_at FROM ${sql.identifier(migrationsTable)} ORDER BY created_at DESC LIMIT 1`\n    );\n    const lastDbMigration = dbMigrations[0] ?? void 0;\n    await session.transaction(async (tx) => {\n      for (const migration of migrations) {\n        if (!lastDbMigration || Number(lastDbMigration[2]) < migration.folderMillis) {\n          for (const stmt of migration.sql) {\n            await tx.run(sql.raw(stmt));\n          }\n          await tx.run(\n            sql`INSERT INTO ${sql.identifier(migrationsTable)} (\"hash\", \"created_at\") VALUES(${migration.hash}, ${migration.folderMillis})`\n          );\n        }\n      }\n    });\n  }\n}\nexport {\n  SQLiteAsyncDialect,\n  SQLiteDialect,\n  SQLiteSyncDialect\n};\n//# sourceMappingURL=dialect.js.map",
    "import { entityKind } from \"../entity.js\";\nclass TypedQueryBuilder {\n  static [entityKind] = \"TypedQueryBuilder\";\n  /** @internal */\n  getSelectedFields() {\n    return this._.selectedFields;\n  }\n}\nexport {\n  TypedQueryBuilder\n};\n//# sourceMappingURL=query-builder.js.map",
    "import { entityKind, is } from \"../../entity.js\";\nimport { TypedQueryBuilder } from \"../../query-builders/query-builder.js\";\nimport { QueryPromise } from \"../../query-promise.js\";\nimport { SelectionProxyHandler } from \"../../selection-proxy.js\";\nimport { SQL, View } from \"../../sql/sql.js\";\nimport { Subquery } from \"../../subquery.js\";\nimport { Table } from \"../../table.js\";\nimport {\n  applyMixins,\n  getTableColumns,\n  getTableLikeName,\n  haveSameKeys,\n  orderSelectedFields\n} from \"../../utils.js\";\nimport { ViewBaseConfig } from \"../../view-common.js\";\nimport { extractUsedTable } from \"../utils.js\";\nimport { SQLiteViewBase } from \"../view-base.js\";\nclass SQLiteSelectBuilder {\n  static [entityKind] = \"SQLiteSelectBuilder\";\n  fields;\n  session;\n  dialect;\n  withList;\n  distinct;\n  constructor(config) {\n    this.fields = config.fields;\n    this.session = config.session;\n    this.dialect = config.dialect;\n    this.withList = config.withList;\n    this.distinct = config.distinct;\n  }\n  from(source) {\n    const isPartialSelect = !!this.fields;\n    let fields;\n    if (this.fields) {\n      fields = this.fields;\n    } else if (is(source, Subquery)) {\n      fields = Object.fromEntries(\n        Object.keys(source._.selectedFields).map((key) => [key, source[key]])\n      );\n    } else if (is(source, SQLiteViewBase)) {\n      fields = source[ViewBaseConfig].selectedFields;\n    } else if (is(source, SQL)) {\n      fields = {};\n    } else {\n      fields = getTableColumns(source);\n    }\n    return new SQLiteSelectBase({\n      table: source,\n      fields,\n      isPartialSelect,\n      session: this.session,\n      dialect: this.dialect,\n      withList: this.withList,\n      distinct: this.distinct\n    });\n  }\n}\nclass SQLiteSelectQueryBuilderBase extends TypedQueryBuilder {\n  static [entityKind] = \"SQLiteSelectQueryBuilder\";\n  _;\n  /** @internal */\n  config;\n  joinsNotNullableMap;\n  tableName;\n  isPartialSelect;\n  session;\n  dialect;\n  cacheConfig = void 0;\n  usedTables = /* @__PURE__ */ new Set();\n  constructor({ table, fields, isPartialSelect, session, dialect, withList, distinct }) {\n    super();\n    this.config = {\n      withList,\n      table,\n      fields: { ...fields },\n      distinct,\n      setOperators: []\n    };\n    this.isPartialSelect = isPartialSelect;\n    this.session = session;\n    this.dialect = dialect;\n    this._ = {\n      selectedFields: fields,\n      config: this.config\n    };\n    this.tableName = getTableLikeName(table);\n    this.joinsNotNullableMap = typeof this.tableName === \"string\" ? { [this.tableName]: true } : {};\n    for (const item of extractUsedTable(table)) this.usedTables.add(item);\n  }\n  /** @internal */\n  getUsedTables() {\n    return [...this.usedTables];\n  }\n  createJoin(joinType) {\n    return (table, on) => {\n      const baseTableName = this.tableName;\n      const tableName = getTableLikeName(table);\n      for (const item of extractUsedTable(table)) this.usedTables.add(item);\n      if (typeof tableName === \"string\" && this.config.joins?.some((join) => join.alias === tableName)) {\n        throw new Error(`Alias \"${tableName}\" is already used in this query`);\n      }\n      if (!this.isPartialSelect) {\n        if (Object.keys(this.joinsNotNullableMap).length === 1 && typeof baseTableName === \"string\") {\n          this.config.fields = {\n            [baseTableName]: this.config.fields\n          };\n        }\n        if (typeof tableName === \"string\" && !is(table, SQL)) {\n          const selection = is(table, Subquery) ? table._.selectedFields : is(table, View) ? table[ViewBaseConfig].selectedFields : table[Table.Symbol.Columns];\n          this.config.fields[tableName] = selection;\n        }\n      }\n      if (typeof on === \"function\") {\n        on = on(\n          new Proxy(\n            this.config.fields,\n            new SelectionProxyHandler({ sqlAliasedBehavior: \"sql\", sqlBehavior: \"sql\" })\n          )\n        );\n      }\n      if (!this.config.joins) {\n        this.config.joins = [];\n      }\n      this.config.joins.push({ on, table, joinType, alias: tableName });\n      if (typeof tableName === \"string\") {\n        switch (joinType) {\n          case \"left\": {\n            this.joinsNotNullableMap[tableName] = false;\n            break;\n          }\n          case \"right\": {\n            this.joinsNotNullableMap = Object.fromEntries(\n              Object.entries(this.joinsNotNullableMap).map(([key]) => [key, false])\n            );\n            this.joinsNotNullableMap[tableName] = true;\n            break;\n          }\n          case \"cross\":\n          case \"inner\": {\n            this.joinsNotNullableMap[tableName] = true;\n            break;\n          }\n          case \"full\": {\n            this.joinsNotNullableMap = Object.fromEntries(\n              Object.entries(this.joinsNotNullableMap).map(([key]) => [key, false])\n            );\n            this.joinsNotNullableMap[tableName] = false;\n            break;\n          }\n        }\n      }\n      return this;\n    };\n  }\n  /**\n   * Executes a `left join` operation by adding another table to the current query.\n   *\n   * Calling this method associates each row of the table with the corresponding row from the joined table, if a match is found. If no matching row exists, it sets all columns of the joined table to null.\n   *\n   * See docs: {@link https://orm.drizzle.team/docs/joins#left-join}\n   *\n   * @param table the table to join.\n   * @param on the `on` clause.\n   *\n   * @example\n   *\n   * ```ts\n   * // Select all users and their pets\n   * const usersWithPets: { user: User; pets: Pet | null; }[] = await db.select()\n   *   .from(users)\n   *   .leftJoin(pets, eq(users.id, pets.ownerId))\n   *\n   * // Select userId and petId\n   * const usersIdsAndPetIds: { userId: number; petId: number | null; }[] = await db.select({\n   *   userId: users.id,\n   *   petId: pets.id,\n   * })\n   *   .from(users)\n   *   .leftJoin(pets, eq(users.id, pets.ownerId))\n   * ```\n   */\n  leftJoin = this.createJoin(\"left\");\n  /**\n   * Executes a `right join` operation by adding another table to the current query.\n   *\n   * Calling this method associates each row of the joined table with the corresponding row from the main table, if a match is found. If no matching row exists, it sets all columns of the main table to null.\n   *\n   * See docs: {@link https://orm.drizzle.team/docs/joins#right-join}\n   *\n   * @param table the table to join.\n   * @param on the `on` clause.\n   *\n   * @example\n   *\n   * ```ts\n   * // Select all users and their pets\n   * const usersWithPets: { user: User | null; pets: Pet; }[] = await db.select()\n   *   .from(users)\n   *   .rightJoin(pets, eq(users.id, pets.ownerId))\n   *\n   * // Select userId and petId\n   * const usersIdsAndPetIds: { userId: number | null; petId: number; }[] = await db.select({\n   *   userId: users.id,\n   *   petId: pets.id,\n   * })\n   *   .from(users)\n   *   .rightJoin(pets, eq(users.id, pets.ownerId))\n   * ```\n   */\n  rightJoin = this.createJoin(\"right\");\n  /**\n   * Executes an `inner join` operation, creating a new table by combining rows from two tables that have matching values.\n   *\n   * Calling this method retrieves rows that have corresponding entries in both joined tables. Rows without matching entries in either table are excluded, resulting in a table that includes only matching pairs.\n   *\n   * See docs: {@link https://orm.drizzle.team/docs/joins#inner-join}\n   *\n   * @param table the table to join.\n   * @param on the `on` clause.\n   *\n   * @example\n   *\n   * ```ts\n   * // Select all users and their pets\n   * const usersWithPets: { user: User; pets: Pet; }[] = await db.select()\n   *   .from(users)\n   *   .innerJoin(pets, eq(users.id, pets.ownerId))\n   *\n   * // Select userId and petId\n   * const usersIdsAndPetIds: { userId: number; petId: number; }[] = await db.select({\n   *   userId: users.id,\n   *   petId: pets.id,\n   * })\n   *   .from(users)\n   *   .innerJoin(pets, eq(users.id, pets.ownerId))\n   * ```\n   */\n  innerJoin = this.createJoin(\"inner\");\n  /**\n   * Executes a `full join` operation by combining rows from two tables into a new table.\n   *\n   * Calling this method retrieves all rows from both main and joined tables, merging rows with matching values and filling in `null` for non-matching columns.\n   *\n   * See docs: {@link https://orm.drizzle.team/docs/joins#full-join}\n   *\n   * @param table the table to join.\n   * @param on the `on` clause.\n   *\n   * @example\n   *\n   * ```ts\n   * // Select all users and their pets\n   * const usersWithPets: { user: User | null; pets: Pet | null; }[] = await db.select()\n   *   .from(users)\n   *   .fullJoin(pets, eq(users.id, pets.ownerId))\n   *\n   * // Select userId and petId\n   * const usersIdsAndPetIds: { userId: number | null; petId: number | null; }[] = await db.select({\n   *   userId: users.id,\n   *   petId: pets.id,\n   * })\n   *   .from(users)\n   *   .fullJoin(pets, eq(users.id, pets.ownerId))\n   * ```\n   */\n  fullJoin = this.createJoin(\"full\");\n  /**\n   * Executes a `cross join` operation by combining rows from two tables into a new table.\n   *\n   * Calling this method retrieves all rows from both main and joined tables, merging all rows from each table.\n   *\n   * See docs: {@link https://orm.drizzle.team/docs/joins#cross-join}\n   *\n   * @param table the table to join.\n   *\n   * @example\n   *\n   * ```ts\n   * // Select all users, each user with every pet\n   * const usersWithPets: { user: User; pets: Pet; }[] = await db.select()\n   *   .from(users)\n   *   .crossJoin(pets)\n   *\n   * // Select userId and petId\n   * const usersIdsAndPetIds: { userId: number; petId: number; }[] = await db.select({\n   *   userId: users.id,\n   *   petId: pets.id,\n   * })\n   *   .from(users)\n   *   .crossJoin(pets)\n   * ```\n   */\n  crossJoin = this.createJoin(\"cross\");\n  createSetOperator(type, isAll) {\n    return (rightSelection) => {\n      const rightSelect = typeof rightSelection === \"function\" ? rightSelection(getSQLiteSetOperators()) : rightSelection;\n      if (!haveSameKeys(this.getSelectedFields(), rightSelect.getSelectedFields())) {\n        throw new Error(\n          \"Set operator error (union / intersect / except): selected fields are not the same or are in a different order\"\n        );\n      }\n      this.config.setOperators.push({ type, isAll, rightSelect });\n      return this;\n    };\n  }\n  /**\n   * Adds `union` set operator to the query.\n   *\n   * Calling this method will combine the result sets of the `select` statements and remove any duplicate rows that appear across them.\n   *\n   * See docs: {@link https://orm.drizzle.team/docs/set-operations#union}\n   *\n   * @example\n   *\n   * ```ts\n   * // Select all unique names from customers and users tables\n   * await db.select({ name: users.name })\n   *   .from(users)\n   *   .union(\n   *     db.select({ name: customers.name }).from(customers)\n   *   );\n   * // or\n   * import { union } from 'drizzle-orm/sqlite-core'\n   *\n   * await union(\n   *   db.select({ name: users.name }).from(users),\n   *   db.select({ name: customers.name }).from(customers)\n   * );\n   * ```\n   */\n  union = this.createSetOperator(\"union\", false);\n  /**\n   * Adds `union all` set operator to the query.\n   *\n   * Calling this method will combine the result-set of the `select` statements and keep all duplicate rows that appear across them.\n   *\n   * See docs: {@link https://orm.drizzle.team/docs/set-operations#union-all}\n   *\n   * @example\n   *\n   * ```ts\n   * // Select all transaction ids from both online and in-store sales\n   * await db.select({ transaction: onlineSales.transactionId })\n   *   .from(onlineSales)\n   *   .unionAll(\n   *     db.select({ transaction: inStoreSales.transactionId }).from(inStoreSales)\n   *   );\n   * // or\n   * import { unionAll } from 'drizzle-orm/sqlite-core'\n   *\n   * await unionAll(\n   *   db.select({ transaction: onlineSales.transactionId }).from(onlineSales),\n   *   db.select({ transaction: inStoreSales.transactionId }).from(inStoreSales)\n   * );\n   * ```\n   */\n  unionAll = this.createSetOperator(\"union\", true);\n  /**\n   * Adds `intersect` set operator to the query.\n   *\n   * Calling this method will retain only the rows that are present in both result sets and eliminate duplicates.\n   *\n   * See docs: {@link https://orm.drizzle.team/docs/set-operations#intersect}\n   *\n   * @example\n   *\n   * ```ts\n   * // Select course names that are offered in both departments A and B\n   * await db.select({ courseName: depA.courseName })\n   *   .from(depA)\n   *   .intersect(\n   *     db.select({ courseName: depB.courseName }).from(depB)\n   *   );\n   * // or\n   * import { intersect } from 'drizzle-orm/sqlite-core'\n   *\n   * await intersect(\n   *   db.select({ courseName: depA.courseName }).from(depA),\n   *   db.select({ courseName: depB.courseName }).from(depB)\n   * );\n   * ```\n   */\n  intersect = this.createSetOperator(\"intersect\", false);\n  /**\n   * Adds `except` set operator to the query.\n   *\n   * Calling this method will retrieve all unique rows from the left query, except for the rows that are present in the result set of the right query.\n   *\n   * See docs: {@link https://orm.drizzle.team/docs/set-operations#except}\n   *\n   * @example\n   *\n   * ```ts\n   * // Select all courses offered in department A but not in department B\n   * await db.select({ courseName: depA.courseName })\n   *   .from(depA)\n   *   .except(\n   *     db.select({ courseName: depB.courseName }).from(depB)\n   *   );\n   * // or\n   * import { except } from 'drizzle-orm/sqlite-core'\n   *\n   * await except(\n   *   db.select({ courseName: depA.courseName }).from(depA),\n   *   db.select({ courseName: depB.courseName }).from(depB)\n   * );\n   * ```\n   */\n  except = this.createSetOperator(\"except\", false);\n  /** @internal */\n  addSetOperators(setOperators) {\n    this.config.setOperators.push(...setOperators);\n    return this;\n  }\n  /**\n   * Adds a `where` clause to the query.\n   *\n   * Calling this method will select only those rows that fulfill a specified condition.\n   *\n   * See docs: {@link https://orm.drizzle.team/docs/select#filtering}\n   *\n   * @param where the `where` clause.\n   *\n   * @example\n   * You can use conditional operators and `sql function` to filter the rows to be selected.\n   *\n   * ```ts\n   * // Select all cars with green color\n   * await db.select().from(cars).where(eq(cars.color, 'green'));\n   * // or\n   * await db.select().from(cars).where(sql`${cars.color} = 'green'`)\n   * ```\n   *\n   * You can logically combine conditional operators with `and()` and `or()` operators:\n   *\n   * ```ts\n   * // Select all BMW cars with a green color\n   * await db.select().from(cars).where(and(eq(cars.color, 'green'), eq(cars.brand, 'BMW')));\n   *\n   * // Select all cars with the green or blue color\n   * await db.select().from(cars).where(or(eq(cars.color, 'green'), eq(cars.color, 'blue')));\n   * ```\n   */\n  where(where) {\n    if (typeof where === \"function\") {\n      where = where(\n        new Proxy(\n          this.config.fields,\n          new SelectionProxyHandler({ sqlAliasedBehavior: \"sql\", sqlBehavior: \"sql\" })\n        )\n      );\n    }\n    this.config.where = where;\n    return this;\n  }\n  /**\n   * Adds a `having` clause to the query.\n   *\n   * Calling this method will select only those rows that fulfill a specified condition. It is typically used with aggregate functions to filter the aggregated data based on a specified condition.\n   *\n   * See docs: {@link https://orm.drizzle.team/docs/select#aggregations}\n   *\n   * @param having the `having` clause.\n   *\n   * @example\n   *\n   * ```ts\n   * // Select all brands with more than one car\n   * await db.select({\n   * \tbrand: cars.brand,\n   * \tcount: sql<number>`cast(count(${cars.id}) as int)`,\n   * })\n   *   .from(cars)\n   *   .groupBy(cars.brand)\n   *   .having(({ count }) => gt(count, 1));\n   * ```\n   */\n  having(having) {\n    if (typeof having === \"function\") {\n      having = having(\n        new Proxy(\n          this.config.fields,\n          new SelectionProxyHandler({ sqlAliasedBehavior: \"sql\", sqlBehavior: \"sql\" })\n        )\n      );\n    }\n    this.config.having = having;\n    return this;\n  }\n  groupBy(...columns) {\n    if (typeof columns[0] === \"function\") {\n      const groupBy = columns[0](\n        new Proxy(\n          this.config.fields,\n          new SelectionProxyHandler({ sqlAliasedBehavior: \"alias\", sqlBehavior: \"sql\" })\n        )\n      );\n      this.config.groupBy = Array.isArray(groupBy) ? groupBy : [groupBy];\n    } else {\n      this.config.groupBy = columns;\n    }\n    return this;\n  }\n  orderBy(...columns) {\n    if (typeof columns[0] === \"function\") {\n      const orderBy = columns[0](\n        new Proxy(\n          this.config.fields,\n          new SelectionProxyHandler({ sqlAliasedBehavior: \"alias\", sqlBehavior: \"sql\" })\n        )\n      );\n      const orderByArray = Array.isArray(orderBy) ? orderBy : [orderBy];\n      if (this.config.setOperators.length > 0) {\n        this.config.setOperators.at(-1).orderBy = orderByArray;\n      } else {\n        this.config.orderBy = orderByArray;\n      }\n    } else {\n      const orderByArray = columns;\n      if (this.config.setOperators.length > 0) {\n        this.config.setOperators.at(-1).orderBy = orderByArray;\n      } else {\n        this.config.orderBy = orderByArray;\n      }\n    }\n    return this;\n  }\n  /**\n   * Adds a `limit` clause to the query.\n   *\n   * Calling this method will set the maximum number of rows that will be returned by this query.\n   *\n   * See docs: {@link https://orm.drizzle.team/docs/select#limit--offset}\n   *\n   * @param limit the `limit` clause.\n   *\n   * @example\n   *\n   * ```ts\n   * // Get the first 10 people from this query.\n   * await db.select().from(people).limit(10);\n   * ```\n   */\n  limit(limit) {\n    if (this.config.setOperators.length > 0) {\n      this.config.setOperators.at(-1).limit = limit;\n    } else {\n      this.config.limit = limit;\n    }\n    return this;\n  }\n  /**\n   * Adds an `offset` clause to the query.\n   *\n   * Calling this method will skip a number of rows when returning results from this query.\n   *\n   * See docs: {@link https://orm.drizzle.team/docs/select#limit--offset}\n   *\n   * @param offset the `offset` clause.\n   *\n   * @example\n   *\n   * ```ts\n   * // Get the 10th-20th people from this query.\n   * await db.select().from(people).offset(10).limit(10);\n   * ```\n   */\n  offset(offset) {\n    if (this.config.setOperators.length > 0) {\n      this.config.setOperators.at(-1).offset = offset;\n    } else {\n      this.config.offset = offset;\n    }\n    return this;\n  }\n  /** @internal */\n  getSQL() {\n    return this.dialect.buildSelectQuery(this.config);\n  }\n  toSQL() {\n    const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());\n    return rest;\n  }\n  as(alias) {\n    const usedTables = [];\n    usedTables.push(...extractUsedTable(this.config.table));\n    if (this.config.joins) {\n      for (const it of this.config.joins) usedTables.push(...extractUsedTable(it.table));\n    }\n    return new Proxy(\n      new Subquery(this.getSQL(), this.config.fields, alias, false, [...new Set(usedTables)]),\n      new SelectionProxyHandler({ alias, sqlAliasedBehavior: \"alias\", sqlBehavior: \"error\" })\n    );\n  }\n  /** @internal */\n  getSelectedFields() {\n    return new Proxy(\n      this.config.fields,\n      new SelectionProxyHandler({ alias: this.tableName, sqlAliasedBehavior: \"alias\", sqlBehavior: \"error\" })\n    );\n  }\n  $dynamic() {\n    return this;\n  }\n}\nclass SQLiteSelectBase extends SQLiteSelectQueryBuilderBase {\n  static [entityKind] = \"SQLiteSelect\";\n  /** @internal */\n  _prepare(isOneTimeQuery = true) {\n    if (!this.session) {\n      throw new Error(\"Cannot execute a query on a query builder. Please use a database instance instead.\");\n    }\n    const fieldsList = orderSelectedFields(this.config.fields);\n    const query = this.session[isOneTimeQuery ? \"prepareOneTimeQuery\" : \"prepareQuery\"](\n      this.dialect.sqlToQuery(this.getSQL()),\n      fieldsList,\n      \"all\",\n      true,\n      void 0,\n      {\n        type: \"select\",\n        tables: [...this.usedTables]\n      },\n      this.cacheConfig\n    );\n    query.joinsNotNullableMap = this.joinsNotNullableMap;\n    return query;\n  }\n  $withCache(config) {\n    this.cacheConfig = config === void 0 ? { config: {}, enable: true, autoInvalidate: true } : config === false ? { enable: false } : { enable: true, autoInvalidate: true, ...config };\n    return this;\n  }\n  prepare() {\n    return this._prepare(false);\n  }\n  run = (placeholderValues) => {\n    return this._prepare().run(placeholderValues);\n  };\n  all = (placeholderValues) => {\n    return this._prepare().all(placeholderValues);\n  };\n  get = (placeholderValues) => {\n    return this._prepare().get(placeholderValues);\n  };\n  values = (placeholderValues) => {\n    return this._prepare().values(placeholderValues);\n  };\n  async execute() {\n    return this.all();\n  }\n}\napplyMixins(SQLiteSelectBase, [QueryPromise]);\nfunction createSetOperator(type, isAll) {\n  return (leftSelect, rightSelect, ...restSelects) => {\n    const setOperators = [rightSelect, ...restSelects].map((select) => ({\n      type,\n      isAll,\n      rightSelect: select\n    }));\n    for (const setOperator of setOperators) {\n      if (!haveSameKeys(leftSelect.getSelectedFields(), setOperator.rightSelect.getSelectedFields())) {\n        throw new Error(\n          \"Set operator error (union / intersect / except): selected fields are not the same or are in a different order\"\n        );\n      }\n    }\n    return leftSelect.addSetOperators(setOperators);\n  };\n}\nconst getSQLiteSetOperators = () => ({\n  union,\n  unionAll,\n  intersect,\n  except\n});\nconst union = createSetOperator(\"union\", false);\nconst unionAll = createSetOperator(\"union\", true);\nconst intersect = createSetOperator(\"intersect\", false);\nconst except = createSetOperator(\"except\", false);\nexport {\n  SQLiteSelectBase,\n  SQLiteSelectBuilder,\n  SQLiteSelectQueryBuilderBase,\n  except,\n  intersect,\n  union,\n  unionAll\n};\n//# sourceMappingURL=select.js.map",
    "import { entityKind, is } from \"../../entity.js\";\nimport { SelectionProxyHandler } from \"../../selection-proxy.js\";\nimport { SQLiteDialect, SQLiteSyncDialect } from \"../dialect.js\";\nimport { WithSubquery } from \"../../subquery.js\";\nimport { SQLiteSelectBuilder } from \"./select.js\";\nclass QueryBuilder {\n  static [entityKind] = \"SQLiteQueryBuilder\";\n  dialect;\n  dialectConfig;\n  constructor(dialect) {\n    this.dialect = is(dialect, SQLiteDialect) ? dialect : void 0;\n    this.dialectConfig = is(dialect, SQLiteDialect) ? void 0 : dialect;\n  }\n  $with = (alias, selection) => {\n    const queryBuilder = this;\n    const as = (qb) => {\n      if (typeof qb === \"function\") {\n        qb = qb(queryBuilder);\n      }\n      return new Proxy(\n        new WithSubquery(\n          qb.getSQL(),\n          selection ?? (\"getSelectedFields\" in qb ? qb.getSelectedFields() ?? {} : {}),\n          alias,\n          true\n        ),\n        new SelectionProxyHandler({ alias, sqlAliasedBehavior: \"alias\", sqlBehavior: \"error\" })\n      );\n    };\n    return { as };\n  };\n  with(...queries) {\n    const self = this;\n    function select(fields) {\n      return new SQLiteSelectBuilder({\n        fields: fields ?? void 0,\n        session: void 0,\n        dialect: self.getDialect(),\n        withList: queries\n      });\n    }\n    function selectDistinct(fields) {\n      return new SQLiteSelectBuilder({\n        fields: fields ?? void 0,\n        session: void 0,\n        dialect: self.getDialect(),\n        withList: queries,\n        distinct: true\n      });\n    }\n    return { select, selectDistinct };\n  }\n  select(fields) {\n    return new SQLiteSelectBuilder({ fields: fields ?? void 0, session: void 0, dialect: this.getDialect() });\n  }\n  selectDistinct(fields) {\n    return new SQLiteSelectBuilder({\n      fields: fields ?? void 0,\n      session: void 0,\n      dialect: this.getDialect(),\n      distinct: true\n    });\n  }\n  // Lazy load dialect to avoid circular dependency\n  getDialect() {\n    if (!this.dialect) {\n      this.dialect = new SQLiteSyncDialect(this.dialectConfig);\n    }\n    return this.dialect;\n  }\n}\nexport {\n  QueryBuilder\n};\n//# sourceMappingURL=query-builder.js.map",
    "import { entityKind, is } from \"../../entity.js\";\nimport { QueryPromise } from \"../../query-promise.js\";\nimport { Param, SQL, sql } from \"../../sql/sql.js\";\nimport { SQLiteTable } from \"../table.js\";\nimport { Columns, Table } from \"../../table.js\";\nimport { haveSameKeys, mapUpdateSet, orderSelectedFields } from \"../../utils.js\";\nimport { extractUsedTable } from \"../utils.js\";\nimport { QueryBuilder } from \"./query-builder.js\";\nclass SQLiteInsertBuilder {\n  constructor(table, session, dialect, withList) {\n    this.table = table;\n    this.session = session;\n    this.dialect = dialect;\n    this.withList = withList;\n  }\n  static [entityKind] = \"SQLiteInsertBuilder\";\n  values(values) {\n    values = Array.isArray(values) ? values : [values];\n    if (values.length === 0) {\n      throw new Error(\"values() must be called with at least one value\");\n    }\n    const mappedValues = values.map((entry) => {\n      const result = {};\n      const cols = this.table[Table.Symbol.Columns];\n      for (const colKey of Object.keys(entry)) {\n        const colValue = entry[colKey];\n        result[colKey] = is(colValue, SQL) ? colValue : new Param(colValue, cols[colKey]);\n      }\n      return result;\n    });\n    return new SQLiteInsertBase(this.table, mappedValues, this.session, this.dialect, this.withList);\n  }\n  select(selectQuery) {\n    const select = typeof selectQuery === \"function\" ? selectQuery(new QueryBuilder()) : selectQuery;\n    if (!is(select, SQL) && !haveSameKeys(this.table[Columns], select._.selectedFields)) {\n      throw new Error(\n        \"Insert select error: selected fields are not the same or are in a different order compared to the table definition\"\n      );\n    }\n    return new SQLiteInsertBase(this.table, select, this.session, this.dialect, this.withList, true);\n  }\n}\nclass SQLiteInsertBase extends QueryPromise {\n  constructor(table, values, session, dialect, withList, select) {\n    super();\n    this.session = session;\n    this.dialect = dialect;\n    this.config = { table, values, withList, select };\n  }\n  static [entityKind] = \"SQLiteInsert\";\n  /** @internal */\n  config;\n  returning(fields = this.config.table[SQLiteTable.Symbol.Columns]) {\n    this.config.returning = orderSelectedFields(fields);\n    return this;\n  }\n  /**\n   * Adds an `on conflict do nothing` clause to the query.\n   *\n   * Calling this method simply avoids inserting a row as its alternative action.\n   *\n   * See docs: {@link https://orm.drizzle.team/docs/insert#on-conflict-do-nothing}\n   *\n   * @param config The `target` and `where` clauses.\n   *\n   * @example\n   * ```ts\n   * // Insert one row and cancel the insert if there's a conflict\n   * await db.insert(cars)\n   *   .values({ id: 1, brand: 'BMW' })\n   *   .onConflictDoNothing();\n   *\n   * // Explicitly specify conflict target\n   * await db.insert(cars)\n   *   .values({ id: 1, brand: 'BMW' })\n   *   .onConflictDoNothing({ target: cars.id });\n   * ```\n   */\n  onConflictDoNothing(config = {}) {\n    if (!this.config.onConflict) this.config.onConflict = [];\n    if (config.target === void 0) {\n      this.config.onConflict.push(sql` on conflict do nothing`);\n    } else {\n      const targetSql = Array.isArray(config.target) ? sql`${config.target}` : sql`${[config.target]}`;\n      const whereSql = config.where ? sql` where ${config.where}` : sql``;\n      this.config.onConflict.push(sql` on conflict ${targetSql} do nothing${whereSql}`);\n    }\n    return this;\n  }\n  /**\n   * Adds an `on conflict do update` clause to the query.\n   *\n   * Calling this method will update the existing row that conflicts with the row proposed for insertion as its alternative action.\n   *\n   * See docs: {@link https://orm.drizzle.team/docs/insert#upserts-and-conflicts}\n   *\n   * @param config The `target`, `set` and `where` clauses.\n   *\n   * @example\n   * ```ts\n   * // Update the row if there's a conflict\n   * await db.insert(cars)\n   *   .values({ id: 1, brand: 'BMW' })\n   *   .onConflictDoUpdate({\n   *     target: cars.id,\n   *     set: { brand: 'Porsche' }\n   *   });\n   *\n   * // Upsert with 'where' clause\n   * await db.insert(cars)\n   *   .values({ id: 1, brand: 'BMW' })\n   *   .onConflictDoUpdate({\n   *     target: cars.id,\n   *     set: { brand: 'newBMW' },\n   *     where: sql`${cars.createdAt} > '2023-01-01'::date`,\n   *   });\n   * ```\n   */\n  onConflictDoUpdate(config) {\n    if (config.where && (config.targetWhere || config.setWhere)) {\n      throw new Error(\n        'You cannot use both \"where\" and \"targetWhere\"/\"setWhere\" at the same time - \"where\" is deprecated, use \"targetWhere\" or \"setWhere\" instead.'\n      );\n    }\n    if (!this.config.onConflict) this.config.onConflict = [];\n    const whereSql = config.where ? sql` where ${config.where}` : void 0;\n    const targetWhereSql = config.targetWhere ? sql` where ${config.targetWhere}` : void 0;\n    const setWhereSql = config.setWhere ? sql` where ${config.setWhere}` : void 0;\n    const targetSql = Array.isArray(config.target) ? sql`${config.target}` : sql`${[config.target]}`;\n    const setSql = this.dialect.buildUpdateSet(this.config.table, mapUpdateSet(this.config.table, config.set));\n    this.config.onConflict.push(\n      sql` on conflict ${targetSql}${targetWhereSql} do update set ${setSql}${whereSql}${setWhereSql}`\n    );\n    return this;\n  }\n  /** @internal */\n  getSQL() {\n    return this.dialect.buildInsertQuery(this.config);\n  }\n  toSQL() {\n    const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());\n    return rest;\n  }\n  /** @internal */\n  _prepare(isOneTimeQuery = true) {\n    return this.session[isOneTimeQuery ? \"prepareOneTimeQuery\" : \"prepareQuery\"](\n      this.dialect.sqlToQuery(this.getSQL()),\n      this.config.returning,\n      this.config.returning ? \"all\" : \"run\",\n      true,\n      void 0,\n      {\n        type: \"insert\",\n        tables: extractUsedTable(this.config.table)\n      }\n    );\n  }\n  prepare() {\n    return this._prepare(false);\n  }\n  run = (placeholderValues) => {\n    return this._prepare().run(placeholderValues);\n  };\n  all = (placeholderValues) => {\n    return this._prepare().all(placeholderValues);\n  };\n  get = (placeholderValues) => {\n    return this._prepare().get(placeholderValues);\n  };\n  values = (placeholderValues) => {\n    return this._prepare().values(placeholderValues);\n  };\n  async execute() {\n    return this.config.returning ? this.all() : this.run();\n  }\n  $dynamic() {\n    return this;\n  }\n}\nexport {\n  SQLiteInsertBase,\n  SQLiteInsertBuilder\n};\n//# sourceMappingURL=insert.js.map",
    "import { entityKind, is } from \"../../entity.js\";\nimport { QueryPromise } from \"../../query-promise.js\";\nimport { SelectionProxyHandler } from \"../../selection-proxy.js\";\nimport { SQLiteTable } from \"../table.js\";\nimport { Subquery } from \"../../subquery.js\";\nimport { Table } from \"../../table.js\";\nimport {\n  getTableLikeName,\n  mapUpdateSet,\n  orderSelectedFields\n} from \"../../utils.js\";\nimport { ViewBaseConfig } from \"../../view-common.js\";\nimport { extractUsedTable } from \"../utils.js\";\nimport { SQLiteViewBase } from \"../view-base.js\";\nclass SQLiteUpdateBuilder {\n  constructor(table, session, dialect, withList) {\n    this.table = table;\n    this.session = session;\n    this.dialect = dialect;\n    this.withList = withList;\n  }\n  static [entityKind] = \"SQLiteUpdateBuilder\";\n  set(values) {\n    return new SQLiteUpdateBase(\n      this.table,\n      mapUpdateSet(this.table, values),\n      this.session,\n      this.dialect,\n      this.withList\n    );\n  }\n}\nclass SQLiteUpdateBase extends QueryPromise {\n  constructor(table, set, session, dialect, withList) {\n    super();\n    this.session = session;\n    this.dialect = dialect;\n    this.config = { set, table, withList, joins: [] };\n  }\n  static [entityKind] = \"SQLiteUpdate\";\n  /** @internal */\n  config;\n  from(source) {\n    this.config.from = source;\n    return this;\n  }\n  createJoin(joinType) {\n    return (table, on) => {\n      const tableName = getTableLikeName(table);\n      if (typeof tableName === \"string\" && this.config.joins.some((join) => join.alias === tableName)) {\n        throw new Error(`Alias \"${tableName}\" is already used in this query`);\n      }\n      if (typeof on === \"function\") {\n        const from = this.config.from ? is(table, SQLiteTable) ? table[Table.Symbol.Columns] : is(table, Subquery) ? table._.selectedFields : is(table, SQLiteViewBase) ? table[ViewBaseConfig].selectedFields : void 0 : void 0;\n        on = on(\n          new Proxy(\n            this.config.table[Table.Symbol.Columns],\n            new SelectionProxyHandler({ sqlAliasedBehavior: \"sql\", sqlBehavior: \"sql\" })\n          ),\n          from && new Proxy(\n            from,\n            new SelectionProxyHandler({ sqlAliasedBehavior: \"sql\", sqlBehavior: \"sql\" })\n          )\n        );\n      }\n      this.config.joins.push({ on, table, joinType, alias: tableName });\n      return this;\n    };\n  }\n  leftJoin = this.createJoin(\"left\");\n  rightJoin = this.createJoin(\"right\");\n  innerJoin = this.createJoin(\"inner\");\n  fullJoin = this.createJoin(\"full\");\n  /**\n   * Adds a 'where' clause to the query.\n   *\n   * Calling this method will update only those rows that fulfill a specified condition.\n   *\n   * See docs: {@link https://orm.drizzle.team/docs/update}\n   *\n   * @param where the 'where' clause.\n   *\n   * @example\n   * You can use conditional operators and `sql function` to filter the rows to be updated.\n   *\n   * ```ts\n   * // Update all cars with green color\n   * db.update(cars).set({ color: 'red' })\n   *   .where(eq(cars.color, 'green'));\n   * // or\n   * db.update(cars).set({ color: 'red' })\n   *   .where(sql`${cars.color} = 'green'`)\n   * ```\n   *\n   * You can logically combine conditional operators with `and()` and `or()` operators:\n   *\n   * ```ts\n   * // Update all BMW cars with a green color\n   * db.update(cars).set({ color: 'red' })\n   *   .where(and(eq(cars.color, 'green'), eq(cars.brand, 'BMW')));\n   *\n   * // Update all cars with the green or blue color\n   * db.update(cars).set({ color: 'red' })\n   *   .where(or(eq(cars.color, 'green'), eq(cars.color, 'blue')));\n   * ```\n   */\n  where(where) {\n    this.config.where = where;\n    return this;\n  }\n  orderBy(...columns) {\n    if (typeof columns[0] === \"function\") {\n      const orderBy = columns[0](\n        new Proxy(\n          this.config.table[Table.Symbol.Columns],\n          new SelectionProxyHandler({ sqlAliasedBehavior: \"alias\", sqlBehavior: \"sql\" })\n        )\n      );\n      const orderByArray = Array.isArray(orderBy) ? orderBy : [orderBy];\n      this.config.orderBy = orderByArray;\n    } else {\n      const orderByArray = columns;\n      this.config.orderBy = orderByArray;\n    }\n    return this;\n  }\n  limit(limit) {\n    this.config.limit = limit;\n    return this;\n  }\n  returning(fields = this.config.table[SQLiteTable.Symbol.Columns]) {\n    this.config.returning = orderSelectedFields(fields);\n    return this;\n  }\n  /** @internal */\n  getSQL() {\n    return this.dialect.buildUpdateQuery(this.config);\n  }\n  toSQL() {\n    const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());\n    return rest;\n  }\n  /** @internal */\n  _prepare(isOneTimeQuery = true) {\n    return this.session[isOneTimeQuery ? \"prepareOneTimeQuery\" : \"prepareQuery\"](\n      this.dialect.sqlToQuery(this.getSQL()),\n      this.config.returning,\n      this.config.returning ? \"all\" : \"run\",\n      true,\n      void 0,\n      {\n        type: \"insert\",\n        tables: extractUsedTable(this.config.table)\n      }\n    );\n  }\n  prepare() {\n    return this._prepare(false);\n  }\n  run = (placeholderValues) => {\n    return this._prepare().run(placeholderValues);\n  };\n  all = (placeholderValues) => {\n    return this._prepare().all(placeholderValues);\n  };\n  get = (placeholderValues) => {\n    return this._prepare().get(placeholderValues);\n  };\n  values = (placeholderValues) => {\n    return this._prepare().values(placeholderValues);\n  };\n  async execute() {\n    return this.config.returning ? this.all() : this.run();\n  }\n  $dynamic() {\n    return this;\n  }\n}\nexport {\n  SQLiteUpdateBase,\n  SQLiteUpdateBuilder\n};\n//# sourceMappingURL=update.js.map",
    "import { entityKind } from \"../../entity.js\";\nimport { SQL, sql } from \"../../sql/sql.js\";\nclass SQLiteCountBuilder extends SQL {\n  constructor(params) {\n    super(SQLiteCountBuilder.buildEmbeddedCount(params.source, params.filters).queryChunks);\n    this.params = params;\n    this.session = params.session;\n    this.sql = SQLiteCountBuilder.buildCount(\n      params.source,\n      params.filters\n    );\n  }\n  sql;\n  static [entityKind] = \"SQLiteCountBuilderAsync\";\n  [Symbol.toStringTag] = \"SQLiteCountBuilderAsync\";\n  session;\n  static buildEmbeddedCount(source, filters) {\n    return sql`(select count(*) from ${source}${sql.raw(\" where \").if(filters)}${filters})`;\n  }\n  static buildCount(source, filters) {\n    return sql`select count(*) from ${source}${sql.raw(\" where \").if(filters)}${filters}`;\n  }\n  then(onfulfilled, onrejected) {\n    return Promise.resolve(this.session.count(this.sql)).then(\n      onfulfilled,\n      onrejected\n    );\n  }\n  catch(onRejected) {\n    return this.then(void 0, onRejected);\n  }\n  finally(onFinally) {\n    return this.then(\n      (value) => {\n        onFinally?.();\n        return value;\n      },\n      (reason) => {\n        onFinally?.();\n        throw reason;\n      }\n    );\n  }\n}\nexport {\n  SQLiteCountBuilder\n};\n//# sourceMappingURL=count.js.map",
    "import { entityKind } from \"../../entity.js\";\nimport { QueryPromise } from \"../../query-promise.js\";\nimport {\n  mapRelationalRow\n} from \"../../relations.js\";\nclass RelationalQueryBuilder {\n  constructor(mode, fullSchema, schema, tableNamesMap, table, tableConfig, dialect, session) {\n    this.mode = mode;\n    this.fullSchema = fullSchema;\n    this.schema = schema;\n    this.tableNamesMap = tableNamesMap;\n    this.table = table;\n    this.tableConfig = tableConfig;\n    this.dialect = dialect;\n    this.session = session;\n  }\n  static [entityKind] = \"SQLiteAsyncRelationalQueryBuilder\";\n  findMany(config) {\n    return this.mode === \"sync\" ? new SQLiteSyncRelationalQuery(\n      this.fullSchema,\n      this.schema,\n      this.tableNamesMap,\n      this.table,\n      this.tableConfig,\n      this.dialect,\n      this.session,\n      config ? config : {},\n      \"many\"\n    ) : new SQLiteRelationalQuery(\n      this.fullSchema,\n      this.schema,\n      this.tableNamesMap,\n      this.table,\n      this.tableConfig,\n      this.dialect,\n      this.session,\n      config ? config : {},\n      \"many\"\n    );\n  }\n  findFirst(config) {\n    return this.mode === \"sync\" ? new SQLiteSyncRelationalQuery(\n      this.fullSchema,\n      this.schema,\n      this.tableNamesMap,\n      this.table,\n      this.tableConfig,\n      this.dialect,\n      this.session,\n      config ? { ...config, limit: 1 } : { limit: 1 },\n      \"first\"\n    ) : new SQLiteRelationalQuery(\n      this.fullSchema,\n      this.schema,\n      this.tableNamesMap,\n      this.table,\n      this.tableConfig,\n      this.dialect,\n      this.session,\n      config ? { ...config, limit: 1 } : { limit: 1 },\n      \"first\"\n    );\n  }\n}\nclass SQLiteRelationalQuery extends QueryPromise {\n  constructor(fullSchema, schema, tableNamesMap, table, tableConfig, dialect, session, config, mode) {\n    super();\n    this.fullSchema = fullSchema;\n    this.schema = schema;\n    this.tableNamesMap = tableNamesMap;\n    this.table = table;\n    this.tableConfig = tableConfig;\n    this.dialect = dialect;\n    this.session = session;\n    this.config = config;\n    this.mode = mode;\n  }\n  static [entityKind] = \"SQLiteAsyncRelationalQuery\";\n  /** @internal */\n  mode;\n  /** @internal */\n  getSQL() {\n    return this.dialect.buildRelationalQuery({\n      fullSchema: this.fullSchema,\n      schema: this.schema,\n      tableNamesMap: this.tableNamesMap,\n      table: this.table,\n      tableConfig: this.tableConfig,\n      queryConfig: this.config,\n      tableAlias: this.tableConfig.tsName\n    }).sql;\n  }\n  /** @internal */\n  _prepare(isOneTimeQuery = false) {\n    const { query, builtQuery } = this._toSQL();\n    return this.session[isOneTimeQuery ? \"prepareOneTimeQuery\" : \"prepareQuery\"](\n      builtQuery,\n      void 0,\n      this.mode === \"first\" ? \"get\" : \"all\",\n      true,\n      (rawRows, mapColumnValue) => {\n        const rows = rawRows.map(\n          (row) => mapRelationalRow(this.schema, this.tableConfig, row, query.selection, mapColumnValue)\n        );\n        if (this.mode === \"first\") {\n          return rows[0];\n        }\n        return rows;\n      }\n    );\n  }\n  prepare() {\n    return this._prepare(false);\n  }\n  _toSQL() {\n    const query = this.dialect.buildRelationalQuery({\n      fullSchema: this.fullSchema,\n      schema: this.schema,\n      tableNamesMap: this.tableNamesMap,\n      table: this.table,\n      tableConfig: this.tableConfig,\n      queryConfig: this.config,\n      tableAlias: this.tableConfig.tsName\n    });\n    const builtQuery = this.dialect.sqlToQuery(query.sql);\n    return { query, builtQuery };\n  }\n  toSQL() {\n    return this._toSQL().builtQuery;\n  }\n  /** @internal */\n  executeRaw() {\n    if (this.mode === \"first\") {\n      return this._prepare(false).get();\n    }\n    return this._prepare(false).all();\n  }\n  async execute() {\n    return this.executeRaw();\n  }\n}\nclass SQLiteSyncRelationalQuery extends SQLiteRelationalQuery {\n  static [entityKind] = \"SQLiteSyncRelationalQuery\";\n  sync() {\n    return this.executeRaw();\n  }\n}\nexport {\n  RelationalQueryBuilder,\n  SQLiteRelationalQuery,\n  SQLiteSyncRelationalQuery\n};\n//# sourceMappingURL=query.js.map",
    "import { entityKind } from \"../../entity.js\";\nimport { QueryPromise } from \"../../query-promise.js\";\nclass SQLiteRaw extends QueryPromise {\n  constructor(execute, getSQL, action, dialect, mapBatchResult) {\n    super();\n    this.execute = execute;\n    this.getSQL = getSQL;\n    this.dialect = dialect;\n    this.mapBatchResult = mapBatchResult;\n    this.config = { action };\n  }\n  static [entityKind] = \"SQLiteRaw\";\n  /** @internal */\n  config;\n  getQuery() {\n    return { ...this.dialect.sqlToQuery(this.getSQL()), method: this.config.action };\n  }\n  mapResult(result, isFromBatch) {\n    return isFromBatch ? this.mapBatchResult(result) : result;\n  }\n  _prepare() {\n    return this;\n  }\n  /** @internal */\n  isResponseInArrayMode() {\n    return false;\n  }\n}\nexport {\n  SQLiteRaw\n};\n//# sourceMappingURL=raw.js.map",
    "import { entityKind } from \"../entity.js\";\nimport { SelectionProxyHandler } from \"../selection-proxy.js\";\nimport { sql } from \"../sql/sql.js\";\nimport {\n  QueryBuilder,\n  SQLiteDeleteBase,\n  SQLiteInsertBuilder,\n  SQLiteSelectBuilder,\n  SQLiteUpdateBuilder\n} from \"./query-builders/index.js\";\nimport { WithSubquery } from \"../subquery.js\";\nimport { SQLiteCountBuilder } from \"./query-builders/count.js\";\nimport { RelationalQueryBuilder } from \"./query-builders/query.js\";\nimport { SQLiteRaw } from \"./query-builders/raw.js\";\nclass BaseSQLiteDatabase {\n  constructor(resultKind, dialect, session, schema) {\n    this.resultKind = resultKind;\n    this.dialect = dialect;\n    this.session = session;\n    this._ = schema ? {\n      schema: schema.schema,\n      fullSchema: schema.fullSchema,\n      tableNamesMap: schema.tableNamesMap\n    } : {\n      schema: void 0,\n      fullSchema: {},\n      tableNamesMap: {}\n    };\n    this.query = {};\n    const query = this.query;\n    if (this._.schema) {\n      for (const [tableName, columns] of Object.entries(this._.schema)) {\n        query[tableName] = new RelationalQueryBuilder(\n          resultKind,\n          schema.fullSchema,\n          this._.schema,\n          this._.tableNamesMap,\n          schema.fullSchema[tableName],\n          columns,\n          dialect,\n          session\n        );\n      }\n    }\n    this.$cache = { invalidate: async (_params) => {\n    } };\n  }\n  static [entityKind] = \"BaseSQLiteDatabase\";\n  query;\n  /**\n   * Creates a subquery that defines a temporary named result set as a CTE.\n   *\n   * It is useful for breaking down complex queries into simpler parts and for reusing the result set in subsequent parts of the query.\n   *\n   * See docs: {@link https://orm.drizzle.team/docs/select#with-clause}\n   *\n   * @param alias The alias for the subquery.\n   *\n   * Failure to provide an alias will result in a DrizzleTypeError, preventing the subquery from being referenced in other queries.\n   *\n   * @example\n   *\n   * ```ts\n   * // Create a subquery with alias 'sq' and use it in the select query\n   * const sq = db.$with('sq').as(db.select().from(users).where(eq(users.id, 42)));\n   *\n   * const result = await db.with(sq).select().from(sq);\n   * ```\n   *\n   * To select arbitrary SQL values as fields in a CTE and reference them in other CTEs or in the main query, you need to add aliases to them:\n   *\n   * ```ts\n   * // Select an arbitrary SQL value as a field in a CTE and reference it in the main query\n   * const sq = db.$with('sq').as(db.select({\n   *   name: sql<string>`upper(${users.name})`.as('name'),\n   * })\n   * .from(users));\n   *\n   * const result = await db.with(sq).select({ name: sq.name }).from(sq);\n   * ```\n   */\n  $with = (alias, selection) => {\n    const self = this;\n    const as = (qb) => {\n      if (typeof qb === \"function\") {\n        qb = qb(new QueryBuilder(self.dialect));\n      }\n      return new Proxy(\n        new WithSubquery(\n          qb.getSQL(),\n          selection ?? (\"getSelectedFields\" in qb ? qb.getSelectedFields() ?? {} : {}),\n          alias,\n          true\n        ),\n        new SelectionProxyHandler({ alias, sqlAliasedBehavior: \"alias\", sqlBehavior: \"error\" })\n      );\n    };\n    return { as };\n  };\n  $count(source, filters) {\n    return new SQLiteCountBuilder({ source, filters, session: this.session });\n  }\n  /**\n   * Incorporates a previously defined CTE (using `$with`) into the main query.\n   *\n   * This method allows the main query to reference a temporary named result set.\n   *\n   * See docs: {@link https://orm.drizzle.team/docs/select#with-clause}\n   *\n   * @param queries The CTEs to incorporate into the main query.\n   *\n   * @example\n   *\n   * ```ts\n   * // Define a subquery 'sq' as a CTE using $with\n   * const sq = db.$with('sq').as(db.select().from(users).where(eq(users.id, 42)));\n   *\n   * // Incorporate the CTE 'sq' into the main query and select from it\n   * const result = await db.with(sq).select().from(sq);\n   * ```\n   */\n  with(...queries) {\n    const self = this;\n    function select(fields) {\n      return new SQLiteSelectBuilder({\n        fields: fields ?? void 0,\n        session: self.session,\n        dialect: self.dialect,\n        withList: queries\n      });\n    }\n    function selectDistinct(fields) {\n      return new SQLiteSelectBuilder({\n        fields: fields ?? void 0,\n        session: self.session,\n        dialect: self.dialect,\n        withList: queries,\n        distinct: true\n      });\n    }\n    function update(table) {\n      return new SQLiteUpdateBuilder(table, self.session, self.dialect, queries);\n    }\n    function insert(into) {\n      return new SQLiteInsertBuilder(into, self.session, self.dialect, queries);\n    }\n    function delete_(from) {\n      return new SQLiteDeleteBase(from, self.session, self.dialect, queries);\n    }\n    return { select, selectDistinct, update, insert, delete: delete_ };\n  }\n  select(fields) {\n    return new SQLiteSelectBuilder({ fields: fields ?? void 0, session: this.session, dialect: this.dialect });\n  }\n  selectDistinct(fields) {\n    return new SQLiteSelectBuilder({\n      fields: fields ?? void 0,\n      session: this.session,\n      dialect: this.dialect,\n      distinct: true\n    });\n  }\n  /**\n   * Creates an update query.\n   *\n   * Calling this method without `.where()` clause will update all rows in a table. The `.where()` clause specifies which rows should be updated.\n   *\n   * Use `.set()` method to specify which values to update.\n   *\n   * See docs: {@link https://orm.drizzle.team/docs/update}\n   *\n   * @param table The table to update.\n   *\n   * @example\n   *\n   * ```ts\n   * // Update all rows in the 'cars' table\n   * await db.update(cars).set({ color: 'red' });\n   *\n   * // Update rows with filters and conditions\n   * await db.update(cars).set({ color: 'red' }).where(eq(cars.brand, 'BMW'));\n   *\n   * // Update with returning clause\n   * const updatedCar: Car[] = await db.update(cars)\n   *   .set({ color: 'red' })\n   *   .where(eq(cars.id, 1))\n   *   .returning();\n   * ```\n   */\n  update(table) {\n    return new SQLiteUpdateBuilder(table, this.session, this.dialect);\n  }\n  $cache;\n  /**\n   * Creates an insert query.\n   *\n   * Calling this method will create new rows in a table. Use `.values()` method to specify which values to insert.\n   *\n   * See docs: {@link https://orm.drizzle.team/docs/insert}\n   *\n   * @param table The table to insert into.\n   *\n   * @example\n   *\n   * ```ts\n   * // Insert one row\n   * await db.insert(cars).values({ brand: 'BMW' });\n   *\n   * // Insert multiple rows\n   * await db.insert(cars).values([{ brand: 'BMW' }, { brand: 'Porsche' }]);\n   *\n   * // Insert with returning clause\n   * const insertedCar: Car[] = await db.insert(cars)\n   *   .values({ brand: 'BMW' })\n   *   .returning();\n   * ```\n   */\n  insert(into) {\n    return new SQLiteInsertBuilder(into, this.session, this.dialect);\n  }\n  /**\n   * Creates a delete query.\n   *\n   * Calling this method without `.where()` clause will delete all rows in a table. The `.where()` clause specifies which rows should be deleted.\n   *\n   * See docs: {@link https://orm.drizzle.team/docs/delete}\n   *\n   * @param table The table to delete from.\n   *\n   * @example\n   *\n   * ```ts\n   * // Delete all rows in the 'cars' table\n   * await db.delete(cars);\n   *\n   * // Delete rows with filters and conditions\n   * await db.delete(cars).where(eq(cars.color, 'green'));\n   *\n   * // Delete with returning clause\n   * const deletedCar: Car[] = await db.delete(cars)\n   *   .where(eq(cars.id, 1))\n   *   .returning();\n   * ```\n   */\n  delete(from) {\n    return new SQLiteDeleteBase(from, this.session, this.dialect);\n  }\n  run(query) {\n    const sequel = typeof query === \"string\" ? sql.raw(query) : query.getSQL();\n    if (this.resultKind === \"async\") {\n      return new SQLiteRaw(\n        async () => this.session.run(sequel),\n        () => sequel,\n        \"run\",\n        this.dialect,\n        this.session.extractRawRunValueFromBatchResult.bind(this.session)\n      );\n    }\n    return this.session.run(sequel);\n  }\n  all(query) {\n    const sequel = typeof query === \"string\" ? sql.raw(query) : query.getSQL();\n    if (this.resultKind === \"async\") {\n      return new SQLiteRaw(\n        async () => this.session.all(sequel),\n        () => sequel,\n        \"all\",\n        this.dialect,\n        this.session.extractRawAllValueFromBatchResult.bind(this.session)\n      );\n    }\n    return this.session.all(sequel);\n  }\n  get(query) {\n    const sequel = typeof query === \"string\" ? sql.raw(query) : query.getSQL();\n    if (this.resultKind === \"async\") {\n      return new SQLiteRaw(\n        async () => this.session.get(sequel),\n        () => sequel,\n        \"get\",\n        this.dialect,\n        this.session.extractRawGetValueFromBatchResult.bind(this.session)\n      );\n    }\n    return this.session.get(sequel);\n  }\n  values(query) {\n    const sequel = typeof query === \"string\" ? sql.raw(query) : query.getSQL();\n    if (this.resultKind === \"async\") {\n      return new SQLiteRaw(\n        async () => this.session.values(sequel),\n        () => sequel,\n        \"values\",\n        this.dialect,\n        this.session.extractRawValuesValueFromBatchResult.bind(this.session)\n      );\n    }\n    return this.session.values(sequel);\n  }\n  transaction(transaction, config) {\n    return this.session.transaction(transaction, config);\n  }\n}\nconst withReplicas = (primary, replicas, getReplica = () => replicas[Math.floor(Math.random() * replicas.length)]) => {\n  const select = (...args) => getReplica(replicas).select(...args);\n  const selectDistinct = (...args) => getReplica(replicas).selectDistinct(...args);\n  const $count = (...args) => getReplica(replicas).$count(...args);\n  const $with = (...args) => getReplica(replicas).with(...args);\n  const update = (...args) => primary.update(...args);\n  const insert = (...args) => primary.insert(...args);\n  const $delete = (...args) => primary.delete(...args);\n  const run = (...args) => primary.run(...args);\n  const all = (...args) => primary.all(...args);\n  const get = (...args) => primary.get(...args);\n  const values = (...args) => primary.values(...args);\n  const transaction = (...args) => primary.transaction(...args);\n  return {\n    ...primary,\n    update,\n    insert,\n    delete: $delete,\n    run,\n    all,\n    get,\n    values,\n    transaction,\n    $primary: primary,\n    select,\n    selectDistinct,\n    $count,\n    with: $with,\n    get query() {\n      return getReplica(replicas).query;\n    }\n  };\n};\nexport {\n  BaseSQLiteDatabase,\n  withReplicas\n};\n//# sourceMappingURL=db.js.map",
    "import { entityKind } from \"../../entity.js\";\nclass Cache {\n  static [entityKind] = \"Cache\";\n}\nclass NoopCache extends Cache {\n  strategy() {\n    return \"all\";\n  }\n  static [entityKind] = \"NoopCache\";\n  async get(_key) {\n    return void 0;\n  }\n  async put(_hashedQuery, _response, _tables, _config) {\n  }\n  async onMutate(_params) {\n  }\n}\nasync function hashQuery(sql, params) {\n  const dataToHash = `${sql}-${JSON.stringify(params)}`;\n  const encoder = new TextEncoder();\n  const data = encoder.encode(dataToHash);\n  const hashBuffer = await crypto.subtle.digest(\"SHA-256\", data);\n  const hashArray = [...new Uint8Array(hashBuffer)];\n  const hashHex = hashArray.map((b) => b.toString(16).padStart(2, \"0\")).join(\"\");\n  return hashHex;\n}\nexport {\n  Cache,\n  NoopCache,\n  hashQuery\n};\n//# sourceMappingURL=cache.js.map",
    "import { hashQuery, NoopCache } from \"../cache/core/cache.js\";\nimport { entityKind, is } from \"../entity.js\";\nimport { DrizzleError, DrizzleQueryError, TransactionRollbackError } from \"../errors.js\";\nimport { QueryPromise } from \"../query-promise.js\";\nimport { BaseSQLiteDatabase } from \"./db.js\";\nclass ExecuteResultSync extends QueryPromise {\n  constructor(resultCb) {\n    super();\n    this.resultCb = resultCb;\n  }\n  static [entityKind] = \"ExecuteResultSync\";\n  async execute() {\n    return this.resultCb();\n  }\n  sync() {\n    return this.resultCb();\n  }\n}\nclass SQLitePreparedQuery {\n  constructor(mode, executeMethod, query, cache, queryMetadata, cacheConfig) {\n    this.mode = mode;\n    this.executeMethod = executeMethod;\n    this.query = query;\n    this.cache = cache;\n    this.queryMetadata = queryMetadata;\n    this.cacheConfig = cacheConfig;\n    if (cache && cache.strategy() === \"all\" && cacheConfig === void 0) {\n      this.cacheConfig = { enable: true, autoInvalidate: true };\n    }\n    if (!this.cacheConfig?.enable) {\n      this.cacheConfig = void 0;\n    }\n  }\n  static [entityKind] = \"PreparedQuery\";\n  /** @internal */\n  joinsNotNullableMap;\n  /** @internal */\n  async queryWithCache(queryString, params, query) {\n    if (this.cache === void 0 || is(this.cache, NoopCache) || this.queryMetadata === void 0) {\n      try {\n        return await query();\n      } catch (e) {\n        throw new DrizzleQueryError(queryString, params, e);\n      }\n    }\n    if (this.cacheConfig && !this.cacheConfig.enable) {\n      try {\n        return await query();\n      } catch (e) {\n        throw new DrizzleQueryError(queryString, params, e);\n      }\n    }\n    if ((this.queryMetadata.type === \"insert\" || this.queryMetadata.type === \"update\" || this.queryMetadata.type === \"delete\") && this.queryMetadata.tables.length > 0) {\n      try {\n        const [res] = await Promise.all([\n          query(),\n          this.cache.onMutate({ tables: this.queryMetadata.tables })\n        ]);\n        return res;\n      } catch (e) {\n        throw new DrizzleQueryError(queryString, params, e);\n      }\n    }\n    if (!this.cacheConfig) {\n      try {\n        return await query();\n      } catch (e) {\n        throw new DrizzleQueryError(queryString, params, e);\n      }\n    }\n    if (this.queryMetadata.type === \"select\") {\n      const fromCache = await this.cache.get(\n        this.cacheConfig.tag ?? (await hashQuery(queryString, params)),\n        this.queryMetadata.tables,\n        this.cacheConfig.tag !== void 0,\n        this.cacheConfig.autoInvalidate\n      );\n      if (fromCache === void 0) {\n        let result;\n        try {\n          result = await query();\n        } catch (e) {\n          throw new DrizzleQueryError(queryString, params, e);\n        }\n        await this.cache.put(\n          this.cacheConfig.tag ?? (await hashQuery(queryString, params)),\n          result,\n          // make sure we send tables that were used in a query only if user wants to invalidate it on each write\n          this.cacheConfig.autoInvalidate ? this.queryMetadata.tables : [],\n          this.cacheConfig.tag !== void 0,\n          this.cacheConfig.config\n        );\n        return result;\n      }\n      return fromCache;\n    }\n    try {\n      return await query();\n    } catch (e) {\n      throw new DrizzleQueryError(queryString, params, e);\n    }\n  }\n  getQuery() {\n    return this.query;\n  }\n  mapRunResult(result, _isFromBatch) {\n    return result;\n  }\n  mapAllResult(_result, _isFromBatch) {\n    throw new Error(\"Not implemented\");\n  }\n  mapGetResult(_result, _isFromBatch) {\n    throw new Error(\"Not implemented\");\n  }\n  execute(placeholderValues) {\n    if (this.mode === \"async\") {\n      return this[this.executeMethod](placeholderValues);\n    }\n    return new ExecuteResultSync(() => this[this.executeMethod](placeholderValues));\n  }\n  mapResult(response, isFromBatch) {\n    switch (this.executeMethod) {\n      case \"run\": {\n        return this.mapRunResult(response, isFromBatch);\n      }\n      case \"all\": {\n        return this.mapAllResult(response, isFromBatch);\n      }\n      case \"get\": {\n        return this.mapGetResult(response, isFromBatch);\n      }\n    }\n  }\n}\nclass SQLiteSession {\n  constructor(dialect) {\n    this.dialect = dialect;\n  }\n  static [entityKind] = \"SQLiteSession\";\n  prepareOneTimeQuery(query, fields, executeMethod, isResponseInArrayMode, customResultMapper, queryMetadata, cacheConfig) {\n    return this.prepareQuery(\n      query,\n      fields,\n      executeMethod,\n      isResponseInArrayMode,\n      customResultMapper,\n      queryMetadata,\n      cacheConfig\n    );\n  }\n  run(query) {\n    const staticQuery = this.dialect.sqlToQuery(query);\n    try {\n      return this.prepareOneTimeQuery(staticQuery, void 0, \"run\", false).run();\n    } catch (err) {\n      throw new DrizzleError({ cause: err, message: `Failed to run the query '${staticQuery.sql}'` });\n    }\n  }\n  /** @internal */\n  extractRawRunValueFromBatchResult(result) {\n    return result;\n  }\n  all(query) {\n    return this.prepareOneTimeQuery(this.dialect.sqlToQuery(query), void 0, \"run\", false).all();\n  }\n  /** @internal */\n  extractRawAllValueFromBatchResult(_result) {\n    throw new Error(\"Not implemented\");\n  }\n  get(query) {\n    return this.prepareOneTimeQuery(this.dialect.sqlToQuery(query), void 0, \"run\", false).get();\n  }\n  /** @internal */\n  extractRawGetValueFromBatchResult(_result) {\n    throw new Error(\"Not implemented\");\n  }\n  values(query) {\n    return this.prepareOneTimeQuery(this.dialect.sqlToQuery(query), void 0, \"run\", false).values();\n  }\n  async count(sql) {\n    const result = await this.values(sql);\n    return result[0][0];\n  }\n  /** @internal */\n  extractRawValuesValueFromBatchResult(_result) {\n    throw new Error(\"Not implemented\");\n  }\n}\nclass SQLiteTransaction extends BaseSQLiteDatabase {\n  constructor(resultType, dialect, session, schema, nestedIndex = 0) {\n    super(resultType, dialect, session, schema);\n    this.schema = schema;\n    this.nestedIndex = nestedIndex;\n  }\n  static [entityKind] = \"SQLiteTransaction\";\n  rollback() {\n    throw new TransactionRollbackError();\n  }\n}\nexport {\n  ExecuteResultSync,\n  SQLitePreparedQuery,\n  SQLiteSession,\n  SQLiteTransaction\n};\n//# sourceMappingURL=session.js.map",
    "import { entityKind } from \"./entity.js\";\nclass ConsoleLogWriter {\n  static [entityKind] = \"ConsoleLogWriter\";\n  write(message) {\n    console.log(message);\n  }\n}\nclass DefaultLogger {\n  static [entityKind] = \"DefaultLogger\";\n  writer;\n  constructor(config) {\n    this.writer = config?.writer ?? new ConsoleLogWriter();\n  }\n  logQuery(query, params) {\n    const stringifiedParams = params.map((p) => {\n      try {\n        return JSON.stringify(p);\n      } catch {\n        return String(p);\n      }\n    });\n    const paramsStr = stringifiedParams.length ? ` -- params: [${stringifiedParams.join(\", \")}]` : \"\";\n    this.writer.write(`Query: ${query}${paramsStr}`);\n  }\n}\nclass NoopLogger {\n  static [entityKind] = \"NoopLogger\";\n  logQuery() {\n  }\n}\nexport {\n  ConsoleLogWriter,\n  DefaultLogger,\n  NoopLogger\n};\n//# sourceMappingURL=logger.js.map",
    "import { __export } from \"../_virtual/rolldown_runtime.js\";\nimport { index, integer, real, sqliteTable, text } from \"drizzle-orm/sqlite-core\";\nimport { relations } from \"drizzle-orm\";\n\n//#region src/db/schema.ts\nvar schema_exports = {};\n__export(schema_exports, {\n\tcharacters: () => characters,\n\tcharactersRelations: () => charactersRelations,\n\tminingFleetParticipants: () => miningFleetParticipants,\n\tminingFleetParticipantsRelations: () => miningFleetParticipantsRelations,\n\tminingFleets: () => miningFleets,\n\tminingFleetsRelations: () => miningFleetsRelations,\n\tresumeCommands: () => resumeCommands,\n\tshared: () => shared,\n\tusers: () => users,\n\tusersRelations: () => usersRelations\n});\nconst shared = {\n\tcreatedAt: integer(\"created_at\").notNull(),\n\tupdatedAt: integer(\"updated_at\")\n};\nconst users = sqliteTable(\"users\", {\n\tid: integer().primaryKey().unique().notNull(),\n\tdiscordID: text(\"discord_id\").unique().notNull(),\n\tmainCharacter: integer(\"main_character\"),\n\t...shared\n}, (table) => [index(\"idx_discord_id\").on(table.discordID), index(\"idx_main_character\").on(table.mainCharacter)]);\nconst usersRelations = relations(users, ({ one, many }) => ({\n\tcharacters: many(characters),\n\tmain: one(characters, {\n\t\tfields: [users.mainCharacter],\n\t\treferences: [characters.id]\n\t})\n}));\nconst characters = sqliteTable(\"characters\", {\n\tid: integer(\"id\").primaryKey({ autoIncrement: true }),\n\teveID: integer(\"eve_id\").notNull(),\n\tuserID: integer(\"user_id\").notNull(),\n\tname: text().notNull(),\n\taccessToken: text(\"access_token\").notNull(),\n\texpiresAt: integer(\"expires_at\").notNull(),\n\trefreshToken: text(\"refresh_token\").notNull(),\n\t...shared\n}, (table) => [index(\"idx_user_id\").on(table.userID), index(\"idx_eve_id\").on(table.eveID)]);\nconst charactersRelations = relations(characters, ({ one }) => ({ user: one(users, {\n\tfields: [characters.userID],\n\treferences: [users.id]\n}) }));\nconst resumeCommands = sqliteTable(\"resumecommands\", {\n\tid: text().primaryKey(),\n\tcommand: text().notNull(),\n\tparams: text().notNull(),\n\tcontext: text().notNull(),\n\t...shared\n});\nconst miningFleets = sqliteTable(\"mining_fleets\", {\n\tid: integer(\"id\").primaryKey({ autoIncrement: true }),\n\tname: text(\"name\").notNull(),\n\tdescription: text(\"description\"),\n\tcreatorDiscordId: text(\"creator_discord_id\").notNull(),\n\tstartTime: integer(\"start_time\").notNull(),\n\tendTime: integer(\"end_time\"),\n\tstatus: text(\"status\", { enum: [\n\t\t\"configuring\",\n\t\t\"active\",\n\t\t\"ended\",\n\t\t\"generating_report\",\n\t\t\"completed\",\n\t\t\"failed\"\n\t] }).notNull().default(\"configuring\"),\n\ttaxRate: real(\"tax_rate\").notNull().default(0),\n\tpublicMessageId: text(\"public_message_id\").unique(),\n\tpublicChannelId: text(\"public_channel_id\"),\n\treportData: text(\"report_data\"),\n\tcreatorEphemeralMessageId: text(\"creator_ephemeral_message_id\"),\n\t...shared\n}, (table) => [\n\tindex(\"idx_fleet_creator_discord_id\").on(table.creatorDiscordId),\n\tindex(\"idx_fleet_status\").on(table.status),\n\tindex(\"idx_fleet_public_message_id\").on(table.publicMessageId)\n]);\nconst miningFleetParticipants = sqliteTable(\"mining_fleet_participants\", {\n\tid: integer(\"id\").primaryKey({ autoIncrement: true }),\n\tfleetId: integer(\"fleet_id\").notNull().references(() => miningFleets.id, { onDelete: \"cascade\" }),\n\tcharacterId: integer(\"character_id\").notNull().references(() => characters.id, { onDelete: \"cascade\" }),\n\tdiscordId: text(\"discord_id\").notNull(),\n\trole: text(\"role\", { enum: [\n\t\t\"miner\",\n\t\t\"security\",\n\t\t\"hauler\"\n\t] }).notNull(),\n\tjoinTime: integer(\"join_time\").notNull(),\n\t...shared\n}, (table) => [\n\tindex(\"idx_participant_fleet_id\").on(table.fleetId),\n\tindex(\"idx_participant_character_id\").on(table.characterId),\n\tindex(\"idx_participant_discord_id\").on(table.discordId)\n]);\nconst miningFleetsRelations = relations(miningFleets, ({ many }) => ({ participants: many(miningFleetParticipants) }));\nconst miningFleetParticipantsRelations = relations(miningFleetParticipants, ({ one }) => ({\n\tfleet: one(miningFleets, {\n\t\tfields: [miningFleetParticipants.fleetId],\n\t\treferences: [miningFleets.id]\n\t}),\n\tcharacter: one(characters, {\n\t\tfields: [miningFleetParticipants.characterId],\n\t\treferences: [characters.id]\n\t})\n}));\n\n//#endregion\nexport { characters, miningFleetParticipants, miningFleets, resumeCommands, schema_exports, users };",
    "//#region src/esi/options.ts\nconst CLIENT_ID = process.env.EVE_CLIENT_ID || \"\";\nconst CLIENT_SECRET = process.env.EVE_CLIENT_SECRET || \"\";\nconst CALLBACK_URL = process.env.EVE_CALLBACK_URL || \"\";\nconst USER_AGENT = process.env.ESI_USER_AGENT || \"\";\nconst options = {\n\tclient_id: CLIENT_ID,\n\tclient_secret: CLIENT_SECRET,\n\tcallback_url: CALLBACK_URL,\n\tuser_agent: USER_AGENT\n};\n\n//#endregion\nexport { options };",
    "export class InvalidTokenError extends Error {\n}\nInvalidTokenError.prototype.name = \"InvalidTokenError\";\nfunction b64DecodeUnicode(str) {\n    return decodeURIComponent(atob(str).replace(/(.)/g, (m, p) => {\n        let code = p.charCodeAt(0).toString(16).toUpperCase();\n        if (code.length < 2) {\n            code = \"0\" + code;\n        }\n        return \"%\" + code;\n    }));\n}\nfunction base64UrlDecode(str) {\n    let output = str.replace(/-/g, \"+\").replace(/_/g, \"/\");\n    switch (output.length % 4) {\n        case 0:\n            break;\n        case 2:\n            output += \"==\";\n            break;\n        case 3:\n            output += \"=\";\n            break;\n        default:\n            throw new Error(\"base64 string is not of the correct length\");\n    }\n    try {\n        return b64DecodeUnicode(output);\n    }\n    catch (err) {\n        return atob(output);\n    }\n}\nexport function jwtDecode(token, options) {\n    if (typeof token !== \"string\") {\n        throw new InvalidTokenError(\"Invalid token specified: must be a string\");\n    }\n    options || (options = {});\n    const pos = options.header === true ? 0 : 1;\n    const part = token.split(\".\")[pos];\n    if (typeof part !== \"string\") {\n        throw new InvalidTokenError(`Invalid token specified: missing part #${pos + 1}`);\n    }\n    let decoded;\n    try {\n        decoded = base64UrlDecode(part);\n    }\n    catch (e) {\n        throw new InvalidTokenError(`Invalid token specified: invalid base64 for part #${pos + 1} (${e.message})`);\n    }\n    try {\n        return JSON.parse(decoded);\n    }\n    catch (e) {\n        throw new InvalidTokenError(`Invalid token specified: invalid json for part #${pos + 1} (${e.message})`);\n    }\n}\n",
    "export function encodeBase32UpperCase(bytes) {\n    return encodeBase32_internal(bytes, base32UpperCaseAlphabet, EncodingPadding.Include);\n}\nexport function encodeBase32UpperCaseNoPadding(bytes) {\n    return encodeBase32_internal(bytes, base32UpperCaseAlphabet, EncodingPadding.None);\n}\nexport function encodeBase32LowerCase(bytes) {\n    return encodeBase32_internal(bytes, base32LowerCaseAlphabet, EncodingPadding.Include);\n}\nexport function encodeBase32LowerCaseNoPadding(bytes) {\n    return encodeBase32_internal(bytes, base32LowerCaseAlphabet, EncodingPadding.None);\n}\n/** Replaced: Use encodeBase32UpperCase() instead. */\nexport function encodeBase32(bytes) {\n    return encodeBase32UpperCase(bytes);\n}\n/** Replaced: Use encodeBase32UpperCaseNoPadding() instead. */\nexport function encodeBase32NoPadding(bytes) {\n    return encodeBase32UpperCaseNoPadding(bytes);\n}\nfunction encodeBase32_internal(bytes, alphabet, padding) {\n    let result = \"\";\n    for (let i = 0; i < bytes.byteLength; i += 5) {\n        let buffer = 0n;\n        let bufferBitSize = 0;\n        for (let j = 0; j < 5 && i + j < bytes.byteLength; j++) {\n            buffer = (buffer << 8n) | BigInt(bytes[i + j]);\n            bufferBitSize += 8;\n        }\n        if (bufferBitSize % 5 !== 0) {\n            buffer = buffer << BigInt(5 - (bufferBitSize % 5));\n            bufferBitSize += 5 - (bufferBitSize % 5);\n        }\n        for (let j = 0; j < 8; j++) {\n            if (bufferBitSize >= 5) {\n                result += alphabet[Number((buffer >> BigInt(bufferBitSize - 5)) & 0x1fn)];\n                bufferBitSize -= 5;\n            }\n            else if (bufferBitSize > 0) {\n                result += alphabet[Number((buffer << BigInt(6 - bufferBitSize)) & 0x3fn)];\n                bufferBitSize = 0;\n            }\n            else if (padding === EncodingPadding.Include) {\n                result += \"=\";\n            }\n        }\n    }\n    return result;\n}\nexport function decodeBase32(encoded) {\n    return decodeBase32_internal(encoded, base32DecodeMap, DecodingPadding.Required);\n}\nexport function decodeBase32IgnorePadding(encoded) {\n    return decodeBase32_internal(encoded, base32DecodeMap, DecodingPadding.Ignore);\n}\nfunction decodeBase32_internal(encoded, decodeMap, padding) {\n    const result = new Uint8Array(Math.ceil(encoded.length / 8) * 5);\n    let totalBytes = 0;\n    for (let i = 0; i < encoded.length; i += 8) {\n        let chunk = 0n;\n        let bitsRead = 0;\n        for (let j = 0; j < 8; j++) {\n            if (padding === DecodingPadding.Required) {\n                if (encoded[i + j] === \"=\") {\n                    continue;\n                }\n                if (i + j >= encoded.length) {\n                    throw new Error(\"Invalid padding\");\n                }\n            }\n            if (padding === DecodingPadding.Ignore) {\n                if (i + j >= encoded.length || encoded[i + j] === \"=\") {\n                    continue;\n                }\n            }\n            if (j > 0 && encoded[i + j - 1] === \"=\") {\n                throw new Error(\"Invalid padding\");\n            }\n            if (!(encoded[i + j] in decodeMap)) {\n                throw new Error(\"Invalid character\");\n            }\n            chunk |= BigInt(decodeMap[encoded[i + j]]) << BigInt((7 - j) * 5);\n            bitsRead += 5;\n        }\n        if (bitsRead < 40) {\n            let unused;\n            if (bitsRead === 10) {\n                unused = chunk & 0xffffffffn;\n            }\n            else if (bitsRead === 20) {\n                unused = chunk & 0xffffffn;\n            }\n            else if (bitsRead === 25) {\n                unused = chunk & 0xffffn;\n            }\n            else if (bitsRead === 35) {\n                unused = chunk & 0xffn;\n            }\n            else {\n                throw new Error(\"Invalid padding\");\n            }\n            if (unused !== 0n) {\n                throw new Error(\"Invalid padding\");\n            }\n        }\n        const byteLength = Math.floor(bitsRead / 8);\n        for (let i = 0; i < byteLength; i++) {\n            result[totalBytes] = Number((chunk >> BigInt(32 - i * 8)) & 0xffn);\n            totalBytes++;\n        }\n    }\n    return result.slice(0, totalBytes);\n}\nconst base32UpperCaseAlphabet = \"ABCDEFGHIJKLMNOPQRSTUVWXYZ234567\";\nconst base32LowerCaseAlphabet = \"abcdefghijklmnopqrstuvwxyz234567\";\nconst base32DecodeMap = {\n    A: 0,\n    B: 1,\n    C: 2,\n    D: 3,\n    E: 4,\n    F: 5,\n    G: 6,\n    H: 7,\n    I: 8,\n    J: 9,\n    K: 10,\n    L: 11,\n    M: 12,\n    N: 13,\n    O: 14,\n    P: 15,\n    Q: 16,\n    R: 17,\n    S: 18,\n    T: 19,\n    U: 20,\n    V: 21,\n    W: 22,\n    X: 23,\n    Y: 24,\n    Z: 25,\n    a: 0,\n    b: 1,\n    c: 2,\n    d: 3,\n    e: 4,\n    f: 5,\n    g: 6,\n    h: 7,\n    i: 8,\n    j: 9,\n    k: 10,\n    l: 11,\n    m: 12,\n    n: 13,\n    o: 14,\n    p: 15,\n    q: 16,\n    r: 17,\n    s: 18,\n    t: 19,\n    u: 20,\n    v: 21,\n    w: 22,\n    x: 23,\n    y: 24,\n    z: 25,\n    \"2\": 26,\n    \"3\": 27,\n    \"4\": 28,\n    \"5\": 29,\n    \"6\": 30,\n    \"7\": 31\n};\nvar EncodingPadding;\n(function (EncodingPadding) {\n    EncodingPadding[EncodingPadding[\"Include\"] = 0] = \"Include\";\n    EncodingPadding[EncodingPadding[\"None\"] = 1] = \"None\";\n})(EncodingPadding || (EncodingPadding = {}));\nvar DecodingPadding;\n(function (DecodingPadding) {\n    DecodingPadding[DecodingPadding[\"Required\"] = 0] = \"Required\";\n    DecodingPadding[DecodingPadding[\"Ignore\"] = 1] = \"Ignore\";\n})(DecodingPadding || (DecodingPadding = {}));\n",
    "export function encodeBase64(bytes) {\n    return encodeBase64_internal(bytes, base64Alphabet, EncodingPadding.Include);\n}\nexport function encodeBase64NoPadding(bytes) {\n    return encodeBase64_internal(bytes, base64Alphabet, EncodingPadding.None);\n}\nexport function encodeBase64url(bytes) {\n    return encodeBase64_internal(bytes, base64urlAlphabet, EncodingPadding.Include);\n}\nexport function encodeBase64urlNoPadding(bytes) {\n    return encodeBase64_internal(bytes, base64urlAlphabet, EncodingPadding.None);\n}\nfunction encodeBase64_internal(bytes, alphabet, padding) {\n    let result = \"\";\n    for (let i = 0; i < bytes.byteLength; i += 3) {\n        let buffer = 0;\n        let bufferBitSize = 0;\n        for (let j = 0; j < 3 && i + j < bytes.byteLength; j++) {\n            buffer = (buffer << 8) | bytes[i + j];\n            bufferBitSize += 8;\n        }\n        for (let j = 0; j < 4; j++) {\n            if (bufferBitSize >= 6) {\n                result += alphabet[(buffer >> (bufferBitSize - 6)) & 0x3f];\n                bufferBitSize -= 6;\n            }\n            else if (bufferBitSize > 0) {\n                result += alphabet[(buffer << (6 - bufferBitSize)) & 0x3f];\n                bufferBitSize = 0;\n            }\n            else if (padding === EncodingPadding.Include) {\n                result += \"=\";\n            }\n        }\n    }\n    return result;\n}\nconst base64Alphabet = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\";\nconst base64urlAlphabet = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_\";\nexport function decodeBase64(encoded) {\n    return decodeBase64_internal(encoded, base64DecodeMap, DecodingPadding.Required);\n}\nexport function decodeBase64IgnorePadding(encoded) {\n    return decodeBase64_internal(encoded, base64DecodeMap, DecodingPadding.Ignore);\n}\nexport function decodeBase64url(encoded) {\n    return decodeBase64_internal(encoded, base64urlDecodeMap, DecodingPadding.Required);\n}\nexport function decodeBase64urlIgnorePadding(encoded) {\n    return decodeBase64_internal(encoded, base64urlDecodeMap, DecodingPadding.Ignore);\n}\nfunction decodeBase64_internal(encoded, decodeMap, padding) {\n    const result = new Uint8Array(Math.ceil(encoded.length / 4) * 3);\n    let totalBytes = 0;\n    for (let i = 0; i < encoded.length; i += 4) {\n        let chunk = 0;\n        let bitsRead = 0;\n        for (let j = 0; j < 4; j++) {\n            if (padding === DecodingPadding.Required && encoded[i + j] === \"=\") {\n                continue;\n            }\n            if (padding === DecodingPadding.Ignore &&\n                (i + j >= encoded.length || encoded[i + j] === \"=\")) {\n                continue;\n            }\n            if (j > 0 && encoded[i + j - 1] === \"=\") {\n                throw new Error(\"Invalid padding\");\n            }\n            if (!(encoded[i + j] in decodeMap)) {\n                throw new Error(\"Invalid character\");\n            }\n            chunk |= decodeMap[encoded[i + j]] << ((3 - j) * 6);\n            bitsRead += 6;\n        }\n        if (bitsRead < 24) {\n            let unused;\n            if (bitsRead === 12) {\n                unused = chunk & 0xffff;\n            }\n            else if (bitsRead === 18) {\n                unused = chunk & 0xff;\n            }\n            else {\n                throw new Error(\"Invalid padding\");\n            }\n            if (unused !== 0) {\n                throw new Error(\"Invalid padding\");\n            }\n        }\n        const byteLength = Math.floor(bitsRead / 8);\n        for (let i = 0; i < byteLength; i++) {\n            result[totalBytes] = (chunk >> (16 - i * 8)) & 0xff;\n            totalBytes++;\n        }\n    }\n    return result.slice(0, totalBytes);\n}\nvar EncodingPadding;\n(function (EncodingPadding) {\n    EncodingPadding[EncodingPadding[\"Include\"] = 0] = \"Include\";\n    EncodingPadding[EncodingPadding[\"None\"] = 1] = \"None\";\n})(EncodingPadding || (EncodingPadding = {}));\nvar DecodingPadding;\n(function (DecodingPadding) {\n    DecodingPadding[DecodingPadding[\"Required\"] = 0] = \"Required\";\n    DecodingPadding[DecodingPadding[\"Ignore\"] = 1] = \"Ignore\";\n})(DecodingPadding || (DecodingPadding = {}));\nconst base64DecodeMap = {\n    \"0\": 52,\n    \"1\": 53,\n    \"2\": 54,\n    \"3\": 55,\n    \"4\": 56,\n    \"5\": 57,\n    \"6\": 58,\n    \"7\": 59,\n    \"8\": 60,\n    \"9\": 61,\n    A: 0,\n    B: 1,\n    C: 2,\n    D: 3,\n    E: 4,\n    F: 5,\n    G: 6,\n    H: 7,\n    I: 8,\n    J: 9,\n    K: 10,\n    L: 11,\n    M: 12,\n    N: 13,\n    O: 14,\n    P: 15,\n    Q: 16,\n    R: 17,\n    S: 18,\n    T: 19,\n    U: 20,\n    V: 21,\n    W: 22,\n    X: 23,\n    Y: 24,\n    Z: 25,\n    a: 26,\n    b: 27,\n    c: 28,\n    d: 29,\n    e: 30,\n    f: 31,\n    g: 32,\n    h: 33,\n    i: 34,\n    j: 35,\n    k: 36,\n    l: 37,\n    m: 38,\n    n: 39,\n    o: 40,\n    p: 41,\n    q: 42,\n    r: 43,\n    s: 44,\n    t: 45,\n    u: 46,\n    v: 47,\n    w: 48,\n    x: 49,\n    y: 50,\n    z: 51,\n    \"+\": 62,\n    \"/\": 63\n};\nconst base64urlDecodeMap = {\n    \"0\": 52,\n    \"1\": 53,\n    \"2\": 54,\n    \"3\": 55,\n    \"4\": 56,\n    \"5\": 57,\n    \"6\": 58,\n    \"7\": 59,\n    \"8\": 60,\n    \"9\": 61,\n    A: 0,\n    B: 1,\n    C: 2,\n    D: 3,\n    E: 4,\n    F: 5,\n    G: 6,\n    H: 7,\n    I: 8,\n    J: 9,\n    K: 10,\n    L: 11,\n    M: 12,\n    N: 13,\n    O: 14,\n    P: 15,\n    Q: 16,\n    R: 17,\n    S: 18,\n    T: 19,\n    U: 20,\n    V: 21,\n    W: 22,\n    X: 23,\n    Y: 24,\n    Z: 25,\n    a: 26,\n    b: 27,\n    c: 28,\n    d: 29,\n    e: 30,\n    f: 31,\n    g: 32,\n    h: 33,\n    i: 34,\n    j: 35,\n    k: 36,\n    l: 37,\n    m: 38,\n    n: 39,\n    o: 40,\n    p: 41,\n    q: 42,\n    r: 43,\n    s: 44,\n    t: 45,\n    u: 46,\n    v: 47,\n    w: 48,\n    x: 49,\n    y: 50,\n    z: 51,\n    \"-\": 62,\n    _: 63\n};\n",
    "import { __export } from \"../_virtual/rolldown_runtime.js\";\nimport { options } from \"./options.js\";\nimport { jwtDecode } from \"jwt-decode\";\nimport { encodeBase64urlNoPadding } from \"@oslojs/encoding\";\nimport jwt from \"jsonwebtoken\";\nimport jwkToPem from \"jwk-to-pem\";\n\n//#region src/esi/auth.ts\nvar auth_exports = {};\n__export(auth_exports, {\n\tcharacterIdFromToken: () => characterIdFromToken,\n\tcreateAuthorizationURL: () => createAuthorizationURL,\n\trefresh: () => refresh,\n\tvalidateAuthorizationCode: () => validateAuthorizationCode,\n\tvalidateToken: () => validateToken\n});\nfunction generateState() {\n\tconst randomValues = new Uint8Array(32);\n\tcrypto.getRandomValues(randomValues);\n\treturn encodeBase64urlNoPadding(randomValues);\n}\nasync function createAuthorizationURL(scopes = \"publicData\") {\n\tconst state = generateState();\n\tconst url = new URL(\"https://login.eveonline.com/v2/oauth/authorize/\");\n\turl.searchParams.set(\"response_type\", \"code\");\n\turl.searchParams.set(\"redirect_uri\", options.callback_url);\n\turl.searchParams.set(\"client_id\", options.client_id);\n\turl.searchParams.set(\"state\", state);\n\turl.searchParams.set(\"scope\", Array.isArray(scopes) ? scopes.join(\" \") : scopes);\n\treturn {\n\t\turl,\n\t\tstate\n\t};\n}\nasync function validateAuthorizationCode(code) {\n\ttry {\n\t\tconst response = await fetch(\"https://login.eveonline.com/v2/oauth/token\", {\n\t\t\tmethod: \"POST\",\n\t\t\theaders: {\n\t\t\t\t\"Content-Type\": \"application/x-www-form-urlencoded\",\n\t\t\t\tAuthorization: `Basic ${Buffer.from(`${options.client_id}:${options.client_secret}`).toString(\"base64\")}`\n\t\t\t},\n\t\t\tbody: new URLSearchParams({\n\t\t\t\tgrant_type: \"authorization_code\",\n\t\t\t\tcode\n\t\t\t})\n\t\t});\n\t\treturn await response.json();\n\t} catch (error) {\n\t\tconsole.error(`failed to validate EVE authorization code`, error);\n\t\tthrow `${error}`;\n\t}\n}\nlet eveAuthPublicKey;\nasync function validateToken(token) {\n\tif (!eveAuthPublicKey) try {\n\t\tconst eveJWKS = await (await fetch(\"https://login.eveonline.com/oauth/jwks\")).json();\n\t\teveAuthPublicKey = jwkToPem(eveJWKS.keys[0]);\n\t} catch (err) {\n\t\tconsole.error(`failed to get EVE Auth public keys`, err);\n\t}\n\ttry {\n\t\tconst decoded = jwt.verify(token, eveAuthPublicKey);\n\t\treturn decoded;\n\t} catch (err) {\n\t\tconsole.error(`failed to validate EVE token`, err);\n\t\treturn null;\n\t}\n}\nasync function refresh({ refresh_token }, scopes) {\n\tconst params = {\n\t\tgrant_type: \"refresh_token\",\n\t\trefresh_token,\n\t\tscope: \"\"\n\t};\n\tif (scopes) params[\"scope\"] = Array.isArray(scopes) ? scopes.join(\" \") : scopes;\n\tconst response = await fetch(\"https://login.eveonline.com/v2/oauth/token\", {\n\t\tmethod: \"POST\",\n\t\theaders: {\n\t\t\t\"Content-Type\": \"application/x-www-form-urlencoded\",\n\t\t\tAuthorization: `Basic ${Buffer.from(`${options.client_id}:${options.client_secret}`).toString(\"base64\")}`\n\t\t},\n\t\tbody: new URLSearchParams(params)\n\t});\n\treturn await response.json();\n}\nfunction characterIdFromToken(token) {\n\tconst payload = jwtDecode(token);\n\treturn parseInt(payload.sub.split(\":\")[2]);\n}\n\n//#endregion\nexport { auth_exports, characterIdFromToken, createAuthorizationURL, refresh, validateAuthorizationCode, validateToken };",
    "import { characters } from \"../schema.js\";\nimport { refresh, validateToken } from \"../../esi/auth.js\";\nimport { db } from \"../index.js\";\nimport { and, eq } from \"drizzle-orm\";\nimport { jwtDecode } from \"jwt-decode\";\n\n//#region src/db/models/character.model.ts\nvar CharacterHelper = class CharacterHelper {\n\tstatic hasValidToken(character) {\n\t\treturn /* @__PURE__ */ new Date() < character.expiresAt;\n\t}\n\tstatic getScopes(character) {\n\t\tconst decoded = jwtDecode(character.accessToken);\n\t\treturn typeof decoded.scp === \"string\" ? [decoded.scp] : decoded.scp;\n\t}\n\tstatic hasOnlyPublicScope(character) {\n\t\treturn this.getScopes(character).length === 1 && this.hasScope(character, \"publicData\");\n\t}\n\tstatic getTokens(character) {\n\t\treturn {\n\t\t\taccess_token: character.accessToken,\n\t\t\trefresh_token: character.refreshToken,\n\t\t\texpires_in: (character.expiresAt.getTime() - Date.now()) / 1e3\n\t\t};\n\t}\n\tstatic hasScope(character, scope) {\n\t\treturn this.getScopes(character).includes(scope);\n\t}\n\tstatic hasAllScopes(character, scopes) {\n\t\tconst has = this.getScopes(character);\n\t\treturn scopes.every((scope) => has.includes(scope));\n\t}\n\tstatic find(id) {\n\t\tconst result = db.select().from(characters).where(eq(characters.id, id)).limit(1).get();\n\t\tconst c = this.createCharacters(result);\n\t\treturn c ? c[0] : void 0;\n\t}\n\tstatic findByUser(user) {\n\t\tconst result = db.select().from(characters).where(eq(characters.userID, user.id)).all();\n\t\treturn this.createCharacters(result);\n\t}\n\tstatic findByUserAndEveID(userID, eveID) {\n\t\tconst result = db.select().from(characters).where(and(eq(characters.userID, userID), eq(characters.eveID, eveID))).limit(1).get();\n\t\tconst c = this.createCharacters(result);\n\t\treturn c ? c[0] : void 0;\n\t}\n\tstatic findByName(userID, name) {\n\t\tconst result = db.select().from(characters).where(and(eq(characters.name, name), eq(characters.userID, userID))).limit(1).get();\n\t\tconst c = this.createCharacters(result);\n\t\treturn c ? c[0] : void 0;\n\t}\n\tstatic findAll() {\n\t\tconst result = db.select().from(characters).all();\n\t\treturn this.createCharacters(result);\n\t}\n\tstatic create(eveID, name, user, tokens) {\n\t\treturn this.save({\n\t\t\teveID,\n\t\t\tuserID: user.id,\n\t\t\taccessToken: tokens.access_token,\n\t\t\texpiresAt: /* @__PURE__ */ new Date(tokens.expires_in * 1e3),\n\t\t\trefreshToken: tokens.refresh_token,\n\t\t\tname,\n\t\t\tcreatedAt: /* @__PURE__ */ new Date()\n\t\t});\n\t}\n\tstatic createCharacters(query) {\n\t\tif (!query) return [];\n\t\tif (Array.isArray(query)) return query.map((character) => {\n\t\t\treturn {\n\t\t\t\tid: character.id,\n\t\t\t\teveID: character.eveID,\n\t\t\t\tuserID: character.userID,\n\t\t\t\taccessToken: character.accessToken,\n\t\t\t\texpiresAt: new Date(character.expiresAt),\n\t\t\t\trefreshToken: character.refreshToken,\n\t\t\t\tname: character.name,\n\t\t\t\tcreatedAt: new Date(character.createdAt),\n\t\t\t\tupdatedAt: new Date(character.updatedAt)\n\t\t\t};\n\t\t});\n\t\telse return [{\n\t\t\tid: query.id,\n\t\t\teveID: query.eveID,\n\t\t\tuserID: query.userID,\n\t\t\taccessToken: query.accessToken,\n\t\t\texpiresAt: new Date(query.expiresAt),\n\t\t\trefreshToken: query.refreshToken,\n\t\t\tname: query.name,\n\t\t\tcreatedAt: new Date(query.createdAt),\n\t\t\tupdatedAt: new Date(query.updatedAt)\n\t\t}];\n\t}\n\tstatic save(character) {\n\t\tdb.insert(characters).values({\n\t\t\tid: character.id,\n\t\t\teveID: character.eveID,\n\t\t\tuserID: character.userID,\n\t\t\tname: character.name,\n\t\t\taccessToken: character.accessToken,\n\t\t\texpiresAt: character.expiresAt.getTime(),\n\t\t\trefreshToken: character.refreshToken,\n\t\t\tcreatedAt: Date.now(),\n\t\t\tupdatedAt: Date.now()\n\t\t}).onConflictDoUpdate({\n\t\t\ttarget: characters.id,\n\t\t\tset: {\n\t\t\t\teveID: character.eveID,\n\t\t\t\tuserID: character.userID,\n\t\t\t\tname: character.name,\n\t\t\t\taccessToken: character.accessToken,\n\t\t\t\texpiresAt: character.expiresAt.getTime(),\n\t\t\t\trefreshToken: character.refreshToken,\n\t\t\t\tupdatedAt: Date.now()\n\t\t\t}\n\t\t}).run();\n\t\treturn CharacterHelper.findByUserAndEveID(character.userID, character.eveID);\n\t}\n\tstatic delete(character) {\n\t\tdb.delete(characters).where(eq(characters.id, character.id)).run();\n\t}\n\tstatic async refreshTokens(character, scopes) {\n\t\tconst tokens = await refresh({ refresh_token: character.refreshToken }, scopes);\n\t\tconst decoded = await validateToken(tokens.access_token);\n\t\tif (!decoded) {\n\t\t\tconsole.error(`Failed to validate token for character ${character.eveID}`);\n\t\t\treturn character;\n\t\t}\n\t\tcharacter.accessToken = tokens.access_token;\n\t\tcharacter.expiresAt = new Date(Date.now() + tokens.expires_in * 1e3);\n\t\tcharacter.refreshToken = tokens.refresh_token;\n\t\tthis.save(character);\n\t\treturn character;\n\t}\n};\n\n//#endregion\nexport { CharacterHelper };",
    "import { characters, users } from \"../schema.js\";\nimport { CharacterHelper } from \"./character.model.js\";\nimport { db } from \"../index.js\";\nimport { eq, sql } from \"drizzle-orm\";\n\n//#region src/db/models/user.model.ts\nvar UserHelper = class {\n\tstatic find(id) {\n\t\tconst result = db.select({\n\t\t\tid: users.id,\n\t\t\tdiscordID: users.discordID,\n\t\t\tcreatedAt: users.createdAt,\n\t\t\tupdatedAt: users.updatedAt,\n\t\t\tmainCharacterID: users.mainCharacter,\n\t\t\tcharacterIDsString: sql`json_group_array(characters.id)`\n\t\t}).from(users).where(eq(users.id, id)).leftJoin(characters, eq(users.id, characters.userID)).get();\n\t\treturn this.createFromQuery(result);\n\t}\n\tstatic findByDiscordId(id) {\n\t\tconst result = db.select({\n\t\t\tid: users.id,\n\t\t\tdiscordID: users.discordID,\n\t\t\tcreatedAt: users.createdAt,\n\t\t\tupdatedAt: users.updatedAt,\n\t\t\tmainCharacterID: users.mainCharacter,\n\t\t\tcharacterIDsString: sql`json_group_array(characters.id)`\n\t\t}).from(users).where(eq(users.discordID, id)).leftJoin(characters, eq(users.id, characters.userID)).get();\n\t\treturn this.createFromQuery(result);\n\t}\n\tstatic findAll() {\n\t\tconst result = db.select({\n\t\t\tid: users.id,\n\t\t\tdiscordID: users.discordID,\n\t\t\tcreatedAt: users.createdAt,\n\t\t\tupdatedAt: users.updatedAt,\n\t\t\tmainCharacterID: users.mainCharacter,\n\t\t\tcharacterIDsString: sql`json_group_array(characters.id)`\n\t\t}).from(users).leftJoin(characters, eq(users.id, characters.userID)).all();\n\t\treturn this.createFromQuery(result);\n\t}\n\tstatic findByCharacterId(id) {\n\t\tconst result = db.select({\n\t\t\tid: users.id,\n\t\t\tdiscordID: users.discordID,\n\t\t\tcreatedAt: users.createdAt,\n\t\t\tupdatedAt: users.updatedAt,\n\t\t\tmainCharacterID: users.mainCharacter,\n\t\t\tcharacterIDsString: sql`json_group_array(characters.id)`\n\t\t}).from(users).leftJoin(characters, eq(users.id, characters.userID)).where(eq(characters.id, id)).all();\n\t\treturn this.createFromQuery(result);\n\t}\n\tstatic findByCharacterName(name) {\n\t\tconst result = db.select({\n\t\t\tid: users.id,\n\t\t\tdiscordID: users.discordID,\n\t\t\tcreatedAt: users.createdAt,\n\t\t\tupdatedAt: users.updatedAt,\n\t\t\tmainCharacterID: users.mainCharacter,\n\t\t\tcharacterIDsString: sql`json_group_array(characters.id)`\n\t\t}).from(users).leftJoin(characters, eq(users.id, characters.userID)).where(eq(characters.name, name)).all();\n\t\treturn this.createFromQuery(result);\n\t}\n\tstatic createFromQuery(query) {\n\t\tif (!query) return [];\n\t\tif (Array.isArray(query)) return query.map((user) => {\n\t\t\treturn {\n\t\t\t\tid: user.id,\n\t\t\t\tdiscordID: user.discordID,\n\t\t\t\tcreatedAt: new Date(user.createdAt),\n\t\t\t\tupdatedAt: new Date(user.updatedAt),\n\t\t\t\tcharacterIDs: user.characterIDsString ? JSON.parse(user.characterIDsString ?? \"[]\").map((s) => Number(s)).sort() : [],\n\t\t\t\tmainCharacterID: user.mainCharacterID\n\t\t\t};\n\t\t});\n\t\telse return {\n\t\t\tid: query.id,\n\t\t\tdiscordID: query.discordID,\n\t\t\tcreatedAt: new Date(query.createdAt),\n\t\t\tupdatedAt: new Date(query.updatedAt),\n\t\t\tcharacterIDs: query.characterIDsString ? JSON.parse(query.characterIDsString ?? \"[]\").map((s) => Number(s)).sort() : [],\n\t\t\tmainCharacterID: query.mainCharacterID\n\t\t};\n\t}\n\tstatic create(discordID) {\n\t\tthis.save({\n\t\t\tdiscordID,\n\t\t\tcreatedAt: /* @__PURE__ */ new Date(),\n\t\t\tupdatedAt: /* @__PURE__ */ new Date()\n\t\t});\n\t\treturn this.findByDiscordId(discordID);\n\t}\n\tstatic save(user) {\n\t\tdb.insert(users).values({\n\t\t\tid: user.id,\n\t\t\tdiscordID: user.discordID,\n\t\t\tmainCharacter: user.mainCharacterID,\n\t\t\tcreatedAt: user.createdAt.getTime(),\n\t\t\tupdatedAt: user.updatedAt.getTime()\n\t\t}).onConflictDoUpdate({\n\t\t\ttarget: users.id,\n\t\t\tset: {\n\t\t\t\tdiscordID: user.discordID,\n\t\t\t\tmainCharacter: user.mainCharacterID,\n\t\t\t\tupdatedAt: user.updatedAt.getTime()\n\t\t\t}\n\t\t}).run();\n\t\treturn user;\n\t}\n\tstatic delete(user) {\n\t\tdb.delete(users).where(eq(users.id, user.id)).run();\n\t}\n\tstatic getCharacter(user, index) {\n\t\tif (!user.characterIDs) return void 0;\n\t\tif (index >= user.characterIDs.length) return void 0;\n\t\treturn CharacterHelper.find(user.characterIDs[index]);\n\t}\n};\n\n//#endregion\nexport { UserHelper };",
    "import { resumeCommands } from \"../schema.js\";\nimport { db } from \"../index.js\";\nimport { eq } from \"drizzle-orm\";\n\n//#region src/db/models/resume-command.model.ts\nvar ResumeCommand = class ResumeCommand {\n\tid;\n\tcommand;\n\tparams;\n\tcontext;\n\tcreated = /* @__PURE__ */ new Date();\n\tconstructor() {\n\t\tthis.created = /* @__PURE__ */ new Date();\n\t}\n\tstatic find(messageId) {\n\t\tconst result = db.select().from(resumeCommands).where(eq(resumeCommands.id, messageId)).get();\n\t\treturn this.createFromQuery(result);\n\t}\n\tstatic create(messageId, command, params = {}, context = {}) {\n\t\tconst resume = new ResumeCommand();\n\t\tresume.id = messageId;\n\t\tresume.command = command;\n\t\tresume.params = JSON.stringify(params);\n\t\tresume.context = JSON.stringify(context);\n\t\treturn resume;\n\t}\n\tstatic createFromQuery(query) {\n\t\tif (!query) return null;\n\t\tconst resume = new ResumeCommand();\n\t\tresume.id = query.id;\n\t\tresume.command = query.command;\n\t\tresume.params = query.params;\n\t\tresume.context = query.context;\n\t\tresume.created = query.created;\n\t\treturn resume;\n\t}\n\tsave() {\n\t\tdb.insert(resumeCommands).values({\n\t\t\tid: this.id,\n\t\t\tcommand: this.command,\n\t\t\tparams: this.params,\n\t\t\tcontext: this.context,\n\t\t\tcreatedAt: this.created.getTime()\n\t\t}).onConflictDoUpdate({\n\t\t\ttarget: resumeCommands.id,\n\t\t\tset: {\n\t\t\t\tcommand: this.command,\n\t\t\t\tparams: this.params,\n\t\t\t\tcontext: this.context\n\t\t\t}\n\t\t}).run();\n\t\treturn this;\n\t}\n\tdelete() {\n\t\tdb.delete(resumeCommands).where(eq(resumeCommands.id, this.id)).run();\n\t}\n\tstatic delete(messageId) {\n\t\tdb.delete(resumeCommands).where(eq(resumeCommands.id, messageId)).run();\n\t}\n};\n\n//#endregion\nexport { ResumeCommand };",
    "import { __export } from \"../../_virtual/rolldown_runtime.js\";\nimport { CharacterHelper } from \"./character.model.js\";\nimport { UserHelper } from \"./user.model.js\";\nimport { ResumeCommand } from \"./resume-command.model.js\";\n\n//#region src/db/models/index.ts\nvar models_exports = {};\n__export(models_exports, {\n\tCharacterHelper: () => CharacterHelper,\n\tResumeCommand: () => ResumeCommand,\n\tUserHelper: () => UserHelper\n});\n\n//#endregion\nexport { models_exports };",
    "import { Database } from \"bun:sqlite\";\nimport { entityKind } from \"../entity.js\";\nimport { DefaultLogger } from \"../logger.js\";\nimport {\n  createTableRelationsHelpers,\n  extractTablesRelationalConfig\n} from \"../relations.js\";\nimport { BaseSQLiteDatabase } from \"../sqlite-core/db.js\";\nimport { SQLiteSyncDialect } from \"../sqlite-core/dialect.js\";\nimport { isConfig } from \"../utils.js\";\nimport { SQLiteBunSession } from \"./session.js\";\nclass BunSQLiteDatabase extends BaseSQLiteDatabase {\n  static [entityKind] = \"BunSQLiteDatabase\";\n}\nfunction construct(client, config = {}) {\n  const dialect = new SQLiteSyncDialect({ casing: config.casing });\n  let logger;\n  if (config.logger === true) {\n    logger = new DefaultLogger();\n  } else if (config.logger !== false) {\n    logger = config.logger;\n  }\n  let schema;\n  if (config.schema) {\n    const tablesConfig = extractTablesRelationalConfig(\n      config.schema,\n      createTableRelationsHelpers\n    );\n    schema = {\n      fullSchema: config.schema,\n      schema: tablesConfig.tables,\n      tableNamesMap: tablesConfig.tableNamesMap\n    };\n  }\n  const session = new SQLiteBunSession(client, dialect, schema, { logger });\n  const db = new BunSQLiteDatabase(\"sync\", dialect, session, schema);\n  db.$client = client;\n  return db;\n}\nfunction drizzle(...params) {\n  if (params[0] === void 0 || typeof params[0] === \"string\") {\n    const instance = params[0] === void 0 ? new Database() : new Database(params[0]);\n    return construct(instance, params[1]);\n  }\n  if (isConfig(params[0])) {\n    const { connection, client, ...drizzleConfig } = params[0];\n    if (client) return construct(client, drizzleConfig);\n    if (typeof connection === \"object\") {\n      const { source, ...opts } = connection;\n      const options = Object.values(opts).filter((v) => v !== void 0).length ? opts : void 0;\n      const instance2 = new Database(source, options);\n      return construct(instance2, drizzleConfig);\n    }\n    const instance = new Database(connection);\n    return construct(instance, drizzleConfig);\n  }\n  return construct(params[0], params[1]);\n}\n((drizzle2) => {\n  function mock(config) {\n    return construct({}, config);\n  }\n  drizzle2.mock = mock;\n})(drizzle || (drizzle = {}));\nexport {\n  BunSQLiteDatabase,\n  drizzle\n};\n//# sourceMappingURL=driver.js.map",
    "import { entityKind } from \"../entity.js\";\nimport { NoopLogger } from \"../logger.js\";\nimport { fillPlaceholders, sql } from \"../sql/sql.js\";\nimport { SQLiteTransaction } from \"../sqlite-core/index.js\";\nimport { SQLitePreparedQuery as PreparedQueryBase, SQLiteSession } from \"../sqlite-core/session.js\";\nimport { mapResultRow } from \"../utils.js\";\nclass SQLiteBunSession extends SQLiteSession {\n  constructor(client, dialect, schema, options = {}) {\n    super(dialect);\n    this.client = client;\n    this.schema = schema;\n    this.logger = options.logger ?? new NoopLogger();\n  }\n  static [entityKind] = \"SQLiteBunSession\";\n  logger;\n  exec(query) {\n    this.client.exec(query);\n  }\n  prepareQuery(query, fields, executeMethod, isResponseInArrayMode, customResultMapper) {\n    const stmt = this.client.prepare(query.sql);\n    return new PreparedQuery(\n      stmt,\n      query,\n      this.logger,\n      fields,\n      executeMethod,\n      isResponseInArrayMode,\n      customResultMapper\n    );\n  }\n  transaction(transaction, config = {}) {\n    const tx = new SQLiteBunTransaction(\"sync\", this.dialect, this, this.schema);\n    let result;\n    const nativeTx = this.client.transaction(() => {\n      result = transaction(tx);\n    });\n    nativeTx[config.behavior ?? \"deferred\"]();\n    return result;\n  }\n}\nclass SQLiteBunTransaction extends SQLiteTransaction {\n  static [entityKind] = \"SQLiteBunTransaction\";\n  transaction(transaction) {\n    const savepointName = `sp${this.nestedIndex}`;\n    const tx = new SQLiteBunTransaction(\"sync\", this.dialect, this.session, this.schema, this.nestedIndex + 1);\n    this.session.run(sql.raw(`savepoint ${savepointName}`));\n    try {\n      const result = transaction(tx);\n      this.session.run(sql.raw(`release savepoint ${savepointName}`));\n      return result;\n    } catch (err) {\n      this.session.run(sql.raw(`rollback to savepoint ${savepointName}`));\n      throw err;\n    }\n  }\n}\nclass PreparedQuery extends PreparedQueryBase {\n  constructor(stmt, query, logger, fields, executeMethod, _isResponseInArrayMode, customResultMapper) {\n    super(\"sync\", executeMethod, query);\n    this.stmt = stmt;\n    this.logger = logger;\n    this.fields = fields;\n    this._isResponseInArrayMode = _isResponseInArrayMode;\n    this.customResultMapper = customResultMapper;\n  }\n  static [entityKind] = \"SQLiteBunPreparedQuery\";\n  run(placeholderValues) {\n    const params = fillPlaceholders(this.query.params, placeholderValues ?? {});\n    this.logger.logQuery(this.query.sql, params);\n    return this.stmt.run(...params);\n  }\n  all(placeholderValues) {\n    const { fields, query, logger, joinsNotNullableMap, stmt, customResultMapper } = this;\n    if (!fields && !customResultMapper) {\n      const params = fillPlaceholders(query.params, placeholderValues ?? {});\n      logger.logQuery(query.sql, params);\n      return stmt.all(...params);\n    }\n    const rows = this.values(placeholderValues);\n    if (customResultMapper) {\n      return customResultMapper(rows);\n    }\n    return rows.map((row) => mapResultRow(fields, row, joinsNotNullableMap));\n  }\n  get(placeholderValues) {\n    const params = fillPlaceholders(this.query.params, placeholderValues ?? {});\n    this.logger.logQuery(this.query.sql, params);\n    const row = this.stmt.values(...params)[0];\n    if (!row) {\n      return void 0;\n    }\n    const { fields, joinsNotNullableMap, customResultMapper } = this;\n    if (!fields && !customResultMapper) {\n      return row;\n    }\n    if (customResultMapper) {\n      return customResultMapper([row]);\n    }\n    return mapResultRow(fields, row, joinsNotNullableMap);\n  }\n  values(placeholderValues) {\n    const params = fillPlaceholders(this.query.params, placeholderValues ?? {});\n    this.logger.logQuery(this.query.sql, params);\n    return this.stmt.values(...params);\n  }\n  /** @internal */\n  isResponseInArrayMode() {\n    return this._isResponseInArrayMode;\n  }\n}\nexport {\n  PreparedQuery,\n  SQLiteBunSession,\n  SQLiteBunTransaction\n};\n//# sourceMappingURL=session.js.map",
    "import { characters, miningFleetParticipants, miningFleets, resumeCommands, schema_exports, users } from \"./schema.js\";\nimport { CharacterHelper } from \"./models/character.model.js\";\nimport { UserHelper } from \"./models/user.model.js\";\nimport { ResumeCommand } from \"./models/resume-command.model.js\";\nimport { models_exports } from \"./models/index.js\";\nimport { drizzle } from \"drizzle-orm/bun-sqlite\";\nimport { Database } from \"bun:sqlite\";\nimport { join } from \"node:path\";\n\n//#region src/db/index.ts\nconst DB_PATH = process.env.AUTH_DB_PATH || join(process.cwd(), \"../../db/kitten.db\");\nconsole.log(\"Using DB_PATH:\", DB_PATH);\nconst sqlite = new Database(DB_PATH);\nconst db = drizzle(sqlite, { schema: {\n\tusers,\n\tcharacters,\n\tresumeCommands,\n\tminingFleets,\n\tminingFleetParticipants\n} });\n\n//#endregion\nexport { CharacterHelper, DB_PATH, ResumeCommand, UserHelper, db, models_exports as models, schema_exports as schema };",
    "import { jwtDecode } from \"jwt-decode\";\n\n//#region src/esi/scopes.ts\nconst EVE_JWKS_URL = \"https://login.eveonline.com/oauth/jwks\";\nconst EVE_ISSUER = \"login.eveonline.com\";\nconst EVE_AUDIENCE = \"eveonline\";\nconst ESI_LATEST_URL = \"https://esi.evetech.net/latest\";\nconst DATA_SOURCE = \"tranquility\";\nfunction joinScopes(...scopes) {\n\treturn scopes.join(\" \");\n}\nlet SCOPES = /* @__PURE__ */ function(SCOPES$1) {\n\tSCOPES$1[\"PUBLIC_DATA\"] = \"publicData\";\n\tSCOPES$1[\"CALENDAR_RESPOND_CALENDAR_EVENTS\"] = \"esi-calendar.respond_calendar_events.v1\";\n\tSCOPES$1[\"CALENDAR_READ_CALENDAR_EVENTS\"] = \"esi-calendar.read_calendar_events.v1\";\n\tSCOPES$1[\"LOCATION_READ_LOCATION\"] = \"esi-location.read_location.v1\";\n\tSCOPES$1[\"LOCATION_READ_SHIP_TYPE\"] = \"esi-location.read_ship_type.v1\";\n\tSCOPES$1[\"MAIL_ORGANIZE_MAIL\"] = \"esi-mail.organize_mail.v1\";\n\tSCOPES$1[\"MAIL_READ_MAIL\"] = \"esi-mail.read_mail.v1\";\n\tSCOPES$1[\"MAIL_SEND_MAIL\"] = \"esi-mail.send_mail.v1\";\n\tSCOPES$1[\"SKILLS_READ_SKILLS\"] = \"esi-skills.read_skills.v1\";\n\tSCOPES$1[\"SKILLS_READ_SKILLQUEUE\"] = \"esi-skills.read_skillqueue.v1\";\n\tSCOPES$1[\"WALLET_READ_CHARACTER_WALLET\"] = \"esi-wallet.read_character_wallet.v1\";\n\tSCOPES$1[\"WALLET_READ_CORPORATION_WALLET\"] = \"esi-wallet.read_corporation_wallet.v1\";\n\tSCOPES$1[\"SEARCH_SEARCH_STRUCTURES\"] = \"esi-search.search_structures.v1\";\n\tSCOPES$1[\"CLONES_READ_CLONES\"] = \"esi-clones.read_clones.v1\";\n\tSCOPES$1[\"CHARACTERS_READ_CONTACTS\"] = \"esi-characters.read_contacts.v1\";\n\tSCOPES$1[\"UNIVERSE_READ_STRUCTURES\"] = \"esi-universe.read_structures.v1\";\n\tSCOPES$1[\"KILLMAILS_READ_KILLMAILS\"] = \"esi-killmails.read_killmails.v1\";\n\tSCOPES$1[\"CORPORATIONS_READ_CORPORATION_MEMBERSHIP\"] = \"esi-corporations.read_corporation_membership.v1\";\n\tSCOPES$1[\"ASSETS_READ_ASSETS\"] = \"esi-assets.read_assets.v1\";\n\tSCOPES$1[\"PLANETS_MANAGE_PLANETS\"] = \"esi-planets.manage_planets.v1\";\n\tSCOPES$1[\"FLEETS_READ_FLEET\"] = \"esi-fleets.read_fleet.v1\";\n\tSCOPES$1[\"FLEETS_WRITE_FLEET\"] = \"esi-fleets.write_fleet.v1\";\n\tSCOPES$1[\"UI_OPEN_WINDOW\"] = \"esi-ui.open_window.v1\";\n\tSCOPES$1[\"UI_WRITE_WAYPOINT\"] = \"esi-ui.write_waypoint.v1\";\n\tSCOPES$1[\"CHARACTERS_WRITE_CONTACTS\"] = \"esi-characters.write_contacts.v1\";\n\tSCOPES$1[\"FITTINGS_READ_FITTINGS\"] = \"esi-fittings.read_fittings.v1\";\n\tSCOPES$1[\"FITTINGS_WRITE_FITTINGS\"] = \"esi-fittings.write_fittings.v1\";\n\tSCOPES$1[\"MARKETS_STRUCTURE_MARKETS\"] = \"esi-markets.structure_markets.v1\";\n\tSCOPES$1[\"CORPORATIONS_READ_STRUCTURES\"] = \"esi-corporations.read_structures.v1\";\n\tSCOPES$1[\"CHARACTERS_READ_LOYALTY\"] = \"esi-characters.read_loyalty.v1\";\n\tSCOPES$1[\"CHARACTERS_READ_OPPORTUNITIES\"] = \"esi-characters.read_opportunities.v1\";\n\tSCOPES$1[\"CHARACTERS_READ_CHAT_CHANNELS\"] = \"esi-characters.read_chat_channels.v1\";\n\tSCOPES$1[\"CHARACTERS_READ_MEDALS\"] = \"esi-characters.read_medals.v1\";\n\tSCOPES$1[\"CHARACTERS_READ_STANDINGS\"] = \"esi-characters.read_standings.v1\";\n\tSCOPES$1[\"CHARACTERS_READ_AGENTS_RESEARCH\"] = \"esi-characters.read_agents_research.v1\";\n\tSCOPES$1[\"INDUSTRY_READ_CHARACTER_JOBS\"] = \"esi-industry.read_character_jobs.v1\";\n\tSCOPES$1[\"MARKETS_READ_CHARACTER_ORDERS\"] = \"esi-markets.read_character_orders.v1\";\n\tSCOPES$1[\"CHARACTERS_READ_BLUEPRINTS\"] = \"esi-characters.read_blueprints.v1\";\n\tSCOPES$1[\"CHARACTERS_READ_CORPORATION_ROLES\"] = \"esi-characters.read_corporation_roles.v1\";\n\tSCOPES$1[\"LOCATION_READ_ONLINE\"] = \"esi-location.read_online.v1\";\n\tSCOPES$1[\"CONTRACTS_READ_CHARACTER_CONTRACTS\"] = \"esi-contracts.read_character_contracts.v1\";\n\tSCOPES$1[\"CLONES_READ_IMPLANTS\"] = \"esi-clones.read_implants.v1\";\n\tSCOPES$1[\"CHARACTERS_READ_FATIGUE\"] = \"esi-characters.read_fatigue.v1\";\n\tSCOPES$1[\"KILLMAILS_READ_CORPORATION_KILLMAILS\"] = \"esi-killmails.read_corporation_killmails.v1\";\n\tSCOPES$1[\"CORPORATIONS_TRACK_MEMBERS\"] = \"esi-corporations.track_members.v1\";\n\tSCOPES$1[\"WALLET_READ_CORPORATION_WALLETS\"] = \"esi-wallet.read_corporation_wallets.v1\";\n\tSCOPES$1[\"CHARACTERS_READ_NOTIFICATIONS\"] = \"esi-characters.read_notifications.v1\";\n\tSCOPES$1[\"CORPORATIONS_READ_DIVISIONS\"] = \"esi-corporations.read_divisions.v1\";\n\tSCOPES$1[\"CORPORATIONS_READ_CONTACTS\"] = \"esi-corporations.read_contacts.v1\";\n\tSCOPES$1[\"ASSETS_READ_CORPORATION_ASSETS\"] = \"esi-assets.read_corporation_assets.v1\";\n\tSCOPES$1[\"CORPORATIONS_READ_TITLES\"] = \"esi-corporations.read_titles.v1\";\n\tSCOPES$1[\"CORPORATIONS_READ_BLUEPRINTS\"] = \"esi-corporations.read_blueprints.v1\";\n\tSCOPES$1[\"CONTRACTS_READ_CORPORATION_CONTRACTS\"] = \"esi-contracts.read_corporation_contracts.v1\";\n\tSCOPES$1[\"CORPORATIONS_READ_STANDINGS\"] = \"esi-corporations.read_standings.v1\";\n\tSCOPES$1[\"CORPORATIONS_READ_STARBASES\"] = \"esi-corporations.read_starbases.v1\";\n\tSCOPES$1[\"INDUSTRY_READ_CORPORATION_JOBS\"] = \"esi-industry.read_corporation_jobs.v1\";\n\tSCOPES$1[\"MARKETS_READ_CORPORATION_ORDERS\"] = \"esi-markets.read_corporation_orders.v1\";\n\tSCOPES$1[\"CORPORATIONS_READ_CONTAINER_LOGS\"] = \"esi-corporations.read_container_logs.v1\";\n\tSCOPES$1[\"INDUSTRY_READ_CHARACTER_MINING\"] = \"esi-industry.read_character_mining.v1\";\n\tSCOPES$1[\"INDUSTRY_READ_CORPORATION_MINING\"] = \"esi-industry.read_corporation_mining.v1\";\n\tSCOPES$1[\"PLANETS_READ_CUSTOMS_OFFICES\"] = \"esi-planets.read_customs_offices.v1\";\n\tSCOPES$1[\"CORPORATIONS_READ_FACILITIES\"] = \"esi-corporations.read_facilities.v1\";\n\tSCOPES$1[\"CORPORATIONS_READ_MEDALS\"] = \"esi-corporations.read_medals.v1\";\n\tSCOPES$1[\"CHARACTERS_READ_TITLES\"] = \"esi-characters.read_titles.v1\";\n\tSCOPES$1[\"ALLIANCES_READ_CONTACTS\"] = \"esi-alliances.read_contacts.v1\";\n\tSCOPES$1[\"CHARACTERS_READ_FW_STATS\"] = \"esi-characters.read_fw_stats.v1\";\n\tSCOPES$1[\"CORPORATIONS_READ_FW_STATS\"] = \"esi-corporations.read_fw_stats.v1\";\n\treturn SCOPES$1;\n}({});\nfunction tokenHasScopes(access_token, ...scopes) {\n\tlet tokenScopes = getScopesFromToken(access_token);\n\treturn scopes.every((scope) => tokenScopes.includes(scope));\n}\nfunction getScopesFromToken(access_token) {\n\tconst decoded = jwtDecode(access_token);\n\treturn typeof decoded.scp === \"string\" ? [decoded.scp] : decoded.scp;\n}\n\n//#endregion\nexport { DATA_SOURCE, ESI_LATEST_URL, EVE_AUDIENCE, EVE_ISSUER, EVE_JWKS_URL, SCOPES, getScopesFromToken, joinScopes, tokenHasScopes };",
    "import { options } from \"./options.js\";\nimport { CharacterHelper } from \"../db/models/character.model.js\";\nimport \"../db/models/index.js\";\nimport { ESI_LATEST_URL } from \"./scopes.js\";\n\n//#region src/esi/fetch.ts\nconst cache = /* @__PURE__ */ new Map();\nfunction cleanCache() {\n\tconst now = Date.now();\n\tfor (const [key, value] of cache) if (value.expires < now) cache.delete(key);\n}\nsetInterval(cleanCache, 1e3 * 60 * 15);\nconst defaultCacheDuration = 1e3 * 60 * 30;\nasync function esiFetch(path, character, { method = \"GET\", body, noCache = false, cacheDuration = defaultCacheDuration } = {}) {\n\ttry {\n\t\tconst headers = {\n\t\t\t\"User-Agent\": options.user_agent,\n\t\t\t\"Accept\": \"application/json\"\n\t\t};\n\t\tif (character) {\n\t\t\tif (!CharacterHelper.hasValidToken(character)) {\n\t\t\t\tawait CharacterHelper.refreshTokens(character);\n\t\t\t\tif (!CharacterHelper.hasValidToken(character)) throw new Error(`Failed to refresh token for character: ${character.eveID}`);\n\t\t\t}\n\t\t\theaders[\"Authorization\"] = `Bearer ${character.accessToken}`;\n\t\t}\n\t\tconst init = {\n\t\t\theaders,\n\t\t\tmethod: method || \"GET\",\n\t\t\tbody: body || void 0\n\t\t};\n\t\tconst url = new URL(`${ESI_LATEST_URL}${path.startsWith(\"/\") ? path : \"/\" + path}`);\n\t\turl.searchParams.set(\"datasource\", \"tranquility\");\n\t\tif (!noCache && init.method === \"GET\") {\n\t\t\tconst cached = cache.get(url.href);\n\t\t\tif (cached && cached?.expires > Date.now()) return cached.data;\n\t\t}\n\t\tconst res = await fetch(url, init);\n\t\tconst data = await res.json();\n\t\tif (!res.ok) {\n\t\t\tconsole.error(`ESI request failure at ${path} | ${res.status}:${res.statusText} => ${JSON.stringify(data)}`);\n\t\t\treturn null;\n\t\t}\n\t\tif (init.method === \"GET\") cache.set(url.href, {\n\t\t\texpires: Math.max(res.headers.get(\"expires\") && new Date(Number(res.headers.get(\"expires\") || \"\")).getTime() || 0, Date.now() + cacheDuration),\n\t\t\tdata\n\t\t});\n\t\treturn data;\n\t} catch (err) {\n\t\tconsole.error(`ESI request failure at ${path} | ${JSON.stringify(err)}`, err);\n\t\treturn null;\n\t}\n}\n\n//#endregion\nexport { esiFetch };",
    "import { __export } from \"../_virtual/rolldown_runtime.js\";\nimport { CharacterHelper } from \"../db/models/character.model.js\";\nimport \"../db/index.js\";\nimport \"./scopes.js\";\nimport { esiFetch } from \"./fetch.js\";\n\n//#region src/esi/character.ts\nvar character_exports = {};\n__export(character_exports, {\n\tgetCharacterAffiliations: () => getCharacterAffiliations,\n\tgetCharacterAgentResearch: () => getCharacterAgentResearch,\n\tgetCharacterAssetLocations: () => getCharacterAssetLocations,\n\tgetCharacterAssetNames: () => getCharacterAssetNames,\n\tgetCharacterAssets: () => getCharacterAssets,\n\tgetCharacterBlueprints: () => getCharacterBlueprints,\n\tgetCharacterClones: () => getCharacterClones,\n\tgetCharacterContactNotifications: () => getCharacterContactNotifications,\n\tgetCharacterCorporationHistory: () => getCharacterCorporationHistory,\n\tgetCharacterCurrentShip: () => getCharacterCurrentShip,\n\tgetCharacterImplants: () => getCharacterImplants,\n\tgetCharacterJumpFatigue: () => getCharacterJumpFatigue,\n\tgetCharacterLocation: () => getCharacterLocation,\n\tgetCharacterMedals: () => getCharacterMedals,\n\tgetCharacterNotifications: () => getCharacterNotifications,\n\tgetCharacterOnline: () => getCharacterOnline,\n\tgetCharacterPortraits: () => getCharacterPortraits,\n\tgetCharacterPublicData: () => getCharacterPublicData,\n\tgetCharacterRoles: () => getCharacterRoles,\n\tgetCharacterStandings: () => getCharacterStandings,\n\tgetCharacterTitles: () => getCharacterTitles,\n\tgetCharacterWallet: () => getCharacterWallet,\n\tgetCharacterWalletJournal: () => getCharacterWalletJournal,\n\tgetCharacterWalletTransactions: () => getCharacterWalletTransactions,\n\tgetPortraitURL: () => getPortraitURL\n});\nfunction getCharacterPublicData(id) {\n\treturn esiFetch(`/characters/${id}/`);\n}\nfunction getCharacterAffiliations(ids) {\n\treturn esiFetch(`/characters/affiliation/`, void 0, {\n\t\tmethod: \"POST\",\n\t\tbody: JSON.stringify(ids)\n\t})[0];\n}\nfunction getCharacterPortraits(id) {\n\treturn esiFetch(`/characters/${id}/portrait/`);\n}\nfunction getCharacterCorporationHistory(id) {\n\treturn esiFetch(`/characters/${id}/corporationhistory/`);\n}\nfunction getPortraitURL(id) {\n\treturn `https://images.evetech.net/characters/${id}/portrait`;\n}\nfunction getCharacterRoles(character) {\n\tif (!CharacterHelper.hasScope(character, \"esi-characters.read_corporation_roles.v1\")) return null;\n\treturn esiFetch(`/characters/${character.eveID}/roles/`, character);\n}\nfunction getCharacterTitles(character) {\n\tif (!CharacterHelper.hasScope(character, \"esi-characters.read_titles.v1\")) return null;\n\treturn esiFetch(`/characters/${character.eveID}/titles/`, character);\n}\nfunction getCharacterStandings(character) {\n\tif (!CharacterHelper.hasScope(character, \"esi-characters.read_standings.v1\")) return null;\n\treturn esiFetch(`/characters/${character.eveID}/standings/`, character);\n}\nfunction getCharacterNotifications(character) {\n\tif (!CharacterHelper.hasScope(character, \"esi-characters.read_notifications.v1\")) return null;\n\treturn esiFetch(`/characters/${character.eveID}/notifications/`, character);\n}\nfunction getCharacterContactNotifications(character) {\n\tif (!CharacterHelper.hasScope(character, \"esi-characters.read_notifications.v1\")) return null;\n\treturn esiFetch(`/characters/${character.eveID}/notifications/contacts`, character);\n}\nfunction getCharacterMedals(character) {\n\tif (!CharacterHelper.hasScope(character, \"esi-characters.read_medals.v1\")) return null;\n\treturn esiFetch(`/characters/${character.eveID}/medals/`, character);\n}\nfunction getCharacterJumpFatigue(character) {\n\tif (!CharacterHelper.hasScope(character, \"esi-characters.read_fatigue.v1\")) return null;\n\treturn esiFetch(`/characters/${character.eveID}/fatigue/`, character);\n}\nfunction getCharacterBlueprints(character) {\n\tif (!CharacterHelper.hasScope(character, \"esi-characters.read_blueprints.v1\")) return null;\n\treturn esiFetch(`/characters/${character.eveID}/blueprints/`, character);\n}\nfunction getCharacterAgentResearch(character) {\n\tif (!CharacterHelper.hasScope(character, \"esi-characters.read_agents_research.v1\")) return null;\n\treturn esiFetch(`/characters/${character.eveID}/agents_research/`, character);\n}\nfunction getCharacterClones(character) {\n\tif (!CharacterHelper.hasScope(character, \"esi-clones.read_clones.v1\")) return null;\n\treturn esiFetch(`/characters/${character.eveID}/clones/`, character);\n}\nfunction getCharacterImplants(character) {\n\tif (!CharacterHelper.hasScope(character, \"esi-clones.read_implants.v1\")) return null;\n\treturn esiFetch(`/characters/${character.eveID}/implants/`, character);\n}\nfunction getCharacterAssets(character) {\n\tif (!CharacterHelper.hasScope(character, \"esi-assets.read_assets.v1\")) return null;\n\treturn esiFetch(`/characters/${character.eveID}/assets/`, character);\n}\nfunction getCharacterAssetLocations(character, ids) {\n\tif (!CharacterHelper.hasScope(character, \"esi-assets.read_assets.v1\")) return null;\n\treturn esiFetch(`/characters/${character.eveID}/assets/locations/`, character, {\n\t\tmethod: \"POST\",\n\t\tbody: JSON.stringify(ids)\n\t});\n}\nfunction getCharacterAssetNames(character, ids) {\n\tif (!CharacterHelper.hasScope(character, \"esi-assets.read_assets.v1\")) return null;\n\treturn esiFetch(`/characters/${character.eveID}/assets/names/`, character, {\n\t\tmethod: \"POST\",\n\t\tbody: JSON.stringify(ids)\n\t});\n}\nfunction getCharacterWallet(character) {\n\tif (!CharacterHelper.hasScope(character, \"esi-wallet.read_character_wallet.v1\")) return null;\n\treturn esiFetch(`/characters/${character.eveID}/wallet/`, character);\n}\nfunction getCharacterWalletTransactions(character, fromId) {\n\tif (!CharacterHelper.hasScope(character, \"esi-wallet.read_character_wallet.v1\")) return null;\n\treturn esiFetch(`/characters/${character.eveID}/wallet/transactions/`, character, {\n\t\tmethod: \"POST\",\n\t\tbody: JSON.stringify(fromId)\n\t});\n}\nfunction getCharacterWalletJournal(character, page = 1) {\n\tif (!CharacterHelper.hasScope(character, \"esi-wallet.read_character_wallet.v1\")) return null;\n\treturn esiFetch(`/characters/${character.eveID}/wallet/journal/?page=${page}`, character);\n}\nfunction getCharacterLocation(character) {\n\tif (!CharacterHelper.hasScope(character, \"esi-location.read_location.v1\")) return null;\n\treturn esiFetch(`/characters/${character.eveID}/location/`, character);\n}\nfunction getCharacterOnline(character) {\n\tif (!CharacterHelper.hasScope(character, \"esi-location.read_online.v1\")) return null;\n\treturn esiFetch(`/characters/${character.eveID}/online/`, character);\n}\nfunction getCharacterCurrentShip(character) {\n\tif (!CharacterHelper.hasScope(character, \"esi-location.read_ship_type.v1\")) return null;\n\treturn esiFetch(`/characters/${character.eveID}/ship/`, character);\n}\n\n//#endregion\nexport { character_exports, getCharacterAffiliations, getCharacterAgentResearch, getCharacterAssetLocations, getCharacterAssetNames, getCharacterAssets, getCharacterBlueprints, getCharacterClones, getCharacterContactNotifications, getCharacterCorporationHistory, getCharacterCurrentShip, getCharacterImplants, getCharacterJumpFatigue, getCharacterLocation, getCharacterMedals, getCharacterNotifications, getCharacterOnline, getCharacterPortraits, getCharacterPublicData, getCharacterRoles, getCharacterStandings, getCharacterTitles, getCharacterWallet, getCharacterWalletJournal, getCharacterWalletTransactions, getPortraitURL };",
    "import { __export } from \"../_virtual/rolldown_runtime.js\";\nimport { CharacterHelper } from \"../db/models/character.model.js\";\nimport \"../db/index.js\";\nimport { esiFetch } from \"./fetch.js\";\n\n//#region src/esi/corporation.ts\nvar corporation_exports = {};\n__export(corporation_exports, {\n\tgetCorporationAllianceHistory: () => getCorporationAllianceHistory,\n\tgetCorporationAssetLocations: () => getCorporationAssetLocations,\n\tgetCorporationAssetNames: () => getCorporationAssetNames,\n\tgetCorporationAssets: () => getCorporationAssets,\n\tgetCorporationData: () => getCorporationData,\n\tgetCorporationIcons: () => getCorporationIcons\n});\nasync function getCorporationData(id) {\n\treturn await esiFetch(`/corporations/${id}/`);\n}\nasync function getCorporationAllianceHistory(id) {\n\treturn await esiFetch(`/corporations/${id}/alliancehistory/`);\n}\nasync function getCorporationIcons(id) {\n\treturn await esiFetch(`/corporations/${id}/icons/`);\n}\nasync function getCorporationAssets(id, character) {\n\tif (!CharacterHelper.hasScope(character, \"esi-assets.read_corporation_assets.v1\")) return null;\n\treturn await esiFetch(`/corporations/${id}/assets/`, character);\n}\nasync function getCorporationAssetLocations(id, character, ids) {\n\tif (!CharacterHelper.hasScope(character, \"esi-assets.read_corporation_assets.v1\")) return null;\n\treturn await esiFetch(`/corporations/${id}/assets/locations/`, character, {\n\t\tmethod: \"POST\",\n\t\tbody: JSON.stringify(ids)\n\t});\n}\nasync function getCorporationAssetNames(id, character, ids) {\n\tif (!CharacterHelper.hasScope(character, \"esi-assets.read_corporation_assets.v1\")) return null;\n\treturn await esiFetch(`/corporations/${id}/assets/names/`, character, {\n\t\tmethod: \"POST\",\n\t\tbody: JSON.stringify(ids)\n\t});\n}\n\n//#endregion\nexport { corporation_exports };",
    "import { __export } from \"../_virtual/rolldown_runtime.js\";\nimport { esiFetch } from \"./fetch.js\";\n\n//#region src/esi/alliance.ts\nvar alliance_exports = {};\n__export(alliance_exports, {\n\tgetAllianceCorporations: () => getAllianceCorporations,\n\tgetAllianceData: () => getAllianceData,\n\tgetAllianceIcons: () => getAllianceIcons\n});\nasync function getAllianceData(id) {\n\treturn await esiFetch(`/alliances/${id}/`);\n}\nasync function getAllianceCorporations(id) {\n\treturn await esiFetch(`/alliances/${id}/corporations/`);\n}\nasync function getAllianceIcons(id) {\n\treturn await esiFetch(`/alliances/${id}/icons/`);\n}\n\n//#endregion\nexport { alliance_exports, getAllianceCorporations, getAllianceData, getAllianceIcons };",
    "import { CharacterHelper } from \"../db/models/character.model.js\";\nimport \"../db/models/index.js\";\nimport { esiFetch } from \"./fetch.js\";\n\n//#region src/esi/skills.ts\nfunction getCharacterAttributes(character) {\n\tif (!CharacterHelper.hasScope(character, \"esi-skills.read_skills.v1\")) return null;\n\treturn esiFetch(`/characters/${character.eveID}/attributes`, character);\n}\nfunction getCharacterSkillQueue(character) {\n\tif (!CharacterHelper.hasScope(character, \"esi-skills.read_skillqueue.v1\")) return null;\n\treturn esiFetch(`/characters/${character.eveID}/skillqueue`, character);\n}\nfunction getCharacterSkills(character) {\n\tif (!CharacterHelper.hasScope(character, \"esi-skills.read_skills.v1\")) return null;\n\treturn esiFetch(`/characters/${character.eveID}/skills`, character);\n}\nfunction calculateTrainingPercentage(queuedSkill) {\n\tconst trainingStartPosition = (queuedSkill.training_start_sp - queuedSkill.level_start_sp) / queuedSkill.level_end_sp;\n\tconst timePosition = ((/* @__PURE__ */ new Date()).getTime() - new Date(queuedSkill.start_date).getTime()) / (new Date(queuedSkill.finish_date).getTime() - new Date(queuedSkill.start_date).getTime());\n\treturn trainingStartPosition + (1 - trainingStartPosition) * timePosition;\n}\n\n//#endregion\nexport { calculateTrainingPercentage, getCharacterAttributes, getCharacterSkillQueue, getCharacterSkills };",
    "import * as fs$1 from \"fs\";\nimport { chain } from \"stream-chain\";\nimport { parser } from \"stream-json\";\nimport { streamArray } from \"stream-json/streamers/StreamArray\";\nimport { streamObject } from \"stream-json/streamers/StreamObject\";\nimport NodeCache from \"node-cache\";\n\n//#region src/jsonQuery.ts\nconst cache = new NodeCache({ stdTTL: 3600 });\n/**\n* Queries a large JSON array file for an item matching the provided query function.\n* This function streams the file to avoid loading the entire content into memory.\n*\n* @param filePath - The path to the JSON file containing an array of items.\n* @param query - A function that takes an item and returns true if it matches the criteria.\n* @returns A promise that resolves to the first matching item or null if no match is found.\n*/\nfunction queryJsonArray(filePath, query, cacheKey, cacheExpiry) {\n\tif (cacheKey) {\n\t\tconst cached = cache.get(cacheKey);\n\t\tif (cached) return Promise.resolve(cached);\n\t}\n\treturn new Promise((resolve, reject) => {\n\t\tconst pipeline = chain([\n\t\t\tfs$1.createReadStream(filePath),\n\t\t\tparser(),\n\t\t\tstreamArray(),\n\t\t\t(data) => query(data.value) ? data.value : null\n\t\t]);\n\t\tpipeline.on(\"data\", (value) => {\n\t\t\tif (value) {\n\t\t\t\tif (cacheKey) cache.set(cacheKey, value, cacheExpiry || 3600);\n\t\t\t\tresolve(value);\n\t\t\t}\n\t\t});\n\t\tpipeline.on(\"end\", () => {\n\t\t\tresolve(null);\n\t\t});\n\t\tpipeline.on(\"error\", (err) => {\n\t\t\treject(err);\n\t\t});\n\t});\n}\n/**\n* Queries a large JSON object file for a value matching the provided query function.\n* This function streams the file to avoid loading the entire content into memory.\n*\n* @param filePath - The path to the JSON file containing an object of key-value pairs.\n* @param query - A function that takes a key-value pair and returns true if it matches the criteria.\n* @returns A promise that resolves to the first matching value or null if no match is found.\n*/\nfunction queryJsonObject(filePath, query, cacheKey, cacheExpiry) {\n\tif (cacheKey) {\n\t\tconst cached = cache.get(cacheKey);\n\t\tif (cached) return Promise.resolve(cached);\n\t}\n\treturn new Promise((resolve, reject) => {\n\t\tconst pipeline = chain([\n\t\t\tfs$1.createReadStream(filePath),\n\t\t\tparser(),\n\t\t\tstreamObject(),\n\t\t\t(data) => query(data) ? data.value : null\n\t\t]);\n\t\tpipeline.on(\"data\", (value) => {\n\t\t\tif (value) {\n\t\t\t\tif (cacheKey) cache.set(cacheKey, value, cacheExpiry || 3600);\n\t\t\t\tresolve(value);\n\t\t\t}\n\t\t});\n\t\tpipeline.on(\"end\", () => {\n\t\t\tresolve(null);\n\t\t});\n\t\tpipeline.on(\"error\", (err) => {\n\t\t\treject(err);\n\t\t});\n\t});\n}\n\n//#endregion\nexport { queryJsonArray, queryJsonObject };",
    "import { getAttribute } from \"./attribute.js\";\nimport { IconSize } from \"./icon.js\";\nimport { getGroup } from \"./group.js\";\nimport { getUnit } from \"./unit.js\";\nimport { getMetaGroup } from \"./meta-group.js\";\nimport { join } from \"node:path\";\nimport { queryJsonObject } from \"@star-kitten/util/jsonQuery.js\";\n\n//#region src/models/type.ts\nasync function getType(type_id) {\n\tconst data = await queryJsonObject(join(process.cwd(), \"../../data/reference-data/types.json\"), (data$1) => data$1.key === String(type_id));\n\tif (!data) throw new Error(`Type ID ${type_id} not found in reference data`);\n\treturn data;\n}\nfunction getTypeIconUrl(type, size = IconSize.SIZE_64) {\n\treturn `https://images.evetech.net/types/${type.type_id}/icon${type.is_blueprint ? \"/bp\" : \"\"}?size=${size}`;\n}\nasync function getSkillBonuses(type) {\n\tif (!type.traits) return [];\n\tconst skillBonuses = [];\n\tfor (const skill_type_id in type.traits.types) skillBonuses.push({\n\t\tskill: await getType(Number(skill_type_id)),\n\t\tbonuses: await Promise.all(Object.keys(type.traits.types[skill_type_id]).map(async (order) => {\n\t\t\tconst bonus = type.traits.types[skill_type_id][order];\n\t\t\treturn {\n\t\t\t\tbonus: bonus.bonus,\n\t\t\t\tbonus_text: bonus.bonus_text,\n\t\t\t\timportance: bonus.importance,\n\t\t\t\tunit: await getUnit(bonus.unit_id)\n\t\t\t};\n\t\t}))\n\t});\n\treturn skillBonuses;\n}\nfunction getRoleBonuses(type) {\n\tif (!type.traits || !type.traits.role_bonuses) return [];\n\treturn Object.values(type.traits.role_bonuses).map((bonus) => ({\n\t\tbonus: bonus.bonus,\n\t\tbonus_text: bonus.bonus_text,\n\t\timportance: bonus.importance,\n\t\tunit: bonus.unit_id && getUnit(bonus.unit_id)\n\t}));\n}\nfunction eveRefLink(type_id) {\n\treturn `https://everef.net/types/${type_id}`;\n}\nfunction renderTypeEveRefLink(type, locale = \"en\") {\n\treturn `[${type.name[locale] ?? type.name.en}](${eveRefLink(type.type_id)})`;\n}\nfunction eveTycoonLink(type_id) {\n\treturn `https://evetycoon.com/market/${type_id}`;\n}\nfunction getTypeAttributes(type) {\n\tif (!type.dogma_attributes) return [];\n\tObject.keys(type.dogma_attributes).map((attribute_id) => ({\n\t\tattribute: getAttribute(Number(attribute_id)),\n\t\tvalue: type.dogma_attributes[attribute_id].value\n\t}));\n}\nfunction typeHasAnyAttribute(type, attribute_ids) {\n\tif (!type.dogma_attributes) return false;\n\tfor (const attribute_id of attribute_ids) if (type.dogma_attributes[attribute_id]) return true;\n\treturn false;\n}\nasync function getTypeSkills(type) {\n\tif (!type.required_skills) return [];\n\treturn Promise.all(Object.keys(type.required_skills).map(async (skill_type_id) => ({\n\t\tskill: await getType(Number(skill_type_id)),\n\t\tlevel: type.required_skills[skill_type_id]\n\t})));\n}\nasync function typeGetAttribute(type, attribute_id) {\n\tif (!type.dogma_attributes || !type.dogma_attributes[attribute_id]) return null;\n\treturn {\n\t\tattribute: await getAttribute(attribute_id),\n\t\tvalue: type.dogma_attributes[attribute_id].value\n\t};\n}\nasync function getTypeBlueprints(type) {\n\tif (!type.produced_by_blueprints) return [];\n\treturn Promise.all(Object.values(type.produced_by_blueprints).map(async (blueprint) => ({\n\t\tblueprint: await getType(blueprint.blueprint_type_id),\n\t\tactivity: blueprint.blueprint_activity\n\t})));\n}\nasync function getTypeSchematics(type) {\n\treturn Promise.all(type.produced_by_schematic_ids?.map((schematic_id) => getType(schematic_id)) ?? []);\n}\nasync function getTypeGroup(type) {\n\tif (!type.group_id) return null;\n\treturn await getGroup(type.group_id);\n}\nasync function getTypeVariants(type) {\n\treturn Promise.all(Object.entries(type.type_variations || {}).map(async ([meta_group_id, variant_ids]) => ({\n\t\tmetaGroup: await getMetaGroup(Number(meta_group_id)),\n\t\ttypes: await Promise.all(variant_ids.map((type_id) => getType(type_id)))\n\t})));\n}\nfunction typeHasAttributes(type) {\n\treturn type.dogma_attributes && Object.keys(type.dogma_attributes).length > 0;\n}\n\n//#endregion\nexport { eveRefLink, eveTycoonLink, getRoleBonuses, getSkillBonuses, getType, getTypeAttributes, getTypeBlueprints, getTypeGroup, getTypeIconUrl, getTypeSchematics, getTypeSkills, getTypeVariants, renderTypeEveRefLink, typeGetAttribute, typeHasAnyAttribute, typeHasAttributes };",
    "//#region src/text.ts\nfunction truncateText(input, length = 1e3) {\n\treturn input.length > length ? input.substring(0, length) + \"...\" : input;\n}\nfunction formatNumberToShortForm(number, locale = \"en-uS\") {\n\tlet suffix = \"\";\n\tlet value = number;\n\tif (Math.abs(number) >= 1e9) {\n\t\tvalue = number / 1e9;\n\t\tsuffix = \"b\";\n\t} else if (Math.abs(number) >= 1e6) {\n\t\tvalue = number / 1e6;\n\t\tsuffix = \"M\";\n\t} else if (Math.abs(number) >= 1e3) {\n\t\tvalue = number / 1e3;\n\t\tsuffix = \"k\";\n\t}\n\tconst formattedValue = new Intl.NumberFormat(locale, { maximumSignificantDigits: 4 }).format(value);\n\treturn `${formattedValue}${suffix}`;\n}\n\n//#endregion\nexport { formatNumberToShortForm, truncateText };",
    "import { getAttribute } from \"./attribute.js\";\nimport { join } from \"node:path\";\nimport { queryJsonObject } from \"@star-kitten/util/jsonQuery.js\";\n\n//#region src/models/skill.ts\nasync function getSkill(type_id) {\n\tconst data = await queryJsonObject(join(process.cwd(), \"../../data/reference-data/skills.json\"), (data$1) => data$1.key === String(type_id));\n\tif (!data) throw new Error(`Skill ID ${type_id} not found in reference data`);\n\treturn data;\n}\nasync function getPrimaryDogmaAttribute(skill) {\n\treturn getAttribute(skill.primary_dogma_attribute_id);\n}\nasync function getSecondaryDogmaAttribute(skill) {\n\treturn getAttribute(skill.secondary_dogma_attribute_id);\n}\nasync function getPrimaryCharacterAttribute(skill) {\n\treturn getAttribute(skill.primary_character_attribute_id);\n}\nasync function getSecondaryCharacterAttribute(skill) {\n\treturn getAttribute(skill.secondary_character_attribute_id);\n}\nasync function getPrerequisites(skill) {\n\tif (!skill.required_skills) return [];\n\treturn Promise.all(Object.entries(skill.required_skills).map(async ([skill_type_id, level]) => ({\n\t\tskill: await getSkill(parseInt(skill_type_id)),\n\t\tlevel\n\t})));\n}\nfunction skillpointsAtLevel(skill, level) {\n\treturn Math.pow(2, 2.5 * (level - 1)) * 250 * skill.training_time_multiplier;\n}\n\n//#endregion\nexport { getPrerequisites, getPrimaryCharacterAttribute, getPrimaryDogmaAttribute, getSecondaryCharacterAttribute, getSecondaryDogmaAttribute, getSkill, skillpointsAtLevel };",
    "// @bun\nvar n=Symbol.for(\"isJSX\");function S(r){return i(null,r)}function i(r,{children:e,...o},s){let a=e;if(Array.isArray(e)&&!l(e))a=e.map((t)=>t?.[n]?t:S({children:t}));return Object.assign([r,{...o,key:s},a],{[n]:!0})}function l(r){return Array.isArray(r)&&((n in r)||m(r))}function m(r){return r?.[0]===\"HTML\"&&typeof r[1]?.html===\"string\"}export{i as jsxs,i as jsxDEV,i as jsx,m as isDangerHTML,l as isArrawOfJSXContent,S as Fragment};\n",
    "import {calculateTrainingPercentage, getCharacterSkillQueue} from \"@star-kitten/eve/esi\";\nimport {getSkill, getType} from \"@star-kitten/eve/models\";\nexport default async function SkillQueueStat({character}) {\n  const queue = await getCharacterSkillQueue(character);\n  const current = queue?.find(skill => skill.queue_position === 0);\n  if (!current || !current.start_date) {\n    return jsxDEV_7x81h0kn(\"div\", {\n      class: \"stat\",\n      children: [jsxDEV_7x81h0kn(\"div\", {\n        class: \"stat-figure text-secondary\"\n      }, undefined, false, undefined, this), jsxDEV_7x81h0kn(\"div\", {\n        class: \"stat-title\",\n        children: \"No Skills Training\"\n      }, undefined, false, undefined, this)]\n    }, undefined, true, undefined, this);\n  }\n  const skill = await getSkill(current.skill_id);\n  const percentage = calculateTrainingPercentage(current) * 100;\n  return jsxDEV_7x81h0kn(\"div\", {\n    class: \"stat\",\n    children: [jsxDEV_7x81h0kn(\"div\", {\n      class: \"stat-figure text-secondary\"\n    }, undefined, false, undefined, this), jsxDEV_7x81h0kn(\"div\", {\n      class: \"stat-title\",\n      children: \"Currently Training\"\n    }, undefined, false, undefined, this), jsxDEV_7x81h0kn(\"div\", {\n      class: \"stat-value\",\n      children: [(await getType(skill.type_id)).name.en, \" \", current.finished_level]\n    }, undefined, true, undefined, this), jsxDEV_7x81h0kn(\"div\", {\n      class: \"stat-desc\",\n      children: jsxDEV_7x81h0kn(\"progress\", {\n        class: \"progress progress-primary w-full\",\n        value: percentage,\n        max: \"100\"\n      }, undefined, false, undefined, this)\n    }, undefined, false, undefined, this)]\n  }, undefined, true, undefined, this);\n}\nSkillQueueStat.suspense = () => jsxDEV_7x81h0kn(\"div\", {\n  class: \"stat\",\n  children: [jsxDEV_7x81h0kn(\"div\", {\n    class: \"stat-figure text-secondary\"\n  }, undefined, false, undefined, this), jsxDEV_7x81h0kn(\"div\", {\n    class: \"stat-title\",\n    children: \"Currently Training\"\n  }, undefined, false, undefined, this), jsxDEV_7x81h0kn(\"div\", {\n    class: \"flex w-52 flex-col gap-4\",\n    children: [jsxDEV_7x81h0kn(\"div\", {\n      class: \"skeleton h-16 w-full\"\n    }, undefined, false, undefined, this), jsxDEV_7x81h0kn(\"div\", {\n      class: \"skeleton h-4 w-full\"\n    }, undefined, false, undefined, this)]\n  }, undefined, true, undefined, this)]\n}, undefined, true, undefined, this);\nimport { jsx as jsx_w77yafs4, jsxs as jsxs_eh6c78nj, jsxDEV as jsxDEV_7x81h0kn, Fragment as Fragment_8vg9x3sq } from 'brisa/jsx-runtime';\n",
    "import {renderComponent} from \"brisa/server\";\nimport {CharacterAPI} from \"@star-kitten/eve/esi\";\nimport {formatNumberToShortForm} from \"@star-kitten/util/text.js\";\nexport default async function WalletStat({character}) {\n  const balance = await CharacterAPI.getCharacterWallet(character) || 0;\n  const journal = await CharacterAPI.getCharacterWalletJournal(character, 1);\n  const earliestTransaction = journal?.filter(transaction => {\n    const date = new Date(transaction.date);\n    return date.getDate() === new Date().getDate();\n  }).sort((a, b) => new Date(a.date).getTime() - new Date(b.date).getTime())[0];\n  const balanceChange = balance - (earliestTransaction?.balance || balance);\n  const balanceChangePercentage = balanceChange / (earliestTransaction?.balance || balance) * 100;\n  const balanceChangeDirection = balanceChange > 0 ? \"↗︎\" : \"↘︎\";\n  const balanceChangeText = `${balanceChangeDirection} ${formatNumberToShortForm(Math.abs(balanceChange))} (${Math.abs(Number(balanceChangePercentage.toFixed(2)))}%)`;\n  return jsxDEV_7x81h0kn(\"div\", {\n    class: \"stat\",\n    children: [jsxDEV_7x81h0kn(\"div\", {\n      class: \"stat-figure text-secondary\"\n    }, undefined, false, undefined, this), jsxDEV_7x81h0kn(\"div\", {\n      class: \"stat-title\",\n      children: \"Wallet\"\n    }, undefined, false, undefined, this), jsxDEV_7x81h0kn(\"div\", {\n      class: \"stat-value\",\n      children: [formatNumberToShortForm(balance), \" ISK\"]\n    }, undefined, true, undefined, this), jsxDEV_7x81h0kn(\"div\", {\n      class: \"stat-desc\",\n      children: balanceChangeText\n    }, undefined, false, undefined, this)]\n  }, undefined, true, undefined, this);\n}\nWalletStat.suspense = () => jsxDEV_7x81h0kn(\"div\", {\n  class: \"stat\",\n  children: [jsxDEV_7x81h0kn(\"div\", {\n    class: \"stat-figure text-secondary\"\n  }, undefined, false, undefined, this), jsxDEV_7x81h0kn(\"div\", {\n    class: \"stat-title\",\n    children: \"Wallet\"\n  }, undefined, false, undefined, this), jsxDEV_7x81h0kn(\"div\", {\n    class: \"flex w-52 flex-col gap-4\",\n    children: [jsxDEV_7x81h0kn(\"div\", {\n      class: \"skeleton h-16 w-full\"\n    }, undefined, false, undefined, this), jsxDEV_7x81h0kn(\"div\", {\n      class: \"skeleton h-4 w-full\"\n    }, undefined, false, undefined, this)]\n  }, undefined, true, undefined, this)]\n}, undefined, true, undefined, this);\nimport { jsx as jsx_w77yafs4, jsxs as jsxs_eh6c78nj, jsxDEV as jsxDEV_7x81h0kn, Fragment as Fragment_8vg9x3sq } from 'brisa/jsx-runtime';\n",
    "import {getCookies} from \"@/utils\";\nimport {CharacterHelper, UserHelper} from \"@star-kitten/eve/db\";\nimport SkillQueueStat from \"@/components/stats/skill-queue\";\nimport WalletStat from \"@/components/stats/wallet\";\nexport default function Homepage(props, request) {\n  const user = UserHelper.find(1);\n  const character = user.mainCharacterID && CharacterHelper.find(user.mainCharacterID);\n  return jsxDEV_7x81h0kn(Fragment_8vg9x3sq, {\n    children: jsxDEV_7x81h0kn(\"div\", {\n      class: \"bg-gray-900 py-24 sm:py-32\",\n      children: jsxDEV_7x81h0kn(\"div\", {\n        class: \"mx-auto max-w-7xl px-6 lg:px-8\",\n        children: jsxDEV_7x81h0kn(\"div\", {\n          class: \"mx-auto max-w-2xl lg:max-w-none\",\n          children: jsxDEV_7x81h0kn(\"div\", {\n            class: \"stats shadow\",\n            children: [jsxDEV_7x81h0kn(\"div\", {\n              class: \"stat\",\n              children: [jsxDEV_7x81h0kn(\"div\", {\n                class: \"stat-figure text-secondary\",\n                children: jsxDEV_7x81h0kn(\"svg\", {\n                  xmlns: \"http://www.w3.org/2000/svg\",\n                  fill: \"none\",\n                  viewBox: \"0 0 24 24\",\n                  class: \"inline-block h-8 w-8 stroke-current\",\n                  children: jsxDEV_7x81h0kn(\"path\", {\n                    \"stroke-linecap\": \"round\",\n                    \"stroke-linejoin\": \"round\",\n                    \"stroke-width\": \"2\",\n                    d: \"M13 16h-1v-4h-1m1-4h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z\"\n                  }, undefined, false, undefined, this)\n                }, undefined, false, undefined, this)\n              }, undefined, false, undefined, this), jsxDEV_7x81h0kn(\"div\", {\n                class: \"stat-title\",\n                children: \"Characters\"\n              }, undefined, false, undefined, this), jsxDEV_7x81h0kn(\"div\", {\n                class: \"stat-value\",\n                children: user.characterIDs.length\n              }, undefined, false, undefined, this), jsxDEV_7x81h0kn(\"div\", {\n                class: \"stat-desc\",\n                children: \"Jan 1st - Feb 1st\"\n              }, undefined, false, undefined, this)]\n            }, undefined, true, undefined, this), character && jsxDEV_7x81h0kn(SkillQueueStat, {\n              character\n            }, undefined, false, undefined, this), character && jsxDEV_7x81h0kn(WalletStat, {\n              character\n            }, undefined, false, undefined, this), jsxDEV_7x81h0kn(\"div\", {\n              class: \"stat\",\n              children: [jsxDEV_7x81h0kn(\"div\", {\n                class: \"stat-figure text-secondary\",\n                children: jsxDEV_7x81h0kn(\"svg\", {\n                  xmlns: \"http://www.w3.org/2000/svg\",\n                  fill: \"none\",\n                  viewBox: \"0 0 24 24\",\n                  class: \"inline-block h-8 w-8 stroke-current\",\n                  children: jsxDEV_7x81h0kn(\"path\", {\n                    \"stroke-linecap\": \"round\",\n                    \"stroke-linejoin\": \"round\",\n                    \"stroke-width\": \"2\",\n                    d: \"M5 8h14M5 8a2 2 0 110-4h14a2 2 0 110 4M5 8v10a2 2 0 002 2h10a2 2 0 002-2V8m-9 4h4\"\n                  }, undefined, false, undefined, this)\n                }, undefined, false, undefined, this)\n              }, undefined, false, undefined, this), jsxDEV_7x81h0kn(\"div\", {\n                class: \"stat-title\",\n                children: \"New Registers\"\n              }, undefined, false, undefined, this), jsxDEV_7x81h0kn(\"div\", {\n                class: \"stat-value\",\n                children: \"1,200\"\n              }, undefined, false, undefined, this), jsxDEV_7x81h0kn(\"div\", {\n                class: \"stat-desc\",\n                children: \"↘︎ 90 (14%)\"\n              }, undefined, false, undefined, this)]\n            }, undefined, true, undefined, this)]\n          }, undefined, true, undefined, this)\n        }, undefined, false, undefined, this)\n      }, undefined, false, undefined, this)\n    }, undefined, false, undefined, this)\n  }, undefined, false, undefined, this);\n}\nimport { jsx as jsx_w77yafs4, jsxs as jsxs_eh6c78nj, jsxDEV as jsxDEV_7x81h0kn, Fragment as Fragment_8vg9x3sq } from 'brisa/jsx-runtime';\n"
  ],
  "mappings": "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AAAA,IAAG;AAAA,IAAI;AAAA,IAAI;AAAA,IAAI;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IACrD;AAAA,IAAI;AAAA,IAAI;AAAA,IAAI;AAAA,IAAI;AAAA,IAAI;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IACpD;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAI;AAAA,IAAG;AAAA,IAAI;AAAA,IAAI;AAAA,IAAI;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,EACvD;AAAA,EAEA,IAAI,KAAK;AAAA,IACP;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAI;AAAA,IAAI;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAI;AAAA,IAAI;AAAA,IAAI;AAAA,IACrD;AAAA,IAAG;AAAA,IAAI;AAAA,IAAI;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAI;AAAA,IACpD;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAI;AAAA,IAAI;AAAA,IAAG;AAAA,IAAI;AAAA,IAAI;AAAA,IAAI;AAAA,IAAG;AAAA,IACrD;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAI;AAAA,IAAI;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAI;AAAA,IACrD;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAG;AAAA,IAAG;AAAA,IAAI;AAAA,IAAI;AAAA,IAAI;AAAA,EACtD;AAAA;;;;EC/IA,IAAI;AAAA,EACJ,IAAI;AAAA,EAEJ,SAAS,IAAI,CAAC,MAAM,KAAK,KAAK;AAAA,IAC5B,MAAM,gBAAgB;AAAA,MACpB,OAAO,IAAI,KAAK,MAAM,KAAK,GAAG;AAAA,IAChC,KAAK,OAAO;AAAA,IACZ,KAAK,YAAY,KAAK,YAAY;AAAA,IAClC,KAAK,UAAU,KAAK,UAAU;AAAA,IAC9B,KAAK,QAAQ;AAAA,IACb,KAAK,QAAQ;AAAA,IAEb,KAAK,MAAM,MAAM,QAAQ,KAAK,GAAG,CAAC;AAAA;AAAA,EAEpC,OAAO,UAAU;AAAA,EAEjB,KAAK,UAAU,QAAQ,SAAS,IAAI,CAAC,KAAK;AAAA,IAExC,IAAI,IAAI,SAAS,KAAK;AAAA,MACpB,MAAM,IAAI,KAAK,KAAK,EAAE,OAAO,GAAG,EAAE,OAAO;AAAA,IAC3C,OAAO,IAAI,UAAU,KAAK,SAAS;AAAA,IAGnC,SAAS,IAAI,IAAI,OAAQ,IAAI,KAAK,WAAW;AAAA,MAC3C,IAAI,KAAK,CAAC;AAAA,IAEZ,KAAK,IAAI,EAAG,IAAI,IAAI,QAAQ;AAAA,MAC1B,IAAI,MAAM;AAAA,IACZ,KAAK,QAAQ,IAAI,KAAK,KAAK,EAAE,OAAO,GAAG;AAAA,IAGvC,KAAK,IAAI,EAAG,IAAI,IAAI,QAAQ;AAAA,MAC1B,IAAI,MAAM;AAAA,IACZ,KAAK,QAAQ,IAAI,KAAK,KAAK,EAAE,OAAO,GAAG;AAAA;AAAA,EAGzC,KAAK,UAAU,SAAS,SAAS,MAAM,CAAC,KAAK,KAAK;AAAA,IAChD,KAAK,MAAM,OAAO,KAAK,GAAG;AAAA,IAC1B,OAAO;AAAA;AAAA,EAGT,KAAK,UAAU,SAAS,SAAS,MAAM,CAAC,KAAK;AAAA,IAC3C,KAAK,MAAM,OAAO,KAAK,MAAM,OAAO,CAAC;AAAA,IACrC,OAAO,KAAK,MAAM,OAAO,GAAG;AAAA;AAAA;;;;EC7C9B,IAAI,OAAO;AAAA,EAEX,KAAK;AAAA,EACL,KAAK;AAAA,EACL,KAAK;AAAA,EACL,KAAK;AAAA,EACL,KAAK;AAAA,EAGL,KAAK,OAAO,KAAK,IAAI;AAAA,EACrB,KAAK,SAAS,KAAK,IAAI;AAAA,EACvB,KAAK,SAAS,KAAK,IAAI;AAAA,EACvB,KAAK,SAAS,KAAK,IAAI;AAAA,EACvB,KAAK,SAAS,KAAK,IAAI;AAAA,EACvB,KAAK,YAAY,KAAK,OAAO;AAAA;;;;ECd7B,OAAO,UAAU;AAAA,IACf,SAAS;AAAA,MACP,MAAM;AAAA,MACN,QAAQ;AAAA,QACN;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,IACA,KAAK;AAAA,MACH,KAAK;AAAA,MACL,QAAQ;AAAA,QACN;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AAAA,QACF;AAAA,QACA;AAAA,UACE;AAAA,UACA;AA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",
  "debugId": "AA342C1D9D53B62B64756E2164756E21",
  "names": []
}
|