jobsys-explore
Version:
Enhanced component based on vant
1,543 lines • 96.3 kB
JavaScript
import { r as __toDynamicImportESM } from "./chunk-DqLtgREg.js";
import { allowMultipleToast, closeToast, showFailToast, showLoadingToast, showSuccessToast } from "vant";
import { cloneDeep, find, flatMapDeep, isArray, isBoolean, isDate, isFunction, isNull, isObject, isString, isUndefined, reduce } from "lodash-es";
import axios from "axios";
import dayjs from "dayjs";
const STATUS = {
STATE_CODE_SUCCESS: "SUCCESS",
STATE_CODE_FAIL: "FAIL",
STATE_CODE_NOT_FOUND: "NOT_FOUND",
STATE_CODE_INFO_NOT_COMPLETE: "INCOMPLETE",
STATE_CODE_NOT_ALLOWED: "NOT_ALLOWED"
};
function _configStatus(e) {
Object.keys(e).forEach((T) => {
STATUS[T] = e[T];
});
}
function useFetch(e) {
let D = null;
return e ||= {}, e.loading = !0, {
get(E, O) {
return new Promise((k, A) => {
axios.get(E, O).then((e) => {
k(e);
}).catch((e) => {
A(e);
}).finally(() => {
D && (allowMultipleToast(!1), D.close()), e.loading = !1;
});
});
},
post(E, O, k) {
return new Promise((A, j) => {
axios.post(E, O, k).then((e) => {
A(e);
}).catch((e) => {
j(e);
}).finally(() => {
D && (allowMultipleToast(!1), D.close()), e.loading = !1;
});
});
},
loading(e) {
return closeToast(!0), allowMultipleToast(), D = isString(e) ? showLoadingToast({
message: e || "加载中...",
duration: 0,
forbidClick: !0
}) : isObject(e) ? showLoadingToast({
duration: 0,
...e
}) : showLoadingToast({
message: "加载中...",
duration: 0,
forbidClick: !0
}), this;
}
};
}
function useTextFromOptionsValue(e, T, E) {
if (!T) return "";
E ||= {
value: "value",
label: "text"
};
let D = T.find((T) => T[E.value] === e);
return D ? D[E.label] : "";
}
function useFindTextsInValues(e, T, E) {
E ||= {
value: "value",
label: "text",
children: "children"
};
let D = [];
function O(e) {
T.includes(e[E.value]) && D.push(e[E.label]), e[E.children]?.length && e[E.children].forEach((e) => {
O(e);
});
}
return e.forEach((e) => {
O(e);
}), D;
}
function useFindLabelsFromPath(e, T, E) {
E ||= {
value: "value",
label: "text",
children: "children"
};
let D = [];
return reduce(T, (e, T) => {
let O = find(e, { [E.value]: T });
if (O) return D.push(O[E.label]), O[E.children];
}, e), D;
}
function useFindOptionByValue(e, T, E) {
E ||= {
value: "value",
label: "text",
children: "children"
};
for (let D of e) {
if (D[E.value] === T) return D;
if (D[E.children] && D[E.children].length) {
let e = useFindOptionByValue(D[E.children], T, E);
if (e) return e;
}
}
return null;
}
function useFindTextsFromPath(e, T, E) {
return E ||= {
value: "value",
label: "text",
children: "children"
}, useFindLabelsFromPath(e, T, E);
}
function useFindPropertyRecursive(e, T, E) {
return flatMapDeep(e, (e, D) => D === T ? e : D === E ? useFindPropertyRecursive(e, T, E) : []);
}
function useFindParentLabels(e, T, E) {
E ||= {
value: "value",
label: "text",
children: "children"
};
let D = [];
function O(e, T, D) {
for (let k of e) if (k[E.value] === T) {
D.unshift(k[E.label]);
break;
} else if (k[E.children] && O(k[E.children], T, D).length > 0) {
D.unshift(k[E.label]);
break;
}
return D;
}
return O(e, T, D);
}
function useFindParentValues(e, T, E) {
E ||= {
value: "value",
label: "text",
children: "children"
};
let D = [];
function O(e, T, D) {
for (let k of e) if (k[E.value] === T) {
D.unshift(k[E.value]);
break;
} else if (k[E.children] && O(k[E.children], T, D).length > 0) {
D.unshift(k[E.value]);
break;
}
return D;
}
return O(e, T, D);
}
var localCacheSession = {}, localSession = {
setItem(e, T) {
localCacheSession[e] = T;
},
getItem(e) {
return localCacheSession[e];
},
removeItem(e) {
delete localCacheSession[e];
}
};
window._printCache = () => {
console.log(JSON.parse(JSON.stringify(localCacheSession, null, 2)));
};
function useCache(e, T) {
let E = T || localSession, D = !!T;
return {
get(T) {
let O = E.getItem(e);
return isNull(O) || isUndefined(O) ? T : D ? JSON.parse(O) : O;
},
set(T) {
E.setItem(e, D ? JSON.stringify(T) : T);
},
remove() {
E.removeItem(e);
}
};
}
function useHiddenForm(e) {
let { url: T, data: E, csrfToken: D } = e, { method: O } = e;
O ||= "post";
let k = document.createElement("form");
if (k.action = T, k.method = O, k.target = "_blank", k.style.display = "none", Object.keys(E).forEach((e) => {
let T = document.createElement("input");
T.type = "hidden", T.name = e, T.value = E[e], k.appendChild(T);
}), !D) {
let e = document.createElement("input");
e.type = "hidden", e.name = "_token", e.value = document.querySelector("meta[name=\"csrf-token\"]").getAttribute("content"), k.appendChild(e);
}
return document.body.appendChild(k), k;
}
function useProcessStatus(e, T) {
let { status: E } = e, O = e.result, A = {};
A.default = "请求失败, 请检查数据并重试", A[STATUS.STATE_CODE_FAIL] = "系统错误，请稍候再试", A[STATUS.STATE_CODE_NOT_FOUND] = "请求的内容不存在", A[STATUS.STATE_CODE_INFO_NOT_COMPLETE] = "信息不完整", A[STATUS.STATE_CODE_NOT_ALLOWED] = "没有权限";
let j = { [STATUS.STATE_CODE_SUCCESS]: "success" }, M = T[E] || T[j[E]] || A[E] || A.default;
isString(M) ? E === STATUS.STATE_CODE_SUCCESS ? showSuccessToast(M) : showFailToast(O || M) : isFunction(M) && M();
}
function useProcessStatusSuccess(e, T) {
useProcessStatus(e, { success: T });
}
function useFormFail(e) {
e && e.errorFields ? e.errorFields.forEach((e) => {
showFailToast(e.errors.join(" "));
}) : e && e.response ? showFailToast("网络异常") : showFailToast("请检查填写项");
}
function useFormFormat(e, T) {
let E = cloneDeep(e);
T ||= {};
let D = (e) => {
for (let E in e) {
let O;
if (dayjs.isDayjs(e[E]) ? O = e[E] : isDate(e[E]) && (O = dayjs(e[E])), O && T.date) {
isString(T.date) ? e[E] = O.format(T.date) : isFunction(T.date) ? e[E] = T.date(O) : e[E] = O.unix();
continue;
}
if (isBoolean(e[E]) && T.boolean) {
T.boolean === !0 ? e[E] = e[E] ? 1 : 0 : Array.isArray(T.boolean) && (e[E] = e[E] ? T.boolean?.[0] || 1 : T.boolean?.[1] || 0);
continue;
}
if (T.attachment) {
let D = T.attachment;
if (isObject(e[E]) && e[E]._type === "file" && isString(D) && !isUndefined(e[E][D])) {
e[E] = e[E][D];
continue;
} else if (isObject(e[E]) && isFunction(D) && e[E]._type === "file") {
e[E] = D(e[E]);
continue;
}
}
isArray(e[E]) && (e[E] = D(e[E]));
}
return e;
};
return D(E);
}
const crypto = typeof globalThis == "object" && "crypto" in globalThis ? globalThis.crypto : void 0;
function isBytes$1(e) {
return e instanceof Uint8Array || ArrayBuffer.isView(e) && e.constructor.name === "Uint8Array";
}
function anumber(e) {
if (!Number.isSafeInteger(e) || e < 0) throw Error("positive integer expected, got " + e);
}
function abytes$1(e, ...T) {
if (!isBytes$1(e)) throw Error("Uint8Array expected");
if (T.length > 0 && !T.includes(e.length)) throw Error("Uint8Array expected of length " + T + ", got length=" + e.length);
}
function ahash(e) {
if (typeof e != "function" || typeof e.create != "function") throw Error("Hash should be wrapped by utils.createHasher");
anumber(e.outputLen), anumber(e.blockLen);
}
function aexists$1(e, T = !0) {
if (e.destroyed) throw Error("Hash instance has been destroyed");
if (T && e.finished) throw Error("Hash#digest() has already been called");
}
function clean$1(...e) {
for (let T = 0; T < e.length; T++) e[T].fill(0);
}
var hasHexBuiltin = /* @__PURE__ */ (() => typeof Uint8Array.from([]).toHex == "function" && typeof Uint8Array.fromHex == "function")(), hexes$1 = /* @__PURE__ */ Array.from({ length: 256 }, (e, T) => T.toString(16).padStart(2, "0"));
function bytesToHex$1(e) {
if (abytes$1(e), hasHexBuiltin) return e.toHex();
let T = "";
for (let E = 0; E < e.length; E++) T += hexes$1[e[E]];
return T;
}
var asciis = {
_0: 48,
_9: 57,
A: 65,
F: 70,
a: 97,
f: 102
};
function asciiToBase16(e) {
if (e >= asciis._0 && e <= asciis._9) return e - asciis._0;
if (e >= asciis.A && e <= asciis.F) return e - (asciis.A - 10);
if (e >= asciis.a && e <= asciis.f) return e - (asciis.a - 10);
}
function hexToBytes(e) {
if (typeof e != "string") throw Error("hex string expected, got " + typeof e);
if (hasHexBuiltin) return Uint8Array.fromHex(e);
let T = e.length, E = T / 2;
if (T % 2) throw Error("hex string expected, got unpadded hex of length " + T);
let D = new Uint8Array(E);
for (let T = 0, O = 0; T < E; T++, O += 2) {
let E = asciiToBase16(e.charCodeAt(O)), k = asciiToBase16(e.charCodeAt(O + 1));
if (E === void 0 || k === void 0) {
let T = e[O] + e[O + 1];
throw Error("hex string expected, got non-hex character \"" + T + "\" at index " + O);
}
D[T] = E * 16 + k;
}
return D;
}
function utf8ToBytes$2(e) {
if (typeof e != "string") throw Error("string expected");
return new Uint8Array(new TextEncoder().encode(e));
}
function toBytes$2(e) {
return typeof e == "string" && (e = utf8ToBytes$2(e)), abytes$1(e), e;
}
function concatBytes$1(...e) {
let T = 0;
for (let E = 0; E < e.length; E++) {
let D = e[E];
abytes$1(D), T += D.length;
}
let E = new Uint8Array(T);
for (let T = 0, D = 0; T < e.length; T++) {
let O = e[T];
E.set(O, D), D += O.length;
}
return E;
}
var Hash$2 = class {};
function randomBytes$1(e = 32) {
if (crypto && typeof crypto.getRandomValues == "function") return crypto.getRandomValues(new Uint8Array(e));
if (crypto && typeof crypto.randomBytes == "function") return Uint8Array.from(crypto.randomBytes(e));
throw Error("crypto.getRandomValues must be defined");
}
var _0n$3 = /* @__PURE__ */ BigInt(0), _1n$3 = /* @__PURE__ */ BigInt(1);
function _abool2(e, T = "") {
if (typeof e != "boolean") {
let E = T && `"${T}"`;
throw Error(E + "expected boolean, got type=" + typeof e);
}
return e;
}
function _abytes2(e, T, E = "") {
let D = isBytes$1(e), O = e?.length, k = T !== void 0;
if (!D || k && O !== T) {
let A = E && `"${E}" `, j = k ? ` of length ${T}` : "", M = D ? `length=${O}` : `type=${typeof e}`;
throw Error(A + "expected Uint8Array" + j + ", got " + M);
}
return e;
}
function numberToHexUnpadded(e) {
let T = e.toString(16);
return T.length & 1 ? "0" + T : T;
}
function hexToNumber$1(e) {
if (typeof e != "string") throw Error("hex string expected, got " + typeof e);
return e === "" ? _0n$3 : BigInt("0x" + e);
}
function bytesToNumberBE(e) {
return hexToNumber$1(bytesToHex$1(e));
}
function bytesToNumberLE(e) {
return abytes$1(e), hexToNumber$1(bytesToHex$1(Uint8Array.from(e).reverse()));
}
function numberToBytesBE(e, T) {
return hexToBytes(e.toString(16).padStart(T * 2, "0"));
}
function numberToBytesLE(e, T) {
return numberToBytesBE(e, T).reverse();
}
function ensureBytes(e, T, E) {
let D;
if (typeof T == "string") try {
D = hexToBytes(T);
} catch (T) {
throw Error(e + " must be hex string or Uint8Array, cause: " + T);
}
else if (isBytes$1(T)) D = Uint8Array.from(T);
else throw Error(e + " must be hex string or Uint8Array");
let O = D.length;
if (typeof E == "number" && O !== E) throw Error(e + " of length " + E + " expected, got " + O);
return D;
}
var isPosBig = (e) => typeof e == "bigint" && _0n$3 <= e;
function inRange(e, T, E) {
return isPosBig(e) && isPosBig(T) && isPosBig(E) && T <= e && e < E;
}
function aInRange(e, T, E, D) {
if (!inRange(T, E, D)) throw Error("expected valid " + e + ": " + E + " <= n < " + D + ", got " + T);
}
function bitLen(e) {
let T;
for (T = 0; e > _0n$3; e >>= _1n$3, T += 1);
return T;
}
const bitMask = (e) => (_1n$3 << BigInt(e)) - _1n$3;
function createHmacDrbg(e, T, E) {
if (typeof e != "number" || e < 2) throw Error("hashLen must be a number");
if (typeof T != "number" || T < 2) throw Error("qByteLen must be a number");
if (typeof E != "function") throw Error("hmacFn must be a function");
let D = (e) => new Uint8Array(e), O = (e) => Uint8Array.of(e), k = D(e), A = D(e), j = 0, M = () => {
k.fill(1), A.fill(0), j = 0;
}, N = (...e) => E(A, k, ...e), P = (e = D(0)) => {
A = N(O(0), e), k = N(), e.length !== 0 && (A = N(O(1), e), k = N());
}, F = () => {
if (j++ >= 1e3) throw Error("drbg: tried 1000 values");
let e = 0, E = [];
for (; e < T;) {
k = N();
let T = k.slice();
E.push(T), e += k.length;
}
return concatBytes$1(...E);
};
return (e, T) => {
M(), P(e);
let E;
for (; !(E = T(F()));) P();
return M(), E;
};
}
function _validateObject(e, T, E = {}) {
if (!e || typeof e != "object") throw Error("expected valid options object");
function D(T, E, D) {
let O = e[T];
if (D && O === void 0) return;
let k = typeof O;
if (k !== E || O === null) throw Error(`param "${T}" is invalid: expected ${E}, got ${k}`);
}
Object.entries(T).forEach(([e, T]) => D(e, T, !1)), Object.entries(E).forEach(([e, T]) => D(e, T, !0));
}
function memoized(e) {
let T = /* @__PURE__ */ new WeakMap();
return (E, ...D) => {
let O = T.get(E);
if (O !== void 0) return O;
let k = e(E, ...D);
return T.set(E, k), k;
};
}
const bytesToHex$2 = bytesToHex$1, concatBytes = concatBytes$1, numberToHexUnpadded$1 = numberToHexUnpadded, hexToNumber = hexToNumber$1, numberToBytesBE$1 = numberToBytesBE;
var HMAC$1 = class extends Hash$2 {
constructor(e, T) {
super(), this.finished = !1, this.destroyed = !1, ahash(e);
let E = toBytes$2(T);
if (this.iHash = e.create(), typeof this.iHash.update != "function") throw Error("Expected instance of class which extends utils.Hash");
this.blockLen = this.iHash.blockLen, this.outputLen = this.iHash.outputLen;
let D = this.blockLen, O = new Uint8Array(D);
O.set(E.length > D ? e.create().update(E).digest() : E);
for (let e = 0; e < O.length; e++) O[e] ^= 54;
this.iHash.update(O), this.oHash = e.create();
for (let e = 0; e < O.length; e++) O[e] ^= 106;
this.oHash.update(O), clean$1(O);
}
update(e) {
return aexists$1(this), this.iHash.update(e), this;
}
digestInto(e) {
aexists$1(this), abytes$1(e, this.outputLen), this.finished = !0, this.iHash.digestInto(e), this.oHash.update(e), this.oHash.digestInto(e), this.destroy();
}
digest() {
let e = new Uint8Array(this.oHash.outputLen);
return this.digestInto(e), e;
}
_cloneInto(e) {
e ||= Object.create(Object.getPrototypeOf(this), {});
let { oHash: T, iHash: E, finished: D, destroyed: O, blockLen: k, outputLen: A } = this;
return e = e, e.finished = D, e.destroyed = O, e.blockLen = k, e.outputLen = A, e.oHash = T._cloneInto(e.oHash), e.iHash = E._cloneInto(e.iHash), e;
}
clone() {
return this._cloneInto();
}
destroy() {
this.destroyed = !0, this.oHash.destroy(), this.iHash.destroy();
}
};
const hmac$1 = (e, T, E) => new HMAC$1(e, T).update(E).digest();
hmac$1.create = (e, T) => new HMAC$1(e, T);
var _0n$2 = BigInt(0), _1n$2 = BigInt(1), _2n$1 = /* @__PURE__ */ BigInt(2), _3n$1 = /* @__PURE__ */ BigInt(3), _4n$1 = /* @__PURE__ */ BigInt(4), _5n = /* @__PURE__ */ BigInt(5), _7n = /* @__PURE__ */ BigInt(7), _8n = /* @__PURE__ */ BigInt(8), _9n = /* @__PURE__ */ BigInt(9), _16n = /* @__PURE__ */ BigInt(16);
function mod(e, T) {
let E = e % T;
return E >= _0n$2 ? E : T + E;
}
function invert(e, T) {
if (e === _0n$2) throw Error("invert: expected non-zero number");
if (T <= _0n$2) throw Error("invert: expected positive modulus, got " + T);
let E = mod(e, T), D = T, O = _0n$2, k = _1n$2, A = _1n$2, j = _0n$2;
for (; E !== _0n$2;) {
let e = D / E, T = D % E, M = O - A * e, N = k - j * e;
D = E, E = T, O = A, k = j, A = M, j = N;
}
if (D !== _1n$2) throw Error("invert: does not exist");
return mod(O, T);
}
function assertIsSquare(e, T, E) {
if (!e.eql(e.sqr(T), E)) throw Error("Cannot find square root");
}
function sqrt3mod4(e, T) {
let E = (e.ORDER + _1n$2) / _4n$1, D = e.pow(T, E);
return assertIsSquare(e, D, T), D;
}
function sqrt5mod8(e, T) {
let E = (e.ORDER - _5n) / _8n, D = e.mul(T, _2n$1), O = e.pow(D, E), k = e.mul(T, O), A = e.mul(e.mul(k, _2n$1), O), j = e.mul(k, e.sub(A, e.ONE));
return assertIsSquare(e, j, T), j;
}
function sqrt9mod16(e) {
let T = Field$1(e), E = tonelliShanks(e), D = E(T, T.neg(T.ONE)), O = E(T, D), k = E(T, T.neg(D)), A = (e + _7n) / _16n;
return (e, T) => {
let E = e.pow(T, A), j = e.mul(E, D), M = e.mul(E, O), N = e.mul(E, k), P = e.eql(e.sqr(j), T), F = e.eql(e.sqr(M), T);
E = e.cmov(E, j, P), j = e.cmov(N, M, F);
let I = e.eql(e.sqr(j), T), L = e.cmov(E, j, I);
return assertIsSquare(e, L, T), L;
};
}
function tonelliShanks(e) {
if (e < _3n$1) throw Error("sqrt is not defined for small field");
let T = e - _1n$2, E = 0;
for (; T % _2n$1 === _0n$2;) T /= _2n$1, E++;
let D = _2n$1, O = Field$1(e);
for (; FpLegendre(O, D) === 1;) if (D++ > 1e3) throw Error("Cannot find square root: probably non-prime P");
if (E === 1) return sqrt3mod4;
let k = O.pow(D, T), A = (T + _1n$2) / _2n$1;
return function(e, D) {
if (e.is0(D)) return D;
if (FpLegendre(e, D) !== 1) throw Error("Cannot find square root");
let O = E, j = e.mul(e.ONE, k), M = e.pow(D, T), N = e.pow(D, A);
for (; !e.eql(M, e.ONE);) {
if (e.is0(M)) return e.ZERO;
let T = 1, E = e.sqr(M);
for (; !e.eql(E, e.ONE);) if (T++, E = e.sqr(E), T === O) throw Error("Cannot find square root");
let D = _1n$2 << BigInt(O - T - 1), k = e.pow(j, D);
O = T, j = e.sqr(k), M = e.mul(M, j), N = e.mul(N, k);
}
return N;
};
}
function FpSqrt(e) {
return e % _4n$1 === _3n$1 ? sqrt3mod4 : e % _8n === _5n ? sqrt5mod8 : e % _16n === _9n ? sqrt9mod16(e) : tonelliShanks(e);
}
var FIELD_FIELDS = [
"create",
"isValid",
"is0",
"neg",
"inv",
"sqrt",
"sqr",
"eql",
"add",
"sub",
"mul",
"pow",
"div",
"addN",
"subN",
"mulN",
"sqrN"
];
function validateField(e) {
return _validateObject(e, FIELD_FIELDS.reduce((e, T) => (e[T] = "function", e), {
ORDER: "bigint",
MASK: "bigint",
BYTES: "number",
BITS: "number"
})), e;
}
function FpPow(e, T, E) {
if (E < _0n$2) throw Error("invalid exponent, negatives unsupported");
if (E === _0n$2) return e.ONE;
if (E === _1n$2) return T;
let D = e.ONE, O = T;
for (; E > _0n$2;) E & _1n$2 && (D = e.mul(D, O)), O = e.sqr(O), E >>= _1n$2;
return D;
}
function FpInvertBatch(e, T, E = !1) {
let D = Array(T.length).fill(E ? e.ZERO : void 0), O = T.reduce((T, E, O) => e.is0(E) ? T : (D[O] = T, e.mul(T, E)), e.ONE), k = e.inv(O);
return T.reduceRight((T, E, O) => e.is0(E) ? T : (D[O] = e.mul(T, D[O]), e.mul(T, E)), k), D;
}
function FpLegendre(e, T) {
let E = (e.ORDER - _1n$2) / _2n$1, D = e.pow(T, E), O = e.eql(D, e.ONE), k = e.eql(D, e.ZERO), A = e.eql(D, e.neg(e.ONE));
if (!O && !k && !A) throw Error("invalid Legendre symbol result");
return O ? 1 : k ? 0 : -1;
}
function nLength(e, T) {
T !== void 0 && anumber(T);
let E = T === void 0 ? e.toString(2).length : T;
return {
nBitLength: E,
nByteLength: Math.ceil(E / 8)
};
}
function Field$1(e, T, E = !1, D = {}) {
if (e <= _0n$2) throw Error("invalid field: expected ORDER > 0, got " + e);
let O, k, A = !1, j;
if (typeof T == "object" && T) {
if (D.sqrt || E) throw Error("cannot specify opts in two arguments");
let e = T;
e.BITS && (O = e.BITS), e.sqrt && (k = e.sqrt), typeof e.isLE == "boolean" && (E = e.isLE), typeof e.modFromBytes == "boolean" && (A = e.modFromBytes), j = e.allowedLengths;
} else typeof T == "number" && (O = T), D.sqrt && (k = D.sqrt);
let { nBitLength: M, nByteLength: N } = nLength(e, O);
if (N > 2048) throw Error("invalid field: expected ORDER of <= 2048 bytes");
let P, F = Object.freeze({
ORDER: e,
isLE: E,
BITS: M,
BYTES: N,
MASK: bitMask(M),
ZERO: _0n$2,
ONE: _1n$2,
allowedLengths: j,
create: (T) => mod(T, e),
isValid: (T) => {
if (typeof T != "bigint") throw Error("invalid field element: expected bigint, got " + typeof T);
return _0n$2 <= T && T < e;
},
is0: (e) => e === _0n$2,
isValidNot0: (e) => !F.is0(e) && F.isValid(e),
isOdd: (e) => (e & _1n$2) === _1n$2,
neg: (T) => mod(-T, e),
eql: (e, T) => e === T,
sqr: (T) => mod(T * T, e),
add: (T, E) => mod(T + E, e),
sub: (T, E) => mod(T - E, e),
mul: (T, E) => mod(T * E, e),
pow: (e, T) => FpPow(F, e, T),
div: (T, E) => mod(T * invert(E, e), e),
sqrN: (e) => e * e,
addN: (e, T) => e + T,
subN: (e, T) => e - T,
mulN: (e, T) => e * T,
inv: (T) => invert(T, e),
sqrt: k || ((T) => (P ||= FpSqrt(e), P(F, T))),
toBytes: (e) => E ? numberToBytesLE(e, N) : numberToBytesBE(e, N),
fromBytes: (T, D = !0) => {
if (j) {
if (!j.includes(T.length) || T.length > N) throw Error("Field.fromBytes: expected " + j + " bytes, got " + T.length);
let e = new Uint8Array(N);
e.set(T, E ? 0 : e.length - T.length), T = e;
}
if (T.length !== N) throw Error("Field.fromBytes: expected " + N + " bytes, got " + T.length);
let O = E ? bytesToNumberLE(T) : bytesToNumberBE(T);
if (A && (O = mod(O, e)), !D && !F.isValid(O)) throw Error("invalid field element: outside of range 0..ORDER");
return O;
},
invertBatch: (e) => FpInvertBatch(F, e),
cmov: (e, T, E) => E ? T : e
});
return Object.freeze(F);
}
function getFieldBytesLength(e) {
if (typeof e != "bigint") throw Error("field order must be bigint");
let T = e.toString(2).length;
return Math.ceil(T / 8);
}
function getMinHashLength(e) {
let T = getFieldBytesLength(e);
return T + Math.ceil(T / 2);
}
function mapHashToField(e, T, E = !1) {
let D = e.length, O = getFieldBytesLength(T), k = getMinHashLength(T);
if (D < 16 || D < k || D > 1024) throw Error("expected " + k + "-1024 bytes of input, got " + D);
let A = mod(E ? bytesToNumberLE(e) : bytesToNumberBE(e), T - _1n$2) + _1n$2;
return E ? numberToBytesLE(A, O) : numberToBytesBE(A, O);
}
var _0n$1 = BigInt(0), _1n$1 = BigInt(1);
function negateCt(e, T) {
let E = T.negate();
return e ? E : T;
}
function normalizeZ(e, T) {
let E = FpInvertBatch(e.Fp, T.map((e) => e.Z));
return T.map((T, D) => e.fromAffine(T.toAffine(E[D])));
}
function validateW(e, T) {
if (!Number.isSafeInteger(e) || e <= 0 || e > T) throw Error("invalid window size, expected [1.." + T + "], got W=" + e);
}
function calcWOpts(e, T) {
validateW(e, T);
let E = Math.ceil(T / e) + 1, D = 2 ** (e - 1), O = 2 ** e;
return {
windows: E,
windowSize: D,
mask: bitMask(e),
maxNumber: O,
shiftBy: BigInt(e)
};
}
function calcOffsets(e, T, E) {
let { windowSize: D, mask: O, maxNumber: k, shiftBy: A } = E, j = Number(e & O), M = e >> A;
j > D && (j -= k, M += _1n$1);
let N = T * D, P = N + Math.abs(j) - 1, F = j === 0, I = j < 0, L = T % 2 != 0;
return {
nextN: M,
offset: P,
isZero: F,
isNeg: I,
isNegF: L,
offsetF: N
};
}
function validateMSMPoints(e, T) {
if (!Array.isArray(e)) throw Error("array expected");
e.forEach((e, E) => {
if (!(e instanceof T)) throw Error("invalid point at index " + E);
});
}
function validateMSMScalars(e, T) {
if (!Array.isArray(e)) throw Error("array of scalars expected");
e.forEach((e, E) => {
if (!T.isValid(e)) throw Error("invalid scalar at index " + E);
});
}
var pointPrecomputes = /* @__PURE__ */ new WeakMap(), pointWindowSizes = /* @__PURE__ */ new WeakMap();
function getW(e) {
return pointWindowSizes.get(e) || 1;
}
function assert0(e) {
if (e !== _0n$1) throw Error("invalid wNAF");
}
var wNAF = class {
constructor(e, T) {
this.BASE = e.BASE, this.ZERO = e.ZERO, this.Fn = e.Fn, this.bits = T;
}
_unsafeLadder(e, T, E = this.ZERO) {
let D = e;
for (; T > _0n$1;) T & _1n$1 && (E = E.add(D)), D = D.double(), T >>= _1n$1;
return E;
}
precomputeWindow(e, T) {
let { windows: E, windowSize: D } = calcWOpts(T, this.bits), O = [], k = e, A = k;
for (let e = 0; e < E; e++) {
A = k, O.push(A);
for (let e = 1; e < D; e++) A = A.add(k), O.push(A);
k = A.double();
}
return O;
}
wNAF(e, T, E) {
if (!this.Fn.isValid(E)) throw Error("invalid scalar");
let D = this.ZERO, O = this.BASE, k = calcWOpts(e, this.bits);
for (let e = 0; e < k.windows; e++) {
let { nextN: A, offset: j, isZero: M, isNeg: N, isNegF: P, offsetF: F } = calcOffsets(E, e, k);
E = A, M ? O = O.add(negateCt(P, T[F])) : D = D.add(negateCt(N, T[j]));
}
return assert0(E), {
p: D,
f: O
};
}
wNAFUnsafe(e, T, E, D = this.ZERO) {
let O = calcWOpts(e, this.bits);
for (let e = 0; e < O.windows && E !== _0n$1; e++) {
let { nextN: k, offset: A, isZero: j, isNeg: M } = calcOffsets(E, e, O);
if (E = k, !j) {
let e = T[A];
D = D.add(M ? e.negate() : e);
}
}
return assert0(E), D;
}
getPrecomputes(e, T, E) {
let D = pointPrecomputes.get(T);
return D || (D = this.precomputeWindow(T, e), e !== 1 && (typeof E == "function" && (D = E(D)), pointPrecomputes.set(T, D))), D;
}
cached(e, T, E) {
let D = getW(e);
return this.wNAF(D, this.getPrecomputes(D, e, E), T);
}
unsafe(e, T, E, D) {
let O = getW(e);
return O === 1 ? this._unsafeLadder(e, T, D) : this.wNAFUnsafe(O, this.getPrecomputes(O, e, E), T, D);
}
createCache(e, T) {
validateW(T, this.bits), pointWindowSizes.set(e, T), pointPrecomputes.delete(e);
}
hasCache(e) {
return getW(e) !== 1;
}
};
function mulEndoUnsafe(e, T, E, D) {
let O = T, k = e.ZERO, A = e.ZERO;
for (; E > _0n$1 || D > _0n$1;) E & _1n$1 && (k = k.add(O)), D & _1n$1 && (A = A.add(O)), O = O.double(), E >>= _1n$1, D >>= _1n$1;
return {
p1: k,
p2: A
};
}
function pippenger(e, T, E, D) {
validateMSMPoints(E, e), validateMSMScalars(D, T);
let O = E.length, k = D.length;
if (O !== k) throw Error("arrays of points and scalars must have equal length");
let A = e.ZERO, j = bitLen(BigInt(O)), M = 1;
j > 12 ? M = j - 3 : j > 4 ? M = j - 2 : j > 0 && (M = 2);
let N = bitMask(M), P = Array(Number(N) + 1).fill(A), F = Math.floor((T.BITS - 1) / M) * M, I = A;
for (let e = F; e >= 0; e -= M) {
P.fill(A);
for (let T = 0; T < k; T++) {
let O = D[T], k = Number(O >> BigInt(e) & N);
P[k] = P[k].add(E[T]);
}
let T = A;
for (let e = P.length - 1, E = A; e > 0; e--) E = E.add(P[e]), T = T.add(E);
if (I = I.add(T), e !== 0) for (let e = 0; e < M; e++) I = I.double();
}
return I;
}
function createField(e, T, E) {
if (T) {
if (T.ORDER !== e) throw Error("Field.ORDER must match order: Fp == p, Fn == n");
return validateField(T), T;
} else return Field$1(e, { isLE: E });
}
function _createCurveFields(e, T, E = {}, D) {
if (D === void 0 && (D = e === "edwards"), !T || typeof T != "object") throw Error(`expected valid ${e} CURVE object`);
for (let e of [
"p",
"n",
"h"
]) {
let E = T[e];
if (!(typeof E == "bigint" && E > _0n$1)) throw Error(`CURVE.${e} must be positive bigint`);
}
let O = createField(T.p, E.Fp, D), k = createField(T.n, E.Fn, D), A = [
"Gx",
"Gy",
"a",
e === "weierstrass" ? "b" : "d"
];
for (let e of A) if (!O.isValid(T[e])) throw Error(`CURVE.${e} must be valid field element of CURVE.Fp`);
return T = Object.freeze(Object.assign({}, T)), {
CURVE: T,
Fp: O,
Fn: k
};
}
var divNearest = (e, T) => (e + (e >= 0 ? T : -T) / _2n) / T;
function _splitEndoScalar(e, T, E) {
let [[D, O], [k, A]] = T, j = divNearest(A * e, E), M = divNearest(-O * e, E), N = e - j * D - M * k, P = -j * O - M * A, F = N < _0n, I = P < _0n;
F && (N = -N), I && (P = -P);
let L = bitMask(Math.ceil(bitLen(E) / 2)) + _1n;
if (N < _0n || N >= L || P < _0n || P >= L) throw Error("splitScalar (endomorphism): failed, k=" + e);
return {
k1neg: F,
k1: N,
k2neg: I,
k2: P
};
}
function validateSigFormat(e) {
if (![
"compact",
"recovered",
"der"
].includes(e)) throw Error("Signature format must be \"compact\", \"recovered\", or \"der\"");
return e;
}
function validateSigOpts(e, T) {
let E = {};
for (let D of Object.keys(T)) E[D] = e[D] === void 0 ? T[D] : e[D];
return _abool2(E.lowS, "lowS"), _abool2(E.prehash, "prehash"), E.format !== void 0 && validateSigFormat(E.format), E;
}
const DER = {
Err: class extends Error {
constructor(e = "") {
super(e);
}
},
_tlv: {
encode: (e, T) => {
let { Err: E } = DER;
if (e < 0 || e > 256) throw new E("tlv.encode: wrong tag");
if (T.length & 1) throw new E("tlv.encode: unpadded data");
let D = T.length / 2, O = numberToHexUnpadded(D);
if (O.length / 2 & 128) throw new E("tlv.encode: long form length too big");
let k = D > 127 ? numberToHexUnpadded(O.length / 2 | 128) : "";
return numberToHexUnpadded(e) + k + O + T;
},
decode(e, T) {
let { Err: E } = DER, D = 0;
if (e < 0 || e > 256) throw new E("tlv.encode: wrong tag");
if (T.length < 2 || T[D++] !== e) throw new E("tlv.decode: wrong tlv");
let O = T[D++], k = !!(O & 128), A = 0;
if (!k) A = O;
else {
let e = O & 127;
if (!e) throw new E("tlv.decode(long): indefinite length not supported");
if (e > 4) throw new E("tlv.decode(long): byte length is too big");
let k = T.subarray(D, D + e);
if (k.length !== e) throw new E("tlv.decode: length bytes not complete");
if (k[0] === 0) throw new E("tlv.decode(long): zero leftmost byte");
for (let e of k) A = A << 8 | e;
if (D += e, A < 128) throw new E("tlv.decode(long): not minimal encoding");
}
let j = T.subarray(D, D + A);
if (j.length !== A) throw new E("tlv.decode: wrong value length");
return {
v: j,
l: T.subarray(D + A)
};
}
},
_int: {
encode(e) {
let { Err: T } = DER;
if (e < _0n) throw new T("integer: negative integers are not allowed");
let E = numberToHexUnpadded(e);
if (Number.parseInt(E[0], 16) & 8 && (E = "00" + E), E.length & 1) throw new T("unexpected DER parsing assertion: unpadded hex");
return E;
},
decode(e) {
let { Err: T } = DER;
if (e[0] & 128) throw new T("invalid signature integer: negative");
if (e[0] === 0 && !(e[1] & 128)) throw new T("invalid signature integer: unnecessary leading zero");
return bytesToNumberBE(e);
}
},
toSig(e) {
let { Err: T, _int: E, _tlv: D } = DER, O = ensureBytes("signature", e), { v: k, l: A } = D.decode(48, O);
if (A.length) throw new T("invalid signature: left bytes after parsing");
let { v: j, l: M } = D.decode(2, k), { v: N, l: P } = D.decode(2, M);
if (P.length) throw new T("invalid signature: left bytes after parsing");
return {
r: E.decode(j),
s: E.decode(N)
};
},
hexFromSig(e) {
let { _tlv: T, _int: E } = DER, D = T.encode(2, E.encode(e.r)) + T.encode(2, E.encode(e.s));
return T.encode(48, D);
}
};
var _0n = BigInt(0), _1n = BigInt(1), _2n = BigInt(2), _3n = BigInt(3), _4n = BigInt(4);
function _normFnElement(e, T) {
let { BYTES: E } = e, D;
if (typeof T == "bigint") D = T;
else {
let O = ensureBytes("private key", T);
try {
D = e.fromBytes(O);
} catch {
throw Error(`invalid private key: expected ui8a of size ${E}, got ${typeof T}`);
}
}
if (!e.isValidNot0(D)) throw Error("invalid private key: out of range [1..N-1]");
return D;
}
function weierstrassN(e, T = {}) {
let E = _createCurveFields("weierstrass", e, T), { Fp: D, Fn: O } = E, k = E.CURVE, { h: A, n: j } = k;
_validateObject(T, {}, {
allowInfinityPoint: "boolean",
clearCofactor: "function",
isTorsionFree: "function",
fromBytes: "function",
toBytes: "function",
endo: "object",
wrapPrivateKey: "boolean"
});
let { endo: M } = T;
if (M && (!D.is0(k.a) || typeof M.beta != "bigint" || !Array.isArray(M.basises))) throw Error("invalid endo: expected \"beta\": bigint and \"basises\": array");
let N = getWLengths(D, O);
function P() {
if (!D.isOdd) throw Error("compression is not supported: Field does not have .isOdd()");
}
function F(e, T, E) {
let { x: O, y: k } = T.toAffine(), A = D.toBytes(O);
return _abool2(E, "isCompressed"), E ? (P(), concatBytes$1(pprefix(!D.isOdd(k)), A)) : concatBytes$1(Uint8Array.of(4), A, D.toBytes(k));
}
function I(e) {
_abytes2(e, void 0, "Point");
let { publicKey: T, publicKeyUncompressed: E } = N, O = e.length, k = e[0], A = e.subarray(1);
if (O === T && (k === 2 || k === 3)) {
let e = D.fromBytes(A);
if (!D.isValid(e)) throw Error("bad point: is not on curve, wrong x");
let T = z(e), E;
try {
E = D.sqrt(T);
} catch (e) {
let T = e instanceof Error ? ": " + e.message : "";
throw Error("bad point: is not on curve, sqrt error" + T);
}
P();
let O = D.isOdd(E);
return (k & 1) == 1 !== O && (E = D.neg(E)), {
x: e,
y: E
};
} else if (O === E && k === 4) {
let e = D.BYTES, T = D.fromBytes(A.subarray(0, e)), E = D.fromBytes(A.subarray(e, e * 2));
if (!B(T, E)) throw Error("bad point: is not on curve");
return {
x: T,
y: E
};
} else throw Error(`bad point: got length ${O}, expected compressed=${T} or uncompressed=${E}`);
}
let L = T.toBytes || F, R = T.fromBytes || I;
function z(e) {
let T = D.sqr(e), E = D.mul(T, e);
return D.add(D.add(E, D.mul(e, k.a)), k.b);
}
function B(e, T) {
let E = D.sqr(T), O = z(e);
return D.eql(E, O);
}
if (!B(k.Gx, k.Gy)) throw Error("bad curve params: generator point");
let V = D.mul(D.pow(k.a, _3n), _4n), H = D.mul(D.sqr(k.b), BigInt(27));
if (D.is0(D.add(V, H))) throw Error("bad curve params: a or b");
function U(e, T, E = !1) {
if (!D.isValid(T) || E && D.is0(T)) throw Error(`bad point coordinate ${e}`);
return T;
}
function W(e) {
if (!(e instanceof Y)) throw Error("ProjectivePoint expected");
}
function G(e) {
if (!M || !M.basises) throw Error("no endo");
return _splitEndoScalar(e, M.basises, O.ORDER);
}
let K = memoized((e, T) => {
let { X: E, Y: O, Z: k } = e;
if (D.eql(k, D.ONE)) return {
x: E,
y: O
};
let A = e.is0();
T ??= A ? D.ONE : D.inv(k);
let j = D.mul(E, T), M = D.mul(O, T), N = D.mul(k, T);
if (A) return {
x: D.ZERO,
y: D.ZERO
};
if (!D.eql(N, D.ONE)) throw Error("invZ was invalid");
return {
x: j,
y: M
};
}), q = memoized((e) => {
if (e.is0()) {
if (T.allowInfinityPoint && !D.is0(e.Y)) return;
throw Error("bad point: ZERO");
}
let { x: E, y: O } = e.toAffine();
if (!D.isValid(E) || !D.isValid(O)) throw Error("bad point: x or y not field elements");
if (!B(E, O)) throw Error("bad point: equation left != right");
if (!e.isTorsionFree()) throw Error("bad point: not in prime-order subgroup");
return !0;
});
function J(e, T, E, O, k) {
return E = new Y(D.mul(E.X, e), E.Y, E.Z), T = negateCt(O, T), E = negateCt(k, E), T.add(E);
}
class Y {
constructor(e, T, E) {
this.X = U("x", e), this.Y = U("y", T, !0), this.Z = U("z", E), Object.freeze(this);
}
static CURVE() {
return k;
}
static fromAffine(e) {
let { x: T, y: E } = e || {};
if (!e || !D.isValid(T) || !D.isValid(E)) throw Error("invalid affine point");
if (e instanceof Y) throw Error("projective point not allowed");
return D.is0(T) && D.is0(E) ? Y.ZERO : new Y(T, E, D.ONE);
}
static fromBytes(e) {
let T = Y.fromAffine(R(_abytes2(e, void 0, "point")));
return T.assertValidity(), T;
}
static fromHex(e) {
return Y.fromBytes(ensureBytes("pointHex", e));
}
get x() {
return this.toAffine().x;
}
get y() {
return this.toAffine().y;
}
precompute(e = 8, T = !0) {
return Z.createCache(this, e), T || this.multiply(_3n), this;
}
assertValidity() {
q(this);
}
hasEvenY() {
let { y: e } = this.toAffine();
if (!D.isOdd) throw Error("Field doesn't support isOdd");
return !D.isOdd(e);
}
equals(e) {
W(e);
let { X: T, Y: E, Z: O } = this, { X: k, Y: A, Z: j } = e, M = D.eql(D.mul(T, j), D.mul(k, O)), N = D.eql(D.mul(E, j), D.mul(A, O));
return M && N;
}
negate() {
return new Y(this.X, D.neg(this.Y), this.Z);
}
double() {
let { a: e, b: T } = k, E = D.mul(T, _3n), { X: O, Y: A, Z: j } = this, M = D.ZERO, N = D.ZERO, P = D.ZERO, F = D.mul(O, O), I = D.mul(A, A), L = D.mul(j, j), R = D.mul(O, A);
return R = D.add(R, R), P = D.mul(O, j), P = D.add(P, P), M = D.mul(e, P), N = D.mul(E, L), N = D.add(M, N), M = D.sub(I, N), N = D.add(I, N), N = D.mul(M, N), M = D.mul(R, M), P = D.mul(E, P), L = D.mul(e, L), R = D.sub(F, L), R = D.mul(e, R), R = D.add(R, P), P = D.add(F, F), F = D.add(P, F), F = D.add(F, L), F = D.mul(F, R), N = D.add(N, F), L = D.mul(A, j), L = D.add(L, L), F = D.mul(L, R), M = D.sub(M, F), P = D.mul(L, I), P = D.add(P, P), P = D.add(P, P), new Y(M, N, P);
}
add(e) {
W(e);
let { X: T, Y: E, Z: O } = this, { X: A, Y: j, Z: M } = e, N = D.ZERO, P = D.ZERO, F = D.ZERO, I = k.a, L = D.mul(k.b, _3n), R = D.mul(T, A), z = D.mul(E, j), B = D.mul(O, M), V = D.add(T, E), H = D.add(A, j);
V = D.mul(V, H), H = D.add(R, z), V = D.sub(V, H), H = D.add(T, O);
let U = D.add(A, M);
return H = D.mul(H, U), U = D.add(R, B), H = D.sub(H, U), U = D.add(E, O), N = D.add(j, M), U = D.mul(U, N), N = D.add(z, B), U = D.sub(U, N), F = D.mul(I, H), N = D.mul(L, B), F = D.add(N, F), N = D.sub(z, F), F = D.add(z, F), P = D.mul(N, F), z = D.add(R, R), z = D.add(z, R), B = D.mul(I, B), H = D.mul(L, H), z = D.add(z, B), B = D.sub(R, B), B = D.mul(I, B), H = D.add(H, B), R = D.mul(z, H), P = D.add(P, R), R = D.mul(U, H), N = D.mul(V, N), N = D.sub(N, R), R = D.mul(V, z), F = D.mul(U, F), F = D.add(F, R), new Y(N, P, F);
}
subtract(e) {
return this.add(e.negate());
}
is0() {
return this.equals(Y.ZERO);
}
multiply(e) {
let { endo: E } = T;
if (!O.isValidNot0(e)) throw Error("invalid scalar: out of range");
let D, k, A = (e) => Z.cached(this, e, (e) => normalizeZ(Y, e));
if (E) {
let { k1neg: T, k1: O, k2neg: j, k2: M } = G(e), { p: N, f: P } = A(O), { p: F, f: I } = A(M);
k = P.add(I), D = J(E.beta, N, F, T, j);
} else {
let { p: T, f: E } = A(e);
D = T, k = E;
}
return normalizeZ(Y, [D, k])[0];
}
multiplyUnsafe(e) {
let { endo: E } = T, D = this;
if (!O.isValid(e)) throw Error("invalid scalar: out of range");
if (e === _0n || D.is0()) return Y.ZERO;
if (e === _1n) return D;
if (Z.hasCache(this)) return this.multiply(e);
if (E) {
let { k1neg: T, k1: O, k2neg: k, k2: A } = G(e), { p1: j, p2: M } = mulEndoUnsafe(Y, D, O, A);
return J(E.beta, j, M, T, k);
} else return Z.unsafe(D, e);
}
multiplyAndAddUnsafe(e, T, E) {
let D = this.multiplyUnsafe(T).add(e.multiplyUnsafe(E));
return D.is0() ? void 0 : D;
}
toAffine(e) {
return K(this, e);
}
isTorsionFree() {
let { isTorsionFree: e } = T;
return A === _1n ? !0 : e ? e(Y, this) : Z.unsafe(this, j).is0();
}
clearCofactor() {
let { clearCofactor: e } = T;
return A === _1n ? this : e ? e(Y, this) : this.multiplyUnsafe(A);
}
isSmallOrder() {
return this.multiplyUnsafe(A).is0();
}
toBytes(e = !0) {
return _abool2(e, "isCompressed"), this.assertValidity(), L(Y, this, e);
}
toHex(e = !0) {
return bytesToHex$1(this.toBytes(e));
}
toString() {
return `<Point ${this.is0() ? "ZERO" : this.toHex()}>`;
}
get px() {
return this.X;
}
get py() {
return this.X;
}
get pz() {
return this.Z;
}
toRawBytes(e = !0) {
return this.toBytes(e);
}
_setWindowSize(e) {
this.precompute(e);
}
static normalizeZ(e) {
return normalizeZ(Y, e);
}
static msm(e, T) {
return pippenger(Y, O, e, T);
}
static fromPrivateKey(e) {
return Y.BASE.multiply(_normFnElement(O, e));
}
}
Y.BASE = new Y(k.Gx, k.Gy, D.ONE), Y.ZERO = new Y(D.ZERO, D.ONE, D.ZERO), Y.Fp = D, Y.Fn = O;
let X = O.BITS, Z = new wNAF(Y, T.endo ? Math.ceil(X / 2) : X);
return Y.BASE.precompute(8), Y;
}
function pprefix(e) {
return Uint8Array.of(e ? 2 : 3);
}
function getWLengths(e, T) {
return {
secretKey: T.BYTES,
publicKey: 1 + e.BYTES,
publicKeyUncompressed: 1 + 2 * e.BYTES,
publicKeyHasPrefix: !0,
signature: 2 * T.BYTES
};
}
function ecdh(e, T = {}) {
let { Fn: E } = e, D = T.randomBytes || randomBytes$1, O = Object.assign(getWLengths(e.Fp, E), { seed: getMinHashLength(E.ORDER) });
function k(e) {
try {
return !!_normFnElement(E, e);
} catch {
return !1;
}
}
function A(T, E) {
let { publicKey: D, publicKeyUncompressed: k } = O;
try {
let O = T.length;
return E === !0 && O !== D || E === !1 && O !== k ? !1 : !!e.fromBytes(T);
} catch {
return !1;
}
}
function j(e = D(O.seed)) {
return mapHashToField(_abytes2(e, O.seed, "seed"), E.ORDER);
}
function M(T, D = !0) {
return e.BASE.multiply(_normFnElement(E, T)).toBytes(D);
}
function N(e) {
let T = j(e);
return {
secretKey: T,
publicKey: M(T)
};
}
function P(T) {
if (typeof T == "bigint") return !1;
if (T instanceof e) return !0;
let { secretKey: D, publicKey: k, publicKeyUncompressed: A } = O;
if (E.allowedLengths || D === k) return;
let j = ensureBytes("key", T).length;
return j === k || j === A;
}
function F(T, D, O = !0) {
if (P(T) === !0) throw Error("first arg must be private key");
if (P(D) === !1) throw Error("second arg must be public key");
let k = _normFnElement(E, T);
return e.fromHex(D).multiply(k).toBytes(O);
}
let I = {
isValidSecretKey: k,
isValidPublicKey: A,
randomSecretKey: j,
isValidPrivateKey: k,
randomPrivateKey: j,
normPrivateKeyToScalar: (e) => _normFnElement(E, e),
precompute(T = 8, E = e.BASE) {
return E.precompute(T, !1);
}
};
return Object.freeze({
getPublicKey: M,
getSharedSecret: F,
keygen: N,
Point: e,
utils: I,
lengths: O
});
}
function ecdsa(e, T, E = {}) {
ahash(T), _validateObject(E, {}, {
hmac: "function",
lowS: "boolean",
randomBytes: "function",
bits2int: "function",
bits2int_modN: "function"
});
let D = E.randomBytes || randomBytes$1, O = E.hmac || ((e, ...E) => hmac$1(T, e, concatBytes$1(...E))), { Fp: k, Fn: A } = e, { ORDER: j, BITS: M } = A, { keygen: N, getPublicKey: P, getSharedSecret: F, utils: I, lengths: L } = ecdh(e, E), R = {
prehash: !1,
lowS: typeof E.lowS == "boolean" ? E.lowS : !1,
format: void 0,
extraEntropy: !1
}, z = "compact";
function B(e) {
return e > j >> _1n;
}
function V(e, T) {
if (!A.isValidNot0(T)) throw Error(`invalid signature ${e}: out of range 1..Point.Fn.ORDER`);
return T;
}
function H(e, T) {
validateSigFormat(T);
let E = L.signature;
return _abytes2(e, T === "compact" ? E : T === "recovered" ? E + 1 : void 0, `${T} signature`);
}
class U {
constructor(e, T, E) {
this.r = V("r", e), this.s = V("s", T), E != null && (this.recovery = E), Object.freeze(this);
}
static fromBytes(e, T = z) {
H(e, T);
let E;
if (T === "der") {
let { r: T, s: E } = DER.toSig(_abytes2(e));
return new U(T, E);
}
T === "recovered" && (E = e[0], T = "compact", e = e.subarray(1));
let D = A.BYTES, O = e.subarray(0, D), k = e.subarray(D, D * 2);
return new U(A.fromBytes(O), A.fromBytes(k), E);
}
static fromHex(e, T) {
return this.fromBytes(hexToBytes(e), T);
}
addRecoveryBit(e) {
return new U(this.r, this.s, e);
}
recoverPublicKey(T) {
let E = k.ORDER, { r: D, s: O, recovery: M } = this;
if (M == null || ![
0,
1,
2,
3
].includes(M)) throw Error("recovery id invalid");
if (j * _2n < E && M > 1) throw Error("recovery id is ambiguous for h>1 curve");
let N = M === 2 || M === 3 ? D + j : D;
if (!k.isValid(N)) throw Error("recovery id 2 or 3 invalid");
let P = k.toBytes(N), F = e.fromBytes(concatBytes$1(pprefix((M & 1) == 0), P)), I = A.inv(N), L = G(ensureBytes("msgHash", T)), R = A.create(-L * I), z = A.create(O * I), B = e.BASE.multiplyUnsafe(R).add(F.multiplyUnsafe(z));
if (B.is0()) throw Error("point at infinify");
return B.assertValidity(), B;
}
hasHighS() {
return B(this.s);
}
toBytes(e = z) {
if (validateSigFormat(e), e === "der") return hexToBytes(DER.hexFromSig(this));
let T = A.toBytes(this.r), E = A.toBytes(this.s);
if (e === "recovered") {
if (this.recovery == null) throw Error("recovery bit must be present");
return concatBytes$1(Uint8Array.of(this.recovery), T, E);
}
return concatBytes$1(T, E);
}
toHex(e) {
return bytesToHex$1(this.toBytes(e));
}
assertValidity() {}
static fromCompact(e) {
return U.fromBytes(ensureBytes("sig", e), "compact");
}
static fromDER(e) {
return U.fromBytes(ensureBytes("sig", e), "der");
}
normalizeS() {
return this.hasHighS() ? new U(this.r, A.neg(this.s), this.recovery) : this;
}
toDERRawBytes() {
return this.toBytes("der");
}
toDERHex() {
return bytesToHex$1(this.toBytes("der"));
}
toCompactRawBytes() {
return this.toBytes("compact");
}
toCompactHex() {
return bytesToHex$1(this.toBytes("compact"));
}
}
let W = E.bits2int || function(e) {
if (e.length > 8192) throw Error("input is too large");
let T = bytesToNumberBE(e), E = e.length * 8 - M;
return E > 0 ? T >> BigInt(E) : T;
}, G = E.bits2int_modN || function(e) {
return A.create(W(e));
}, K = bitMask(M);
function q(e) {
return aInRange("num < 2^" + M, e, _0n, K), A.toBytes(e);
}
function J(e, E) {
return _abytes2(e, void 0, "message"), E ? _abytes2(T(e), void 0, "prehashed message") : e;
}
function Y(T, E, O) {
if (["recovered", "canonical"].some((e) => e in O)) throw Error("sign() legacy options not supported");
let { lowS: k, prehash: j, extraEntropy: M } = validateSigOpts(O, R);
T = J(T, j);
let N = G(T), P = _normFnElement(A, E), F = [q(P), q(N)];
if (M != null && M !== !1) {
let e = M === !0 ? D(L.secretKey) : M;
F.push(ensureBytes("extraEntropy", e));
}
let I = concatBytes$1(...F), z = N;
function V(T) {
let E = W(T);
if (!A.isValidNot0(E)) return;
let D = A.inv(E), O = e.BASE.multiply(E).toAffine(), j = A.create(O.x);
if (j === _0n) return;
let M = A.create(D * A.create(z + j * P));
if (M === _0n) return;
let N = (O.x === j ? 0 : 2) | Number(O.y & _1n), F = M;
return k && B(M) && (F = A.neg(M), N ^= 1), new U(j, F, N);
}
return {
seed: I,
k2sig: V
};
}
function X(e, E, D = {}) {
e = ensureBytes("message", e);
let { seed: k, k2sig: j } = Y(e, E, D);
return createHmacDrbg(T.outputLen, A.BYTES, O)(k, j);
}
function Z(e) {
let T, E = typeof e == "string" || isBytes$1(e), D = !E && typeof e == "object" && !!e && typeof e.r == "bigint" && typeof e.s == "bigint";
if (!E && !D) throw Error("invalid signature, expected Uint8Array, hex string or Signature instance");
if (D) T = new U(e.r, e.s);
else if (E) {
try {
T = U.fromBytes(ensureBytes("sig", e), "der");
} catch (e) {
if (!(e instanceof DER.Err)) throw e;
}
if (!T) try {
T = U.fromBytes(ensureBytes("sig", e), "compact");
} catch {
return !1;
}
}
return T || !1;
}
function Q(T, E, D, O = {}) {
let { lowS: k, prehash: j, format: M } = validateSigOpts(O, R);
if (D = ensureBytes("publicKey", D), E = J(ensureBytes("message", E), j), "strict" in O) throw Error("options.strict was renamed to lowS");
let N = M === void 0 ? Z(T) : U.fromBytes(ensureBytes("sig", T), M);
if (N === !1) return !1;
try {
let T = e.fromBytes(D);
if (k && N.hasHighS()) return !1;
let { r: O, s: j } = N, M = G(E), P = A.inv(j), F = A.create(M * P), I = A.create(O * P), L = e.BASE.multiplyUnsafe(F).add(T.multiplyUnsafe(I));
return L.is0() ? !1 : A.create(L.x) === O;
} catch {
return !1;
}
}
function $(e, T, E = {}) {
let { prehash: D } = validateSigOpts(E, R);
return T = J(T, D), U.fromBytes(e, "recovered").recoverPublicKey(T).toBytes();
}
return Object.freeze({
keygen: N,
getPublicKey: P,
getSharedSecret: F,
utils: I,
lengths: L,
Point: e,
sign: X,
verify: Q,
recoverPublicKey: $,
Signature: U,
hash: T
});
}
function _weierstrass_legacy_opts_to_new(e) {
let T = {
a: e.a,
b: e.b,
p: e.Fp.ORDER,
n: e.n,
h: e.h,
Gx: e.Gx,
Gy: e.Gy
}, E = e.Fp, D = e.allowedPrivateKeyLengths ? Array.from(new Set(e.allowedPrivateKeyLengths.map((e) => Math.ceil(e / 2)))) : void 0;
return {
CURVE: T,
curveOpts: {
Fp: E,
Fn: Field$1(T.n, {
BITS: e.nBitLength,
allowedLengths: D,
modFromBytes: e.wrapPrivateKey
}),
allowInfinityPoint: e.allowInfinityPoint,
endo: e.endo,
isTorsionFree: e.isTorsionFree,
clearCofactor: e.clearCofactor,
fromBytes: e.fromBytes,
toBytes: e.toBytes
}
};
}
function _ecdsa_legacy_opts_to_new(e) {
let { CURVE: T, curveOpts: E } = _weierstrass_legacy_opts_to_new(e), D = {
hmac: e.hmac,
randomBytes: e.randomBytes,
lowS: e.lowS,
bits2int: e.bits2int,
bits2int_modN: e.bits2int_modN
};
return {
CURVE: T,
curveOpts: E,
hash: e.hash,
ecdsaOpts: D
};
}
function _ecdsa_new_output_to_legacy(e, T) {
let E = T.Point;
return Object.assign({}, T, {
ProjectivePoint: E,
CURVE: Object.assign({}, e, nLength(E.Fn.ORDER, E.Fn.BITS))
});
}
function weierstrass(e) {
let { CURVE: T, curveOpts: E, hash: D, ecdsaOpts: O } = _ecdsa_legacy_opts_to_new(e);
return _ecdsa_new_output_to_legacy(e, ecdsa(weierstrassN(T, E), D, O));
}
function isBytes(e) {
return e instanceof Uint8Array || ArrayBuffer.isView(e) && e.constructor.name === "Uint8Array";
}
function abytes(e, ...T) {
if (!isBytes(e)) throw Error("Uint8Array expected");
if (T.length > 0 && !T.includes(e.length)) throw Error("Uint8Array expected of length " + T + ", got length=" + e.length);
}
function aexists(e, T = !0) {
if (e.destroyed) throw Error("Hash instance has been destroyed");
if (T && e.finished) throw Error("Hash#digest() has already been called");
}
function aoutput(e, T) {
abytes(e);
let E = T.outputLen;
if (e.length < E) throw Error("digestInto() expects output buffer of length at least " + E);
}
function u32(e) {
return new Uint32Array(e.buffer, e.byteOffset, Math.floor(e.byteLength / 4));
}
function clean(...e) {
for (let T = 0; T < e.length; T++) e[T].fill(0);
}
function createView(e) {
return new DataView(e.buffer, e.byteOffset, e.byteLength);
}
function utf8ToBytes(e) {
if (typeof e != "string") throw Error("string expected");
return new Uint8Array(new TextEncoder().encode(e));
}
function toBytes$1(e) {
if (typeof e == "string") e = utf8ToBytes(e);
else if (isBytes(e)) e = copyBytes(e);
else