acpilot 2.3.1 → 2.3.3

package/dist/cli.js

@@ -30358,42 +30358,42 @@ var require_abort_signal = __commonJS({
     var { RequestAbortedError } = require_errors();
     var kListener = Symbol("kListener");
     var kSignal = Symbol("kSignal");
-    function abort(self2) {
-      if (self2.abort) {
-        self2.abort(self2[kSignal]?.reason);
+    function abort(self) {
+      if (self.abort) {
+        self.abort(self[kSignal]?.reason);
       } else {
-        self2.reason = self2[kSignal]?.reason ?? new RequestAbortedError();
+        self.reason = self[kSignal]?.reason ?? new RequestAbortedError();
       }
-      removeSignal(self2);
+      removeSignal(self);
     }
-    function addSignal(self2, signal) {
-      self2.reason = null;
-      self2[kSignal] = null;
-      self2[kListener] = null;
+    function addSignal(self, signal) {
+      self.reason = null;
+      self[kSignal] = null;
+      self[kListener] = null;
       if (!signal) {
         return;
       }
       if (signal.aborted) {
-        abort(self2);
+        abort(self);
         return;
       }
-      self2[kSignal] = signal;
-      self2[kListener] = () => {
-        abort(self2);
+      self[kSignal] = signal;
+      self[kListener] = () => {
+        abort(self);
       };
-      addAbortListener(self2[kSignal], self2[kListener]);
+      addAbortListener(self[kSignal], self[kListener]);
     }
-    function removeSignal(self2) {
-      if (!self2[kSignal]) {
+    function removeSignal(self) {
+      if (!self[kSignal]) {
         return;
       }
-      if ("removeEventListener" in self2[kSignal]) {
-        self2[kSignal].removeEventListener("abort", self2[kListener]);
+      if ("removeEventListener" in self[kSignal]) {
+        self[kSignal].removeEventListener("abort", self[kListener]);
       } else {
-        self2[kSignal].removeListener("abort", self2[kListener]);
+        self[kSignal].removeListener("abort", self[kListener]);
       }
-      self2[kSignal] = null;
-      self2[kListener] = null;
+      self[kSignal] = null;
+      self[kListener] = null;
     }
     module2.exports = {
       addSignal,
@@ -32674,7 +32674,7 @@ var require_snapshot_agent = __commonJS({
           trailers: {},
           body: []
         };
-        const self2 = this;
+        const self = this;
         const recordingHandler = {
           onRequestStart(controller, context) {
             return handler.onRequestStart(controller, { ...context, history: this.history });
@@ -32694,7 +32694,7 @@ var require_snapshot_agent = __commonJS({
           onResponseEnd(controller, trailers) {
             responseData.trailers = trailers;
             const responseBody = Buffer.concat(responseData.body);
-            self2[kSnapshotRecorder].record(opts, {
+            self[kSnapshotRecorder].record(opts, {
               statusCode: responseData.statusCode,
               headers: responseData.headers,
               body: responseBody,
@@ -54476,2490 +54476,6 @@ var init_consent_dark_patterns = __esm({
   }
 });
 
-// ../../node_modules/geoip-lite/lib/utils.js
-var require_utils3 = __commonJS({
-  "../../node_modules/geoip-lite/lib/utils.js"(exports2, module2) {
-    var utils = module2.exports = {};
-    utils.aton4 = function(a) {
-      a = a.split(/\./);
-      return (parseInt(a[0], 10) << 24 >>> 0) + (parseInt(a[1], 10) << 16 >>> 0) + (parseInt(a[2], 10) << 8 >>> 0) + (parseInt(a[3], 10) >>> 0);
-    };
-    utils.aton6 = function(a) {
-      a = a.replace(/"/g, "").split(/:/);
-      var l = a.length - 1;
-      var i;
-      if (a[l] === "") {
-        a[l] = 0;
-      }
-      if (l < 7) {
-        a.length = 8;
-        for (i = l; i >= 0 && a[i] !== ""; i--) {
-          a[7 - l + i] = a[i];
-        }
-      }
-      for (i = 0; i < 8; i++) {
-        if (!a[i]) {
-          a[i] = 0;
-        } else {
-          a[i] = parseInt(a[i], 16);
-        }
-      }
-      var r = [];
-      for (i = 0; i < 4; i++) {
-        r.push((a[2 * i] << 16) + a[2 * i + 1] >>> 0);
-      }
-      return r;
-    };
-    utils.cmp = function(a, b) {
-      if (typeof a === "number" && typeof b === "number") {
-        return a < b ? -1 : a > b ? 1 : 0;
-      }
-      if (a instanceof Array && b instanceof Array) {
-        return this.cmp6(a, b);
-      }
-      return null;
-    };
-    utils.cmp6 = function(a, b) {
-      for (var ii = 0; ii < 2; ii++) {
-        if (a[ii] < b[ii]) {
-          return -1;
-        }
-        if (a[ii] > b[ii]) {
-          return 1;
-        }
-      }
-      return 0;
-    };
-    utils.isPrivateIP = function(addr) {
-      addr = addr.toString();
-      return addr.match(/^10\.([0-9]{1,3})\.([0-9]{1,3})\.([0-9]{1,3})/) != null || addr.match(/^192\.168\.([0-9]{1,3})\.([0-9]{1,3})/) != null || addr.match(/^172\.16\.([0-9]{1,3})\.([0-9]{1,3})/) != null || addr.match(/^127\.([0-9]{1,3})\.([0-9]{1,3})\.([0-9]{1,3})/) != null || addr.match(/^169\.254\.([0-9]{1,3})\.([0-9]{1,3})/) != null || addr.match(/^fc00:/) != null || addr.match(/^fe80:/) != null;
-    };
-    utils.ntoa4 = function(n) {
-      n = n.toString();
-      n = "" + (n >>> 24 & 255) + "." + (n >>> 16 & 255) + "." + (n >>> 8 & 255) + "." + (n & 255);
-      return n;
-    };
-    utils.ntoa6 = function(n) {
-      var a = "[";
-      for (var i = 0; i < n.length; i++) {
-        a += (n[i] >>> 16).toString(16) + ":";
-        a += (n[i] & 65535).toString(16) + ":";
-      }
-      a = a.replace(/:$/, "]").replace(/:0+/g, ":").replace(/::+/, "::");
-      return a;
-    };
-  }
-});
-
-// ../../node_modules/geoip-lite/lib/fsWatcher.js
-var require_fsWatcher = __commonJS({
-  "../../node_modules/geoip-lite/lib/fsWatcher.js"(exports2, module2) {
-    var fs3 = require("fs");
-    var path = require("path");
-    var FSWatcher = {};
-    function makeFsWatchFilter(name, directory, filename, cooldownDelay, callback) {
-      var cooldownId = null;
-      function timeoutCallback() {
-        cooldownId = null;
-        callback();
-      }
-      function onWatchEvent(event, changedFile) {
-        if (!changedFile) {
-          return;
-        }
-        var filePath = path.join(directory, changedFile);
-        if (!filename || filename === changedFile) {
-          fs3.exists(filePath, function onExists(exists) {
-            if (!exists) {
-              return;
-            }
-            if (cooldownId !== null) {
-              clearTimeout(cooldownId);
-              cooldownId = null;
-            }
-            cooldownId = setTimeout(timeoutCallback, cooldownDelay);
-          });
-        }
-      }
-      if (typeof cooldownDelay === "function") {
-        callback = cooldownDelay;
-        cooldownDelay = filename;
-        filename = null;
-      }
-      if (FSWatcher[name]) {
-        stopWatching(name);
-      }
-      FSWatcher[name] = fs3.watch(directory, onWatchEvent);
-    }
-    function stopWatching(name) {
-      FSWatcher[name].close();
-    }
-    module2.exports.makeFsWatchFilter = makeFsWatchFilter;
-    module2.exports.stopWatching = stopWatching;
-  }
-});
-
-// ../../node_modules/async/dist/async.js
-var require_async = __commonJS({
-  "../../node_modules/async/dist/async.js"(exports2, module2) {
-    (function(global2, factory) {
-      typeof exports2 === "object" && typeof module2 !== "undefined" ? factory(exports2) : typeof define === "function" && define.amd ? define(["exports"], factory) : factory(global2.async = global2.async || {});
-    })(exports2, function(exports3) {
-      "use strict";
-      function slice2(arrayLike, start) {
-        start = start | 0;
-        var newLen = Math.max(arrayLike.length - start, 0);
-        var newArr = Array(newLen);
-        for (var idx = 0; idx < newLen; idx++) {
-          newArr[idx] = arrayLike[start + idx];
-        }
-        return newArr;
-      }
-      var apply = function(fn) {
-        var args = slice2(arguments, 1);
-        return function() {
-          var callArgs = slice2(arguments);
-          return fn.apply(null, args.concat(callArgs));
-        };
-      };
-      var initialParams = function(fn) {
-        return function() {
-          var args = slice2(arguments);
-          var callback = args.pop();
-          fn.call(this, args, callback);
-        };
-      };
-      function isObject(value) {
-        var type = typeof value;
-        return value != null && (type == "object" || type == "function");
-      }
-      var hasSetImmediate = typeof setImmediate === "function" && setImmediate;
-      var hasNextTick = typeof process === "object" && typeof process.nextTick === "function";
-      function fallback(fn) {
-        setTimeout(fn, 0);
-      }
-      function wrap2(defer) {
-        return function(fn) {
-          var args = slice2(arguments, 1);
-          defer(function() {
-            fn.apply(null, args);
-          });
-        };
-      }
-      var _defer;
-      if (hasSetImmediate) {
-        _defer = setImmediate;
-      } else if (hasNextTick) {
-        _defer = process.nextTick;
-      } else {
-        _defer = fallback;
-      }
-      var setImmediate$1 = wrap2(_defer);
-      function asyncify(func) {
-        return initialParams(function(args, callback) {
-          var result;
-          try {
-            result = func.apply(this, args);
-          } catch (e) {
-            return callback(e);
-          }
-          if (isObject(result) && typeof result.then === "function") {
-            result.then(function(value) {
-              invokeCallback(callback, null, value);
-            }, function(err) {
-              invokeCallback(callback, err.message ? err : new Error(err));
-            });
-          } else {
-            callback(null, result);
-          }
-        });
-      }
-      function invokeCallback(callback, error, value) {
-        try {
-          callback(error, value);
-        } catch (e) {
-          setImmediate$1(rethrow, e);
-        }
-      }
-      function rethrow(error) {
-        throw error;
-      }
-      var supportsSymbol = typeof Symbol === "function";
-      function isAsync(fn) {
-        return supportsSymbol && fn[Symbol.toStringTag] === "AsyncFunction";
-      }
-      function wrapAsync(asyncFn) {
-        return isAsync(asyncFn) ? asyncify(asyncFn) : asyncFn;
-      }
-      function applyEach$1(eachfn) {
-        return function(fns) {
-          var args = slice2(arguments, 1);
-          var go = initialParams(function(args2, callback) {
-            var that = this;
-            return eachfn(fns, function(fn, cb) {
-              wrapAsync(fn).apply(that, args2.concat(cb));
-            }, callback);
-          });
-          if (args.length) {
-            return go.apply(this, args);
-          } else {
-            return go;
-          }
-        };
-      }
-      var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
-      var freeSelf = typeof self == "object" && self && self.Object === Object && self;
-      var root2 = freeGlobal || freeSelf || Function("return this")();
-      var Symbol$1 = root2.Symbol;
-      var objectProto = Object.prototype;
-      var hasOwnProperty = objectProto.hasOwnProperty;
-      var nativeObjectToString = objectProto.toString;
-      var symToStringTag$1 = Symbol$1 ? Symbol$1.toStringTag : void 0;
-      function getRawTag(value) {
-        var isOwn = hasOwnProperty.call(value, symToStringTag$1), tag = value[symToStringTag$1];
-        try {
-          value[symToStringTag$1] = void 0;
-          var unmasked = true;
-        } catch (e) {
-        }
-        var result = nativeObjectToString.call(value);
-        if (unmasked) {
-          if (isOwn) {
-            value[symToStringTag$1] = tag;
-          } else {
-            delete value[symToStringTag$1];
-          }
-        }
-        return result;
-      }
-      var objectProto$1 = Object.prototype;
-      var nativeObjectToString$1 = objectProto$1.toString;
-      function objectToString(value) {
-        return nativeObjectToString$1.call(value);
-      }
-      var nullTag = "[object Null]";
-      var undefinedTag = "[object Undefined]";
-      var symToStringTag = Symbol$1 ? Symbol$1.toStringTag : void 0;
-      function baseGetTag(value) {
-        if (value == null) {
-          return value === void 0 ? undefinedTag : nullTag;
-        }
-        return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
-      }
-      var asyncTag = "[object AsyncFunction]";
-      var funcTag = "[object Function]";
-      var genTag = "[object GeneratorFunction]";
-      var proxyTag = "[object Proxy]";
-      function isFunction(value) {
-        if (!isObject(value)) {
-          return false;
-        }
-        var tag = baseGetTag(value);
-        return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
-      }
-      var MAX_SAFE_INTEGER = 9007199254740991;
-      function isLength(value) {
-        return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
-      }
-      function isArrayLike2(value) {
-        return value != null && isLength(value.length) && !isFunction(value);
-      }
-      var breakLoop = {};
-      function noop() {
-      }
-      function once(fn) {
-        return function() {
-          if (fn === null) return;
-          var callFn = fn;
-          fn = null;
-          callFn.apply(this, arguments);
-        };
-      }
-      var iteratorSymbol = typeof Symbol === "function" && Symbol.iterator;
-      var getIterator = function(coll) {
-        return iteratorSymbol && coll[iteratorSymbol] && coll[iteratorSymbol]();
-      };
-      function baseTimes(n, iteratee) {
-        var index3 = -1, result = Array(n);
-        while (++index3 < n) {
-          result[index3] = iteratee(index3);
-        }
-        return result;
-      }
-      function isObjectLike(value) {
-        return value != null && typeof value == "object";
-      }
-      var argsTag = "[object Arguments]";
-      function baseIsArguments(value) {
-        return isObjectLike(value) && baseGetTag(value) == argsTag;
-      }
-      var objectProto$3 = Object.prototype;
-      var hasOwnProperty$2 = objectProto$3.hasOwnProperty;
-      var propertyIsEnumerable = objectProto$3.propertyIsEnumerable;
-      var isArguments = baseIsArguments(/* @__PURE__ */ function() {
-        return arguments;
-      }()) ? baseIsArguments : function(value) {
-        return isObjectLike(value) && hasOwnProperty$2.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
-      };
-      var isArray = Array.isArray;
-      function stubFalse() {
-        return false;
-      }
-      var freeExports = typeof exports3 == "object" && exports3 && !exports3.nodeType && exports3;
-      var freeModule = freeExports && typeof module2 == "object" && module2 && !module2.nodeType && module2;
-      var moduleExports = freeModule && freeModule.exports === freeExports;
-      var Buffer2 = moduleExports ? root2.Buffer : void 0;
-      var nativeIsBuffer = Buffer2 ? Buffer2.isBuffer : void 0;
-      var isBuffer = nativeIsBuffer || stubFalse;
-      var MAX_SAFE_INTEGER$1 = 9007199254740991;
-      var reIsUint = /^(?:0|[1-9]\d*)$/;
-      function isIndex(value, length) {
-        var type = typeof value;
-        length = length == null ? MAX_SAFE_INTEGER$1 : length;
-        return !!length && (type == "number" || type != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
-      }
-      var argsTag$1 = "[object Arguments]";
-      var arrayTag = "[object Array]";
-      var boolTag = "[object Boolean]";
-      var dateTag = "[object Date]";
-      var errorTag = "[object Error]";
-      var funcTag$1 = "[object Function]";
-      var mapTag = "[object Map]";
-      var numberTag = "[object Number]";
-      var objectTag = "[object Object]";
-      var regexpTag = "[object RegExp]";
-      var setTag = "[object Set]";
-      var stringTag = "[object String]";
-      var weakMapTag = "[object WeakMap]";
-      var arrayBufferTag = "[object ArrayBuffer]";
-      var dataViewTag = "[object DataView]";
-      var float32Tag = "[object Float32Array]";
-      var float64Tag = "[object Float64Array]";
-      var int8Tag = "[object Int8Array]";
-      var int16Tag = "[object Int16Array]";
-      var int32Tag = "[object Int32Array]";
-      var uint8Tag = "[object Uint8Array]";
-      var uint8ClampedTag = "[object Uint8ClampedArray]";
-      var uint16Tag = "[object Uint16Array]";
-      var uint32Tag = "[object Uint32Array]";
-      var typedArrayTags = {};
-      typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
-      typedArrayTags[argsTag$1] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag$1] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[objectTag] = typedArrayTags[regexpTag] = typedArrayTags[setTag] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;
-      function baseIsTypedArray(value) {
-        return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
-      }
-      function baseUnary(func) {
-        return function(value) {
-          return func(value);
-        };
-      }
-      var freeExports$1 = typeof exports3 == "object" && exports3 && !exports3.nodeType && exports3;
-      var freeModule$1 = freeExports$1 && typeof module2 == "object" && module2 && !module2.nodeType && module2;
-      var moduleExports$1 = freeModule$1 && freeModule$1.exports === freeExports$1;
-      var freeProcess = moduleExports$1 && freeGlobal.process;
-      var nodeUtil = function() {
-        try {
-          var types = freeModule$1 && freeModule$1.require && freeModule$1.require("util").types;
-          if (types) {
-            return types;
-          }
-          return freeProcess && freeProcess.binding && freeProcess.binding("util");
-        } catch (e) {
-        }
-      }();
-      var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
-      var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
-      var objectProto$2 = Object.prototype;
-      var hasOwnProperty$1 = objectProto$2.hasOwnProperty;
-      function arrayLikeKeys(value, inherited) {
-        var isArr = isArray(value), isArg = !isArr && isArguments(value), isBuff = !isArr && !isArg && isBuffer(value), isType = !isArr && !isArg && !isBuff && isTypedArray(value), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? baseTimes(value.length, String) : [], length = result.length;
-        for (var key in value) {
-          if ((inherited || hasOwnProperty$1.call(value, key)) && !(skipIndexes && // Safari 9 has enumerable `arguments.length` in strict mode.
-          (key == "length" || // Node.js 0.10 has enumerable non-index properties on buffers.
-          isBuff && (key == "offset" || key == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays.
-          isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || // Skip index properties.
-          isIndex(key, length)))) {
-            result.push(key);
-          }
-        }
-        return result;
-      }
-      var objectProto$5 = Object.prototype;
-      function isPrototype(value) {
-        var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto$5;
-        return value === proto;
-      }
-      function overArg(func, transform2) {
-        return function(arg) {
-          return func(transform2(arg));
-        };
-      }
-      var nativeKeys = overArg(Object.keys, Object);
-      var objectProto$4 = Object.prototype;
-      var hasOwnProperty$3 = objectProto$4.hasOwnProperty;
-      function baseKeys(object) {
-        if (!isPrototype(object)) {
-          return nativeKeys(object);
-        }
-        var result = [];
-        for (var key in Object(object)) {
-          if (hasOwnProperty$3.call(object, key) && key != "constructor") {
-            result.push(key);
-          }
-        }
-        return result;
-      }
-      function keys(object) {
-        return isArrayLike2(object) ? arrayLikeKeys(object) : baseKeys(object);
-      }
-      function createArrayIterator(coll) {
-        var i = -1;
-        var len = coll.length;
-        return function next2() {
-          return ++i < len ? { value: coll[i], key: i } : null;
-        };
-      }
-      function createES2015Iterator(iterator2) {
-        var i = -1;
-        return function next2() {
-          var item = iterator2.next();
-          if (item.done)
-            return null;
-          i++;
-          return { value: item.value, key: i };
-        };
-      }
-      function createObjectIterator(obj) {
-        var okeys = keys(obj);
-        var i = -1;
-        var len = okeys.length;
-        return function next2() {
-          var key = okeys[++i];
-          if (key === "__proto__") {
-            return next2();
-          }
-          return i < len ? { value: obj[key], key } : null;
-        };
-      }
-      function iterator(coll) {
-        if (isArrayLike2(coll)) {
-          return createArrayIterator(coll);
-        }
-        var iterator2 = getIterator(coll);
-        return iterator2 ? createES2015Iterator(iterator2) : createObjectIterator(coll);
-      }
-      function onlyOnce(fn) {
-        return function() {
-          if (fn === null) throw new Error("Callback was already called.");
-          var callFn = fn;
-          fn = null;
-          callFn.apply(this, arguments);
-        };
-      }
-      function _eachOfLimit(limit) {
-        return function(obj, iteratee, callback) {
-          callback = once(callback || noop);
-          if (limit <= 0 || !obj) {
-            return callback(null);
-          }
-          var nextElem = iterator(obj);
-          var done = false;
-          var running = 0;
-          var looping = false;
-          function iterateeCallback(err, value) {
-            running -= 1;
-            if (err) {
-              done = true;
-              callback(err);
-            } else if (value === breakLoop || done && running <= 0) {
-              done = true;
-              return callback(null);
-            } else if (!looping) {
-              replenish();
-            }
-          }
-          function replenish() {
-            looping = true;
-            while (running < limit && !done) {
-              var elem = nextElem();
-              if (elem === null) {
-                done = true;
-                if (running <= 0) {
-                  callback(null);
-                }
-                return;
-              }
-              running += 1;
-              iteratee(elem.value, elem.key, onlyOnce(iterateeCallback));
-            }
-            looping = false;
-          }
-          replenish();
-        };
-      }
-      function eachOfLimit(coll, limit, iteratee, callback) {
-        _eachOfLimit(limit)(coll, wrapAsync(iteratee), callback);
-      }
-      function doLimit(fn, limit) {
-        return function(iterable, iteratee, callback) {
-          return fn(iterable, limit, iteratee, callback);
-        };
-      }
-      function eachOfArrayLike(coll, iteratee, callback) {
-        callback = once(callback || noop);
-        var index3 = 0, completed = 0, length = coll.length;
-        if (length === 0) {
-          callback(null);
-        }
-        function iteratorCallback(err, value) {
-          if (err) {
-            callback(err);
-          } else if (++completed === length || value === breakLoop) {
-            callback(null);
-          }
-        }
-        for (; index3 < length; index3++) {
-          iteratee(coll[index3], index3, onlyOnce(iteratorCallback));
-        }
-      }
-      var eachOfGeneric = doLimit(eachOfLimit, Infinity);
-      var eachOf = function(coll, iteratee, callback) {
-        var eachOfImplementation = isArrayLike2(coll) ? eachOfArrayLike : eachOfGeneric;
-        eachOfImplementation(coll, wrapAsync(iteratee), callback);
-      };
-      function doParallel(fn) {
-        return function(obj, iteratee, callback) {
-          return fn(eachOf, obj, wrapAsync(iteratee), callback);
-        };
-      }
-      function _asyncMap(eachfn, arr, iteratee, callback) {
-        callback = callback || noop;
-        arr = arr || [];
-        var results = [];
-        var counter = 0;
-        var _iteratee = wrapAsync(iteratee);
-        eachfn(arr, function(value, _, callback2) {
-          var index3 = counter++;
-          _iteratee(value, function(err, v) {
-            results[index3] = v;
-            callback2(err);
-          });
-        }, function(err) {
-          callback(err, results);
-        });
-      }
-      var map2 = doParallel(_asyncMap);
-      var applyEach = applyEach$1(map2);
-      function doParallelLimit(fn) {
-        return function(obj, limit, iteratee, callback) {
-          return fn(_eachOfLimit(limit), obj, wrapAsync(iteratee), callback);
-        };
-      }
-      var mapLimit = doParallelLimit(_asyncMap);
-      var mapSeries = doLimit(mapLimit, 1);
-      var applyEachSeries = applyEach$1(mapSeries);
-      function arrayEach(array, iteratee) {
-        var index3 = -1, length = array == null ? 0 : array.length;
-        while (++index3 < length) {
-          if (iteratee(array[index3], index3, array) === false) {
-            break;
-          }
-        }
-        return array;
-      }
-      function createBaseFor(fromRight) {
-        return function(object, iteratee, keysFunc) {
-          var index3 = -1, iterable = Object(object), props = keysFunc(object), length = props.length;
-          while (length--) {
-            var key = props[fromRight ? length : ++index3];
-            if (iteratee(iterable[key], key, iterable) === false) {
-              break;
-            }
-          }
-          return object;
-        };
-      }
-      var baseFor = createBaseFor();
-      function baseForOwn(object, iteratee) {
-        return object && baseFor(object, iteratee, keys);
-      }
-      function baseFindIndex(array, predicate, fromIndex, fromRight) {
-        var length = array.length, index3 = fromIndex + (fromRight ? 1 : -1);
-        while (fromRight ? index3-- : ++index3 < length) {
-          if (predicate(array[index3], index3, array)) {
-            return index3;
-          }
-        }
-        return -1;
-      }
-      function baseIsNaN(value) {
-        return value !== value;
-      }
-      function strictIndexOf(array, value, fromIndex) {
-        var index3 = fromIndex - 1, length = array.length;
-        while (++index3 < length) {
-          if (array[index3] === value) {
-            return index3;
-          }
-        }
-        return -1;
-      }
-      function baseIndexOf(array, value, fromIndex) {
-        return value === value ? strictIndexOf(array, value, fromIndex) : baseFindIndex(array, baseIsNaN, fromIndex);
-      }
-      var auto = function(tasks, concurrency, callback) {
-        if (typeof concurrency === "function") {
-          callback = concurrency;
-          concurrency = null;
-        }
-        callback = once(callback || noop);
-        var keys$$1 = keys(tasks);
-        var numTasks = keys$$1.length;
-        if (!numTasks) {
-          return callback(null);
-        }
-        if (!concurrency) {
-          concurrency = numTasks;
-        }
-        var results = {};
-        var runningTasks = 0;
-        var hasError = false;
-        var listeners = /* @__PURE__ */ Object.create(null);
-        var readyTasks = [];
-        var readyToCheck = [];
-        var uncheckedDependencies = {};
-        baseForOwn(tasks, function(task, key) {
-          if (!isArray(task)) {
-            enqueueTask(key, [task]);
-            readyToCheck.push(key);
-            return;
-          }
-          var dependencies = task.slice(0, task.length - 1);
-          var remainingDependencies = dependencies.length;
-          if (remainingDependencies === 0) {
-            enqueueTask(key, task);
-            readyToCheck.push(key);
-            return;
-          }
-          uncheckedDependencies[key] = remainingDependencies;
-          arrayEach(dependencies, function(dependencyName) {
-            if (!tasks[dependencyName]) {
-              throw new Error("async.auto task `" + key + "` has a non-existent dependency `" + dependencyName + "` in " + dependencies.join(", "));
-            }
-            addListener(dependencyName, function() {
-              remainingDependencies--;
-              if (remainingDependencies === 0) {
-                enqueueTask(key, task);
-              }
-            });
-          });
-        });
-        checkForDeadlocks();
-        processQueue();
-        function enqueueTask(key, task) {
-          readyTasks.push(function() {
-            runTask(key, task);
-          });
-        }
-        function processQueue() {
-          if (readyTasks.length === 0 && runningTasks === 0) {
-            return callback(null, results);
-          }
-          while (readyTasks.length && runningTasks < concurrency) {
-            var run = readyTasks.shift();
-            run();
-          }
-        }
-        function addListener(taskName, fn) {
-          var taskListeners = listeners[taskName];
-          if (!taskListeners) {
-            taskListeners = listeners[taskName] = [];
-          }
-          taskListeners.push(fn);
-        }
-        function taskComplete(taskName) {
-          var taskListeners = listeners[taskName] || [];
-          arrayEach(taskListeners, function(fn) {
-            fn();
-          });
-          processQueue();
-        }
-        function runTask(key, task) {
-          if (hasError) return;
-          var taskCallback = onlyOnce(function(err, result) {
-            runningTasks--;
-            if (arguments.length > 2) {
-              result = slice2(arguments, 1);
-            }
-            if (err) {
-              var safeResults = {};
-              baseForOwn(results, function(val2, rkey) {
-                safeResults[rkey] = val2;
-              });
-              safeResults[key] = result;
-              hasError = true;
-              listeners = /* @__PURE__ */ Object.create(null);
-              callback(err, safeResults);
-            } else {
-              results[key] = result;
-              taskComplete(key);
-            }
-          });
-          runningTasks++;
-          var taskFn = wrapAsync(task[task.length - 1]);
-          if (task.length > 1) {
-            taskFn(results, taskCallback);
-          } else {
-            taskFn(taskCallback);
-          }
-        }
-        function checkForDeadlocks() {
-          var currentTask;
-          var counter = 0;
-          while (readyToCheck.length) {
-            currentTask = readyToCheck.pop();
-            counter++;
-            arrayEach(getDependents(currentTask), function(dependent) {
-              if (--uncheckedDependencies[dependent] === 0) {
-                readyToCheck.push(dependent);
-              }
-            });
-          }
-          if (counter !== numTasks) {
-            throw new Error(
-              "async.auto cannot execute tasks due to a recursive dependency"
-            );
-          }
-        }
-        function getDependents(taskName) {
-          var result = [];
-          baseForOwn(tasks, function(task, key) {
-            if (isArray(task) && baseIndexOf(task, taskName, 0) >= 0) {
-              result.push(key);
-            }
-          });
-          return result;
-        }
-      };
-      function arrayMap(array, iteratee) {
-        var index3 = -1, length = array == null ? 0 : array.length, result = Array(length);
-        while (++index3 < length) {
-          result[index3] = iteratee(array[index3], index3, array);
-        }
-        return result;
-      }
-      var symbolTag = "[object Symbol]";
-      function isSymbol(value) {
-        return typeof value == "symbol" || isObjectLike(value) && baseGetTag(value) == symbolTag;
-      }
-      var INFINITY = 1 / 0;
-      var symbolProto = Symbol$1 ? Symbol$1.prototype : void 0;
-      var symbolToString = symbolProto ? symbolProto.toString : void 0;
-      function baseToString(value) {
-        if (typeof value == "string") {
-          return value;
-        }
-        if (isArray(value)) {
-          return arrayMap(value, baseToString) + "";
-        }
-        if (isSymbol(value)) {
-          return symbolToString ? symbolToString.call(value) : "";
-        }
-        var result = value + "";
-        return result == "0" && 1 / value == -INFINITY ? "-0" : result;
-      }
-      function baseSlice(array, start, end2) {
-        var index3 = -1, length = array.length;
-        if (start < 0) {
-          start = -start > length ? 0 : length + start;
-        }
-        end2 = end2 > length ? length : end2;
-        if (end2 < 0) {
-          end2 += length;
-        }
-        length = start > end2 ? 0 : end2 - start >>> 0;
-        start >>>= 0;
-        var result = Array(length);
-        while (++index3 < length) {
-          result[index3] = array[index3 + start];
-        }
-        return result;
-      }
-      function castSlice(array, start, end2) {
-        var length = array.length;
-        end2 = end2 === void 0 ? length : end2;
-        return !start && end2 >= length ? array : baseSlice(array, start, end2);
-      }
-      function charsEndIndex(strSymbols, chrSymbols) {
-        var index3 = strSymbols.length;
-        while (index3-- && baseIndexOf(chrSymbols, strSymbols[index3], 0) > -1) {
-        }
-        return index3;
-      }
-      function charsStartIndex(strSymbols, chrSymbols) {
-        var index3 = -1, length = strSymbols.length;
-        while (++index3 < length && baseIndexOf(chrSymbols, strSymbols[index3], 0) > -1) {
-        }
-        return index3;
-      }
-      function asciiToArray(string) {
-        return string.split("");
-      }
-      var rsAstralRange = "\\ud800-\\udfff";
-      var rsComboMarksRange = "\\u0300-\\u036f";
-      var reComboHalfMarksRange = "\\ufe20-\\ufe2f";
-      var rsComboSymbolsRange = "\\u20d0-\\u20ff";
-      var rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange;
-      var rsVarRange = "\\ufe0e\\ufe0f";
-      var rsZWJ = "\\u200d";
-      var reHasUnicode = RegExp("[" + rsZWJ + rsAstralRange + rsComboRange + rsVarRange + "]");
-      function hasUnicode(string) {
-        return reHasUnicode.test(string);
-      }
-      var rsAstralRange$1 = "\\ud800-\\udfff";
-      var rsComboMarksRange$1 = "\\u0300-\\u036f";
-      var reComboHalfMarksRange$1 = "\\ufe20-\\ufe2f";
-      var rsComboSymbolsRange$1 = "\\u20d0-\\u20ff";
-      var rsComboRange$1 = rsComboMarksRange$1 + reComboHalfMarksRange$1 + rsComboSymbolsRange$1;
-      var rsVarRange$1 = "\\ufe0e\\ufe0f";
-      var rsAstral = "[" + rsAstralRange$1 + "]";
-      var rsCombo = "[" + rsComboRange$1 + "]";
-      var rsFitz = "\\ud83c[\\udffb-\\udfff]";
-      var rsModifier = "(?:" + rsCombo + "|" + rsFitz + ")";
-      var rsNonAstral = "[^" + rsAstralRange$1 + "]";
-      var rsRegional = "(?:\\ud83c[\\udde6-\\uddff]){2}";
-      var rsSurrPair = "[\\ud800-\\udbff][\\udc00-\\udfff]";
-      var rsZWJ$1 = "\\u200d";
-      var reOptMod = rsModifier + "?";
-      var rsOptVar = "[" + rsVarRange$1 + "]?";
-      var rsOptJoin = "(?:" + rsZWJ$1 + "(?:" + [rsNonAstral, rsRegional, rsSurrPair].join("|") + ")" + rsOptVar + reOptMod + ")*";
-      var rsSeq = rsOptVar + reOptMod + rsOptJoin;
-      var rsSymbol = "(?:" + [rsNonAstral + rsCombo + "?", rsCombo, rsRegional, rsSurrPair, rsAstral].join("|") + ")";
-      var reUnicode = RegExp(rsFitz + "(?=" + rsFitz + ")|" + rsSymbol + rsSeq, "g");
-      function unicodeToArray(string) {
-        return string.match(reUnicode) || [];
-      }
-      function stringToArray(string) {
-        return hasUnicode(string) ? unicodeToArray(string) : asciiToArray(string);
-      }
-      function toString2(value) {
-        return value == null ? "" : baseToString(value);
-      }
-      var reTrim = /^\s+|\s+$/g;
-      function trim(string, chars, guard) {
-        string = toString2(string);
-        if (string && (guard || chars === void 0)) {
-          return string.replace(reTrim, "");
-        }
-        if (!string || !(chars = baseToString(chars))) {
-          return string;
-        }
-        var strSymbols = stringToArray(string), chrSymbols = stringToArray(chars), start = charsStartIndex(strSymbols, chrSymbols), end2 = charsEndIndex(strSymbols, chrSymbols) + 1;
-        return castSlice(strSymbols, start, end2).join("");
-      }
-      var FN_ARGS = /^(?:async\s+)?(function)?\s*[^\(]*\(\s*([^\)]*)\)/m;
-      var FN_ARG_SPLIT = /,/;
-      var FN_ARG = /(=.+)?(\s*)$/;
-      var STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg;
-      function parseParams(func) {
-        func = func.toString().replace(STRIP_COMMENTS, "");
-        func = func.match(FN_ARGS)[2].replace(" ", "");
-        func = func ? func.split(FN_ARG_SPLIT) : [];
-        func = func.map(function(arg) {
-          return trim(arg.replace(FN_ARG, ""));
-        });
-        return func;
-      }
-      function autoInject(tasks, callback) {
-        var newTasks = {};
-        baseForOwn(tasks, function(taskFn, key) {
-          var params;
-          var fnIsAsync = isAsync(taskFn);
-          var hasNoDeps = !fnIsAsync && taskFn.length === 1 || fnIsAsync && taskFn.length === 0;
-          if (isArray(taskFn)) {
-            params = taskFn.slice(0, -1);
-            taskFn = taskFn[taskFn.length - 1];
-            newTasks[key] = params.concat(params.length > 0 ? newTask : taskFn);
-          } else if (hasNoDeps) {
-            newTasks[key] = taskFn;
-          } else {
-            params = parseParams(taskFn);
-            if (taskFn.length === 0 && !fnIsAsync && params.length === 0) {
-              throw new Error("autoInject task functions require explicit parameters.");
-            }
-            if (!fnIsAsync) params.pop();
-            newTasks[key] = params.concat(newTask);
-          }
-          function newTask(results, taskCb) {
-            var newArgs = arrayMap(params, function(name) {
-              return results[name];
-            });
-            newArgs.push(taskCb);
-            wrapAsync(taskFn).apply(null, newArgs);
-          }
-        });
-        auto(newTasks, callback);
-      }
-      function DLL() {
-        this.head = this.tail = null;
-        this.length = 0;
-      }
-      function setInitial(dll, node) {
-        dll.length = 1;
-        dll.head = dll.tail = node;
-      }
-      DLL.prototype.removeLink = function(node) {
-        if (node.prev) node.prev.next = node.next;
-        else this.head = node.next;
-        if (node.next) node.next.prev = node.prev;
-        else this.tail = node.prev;
-        node.prev = node.next = null;
-        this.length -= 1;
-        return node;
-      };
-      DLL.prototype.empty = function() {
-        while (this.head) this.shift();
-        return this;
-      };
-      DLL.prototype.insertAfter = function(node, newNode) {
-        newNode.prev = node;
-        newNode.next = node.next;
-        if (node.next) node.next.prev = newNode;
-        else this.tail = newNode;
-        node.next = newNode;
-        this.length += 1;
-      };
-      DLL.prototype.insertBefore = function(node, newNode) {
-        newNode.prev = node.prev;
-        newNode.next = node;
-        if (node.prev) node.prev.next = newNode;
-        else this.head = newNode;
-        node.prev = newNode;
-        this.length += 1;
-      };
-      DLL.prototype.unshift = function(node) {
-        if (this.head) this.insertBefore(this.head, node);
-        else setInitial(this, node);
-      };
-      DLL.prototype.push = function(node) {
-        if (this.tail) this.insertAfter(this.tail, node);
-        else setInitial(this, node);
-      };
-      DLL.prototype.shift = function() {
-        return this.head && this.removeLink(this.head);
-      };
-      DLL.prototype.pop = function() {
-        return this.tail && this.removeLink(this.tail);
-      };
-      DLL.prototype.toArray = function() {
-        var arr = Array(this.length);
-        var curr = this.head;
-        for (var idx = 0; idx < this.length; idx++) {
-          arr[idx] = curr.data;
-          curr = curr.next;
-        }
-        return arr;
-      };
-      DLL.prototype.remove = function(testFn) {
-        var curr = this.head;
-        while (!!curr) {
-          var next2 = curr.next;
-          if (testFn(curr)) {
-            this.removeLink(curr);
-          }
-          curr = next2;
-        }
-        return this;
-      };
-      function queue(worker, concurrency, payload) {
-        if (concurrency == null) {
-          concurrency = 1;
-        } else if (concurrency === 0) {
-          throw new Error("Concurrency must not be zero");
-        }
-        var _worker = wrapAsync(worker);
-        var numRunning = 0;
-        var workersList = [];
-        var processingScheduled = false;
-        function _insert2(data2, insertAtFront, callback) {
-          if (callback != null && typeof callback !== "function") {
-            throw new Error("task callback must be a function");
-          }
-          q.started = true;
-          if (!isArray(data2)) {
-            data2 = [data2];
-          }
-          if (data2.length === 0 && q.idle()) {
-            return setImmediate$1(function() {
-              q.drain();
-            });
-          }
-          for (var i = 0, l = data2.length; i < l; i++) {
-            var item = {
-              data: data2[i],
-              callback: callback || noop
-            };
-            if (insertAtFront) {
-              q._tasks.unshift(item);
-            } else {
-              q._tasks.push(item);
-            }
-          }
-          if (!processingScheduled) {
-            processingScheduled = true;
-            setImmediate$1(function() {
-              processingScheduled = false;
-              q.process();
-            });
-          }
-        }
-        function _next(tasks) {
-          return function(err) {
-            numRunning -= 1;
-            for (var i = 0, l = tasks.length; i < l; i++) {
-              var task = tasks[i];
-              var index3 = baseIndexOf(workersList, task, 0);
-              if (index3 === 0) {
-                workersList.shift();
-              } else if (index3 > 0) {
-                workersList.splice(index3, 1);
-              }
-              task.callback.apply(task, arguments);
-              if (err != null) {
-                q.error(err, task.data);
-              }
-            }
-            if (numRunning <= q.concurrency - q.buffer) {
-              q.unsaturated();
-            }
-            if (q.idle()) {
-              q.drain();
-            }
-            q.process();
-          };
-        }
-        var isProcessing = false;
-        var q = {
-          _tasks: new DLL(),
-          concurrency,
-          payload,
-          saturated: noop,
-          unsaturated: noop,
-          buffer: concurrency / 4,
-          empty: noop,
-          drain: noop,
-          error: noop,
-          started: false,
-          paused: false,
-          push: function(data2, callback) {
-            _insert2(data2, false, callback);
-          },
-          kill: function() {
-            q.drain = noop;
-            q._tasks.empty();
-          },
-          unshift: function(data2, callback) {
-            _insert2(data2, true, callback);
-          },
-          remove: function(testFn) {
-            q._tasks.remove(testFn);
-          },
-          process: function() {
-            if (isProcessing) {
-              return;
-            }
-            isProcessing = true;
-            while (!q.paused && numRunning < q.concurrency && q._tasks.length) {
-              var tasks = [], data2 = [];
-              var l = q._tasks.length;
-              if (q.payload) l = Math.min(l, q.payload);
-              for (var i = 0; i < l; i++) {
-                var node = q._tasks.shift();
-                tasks.push(node);
-                workersList.push(node);
-                data2.push(node.data);
-              }
-              numRunning += 1;
-              if (q._tasks.length === 0) {
-                q.empty();
-              }
-              if (numRunning === q.concurrency) {
-                q.saturated();
-              }
-              var cb = onlyOnce(_next(tasks));
-              _worker(data2, cb);
-            }
-            isProcessing = false;
-          },
-          length: function() {
-            return q._tasks.length;
-          },
-          running: function() {
-            return numRunning;
-          },
-          workersList: function() {
-            return workersList;
-          },
-          idle: function() {
-            return q._tasks.length + numRunning === 0;
-          },
-          pause: function() {
-            q.paused = true;
-          },
-          resume: function() {
-            if (q.paused === false) {
-              return;
-            }
-            q.paused = false;
-            setImmediate$1(q.process);
-          }
-        };
-        return q;
-      }
-      function cargo(worker, payload) {
-        return queue(worker, 1, payload);
-      }
-      var eachOfSeries = doLimit(eachOfLimit, 1);
-      function reduce(coll, memo, iteratee, callback) {
-        callback = once(callback || noop);
-        var _iteratee = wrapAsync(iteratee);
-        eachOfSeries(coll, function(x, i, callback2) {
-          _iteratee(memo, x, function(err, v) {
-            memo = v;
-            callback2(err);
-          });
-        }, function(err) {
-          callback(err, memo);
-        });
-      }
-      function seq() {
-        var _functions = arrayMap(arguments, wrapAsync);
-        return function() {
-          var args = slice2(arguments);
-          var that = this;
-          var cb = args[args.length - 1];
-          if (typeof cb == "function") {
-            args.pop();
-          } else {
-            cb = noop;
-          }
-          reduce(
-            _functions,
-            args,
-            function(newargs, fn, cb2) {
-              fn.apply(that, newargs.concat(function(err) {
-                var nextargs = slice2(arguments, 1);
-                cb2(err, nextargs);
-              }));
-            },
-            function(err, results) {
-              cb.apply(that, [err].concat(results));
-            }
-          );
-        };
-      }
-      var compose = function() {
-        return seq.apply(null, slice2(arguments).reverse());
-      };
-      var _concat = Array.prototype.concat;
-      var concatLimit = function(coll, limit, iteratee, callback) {
-        callback = callback || noop;
-        var _iteratee = wrapAsync(iteratee);
-        mapLimit(coll, limit, function(val2, callback2) {
-          _iteratee(val2, function(err) {
-            if (err) return callback2(err);
-            return callback2(null, slice2(arguments, 1));
-          });
-        }, function(err, mapResults) {
-          var result = [];
-          for (var i = 0; i < mapResults.length; i++) {
-            if (mapResults[i]) {
-              result = _concat.apply(result, mapResults[i]);
-            }
-          }
-          return callback(err, result);
-        });
-      };
-      var concat = doLimit(concatLimit, Infinity);
-      var concatSeries = doLimit(concatLimit, 1);
-      var constant = function() {
-        var values = slice2(arguments);
-        var args = [null].concat(values);
-        return function() {
-          var callback = arguments[arguments.length - 1];
-          return callback.apply(this, args);
-        };
-      };
-      function identity(value) {
-        return value;
-      }
-      function _createTester(check, getResult) {
-        return function(eachfn, arr, iteratee, cb) {
-          cb = cb || noop;
-          var testPassed = false;
-          var testResult;
-          eachfn(arr, function(value, _, callback) {
-            iteratee(value, function(err, result) {
-              if (err) {
-                callback(err);
-              } else if (check(result) && !testResult) {
-                testPassed = true;
-                testResult = getResult(true, value);
-                callback(null, breakLoop);
-              } else {
-                callback();
-              }
-            });
-          }, function(err) {
-            if (err) {
-              cb(err);
-            } else {
-              cb(null, testPassed ? testResult : getResult(false));
-            }
-          });
-        };
-      }
-      function _findGetResult(v, x) {
-        return x;
-      }
-      var detect = doParallel(_createTester(identity, _findGetResult));
-      var detectLimit = doParallelLimit(_createTester(identity, _findGetResult));
-      var detectSeries = doLimit(detectLimit, 1);
-      function consoleFunc(name) {
-        return function(fn) {
-          var args = slice2(arguments, 1);
-          args.push(function(err) {
-            var args2 = slice2(arguments, 1);
-            if (typeof console === "object") {
-              if (err) {
-                if (console.error) {
-                  console.error(err);
-                }
-              } else if (console[name]) {
-                arrayEach(args2, function(x) {
-                  console[name](x);
-                });
-              }
-            }
-          });
-          wrapAsync(fn).apply(null, args);
-        };
-      }
-      var dir = consoleFunc("dir");
-      function doDuring(fn, test, callback) {
-        callback = onlyOnce(callback || noop);
-        var _fn = wrapAsync(fn);
-        var _test = wrapAsync(test);
-        function next2(err) {
-          if (err) return callback(err);
-          var args = slice2(arguments, 1);
-          args.push(check);
-          _test.apply(this, args);
-        }
-        function check(err, truth) {
-          if (err) return callback(err);
-          if (!truth) return callback(null);
-          _fn(next2);
-        }
-        check(null, true);
-      }
-      function doWhilst(iteratee, test, callback) {
-        callback = onlyOnce(callback || noop);
-        var _iteratee = wrapAsync(iteratee);
-        var next2 = function(err) {
-          if (err) return callback(err);
-          var args = slice2(arguments, 1);
-          if (test.apply(this, args)) return _iteratee(next2);
-          callback.apply(null, [null].concat(args));
-        };
-        _iteratee(next2);
-      }
-      function doUntil(iteratee, test, callback) {
-        doWhilst(iteratee, function() {
-          return !test.apply(this, arguments);
-        }, callback);
-      }
-      function during(test, fn, callback) {
-        callback = onlyOnce(callback || noop);
-        var _fn = wrapAsync(fn);
-        var _test = wrapAsync(test);
-        function next2(err) {
-          if (err) return callback(err);
-          _test(check);
-        }
-        function check(err, truth) {
-          if (err) return callback(err);
-          if (!truth) return callback(null);
-          _fn(next2);
-        }
-        _test(check);
-      }
-      function _withoutIndex(iteratee) {
-        return function(value, index3, callback) {
-          return iteratee(value, callback);
-        };
-      }
-      function eachLimit(coll, iteratee, callback) {
-        eachOf(coll, _withoutIndex(wrapAsync(iteratee)), callback);
-      }
-      function eachLimit$1(coll, limit, iteratee, callback) {
-        _eachOfLimit(limit)(coll, _withoutIndex(wrapAsync(iteratee)), callback);
-      }
-      var eachSeries = doLimit(eachLimit$1, 1);
-      function ensureAsync(fn) {
-        if (isAsync(fn)) return fn;
-        return initialParams(function(args, callback) {
-          var sync = true;
-          args.push(function() {
-            var innerArgs = arguments;
-            if (sync) {
-              setImmediate$1(function() {
-                callback.apply(null, innerArgs);
-              });
-            } else {
-              callback.apply(null, innerArgs);
-            }
-          });
-          fn.apply(this, args);
-          sync = false;
-        });
-      }
-      function notId(v) {
-        return !v;
-      }
-      var every = doParallel(_createTester(notId, notId));
-      var everyLimit = doParallelLimit(_createTester(notId, notId));
-      var everySeries = doLimit(everyLimit, 1);
-      function baseProperty(key) {
-        return function(object) {
-          return object == null ? void 0 : object[key];
-        };
-      }
-      function filterArray2(eachfn, arr, iteratee, callback) {
-        var truthValues = new Array(arr.length);
-        eachfn(arr, function(x, index3, callback2) {
-          iteratee(x, function(err, v) {
-            truthValues[index3] = !!v;
-            callback2(err);
-          });
-        }, function(err) {
-          if (err) return callback(err);
-          var results = [];
-          for (var i = 0; i < arr.length; i++) {
-            if (truthValues[i]) results.push(arr[i]);
-          }
-          callback(null, results);
-        });
-      }
-      function filterGeneric(eachfn, coll, iteratee, callback) {
-        var results = [];
-        eachfn(coll, function(x, index3, callback2) {
-          iteratee(x, function(err, v) {
-            if (err) {
-              callback2(err);
-            } else {
-              if (v) {
-                results.push({ index: index3, value: x });
-              }
-              callback2();
-            }
-          });
-        }, function(err) {
-          if (err) {
-            callback(err);
-          } else {
-            callback(null, arrayMap(results.sort(function(a, b) {
-              return a.index - b.index;
-            }), baseProperty("value")));
-          }
-        });
-      }
-      function _filter(eachfn, coll, iteratee, callback) {
-        var filter5 = isArrayLike2(coll) ? filterArray2 : filterGeneric;
-        filter5(eachfn, coll, wrapAsync(iteratee), callback || noop);
-      }
-      var filter4 = doParallel(_filter);
-      var filterLimit = doParallelLimit(_filter);
-      var filterSeries = doLimit(filterLimit, 1);
-      function forever(fn, errback) {
-        var done = onlyOnce(errback || noop);
-        var task = wrapAsync(ensureAsync(fn));
-        function next2(err) {
-          if (err) return done(err);
-          task(next2);
-        }
-        next2();
-      }
-      var groupByLimit = function(coll, limit, iteratee, callback) {
-        callback = callback || noop;
-        var _iteratee = wrapAsync(iteratee);
-        mapLimit(coll, limit, function(val2, callback2) {
-          _iteratee(val2, function(err, key) {
-            if (err) return callback2(err);
-            return callback2(null, { key, val: val2 });
-          });
-        }, function(err, mapResults) {
-          var result = {};
-          var hasOwnProperty2 = Object.prototype.hasOwnProperty;
-          for (var i = 0; i < mapResults.length; i++) {
-            if (mapResults[i]) {
-              var key = mapResults[i].key;
-              var val2 = mapResults[i].val;
-              if (hasOwnProperty2.call(result, key)) {
-                result[key].push(val2);
-              } else {
-                result[key] = [val2];
-              }
-            }
-          }
-          return callback(err, result);
-        });
-      };
-      var groupBy = doLimit(groupByLimit, Infinity);
-      var groupBySeries = doLimit(groupByLimit, 1);
-      var log = consoleFunc("log");
-      function mapValuesLimit(obj, limit, iteratee, callback) {
-        callback = once(callback || noop);
-        var newObj = {};
-        var _iteratee = wrapAsync(iteratee);
-        eachOfLimit(obj, limit, function(val2, key, next2) {
-          _iteratee(val2, key, function(err, result) {
-            if (err) return next2(err);
-            newObj[key] = result;
-            next2();
-          });
-        }, function(err) {
-          callback(err, newObj);
-        });
-      }
-      var mapValues = doLimit(mapValuesLimit, Infinity);
-      var mapValuesSeries = doLimit(mapValuesLimit, 1);
-      function has2(obj, key) {
-        return key in obj;
-      }
-      function memoize(fn, hasher) {
-        var memo = /* @__PURE__ */ Object.create(null);
-        var queues = /* @__PURE__ */ Object.create(null);
-        hasher = hasher || identity;
-        var _fn = wrapAsync(fn);
-        var memoized = initialParams(function memoized2(args, callback) {
-          var key = hasher.apply(null, args);
-          if (has2(memo, key)) {
-            setImmediate$1(function() {
-              callback.apply(null, memo[key]);
-            });
-          } else if (has2(queues, key)) {
-            queues[key].push(callback);
-          } else {
-            queues[key] = [callback];
-            _fn.apply(null, args.concat(function() {
-              var args2 = slice2(arguments);
-              memo[key] = args2;
-              var q = queues[key];
-              delete queues[key];
-              for (var i = 0, l = q.length; i < l; i++) {
-                q[i].apply(null, args2);
-              }
-            }));
-          }
-        });
-        memoized.memo = memo;
-        memoized.unmemoized = fn;
-        return memoized;
-      }
-      var _defer$1;
-      if (hasNextTick) {
-        _defer$1 = process.nextTick;
-      } else if (hasSetImmediate) {
-        _defer$1 = setImmediate;
-      } else {
-        _defer$1 = fallback;
-      }
-      var nextTick = wrap2(_defer$1);
-      function _parallel(eachfn, tasks, callback) {
-        callback = callback || noop;
-        var results = isArrayLike2(tasks) ? [] : {};
-        eachfn(tasks, function(task, key, callback2) {
-          wrapAsync(task)(function(err, result) {
-            if (arguments.length > 2) {
-              result = slice2(arguments, 1);
-            }
-            results[key] = result;
-            callback2(err);
-          });
-        }, function(err) {
-          callback(err, results);
-        });
-      }
-      function parallelLimit(tasks, callback) {
-        _parallel(eachOf, tasks, callback);
-      }
-      function parallelLimit$1(tasks, limit, callback) {
-        _parallel(_eachOfLimit(limit), tasks, callback);
-      }
-      var queue$1 = function(worker, concurrency) {
-        var _worker = wrapAsync(worker);
-        return queue(function(items, cb) {
-          _worker(items[0], cb);
-        }, concurrency, 1);
-      };
-      var priorityQueue = function(worker, concurrency) {
-        var q = queue$1(worker, concurrency);
-        q.push = function(data2, priority, callback) {
-          if (callback == null) callback = noop;
-          if (typeof callback !== "function") {
-            throw new Error("task callback must be a function");
-          }
-          q.started = true;
-          if (!isArray(data2)) {
-            data2 = [data2];
-          }
-          if (data2.length === 0) {
-            return setImmediate$1(function() {
-              q.drain();
-            });
-          }
-          priority = priority || 0;
-          var nextNode = q._tasks.head;
-          while (nextNode && priority >= nextNode.priority) {
-            nextNode = nextNode.next;
-          }
-          for (var i = 0, l = data2.length; i < l; i++) {
-            var item = {
-              data: data2[i],
-              priority,
-              callback
-            };
-            if (nextNode) {
-              q._tasks.insertBefore(nextNode, item);
-            } else {
-              q._tasks.push(item);
-            }
-          }
-          setImmediate$1(q.process);
-        };
-        delete q.unshift;
-        return q;
-      };
-      function race(tasks, callback) {
-        callback = once(callback || noop);
-        if (!isArray(tasks)) return callback(new TypeError("First argument to race must be an array of functions"));
-        if (!tasks.length) return callback();
-        for (var i = 0, l = tasks.length; i < l; i++) {
-          wrapAsync(tasks[i])(callback);
-        }
-      }
-      function reduceRight(array, memo, iteratee, callback) {
-        var reversed = slice2(array).reverse();
-        reduce(reversed, memo, iteratee, callback);
-      }
-      function reflect(fn) {
-        var _fn = wrapAsync(fn);
-        return initialParams(function reflectOn(args, reflectCallback) {
-          args.push(function callback(error, cbArg) {
-            if (error) {
-              reflectCallback(null, { error });
-            } else {
-              var value;
-              if (arguments.length <= 2) {
-                value = cbArg;
-              } else {
-                value = slice2(arguments, 1);
-              }
-              reflectCallback(null, { value });
-            }
-          });
-          return _fn.apply(this, args);
-        });
-      }
-      function reflectAll(tasks) {
-        var results;
-        if (isArray(tasks)) {
-          results = arrayMap(tasks, reflect);
-        } else {
-          results = {};
-          baseForOwn(tasks, function(task, key) {
-            results[key] = reflect.call(this, task);
-          });
-        }
-        return results;
-      }
-      function reject$1(eachfn, arr, iteratee, callback) {
-        _filter(eachfn, arr, function(value, cb) {
-          iteratee(value, function(err, v) {
-            cb(err, !v);
-          });
-        }, callback);
-      }
-      var reject = doParallel(reject$1);
-      var rejectLimit = doParallelLimit(reject$1);
-      var rejectSeries = doLimit(rejectLimit, 1);
-      function constant$1(value) {
-        return function() {
-          return value;
-        };
-      }
-      function retry(opts, task, callback) {
-        var DEFAULT_TIMES = 5;
-        var DEFAULT_INTERVAL = 0;
-        var options = {
-          times: DEFAULT_TIMES,
-          intervalFunc: constant$1(DEFAULT_INTERVAL)
-        };
-        function parseTimes(acc, t) {
-          if (typeof t === "object") {
-            acc.times = +t.times || DEFAULT_TIMES;
-            acc.intervalFunc = typeof t.interval === "function" ? t.interval : constant$1(+t.interval || DEFAULT_INTERVAL);
-            acc.errorFilter = t.errorFilter;
-          } else if (typeof t === "number" || typeof t === "string") {
-            acc.times = +t || DEFAULT_TIMES;
-          } else {
-            throw new Error("Invalid arguments for async.retry");
-          }
-        }
-        if (arguments.length < 3 && typeof opts === "function") {
-          callback = task || noop;
-          task = opts;
-        } else {
-          parseTimes(options, opts);
-          callback = callback || noop;
-        }
-        if (typeof task !== "function") {
-          throw new Error("Invalid arguments for async.retry");
-        }
-        var _task = wrapAsync(task);
-        var attempt = 1;
-        function retryAttempt() {
-          _task(function(err) {
-            if (err && attempt++ < options.times && (typeof options.errorFilter != "function" || options.errorFilter(err))) {
-              setTimeout(retryAttempt, options.intervalFunc(attempt));
-            } else {
-              callback.apply(null, arguments);
-            }
-          });
-        }
-        retryAttempt();
-      }
-      var retryable = function(opts, task) {
-        if (!task) {
-          task = opts;
-          opts = null;
-        }
-        var _task = wrapAsync(task);
-        return initialParams(function(args, callback) {
-          function taskFn(cb) {
-            _task.apply(null, args.concat(cb));
-          }
-          if (opts) retry(opts, taskFn, callback);
-          else retry(taskFn, callback);
-        });
-      };
-      function series(tasks, callback) {
-        _parallel(eachOfSeries, tasks, callback);
-      }
-      var some2 = doParallel(_createTester(Boolean, identity));
-      var someLimit = doParallelLimit(_createTester(Boolean, identity));
-      var someSeries = doLimit(someLimit, 1);
-      function sortBy(coll, iteratee, callback) {
-        var _iteratee = wrapAsync(iteratee);
-        map2(coll, function(x, callback2) {
-          _iteratee(x, function(err, criteria) {
-            if (err) return callback2(err);
-            callback2(null, { value: x, criteria });
-          });
-        }, function(err, results) {
-          if (err) return callback(err);
-          callback(null, arrayMap(results.sort(comparator), baseProperty("value")));
-        });
-        function comparator(left, right) {
-          var a = left.criteria, b = right.criteria;
-          return a < b ? -1 : a > b ? 1 : 0;
-        }
-      }
-      function timeout(asyncFn, milliseconds, info) {
-        var fn = wrapAsync(asyncFn);
-        return initialParams(function(args, callback) {
-          var timedOut = false;
-          var timer;
-          function timeoutCallback() {
-            var name = asyncFn.name || "anonymous";
-            var error = new Error('Callback function "' + name + '" timed out.');
-            error.code = "ETIMEDOUT";
-            if (info) {
-              error.info = info;
-            }
-            timedOut = true;
-            callback(error);
-          }
-          args.push(function() {
-            if (!timedOut) {
-              callback.apply(null, arguments);
-              clearTimeout(timer);
-            }
-          });
-          timer = setTimeout(timeoutCallback, milliseconds);
-          fn.apply(null, args);
-        });
-      }
-      var nativeCeil = Math.ceil;
-      var nativeMax = Math.max;
-      function baseRange(start, end2, step, fromRight) {
-        var index3 = -1, length = nativeMax(nativeCeil((end2 - start) / (step || 1)), 0), result = Array(length);
-        while (length--) {
-          result[fromRight ? length : ++index3] = start;
-          start += step;
-        }
-        return result;
-      }
-      function timeLimit(count, limit, iteratee, callback) {
-        var _iteratee = wrapAsync(iteratee);
-        mapLimit(baseRange(0, count, 1), limit, _iteratee, callback);
-      }
-      var times = doLimit(timeLimit, Infinity);
-      var timesSeries = doLimit(timeLimit, 1);
-      function transform(coll, accumulator, iteratee, callback) {
-        if (arguments.length <= 3) {
-          callback = iteratee;
-          iteratee = accumulator;
-          accumulator = isArray(coll) ? [] : {};
-        }
-        callback = once(callback || noop);
-        var _iteratee = wrapAsync(iteratee);
-        eachOf(coll, function(v, k, cb) {
-          _iteratee(accumulator, v, k, cb);
-        }, function(err) {
-          callback(err, accumulator);
-        });
-      }
-      function tryEach(tasks, callback) {
-        var error = null;
-        var result;
-        callback = callback || noop;
-        eachSeries(tasks, function(task, callback2) {
-          wrapAsync(task)(function(err, res) {
-            if (arguments.length > 2) {
-              result = slice2(arguments, 1);
-            } else {
-              result = res;
-            }
-            error = err;
-            callback2(!err);
-          });
-        }, function() {
-          callback(error, result);
-        });
-      }
-      function unmemoize(fn) {
-        return function() {
-          return (fn.unmemoized || fn).apply(null, arguments);
-        };
-      }
-      function whilst(test, iteratee, callback) {
-        callback = onlyOnce(callback || noop);
-        var _iteratee = wrapAsync(iteratee);
-        if (!test()) return callback(null);
-        var next2 = function(err) {
-          if (err) return callback(err);
-          if (test()) return _iteratee(next2);
-          var args = slice2(arguments, 1);
-          callback.apply(null, [null].concat(args));
-        };
-        _iteratee(next2);
-      }
-      function until(test, iteratee, callback) {
-        whilst(function() {
-          return !test.apply(this, arguments);
-        }, iteratee, callback);
-      }
-      var waterfall = function(tasks, callback) {
-        callback = once(callback || noop);
-        if (!isArray(tasks)) return callback(new Error("First argument to waterfall must be an array of functions"));
-        if (!tasks.length) return callback();
-        var taskIndex = 0;
-        function nextTask(args) {
-          var task = wrapAsync(tasks[taskIndex++]);
-          args.push(onlyOnce(next2));
-          task.apply(null, args);
-        }
-        function next2(err) {
-          if (err || taskIndex === tasks.length) {
-            return callback.apply(null, arguments);
-          }
-          nextTask(slice2(arguments, 1));
-        }
-        nextTask([]);
-      };
-      var index2 = {
-        apply,
-        applyEach,
-        applyEachSeries,
-        asyncify,
-        auto,
-        autoInject,
-        cargo,
-        compose,
-        concat,
-        concatLimit,
-        concatSeries,
-        constant,
-        detect,
-        detectLimit,
-        detectSeries,
-        dir,
-        doDuring,
-        doUntil,
-        doWhilst,
-        during,
-        each: eachLimit,
-        eachLimit: eachLimit$1,
-        eachOf,
-        eachOfLimit,
-        eachOfSeries,
-        eachSeries,
-        ensureAsync,
-        every,
-        everyLimit,
-        everySeries,
-        filter: filter4,
-        filterLimit,
-        filterSeries,
-        forever,
-        groupBy,
-        groupByLimit,
-        groupBySeries,
-        log,
-        map: map2,
-        mapLimit,
-        mapSeries,
-        mapValues,
-        mapValuesLimit,
-        mapValuesSeries,
-        memoize,
-        nextTick,
-        parallel: parallelLimit,
-        parallelLimit: parallelLimit$1,
-        priorityQueue,
-        queue: queue$1,
-        race,
-        reduce,
-        reduceRight,
-        reflect,
-        reflectAll,
-        reject,
-        rejectLimit,
-        rejectSeries,
-        retry,
-        retryable,
-        seq,
-        series,
-        setImmediate: setImmediate$1,
-        some: some2,
-        someLimit,
-        someSeries,
-        sortBy,
-        timeout,
-        times,
-        timesLimit: timeLimit,
-        timesSeries,
-        transform,
-        tryEach,
-        unmemoize,
-        until,
-        waterfall,
-        whilst,
-        // aliases
-        all: every,
-        allLimit: everyLimit,
-        allSeries: everySeries,
-        any: some2,
-        anyLimit: someLimit,
-        anySeries: someSeries,
-        find: detect,
-        findLimit: detectLimit,
-        findSeries: detectSeries,
-        forEach: eachLimit,
-        forEachSeries: eachSeries,
-        forEachLimit: eachLimit$1,
-        forEachOf: eachOf,
-        forEachOfSeries: eachOfSeries,
-        forEachOfLimit: eachOfLimit,
-        inject: reduce,
-        foldl: reduce,
-        foldr: reduceRight,
-        select: filter4,
-        selectLimit: filterLimit,
-        selectSeries: filterSeries,
-        wrapSync: asyncify
-      };
-      exports3["default"] = index2;
-      exports3.apply = apply;
-      exports3.applyEach = applyEach;
-      exports3.applyEachSeries = applyEachSeries;
-      exports3.asyncify = asyncify;
-      exports3.auto = auto;
-      exports3.autoInject = autoInject;
-      exports3.cargo = cargo;
-      exports3.compose = compose;
-      exports3.concat = concat;
-      exports3.concatLimit = concatLimit;
-      exports3.concatSeries = concatSeries;
-      exports3.constant = constant;
-      exports3.detect = detect;
-      exports3.detectLimit = detectLimit;
-      exports3.detectSeries = detectSeries;
-      exports3.dir = dir;
-      exports3.doDuring = doDuring;
-      exports3.doUntil = doUntil;
-      exports3.doWhilst = doWhilst;
-      exports3.during = during;
-      exports3.each = eachLimit;
-      exports3.eachLimit = eachLimit$1;
-      exports3.eachOf = eachOf;
-      exports3.eachOfLimit = eachOfLimit;
-      exports3.eachOfSeries = eachOfSeries;
-      exports3.eachSeries = eachSeries;
-      exports3.ensureAsync = ensureAsync;
-      exports3.every = every;
-      exports3.everyLimit = everyLimit;
-      exports3.everySeries = everySeries;
-      exports3.filter = filter4;
-      exports3.filterLimit = filterLimit;
-      exports3.filterSeries = filterSeries;
-      exports3.forever = forever;
-      exports3.groupBy = groupBy;
-      exports3.groupByLimit = groupByLimit;
-      exports3.groupBySeries = groupBySeries;
-      exports3.log = log;
-      exports3.map = map2;
-      exports3.mapLimit = mapLimit;
-      exports3.mapSeries = mapSeries;
-      exports3.mapValues = mapValues;
-      exports3.mapValuesLimit = mapValuesLimit;
-      exports3.mapValuesSeries = mapValuesSeries;
-      exports3.memoize = memoize;
-      exports3.nextTick = nextTick;
-      exports3.parallel = parallelLimit;
-      exports3.parallelLimit = parallelLimit$1;
-      exports3.priorityQueue = priorityQueue;
-      exports3.queue = queue$1;
-      exports3.race = race;
-      exports3.reduce = reduce;
-      exports3.reduceRight = reduceRight;
-      exports3.reflect = reflect;
-      exports3.reflectAll = reflectAll;
-      exports3.reject = reject;
-      exports3.rejectLimit = rejectLimit;
-      exports3.rejectSeries = rejectSeries;
-      exports3.retry = retry;
-      exports3.retryable = retryable;
-      exports3.seq = seq;
-      exports3.series = series;
-      exports3.setImmediate = setImmediate$1;
-      exports3.some = some2;
-      exports3.someLimit = someLimit;
-      exports3.someSeries = someSeries;
-      exports3.sortBy = sortBy;
-      exports3.timeout = timeout;
-      exports3.times = times;
-      exports3.timesLimit = timeLimit;
-      exports3.timesSeries = timesSeries;
-      exports3.transform = transform;
-      exports3.tryEach = tryEach;
-      exports3.unmemoize = unmemoize;
-      exports3.until = until;
-      exports3.waterfall = waterfall;
-      exports3.whilst = whilst;
-      exports3.all = every;
-      exports3.allLimit = everyLimit;
-      exports3.allSeries = everySeries;
-      exports3.any = some2;
-      exports3.anyLimit = someLimit;
-      exports3.anySeries = someSeries;
-      exports3.find = detect;
-      exports3.findLimit = detectLimit;
-      exports3.findSeries = detectSeries;
-      exports3.forEach = eachLimit;
-      exports3.forEachSeries = eachSeries;
-      exports3.forEachLimit = eachLimit$1;
-      exports3.forEachOf = eachOf;
-      exports3.forEachOfSeries = eachOfSeries;
-      exports3.forEachOfLimit = eachOfLimit;
-      exports3.inject = reduce;
-      exports3.foldl = reduce;
-      exports3.foldr = reduceRight;
-      exports3.select = filter4;
-      exports3.selectLimit = filterLimit;
-      exports3.selectSeries = filterSeries;
-      exports3.wrapSync = asyncify;
-      Object.defineProperty(exports3, "__esModule", { value: true });
-    });
-  }
-});
-
-// ../../node_modules/geoip-lite/lib/geoip.js
-var require_geoip = __commonJS({
-  "../../node_modules/geoip-lite/lib/geoip.js"(exports2, module2) {
-    var fs3 = require("fs");
-    var net = require("net");
-    var path = require("path");
-    fs3.existsSync = fs3.existsSync || path.existsSync;
-    var utils = require_utils3();
-    var fsWatcher = require_fsWatcher();
-    var async = require_async();
-    var watcherName = "dataWatcher";
-    var geodatadir = path.resolve(
-      __dirname,
-      global.geodatadir || process.env.GEODATADIR || "../data/"
-    );
-    var dataFiles = {
-      city: path.join(geodatadir, "geoip-city.dat"),
-      city6: path.join(geodatadir, "geoip-city6.dat"),
-      cityNames: path.join(geodatadir, "geoip-city-names.dat"),
-      country: path.join(geodatadir, "geoip-country.dat"),
-      country6: path.join(geodatadir, "geoip-country6.dat")
-    };
-    var privateRange4 = [
-      [utils.aton4("10.0.0.0"), utils.aton4("10.255.255.255")],
-      [utils.aton4("172.16.0.0"), utils.aton4("172.31.255.255")],
-      [utils.aton4("192.168.0.0"), utils.aton4("192.168.255.255")]
-    ];
-    var conf4 = {
-      firstIP: null,
-      lastIP: null,
-      lastLine: 0,
-      locationBuffer: null,
-      locationRecordSize: 88,
-      mainBuffer: null,
-      recordSize: 24
-    };
-    var conf6 = {
-      firstIP: null,
-      lastIP: null,
-      lastLine: 0,
-      mainBuffer: null,
-      recordSize: 48
-    };
-    var cache4 = JSON.parse(JSON.stringify(conf4));
-    var cache6 = JSON.parse(JSON.stringify(conf6));
-    var RECORD_SIZE = 10;
-    var RECORD_SIZE6 = 34;
-    function lookup4(ip) {
-      var fline = 0;
-      var floor = cache4.lastIP;
-      var cline = cache4.lastLine;
-      var ceil = cache4.firstIP;
-      var line;
-      var locId;
-      var buffer = cache4.mainBuffer;
-      var locBuffer = cache4.locationBuffer;
-      var privateRange = privateRange4;
-      var recordSize = cache4.recordSize;
-      var locRecordSize = cache4.locationRecordSize;
-      var i;
-      var geodata = {
-        range: "",
-        country: "",
-        region: "",
-        eu: "",
-        timezone: "",
-        city: "",
-        ll: [null, null]
-      };
-      if (ip > cache4.lastIP || ip < cache4.firstIP) {
-        return null;
-      }
-      for (i = 0; i < privateRange.length; i++) {
-        if (ip >= privateRange[i][0] && ip <= privateRange[i][1]) {
-          return null;
-        }
-      }
-      do {
-        line = Math.round((cline - fline) / 2) + fline;
-        floor = buffer.readUInt32BE(line * recordSize);
-        ceil = buffer.readUInt32BE(line * recordSize + 4);
-        if (floor <= ip && ceil >= ip) {
-          geodata.range = [floor, ceil];
-          if (recordSize === RECORD_SIZE) {
-            geodata.country = buffer.toString("utf8", line * recordSize + 8, line * recordSize + 10);
-          } else {
-            locId = buffer.readUInt32BE(line * recordSize + 8);
-            if (-1 >>> 0 > locId) {
-              geodata.country = locBuffer.toString("utf8", locId * locRecordSize + 0, locId * locRecordSize + 2).replace(/\u0000.*/, "");
-              geodata.region = locBuffer.toString("utf8", locId * locRecordSize + 2, locId * locRecordSize + 5).replace(/\u0000.*/, "");
-              geodata.metro = locBuffer.readInt32BE(locId * locRecordSize + 5);
-              geodata.ll[0] = buffer.readInt32BE(line * recordSize + 12) / 1e4;
-              geodata.ll[1] = buffer.readInt32BE(line * recordSize + 16) / 1e4;
-              geodata.area = buffer.readUInt32BE(line * recordSize + 20);
-              geodata.eu = locBuffer.toString("utf8", locId * locRecordSize + 9, locId * locRecordSize + 10).replace(/\u0000.*/, "");
-              geodata.timezone = locBuffer.toString("utf8", locId * locRecordSize + 10, locId * locRecordSize + 42).replace(/\u0000.*/, "");
-              geodata.city = locBuffer.toString("utf8", locId * locRecordSize + 42, locId * locRecordSize + locRecordSize).replace(/\u0000.*/, "");
-            }
-          }
-          return geodata;
-        } else if (fline === cline) {
-          return null;
-        } else if (fline === cline - 1) {
-          if (line === fline) {
-            fline = cline;
-          } else {
-            cline = fline;
-          }
-        } else if (floor > ip) {
-          cline = line;
-        } else if (ceil < ip) {
-          fline = line;
-        }
-      } while (1);
-    }
-    function lookup6(ip) {
-      var buffer = cache6.mainBuffer;
-      var recordSize = cache6.recordSize;
-      var locBuffer = cache4.locationBuffer;
-      var locRecordSize = cache4.locationRecordSize;
-      var geodata = {
-        range: "",
-        country: "",
-        region: "",
-        city: "",
-        ll: [0, 0]
-      };
-      function readip(line2, offset) {
-        var ii = 0;
-        var ip2 = [];
-        for (ii = 0; ii < 2; ii++) {
-          ip2.push(buffer.readUInt32BE(line2 * recordSize + offset * 16 + ii * 4));
-        }
-        return ip2;
-      }
-      cache6.lastIP = readip(cache6.lastLine, 1);
-      cache6.firstIP = readip(0, 0);
-      var fline = 0;
-      var floor = cache6.lastIP;
-      var cline = cache6.lastLine;
-      var ceil = cache6.firstIP;
-      var line;
-      var locId;
-      if (utils.cmp6(ip, cache6.lastIP) > 0 || utils.cmp6(ip, cache6.firstIP) < 0) {
-        return null;
-      }
-      do {
-        line = Math.round((cline - fline) / 2) + fline;
-        floor = readip(line, 0);
-        ceil = readip(line, 1);
-        if (utils.cmp6(floor, ip) <= 0 && utils.cmp6(ceil, ip) >= 0) {
-          if (recordSize === RECORD_SIZE6) {
-            geodata.country = buffer.toString("utf8", line * recordSize + 32, line * recordSize + 34).replace(/\u0000.*/, "");
-          } else {
-            locId = buffer.readUInt32BE(line * recordSize + 32);
-            if (-1 >>> 0 > locId) {
-              geodata.country = locBuffer.toString("utf8", locId * locRecordSize + 0, locId * locRecordSize + 2).replace(/\u0000.*/, "");
-              geodata.region = locBuffer.toString("utf8", locId * locRecordSize + 2, locId * locRecordSize + 5).replace(/\u0000.*/, "");
-              geodata.metro = locBuffer.readInt32BE(locId * locRecordSize + 5);
-              geodata.ll[0] = buffer.readInt32BE(line * recordSize + 36) / 1e4;
-              geodata.ll[1] = buffer.readInt32BE(line * recordSize + 40) / 1e4;
-              geodata.area = buffer.readUInt32BE(line * recordSize + 44);
-              geodata.eu = locBuffer.toString("utf8", locId * locRecordSize + 9, locId * locRecordSize + 10).replace(/\u0000.*/, "");
-              geodata.timezone = locBuffer.toString("utf8", locId * locRecordSize + 10, locId * locRecordSize + 42).replace(/\u0000.*/, "");
-              geodata.city = locBuffer.toString("utf8", locId * locRecordSize + 42, locId * locRecordSize + locRecordSize).replace(/\u0000.*/, "");
-            }
-          }
-          return geodata;
-        } else if (fline === cline) {
-          return null;
-        } else if (fline === cline - 1) {
-          if (line === fline) {
-            fline = cline;
-          } else {
-            cline = fline;
-          }
-        } else if (utils.cmp6(floor, ip) > 0) {
-          cline = line;
-        } else if (utils.cmp6(ceil, ip) < 0) {
-          fline = line;
-        }
-      } while (1);
-    }
-    function get4mapped(ip) {
-      var ipv6 = ip.toUpperCase();
-      var v6prefixes = ["0:0:0:0:0:FFFF:", "::FFFF:"];
-      for (var i = 0; i < v6prefixes.length; i++) {
-        var v6prefix = v6prefixes[i];
-        if (ipv6.indexOf(v6prefix) == 0) {
-          return ipv6.substring(v6prefix.length);
-        }
-      }
-      return null;
-    }
-    function preload(callback) {
-      var datFile;
-      var datSize;
-      var asyncCache = JSON.parse(JSON.stringify(conf4));
-      if (typeof arguments[0] === "function") {
-        async.series([
-          function(cb) {
-            async.series([
-              function(cb2) {
-                fs3.open(dataFiles.cityNames, "r", function(err, file) {
-                  datFile = file;
-                  cb2(err);
-                });
-              },
-              function(cb2) {
-                fs3.fstat(datFile, function(err, stats) {
-                  datSize = stats.size;
-                  asyncCache.locationBuffer = Buffer.alloc(datSize);
-                  cb2(err);
-                });
-              },
-              function(cb2) {
-                fs3.read(datFile, asyncCache.locationBuffer, 0, datSize, 0, cb2);
-              },
-              function(cb2) {
-                fs3.close(datFile, cb2);
-              },
-              function(cb2) {
-                fs3.open(dataFiles.city, "r", function(err, file) {
-                  datFile = file;
-                  cb2(err);
-                });
-              },
-              function(cb2) {
-                fs3.fstat(datFile, function(err, stats) {
-                  datSize = stats.size;
-                  cb2(err);
-                });
-              }
-            ], function(err) {
-              if (err) {
-                if (err.code !== "ENOENT" && err.code !== "EBADF") {
-                  throw err;
-                }
-                fs3.open(dataFiles.country, "r", function(err2, file) {
-                  if (err2) {
-                    cb(err2);
-                  } else {
-                    datFile = file;
-                    fs3.fstat(datFile, function(err3, stats) {
-                      datSize = stats.size;
-                      asyncCache.recordSize = RECORD_SIZE;
-                      cb();
-                    });
-                  }
-                });
-              } else {
-                cb();
-              }
-            });
-          },
-          function() {
-            asyncCache.mainBuffer = Buffer.alloc(datSize);
-            async.series([
-              function(cb2) {
-                fs3.read(datFile, asyncCache.mainBuffer, 0, datSize, 0, cb2);
-              },
-              function(cb2) {
-                fs3.close(datFile, cb2);
-              }
-            ], function(err) {
-              if (err) {
-              } else {
-                asyncCache.lastLine = datSize / asyncCache.recordSize - 1;
-                asyncCache.lastIP = asyncCache.mainBuffer.readUInt32BE(asyncCache.lastLine * asyncCache.recordSize + 4);
-                asyncCache.firstIP = asyncCache.mainBuffer.readUInt32BE(0);
-                cache4 = asyncCache;
-              }
-              callback(err);
-            });
-          }
-        ]);
-      } else {
-        try {
-          datFile = fs3.openSync(dataFiles.cityNames, "r");
-          datSize = fs3.fstatSync(datFile).size;
-          if (datSize === 0) {
-            throw {
-              code: "EMPTY_FILE"
-            };
-          }
-          cache4.locationBuffer = Buffer.alloc(datSize);
-          fs3.readSync(datFile, cache4.locationBuffer, 0, datSize, 0);
-          fs3.closeSync(datFile);
-          datFile = fs3.openSync(dataFiles.city, "r");
-          datSize = fs3.fstatSync(datFile).size;
-        } catch (err) {
-          if (err.code !== "ENOENT" && err.code !== "EBADF" && err.code !== "EMPTY_FILE") {
-            throw err;
-          }
-          datFile = fs3.openSync(dataFiles.country, "r");
-          datSize = fs3.fstatSync(datFile).size;
-          cache4.recordSize = RECORD_SIZE;
-        }
-        cache4.mainBuffer = Buffer.alloc(datSize);
-        fs3.readSync(datFile, cache4.mainBuffer, 0, datSize, 0);
-        fs3.closeSync(datFile);
-        cache4.lastLine = datSize / cache4.recordSize - 1;
-        cache4.lastIP = cache4.mainBuffer.readUInt32BE(cache4.lastLine * cache4.recordSize + 4);
-        cache4.firstIP = cache4.mainBuffer.readUInt32BE(0);
-      }
-    }
-    function preload6(callback) {
-      var datFile;
-      var datSize;
-      var asyncCache6 = JSON.parse(JSON.stringify(conf6));
-      if (typeof arguments[0] === "function") {
-        async.series([
-          function(cb) {
-            async.series([
-              function(cb2) {
-                fs3.open(dataFiles.city6, "r", function(err, file) {
-                  datFile = file;
-                  cb2(err);
-                });
-              },
-              function(cb2) {
-                fs3.fstat(datFile, function(err, stats) {
-                  datSize = stats.size;
-                  cb2(err);
-                });
-              }
-            ], function(err) {
-              if (err) {
-                if (err.code !== "ENOENT" && err.code !== "EBADF") {
-                  throw err;
-                }
-                fs3.open(dataFiles.country6, "r", function(err2, file) {
-                  if (err2) {
-                    cb(err2);
-                  } else {
-                    datFile = file;
-                    fs3.fstat(datFile, function(err3, stats) {
-                      datSize = stats.size;
-                      asyncCache6.recordSize = RECORD_SIZE6;
-                      cb();
-                    });
-                  }
-                });
-              } else {
-                cb();
-              }
-            });
-          },
-          function() {
-            asyncCache6.mainBuffer = Buffer.alloc(datSize);
-            async.series([
-              function(cb2) {
-                fs3.read(datFile, asyncCache6.mainBuffer, 0, datSize, 0, cb2);
-              },
-              function(cb2) {
-                fs3.close(datFile, cb2);
-              }
-            ], function(err) {
-              if (err) {
-              } else {
-                asyncCache6.lastLine = datSize / asyncCache6.recordSize - 1;
-                cache6 = asyncCache6;
-              }
-              callback(err);
-            });
-          }
-        ]);
-      } else {
-        try {
-          datFile = fs3.openSync(dataFiles.city6, "r");
-          datSize = fs3.fstatSync(datFile).size;
-          if (datSize === 0) {
-            throw {
-              code: "EMPTY_FILE"
-            };
-          }
-        } catch (err) {
-          if (err.code !== "ENOENT" && err.code !== "EBADF" && err.code !== "EMPTY_FILE") {
-            throw err;
-          }
-          datFile = fs3.openSync(dataFiles.country6, "r");
-          datSize = fs3.fstatSync(datFile).size;
-          cache6.recordSize = RECORD_SIZE6;
-        }
-        cache6.mainBuffer = Buffer.alloc(datSize);
-        fs3.readSync(datFile, cache6.mainBuffer, 0, datSize, 0);
-        fs3.closeSync(datFile);
-        cache6.lastLine = datSize / cache6.recordSize - 1;
-      }
-    }
-    module2.exports = {
-      cmp: utils.cmp,
-      lookup: function(ip) {
-        if (!ip) {
-          return null;
-        } else if (typeof ip === "number") {
-          return lookup4(ip);
-        } else if (net.isIP(ip) === 4) {
-          return lookup4(utils.aton4(ip));
-        } else if (net.isIP(ip) === 6) {
-          var ipv4 = get4mapped(ip);
-          if (ipv4) {
-            return lookup4(utils.aton4(ipv4));
-          } else {
-            return lookup6(utils.aton6(ip));
-          }
-        }
-        return null;
-      },
-      pretty: function(n) {
-        if (typeof n === "string") {
-          return n;
-        } else if (typeof n === "number") {
-          return utils.ntoa4(n);
-        } else if (n instanceof Array) {
-          return utils.ntoa6(n);
-        }
-        return n;
-      },
-      // Start watching for data updates. The watcher waits one minute for file transfer to 
-      // completete before triggering the callback.
-      startWatchingDataUpdate: function(callback) {
-        fsWatcher.makeFsWatchFilter(watcherName, geodatadir, 60 * 1e3, function() {
-          async.series([
-            function(cb) {
-              preload(cb);
-            },
-            function(cb) {
-              preload6(cb);
-            }
-          ], callback);
-        });
-      },
-      // Stop watching for data updates.
-      stopWatchingDataUpdate: function() {
-        fsWatcher.stopWatching(watcherName);
-      },
-      //clear data
-      clear: function() {
-        cache4 = JSON.parse(JSON.stringify(conf4));
-        cache6 = JSON.parse(JSON.stringify(conf6));
-      },
-      // Reload data synchronously
-      reloadDataSync: function() {
-        preload();
-        preload6();
-      },
-      // Reload data asynchronously
-      reloadData: function(callback) {
-        async.series([
-          function(cb) {
-            preload(cb);
-          },
-          function(cb) {
-            preload6(cb);
-          }
-        ], callback);
-      }
-    };
-    preload();
-    preload6();
-  }
-});
-
 // ../../src/lib/scanner/geo-ip-check.ts
 var geo_ip_check_exports = {};
 __export(geo_ip_check_exports, {
@@ -56986,7 +54502,7 @@ function classifyRegion(countryCode, serviceName) {
 async function checkServerLocations(networkRequests) {
   let geoLookup;
   try {
-    const geoip = await Promise.resolve().then(() => __toESM(require_geoip()));
+    const geoip = await import("geoip-lite");
     geoLookup = geoip.default?.lookup || geoip.lookup;
   } catch {
     console.error("[GeoIP] geoip-lite not available, skipping location checks");
@@ -60641,7 +58157,7 @@ var init_scanner = __esm({
 var readline = __toESM(require("readline"));
 
 // package.json
-var version = "2.3.1";
+var version = "2.3.3";
 
 // src/cli.ts
 var PKG_VERSION = version;