@prosopo/cli 3.5.19 → 3.6.32

package/dist/bundle/index-DUVLsNmB.js

@@ -0,0 +1,2371 @@
+import Re from "assert";
+import Ct from "net";
+import Xt from "fs";
+import de from "util";
+import Yt from "stream";
+import Qt from "https";
+function er(o, g) {
+  for (var m = 0; m < g.length; m++) {
+    const u = g[m];
+    if (typeof u != "string" && !Array.isArray(u)) {
+      for (const l in u)
+        if (l !== "default" && !(l in o)) {
+          const p = Object.getOwnPropertyDescriptor(u, l);
+          p && Object.defineProperty(o, l, p.get ? p : {
+            enumerable: !0,
+            get: () => u[l]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(o, Symbol.toStringTag, { value: "Module" }));
+}
+var G = {}, Q = {}, J = {}, K = {}, ee = {}, _e = {}, ze;
+function Pt() {
+  if (ze) return _e;
+  ze = 1, Object.defineProperty(_e, "__esModule", { value: !0 });
+  const o = `Maxmind v2 module has changed API.
+Upgrade instructions can be found here: https://github.com/runk/node-maxmind/wiki/Migration-guide
+If you want to use legacy library then explicitly install maxmind@1`, g = (m, u) => {
+    if (!m)
+      throw new Error(u);
+  };
+  return _e.default = {
+    assert: g,
+    legacyErrorMessage: o
+  }, _e;
+}
+var Ve;
+function St() {
+  if (Ve) return ee;
+  Ve = 1;
+  var o = ee && ee.__importDefault || function(s) {
+    return s && s.__esModule ? s : { default: s };
+  };
+  Object.defineProperty(ee, "__esModule", { value: !0 });
+  const g = o(/* @__PURE__ */ Pt());
+  g.default.assert(typeof BigInt < "u", "Apparently you are using old version of node. Please upgrade to node 10.4.x or above.");
+  var m;
+  (function(s) {
+    s[s.Extended = 0] = "Extended", s[s.Pointer = 1] = "Pointer", s[s.Utf8String = 2] = "Utf8String", s[s.Double = 3] = "Double", s[s.Bytes = 4] = "Bytes", s[s.Uint16 = 5] = "Uint16", s[s.Uint32 = 6] = "Uint32", s[s.Map = 7] = "Map", s[s.Int32 = 8] = "Int32", s[s.Uint64 = 9] = "Uint64", s[s.Uint128 = 10] = "Uint128", s[s.Array = 11] = "Array", s[s.Container = 12] = "Container", s[s.EndMarker = 13] = "EndMarker", s[s.Boolean = 14] = "Boolean", s[s.Float = 15] = "Float";
+  })(m || (m = {}));
+  const u = [0, 2048, 526336, 0], l = {
+    get: () => {
+    },
+    set: () => {
+    }
+  }, p = (s, n) => ({ value: s, offset: n });
+  class h {
+    constructor(n, t = 0, e = l) {
+      this.telemetry = {}, g.default.assert(!!n, "Database buffer is required"), this.db = n, this.baseOffset = t, this.cache = e;
+    }
+    decode(n) {
+      let t;
+      const e = this.db[n++];
+      let r = e >> 5;
+      if (r === m.Pointer)
+        return t = this.decodePointer(e, n), p(this.decodeFast(t.value).value, t.offset);
+      if (r === m.Extended) {
+        if (t = this.db[n] + 7, t < 8)
+          throw new Error("Invalid Extended Type at offset " + n + " val " + t);
+        r = t, n++;
+      }
+      const i = this.sizeFromCtrlByte(e, n);
+      return this.decodeByType(r, i.offset, i.value);
+    }
+    decodeFast(n) {
+      const t = this.cache.get(n);
+      if (t)
+        return t;
+      const e = this.decode(n);
+      return this.cache.set(n, e), e;
+    }
+    decodeByType(n, t, e) {
+      const r = t + e;
+      switch (n) {
+        case m.Utf8String:
+          return p(this.decodeString(t, e), r);
+        case m.Map:
+          return this.decodeMap(e, t);
+        case m.Uint32:
+          return p(this.decodeUint(t, e), r);
+        case m.Double:
+          return p(this.decodeDouble(t), r);
+        case m.Array:
+          return this.decodeArray(e, t);
+        case m.Boolean:
+          return p(this.decodeBoolean(e), t);
+        case m.Float:
+          return p(this.decodeFloat(t), r);
+        case m.Bytes:
+          return p(this.decodeBytes(t, e), r);
+        case m.Uint16:
+          return p(this.decodeUint(t, e), r);
+        case m.Int32:
+          return p(this.decodeInt32(t, e), r);
+        case m.Uint64:
+          return p(this.decodeUint(t, e), r);
+        case m.Uint128:
+          return p(this.decodeUint(t, e), r);
+      }
+      throw new Error("Unknown type " + n + " at offset " + t);
+    }
+    sizeFromCtrlByte(n, t) {
+      const e = n & 31;
+      return e < 29 ? p(e, t) : e === 29 ? p(29 + this.db[t], t + 1) : e === 30 ? p(285 + this.db.readUInt16BE(t), t + 2) : p(65821 + this.db.readUIntBE(t, 3), t + 3);
+    }
+    decodeBytes(n, t) {
+      return this.db.subarray(n, n + t);
+    }
+    decodePointer(n, t) {
+      const e = n >> 3 & 3, r = this.baseOffset + u[e];
+      let i = 0;
+      return e === 0 ? i = (n & 7) << 8 | this.db[t] : e === 1 ? i = (n & 7) << 16 | this.db.readUInt16BE(t) : e === 2 ? i = (n & 7) << 24 | this.db.readUIntBE(t, 3) : i = this.db.readUInt32BE(t), t += e + 1, p(r + i, t);
+    }
+    decodeArray(n, t) {
+      let e;
+      const r = new Array(n);
+      for (let i = 0; i < n; i++)
+        e = this.decode(t), t = e.offset, r[i] = e.value;
+      return p(r, t);
+    }
+    decodeBoolean(n) {
+      return n !== 0;
+    }
+    decodeDouble(n) {
+      return this.db.readDoubleBE(n);
+    }
+    decodeFloat(n) {
+      return this.db.readFloatBE(n);
+    }
+    decodeMap(n, t) {
+      let e, r;
+      const i = {};
+      for (let f = 0; f < n; f++)
+        e = this.decode(t), r = e.value, e = this.decode(e.offset), t = e.offset, i[r] = e.value;
+      return p(i, t);
+    }
+    decodeInt32(n, t) {
+      return t === 0 ? 0 : t < 4 ? this.db.readUIntBE(n, t) : this.db.readInt32BE(n);
+    }
+    decodeUint(n, t) {
+      return t === 0 ? 0 : t <= 6 ? this.db.readUIntBE(n, t) : t == 8 ? this.db.readBigUInt64BE(n).toString() : t > 16 ? 0 : this.decodeBigUint(n, t);
+    }
+    decodeString(n, t) {
+      return this.db.toString("utf8", n, n + t);
+    }
+    decodeBigUint(n, t) {
+      let e = 0n;
+      for (let r = 0; r < t; r++)
+        e <<= 8n, e |= BigInt(this.db.readUInt8(n + r));
+      return e.toString();
+    }
+  }
+  return ee.default = h, ee;
+}
+var te = {}, We;
+function tr() {
+  if (We) return te;
+  We = 1;
+  var o = te && te.__importDefault || function(n) {
+    return n && n.__esModule ? n : { default: n };
+  };
+  Object.defineProperty(te, "__esModule", { value: !0 });
+  const g = o(Ct), m = (n) => {
+    const t = n.split(".", 4), e = parseInt(t[0]), r = parseInt(t[1]), i = parseInt(t[2]), f = parseInt(t[3]);
+    return [e, r, i, f];
+  }, u = (n) => {
+    const t = parseInt(n, 10).toString(16);
+    return t.length === 2 ? t : "0" + t;
+  }, l = (n) => {
+    const t = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    let e, r, i;
+    const f = n.indexOf(".") > -1 ? n.replace(/(\d+)\.(\d+)\.(\d+)\.(\d+)/, (b, x, E, I, S) => u(x) + u(E) + ":" + u(I) + u(S)) : n, [y, _] = f.split("::", 2);
+    if (y)
+      for (r = y.split(":"), e = 0; e < r.length; e++)
+        i = parseInt(r[e], 16), t[e * 2] = i >> 8, t[e * 2 + 1] = i & 255;
+    if (_) {
+      r = _.split(":");
+      const b = 16 - r.length * 2;
+      for (e = 0; e < r.length; e++)
+        i = parseInt(r[e], 16), t[b + e * 2] = i >> 8, t[b + (e * 2 + 1)] = i & 255;
+    }
+    return t;
+  }, p = (n) => n.indexOf(":") === -1 ? m(n) : l(n), h = (n, t) => {
+    const e = t >> 3, r = 7 ^ t & 7;
+    return n[e] >>> r & 1;
+  }, s = (n) => {
+    const t = g.default.isIP(n);
+    return t === 4 || t === 6;
+  };
+  return te.default = {
+    bitAt: h,
+    parse: p,
+    validate: s
+  }, te;
+}
+var ce = {}, He;
+function rr() {
+  return He || (He = 1, (function(o) {
+    var g = ce && ce.__importDefault || function(n) {
+      return n && n.__esModule ? n : { default: n };
+    };
+    Object.defineProperty(o, "__esModule", { value: !0 }), o.isLegacyFormat = o.parseMetadata = void 0;
+    const m = g(/* @__PURE__ */ St()), u = g(/* @__PURE__ */ Pt()), l = Buffer.from("ABCDEF4D61784D696E642E636F6D", "hex"), p = (n) => {
+      const t = h(n), r = new m.default(n, t).decode(t).value;
+      if (!r)
+        throw new Error((0, o.isLegacyFormat)(n) ? u.default.legacyErrorMessage : "Cannot parse binary database");
+      return u.default.assert([24, 28, 32].indexOf(r.record_size) > -1, "Unsupported record size"), {
+        binaryFormatMajorVersion: r.binary_format_major_version,
+        binaryFormatMinorVersion: r.binary_format_minor_version,
+        buildEpoch: new Date(r.build_epoch * 1e3),
+        databaseType: r.database_type,
+        description: r.description,
+        ipVersion: r.ip_version,
+        languages: r.languages,
+        nodeByteSize: r.record_size / 4,
+        nodeCount: r.node_count,
+        recordSize: r.record_size,
+        searchTreeSize: r.node_count * r.record_size / 4,
+        // Depth depends on the IP version, it's 32 for IPv4 and 128 for IPv6.
+        treeDepth: Math.pow(2, r.ip_version + 1)
+      };
+    };
+    o.parseMetadata = p;
+    const h = (n) => {
+      let t = 0, e = n.length - 1;
+      const r = l.length - 1;
+      for (; t <= r && e-- > 0; )
+        t += n[e] === l[r - t] ? 1 : -t;
+      return e + t;
+    }, s = (n) => {
+      for (let e = 0; e < 20; e++) {
+        const r = n.slice(n.length - 3 - e, n.length - e);
+        if (r[0] === 255 && r[1] === 255 && r[2] === 255)
+          return !0;
+      }
+      return !1;
+    };
+    o.isLegacyFormat = s;
+  })(ce)), ce;
+}
+var ve = {}, Ge;
+function nr() {
+  if (Ge) return ve;
+  Ge = 1, Object.defineProperty(ve, "__esModule", { value: !0 });
+  const o = (h) => (s) => h.readUIntBE(s + 3, 3), g = (h) => (s) => h.readUIntBE(s, 3), m = (h) => (s) => (h[s + 3] & 240) << 20 | h.readUIntBE(s, 3), u = (h) => (s) => (h[s + 3] & 15) << 24 | h.readUIntBE(s + 4, 3), l = (h) => (s) => h.readUInt32BE(s), p = (h) => (s) => h.readUInt32BE(s + 4);
+  return ve.default = (h, s) => {
+    switch (s) {
+      case 24:
+        return { left: g(h), right: o(h) };
+      case 28:
+        return { left: m(h), right: u(h) };
+      case 32:
+        return { left: l(h), right: p(h) };
+    }
+    throw new Error("Unsupported record size");
+  }, ve;
+}
+var Ae = {}, Je;
+function ir() {
+  return Je || (Je = 1, Object.defineProperty(Ae, "__esModule", { value: !0 })), Ae;
+}
+var Ke;
+function Ze() {
+  return Ke || (Ke = 1, (function(o) {
+    var g = K && K.__createBinding || (Object.create ? (function(e, r, i, f) {
+      f === void 0 && (f = i);
+      var y = Object.getOwnPropertyDescriptor(r, i);
+      (!y || ("get" in y ? !r.__esModule : y.writable || y.configurable)) && (y = { enumerable: !0, get: function() {
+        return r[i];
+      } }), Object.defineProperty(e, f, y);
+    }) : (function(e, r, i, f) {
+      f === void 0 && (f = i), e[f] = r[i];
+    })), m = K && K.__exportStar || function(e, r) {
+      for (var i in e) i !== "default" && !Object.prototype.hasOwnProperty.call(r, i) && g(r, e, i);
+    }, u = K && K.__importDefault || function(e) {
+      return e && e.__esModule ? e : { default: e };
+    };
+    Object.defineProperty(o, "__esModule", { value: !0 }), o.Reader = void 0;
+    const l = u(/* @__PURE__ */ St()), p = u(/* @__PURE__ */ tr()), h = /* @__PURE__ */ rr(), s = u(/* @__PURE__ */ nr()), n = 16;
+    class t {
+      constructor(r, i = {}) {
+        this.opts = i, this.load(r);
+      }
+      load(r) {
+        if (!Buffer.isBuffer(r))
+          throw new Error(`mmdb-lib expects an instance of Buffer, got: ${typeof r}`);
+        this.db = r, this.metadata = (0, h.parseMetadata)(this.db), this.decoder = new l.default(this.db, this.metadata.searchTreeSize + n, this.opts.cache), this.walker = (0, s.default)(this.db, this.metadata.recordSize), this.ipv4StartNodeNumber = this.ipv4Start();
+      }
+      get(r) {
+        const [i] = this.getWithPrefixLength(r);
+        return i;
+      }
+      getWithPrefixLength(r) {
+        const [i, f] = this.findAddressInTree(r);
+        return [i ? this.resolveDataPointer(i) : null, f];
+      }
+      findAddressInTree(r) {
+        const i = p.default.parse(r), f = this.metadata.nodeCount, y = i.length * 8;
+        let _, b = 0, x, E = 0;
+        for (i.length === 4 && (b = this.ipv4StartNodeNumber); E < y && b < f; E++)
+          _ = p.default.bitAt(i, E), x = b * this.metadata.nodeByteSize, b = _ ? this.walker.right(x) : this.walker.left(x);
+        return b > f ? [b, E] : [null, E];
+      }
+      resolveDataPointer(r) {
+        const i = r - this.metadata.nodeCount + this.metadata.searchTreeSize;
+        return this.decoder.decodeFast(i).value;
+      }
+      ipv4Start() {
+        if (this.metadata.ipVersion === 4)
+          return 0;
+        const r = this.metadata.nodeCount;
+        let i = 0, f = 0;
+        for (; f < 96 && i < r; f++) {
+          const y = i * this.metadata.nodeByteSize;
+          i = this.walker.left(y);
+        }
+        return i;
+      }
+    }
+    o.Reader = t, m(/* @__PURE__ */ ir(), o);
+  })(K)), K;
+}
+var me = {};
+var Xe;
+function or() {
+  if (Xe) return me;
+  Xe = 1;
+  class o {
+    /**
+     * Creates a new LRU cache instance.
+     *
+     * @constructor
+     * @param {number} [max=0] - Maximum number of items to store. 0 means unlimited.
+     * @param {number} [ttl=0] - Time to live in milliseconds. 0 means no expiration.
+     * @param {boolean} [resetTtl=false] - Whether to reset TTL when accessing existing items.
+     * @throws {TypeError} When parameters are of invalid type.
+     * @example
+     * const cache = new LRU(1000, 60000, true); // 1000 items, 1 minute TTL, reset on access
+     * @since 1.0.0
+     */
+    constructor(u = 0, l = 0, p = !1) {
+      this.first = null, this.items = /* @__PURE__ */ Object.create(null), this.last = null, this.max = u, this.resetTtl = p, this.size = 0, this.ttl = l;
+    }
+    /**
+     * Removes all items from the cache.
+     *
+     * @method clear
+     * @memberof LRU
+     * @returns {LRU} The LRU instance for method chaining.
+     * @example
+     * cache.clear();
+     * console.log(cache.size); // 0
+     * @since 1.0.0
+     */
+    clear() {
+      return this.first = null, this.items = /* @__PURE__ */ Object.create(null), this.last = null, this.size = 0, this;
+    }
+    /**
+     * Removes an item from the cache by key.
+     *
+     * @method delete
+     * @memberof LRU
+     * @param {string} key - The key of the item to delete.
+     * @returns {LRU} The LRU instance for method chaining.
+     * @example
+     * cache.set('key1', 'value1');
+     * cache.delete('key1');
+     * console.log(cache.has('key1')); // false
+     * @see {@link LRU#has}
+     * @see {@link LRU#clear}
+     * @since 1.0.0
+     */
+    delete(u) {
+      if (this.has(u)) {
+        const l = this.items[u];
+        delete this.items[u], this.size--, l.prev !== null && (l.prev.next = l.next), l.next !== null && (l.next.prev = l.prev), this.first === l && (this.first = l.next), this.last === l && (this.last = l.prev);
+      }
+      return this;
+    }
+    /**
+     * Returns an array of [key, value] pairs for the specified keys.
+     *
+     * @method entries
+     * @memberof LRU
+     * @param {string[]} [keys=this.keys()] - Array of keys to get entries for. Defaults to all keys.
+     * @returns {Array<Array<*>>} Array of [key, value] pairs.
+     * @example
+     * cache.set('a', 1).set('b', 2);
+     * console.log(cache.entries()); // [['a', 1], ['b', 2]]
+     * console.log(cache.entries(['a'])); // [['a', 1]]
+     * @see {@link LRU#keys}
+     * @see {@link LRU#values}
+     * @since 11.1.0
+     */
+    entries(u = this.keys()) {
+      return u.map((l) => [l, this.get(l)]);
+    }
+    /**
+     * Removes the least recently used item from the cache.
+     *
+     * @method evict
+     * @memberof LRU
+     * @param {boolean} [bypass=false] - Whether to bypass the size check and force eviction.
+     * @returns {LRU} The LRU instance for method chaining.
+     * @example
+     * cache.set('old', 'value').set('new', 'value');
+     * cache.evict(); // Removes 'old' item
+     * @see {@link LRU#setWithEvicted}
+     * @since 1.0.0
+     */
+    evict(u = !1) {
+      if (u || this.size > 0) {
+        const l = this.first;
+        delete this.items[l.key], --this.size === 0 ? (this.first = null, this.last = null) : (this.first = l.next, this.first.prev = null);
+      }
+      return this;
+    }
+    /**
+     * Returns the expiration timestamp for a given key.
+     *
+     * @method expiresAt
+     * @memberof LRU
+     * @param {string} key - The key to check expiration for.
+     * @returns {number|undefined} The expiration timestamp in milliseconds, or undefined if key doesn't exist.
+     * @example
+     * const cache = new LRU(100, 5000); // 5 second TTL
+     * cache.set('key1', 'value1');
+     * console.log(cache.expiresAt('key1')); // timestamp 5 seconds from now
+     * @see {@link LRU#get}
+     * @see {@link LRU#has}
+     * @since 1.0.0
+     */
+    expiresAt(u) {
+      let l;
+      return this.has(u) && (l = this.items[u].expiry), l;
+    }
+    /**
+     * Retrieves a value from the cache by key. Updates the item's position to most recently used.
+     *
+     * @method get
+     * @memberof LRU
+     * @param {string} key - The key to retrieve.
+     * @returns {*} The value associated with the key, or undefined if not found or expired.
+     * @example
+     * cache.set('key1', 'value1');
+     * console.log(cache.get('key1')); // 'value1'
+     * console.log(cache.get('nonexistent')); // undefined
+     * @see {@link LRU#set}
+     * @see {@link LRU#has}
+     * @since 1.0.0
+     */
+    get(u) {
+      let l;
+      if (this.has(u)) {
+        const p = this.items[u];
+        this.ttl > 0 && p.expiry <= Date.now() ? this.delete(u) : (l = p.value, this.set(u, l, !0));
+      }
+      return l;
+    }
+    /**
+     * Checks if a key exists in the cache.
+     *
+     * @method has
+     * @memberof LRU
+     * @param {string} key - The key to check for.
+     * @returns {boolean} True if the key exists, false otherwise.
+     * @example
+     * cache.set('key1', 'value1');
+     * console.log(cache.has('key1')); // true
+     * console.log(cache.has('nonexistent')); // false
+     * @see {@link LRU#get}
+     * @see {@link LRU#delete}
+     * @since 9.0.0
+     */
+    has(u) {
+      return u in this.items;
+    }
+    /**
+     * Returns an array of all keys in the cache, ordered from least to most recently used.
+     *
+     * @method keys
+     * @memberof LRU
+     * @returns {string[]} Array of keys in LRU order.
+     * @example
+     * cache.set('a', 1).set('b', 2);
+     * cache.get('a'); // Move 'a' to most recent
+     * console.log(cache.keys()); // ['b', 'a']
+     * @see {@link LRU#values}
+     * @see {@link LRU#entries}
+     * @since 9.0.0
+     */
+    keys() {
+      const u = [];
+      let l = this.first;
+      for (; l !== null; )
+        u.push(l.key), l = l.next;
+      return u;
+    }
+    /**
+     * Sets a value in the cache and returns any evicted item.
+     *
+     * @method setWithEvicted
+     * @memberof LRU
+     * @param {string} key - The key to set.
+     * @param {*} value - The value to store.
+     * @param {boolean} [resetTtl=this.resetTtl] - Whether to reset the TTL for this operation.
+     * @returns {Object|null} The evicted item (if any) with shape {key, value, expiry, prev, next}, or null.
+     * @example
+     * const cache = new LRU(2);
+     * cache.set('a', 1).set('b', 2);
+     * const evicted = cache.setWithEvicted('c', 3); // evicted = {key: 'a', value: 1, ...}
+     * @see {@link LRU#set}
+     * @see {@link LRU#evict}
+     * @since 11.3.0
+     */
+    setWithEvicted(u, l, p = this.resetTtl) {
+      let h = null;
+      if (this.has(u))
+        this.set(u, l, !0, p);
+      else {
+        this.max > 0 && this.size === this.max && (h = { ...this.first }, this.evict(!0));
+        let s = this.items[u] = {
+          expiry: this.ttl > 0 ? Date.now() + this.ttl : this.ttl,
+          key: u,
+          prev: this.last,
+          next: null,
+          value: l
+        };
+        ++this.size === 1 ? this.first = s : this.last.next = s, this.last = s;
+      }
+      return h;
+    }
+    /**
+     * Sets a value in the cache. Updates the item's position to most recently used.
+     *
+     * @method set
+     * @memberof LRU
+     * @param {string} key - The key to set.
+     * @param {*} value - The value to store.
+     * @param {boolean} [bypass=false] - Whether to bypass normal LRU positioning (internal use).
+     * @param {boolean} [resetTtl=this.resetTtl] - Whether to reset the TTL for this operation.
+     * @returns {LRU} The LRU instance for method chaining.
+     * @example
+     * cache.set('key1', 'value1')
+     *      .set('key2', 'value2')
+     *      .set('key3', 'value3');
+     * @see {@link LRU#get}
+     * @see {@link LRU#setWithEvicted}
+     * @since 1.0.0
+     */
+    set(u, l, p = !1, h = this.resetTtl) {
+      let s;
+      if (p || this.has(u)) {
+        if (s = this.items[u], s.value = l, p === !1 && h && (s.expiry = this.ttl > 0 ? Date.now() + this.ttl : this.ttl), this.last !== s) {
+          const n = this.last, t = s.next, e = s.prev;
+          this.first === s && (this.first = s.next), s.next = null, s.prev = this.last, n.next = s, e !== null && (e.next = t), t !== null && (t.prev = e);
+        }
+      } else
+        this.max > 0 && this.size === this.max && this.evict(!0), s = this.items[u] = {
+          expiry: this.ttl > 0 ? Date.now() + this.ttl : this.ttl,
+          key: u,
+          prev: this.last,
+          next: null,
+          value: l
+        }, ++this.size === 1 ? this.first = s : this.last.next = s;
+      return this.last = s, this;
+    }
+    /**
+     * Returns an array of all values in the cache for the specified keys.
+     *
+     * @method values
+     * @memberof LRU
+     * @param {string[]} [keys=this.keys()] - Array of keys to get values for. Defaults to all keys.
+     * @returns {Array<*>} Array of values corresponding to the keys.
+     * @example
+     * cache.set('a', 1).set('b', 2);
+     * console.log(cache.values()); // [1, 2]
+     * console.log(cache.values(['a'])); // [1]
+     * @see {@link LRU#keys}
+     * @see {@link LRU#entries}
+     * @since 11.1.0
+     */
+    values(u = this.keys()) {
+      return u.map((l) => this.get(l));
+    }
+  }
+  function g(m = 1e3, u = 0, l = !1) {
+    if (isNaN(m) || m < 0)
+      throw new TypeError("Invalid max value");
+    if (isNaN(u) || u < 0)
+      throw new TypeError("Invalid ttl value");
+    if (typeof l != "boolean")
+      throw new TypeError("Invalid resetTtl value");
+    return new o(m, u, l);
+  }
+  return me.LRU = o, me.lru = g, me;
+}
+var re = {}, Ye;
+function sr() {
+  if (Ye) return re;
+  Ye = 1;
+  var o = re && re.__importDefault || function(u) {
+    return u && u.__esModule ? u : { default: u };
+  };
+  Object.defineProperty(re, "__esModule", { value: !0 });
+  const g = o(Xt), m = o(de);
+  return re.default = {
+    existsSync: g.default.existsSync,
+    readFile: m.default.promisify(g.default.readFile),
+    watchFile: g.default.watchFile,
+    createReadStream: g.default.createReadStream,
+    stat: m.default.promisify(g.default.stat)
+  }, re;
+}
+var ne = {}, Qe;
+function ar() {
+  if (Qe) return ne;
+  Qe = 1;
+  var o = ne && ne.__importDefault || function(n) {
+    return n && n.__esModule ? n : { default: n };
+  };
+  Object.defineProperty(ne, "__esModule", { value: !0 });
+  const g = o(Ct), m = (n) => {
+    const t = n.split(".", 4), e = parseInt(t[0]), r = parseInt(t[1]), i = parseInt(t[2]), f = parseInt(t[3]);
+    return [e, r, i, f];
+  }, u = (n) => (n = parseInt(n, 10).toString(16), n.length === 2 ? n : "0" + n), l = (n) => {
+    const t = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    let e, r, i;
+    n.indexOf(".") > -1 && (n = n.replace(/(\d+)\.(\d+)\.(\d+)\.(\d+)/, (_, b, x, E, I) => u(b) + u(x) + ":" + u(E) + u(I)));
+    const [f, y] = n.split("::", 2);
+    if (f)
+      for (r = f.split(":"), e = 0; e < r.length; e++)
+        i = parseInt(r[e], 16), t[e * 2] = i >> 8, t[e * 2 + 1] = i & 255;
+    if (y) {
+      r = y.split(":");
+      const _ = 16 - r.length * 2;
+      for (e = 0; e < r.length; e++)
+        i = parseInt(r[e], 16), t[_ + e * 2] = i >> 8, t[_ + (e * 2 + 1)] = i & 255;
+    }
+    return t;
+  }, p = (n) => n.indexOf(":") === -1 ? m(n) : l(n), h = (n, t) => {
+    const e = t >> 3, r = 7 ^ t & 7;
+    return n[e] >>> r & 1;
+  }, s = (n) => {
+    const t = g.default.isIP(n);
+    return t === 4 || t === 6;
+  };
+  return ne.default = {
+    bitAt: h,
+    parse: p,
+    validate: s
+  }, ne;
+}
+var ye = {}, et;
+function ur() {
+  return et || (et = 1, Object.defineProperty(ye, "__esModule", { value: !0 }), ye.default = (o) => !o || o.length < 3 ? !1 : o[0] === 31 && o[1] === 139 && o[2] === 8), ye;
+}
+var ge = {}, tt;
+function fr() {
+  if (tt) return ge;
+  tt = 1, Object.defineProperty(ge, "__esModule", { value: !0 });
+  const o = (l, p) => l << 8 | p, g = (l, p, h) => l << 16 | p << 8 | h, m = (l, p, h, s) => l << 24 | p << 16 | h << 8 | s, u = `Maxmind v2 module has changed API.
+Upgrade instructions can be found here: https://github.com/runk/node-maxmind/wiki/Migration-guide
+If you want to use legacy libary then explicitly install maxmind@1`;
+  return ge.default = {
+    concat2: o,
+    concat3: g,
+    concat4: m,
+    legacyErrorMessage: u
+  }, ge;
+}
+var rt;
+function je() {
+  return rt || (rt = 1, (function(o) {
+    var g = J && J.__createBinding || (Object.create ? (function(E, I, S, q) {
+      q === void 0 && (q = S);
+      var F = Object.getOwnPropertyDescriptor(I, S);
+      (!F || ("get" in F ? !I.__esModule : F.writable || F.configurable)) && (F = { enumerable: !0, get: function() {
+        return I[S];
+      } }), Object.defineProperty(E, q, F);
+    }) : (function(E, I, S, q) {
+      q === void 0 && (q = S), E[q] = I[S];
+    })), m = J && J.__exportStar || function(E, I) {
+      for (var S in E) S !== "default" && !Object.prototype.hasOwnProperty.call(I, S) && g(I, E, S);
+    }, u = J && J.__importDefault || function(E) {
+      return E && E.__esModule ? E : { default: E };
+    };
+    Object.defineProperty(o, "__esModule", { value: !0 }), o.Reader = o.validate = o.init = o.openSync = o.open = void 0;
+    const l = u(Re), p = /* @__PURE__ */ Ze();
+    Object.defineProperty(o, "Reader", { enumerable: !0, get: function() {
+      return p.Reader;
+    } });
+    const h = /* @__PURE__ */ or(), s = u(/* @__PURE__ */ sr()), n = u(/* @__PURE__ */ ar()), t = u(/* @__PURE__ */ ur()), e = u(/* @__PURE__ */ fr()), r = 512 * 1024 * 1024, i = 8 * 1024 * 1024, f = async (E, I) => new Promise((S, q) => {
+      let F = Buffer.allocUnsafe(I), d = 0;
+      const c = s.default.createReadStream(E, {
+        highWaterMark: i
+      });
+      c.on("data", (v) => {
+        if (Buffer.isBuffer(v))
+          v.copy(F, d), d += v.length;
+        else {
+          const O = Buffer.from(v);
+          O.copy(F, d), d += O.length;
+        }
+      }), c.on("end", () => {
+        c.close(), S(F);
+      }), c.on("error", (v) => {
+        q(v);
+      });
+    }), y = async (E) => {
+      const I = await s.default.stat(E);
+      return I.size < r ? s.default.readFile(E) : f(E, I.size);
+    }, _ = async (E, I, S) => {
+      var q;
+      (0, l.default)(!S, e.default.legacyErrorMessage);
+      const F = await y(E);
+      if ((0, t.default)(F))
+        throw new Error("Looks like you are passing in a file in gzip format, please use mmdb database instead.");
+      const d = (0, h.lru)(((q = I?.cache) === null || q === void 0 ? void 0 : q.max) || 1e4), c = new p.Reader(F, { cache: d });
+      if (I && I.watchForUpdates) {
+        if (I.watchForUpdatesHook && typeof I.watchForUpdatesHook != "function")
+          throw new Error("opts.watchForUpdatesHook should be a function");
+        const v = {
+          persistent: I.watchForUpdatesNonPersistent !== !0
+        };
+        s.default.watchFile(E, v, async () => {
+          if (!await (async () => {
+            for (let R = 0; R < 3; R++) {
+              if (s.default.existsSync(E))
+                return !0;
+              await new Promise((M) => setTimeout(M, 500));
+            }
+            return !1;
+          })())
+            return;
+          const P = await y(E);
+          d.clear(), c.load(P), I.watchForUpdatesHook && I.watchForUpdatesHook();
+        });
+      }
+      return c;
+    };
+    o.open = _;
+    const b = () => {
+      throw new Error(e.default.legacyErrorMessage);
+    };
+    o.openSync = b;
+    const x = () => {
+      throw new Error(e.default.legacyErrorMessage);
+    };
+    o.init = x, o.validate = n.default.validate, m(/* @__PURE__ */ Ze(), o), o.default = {
+      init: o.init,
+      open: o.open,
+      openSync: o.openSync,
+      validate: n.default.validate
+    };
+  })(J)), J;
+}
+var V = {}, nt;
+function Be() {
+  if (nt) return V;
+  nt = 1, Object.defineProperty(V, "__esModule", { value: !0 }), V.ValueError = V.InvalidDbBufferError = V.BadMethodCallError = V.AddressNotFoundError = void 0;
+  class o extends Error {
+    constructor(p) {
+      super(p), this.name = this.constructor.name;
+    }
+  }
+  V.AddressNotFoundError = o;
+  class g extends Error {
+    constructor(p) {
+      super(p), this.name = this.constructor.name;
+    }
+  }
+  V.BadMethodCallError = g;
+  class m extends Error {
+    constructor(p) {
+      super(p), this.name = this.constructor.name;
+    }
+  }
+  V.InvalidDbBufferError = m;
+  class u extends Error {
+    constructor(p) {
+      super(p), this.name = this.constructor.name;
+    }
+  }
+  return V.ValueError = u, V;
+}
+var W = {}, Ce, it;
+function qe() {
+  if (it) return Ce;
+  it = 1;
+  var o = Re, g = Yt.Stream, m = de, u = /^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$/;
+  function l(e) {
+    return e.charAt(0).toUpperCase() + e.slice(1);
+  }
+  function p(e, r, i, f, y) {
+    throw new o.AssertionError({
+      message: m.format("%s (%s) is required", e, r),
+      actual: y === void 0 ? typeof f : y(f),
+      expected: r,
+      operator: i || "===",
+      stackStartFunction: p.caller
+    });
+  }
+  function h(e) {
+    return Object.prototype.toString.call(e).slice(8, -1);
+  }
+  function s() {
+  }
+  var n = {
+    bool: {
+      check: function(e) {
+        return typeof e == "boolean";
+      }
+    },
+    func: {
+      check: function(e) {
+        return typeof e == "function";
+      }
+    },
+    string: {
+      check: function(e) {
+        return typeof e == "string";
+      }
+    },
+    object: {
+      check: function(e) {
+        return typeof e == "object" && e !== null;
+      }
+    },
+    number: {
+      check: function(e) {
+        return typeof e == "number" && !isNaN(e);
+      }
+    },
+    finite: {
+      check: function(e) {
+        return typeof e == "number" && !isNaN(e) && isFinite(e);
+      }
+    },
+    buffer: {
+      check: function(e) {
+        return Buffer.isBuffer(e);
+      },
+      operator: "Buffer.isBuffer"
+    },
+    array: {
+      check: function(e) {
+        return Array.isArray(e);
+      },
+      operator: "Array.isArray"
+    },
+    stream: {
+      check: function(e) {
+        return e instanceof g;
+      },
+      operator: "instanceof",
+      actual: h
+    },
+    date: {
+      check: function(e) {
+        return e instanceof Date;
+      },
+      operator: "instanceof",
+      actual: h
+    },
+    regexp: {
+      check: function(e) {
+        return e instanceof RegExp;
+      },
+      operator: "instanceof",
+      actual: h
+    },
+    uuid: {
+      check: function(e) {
+        return typeof e == "string" && u.test(e);
+      },
+      operator: "isUUID"
+    }
+  };
+  function t(e) {
+    var r = Object.keys(n), i;
+    return process.env.NODE_NDEBUG ? i = s : i = function(f, y) {
+      f || p(y, "true", f);
+    }, r.forEach(function(f) {
+      if (e) {
+        i[f] = s;
+        return;
+      }
+      var y = n[f];
+      i[f] = function(_, b) {
+        y.check(_) || p(b, f, y.operator, _, y.actual);
+      };
+    }), r.forEach(function(f) {
+      var y = "optional" + l(f);
+      if (e) {
+        i[y] = s;
+        return;
+      }
+      var _ = n[f];
+      i[y] = function(b, x) {
+        b != null && (_.check(b) || p(x, f, _.operator, b, _.actual));
+      };
+    }), r.forEach(function(f) {
+      var y = "arrayOf" + l(f);
+      if (e) {
+        i[y] = s;
+        return;
+      }
+      var _ = n[f], b = "[" + f + "]";
+      i[y] = function(x, E) {
+        Array.isArray(x) || p(E, b, _.operator, x, _.actual);
+        var I;
+        for (I = 0; I < x.length; I++)
+          _.check(x[I]) || p(E, b, _.operator, x, _.actual);
+      };
+    }), r.forEach(function(f) {
+      var y = "optionalArrayOf" + l(f);
+      if (e) {
+        i[y] = s;
+        return;
+      }
+      var _ = n[f], b = "[" + f + "]";
+      i[y] = function(x, E) {
+        if (x != null) {
+          Array.isArray(x) || p(E, b, _.operator, x, _.actual);
+          var I;
+          for (I = 0; I < x.length; I++)
+            _.check(x[I]) || p(E, b, _.operator, x, _.actual);
+        }
+      };
+    }), Object.keys(o).forEach(function(f) {
+      if (f === "AssertionError") {
+        i[f] = o[f];
+        return;
+      }
+      if (e) {
+        i[f] = s;
+        return;
+      }
+      i[f] = o[f];
+    }), i._setExports = t, i;
+  }
+  return Ce = t(process.env.NODE_NDEBUG), Ce;
+}
+var B = {}, le = {}, ot;
+function Mt() {
+  if (ot) return le;
+  ot = 1;
+  var o = Re, g = de;
+  le.sprintf = m, le.printf = u, le.fprintf = l;
+  function m(s) {
+    var n = [
+      "([^%]*)",
+      /* normal text */
+      "%",
+      /* start of format */
+      "(['\\-+ #0]*?)",
+      /* flags (optional) */
+      "([1-9]\\d*)?",
+      /* width (optional) */
+      "(\\.([1-9]\\d*))?",
+      /* precision (optional) */
+      "[lhjztL]*?",
+      /* length mods (ignored) */
+      "([diouxXfFeEgGaAcCsSp%jr])"
+      /* conversion */
+    ].join(""), t = new RegExp(n), e = Array.prototype.slice.call(arguments, 1), r, i, f, y, _, b, x, E, I, S = "", q = 1;
+    for (o.equal("string", typeof s); (I = t.exec(s)) !== null; ) {
+      if (S += I[1], s = s.substring(I[0].length), r = I[2] || "", i = I[3] || 0, f = I[4] || "", y = I[6], _ = !1, x = !1, b = " ", y == "%") {
+        S += "%";
+        continue;
+      }
+      if (e.length === 0)
+        throw new Error("too few args to sprintf");
+      if (E = e.shift(), q++, r.match(/[\' #]/))
+        throw new Error(
+          "unsupported flags: " + r
+        );
+      if (f.length > 0)
+        throw new Error(
+          "non-zero precision not supported"
+        );
+      switch (r.match(/-/) && (_ = !0), r.match(/0/) && (b = "0"), r.match(/\+/) && (x = !0), y) {
+        case "s":
+          if (E == null)
+            throw new Error("argument " + q + ": attempted to print undefined or null as a string");
+          S += p(b, i, _, E.toString());
+          break;
+        case "d":
+          E = Math.floor(E);
+        /*jsl:fallthru*/
+        case "f":
+          x = x && E > 0 ? "+" : "", S += x + p(
+            b,
+            i,
+            _,
+            E.toString()
+          );
+          break;
+        case "x":
+          S += p(b, i, _, E.toString(16));
+          break;
+        case "j":
+          i === 0 && (i = 10), S += g.inspect(E, !1, i);
+          break;
+        case "r":
+          S += h(E);
+          break;
+        default:
+          throw new Error("unsupported conversion: " + y);
+      }
+    }
+    return S += s, S;
+  }
+  function u() {
+    var s = Array.prototype.slice.call(arguments);
+    s.unshift(process.stdout), l.apply(null, s);
+  }
+  function l(s) {
+    var n = Array.prototype.slice.call(arguments, 1);
+    return s.write(m.apply(this, n));
+  }
+  function p(s, n, t, e) {
+    for (var r = e; r.length < n; )
+      t ? r += s : r = s + r;
+    return r;
+  }
+  function h(s) {
+    var n;
+    if (!(s instanceof Error))
+      throw new Error(m("invalid type for %%r: %j", s));
+    if (n = "EXCEPTION: " + s.constructor.name + ": " + s.stack, s.cause && typeof s.cause == "function") {
+      var t = s.cause();
+      t && (n += `
+Caused by: ` + h(t));
+    }
+    return n;
+  }
+  return le;
+}
+var N = {}, st;
+function cr() {
+  if (st) return N;
+  st = 1;
+  function o(_) {
+    return Array.isArray ? Array.isArray(_) : y(_) === "[object Array]";
+  }
+  N.isArray = o;
+  function g(_) {
+    return typeof _ == "boolean";
+  }
+  N.isBoolean = g;
+  function m(_) {
+    return _ === null;
+  }
+  N.isNull = m;
+  function u(_) {
+    return _ == null;
+  }
+  N.isNullOrUndefined = u;
+  function l(_) {
+    return typeof _ == "number";
+  }
+  N.isNumber = l;
+  function p(_) {
+    return typeof _ == "string";
+  }
+  N.isString = p;
+  function h(_) {
+    return typeof _ == "symbol";
+  }
+  N.isSymbol = h;
+  function s(_) {
+    return _ === void 0;
+  }
+  N.isUndefined = s;
+  function n(_) {
+    return y(_) === "[object RegExp]";
+  }
+  N.isRegExp = n;
+  function t(_) {
+    return typeof _ == "object" && _ !== null;
+  }
+  N.isObject = t;
+  function e(_) {
+    return y(_) === "[object Date]";
+  }
+  N.isDate = e;
+  function r(_) {
+    return y(_) === "[object Error]" || _ instanceof Error;
+  }
+  N.isError = r;
+  function i(_) {
+    return typeof _ == "function";
+  }
+  N.isFunction = i;
+  function f(_) {
+    return _ === null || typeof _ == "boolean" || typeof _ == "number" || typeof _ == "string" || typeof _ == "symbol" || // ES6 symbol
+    typeof _ > "u";
+  }
+  N.isPrimitive = f, N.isBuffer = Buffer.isBuffer;
+  function y(_) {
+    return Object.prototype.toString.call(_);
+  }
+  return N;
+}
+var Pe, at;
+function lr() {
+  if (at) return Pe;
+  at = 1;
+  var o = /* @__PURE__ */ qe(), g = de, m = /* @__PURE__ */ Mt(), u = cr().isError, l = m.sprintf;
+  Pe = h, h.VError = h, h.SError = s, h.WError = t, h.MultiError = n;
+  function p(e) {
+    var r, i, f, y, _;
+    if (o.object(e, "args"), o.bool(e.strict, "args.strict"), o.array(e.argv, "args.argv"), r = e.argv, r.length === 0)
+      i = {}, f = [];
+    else if (u(r[0]))
+      i = { cause: r[0] }, f = r.slice(1);
+    else if (typeof r[0] == "object") {
+      i = {};
+      for (_ in r[0])
+        i[_] = r[0][_];
+      f = r.slice(1);
+    } else
+      o.string(
+        r[0],
+        "first argument to VError, SError, or WError constructor must be a string, object, or Error"
+      ), i = {}, f = r;
+    return o.object(i), !i.strict && !e.strict && (f = f.map(function(b) {
+      return b === null ? "null" : b === void 0 ? "undefined" : b;
+    })), f.length === 0 ? y = "" : y = l.apply(null, f), {
+      options: i,
+      shortmessage: y
+    };
+  }
+  function h() {
+    var e, r, i, f, y, _, b;
+    if (e = Array.prototype.slice.call(arguments, 0), !(this instanceof h))
+      return r = Object.create(h.prototype), h.apply(r, arguments), r;
+    if (i = p({
+      argv: e,
+      strict: !1
+    }), i.options.name && (o.string(
+      i.options.name,
+      `error's "name" must be a string`
+    ), this.name = i.options.name), this.jse_shortmsg = i.shortmessage, _ = i.shortmessage, f = i.options.cause, f && (o.ok(u(f), "cause is not an Error"), this.jse_cause = f, i.options.skipCauseMessage || (_ += ": " + f.message)), this.jse_info = {}, i.options.info)
+      for (b in i.options.info)
+        this.jse_info[b] = i.options.info[b];
+    return this.message = _, Error.call(this, _), Error.captureStackTrace && (y = i.options.constructorOpt || this.constructor, Error.captureStackTrace(this, y)), this;
+  }
+  g.inherits(h, Error), h.prototype.name = "VError", h.prototype.toString = function() {
+    var r = this.hasOwnProperty("name") && this.name || this.constructor.name || this.constructor.prototype.name;
+    return this.message && (r += ": " + this.message), r;
+  }, h.prototype.cause = function() {
+    var r = h.cause(this);
+    return r === null ? void 0 : r;
+  }, h.cause = function(e) {
+    return o.ok(u(e), "err must be an Error"), u(e.jse_cause) ? e.jse_cause : null;
+  }, h.info = function(e) {
+    var r, i, f;
+    if (o.ok(u(e), "err must be an Error"), i = h.cause(e), i !== null ? r = h.info(i) : r = {}, typeof e.jse_info == "object" && e.jse_info !== null)
+      for (f in e.jse_info)
+        r[f] = e.jse_info[f];
+    return r;
+  }, h.findCauseByName = function(e, r) {
+    var i;
+    for (o.ok(u(e), "err must be an Error"), o.string(r, "name"), o.ok(r.length > 0, "name cannot be empty"), i = e; i !== null; i = h.cause(i))
+      if (o.ok(u(i)), i.name == r)
+        return i;
+    return null;
+  }, h.hasCauseWithName = function(e, r) {
+    return h.findCauseByName(e, r) !== null;
+  }, h.fullStack = function(e) {
+    o.ok(u(e), "err must be an Error");
+    var r = h.cause(e);
+    return r ? e.stack + `
+caused by: ` + h.fullStack(r) : e.stack;
+  }, h.errorFromList = function(e) {
+    return o.arrayOfObject(e, "errors"), e.length === 0 ? null : (e.forEach(function(r) {
+      o.ok(u(r));
+    }), e.length == 1 ? e[0] : new n(e));
+  }, h.errorForEach = function(e, r) {
+    o.ok(u(e), "err must be an Error"), o.func(r, "func"), e instanceof n ? e.errors().forEach(function(f) {
+      r(f);
+    }) : r(e);
+  };
+  function s() {
+    var e, r, i, f;
+    return e = Array.prototype.slice.call(arguments, 0), this instanceof s ? (i = p({
+      argv: e,
+      strict: !0
+    }), f = i.options, h.call(this, f, "%s", i.shortmessage), this) : (r = Object.create(s.prototype), s.apply(r, arguments), r);
+  }
+  g.inherits(s, h);
+  function n(e) {
+    o.array(e, "list of errors"), o.ok(e.length > 0, "must be at least one error"), this.ase_errors = e, h.call(this, {
+      cause: e[0]
+    }, "first of %d error%s", e.length, e.length == 1 ? "" : "s");
+  }
+  g.inherits(n, h), n.prototype.name = "MultiError", n.prototype.errors = function() {
+    return this.ase_errors.slice(0);
+  };
+  function t() {
+    var e, r, i, f;
+    return e = Array.prototype.slice.call(arguments, 0), this instanceof t ? (i = p({
+      argv: e,
+      strict: !1
+    }), f = i.options, f.skipCauseMessage = !0, h.call(this, f, "%s", i.shortmessage), this) : (r = Object.create(t.prototype), t.apply(r, e), r);
+  }
+  return g.inherits(t, h), t.prototype.name = "WError", t.prototype.toString = function() {
+    var r = this.hasOwnProperty("name") && this.name || this.constructor.name || this.constructor.prototype.name;
+    return this.message && (r += ": " + this.message), this.jse_cause && this.jse_cause.message && (r += "; caused by " + this.jse_cause.toString()), r;
+  }, t.prototype.cause = function(r) {
+    return u(r) && (this.jse_cause = r), this.jse_cause;
+  }, Pe;
+}
+var Oe = { exports: {} }, dr = Oe.exports, ut;
+function hr() {
+  return ut || (ut = 1, (function(o) {
+    (function(g, m) {
+      o.exports ? o.exports = m() : g.jsonSchema = m();
+    })(dr, function() {
+      var g = u;
+      g.Integer = { type: "integer" };
+      var m = {
+        String,
+        Boolean,
+        Number,
+        Object,
+        Array,
+        Date
+      };
+      g.validate = u;
+      function u(l, p) {
+        return u(l, p, { changing: !1 });
+      }
+      g.checkPropertyChange = function(l, p, h) {
+        return u(l, p, { changing: h || "property" });
+      };
+      var u = g._validate = function(l, p, h) {
+        h || (h = {});
+        var s = h.changing;
+        function n(i) {
+          return i.type || m[i.name] == i && i.name.toLowerCase();
+        }
+        var t = [];
+        function e(i, f, y, _) {
+          var b;
+          y += y ? typeof _ == "number" ? "[" + _ + "]" : typeof _ > "u" ? "" : "." + _ : _;
+          function x(c) {
+            t.push({ property: y, message: c });
+          }
+          if ((typeof f != "object" || f instanceof Array) && (y || typeof f != "function") && !(f && n(f)))
+            return typeof f == "function" ? i instanceof f || x("is not an instance of the class/constructor " + f.name) : f && x("Invalid schema/property definition " + f), null;
+          s && f.readonly && x("is a readonly field, it can not be changed"), f.extends && e(i, f.extends, y, _);
+          function E(c, v) {
+            if (c) {
+              if (typeof c == "string" && c != "any" && (c == "null" ? v !== null : typeof v != c) && !(v instanceof Array && c == "array") && !(v instanceof Date && c == "date") && !(c == "integer" && v % 1 === 0))
+                return [{ property: y, message: v + " - " + typeof v + " value found, but a " + c + " is required" }];
+              if (c instanceof Array) {
+                for (var O = [], P = 0; P < c.length && (O = E(c[P], v)).length; P++)
+                  ;
+                if (O.length)
+                  return O;
+              } else if (typeof c == "object") {
+                var R = t;
+                t = [], e(v, c, y);
+                var M = t;
+                return t = R, M;
+              }
+            }
+            return [];
+          }
+          if (i === void 0)
+            f.required && x("is missing and it is required");
+          else if (t = t.concat(E(n(f), i)), f.disallow && !E(f.disallow, i).length && x(" disallowed value was matched"), i !== null) {
+            if (i instanceof Array) {
+              if (f.items) {
+                var I = f.items instanceof Array, S = f.items;
+                for (_ = 0, b = i.length; _ < b; _ += 1)
+                  I && (S = f.items[_]), h.coerce && (i[_] = h.coerce(i[_], S)), t.concat(e(i[_], S, y, _));
+              }
+              f.minItems && i.length < f.minItems && x("There must be a minimum of " + f.minItems + " in the array"), f.maxItems && i.length > f.maxItems && x("There must be a maximum of " + f.maxItems + " in the array");
+            } else (f.properties || f.additionalProperties) && t.concat(r(i, f.properties, y, f.additionalProperties));
+            if (f.pattern && typeof i == "string" && !i.match(f.pattern) && x("does not match the regex pattern " + f.pattern), f.maxLength && typeof i == "string" && i.length > f.maxLength && x("may only be " + f.maxLength + " characters long"), f.minLength && typeof i == "string" && i.length < f.minLength && x("must be at least " + f.minLength + " characters long"), typeof f.minimum < "u" && typeof i == typeof f.minimum && f.minimum > i && x("must have a minimum value of " + f.minimum), typeof f.maximum < "u" && typeof i == typeof f.maximum && f.maximum < i && x("must have a maximum value of " + f.maximum), f.enum) {
+              var q = f.enum;
+              b = q.length;
+              for (var F, d = 0; d < b; d++)
+                if (q[d] === i) {
+                  F = 1;
+                  break;
+                }
+              F || x("does not have a value in the enumeration " + q.join(", "));
+            }
+            typeof f.maxDecimal == "number" && i.toString().match(new RegExp("\\.[0-9]{" + (f.maxDecimal + 1) + ",}")) && x("may only have " + f.maxDecimal + " digits of decimal places");
+          }
+          return null;
+        }
+        function r(i, f, y, _) {
+          if (typeof f == "object") {
+            (typeof i != "object" || i instanceof Array) && t.push({ property: y, message: "an object is required" });
+            for (var b in f)
+              if (f.hasOwnProperty(b) && b != "__proto__" && b != "constructor") {
+                var x = i.hasOwnProperty(b) ? i[b] : void 0;
+                if (x === void 0 && h.existingOnly) continue;
+                var E = f[b];
+                x === void 0 && E.default && (x = i[b] = E.default), h.coerce && b in i && (x = i[b] = h.coerce(x, E)), e(x, E, y, b);
+              }
+          }
+          for (b in i) {
+            if (i.hasOwnProperty(b) && !(b.charAt(0) == "_" && b.charAt(1) == "_") && f && !f[b] && _ === !1)
+              if (h.filter) {
+                delete i[b];
+                continue;
+              } else
+                t.push({ property: y, message: "The property " + b + " is not defined in the schema and the schema does not allow additional properties" });
+            var I = f && f[b] && f[b].requires;
+            I && !(I in i) && t.push({ property: y, message: "the presence of the property " + b + " requires that " + I + " also be present" }), x = i[b], _ && (!(f && typeof f == "object") || !(b in f)) && (h.coerce && (x = i[b] = h.coerce(x, _)), e(x, _, y, b)), !s && x && x.$schema && (t = t.concat(e(x, x.$schema, y, b)));
+          }
+          return t;
+        }
+        return p && e(l, p, "", s || ""), !s && l && l.$schema && e(l, l.$schema, "", ""), { valid: !t.length, errors: t };
+      };
+      return g.mustBeValid = function(l) {
+        if (!l.valid)
+          throw new TypeError(l.errors.map(function(p) {
+            return "for property " + p.property + ": " + p.message;
+          }).join(`, 
+`));
+      }, g;
+    });
+  })(Oe)), Oe.exports;
+}
+var ft;
+function pr() {
+  if (ft) return B;
+  ft = 1;
+  var o = /* @__PURE__ */ qe(), g = /* @__PURE__ */ Mt(), m = /* @__PURE__ */ lr(), u = /* @__PURE__ */ hr();
+  B.deepCopy = l, B.deepEqual = p, B.isEmpty = h, B.hasKey = s, B.forEachKey = n, B.pluck = t, B.flattenObject = f, B.flattenIter = r, B.validateJsonObject = Te, B.validateJsonObjectJS = Te, B.randElt = Wt, B.extraProperties = Zt, B.mergeObjects = $e, B.startsWith = y, B.endsWith = _, B.parseInteger = Lt, B.iso8601 = b, B.rfc1123 = I, B.parseDateTime = S, B.hrtimediff = Ne, B.hrtimeDiff = Ne, B.hrtimeAccum = ke, B.hrtimeAdd = Kt, B.hrtimeNanosec = Ht, B.hrtimeMicrosec = Gt, B.hrtimeMillisec = Jt;
+  function l(a) {
+    var w, A, C = "__deepCopy";
+    if (a && a[C])
+      throw new Error("attempted deep copy of cyclic object");
+    if (a && a.constructor == Object) {
+      w = {}, a[C] = !0;
+      for (A in a)
+        A != C && (w[A] = l(a[A]));
+      return delete a[C], w;
+    }
+    if (a && a.constructor == Array) {
+      for (w = [], a[C] = !0, A = 0; A < a.length; A++)
+        w.push(l(a[A]));
+      return delete a[C], w;
+    }
+    return a;
+  }
+  function p(a, w) {
+    if (typeof a != typeof w)
+      return !1;
+    if (a === null || w === null || typeof a != "object")
+      return a === w;
+    if (a.constructor != w.constructor)
+      return !1;
+    var A;
+    for (A in a)
+      if (!(A in w) || !p(a[A], w[A]))
+        return !1;
+    for (A in w)
+      if (!(A in a))
+        return !1;
+    return !0;
+  }
+  function h(a) {
+    var w;
+    for (w in a)
+      return !1;
+    return !0;
+  }
+  function s(a, w) {
+    return o.equal(typeof w, "string"), Object.prototype.hasOwnProperty.call(a, w);
+  }
+  function n(a, w) {
+    for (var A in a)
+      s(a, A) && w(A, a[A]);
+  }
+  function t(a, w) {
+    return o.equal(typeof w, "string"), e(a, w);
+  }
+  function e(a, w) {
+    if (!(a === null || typeof a != "object")) {
+      if (a.hasOwnProperty(w))
+        return a[w];
+      var A = w.indexOf(".");
+      if (A != -1) {
+        var C = w.substr(0, A);
+        if (a.hasOwnProperty(C))
+          return e(a[C], w.substr(A + 1));
+      }
+    }
+  }
+  function r(a, w, A) {
+    i(a, w, [], A);
+  }
+  function i(a, w, A, C) {
+    var j, k;
+    if (w === 0) {
+      j = A.slice(0), j.push(a), C(j);
+      return;
+    }
+    o.ok(a !== null), o.equal(typeof a, "object"), o.equal(typeof w, "number"), o.ok(w >= 0);
+    for (k in a)
+      j = A.slice(0), j.push(k), i(a[k], w - 1, j, C);
+  }
+  function f(a, w) {
+    if (w === 0)
+      return [a];
+    o.ok(a !== null), o.equal(typeof a, "object"), o.equal(typeof w, "number"), o.ok(w >= 0);
+    var A = [], C;
+    for (C in a)
+      f(a[C], w - 1).forEach(function(j) {
+        A.push([C].concat(j));
+      });
+    return A;
+  }
+  function y(a, w) {
+    return a.substr(0, w.length) == w;
+  }
+  function _(a, w) {
+    return a.substr(
+      a.length - w.length,
+      w.length
+    ) == w;
+  }
+  function b(a) {
+    return typeof a == "number" && (a = new Date(a)), o.ok(a.constructor === Date), g.sprintf(
+      "%4d-%02d-%02dT%02d:%02d:%02d.%03dZ",
+      a.getUTCFullYear(),
+      a.getUTCMonth() + 1,
+      a.getUTCDate(),
+      a.getUTCHours(),
+      a.getUTCMinutes(),
+      a.getUTCSeconds(),
+      a.getUTCMilliseconds()
+    );
+  }
+  var x = [
+    "Jan",
+    "Feb",
+    "Mar",
+    "Apr",
+    "May",
+    "Jun",
+    "Jul",
+    "Aug",
+    "Sep",
+    "Oct",
+    "Nov",
+    "Dec"
+  ], E = [
+    "Sun",
+    "Mon",
+    "Tue",
+    "Wed",
+    "Thu",
+    "Fri",
+    "Sat"
+  ];
+  function I(a) {
+    return g.sprintf(
+      "%s, %02d %s %04d %02d:%02d:%02d GMT",
+      E[a.getUTCDay()],
+      a.getUTCDate(),
+      x[a.getUTCMonth()],
+      a.getUTCFullYear(),
+      a.getUTCHours(),
+      a.getUTCMinutes(),
+      a.getUTCSeconds()
+    );
+  }
+  function S(a) {
+    var w = +a;
+    return isNaN(w) ? new Date(a) : new Date(w);
+  }
+  var q = Number.MAX_SAFE_INTEGER || 9007199254740991, F = Number.MIN_SAFE_INTEGER || -9007199254740991, d = {
+    base: 10,
+    allowSign: !0,
+    allowPrefix: !1,
+    allowTrailing: !1,
+    allowImprecise: !1,
+    trimWhitespace: !1,
+    leadingZeroIsOctal: !1
+  }, c = 48, v = 57, O = 65, P = 66, R = 79, M = 84, $ = 88, L = 90, T = 97, he = 98, Ut = 111, Ft = 116, Dt = 120, Tt = 122, Nt = 48, kt = 55, $t = 87;
+  function Lt(a, w) {
+    o.string(a, "str"), o.optionalObject(w, "options");
+    var A = !1, C = d;
+    w && (A = s(w, "base"), C = $e(C, w), o.number(C.base, "options.base"), o.ok(C.base >= 2, "options.base >= 2"), o.ok(C.base <= 36, "options.base <= 36"), o.bool(C.allowSign, "options.allowSign"), o.bool(C.allowPrefix, "options.allowPrefix"), o.bool(
+      C.allowTrailing,
+      "options.allowTrailing"
+    ), o.bool(
+      C.allowImprecise,
+      "options.allowImprecise"
+    ), o.bool(
+      C.trimWhitespace,
+      "options.trimWhitespace"
+    ), o.bool(
+      C.leadingZeroIsOctal,
+      "options.leadingZeroIsOctal"
+    ), C.leadingZeroIsOctal && o.ok(
+      !A,
+      '"base" and "leadingZeroIsOctal" are mutually exclusive'
+    ));
+    var j, k = -1, z = C.base, X, ue = 1, fe = 0, D = 0, pe = a.length;
+    if (C.trimWhitespace)
+      for (; D < pe && De(a.charCodeAt(D)); )
+        ++D;
+    for (C.allowSign && (a[D] === "-" ? (D += 1, ue = -1) : a[D] === "+" && (D += 1)), a[D] === "0" && (C.allowPrefix && (k = Vt(a.charCodeAt(D + 1)), k !== -1 && (!A || k === z) && (z = k, D += 2)), k === -1 && C.leadingZeroIsOctal && (z = 8)), X = D; D < pe && (j = zt(a.charCodeAt(D)), j !== -1 && j < z); ++D)
+      fe *= z, fe += j;
+    if (X === D)
+      return new Error("invalid number: " + JSON.stringify(a));
+    if (C.trimWhitespace)
+      for (; D < pe && De(a.charCodeAt(D)); )
+        ++D;
+    if (D < pe && !C.allowTrailing)
+      return new Error("trailing characters after number: " + JSON.stringify(a.slice(D)));
+    if (fe === 0)
+      return 0;
+    var Le = fe * ue;
+    return !C.allowImprecise && (fe > q || Le < F) ? new Error("number is outside of the supported range: " + JSON.stringify(a.slice(X, D))) : Le;
+  }
+  function zt(a) {
+    return a >= c && a <= v ? a - Nt : a >= O && a <= L ? a - kt : a >= T && a <= Tt ? a - $t : -1;
+  }
+  function De(a) {
+    return a === 32 || a >= 9 && a <= 13 || a === 160 || a === 5760 || a === 6158 || a >= 8192 && a <= 8202 || a === 8232 || a === 8233 || a === 8239 || a === 8287 || a === 12288 || a === 65279;
+  }
+  function Vt(a) {
+    return a === he || a === P ? 2 : a === Ut || a === R ? 8 : a === Ft || a === M ? 10 : a === Dt || a === $ ? 16 : -1;
+  }
+  function Te(a, w) {
+    var A = u.validate(w, a);
+    if (A.errors.length === 0)
+      return null;
+    var C = A.errors[0], j = C.property, k = C.message.toLowerCase(), z, X;
+    (z = k.indexOf("the property ")) != -1 && (X = k.indexOf(" is not defined in the schema and the schema does not allow additional properties")) != -1 && (z += 13, j === "" ? j = k.substr(z, X - z) : j = j + "." + k.substr(z, X - z), k = "unsupported property");
+    var ue = new m.VError('property "%s": %s', j, k);
+    return ue.jsv_details = C, ue;
+  }
+  function Wt(a) {
+    return o.ok(
+      Array.isArray(a) && a.length > 0,
+      "randElt argument must be a non-empty array"
+    ), a[Math.floor(Math.random() * a.length)];
+  }
+  function Z(a) {
+    o.ok(
+      a[0] >= 0 && a[1] >= 0,
+      "negative numbers not allowed in hrtimes"
+    ), o.ok(a[1] < 1e9, "nanoseconds column overflow");
+  }
+  function Ne(a, w) {
+    Z(a), Z(w), o.ok(
+      a[0] > w[0] || a[0] == w[0] && a[1] >= w[1],
+      "negative differences not allowed"
+    );
+    var A = [a[0] - w[0], 0];
+    return a[1] >= w[1] ? A[1] = a[1] - w[1] : (A[0]--, A[1] = 1e9 - (w[1] - a[1])), A;
+  }
+  function Ht(a) {
+    return Z(a), Math.floor(a[0] * 1e9 + a[1]);
+  }
+  function Gt(a) {
+    return Z(a), Math.floor(a[0] * 1e6 + a[1] / 1e3);
+  }
+  function Jt(a) {
+    return Z(a), Math.floor(a[0] * 1e3 + a[1] / 1e6);
+  }
+  function ke(a, w) {
+    return Z(a), Z(w), a[1] += w[1], a[1] >= 1e9 && (a[0]++, a[1] -= 1e9), a[0] += w[0], a;
+  }
+  function Kt(a, w) {
+    Z(a);
+    var A = [a[0], a[1]];
+    return ke(A, w);
+  }
+  function Zt(a, w) {
+    o.ok(
+      typeof a == "object" && a !== null,
+      "obj argument must be a non-null object"
+    ), o.ok(
+      Array.isArray(w),
+      "allowed argument must be an array of strings"
+    );
+    for (var A = 0; A < w.length; A++)
+      o.ok(
+        typeof w[A] == "string",
+        "allowed argument must be an array of strings"
+      );
+    return Object.keys(a).filter(function(C) {
+      return w.indexOf(C) === -1;
+    });
+  }
+  function $e(a, w, A) {
+    var C, j;
+    if (C = {}, A)
+      for (j in A)
+        C[j] = A[j];
+    if (a)
+      for (j in a)
+        C[j] = a[j];
+    if (w)
+      for (j in w)
+        C[j] = w[j];
+    return C;
+  }
+  return B;
+}
+var Se, ct;
+function _r() {
+  if (ct) return Se;
+  ct = 1;
+  var o = /* @__PURE__ */ qe(), g = /* @__PURE__ */ pr(), m = de;
+  function u(d, c, v) {
+    Error.captureStackTrace && Error.captureStackTrace(this, u), this.input = d, this.message = c, v !== void 0 && (this.message += " at index " + v);
+  }
+  m.inherits(u, Error);
+  function l(d, c) {
+    return (c + d % c) % c;
+  }
+  function p(d) {
+    var c;
+    return c = (d[0] >> 8) + "." + (d[0] & 255) + ".", c += (d[1] >> 8) + "." + (d[1] & 255), c;
+  }
+  function h(d) {
+    return !!(typeof d == "object" && Array.isArray(d._fields) && typeof d._attrs == "object");
+  }
+  function s(d) {
+    if (typeof d == "string")
+      return I(d);
+    if (h(d))
+      return d;
+    throw new Error("Invalid argument: Addr or parsable string expected");
+  }
+  function n(d, c, v) {
+    var O, P = null, R = 0;
+    if (c) {
+      var M = null, $ = null;
+      for (O = 0; O < d.length; O++)
+        d[O] === 0 ? M === null ? (M = O, $ = 1) : $++ : M !== null && ($ > R && (P = M, R = $), M = null);
+      M !== null && $ > R && (P = M, R = $);
+    }
+    var L = [], T;
+    for (O = 0; O < d.length; O++) {
+      if (P !== null) {
+        if (O === P) {
+          if (R === 8)
+            return ["::"];
+          P === 0 || P + R === d.length ? L.push(":") : L.push("");
+        }
+        if (O >= P && O < P + R)
+          continue;
+      }
+      T = d[O].toString(16), v && T.length != 4 && (T = "0000".slice(T.length) + T), L.push(T);
+    }
+    return L;
+  }
+  function t(d) {
+    var c = [0, 0, 0, 0, 0, 65535], v;
+    for (v = 0; v < 6; v++)
+      if (d[v] != c[v])
+        return !1;
+    return !0;
+  }
+  function e(d) {
+    o.number(d), d = d | 0, o.ok(d <= 128), o.ok(d >= 0);
+    var c = new y(), v;
+    for (v = 0; d > 16; v++, d -= 16)
+      c._fields[v] = 65535;
+    return d > 0 && (c._fields[v] = 65535 - ((1 << 16 - d) - 1)), c;
+  }
+  function r(d) {
+    if (typeof d == "string")
+      return new _(d);
+    if (d instanceof _)
+      return d;
+    throw new Error("Invalid argument: CIDR or parsable string expected");
+  }
+  var i = {
+    format: "auto",
+    // Control format of printed address
+    zeroElide: !0,
+    // Elide longest run of zeros
+    zeroPad: !1
+    // Pad with zeros when a group would print as < 4 chars
+  };
+  function f(d, c) {
+    return d && d.hasOwnProperty(c) ? d[c] : i[c];
+  }
+  function y() {
+    this._fields = [0, 0, 0, 0, 0, 0, 0, 0], this._attrs = {};
+  }
+  y.prototype.kind = function() {
+    return b.contains(this) ? "ipv4" : "ipv6";
+  }, y.prototype.toString = function(c) {
+    o.optionalObject(c, "opts");
+    var v = f(c, "format"), O = f(c, "zeroElide"), P = f(c, "zeroPad");
+    switch (o.string(v, "opts.format"), o.bool(O, "opts.zeroElide"), o.bool(P, "opts.zeroPad"), v === "auto" && (this._attrs.ipv4Bare ? v = "v4" : this._attrs.ipv4Mapped ? v = "v4-mapped" : v = "v6"), v) {
+      // Print in dotted-quad notation (but only if truly IPv4)
+      case "v4":
+        if (!b.contains(this))
+          throw new Error("cannot print non-v4 address in dotted quad notation");
+        return p(this._fields.slice(6));
+      // Print as an IPv4-mapped IPv6 address
+      case "v4-mapped":
+        if (!b.contains(this))
+          throw new Error("cannot print non-v4 address as a v4-mapped address");
+        var R = n(this._fields.slice(0, 6), O, P);
+        return R.push(p(this._fields.slice(6))), R.join(":");
+      // Print as an IPv6 address
+      case "v6":
+        return n(this._fields, O, P).join(":");
+      // Unrecognized formatting method
+      default:
+        throw new Error('unrecognized format method "' + v + '"');
+    }
+  }, y.prototype.toBuffer = function(c) {
+    if (c !== void 0) {
+      if (!Buffer.isBuffer(c))
+        throw new Error("optional arg must be Buffer");
+    } else
+      c = new Buffer(16);
+    var v;
+    for (v = 0; v < 8; v++)
+      c.writeUInt16BE(this._fields[v], v * 2);
+    return c;
+  }, y.prototype.toLong = function() {
+    if (!b.contains(this))
+      throw new Error("only possible for ipv4-mapped addresses");
+    return (this._fields[6] << 16 >>> 0) + this._fields[7];
+  }, y.prototype.clone = function() {
+    var c = new y();
+    c._fields = this._fields.slice();
+    for (var v in this._attrs)
+      c._attrs[v] = this._attrs[v];
+    return c;
+  }, y.prototype.offset = function(c) {
+    if (c < -4294967295 || c > 4294967295)
+      throw new Error("offsets should be between -4294967295 and 4294967295");
+    var v = this.clone(), O, P;
+    for (O = 7; O >= 0 && (P = v._fields[O] + c, P > 65535 ? (c = P >>> 16, P = P & 65535) : P < 0 ? (c = Math.floor(P / 65536), P = l(P, 65536)) : c = 0, v._fields[O] = P, c !== 0); O--)
+      if (O === 0 || O === 6 && this._attrs.ipv4Mapped)
+        return null;
+    return v;
+  }, y.prototype.and = function(c) {
+    c = s(c);
+    var v, O = this.clone();
+    for (v = 0; v < 8; v++)
+      O._fields[v] = O._fields[v] & c._fields[v];
+    return O;
+  }, y.prototype.or = function(c) {
+    c = s(c);
+    var v, O = this.clone();
+    for (v = 0; v < 8; v++)
+      O._fields[v] = O._fields[v] | c._fields[v];
+    return O;
+  }, y.prototype.not = function() {
+    var c, v = this.clone();
+    for (c = 0; c < 8; c++)
+      v._fields[c] = ~v._fields[c] & 65535;
+    return v;
+  }, y.prototype.compare = function(c) {
+    return F(this, c);
+  };
+  function _(d, c) {
+    if (c === void 0) {
+      o.string(d);
+      var v = d.match(/^([a-fA-F0-9:.]+)\/([0-9]+)$/);
+      if (v === null)
+        throw new Error("Invalid argument: <addr>/<prefix> expected");
+      d = v[1], c = parseInt(v[2], 10);
+    }
+    if (o.number(c), c = c | 0, d = s(d), d._attrs.ipv4Bare && (c += 96), c < 0 || c > 128)
+      throw new Error("Invalid prefix length");
+    this._prefix = c, this._mask = e(c), this._addr = d.and(this._mask);
+  }
+  _.prototype.contains = function(c) {
+    return c = s(c), this._addr.compare(c.and(this._mask)) === 0;
+  }, _.prototype.first = function() {
+    return this._prefix >= 127 ? this._addr : this._addr.offset(1);
+  }, _.prototype.last = function() {
+    var c = this._addr.or(this._mask.not());
+    return this._prefix >= 127 ? c : this._addr._attrs.ipv4Mapped ? c.offset(-1) : c;
+  }, _.prototype.broadcast = function() {
+    if (!b.contains(this._addr))
+      throw new Error("Only IPv4 networks have broadcast addresses");
+    return this._addr.or(this._mask.not());
+  }, _.prototype.compare = function(c) {
+    return x(this, c);
+  }, _.prototype.prefixLength = function(c) {
+    switch (o.optionalString(c, "format"), (c === void 0 || c === "auto") && (c = this._addr._attrs.ipv4Bare ? "v4" : "v6"), c) {
+      case "v4":
+        if (!b.contains(this._addr))
+          throw new Error("cannot return v4 prefix length for non-v4 address");
+        return this._prefix - 96;
+      case "v6":
+        return this._prefix;
+      default:
+        throw new Error('unrecognized format method "' + c + '"');
+    }
+  }, _.prototype.address = function() {
+    return this._addr;
+  }, _.prototype.toString = function(c) {
+    o.optionalObject(c, "opts");
+    var v = f(c, "format");
+    return v === "v4-mapped" && (v = "v6"), this._addr.toString(c) + "/" + this.prefixLength(v);
+  };
+  var b = new _("::ffff:0:0", 96);
+  function x(d, c) {
+    d = r(d), c = r(c);
+    var v = F(d._addr, c._addr);
+    return v === 0 ? c._prefix - d._prefix : v;
+  }
+  function E(d, c) {
+    if (d = s(d), c = s(c), d.compare(c) > 0)
+      throw new Error("begin address must be <= end address");
+    this._begin = d, this._end = c;
+  }
+  E.prototype.contains = function(c) {
+    return c = s(c), this._begin.compare(c) <= 0 && this._end.compare(c) >= 0;
+  }, E.prototype.first = function() {
+    return this._begin;
+  }, E.prototype.last = function() {
+    return this._end;
+  };
+  function I(d) {
+    if (typeof d == "string")
+      return S(d);
+    if (typeof d == "number")
+      return q(d);
+    if (typeof d == "object" && h(d))
+      return d;
+    throw new Error("Invalid argument: only string|number allowed");
+  }
+  function S(d) {
+    o.string(d), d = d.toLowerCase();
+    var c = new y(), v = [], O = [], P = null, R = "", M, $;
+    if (d.length > 40)
+      throw new u(d, "Input too long");
+    for (M = 0; M < d.length; M++)
+      if ($ = d[M], $ === ":")
+        if (M + 1 < d.length && d[M + 1] === ":") {
+          if (P !== null)
+            throw new u(d, "Multiple :: delimiters", M);
+          R !== "" && (v.push(R), R = ""), P = v.length, M++;
+        } else {
+          if (R === "")
+            throw new u(d, "illegal delimiter", M);
+          v.push(R), R = "";
+        }
+      else $ === "." ? (O.push(R), R = "") : R = R + $;
+    if (R !== "")
+      O.length !== 0 ? O.push(R) : v.push(R), R = "";
+    else if (P !== v.length || O.length > 0)
+      throw new u(d, "Cannot end with delimiter besides ::");
+    if (O.length === 0) {
+      if (v.length > 8)
+        throw new u(d, "Too many fields");
+      if (v.length < 8 && P === null)
+        throw new u(d, "Too few fields");
+    } else {
+      if (O.length !== 4)
+        throw new u(d, "IPv4 portion must have 4 fields");
+      if (v.length === 0 && P === null && (c._attrs.ipv4Bare = !0, v = ["ffff"], P = 0), v.length > 6)
+        throw new u(d, "Too many fields");
+      if (v.length < 6 && P === null)
+        throw new u(d, "Too few fields");
+    }
+    var L, T;
+    for (M = 0; M < v.length; M++) {
+      if (L = v[M], T = g.parseInteger(L, { base: 16, allowSign: !1 }), T instanceof Error || T < 0 || T > 65535)
+        throw new u(d, "Invalid field value: " + L);
+      v[M] = T;
+    }
+    for (M = 0; M < O.length; M++) {
+      if (L = O[M], T = g.parseInteger(L, { base: 10, allowSign: !1 }), T instanceof Error || T < 0 || T > 255)
+        throw new u(d, "Invalid field value: " + L);
+      O[M] = T;
+    }
+    if (O.length !== 0 && (v.push(O[0] * 256 + O[1]), v.push(O[2] * 256 + O[3])), v.length < 8 && P !== null) {
+      var he = [];
+      for (M = 0; M < 8 - v.length; M++)
+        he.push(0);
+      v = Array.prototype.concat(
+        v.slice(0, P),
+        he,
+        v.slice(P)
+      );
+    }
+    if (O.length !== 0)
+      if (t(v))
+        c._attrs.ipv4Mapped = !0;
+      else
+        throw new u(d, "invalid dotted-quad notation");
+    return c._fields = v, c;
+  }
+  function q(d) {
+    if (o.number(d), d !== Math.floor(d))
+      throw new Error("Value must be integer");
+    if (d < 0 || d > 4294967295)
+      throw new Error("Value must be 32 bit");
+    var c = new y();
+    return c._fields[7] = d & 65535, c._fields[6] = d >>> 16, c._fields[5] = 65535, c._attrs.ipv4Bare = !0, c._attrs.ipv4Mapped = !0, c;
+  }
+  function F(d, c) {
+    d = s(d), c = s(c);
+    var v;
+    for (v = 0; v < 8; v++) {
+      if (d._fields[v] < c._fields[v])
+        return -1;
+      if (d._fields[v] > c._fields[v])
+        return 1;
+    }
+    return 0;
+  }
+  return Se = {
+    parse: I,
+    compare: F,
+    createCIDR: function(d, c) {
+      return new _(d, c);
+    },
+    compareCIDR: x,
+    createAddrRange: function(d, c) {
+      return new E(d, c);
+    }
+  }, Se;
+}
+var U = {}, be = {}, lt;
+function vr() {
+  if (lt) return be;
+  lt = 1, Object.defineProperty(be, "__esModule", { value: !0 });
+  let o = class {
+    constructor(m, u, l) {
+      this.ipAddress = u, this.isAnonymous = !!m.is_anonymous, this.isAnonymousVpn = !!m.is_anonymous_vpn, this.isHostingProvider = !!m.is_hosting_provider, this.isPublicProxy = !!m.is_public_proxy, this.isResidentialProxy = !!m.is_residential_proxy, this.isTorExitNode = !!m.is_tor_exit_node, this.network = l;
+    }
+  };
+  return be.default = o, be;
+}
+var we = {}, dt;
+function Rt() {
+  if (dt) return we;
+  dt = 1, Object.defineProperty(we, "__esModule", { value: !0 });
+  let o = class {
+    constructor(m, u, l) {
+      this.autonomousSystemNumber = m.autonomous_system_number, this.autonomousSystemOrganization = m.autonomous_system_organization, this.ipAddress = u, this.network = l;
+    }
+  };
+  return we.default = o, we;
+}
+var ie = {}, Y = {}, ht;
+function jt() {
+  if (ht) return Y;
+  ht = 1, Object.defineProperty(Y, "__esModule", { value: !0 }), Y.camelcaseKeys = Y.snakeToCamelCase = void 0;
+  function o(l) {
+    return l.replace(/_+(\w?)/g, (p, h, s) => s === 0 ? h : h.toUpperCase());
+  }
+  Y.snakeToCamelCase = o;
+  const g = (l) => typeof l == "object" && l !== null && !Array.isArray(l) && !(l instanceof RegExp) && !(l instanceof Error) && !(l instanceof Date), m = (l) => l.map((p) => Array.isArray(p) ? m(p) : g(p) ? u(p) : p);
+  function u(l) {
+    if (Array.isArray(l))
+      return m(l);
+    const p = {};
+    for (const [h, s] of Object.entries(l))
+      Array.isArray(s) ? p[o(h)] = m(s) : g(s) ? p[o(h)] = u(s) : p[o(h)] = s;
+    return p;
+  }
+  return Y.camelcaseKeys = u, Y;
+}
+var Ee = {}, pt;
+function Bt() {
+  if (pt) return Ee;
+  pt = 1, Object.defineProperty(Ee, "__esModule", { value: !0 });
+  const o = /* @__PURE__ */ jt();
+  let g = class {
+    constructor(u, l, p) {
+      var h, s, n, t;
+      const e = (0, o.camelcaseKeys)(u);
+      this.continent = e.continent || void 0, this.country = e.country || void 0, this.maxmind = e.maxmind || void 0, this.registeredCountry = this.setBooleanRegisteredCountry(e.registeredCountry) || void 0, this.representedCountry = e.representedCountry || void 0, this.traits = this.setBooleanTraits(e.traits || {}), (h = (n = this.traits).ipAddress) !== null && h !== void 0 || (n.ipAddress = l), (s = (t = this.traits).network) !== null && s !== void 0 || (t.network = p);
+    }
+    setBooleanTraits(u) {
+      return [
+        "isAnonymous",
+        "isAnonymousProxy",
+        "isAnonymousVpn",
+        "isAnycast",
+        "isHostingProvider",
+        "isLegitimateProxy",
+        "isPublicProxy",
+        "isResidentialProxy",
+        "isSatelliteProvider",
+        "isTorExitNode"
+      ].forEach((p) => {
+        u[p] = !!u[p];
+      }), u;
+    }
+    setBooleanRegisteredCountry(u) {
+      return u && (u.isInEuropeanUnion = !!u.isInEuropeanUnion), u;
+    }
+  };
+  return Ee.default = g, Ee;
+}
+var _t;
+function Ue() {
+  if (_t) return ie;
+  _t = 1;
+  var o = ie && ie.__importDefault || function(l) {
+    return l && l.__esModule ? l : { default: l };
+  };
+  Object.defineProperty(ie, "__esModule", { value: !0 });
+  const g = /* @__PURE__ */ jt(), m = o(/* @__PURE__ */ Bt());
+  let u = class extends m.default {
+    constructor(p, h, s) {
+      super(p, h, s);
+      const n = (0, g.camelcaseKeys)(p);
+      this.city = n.city || void 0, this.location = n.location || void 0, this.postal = n.postal || void 0, this.subdivisions = n.subdivisions || void 0;
+    }
+  };
+  return ie.default = u, ie;
+}
+var xe = {}, vt;
+function mr() {
+  if (vt) return xe;
+  vt = 1, Object.defineProperty(xe, "__esModule", { value: !0 });
+  let o = class {
+    constructor(m, u, l) {
+      this.connectionType = m.connection_type, this.ipAddress = u, this.network = l;
+    }
+  };
+  return xe.default = o, xe;
+}
+var Ie = {}, mt;
+function yr() {
+  if (mt) return Ie;
+  mt = 1, Object.defineProperty(Ie, "__esModule", { value: !0 });
+  let o = class {
+    constructor(m, u, l) {
+      this.domain = m.domain, this.ipAddress = u, this.network = l;
+    }
+  };
+  return Ie.default = o, Ie;
+}
+var oe = {}, yt;
+function gr() {
+  if (yt) return oe;
+  yt = 1;
+  var o = oe && oe.__importDefault || function(u) {
+    return u && u.__esModule ? u : { default: u };
+  };
+  Object.defineProperty(oe, "__esModule", { value: !0 });
+  const g = o(/* @__PURE__ */ Ue());
+  let m = class extends g.default {
+    constructor(l, p, h) {
+      super(l, p, h);
+    }
+  };
+  return oe.default = m, oe;
+}
+var se = {}, gt;
+function br() {
+  if (gt) return se;
+  gt = 1;
+  var o = se && se.__importDefault || function(u) {
+    return u && u.__esModule ? u : { default: u };
+  };
+  Object.defineProperty(se, "__esModule", { value: !0 });
+  const g = o(/* @__PURE__ */ Ue());
+  let m = class extends g.default {
+    constructor(l) {
+      super(l);
+    }
+  };
+  return se.default = m, se;
+}
+var ae = {}, bt;
+function wr() {
+  if (bt) return ae;
+  bt = 1;
+  var o = ae && ae.__importDefault || function(u) {
+    return u && u.__esModule ? u : { default: u };
+  };
+  Object.defineProperty(ae, "__esModule", { value: !0 });
+  const g = o(/* @__PURE__ */ Rt());
+  let m = class extends g.default {
+    constructor(l, p, h) {
+      super(l, p, h), this.isp = l.isp, this.mobileCountryCode = l.mobile_country_code, this.mobileNetworkCode = l.mobile_network_code, this.organization = l.organization;
+    }
+  };
+  return ae.default = m, ae;
+}
+var wt;
+function Fe() {
+  if (wt) return U;
+  wt = 1;
+  var o = U && U.__importDefault || function(e) {
+    return e && e.__esModule ? e : { default: e };
+  };
+  Object.defineProperty(U, "__esModule", { value: !0 }), U.Isp = U.Insights = U.Enterprise = U.Domain = U.Country = U.ConnectionType = U.City = U.Asn = U.AnonymousIP = void 0;
+  const g = o(/* @__PURE__ */ vr());
+  U.AnonymousIP = g.default;
+  const m = o(/* @__PURE__ */ Rt());
+  U.Asn = m.default;
+  const u = o(/* @__PURE__ */ Ue());
+  U.City = u.default;
+  const l = o(/* @__PURE__ */ mr());
+  U.ConnectionType = l.default;
+  const p = o(/* @__PURE__ */ Bt());
+  U.Country = p.default;
+  const h = o(/* @__PURE__ */ yr());
+  U.Domain = h.default;
+  const s = o(/* @__PURE__ */ gr());
+  U.Enterprise = s.default;
+  const n = o(/* @__PURE__ */ br());
+  U.Insights = n.default;
+  const t = o(/* @__PURE__ */ wr());
+  return U.Isp = t.default, U;
+}
+var Et;
+function qt() {
+  if (Et) return W;
+  Et = 1;
+  var o = W && W.__createBinding || (Object.create ? (function(n, t, e, r) {
+    r === void 0 && (r = e);
+    var i = Object.getOwnPropertyDescriptor(t, e);
+    (!i || ("get" in i ? !t.__esModule : i.writable || i.configurable)) && (i = { enumerable: !0, get: function() {
+      return t[e];
+    } }), Object.defineProperty(n, r, i);
+  }) : (function(n, t, e, r) {
+    r === void 0 && (r = e), n[r] = t[e];
+  })), g = W && W.__setModuleDefault || (Object.create ? (function(n, t) {
+    Object.defineProperty(n, "default", { enumerable: !0, value: t });
+  }) : function(n, t) {
+    n.default = t;
+  }), m = W && W.__importStar || function(n) {
+    if (n && n.__esModule) return n;
+    var t = {};
+    if (n != null) for (var e in n) e !== "default" && Object.prototype.hasOwnProperty.call(n, e) && o(t, n, e);
+    return g(t, n), t;
+  };
+  Object.defineProperty(W, "__esModule", { value: !0 });
+  const u = /* @__PURE__ */ _r(), l = /* @__PURE__ */ je(), p = /* @__PURE__ */ Be(), h = m(/* @__PURE__ */ Fe());
+  class s {
+    constructor(t) {
+      this.mmdbReader = t;
+    }
+    anonymousIP(t) {
+      return this.modelFor(h.AnonymousIP, "GeoIP2-Anonymous-IP", t, "anonymousIP()");
+    }
+    city(t) {
+      return this.modelFor(h.City, "City", t, "city()");
+    }
+    country(t) {
+      return this.modelFor(h.Country, "Country", t, "country()");
+    }
+    asn(t) {
+      return this.modelFor(h.Asn, "ASN", t, "asn()");
+    }
+    connectionType(t) {
+      return this.modelFor(h.ConnectionType, "Connection-Type", t, "connectionType()");
+    }
+    domain(t) {
+      return this.modelFor(h.Domain, "Domain", t, "domain()");
+    }
+    isp(t) {
+      return this.modelFor(h.Isp, "ISP", t, "isp()");
+    }
+    enterprise(t) {
+      return this.modelFor(h.Enterprise, "Enterprise", t, "enterprise()");
+    }
+    getRecord(t, e, r) {
+      const i = this.mmdbReader.metadata.databaseType;
+      if (!l.validate(e))
+        throw new p.ValueError(`${e} is invalid`);
+      if (!i.includes(t))
+        throw new p.BadMethodCallError(`The ${r} method cannot be used with the ${i} database`);
+      const [f, y] = this.mmdbReader.getWithPrefixLength(e);
+      if (!f)
+        throw new p.AddressNotFoundError(`The address ${e} is not in the database`);
+      return [f, u.createCIDR(e, y).toString()];
+    }
+    modelFor(t, e, r, i) {
+      const [f, y] = this.getRecord(e, r, i);
+      return new t(f, r, y);
+    }
+  }
+  return W.default = s, W;
+}
+var xt;
+function Er() {
+  if (xt) return Q;
+  xt = 1;
+  var o = Q && Q.__importDefault || function(p) {
+    return p && p.__esModule ? p : { default: p };
+  };
+  Object.defineProperty(Q, "__esModule", { value: !0 });
+  const g = /* @__PURE__ */ je(), m = /* @__PURE__ */ Be(), u = o(/* @__PURE__ */ qt());
+  class l {
+    static open(h, s) {
+      return g.open(h, s).then((n) => new u.default(n));
+    }
+    static openBuffer(h) {
+      let s;
+      try {
+        s = new g.Reader(h);
+      } catch (n) {
+        throw new m.InvalidDbBufferError(n);
+      }
+      return new u.default(s);
+    }
+  }
+  return Q.default = l, Q;
+}
+var H = {};
+const xr = "5.0.0", Ir = {
+  version: xr
+};
+var It;
+function Or() {
+  if (It) return H;
+  It = 1;
+  var o = H && H.__createBinding || (Object.create ? (function(n, t, e, r) {
+    r === void 0 && (r = e);
+    var i = Object.getOwnPropertyDescriptor(t, e);
+    (!i || ("get" in i ? !t.__esModule : i.writable || i.configurable)) && (i = { enumerable: !0, get: function() {
+      return t[e];
+    } }), Object.defineProperty(n, r, i);
+  }) : (function(n, t, e, r) {
+    r === void 0 && (r = e), n[r] = t[e];
+  })), g = H && H.__setModuleDefault || (Object.create ? (function(n, t) {
+    Object.defineProperty(n, "default", { enumerable: !0, value: t });
+  }) : function(n, t) {
+    n.default = t;
+  }), m = H && H.__importStar || function(n) {
+    if (n && n.__esModule) return n;
+    var t = {};
+    if (n != null) for (var e in n) e !== "default" && Object.prototype.hasOwnProperty.call(n, e) && o(t, n, e);
+    return g(t, n), t;
+  };
+  Object.defineProperty(H, "__esModule", { value: !0 });
+  const u = Qt, l = /* @__PURE__ */ je(), p = Ir, h = m(/* @__PURE__ */ Fe());
+  class s {
+    constructor(t, e, r) {
+      if (this.timeout = 3e3, this.host = "geoip.maxmind.com", this.accountID = t, this.licenseKey = e, r !== void 0) {
+        if (typeof r == "object") {
+          r.host !== void 0 && (this.host = r.host), r.timeout !== void 0 && (this.timeout = r.timeout);
+          return;
+        }
+        this.timeout = r;
+      }
+    }
+    city(t) {
+      return this.responseFor("city", t, h.City);
+    }
+    country(t) {
+      return this.responseFor("country", t, h.Country);
+    }
+    insights(t) {
+      return this.responseFor("insights", t, h.Insights);
+    }
+    responseFor(t, e, r) {
+      const i = `/geoip/v2.1/${t}/${e}`, f = `https://${this.host}${i}`;
+      if (!l.validate(e))
+        return Promise.reject({
+          code: "IP_ADDRESS_INVALID",
+          error: "The IP address provided is invalid",
+          url: f
+        });
+      const y = {
+        auth: `${this.accountID}:${this.licenseKey}`,
+        headers: {
+          Accept: "application/json",
+          "User-Agent": `GeoIP2-node/${p.version}`
+        },
+        host: this.host,
+        method: "GET",
+        path: i,
+        timeout: this.timeout
+      };
+      return new Promise((_, b) => {
+        const x = u.request(y, (E) => {
+          let I = "";
+          E.on("data", (S) => {
+            I += S;
+          }), E.on("end", () => {
+            try {
+              I = JSON.parse(I);
+            } catch {
+              return b(this.handleError({}, E, f));
+            }
+            return E.statusCode && E.statusCode !== 200 ? b(this.handleError(I, E, f)) : _(new r(I));
+          });
+        });
+        x.on("error", (E) => b({
+          code: E.code,
+          error: E.message,
+          url: f
+        })), x.end();
+      });
+    }
+    handleError(t, e, r) {
+      return e.statusCode && e.statusCode >= 500 && e.statusCode < 600 ? {
+        code: "SERVER_ERROR",
+        error: `Received a server error with HTTP status code: ${e.statusCode}`,
+        url: r
+      } : e.statusCode && (e.statusCode < 400 || e.statusCode >= 600) ? {
+        code: "HTTP_STATUS_CODE_ERROR",
+        error: `Received an unexpected HTTP status code: ${e.statusCode}`,
+        url: r
+      } : !t.code || !t.error ? {
+        code: "INVALID_RESPONSE_BODY",
+        error: "Received an invalid or unparseable response body",
+        url: r
+      } : Object.assign(Object.assign({}, t), { url: r });
+    }
+  }
+  return H.default = s, H;
+}
+var Me = {}, Ot;
+function Ar() {
+  return Ot || (Ot = 1, Object.defineProperty(Me, "__esModule", { value: !0 })), Me;
+}
+var At;
+function Cr() {
+  return At || (At = 1, (function(o) {
+    var g = G && G.__createBinding || (Object.create ? (function(s, n, t, e) {
+      e === void 0 && (e = t);
+      var r = Object.getOwnPropertyDescriptor(n, t);
+      (!r || ("get" in r ? !n.__esModule : r.writable || r.configurable)) && (r = { enumerable: !0, get: function() {
+        return n[t];
+      } }), Object.defineProperty(s, e, r);
+    }) : (function(s, n, t, e) {
+      e === void 0 && (e = t), s[e] = n[t];
+    })), m = G && G.__exportStar || function(s, n) {
+      for (var t in s) t !== "default" && !Object.prototype.hasOwnProperty.call(n, t) && g(n, s, t);
+    }, u = G && G.__importDefault || function(s) {
+      return s && s.__esModule ? s : { default: s };
+    };
+    Object.defineProperty(o, "__esModule", { value: !0 }), o.WebServiceClient = o.ReaderModel = o.Reader = void 0;
+    const l = u(/* @__PURE__ */ Er());
+    o.Reader = l.default;
+    const p = u(/* @__PURE__ */ Or());
+    o.WebServiceClient = p.default;
+    const h = u(/* @__PURE__ */ qt());
+    o.ReaderModel = h.default, m(/* @__PURE__ */ Ar(), o), m(/* @__PURE__ */ Fe(), o), m(/* @__PURE__ */ Be(), o);
+  })(G)), G;
+}
+var Pr = /* @__PURE__ */ Cr();
+const Vr = /* @__PURE__ */ er({
+  __proto__: null
+}, [Pr]);
+export {
+  Vr as i
+};