
// @from(Start 5321583, End 5386557)
Em0 = z((SR8, wm0) => {
  var {
    Buffer: rF6
  } = Z1("node:buffer");
  wm0.exports = rF6.from("[encoded data, 64860 characters]", "base64")
})
// @from(Start 5386563, End 5388766)
fr = z((_R8, Om0) => {
  var Um0 = ["GET", "HEAD", "POST"],
    oF6 = new Set(Um0),
    tF6 = [101, 204, 205, 304],
    Nm0 = [301, 302, 303, 307, 308],
    eF6 = new Set(Nm0),
    $m0 = ["1", "7", "9", "11", "13", "15", "17", "19", "20", "21", "22", "23", "25", "37", "42", "43", "53", "69", "77", "79", "87", "95", "101", "102", "103", "104", "109", "110", "111", "113", "115", "117", "119", "123", "135", "137", "139", "143", "161", "179", "389", "427", "465", "512", "513", "514", "515", "526", "530", "531", "532", "540", "548", "554", "556", "563", "587", "601", "636", "989", "990", "993", "995", "1719", "1720", "1723", "2049", "3659", "4045", "4190", "5060", "5061", "6000", "6566", "6665", "6666", "6667", "6668", "6669", "6679", "6697", "10080"],
    AX6 = new Set($m0),
    qm0 = ["", "no-referrer", "no-referrer-when-downgrade", "same-origin", "origin", "strict-origin", "origin-when-cross-origin", "strict-origin-when-cross-origin", "unsafe-url"],
    BX6 = new Set(qm0),
    QX6 = ["follow", "manual", "error"],
    Mm0 = ["GET", "HEAD", "OPTIONS", "TRACE"],
    IX6 = new Set(Mm0),
    GX6 = ["navigate", "same-origin", "no-cors", "cors"],
    ZX6 = ["omit", "same-origin", "include"],
    DX6 = ["default", "no-store", "reload", "no-cache", "force-cache", "only-if-cached"],
    YX6 = ["content-encoding", "content-language", "content-location", "content-type", "content-length"],
    WX6 = ["half"],
    Lm0 = ["CONNECT", "TRACE", "TRACK"],
    JX6 = new Set(Lm0),
    Rm0 = ["audio", "audioworklet", "font", "image", "manifest", "paintworklet", "script", "style", "track", "video", "xslt", ""],
    FX6 = new Set(Rm0);
  Om0.exports = {
    subresource: Rm0,
    forbiddenMethods: Lm0,
    requestBodyHeader: YX6,
    referrerPolicy: qm0,
    requestRedirect: QX6,
    requestMode: GX6,
    requestCredentials: ZX6,
    requestCache: DX6,
    redirectStatus: Nm0,
    corsSafeListedMethods: Um0,
    nullBodyStatus: tF6,
    safeMethods: Mm0,
    badPorts: $m0,
    requestDuplex: WX6,
    subresourceSet: FX6,
    badPortsSet: AX6,
    redirectStatusSet: eF6,
    corsSafeListedMethodsSet: oF6,
    safeMethodsSet: IX6,
    forbiddenMethodsSet: JX6,
    referrerPolicySet: BX6
  }
})
// @from(Start 5388772, End 5389489)
ku1 = z((jR8, Tm0) => {
  var yu1 = Symbol.for("undici.globalOrigin.1");

  function XX6() {
    return globalThis[yu1]
  }

  function VX6(A) {
    if (A === void 0) {
      Object.defineProperty(globalThis, yu1, {
        value: void 0,
        writable: !0,
        enumerable: !1,
        configurable: !1
      });
      return
    }
    let B = new URL(A);
    if (B.protocol !== "http:" && B.protocol !== "https:") throw new TypeError(`Only http & https urls are allowed, received ${B.protocol}`);
    Object.defineProperty(globalThis, yu1, {
      value: B,
      writable: !0,
      enumerable: !1,
      configurable: !1
    })
  }
  Tm0.exports = {
    getGlobalOrigin: XX6,
    setGlobalOrigin: VX6
  }
})
// @from(Start 5389495, End 5396341)
nY = z((yR8, xm0) => {
  var yY1 = Z1("node:assert"),
    CX6 = new TextEncoder,
    vr = /^[!#$%&'*+\-.^_|~A-Za-z0-9]+$/,
    KX6 = /[\u000A\u000D\u0009\u0020]/,
    HX6 = /[\u0009\u000A\u000C\u000D\u0020]/g,
    zX6 = /^[\u0009\u0020-\u007E\u0080-\u00FF]+$/;

  function wX6(A) {
    yY1(A.protocol === "data:");
    let B = _m0(A, !0);
    B = B.slice(5);
    let Q = {
        position: 0
      },
      I = yh(",", B, Q),
      G = I.length;
    if (I = MX6(I, !0, !0), Q.position >= B.length) return "failure";
    Q.position++;
    let Z = B.slice(G + 1),
      D = jm0(Z);
    if (/;(\u0020){0,}base64$/i.test(I)) {
      let W = km0(D);
      if (D = UX6(W), D === "failure") return "failure";
      I = I.slice(0, -6), I = I.replace(/(\u0020)+$/, ""), I = I.slice(0, -1)
    }
    if (I.startsWith(";")) I = "text/plain" + I;
    let Y = xu1(I);
    if (Y === "failure") Y = xu1("text/plain;charset=US-ASCII");
    return {
      mimeType: Y,
      body: D
    }
  }

  function _m0(A, B = !1) {
    if (!B) return A.href;
    let Q = A.href,
      I = A.hash.length,
      G = I === 0 ? Q : Q.substring(0, Q.length - I);
    if (!I && Q.endsWith("#")) return G.slice(0, -1);
    return G
  }

  function kY1(A, B, Q) {
    let I = "";
    while (Q.position < B.length && A(B[Q.position])) I += B[Q.position], Q.position++;
    return I
  }

  function yh(A, B, Q) {
    let I = B.indexOf(A, Q.position),
      G = Q.position;
    if (I === -1) return Q.position = B.length, B.slice(G);
    return Q.position = I, B.slice(G, Q.position)
  }

  function jm0(A) {
    let B = CX6.encode(A);
    return EX6(B)
  }

  function Pm0(A) {
    return A >= 48 && A <= 57 || A >= 65 && A <= 70 || A >= 97 && A <= 102
  }

  function Sm0(A) {
    return A >= 48 && A <= 57 ? A - 48 : (A & 223) - 55
  }

  function EX6(A) {
    let B = A.length,
      Q = new Uint8Array(B),
      I = 0;
    for (let G = 0; G < B; ++G) {
      let Z = A[G];
      if (Z !== 37) Q[I++] = Z;
      else if (Z === 37 && !(Pm0(A[G + 1]) && Pm0(A[G + 2]))) Q[I++] = 37;
      else Q[I++] = Sm0(A[G + 1]) << 4 | Sm0(A[G + 2]), G += 2
    }
    return B === I ? Q : Q.subarray(0, I)
  }

  function xu1(A) {
    A = jY1(A, !0, !0);
    let B = {
        position: 0
      },
      Q = yh("/", A, B);
    if (Q.length === 0 || !vr.test(Q)) return "failure";
    if (B.position > A.length) return "failure";
    B.position++;
    let I = yh(";", A, B);
    if (I = jY1(I, !1, !0), I.length === 0 || !vr.test(I)) return "failure";
    let G = Q.toLowerCase(),
      Z = I.toLowerCase(),
      D = {
        type: G,
        subtype: Z,
        parameters: new Map,
        essence: `${G}/${Z}`
      };
    while (B.position < A.length) {
      B.position++, kY1((J) => KX6.test(J), A, B);
      let Y = kY1((J) => J !== ";" && J !== "=", A, B);
      if (Y = Y.toLowerCase(), B.position < A.length) {
        if (A[B.position] === ";") continue;
        B.position++
      }
      if (B.position > A.length) break;
      let W = null;
      if (A[B.position] === '"') W = ym0(A, B, !0), yh(";", A, B);
      else if (W = yh(";", A, B), W = jY1(W, !1, !0), W.length === 0) continue;
      if (Y.length !== 0 && vr.test(Y) && (W.length === 0 || zX6.test(W)) && !D.parameters.has(Y)) D.parameters.set(Y, W)
    }
    return D
  }

  function UX6(A) {
    A = A.replace(HX6, "");
    let B = A.length;
    if (B % 4 === 0) {
      if (A.charCodeAt(B - 1) === 61) {
        if (--B, A.charCodeAt(B - 1) === 61) --B
      }
    }
    if (B % 4 === 1) return "failure";
    if (/[^+/0-9A-Za-z]/.test(A.length === B ? A : A.substring(0, B))) return "failure";
    let Q = Buffer.from(A, "base64");
    return new Uint8Array(Q.buffer, Q.byteOffset, Q.byteLength)
  }

  function ym0(A, B, Q) {
    let I = B.position,
      G = "";
    yY1(A[B.position] === '"'), B.position++;
    while (!0) {
      if (G += kY1((D) => D !== '"' && D !== "\\", A, B), B.position >= A.length) break;
      let Z = A[B.position];
      if (B.position++, Z === "\\") {
        if (B.position >= A.length) {
          G += "\\";
          break
        }
        G += A[B.position], B.position++
      } else {
        yY1(Z === '"');
        break
      }
    }
    if (Q) return G;
    return A.slice(I, B.position)
  }

  function NX6(A) {
    yY1(A !== "failure");
    let {
      parameters: B,
      essence: Q
    } = A, I = Q;
    for (let [G, Z] of B.entries()) {
      if (I += ";", I += G, I += "=", !vr.test(Z)) Z = Z.replace(/(\\|")/g, "\\$1"), Z = '"' + Z, Z += '"';
      I += Z
    }
    return I
  }

  function $X6(A) {
    return A === 13 || A === 10 || A === 9 || A === 32
  }

  function jY1(A, B = !0, Q = !0) {
    return fu1(A, B, Q, $X6)
  }

  function qX6(A) {
    return A === 13 || A === 10 || A === 9 || A === 12 || A === 32
  }

  function MX6(A, B = !0, Q = !0) {
    return fu1(A, B, Q, qX6)
  }

  function fu1(A, B, Q, I) {
    let G = 0,
      Z = A.length - 1;
    if (B)
      while (G < A.length && I(A.charCodeAt(G))) G++;
    if (Q)
      while (Z > 0 && I(A.charCodeAt(Z))) Z--;
    return G === 0 && Z === A.length - 1 ? A : A.slice(G, Z + 1)
  }

  function km0(A) {
    let B = A.length;
    if (65535 > B) return String.fromCharCode.apply(null, A);
    let Q = "",
      I = 0,
      G = 65535;
    while (I < B) {
      if (I + G > B) G = B - I;
      Q += String.fromCharCode.apply(null, A.subarray(I, I += G))
    }
    return Q
  }

  function LX6(A) {
    switch (A.essence) {
      case "application/ecmascript":
      case "application/javascript":
      case "application/x-ecmascript":
      case "application/x-javascript":
      case "text/ecmascript":
      case "text/javascript":
      case "text/javascript1.0":
      case "text/javascript1.1":
      case "text/javascript1.2":
      case "text/javascript1.3":
      case "text/javascript1.4":
      case "text/javascript1.5":
      case "text/jscript":
      case "text/livescript":
      case "text/x-ecmascript":
      case "text/x-javascript":
        return "text/javascript";
      case "application/json":
      case "text/json":
        return "application/json";
      case "image/svg+xml":
        return "image/svg+xml";
      case "text/xml":
      case "application/xml":
        return "application/xml"
    }
    if (A.subtype.endsWith("+json")) return "application/json";
    if (A.subtype.endsWith("+xml")) return "application/xml";
    return ""
  }
  xm0.exports = {
    dataURLProcessor: wX6,
    URLSerializer: _m0,
    collectASequenceOfCodePoints: kY1,
    collectASequenceOfCodePointsFast: yh,
    stringPercentDecode: jm0,
    parseMIMEType: xu1,
    collectAnHTTPQuotedString: ym0,
    serializeAMimeType: NX6,
    removeChars: fu1,
    removeHTTPWhitespace: jY1,
    minimizeSupportedMimeType: LX6,
    HTTP_TOKEN_CODEPOINTS: vr,
    isomorphicDecode: km0
  }
})
// @from(Start 5396347, End 5407105)
jG = z((kR8, fm0) => {
  var {
    types: Nw,
    inspect: RX6
  } = Z1("node:util"), {
    markAsUncloneable: OX6
  } = Z1("node:worker_threads"), {
    toUSVString: TX6
  } = C6(), P0 = {};
  P0.converters = {};
  P0.util = {};
  P0.errors = {};
  P0.errors.exception = function(A) {
    return new TypeError(`${A.header}: ${A.message}`)
  };
  P0.errors.conversionFailed = function(A) {
    let B = A.types.length === 1 ? "" : " one of",
      Q = `${A.argument} could not be converted to${B}: ${A.types.join(", ")}.`;
    return P0.errors.exception({
      header: A.prefix,
      message: Q
    })
  };
  P0.errors.invalidArgument = function(A) {
    return P0.errors.exception({
      header: A.prefix,
      message: `"${A.value}" is an invalid ${A.type}.`
    })
  };
  P0.brandCheck = function(A, B, Q) {
    if (Q?.strict !== !1) {
      if (!(A instanceof B)) {
        let I = new TypeError("Illegal invocation");
        throw I.code = "ERR_INVALID_THIS", I
      }
    } else if (A?.[Symbol.toStringTag] !== B.prototype[Symbol.toStringTag]) {
      let I = new TypeError("Illegal invocation");
      throw I.code = "ERR_INVALID_THIS", I
    }
  };
  P0.argumentLengthCheck = function({
    length: A
  }, B, Q) {
    if (A < B) throw P0.errors.exception({
      message: `${B} argument${B!==1?"s":""} required, but${A?" only":""} ${A} found.`,
      header: Q
    })
  };
  P0.illegalConstructor = function() {
    throw P0.errors.exception({
      header: "TypeError",
      message: "Illegal constructor"
    })
  };
  P0.util.Type = function(A) {
    switch (typeof A) {
      case "undefined":
        return "Undefined";
      case "boolean":
        return "Boolean";
      case "string":
        return "String";
      case "symbol":
        return "Symbol";
      case "number":
        return "Number";
      case "bigint":
        return "BigInt";
      case "function":
      case "object": {
        if (A === null) return "Null";
        return "Object"
      }
    }
  };
  P0.util.markAsUncloneable = OX6 || (() => {});
  P0.util.ConvertToInt = function(A, B, Q, I) {
    let G, Z;
    if (B === 64)
      if (G = Math.pow(2, 53) - 1, Q === "unsigned") Z = 0;
      else Z = Math.pow(-2, 53) + 1;
    else if (Q === "unsigned") Z = 0, G = Math.pow(2, B) - 1;
    else Z = Math.pow(-2, B) - 1, G = Math.pow(2, B - 1) - 1;
    let D = Number(A);
    if (D === 0) D = 0;
    if (I?.enforceRange === !0) {
      if (Number.isNaN(D) || D === Number.POSITIVE_INFINITY || D === Number.NEGATIVE_INFINITY) throw P0.errors.exception({
        header: "Integer conversion",
        message: `Could not convert ${P0.util.Stringify(A)} to an integer.`
      });
      if (D = P0.util.IntegerPart(D), D < Z || D > G) throw P0.errors.exception({
        header: "Integer conversion",
        message: `Value must be between ${Z}-${G}, got ${D}.`
      });
      return D
    }
    if (!Number.isNaN(D) && I?.clamp === !0) {
      if (D = Math.min(Math.max(D, Z), G), Math.floor(D) % 2 === 0) D = Math.floor(D);
      else D = Math.ceil(D);
      return D
    }
    if (Number.isNaN(D) || D === 0 && Object.is(0, D) || D === Number.POSITIVE_INFINITY || D === Number.NEGATIVE_INFINITY) return 0;
    if (D = P0.util.IntegerPart(D), D = D % Math.pow(2, B), Q === "signed" && D >= Math.pow(2, B) - 1) return D - Math.pow(2, B);
    return D
  };
  P0.util.IntegerPart = function(A) {
    let B = Math.floor(Math.abs(A));
    if (A < 0) return -1 * B;
    return B
  };
  P0.util.Stringify = function(A) {
    switch (P0.util.Type(A)) {
      case "Symbol":
        return `Symbol(${A.description})`;
      case "Object":
        return RX6(A);
      case "String":
        return `"${A}"`;
      default:
        return `${A}`
    }
  };
  P0.sequenceConverter = function(A) {
    return (B, Q, I, G) => {
      if (P0.util.Type(B) !== "Object") throw P0.errors.exception({
        header: Q,
        message: `${I} (${P0.util.Stringify(B)}) is not iterable.`
      });
      let Z = typeof G === "function" ? G() : B?.[Symbol.iterator]?.(),
        D = [],
        Y = 0;
      if (Z === void 0 || typeof Z.next !== "function") throw P0.errors.exception({
        header: Q,
        message: `${I} is not iterable.`
      });
      while (!0) {
        let {
          done: W,
          value: J
        } = Z.next();
        if (W) break;
        D.push(A(J, Q, `${I}[${Y++}]`))
      }
      return D
    }
  };
  P0.recordConverter = function(A, B) {
    return (Q, I, G) => {
      if (P0.util.Type(Q) !== "Object") throw P0.errors.exception({
        header: I,
        message: `${G} ("${P0.util.Type(Q)}") is not an Object.`
      });
      let Z = {};
      if (!Nw.isProxy(Q)) {
        let Y = [...Object.getOwnPropertyNames(Q), ...Object.getOwnPropertySymbols(Q)];
        for (let W of Y) {
          let J = A(W, I, G),
            F = B(Q[W], I, G);
          Z[J] = F
        }
        return Z
      }
      let D = Reflect.ownKeys(Q);
      for (let Y of D)
        if (Reflect.getOwnPropertyDescriptor(Q, Y)?.enumerable) {
          let J = A(Y, I, G),
            F = B(Q[Y], I, G);
          Z[J] = F
        } return Z
    }
  };
  P0.interfaceConverter = function(A) {
    return (B, Q, I, G) => {
      if (G?.strict !== !1 && !(B instanceof A)) throw P0.errors.exception({
        header: Q,
        message: `Expected ${I} ("${P0.util.Stringify(B)}") to be an instance of ${A.name}.`
      });
      return B
    }
  };
  P0.dictionaryConverter = function(A) {
    return (B, Q, I) => {
      let G = P0.util.Type(B),
        Z = {};
      if (G === "Null" || G === "Undefined") return Z;
      else if (G !== "Object") throw P0.errors.exception({
        header: Q,
        message: `Expected ${B} to be one of: Null, Undefined, Object.`
      });
      for (let D of A) {
        let {
          key: Y,
          defaultValue: W,
          required: J,
          converter: F
        } = D;
        if (J === !0) {
          if (!Object.hasOwn(B, Y)) throw P0.errors.exception({
            header: Q,
            message: `Missing required key "${Y}".`
          })
        }
        let X = B[Y],
          V = Object.hasOwn(D, "defaultValue");
        if (V && X !== null) X ??= W();
        if (J || V || X !== void 0) {
          if (X = F(X, Q, `${I}.${Y}`), D.allowedValues && !D.allowedValues.includes(X)) throw P0.errors.exception({
            header: Q,
            message: `${X} is not an accepted type. Expected one of ${D.allowedValues.join(", ")}.`
          });
          Z[Y] = X
        }
      }
      return Z
    }
  };
  P0.nullableConverter = function(A) {
    return (B, Q, I) => {
      if (B === null) return B;
      return A(B, Q, I)
    }
  };
  P0.converters.DOMString = function(A, B, Q, I) {
    if (A === null && I?.legacyNullToEmptyString) return "";
    if (typeof A === "symbol") throw P0.errors.exception({
      header: B,
      message: `${Q} is a symbol, which cannot be converted to a DOMString.`
    });
    return String(A)
  };
  P0.converters.ByteString = function(A, B, Q) {
    let I = P0.converters.DOMString(A, B, Q);
    for (let G = 0; G < I.length; G++)
      if (I.charCodeAt(G) > 255) throw new TypeError(`Cannot convert argument to a ByteString because the character at index ${G} has a value of ${I.charCodeAt(G)} which is greater than 255.`);
    return I
  };
  P0.converters.USVString = TX6;
  P0.converters.boolean = function(A) {
    return Boolean(A)
  };
  P0.converters.any = function(A) {
    return A
  };
  P0.converters["long long"] = function(A, B, Q) {
    return P0.util.ConvertToInt(A, 64, "signed", void 0, B, Q)
  };
  P0.converters["unsigned long long"] = function(A, B, Q) {
    return P0.util.ConvertToInt(A, 64, "unsigned", void 0, B, Q)
  };
  P0.converters["unsigned long"] = function(A, B, Q) {
    return P0.util.ConvertToInt(A, 32, "unsigned", void 0, B, Q)
  };
  P0.converters["unsigned short"] = function(A, B, Q, I) {
    return P0.util.ConvertToInt(A, 16, "unsigned", I, B, Q)
  };
  P0.converters.ArrayBuffer = function(A, B, Q, I) {
    if (P0.util.Type(A) !== "Object" || !Nw.isAnyArrayBuffer(A)) throw P0.errors.conversionFailed({
      prefix: B,
      argument: `${Q} ("${P0.util.Stringify(A)}")`,
      types: ["ArrayBuffer"]
    });
    if (I?.allowShared === !1 && Nw.isSharedArrayBuffer(A)) throw P0.errors.exception({
      header: "ArrayBuffer",
      message: "SharedArrayBuffer is not allowed."
    });
    if (A.resizable || A.growable) throw P0.errors.exception({
      header: "ArrayBuffer",
      message: "Received a resizable ArrayBuffer."
    });
    return A
  };
  P0.converters.TypedArray = function(A, B, Q, I, G) {
    if (P0.util.Type(A) !== "Object" || !Nw.isTypedArray(A) || A.constructor.name !== B.name) throw P0.errors.conversionFailed({
      prefix: Q,
      argument: `${I} ("${P0.util.Stringify(A)}")`,
      types: [B.name]
    });
    if (G?.allowShared === !1 && Nw.isSharedArrayBuffer(A.buffer)) throw P0.errors.exception({
      header: "ArrayBuffer",
      message: "SharedArrayBuffer is not allowed."
    });
    if (A.buffer.resizable || A.buffer.growable) throw P0.errors.exception({
      header: "ArrayBuffer",
      message: "Received a resizable ArrayBuffer."
    });
    return A
  };
  P0.converters.DataView = function(A, B, Q, I) {
    if (P0.util.Type(A) !== "Object" || !Nw.isDataView(A)) throw P0.errors.exception({
      header: B,
      message: `${Q} is not a DataView.`
    });
    if (I?.allowShared === !1 && Nw.isSharedArrayBuffer(A.buffer)) throw P0.errors.exception({
      header: "ArrayBuffer",
      message: "SharedArrayBuffer is not allowed."
    });
    if (A.buffer.resizable || A.buffer.growable) throw P0.errors.exception({
      header: "ArrayBuffer",
      message: "Received a resizable ArrayBuffer."
    });
    return A
  };
  P0.converters.BufferSource = function(A, B, Q, I) {
    if (Nw.isAnyArrayBuffer(A)) return P0.converters.ArrayBuffer(A, B, Q, {
      ...I,
      allowShared: !1
    });
    if (Nw.isTypedArray(A)) return P0.converters.TypedArray(A, A.constructor, B, Q, {
      ...I,
      allowShared: !1
    });
    if (Nw.isDataView(A)) return P0.converters.DataView(A, B, Q, {
      ...I,
      allowShared: !1
    });
    throw P0.errors.conversionFailed({
      prefix: B,
      argument: `${Q} ("${P0.util.Stringify(A)}")`,
      types: ["BufferSource"]
    })
  };
  P0.converters["sequence<ByteString>"] = P0.sequenceConverter(P0.converters.ByteString);
  P0.converters["sequence<sequence<ByteString>>"] = P0.sequenceConverter(P0.converters["sequence<ByteString>"]);
  P0.converters["record<ByteString, ByteString>"] = P0.recordConverter(P0.converters.ByteString, P0.converters.ByteString);
  fm0.exports = {
    webidl: P0
  }
})