@volter/tabnode 0.5.49 → 0.5.51

package/dist/index.mjs

@@ -18,8 +18,8 @@ var __privateWrapper = (obj, member, setter, getter) => ({
   }
 });
 var _a, _b, _asyncId, _triggerAsyncId, _c, _d, _e, _f, _g, _h, _i, _j, _ptr, _type, _maxHeaderSize, _headerBytes, _headers, _field, _value, _readingValue, _url, _statusMessage, _headersSent, _paused, _buffer, _bufferPtr, _bufferSize, _connections, _HTTPParser_instances, reset_fn, copyIn_fn, pushHeader_fn, countHeaderBytes_fn, _parsers, _strm, _writeState, _callback, _level, _strategy, _windowBits, _memLevel, _dictionary, _ended, _Zlib_instances, inflating_get, windowFor_fn, start_fn, fail_fn, report_fn, run_fn, end_fn, _writeState2, _callback2, _input, _output, _outputAt, _BrotliDecoderHandle_instances, run_fn2, _k, _resolveChain, _loadChain, _initializing, _initializeFailure, _RunModuleHooks_instances, run_fn3;
-import { u as uint8ToBase64, b as base64ToUint8, a as uint8ToBinaryString, c as uint8ToHex, P as PortBridge } from "./port-bridge-CixAESwA.js";
-import { g } from "./port-bridge-CixAESwA.js";
+import { u as uint8ToBase64, b as base64ToUint8, a as uint8ToBinaryString, c as uint8ToHex, P as PortBridge } from "./port-bridge-Cergvxli.js";
+import { g } from "./port-bridge-Cergvxli.js";
 import { defineCommand, Bash, getCommandNames } from "just-bash";
 import { imports, resolve as resolve$3 } from "resolve.exports";
 import { wrap, proxy } from "comlink";
@@ -19400,14 +19400,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 e, m;
   var eLen = nBytes * 8 - mLen - 1;
   var eMax = (1 << eLen) - 1;
   var eBias = eMax >> 1;
   var nBits = -7;
-  var i2 = isLE ? nBytes - 1 : 0;
-  var d = isLE ? -1 : 1;
+  var i2 = isLE2 ? nBytes - 1 : 0;
+  var d = isLE2 ? -1 : 1;
   var s = buffer2[offset2 + i2];
   i2 += d;
   e = s & (1 << -nBits) - 1;
@@ -19430,14 +19430,14 @@ ieee754.read = function(buffer2, offset2, isLE, mLen, nBytes) {
   }
   return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
 };
-ieee754.write = function(buffer2, value, offset2, isLE, mLen, nBytes) {
+ieee754.write = function(buffer2, value, offset2, isLE2, mLen, nBytes) {
   var e, m, c;
   var eLen = nBytes * 8 - mLen - 1;
   var eMax = (1 << eLen) - 1;
   var eBias = eMax >> 1;
   var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
-  var i2 = isLE ? 0 : nBytes - 1;
-  var d = isLE ? 1 : -1;
+  var i2 = isLE2 ? 0 : nBytes - 1;
+  var d = isLE2 ? 1 : -1;
   var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
   value = Math.abs(value);
   if (isNaN(value) || value === Infinity) {
@@ -20328,10 +20328,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 i2 = 0;
-    while (++i2 < byteLength3 && (mul *= 256)) {
-      val += this[offset2 + i2] * mul;
+    while (++i2 < byteLength3 && (mul3 *= 256)) {
+      val += this[offset2 + i2] * mul3;
     }
     return val;
   };
@@ -20342,9 +20342,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;
   };
@@ -20402,13 +20402,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 i2 = 0;
-    while (++i2 < byteLength3 && (mul *= 256)) {
-      val += this[offset2 + i2] * mul;
+    while (++i2 < byteLength3 && (mul3 *= 256)) {
+      val += this[offset2 + i2] * 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) {
@@ -20416,13 +20416,13 @@ ieee754.write = function(buffer2, value, offset2, isLE, mLen, nBytes) {
     byteLength3 = byteLength3 >>> 0;
     if (!noAssert) checkOffset(offset2, byteLength3, this.length);
     let i2 = byteLength3;
-    let mul = 1;
+    let mul3 = 1;
     let val = this[offset2 + --i2];
-    while (i2 > 0 && (mul *= 256)) {
-      val += this[offset2 + --i2] * mul;
+    while (i2 > 0 && (mul3 *= 256)) {
+      val += this[offset2 + --i2] * 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) {
@@ -20509,11 +20509,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 i2 = 0;
     this[offset2] = value & 255;
-    while (++i2 < byteLength3 && (mul *= 256)) {
-      this[offset2 + i2] = value / mul & 255;
+    while (++i2 < byteLength3 && (mul3 *= 256)) {
+      this[offset2 + i2] = value / mul3 & 255;
     }
     return offset2 + byteLength3;
   };
@@ -20526,10 +20526,10 @@ ieee754.write = function(buffer2, value, offset2, isLE, mLen, nBytes) {
       checkInt(this, value, offset2, byteLength3, maxBytes, 0);
     }
     let i2 = byteLength3 - 1;
-    let mul = 1;
+    let mul3 = 1;
     this[offset2 + i2] = value & 255;
-    while (--i2 >= 0 && (mul *= 256)) {
-      this[offset2 + i2] = value / mul & 255;
+    while (--i2 >= 0 && (mul3 *= 256)) {
+      this[offset2 + i2] = value / mul3 & 255;
     }
     return offset2 + byteLength3;
   };
@@ -20630,14 +20630,14 @@ ieee754.write = function(buffer2, value, offset2, isLE, mLen, nBytes) {
       checkInt(this, value, offset2, byteLength3, limit - 1, -limit);
     }
     let i2 = 0;
-    let mul = 1;
+    let mul3 = 1;
     let sub = 0;
     this[offset2] = value & 255;
-    while (++i2 < byteLength3 && (mul *= 256)) {
+    while (++i2 < byteLength3 && (mul3 *= 256)) {
       if (value < 0 && sub === 0 && this[offset2 + i2 - 1] !== 0) {
         sub = 1;
       }
-      this[offset2 + i2] = (value / mul >> 0) - sub & 255;
+      this[offset2 + i2] = (value / mul3 >> 0) - sub & 255;
     }
     return offset2 + byteLength3;
   };
@@ -20649,14 +20649,14 @@ ieee754.write = function(buffer2, value, offset2, isLE, mLen, nBytes) {
       checkInt(this, value, offset2, byteLength3, limit - 1, -limit);
     }
     let i2 = byteLength3 - 1;
-    let mul = 1;
+    let mul3 = 1;
     let sub = 0;
     this[offset2 + i2] = value & 255;
-    while (--i2 >= 0 && (mul *= 256)) {
+    while (--i2 >= 0 && (mul3 *= 256)) {
       if (value < 0 && sub === 0 && this[offset2 + i2 + 1] !== 0) {
         sub = 1;
       }
-      this[offset2 + i2] = (value / mul >> 0) - sub & 255;
+      this[offset2 + i2] = (value / mul3 >> 0) - sub & 255;
     }
     return offset2 + byteLength3;
   };
@@ -21339,17 +21339,10 @@ var implementation$1 = function bind2(that) {
 var implementation = implementation$1;
 var functionBind = Function.prototype.bind || implementation;
 var functionCall = Function.prototype.call;
-var functionApply;
-var hasRequiredFunctionApply;
-function requireFunctionApply() {
-  if (hasRequiredFunctionApply) return functionApply;
-  hasRequiredFunctionApply = 1;
-  functionApply = Function.prototype.apply;
-  return functionApply;
-}
+var functionApply = Function.prototype.apply;
 var reflectApply = typeof Reflect !== "undefined" && Reflect && Reflect.apply;
 var bind$2 = functionBind;
-var $apply$1 = requireFunctionApply();
+var $apply$1 = functionApply;
 var $call$2 = functionCall;
 var $reflectApply = reflectApply;
 var actualApply = $reflectApply || bind$2.call($call$2, $apply$1);
@@ -21469,7 +21462,7 @@ var hasSymbols = requireHasSymbols()();
 var getProto = requireGetProto();
 var $ObjectGPO = requireObject_getPrototypeOf();
 var $ReflectGPO = requireReflect_getPrototypeOf();
-var $apply = requireFunctionApply();
+var $apply = functionApply;
 var $call = functionCall;
 var needsEval = {};
 var TypedArray = typeof Uint8Array === "undefined" || !getProto ? undefined$1 : getProto(Uint8Array);
@@ -22110,7 +22103,7 @@ function requireApplyBind() {
   if (hasRequiredApplyBind) return applyBind;
   hasRequiredApplyBind = 1;
   var bind3 = functionBind;
-  var $apply2 = requireFunctionApply();
+  var $apply2 = functionApply;
   var actualApply$1 = actualApply;
   applyBind = function applyBind2() {
     return actualApply$1(bind3, $apply2, arguments);
@@ -23157,23 +23150,23 @@ var sha_jsExports = sha_js.exports;
 const SHA = /* @__PURE__ */ getDefaultExportFromCjs(sha_jsExports);
 const fromNumH = (n) => n / 2 ** 32 | 0;
 const fromNumL = (n) => n >>> 0;
-function setU64FromNum(view, byteOffset, n, isLE) {
+function setU64FromNum(view, byteOffset, n, isLE2) {
   const h = fromNumH(n);
   const l = fromNumL(n);
-  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);
@@ -23182,25 +23175,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 i2 = 0; i2 < arrays.length; i2++) {
     arrays[i2].fill(0);
   }
 }
-function createView(arr) {
+function createView$1(arr) {
   return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
 }
 function rotr(word, shift) {
@@ -23215,7 +23208,7 @@ const hasHexBuiltin = /* @__PURE__ */ (() => (
 ))();
 const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i2) => i2.toString(16).padStart(2, "0"));
 function bytesToHex(bytes2) {
-  abytes(bytes2);
+  abytes$1(bytes2);
   if (hasHexBuiltin)
     return bytes2.toHex();
   let hex = "";
@@ -23256,7 +23249,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);
@@ -23272,20 +23265,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;
@@ -23306,10 +23299,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);
@@ -23317,17 +23310,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 i2 = 0; i2 < outLen; i2++)
-      oview.setUint32(4 * i2, state[i2], isLE);
+      oview.setUint32(4 * i2, state[i2], isLE2);
   }
   digest() {
     const { buffer: buffer2, outputLen } = this;
@@ -23434,12 +23427,12 @@ class _MD5 extends HashMD {
     this.set(A, B, C, D);
   }
   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());
@@ -23449,6 +23442,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(n, title = "") {
+  if (typeof n !== "number")
+    throw new TypeError(atitle(title) + "expected number, got " + typeof n);
+  if (!Number.isSafeInteger(n) || n < 0)
+    throw new RangeError(atitle(title) + "expected integer >= 0, got " + n);
+  return n;
+}
+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(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 i2 = 0; i2 < arrays.length; i2++) {
+    arrays[i2].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 ? (n) => n : (n) => byteSwap(n) >>> 0;
+function byteSwap32(arr) {
+  for (let i2 = 0; i2 < arr.length; i2++) {
+    arr[i2] = byteSwap(arr[i2]);
+  }
+  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 = (s0, s1, s2, s3) => {
+  const hiBit = s3 & 1;
+  return {
+    s3: s2 << 31 | s3 >>> 1,
+    s2: s1 << 31 | s2 >>> 1,
+    s1: s0 << 31 | s1 >>> 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: s0 >>> 1 ^ POLY$1 << 24 & -(hiBit & 1)
+    // reduce % poly
+  };
+};
+const swapLE = (n) => (n >>> 0 & 255) << 24 | (n >>> 8 & 255) << 16 | (n >>> 16 & 255) << 8 | n >>> 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 k0 = kView.getUint32(0, false);
+    let k1 = kView.getUint32(4, false);
+    let k2 = kView.getUint32(8, false);
+    let k3 = kView.getUint32(12, false);
+    const doubles = [];
+    for (let i2 = 0; i2 < 128; i2++) {
+      doubles.push({ s0: swapLE(k0), s1: swapLE(k1), s2: swapLE(k2), s3: swapLE(k3) });
+      ({ s0: k0, s1: k1, s2: k2, s3: k3 } = mul2$1(k0, k1, k2, k3));
+    }
+    const W2 = estimateWindow(expectedLength || 1024);
+    if (![1, 2, 4, 8].includes(W2))
+      throw new Error("ghash: invalid window size, expected 2, 4 or 8");
+    this.W = W2;
+    const bits = 128;
+    const windows = bits / W2;
+    const windowSize = this.windowSize = 2 ** W2;
+    const items = [];
+    for (let w = 0; w < windows; w++) {
+      for (let byte = 0; byte < windowSize; byte++) {
+        let s0 = 0, s1 = 0, s2 = 0, s3 = 0;
+        for (let j = 0; j < W2; j++) {
+          const bit = byte >>> W2 - j - 1 & 1;
+          if (!bit)
+            continue;
+          const { s0: d0, s1: d1, s2: d2, s3: d3 } = doubles[W2 * w + j];
+          s0 ^= d0, s1 ^= d1, s2 ^= d2, s3 ^= d3;
+        }
+        items.push({ s0, s1, s2, s3 });
+      }
+    }
+    this.t = items;
+  }
+  _updateBlock(s0, s1, s2, s3) {
+    s0 ^= this.s0, s1 ^= this.s1, s2 ^= this.s2, s3 ^= this.s3;
+    const { W: W2, t, windowSize } = this;
+    let o0 = 0, o1 = 0, o2 = 0, o3 = 0;
+    const mask = (1 << W2) - 1;
+    let w = 0;
+    for (const num of [s0, s1, s2, s3]) {
+      for (let bytePos = 0; bytePos < 4; bytePos++) {
+        const byte = num >>> 8 * bytePos & 255;
+        for (let bitPos = 8 / W2 - 1; bitPos >= 0; bitPos--) {
+          const bit = byte >>> W2 * bitPos & mask;
+          const { s0: e0, s1: e1, s2: e2, s3: e3 } = t[w * windowSize + bit];
+          o0 ^= e0, o1 ^= e1, o2 ^= e2, o3 ^= e3;
+          w += 1;
+        }
+      }
+    }
+    this.s0 = o0;
+    this.s1 = o1;
+    this.s2 = o2;
+    this.s3 = o3;
+  }
+  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 i2 = 0; i2 < blocks; i2++) {
+      this._updateBlock(swap8IfBE(b32[i2 * 4 + 0]), swap8IfBE(b32[i2 * 4 + 1]), swap8IfBE(b32[i2 * 4 + 2]), swap8IfBE(b32[i2 * 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 } = this;
+    for (const elm of t) {
+      elm.s0 = 0, elm.s1 = 0, elm.s2 = 0, elm.s3 = 0;
+    }
+  }
+  digestInto(out) {
+    aexists(this);
+    aoutput32(out, this);
+    this.finished = true;
+    const { s0, s1, s2, s3 } = this;
+    const o32 = u32(out);
+    o32[0] = s0;
+    o32[1] = s1;
+    o32[2] = s2;
+    o32[3] = s3;
+    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(n) {
+  return n << 1 ^ POLY & -(n >> 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 t = new Uint8Array(256);
+  for (let i2 = 0, x = 1; i2 < 256; i2++, x ^= mul2(x))
+    t[i2] = x;
+  const box = new Uint8Array(256);
+  box[0] = 99;
+  for (let i2 = 0; i2 < 255; i2++) {
+    let x = t[255 - i2];
+    x |= x << 8;
+    box[t[i2]] = (x ^ x >> 4 ^ x >> 5 ^ x >> 6 ^ x >> 7 ^ 99) & 255;
+  }
+  clean(t);
+  return box;
+})();
+const invSbox = /* @__PURE__ */ sbox.map((_, j) => sbox.indexOf(j));
+const rotr32_8 = (n) => n << 24 | n >>> 8;
+const rotl32_8 = (n) => n << 8 | n >>> 24;
+function genTtable(sbox2, fn) {
+  if (sbox2.length !== 256)
+    throw new Error("wrong sbox length");
+  const T0 = new Uint32Array(256).map((_, j) => fn(sbox2[j]));
+  const T1 = T0.map(rotl32_8);
+  const T2 = T1.map(rotl32_8);
+  const T3 = T2.map(rotl32_8);
+  const T01 = new Uint32Array(256 * 256);
+  const T23 = new Uint32Array(256 * 256);
+  const sbox22 = new Uint16Array(256 * 256);
+  for (let i2 = 0; i2 < 256; i2++) {
+    for (let j = 0; j < 256; j++) {
+      const idx = i2 * 256 + j;
+      T01[idx] = T0[i2] ^ T1[j];
+      T23[idx] = T2[i2] ^ T3[j];
+      sbox22[idx] = sbox2[i2] << 8 | sbox2[j];
+    }
+  }
+  return { sbox: sbox2, sbox2: sbox22, T0, T1, T2, T3, T01, T23 };
+}
+const tableEncoding = /* @__PURE__ */ genTtable(sbox, (s) => mul(s, 3) << 24 | s << 16 | s << 8 | mul(s, 2));
+const tableDecoding = /* @__PURE__ */ genTtable(invSbox, (s) => mul(s, 11) << 24 | mul(s, 13) << 16 | mul(s, 9) << 8 | mul(s, 14));
+const xPowers = /* @__PURE__ */ (() => {
+  const p = new Uint8Array(16);
+  for (let i2 = 0, x = 1; i2 < 16; i2++, x = mul2(x))
+    p[i2] = 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 = (n) => applySbox(sbox2, n, n, n, n);
+  const xk = new Uint32Array(len2 + 28);
+  xk.set(k32);
+  for (let i2 = Nk; i2 < xk.length; i2++) {
+    let t = xk[i2 - 1];
+    if (i2 % Nk === 0)
+      t = subByte(rotr32_8(t)) ^ xPowers[i2 / Nk - 1];
+    else if (Nk > 6 && i2 % Nk === 4)
+      t = subByte(t);
+    xk[i2] = xk[i2 - Nk] ^ t;
+  }
+  clean(...toClean);
+  return xk;
+}
+function expandKeyDecLE(key) {
+  const encKey = expandKeyLE(key);
+  const xk = encKey.slice();
+  const Nk = encKey.length;
+  const { sbox2 } = tableEncoding;
+  const { T0, T1, T2, T3 } = tableDecoding;
+  for (let i2 = 0; i2 < Nk; i2 += 4) {
+    for (let j = 0; j < 4; j++)
+      xk[i2 + j] = encKey[Nk - i2 - 4 + j];
+  }
+  clean(encKey);
+  for (let i2 = 4; i2 < Nk - 4; i2++) {
+    const x = xk[i2];
+    const w = applySbox(sbox2, x, x, x, x);
+    xk[i2] = T0[w & 255] ^ T1[w >>> 8 & 255] ^ T2[w >>> 16 & 255] ^ T3[w >>> 24];
+  }
+  return xk;
+}
+function apply0123(T01, T23, s0, s1, s2, s3) {
+  return T01[s0 << 8 & 65280 | s1 >>> 8 & 255] ^ T23[s2 >>> 8 & 65280 | s3 >>> 24 & 255];
+}
+function applySbox(sbox2, s0, s1, s2, s3) {
+  return sbox2[s0 & 255 | s1 & 65280] | sbox2[s2 >>> 16 & 255 | s3 >>> 16 & 65280] << 16;
+}
+function encrypt(xk, s0, s1, s2, s3) {
+  const { sbox2, T01, T23 } = tableEncoding;
+  let k = 0;
+  s0 ^= xk[k++], s1 ^= xk[k++], s2 ^= xk[k++], s3 ^= xk[k++];
+  const rounds = xk.length / 4 - 2;
+  for (let i2 = 0; i2 < rounds; i2++) {
+    const t02 = xk[k++] ^ apply0123(T01, T23, s0, s1, s2, s3);
+    const t12 = xk[k++] ^ apply0123(T01, T23, s1, s2, s3, s0);
+    const t22 = xk[k++] ^ apply0123(T01, T23, s2, s3, s0, s1);
+    const t32 = xk[k++] ^ apply0123(T01, T23, s3, s0, s1, s2);
+    s0 = t02, s1 = t12, s2 = t22, s3 = t32;
+  }
+  const t0 = xk[k++] ^ applySbox(sbox2, s0, s1, s2, s3);
+  const t1 = xk[k++] ^ applySbox(sbox2, s1, s2, s3, s0);
+  const t2 = xk[k++] ^ applySbox(sbox2, s2, s3, s0, s1);
+  const t3 = xk[k++] ^ applySbox(sbox2, s3, s0, s1, s2);
+  return { s0: t0, s1: t1, s2: t2, s3: t3 };
+}
+function decrypt(xk, s0, s1, s2, s3) {
+  const { sbox2, T01, T23 } = tableDecoding;
+  let k = 0;
+  s0 ^= xk[k++], s1 ^= xk[k++], s2 ^= xk[k++], s3 ^= xk[k++];
+  const rounds = xk.length / 4 - 2;
+  for (let i2 = 0; i2 < rounds; i2++) {
+    const t02 = xk[k++] ^ apply0123(T01, T23, s0, s3, s2, s1);
+    const t12 = xk[k++] ^ apply0123(T01, T23, s1, s0, s3, s2);
+    const t22 = xk[k++] ^ apply0123(T01, T23, s2, s1, s0, s3);
+    const t32 = xk[k++] ^ apply0123(T01, T23, s3, s2, s1, s0);
+    s0 = t02, s1 = t12, s2 = t22, s3 = t32;
+  }
+  const t0 = xk[k++] ^ applySbox(sbox2, s0, s3, s2, s1);
+  const t1 = xk[k++] ^ applySbox(sbox2, s1, s0, s3, s2);
+  const t2 = xk[k++] ^ applySbox(sbox2, s2, s1, s0, s3);
+  const t3 = xk[k++] ^ applySbox(sbox2, s3, s2, s1, s0);
+  return { s0: t0, s1: t1, s2: t2, s3: t3 };
+}
+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 i2 = 0; i2 + 4 <= src32.length; i2 += 4) {
+    const { s0, s1, s2, s3 } = encrypt(xk, swap8IfBE(c32[0]), swap8IfBE(c32[1]), swap8IfBE(c32[2]), swap8IfBE(c32[3]));
+    dst32[i2 + 0] = src32[i2 + 0] ^ swap8IfBE(s0);
+    dst32[i2 + 1] = src32[i2 + 1] ^ swap8IfBE(s1);
+    dst32[i2 + 2] = src32[i2 + 2] ^ swap8IfBE(s2);
+    dst32[i2 + 3] = src32[i2 + 3] ^ swap8IfBE(s3);
+    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, s1, s2, s3 } = encrypt(xk, swap8IfBE(c32[0]), swap8IfBE(c32[1]), swap8IfBE(c32[2]), swap8IfBE(c32[3]));
+    const b32 = new Uint32Array([s0, s1, s2, s3]);
+    swap32IfBE(b32);
+    const buf = u8(b32);
+    for (let i2 = start, pos = 0; i2 < srcLen; i2++, pos++)
+      dst[i2] = src[i2] ^ 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 i2 = 0; i2 + 4 <= src32.length; i2 += 4) {
+    const { s0, s1, s2, s3 } = encrypt(xk, swap8IfBE(c32[0]), swap8IfBE(c32[1]), swap8IfBE(c32[2]), swap8IfBE(c32[3]));
+    dst32[i2 + 0] = src32[i2 + 0] ^ swap8IfBE(s0);
+    dst32[i2 + 1] = src32[i2 + 1] ^ swap8IfBE(s1);
+    dst32[i2 + 2] = src32[i2 + 2] ^ swap8IfBE(s2);
+    dst32[i2 + 3] = src32[i2 + 3] ^ swap8IfBE(s3);
+    ctrNum = ctrNum + 1 >>> 0;
+    view.setUint32(ctrPos, ctrNum, isLE2);
+  }
+  const start = BLOCK_SIZE * Math.floor(src32.length / BLOCK_SIZE32);
+  if (start < srcLen) {
+    const { s0, s1, s2, s3 } = encrypt(xk, swap8IfBE(c32[0]), swap8IfBE(c32[1]), swap8IfBE(c32[2]), swap8IfBE(c32[3]));
+    const b32 = new Uint32Array([s0, s1, s2, s3]);
+    swap32IfBE(b32);
+    const buf = u8(b32);
+    for (let i2 = start, pos = 0; i2 < srcLen; i2++, pos++)
+      dst[i2] = src[i2] ^ 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, s1, s2, s3 } = encrypt(xk, b32[0], b32[1], b32[2], b32[3]);
+  b32[0] = s0, b32[1] = s1, b32[2] = s2, b32[3] = s3;
+  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, s1, s2, s3 } = decrypt(xk, b32[0], b32[1], b32[2], b32[3]);
+  b32[0] = s0, b32[1] = s1, b32[2] = s2, b32[3] = s3;
+  swap32IfBE(b32);
+  return block;
+}
+function dbl(block) {
+  let carry = 0;
+  for (let i2 = BLOCK_SIZE - 1; i2 >= 0; i2--) {
+    const newCarry = (block[i2] & 128) >>> 7;
+    block[i2] = block[i2] << 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 i2 = 0; i2 < a.length; i2++) {
+    a[i2] = a[i2] ^ b[i2];
+  }
+  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 i2 = 0; i2 < b.length; i2++) {
+    a[offset2 + i2] = a[offset2 + i2] ^ b[i2];
+  }
+  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 i2 = 0; i2 < BLOCK_SIZE; i2++)
+      x[i2] ^= data2[pos + i2];
+    swap32IfBE(x32);
+    const { s0, s1, s2, s3 } = encrypt(xk, x32[0], x32[1], x32[2], x32[3]);
+    x32[0] = s0, x32[1] = s1, x32[2] = s2, x32[3] = s3;
+    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, k2 } = this;
+    if (destroyed)
+      return;
+    this.destroyed = true;
+    clean(buffer2, x, xk, k1, k2);
+  }
+}
+const cmac = /* @__PURE__ */ wrapMacConstructor(16, (key) => new _CMAC(key));
+function s2v(key, strings) {
+  validateKeyLength(key);
+  const len2 = strings.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 i2 = 0; i2 < len2 - 1; i2++) {
+    dbl(d);
+    const cmacResult = cmac(strings[i2], key);
+    xorBlock(d, cmacResult);
+    clean(cmacResult);
+  }
+  const s_n = strings[len2 - 1];
+  abytes(s_n);
+  let t;
+  if (s_n.byteLength >= BLOCK_SIZE) {
+    t = xorend(Uint8Array.from(s_n), d);
+  } else {
+    const paddedSn = new Uint8Array(BLOCK_SIZE);
+    paddedSn.set(s_n);
+    paddedSn[s_n.length] = 128;
+    t = xorBlock(dbl(d), paddedSn);
+    clean(paddedSn);
+  }
+  const result = cmac(t, key);
+  clean(d, t);
+  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 match = CIPHERS.exec(algorithm.toLowerCase());
+    if (!match) throw error("ERR_CRYPTO_UNKNOWN_CIPHER", "Unknown cipher");
+    return { keyLength: Number(match[1]) / 8, mode: match[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(iv, mode) {
+    if (mode === "ecb") {
+      if (iv === null || iv === void 0) return void 0;
+      const bytes22 = deps.bytesOf(iv);
+      if (bytes22.length !== 0) throw Object.assign(new TypeError("Invalid initialization vector"), { code: "ERR_CRYPTO_INVALID_IV" });
+      return void 0;
+    }
+    if (iv === null || iv === void 0) throw Object.assign(new TypeError("Invalid initialization vector"), { code: "ERR_CRYPTO_INVALID_IV" });
+    const bytes2 = new Uint8Array(deps.bytesOf(iv));
+    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 i2 = 15; i2 >= from; i2--) {
+      counter[i2] = counter[i2] + 1 & 255;
+      if (counter[i2] !== 0) return;
+    }
+  }
+  let authTagOf;
+  let expectTagOf;
+  class CipherBase {
+    constructor(decrypt2, algorithm, key, iv, 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(iv, 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 j0;
+        if (ivBytes.length === 12) {
+          j0 = new Uint8Array(16);
+          j0.set(ivBytes);
+          j0[15] = 1;
+        } else {
+          const lengths = new Uint8Array(16);
+          new DataView(lengths.buffer).setBigUint64(8, BigInt(ivBytes.length * 8), false);
+          const g2 = new GHASH(h);
+          g2.update(ivBytes).update(lengths);
+          j0 = g2.digest();
+        }
+        __privateSet(this, _tagMask, encryptBlock2(__privateGet(this, _xk), j0));
+        __privateSet(this, _counter, new Uint8Array(j0));
+        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, _options2) {
+      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 at2 = 0;
+    while (at2 < 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 - at2);
+      for (let i2 = 0; i2 < take; i2++) out[at2 + i2] = input[at2 + i2] ^ __privateGet(this, _keystream)[i2];
+      __privateSet(this, _keystream, __privateGet(this, _keystream).subarray(take));
+      at2 += 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 at2 = 0; at2 < whole; at2 += 16) out.set(__privateMethod(this, _CipherBase_instances, block_fn).call(this, all.subarray(at2, at2 + 16)), at2);
+    __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 i2 = 0; i2 < 16; i2++) plain[i2] = plain[i2] ^ __privateGet(this, _chain)[i2];
+      __privateSet(this, _chain, new Uint8Array(block));
+      return plain;
+    }
+    const mixed = new Uint8Array(16);
+    for (let i2 = 0; i2 < 16; i2++) mixed[i2] = block[i2] ^ __privateGet(this, _chain)[i2];
+    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 i2 = 16 - pad; valid && i2 < 16; i2++) valid = plain[i2] === 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 i2 = 0; i2 < 16; i2++) full[i2] = full[i2] ^ __privateGet(this, _tagMask)[i2];
+    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 i2 = 0; i2 < expected.length; i2++) same = same && full[i2] === expected[i2];
+    if (!same) throw new Error("Unsupported state or unable to authenticate data");
+    return new Uint8Array(0);
+  };
+  authTagOf = (cipher) => {
+    var _a2;
+    return __privateMethod(_a2 = cipher, _CipherBase_instances, getTag_fn).call(_a2);
+  };
+  expectTagOf = (cipher, tag, encoding) => {
+    var _a2;
+    return __privateMethod(_a2 = cipher, _CipherBase_instances, setTag_fn).call(_a2, tag, encoding);
+  };
+  class Cipheriv2 extends CipherBase {
+    constructor(algorithm, key, iv, options) {
+      super(false, algorithm, key, iv, options);
+    }
+    getAuthTag() {
+      return deps.toBuffer(authTagOf(this));
+    }
+  }
+  class Decipheriv2 extends CipherBase {
+    constructor(algorithm, key, iv, options) {
+      super(true, algorithm, key, iv, options);
+    }
+    setAuthTag(tag, encoding) {
+      expectTagOf(this, tag, encoding);
+      return this;
+    }
+  }
+  return {
+    Cipheriv: Cipheriv2,
+    Decipheriv: Decipheriv2,
+    createCipheriv: (algorithm, key, iv, options) => new Cipheriv2(algorithm, key, iv, options),
+    createDecipheriv: (algorithm, key, iv, options) => new Decipheriv2(algorithm, key, iv, options)
+  };
+}
 function createCryptoModule(require2) {
   var _state, _done, _inner, _outer, _done2, _algorithm, _data, _algorithm2, _data2, __keyData, __type, __algorithm;
   const bufferModule2 = require2 ? require2("buffer") : lazyModule("buffer");
@@ -24028,7 +25008,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();
@@ -24149,7 +25129,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,
@@ -24178,12 +25176,16 @@ ${body}
   };
 }
 const cryptoModule = createCryptoModule();
-const { randomBytes, randomFillSync, randomFill, randomUUID, randomInt, getRandomValues, unsupported: unsupported$1, 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: unsupported$1, createHash, createHmac, hash, pbkdf2Sync, pbkdf2, sign, verify, createSign, createVerify, KeyObject, createSecretKey, createPublicKey, createPrivateKey, generateKeyPair, timingSafeEqual, getCiphers, getHashes } = cryptoModule;
 const cryptoShim = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
+  Cipheriv,
+  Decipheriv,
   KeyObject,
   constants: cryptoConstants,
+  createCipheriv,
   createCryptoModule,
+  createDecipheriv,
   createHash,
   createHmac,
   createPrivateKey,
@@ -32833,12 +33835,12 @@ class SHA2_32B extends HashMD {
     this.set(A, B, C, D, E, F, G, 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 {
@@ -40696,7 +41698,7 @@ class WorkerRuntime {
     this.worker = new Worker(
       new URL(
         /* @vite-ignore */
-        "/assets/runtime-worker-C1IV4qnr.js",
+        "/assets/runtime-worker-Cu2mr9G9.js",
         import.meta.url
       ),
       { type: "module" }