@volter/tabnode 0.5.49 → 0.5.51

package/dist/assets/{runtime-worker-C1IV4qnr.js → runtime-worker-Cu2mr9G9.js}

@@ -19252,14 +19252,14 @@ var safeBuffer = { exports: {} };
 var buffer = {};
 var ieee754 = {};
 /*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
-ieee754.read = function(buffer2, offset2, isLE, mLen, nBytes) {
+ieee754.read = function(buffer2, offset2, isLE2, mLen, nBytes) {
   var e2, m;
   var eLen = nBytes * 8 - mLen - 1;
   var eMax = (1 << eLen) - 1;
   var eBias = eMax >> 1;
   var nBits = -7;
-  var i10 = isLE ? nBytes - 1 : 0;
-  var d = isLE ? -1 : 1;
+  var i10 = isLE2 ? nBytes - 1 : 0;
+  var d = isLE2 ? -1 : 1;
   var s10 = buffer2[offset2 + i10];
   i10 += d;
   e2 = s10 & (1 << -nBits) - 1;
@@ -19282,14 +19282,14 @@ ieee754.read = function(buffer2, offset2, isLE, mLen, nBytes) {
   }
   return (s10 ? -1 : 1) * m * Math.pow(2, e2 - mLen);
 };
-ieee754.write = function(buffer2, value, offset2, isLE, mLen, nBytes) {
+ieee754.write = function(buffer2, value, offset2, isLE2, mLen, nBytes) {
   var e2, m, c;
   var eLen = nBytes * 8 - mLen - 1;
   var eMax = (1 << eLen) - 1;
   var eBias = eMax >> 1;
   var rt2 = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
-  var i10 = isLE ? 0 : nBytes - 1;
-  var d = isLE ? 1 : -1;
+  var i10 = isLE2 ? 0 : nBytes - 1;
+  var d = isLE2 ? 1 : -1;
   var s10 = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
   value = Math.abs(value);
   if (isNaN(value) || value === Infinity) {
@@ -20180,10 +20180,10 @@ ieee754.write = function(buffer2, value, offset2, isLE, mLen, nBytes) {
     byteLength3 = byteLength3 >>> 0;
     if (!noAssert) checkOffset(offset2, byteLength3, this.length);
     let val = this[offset2];
-    let mul = 1;
+    let mul3 = 1;
     let i10 = 0;
-    while (++i10 < byteLength3 && (mul *= 256)) {
-      val += this[offset2 + i10] * mul;
+    while (++i10 < byteLength3 && (mul3 *= 256)) {
+      val += this[offset2 + i10] * mul3;
     }
     return val;
   };
@@ -20194,9 +20194,9 @@ ieee754.write = function(buffer2, value, offset2, isLE, mLen, nBytes) {
       checkOffset(offset2, byteLength3, this.length);
     }
     let val = this[offset2 + --byteLength3];
-    let mul = 1;
-    while (byteLength3 > 0 && (mul *= 256)) {
-      val += this[offset2 + --byteLength3] * mul;
+    let mul3 = 1;
+    while (byteLength3 > 0 && (mul3 *= 256)) {
+      val += this[offset2 + --byteLength3] * mul3;
     }
     return val;
   };
@@ -20254,13 +20254,13 @@ ieee754.write = function(buffer2, value, offset2, isLE, mLen, nBytes) {
     byteLength3 = byteLength3 >>> 0;
     if (!noAssert) checkOffset(offset2, byteLength3, this.length);
     let val = this[offset2];
-    let mul = 1;
+    let mul3 = 1;
     let i10 = 0;
-    while (++i10 < byteLength3 && (mul *= 256)) {
-      val += this[offset2 + i10] * mul;
+    while (++i10 < byteLength3 && (mul3 *= 256)) {
+      val += this[offset2 + i10] * mul3;
     }
-    mul *= 128;
-    if (val >= mul) val -= Math.pow(2, 8 * byteLength3);
+    mul3 *= 128;
+    if (val >= mul3) val -= Math.pow(2, 8 * byteLength3);
     return val;
   };
   Buffer2.prototype.readIntBE = function readIntBE(offset2, byteLength3, noAssert) {
@@ -20268,13 +20268,13 @@ ieee754.write = function(buffer2, value, offset2, isLE, mLen, nBytes) {
     byteLength3 = byteLength3 >>> 0;
     if (!noAssert) checkOffset(offset2, byteLength3, this.length);
     let i10 = byteLength3;
-    let mul = 1;
+    let mul3 = 1;
     let val = this[offset2 + --i10];
-    while (i10 > 0 && (mul *= 256)) {
-      val += this[offset2 + --i10] * mul;
+    while (i10 > 0 && (mul3 *= 256)) {
+      val += this[offset2 + --i10] * mul3;
     }
-    mul *= 128;
-    if (val >= mul) val -= Math.pow(2, 8 * byteLength3);
+    mul3 *= 128;
+    if (val >= mul3) val -= Math.pow(2, 8 * byteLength3);
     return val;
   };
   Buffer2.prototype.readInt8 = function readInt8(offset2, noAssert) {
@@ -20361,11 +20361,11 @@ ieee754.write = function(buffer2, value, offset2, isLE, mLen, nBytes) {
       const maxBytes = Math.pow(2, 8 * byteLength3) - 1;
       checkInt(this, value, offset2, byteLength3, maxBytes, 0);
     }
-    let mul = 1;
+    let mul3 = 1;
     let i10 = 0;
     this[offset2] = value & 255;
-    while (++i10 < byteLength3 && (mul *= 256)) {
-      this[offset2 + i10] = value / mul & 255;
+    while (++i10 < byteLength3 && (mul3 *= 256)) {
+      this[offset2 + i10] = value / mul3 & 255;
     }
     return offset2 + byteLength3;
   };
@@ -20378,10 +20378,10 @@ ieee754.write = function(buffer2, value, offset2, isLE, mLen, nBytes) {
       checkInt(this, value, offset2, byteLength3, maxBytes, 0);
     }
     let i10 = byteLength3 - 1;
-    let mul = 1;
+    let mul3 = 1;
     this[offset2 + i10] = value & 255;
-    while (--i10 >= 0 && (mul *= 256)) {
-      this[offset2 + i10] = value / mul & 255;
+    while (--i10 >= 0 && (mul3 *= 256)) {
+      this[offset2 + i10] = value / mul3 & 255;
     }
     return offset2 + byteLength3;
   };
@@ -20482,14 +20482,14 @@ ieee754.write = function(buffer2, value, offset2, isLE, mLen, nBytes) {
       checkInt(this, value, offset2, byteLength3, limit - 1, -limit);
     }
     let i10 = 0;
-    let mul = 1;
+    let mul3 = 1;
     let sub = 0;
     this[offset2] = value & 255;
-    while (++i10 < byteLength3 && (mul *= 256)) {
+    while (++i10 < byteLength3 && (mul3 *= 256)) {
       if (value < 0 && sub === 0 && this[offset2 + i10 - 1] !== 0) {
         sub = 1;
       }
-      this[offset2 + i10] = (value / mul >> 0) - sub & 255;
+      this[offset2 + i10] = (value / mul3 >> 0) - sub & 255;
     }
     return offset2 + byteLength3;
   };
@@ -20501,14 +20501,14 @@ ieee754.write = function(buffer2, value, offset2, isLE, mLen, nBytes) {
       checkInt(this, value, offset2, byteLength3, limit - 1, -limit);
     }
     let i10 = byteLength3 - 1;
-    let mul = 1;
+    let mul3 = 1;
     let sub = 0;
     this[offset2 + i10] = value & 255;
-    while (--i10 >= 0 && (mul *= 256)) {
+    while (--i10 >= 0 && (mul3 *= 256)) {
       if (value < 0 && sub === 0 && this[offset2 + i10 + 1] !== 0) {
         sub = 1;
       }
-      this[offset2 + i10] = (value / mul >> 0) - sub & 255;
+      this[offset2 + i10] = (value / mul3 >> 0) - sub & 255;
     }
     return offset2 + byteLength3;
   };
@@ -23009,23 +23009,23 @@ var sha_jsExports = sha_js.exports;
 var SHA = /* @__PURE__ */ getDefaultExportFromCjs(sha_jsExports);
 const fromNumH = (n8) => n8 / 2 ** 32 | 0;
 const fromNumL = (n8) => n8 >>> 0;
-function setU64FromNum(view, byteOffset, n8, isLE) {
+function setU64FromNum(view, byteOffset, n8, isLE2) {
   const h = fromNumH(n8);
   const l = fromNumL(n8);
-  view.setUint32(byteOffset, isLE ? l : h, isLE);
-  view.setUint32(byteOffset + 4, isLE ? h : l, isLE);
+  view.setUint32(byteOffset, isLE2 ? l : h, isLE2);
+  view.setUint32(byteOffset + 4, isLE2 ? h : l, isLE2);
 }
-function isBytes(a) {
+function isBytes$1(a) {
   return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array" && "BYTES_PER_ELEMENT" in a && a.BYTES_PER_ELEMENT === 1;
 }
-const atitle = (title) => title ? `"${title}" ` : "";
-function abytes(value, length, title = "") {
-  if (isBytes(value) && length === void 0)
+const atitle$1 = (title) => title ? `"${title}" ` : "";
+function abytes$1(value, length, title = "") {
+  if (isBytes$1(value) && length === void 0)
     return value;
-  const bytes2 = isBytes(value);
+  const bytes2 = isBytes$1(value);
   const ofLen = "";
   const got = bytes2 ? `length=${value.length}` : `type=${typeof value}`;
-  const message = atitle(title) + "expected Uint8Array" + ofLen + ", got " + got;
+  const message = atitle$1(title) + "expected Uint8Array" + ofLen + ", got " + got;
   if (!bytes2)
     throw new TypeError(message);
   throw new RangeError(message);
@@ -23034,25 +23034,25 @@ const aobject = (value, label) => {
   if (value === null || typeof value !== "object" || Array.isArray(value))
     throw new TypeError((label === "object" ? "" : `"${label}" `) + "expected object, got type=" + typeof value);
 };
-function aexists(instance, checkFinished = true) {
+function aexists$1(instance, checkFinished = true) {
   if (instance.destroyed)
     throw new Error("hash was destroyed");
   if (checkFinished && instance.finished)
     throw new Error("digest() was already called");
 }
-function aoutput(out, instance) {
-  abytes(out, void 0, "output");
+function aoutput$1(out, instance) {
+  abytes$1(out, void 0, "output");
   const min2 = instance.outputLen;
   if (!(out.length >= min2)) {
     throw new RangeError('"output" expected length >= ' + min2);
   }
 }
-function clean(...arrays) {
+function clean$1(...arrays) {
   for (let i10 = 0; i10 < arrays.length; i10++) {
     arrays[i10].fill(0);
   }
 }
-function createView(arr) {
+function createView$1(arr) {
   return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
 }
 function rotr(word, shift) {
@@ -23067,7 +23067,7 @@ const hasHexBuiltin = /* @__PURE__ */ (() => (
 ))();
 const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i10) => i10.toString(16).padStart(2, "0"));
 function bytesToHex(bytes2) {
-  abytes(bytes2);
+  abytes$1(bytes2);
   if (hasHexBuiltin)
     return bytes2.toHex();
   let hex = "";
@@ -23108,7 +23108,7 @@ function Maj(a, b, c) {
   return a & b ^ a & c ^ b & c;
 }
 class HashMD {
-  constructor(blockLen, outputLen, padOffset, isLE) {
+  constructor(blockLen, outputLen, padOffset, isLE2) {
     __publicField(this, "blockLen");
     __publicField(this, "outputLen");
     __publicField(this, "canXOF", false);
@@ -23124,20 +23124,20 @@ class HashMD {
     this.blockLen = blockLen;
     this.outputLen = outputLen;
     this.padOffset = padOffset;
-    this.isLE = isLE;
+    this.isLE = isLE2;
     this.buffer = new Uint8Array(blockLen);
-    this.view = createView(this.buffer);
+    this.view = createView$1(this.buffer);
   }
   update(data2) {
-    aexists(this);
-    abytes(data2);
+    aexists$1(this);
+    abytes$1(data2);
     const { view, buffer: buffer2, blockLen } = this;
     const len2 = data2.length;
     let processed = false;
     for (let pos = 0; pos < len2; ) {
       const take = Math.min(blockLen - this.pos, len2 - pos);
       if (take === blockLen) {
-        const dataView = createView(data2);
+        const dataView = createView$1(data2);
         for (; blockLen <= len2 - pos; pos += blockLen)
           this.process(dataView, pos);
         processed = true;
@@ -23158,10 +23158,10 @@ class HashMD {
     return this;
   }
   digestInto(out) {
-    aexists(this);
-    aoutput(out, this);
+    aexists$1(this);
+    aoutput$1(out, this);
     this.finished = true;
-    const { buffer: buffer2, view, blockLen, isLE } = this;
+    const { buffer: buffer2, view, blockLen, isLE: isLE2 } = this;
     let { pos } = this;
     buffer2[pos++] = 128;
     buffer2.fill(0, pos);
@@ -23169,17 +23169,17 @@ class HashMD {
       this.process(view, 0);
       buffer2.fill(0);
     }
-    setU64FromNum(view, blockLen - 8, this.length * 8, isLE);
+    setU64FromNum(view, blockLen - 8, this.length * 8, isLE2);
     this.process(view, 0);
     this.roundClean();
-    const oview = out === buffer2 ? view : createView(out);
+    const oview = out === buffer2 ? view : createView$1(out);
     const len2 = this.outputLen;
     const outLen = len2 / 4;
     const state = this.get();
     if (len2 % 4 || outLen > state.length)
       throw new Error("invalid outputLen");
     for (let i10 = 0; i10 < outLen; i10++)
-      oview.setUint32(4 * i10, state[i10], isLE);
+      oview.setUint32(4 * i10, state[i10], isLE2);
   }
   digest() {
     const { buffer: buffer2, outputLen } = this;
@@ -23286,12 +23286,12 @@ class _MD5 extends HashMD {
     this.set(A10, B, C, D10);
   }
   roundClean() {
-    clean(MD5_W);
+    clean$1(MD5_W);
   }
   destroy() {
     this.destroyed = true;
     this.set(0, 0, 0, 0);
-    clean(this.buffer);
+    clean$1(this.buffer);
   }
 }
 const md5 = /* @__PURE__ */ createHasher(() => new _MD5());
@@ -23301,6 +23301,993 @@ const cryptoConstants = {
   RSA_PKCS1_OAEP_PADDING: 4,
   RSA_PKCS1_PSS_PADDING: 6
 };
+/*! noble-ciphers - MIT License (c) 2023 Paul Miller (paulmillr.com) */
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array" && "BYTES_PER_ELEMENT" in a && a.BYTES_PER_ELEMENT === 1;
+}
+const atitle = (title) => title ? `"${title}" ` : "";
+function anumber(n8, title = "") {
+  if (typeof n8 !== "number")
+    throw new TypeError(atitle(title) + "expected number, got " + typeof n8);
+  if (!Number.isSafeInteger(n8) || n8 < 0)
+    throw new RangeError(atitle(title) + "expected integer >= 0, got " + n8);
+  return n8;
+}
+function abytes(value, length, title = "") {
+  if (isBytes(value) && (length === void 0 || value.length === length))
+    return value;
+  if (length !== void 0)
+    anumber(length, "length");
+  const bytes2 = isBytes(value);
+  const ofLen = length !== void 0 ? ` of length ${length}` : "";
+  const got = bytes2 ? `length=${value.length}` : `type=${typeof value}`;
+  const message = atitle(title) + "expected Uint8Array" + ofLen + ", got " + got;
+  if (!bytes2)
+    throw new TypeError(message);
+  throw new RangeError(message);
+}
+function aexists(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("hash was destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("digest() was already called");
+}
+function aoutput(out, instance) {
+  abytes(out, void 0, "output");
+  const min2 = instance.outputLen;
+  if (!(out.length >= min2)) {
+    throw new RangeError('"output" expected length >= ' + min2);
+  }
+}
+function aoutput32(out, instance) {
+  aoutput(out, instance);
+  if (!isAligned32(out))
+    throw new Error("invalid output, must be aligned");
+}
+function u8$1(arr) {
+  return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+function u32(arr) {
+  return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+}
+function clean(...arrays) {
+  for (let i10 = 0; i10 < arrays.length; i10++) {
+    arrays[i10].fill(0);
+  }
+}
+function createView(arr) {
+  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+const isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
+function byteSwap(word) {
+  return word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
+}
+const swap8IfBE = isLE ? (n8) => n8 : (n8) => byteSwap(n8) >>> 0;
+function byteSwap32(arr) {
+  for (let i10 = 0; i10 < arr.length; i10++) {
+    arr[i10] = byteSwap(arr[i10]);
+  }
+  return arr;
+}
+const swap32IfBE = isLE ? (u) => u : byteSwap32;
+function overlapBytes(a, b) {
+  if (!a.byteLength || !b.byteLength)
+    return false;
+  return a.buffer === b.buffer && // best we can do, may fail with an obscure Proxy
+  a.byteOffset < b.byteOffset + b.byteLength && // a starts before b end
+  b.byteOffset < a.byteOffset + a.byteLength;
+}
+function complexOverlapBytes(input, output) {
+  if (overlapBytes(input, output) && input.byteOffset < output.byteOffset)
+    throw new Error("complex overlap of input and output is not supported");
+}
+function wrapMacConstructor(keyLen, macCons, fromMsg) {
+  const mac = macCons;
+  const getArgs = fromMsg || (() => []);
+  const macC = (msg2, key) => mac(key, ...getArgs(msg2)).update(msg2).digest();
+  const tmp = mac(new Uint8Array(keyLen), ...getArgs(new Uint8Array(0)));
+  macC.outputLen = tmp.outputLen;
+  macC.blockLen = tmp.blockLen;
+  macC.create = (key, ...args) => mac(key, ...args);
+  return macC;
+}
+function getOutput(expectedLength, out, onlyAligned = true) {
+  if (out === void 0)
+    return new Uint8Array(expectedLength);
+  abytes(out, expectedLength, "output");
+  if (onlyAligned && !isAligned32(out))
+    throw new Error("invalid output, must be aligned");
+  return out;
+}
+function isAligned32(bytes2) {
+  return bytes2.byteOffset % 4 === 0;
+}
+function copyBytes(bytes2) {
+  return Uint8Array.from(abytes(bytes2));
+}
+const BLOCK_SIZE$1 = 16;
+const ZEROS16 = /* @__PURE__ */ new Uint8Array(16);
+const ZEROS32 = /* @__PURE__ */ u32(ZEROS16);
+const POLY$1 = 225;
+const mul2$1 = (s02, s12, s22, s32) => {
+  const hiBit = s32 & 1;
+  return {
+    s3: s22 << 31 | s32 >>> 1,
+    s2: s12 << 31 | s22 >>> 1,
+    s1: s02 << 31 | s12 >>> 1,
+    // NIST SP 800-38D §6.3 applies `V >> 1` and XORs R on carry. In this
+    // 4x32-bit split, R = 0xe1 || 0^120 lives in the top byte of s0.
+    s0: s02 >>> 1 ^ POLY$1 << 24 & -(hiBit & 1)
+    // reduce % poly
+  };
+};
+const swapLE = (n8) => (n8 >>> 0 & 255) << 24 | (n8 >>> 8 & 255) << 16 | (n8 >>> 16 & 255) << 8 | n8 >>> 24 & 255 | 0;
+const estimateWindow = (bytes2) => {
+  if (bytes2 > 64 * 1024)
+    return 8;
+  if (bytes2 > 1024)
+    return 4;
+  return 2;
+};
+class GHASH {
+  // We select bits per window adaptively based on expectedLength
+  constructor(key, expectedLength) {
+    __publicField(this, "blockLen", BLOCK_SIZE$1);
+    __publicField(this, "outputLen", BLOCK_SIZE$1);
+    __publicField(this, "s0", 0);
+    __publicField(this, "s1", 0);
+    __publicField(this, "s2", 0);
+    __publicField(this, "s3", 0);
+    __publicField(this, "finished", false);
+    __publicField(this, "destroyed", false);
+    __publicField(this, "t");
+    __publicField(this, "W");
+    __publicField(this, "windowSize");
+    abytes(key, 16, "key");
+    key = copyBytes(key);
+    const kView = createView(key);
+    let k02 = kView.getUint32(0, false);
+    let k12 = kView.getUint32(4, false);
+    let k22 = kView.getUint32(8, false);
+    let k32 = kView.getUint32(12, false);
+    const doubles = [];
+    for (let i10 = 0; i10 < 128; i10++) {
+      doubles.push({ s0: swapLE(k02), s1: swapLE(k12), s2: swapLE(k22), s3: swapLE(k32) });
+      ({ s0: k02, s1: k12, s2: k22, s3: k32 } = mul2$1(k02, k12, k22, k32));
+    }
+    const W10 = estimateWindow(expectedLength || 1024);
+    if (![1, 2, 4, 8].includes(W10))
+      throw new Error("ghash: invalid window size, expected 2, 4 or 8");
+    this.W = W10;
+    const bits = 128;
+    const windows = bits / W10;
+    const windowSize = this.windowSize = 2 ** W10;
+    const items = [];
+    for (let w = 0; w < windows; w++) {
+      for (let byte = 0; byte < windowSize; byte++) {
+        let s02 = 0, s12 = 0, s22 = 0, s32 = 0;
+        for (let j = 0; j < W10; j++) {
+          const bit = byte >>> W10 - j - 1 & 1;
+          if (!bit)
+            continue;
+          const { s0: d02, s1: d12, s2: d22, s3: d32 } = doubles[W10 * w + j];
+          s02 ^= d02, s12 ^= d12, s22 ^= d22, s32 ^= d32;
+        }
+        items.push({ s0: s02, s1: s12, s2: s22, s3: s32 });
+      }
+    }
+    this.t = items;
+  }
+  _updateBlock(s02, s12, s22, s32) {
+    s02 ^= this.s0, s12 ^= this.s1, s22 ^= this.s2, s32 ^= this.s3;
+    const { W: W10, t: t10, windowSize } = this;
+    let o02 = 0, o12 = 0, o22 = 0, o32 = 0;
+    const mask = (1 << W10) - 1;
+    let w = 0;
+    for (const num of [s02, s12, s22, s32]) {
+      for (let bytePos = 0; bytePos < 4; bytePos++) {
+        const byte = num >>> 8 * bytePos & 255;
+        for (let bitPos = 8 / W10 - 1; bitPos >= 0; bitPos--) {
+          const bit = byte >>> W10 * bitPos & mask;
+          const { s0: e0, s1: e12, s2: e2, s3: e32 } = t10[w * windowSize + bit];
+          o02 ^= e0, o12 ^= e12, o22 ^= e2, o32 ^= e32;
+          w += 1;
+        }
+      }
+    }
+    this.s0 = o02;
+    this.s1 = o12;
+    this.s2 = o22;
+    this.s3 = o32;
+  }
+  update(data2) {
+    aexists(this);
+    abytes(data2);
+    data2 = copyBytes(data2);
+    const b32 = u32(data2);
+    const blocks = Math.floor(data2.length / BLOCK_SIZE$1);
+    const left = data2.length % BLOCK_SIZE$1;
+    for (let i10 = 0; i10 < blocks; i10++) {
+      this._updateBlock(swap8IfBE(b32[i10 * 4 + 0]), swap8IfBE(b32[i10 * 4 + 1]), swap8IfBE(b32[i10 * 4 + 2]), swap8IfBE(b32[i10 * 4 + 3]));
+    }
+    if (left) {
+      ZEROS16.set(data2.subarray(blocks * BLOCK_SIZE$1));
+      this._updateBlock(swap8IfBE(ZEROS32[0]), swap8IfBE(ZEROS32[1]), swap8IfBE(ZEROS32[2]), swap8IfBE(ZEROS32[3]));
+      clean(ZEROS32);
+    }
+    return this;
+  }
+  destroy() {
+    this.destroyed = true;
+    const { t: t10 } = this;
+    for (const elm of t10) {
+      elm.s0 = 0, elm.s1 = 0, elm.s2 = 0, elm.s3 = 0;
+    }
+  }
+  digestInto(out) {
+    aexists(this);
+    aoutput32(out, this);
+    this.finished = true;
+    const { s0: s02, s1: s12, s2: s22, s3: s32 } = this;
+    const o32 = u32(out);
+    o32[0] = s02;
+    o32[1] = s12;
+    o32[2] = s22;
+    o32[3] = s32;
+    if (!isLE)
+      swap32IfBE(o32.subarray(0, BLOCK_SIZE$1 / 4));
+  }
+  digest() {
+    const res = new Uint8Array(BLOCK_SIZE$1);
+    this.digestInto(res);
+    this.destroy();
+    return res;
+  }
+}
+const BLOCK_SIZE = 16;
+const BLOCK_SIZE32 = 4;
+const EMPTY_BLOCK = /* @__PURE__ */ new Uint8Array(BLOCK_SIZE);
+const ONE_BLOCK = /* @__PURE__ */ Uint8Array.from([
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  1
+]);
+const POLY = 283;
+function validateKeyLength(key) {
+  if (![16, 24, 32].includes(key.length))
+    throw new Error('"aes key" expected Uint8Array of length 16/24/32, got length=' + key.length);
+}
+function mul2(n8) {
+  return n8 << 1 ^ POLY & -(n8 >> 7);
+}
+function mul(a, b) {
+  let res = 0;
+  for (; b > 0; b >>= 1) {
+    res ^= a & -(b & 1);
+    a = mul2(a);
+  }
+  return res;
+}
+const sbox = /* @__PURE__ */ (() => {
+  const t10 = new Uint8Array(256);
+  for (let i10 = 0, x = 1; i10 < 256; i10++, x ^= mul2(x))
+    t10[i10] = x;
+  const box = new Uint8Array(256);
+  box[0] = 99;
+  for (let i10 = 0; i10 < 255; i10++) {
+    let x = t10[255 - i10];
+    x |= x << 8;
+    box[t10[i10]] = (x ^ x >> 4 ^ x >> 5 ^ x >> 6 ^ x >> 7 ^ 99) & 255;
+  }
+  clean(t10);
+  return box;
+})();
+const invSbox = /* @__PURE__ */ sbox.map((_, j) => sbox.indexOf(j));
+const rotr32_8 = (n8) => n8 << 24 | n8 >>> 8;
+const rotl32_8 = (n8) => n8 << 8 | n8 >>> 24;
+function genTtable(sbox2, fn2) {
+  if (sbox2.length !== 256)
+    throw new Error("wrong sbox length");
+  const T02 = new Uint32Array(256).map((_, j) => fn2(sbox2[j]));
+  const T12 = T02.map(rotl32_8);
+  const T22 = T12.map(rotl32_8);
+  const T32 = T22.map(rotl32_8);
+  const T01 = new Uint32Array(256 * 256);
+  const T23 = new Uint32Array(256 * 256);
+  const sbox22 = new Uint16Array(256 * 256);
+  for (let i10 = 0; i10 < 256; i10++) {
+    for (let j = 0; j < 256; j++) {
+      const idx = i10 * 256 + j;
+      T01[idx] = T02[i10] ^ T12[j];
+      T23[idx] = T22[i10] ^ T32[j];
+      sbox22[idx] = sbox2[i10] << 8 | sbox2[j];
+    }
+  }
+  return { sbox: sbox2, sbox2: sbox22, T0: T02, T1: T12, T2: T22, T3: T32, T01, T23 };
+}
+const tableEncoding = /* @__PURE__ */ genTtable(sbox, (s10) => mul(s10, 3) << 24 | s10 << 16 | s10 << 8 | mul(s10, 2));
+const tableDecoding = /* @__PURE__ */ genTtable(invSbox, (s10) => mul(s10, 11) << 24 | mul(s10, 13) << 16 | mul(s10, 9) << 8 | mul(s10, 14));
+const xPowers = /* @__PURE__ */ (() => {
+  const p = new Uint8Array(16);
+  for (let i10 = 0, x = 1; i10 < 16; i10++, x = mul2(x))
+    p[i10] = x;
+  return p;
+})();
+function expandKeyLE(key) {
+  abytes(key);
+  const len2 = key.length;
+  validateKeyLength(key);
+  const { sbox2 } = tableEncoding;
+  const toClean = [];
+  if (!isLE || !isAligned32(key))
+    toClean.push(key = copyBytes(key));
+  const k32 = swap32IfBE(u32(key));
+  const Nk = k32.length;
+  const subByte = (n8) => applySbox(sbox2, n8, n8, n8, n8);
+  const xk = new Uint32Array(len2 + 28);
+  xk.set(k32);
+  for (let i10 = Nk; i10 < xk.length; i10++) {
+    let t10 = xk[i10 - 1];
+    if (i10 % Nk === 0)
+      t10 = subByte(rotr32_8(t10)) ^ xPowers[i10 / Nk - 1];
+    else if (Nk > 6 && i10 % Nk === 4)
+      t10 = subByte(t10);
+    xk[i10] = xk[i10 - Nk] ^ t10;
+  }
+  clean(...toClean);
+  return xk;
+}
+function expandKeyDecLE(key) {
+  const encKey = expandKeyLE(key);
+  const xk = encKey.slice();
+  const Nk = encKey.length;
+  const { sbox2 } = tableEncoding;
+  const { T0: T02, T1: T12, T2: T22, T3: T32 } = tableDecoding;
+  for (let i10 = 0; i10 < Nk; i10 += 4) {
+    for (let j = 0; j < 4; j++)
+      xk[i10 + j] = encKey[Nk - i10 - 4 + j];
+  }
+  clean(encKey);
+  for (let i10 = 4; i10 < Nk - 4; i10++) {
+    const x = xk[i10];
+    const w = applySbox(sbox2, x, x, x, x);
+    xk[i10] = T02[w & 255] ^ T12[w >>> 8 & 255] ^ T22[w >>> 16 & 255] ^ T32[w >>> 24];
+  }
+  return xk;
+}
+function apply0123(T01, T23, s02, s12, s22, s32) {
+  return T01[s02 << 8 & 65280 | s12 >>> 8 & 255] ^ T23[s22 >>> 8 & 65280 | s32 >>> 24 & 255];
+}
+function applySbox(sbox2, s02, s12, s22, s32) {
+  return sbox2[s02 & 255 | s12 & 65280] | sbox2[s22 >>> 16 & 255 | s32 >>> 16 & 65280] << 16;
+}
+function encrypt(xk, s02, s12, s22, s32) {
+  const { sbox2, T01, T23 } = tableEncoding;
+  let k10 = 0;
+  s02 ^= xk[k10++], s12 ^= xk[k10++], s22 ^= xk[k10++], s32 ^= xk[k10++];
+  const rounds = xk.length / 4 - 2;
+  for (let i10 = 0; i10 < rounds; i10++) {
+    const t03 = xk[k10++] ^ apply0123(T01, T23, s02, s12, s22, s32);
+    const t13 = xk[k10++] ^ apply0123(T01, T23, s12, s22, s32, s02);
+    const t23 = xk[k10++] ^ apply0123(T01, T23, s22, s32, s02, s12);
+    const t33 = xk[k10++] ^ apply0123(T01, T23, s32, s02, s12, s22);
+    s02 = t03, s12 = t13, s22 = t23, s32 = t33;
+  }
+  const t02 = xk[k10++] ^ applySbox(sbox2, s02, s12, s22, s32);
+  const t12 = xk[k10++] ^ applySbox(sbox2, s12, s22, s32, s02);
+  const t22 = xk[k10++] ^ applySbox(sbox2, s22, s32, s02, s12);
+  const t32 = xk[k10++] ^ applySbox(sbox2, s32, s02, s12, s22);
+  return { s0: t02, s1: t12, s2: t22, s3: t32 };
+}
+function decrypt(xk, s02, s12, s22, s32) {
+  const { sbox2, T01, T23 } = tableDecoding;
+  let k10 = 0;
+  s02 ^= xk[k10++], s12 ^= xk[k10++], s22 ^= xk[k10++], s32 ^= xk[k10++];
+  const rounds = xk.length / 4 - 2;
+  for (let i10 = 0; i10 < rounds; i10++) {
+    const t03 = xk[k10++] ^ apply0123(T01, T23, s02, s32, s22, s12);
+    const t13 = xk[k10++] ^ apply0123(T01, T23, s12, s02, s32, s22);
+    const t23 = xk[k10++] ^ apply0123(T01, T23, s22, s12, s02, s32);
+    const t33 = xk[k10++] ^ apply0123(T01, T23, s32, s22, s12, s02);
+    s02 = t03, s12 = t13, s22 = t23, s32 = t33;
+  }
+  const t02 = xk[k10++] ^ applySbox(sbox2, s02, s32, s22, s12);
+  const t12 = xk[k10++] ^ applySbox(sbox2, s12, s02, s32, s22);
+  const t22 = xk[k10++] ^ applySbox(sbox2, s22, s12, s02, s32);
+  const t32 = xk[k10++] ^ applySbox(sbox2, s32, s22, s12, s02);
+  return { s0: t02, s1: t12, s2: t22, s3: t32 };
+}
+function ctrCounter(xk, nonce, src, dst) {
+  abytes(nonce, BLOCK_SIZE, "nonce");
+  abytes(src);
+  const srcLen = src.length;
+  dst = getOutput(srcLen, dst);
+  complexOverlapBytes(src, dst);
+  const ctr = nonce;
+  const c32 = u32(ctr);
+  const src32 = u32(src);
+  const dst32 = u32(dst);
+  for (let i10 = 0; i10 + 4 <= src32.length; i10 += 4) {
+    const { s0: s02, s1: s12, s2: s22, s3: s32 } = encrypt(xk, swap8IfBE(c32[0]), swap8IfBE(c32[1]), swap8IfBE(c32[2]), swap8IfBE(c32[3]));
+    dst32[i10 + 0] = src32[i10 + 0] ^ swap8IfBE(s02);
+    dst32[i10 + 1] = src32[i10 + 1] ^ swap8IfBE(s12);
+    dst32[i10 + 2] = src32[i10 + 2] ^ swap8IfBE(s22);
+    dst32[i10 + 3] = src32[i10 + 3] ^ swap8IfBE(s32);
+    for (let j = BLOCK_SIZE - 1, carry = 1; j >= 0; j--) {
+      carry = carry + ctr[j] | 0;
+      ctr[j] = carry & 255;
+      carry >>>= 8;
+    }
+  }
+  const start = BLOCK_SIZE * Math.floor(src32.length / BLOCK_SIZE32);
+  if (start < srcLen) {
+    const { s0: s02, s1: s12, s2: s22, s3: s32 } = encrypt(xk, swap8IfBE(c32[0]), swap8IfBE(c32[1]), swap8IfBE(c32[2]), swap8IfBE(c32[3]));
+    const b32 = new Uint32Array([s02, s12, s22, s32]);
+    swap32IfBE(b32);
+    const buf = u8$1(b32);
+    for (let i10 = start, pos = 0; i10 < srcLen; i10++, pos++)
+      dst[i10] = src[i10] ^ buf[pos];
+    clean(b32);
+  }
+  return dst;
+}
+function ctr32(xk, isLE2, nonce, src, dst) {
+  abytes(nonce, BLOCK_SIZE, "nonce");
+  abytes(src);
+  dst = getOutput(src.length, dst);
+  const ctr = nonce;
+  const c32 = u32(ctr);
+  const view = createView(ctr);
+  const src32 = u32(src);
+  const dst32 = u32(dst);
+  const ctrPos = isLE2 ? 0 : 12;
+  const srcLen = src.length;
+  let ctrNum = view.getUint32(ctrPos, isLE2);
+  for (let i10 = 0; i10 + 4 <= src32.length; i10 += 4) {
+    const { s0: s02, s1: s12, s2: s22, s3: s32 } = encrypt(xk, swap8IfBE(c32[0]), swap8IfBE(c32[1]), swap8IfBE(c32[2]), swap8IfBE(c32[3]));
+    dst32[i10 + 0] = src32[i10 + 0] ^ swap8IfBE(s02);
+    dst32[i10 + 1] = src32[i10 + 1] ^ swap8IfBE(s12);
+    dst32[i10 + 2] = src32[i10 + 2] ^ swap8IfBE(s22);
+    dst32[i10 + 3] = src32[i10 + 3] ^ swap8IfBE(s32);
+    ctrNum = ctrNum + 1 >>> 0;
+    view.setUint32(ctrPos, ctrNum, isLE2);
+  }
+  const start = BLOCK_SIZE * Math.floor(src32.length / BLOCK_SIZE32);
+  if (start < srcLen) {
+    const { s0: s02, s1: s12, s2: s22, s3: s32 } = encrypt(xk, swap8IfBE(c32[0]), swap8IfBE(c32[1]), swap8IfBE(c32[2]), swap8IfBE(c32[3]));
+    const b32 = new Uint32Array([s02, s12, s22, s32]);
+    swap32IfBE(b32);
+    const buf = u8$1(b32);
+    for (let i10 = start, pos = 0; i10 < srcLen; i10++, pos++)
+      dst[i10] = src[i10] ^ buf[pos];
+    clean(b32);
+  }
+  return dst;
+}
+function isBytes32(a) {
+  return a instanceof Uint32Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint32Array";
+}
+function encryptBlock(xk, block) {
+  abytes(block, 16, "block");
+  if (!isBytes32(xk))
+    throw new Error("_encryptBlock accepts result of expandKeyLE");
+  const b32 = u32(block);
+  swap32IfBE(b32);
+  let { s0: s02, s1: s12, s2: s22, s3: s32 } = encrypt(xk, b32[0], b32[1], b32[2], b32[3]);
+  b32[0] = s02, b32[1] = s12, b32[2] = s22, b32[3] = s32;
+  swap32IfBE(b32);
+  return block;
+}
+function decryptBlock(xk, block) {
+  abytes(block, 16, "block");
+  if (!isBytes32(xk))
+    throw new Error("_decryptBlock accepts result of expandKeyLE");
+  const b32 = u32(block);
+  swap32IfBE(b32);
+  let { s0: s02, s1: s12, s2: s22, s3: s32 } = decrypt(xk, b32[0], b32[1], b32[2], b32[3]);
+  b32[0] = s02, b32[1] = s12, b32[2] = s22, b32[3] = s32;
+  swap32IfBE(b32);
+  return block;
+}
+function dbl(block) {
+  let carry = 0;
+  for (let i10 = BLOCK_SIZE - 1; i10 >= 0; i10--) {
+    const newCarry = (block[i10] & 128) >>> 7;
+    block[i10] = block[i10] << 1 | carry;
+    carry = newCarry;
+  }
+  block[BLOCK_SIZE - 1] ^= 135 & -carry;
+  return block;
+}
+function xorBlock(a, b) {
+  if (a.length !== b.length)
+    throw new Error("xorBlock: blocks must have same length");
+  for (let i10 = 0; i10 < a.length; i10++) {
+    a[i10] = a[i10] ^ b[i10];
+  }
+  return a;
+}
+function xorend(a, b) {
+  if (b.length > a.length) {
+    throw new Error("xorend: expected len(B) <= len(A)");
+  }
+  const offset2 = a.length - b.length;
+  for (let i10 = 0; i10 < b.length; i10++) {
+    a[offset2 + i10] = a[offset2 + i10] ^ b[i10];
+  }
+  return a;
+}
+class _CMAC {
+  constructor(key) {
+    __publicField(this, "blockLen", BLOCK_SIZE);
+    __publicField(this, "outputLen", BLOCK_SIZE);
+    // CMAC can only decide between `K1` and `K2` once the true final block is known,
+    // so updates process older blocks eagerly but keep one pending block buffered.
+    __publicField(this, "buffer");
+    __publicField(this, "pos");
+    __publicField(this, "finished");
+    __publicField(this, "destroyed");
+    __publicField(this, "k1");
+    __publicField(this, "k2");
+    __publicField(this, "x");
+    __publicField(this, "x32");
+    __publicField(this, "xk");
+    abytes(key);
+    validateKeyLength(key);
+    this.xk = expandKeyLE(key);
+    this.buffer = new Uint8Array(BLOCK_SIZE);
+    this.pos = 0;
+    this.finished = false;
+    this.destroyed = false;
+    this.x = new Uint8Array(BLOCK_SIZE);
+    this.x32 = u32(this.x);
+    const L = new Uint8Array(BLOCK_SIZE);
+    encryptBlock(this.xk, L);
+    this.k1 = dbl(L);
+    this.k2 = dbl(new Uint8Array(this.k1));
+  }
+  // Consumes 16 bytes of `data` starting at `pos`; `pos` avoids a per-block
+  // subarray view allocation in update().
+  process(data2, pos) {
+    const { x, x32, xk } = this;
+    for (let i10 = 0; i10 < BLOCK_SIZE; i10++)
+      x[i10] ^= data2[pos + i10];
+    swap32IfBE(x32);
+    const { s0: s02, s1: s12, s2: s22, s3: s32 } = encrypt(xk, x32[0], x32[1], x32[2], x32[3]);
+    x32[0] = s02, x32[1] = s12, x32[2] = s22, x32[3] = s32;
+    swap32IfBE(x32);
+  }
+  update(data2) {
+    aexists(this);
+    abytes(data2);
+    let pos = 0;
+    if (this.pos) {
+      const take = Math.min(BLOCK_SIZE - this.pos, data2.length);
+      this.buffer.set(data2.subarray(0, take), this.pos);
+      this.pos += take;
+      pos = take;
+      if (this.pos === BLOCK_SIZE && pos < data2.length) {
+        this.process(this.buffer, 0);
+        this.pos = 0;
+      }
+    }
+    while (pos + BLOCK_SIZE < data2.length) {
+      this.process(data2, pos);
+      pos += BLOCK_SIZE;
+    }
+    if (pos < data2.length) {
+      this.buffer.set(data2.subarray(pos), 0);
+      this.pos = data2.length - pos;
+    }
+    return this;
+  }
+  // See {@link https://www.rfc-editor.org/rfc/rfc4493.html#section-2.4 | RFC 4493 Section 2.4}.
+  digestInto(out) {
+    aexists(this);
+    aoutput32(out, this);
+    this.finished = true;
+    const view = out.subarray(0, this.outputLen);
+    let last = new Uint8Array(BLOCK_SIZE);
+    if (this.pos === BLOCK_SIZE) {
+      last.set(this.buffer);
+      xorBlock(last, this.k1);
+    } else {
+      last.set(this.buffer.subarray(0, this.pos));
+      last[this.pos] = 128;
+      xorBlock(last, this.k2);
+    }
+    view.set(this.x);
+    xorBlock(view, last);
+    encryptBlock(this.xk, view);
+    clean(last);
+  }
+  digest() {
+    const { buffer: buffer2, outputLen } = this;
+    this.digestInto(buffer2);
+    const res = buffer2.slice(0, outputLen);
+    this.destroy();
+    return res;
+  }
+  destroy() {
+    const { buffer: buffer2, destroyed, x, xk, k1: k12, k2: k22 } = this;
+    if (destroyed)
+      return;
+    this.destroyed = true;
+    clean(buffer2, x, xk, k12, k22);
+  }
+}
+const cmac = /* @__PURE__ */ wrapMacConstructor(16, (key) => new _CMAC(key));
+function s2v(key, strings2) {
+  validateKeyLength(key);
+  const len2 = strings2.length;
+  if (len2 > 127) {
+    throw new Error("s2v: expected <= 127 inputs");
+  }
+  if (len2 === 0)
+    return cmac(ONE_BLOCK, key);
+  let d = cmac(EMPTY_BLOCK, key);
+  for (let i10 = 0; i10 < len2 - 1; i10++) {
+    dbl(d);
+    const cmacResult = cmac(strings2[i10], key);
+    xorBlock(d, cmacResult);
+    clean(cmacResult);
+  }
+  const s_n = strings2[len2 - 1];
+  abytes(s_n);
+  let t10;
+  if (s_n.byteLength >= BLOCK_SIZE) {
+    t10 = xorend(Uint8Array.from(s_n), d);
+  } else {
+    const paddedSn = new Uint8Array(BLOCK_SIZE);
+    paddedSn.set(s_n);
+    paddedSn[s_n.length] = 128;
+    t10 = xorBlock(dbl(d), paddedSn);
+    clean(paddedSn);
+  }
+  const result = cmac(t10, key);
+  clean(d, t10);
+  return result;
+}
+const unsafe = /* @__PURE__ */ Object.freeze({
+  expandKeyLE,
+  expandKeyDecLE,
+  encrypt,
+  decrypt,
+  encryptBlock,
+  decryptBlock,
+  ctrCounter,
+  ctr32,
+  dbl,
+  xorBlock,
+  xorend,
+  s2v
+});
+const CIPHERS = /^aes-(128|192|256)-(gcm|cbc|ctr|ecb)$/u;
+function cipherNames() {
+  const names2 = [];
+  for (const bits of [128, 192, 256]) for (const mode of ["cbc", "ctr", "ecb", "gcm"]) names2.push(`aes-${bits}-${mode}`);
+  return names2;
+}
+const GCM_TAG_LENGTHS = /* @__PURE__ */ new Set([4, 8, 12, 13, 14, 15, 16]);
+function createCipherClasses(deps) {
+  var _decrypt, _mode, _xk, _xkDec, _padding, _finished, _started, _pending, _chain, _counter, _keystream, _ghash, _tagMask, _ghashPending, _aadLength, _dataLength, _authTagLength, _authTag, _CipherBase_instances, getTag_fn, setTag_fn, process_fn, stream_fn, absorb_fn, blocks_fn, block_fn, finish_fn, finishGcm_fn;
+  const { error } = deps;
+  function parse4(algorithm) {
+    if (typeof algorithm !== "string") throw Object.assign(new TypeError('The "cipher" argument must be of type string.'), { code: "ERR_INVALID_ARG_TYPE" });
+    const match2 = CIPHERS.exec(algorithm.toLowerCase());
+    if (!match2) throw error("ERR_CRYPTO_UNKNOWN_CIPHER", "Unknown cipher");
+    return { keyLength: Number(match2[1]) / 8, mode: match2[2] };
+  }
+  function keyOf(key, keyLength) {
+    const bytes2 = deps.secretKeyBytes(key) ?? deps.bytesOf(key);
+    if (bytes2.length !== keyLength) throw Object.assign(new RangeError("Invalid key length"), { code: "ERR_CRYPTO_INVALID_KEYLEN" });
+    return new Uint8Array(bytes2);
+  }
+  function ivOf(iv2, mode) {
+    if (mode === "ecb") {
+      if (iv2 === null || iv2 === void 0) return void 0;
+      const bytes22 = deps.bytesOf(iv2);
+      if (bytes22.length !== 0) throw Object.assign(new TypeError("Invalid initialization vector"), { code: "ERR_CRYPTO_INVALID_IV" });
+      return void 0;
+    }
+    if (iv2 === null || iv2 === void 0) throw Object.assign(new TypeError("Invalid initialization vector"), { code: "ERR_CRYPTO_INVALID_IV" });
+    const bytes2 = new Uint8Array(deps.bytesOf(iv2));
+    if (mode === "gcm" ? bytes2.length === 0 : bytes2.length !== 16) throw Object.assign(new TypeError("Invalid initialization vector"), { code: "ERR_CRYPTO_INVALID_IV" });
+    return bytes2;
+  }
+  function encryptBlock2(xk, block) {
+    const out = new Uint8Array(16);
+    out.set(block);
+    return unsafe.encryptBlock(xk, out);
+  }
+  function decryptBlock2(xk, block) {
+    const out = new Uint8Array(16);
+    out.set(block);
+    return unsafe.decryptBlock(xk, out);
+  }
+  function concat(a, b) {
+    if (a.length === 0) return b;
+    if (b.length === 0) return a;
+    const out = new Uint8Array(a.length + b.length);
+    out.set(a);
+    out.set(b, a.length);
+    return out;
+  }
+  function increment(counter, from) {
+    for (let i10 = 15; i10 >= from; i10--) {
+      counter[i10] = counter[i10] + 1 & 255;
+      if (counter[i10] !== 0) return;
+    }
+  }
+  let authTagOf;
+  let expectTagOf;
+  class CipherBase {
+    constructor(decrypt2, algorithm, key, iv2, options) {
+      __privateAdd(this, _CipherBase_instances);
+      __privateAdd(this, _decrypt);
+      __privateAdd(this, _mode);
+      __privateAdd(this, _xk);
+      __privateAdd(this, _xkDec);
+      __privateAdd(this, _padding, true);
+      __privateAdd(this, _finished, false);
+      __privateAdd(this, _started, false);
+      /** CBC/ECB: bytes not yet a whole block (and, decrypting with padding, the last whole block). */
+      __privateAdd(this, _pending, new Uint8Array(0));
+      /** CBC's chaining block. */
+      __privateAdd(this, _chain);
+      /** CTR/GCM: the next counter block and what is left of the current keystream block. */
+      __privateAdd(this, _counter);
+      __privateAdd(this, _keystream, new Uint8Array(0));
+      /** GCM. */
+      __privateAdd(this, _ghash);
+      __privateAdd(this, _tagMask);
+      __privateAdd(this, _ghashPending, new Uint8Array(0));
+      __privateAdd(this, _aadLength, 0);
+      __privateAdd(this, _dataLength, 0);
+      __privateAdd(this, _authTagLength);
+      __privateAdd(this, _authTag);
+      const { keyLength, mode } = parse4(algorithm);
+      __privateSet(this, _decrypt, decrypt2);
+      __privateSet(this, _mode, mode);
+      const keyBytes = keyOf(key, keyLength);
+      const ivBytes = ivOf(iv2, mode);
+      __privateSet(this, _xk, unsafe.expandKeyLE(keyBytes));
+      __privateSet(this, _xkDec, decrypt2 && (mode === "cbc" || mode === "ecb") ? unsafe.expandKeyDecLE(keyBytes) : void 0);
+      const tagLength = options == null ? void 0 : options.authTagLength;
+      if (tagLength !== void 0) {
+        if (mode !== "gcm") throw Object.assign(new TypeError(`Invalid authentication tag length: ${tagLength}`), { code: "ERR_CRYPTO_INVALID_AUTH_TAG" });
+        if (!GCM_TAG_LENGTHS.has(tagLength)) throw Object.assign(new TypeError(`Invalid authentication tag length: ${tagLength}`), { code: "ERR_CRYPTO_INVALID_AUTH_TAG" });
+        __privateSet(this, _authTagLength, tagLength);
+      }
+      if (mode === "cbc") __privateSet(this, _chain, ivBytes);
+      if (mode === "ctr") __privateSet(this, _counter, new Uint8Array(ivBytes));
+      if (mode === "gcm") {
+        const h = encryptBlock2(__privateGet(this, _xk), new Uint8Array(16));
+        let j02;
+        if (ivBytes.length === 12) {
+          j02 = new Uint8Array(16);
+          j02.set(ivBytes);
+          j02[15] = 1;
+        } else {
+          const lengths = new Uint8Array(16);
+          new DataView(lengths.buffer).setBigUint64(8, BigInt(ivBytes.length * 8), false);
+          const g = new GHASH(h);
+          g.update(ivBytes).update(lengths);
+          j02 = g.digest();
+        }
+        __privateSet(this, _tagMask, encryptBlock2(__privateGet(this, _xk), j02));
+        __privateSet(this, _counter, new Uint8Array(j02));
+        increment(__privateGet(this, _counter), 12);
+        __privateSet(this, _ghash, new GHASH(h));
+      }
+    }
+    setAutoPadding(autoPadding = true) {
+      if (__privateGet(this, _finished)) throw error("ERR_CRYPTO_INVALID_STATE", "Invalid state for operation setAutoPadding");
+      __privateSet(this, _padding, Boolean(autoPadding));
+      return this;
+    }
+    setAAD(buffer2, _options3) {
+      if (__privateGet(this, _mode) !== "gcm" || __privateGet(this, _started) || __privateGet(this, _finished)) throw error("ERR_CRYPTO_INVALID_STATE", "Invalid state for operation setAAD");
+      const aad = deps.bytesOf(buffer2);
+      __privateGet(this, _ghash).update(aad);
+      __privateSet(this, _aadLength, __privateGet(this, _aadLength) + aad.length);
+      return this;
+    }
+    update(data2, inputEncoding, outputEncoding) {
+      if (__privateGet(this, _finished)) throw error("ERR_CRYPTO_INVALID_STATE", "Invalid state for operation update");
+      __privateSet(this, _started, true);
+      const input = typeof data2 === "string" ? deps.bytesOf(data2, inputEncoding) : deps.bytesOf(data2);
+      return deps.encode(__privateMethod(this, _CipherBase_instances, process_fn).call(this, new Uint8Array(input)), outputEncoding);
+    }
+    final(outputEncoding) {
+      if (__privateGet(this, _finished)) throw error("ERR_CRYPTO_INVALID_STATE", "Unsupported state");
+      __privateSet(this, _finished, true);
+      return deps.encode(__privateMethod(this, _CipherBase_instances, finish_fn).call(this), outputEncoding);
+    }
+  }
+  _decrypt = new WeakMap();
+  _mode = new WeakMap();
+  _xk = new WeakMap();
+  _xkDec = new WeakMap();
+  _padding = new WeakMap();
+  _finished = new WeakMap();
+  _started = new WeakMap();
+  _pending = new WeakMap();
+  _chain = new WeakMap();
+  _counter = new WeakMap();
+  _keystream = new WeakMap();
+  _ghash = new WeakMap();
+  _tagMask = new WeakMap();
+  _ghashPending = new WeakMap();
+  _aadLength = new WeakMap();
+  _dataLength = new WeakMap();
+  _authTagLength = new WeakMap();
+  _authTag = new WeakMap();
+  _CipherBase_instances = new WeakSet();
+  getTag_fn = function() {
+    if (__privateGet(this, _mode) !== "gcm" || __privateGet(this, _decrypt) || !__privateGet(this, _finished) || !__privateGet(this, _authTag)) throw error("ERR_CRYPTO_INVALID_STATE", "Invalid state for operation getAuthTag");
+    return __privateGet(this, _authTag);
+  };
+  setTag_fn = function(tag, encoding) {
+    if (__privateGet(this, _mode) !== "gcm" || !__privateGet(this, _decrypt) || __privateGet(this, _finished)) throw error("ERR_CRYPTO_INVALID_STATE", "Invalid state for operation setAuthTag");
+    const bytes2 = new Uint8Array(typeof tag === "string" ? deps.bytesOf(tag, encoding) : deps.bytesOf(tag));
+    const allowed = __privateGet(this, _authTagLength) === void 0 ? GCM_TAG_LENGTHS.has(bytes2.length) : bytes2.length === __privateGet(this, _authTagLength);
+    if (!allowed) throw Object.assign(new TypeError(`Invalid authentication tag length: ${bytes2.length}`), { code: "ERR_CRYPTO_INVALID_AUTH_TAG" });
+    __privateSet(this, _authTag, bytes2);
+  };
+  process_fn = function(input) {
+    switch (__privateGet(this, _mode)) {
+      case "ctr":
+        return __privateMethod(this, _CipherBase_instances, stream_fn).call(this, input);
+      case "gcm": {
+        if (__privateGet(this, _decrypt)) __privateMethod(this, _CipherBase_instances, absorb_fn).call(this, input);
+        const out = __privateMethod(this, _CipherBase_instances, stream_fn).call(this, input);
+        if (!__privateGet(this, _decrypt)) __privateMethod(this, _CipherBase_instances, absorb_fn).call(this, out);
+        __privateSet(this, _dataLength, __privateGet(this, _dataLength) + input.length);
+        return out;
+      }
+      default:
+        return __privateMethod(this, _CipherBase_instances, blocks_fn).call(this, input);
+    }
+  };
+  /** XOR with the counter's keystream, carrying a partial block across calls. */
+  stream_fn = function(input) {
+    const out = new Uint8Array(input.length);
+    let at3 = 0;
+    while (at3 < input.length) {
+      if (__privateGet(this, _keystream).length === 0) {
+        __privateSet(this, _keystream, encryptBlock2(__privateGet(this, _xk), __privateGet(this, _counter)));
+        increment(__privateGet(this, _counter), __privateGet(this, _mode) === "gcm" ? 12 : 0);
+      }
+      const take = Math.min(__privateGet(this, _keystream).length, input.length - at3);
+      for (let i10 = 0; i10 < take; i10++) out[at3 + i10] = input[at3 + i10] ^ __privateGet(this, _keystream)[i10];
+      __privateSet(this, _keystream, __privateGet(this, _keystream).subarray(take));
+      at3 += take;
+    }
+    return out;
+  };
+  /** GHASH over the ciphertext, in whole blocks: GHASH pads each update, so a partial block waits for the next. */
+  absorb_fn = function(ciphertext) {
+    const all = concat(__privateGet(this, _ghashPending), ciphertext);
+    const whole = all.length - all.length % 16;
+    if (whole > 0) __privateGet(this, _ghash).update(all.subarray(0, whole));
+    __privateSet(this, _ghashPending, all.slice(whole));
+  };
+  /** CBC and ECB: every whole block now; decrypting with padding, the last whole block waits for `final`. */
+  blocks_fn = function(input) {
+    const all = concat(__privateGet(this, _pending), input);
+    let whole = all.length - all.length % 16;
+    if (__privateGet(this, _decrypt) && __privateGet(this, _padding) && whole === all.length && whole > 0) whole -= 16;
+    const out = new Uint8Array(whole);
+    for (let at3 = 0; at3 < whole; at3 += 16) out.set(__privateMethod(this, _CipherBase_instances, block_fn).call(this, all.subarray(at3, at3 + 16)), at3);
+    __privateSet(this, _pending, all.slice(whole));
+    return out;
+  };
+  block_fn = function(block) {
+    if (__privateGet(this, _mode) === "ecb") return __privateGet(this, _decrypt) ? decryptBlock2(__privateGet(this, _xkDec), block) : encryptBlock2(__privateGet(this, _xk), block);
+    if (__privateGet(this, _decrypt)) {
+      const plain = decryptBlock2(__privateGet(this, _xkDec), block);
+      for (let i10 = 0; i10 < 16; i10++) plain[i10] = plain[i10] ^ __privateGet(this, _chain)[i10];
+      __privateSet(this, _chain, new Uint8Array(block));
+      return plain;
+    }
+    const mixed = new Uint8Array(16);
+    for (let i10 = 0; i10 < 16; i10++) mixed[i10] = block[i10] ^ __privateGet(this, _chain)[i10];
+    const cipher = encryptBlock2(__privateGet(this, _xk), mixed);
+    __privateSet(this, _chain, cipher);
+    return cipher;
+  };
+  finish_fn = function() {
+    if (__privateGet(this, _mode) === "ctr") return new Uint8Array(0);
+    if (__privateGet(this, _mode) === "gcm") return __privateMethod(this, _CipherBase_instances, finishGcm_fn).call(this);
+    const rest = __privateGet(this, _pending);
+    __privateSet(this, _pending, new Uint8Array(0));
+    if (!__privateGet(this, _decrypt)) {
+      if (!__privateGet(this, _padding)) {
+        if (rest.length !== 0) throw error("ERR_OSSL_WRONG_FINAL_BLOCK_LENGTH", "error:1C80006B:Provider routines::wrong final block length");
+        return rest;
+      }
+      const pad2 = 16 - rest.length;
+      const block = new Uint8Array(16);
+      block.set(rest);
+      block.fill(pad2, rest.length);
+      return __privateMethod(this, _CipherBase_instances, block_fn).call(this, block);
+    }
+    if (!__privateGet(this, _padding)) {
+      if (rest.length !== 0) throw error("ERR_OSSL_WRONG_FINAL_BLOCK_LENGTH", "error:1C80006B:Provider routines::wrong final block length");
+      return rest;
+    }
+    if (rest.length !== 16) throw error("ERR_OSSL_WRONG_FINAL_BLOCK_LENGTH", "error:1C80006B:Provider routines::wrong final block length");
+    const plain = __privateMethod(this, _CipherBase_instances, block_fn).call(this, rest);
+    const pad = plain[15];
+    let valid = pad >= 1 && pad <= 16;
+    for (let i10 = 16 - pad; valid && i10 < 16; i10++) valid = plain[i10] === pad;
+    if (!valid) throw error("ERR_OSSL_BAD_DECRYPT", "error:1C800064:Provider routines::bad decrypt");
+    return plain.slice(0, 16 - pad);
+  };
+  finishGcm_fn = function() {
+    if (__privateGet(this, _ghashPending).length) __privateGet(this, _ghash).update(__privateGet(this, _ghashPending));
+    const lengths = new Uint8Array(16);
+    const view = new DataView(lengths.buffer);
+    view.setBigUint64(0, BigInt(__privateGet(this, _aadLength) * 8), false);
+    view.setBigUint64(8, BigInt(__privateGet(this, _dataLength) * 8), false);
+    const full = __privateGet(this, _ghash).update(lengths).digest();
+    for (let i10 = 0; i10 < 16; i10++) full[i10] = full[i10] ^ __privateGet(this, _tagMask)[i10];
+    if (!__privateGet(this, _decrypt)) {
+      __privateSet(this, _authTag, full.slice(0, __privateGet(this, _authTagLength) ?? 16));
+      return new Uint8Array(0);
+    }
+    const expected = __privateGet(this, _authTag);
+    let same = expected !== void 0;
+    if (expected) for (let i10 = 0; i10 < expected.length; i10++) same = same && full[i10] === expected[i10];
+    if (!same) throw new Error("Unsupported state or unable to authenticate data");
+    return new Uint8Array(0);
+  };
+  authTagOf = (cipher) => {
+    var _a3;
+    return __privateMethod(_a3 = cipher, _CipherBase_instances, getTag_fn).call(_a3);
+  };
+  expectTagOf = (cipher, tag, encoding) => {
+    var _a3;
+    return __privateMethod(_a3 = cipher, _CipherBase_instances, setTag_fn).call(_a3, tag, encoding);
+  };
+  class Cipheriv2 extends CipherBase {
+    constructor(algorithm, key, iv2, options) {
+      super(false, algorithm, key, iv2, options);
+    }
+    getAuthTag() {
+      return deps.toBuffer(authTagOf(this));
+    }
+  }
+  class Decipheriv2 extends CipherBase {
+    constructor(algorithm, key, iv2, options) {
+      super(true, algorithm, key, iv2, options);
+    }
+    setAuthTag(tag, encoding) {
+      expectTagOf(this, tag, encoding);
+      return this;
+    }
+  }
+  return {
+    Cipheriv: Cipheriv2,
+    Decipheriv: Decipheriv2,
+    createCipheriv: (algorithm, key, iv2, options) => new Cipheriv2(algorithm, key, iv2, options),
+    createDecipheriv: (algorithm, key, iv2, options) => new Decipheriv2(algorithm, key, iv2, options)
+  };
+}
 function createCryptoModule(require2) {
   var _state, _done, _inner, _outer, _done2, _algorithm, _data, _algorithm2, _data2, __keyData, __type, __algorithm;
   const bufferModule2 = require2 ? require2("buffer") : lazyModule("buffer");
@@ -23880,7 +24867,7 @@ ${body}
     return result === 0;
   }
   function getCiphers2() {
-    return ["aes-128-cbc", "aes-256-cbc", "aes-128-gcm", "aes-256-gcm"];
+    return cipherNames();
   }
   function getHashes2() {
     return HASH_ALGORITHMS.slice();
@@ -24001,7 +24988,25 @@ ${body}
     }
     throw new Error(`Unsupported key format: ${keyInfo.format}`);
   }
+  const { Cipheriv: Cipheriv2, Decipheriv: Decipheriv2, createCipheriv: createCipheriv2, createDecipheriv: createDecipheriv2 } = createCipherClasses({
+    toBuffer: (bytes2) => Buffer2.from(bytes2),
+    bytesOf: (value, encoding) => cryptoBytes(value, encoding, true),
+    secretKeyBytes: (value) => {
+      if (!(value instanceof KeyObject2)) return void 0;
+      const info = keyInfoOf(value);
+      if (info.type !== "secret" || !(info.keyData instanceof Uint8Array)) {
+        throw Object.assign(new TypeError(`Invalid key object type ${info.type}, expected secret.`), { code: "ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE" });
+      }
+      return info.keyData;
+    },
+    encode: (bytes2, encoding) => digestResult(bytes2, encoding),
+    error: cryptoError
+  });
   return {
+    Cipheriv: Cipheriv2,
+    Decipheriv: Decipheriv2,
+    createCipheriv: createCipheriv2,
+    createDecipheriv: createDecipheriv2,
     unsupported: unsupported2,
     randomBytes: randomBytes2,
     randomFill: randomFill2,
@@ -24030,12 +25035,16 @@ ${body}
   };
 }
 const cryptoModule = createCryptoModule();
-const { randomBytes, randomFillSync, randomFill, randomUUID, randomInt, getRandomValues, unsupported, createHash, createHmac, hash, pbkdf2Sync, pbkdf2, sign, verify, createSign, createVerify, KeyObject, createSecretKey, createPublicKey, createPrivateKey, generateKeyPair, timingSafeEqual, getCiphers, getHashes } = cryptoModule;
+const { Cipheriv, Decipheriv, createCipheriv, createDecipheriv, randomBytes, randomFillSync, randomFill, randomUUID, randomInt, getRandomValues, unsupported, createHash, createHmac, hash, pbkdf2Sync, pbkdf2, sign, verify, createSign, createVerify, KeyObject, createSecretKey, createPublicKey, createPrivateKey, generateKeyPair, timingSafeEqual, getCiphers, getHashes } = cryptoModule;
 var cryptoShim = /* @__PURE__ */ Object.freeze({
   __proto__: null,
+  Cipheriv,
+  Decipheriv,
   KeyObject,
   constants: cryptoConstants,
+  createCipheriv,
   createCryptoModule,
+  createDecipheriv,
   createHash,
   createHmac,
   createPrivateKey,
@@ -32621,12 +33630,12 @@ class SHA2_32B extends HashMD {
     this.set(A10, B, C, D10, E7, F, G10, H);
   }
   roundClean() {
-    clean(SHA256_W);
+    clean$1(SHA256_W);
   }
   destroy() {
     this.destroyed = true;
     this.set(0, 0, 0, 0, 0, 0, 0, 0);
-    clean(this.buffer);
+    clean$1(this.buffer);
   }
 }
 class _SHA256 extends SHA2_32B {