llonebot-dist 7.1.2 → 7.1.3

package/llonebot.js

@@ -7,26 +7,27 @@ import * as fs from "node:fs";
 import fs__default, { existsSync, mkdirSync, appendFile, statSync, appendFileSync } from "node:fs";
 import * as os from "node:os";
 import os__default from "node:os";
-import require$$0$4 from "fs";
+import require$$0$3 from "fs";
 import fsPromise, { unlink, stat, access, copyFile, writeFile, readFile } from "node:fs/promises";
 import crypto$1, { randomUUID, randomBytes, createHash } from "node:crypto";
 import require$$4$1, { gzipSync, gunzipSync, deflateSync, inflateSync } from "node:zlib";
 import path$1 from "path";
 import require$$1$2 from "util";
 import require$$2$2 from "events";
-import require$$0$5 from "child_process";
+import require$$0$4 from "child_process";
 import require$$1$1 from "os";
 import require$$2$1 from "stream";
 import { WebSocketServer, WebSocket as WebSocket$2 } from "ws";
-import require$$0$7 from "debug";
-import require$$0$6 from "buffer";
+import require$$0$6 from "debug";
+import require$$0$5 from "buffer";
 import require$$1$3 from "string_decoder";
 import require$$2$3 from "object-inspect";
 import require$$1$5 from "node:events";
-import require$$0$8, { fileURLToPath as fileURLToPath$1 } from "url";
+import require$$0$7, { fileURLToPath as fileURLToPath$1 } from "url";
 import require$$2$4 from "node:http";
-import require$$0$9 from "crypto";
-import require$$6$1 from "querystring";
+import require$$0$8 from "crypto";
+import require$$6$1 from "node:querystring";
+import require$$7$1 from "node:buffer";
 import require$$1$4 from "node:net";
 import require$$8 from "ms";
 import * as fileType from "file-type";
@@ -1233,11 +1234,12 @@ var __name$8 = (target, value) => __defProp$9(target, "name", { value, configura
 var __commonJS$1 = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames$1(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
-var require_src = __commonJS$1({
+var require_index$1 = __commonJS$1({
   "src/index.ts"(exports$1, module) {
     var kSchema = Symbol.for("schemastery");
     var kValidationError = Symbol.for("ValidationError");
     globalThis.__schemastery_index__ ??= 0;
+    globalThis.__schemastery_refs__ = void 0;
     var ValidationError = class extends TypeError {
       constructor(message, options) {
         let prefix = "$";
@@ -1270,16 +1272,16 @@ var require_src = __commonJS$1({
         return Schema.resolve(data, schema, options2)[0];
       }, "schema");
       if (options.refs) {
-        const refs2 = valueMap(options.refs, (options2) => new Schema(options2));
-        const getRef = /* @__PURE__ */ __name$8((uid) => refs2[uid], "getRef");
-        for (const key2 in refs2) {
-          const options2 = refs2[key2];
+        const refs = valueMap(options.refs, (options2) => new Schema(options2));
+        const getRef = /* @__PURE__ */ __name$8((uid) => refs[uid], "getRef");
+        for (const key2 in refs) {
+          const options2 = refs[key2];
           options2.sKey = getRef(options2.sKey);
           options2.inner = getRef(options2.inner);
           options2.list = options2.list && options2.list.map(getRef);
           options2.dict = options2.dict && valueMap(options2.dict, getRef);
         }
-        return refs2[options.uid];
+        return refs[options.uid];
       }
       Object.assign(schema, options);
       if (typeof schema.callback === "string") {
@@ -1297,16 +1299,15 @@ var require_src = __commonJS$1({
     Schema.prototype = Object.create(Function.prototype);
     Schema.prototype[kSchema] = true;
     Schema.ValidationError = ValidationError;
-    var refs;
     Schema.prototype.toJSON = /* @__PURE__ */ __name$8(function toJSON() {
-      if (refs) {
-        refs[this.uid] ??= JSON.parse(JSON.stringify({ ...this }));
+      if (globalThis.__schemastery_refs__) {
+        globalThis.__schemastery_refs__[this.uid] ??= JSON.parse(JSON.stringify({ ...this }));
         return this.uid;
       }
-      refs = { [this.uid]: { ...this } };
-      refs[this.uid] = JSON.parse(JSON.stringify({ ...this }));
-      const result = { uid: this.uid, refs };
-      refs = void 0;
+      globalThis.__schemastery_refs__ = { [this.uid]: { ...this } };
+      globalThis.__schemastery_refs__[this.uid] = JSON.parse(JSON.stringify({ ...this }));
+      const result = { uid: this.uid, refs: globalThis.__schemastery_refs__ };
+      globalThis.__schemastery_refs__ = void 0;
       return result;
     }, "toJSON");
     Schema.prototype.set = /* @__PURE__ */ __name$8(function set2(key2, value) {
@@ -1651,9 +1652,21 @@ var require_src = __commonJS$1({
       if (typeof data === "function") return [data];
       throw new ValidationError(`expected function but got ${data}`, options);
     });
-    Schema.extend("is", (data, { callback }, options) => {
-      if (data instanceof callback) return [data];
-      throw new ValidationError(`expected ${callback.name} but got ${data}`, options);
+    Schema.extend("is", (data, { constructor }, options) => {
+      if (typeof constructor === "function") {
+        if (data instanceof constructor) return [data];
+        throw new ValidationError(`expected ${constructor.name} but got ${data}`, options);
+      } else {
+        if (isNullable(data)) {
+          throw new ValidationError(`expected ${constructor} but got ${data}`, options);
+        }
+        let prototype = Object.getPrototypeOf(data);
+        while (prototype) {
+          if (prototype.constructor?.name === constructor) return [data];
+          prototype = Object.getPrototypeOf(prototype);
+        }
+        throw new ValidationError(`expected ${constructor} but got ${data}`, options);
+      }
     });
     function property(data, key2, schema, options) {
       try {
@@ -1728,6 +1741,7 @@ var require_src = __commonJS$1({
       throw new ValidationError(`expected ${toString()} but got ${JSON.stringify(data)}`, options);
     });
     Schema.extend("intersect", (data, { list, toString }, options, strict) => {
+      if (!list.length) return [data];
       let result;
       for (const inner of list) {
         const value = Schema.resolve(data, inner, options, true)[0];
@@ -1782,8 +1796,15 @@ var require_src = __commonJS$1({
                 break;
               }
               case "callback": {
-                schema.callback = args[index2];
-                schema.callback["toJSON"] ||= () => schema.callback.toString();
+                const callback = schema.callback = args[index2];
+                callback["toJSON"] ||= () => callback.toString();
+                break;
+              }
+              case "constructor": {
+                const constructor = schema.constructor = args[index2];
+                if (typeof constructor === "function") {
+                  constructor["toJSON"] ||= () => constructor["name"];
+                }
                 break;
               }
               default:
@@ -1802,7 +1823,13 @@ var require_src = __commonJS$1({
       });
     }
     __name$8(defineMethod, "defineMethod");
-    defineMethod("is", ["callback"], ({ callback }) => callback.name);
+    defineMethod("is", ["constructor"], ({ constructor }) => {
+      if (typeof constructor === "function") {
+        return constructor.name;
+      } else {
+        return constructor;
+      }
+    });
     defineMethod("any", [], () => "any");
     defineMethod("never", [], () => "never");
     defineMethod("const", ["value"], ({ value }) => typeof value === "string" ? JSON.stringify(value) : value);
@@ -1831,7 +1858,7 @@ var require_src = __commonJS$1({
     module.exports = Schema;
   }
 });
-const z$1 = require_src();
+const z$1 = require_index$1();
 var __defProp$8 = Object.defineProperty;
 var __name$7 = (target, value) => __defProp$8(target, "name", { value, configurable: true });
 var kSchemaOrder = Symbol("cordis.schema.order");
@@ -3764,7 +3791,7 @@ class PMHQ {
         reject(new Error("pmhq ws send: wait result timeout"));
         this.removeResListener(listenerId);
       }, timeout2);
-      const listenerId = this.addResListener((res) => {
+      const listenerId = this.addResListener(((res) => {
         if (!res.data) {
           console.error(`PMHQ WS send error: payload ${JSON.stringify(data)}, response ${JSON.stringify(res)}`);
         }
@@ -3773,7 +3800,7 @@ class PMHQ {
           clearTimeout(timeoutId);
           this.removeResListener(listenerId);
         }
-      });
+      }));
     });
     this.ws.send(payload);
     return p;
@@ -6039,7 +6066,7 @@ function requireWindows() {
   hasRequiredWindows = 1;
   windows = isexe;
   isexe.sync = sync;
-  var fs2 = require$$0$4;
+  var fs2 = require$$0$3;
   function checkPathExt(path2, options) {
     var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
     if (!pathext) {
@@ -6080,7 +6107,7 @@ function requireMode() {
   hasRequiredMode = 1;
   mode = isexe;
   isexe.sync = sync;
-  var fs2 = require$$0$4;
+  var fs2 = require$$0$3;
   function isexe(path2, options, cb) {
     fs2.stat(path2, function(er, stat2) {
       cb(er, er ? false : checkStat(stat2, options));
@@ -6280,7 +6307,7 @@ var hasRequiredUtils$3;
 function requireUtils$3() {
   if (hasRequiredUtils$3) return utils$3.exports;
   hasRequiredUtils$3 = 1;
-  require$$0$5.exec;
+  require$$0$4.exec;
   var isWindows = require$$1$1.platform().match(/win(32|64)/);
   var which = requireWhich();
   var nlRegexp = /\r\n|\r|\n/g;
@@ -7998,7 +8025,7 @@ var hasRequiredProcessor;
 function requireProcessor() {
   if (hasRequiredProcessor) return processor;
   hasRequiredProcessor = 1;
-  var spawn = require$$0$5.spawn;
+  var spawn = require$$0$4.spawn;
   var async2 = requireAsync();
   var utils2 = requireUtils$3();
   function runFfprobe(command) {
@@ -8394,7 +8421,7 @@ var hasRequiredCapabilities;
 function requireCapabilities() {
   if (hasRequiredCapabilities) return capabilities;
   hasRequiredCapabilities = 1;
-  var fs2 = require$$0$4;
+  var fs2 = require$$0$3;
   var path2 = path$1;
   var async2 = requireAsync();
   var utils2 = requireUtils$3();
@@ -8807,7 +8834,7 @@ var hasRequiredFfprobe;
 function requireFfprobe() {
   if (hasRequiredFfprobe) return ffprobe;
   hasRequiredFfprobe = 1;
-  var spawn = require$$0$5.spawn;
+  var spawn = require$$0$4.spawn;
   function legacyTag(key2) {
     return key2.match(/^TAG:/);
   }
@@ -8993,7 +9020,7 @@ var hasRequiredRecipes;
 function requireRecipes() {
   if (hasRequiredRecipes) return recipes;
   hasRequiredRecipes = 1;
-  var fs2 = require$$0$4;
+  var fs2 = require$$0$3;
   var path2 = path$1;
   var PassThrough = require$$2$1.PassThrough;
   var async2 = requireAsync();
@@ -10690,7 +10717,7 @@ class OB11HeartbeatEvent extends OB11BaseMetaEvent {
     };
   }
 }
-const version$1 = "7.1.2";
+const version$1 = "7.1.3";
 class OB11WebSocket {
   constructor(ctx, config2) {
     this.ctx = ctx;
@@ -11407,7 +11434,7 @@ function requireSetprototypeof() {
   }
   return setprototypeof;
 }
-const require$$0$3 = {
+const require$$0$2 = {
   "100": "Continue",
   "101": "Switching Protocols",
   "102": "Processing",
@@ -11472,13 +11499,13 @@ const require$$0$3 = {
   "510": "Not Extended",
   "511": "Network Authentication Required"
 };
-var statuses$1;
-var hasRequiredStatuses$1;
-function requireStatuses$1() {
-  if (hasRequiredStatuses$1) return statuses$1;
-  hasRequiredStatuses$1 = 1;
-  var codes = require$$0$3;
-  statuses$1 = status;
+var statuses;
+var hasRequiredStatuses;
+function requireStatuses() {
+  if (hasRequiredStatuses) return statuses;
+  hasRequiredStatuses = 1;
+  var codes = require$$0$2;
+  statuses = status;
   status.message = codes;
   status.code = createMessageToStatusCodeMap(codes);
   status.codes = createStatusCodeList(codes);
@@ -11541,7 +11568,7 @@ function requireStatuses$1() {
     }
     return getStatusCode(code);
   }
-  return statuses$1;
+  return statuses;
 }
 var inherits_browser = { exports: {} };
 var hasRequiredInherits_browser;
@@ -11596,7 +11623,7 @@ function requireHttpErrors() {
   (function(module) {
     var deprecate = requireBrowser()("http-errors");
     var setPrototypeOf = requireSetprototypeof();
-    var statuses2 = requireStatuses$1();
+    var statuses2 = requireStatuses();
     var inherits = requireInherits_browser();
     var toIdentifier = requireToidentifier();
     module.exports = createError;
@@ -11749,171 +11776,11 @@ function requireHttpErrors() {
       });
     }
     function toClassName(name) {
-      return name.substr(-5) !== "Error" ? name + "Error" : name;
+      return name.slice(-5) === "Error" ? name : name + "Error";
     }
   })(httpErrors);
   return httpErrors.exports;
 }
-var onFinished = { exports: {} };
-var eeFirst;
-var hasRequiredEeFirst;
-function requireEeFirst() {
-  if (hasRequiredEeFirst) return eeFirst;
-  hasRequiredEeFirst = 1;
-  eeFirst = first;
-  function first(stuff, done) {
-    if (!Array.isArray(stuff))
-      throw new TypeError("arg must be an array of [ee, events...] arrays");
-    var cleanups = [];
-    for (var i = 0; i < stuff.length; i++) {
-      var arr = stuff[i];
-      if (!Array.isArray(arr) || arr.length < 2)
-        throw new TypeError("each array member must be [ee, events...]");
-      var ee = arr[0];
-      for (var j = 1; j < arr.length; j++) {
-        var event = arr[j];
-        var fn = listener(event, callback);
-        ee.on(event, fn);
-        cleanups.push({
-          ee,
-          event,
-          fn
-        });
-      }
-    }
-    function callback() {
-      cleanup();
-      done.apply(null, arguments);
-    }
-    function cleanup() {
-      var x;
-      for (var i2 = 0; i2 < cleanups.length; i2++) {
-        x = cleanups[i2];
-        x.ee.removeListener(x.event, x.fn);
-      }
-    }
-    function thunk(fn2) {
-      done = fn2;
-    }
-    thunk.cancel = cleanup;
-    return thunk;
-  }
-  function listener(event, done) {
-    return function onevent(arg1) {
-      var args = new Array(arguments.length);
-      var ee = this;
-      var err = event === "error" ? arg1 : null;
-      for (var i = 0; i < args.length; i++) {
-        args[i] = arguments[i];
-      }
-      done(err, ee, event, args);
-    };
-  }
-  return eeFirst;
-}
-var hasRequiredOnFinished;
-function requireOnFinished() {
-  if (hasRequiredOnFinished) return onFinished.exports;
-  hasRequiredOnFinished = 1;
-  onFinished.exports = onFinished$1;
-  onFinished.exports.isFinished = isFinished;
-  var asyncHooks = tryRequireAsyncHooks();
-  var first = requireEeFirst();
-  var defer = typeof setImmediate === "function" ? setImmediate : function(fn) {
-    process.nextTick(fn.bind.apply(fn, arguments));
-  };
-  function onFinished$1(msg, listener) {
-    if (isFinished(msg) !== false) {
-      defer(listener, null, msg);
-      return msg;
-    }
-    attachListener(msg, wrap(listener));
-    return msg;
-  }
-  function isFinished(msg) {
-    var socket = msg.socket;
-    if (typeof msg.finished === "boolean") {
-      return Boolean(msg.finished || socket && !socket.writable);
-    }
-    if (typeof msg.complete === "boolean") {
-      return Boolean(msg.upgrade || !socket || !socket.readable || msg.complete && !msg.readable);
-    }
-    return void 0;
-  }
-  function attachFinishedListener(msg, callback) {
-    var eeMsg;
-    var eeSocket;
-    var finished = false;
-    function onFinish(error2) {
-      eeMsg.cancel();
-      eeSocket.cancel();
-      finished = true;
-      callback(error2);
-    }
-    eeMsg = eeSocket = first([[msg, "end", "finish"]], onFinish);
-    function onSocket(socket) {
-      msg.removeListener("socket", onSocket);
-      if (finished) return;
-      if (eeMsg !== eeSocket) return;
-      eeSocket = first([[socket, "error", "close"]], onFinish);
-    }
-    if (msg.socket) {
-      onSocket(msg.socket);
-      return;
-    }
-    msg.on("socket", onSocket);
-    if (msg.socket === void 0) {
-      patchAssignSocket(msg, onSocket);
-    }
-  }
-  function attachListener(msg, listener) {
-    var attached = msg.__onFinished;
-    if (!attached || !attached.queue) {
-      attached = msg.__onFinished = createListener(msg);
-      attachFinishedListener(msg, attached);
-    }
-    attached.queue.push(listener);
-  }
-  function createListener(msg) {
-    function listener(err) {
-      if (msg.__onFinished === listener) msg.__onFinished = null;
-      if (!listener.queue) return;
-      var queue2 = listener.queue;
-      listener.queue = null;
-      for (var i = 0; i < queue2.length; i++) {
-        queue2[i](err, msg);
-      }
-    }
-    listener.queue = [];
-    return listener;
-  }
-  function patchAssignSocket(res, callback) {
-    var assignSocket = res.assignSocket;
-    if (typeof assignSocket !== "function") return;
-    res.assignSocket = function _assignSocket(socket) {
-      assignSocket.call(this, socket);
-      callback(socket);
-    };
-  }
-  function tryRequireAsyncHooks() {
-    try {
-      return require("async_hooks");
-    } catch (e) {
-      return {};
-    }
-  }
-  function wrap(fn) {
-    var res;
-    if (asyncHooks.AsyncResource) {
-      res = new asyncHooks.AsyncResource(fn.name || "bound-anonymous-fn");
-    }
-    if (!res || !res.runInAsyncScope) {
-      return fn;
-    }
-    return res.runInAsyncScope.bind(res, fn, null);
-  }
-  return onFinished.exports;
-}
 var bytes = { exports: {} };
 var hasRequiredBytes;
 function requireBytes() {
@@ -12009,7 +11876,7 @@ var hasRequiredSafer;
 function requireSafer() {
   if (hasRequiredSafer) return safer_1;
   hasRequiredSafer = 1;
-  var buffer2 = require$$0$6;
+  var buffer2 = require$$0$5;
   var Buffer2 = buffer2.Buffer;
   var safer = {};
   var key2;
@@ -12101,12 +11968,14 @@ function requireBomHandling() {
   }
   StripBOMWrapper.prototype.write = function(buf) {
     var res = this.decoder.write(buf);
-    if (this.pass || !res)
+    if (this.pass || !res) {
       return res;
+    }
     if (res[0] === BOMChar) {
       res = res.slice(1);
-      if (typeof this.options.stripBOM === "function")
+      if (typeof this.options.stripBOM === "function") {
         this.options.stripBOM();
+      }
     }
     this.pass = true;
     return res;
@@ -12116,6 +11985,22 @@ function requireBomHandling() {
   };
   return bomHandling;
 }
+var mergeExports;
+var hasRequiredMergeExports;
+function requireMergeExports() {
+  if (hasRequiredMergeExports) return mergeExports;
+  hasRequiredMergeExports = 1;
+  var hasOwn = typeof Object.hasOwn === "undefined" ? Function.call.bind(Object.prototype.hasOwnProperty) : Object.hasOwn;
+  function mergeModules(target, module) {
+    for (var key2 in module) {
+      if (hasOwn(module, key2)) {
+        target[key2] = module[key2];
+      }
+    }
+  }
+  mergeExports = mergeModules;
+  return mergeExports;
+}
 var encodings = {};
 var internal;
 var hasRequiredInternal;
@@ -12139,9 +12024,11 @@ function requireInternal() {
   function InternalCodec(codecOptions, iconv) {
     this.enc = codecOptions.encodingName;
     this.bomAware = codecOptions.bomAware;
-    if (this.enc === "base64")
+    if (this.enc === "base64") {
       this.encoder = InternalEncoderBase64;
-    else if (this.enc === "cesu8") {
+    } else if (this.enc === "utf8") {
+      this.encoder = InternalEncoderUtf8;
+    } else if (this.enc === "cesu8") {
       this.enc = "utf8";
       this.encoder = InternalEncoderCesu8;
       if (Buffer2.from("eda0bdedb2a9", "hex").toString() !== "💩") {
@@ -12153,9 +12040,6 @@ function requireInternal() {
   InternalCodec.prototype.encoder = InternalEncoder;
   InternalCodec.prototype.decoder = InternalDecoder;
   var StringDecoder = require$$1$3.StringDecoder;
-  if (!StringDecoder.prototype.end)
-    StringDecoder.prototype.end = function() {
-    };
   function InternalDecoder(options, codec2) {
     this.decoder = new StringDecoder(codec2.enc);
   }
@@ -12192,12 +12076,13 @@ function requireInternal() {
   function InternalEncoderCesu8(options, codec2) {
   }
   InternalEncoderCesu8.prototype.write = function(str) {
-    var buf = Buffer2.alloc(str.length * 3), bufIdx = 0;
+    var buf = Buffer2.alloc(str.length * 3);
+    var bufIdx = 0;
     for (var i = 0; i < str.length; i++) {
       var charCode = str.charCodeAt(i);
-      if (charCode < 128)
+      if (charCode < 128) {
         buf[bufIdx++] = charCode;
-      else if (charCode < 2048) {
+      } else if (charCode < 2048) {
         buf[bufIdx++] = 192 + (charCode >>> 6);
         buf[bufIdx++] = 128 + (charCode & 63);
       } else {
@@ -12217,7 +12102,10 @@ function requireInternal() {
     this.defaultCharUnicode = codec2.defaultCharUnicode;
   }
   InternalDecoderCesu8.prototype.write = function(buf) {
-    var acc = this.acc, contBytes = this.contBytes, accBytes = this.accBytes, res = "";
+    var acc = this.acc;
+    var contBytes = this.contBytes;
+    var accBytes = this.accBytes;
+    var res = "";
     for (var i = 0; i < buf.length; i++) {
       var curByte = buf[i];
       if ((curByte & 192) !== 128) {
@@ -12244,12 +12132,13 @@ function requireInternal() {
           contBytes--;
           accBytes++;
           if (contBytes === 0) {
-            if (accBytes === 2 && acc < 128 && acc > 0)
+            if (accBytes === 2 && acc < 128 && acc > 0) {
               res += this.defaultCharUnicode;
-            else if (accBytes === 3 && acc < 2048)
+            } else if (accBytes === 3 && acc < 2048) {
               res += this.defaultCharUnicode;
-            else
+            } else {
               res += String.fromCharCode(acc);
+            }
           }
         } else {
           res += this.defaultCharUnicode;
@@ -12263,10 +12152,35 @@ function requireInternal() {
   };
   InternalDecoderCesu8.prototype.end = function() {
     var res = 0;
-    if (this.contBytes > 0)
+    if (this.contBytes > 0) {
       res += this.defaultCharUnicode;
+    }
     return res;
   };
+  function InternalEncoderUtf8(options, codec2) {
+    this.highSurrogate = "";
+  }
+  InternalEncoderUtf8.prototype.write = function(str) {
+    if (this.highSurrogate) {
+      str = this.highSurrogate + str;
+      this.highSurrogate = "";
+    }
+    if (str.length > 0) {
+      var charCode = str.charCodeAt(str.length - 1);
+      if (charCode >= 55296 && charCode < 56320) {
+        this.highSurrogate = str[str.length - 1];
+        str = str.slice(0, str.length - 1);
+      }
+    }
+    return Buffer2.from(str, this.enc);
+  };
+  InternalEncoderUtf8.prototype.end = function() {
+    if (this.highSurrogate) {
+      var str = this.highSurrogate;
+      this.highSurrogate = "";
+      return Buffer2.from(str, this.enc);
+    }
+  };
   return internal;
 }
 var utf32 = {};
@@ -12298,8 +12212,8 @@ function requireUtf32() {
     var offset = 0;
     for (var i = 0; i < src.length; i += 2) {
       var code = src.readUInt16LE(i);
-      var isHighSurrogate = 55296 <= code && code < 56320;
-      var isLowSurrogate = 56320 <= code && code < 57344;
+      var isHighSurrogate = code >= 55296 && code < 56320;
+      var isLowSurrogate = code >= 56320 && code < 57344;
       if (this.highSurrogate) {
         if (isHighSurrogate || !isLowSurrogate) {
           write32.call(dst, this.highSurrogate, offset);
@@ -12312,26 +12226,29 @@ function requireUtf32() {
           continue;
         }
       }
-      if (isHighSurrogate)
+      if (isHighSurrogate) {
         this.highSurrogate = code;
-      else {
+      } else {
         write32.call(dst, code, offset);
         offset += 4;
         this.highSurrogate = 0;
       }
     }
-    if (offset < dst.length)
+    if (offset < dst.length) {
       dst = dst.slice(0, offset);
+    }
     return dst;
   };
   Utf32Encoder.prototype.end = function() {
-    if (!this.highSurrogate)
+    if (!this.highSurrogate) {
       return;
+    }
     var buf = Buffer2.alloc(4);
-    if (this.isLE)
+    if (this.isLE) {
       buf.writeUInt32LE(this.highSurrogate, 0);
-    else
+    } else {
       buf.writeUInt32BE(this.highSurrogate, 0);
+    }
     this.highSurrogate = 0;
     return buf;
   };
@@ -12341,8 +12258,9 @@ function requireUtf32() {
     this.overflow = [];
   }
   Utf32Decoder.prototype.write = function(src) {
-    if (src.length === 0)
+    if (src.length === 0) {
       return "";
+    }
     var i = 0;
     var codepoint = 0;
     var dst = Buffer2.alloc(src.length + 4);
@@ -12351,8 +12269,9 @@ function requireUtf32() {
     var overflow = this.overflow;
     var badChar = this.badChar;
     if (overflow.length > 0) {
-      for (; i < src.length && overflow.length < 4; i++)
+      for (; i < src.length && overflow.length < 4; i++) {
         overflow.push(src[i]);
+      }
       if (overflow.length === 4) {
         if (isLE) {
           codepoint = overflow[i] | overflow[i + 1] << 8 | overflow[i + 2] << 16 | overflow[i + 3] << 24;
@@ -12403,8 +12322,9 @@ function requireUtf32() {
   Utf32AutoCodec.prototype.decoder = Utf32AutoDecoder;
   function Utf32AutoEncoder(options, codec2) {
     options = options || {};
-    if (options.addBOM === void 0)
+    if (options.addBOM === void 0) {
       options.addBOM = true;
+    }
     this.encoder = codec2.iconv.getEncoder(options.defaultEncoding || "utf-32le", options);
   }
   Utf32AutoEncoder.prototype.write = function(str) {
@@ -12424,13 +12344,15 @@ function requireUtf32() {
     if (!this.decoder) {
       this.initialBufs.push(buf);
       this.initialBufsLen += buf.length;
-      if (this.initialBufsLen < 32)
+      if (this.initialBufsLen < 32) {
         return "";
+      }
       var encoding2 = detectEncoding(this.initialBufs, this.options.defaultEncoding);
       this.decoder = this.iconv.getDecoder(encoding2, this.options);
       var resStr = "";
-      for (var i = 0; i < this.initialBufs.length; i++)
+      for (var i = 0; i < this.initialBufs.length; i++) {
         resStr += this.decoder.write(this.initialBufs[i]);
+      }
       this.initialBufs.length = this.initialBufsLen = 0;
       return resStr;
     }
@@ -12441,11 +12363,13 @@ function requireUtf32() {
       var encoding2 = detectEncoding(this.initialBufs, this.options.defaultEncoding);
       this.decoder = this.iconv.getDecoder(encoding2, this.options);
       var resStr = "";
-      for (var i = 0; i < this.initialBufs.length; i++)
+      for (var i = 0; i < this.initialBufs.length; i++) {
         resStr += this.decoder.write(this.initialBufs[i]);
+      }
       var trail = this.decoder.end();
-      if (trail)
+      if (trail) {
         resStr += trail;
+      }
       this.initialBufs.length = this.initialBufsLen = 0;
       return resStr;
     }
@@ -12454,9 +12378,11 @@ function requireUtf32() {
   function detectEncoding(bufs, defaultEncoding) {
     var b = [];
     var charsProcessed = 0;
-    var invalidLE = 0, invalidBE = 0;
-    var bmpCharsLE = 0, bmpCharsBE = 0;
-    outer_loop:
+    var invalidLE = 0;
+    var invalidBE = 0;
+    var bmpCharsLE = 0;
+    var bmpCharsBE = 0;
+    outerLoop:
       for (var i = 0; i < bufs.length; i++) {
         var buf = bufs[i];
         for (var j = 0; j < buf.length; j++) {
@@ -12477,7 +12403,7 @@ function requireUtf32() {
             b.length = 0;
             charsProcessed++;
             if (charsProcessed >= 100) {
-              break outer_loop;
+              break outerLoop;
             }
           }
         }
@@ -12517,9 +12443,12 @@ function requireUtf16() {
     this.overflowByte = -1;
   }
   Utf16BEDecoder.prototype.write = function(buf) {
-    if (buf.length == 0)
+    if (buf.length == 0) {
       return "";
-    var buf2 = Buffer2.alloc(buf.length + 1), i = 0, j = 0;
+    }
+    var buf2 = Buffer2.alloc(buf.length + 1);
+    var i = 0;
+    var j = 0;
     if (this.overflowByte !== -1) {
       buf2[0] = buf[0];
       buf2[1] = this.overflowByte;
@@ -12544,8 +12473,9 @@ function requireUtf16() {
   Utf16Codec.prototype.decoder = Utf16Decoder;
   function Utf16Encoder(options, codec2) {
     options = options || {};
-    if (options.addBOM === void 0)
+    if (options.addBOM === void 0) {
       options.addBOM = true;
+    }
     this.encoder = codec2.iconv.getEncoder("utf-16le", options);
   }
   Utf16Encoder.prototype.write = function(str) {
@@ -12565,13 +12495,15 @@ function requireUtf16() {
     if (!this.decoder) {
       this.initialBufs.push(buf);
       this.initialBufsLen += buf.length;
-      if (this.initialBufsLen < 16)
+      if (this.initialBufsLen < 16) {
         return "";
+      }
       var encoding2 = detectEncoding(this.initialBufs, this.options.defaultEncoding);
       this.decoder = this.iconv.getDecoder(encoding2, this.options);
       var resStr = "";
-      for (var i = 0; i < this.initialBufs.length; i++)
+      for (var i = 0; i < this.initialBufs.length; i++) {
         resStr += this.decoder.write(this.initialBufs[i]);
+      }
       this.initialBufs.length = this.initialBufsLen = 0;
       return resStr;
     }
@@ -12582,11 +12514,13 @@ function requireUtf16() {
       var encoding2 = detectEncoding(this.initialBufs, this.options.defaultEncoding);
       this.decoder = this.iconv.getDecoder(encoding2, this.options);
       var resStr = "";
-      for (var i = 0; i < this.initialBufs.length; i++)
+      for (var i = 0; i < this.initialBufs.length; i++) {
         resStr += this.decoder.write(this.initialBufs[i]);
+      }
       var trail = this.decoder.end();
-      if (trail)
+      if (trail) {
         resStr += trail;
+      }
       this.initialBufs.length = this.initialBufsLen = 0;
       return resStr;
     }
@@ -12595,8 +12529,9 @@ function requireUtf16() {
   function detectEncoding(bufs, defaultEncoding) {
     var b = [];
     var charsProcessed = 0;
-    var asciiCharsLE = 0, asciiCharsBE = 0;
-    outer_loop:
+    var asciiCharsLE = 0;
+    var asciiCharsBE = 0;
+    outerLoop:
       for (var i = 0; i < bufs.length; i++) {
         var buf = bufs[i];
         for (var j = 0; j < buf.length; j++) {
@@ -12611,7 +12546,7 @@ function requireUtf16() {
             b.length = 0;
             charsProcessed++;
             if (charsProcessed >= 100) {
-              break outer_loop;
+              break outerLoop;
             }
           }
         }
@@ -12654,11 +12589,17 @@ function requireUtf7() {
   }
   var base64Regex = /[A-Za-z0-9\/+]/;
   var base64Chars = [];
-  for (var i = 0; i < 256; i++)
+  for (var i = 0; i < 256; i++) {
     base64Chars[i] = base64Regex.test(String.fromCharCode(i));
-  var plusChar = "+".charCodeAt(0), minusChar = "-".charCodeAt(0), andChar = "&".charCodeAt(0);
+  }
+  var plusChar = "+".charCodeAt(0);
+  var minusChar = "-".charCodeAt(0);
+  var andChar = "&".charCodeAt(0);
   Utf7Decoder.prototype.write = function(buf) {
-    var res = "", lastI = 0, inBase64 = this.inBase64, base64Accum = this.base64Accum;
+    var res = "";
+    var lastI = 0;
+    var inBase64 = this.inBase64;
+    var base64Accum = this.base64Accum;
     for (var i2 = 0; i2 < buf.length; i2++) {
       if (!inBase64) {
         if (buf[i2] == plusChar) {
@@ -12674,8 +12615,9 @@ function requireUtf7() {
             var b64str = base64Accum + this.iconv.decode(buf.slice(lastI, i2), "ascii");
             res += this.iconv.decode(Buffer2.from(b64str, "base64"), "utf16-be");
           }
-          if (buf[i2] != minusChar)
+          if (buf[i2] != minusChar) {
             i2--;
+          }
           lastI = i2 + 1;
           inBase64 = false;
           base64Accum = "";
@@ -12697,8 +12639,9 @@ function requireUtf7() {
   };
   Utf7Decoder.prototype.end = function() {
     var res = "";
-    if (this.inBase64 && this.base64Accum.length > 0)
+    if (this.inBase64 && this.base64Accum.length > 0) {
       res = this.iconv.decode(Buffer2.from(this.base64Accum, "base64"), "utf16-be");
+    }
     this.inBase64 = false;
     this.base64Accum = "";
     return res;
@@ -12717,10 +12660,14 @@ function requireUtf7() {
     this.base64AccumIdx = 0;
   }
   Utf7IMAPEncoder.prototype.write = function(str) {
-    var inBase64 = this.inBase64, base64Accum = this.base64Accum, base64AccumIdx = this.base64AccumIdx, buf = Buffer2.alloc(str.length * 5 + 10), bufIdx = 0;
+    var inBase64 = this.inBase64;
+    var base64Accum = this.base64Accum;
+    var base64AccumIdx = this.base64AccumIdx;
+    var buf = Buffer2.alloc(str.length * 5 + 10);
+    var bufIdx = 0;
     for (var i2 = 0; i2 < str.length; i2++) {
       var uChar = str.charCodeAt(i2);
-      if (32 <= uChar && uChar <= 126) {
+      if (uChar >= 32 && uChar <= 126) {
         if (inBase64) {
           if (base64AccumIdx > 0) {
             bufIdx += buf.write(base64Accum.slice(0, base64AccumIdx).toString("base64").replace(/\//g, ",").replace(/=+$/, ""), bufIdx);
@@ -12731,8 +12678,9 @@ function requireUtf7() {
         }
         if (!inBase64) {
           buf[bufIdx++] = uChar;
-          if (uChar === andChar)
+          if (uChar === andChar) {
             buf[bufIdx++] = minusChar;
+          }
         }
       } else {
         if (!inBase64) {
@@ -12754,7 +12702,8 @@ function requireUtf7() {
     return buf.slice(0, bufIdx);
   };
   Utf7IMAPEncoder.prototype.end = function() {
-    var buf = Buffer2.alloc(10), bufIdx = 0;
+    var buf = Buffer2.alloc(10);
+    var bufIdx = 0;
     if (this.inBase64) {
       if (this.base64AccumIdx > 0) {
         bufIdx += buf.write(this.base64Accum.slice(0, this.base64AccumIdx).toString("base64").replace(/\//g, ",").replace(/=+$/, ""), bufIdx);
@@ -12773,7 +12722,10 @@ function requireUtf7() {
   var base64IMAPChars = base64Chars.slice();
   base64IMAPChars[",".charCodeAt(0)] = true;
   Utf7IMAPDecoder.prototype.write = function(buf) {
-    var res = "", lastI = 0, inBase64 = this.inBase64, base64Accum = this.base64Accum;
+    var res = "";
+    var lastI = 0;
+    var inBase64 = this.inBase64;
+    var base64Accum = this.base64Accum;
     for (var i2 = 0; i2 < buf.length; i2++) {
       if (!inBase64) {
         if (buf[i2] == andChar) {
@@ -12789,8 +12741,9 @@ function requireUtf7() {
             var b64str = base64Accum + this.iconv.decode(buf.slice(lastI, i2), "ascii").replace(/,/g, "/");
             res += this.iconv.decode(Buffer2.from(b64str, "base64"), "utf16-be");
           }
-          if (buf[i2] != minusChar)
+          if (buf[i2] != minusChar) {
             i2--;
+          }
           lastI = i2 + 1;
           inBase64 = false;
           base64Accum = "";
@@ -12812,8 +12765,9 @@ function requireUtf7() {
   };
   Utf7IMAPDecoder.prototype.end = function() {
     var res = "";
-    if (this.inBase64 && this.base64Accum.length > 0)
+    if (this.inBase64 && this.base64Accum.length > 0) {
       res = this.iconv.decode(Buffer2.from(this.base64Accum, "base64"), "utf16-be");
+    }
     this.inBase64 = false;
     this.base64Accum = "";
     return res;
@@ -12828,20 +12782,24 @@ function requireSbcsCodec() {
   var Buffer2 = requireSafer().Buffer;
   sbcsCodec._sbcs = SBCSCodec;
   function SBCSCodec(codecOptions, iconv) {
-    if (!codecOptions)
+    if (!codecOptions) {
       throw new Error("SBCS codec is called without the data.");
-    if (!codecOptions.chars || codecOptions.chars.length !== 128 && codecOptions.chars.length !== 256)
+    }
+    if (!codecOptions.chars || codecOptions.chars.length !== 128 && codecOptions.chars.length !== 256) {
       throw new Error("Encoding '" + codecOptions.type + "' has incorrect 'chars' (must be of len 128 or 256)");
+    }
     if (codecOptions.chars.length === 128) {
       var asciiString = "";
-      for (var i = 0; i < 128; i++)
+      for (var i = 0; i < 128; i++) {
         asciiString += String.fromCharCode(i);
+      }
       codecOptions.chars = asciiString + codecOptions.chars;
     }
     this.decodeBuf = Buffer2.from(codecOptions.chars, "ucs2");
     var encodeBuf = Buffer2.alloc(65536, iconv.defaultCharSingleByte.charCodeAt(0));
-    for (var i = 0; i < codecOptions.chars.length; i++)
+    for (var i = 0; i < codecOptions.chars.length; i++) {
       encodeBuf[codecOptions.chars.charCodeAt(i)] = i;
+    }
     this.encodeBuf = encodeBuf;
   }
   SBCSCodec.prototype.encoder = SBCSEncoder;
@@ -12851,8 +12809,9 @@ function requireSbcsCodec() {
   }
   SBCSEncoder.prototype.write = function(str) {
     var buf = Buffer2.alloc(str.length);
-    for (var i = 0; i < str.length; i++)
+    for (var i = 0; i < str.length; i++) {
       buf[i] = this.encodeBuf[str.charCodeAt(i)];
+    }
     return buf;
   };
   SBCSEncoder.prototype.end = function() {
@@ -12863,7 +12822,8 @@ function requireSbcsCodec() {
   SBCSDecoder.prototype.write = function(buf) {
     var decodeBuf = this.decodeBuf;
     var newBuf = Buffer2.alloc(buf.length * 2);
-    var idx1 = 0, idx2 = 0;
+    var idx1 = 0;
+    var idx2 = 0;
     for (var i = 0; i < buf.length; i++) {
       idx1 = buf[i] * 2;
       idx2 = i * 2;
@@ -12883,149 +12843,149 @@ function requireSbcsData() {
   hasRequiredSbcsData = 1;
   sbcsData = {
     // Not supported by iconv, not sure why.
-    "10029": "maccenteuro",
-    "maccenteuro": {
-      "type": "_sbcs",
-      "chars": "ÄĀāÉĄÖÜáąČäčĆć鏟ĎíďĒēĖóėôöõúĚěü†°Ę£§•¶ß®©™ę¨≠ģĮįĪ≤≥īĶ∂∑łĻļĽľĹĺŅņѬ√ńŇ∆«»… ňŐÕőŌ–—“”‘’÷◊ōŔŕŘ‹›řŖŗŠ‚„šŚśÁŤťÍŽžŪÓÔūŮÚůŰűŲųÝýķŻŁżĢˇ"
+    10029: "maccenteuro",
+    maccenteuro: {
+      type: "_sbcs",
+      chars: "ÄĀāÉĄÖÜáąČäčĆć鏟ĎíďĒēĖóėôöõúĚěü†°Ę£§•¶ß®©™ę¨≠ģĮįĪ≤≥īĶ∂∑łĻļĽľĹĺŅņѬ√ńŇ∆«»… ňŐÕőŌ–—“”‘’÷◊ōŔŕŘ‹›řŖŗŠ‚„šŚśÁŤťÍŽžŪÓÔūŮÚůŰűŲųÝýķŻŁżĢˇ"
     },
-    "808": "cp808",
-    "ibm808": "cp808",
-    "cp808": {
-      "type": "_sbcs",
-      "chars": "АБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯабвгдежзийклмноп░▒▓│┤╡╢╖╕╣║╗╝╜╛┐└┴┬├─┼╞╟╚╔╩╦╠═╬╧╨╤╥╙╘╒╓╫╪┘┌█▄▌▐▀рстуфхцчшщъыьэюяЁёЄєЇїЎў°∙·√№€■ "
+    808: "cp808",
+    ibm808: "cp808",
+    cp808: {
+      type: "_sbcs",
+      chars: "АБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯабвгдежзийклмноп░▒▓│┤╡╢╖╕╣║╗╝╜╛┐└┴┬├─┼╞╟╚╔╩╦╠═╬╧╨╤╥╙╘╒╓╫╪┘┌█▄▌▐▀рстуфхцчшщъыьэюяЁёЄєЇїЎў°∙·√№€■ "
     },
-    "mik": {
-      "type": "_sbcs",
-      "chars": "АБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯабвгдежзийклмнопрстуфхцчшщъыьэюя└┴┬├─┼╣║╚╔╩╦╠═╬┐░▒▓│┤№§╗╝┘┌█▄▌▐▀αßΓπΣσµτΦΘΩδ∞φε∩≡±≥≤⌠⌡÷≈°∙·√ⁿ²■ "
+    mik: {
+      type: "_sbcs",
+      chars: "АБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯабвгдежзийклмнопрстуфхцчшщъыьэюя└┴┬├─┼╣║╚╔╩╦╠═╬┐░▒▓│┤№§╗╝┘┌█▄▌▐▀αßΓπΣσµτΦΘΩδ∞φε∩≡±≥≤⌠⌡÷≈°∙·√ⁿ²■ "
     },
-    "cp720": {
-      "type": "_sbcs",
-      "chars": "€éâ„à†çêëèïّْô¤ـûùءآأؤ£إئابةتثجحخدذرزسشص«»░▒▓│┤╡╢╖╕╣║╗╝╜╛┐└┴┬├─┼╞╟╚╔╩╦╠═╬╧╨╤╥╙╘╒╓╫╪┘┌█▄▌▐▀ضطظعغفµقكلمنهوىي≡ًٌٍَُِ≈°∙·√ⁿ²■ "
+    cp720: {
+      type: "_sbcs",
+      chars: "€éâ„à†çêëèïّْô¤ـûùءآأؤ£إئابةتثجحخدذرزسشص«»░▒▓│┤╡╢╖╕╣║╗╝╜╛┐└┴┬├─┼╞╟╚╔╩╦╠═╬╧╨╤╥╙╘╒╓╫╪┘┌█▄▌▐▀ضطظعغفµقكلمنهوىي≡ًٌٍَُِ≈°∙·√ⁿ²■ "
     },
     // Aliases of generated encodings.
-    "ascii8bit": "ascii",
-    "usascii": "ascii",
-    "ansix34": "ascii",
-    "ansix341968": "ascii",
-    "ansix341986": "ascii",
-    "csascii": "ascii",
-    "cp367": "ascii",
-    "ibm367": "ascii",
-    "isoir6": "ascii",
-    "iso646us": "ascii",
-    "iso646irv": "ascii",
-    "us": "ascii",
-    "latin1": "iso88591",
-    "latin2": "iso88592",
-    "latin3": "iso88593",
-    "latin4": "iso88594",
-    "latin5": "iso88599",
-    "latin6": "iso885910",
-    "latin7": "iso885913",
-    "latin8": "iso885914",
-    "latin9": "iso885915",
-    "latin10": "iso885916",
-    "csisolatin1": "iso88591",
-    "csisolatin2": "iso88592",
-    "csisolatin3": "iso88593",
-    "csisolatin4": "iso88594",
-    "csisolatincyrillic": "iso88595",
-    "csisolatinarabic": "iso88596",
-    "csisolatingreek": "iso88597",
-    "csisolatinhebrew": "iso88598",
-    "csisolatin5": "iso88599",
-    "csisolatin6": "iso885910",
-    "l1": "iso88591",
-    "l2": "iso88592",
-    "l3": "iso88593",
-    "l4": "iso88594",
-    "l5": "iso88599",
-    "l6": "iso885910",
-    "l7": "iso885913",
-    "l8": "iso885914",
-    "l9": "iso885915",
-    "l10": "iso885916",
-    "isoir14": "iso646jp",
-    "isoir57": "iso646cn",
-    "isoir100": "iso88591",
-    "isoir101": "iso88592",
-    "isoir109": "iso88593",
-    "isoir110": "iso88594",
-    "isoir144": "iso88595",
-    "isoir127": "iso88596",
-    "isoir126": "iso88597",
-    "isoir138": "iso88598",
-    "isoir148": "iso88599",
-    "isoir157": "iso885910",
-    "isoir166": "tis620",
-    "isoir179": "iso885913",
-    "isoir199": "iso885914",
-    "isoir203": "iso885915",
-    "isoir226": "iso885916",
-    "cp819": "iso88591",
-    "ibm819": "iso88591",
-    "cyrillic": "iso88595",
-    "arabic": "iso88596",
-    "arabic8": "iso88596",
-    "ecma114": "iso88596",
-    "asmo708": "iso88596",
-    "greek": "iso88597",
-    "greek8": "iso88597",
-    "ecma118": "iso88597",
-    "elot928": "iso88597",
-    "hebrew": "iso88598",
-    "hebrew8": "iso88598",
-    "turkish": "iso88599",
-    "turkish8": "iso88599",
-    "thai": "iso885911",
-    "thai8": "iso885911",
-    "celtic": "iso885914",
-    "celtic8": "iso885914",
-    "isoceltic": "iso885914",
-    "tis6200": "tis620",
-    "tis62025291": "tis620",
-    "tis62025330": "tis620",
-    "10000": "macroman",
-    "10006": "macgreek",
-    "10007": "maccyrillic",
-    "10079": "maciceland",
-    "10081": "macturkish",
-    "cspc8codepage437": "cp437",
-    "cspc775baltic": "cp775",
-    "cspc850multilingual": "cp850",
-    "cspcp852": "cp852",
-    "cspc862latinhebrew": "cp862",
-    "cpgr": "cp869",
-    "msee": "cp1250",
-    "mscyrl": "cp1251",
-    "msansi": "cp1252",
-    "msgreek": "cp1253",
-    "msturk": "cp1254",
-    "mshebr": "cp1255",
-    "msarab": "cp1256",
-    "winbaltrim": "cp1257",
-    "cp20866": "koi8r",
-    "20866": "koi8r",
-    "ibm878": "koi8r",
-    "cskoi8r": "koi8r",
-    "cp21866": "koi8u",
-    "21866": "koi8u",
-    "ibm1168": "koi8u",
-    "strk10482002": "rk1048",
-    "tcvn5712": "tcvn",
-    "tcvn57121": "tcvn",
-    "gb198880": "iso646cn",
-    "cn": "iso646cn",
-    "csiso14jisc6220ro": "iso646jp",
-    "jisc62201969ro": "iso646jp",
-    "jp": "iso646jp",
-    "cshproman8": "hproman8",
-    "r8": "hproman8",
-    "roman8": "hproman8",
-    "xroman8": "hproman8",
-    "ibm1051": "hproman8",
-    "mac": "macintosh",
-    "csmacintosh": "macintosh"
+    ascii8bit: "ascii",
+    usascii: "ascii",
+    ansix34: "ascii",
+    ansix341968: "ascii",
+    ansix341986: "ascii",
+    csascii: "ascii",
+    cp367: "ascii",
+    ibm367: "ascii",
+    isoir6: "ascii",
+    iso646us: "ascii",
+    iso646irv: "ascii",
+    us: "ascii",
+    latin1: "iso88591",
+    latin2: "iso88592",
+    latin3: "iso88593",
+    latin4: "iso88594",
+    latin5: "iso88599",
+    latin6: "iso885910",
+    latin7: "iso885913",
+    latin8: "iso885914",
+    latin9: "iso885915",
+    latin10: "iso885916",
+    csisolatin1: "iso88591",
+    csisolatin2: "iso88592",
+    csisolatin3: "iso88593",
+    csisolatin4: "iso88594",
+    csisolatincyrillic: "iso88595",
+    csisolatinarabic: "iso88596",
+    csisolatingreek: "iso88597",
+    csisolatinhebrew: "iso88598",
+    csisolatin5: "iso88599",
+    csisolatin6: "iso885910",
+    l1: "iso88591",
+    l2: "iso88592",
+    l3: "iso88593",
+    l4: "iso88594",
+    l5: "iso88599",
+    l6: "iso885910",
+    l7: "iso885913",
+    l8: "iso885914",
+    l9: "iso885915",
+    l10: "iso885916",
+    isoir14: "iso646jp",
+    isoir57: "iso646cn",
+    isoir100: "iso88591",
+    isoir101: "iso88592",
+    isoir109: "iso88593",
+    isoir110: "iso88594",
+    isoir144: "iso88595",
+    isoir127: "iso88596",
+    isoir126: "iso88597",
+    isoir138: "iso88598",
+    isoir148: "iso88599",
+    isoir157: "iso885910",
+    isoir166: "tis620",
+    isoir179: "iso885913",
+    isoir199: "iso885914",
+    isoir203: "iso885915",
+    isoir226: "iso885916",
+    cp819: "iso88591",
+    ibm819: "iso88591",
+    cyrillic: "iso88595",
+    arabic: "iso88596",
+    arabic8: "iso88596",
+    ecma114: "iso88596",
+    asmo708: "iso88596",
+    greek: "iso88597",
+    greek8: "iso88597",
+    ecma118: "iso88597",
+    elot928: "iso88597",
+    hebrew: "iso88598",
+    hebrew8: "iso88598",
+    turkish: "iso88599",
+    turkish8: "iso88599",
+    thai: "iso885911",
+    thai8: "iso885911",
+    celtic: "iso885914",
+    celtic8: "iso885914",
+    isoceltic: "iso885914",
+    tis6200: "tis620",
+    tis62025291: "tis620",
+    tis62025330: "tis620",
+    1e4: "macroman",
+    10006: "macgreek",
+    10007: "maccyrillic",
+    10079: "maciceland",
+    10081: "macturkish",
+    cspc8codepage437: "cp437",
+    cspc775baltic: "cp775",
+    cspc850multilingual: "cp850",
+    cspcp852: "cp852",
+    cspc862latinhebrew: "cp862",
+    cpgr: "cp869",
+    msee: "cp1250",
+    mscyrl: "cp1251",
+    msansi: "cp1252",
+    msgreek: "cp1253",
+    msturk: "cp1254",
+    mshebr: "cp1255",
+    msarab: "cp1256",
+    winbaltrim: "cp1257",
+    cp20866: "koi8r",
+    20866: "koi8r",
+    ibm878: "koi8r",
+    cskoi8r: "koi8r",
+    cp21866: "koi8u",
+    21866: "koi8u",
+    ibm1168: "koi8u",
+    strk10482002: "rk1048",
+    tcvn5712: "tcvn",
+    tcvn57121: "tcvn",
+    gb198880: "iso646cn",
+    cn: "iso646cn",
+    csiso14jisc6220ro: "iso646jp",
+    jisc62201969ro: "iso646jp",
+    jp: "iso646jp",
+    cshproman8: "hproman8",
+    r8: "hproman8",
+    roman8: "hproman8",
+    xroman8: "hproman8",
+    ibm1051: "hproman8",
+    mac: "macintosh",
+    csmacintosh: "macintosh"
   };
   return sbcsData;
 }
@@ -13491,21 +13451,30 @@ function requireDbcsCodec() {
   hasRequiredDbcsCodec = 1;
   var Buffer2 = requireSafer().Buffer;
   dbcsCodec._dbcs = DBCSCodec;
-  var UNASSIGNED = -1, GB18030_CODE = -2, SEQ_START = -10, NODE_START = -1e3, UNASSIGNED_NODE = new Array(256), DEF_CHAR = -1;
-  for (var i = 0; i < 256; i++)
+  var UNASSIGNED = -1;
+  var GB18030_CODE = -2;
+  var SEQ_START = -10;
+  var NODE_START = -1e3;
+  var UNASSIGNED_NODE = new Array(256);
+  var DEF_CHAR = -1;
+  for (var i = 0; i < 256; i++) {
     UNASSIGNED_NODE[i] = UNASSIGNED;
+  }
   function DBCSCodec(codecOptions, iconv) {
     this.encodingName = codecOptions.encodingName;
-    if (!codecOptions)
+    if (!codecOptions) {
       throw new Error("DBCS codec is called without the data.");
-    if (!codecOptions.table)
+    }
+    if (!codecOptions.table) {
       throw new Error("Encoding '" + this.encodingName + "' has no data.");
+    }
     var mappingTable = codecOptions.table();
     this.decodeTables = [];
     this.decodeTables[0] = UNASSIGNED_NODE.slice(0);
     this.decodeTableSeq = [];
-    for (var i2 = 0; i2 < mappingTable.length; i2++)
+    for (var i2 = 0; i2 < mappingTable.length; i2++) {
       this._addDecodeChunk(mappingTable[i2]);
+    }
     if (typeof codecOptions.gb18030 === "function") {
       this.gb18030 = codecOptions.gb18030();
       var commonThirdByteNodeIdx = this.decodeTables.length;
@@ -13532,8 +13501,9 @@ function requireDbcsCodec() {
             }
             var fourthByteNode = this.decodeTables[NODE_START - thirdByteNode[k]];
             for (var l = 48; l <= 57; l++) {
-              if (fourthByteNode[l] === UNASSIGNED)
+              if (fourthByteNode[l] === UNASSIGNED) {
                 fourthByteNode[l] = GB18030_CODE;
+              }
             }
           }
         }
@@ -13543,20 +13513,25 @@ function requireDbcsCodec() {
     this.encodeTable = [];
     this.encodeTableSeq = [];
     var skipEncodeChars = {};
-    if (codecOptions.encodeSkipVals)
+    if (codecOptions.encodeSkipVals) {
       for (var i2 = 0; i2 < codecOptions.encodeSkipVals.length; i2++) {
         var val = codecOptions.encodeSkipVals[i2];
-        if (typeof val === "number")
+        if (typeof val === "number") {
           skipEncodeChars[val] = true;
-        else
-          for (var j = val.from; j <= val.to; j++)
+        } else {
+          for (var j = val.from; j <= val.to; j++) {
             skipEncodeChars[j] = true;
+          }
+        }
       }
+    }
     this._fillEncodeTable(0, 0, skipEncodeChars);
     if (codecOptions.encodeAdd) {
-      for (var uChar in codecOptions.encodeAdd)
-        if (Object.prototype.hasOwnProperty.call(codecOptions.encodeAdd, uChar))
+      for (var uChar in codecOptions.encodeAdd) {
+        if (Object.prototype.hasOwnProperty.call(codecOptions.encodeAdd, uChar)) {
           this._setEncodeChar(uChar.charCodeAt(0), codecOptions.encodeAdd[uChar]);
+        }
+      }
     }
     this.defCharSB = this.encodeTable[0][iconv.defaultCharSingleByte.charCodeAt(0)];
     if (this.defCharSB === UNASSIGNED) this.defCharSB = this.encodeTable[0]["?"];
@@ -13566,10 +13541,12 @@ function requireDbcsCodec() {
   DBCSCodec.prototype.decoder = DBCSDecoder;
   DBCSCodec.prototype._getDecodeTrieNode = function(addr) {
     var bytes2 = [];
-    for (; addr > 0; addr >>>= 8)
+    for (; addr > 0; addr >>>= 8) {
       bytes2.push(addr & 255);
-    if (bytes2.length == 0)
+    }
+    if (bytes2.length == 0) {
       bytes2.push(0);
+    }
     var node = this.decodeTables[0];
     for (var i2 = bytes2.length - 1; i2 > 0; i2--) {
       var val = node[bytes2[i2]];
@@ -13578,8 +13555,9 @@ function requireDbcsCodec() {
         this.decodeTables.push(node = UNASSIGNED_NODE.slice(0));
       } else if (val <= NODE_START) {
         node = this.decodeTables[NODE_START - val];
-      } else
+      } else {
         throw new Error("Overwrite byte in " + this.encodingName + ", addr: " + addr.toString(16));
+      }
     }
     return node;
   };
@@ -13592,45 +13570,53 @@ function requireDbcsCodec() {
       if (typeof part === "string") {
         for (var l = 0; l < part.length; ) {
           var code = part.charCodeAt(l++);
-          if (55296 <= code && code < 56320) {
+          if (code >= 55296 && code < 56320) {
             var codeTrail = part.charCodeAt(l++);
-            if (56320 <= codeTrail && codeTrail < 57344)
+            if (codeTrail >= 56320 && codeTrail < 57344) {
               writeTable[curAddr++] = 65536 + (code - 55296) * 1024 + (codeTrail - 56320);
-            else
+            } else {
               throw new Error("Incorrect surrogate pair in " + this.encodingName + " at chunk " + chunk[0]);
-          } else if (4080 < code && code <= 4095) {
+            }
+          } else if (code > 4080 && code <= 4095) {
             var len = 4095 - code + 2;
             var seq = [];
-            for (var m = 0; m < len; m++)
+            for (var m = 0; m < len; m++) {
               seq.push(part.charCodeAt(l++));
+            }
             writeTable[curAddr++] = SEQ_START - this.decodeTableSeq.length;
             this.decodeTableSeq.push(seq);
-          } else
+          } else {
             writeTable[curAddr++] = code;
+          }
         }
       } else if (typeof part === "number") {
         var charCode = writeTable[curAddr - 1] + 1;
-        for (var l = 0; l < part; l++)
+        for (var l = 0; l < part; l++) {
           writeTable[curAddr++] = charCode++;
-      } else
+        }
+      } else {
         throw new Error("Incorrect type '" + typeof part + "' given in " + this.encodingName + " at chunk " + chunk[0]);
+      }
     }
-    if (curAddr > 255)
+    if (curAddr > 255) {
       throw new Error("Incorrect chunk in " + this.encodingName + " at addr " + chunk[0] + ": too long" + curAddr);
+    }
   };
   DBCSCodec.prototype._getEncodeBucket = function(uCode) {
     var high = uCode >> 8;
-    if (this.encodeTable[high] === void 0)
+    if (this.encodeTable[high] === void 0) {
       this.encodeTable[high] = UNASSIGNED_NODE.slice(0);
+    }
     return this.encodeTable[high];
   };
   DBCSCodec.prototype._setEncodeChar = function(uCode, dbcsCode) {
     var bucket = this._getEncodeBucket(uCode);
     var low = uCode & 255;
-    if (bucket[low] <= SEQ_START)
+    if (bucket[low] <= SEQ_START) {
       this.encodeTableSeq[SEQ_START - bucket[low]][DEF_CHAR] = dbcsCode;
-    else if (bucket[low] == UNASSIGNED)
+    } else if (bucket[low] == UNASSIGNED) {
       bucket[low] = dbcsCode;
+    }
   };
   DBCSCodec.prototype._setEncodeSequence = function(seq, dbcsCode) {
     var uCode = seq[0];
@@ -13647,12 +13633,13 @@ function requireDbcsCodec() {
     }
     for (var j = 1; j < seq.length - 1; j++) {
       var oldVal = node[uCode];
-      if (typeof oldVal === "object")
+      if (typeof oldVal === "object") {
         node = oldVal;
-      else {
+      } else {
         node = node[uCode] = {};
-        if (oldVal !== void 0)
+        if (oldVal !== void 0) {
           node[DEF_CHAR] = oldVal;
+        }
       }
     }
     uCode = seq[seq.length - 1];
@@ -13665,8 +13652,9 @@ function requireDbcsCodec() {
     for (var i2 = 0; i2 < 256; i2++) {
       var uCode = node[i2];
       var mbCode = prefix + i2;
-      if (skipEncodeChars[mbCode])
+      if (skipEncodeChars[mbCode]) {
         continue;
+      }
       if (uCode >= 0) {
         this._setEncodeChar(uCode, mbCode);
         hasValues = true;
@@ -13674,10 +13662,11 @@ function requireDbcsCodec() {
         var subNodeIdx = NODE_START - uCode;
         if (!subNodeEmpty[subNodeIdx]) {
           var newPrefix = mbCode << 8 >>> 0;
-          if (this._fillEncodeTable(subNodeIdx, newPrefix, skipEncodeChars))
+          if (this._fillEncodeTable(subNodeIdx, newPrefix, skipEncodeChars)) {
             hasValues = true;
-          else
+          } else {
             subNodeEmpty[subNodeIdx] = true;
+          }
         }
       } else if (uCode <= SEQ_START) {
         this._setEncodeSequence(this.decodeTableSeq[SEQ_START - uCode], mbCode);
@@ -13695,7 +13684,12 @@ function requireDbcsCodec() {
     this.gb18030 = codec2.gb18030;
   }
   DBCSEncoder.prototype.write = function(str) {
-    var newBuf = Buffer2.alloc(str.length * (this.gb18030 ? 4 : 3)), leadSurrogate = this.leadSurrogate, seqObj = this.seqObj, nextChar = -1, i2 = 0, j = 0;
+    var newBuf = Buffer2.alloc(str.length * (this.gb18030 ? 4 : 3));
+    var leadSurrogate = this.leadSurrogate;
+    var seqObj = this.seqObj;
+    var nextChar = -1;
+    var i2 = 0;
+    var j = 0;
     while (true) {
       if (nextChar === -1) {
         if (i2 == str.length) break;
@@ -13704,7 +13698,7 @@ function requireDbcsCodec() {
         var uCode = nextChar;
         nextChar = -1;
       }
-      if (55296 <= uCode && uCode < 57344) {
+      if (uCode >= 55296 && uCode < 57344) {
         if (uCode < 56320) {
           if (leadSurrogate === -1) {
             leadSurrogate = uCode;
@@ -13732,7 +13726,7 @@ function requireDbcsCodec() {
         if (typeof resCode === "object") {
           seqObj = resCode;
           continue;
-        } else if (typeof resCode == "number") {
+        } else if (typeof resCode === "number") {
           dbcsCode = resCode;
         } else if (resCode == void 0) {
           resCode = seqObj[DEF_CHAR];
@@ -13744,8 +13738,9 @@ function requireDbcsCodec() {
         seqObj = void 0;
       } else if (uCode >= 0) {
         var subtable = this.encodeTable[uCode >> 8];
-        if (subtable !== void 0)
+        if (subtable !== void 0) {
           dbcsCode = subtable[uCode & 255];
+        }
         if (dbcsCode <= SEQ_START) {
           seqObj = this.encodeTableSeq[SEQ_START - dbcsCode];
           continue;
@@ -13765,8 +13760,9 @@ function requireDbcsCodec() {
           }
         }
       }
-      if (dbcsCode === UNASSIGNED)
+      if (dbcsCode === UNASSIGNED) {
         dbcsCode = this.defaultCharSingleByte;
+      }
       if (dbcsCode < 256) {
         newBuf[j++] = dbcsCode;
       } else if (dbcsCode < 65536) {
@@ -13788,9 +13784,11 @@ function requireDbcsCodec() {
     return newBuf.slice(0, j);
   };
   DBCSEncoder.prototype.end = function() {
-    if (this.leadSurrogate === -1 && this.seqObj === void 0)
+    if (this.leadSurrogate === -1 && this.seqObj === void 0) {
       return;
-    var newBuf = Buffer2.alloc(10), j = 0;
+    }
+    var newBuf = Buffer2.alloc(10);
+    var j = 0;
     if (this.seqObj) {
       var dbcsCode = this.seqObj[DEF_CHAR];
       if (dbcsCode !== void 0) {
@@ -13819,7 +13817,12 @@ function requireDbcsCodec() {
     this.gb18030 = codec2.gb18030;
   }
   DBCSDecoder.prototype.write = function(buf) {
-    var newBuf = Buffer2.alloc(buf.length * 2), nodeIdx = this.nodeIdx, prevBytes = this.prevBytes, prevOffset = this.prevBytes.length, seqStart = -this.prevBytes.length, uCode;
+    var newBuf = Buffer2.alloc(buf.length * 2);
+    var nodeIdx = this.nodeIdx;
+    var prevBytes = this.prevBytes;
+    var prevOffset = this.prevBytes.length;
+    var seqStart = -this.prevBytes.length;
+    var uCode;
     for (var i2 = 0, j = 0; i2 < buf.length; i2++) {
       var curByte = i2 >= 0 ? buf[i2] : prevBytes[i2 + prevOffset];
       var uCode = this.decodeTables[nodeIdx][curByte];
@@ -13846,8 +13849,9 @@ function requireDbcsCodec() {
           newBuf[j++] = uCode >> 8;
         }
         uCode = seq[seq.length - 1];
-      } else
+      } else {
         throw new Error("iconv-lite internal error: invalid decoding table value " + uCode + " at " + nodeIdx + "/" + curByte);
+      }
       if (uCode >= 65536) {
         uCode -= 65536;
         var uCodeLead = 55296 | uCode >> 10;
@@ -13871,29 +13875,33 @@ function requireDbcsCodec() {
       var bytesArr = this.prevBytes.slice(1);
       this.prevBytes = [];
       this.nodeIdx = 0;
-      if (bytesArr.length > 0)
+      if (bytesArr.length > 0) {
         ret += this.write(bytesArr);
+      }
     }
     this.prevBytes = [];
     this.nodeIdx = 0;
     return ret;
   };
   function findIdx(table, val) {
-    if (table[0] > val)
+    if (table[0] > val) {
       return -1;
-    var l = 0, r = table.length;
+    }
+    var l = 0;
+    var r = table.length;
     while (l < r - 1) {
       var mid = l + (r - l + 1 >> 1);
-      if (table[mid] <= val)
+      if (table[mid] <= val) {
         l = mid;
-      else
+      } else {
         r = mid;
+      }
     }
     return l;
   }
   return dbcsCodec;
 }
-const require$$0$2 = [
+const require$$0$1 = [
   [
     "0",
     "\0",
@@ -15224,7 +15232,7 @@ function requireDbcsData() {
     // == Japanese/ShiftJIS ====================================================
     // All japanese encodings are based on JIS X set of standards:
     // JIS X 0201 - Single-byte encoding of ASCII + ¥ + Kana chars at 0xA1-0xDF.
-    // JIS X 0208 - Main set of 6879 characters, placed in 94x94 plane, to be encoded by 2 bytes. 
+    // JIS X 0208 - Main set of 6879 characters, placed in 94x94 plane, to be encoded by 2 bytes.
     //              Has several variations in 1978, 1983, 1990 and 1997.
     // JIS X 0212 - Supplementary plane of 6067 chars in 94x94 plane. 1990. Effectively dead.
     // JIS X 0213 - Extension and modern replacement of 0208 and 0212. Total chars: 11233.
@@ -15241,7 +15249,7 @@ function requireDbcsData() {
     //               0x8F, (0xA1-0xFE)x2 - 0212 plane (94x94).
     //  * JIS X 208: 7-bit, direct encoding of 0208. Byte ranges: 0x21-0x7E (94 values). Uncommon.
     //               Used as-is in ISO2022 family.
-    //  * ISO2022-JP: Stateful encoding, with escape sequences to switch between ASCII, 
+    //  * ISO2022-JP: Stateful encoding, with escape sequences to switch between ASCII,
     //                0201-1976 Roman, 0208-1978, 0208-1983.
     //  * ISO2022-JP-1: Adds esc seq for 0212-1990.
     //  * ISO2022-JP-2: Adds esc seq for GB2313-1980, KSX1001-1992, ISO8859-1, ISO8859-7.
@@ -15251,25 +15259,25 @@ function requireDbcsData() {
     // After JIS X 0213 appeared, Shift_JIS-2004, EUC-JISX0213 and ISO2022-JP-2004 followed, with just changing the planes.
     //
     // Overall, it seems that it's a mess :( http://www8.plala.or.jp/tkubota1/unicode-symbols-map2.html
-    "shiftjis": {
+    shiftjis: {
       type: "_dbcs",
       table: function() {
-        return require$$0$2;
+        return require$$0$1;
       },
       encodeAdd: { "¥": 92, "‾": 126 },
       encodeSkipVals: [{ from: 60736, to: 63808 }]
     },
-    "csshiftjis": "shiftjis",
-    "mskanji": "shiftjis",
-    "sjis": "shiftjis",
-    "windows31j": "shiftjis",
-    "ms31j": "shiftjis",
-    "xsjis": "shiftjis",
-    "windows932": "shiftjis",
-    "ms932": "shiftjis",
-    "932": "shiftjis",
-    "cp932": "shiftjis",
-    "eucjp": {
+    csshiftjis: "shiftjis",
+    mskanji: "shiftjis",
+    sjis: "shiftjis",
+    windows31j: "shiftjis",
+    ms31j: "shiftjis",
+    xsjis: "shiftjis",
+    windows932: "shiftjis",
+    ms932: "shiftjis",
+    932: "shiftjis",
+    cp932: "shiftjis",
+    eucjp: {
       type: "_dbcs",
       table: function() {
         return require$$1;
@@ -15283,37 +15291,37 @@ function requireDbcsData() {
     // http://en.wikipedia.org/wiki/GBK
     // We mostly implement W3C recommendation: https://www.w3.org/TR/encoding/#gbk-encoder
     // Oldest GB2312 (1981, ~7600 chars) is a subset of CP936
-    "gb2312": "cp936",
-    "gb231280": "cp936",
-    "gb23121980": "cp936",
-    "csgb2312": "cp936",
-    "csiso58gb231280": "cp936",
-    "euccn": "cp936",
+    gb2312: "cp936",
+    gb231280: "cp936",
+    gb23121980: "cp936",
+    csgb2312: "cp936",
+    csiso58gb231280: "cp936",
+    euccn: "cp936",
     // Microsoft's CP936 is a subset and approximation of GBK.
-    "windows936": "cp936",
-    "ms936": "cp936",
-    "936": "cp936",
-    "cp936": {
+    windows936: "cp936",
+    ms936: "cp936",
+    936: "cp936",
+    cp936: {
       type: "_dbcs",
       table: function() {
         return require$$2;
       }
     },
     // GBK (~22000 chars) is an extension of CP936 that added user-mapped chars and some other.
-    "gbk": {
+    gbk: {
       type: "_dbcs",
       table: function() {
         return require$$2.concat(require$$3);
       }
     },
-    "xgbk": "gbk",
-    "isoir58": "gbk",
+    xgbk: "gbk",
+    isoir58: "gbk",
     // GB18030 is an algorithmic extension of GBK.
     // Main source: https://www.w3.org/TR/encoding/#gbk-encoder
     // http://icu-project.org/docs/papers/gb18030.html
     // http://source.icu-project.org/repos/icu/data/trunk/charset/data/xml/gb-18030-2000.xml
     // http://www.khngai.com/chinese/charmap/tblgbk.php?page=0
-    "gb18030": {
+    gb18030: {
       type: "_dbcs",
       table: function() {
         return require$$2.concat(require$$3);
@@ -15324,26 +15332,26 @@ function requireDbcsData() {
       encodeSkipVals: [128],
       encodeAdd: { "€": 41699 }
     },
-    "chinese": "gb18030",
+    chinese: "gb18030",
     // == Korean ===============================================================
     // EUC-KR, KS_C_5601 and KS X 1001 are exactly the same.
-    "windows949": "cp949",
-    "ms949": "cp949",
-    "949": "cp949",
-    "cp949": {
+    windows949: "cp949",
+    ms949: "cp949",
+    949: "cp949",
+    cp949: {
       type: "_dbcs",
       table: function() {
         return require$$5;
       }
     },
-    "cseuckr": "cp949",
-    "csksc56011987": "cp949",
-    "euckr": "cp949",
-    "isoir149": "cp949",
-    "korean": "cp949",
-    "ksc56011987": "cp949",
-    "ksc56011989": "cp949",
-    "ksc5601": "cp949",
+    cseuckr: "cp949",
+    csksc56011987: "cp949",
+    euckr: "cp949",
+    isoir149: "cp949",
+    korean: "cp949",
+    ksc56011987: "cp949",
+    ksc56011989: "cp949",
+    ksc5601: "cp949",
     // == Big5/Taiwan/Hong Kong ================================================
     // There are lots of tables for Big5 and cp950. Please see the following links for history:
     // http://moztw.org/docs/big5/  http://www.haible.de/bruno/charsets/conversion-tables/Big5.html
@@ -15352,7 +15360,7 @@ function requireDbcsData() {
     //  * Windows CP 951: Microsoft variant of Big5-HKSCS-2001. Seems to be never public. http://me.abelcheung.org/articles/research/what-is-cp951/
     //  * Big5-2003 (Taiwan standard) almost superset of cp950.
     //  * Unicode-at-on (UAO) / Mozilla 1.8. Falling out of use on the Web. Not supported by other browsers.
-    //  * Big5-HKSCS (-2001, -2004, -2008). Hong Kong standard. 
+    //  * Big5-HKSCS (-2001, -2004, -2008). Hong Kong standard.
     //    many unicode code points moved from PUA to Supplementary plane (U+2XXXX) over the years.
     //    Plus, it has 4 combining sequences.
     //    Seems that Mozilla refused to support it for 10 yrs. https://bugzilla.mozilla.org/show_bug.cgi?id=162431 https://bugzilla.mozilla.org/show_bug.cgi?id=310299
@@ -15363,21 +15371,21 @@ function requireDbcsData() {
     //    In the encoder, it might make sense to support encoding old PUA mappings to Big5 bytes seq-s.
     //    Official spec: http://www.ogcio.gov.hk/en/business/tech_promotion/ccli/terms/doc/2003cmp_2008.txt
     //                   http://www.ogcio.gov.hk/tc/business/tech_promotion/ccli/terms/doc/hkscs-2008-big5-iso.txt
-    // 
+    //
     // Current understanding of how to deal with Big5(-HKSCS) is in the Encoding Standard, http://encoding.spec.whatwg.org/#big5-encoder
     // Unicode mapping (http://www.unicode.org/Public/MAPPINGS/OBSOLETE/EASTASIA/OTHER/BIG5.TXT) is said to be wrong.
-    "windows950": "cp950",
-    "ms950": "cp950",
-    "950": "cp950",
-    "cp950": {
+    windows950: "cp950",
+    ms950: "cp950",
+    950: "cp950",
+    cp950: {
       type: "_dbcs",
       table: function() {
         return require$$6;
       }
     },
     // Big5 has many variations and is an extension of cp950. We use Encoding Standard's as a consensus.
-    "big5": "big5hkscs",
-    "big5hkscs": {
+    big5: "big5hkscs",
+    big5hkscs: {
       type: "_dbcs",
       table: function() {
         return require$$6.concat(require$$7);
@@ -15456,9 +15464,9 @@ function requireDbcsData() {
         41678
       ]
     },
-    "cnbig5": "big5hkscs",
-    "csbig5": "big5hkscs",
-    "xxbig5": "big5hkscs"
+    cnbig5: "big5hkscs",
+    csbig5: "big5hkscs",
+    xxbig5: "big5hkscs"
   };
   return dbcsData;
 }
@@ -15467,6 +15475,7 @@ function requireEncodings() {
   if (hasRequiredEncodings) return encodings;
   hasRequiredEncodings = 1;
   (function(exports$1) {
+    var mergeModules = requireMergeExports();
     var modules = [
       requireInternal(),
       requireUtf32(),
@@ -15480,9 +15489,7 @@ function requireEncodings() {
     ];
     for (var i = 0; i < modules.length; i++) {
       var module = modules[i];
-      for (var enc in module)
-        if (Object.prototype.hasOwnProperty.call(module, enc))
-          exports$1[enc] = module[enc];
+      mergeModules(exports$1, module);
     }
   })(encodings);
   return encodings;
@@ -15493,8 +15500,8 @@ function requireStreams() {
   if (hasRequiredStreams) return streams;
   hasRequiredStreams = 1;
   var Buffer2 = requireSafer().Buffer;
-  streams = function(stream_module) {
-    var Transform = stream_module.Transform;
+  streams = function(streamModule) {
+    var Transform = streamModule.Transform;
     function IconvLiteEncoderStream(conv, options) {
       this.conv = conv;
       options = options || {};
@@ -15505,8 +15512,9 @@ function requireStreams() {
       constructor: { value: IconvLiteEncoderStream }
     });
     IconvLiteEncoderStream.prototype._transform = function(chunk, encoding2, done) {
-      if (typeof chunk != "string")
+      if (typeof chunk !== "string") {
         return done(new Error("Iconv encoding stream needs strings as its input."));
+      }
       try {
         var res = this.conv.write(chunk);
         if (res && res.length) this.push(res);
@@ -15545,8 +15553,9 @@ function requireStreams() {
       constructor: { value: IconvLiteDecoderStream }
     });
     IconvLiteDecoderStream.prototype._transform = function(chunk, encoding2, done) {
-      if (!Buffer2.isBuffer(chunk) && !(chunk instanceof Uint8Array))
+      if (!Buffer2.isBuffer(chunk) && !(chunk instanceof Uint8Array)) {
         return done(new Error("Iconv decoding stream needs buffers as its input."));
+      }
       try {
         var res = this.conv.write(chunk);
         if (res && res.length) this.push(res, this.encoding);
@@ -15588,7 +15597,9 @@ function requireLib$2() {
   hasRequiredLib$2 = 1;
   (function(module) {
     var Buffer2 = requireSafer().Buffer;
-    var bomHandling2 = requireBomHandling(), iconv = module.exports;
+    var bomHandling2 = requireBomHandling();
+    var mergeModules = requireMergeExports();
+    var iconv = module.exports;
     iconv.encodings = null;
     iconv.defaultCharUnicode = "�";
     iconv.defaultCharSingleByte = "?";
@@ -15622,31 +15633,38 @@ function requireLib$2() {
     };
     iconv.toEncoding = iconv.encode;
     iconv.fromEncoding = iconv.decode;
-    iconv._codecDataCache = {};
+    iconv._codecDataCache = { __proto__: null };
     iconv.getCodec = function getCodec(encoding2) {
-      if (!iconv.encodings)
-        iconv.encodings = requireEncodings();
+      if (!iconv.encodings) {
+        var raw = requireEncodings();
+        iconv.encodings = { __proto__: null };
+        mergeModules(iconv.encodings, raw);
+      }
       var enc = iconv._canonicalizeEncoding(encoding2);
       var codecOptions = {};
       while (true) {
         var codec2 = iconv._codecDataCache[enc];
-        if (codec2)
+        if (codec2) {
           return codec2;
+        }
         var codecDef = iconv.encodings[enc];
         switch (typeof codecDef) {
           case "string":
             enc = codecDef;
             break;
           case "object":
-            for (var key2 in codecDef)
+            for (var key2 in codecDef) {
               codecOptions[key2] = codecDef[key2];
-            if (!codecOptions.encodingName)
+            }
+            if (!codecOptions.encodingName) {
               codecOptions.encodingName = enc;
+            }
             enc = codecDef.type;
             break;
           case "function":
-            if (!codecOptions.encodingName)
+            if (!codecOptions.encodingName) {
               codecOptions.encodingName = enc;
+            }
             codec2 = new codecDef(codecOptions, iconv);
             iconv._codecDataCache[codecOptions.encodingName] = codec2;
             return codec2;
@@ -15659,21 +15677,26 @@ function requireLib$2() {
       return ("" + encoding2).toLowerCase().replace(/:\d{4}$|[^0-9a-z]/g, "");
     };
     iconv.getEncoder = function getEncoder(encoding2, options) {
-      var codec2 = iconv.getCodec(encoding2), encoder = new codec2.encoder(options, codec2);
-      if (codec2.bomAware && options && options.addBOM)
+      var codec2 = iconv.getCodec(encoding2);
+      var encoder = new codec2.encoder(options, codec2);
+      if (codec2.bomAware && options && options.addBOM) {
         encoder = new bomHandling2.PrependBOM(encoder, options);
+      }
       return encoder;
     };
     iconv.getDecoder = function getDecoder(encoding2, options) {
-      var codec2 = iconv.getCodec(encoding2), decoder2 = new codec2.decoder(options, codec2);
-      if (codec2.bomAware && !(options && options.stripBOM === false))
+      var codec2 = iconv.getCodec(encoding2);
+      var decoder2 = new codec2.decoder(options, codec2);
+      if (codec2.bomAware && !(options && options.stripBOM === false)) {
         decoder2 = new bomHandling2.StripBOM(decoder2, options);
+      }
       return decoder2;
     };
-    iconv.enableStreamingAPI = function enableStreamingAPI(stream_module2) {
-      if (iconv.supportsStreams)
+    iconv.enableStreamingAPI = function enableStreamingAPI(streamModule2) {
+      if (iconv.supportsStreams) {
         return;
-      var streams2 = requireStreams()(stream_module2);
+      }
+      var streams2 = requireStreams()(streamModule2);
       iconv.IconvLiteEncoderStream = streams2.IconvLiteEncoderStream;
       iconv.IconvLiteDecoderStream = streams2.IconvLiteDecoderStream;
       iconv.encodeStream = function encodeStream(encoding2, options) {
@@ -15684,13 +15707,13 @@ function requireLib$2() {
       };
       iconv.supportsStreams = true;
     };
-    var stream_module;
+    var streamModule;
     try {
-      stream_module = require("stream");
+      streamModule = require("stream");
     } catch (e) {
     }
-    if (stream_module && stream_module.Transform) {
-      iconv.enableStreamingAPI(stream_module);
+    if (streamModule && streamModule.Transform) {
+      iconv.enableStreamingAPI(streamModule);
     } else {
       iconv.encodeStream = iconv.decodeStream = function() {
         throw new Error("iconv-lite Streaming API is not enabled. Use iconv.enableStreamingAPI(require('stream')); to enable it.");
@@ -15926,131 +15949,165 @@ function requireRawBody() {
   }
   return rawBody;
 }
-var read_1;
-var hasRequiredRead;
-function requireRead() {
-  if (hasRequiredRead) return read_1;
-  hasRequiredRead = 1;
-  var createError = requireHttpErrors();
-  var getBody = requireRawBody();
-  var iconv = requireLib$2();
-  var onFinished2 = requireOnFinished();
-  var zlib = require$$4$1;
-  read_1 = read2;
-  function read2(req, res, next, parse3, debug, options) {
-    var length;
-    var opts = options;
-    var stream;
-    var encoding2 = opts.encoding !== null ? opts.encoding : null;
-    var verify = opts.verify;
-    try {
-      stream = contentstream(req, debug, opts.inflate);
-      length = stream.length;
-      stream.length = void 0;
-    } catch (err) {
-      return next(err);
-    }
-    opts.length = length;
-    opts.encoding = verify ? null : encoding2;
-    if (opts.encoding === null && encoding2 !== null && !iconv.encodingExists(encoding2)) {
-      return next(createError(415, 'unsupported charset "' + encoding2.toUpperCase() + '"', {
-        charset: encoding2.toLowerCase(),
-        type: "charset.unsupported"
-      }));
-    }
-    debug("read body");
-    getBody(stream, opts, function(error2, body) {
-      if (error2) {
-        var _error;
-        if (error2.type === "encoding.unsupported") {
-          _error = createError(415, 'unsupported charset "' + encoding2.toUpperCase() + '"', {
-            charset: encoding2.toLowerCase(),
-            type: "charset.unsupported"
-          });
-        } else {
-          _error = createError(400, error2);
-        }
-        if (stream !== req) {
-          req.unpipe();
-          stream.destroy();
-        }
-        dump(req, function onfinished() {
-          next(createError(400, _error));
+var onFinished = { exports: {} };
+var eeFirst;
+var hasRequiredEeFirst;
+function requireEeFirst() {
+  if (hasRequiredEeFirst) return eeFirst;
+  hasRequiredEeFirst = 1;
+  eeFirst = first;
+  function first(stuff, done) {
+    if (!Array.isArray(stuff))
+      throw new TypeError("arg must be an array of [ee, events...] arrays");
+    var cleanups = [];
+    for (var i = 0; i < stuff.length; i++) {
+      var arr = stuff[i];
+      if (!Array.isArray(arr) || arr.length < 2)
+        throw new TypeError("each array member must be [ee, events...]");
+      var ee = arr[0];
+      for (var j = 1; j < arr.length; j++) {
+        var event = arr[j];
+        var fn = listener(event, callback);
+        ee.on(event, fn);
+        cleanups.push({
+          ee,
+          event,
+          fn
         });
-        return;
       }
-      if (verify) {
-        try {
-          debug("verify body");
-          verify(req, res, body, encoding2);
-        } catch (err) {
-          next(createError(403, err, {
-            body,
-            type: err.type || "entity.verify.failed"
-          }));
-          return;
-        }
+    }
+    function callback() {
+      cleanup();
+      done.apply(null, arguments);
+    }
+    function cleanup() {
+      var x;
+      for (var i2 = 0; i2 < cleanups.length; i2++) {
+        x = cleanups[i2];
+        x.ee.removeListener(x.event, x.fn);
       }
-      var str = body;
-      try {
-        debug("parse body");
-        str = typeof body !== "string" && encoding2 !== null ? iconv.decode(body, encoding2) : body;
-        req.body = parse3(str, encoding2);
-      } catch (err) {
-        next(createError(400, err, {
-          body: str,
-          type: err.type || "entity.parse.failed"
-        }));
-        return;
+    }
+    function thunk(fn2) {
+      done = fn2;
+    }
+    thunk.cancel = cleanup;
+    return thunk;
+  }
+  function listener(event, done) {
+    return function onevent(arg1) {
+      var args = new Array(arguments.length);
+      var ee = this;
+      var err = event === "error" ? arg1 : null;
+      for (var i = 0; i < args.length; i++) {
+        args[i] = arguments[i];
       }
-      next();
-    });
+      done(err, ee, event, args);
+    };
   }
-  function contentstream(req, debug, inflate) {
-    var encoding2 = (req.headers["content-encoding"] || "identity").toLowerCase();
-    var length = req.headers["content-length"];
-    debug('content-encoding "%s"', encoding2);
-    if (inflate === false && encoding2 !== "identity") {
-      throw createError(415, "content encoding unsupported", {
-        encoding: encoding2,
-        type: "encoding.unsupported"
-      });
+  return eeFirst;
+}
+var hasRequiredOnFinished;
+function requireOnFinished() {
+  if (hasRequiredOnFinished) return onFinished.exports;
+  hasRequiredOnFinished = 1;
+  onFinished.exports = onFinished$1;
+  onFinished.exports.isFinished = isFinished;
+  var asyncHooks = tryRequireAsyncHooks();
+  var first = requireEeFirst();
+  var defer = typeof setImmediate === "function" ? setImmediate : function(fn) {
+    process.nextTick(fn.bind.apply(fn, arguments));
+  };
+  function onFinished$1(msg, listener) {
+    if (isFinished(msg) !== false) {
+      defer(listener, null, msg);
+      return msg;
     }
-    if (encoding2 === "identity") {
-      req.length = length;
-      return req;
+    attachListener(msg, wrap(listener));
+    return msg;
+  }
+  function isFinished(msg) {
+    var socket = msg.socket;
+    if (typeof msg.finished === "boolean") {
+      return Boolean(msg.finished || socket && !socket.writable);
     }
-    var stream = createDecompressionStream(encoding2, debug);
-    req.pipe(stream);
-    return stream;
+    if (typeof msg.complete === "boolean") {
+      return Boolean(msg.upgrade || !socket || !socket.readable || msg.complete && !msg.readable);
+    }
+    return void 0;
   }
-  function createDecompressionStream(encoding2, debug) {
-    switch (encoding2) {
-      case "deflate":
-        debug("inflate body");
-        return zlib.createInflate();
-      case "gzip":
-        debug("gunzip body");
-        return zlib.createGunzip();
-      case "br":
-        debug("brotli decompress body");
-        return zlib.createBrotliDecompress();
-      default:
-        throw createError(415, 'unsupported content encoding "' + encoding2 + '"', {
-          encoding: encoding2,
-          type: "encoding.unsupported"
-        });
+  function attachFinishedListener(msg, callback) {
+    var eeMsg;
+    var eeSocket;
+    var finished = false;
+    function onFinish(error2) {
+      eeMsg.cancel();
+      eeSocket.cancel();
+      finished = true;
+      callback(error2);
+    }
+    eeMsg = eeSocket = first([[msg, "end", "finish"]], onFinish);
+    function onSocket(socket) {
+      msg.removeListener("socket", onSocket);
+      if (finished) return;
+      if (eeMsg !== eeSocket) return;
+      eeSocket = first([[socket, "error", "close"]], onFinish);
+    }
+    if (msg.socket) {
+      onSocket(msg.socket);
+      return;
+    }
+    msg.on("socket", onSocket);
+    if (msg.socket === void 0) {
+      patchAssignSocket(msg, onSocket);
     }
   }
-  function dump(req, callback) {
-    if (onFinished2.isFinished(req)) {
-      callback(null);
-    } else {
-      onFinished2(req, callback);
-      req.resume();
+  function attachListener(msg, listener) {
+    var attached = msg.__onFinished;
+    if (!attached || !attached.queue) {
+      attached = msg.__onFinished = createListener(msg);
+      attachFinishedListener(msg, attached);
     }
+    attached.queue.push(listener);
   }
-  return read_1;
+  function createListener(msg) {
+    function listener(err) {
+      if (msg.__onFinished === listener) msg.__onFinished = null;
+      if (!listener.queue) return;
+      var queue2 = listener.queue;
+      listener.queue = null;
+      for (var i = 0; i < queue2.length; i++) {
+        queue2[i](err, msg);
+      }
+    }
+    listener.queue = [];
+    return listener;
+  }
+  function patchAssignSocket(res, callback) {
+    var assignSocket = res.assignSocket;
+    if (typeof assignSocket !== "function") return;
+    res.assignSocket = function _assignSocket(socket) {
+      assignSocket.call(this, socket);
+      callback(socket);
+    };
+  }
+  function tryRequireAsyncHooks() {
+    try {
+      return require("async_hooks");
+    } catch (e) {
+      return {};
+    }
+  }
+  function wrap(fn) {
+    var res;
+    if (asyncHooks.AsyncResource) {
+      res = new asyncHooks.AsyncResource(fn.name || "bound-anonymous-fn");
+    }
+    if (!res || !res.runInAsyncScope) {
+      return fn;
+    }
+    return res.runInAsyncScope.bind(res, fn, null);
+  }
+  return onFinished.exports;
 }
 var typeIs = { exports: {} };
 var contentType = {};
@@ -16158,7 +16215,7 @@ function requireContentType() {
   return contentType;
 }
 var mimeTypes = {};
-const require$$0$1 = {
+const require$$0 = {
   "application/1d-interleaved-parityfec": { "source": "iana" },
   "application/3gpdash-qoe-report+xml": { "source": "iana", "charset": "UTF-8", "compressible": true },
   "application/3gpp-ims+xml": { "source": "iana", "compressible": true },
@@ -18687,7 +18744,7 @@ var hasRequiredMimeDb;
 function requireMimeDb() {
   if (hasRequiredMimeDb) return mimeDb;
   hasRequiredMimeDb = 1;
-  mimeDb = require$$0$1;
+  mimeDb = require$$0;
   return mimeDb;
 }
 var mimeScore;
@@ -18715,6 +18772,10 @@ function requireMimeScore() {
     application: 1,
     // prefer font/woff over application/font-woff
     font: 2,
+    // prefer video/mp4 over audio/mp4 over application/mp4
+    // See https://www.rfc-editor.org/rfc/rfc4337.html#section-2
+    audio: 2,
+    video: 3,
     default: 0
   };
   mimeScore = function mimeScore2(mimeType, source2 = "default") {
@@ -19011,7 +19072,8 @@ function requireUtils$2() {
   var typeis = requireTypeIs();
   utils$2 = {
     getCharset,
-    normalizeOptions
+    normalizeOptions,
+    passthrough
   };
   function getCharset(req) {
     try {
@@ -19033,6 +19095,7 @@ function requireUtils$2() {
     var limit = typeof options?.limit !== "number" ? bytes2.parse(options?.limit || "100kb") : options?.limit;
     var type2 = options?.type || defaultType;
     var verify = options?.verify || false;
+    var defaultCharset = options?.defaultCharset || "utf-8";
     if (verify !== false && typeof verify !== "function") {
       throw new TypeError("option verify must be function");
     }
@@ -19041,28 +19104,187 @@ function requireUtils$2() {
       inflate,
       limit,
       verify,
+      defaultCharset,
       shouldParse
     };
   }
+  function passthrough(value) {
+    return value;
+  }
   return utils$2;
 }
+var read_1;
+var hasRequiredRead;
+function requireRead() {
+  if (hasRequiredRead) return read_1;
+  hasRequiredRead = 1;
+  var createError = requireHttpErrors();
+  var getBody = requireRawBody();
+  var iconv = requireLib$2();
+  var onFinished2 = requireOnFinished();
+  var zlib = require$$4$1;
+  var hasBody = requireTypeIs().hasBody;
+  var { getCharset } = requireUtils$2();
+  read_1 = read2;
+  function read2(req, res, next, parse3, debug, options) {
+    if (onFinished2.isFinished(req)) {
+      debug("body already parsed");
+      next();
+      return;
+    }
+    if (!("body" in req)) {
+      req.body = void 0;
+    }
+    if (!hasBody(req)) {
+      debug("skip empty body");
+      next();
+      return;
+    }
+    debug("content-type %j", req.headers["content-type"]);
+    if (!options.shouldParse(req)) {
+      debug("skip parsing");
+      next();
+      return;
+    }
+    var encoding2 = null;
+    if (options?.skipCharset !== true) {
+      encoding2 = getCharset(req) || options.defaultCharset;
+      if (!!options?.isValidCharset && !options.isValidCharset(encoding2)) {
+        debug("invalid charset");
+        next(createError(415, 'unsupported charset "' + encoding2.toUpperCase() + '"', {
+          charset: encoding2,
+          type: "charset.unsupported"
+        }));
+        return;
+      }
+    }
+    var length;
+    var opts = options;
+    var stream;
+    var verify = opts.verify;
+    try {
+      stream = contentstream(req, debug, opts.inflate);
+      length = stream.length;
+      stream.length = void 0;
+    } catch (err) {
+      return next(err);
+    }
+    opts.length = length;
+    opts.encoding = verify ? null : encoding2;
+    if (opts.encoding === null && encoding2 !== null && !iconv.encodingExists(encoding2)) {
+      return next(createError(415, 'unsupported charset "' + encoding2.toUpperCase() + '"', {
+        charset: encoding2.toLowerCase(),
+        type: "charset.unsupported"
+      }));
+    }
+    debug("read body");
+    getBody(stream, opts, function(error2, body) {
+      if (error2) {
+        var _error;
+        if (error2.type === "encoding.unsupported") {
+          _error = createError(415, 'unsupported charset "' + encoding2.toUpperCase() + '"', {
+            charset: encoding2.toLowerCase(),
+            type: "charset.unsupported"
+          });
+        } else {
+          _error = createError(400, error2);
+        }
+        if (stream !== req) {
+          req.unpipe();
+          stream.destroy();
+        }
+        dump(req, function onfinished() {
+          next(createError(400, _error));
+        });
+        return;
+      }
+      if (verify) {
+        try {
+          debug("verify body");
+          verify(req, res, body, encoding2);
+        } catch (err) {
+          next(createError(403, err, {
+            body,
+            type: err.type || "entity.verify.failed"
+          }));
+          return;
+        }
+      }
+      var str = body;
+      try {
+        debug("parse body");
+        str = typeof body !== "string" && encoding2 !== null ? iconv.decode(body, encoding2) : body;
+        req.body = parse3(str, encoding2);
+      } catch (err) {
+        next(createError(400, err, {
+          body: str,
+          type: err.type || "entity.parse.failed"
+        }));
+        return;
+      }
+      next();
+    });
+  }
+  function contentstream(req, debug, inflate) {
+    var encoding2 = (req.headers["content-encoding"] || "identity").toLowerCase();
+    var length = req.headers["content-length"];
+    debug('content-encoding "%s"', encoding2);
+    if (inflate === false && encoding2 !== "identity") {
+      throw createError(415, "content encoding unsupported", {
+        encoding: encoding2,
+        type: "encoding.unsupported"
+      });
+    }
+    if (encoding2 === "identity") {
+      req.length = length;
+      return req;
+    }
+    var stream = createDecompressionStream(encoding2, debug);
+    req.pipe(stream);
+    return stream;
+  }
+  function createDecompressionStream(encoding2, debug) {
+    switch (encoding2) {
+      case "deflate":
+        debug("inflate body");
+        return zlib.createInflate();
+      case "gzip":
+        debug("gunzip body");
+        return zlib.createGunzip();
+      case "br":
+        debug("brotli decompress body");
+        return zlib.createBrotliDecompress();
+      default:
+        throw createError(415, 'unsupported content encoding "' + encoding2 + '"', {
+          encoding: encoding2,
+          type: "encoding.unsupported"
+        });
+    }
+  }
+  function dump(req, callback) {
+    if (onFinished2.isFinished(req)) {
+      callback(null);
+    } else {
+      onFinished2(req, callback);
+      req.resume();
+    }
+  }
+  return read_1;
+}
 var json_1;
 var hasRequiredJson;
 function requireJson() {
   if (hasRequiredJson) return json_1;
   hasRequiredJson = 1;
-  var createError = requireHttpErrors();
-  var debug = require$$0$7("body-parser:json");
-  var isFinished = requireOnFinished().isFinished;
+  var debug = require$$0$6("body-parser:json");
   var read2 = requireRead();
-  var typeis = requireTypeIs();
-  var { getCharset, normalizeOptions } = requireUtils$2();
+  var { normalizeOptions } = requireUtils$2();
   json_1 = json2;
   var FIRST_CHAR_REGEXP = /^[\x20\x09\x0a\x0d]*([^\x20\x09\x0a\x0d])/;
   var JSON_SYNTAX_CHAR = "#";
   var JSON_SYNTAX_REGEXP = /#+/g;
   function json2(options) {
-    var { inflate, limit, verify, shouldParse } = normalizeOptions(options, "application/json");
+    const normalizedOptions = normalizeOptions(options, "application/json");
     var reviver = options?.reviver;
     var strict = options?.strict !== false;
     function parse3(body) {
@@ -19086,41 +19308,13 @@ function requireJson() {
         });
       }
     }
+    const readOptions = {
+      ...normalizedOptions,
+      // assert charset per RFC 7159 sec 8.1
+      isValidCharset: (charset2) => charset2.slice(0, 4) === "utf-"
+    };
     return function jsonParser(req, res, next) {
-      if (isFinished(req)) {
-        debug("body already parsed");
-        next();
-        return;
-      }
-      if (!("body" in req)) {
-        req.body = void 0;
-      }
-      if (!typeis.hasBody(req)) {
-        debug("skip empty body");
-        next();
-        return;
-      }
-      debug("content-type %j", req.headers["content-type"]);
-      if (!shouldParse(req)) {
-        debug("skip parsing");
-        next();
-        return;
-      }
-      var charset2 = getCharset(req) || "utf-8";
-      if (charset2.slice(0, 4) !== "utf-") {
-        debug("invalid charset");
-        next(createError(415, 'unsupported charset "' + charset2.toUpperCase() + '"', {
-          charset: charset2,
-          type: "charset.unsupported"
-        }));
-        return;
-      }
-      read2(req, res, next, parse3, debug, {
-        encoding: charset2,
-        inflate,
-        limit,
-        verify
-      });
+      read2(req, res, next, parse3, debug, readOptions);
     };
   }
   function createStrictSyntaxError(str, char) {
@@ -19167,43 +19361,19 @@ var hasRequiredRaw;
 function requireRaw() {
   if (hasRequiredRaw) return raw_1;
   hasRequiredRaw = 1;
-  var debug = require$$0$7("body-parser:raw");
-  var isFinished = requireOnFinished().isFinished;
+  var debug = require$$0$6("body-parser:raw");
   var read2 = requireRead();
-  var typeis = requireTypeIs();
-  var { normalizeOptions } = requireUtils$2();
+  var { normalizeOptions, passthrough } = requireUtils$2();
   raw_1 = raw;
   function raw(options) {
-    var { inflate, limit, verify, shouldParse } = normalizeOptions(options, "application/octet-stream");
-    function parse3(buf) {
-      return buf;
-    }
+    const normalizedOptions = normalizeOptions(options, "application/octet-stream");
+    const readOptions = {
+      ...normalizedOptions,
+      // Skip charset validation and parse the body as is
+      skipCharset: true
+    };
     return function rawParser(req, res, next) {
-      if (isFinished(req)) {
-        debug("body already parsed");
-        next();
-        return;
-      }
-      if (!("body" in req)) {
-        req.body = void 0;
-      }
-      if (!typeis.hasBody(req)) {
-        debug("skip empty body");
-        next();
-        return;
-      }
-      debug("content-type %j", req.headers["content-type"]);
-      if (!shouldParse(req)) {
-        debug("skip parsing");
-        next();
-        return;
-      }
-      read2(req, res, next, parse3, debug, {
-        encoding: null,
-        inflate,
-        limit,
-        verify
-      });
+      read2(req, res, next, passthrough, debug, readOptions);
     };
   }
   return raw_1;
@@ -19213,45 +19383,14 @@ var hasRequiredText;
 function requireText() {
   if (hasRequiredText) return text_1;
   hasRequiredText = 1;
-  var debug = require$$0$7("body-parser:text");
-  var isFinished = requireOnFinished().isFinished;
+  var debug = require$$0$6("body-parser:text");
   var read2 = requireRead();
-  var typeis = requireTypeIs();
-  var { getCharset, normalizeOptions } = requireUtils$2();
+  var { normalizeOptions, passthrough } = requireUtils$2();
   text_1 = text;
   function text(options) {
-    var { inflate, limit, verify, shouldParse } = normalizeOptions(options, "text/plain");
-    var defaultCharset = options?.defaultCharset || "utf-8";
-    function parse3(buf) {
-      return buf;
-    }
+    const normalizedOptions = normalizeOptions(options, "text/plain");
     return function textParser(req, res, next) {
-      if (isFinished(req)) {
-        debug("body already parsed");
-        next();
-        return;
-      }
-      if (!("body" in req)) {
-        req.body = void 0;
-      }
-      if (!typeis.hasBody(req)) {
-        debug("skip empty body");
-        next();
-        return;
-      }
-      debug("content-type %j", req.headers["content-type"]);
-      if (!shouldParse(req)) {
-        debug("skip parsing");
-        next();
-        return;
-      }
-      var charset2 = getCharset(req) || defaultCharset;
-      read2(req, res, next, parse3, debug, {
-        encoding: charset2,
-        inflate,
-        limit,
-        verify
-      });
+      read2(req, res, next, passthrough, debug, normalizedOptions);
     };
   }
   return text_1;
@@ -19855,7 +19994,7 @@ function requireGetIntrinsic() {
   var throwTypeError = function() {
     throw new $TypeError();
   };
-  var ThrowTypeError = $gOPD ? function() {
+  var ThrowTypeError = $gOPD ? (function() {
     try {
       arguments.callee;
       return throwTypeError;
@@ -19866,7 +20005,7 @@ function requireGetIntrinsic() {
         return throwTypeError;
       }
     }
-  }() : throwTypeError;
+  })() : throwTypeError;
   var hasSymbols2 = requireHasSymbols()();
   var getProto2 = requireGetProto();
   var $ObjectGPO = requireObject_getPrototypeOf();
@@ -20377,13 +20516,13 @@ function requireUtils$1() {
   var formats2 = /* @__PURE__ */ requireFormats();
   var has = Object.prototype.hasOwnProperty;
   var isArray = Array.isArray;
-  var hexTable = function() {
+  var hexTable = (function() {
     var array2 = [];
     for (var i = 0; i < 256; ++i) {
       array2.push("%" + ((i < 16 ? "0" : "") + i.toString(16)).toUpperCase());
     }
     return array2;
-  }();
+  })();
   var compactQueue = function compactQueue2(queue2) {
     while (queue2.length > 1) {
       var item = queue2.pop();
@@ -21129,58 +21268,27 @@ function requireUrlencoded() {
   if (hasRequiredUrlencoded) return urlencoded_1;
   hasRequiredUrlencoded = 1;
   var createError = requireHttpErrors();
-  var debug = require$$0$7("body-parser:urlencoded");
-  var isFinished = requireOnFinished().isFinished;
+  var debug = require$$0$6("body-parser:urlencoded");
   var read2 = requireRead();
-  var typeis = requireTypeIs();
   var qs = /* @__PURE__ */ requireLib$1();
-  var { getCharset, normalizeOptions } = requireUtils$2();
+  var { normalizeOptions } = requireUtils$2();
   urlencoded_1 = urlencoded;
   function urlencoded(options) {
-    var { inflate, limit, verify, shouldParse } = normalizeOptions(options, "application/x-www-form-urlencoded");
-    var defaultCharset = options?.defaultCharset || "utf-8";
-    if (defaultCharset !== "utf-8" && defaultCharset !== "iso-8859-1") {
+    const normalizedOptions = normalizeOptions(options, "application/x-www-form-urlencoded");
+    if (normalizedOptions.defaultCharset !== "utf-8" && normalizedOptions.defaultCharset !== "iso-8859-1") {
       throw new TypeError("option defaultCharset must be either utf-8 or iso-8859-1");
     }
     var queryparse = createQueryParser(options);
     function parse3(body, encoding2) {
       return body.length ? queryparse(body, encoding2) : {};
     }
+    const readOptions = {
+      ...normalizedOptions,
+      // assert charset
+      isValidCharset: (charset2) => charset2 === "utf-8" || charset2 === "iso-8859-1"
+    };
     return function urlencodedParser(req, res, next) {
-      if (isFinished(req)) {
-        debug("body already parsed");
-        next();
-        return;
-      }
-      if (!("body" in req)) {
-        req.body = void 0;
-      }
-      if (!typeis.hasBody(req)) {
-        debug("skip empty body");
-        next();
-        return;
-      }
-      debug("content-type %j", req.headers["content-type"]);
-      if (!shouldParse(req)) {
-        debug("skip parsing");
-        next();
-        return;
-      }
-      var charset2 = getCharset(req) || defaultCharset;
-      if (charset2 !== "utf-8" && charset2 !== "iso-8859-1") {
-        debug("invalid charset");
-        next(createError(415, 'unsupported charset "' + charset2.toUpperCase() + '"', {
-          charset: charset2,
-          type: "charset.unsupported"
-        }));
-        return;
-      }
-      read2(req, res, next, parse3, debug, {
-        encoding: charset2,
-        inflate,
-        limit,
-        verify
-      });
+      read2(req, res, next, parse3, debug, readOptions);
     };
   }
   function createQueryParser(options) {
@@ -21231,8 +21339,14 @@ function requireUrlencoded() {
     };
   }
   function parameterCount(body, limit) {
-    var len = body.split("&").length;
-    return len > limit ? void 0 : len - 1;
+    let count = 0;
+    let index2 = -1;
+    do {
+      count++;
+      if (count > limit) return void 0;
+      index2 = body.indexOf("&", index2 + 1);
+    } while (index2 !== -1);
+    return count;
   }
   return urlencoded_1;
 }
@@ -21359,7 +21473,7 @@ var hasRequiredParseurl;
 function requireParseurl() {
   if (hasRequiredParseurl) return parseurl.exports;
   hasRequiredParseurl = 1;
-  var url2 = require$$0$8;
+  var url2 = require$$0$7;
   var parse3 = url2.parse;
   var Url = url2.Url;
   parseurl.exports = parseurl$1;
@@ -21438,148 +21552,12 @@ function requireParseurl() {
   }
   return parseurl.exports;
 }
-const require$$0 = {
-  "100": "Continue",
-  "101": "Switching Protocols",
-  "102": "Processing",
-  "103": "Early Hints",
-  "200": "OK",
-  "201": "Created",
-  "202": "Accepted",
-  "203": "Non-Authoritative Information",
-  "204": "No Content",
-  "205": "Reset Content",
-  "206": "Partial Content",
-  "207": "Multi-Status",
-  "208": "Already Reported",
-  "226": "IM Used",
-  "300": "Multiple Choices",
-  "301": "Moved Permanently",
-  "302": "Found",
-  "303": "See Other",
-  "304": "Not Modified",
-  "305": "Use Proxy",
-  "307": "Temporary Redirect",
-  "308": "Permanent Redirect",
-  "400": "Bad Request",
-  "401": "Unauthorized",
-  "402": "Payment Required",
-  "403": "Forbidden",
-  "404": "Not Found",
-  "405": "Method Not Allowed",
-  "406": "Not Acceptable",
-  "407": "Proxy Authentication Required",
-  "408": "Request Timeout",
-  "409": "Conflict",
-  "410": "Gone",
-  "411": "Length Required",
-  "412": "Precondition Failed",
-  "413": "Payload Too Large",
-  "414": "URI Too Long",
-  "415": "Unsupported Media Type",
-  "416": "Range Not Satisfiable",
-  "417": "Expectation Failed",
-  "418": "I'm a Teapot",
-  "421": "Misdirected Request",
-  "422": "Unprocessable Entity",
-  "423": "Locked",
-  "424": "Failed Dependency",
-  "425": "Too Early",
-  "426": "Upgrade Required",
-  "428": "Precondition Required",
-  "429": "Too Many Requests",
-  "431": "Request Header Fields Too Large",
-  "451": "Unavailable For Legal Reasons",
-  "500": "Internal Server Error",
-  "501": "Not Implemented",
-  "502": "Bad Gateway",
-  "503": "Service Unavailable",
-  "504": "Gateway Timeout",
-  "505": "HTTP Version Not Supported",
-  "506": "Variant Also Negotiates",
-  "507": "Insufficient Storage",
-  "508": "Loop Detected",
-  "509": "Bandwidth Limit Exceeded",
-  "510": "Not Extended",
-  "511": "Network Authentication Required"
-};
-var statuses;
-var hasRequiredStatuses;
-function requireStatuses() {
-  if (hasRequiredStatuses) return statuses;
-  hasRequiredStatuses = 1;
-  var codes = require$$0;
-  statuses = status;
-  status.message = codes;
-  status.code = createMessageToStatusCodeMap(codes);
-  status.codes = createStatusCodeList(codes);
-  status.redirect = {
-    300: true,
-    301: true,
-    302: true,
-    303: true,
-    305: true,
-    307: true,
-    308: true
-  };
-  status.empty = {
-    204: true,
-    205: true,
-    304: true
-  };
-  status.retry = {
-    502: true,
-    503: true,
-    504: true
-  };
-  function createMessageToStatusCodeMap(codes2) {
-    var map2 = {};
-    Object.keys(codes2).forEach(function forEachCode(code) {
-      var message = codes2[code];
-      var status2 = Number(code);
-      map2[message.toLowerCase()] = status2;
-    });
-    return map2;
-  }
-  function createStatusCodeList(codes2) {
-    return Object.keys(codes2).map(function mapCode(code) {
-      return Number(code);
-    });
-  }
-  function getStatusCode(message) {
-    var msg = message.toLowerCase();
-    if (!Object.prototype.hasOwnProperty.call(status.code, msg)) {
-      throw new Error('invalid status message: "' + message + '"');
-    }
-    return status.code[msg];
-  }
-  function getStatusMessage(code) {
-    if (!Object.prototype.hasOwnProperty.call(status.message, code)) {
-      throw new Error("invalid status code: " + code);
-    }
-    return status.message[code];
-  }
-  function status(code) {
-    if (typeof code === "number") {
-      return getStatusMessage(code);
-    }
-    if (typeof code !== "string") {
-      throw new TypeError("code must be a number or string");
-    }
-    var n = parseInt(code, 10);
-    if (!isNaN(n)) {
-      return getStatusMessage(n);
-    }
-    return getStatusCode(code);
-  }
-  return statuses;
-}
 var finalhandler_1;
 var hasRequiredFinalhandler;
 function requireFinalhandler() {
   if (hasRequiredFinalhandler) return finalhandler_1;
   hasRequiredFinalhandler = 1;
-  var debug = require$$0$7("finalhandler");
+  var debug = require$$0$6("finalhandler");
   var encodeUrl = requireEncodeurl();
   var escapeHtml = requireEscapeHtml();
   var onFinished2 = requireOnFinished();
@@ -21706,7 +21684,7 @@ var hasRequiredView;
 function requireView() {
   if (hasRequiredView) return view;
   hasRequiredView = 1;
-  var debug = require$$0$7("express:view");
+  var debug = require$$0$6("express:view");
   var path2 = path__default;
   var fs2 = fs__default;
   var dirname = path2.dirname;
@@ -21802,8 +21780,8 @@ function requireEtag() {
   if (hasRequiredEtag) return etag_1;
   hasRequiredEtag = 1;
   etag_1 = etag;
-  var crypto2 = require$$0$9;
-  var Stats = require$$0$4.Stats;
+  var crypto2 = require$$0$8;
+  var Stats = require$$0$3.Stats;
   var toString = Object.prototype.toString;
   function entitytag(entity) {
     if (entity.length === 0) {
@@ -21942,7 +21920,7 @@ function requireIpaddr() {
         }
         return defaultName;
       };
-      ipaddr2.IPv4 = function() {
+      ipaddr2.IPv4 = (function() {
         function IPv4(octets) {
           var k, len, octet;
           if (octets.length !== 4) {
@@ -22027,7 +22005,7 @@ function requireIpaddr() {
           return 32 - cidr;
         };
         return IPv4;
-      }();
+      })();
       ipv4Part = "(0?\\d+|0x[a-f0-9]+)";
       ipv4Regexes = {
         fourOctet: new RegExp("^" + ipv4Part + "\\." + ipv4Part + "\\." + ipv4Part + "\\." + ipv4Part + "$", "i"),
@@ -22043,7 +22021,7 @@ function requireIpaddr() {
           }
         };
         if (match = string2.match(ipv4Regexes.fourOctet)) {
-          return function() {
+          return (function() {
             var k, len, ref2, results;
             ref2 = match.slice(1, 6);
             results = [];
@@ -22052,25 +22030,25 @@ function requireIpaddr() {
               results.push(parseIntAuto(part));
             }
             return results;
-          }();
+          })();
         } else if (match = string2.match(ipv4Regexes.longValue)) {
           value = parseIntAuto(match[1]);
           if (value > 4294967295 || value < 0) {
             throw new Error("ipaddr: address outside defined range");
           }
-          return function() {
+          return (function() {
             var k, results;
             results = [];
             for (shift = k = 0; k <= 24; shift = k += 8) {
               results.push(value >> shift & 255);
             }
             return results;
-          }().reverse();
+          })().reverse();
         } else {
           return null;
         }
       };
-      ipaddr2.IPv6 = function() {
+      ipaddr2.IPv6 = (function() {
         function IPv6(parts, zoneId) {
           var i, k, l, len, part, ref2;
           if (parts.length === 16) {
@@ -22130,7 +22108,7 @@ function requireIpaddr() {
         };
         IPv6.prototype.toNormalizedString = function() {
           var addr, part, suffix;
-          addr = function() {
+          addr = (function() {
             var k, len, ref2, results;
             ref2 = this.parts;
             results = [];
@@ -22139,7 +22117,7 @@ function requireIpaddr() {
               results.push(part.toString(16));
             }
             return results;
-          }.call(this).join(":");
+          }).call(this).join(":");
           suffix = "";
           if (this.zoneId) {
             suffix = "%" + this.zoneId;
@@ -22148,7 +22126,7 @@ function requireIpaddr() {
         };
         IPv6.prototype.toFixedLengthString = function() {
           var addr, part, suffix;
-          addr = function() {
+          addr = (function() {
             var k, len, ref2, results;
             ref2 = this.parts;
             results = [];
@@ -22157,7 +22135,7 @@ function requireIpaddr() {
               results.push(part.toString(16).padStart(4, "0"));
             }
             return results;
-          }.call(this).join(":");
+          }).call(this).join(":");
           suffix = "";
           if (this.zoneId) {
             suffix = "%" + this.zoneId;
@@ -22242,7 +22220,7 @@ function requireIpaddr() {
           return 128 - cidr;
         };
         return IPv6;
-      }();
+      })();
       ipv6Part = "(?:[0-9a-f]+::?)+";
       zoneIndex = "%[0-9a-z]{1,}";
       ipv6Regexes = {
@@ -22286,7 +22264,7 @@ function requireIpaddr() {
         if (string2[string2.length - 1] === ":") {
           string2 = string2.slice(0, -1);
         }
-        parts = function() {
+        parts = (function() {
           var k, len, ref2, results;
           ref2 = string2.split(":");
           results = [];
@@ -22295,7 +22273,7 @@ function requireIpaddr() {
             results.push(parseInt(part, 16));
           }
           return results;
-        }();
+        })();
         return {
           parts,
           zoneId
@@ -22674,6 +22652,7 @@ function requireUtils() {
     var proxyaddr = requireProxyAddr();
     var qs = /* @__PURE__ */ requireLib$1();
     var querystring = require$$6$1;
+    const { Buffer: Buffer2 } = require$$7$1;
     exports$1.methods = METHODS.map((method) => method.toLowerCase());
     exports$1.etag = createETagGenerator({ weak: false });
     exports$1.wetag = createETagGenerator({ weak: true });
@@ -22777,7 +22756,7 @@ function requireUtils() {
     };
     function createETagGenerator(options) {
       return function generateETag(body, encoding2) {
-        var buf = !Buffer.isBuffer(body) ? Buffer.from(body, encoding2) : body;
+        var buf = !Buffer2.isBuffer(body) ? Buffer2.from(body, encoding2) : body;
         return etag(buf, options);
       };
     }
@@ -22884,7 +22863,7 @@ function requireDist() {
   if (hasRequiredDist) return dist;
   hasRequiredDist = 1;
   Object.defineProperty(dist, "__esModule", { value: true });
-  dist.TokenData = void 0;
+  dist.PathError = dist.TokenData = void 0;
   dist.parse = parse3;
   dist.compile = compile;
   dist.match = match;
@@ -22894,7 +22873,6 @@ function requireDist() {
   const NOOP_VALUE = (value) => value;
   const ID_START = /^[$_\p{ID_Start}]$/u;
   const ID_CONTINUE = /^[$\u200c\u200d\p{ID_Continue}]$/u;
-  const DEBUG_URL = "https://git.new/pathToRegexpError";
   const SIMPLE_TOKENS = {
     // Groups.
     "{": "{",
@@ -22909,149 +22887,123 @@ function requireDist() {
     "!": "!"
   };
   function escapeText(str) {
-    return str.replace(/[{}()\[\]+?!:*]/g, "\\$&");
+    return str.replace(/[{}()\[\]+?!:*\\]/g, "\\$&");
   }
   function escape2(str) {
     return str.replace(/[.+*?^${}()[\]|/\\]/g, "\\$&");
   }
-  function* lexer(str) {
+  class TokenData {
+    constructor(tokens, originalPath) {
+      this.tokens = tokens;
+      this.originalPath = originalPath;
+    }
+  }
+  dist.TokenData = TokenData;
+  class PathError extends TypeError {
+    constructor(message, originalPath) {
+      let text = message;
+      if (originalPath)
+        text += `: ${originalPath}`;
+      text += `; visit https://git.new/pathToRegexpError for info`;
+      super(text);
+      this.originalPath = originalPath;
+    }
+  }
+  dist.PathError = PathError;
+  function parse3(str, options = {}) {
+    const { encodePath = NOOP_VALUE } = options;
     const chars = [...str];
-    let i = 0;
+    const tokens = [];
+    let index2 = 0;
+    let pos2 = 0;
     function name() {
       let value = "";
-      if (ID_START.test(chars[++i])) {
-        value += chars[i];
-        while (ID_CONTINUE.test(chars[++i])) {
-          value += chars[i];
-        }
-      } else if (chars[i] === '"') {
-        let pos2 = i;
-        while (i < chars.length) {
-          if (chars[++i] === '"') {
-            i++;
-            pos2 = 0;
+      if (ID_START.test(chars[index2])) {
+        do {
+          value += chars[index2++];
+        } while (ID_CONTINUE.test(chars[index2]));
+      } else if (chars[index2] === '"') {
+        let quoteStart = index2;
+        while (index2++ < chars.length) {
+          if (chars[index2] === '"') {
+            index2++;
+            quoteStart = 0;
             break;
           }
-          if (chars[i] === "\\") {
-            value += chars[++i];
-          } else {
-            value += chars[i];
-          }
+          if (chars[index2] === "\\")
+            index2++;
+          value += chars[index2];
         }
-        if (pos2) {
-          throw new TypeError(`Unterminated quote at ${pos2}: ${DEBUG_URL}`);
+        if (quoteStart) {
+          throw new PathError(`Unterminated quote at index ${quoteStart}`, str);
         }
       }
       if (!value) {
-        throw new TypeError(`Missing parameter name at ${i}: ${DEBUG_URL}`);
+        throw new PathError(`Missing parameter name at index ${index2}`, str);
       }
       return value;
     }
-    while (i < chars.length) {
-      const value = chars[i];
+    while (index2 < chars.length) {
+      const value = chars[index2];
       const type2 = SIMPLE_TOKENS[value];
       if (type2) {
-        yield { type: type2, index: i++, value };
+        tokens.push({ type: type2, index: index2++, value });
       } else if (value === "\\") {
-        yield { type: "ESCAPED", index: i++, value: chars[i++] };
+        tokens.push({ type: "escape", index: index2++, value: chars[index2++] });
       } else if (value === ":") {
-        const value2 = name();
-        yield { type: "PARAM", index: i, value: value2 };
+        tokens.push({ type: "param", index: index2++, value: name() });
       } else if (value === "*") {
-        const value2 = name();
-        yield { type: "WILDCARD", index: i, value: value2 };
+        tokens.push({ type: "wildcard", index: index2++, value: name() });
       } else {
-        yield { type: "CHAR", index: i, value: chars[i++] };
-      }
-    }
-    return { type: "END", index: i, value: "" };
-  }
-  class Iter {
-    constructor(tokens) {
-      this.tokens = tokens;
-    }
-    peek() {
-      if (!this._peek) {
-        const next = this.tokens.next();
-        this._peek = next.value;
-      }
-      return this._peek;
-    }
-    tryConsume(type2) {
-      const token2 = this.peek();
-      if (token2.type !== type2)
-        return;
-      this._peek = void 0;
-      return token2.value;
-    }
-    consume(type2) {
-      const value = this.tryConsume(type2);
-      if (value !== void 0)
-        return value;
-      const { type: nextType, index: index2 } = this.peek();
-      throw new TypeError(`Unexpected ${nextType} at ${index2}, expected ${type2}: ${DEBUG_URL}`);
-    }
-    text() {
-      let result = "";
-      let value;
-      while (value = this.tryConsume("CHAR") || this.tryConsume("ESCAPED")) {
-        result += value;
+        tokens.push({ type: "char", index: index2++, value });
       }
-      return result;
-    }
-  }
-  class TokenData {
-    constructor(tokens) {
-      this.tokens = tokens;
     }
-  }
-  dist.TokenData = TokenData;
-  function parse3(str, options = {}) {
-    const { encodePath = NOOP_VALUE } = options;
-    const it2 = new Iter(lexer(str));
-    function consume(endType) {
-      const tokens2 = [];
+    tokens.push({ type: "end", index: index2, value: "" });
+    function consumeUntil(endType) {
+      const output2 = [];
       while (true) {
-        const path2 = it2.text();
-        if (path2)
-          tokens2.push({ type: "text", value: encodePath(path2) });
-        const param = it2.tryConsume("PARAM");
-        if (param) {
-          tokens2.push({
-            type: "param",
-            name: param
+        const token2 = tokens[pos2++];
+        if (token2.type === endType)
+          break;
+        if (token2.type === "char" || token2.type === "escape") {
+          let path2 = token2.value;
+          let cur = tokens[pos2];
+          while (cur.type === "char" || cur.type === "escape") {
+            path2 += cur.value;
+            cur = tokens[++pos2];
+          }
+          output2.push({
+            type: "text",
+            value: encodePath(path2)
           });
           continue;
         }
-        const wildcard = it2.tryConsume("WILDCARD");
-        if (wildcard) {
-          tokens2.push({
-            type: "wildcard",
-            name: wildcard
+        if (token2.type === "param" || token2.type === "wildcard") {
+          output2.push({
+            type: token2.type,
+            name: token2.value
           });
           continue;
         }
-        const open = it2.tryConsume("{");
-        if (open) {
-          tokens2.push({
+        if (token2.type === "{") {
+          output2.push({
             type: "group",
-            tokens: consume("}")
+            tokens: consumeUntil("}")
           });
           continue;
         }
-        it2.consume(endType);
-        return tokens2;
+        throw new PathError(`Unexpected ${token2.type} at index ${token2.index}, expected ${endType}`, str);
       }
+      return output2;
     }
-    const tokens = consume("END");
-    return new TokenData(tokens);
+    return new TokenData(consumeUntil("end"), str);
   }
   function compile(path2, options = {}) {
     const { encode: encode2 = encodeURIComponent, delimiter = DEFAULT_DELIMITER } = options;
-    const data = path2 instanceof TokenData ? path2 : parse3(path2, options);
+    const data = typeof path2 === "object" ? path2 : parse3(path2, options);
     const fn = tokensToFunction(data.tokens, delimiter, encode2);
-    return function path3(data2 = {}) {
-      const [path4, ...missing] = fn(data2);
+    return function path3(params = {}) {
+      const [path4, ...missing] = fn(params);
       if (missing.length) {
         throw new TypeError(`Missing parameters: ${missing.join(", ")}`);
       }
@@ -23140,14 +23092,12 @@ function requireDist() {
   function pathToRegexp(path2, options = {}) {
     const { delimiter = DEFAULT_DELIMITER, end = true, sensitive = false, trailing = true } = options;
     const keys = [];
-    const sources = [];
     const flags = sensitive ? "" : "i";
-    const paths = Array.isArray(path2) ? path2 : [path2];
-    const items = paths.map((path3) => path3 instanceof TokenData ? path3 : parse3(path3, options));
-    for (const { tokens } of items) {
-      for (const seq of flatten2(tokens, 0, [])) {
-        const regexp2 = sequenceToRegExp(seq, delimiter, keys);
-        sources.push(regexp2);
+    const sources = [];
+    for (const input of pathsToArray(path2, [])) {
+      const data = typeof input === "object" ? input : parse3(input, options);
+      for (const tokens of flatten2(data.tokens, 0, [])) {
+        sources.push(toRegExpSource(tokens, delimiter, keys, data.originalPath));
       }
     }
     let pattern2 = `^(?:${sources.join("|")})`;
@@ -23157,14 +23107,22 @@ function requireDist() {
     const regexp = new RegExp(pattern2, flags);
     return { regexp, keys };
   }
+  function pathsToArray(paths, init2) {
+    if (Array.isArray(paths)) {
+      for (const p of paths)
+        pathsToArray(p, init2);
+    } else {
+      init2.push(paths);
+    }
+    return init2;
+  }
   function* flatten2(tokens, index2, init2) {
     if (index2 === tokens.length) {
       return yield init2;
     }
     const token2 = tokens[index2];
     if (token2.type === "group") {
-      const fork = init2.slice();
-      for (const seq of flatten2(token2.tokens, 0, fork)) {
+      for (const seq of flatten2(token2.tokens, 0, init2.slice())) {
         yield* flatten2(tokens, index2 + 1, seq);
       }
     } else {
@@ -23172,12 +23130,11 @@ function requireDist() {
     }
     yield* flatten2(tokens, index2 + 1, init2);
   }
-  function sequenceToRegExp(tokens, delimiter, keys) {
+  function toRegExpSource(tokens, delimiter, keys, originalPath) {
     let result = "";
     let backtrack = "";
     let isSafeSegmentParam = true;
-    for (let i = 0; i < tokens.length; i++) {
-      const token2 = tokens[i];
+    for (const token2 of tokens) {
       if (token2.type === "text") {
         result += escape2(token2.value);
         backtrack += token2.value;
@@ -23186,7 +23143,7 @@ function requireDist() {
       }
       if (token2.type === "param" || token2.type === "wildcard") {
         if (!isSafeSegmentParam && !backtrack) {
-          throw new TypeError(`Missing text after "${token2.name}": ${DEBUG_URL}`);
+          throw new PathError(`Missing text before "${token2.name}" ${token2.type}`, originalPath);
         }
         if (token2.type === "param") {
           result += `(${negate(delimiter, isSafeSegmentParam ? "" : backtrack)}+)`;
@@ -23212,32 +23169,46 @@ function requireDist() {
     }
     return `(?:(?!${escape2(backtrack)}|${escape2(delimiter)})[\\s\\S])`;
   }
-  function stringify3(data) {
-    return data.tokens.map(function stringifyToken(token2, index2, tokens) {
-      if (token2.type === "text")
-        return escapeText(token2.value);
+  function stringifyTokens(tokens) {
+    let value = "";
+    let i = 0;
+    function name(value2) {
+      const isSafe = isNameSafe(value2) && isNextNameSafe(tokens[i]);
+      return isSafe ? value2 : JSON.stringify(value2);
+    }
+    while (i < tokens.length) {
+      const token2 = tokens[i++];
+      if (token2.type === "text") {
+        value += escapeText(token2.value);
+        continue;
+      }
       if (token2.type === "group") {
-        return `{${token2.tokens.map(stringifyToken).join("")}}`;
+        value += `{${stringifyTokens(token2.tokens)}}`;
+        continue;
       }
-      const isSafe = isNameSafe(token2.name) && isNextNameSafe(tokens[index2 + 1]);
-      const key2 = isSafe ? token2.name : JSON.stringify(token2.name);
-      if (token2.type === "param")
-        return `:${key2}`;
-      if (token2.type === "wildcard")
-        return `*${key2}`;
-      throw new TypeError(`Unexpected token: ${token2}`);
-    }).join("");
+      if (token2.type === "param") {
+        value += `:${name(token2.name)}`;
+        continue;
+      }
+      if (token2.type === "wildcard") {
+        value += `*${name(token2.name)}`;
+        continue;
+      }
+      throw new TypeError(`Unknown token type: ${token2.type}`);
+    }
+    return value;
+  }
+  function stringify3(data) {
+    return stringifyTokens(data.tokens);
   }
   function isNameSafe(name) {
     const [first, ...rest] = name;
-    if (!ID_START.test(first))
-      return false;
-    return rest.every((char) => ID_CONTINUE.test(char));
+    return ID_START.test(first) && rest.every((char) => ID_CONTINUE.test(char));
   }
   function isNextNameSafe(token2) {
-    if ((token2 === null || token2 === void 0 ? void 0 : token2.type) !== "text")
-      return true;
-    return !ID_CONTINUE.test(token2.value[0]);
+    if (token2 && token2.type === "text")
+      return !ID_CONTINUE.test(token2.value[0]);
+    return true;
   }
   return dist;
 }
@@ -23248,7 +23219,7 @@ function requireLayer() {
   hasRequiredLayer = 1;
   const isPromise2 = requireIsPromise();
   const pathRegexp = requireDist();
-  const debug = require$$0$7("router:layer");
+  const debug = require$$0$6("router:layer");
   const deprecate = requireBrowser()("router");
   const TRAILING_SLASH_REGEXP = /\/+$/;
   const MATCHING_GROUP_REGEXP = /\((?:\?<(.*?)>)?(?!\?)/g;
@@ -23396,7 +23367,7 @@ var hasRequiredRoute;
 function requireRoute() {
   if (hasRequiredRoute) return route;
   hasRequiredRoute = 1;
-  const debug = require$$0$7("router:route");
+  const debug = require$$0$6("router:route");
   const Layer = requireLayer();
   const { METHODS } = require$$2$4;
   const slice = Array.prototype.slice;
@@ -23520,7 +23491,7 @@ function requireRouter() {
   const { METHODS } = require$$2$4;
   const parseUrl = requireParseurl();
   const Route = requireRoute();
-  const debug = require$$0$7("router");
+  const debug = require$$0$6("router");
   const deprecate = requireBrowser()("router");
   const slice = Array.prototype.slice;
   const flatten2 = Array.prototype.flat;
@@ -23914,7 +23885,7 @@ function requireApplication() {
   hasRequiredApplication = 1;
   (function(module, exports$1) {
     var finalhandler = requireFinalhandler();
-    var debug = require$$0$7("express:application");
+    var debug = require$$0$6("express:application");
     var View = requireView();
     var http = require$$2$4;
     var methods2 = requireUtils().methods;
@@ -24150,7 +24121,7 @@ function requireApplication() {
     };
     app.listen = function listen() {
       var server = http.createServer(this);
-      var args = Array.prototype.slice.call(arguments);
+      var args = slice.call(arguments);
       if (typeof args[args.length - 1] === "function") {
         var done = args[args.length - 1] = once2(args[args.length - 1]);
         server.once("error", done);
@@ -24960,9 +24931,8 @@ function requireRequest() {
     var accept = accepts2(this);
     return accept.charsets.apply(accept, arguments);
   };
-  req.acceptsLanguages = function() {
-    var accept = accepts2(this);
-    return accept.languages.apply(accept, arguments);
+  req.acceptsLanguages = function(...languages) {
+    return accepts2(this).languages(...languages);
   };
   req.range = function range2(size, options) {
     var range3 = this.get("Range");
@@ -24988,9 +24958,9 @@ function requireRequest() {
     return typeis(this, arr);
   };
   defineGetter(req, "protocol", function protocol() {
-    var proto = this.connection.encrypted ? "https" : "http";
+    var proto = this.socket.encrypted ? "https" : "http";
     var trust = this.app.get("trust proxy fn");
-    if (!trust(this.connection.remoteAddress, 0)) {
+    if (!trust(this.socket.remoteAddress, 0)) {
       return proto;
     }
     var header = this.get("X-Forwarded-Proto") || proto;
@@ -25023,7 +24993,7 @@ function requireRequest() {
   defineGetter(req, "host", function host() {
     var trust = this.app.get("trust proxy fn");
     var val = this.get("X-Forwarded-Host");
-    if (!val || !trust(this.connection.remoteAddress, 0)) {
+    if (!val || !trust(this.socket.remoteAddress, 0)) {
       val = this.get("Host");
     } else if (val.indexOf(",") !== -1) {
       val = val.substring(0, val.indexOf(",")).trimRight();
@@ -25067,67 +25037,6 @@ function requireRequest() {
   return request;
 }
 var contentDisposition = { exports: {} };
-var safeBuffer = { exports: {} };
-var hasRequiredSafeBuffer;
-function requireSafeBuffer() {
-  if (hasRequiredSafeBuffer) return safeBuffer.exports;
-  hasRequiredSafeBuffer = 1;
-  (function(module, exports$1) {
-    var buffer2 = require$$0$6;
-    var Buffer2 = buffer2.Buffer;
-    function copyProps(src, dst) {
-      for (var key2 in src) {
-        dst[key2] = src[key2];
-      }
-    }
-    if (Buffer2.from && Buffer2.alloc && Buffer2.allocUnsafe && Buffer2.allocUnsafeSlow) {
-      module.exports = buffer2;
-    } else {
-      copyProps(buffer2, exports$1);
-      exports$1.Buffer = SafeBuffer;
-    }
-    function SafeBuffer(arg, encodingOrOffset, length) {
-      return Buffer2(arg, encodingOrOffset, length);
-    }
-    SafeBuffer.prototype = Object.create(Buffer2.prototype);
-    copyProps(Buffer2, SafeBuffer);
-    SafeBuffer.from = function(arg, encodingOrOffset, length) {
-      if (typeof arg === "number") {
-        throw new TypeError("Argument must not be a number");
-      }
-      return Buffer2(arg, encodingOrOffset, length);
-    };
-    SafeBuffer.alloc = function(size, fill, encoding2) {
-      if (typeof size !== "number") {
-        throw new TypeError("Argument must be a number");
-      }
-      var buf = Buffer2(size);
-      if (fill !== void 0) {
-        if (typeof encoding2 === "string") {
-          buf.fill(fill, encoding2);
-        } else {
-          buf.fill(fill);
-        }
-      } else {
-        buf.fill(0);
-      }
-      return buf;
-    };
-    SafeBuffer.allocUnsafe = function(size) {
-      if (typeof size !== "number") {
-        throw new TypeError("Argument must be a number");
-      }
-      return Buffer2(size);
-    };
-    SafeBuffer.allocUnsafeSlow = function(size) {
-      if (typeof size !== "number") {
-        throw new TypeError("Argument must be a number");
-      }
-      return buffer2.SlowBuffer(size);
-    };
-  })(safeBuffer, safeBuffer.exports);
-  return safeBuffer.exports;
-}
 var hasRequiredContentDisposition;
 function requireContentDisposition() {
   if (hasRequiredContentDisposition) return contentDisposition.exports;
@@ -25135,7 +25044,6 @@ function requireContentDisposition() {
   contentDisposition.exports = contentDisposition$1;
   contentDisposition.exports.parse = parse3;
   var basename = path$1.basename;
-  var Buffer2 = requireSafeBuffer().Buffer;
   var ENCODE_URL_ATTR_CHAR_REGEXP = /[\x00-\x20"'()*,/:;<=>?@[\\\]{}\x7f]/g;
   var HEX_ESCAPE_REGEXP = /%[0-9A-Fa-f]{2}/;
   var HEX_ESCAPE_REPLACE_REGEXP = /%([0-9A-Fa-f]{2})/g;
@@ -25215,7 +25123,7 @@ function requireContentDisposition() {
         break;
       case "utf-8":
       case "utf8":
-        value = Buffer2.from(binary, "binary").toString("utf8");
+        value = Buffer.from(binary, "binary").toString("utf8");
         break;
       default:
         throw new TypeError("unsupported charset in extended field");
@@ -25297,7 +25205,7 @@ function requireCookieSignature() {
   if (hasRequiredCookieSignature) return cookieSignature;
   hasRequiredCookieSignature = 1;
   (function(exports$1) {
-    var crypto2 = require$$0$9;
+    var crypto2 = require$$0$8;
     exports$1.sign = function(val, secret) {
       if ("string" != typeof val) throw new TypeError("Cookie value must be provided as a string.");
       if (null == secret) throw new TypeError("Secret key must be provided.");
@@ -25484,12 +25392,12 @@ function requireSend() {
   if (hasRequiredSend) return send_1;
   hasRequiredSend = 1;
   var createError = requireHttpErrors();
-  var debug = require$$0$7("send");
+  var debug = require$$0$6("send");
   var encodeUrl = requireEncodeurl();
   var escapeHtml = requireEscapeHtml();
   var etag = requireEtag();
   var fresh = requireFresh();
-  var fs2 = require$$0$4;
+  var fs2 = require$$0$3;
   var mime = requireMimeTypes();
   var ms2 = require$$8;
   var onFinished2 = requireOnFinished();
@@ -25968,6 +25876,7 @@ function requireResponse() {
   hasRequiredResponse = 1;
   var contentDisposition2 = requireContentDisposition();
   var createError = requireHttpErrors();
+  var deprecate = requireBrowser()("express");
   var encodeUrl = requireEncodeurl();
   var escapeHtml = requireEscapeHtml();
   var http = require$$2$4;
@@ -25985,6 +25894,7 @@ function requireResponse() {
   var extname = path2.extname;
   var resolve2 = path2.resolve;
   var vary2 = requireVary();
+  const { Buffer: Buffer2 } = require$$7$1;
   var res = Object.create(http.ServerResponse.prototype);
   response = res;
   res.status = function status(code) {
@@ -26048,12 +25958,12 @@ function requireResponse() {
     var generateETag = !this.get("ETag") && typeof etagFn === "function";
     var len;
     if (chunk !== void 0) {
-      if (Buffer.isBuffer(chunk)) {
+      if (Buffer2.isBuffer(chunk)) {
         len = chunk.length;
       } else if (!generateETag && chunk.length < 1e3) {
-        len = Buffer.byteLength(chunk, encoding2);
+        len = Buffer2.byteLength(chunk, encoding2);
       } else {
-        chunk = Buffer.from(chunk, encoding2);
+        chunk = Buffer2.from(chunk, encoding2);
         encoding2 = void 0;
         len = chunk.length;
       }
@@ -26292,6 +26202,15 @@ function requireResponse() {
       status = arguments[0];
       address = arguments[1];
     }
+    if (!address) {
+      deprecate("Provide a url argument");
+    }
+    if (typeof address !== "string") {
+      deprecate("Url must be a string");
+    }
+    if (typeof status !== "number") {
+      deprecate("Status must be a number");
+    }
     address = this.location(address).get("Location");
     this.format({
       text: function() {
@@ -26306,7 +26225,7 @@ function requireResponse() {
       }
     });
     this.status(status);
-    this.set("Content-Length", Buffer.byteLength(body));
+    this.set("Content-Length", Buffer2.byteLength(body));
     if (this.req.method === "HEAD") {
       this.end();
     } else {
@@ -26430,7 +26349,7 @@ function requireServeStatic() {
   var parseUrl = requireParseurl();
   var resolve2 = path$1.resolve;
   var send = requireSend();
-  var url2 = require$$0$8;
+  var url2 = require$$0$7;
   serveStatic_1 = serveStatic;
   function serveStatic(root2, options) {
     if (!root2) {
@@ -30220,7 +30139,7 @@ class DownloadFile extends BaseAction {
     } else {
       throw new Error("不存在任何文件, 无法下载");
     }
-    if (require$$0$4.existsSync(filePath)) {
+    if (require$$0$3.existsSync(filePath)) {
       if (isRandomName) {
         const md5 = await calculateFileMD5(filePath);
         const newPath = path__default.join(TEMP_DIR, md5);
@@ -44620,7 +44539,7 @@ function _stringbool(Classes, _params) {
     type: "pipe",
     in: stringSchema,
     out: booleanSchema,
-    transform: (input, payload) => {
+    transform: ((input, payload) => {
       let data = input;
       if (params.case !== "sensitive")
         data = data.toLowerCase();
@@ -44639,14 +44558,14 @@ function _stringbool(Classes, _params) {
         });
         return {};
       }
-    },
-    reverseTransform: (input, _payload) => {
+    }),
+    reverseTransform: ((input, _payload) => {
       if (input === true) {
         return truthyArray[0] || "true";
       } else {
         return falsyArray[0] || "false";
       }
-    },
+    }),
     error: params.error
   });
   return codec2;
@@ -45809,10 +45728,10 @@ const ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
   };
   inst.clone = (def2, params) => clone(inst, def2, params);
   inst.brand = () => inst;
-  inst.register = (reg, meta2) => {
+  inst.register = ((reg, meta2) => {
     reg.add(inst, meta2);
     return inst;
-  };
+  });
   inst.parse = (data, params) => parse2(inst, data, params, { callee: inst.parse });
   inst.safeParse = (data, params) => safeParse(inst, data, params);
   inst.parseAsync = async (data, params) => parseAsync(inst, data, params, { callee: inst.parseAsync });
@@ -55989,7 +55908,7 @@ class WebUIServer extends Service2 {
   connections = /* @__PURE__ */ new Set();
   currentPort;
   port = void 0;
-  static inject = ["app", "ntLoginApi", "ntFriendApi", "ntGroupApi"];
+  static inject = ["ntLoginApi", "ntFriendApi", "ntGroupApi"];
   initServer() {
     this.app.use(express.static(feDistPath));
     this.app.use(express.json());
@@ -56144,7 +56063,11 @@ class WebUIServer extends Service2 {
     });
     this.app.get("/api/dashboard/stats", async (req, res) => {
       try {
-        const app = this.ctx.app;
+        const app = this.ctx.get("app");
+        if (!app) {
+          res.status(503).json({ success: false, message: "服务尚未就绪，请等待登录完成" });
+          return;
+        }
         const friends = await this.ctx.ntFriendApi.getBuddyList();
         const groups = await this.ctx.ntGroupApi.getGroups(false);
         const qqInfo = await pmhq.getProcessInfo();
@@ -56251,6 +56174,7 @@ class WebUIServer extends Service2 {
     this.config = { onlyLocalhost: newConfig.onlyLocalhost, ...newConfig.webui };
   }
   async start() {
+    console.log("webui start");
     if (!this.config?.enable) {
       return;
     }