jobsys-newbie
Version:
Enhanced component based on ant-design-vue
1,473 lines • 209 kB
JavaScript
import { i as __toDynamicImportESM } from "./chunk-CJnywcLQ.js";
import { Fragment, Text, computed, createVNode, defineComponent, effectScope, getCurrentInstance, h, inject, isRef, onMounted, onUnmounted, ref, shallowRef, watch } from "vue";
import { Modal, message } from "ant-design-vue";
import dayjs from "dayjs";
import { cloneDeep, find, flatMapDeep, isArray, isBoolean, isFunction, isNull, isObject, isString, isUndefined, reduce } from "lodash-es";
import axios from "axios";
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 n = 0; n < e.length; n++) t += hexes$1[e[n]];
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, n = t / 2;
if (t % 2) throw Error("hex string expected, got unpadded hex of length " + t);
let r = new Uint8Array(n);
for (let t = 0, i = 0; t < n; t++, i += 2) {
let n = asciiToBase16(e.charCodeAt(i)), a = asciiToBase16(e.charCodeAt(i + 1));
if (n === void 0 || a === void 0) {
let t = e[i] + e[i + 1];
throw Error("hex string expected, got non-hex character \"" + t + "\" at index " + i);
}
r[t] = n * 16 + a;
}
return r;
}
function utf8ToBytes$3(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$3(e)), abytes$1(e), e;
}
function concatBytes$1(...e) {
let t = 0;
for (let n = 0; n < e.length; n++) {
let r = e[n];
abytes$1(r), t += r.length;
}
let n = new Uint8Array(t);
for (let t = 0, r = 0; t < e.length; t++) {
let i = e[t];
n.set(i, r), r += i.length;
}
return n;
}
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 n = t && `"${t}"`;
throw Error(n + "expected boolean, got type=" + typeof e);
}
return e;
}
function _abytes2(e, t, n = "") {
let r = isBytes$1(e), i = e?.length, a = t !== void 0;
if (!r || a && i !== t) {
let o = n && `"${n}" `, s = a ? ` of length ${t}` : "", c = r ? `length=${i}` : `type=${typeof e}`;
throw Error(o + "expected Uint8Array" + s + ", got " + c);
}
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, n) {
let r;
if (typeof t == "string") try {
r = hexToBytes(t);
} catch (t) {
throw Error(e + " must be hex string or Uint8Array, cause: " + t);
}
else if (isBytes$1(t)) r = Uint8Array.from(t);
else throw Error(e + " must be hex string or Uint8Array");
let i = r.length;
if (typeof n == "number" && i !== n) throw Error(e + " of length " + n + " expected, got " + i);
return r;
}
var isPosBig = (e) => typeof e == "bigint" && _0n$3 <= e;
function inRange(e, t, n) {
return isPosBig(e) && isPosBig(t) && isPosBig(n) && t <= e && e < n;
}
function aInRange(e, t, n, r) {
if (!inRange(t, n, r)) throw Error("expected valid " + e + ": " + n + " <= n < " + r + ", 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, n) {
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 n != "function") throw Error("hmacFn must be a function");
let r = (e) => new Uint8Array(e), i = (e) => Uint8Array.of(e), a = r(e), o = r(e), s = 0, c = () => {
a.fill(1), o.fill(0), s = 0;
}, l = (...e) => n(o, a, ...e), u = (e = r(0)) => {
o = l(i(0), e), a = l(), e.length !== 0 && (o = l(i(1), e), a = l());
}, d = () => {
if (s++ >= 1e3) throw Error("drbg: tried 1000 values");
let e = 0, n = [];
for (; e < t;) {
a = l();
let t = a.slice();
n.push(t), e += a.length;
}
return concatBytes$1(...n);
};
return (e, t) => {
c(), u(e);
let n;
for (; !(n = t(d()));) u();
return c(), n;
};
}
function _validateObject(e, t, n = {}) {
if (!e || typeof e != "object") throw Error("expected valid options object");
function r(t, n, r) {
let i = e[t];
if (r && i === void 0) return;
let a = typeof i;
if (a !== n || i === null) throw Error(`param "${t}" is invalid: expected ${n}, got ${a}`);
}
Object.entries(t).forEach(([e, t]) => r(e, t, !1)), Object.entries(n).forEach(([e, t]) => r(e, t, !0));
}
function memoized(e) {
let t = /* @__PURE__ */ new WeakMap();
return (n, ...r) => {
let i = t.get(n);
if (i !== void 0) return i;
let a = e(n, ...r);
return t.set(n, a), a;
};
}
const bytesToHex$2 = bytesToHex$1, concatBytes = concatBytes$1, utf8ToBytes$2 = utf8ToBytes$3, 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 n = 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 r = this.blockLen, i = new Uint8Array(r);
i.set(n.length > r ? e.create().update(n).digest() : n);
for (let e = 0; e < i.length; e++) i[e] ^= 54;
this.iHash.update(i), this.oHash = e.create();
for (let e = 0; e < i.length; e++) i[e] ^= 106;
this.oHash.update(i), clean$1(i);
}
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: n, finished: r, destroyed: i, blockLen: a, outputLen: o } = this;
return e = e, e.finished = r, e.destroyed = i, e.blockLen = a, e.outputLen = o, e.oHash = t._cloneInto(e.oHash), e.iHash = n._cloneInto(e.iHash), e;
}
clone() {
return this._cloneInto();
}
destroy() {
this.destroyed = !0, this.oHash.destroy(), this.iHash.destroy();
}
};
const hmac$1 = (e, t, n) => new HMAC$1(e, t).update(n).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 n = e % t;
return n >= _0n$2 ? n : t + n;
}
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 n = mod(e, t), r = t, i = _0n$2, a = _1n$2, o = _1n$2, s = _0n$2;
for (; n !== _0n$2;) {
let e = r / n, t = r % n, c = i - o * e, l = a - s * e;
r = n, n = t, i = o, a = s, o = c, s = l;
}
if (r !== _1n$2) throw Error("invert: does not exist");
return mod(i, t);
}
function assertIsSquare(e, t, n) {
if (!e.eql(e.sqr(t), n)) throw Error("Cannot find square root");
}
function sqrt3mod4(e, t) {
let n = (e.ORDER + _1n$2) / _4n$1, r = e.pow(t, n);
return assertIsSquare(e, r, t), r;
}
function sqrt5mod8(e, t) {
let n = (e.ORDER - _5n) / _8n, r = e.mul(t, _2n$1), i = e.pow(r, n), a = e.mul(t, i), o = e.mul(e.mul(a, _2n$1), i), s = e.mul(a, e.sub(o, e.ONE));
return assertIsSquare(e, s, t), s;
}
function sqrt9mod16(e) {
let t = Field(e), n = tonelliShanks(e), r = n(t, t.neg(t.ONE)), i = n(t, r), a = n(t, t.neg(r)), o = (e + _7n) / _16n;
return (e, t) => {
let n = e.pow(t, o), s = e.mul(n, r), c = e.mul(n, i), l = e.mul(n, a), u = e.eql(e.sqr(s), t), d = e.eql(e.sqr(c), t);
n = e.cmov(n, s, u), s = e.cmov(l, c, d);
let f = e.eql(e.sqr(s), t), p = e.cmov(n, s, f);
return assertIsSquare(e, p, t), p;
};
}
function tonelliShanks(e) {
if (e < _3n$1) throw Error("sqrt is not defined for small field");
let t = e - _1n$2, n = 0;
for (; t % _2n$1 === _0n$2;) t /= _2n$1, n++;
let r = _2n$1, i = Field(e);
for (; FpLegendre(i, r) === 1;) if (r++ > 1e3) throw Error("Cannot find square root: probably non-prime P");
if (n === 1) return sqrt3mod4;
let a = i.pow(r, t), o = (t + _1n$2) / _2n$1;
return function(e, r) {
if (e.is0(r)) return r;
if (FpLegendre(e, r) !== 1) throw Error("Cannot find square root");
let i = n, s = e.mul(e.ONE, a), c = e.pow(r, t), l = e.pow(r, o);
for (; !e.eql(c, e.ONE);) {
if (e.is0(c)) return e.ZERO;
let t = 1, n = e.sqr(c);
for (; !e.eql(n, e.ONE);) if (t++, n = e.sqr(n), t === i) throw Error("Cannot find square root");
let r = _1n$2 << BigInt(i - t - 1), a = e.pow(s, r);
i = t, s = e.sqr(a), c = e.mul(c, s), l = e.mul(l, a);
}
return l;
};
}
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, n) {
if (n < _0n$2) throw Error("invalid exponent, negatives unsupported");
if (n === _0n$2) return e.ONE;
if (n === _1n$2) return t;
let r = e.ONE, i = t;
for (; n > _0n$2;) n & _1n$2 && (r = e.mul(r, i)), i = e.sqr(i), n >>= _1n$2;
return r;
}
function FpInvertBatch(e, t, n = !1) {
let r = Array(t.length).fill(n ? e.ZERO : void 0), i = t.reduce((t, n, i) => e.is0(n) ? t : (r[i] = t, e.mul(t, n)), e.ONE), a = e.inv(i);
return t.reduceRight((t, n, i) => e.is0(n) ? t : (r[i] = e.mul(t, r[i]), e.mul(t, n)), a), r;
}
function FpLegendre(e, t) {
let n = (e.ORDER - _1n$2) / _2n$1, r = e.pow(t, n), i = e.eql(r, e.ONE), a = e.eql(r, e.ZERO), o = e.eql(r, e.neg(e.ONE));
if (!i && !a && !o) throw Error("invalid Legendre symbol result");
return i ? 1 : a ? 0 : -1;
}
function nLength(e, t) {
t !== void 0 && anumber(t);
let n = t === void 0 ? e.toString(2).length : t;
return {
nBitLength: n,
nByteLength: Math.ceil(n / 8)
};
}
function Field(e, t, n = !1, r = {}) {
if (e <= _0n$2) throw Error("invalid field: expected ORDER > 0, got " + e);
let i, a, o = !1, s;
if (typeof t == "object" && t) {
if (r.sqrt || n) throw Error("cannot specify opts in two arguments");
let e = t;
e.BITS && (i = e.BITS), e.sqrt && (a = e.sqrt), typeof e.isLE == "boolean" && (n = e.isLE), typeof e.modFromBytes == "boolean" && (o = e.modFromBytes), s = e.allowedLengths;
} else typeof t == "number" && (i = t), r.sqrt && (a = r.sqrt);
let { nBitLength: c, nByteLength: l } = nLength(e, i);
if (l > 2048) throw Error("invalid field: expected ORDER of <= 2048 bytes");
let u, d = Object.freeze({
ORDER: e,
isLE: n,
BITS: c,
BYTES: l,
MASK: bitMask(c),
ZERO: _0n$2,
ONE: _1n$2,
allowedLengths: s,
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) => !d.is0(e) && d.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, n) => mod(t + n, e),
sub: (t, n) => mod(t - n, e),
mul: (t, n) => mod(t * n, e),
pow: (e, t) => FpPow(d, e, t),
div: (t, n) => mod(t * invert(n, 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: a || ((t) => (u ||= FpSqrt(e), u(d, t))),
toBytes: (e) => n ? numberToBytesLE(e, l) : numberToBytesBE(e, l),
fromBytes: (t, r = !0) => {
if (s) {
if (!s.includes(t.length) || t.length > l) throw Error("Field.fromBytes: expected " + s + " bytes, got " + t.length);
let e = new Uint8Array(l);
e.set(t, n ? 0 : e.length - t.length), t = e;
}
if (t.length !== l) throw Error("Field.fromBytes: expected " + l + " bytes, got " + t.length);
let i = n ? bytesToNumberLE(t) : bytesToNumberBE(t);
if (o && (i = mod(i, e)), !r && !d.isValid(i)) throw Error("invalid field element: outside of range 0..ORDER");
return i;
},
invertBatch: (e) => FpInvertBatch(d, e),
cmov: (e, t, n) => n ? t : e
});
return Object.freeze(d);
}
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, n = !1) {
let r = e.length, i = getFieldBytesLength(t), a = getMinHashLength(t);
if (r < 16 || r < a || r > 1024) throw Error("expected " + a + "-1024 bytes of input, got " + r);
let o = mod(n ? bytesToNumberLE(e) : bytesToNumberBE(e), t - _1n$2) + _1n$2;
return n ? numberToBytesLE(o, i) : numberToBytesBE(o, i);
}
var _0n$1 = BigInt(0), _1n$1 = BigInt(1);
function negateCt(e, t) {
let n = t.negate();
return e ? n : t;
}
function normalizeZ(e, t) {
let n = FpInvertBatch(e.Fp, t.map((e) => e.Z));
return t.map((t, r) => e.fromAffine(t.toAffine(n[r])));
}
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 n = Math.ceil(t / e) + 1, r = 2 ** (e - 1), i = 2 ** e;
return {
windows: n,
windowSize: r,
mask: bitMask(e),
maxNumber: i,
shiftBy: BigInt(e)
};
}
function calcOffsets(e, t, n) {
let { windowSize: r, mask: i, maxNumber: a, shiftBy: o } = n, s = Number(e & i), c = e >> o;
s > r && (s -= a, c += _1n$1);
let l = t * r, u = l + Math.abs(s) - 1, d = s === 0, f = s < 0, p = t % 2 != 0;
return {
nextN: c,
offset: u,
isZero: d,
isNeg: f,
isNegF: p,
offsetF: l
};
}
function validateMSMPoints(e, t) {
if (!Array.isArray(e)) throw Error("array expected");
e.forEach((e, n) => {
if (!(e instanceof t)) throw Error("invalid point at index " + n);
});
}
function validateMSMScalars(e, t) {
if (!Array.isArray(e)) throw Error("array of scalars expected");
e.forEach((e, n) => {
if (!t.isValid(e)) throw Error("invalid scalar at index " + n);
});
}
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, n = this.ZERO) {
let r = e;
for (; t > _0n$1;) t & _1n$1 && (n = n.add(r)), r = r.double(), t >>= _1n$1;
return n;
}
precomputeWindow(e, t) {
let { windows: n, windowSize: r } = calcWOpts(t, this.bits), i = [], a = e, o = a;
for (let e = 0; e < n; e++) {
o = a, i.push(o);
for (let e = 1; e < r; e++) o = o.add(a), i.push(o);
a = o.double();
}
return i;
}
wNAF(e, t, n) {
if (!this.Fn.isValid(n)) throw Error("invalid scalar");
let r = this.ZERO, i = this.BASE, a = calcWOpts(e, this.bits);
for (let e = 0; e < a.windows; e++) {
let { nextN: o, offset: s, isZero: c, isNeg: l, isNegF: u, offsetF: d } = calcOffsets(n, e, a);
n = o, c ? i = i.add(negateCt(u, t[d])) : r = r.add(negateCt(l, t[s]));
}
return assert0(n), {
p: r,
f: i
};
}
wNAFUnsafe(e, t, n, r = this.ZERO) {
let i = calcWOpts(e, this.bits);
for (let e = 0; e < i.windows && n !== _0n$1; e++) {
let { nextN: a, offset: o, isZero: s, isNeg: c } = calcOffsets(n, e, i);
if (n = a, !s) {
let e = t[o];
r = r.add(c ? e.negate() : e);
}
}
return assert0(n), r;
}
getPrecomputes(e, t, n) {
let r = pointPrecomputes.get(t);
return r || (r = this.precomputeWindow(t, e), e !== 1 && (typeof n == "function" && (r = n(r)), pointPrecomputes.set(t, r))), r;
}
cached(e, t, n) {
let r = getW(e);
return this.wNAF(r, this.getPrecomputes(r, e, n), t);
}
unsafe(e, t, n, r) {
let i = getW(e);
return i === 1 ? this._unsafeLadder(e, t, r) : this.wNAFUnsafe(i, this.getPrecomputes(i, e, n), t, r);
}
createCache(e, t) {
validateW(t, this.bits), pointWindowSizes.set(e, t), pointPrecomputes.delete(e);
}
hasCache(e) {
return getW(e) !== 1;
}
};
function mulEndoUnsafe(e, t, n, r) {
let i = t, a = e.ZERO, o = e.ZERO;
for (; n > _0n$1 || r > _0n$1;) n & _1n$1 && (a = a.add(i)), r & _1n$1 && (o = o.add(i)), i = i.double(), n >>= _1n$1, r >>= _1n$1;
return {
p1: a,
p2: o
};
}
function pippenger(e, t, n, r) {
validateMSMPoints(n, e), validateMSMScalars(r, t);
let i = n.length, a = r.length;
if (i !== a) throw Error("arrays of points and scalars must have equal length");
let o = e.ZERO, s = bitLen(BigInt(i)), c = 1;
s > 12 ? c = s - 3 : s > 4 ? c = s - 2 : s > 0 && (c = 2);
let l = bitMask(c), u = Array(Number(l) + 1).fill(o), d = Math.floor((t.BITS - 1) / c) * c, f = o;
for (let e = d; e >= 0; e -= c) {
u.fill(o);
for (let t = 0; t < a; t++) {
let i = r[t], a = Number(i >> BigInt(e) & l);
u[a] = u[a].add(n[t]);
}
let t = o;
for (let e = u.length - 1, n = o; e > 0; e--) n = n.add(u[e]), t = t.add(n);
if (f = f.add(t), e !== 0) for (let e = 0; e < c; e++) f = f.double();
}
return f;
}
function createField(e, t, n) {
if (t) {
if (t.ORDER !== e) throw Error("Field.ORDER must match order: Fp == p, Fn == n");
return validateField(t), t;
} else return Field(e, { isLE: n });
}
function _createCurveFields(e, t, n = {}, r) {
if (r === void 0 && (r = e === "edwards"), !t || typeof t != "object") throw Error(`expected valid ${e} CURVE object`);
for (let e of [
"p",
"n",
"h"
]) {
let n = t[e];
if (!(typeof n == "bigint" && n > _0n$1)) throw Error(`CURVE.${e} must be positive bigint`);
}
let i = createField(t.p, n.Fp, r), a = createField(t.n, n.Fn, r), o = [
"Gx",
"Gy",
"a",
e === "weierstrass" ? "b" : "d"
];
for (let e of o) if (!i.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: i,
Fn: a
};
}
var divNearest = (e, t) => (e + (e >= 0 ? t : -t) / _2n) / t;
function _splitEndoScalar(e, t, n) {
let [[r, i], [a, o]] = t, s = divNearest(o * e, n), c = divNearest(-i * e, n), l = e - s * r - c * a, u = -s * i - c * o, d = l < _0n, f = u < _0n;
d && (l = -l), f && (u = -u);
let p = bitMask(Math.ceil(bitLen(n) / 2)) + _1n;
if (l < _0n || l >= p || u < _0n || u >= p) throw Error("splitScalar (endomorphism): failed, k=" + e);
return {
k1neg: d,
k1: l,
k2neg: f,
k2: u
};
}
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 n = {};
for (let r of Object.keys(t)) n[r] = e[r] === void 0 ? t[r] : e[r];
return _abool2(n.lowS, "lowS"), _abool2(n.prehash, "prehash"), n.format !== void 0 && validateSigFormat(n.format), n;
}
const DER = {
Err: class extends Error {
constructor(e = "") {
super(e);
}
},
_tlv: {
encode: (e, t) => {
let { Err: n } = DER;
if (e < 0 || e > 256) throw new n("tlv.encode: wrong tag");
if (t.length & 1) throw new n("tlv.encode: unpadded data");
let r = t.length / 2, i = numberToHexUnpadded(r);
if (i.length / 2 & 128) throw new n("tlv.encode: long form length too big");
let a = r > 127 ? numberToHexUnpadded(i.length / 2 | 128) : "";
return numberToHexUnpadded(e) + a + i + t;
},
decode(e, t) {
let { Err: n } = DER, r = 0;
if (e < 0 || e > 256) throw new n("tlv.encode: wrong tag");
if (t.length < 2 || t[r++] !== e) throw new n("tlv.decode: wrong tlv");
let i = t[r++], a = !!(i & 128), o = 0;
if (!a) o = i;
else {
let e = i & 127;
if (!e) throw new n("tlv.decode(long): indefinite length not supported");
if (e > 4) throw new n("tlv.decode(long): byte length is too big");
let a = t.subarray(r, r + e);
if (a.length !== e) throw new n("tlv.decode: length bytes not complete");
if (a[0] === 0) throw new n("tlv.decode(long): zero leftmost byte");
for (let e of a) o = o << 8 | e;
if (r += e, o < 128) throw new n("tlv.decode(long): not minimal encoding");
}
let s = t.subarray(r, r + o);
if (s.length !== o) throw new n("tlv.decode: wrong value length");
return {
v: s,
l: t.subarray(r + o)
};
}
},
_int: {
encode(e) {
let { Err: t } = DER;
if (e < _0n) throw new t("integer: negative integers are not allowed");
let n = numberToHexUnpadded(e);
if (Number.parseInt(n[0], 16) & 8 && (n = "00" + n), n.length & 1) throw new t("unexpected DER parsing assertion: unpadded hex");
return n;
},
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: n, _tlv: r } = DER, i = ensureBytes("signature", e), { v: a, l: o } = r.decode(48, i);
if (o.length) throw new t("invalid signature: left bytes after parsing");
let { v: s, l: c } = r.decode(2, a), { v: l, l: u } = r.decode(2, c);
if (u.length) throw new t("invalid signature: left bytes after parsing");
return {
r: n.decode(s),
s: n.decode(l)
};
},
hexFromSig(e) {
let { _tlv: t, _int: n } = DER, r = t.encode(2, n.encode(e.r)) + t.encode(2, n.encode(e.s));
return t.encode(48, r);
}
};
var _0n = BigInt(0), _1n = BigInt(1), _2n = BigInt(2), _3n = BigInt(3), _4n = BigInt(4);
function _normFnElement(e, t) {
let { BYTES: n } = e, r;
if (typeof t == "bigint") r = t;
else {
let i = ensureBytes("private key", t);
try {
r = e.fromBytes(i);
} catch {
throw Error(`invalid private key: expected ui8a of size ${n}, got ${typeof t}`);
}
}
if (!e.isValidNot0(r)) throw Error("invalid private key: out of range [1..N-1]");
return r;
}
function weierstrassN(e, t = {}) {
let n = _createCurveFields("weierstrass", e, t), { Fp: r, Fn: i } = n, a = n.CURVE, { h: o, n: s } = a;
_validateObject(t, {}, {
allowInfinityPoint: "boolean",
clearCofactor: "function",
isTorsionFree: "function",
fromBytes: "function",
toBytes: "function",
endo: "object",
wrapPrivateKey: "boolean"
});
let { endo: c } = t;
if (c && (!r.is0(a.a) || typeof c.beta != "bigint" || !Array.isArray(c.basises))) throw Error("invalid endo: expected \"beta\": bigint and \"basises\": array");
let l = getWLengths(r, i);
function u() {
if (!r.isOdd) throw Error("compression is not supported: Field does not have .isOdd()");
}
function d(e, t, n) {
let { x: i, y: a } = t.toAffine(), o = r.toBytes(i);
return _abool2(n, "isCompressed"), n ? (u(), concatBytes$1(pprefix(!r.isOdd(a)), o)) : concatBytes$1(Uint8Array.of(4), o, r.toBytes(a));
}
function f(e) {
_abytes2(e, void 0, "Point");
let { publicKey: t, publicKeyUncompressed: n } = l, i = e.length, a = e[0], o = e.subarray(1);
if (i === t && (a === 2 || a === 3)) {
let e = r.fromBytes(o);
if (!r.isValid(e)) throw Error("bad point: is not on curve, wrong x");
let t = g(e), n;
try {
n = r.sqrt(t);
} catch (e) {
let t = e instanceof Error ? ": " + e.message : "";
throw Error("bad point: is not on curve, sqrt error" + t);
}
u();
let i = r.isOdd(n);
return (a & 1) == 1 !== i && (n = r.neg(n)), {
x: e,
y: n
};
} else if (i === n && a === 4) {
let e = r.BYTES, t = r.fromBytes(o.subarray(0, e)), n = r.fromBytes(o.subarray(e, e * 2));
if (!_(t, n)) throw Error("bad point: is not on curve");
return {
x: t,
y: n
};
} else throw Error(`bad point: got length ${i}, expected compressed=${t} or uncompressed=${n}`);
}
let p = t.toBytes || d, m = t.fromBytes || f;
function g(e) {
let t = r.sqr(e), n = r.mul(t, e);
return r.add(r.add(n, r.mul(e, a.a)), a.b);
}
function _(e, t) {
let n = r.sqr(t), i = g(e);
return r.eql(n, i);
}
if (!_(a.Gx, a.Gy)) throw Error("bad curve params: generator point");
let v = r.mul(r.pow(a.a, _3n), _4n), y = r.mul(r.sqr(a.b), BigInt(27));
if (r.is0(r.add(v, y))) throw Error("bad curve params: a or b");
function b(e, t, n = !1) {
if (!r.isValid(t) || n && r.is0(t)) throw Error(`bad point coordinate ${e}`);
return t;
}
function x(e) {
if (!(e instanceof E)) throw Error("ProjectivePoint expected");
}
function S(e) {
if (!c || !c.basises) throw Error("no endo");
return _splitEndoScalar(e, c.basises, i.ORDER);
}
let C = memoized((e, t) => {
let { X: n, Y: i, Z: a } = e;
if (r.eql(a, r.ONE)) return {
x: n,
y: i
};
let o = e.is0();
t ??= o ? r.ONE : r.inv(a);
let s = r.mul(n, t), c = r.mul(i, t), l = r.mul(a, t);
if (o) return {
x: r.ZERO,
y: r.ZERO
};
if (!r.eql(l, r.ONE)) throw Error("invZ was invalid");
return {
x: s,
y: c
};
}), w = memoized((e) => {
if (e.is0()) {
if (t.allowInfinityPoint && !r.is0(e.Y)) return;
throw Error("bad point: ZERO");
}
let { x: n, y: i } = e.toAffine();
if (!r.isValid(n) || !r.isValid(i)) throw Error("bad point: x or y not field elements");
if (!_(n, i)) throw Error("bad point: equation left != right");
if (!e.isTorsionFree()) throw Error("bad point: not in prime-order subgroup");
return !0;
});
function T(e, t, n, i, a) {
return n = new E(r.mul(n.X, e), n.Y, n.Z), t = negateCt(i, t), n = negateCt(a, n), t.add(n);
}
class E {
constructor(e, t, n) {
this.X = b("x", e), this.Y = b("y", t, !0), this.Z = b("z", n), Object.freeze(this);
}
static CURVE() {
return a;
}
static fromAffine(e) {
let { x: t, y: n } = e || {};
if (!e || !r.isValid(t) || !r.isValid(n)) throw Error("invalid affine point");
if (e instanceof E) throw Error("projective point not allowed");
return r.is0(t) && r.is0(n) ? E.ZERO : new E(t, n, r.ONE);
}
static fromBytes(e) {
let t = E.fromAffine(m(_abytes2(e, void 0, "point")));
return t.assertValidity(), t;
}
static fromHex(e) {
return E.fromBytes(ensureBytes("pointHex", e));
}
get x() {
return this.toAffine().x;
}
get y() {
return this.toAffine().y;
}
precompute(e = 8, t = !0) {
return O.createCache(this, e), t || this.multiply(_3n), this;
}
assertValidity() {
w(this);
}
hasEvenY() {
let { y: e } = this.toAffine();
if (!r.isOdd) throw Error("Field doesn't support isOdd");
return !r.isOdd(e);
}
equals(e) {
x(e);
let { X: t, Y: n, Z: i } = this, { X: a, Y: o, Z: s } = e, c = r.eql(r.mul(t, s), r.mul(a, i)), l = r.eql(r.mul(n, s), r.mul(o, i));
return c && l;
}
negate() {
return new E(this.X, r.neg(this.Y), this.Z);
}
double() {
let { a: e, b: t } = a, n = r.mul(t, _3n), { X: i, Y: o, Z: s } = this, c = r.ZERO, l = r.ZERO, u = r.ZERO, d = r.mul(i, i), f = r.mul(o, o), p = r.mul(s, s), m = r.mul(i, o);
return m = r.add(m, m), u = r.mul(i, s), u = r.add(u, u), c = r.mul(e, u), l = r.mul(n, p), l = r.add(c, l), c = r.sub(f, l), l = r.add(f, l), l = r.mul(c, l), c = r.mul(m, c), u = r.mul(n, u), p = r.mul(e, p), m = r.sub(d, p), m = r.mul(e, m), m = r.add(m, u), u = r.add(d, d), d = r.add(u, d), d = r.add(d, p), d = r.mul(d, m), l = r.add(l, d), p = r.mul(o, s), p = r.add(p, p), d = r.mul(p, m), c = r.sub(c, d), u = r.mul(p, f), u = r.add(u, u), u = r.add(u, u), new E(c, l, u);
}
add(e) {
x(e);
let { X: t, Y: n, Z: i } = this, { X: o, Y: s, Z: c } = e, l = r.ZERO, u = r.ZERO, d = r.ZERO, f = a.a, p = r.mul(a.b, _3n), m = r.mul(t, o), g = r.mul(n, s), _ = r.mul(i, c), v = r.add(t, n), y = r.add(o, s);
v = r.mul(v, y), y = r.add(m, g), v = r.sub(v, y), y = r.add(t, i);
let b = r.add(o, c);
return y = r.mul(y, b), b = r.add(m, _), y = r.sub(y, b), b = r.add(n, i), l = r.add(s, c), b = r.mul(b, l), l = r.add(g, _), b = r.sub(b, l), d = r.mul(f, y), l = r.mul(p, _), d = r.add(l, d), l = r.sub(g, d), d = r.add(g, d), u = r.mul(l, d), g = r.add(m, m), g = r.add(g, m), _ = r.mul(f, _), y = r.mul(p, y), g = r.add(g, _), _ = r.sub(m, _), _ = r.mul(f, _), y = r.add(y, _), m = r.mul(g, y), u = r.add(u, m), m = r.mul(b, y), l = r.mul(v, l), l = r.sub(l, m), m = r.mul(v, g), d = r.mul(b, d), d = r.add(d, m), new E(l, u, d);
}
subtract(e) {
return this.add(e.negate());
}
is0() {
return this.equals(E.ZERO);
}
multiply(e) {
let { endo: n } = t;
if (!i.isValidNot0(e)) throw Error("invalid scalar: out of range");
let r, a, o = (e) => O.cached(this, e, (e) => normalizeZ(E, e));
if (n) {
let { k1neg: t, k1: i, k2neg: s, k2: c } = S(e), { p: l, f: u } = o(i), { p: d, f } = o(c);
a = u.add(f), r = T(n.beta, l, d, t, s);
} else {
let { p: t, f: n } = o(e);
r = t, a = n;
}
return normalizeZ(E, [r, a])[0];
}
multiplyUnsafe(e) {
let { endo: n } = t, r = this;
if (!i.isValid(e)) throw Error("invalid scalar: out of range");
if (e === _0n || r.is0()) return E.ZERO;
if (e === _1n) return r;
if (O.hasCache(this)) return this.multiply(e);
if (n) {
let { k1neg: t, k1: i, k2neg: a, k2: o } = S(e), { p1: s, p2: c } = mulEndoUnsafe(E, r, i, o);
return T(n.beta, s, c, t, a);
} else return O.unsafe(r, e);
}
multiplyAndAddUnsafe(e, t, n) {
let r = this.multiplyUnsafe(t).add(e.multiplyUnsafe(n));
return r.is0() ? void 0 : r;
}
toAffine(e) {
return C(this, e);
}
isTorsionFree() {
let { isTorsionFree: e } = t;
return o === _1n ? !0 : e ? e(E, this) : O.unsafe(this, s).is0();
}
clearCofactor() {
let { clearCofactor: e } = t;
return o === _1n ? this : e ? e(E, this) : this.multiplyUnsafe(o);
}
isSmallOrder() {
return this.multiplyUnsafe(o).is0();
}
toBytes(e = !0) {
return _abool2(e, "isCompressed"), this.assertValidity(), p(E, 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(E, e);
}
static msm(e, t) {
return pippenger(E, i, e, t);
}
static fromPrivateKey(e) {
return E.BASE.multiply(_normFnElement(i, e));
}
}
E.BASE = new E(a.Gx, a.Gy, r.ONE), E.ZERO = new E(r.ZERO, r.ONE, r.ZERO), E.Fp = r, E.Fn = i;
let D = i.BITS, O = new wNAF(E, t.endo ? Math.ceil(D / 2) : D);
return E.BASE.precompute(8), E;
}
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: n } = e, r = t.randomBytes || randomBytes$1, i = Object.assign(getWLengths(e.Fp, n), { seed: getMinHashLength(n.ORDER) });
function a(e) {
try {
return !!_normFnElement(n, e);
} catch {
return !1;
}
}
function o(t, n) {
let { publicKey: r, publicKeyUncompressed: a } = i;
try {
let i = t.length;
return n === !0 && i !== r || n === !1 && i !== a ? !1 : !!e.fromBytes(t);
} catch {
return !1;
}
}
function s(e = r(i.seed)) {
return mapHashToField(_abytes2(e, i.seed, "seed"), n.ORDER);
}
function c(t, r = !0) {
return e.BASE.multiply(_normFnElement(n, t)).toBytes(r);
}
function l(e) {
let t = s(e);
return {
secretKey: t,
publicKey: c(t)
};
}
function u(t) {
if (typeof t == "bigint") return !1;
if (t instanceof e) return !0;
let { secretKey: r, publicKey: a, publicKeyUncompressed: o } = i;
if (n.allowedLengths || r === a) return;
let s = ensureBytes("key", t).length;
return s === a || s === o;
}
function d(t, r, i = !0) {
if (u(t) === !0) throw Error("first arg must be private key");
if (u(r) === !1) throw Error("second arg must be public key");
let a = _normFnElement(n, t);
return e.fromHex(r).multiply(a).toBytes(i);
}
let f = {
isValidSecretKey: a,
isValidPublicKey: o,
randomSecretKey: s,
isValidPrivateKey: a,
randomPrivateKey: s,
normPrivateKeyToScalar: (e) => _normFnElement(n, e),
precompute(t = 8, n = e.BASE) {
return n.precompute(t, !1);
}
};
return Object.freeze({
getPublicKey: c,
getSharedSecret: d,
keygen: l,
Point: e,
utils: f,
lengths: i
});
}
function ecdsa(e, t, n = {}) {
ahash(t), _validateObject(n, {}, {
hmac: "function",
lowS: "boolean",
randomBytes: "function",
bits2int: "function",
bits2int_modN: "function"
});
let r = n.randomBytes || randomBytes$1, i = n.hmac || ((e, ...n) => hmac$1(t, e, concatBytes$1(...n))), { Fp: a, Fn: o } = e, { ORDER: s, BITS: c } = o, { keygen: l, getPublicKey: u, getSharedSecret: d, utils: f, lengths: p } = ecdh(e, n), m = {
prehash: !1,
lowS: typeof n.lowS == "boolean" ? n.lowS : !1,
format: void 0,
extraEntropy: !1
}, g = "compact";
function _(e) {
return e > s >> _1n;
}
function v(e, t) {
if (!o.isValidNot0(t)) throw Error(`invalid signature ${e}: out of range 1..Point.Fn.ORDER`);
return t;
}
function y(e, t) {
validateSigFormat(t);
let n = p.signature;
return _abytes2(e, t === "compact" ? n : t === "recovered" ? n + 1 : void 0, `${t} signature`);
}
class b {
constructor(e, t, n) {
this.r = v("r", e), this.s = v("s", t), n != null && (this.recovery = n), Object.freeze(this);
}
static fromBytes(e, t = g) {
y(e, t);
let n;
if (t === "der") {
let { r: t, s: n } = DER.toSig(_abytes2(e));
return new b(t, n);
}
t === "recovered" && (n = e[0], t = "compact", e = e.subarray(1));
let r = o.BYTES, i = e.subarray(0, r), a = e.subarray(r, r * 2);
return new b(o.fromBytes(i), o.fromBytes(a), n);
}
static fromHex(e, t) {
return this.fromBytes(hexToBytes(e), t);
}
addRecoveryBit(e) {
return new b(this.r, this.s, e);
}
recoverPublicKey(t) {
let n = a.ORDER, { r, s: i, recovery: c } = this;
if (c == null || ![
0,
1,
2,
3
].includes(c)) throw Error("recovery id invalid");
if (s * _2n < n && c > 1) throw Error("recovery id is ambiguous for h>1 curve");
let l = c === 2 || c === 3 ? r + s : r;
if (!a.isValid(l)) throw Error("recovery id 2 or 3 invalid");
let u = a.toBytes(l), d = e.fromBytes(concatBytes$1(pprefix((c & 1) == 0), u)), f = o.inv(l), p = S(ensureBytes("msgHash", t)), m = o.create(-p * f), g = o.create(i * f), _ = e.BASE.multiplyUnsafe(m).add(d.multiplyUnsafe(g));
if (_.is0()) throw Error("point at infinify");
return _.assertValidity(), _;
}
hasHighS() {
return _(this.s);
}
toBytes(e = g) {
if (validateSigFormat(e), e === "der") return hexToBytes(DER.hexFromSig(this));
let t = o.toBytes(this.r), n = o.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, n);
}
return concatBytes$1(t, n);
}
toHex(e) {
return bytesToHex$1(this.toBytes(e));
}
assertValidity() {}
static fromCompact(e) {
return b.fromBytes(ensureBytes("sig", e), "compact");
}
static fromDER(e) {
return b.fromBytes(ensureBytes("sig", e), "der");
}
normalizeS() {
return this.hasHighS() ? new b(this.r, o.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 x = n.bits2int || function(e) {
if (e.length > 8192) throw Error("input is too large");
let t = bytesToNumberBE(e), n = e.length * 8 - c;
return n > 0 ? t >> BigInt(n) : t;
}, S = n.bits2int_modN || function(e) {
return o.create(x(e));
}, C = bitMask(c);
function w(e) {
return aInRange("num < 2^" + c, e, _0n, C), o.toBytes(e);
}
function T(e, n) {
return _abytes2(e, void 0, "message"), n ? _abytes2(t(e), void 0, "prehashed message") : e;
}
function E(t, n, i) {
if (["recovered", "canonical"].some((e) => e in i)) throw Error("sign() legacy options not supported");
let { lowS: a, prehash: s, extraEntropy: c } = validateSigOpts(i, m);
t = T(t, s);
let l = S(t), u = _normFnElement(o, n), d = [w(u), w(l)];
if (c != null && c !== !1) {
let e = c === !0 ? r(p.secretKey) : c;
d.push(ensureBytes("extraEntropy", e));
}
let f = concatBytes$1(...d), g = l;
function v(t) {
let n = x(t);
if (!o.isValidNot0(n)) return;
let r = o.inv(n), i = e.BASE.multiply(n).toAffine(), s = o.create(i.x);
if (s === _0n) return;
let c = o.create(r * o.create(g + s * u));
if (c === _0n) return;
let l = (i.x === s ? 0 : 2) | Number(i.y & _1n), d = c;
return a && _(c) && (d = o.neg(c), l ^= 1), new b(s, d, l);
}
return {
seed: f,
k2sig: v
};
}
function D(e, n, r = {}) {
e = ensureBytes("message", e);
let { seed: a, k2sig: s } = E(e, n, r);
return createHmacDrbg(t.outputLen, o.BYTES, i)(a, s);
}
function O(e) {
let t, n = typeof e == "string" || isBytes$1(e), r = !n && typeof e == "object" && !!e && typeof e.r == "bigint" && typeof e.s == "bigint";
if (!n && !r) throw Error("invalid signature, expected Uint8Array, hex string or Signature instance");
if (r) t = new b(e.r, e.s);
else if (n) {
try {
t = b.fromBytes(ensureBytes("sig", e), "der");
} catch (e) {
if (!(e instanceof DER.Err)) throw e;
}
if (!t) try {
t = b.fromBytes(ensureBytes("sig", e), "compact");
} catch {
return !1;
}
}
return t || !1;
}
function k(t, n, r, i = {}) {
let { lowS: a, prehash: s, format: c } = validateSigOpts(i, m);
if (r = ensureBytes("publicKey", r), n = T(ensureBytes("message", n), s), "strict" in i) throw Error("options.strict was renamed to lowS");
let l = c === void 0 ? O(t) : b.fromBytes(ensureBytes("sig", t), c);
if (l === !1) return !1;
try {
let t = e.fromBytes(r);
if (a && l.hasHighS()) return !1;
let { r: i, s } = l, c = S(n), u = o.inv(s), d = o.create(c * u), f = o.create(i * u), p = e.BASE.multiplyUnsafe(d).add(t.multiplyUnsafe(f));
return p.is0() ? !1 : o.create(p.x) === i;
} catch {
return !1;
}
}
function A(e, t, n = {}) {
let { prehash: r } = validateSigOpts(n, m);
return t = T(t, r), b.fromBytes(e, "recovered").recoverPublicKey(t).toBytes();
}
return Object.freeze({
keygen: l,
getPublicKey: u,
getSharedSecret: d,
utils: f,
lengths: p,
Point: e,
sign: D,
verify: k,
recoverPublicKey: A,
Signature: b,
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
}, n = e.Fp, r = e.allowedPrivateKeyLengths ? Array.from(new Set(e.allowedPrivateKeyLengths.map((e) => Math.ceil(e / 2)))) : void 0;
return {
CURVE: t,
curveOpts: {
Fp: n,
Fn: Field(t.n, {
BITS: e.nBitLength,
allowedLengths: r,
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: n } = _weierstrass_legacy_opts_to_new(e), r = {
hmac: e.hmac,
randomBytes: e.randomBytes,
lowS: e.lowS,
bits2int: e.bits2int,
bits2int_modN: e.bits2int_modN
};
return {
CURVE: t,
curveOpts: n,
hash: e.hash,
ecdsaOpts: r
};
}
function _ecdsa_new_output_to_legacy(e, t) {
let n = t.Point;
return Object.assign({}, t, {
ProjectivePoint: n,
CURVE: Object.assign({}, e, nLength(n.Fn.ORDER, n.Fn.BITS))
});
}
function weierstrass(e) {
let { CURVE: t, curveOpts: n, hash: r, ecdsaOpts: i } = _ecdsa_legacy_opts_to_new(e);
return _ecdsa_new_output_to_legacy(e, ecdsa(weierstrassN(t, n), r, i));
}
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 n = t.outputLen;
if (e.length < n) throw Error("digestInto() expects output buffer of length at least " + n);
}
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$1(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$1(e);
else if (isBytes(e)) e = copyBytes(e);
else throw Error("Uint8Array expected, got " + typeof e);
return e;
}
function setBigUint64(e, t, n, r) {
if (typeof e.setBigUint64 == "function") return e.setBigUint64(t, n, r);
let i = BigInt(32), a = BigInt(4294967295), o = Number(n >> i & a), s = Number(n & a), c = r ? 4 : 0, l = r ? 0 : 4;
e.setUint32(t + c, o, r), e.setUint32(t + l, s, r);
}
function copyBytes(e) {
return Uint8Array.from(e);
}
var BLOCK_SIZE = 16, ZEROS16 = /* @__PURE__ */ new Uint8Array(16), ZEROS32 = u32(ZEROS16), POLY = 225, mul2 = (e, t, n, r) => {
let i = r & 1;
return {
s3: n << 31 | r >>> 1,
s2: t << 31 | n >>> 1,
s1: e << 31 | t >>> 1,
s0: e >>> 1 ^ POLY << 24 & -(i & 1)
};
}, swapLE = (e) => (e >>> 0 & 255) << 24 | (e >>> 8 & 255) << 16 | (e >>> 16 & 255) << 8 | e >>> 24 & 255 | 0;
function _toGHASHKey(e) {
e.reverse();
let t = e[15] & 1, n = 0;
for (let t = 0; t < e.length; t++) {
let r = e[t];
e[t] = r >>> 1 | n, n = (r & 1) << 7;
}
return e[0] ^= -t & 225, e;
}
var estimateWindow = (e) => e > 64 * 1024 ? 8 : e > 1024 ? 4 : 2, GHASH = class {
constructor(e, t) {
this.blockLen = BLOCK_SIZE, this.outputLen = BLOCK_SIZE, this.s0 = 0, this.s1 = 0, this.s2 = 0, this.s3 = 0, this.finished = !1, e = toBytes$1(e), abytes(e, 16);
let n = createView(e), r = n.getUint32(0, !1), i = n.getUint32(4, !1), a = n.getUint32(8, !1), o = n.getUint32(12, !1), s = [];
for (let e = 0; e < 128; e++) s.push({
s0: swapLE(r),
s1: swapLE(i),
s2: swapLE(a),
s3: swapLE(o)
}), {s0: r, s1: i, s2: a, s3: o} = mul2(r, i, a, o);
let c = estimateWindow(t || 1024);
if (![
1,
2,
4,
8
].includes(c)) throw Error("ghash: invalid window size, expected 2, 4 or 8");
this.W = c;
let l = 128 / c, u = this.windowSize = 2 ** c, d = [];
for (let e = 0; e < l; e++) for (let t = 0; t < u; t++) {
let n = 0, r = 0, i = 0, a = 0;
for (let o = 0; o < c; o++) {
if (!(t >>> c - o - 1 & 1)) continue;
let { s0: l, s1: u, s2: d, s3: f } = s[c * e + o];
n ^= l, r ^= u, i ^= d, a ^= f;
}
d.push({
s0: n,
s1: r,
s2: i,
s3: a
});
}
this.t = d;
}
_updateBlock(e, t, n, r) {
e ^= this.s0, t ^= this.s1, n ^= this.s2, r ^= this.s3;
let { W: i, t: a, windowSize: o } = this, s = 0, c = 0, l = 0, u = 0, d = (1 << i) - 1, f = 0;
for (let p of [
e,
t,
n,
r
]) for (let e = 0; e < 4; e++) {
let t = p >>> 8 * e & 255;
for (let e = 8 / i - 1; e >= 0; e--) {
let n = t >>> i * e & d, { s0: r, s1: p, s2: m, s3: g } = a[f * o + n];
s ^= r, c ^= p, l ^= m, u ^= g, f += 1;
}
}
this.s0 = s, this.s1 = c, this.s2 = l, this.s3 = u;
}
update(e) {
aexists(this), e = toBytes$1(e), abytes(e);
let t = u32(e), n = Math.floor(e.length / BLOCK_SIZE), r = e.length % BLOCK_SIZE;
for (let e = 0; e < n; e++) this._updateBlock(t[e * 4 + 0], t[e * 4 + 1], t[e * 4 + 2], t[e * 4 + 3]);
return r && (ZEROS16.set(e.subarray(n * BLOCK_SIZE)), this._updateBlock(ZEROS32[0], ZEROS32[1], ZEROS32[2], ZEROS32[3]), clean(ZEROS32)), this;
}
destroy() {
let { t: e } = this;
for (let t of e) t.s0 = 0, t.s1 = 0, t.s2 = 0, t.s3 = 0;
}
digestInto(e) {
aexists(this), aoutput(e, this), this.finished = !0;
let { s0: t, s1: n, s2: r, s3: i } = this, a = u32(e);
return a[0] = t, a[1] = n, a[2] = r, a[3] = i, e;
}
digest() {
let e = new Uint8Array(BLOCK_SIZE);
return this.digestInto(e), this.destroy(), e;
}
}, Polyval = class extends GHASH {
constructor(e, t) {
e = toBytes$1(e), abytes(e);
let n = _toGHASHKey(copyBytes(e));
super(n, t), clean(n);
}
update(e) {
e = toBytes$1(e), aexists(this);
let t = u32(e), n = e.length % BLOCK_SIZE, r = Math.floor(e.length / BLOCK_SIZE);
for (let e = 0; e < r; e++) this._updateBlock(swapLE(t[e * 4 + 3]), swapLE(t[e * 4 + 2]), swapLE(t[e * 4 + 1]), swapLE(t[e * 4 + 0]));
return n && (ZEROS16.set(e.subarray(r * BLOCK_SIZE)), this._updateBlock(swapLE(ZEROS32[3]), swapLE(ZEROS32[2]), swapLE(ZEROS32[1]), swapLE(ZEROS32[0])), clean(ZEROS32)), this;
}
digestInto(e) {
aexists(this), aoutput(e, this), this.finished = !0;
let { s0: t, s1: n, s2: r, s3: i } = this, a = u32(e);
return a[0] = t, a[1] = n, a[2] = r, a[3] = i, e.reverse();
}
};
function wrapConstructorWithKey(e) {
let t = (t, n) => e(n, t.length).update(toBytes$1(t)).digest(), n = e(new Uint8Array(16), 0);
return t.outputLen = n.outputLen, t.blockLen = n.blockLen, t.create = (t, n) => e(t, n), t;
}
const ghash = wrapConstructorWithKey((e, t) => new GHASH(e, t));
wrapConstructorWithKey((e, t) => new Polyval(e, t));
var __defProp = Object.defineProperty, __export = (e, t) => {
for (var n in t) __defProp(e, n, {
get: t[n],
enumerable: !0
});
}, sm2_exports = {};
__export(sm2_exports, {
EmptyArray: () => EmptyArray,
arrayToHex: () => arrayToHex,
arrayToUtf8: () => arrayToUtf8,
calculateSharedKey: () => calculateSharedKey,
comparePublicKeyHex: () => comparePublicKeyHex,
compressPublicKeyHex: () => compressPublicKeyHex,
doDecrypt: () => doDecrypt,
doEncrypt: () => doEncrypt,
doSignature: () => doSignature,
doVerifySignature: () => doVerifySignature,
generateKeyPairHex: () => generateKeyPairHex,
getHash: () => getHash,
getPoint: () => getPoint,
getPublicKeyFromPrivateKey: () => getPublicKeyFromPrivateKey,
getZ: () => getZ,
hexToArray: () => hexToArray,
initRNGPool: () => initRNGPool,
leftPad: () => leftPad,
precomputePublicKey: () => precomputePublicKey,
utf8ToHex: () => utf8ToHex,
verifyPublicKey: () => verifyPublicKey
});
var ZERO = BigInt(0), ONE = BigInt(1), TWO = BigInt(2);
function bigintToValue(e) {
let t = e.toString(16);
if (t[0] !== "-") t.length % 2 == 1 ? t = "0" + t : t.match(/^[0-7]/) || (t = "00" + t);
else {
t = t.substring(1);
let n = t.length;
n % 2 == 1 ? n += 1 : t.match(/^[0-7]/) || (n += 2);
let r = "";
for (let e = 0; e < n; e++) r += "f";
t = ((hexToNumber(r) ^ e) + ONE).toString(16).replace(/^-/, "");
}
return t;
}
var ASN1Object = class {
constructor(e = null, t = "00", n = "00