var __bare_os_bundle_exports__ = (() => {
  var __create = Object.create;
  var __defProp = Object.defineProperty;
  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
  var __getOwnPropNames = Object.getOwnPropertyNames;
  var __getProtoOf = Object.getPrototypeOf;
  var __hasOwnProp = Object.prototype.hasOwnProperty;
  var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
    get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
  }) : x)(function(x) {
    if (typeof require !== "undefined") return require.apply(this, arguments);
    throw Error('Dynamic require of "' + x + '" is not supported');
  });
  var __esm = (fn, res) => function __init() {
    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
  };
  var __commonJS = (cb, mod) => function __require2() {
    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
  };
  var __export = (target, all) => {
    for (var name in all)
      __defProp(target, name, { get: all[name], enumerable: true });
  };
  var __copyProps = (to, from, except, desc) => {
    if (from && typeof from === "object" || typeof from === "function") {
      for (let key of __getOwnPropNames(from))
        if (!__hasOwnProp.call(to, key) && key !== except)
          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
    }
    return to;
  };
  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
    // If the importer is in node compatibility mode or this is not an ESM
    // file that has been converted to a CommonJS file using a Babel-
    // compatible transform (i.e. "__esModule" has not been set), then set
    // "default" to the CommonJS "module.exports" for node compatibility.
    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
    mod
  ));
  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

  // ../../node_modules/which-runtime/index.js
  var require_which_runtime = __commonJS({
    "../../node_modules/which-runtime/index.js"(exports) {
      var { runtime, platform, arch } = typeof Bare !== "undefined" ? { runtime: "bare", platform: global.Bare.platform, arch: global.Bare.arch } : typeof process !== "undefined" ? { runtime: "node", platform: global.process.platform, arch: global.process.arch } : typeof Window !== "undefined" ? { runtime: "browser", platform: "unknown", arch: "unknown" } : { runtime: "unknown", platform: "unknown", arch: "unknown" };
      exports.runtime = runtime;
      exports.platform = platform;
      exports.arch = arch;
      exports.isBare = runtime === "bare";
      exports.isBareKit = exports.isBare && typeof BareKit !== "undefined";
      exports.isPear = typeof Pear !== "undefined";
      exports.isNode = runtime === "node";
      exports.isBrowser = runtime === "browser";
      exports.isWindows = platform === "win32";
      exports.isLinux = platform === "linux";
      exports.isMac = platform === "darwin";
      exports.isIOS = platform === "ios" || platform === "ios-simulator";
      exports.isAndroid = platform === "android";
      exports.isElectron = typeof process !== "undefined" && !!global.process.versions?.electron;
      exports.isElectronRenderer = exports.isElectron && global.process.type === "renderer";
      exports.isElectronWorker = exports.isElectron && global.process.type === "worker";
    }
  });

  // ../../node_modules/fast-fifo/fixed-size.js
  var require_fixed_size = __commonJS({
    "../../node_modules/fast-fifo/fixed-size.js"(exports, module) {
      module.exports = class FixedFIFO {
        constructor(hwm) {
          if (!(hwm > 0) || (hwm - 1 & hwm) !== 0) throw new Error("Max size for a FixedFIFO should be a power of two");
          this.buffer = new Array(hwm);
          this.mask = hwm - 1;
          this.top = 0;
          this.btm = 0;
          this.next = null;
        }
        clear() {
          this.top = this.btm = 0;
          this.next = null;
          this.buffer.fill(void 0);
        }
        push(data) {
          if (this.buffer[this.top] !== void 0) return false;
          this.buffer[this.top] = data;
          this.top = this.top + 1 & this.mask;
          return true;
        }
        shift() {
          const last = this.buffer[this.btm];
          if (last === void 0) return void 0;
          this.buffer[this.btm] = void 0;
          this.btm = this.btm + 1 & this.mask;
          return last;
        }
        peek() {
          return this.buffer[this.btm];
        }
        isEmpty() {
          return this.buffer[this.btm] === void 0;
        }
      };
    }
  });

  // ../../node_modules/fast-fifo/index.js
  var require_fast_fifo = __commonJS({
    "../../node_modules/fast-fifo/index.js"(exports, module) {
      var FixedFIFO = require_fixed_size();
      module.exports = class FastFIFO {
        constructor(hwm) {
          this.hwm = hwm || 16;
          this.head = new FixedFIFO(this.hwm);
          this.tail = this.head;
          this.length = 0;
        }
        clear() {
          this.head = this.tail;
          this.head.clear();
          this.length = 0;
        }
        push(val) {
          this.length++;
          if (!this.head.push(val)) {
            const prev = this.head;
            this.head = prev.next = new FixedFIFO(2 * this.head.buffer.length);
            this.head.push(val);
          }
        }
        shift() {
          if (this.length !== 0) this.length--;
          const val = this.tail.shift();
          if (val === void 0 && this.tail.next) {
            const next = this.tail.next;
            this.tail.next = null;
            this.tail = next;
            return this.tail.shift();
          }
          return val;
        }
        peek() {
          const val = this.tail.peek();
          if (val === void 0 && this.tail.next) return this.tail.next.peek();
          return val;
        }
        isEmpty() {
          return this.length === 0;
        }
      };
    }
  });

  // ../../node_modules/bare-events/lib/errors.js
  var require_errors = __commonJS({
    "../../node_modules/bare-events/lib/errors.js"(exports, module) {
      module.exports = class EventEmitterError extends Error {
        constructor(msg, code, fn = EventEmitterError, opts) {
          super(`${code}: ${msg}`, opts);
          this.code = code;
          if (Error.captureStackTrace) {
            Error.captureStackTrace(this, fn);
          }
        }
        get name() {
          return "EventEmitterError";
        }
        static OPERATION_ABORTED(cause, msg = "Operation aborted") {
          return new EventEmitterError(msg, "OPERATION_ABORTED", EventEmitterError.OPERATION_ABORTED, {
            cause
          });
        }
        static UNHANDLED_ERROR(cause, msg = "Unhandled error") {
          return new EventEmitterError(msg, "UNHANDLED_ERROR", EventEmitterError.UNHANDLED_ERROR, {
            cause
          });
        }
      };
    }
  });

  // ../../node_modules/bare-events/index.js
  var require_bare_events = __commonJS({
    "../../node_modules/bare-events/index.js"(exports, module) {
      var errors = require_errors();
      var EventListener = class {
        constructor() {
          this.list = [];
          this.count = 0;
        }
        append(ctx, name, fn, once) {
          this.count++;
          ctx.emit("newListener", name, fn);
          this.list.push([fn, once]);
        }
        prepend(ctx, name, fn, once) {
          this.count++;
          ctx.emit("newListener", name, fn);
          this.list.unshift([fn, once]);
        }
        remove(ctx, name, fn) {
          for (let i = 0, n = this.list.length; i < n; i++) {
            const l = this.list[i];
            if (l[0] === fn) {
              this.list.splice(i, 1);
              if (this.count === 1) delete ctx._events[name];
              ctx.emit("removeListener", name, fn);
              this.count--;
              return;
            }
          }
        }
        removeAll(ctx, name) {
          const list = [...this.list];
          this.list = [];
          if (this.count === list.length) delete ctx._events[name];
          for (let i = list.length - 1; i >= 0; i--) {
            ctx.emit("removeListener", name, list[i][0]);
          }
          this.count -= list.length;
        }
        emit(ctx, name, ...args) {
          const list = [...this.list];
          for (let i = 0, n = list.length; i < n; i++) {
            const l = list[i];
            if (l[1] === true) this.remove(ctx, name, l[0]);
            Reflect.apply(l[0], ctx, args);
          }
          return list.length > 0;
        }
      };
      function appendListener(ctx, name, fn, once) {
        if (ctx._events === void 0) ctx._events = /* @__PURE__ */ Object.create(null);
        const e = ctx._events[name] || (ctx._events[name] = new EventListener());
        e.append(ctx, name, fn, once);
        return ctx;
      }
      function prependListener(ctx, name, fn, once) {
        if (ctx._events === void 0) ctx._events = /* @__PURE__ */ Object.create(null);
        const e = ctx._events[name] || (ctx._events[name] = new EventListener());
        e.prepend(ctx, name, fn, once);
        return ctx;
      }
      function removeListener(ctx, name, fn) {
        if (ctx._events === void 0) return ctx;
        const e = ctx._events[name];
        if (e !== void 0) e.remove(ctx, name, fn);
        return ctx;
      }
      function throwUnhandledError(...args) {
        let err;
        if (args.length > 0) err = args[0];
        if (err instanceof Error === false) err = errors.UNHANDLED_ERROR(err);
        if (Error.captureStackTrace) {
          Error.captureStackTrace(err, exports.prototype.emit);
        }
        queueMicrotask(() => {
          throw err;
        });
      }
      module.exports = exports = class EventEmitter {
        constructor() {
          this._events = /* @__PURE__ */ Object.create(null);
        }
        addListener(name, fn) {
          return appendListener(this, name, fn, false);
        }
        addOnceListener(name, fn) {
          return appendListener(this, name, fn, true);
        }
        prependListener(name, fn) {
          return prependListener(this, name, fn, false);
        }
        prependOnceListener(name, fn) {
          return prependListener(this, name, fn, true);
        }
        removeListener(name, fn) {
          return removeListener(this, name, fn);
        }
        on(name, fn) {
          return appendListener(this, name, fn, false);
        }
        once(name, fn) {
          return appendListener(this, name, fn, true);
        }
        off(name, fn) {
          return removeListener(this, name, fn);
        }
        emit(name, ...args) {
          if (name === "error" && this._events !== void 0 && this._events.error === void 0) {
            throwUnhandledError(...args);
          }
          if (this._events === void 0) return false;
          const e = this._events[name];
          return e === void 0 ? false : e.emit(this, name, ...args);
        }
        listeners(name) {
          if (this._events === void 0) return [];
          const e = this._events[name];
          return e === void 0 ? [] : [...e.list];
        }
        listenerCount(name) {
          if (this._events === void 0) return 0;
          const e = this._events[name];
          return e === void 0 ? 0 : e.list.length;
        }
        getMaxListeners() {
          return EventEmitter.defaultMaxListeners;
        }
        setMaxListeners(n) {
        }
        removeAllListeners(name) {
          if (arguments.length === 0) {
            for (const key of Reflect.ownKeys(this._events)) {
              if (key === "removeListener") continue;
              this.removeAllListeners(key);
            }
            this.removeAllListeners("removeListener");
          } else {
            const e = this._events[name];
            if (e !== void 0) e.removeAll(this, name);
          }
          return this;
        }
      };
      exports.EventEmitter = exports;
      exports.errors = errors;
      exports.defaultMaxListeners = 10;
      exports.on = function on(emitter, name, opts = {}) {
        const { signal } = opts;
        if (signal && signal.aborted) {
          throw errors.OPERATION_ABORTED(signal.reason);
        }
        let error = null;
        let done = false;
        const events = [];
        const promises = [];
        if (name !== "error") emitter.on("error", onerror);
        if (signal) signal.addEventListener("abort", onabort);
        emitter.on(name, onevent);
        return {
          next() {
            if (events.length) {
              return Promise.resolve({ value: events.shift(), done: false });
            }
            if (error) {
              const err = error;
              error = null;
              return Promise.reject(err);
            }
            if (done) return onclose();
            return new Promise((resolve, reject) => promises.push({ resolve, reject }));
          },
          return() {
            return onclose();
          },
          throw(err) {
            return onerror(err);
          },
          [Symbol.asyncIterator]() {
            return this;
          }
        };
        function onevent(...args) {
          if (promises.length) {
            promises.shift().resolve({ value: args, done: false });
          } else {
            events.push(args);
          }
        }
        function onerror(err) {
          emitter.off(name, onevent).off("error", onerror);
          if (promises.length) {
            promises.shift().reject(err);
          } else {
            error = err;
          }
          return Promise.resolve({ done: true });
        }
        function onabort() {
          signal.removeEventListener("abort", onabort);
          onerror(errors.OPERATION_ABORTED(signal.reason));
        }
        function onclose() {
          emitter.off(name, onevent);
          if (name !== "error") emitter.off("error", onerror);
          if (signal) signal.removeEventListener("abort", onabort);
          done = true;
          if (promises.length) promises.shift().resolve({ done: true });
          return Promise.resolve({ done: true });
        }
      };
      exports.once = function once(emitter, name, opts = {}) {
        const { signal } = opts;
        if (signal && signal.aborted) {
          return Promise.reject(errors.OPERATION_ABORTED(signal.reason));
        }
        return new Promise((resolve, reject) => {
          if (name !== "error") emitter.on("error", onerror);
          if (signal) signal.addEventListener("abort", onabort);
          emitter.once(name, onevent);
          function onevent(...args) {
            if (name !== "error") emitter.off("error", onerror);
            if (signal) signal.removeEventListener("abort", onabort);
            resolve(args);
          }
          function onerror(err) {
            emitter.off(name, onevent);
            if (name !== "error") emitter.off("error", onerror);
            reject(err);
          }
          function onabort() {
            signal.removeEventListener("abort", onabort);
            onerror(errors.OPERATION_ABORTED(signal.reason));
          }
        });
      };
      exports.forward = function forward(from, to, names, opts = {}) {
        if (typeof names === "string") names = [names];
        const { emit = to.emit.bind(to) } = opts;
        const listeners = names.map(
          (name) => function onevent(...args) {
            emit(name, ...args);
          }
        );
        to.on("newListener", (name) => {
          const i = names.indexOf(name);
          if (i !== -1 && to.listenerCount(name) === 0) {
            from.on(name, listeners[i]);
          }
        }).on("removeListener", (name) => {
          const i = names.indexOf(name);
          if (i !== -1 && to.listenerCount(name) === 0) {
            from.off(name, listeners[i]);
          }
        });
      };
      exports.listenerCount = function listenerCount(emitter, name) {
        return emitter.listenerCount(name);
      };
      exports.getMaxListeners = function getMaxListeners(emitter) {
        if (typeof emitter.getMaxListeners === "function") {
          return emitter.getMaxListeners();
        }
        return exports.defaultMaxListeners;
      };
      exports.setMaxListeners = function setMaxListeners(n, ...emitters) {
        if (emitters.length === 0) exports.defaultMaxListeners = n;
        else {
          for (const emitter of emitters) {
            if (typeof emitter.setMaxListeners === "function") {
              emitter.setMaxListeners(n);
            }
          }
        }
      };
    }
  });

  // ../../node_modules/bare-os/binding.js
  var require_binding = __commonJS({
    "../../node_modules/bare-os/binding.js"(exports, module) {
      module.exports = __require.addon();
    }
  });

  // ../../node_modules/bare-os/lib/errors.js
  var require_errors2 = __commonJS({
    "../../node_modules/bare-os/lib/errors.js"(exports, module) {
      module.exports = class OSError extends Error {
        constructor(msg, code, fn = OSError) {
          super(`${code}: ${msg}`);
          this.code = code;
          if (Error.captureStackTrace) {
            Error.captureStackTrace(this, fn);
          }
        }
        get name() {
          return "OSError";
        }
        static UNKNOWN_SIGNAL(msg) {
          return new OSError(msg, "UNKNOWN_SIGNAL", OSError.UNKNOWN_SIGNAL);
        }
        static TITLE_OVERFLOW(msg) {
          return new OSError(msg, "TITLE_OVERFLOW", OSError.TITLE_OVERFLOW);
        }
      };
    }
  });

  // ../../node_modules/bare-os/lib/constants.js
  var require_constants = __commonJS({
    "../../node_modules/bare-os/lib/constants.js"(exports, module) {
      var binding = require_binding();
      module.exports = {
        signals: binding.signals,
        errnos: binding.errnos,
        priority: binding.priority
      };
    }
  });

  // ../../node_modules/bare-os/index.js
  var require_bare_os = __commonJS({
    "../../node_modules/bare-os/index.js"(exports) {
      var binding = require_binding();
      var errors = require_errors2();
      var constants = require_constants();
      exports.constants = constants;
      exports.EOL = binding.platform === "win32" ? "\r\n" : "\n";
      exports.devNull = binding.platform === "win32" ? "\\\\.\\nul" : "/dev/null";
      exports.platform = function platform() {
        return binding.platform;
      };
      exports.arch = function arch() {
        return binding.arch;
      };
      exports.type = binding.type;
      exports.version = binding.version;
      exports.release = binding.release;
      exports.machine = binding.machine;
      exports.execPath = binding.execPath;
      exports.pid = binding.pid;
      exports.ppid = binding.ppid;
      exports.cwd = binding.cwd;
      exports.chdir = binding.chdir;
      exports.tmpdir = binding.tmpdir;
      exports.homedir = binding.homedir;
      exports.hostname = binding.hostname;
      exports.userInfo = binding.userInfo;
      exports.networkInterfaces = function networkInterfaces() {
        const result = {};
        for (const entry of binding.networkInterfaces()) {
          const { name, ...properties } = entry;
          if (result[name]) result[name].push(properties);
          else result[name] = [properties];
        }
        return result;
      };
      exports.kill = function kill(pid, signal = constants.signals.SIGTERM) {
        if (typeof signal === "string") {
          if (signal in constants.signals === false) {
            throw errors.UNKNOWN_SIGNAL("Unknown signal: " + signal);
          }
          signal = constants.signals[signal];
        }
        binding.kill(pid, signal);
      };
      exports.endianness = function endianness() {
        return binding.isLittleEndian ? "LE" : "BE";
      };
      exports.availableParallelism = binding.availableParallelism;
      exports.cpuUsage = function cpuUsage(previous) {
        const current = binding.cpuUsage();
        if (previous) {
          return {
            user: current.user - previous.user,
            system: current.system - previous.system
          };
        }
        return current;
      };
      exports.threadCpuUsage = function threadCpuUsage(previous) {
        const current = binding.threadCpuUsage();
        if (previous) {
          return {
            user: current.user - previous.user,
            system: current.system - previous.system
          };
        }
        return current;
      };
      exports.resourceUsage = binding.resourceUsage;
      exports.memoryUsage = binding.memoryUsage;
      exports.freemem = binding.freemem;
      exports.totalmem = binding.totalmem;
      exports.availableMemory = binding.availableMemory;
      exports.constrainedMemory = binding.constrainedMemory;
      exports.uptime = binding.uptime;
      exports.loadavg = binding.loadavg;
      exports.cpus = binding.cpus;
      exports.getProcessTitle = binding.getProcessTitle;
      exports.setProcessTitle = function setProcessTitle(title) {
        if (typeof title !== "string") title = title.toString();
        if (title.length >= 256) {
          throw errors.TITLE_OVERFLOW("Process title is too long");
        }
        binding.setProcessTitle(title);
      };
      exports.getPriority = function getPriority(pid = 0) {
        return binding.getPriority(pid);
      };
      exports.setPriority = function setPriority(pid, priority) {
        if (priority === void 0) {
          priority = pid;
          pid = 0;
        }
        binding.setPriority(pid, priority);
      };
      exports.getEnvKeys = binding.getEnvKeys;
      exports.getEnv = binding.getEnv;
      exports.hasEnv = binding.hasEnv;
      exports.setEnv = binding.setEnv;
      exports.unsetEnv = binding.unsetEnv;
    }
  });

  // ../../node_modules/bare-path/lib/constants.js
  var require_constants2 = __commonJS({
    "../../node_modules/bare-path/lib/constants.js"(exports, module) {
      module.exports = {
        CHAR_UPPERCASE_A: 65,
        CHAR_LOWERCASE_A: 97,
        CHAR_UPPERCASE_Z: 90,
        CHAR_LOWERCASE_Z: 122,
        CHAR_DOT: 46,
        CHAR_FORWARD_SLASH: 47,
        CHAR_BACKWARD_SLASH: 92,
        CHAR_COLON: 58,
        CHAR_QUESTION_MARK: 63
      };
    }
  });

  // ../../node_modules/bare-path/lib/shared.js
  var require_shared = __commonJS({
    "../../node_modules/bare-path/lib/shared.js"(exports) {
      var {
        CHAR_DOT,
        CHAR_FORWARD_SLASH
      } = require_constants2();
      exports.normalizeString = function normalizeString(path, allowAboveRoot, separator, isPathSeparator) {
        let res = "";
        let lastSegmentLength = 0;
        let lastSlash = -1;
        let dots = 0;
        let code = 0;
        for (let i = 0; i <= path.length; ++i) {
          if (i < path.length) {
            code = path.charCodeAt(i);
          } else if (isPathSeparator(code)) {
            break;
          } else {
            code = CHAR_FORWARD_SLASH;
          }
          if (isPathSeparator(code)) {
            if (lastSlash === i - 1 || dots === 1) ;
            else if (dots === 2) {
              if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== CHAR_DOT || res.charCodeAt(res.length - 2) !== CHAR_DOT) {
                if (res.length > 2) {
                  const lastSlashIndex = res.lastIndexOf(separator);
                  if (lastSlashIndex === -1) {
                    res = "";
                    lastSegmentLength = 0;
                  } else {
                    res = res.substring(0, lastSlashIndex);
                    lastSegmentLength = res.length - 1 - res.lastIndexOf(separator);
                  }
                  lastSlash = i;
                  dots = 0;
                  continue;
                } else if (res.length !== 0) {
                  res = "";
                  lastSegmentLength = 0;
                  lastSlash = i;
                  dots = 0;
                  continue;
                }
              }
              if (allowAboveRoot) {
                res += res.length > 0 ? `${separator}..` : "..";
                lastSegmentLength = 2;
              }
            } else {
              if (res.length > 0) {
                res += `${separator}${path.substring(lastSlash + 1, i)}`;
              } else {
                res = path.substring(lastSlash + 1, i);
              }
              lastSegmentLength = i - lastSlash - 1;
            }
            lastSlash = i;
            dots = 0;
          } else if (code === CHAR_DOT && dots !== -1) {
            ++dots;
          } else {
            dots = -1;
          }
        }
        return res;
      };
    }
  });

  // ../../node_modules/bare-path/lib/posix.js
  var require_posix = __commonJS({
    "../../node_modules/bare-path/lib/posix.js"(exports) {
      var os = require_bare_os();
      var { normalizeString } = require_shared();
      var {
        CHAR_DOT,
        CHAR_FORWARD_SLASH
      } = require_constants2();
      function isPosixPathSeparator(code) {
        return code === CHAR_FORWARD_SLASH;
      }
      exports.win32 = require_win32();
      exports.posix = exports;
      exports.sep = "/";
      exports.delimiter = ":";
      exports.resolve = function resolve(...args) {
        let resolvedPath = "";
        let resolvedAbsolute = false;
        for (let i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {
          const path = i >= 0 ? args[i] : os.cwd();
          if (path.length === 0) {
            continue;
          }
          resolvedPath = `${path}/${resolvedPath}`;
          resolvedAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
        }
        resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute, "/", isPosixPathSeparator);
        if (resolvedAbsolute) {
          return `/${resolvedPath}`;
        }
        return resolvedPath.length > 0 ? resolvedPath : ".";
      };
      exports.normalize = function normalize(path) {
        if (path.length === 0) return ".";
        const isAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
        const trailingSeparator = path.charCodeAt(path.length - 1) === CHAR_FORWARD_SLASH;
        path = normalizeString(path, !isAbsolute, "/", isPosixPathSeparator);
        if (path.length === 0) {
          if (isAbsolute) return "/";
          return trailingSeparator ? "./" : ".";
        }
        if (trailingSeparator) path += "/";
        return isAbsolute ? `/${path}` : path;
      };
      exports.isAbsolute = function isAbsolute(path) {
        return path.length > 0 && path.charCodeAt(0) === CHAR_FORWARD_SLASH;
      };
      exports.join = function join(...args) {
        if (args.length === 0) return ".";
        let joined;
        for (let i = 0; i < args.length; ++i) {
          const arg = args[i];
          if (arg.length > 0) {
            if (joined === void 0) joined = arg;
            else joined += `/${arg}`;
          }
        }
        if (joined === void 0) return ".";
        return exports.normalize(joined);
      };
      exports.relative = function relative(from, to) {
        if (from === to) return "";
        from = exports.resolve(from);
        to = exports.resolve(to);
        if (from === to) return "";
        const fromStart = 1;
        const fromEnd = from.length;
        const fromLen = fromEnd - fromStart;
        const toStart = 1;
        const toLen = to.length - toStart;
        const length = fromLen < toLen ? fromLen : toLen;
        let lastCommonSep = -1;
        let i = 0;
        for (; i < length; i++) {
          const fromCode = from.charCodeAt(fromStart + i);
          if (fromCode !== to.charCodeAt(toStart + i)) {
            break;
          } else if (fromCode === CHAR_FORWARD_SLASH) {
            lastCommonSep = i;
          }
        }
        if (i === length) {
          if (toLen > length) {
            if (to.charCodeAt(toStart + i) === CHAR_FORWARD_SLASH) {
              return to.substring(toStart + i + 1);
            }
            if (i === 0) {
              return to.substring(toStart + i);
            }
          } else if (fromLen > length) {
            if (from.charCodeAt(fromStart + i) === CHAR_FORWARD_SLASH) {
              lastCommonSep = i;
            } else if (i === 0) {
              lastCommonSep = 0;
            }
          }
        }
        let out = "";
        for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
          if (i === fromEnd || from.charCodeAt(i) === CHAR_FORWARD_SLASH) {
            out += out.length === 0 ? ".." : "/..";
          }
        }
        return `${out}${to.substring(toStart + lastCommonSep)}`;
      };
      exports.toNamespacedPath = function toNamespacedPath(path) {
        return path;
      };
      exports.dirname = function dirname(path) {
        if (path.length === 0) return ".";
        const hasRoot = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
        let end = -1;
        let matchedSlash = true;
        for (let i = path.length - 1; i >= 1; --i) {
          if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) {
            if (!matchedSlash) {
              end = i;
              break;
            }
          } else {
            matchedSlash = false;
          }
        }
        if (end === -1) return hasRoot ? "/" : ".";
        if (hasRoot && end === 1) return "//";
        return path.substring(0, end);
      };
      exports.basename = function basename(path, suffix) {
        let start = 0;
        let end = -1;
        let matchedSlash = true;
        if (suffix !== void 0 && suffix.length > 0 && suffix.length <= path.length) {
          if (suffix === path) {
            return "";
          }
          let extIdx = suffix.length - 1;
          let firstNonSlashEnd = -1;
          for (let i = path.length - 1; i >= 0; --i) {
            const code = path.charCodeAt(i);
            if (code === CHAR_FORWARD_SLASH) {
              if (!matchedSlash) {
                start = i + 1;
                break;
              }
            } else {
              if (firstNonSlashEnd === -1) {
                matchedSlash = false;
                firstNonSlashEnd = i + 1;
              }
              if (extIdx >= 0) {
                if (code === suffix.charCodeAt(extIdx)) {
                  if (--extIdx === -1) {
                    end = i;
                  }
                } else {
                  extIdx = -1;
                  end = firstNonSlashEnd;
                }
              }
            }
          }
          if (start === end) end = firstNonSlashEnd;
          else if (end === -1) end = path.length;
          return path.substring(start, end);
        }
        for (let i = path.length - 1; i >= 0; --i) {
          if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) {
            if (!matchedSlash) {
              start = i + 1;
              break;
            }
          } else if (end === -1) {
            matchedSlash = false;
            end = i + 1;
          }
        }
        if (end === -1) return "";
        return path.substring(start, end);
      };
      exports.extname = function extname(path) {
        let startDot = -1;
        let startPart = 0;
        let end = -1;
        let matchedSlash = true;
        let preDotState = 0;
        for (let i = path.length - 1; i >= 0; --i) {
          const code = path.charCodeAt(i);
          if (code === CHAR_FORWARD_SLASH) {
            if (!matchedSlash) {
              startPart = i + 1;
              break;
            }
            continue;
          }
          if (end === -1) {
            matchedSlash = false;
            end = i + 1;
          }
          if (code === CHAR_DOT) {
            if (startDot === -1) startDot = i;
            else if (preDotState !== 1) preDotState = 1;
          } else if (startDot !== -1) {
            preDotState = -1;
          }
        }
        if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
          return "";
        }
        return path.substring(startDot, end);
      };
    }
  });

  // ../../node_modules/bare-path/lib/win32.js
  var require_win32 = __commonJS({
    "../../node_modules/bare-path/lib/win32.js"(exports) {
      var os = require_bare_os();
      var { normalizeString } = require_shared();
      var {
        CHAR_UPPERCASE_A,
        CHAR_LOWERCASE_A,
        CHAR_UPPERCASE_Z,
        CHAR_LOWERCASE_Z,
        CHAR_DOT,
        CHAR_FORWARD_SLASH,
        CHAR_BACKWARD_SLASH,
        CHAR_COLON,
        CHAR_QUESTION_MARK
      } = require_constants2();
      function isWindowsPathSeparator(code) {
        return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
      }
      function isWindowsDeviceRoot(code) {
        return code >= CHAR_UPPERCASE_A && code <= CHAR_UPPERCASE_Z || code >= CHAR_LOWERCASE_A && code <= CHAR_LOWERCASE_Z;
      }
      exports.posix = require_posix();
      exports.win32 = exports;
      exports.sep = "\\";
      exports.delimiter = ";";
      exports.resolve = function resolve(...args) {
        let resolvedDevice = "";
        let resolvedTail = "";
        let resolvedAbsolute = false;
        for (let i = args.length - 1; i >= -1; i--) {
          let path;
          if (i >= 0) {
            path = args[i];
            if (path.length === 0) continue;
          } else if (resolvedDevice.length === 0) {
            path = os.cwd();
          } else {
            path = os.getEnv(`=${resolvedDevice}`) || os.cwd();
            if (path === void 0 || path.substring(0, 2).toLowerCase() !== resolvedDevice.toLowerCase() && path.charCodeAt(2) === CHAR_BACKWARD_SLASH) {
              path = `${resolvedDevice}\\`;
            }
          }
          const len = path.length;
          let rootEnd = 0;
          let device = "";
          let isAbsolute = false;
          const code = path.charCodeAt(0);
          if (len === 1) {
            if (isWindowsPathSeparator(code)) {
              rootEnd = 1;
              isAbsolute = true;
            }
          } else if (isWindowsPathSeparator(code)) {
            isAbsolute = true;
            if (isWindowsPathSeparator(path.charCodeAt(1))) {
              let j = 2;
              let last = j;
              while (j < len && !isWindowsPathSeparator(path.charCodeAt(j))) {
                j++;
              }
              if (j < len && j !== last) {
                const firstPart = path.substring(last, j);
                last = j;
                while (j < len && isWindowsPathSeparator(path.charCodeAt(j))) {
                  j++;
                }
                if (j < len && j !== last) {
                  last = j;
                  while (j < len && !isWindowsPathSeparator(path.charCodeAt(j))) {
                    j++;
                  }
                  if (j === len || j !== last) {
                    device = `\\\\${firstPart}\\${path.substring(last, j)}`;
                    rootEnd = j;
                  }
                }
              }
            } else {
              rootEnd = 1;
            }
          } else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) {
            device = path.substring(0, 2);
            rootEnd = 2;
            if (len > 2 && isWindowsPathSeparator(path.charCodeAt(2))) {
              isAbsolute = true;
              rootEnd = 3;
            }
          }
          if (device.length > 0) {
            if (resolvedDevice.length > 0) {
              if (device.toLowerCase() !== resolvedDevice.toLowerCase()) {
                continue;
              }
            } else {
              resolvedDevice = device;
            }
          }
          if (resolvedAbsolute) {
            if (resolvedDevice.length > 0) {
              break;
            }
          } else {
            resolvedTail = `${path.substring(rootEnd)}\\${resolvedTail}`;
            resolvedAbsolute = isAbsolute;
            if (isAbsolute && resolvedDevice.length > 0) {
              break;
            }
          }
        }
        resolvedTail = normalizeString(resolvedTail, !resolvedAbsolute, "\\", isWindowsPathSeparator);
        return resolvedAbsolute ? `${resolvedDevice}\\${resolvedTail}` : `${resolvedDevice}${resolvedTail}` || ".";
      };
      exports.normalize = function normalize(path) {
        const len = path.length;
        if (len === 0) return ".";
        let rootEnd = 0;
        let device;
        let isAbsolute = false;
        const code = path.charCodeAt(0);
        if (len === 1) {
          return code === CHAR_FORWARD_SLASH ? "\\" : path;
        }
        if (isWindowsPathSeparator(code)) {
          isAbsolute = true;
          if (isWindowsPathSeparator(path.charCodeAt(1))) {
            let j = 2;
            let last = j;
            while (j < len && !isWindowsPathSeparator(path.charCodeAt(j))) {
              j++;
            }
            if (j < len && j !== last) {
              const firstPart = path.substring(last, j);
              last = j;
              while (j < len && isWindowsPathSeparator(path.charCodeAt(j))) {
                j++;
              }
              if (j < len && j !== last) {
                last = j;
                while (j < len && !isWindowsPathSeparator(path.charCodeAt(j))) {
                  j++;
                }
                if (j === len) {
                  return `\\\\${firstPart}\\${path.substring(last)}\\`;
                }
                if (j !== last) {
                  device = `\\\\${firstPart}\\${path.substring(last, j)}`;
                  rootEnd = j;
                }
              }
            }
          } else {
            rootEnd = 1;
          }
        } else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) {
          device = path.substring(0, 2);
          rootEnd = 2;
          if (len > 2 && isWindowsPathSeparator(path.charCodeAt(2))) {
            isAbsolute = true;
            rootEnd = 3;
          }
        }
        let tail = rootEnd < len ? normalizeString(path.substring(rootEnd), !isAbsolute, "\\", isWindowsPathSeparator) : "";
        if (tail.length === 0 && !isAbsolute) {
          tail = ".";
        }
        if (tail.length > 0 && isWindowsPathSeparator(path.charCodeAt(len - 1))) {
          tail += "\\";
        }
        if (device === void 0) {
          return isAbsolute ? `\\${tail}` : tail;
        }
        return isAbsolute ? `${device}\\${tail}` : `${device}${tail}`;
      };
      exports.isAbsolute = function isAbsolute(path) {
        const len = path.length;
        if (len === 0) return false;
        const code = path.charCodeAt(0);
        return isWindowsPathSeparator(code) || len > 2 && isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON && isWindowsPathSeparator(path.charCodeAt(2));
      };
      exports.join = function join(...args) {
        if (args.length === 0) return ".";
        let joined;
        let firstPart;
        for (let i = 0; i < args.length; ++i) {
          const arg = args[i];
          if (arg.length > 0) {
            if (joined === void 0) joined = firstPart = arg;
            else joined += `\\${arg}`;
          }
        }
        if (joined === void 0) return ".";
        let needsReplace = true;
        let slashCount = 0;
        if (isWindowsPathSeparator(firstPart.charCodeAt(0))) {
          ++slashCount;
          const firstLen = firstPart.length;
          if (firstLen > 1 && isWindowsPathSeparator(firstPart.charCodeAt(1))) {
            ++slashCount;
            if (firstLen > 2) {
              if (isWindowsPathSeparator(firstPart.charCodeAt(2))) {
                ++slashCount;
              } else {
                needsReplace = false;
              }
            }
          }
        }
        if (needsReplace) {
          while (slashCount < joined.length && isWindowsPathSeparator(joined.charCodeAt(slashCount))) {
            slashCount++;
          }
          if (slashCount >= 2) {
            joined = `\\${joined.substring(slashCount)}`;
          }
        }
        return exports.normalize(joined);
      };
      exports.relative = function relative(from, to) {
        if (from === to) return "";
        const fromOrig = exports.resolve(from);
        const toOrig = exports.resolve(to);
        if (fromOrig === toOrig) return "";
        from = fromOrig.toLowerCase();
        to = toOrig.toLowerCase();
        if (from === to) return "";
        let fromStart = 0;
        while (fromStart < from.length && from.charCodeAt(fromStart) === CHAR_BACKWARD_SLASH) {
          fromStart++;
        }
        let fromEnd = from.length;
        while (fromEnd - 1 > fromStart && from.charCodeAt(fromEnd - 1) === CHAR_BACKWARD_SLASH) {
          fromEnd--;
        }
        const fromLen = fromEnd - fromStart;
        let toStart = 0;
        while (toStart < to.length && to.charCodeAt(toStart) === CHAR_BACKWARD_SLASH) {
          toStart++;
        }
        let toEnd = to.length;
        while (toEnd - 1 > toStart && to.charCodeAt(toEnd - 1) === CHAR_BACKWARD_SLASH) {
          toEnd--;
        }
        const toLen = toEnd - toStart;
        const length = fromLen < toLen ? fromLen : toLen;
        let lastCommonSep = -1;
        let i = 0;
        for (; i < length; i++) {
          const fromCode = from.charCodeAt(fromStart + i);
          if (fromCode !== to.charCodeAt(toStart + i)) {
            break;
          } else if (fromCode === CHAR_BACKWARD_SLASH) {
            lastCommonSep = i;
          }
        }
        if (i !== length) {
          if (lastCommonSep === -1) return toOrig;
        } else {
          if (toLen > length) {
            if (to.charCodeAt(toStart + i) === CHAR_BACKWARD_SLASH) {
              return toOrig.substring(toStart + i + 1);
            }
            if (i === 2) {
              return toOrig.substring(toStart + i);
            }
          }
          if (fromLen > length) {
            if (from.charCodeAt(fromStart + i) === CHAR_BACKWARD_SLASH) {
              lastCommonSep = i;
            } else if (i === 2) {
              lastCommonSep = 3;
            }
          }
          if (lastCommonSep === -1) lastCommonSep = 0;
        }
        let out = "";
        for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
          if (i === fromEnd || from.charCodeAt(i) === CHAR_BACKWARD_SLASH) {
            out += out.length === 0 ? ".." : "\\..";
          }
        }
        toStart += lastCommonSep;
        if (out.length > 0) {
          return `${out}${toOrig.substring(toStart, toEnd)}`;
        }
        if (toOrig.charCodeAt(toStart) === CHAR_BACKWARD_SLASH) {
          ++toStart;
        }
        return toOrig.substring(toStart, toEnd);
      };
      exports.toNamespacedPath = function toNamespacedPath(path) {
        if (path.length === 0) return path;
        const resolvedPath = exports.resolve(path);
        if (resolvedPath.length <= 2) return path;
        if (resolvedPath.charCodeAt(0) === CHAR_BACKWARD_SLASH) {
          if (resolvedPath.charCodeAt(1) === CHAR_BACKWARD_SLASH) {
            const code = resolvedPath.charCodeAt(2);
            if (code !== CHAR_QUESTION_MARK && code !== CHAR_DOT) {
              return `\\\\?\\UNC\\${resolvedPath.substring(2)}`;
            }
          }
        } else if (isWindowsDeviceRoot(resolvedPath.charCodeAt(0)) && resolvedPath.charCodeAt(1) === CHAR_COLON && resolvedPath.charCodeAt(2) === CHAR_BACKWARD_SLASH) {
          return `\\\\?\\${resolvedPath}`;
        }
        return path;
      };
      exports.dirname = function dirname(path) {
        const len = path.length;
        if (len === 0) return ".";
        let rootEnd = -1;
        let offset = 0;
        const code = path.charCodeAt(0);
        if (len === 1) {
          return isWindowsPathSeparator(code) ? path : ".";
        }
        if (isWindowsPathSeparator(code)) {
          rootEnd = offset = 1;
          if (isWindowsPathSeparator(path.charCodeAt(1))) {
            let j = 2;
            let last = j;
            while (j < len && !isWindowsPathSeparator(path.charCodeAt(j))) {
              j++;
            }
            if (j < len && j !== last) {
              last = j;
              while (j < len && isWindowsPathSeparator(path.charCodeAt(j))) {
                j++;
              }
              if (j < len && j !== last) {
                last = j;
                while (j < len && !isWindowsPathSeparator(path.charCodeAt(j))) {
                  j++;
                }
                if (j === len) {
                  return path;
                }
                if (j !== last) {
                  rootEnd = offset = j + 1;
                }
              }
            }
          }
        } else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) {
          rootEnd = len > 2 && isWindowsPathSeparator(path.charCodeAt(2)) ? 3 : 2;
          offset = rootEnd;
        }
        let end = -1;
        let matchedSlash = true;
        for (let i = len - 1; i >= offset; --i) {
          if (isWindowsPathSeparator(path.charCodeAt(i))) {
            if (!matchedSlash) {
              end = i;
              break;
            }
          } else {
            matchedSlash = false;
          }
        }
        if (end === -1) {
          if (rootEnd === -1) return ".";
          end = rootEnd;
        }
        return path.substring(0, end);
      };
      exports.basename = function basename(path, suffix) {
        let start = 0;
        let end = -1;
        let matchedSlash = true;
        if (path.length >= 2 && isWindowsDeviceRoot(path.charCodeAt(0)) && path.charCodeAt(1) === CHAR_COLON) {
          start = 2;
        }
        if (suffix !== void 0 && suffix.length > 0 && suffix.length <= path.length) {
          if (suffix === path) return "";
          let extIdx = suffix.length - 1;
          let firstNonSlashEnd = -1;
          for (let i = path.length - 1; i >= start; --i) {
            const code = path.charCodeAt(i);
            if (isWindowsPathSeparator(code)) {
              if (!matchedSlash) {
                start = i + 1;
                break;
              }
            } else {
              if (firstNonSlashEnd === -1) {
                matchedSlash = false;
                firstNonSlashEnd = i + 1;
              }
              if (extIdx >= 0) {
                if (code === suffix.charCodeAt(extIdx)) {
                  if (--extIdx === -1) {
                    end = i;
                  }
                } else {
                  extIdx = -1;
                  end = firstNonSlashEnd;
                }
              }
            }
          }
          if (start === end) end = firstNonSlashEnd;
          else if (end === -1) end = path.length;
          return path.substring(start, end);
        }
        for (let i = path.length - 1; i >= start; --i) {
          if (isWindowsPathSeparator(path.charCodeAt(i))) {
            if (!matchedSlash) {
              start = i + 1;
              break;
            }
          } else if (end === -1) {
            matchedSlash = false;
            end = i + 1;
          }
        }
        if (end === -1) return "";
        return path.substring(start, end);
      };
      exports.extname = function extname(path) {
        let start = 0;
        let startDot = -1;
        let startPart = 0;
        let end = -1;
        let matchedSlash = true;
        let preDotState = 0;
        if (path.length >= 2 && path.charCodeAt(1) === CHAR_COLON && isWindowsDeviceRoot(path.charCodeAt(0))) {
          start = startPart = 2;
        }
        for (let i = path.length - 1; i >= start; --i) {
          const code = path.charCodeAt(i);
          if (isWindowsPathSeparator(code)) {
            if (!matchedSlash) {
              startPart = i + 1;
              break;
            }
            continue;
          }
          if (end === -1) {
            matchedSlash = false;
            end = i + 1;
          }
          if (code === CHAR_DOT) {
            if (startDot === -1) startDot = i;
            else if (preDotState !== 1) preDotState = 1;
          } else if (startDot !== -1) {
            preDotState = -1;
          }
        }
        if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
          return "";
        }
        return path.substring(startDot, end);
      };
    }
  });

  // ../../node_modules/bare-path/index.js
  var require_bare_path = __commonJS({
    "../../node_modules/bare-path/index.js"(exports, module) {
      if (Bare.platform === "win32") {
        module.exports = require_win32();
      } else {
        module.exports = require_posix();
      }
    }
  });

  // ../../node_modules/bare-url/binding.js
  var require_binding2 = __commonJS({
    "../../node_modules/bare-url/binding.js"(exports, module) {
      module.exports = __require.addon();
    }
  });

  // ../../node_modules/bare-url/lib/errors.js
  var require_errors3 = __commonJS({
    "../../node_modules/bare-url/lib/errors.js"(exports, module) {
      module.exports = class URLError extends Error {
        constructor(msg, fn = URLError, code = fn.name) {
          super(`${code}: ${msg}`);
          this.code = code;
          if (Error.captureStackTrace) Error.captureStackTrace(this, fn);
        }
        get name() {
          return "URLError";
        }
        static INVALID_URL(msg, input) {
          const err = new URLError(msg, URLError.INVALID_URL);
          err.input = input;
          return err;
        }
        static INVALID_URL_SCHEME(msg = "Invalid URL") {
          return new URLError(msg, URLError.INVALID_URL_SCHEME);
        }
        static INVALID_FILE_URL_HOST(msg = "Invalid file: URL host") {
          return new URLError(msg, URLError.INVALID_FILE_URL_HOST);
        }
        static INVALID_FILE_URL_PATH(msg = "Invalid file: URL path") {
          return new URLError(msg, URLError.INVALID_FILE_URL_PATH);
        }
      };
    }
  });

  // ../../node_modules/bare-url/lib/url-search-params.js
  var require_url_search_params = __commonJS({
    "../../node_modules/bare-url/lib/url-search-params.js"(exports, module) {
      var kind = Symbol.for("bare.url.search-params.kind");
      var URLSearchParams = class _URLSearchParams {
        static _urls = /* @__PURE__ */ new WeakMap();
        static get [kind]() {
          return 0;
        }
        // https://url.spec.whatwg.org/#dom-urlsearchparams-urlsearchparams
        constructor(init2, url = null) {
          this._params = /* @__PURE__ */ new Map();
          if (url) _URLSearchParams._urls.set(this, url);
          if (typeof init2 === "string") {
            this._parse(init2);
          } else if (init2) {
            for (const [name, value] of typeof init2[Symbol.iterator] === "function" ? init2 : Object.entries(init2)) {
              this.append(name, value);
            }
          }
        }
        get [kind]() {
          return _URLSearchParams[kind];
        }
        // https://url.spec.whatwg.org/#dom-urlsearchparams-size
        get size() {
          return this._params.length;
        }
        // https://url.spec.whatwg.org/#dom-urlsearchparams-append
        append(name, value = null) {
          if (value === null) return;
          let list = this._params.get(name);
          if (list === void 0) {
            list = [];
            this._params.set(name, list);
          }
          list.push(value);
          this._update();
        }
        // https://url.spec.whatwg.org/#dom-urlsearchparams-delete
        delete(name, value = null) {
          if (value === null) this._params.delete(name);
          else {
            let list = this._params.get(name);
            if (list === void 0) return;
            list = list.filter((found) => found !== value);
            if (list.length === 0) this._params.delete(name);
            else this._params.set(name, list);
          }
          this._update();
        }
        // https://url.spec.whatwg.org/#dom-urlsearchparams-get
        get(name) {
          const list = this._params.get(name);
          if (list === void 0) return null;
          return list[0];
        }
        // https://url.spec.whatwg.org/#dom-urlsearchparams-getall
        getAll(name) {
          const list = this._params.get(name);
          if (list === void 0) return [];
          return Array.from(list);
        }
        // https://url.spec.whatwg.org/#dom-urlsearchparams-has
        has(name, value = null) {
          const list = this._params.get(name);
          if (list === void 0) return false;
          if (value === null) return true;
          return list.includes(value);
        }
        // https://url.spec.whatwg.org/#dom-urlsearchparams-set
        set(name, value = null) {
          if (value === null) this._params.delete(name);
          else this._params.set(name, [value]);
          this._update();
        }
        toString() {
          return this._serialize();
        }
        toJSON() {
          return [...this];
        }
        *[Symbol.iterator]() {
          for (const [name, values] of this._params) {
            for (const value of values) yield [name, value];
          }
        }
        [Symbol.for("bare.inspect")]() {
          const object = {
            __proto__: { constructor: _URLSearchParams }
          };
          for (const [name, values] of this._params) {
            if (values.length === 1) object[name] = values[0];
            else object[name] = values;
          }
          return object;
        }
        // https://url.spec.whatwg.org/#concept-urlsearchparams-update
        _update() {
          const url = _URLSearchParams._urls.get(this);
          if (url === void 0) return;
          url.search = this._serialize();
        }
        // https://url.spec.whatwg.org/#concept-urlencoded-parser
        _parse(input) {
          if (input[0] === "?") input = input.substring(1);
          this._params = /* @__PURE__ */ new Map();
          for (const sequence of input.split("&")) {
            if (sequence.length === 0) continue;
            let i = sequence.indexOf("=");
            if (i === -1) i = sequence.length;
            const name = decodeURIComponent(sequence.substring(0, i));
            const value = decodeURIComponent(sequence.substring(i + 1, sequence.length));
            let list = this._params.get(name);
            if (list === void 0) {
              list = [];
              this._params.set(name, list);
            }
            list.push(value);
          }
        }
        // https://url.spec.whatwg.org/#concept-urlencoded-serializer
        _serialize() {
          let output = "";
          for (let [name, values] of this._params) {
            name = encodeURIComponent(name);
            for (const value of values) {
              if (output) output += "&";
              output += name + "=" + encodeURIComponent(value);
            }
          }
          return output;
        }
      };
      module.exports = exports = URLSearchParams;
      exports.isURLSearchParams = function isURLSearchParams(value) {
        if (value instanceof URLSearchParams) return true;
        return typeof value === "object" && value !== null && value[kind] === URLSearchParams[kind];
      };
    }
  });

  // ../../node_modules/bare-url/index.js
  var require_bare_url = __commonJS({
    "../../node_modules/bare-url/index.js"(exports, module) {
      var path = require_bare_path();
      var binding = require_binding2();
      var errors = require_errors3();
      var URLSearchParams = require_url_search_params();
      var kind = Symbol.for("bare.url.kind");
      var isWindows = Bare.platform === "win32";
      var URL2 = class _URL {
        static get [kind]() {
          return 0;
        }
        constructor(input, base, opts = {}) {
          if (arguments.length === 0) throw errors.INVALID_URL();
          input = String(input);
          if (base !== void 0) base = String(base);
          this._components = new Uint32Array(8);
          this._parse(input, base, opts.throw !== false);
          if (this._href) this._params = new URLSearchParams(this.search, this);
        }
        get [kind]() {
          return _URL[kind];
        }
        // https://url.spec.whatwg.org/#dom-url-href
        get href() {
          return this._href;
        }
        set href(value) {
          this._update(value);
          this._params._parse(this.search);
        }
        // https://url.spec.whatwg.org/#dom-url-protocol
        get protocol() {
          return this._slice(0, this._components[0]) + ":";
        }
        set protocol(value) {
          this._update(this._replace(value.replace(/:+$/, ""), 0, this._components[0]));
        }
        // https://url.spec.whatwg.org/#dom-url-username
        get username() {
          return this._slice(this._components[0] + 3, this._components[1]);
        }
        set username(value) {
          if (cannotHaveCredentialsOrPort(this)) {
            return;
          }
          if (this.username === "") value += "@";
          this._update(this._replace(value, this._components[0] + 3, this._components[1]));
        }
        // https://url.spec.whatwg.org/#dom-url-password
        get password() {
          return this._href.slice(
            this._components[1] + 1,
            this._components[2] - 1
            /* @ */
          );
        }
        set password(value) {
          if (cannotHaveCredentialsOrPort(this)) {
            return;
          }
          let start = this._components[1] + 1;
          let end = this._components[2] - 1;
          if (this.password === "") {
            value = ":" + value;
            start--;
          }
          if (this.username === "") {
            value += "@";
            end++;
          }
          this._update(this._replace(value, start, end));
        }
        // https://url.spec.whatwg.org/#dom-url-host
        get host() {
          return this._slice(this._components[2], this._components[5]);
        }
        set host(value) {
          if (hasOpaquePath(this)) {
            return;
          }
          this._update(
            this._replace(value, this._components[2], this._components[value.includes(":") ? 5 : 3])
          );
        }
        // https://url.spec.whatwg.org/#dom-url-hostname
        get hostname() {
          return this._slice(this._components[2], this._components[3]);
        }
        set hostname(value) {
          if (hasOpaquePath(this)) {
            return;
          }
          this._update(this._replace(value, this._components[2], this._components[3]));
        }
        // https://url.spec.whatwg.org/#dom-url-port
        get port() {
          return this._slice(this._components[3] + 1, this._components[5]);
        }
        set port(value) {
          if (cannotHaveCredentialsOrPort(this)) {
            return;
          }
          let start = this._components[3] + 1;
          if (this.port === "") {
            value = ":" + value;
            start--;
          }
          this._update(this._replace(value, start, this._components[5]));
        }
        // https://url.spec.whatwg.org/#dom-url-pathname
        get pathname() {
          return this._slice(
            this._components[5],
            this._components[6] - 1
            /* ? */
          );
        }
        set pathname(value) {
          if (hasOpaquePath(this)) {
            return;
          }
          if (value[0] !== "/" && value[0] !== "\\") {
            value = "/" + value;
          }
          this._update(this._replace(
            value,
            this._components[5],
            this._components[6] - 1
            /* ? */
          ));
        }
        // https://url.spec.whatwg.org/#dom-url-search
        get search() {
          return this._slice(
            this._components[6] - 1,
            this._components[7] - 1
            /* # */
          );
        }
        set search(value) {
          if (value && value[0] !== "?") value = "?" + value;
          this._update(
            this._replace(
              value,
              this._components[6] - 1,
              this._components[7] - 1
              /* # */
            )
          );
          this._params._parse(this.search);
        }
        // https://url.spec.whatwg.org/#dom-url-searchparams
        get searchParams() {
          return this._params;
        }
        // https://url.spec.whatwg.org/#dom-url-hash
        get hash() {
          return this._slice(
            this._components[7] - 1
            /* # */
          );
        }
        set hash(value) {
          if (value && value[0] !== "#") value = "#" + value;
          this._update(this._replace(
            value,
            this._components[7] - 1
            /* # */
          ));
        }
        toString() {
          return this._href;
        }
        toJSON() {
          return this._href;
        }
        [Symbol.for("bare.inspect")]() {
          return {
            __proto__: { constructor: _URL },
            href: this.href,
            protocol: this.protocol,
            username: this.username,
            password: this.password,
            host: this.host,
            hostname: this.hostname,
            port: this.port,
            pathname: this.pathname,
            search: this.search,
            searchParams: this.searchParams,
            hash: this.hash
          };
        }
        _slice(start, end = this._href.length) {
          return this._href.slice(start, end);
        }
        _replace(replacement, start, end = this._href.length) {
          return this._slice(0, start) + replacement + this._slice(end);
        }
        _parse(input, base, shouldThrow) {
          try {
            this._href = binding.parse(
              String(input),
              base ? String(base) : null,
              this._components,
              shouldThrow
            );
          } catch (err) {
            if (err instanceof TypeError) throw err;
            throw errors.INVALID_URL(`Invalid URL '${input}'`, input);
          }
        }
        _update(input) {
          try {
            this._parse(input, null, true);
          } catch (err) {
            if (err instanceof TypeError) throw err;
          }
        }
      };
      module.exports = exports = URL2;
      function hasOpaquePath(url) {
        return url.pathname[0] !== "/";
      }
      function cannotHaveCredentialsOrPort(url) {
        return url.hostname === "" || url.protocol === "file:";
      }
      exports.URL = URL2;
      exports.URLSearchParams = URLSearchParams;
      exports.errors = errors;
      exports.isURL = function isURL(value) {
        if (value instanceof URL2) return true;
        return typeof value === "object" && value !== null && value[kind] === URL2[kind];
      };
      exports.isURLSearchParams = URLSearchParams.isURLSearchParams;
      exports.parse = function parse2(input, base) {
        const url = new URL2(input, base, { throw: false });
        return url._href ? url : null;
      };
      exports.canParse = function canParse(input, base) {
        return binding.canParse(String(input), base ? String(base) : null);
      };
      exports.fileURLToPath = function fileURLToPath(url) {
        if (typeof url === "string") {
          url = new URL2(url);
        }
        if (url.protocol !== "file:") {
          throw errors.INVALID_URL_SCHEME("The URL must use the file: protocol");
        }
        if (isWindows) {
          if (/%2f|%5c/i.test(url.pathname)) {
            throw errors.INVALID_FILE_URL_PATH(
              "The file: URL path must not include encoded \\ or / characters"
            );
          }
        } else {
          if (url.hostname) {
            throw errors.INVALID_FILE_URL_HOST("The file: URL host must be 'localhost' or empty");
          }
          if (/%2f/i.test(url.pathname)) {
            throw errors.INVALID_FILE_URL_PATH("The file: URL path must not include encoded / characters");
          }
        }
        const pathname = path.normalize(decodeURIComponent(url.pathname));
        if (isWindows) {
          if (url.hostname) return "\\\\" + url.hostname + pathname;
          const letter = pathname.charCodeAt(1) | 32;
          if (letter < 97 || letter > 122 || pathname.charCodeAt(2) !== 58) {
            throw errors.INVALID_FILE_URL_PATH("The file: URL path must be absolute");
          }
          return pathname.slice(1);
        }
        return pathname;
      };
      exports.pathToFileURL = function pathToFileURL(pathname) {
        let resolved = path.resolve(pathname);
        if (pathname[pathname.length - 1] === "/") {
          resolved += "/";
        } else if (isWindows && pathname[pathname.length - 1] === "\\") {
          resolved += "\\";
        }
        resolved = resolved.replaceAll("%", "%25").replaceAll("#", "%23").replaceAll("?", "%3f").replaceAll("\n", "%0a").replaceAll("\r", "%0d").replaceAll("	", "%09");
        if (!isWindows) {
          resolved = resolved.replaceAll("\\", "%5c");
        }
        return new URL2("file:" + resolved);
      };
      exports.format = function format(parts) {
        const { protocol, auth, host, hostname, port, pathname, search, query, hash, slashes } = parts;
        let result = "";
        if (typeof protocol === "string") {
          result += protocol;
          if (protocol[protocol.length - 1] !== ":") {
            result += ":";
          }
          if (slashes === true || /https?|ftp|gopher|file/.test(protocol)) {
            result += "//";
          }
        }
        if (typeof auth === "string") {
          if (host || hostname) result += auth + "@";
        }
        if (typeof host === "string") result += host;
        else {
          result += hostname;
          if (port) result += ":" + port;
        }
        if (typeof pathname === "string" && pathname !== "") {
          if (pathname[0] !== "/") result += "/";
          result += pathname;
        }
        if (typeof search === "string") {
          if (search[0] !== "?") result += "?";
          result += search;
        } else if (typeof query === "object" && query !== null) {
          result += "?" + new URLSearchParams(query);
        }
        if (typeof hash === "string") {
          if (hash[0] !== "#") result += "#";
          result += hash;
        }
        return result;
      };
    }
  });

  // ../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js
  var require_bare_node_events = __commonJS({
    "../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js"(exports, module) {
      module.exports = require_bare_events();
    }
  });

  // ../../node_modules/events-universal/default.js
  var require_default = __commonJS({
    "../../node_modules/events-universal/default.js"(exports, module) {
      module.exports = require_bare_node_events();
    }
  });

  // ../../node_modules/b4a/index.js
  var require_b4a = __commonJS({
    "../../node_modules/b4a/index.js"(exports, module) {
      function isBuffer(value) {
        return Buffer.isBuffer(value) || value instanceof Uint8Array;
      }
      function isEncoding(encoding) {
        return Buffer.isEncoding(encoding);
      }
      function alloc(size, fill2, encoding) {
        return Buffer.alloc(size, fill2, encoding);
      }
      function allocUnsafe(size) {
        return Buffer.allocUnsafe(size);
      }
      function allocUnsafeSlow(size) {
        return Buffer.allocUnsafeSlow(size);
      }
      function byteLength(string, encoding) {
        return Buffer.byteLength(string, encoding);
      }
      function compare(a, b) {
        return Buffer.compare(a, b);
      }
      function concat(buffers, totalLength) {
        return Buffer.concat(buffers, totalLength);
      }
      function copy(source, target, targetStart, start, end) {
        return toBuffer(source).copy(target, targetStart, start, end);
      }
      function equals(a, b) {
        return toBuffer(a).equals(b);
      }
      function fill(buffer, value, offset, end, encoding) {
        return toBuffer(buffer).fill(value, offset, end, encoding);
      }
      function from(value, encodingOrOffset, length) {
        return Buffer.from(value, encodingOrOffset, length);
      }
      function includes(buffer, value, byteOffset, encoding) {
        return toBuffer(buffer).includes(value, byteOffset, encoding);
      }
      function indexOf(buffer, value, byfeOffset, encoding) {
        return toBuffer(buffer).indexOf(value, byfeOffset, encoding);
      }
      function lastIndexOf(buffer, value, byteOffset, encoding) {
        return toBuffer(buffer).lastIndexOf(value, byteOffset, encoding);
      }
      function swap16(buffer) {
        return toBuffer(buffer).swap16();
      }
      function swap32(buffer) {
        return toBuffer(buffer).swap32();
      }
      function swap64(buffer) {
        return toBuffer(buffer).swap64();
      }
      function toBuffer(buffer) {
        if (Buffer.isBuffer(buffer)) return buffer;
        return Buffer.from(buffer.buffer, buffer.byteOffset, buffer.byteLength);
      }
      function toString(buffer, encoding, start, end) {
        return toBuffer(buffer).toString(encoding, start, end);
      }
      function write(buffer, string, offset, length, encoding) {
        return toBuffer(buffer).write(string, offset, length, encoding);
      }
      function readDoubleBE(buffer, offset) {
        return toBuffer(buffer).readDoubleBE(offset);
      }
      function readDoubleLE(buffer, offset) {
        return toBuffer(buffer).readDoubleLE(offset);
      }
      function readFloatBE(buffer, offset) {
        return toBuffer(buffer).readFloatBE(offset);
      }
      function readFloatLE(buffer, offset) {
        return toBuffer(buffer).readFloatLE(offset);
      }
      function readInt32BE(buffer, offset) {
        return toBuffer(buffer).readInt32BE(offset);
      }
      function readInt32LE(buffer, offset) {
        return toBuffer(buffer).readInt32LE(offset);
      }
      function readUInt32BE(buffer, offset) {
        return toBuffer(buffer).readUInt32BE(offset);
      }
      function readUInt32LE(buffer, offset) {
        return toBuffer(buffer).readUInt32LE(offset);
      }
      function writeDoubleBE(buffer, value, offset) {
        return toBuffer(buffer).writeDoubleBE(value, offset);
      }
      function writeDoubleLE(buffer, value, offset) {
        return toBuffer(buffer).writeDoubleLE(value, offset);
      }
      function writeFloatBE(buffer, value, offset) {
        return toBuffer(buffer).writeFloatBE(value, offset);
      }
      function writeFloatLE(buffer, value, offset) {
        return toBuffer(buffer).writeFloatLE(value, offset);
      }
      function writeInt32BE(buffer, value, offset) {
        return toBuffer(buffer).writeInt32BE(value, offset);
      }
      function writeInt32LE(buffer, value, offset) {
        return toBuffer(buffer).writeInt32LE(value, offset);
      }
      function writeUInt32BE(buffer, value, offset) {
        return toBuffer(buffer).writeUInt32BE(value, offset);
      }
      function writeUInt32LE(buffer, value, offset) {
        return toBuffer(buffer).writeUInt32LE(value, offset);
      }
      module.exports = {
        isBuffer,
        isEncoding,
        alloc,
        allocUnsafe,
        allocUnsafeSlow,
        byteLength,
        compare,
        concat,
        copy,
        equals,
        fill,
        from,
        includes,
        indexOf,
        lastIndexOf,
        swap16,
        swap32,
        swap64,
        toBuffer,
        toString,
        write,
        readDoubleBE,
        readDoubleLE,
        readFloatBE,
        readFloatLE,
        readInt32BE,
        readInt32LE,
        readUInt32BE,
        readUInt32LE,
        writeDoubleBE,
        writeDoubleLE,
        writeFloatBE,
        writeFloatLE,
        writeInt32BE,
        writeInt32LE,
        writeUInt32BE,
        writeUInt32LE
      };
    }
  });

  // ../../node_modules/text-decoder/lib/pass-through-decoder.js
  var require_pass_through_decoder = __commonJS({
    "../../node_modules/text-decoder/lib/pass-through-decoder.js"(exports, module) {
      var b4a = require_b4a();
      module.exports = class PassThroughDecoder {
        constructor(encoding) {
          this.encoding = encoding;
        }
        get remaining() {
          return 0;
        }
        decode(data) {
          return b4a.toString(data, this.encoding);
        }
        flush() {
          return "";
        }
      };
    }
  });

  // ../../node_modules/text-decoder/lib/utf8-decoder.js
  var require_utf8_decoder = __commonJS({
    "../../node_modules/text-decoder/lib/utf8-decoder.js"(exports, module) {
      var b4a = require_b4a();
      module.exports = class UTF8Decoder {
        constructor() {
          this._reset();
        }
        get remaining() {
          return this.bytesSeen;
        }
        decode(data) {
          if (data.byteLength === 0) return "";
          if (this.bytesNeeded === 0 && trailingIncomplete(data, 0) === 0) {
            this.bytesSeen = trailingBytesSeen(data);
            return b4a.toString(data, "utf8");
          }
          let result = "";
          let start = 0;
          if (this.bytesNeeded > 0) {
            while (start < data.byteLength) {
              const byte = data[start];
              if (byte < this.lowerBoundary || byte > this.upperBoundary) {
                result += "\uFFFD";
                this._reset();
                break;
              }
              this.lowerBoundary = 128;
              this.upperBoundary = 191;
              this.codePoint = this.codePoint << 6 | byte & 63;
              this.bytesSeen++;
              start++;
              if (this.bytesSeen === this.bytesNeeded) {
                result += String.fromCodePoint(this.codePoint);
                this._reset();
                break;
              }
            }
            if (this.bytesNeeded > 0) return result;
          }
          const trailing = trailingIncomplete(data, start);
          const end = data.byteLength - trailing;
          if (end > start) result += b4a.toString(data, "utf8", start, end);
          for (let i = end; i < data.byteLength; i++) {
            const byte = data[i];
            if (this.bytesNeeded === 0) {
              if (byte <= 127) {
                this.bytesSeen = 0;
                result += String.fromCharCode(byte);
              } else if (byte >= 194 && byte <= 223) {
                this.bytesNeeded = 2;
                this.bytesSeen = 1;
                this.codePoint = byte & 31;
              } else if (byte >= 224 && byte <= 239) {
                if (byte === 224) this.lowerBoundary = 160;
                else if (byte === 237) this.upperBoundary = 159;
                this.bytesNeeded = 3;
                this.bytesSeen = 1;
                this.codePoint = byte & 15;
              } else if (byte >= 240 && byte <= 244) {
                if (byte === 240) this.lowerBoundary = 144;
                else if (byte === 244) this.upperBoundary = 143;
                this.bytesNeeded = 4;
                this.bytesSeen = 1;
                this.codePoint = byte & 7;
              } else {
                this.bytesSeen = 1;
                result += "\uFFFD";
              }
              continue;
            }
            if (byte < this.lowerBoundary || byte > this.upperBoundary) {
              result += "\uFFFD";
              i--;
              this._reset();
              continue;
            }
            this.lowerBoundary = 128;
            this.upperBoundary = 191;
            this.codePoint = this.codePoint << 6 | byte & 63;
            this.bytesSeen++;
            if (this.bytesSeen === this.bytesNeeded) {
              result += String.fromCodePoint(this.codePoint);
              this._reset();
            }
          }
          return result;
        }
        flush() {
          const result = this.bytesNeeded > 0 ? "\uFFFD" : "";
          this._reset();
          return result;
        }
        _reset() {
          this.codePoint = 0;
          this.bytesNeeded = 0;
          this.bytesSeen = 0;
          this.lowerBoundary = 128;
          this.upperBoundary = 191;
        }
      };
      function trailingIncomplete(data, start) {
        const len = data.byteLength;
        if (len <= start) return 0;
        const limit = Math.max(start, len - 4);
        let i = len - 1;
        while (i > limit && (data[i] & 192) === 128) i--;
        if (i < start) return 0;
        const byte = data[i];
        let needed;
        if (byte <= 127) return 0;
        if (byte >= 194 && byte <= 223) needed = 2;
        else if (byte >= 224 && byte <= 239) needed = 3;
        else if (byte >= 240 && byte <= 244) needed = 4;
        else return 0;
        const available = len - i;
        return available < needed ? available : 0;
      }
      function trailingBytesSeen(data) {
        const len = data.byteLength;
        if (len === 0) return 0;
        const last = data[len - 1];
        if (last <= 127) return 0;
        if ((last & 192) !== 128) return 1;
        const limit = Math.max(0, len - 4);
        let i = len - 2;
        while (i >= limit && (data[i] & 192) === 128) i--;
        if (i < 0) return 1;
        const first = data[i];
        let needed;
        if (first >= 194 && first <= 223) needed = 2;
        else if (first >= 224 && first <= 239) needed = 3;
        else if (first >= 240 && first <= 244) needed = 4;
        else return 1;
        if (len - i !== needed) return 1;
        if (needed >= 3) {
          const second = data[i + 1];
          if (first === 224 && second < 160) return 1;
          if (first === 237 && second > 159) return 1;
          if (first === 240 && second < 144) return 1;
          if (first === 244 && second > 143) return 1;
        }
        return 0;
      }
    }
  });

  // ../../node_modules/text-decoder/index.js
  var require_text_decoder = __commonJS({
    "../../node_modules/text-decoder/index.js"(exports, module) {
      var PassThroughDecoder = require_pass_through_decoder();
      var UTF8Decoder = require_utf8_decoder();
      module.exports = class TextDecoder {
        constructor(encoding = "utf8") {
          this.encoding = normalizeEncoding(encoding);
          switch (this.encoding) {
            case "utf8":
              this.decoder = new UTF8Decoder();
              break;
            case "utf16le":
            case "base64":
              throw new Error("Unsupported encoding: " + this.encoding);
            default:
              this.decoder = new PassThroughDecoder(this.encoding);
          }
        }
        get remaining() {
          return this.decoder.remaining;
        }
        push(data) {
          if (typeof data === "string") return data;
          return this.decoder.decode(data);
        }
        // For Node.js compatibility
        write(data) {
          return this.push(data);
        }
        end(data) {
          let result = "";
          if (data) result = this.push(data);
          result += this.decoder.flush();
          return result;
        }
      };
      function normalizeEncoding(encoding) {
        encoding = encoding.toLowerCase();
        switch (encoding) {
          case "utf8":
          case "utf-8":
            return "utf8";
          case "ucs2":
          case "ucs-2":
          case "utf16le":
          case "utf-16le":
            return "utf16le";
          case "latin1":
          case "binary":
            return "latin1";
          case "base64":
          case "ascii":
          case "hex":
            return encoding;
          default:
            throw new Error("Unknown encoding: " + encoding);
        }
      }
    }
  });

  // ../../node_modules/streamx/index.js
  var require_streamx = __commonJS({
    "../../node_modules/streamx/index.js"(exports, module) {
      var { EventEmitter } = require_default();
      var STREAM_DESTROYED = new Error("Stream was destroyed");
      var PREMATURE_CLOSE = new Error("Premature close");
      var FIFO = require_fast_fifo();
      var TextDecoder = require_text_decoder();
      var qmt = typeof queueMicrotask === "undefined" ? (fn) => global.process.nextTick(fn) : queueMicrotask;
      var MAX = (1 << 29) - 1;
      var OPENING = 1;
      var PREDESTROYING = 2;
      var DESTROYING = 4;
      var DESTROYED = 8;
      var NOT_OPENING = MAX ^ OPENING;
      var NOT_PREDESTROYING = MAX ^ PREDESTROYING;
      var READ_ACTIVE = 1 << 4;
      var READ_UPDATING = 2 << 4;
      var READ_PRIMARY = 4 << 4;
      var READ_QUEUED = 8 << 4;
      var READ_RESUMED = 16 << 4;
      var READ_PIPE_DRAINED = 32 << 4;
      var READ_ENDING = 64 << 4;
      var READ_EMIT_DATA = 128 << 4;
      var READ_EMIT_READABLE = 256 << 4;
      var READ_EMITTED_READABLE = 512 << 4;
      var READ_DONE = 1024 << 4;
      var READ_NEXT_TICK = 2048 << 4;
      var READ_NEEDS_PUSH = 4096 << 4;
      var READ_READ_AHEAD = 8192 << 4;
      var READ_FLOWING = READ_RESUMED | READ_PIPE_DRAINED;
      var READ_ACTIVE_AND_NEEDS_PUSH = READ_ACTIVE | READ_NEEDS_PUSH;
      var READ_PRIMARY_AND_ACTIVE = READ_PRIMARY | READ_ACTIVE;
      var READ_EMIT_READABLE_AND_QUEUED = READ_EMIT_READABLE | READ_QUEUED;
      var READ_RESUMED_READ_AHEAD = READ_RESUMED | READ_READ_AHEAD;
      var READ_NOT_ACTIVE = MAX ^ READ_ACTIVE;
      var READ_NON_PRIMARY = MAX ^ READ_PRIMARY;
      var READ_NON_PRIMARY_AND_PUSHED = MAX ^ (READ_PRIMARY | READ_NEEDS_PUSH);
      var READ_PUSHED = MAX ^ READ_NEEDS_PUSH;
      var READ_PAUSED = MAX ^ READ_RESUMED;
      var READ_NOT_QUEUED = MAX ^ (READ_QUEUED | READ_EMITTED_READABLE);
      var READ_NOT_ENDING = MAX ^ READ_ENDING;
      var READ_PIPE_NOT_DRAINED = MAX ^ READ_FLOWING;
      var READ_NOT_NEXT_TICK = MAX ^ READ_NEXT_TICK;
      var READ_NOT_UPDATING = MAX ^ READ_UPDATING;
      var READ_NO_READ_AHEAD = MAX ^ READ_READ_AHEAD;
      var READ_PAUSED_NO_READ_AHEAD = MAX ^ READ_RESUMED_READ_AHEAD;
      var WRITE_ACTIVE = 1 << 18;
      var WRITE_UPDATING = 2 << 18;
      var WRITE_PRIMARY = 4 << 18;
      var WRITE_QUEUED = 8 << 18;
      var WRITE_UNDRAINED = 16 << 18;
      var WRITE_DONE = 32 << 18;
      var WRITE_EMIT_DRAIN = 64 << 18;
      var WRITE_NEXT_TICK = 128 << 18;
      var WRITE_WRITING = 256 << 18;
      var WRITE_FINISHING = 512 << 18;
      var WRITE_CORKED = 1024 << 18;
      var WRITE_NOT_ACTIVE = MAX ^ (WRITE_ACTIVE | WRITE_WRITING);
      var WRITE_NON_PRIMARY = MAX ^ WRITE_PRIMARY;
      var WRITE_NOT_FINISHING = MAX ^ (WRITE_ACTIVE | WRITE_FINISHING);
      var WRITE_DRAINED = MAX ^ WRITE_UNDRAINED;
      var WRITE_NOT_QUEUED = MAX ^ WRITE_QUEUED;
      var WRITE_NOT_NEXT_TICK = MAX ^ WRITE_NEXT_TICK;
      var WRITE_NOT_UPDATING = MAX ^ WRITE_UPDATING;
      var WRITE_NOT_CORKED = MAX ^ WRITE_CORKED;
      var ACTIVE = READ_ACTIVE | WRITE_ACTIVE;
      var NOT_ACTIVE = MAX ^ ACTIVE;
      var DONE = READ_DONE | WRITE_DONE;
      var DESTROY_STATUS = DESTROYING | DESTROYED | PREDESTROYING;
      var OPEN_STATUS = DESTROY_STATUS | OPENING;
      var AUTO_DESTROY = DESTROY_STATUS | DONE;
      var NON_PRIMARY = WRITE_NON_PRIMARY & READ_NON_PRIMARY;
      var ACTIVE_OR_TICKING = WRITE_NEXT_TICK | READ_NEXT_TICK;
      var TICKING = ACTIVE_OR_TICKING & NOT_ACTIVE;
      var IS_OPENING = OPEN_STATUS | TICKING;
      var READ_PRIMARY_STATUS = OPEN_STATUS | READ_ENDING | READ_DONE;
      var READ_STATUS = OPEN_STATUS | READ_DONE | READ_QUEUED;
      var READ_ENDING_STATUS = OPEN_STATUS | READ_ENDING | READ_QUEUED;
      var READ_READABLE_STATUS = OPEN_STATUS | READ_EMIT_READABLE | READ_QUEUED | READ_EMITTED_READABLE;
      var SHOULD_NOT_READ = OPEN_STATUS | READ_ACTIVE | READ_ENDING | READ_DONE | READ_NEEDS_PUSH | READ_READ_AHEAD;
      var READ_BACKPRESSURE_STATUS = DESTROY_STATUS | READ_ENDING | READ_DONE;
      var READ_UPDATE_SYNC_STATUS = READ_UPDATING | OPEN_STATUS | READ_NEXT_TICK | READ_PRIMARY;
      var READ_NEXT_TICK_OR_OPENING = READ_NEXT_TICK | OPENING;
      var WRITE_PRIMARY_STATUS = OPEN_STATUS | WRITE_FINISHING | WRITE_DONE;
      var WRITE_QUEUED_AND_UNDRAINED = WRITE_QUEUED | WRITE_UNDRAINED;
      var WRITE_QUEUED_AND_ACTIVE = WRITE_QUEUED | WRITE_ACTIVE;
      var WRITE_DRAIN_STATUS = WRITE_QUEUED | WRITE_UNDRAINED | OPEN_STATUS | WRITE_ACTIVE;
      var WRITE_STATUS = OPEN_STATUS | WRITE_ACTIVE | WRITE_QUEUED | WRITE_CORKED;
      var WRITE_PRIMARY_AND_ACTIVE = WRITE_PRIMARY | WRITE_ACTIVE;
      var WRITE_ACTIVE_AND_WRITING = WRITE_ACTIVE | WRITE_WRITING;
      var WRITE_FINISHING_STATUS = OPEN_STATUS | WRITE_FINISHING | WRITE_QUEUED_AND_ACTIVE | WRITE_DONE;
      var WRITE_BACKPRESSURE_STATUS = WRITE_UNDRAINED | DESTROY_STATUS | WRITE_FINISHING | WRITE_DONE;
      var WRITE_UPDATE_SYNC_STATUS = WRITE_UPDATING | OPEN_STATUS | WRITE_NEXT_TICK | WRITE_PRIMARY;
      var WRITE_DROP_DATA = WRITE_FINISHING | WRITE_DONE | DESTROY_STATUS;
      var asyncIterator = Symbol.asyncIterator || Symbol("asyncIterator");
      var WritableState = class {
        constructor(stream, { highWaterMark = 16384, map = null, mapWritable, byteLength, byteLengthWritable } = {}) {
          this.stream = stream;
          this.queue = new FIFO();
          this.highWaterMark = highWaterMark;
          this.buffered = 0;
          this.error = null;
          this.pipeline = null;
          this.drains = null;
          this.byteLength = byteLengthWritable || byteLength || defaultByteLength;
          this.map = mapWritable || map;
          this.afterWrite = afterWrite.bind(this);
          this.afterUpdateNextTick = updateWriteNT.bind(this);
        }
        get ending() {
          return (this.stream._duplexState & WRITE_FINISHING) !== 0;
        }
        get ended() {
          return (this.stream._duplexState & WRITE_DONE) !== 0;
        }
        push(data) {
          if ((this.stream._duplexState & WRITE_DROP_DATA) !== 0) return false;
          if (this.map !== null) data = this.map(data);
          this.buffered += this.byteLength(data);
          this.queue.push(data);
          if (this.buffered < this.highWaterMark) {
            this.stream._duplexState |= WRITE_QUEUED;
            return true;
          }
          this.stream._duplexState |= WRITE_QUEUED_AND_UNDRAINED;
          return false;
        }
        shift() {
          const data = this.queue.shift();
          this.buffered -= this.byteLength(data);
          if (this.buffered === 0) this.stream._duplexState &= WRITE_NOT_QUEUED;
          return data;
        }
        end(data) {
          if (typeof data === "function") this.stream.once("finish", data);
          else if (data !== void 0 && data !== null) this.push(data);
          this.stream._duplexState = (this.stream._duplexState | WRITE_FINISHING) & WRITE_NON_PRIMARY;
        }
        autoBatch(data, cb) {
          const buffer = [];
          const stream = this.stream;
          buffer.push(data);
          while ((stream._duplexState & WRITE_STATUS) === WRITE_QUEUED_AND_ACTIVE) {
            buffer.push(stream._writableState.shift());
          }
          if ((stream._duplexState & OPEN_STATUS) !== 0) return cb(null);
          stream._writev(buffer, cb);
        }
        update() {
          const stream = this.stream;
          stream._duplexState |= WRITE_UPDATING;
          do {
            while ((stream._duplexState & WRITE_STATUS) === WRITE_QUEUED) {
              const data = this.shift();
              stream._duplexState |= WRITE_ACTIVE_AND_WRITING;
              stream._write(data, this.afterWrite);
            }
            if ((stream._duplexState & WRITE_PRIMARY_AND_ACTIVE) === 0) this.updateNonPrimary();
          } while (this.continueUpdate() === true);
          stream._duplexState &= WRITE_NOT_UPDATING;
        }
        updateNonPrimary() {
          const stream = this.stream;
          if ((stream._duplexState & WRITE_FINISHING_STATUS) === WRITE_FINISHING) {
            stream._duplexState = stream._duplexState | WRITE_ACTIVE;
            stream._final(afterFinal.bind(this));
            return;
          }
          if ((stream._duplexState & DESTROY_STATUS) === DESTROYING) {
            if ((stream._duplexState & ACTIVE_OR_TICKING) === 0) {
              stream._duplexState |= ACTIVE;
              stream._destroy(afterDestroy.bind(this));
            }
            return;
          }
          if ((stream._duplexState & IS_OPENING) === OPENING) {
            stream._duplexState = (stream._duplexState | ACTIVE) & NOT_OPENING;
            stream._open(afterOpen.bind(this));
          }
        }
        continueUpdate() {
          if ((this.stream._duplexState & WRITE_NEXT_TICK) === 0) return false;
          this.stream._duplexState &= WRITE_NOT_NEXT_TICK;
          return true;
        }
        updateCallback() {
          if ((this.stream._duplexState & WRITE_UPDATE_SYNC_STATUS) === WRITE_PRIMARY) this.update();
          else this.updateNextTick();
        }
        updateNextTick() {
          if ((this.stream._duplexState & WRITE_NEXT_TICK) !== 0) return;
          this.stream._duplexState |= WRITE_NEXT_TICK;
          if ((this.stream._duplexState & WRITE_UPDATING) === 0) qmt(this.afterUpdateNextTick);
        }
      };
      var ReadableState = class {
        constructor(stream, { highWaterMark = 16384, map = null, mapReadable, byteLength, byteLengthReadable } = {}) {
          this.stream = stream;
          this.queue = new FIFO();
          this.highWaterMark = highWaterMark === 0 ? 1 : highWaterMark;
          this.buffered = 0;
          this.readAhead = highWaterMark > 0;
          this.error = null;
          this.pipeline = null;
          this.byteLength = byteLengthReadable || byteLength || defaultByteLength;
          this.map = mapReadable || map;
          this.pipeTo = null;
          this.afterRead = afterRead.bind(this);
          this.afterUpdateNextTick = updateReadNT.bind(this);
        }
        get ending() {
          return (this.stream._duplexState & READ_ENDING) !== 0;
        }
        get ended() {
          return (this.stream._duplexState & READ_DONE) !== 0;
        }
        pipe(pipeTo, cb) {
          if (this.pipeTo !== null) throw new Error("Can only pipe to one destination");
          if (typeof cb !== "function") cb = null;
          this.stream._duplexState |= READ_PIPE_DRAINED;
          this.pipeTo = pipeTo;
          this.pipeline = new Pipeline(this.stream, pipeTo, cb);
          if (cb) this.stream.on("error", noop);
          if (isStreamx(pipeTo)) {
            pipeTo._writableState.pipeline = this.pipeline;
            if (cb) pipeTo.on("error", noop);
            pipeTo.on("finish", this.pipeline.finished.bind(this.pipeline));
          } else {
            const onerror = this.pipeline.done.bind(this.pipeline, pipeTo);
            const onclose = this.pipeline.done.bind(this.pipeline, pipeTo, null);
            pipeTo.on("error", onerror);
            pipeTo.on("close", onclose);
            pipeTo.on("finish", this.pipeline.finished.bind(this.pipeline));
          }
          pipeTo.on("drain", afterDrain.bind(this));
          this.stream.emit("piping", pipeTo);
          pipeTo.emit("pipe", this.stream);
        }
        push(data) {
          const stream = this.stream;
          if (data === null) {
            this.highWaterMark = 0;
            stream._duplexState = (stream._duplexState | READ_ENDING) & READ_NON_PRIMARY_AND_PUSHED;
            return false;
          }
          if (this.map !== null) {
            data = this.map(data);
            if (data === null) {
              stream._duplexState &= READ_PUSHED;
              return this.buffered < this.highWaterMark;
            }
          }
          this.buffered += this.byteLength(data);
          this.queue.push(data);
          stream._duplexState = (stream._duplexState | READ_QUEUED) & READ_PUSHED;
          return this.buffered < this.highWaterMark;
        }
        shift() {
          const data = this.queue.shift();
          this.buffered -= this.byteLength(data);
          if (this.buffered === 0) this.stream._duplexState &= READ_NOT_QUEUED;
          return data;
        }
        unshift(data) {
          const pending = [this.map !== null ? this.map(data) : data];
          while (this.buffered > 0) pending.push(this.shift());
          for (let i = 0; i < pending.length - 1; i++) {
            const data2 = pending[i];
            this.buffered += this.byteLength(data2);
            this.queue.push(data2);
          }
          this.push(pending[pending.length - 1]);
        }
        read() {
          const stream = this.stream;
          if ((stream._duplexState & READ_STATUS) === READ_QUEUED) {
            const data = this.shift();
            if (this.pipeTo !== null && this.pipeTo.write(data) === false)
              stream._duplexState &= READ_PIPE_NOT_DRAINED;
            if ((stream._duplexState & READ_EMIT_DATA) !== 0) stream.emit("data", data);
            return data;
          }
          if (this.readAhead === false) {
            stream._duplexState |= READ_READ_AHEAD;
            this.updateNextTick();
          }
          return null;
        }
        drain() {
          const stream = this.stream;
          while ((stream._duplexState & READ_STATUS) === READ_QUEUED && (stream._duplexState & READ_FLOWING) !== 0) {
            const data = this.shift();
            if (this.pipeTo !== null && this.pipeTo.write(data) === false)
              stream._duplexState &= READ_PIPE_NOT_DRAINED;
            if ((stream._duplexState & READ_EMIT_DATA) !== 0) stream.emit("data", data);
          }
        }
        update() {
          const stream = this.stream;
          stream._duplexState |= READ_UPDATING;
          do {
            this.drain();
            while (this.buffered < this.highWaterMark && (stream._duplexState & SHOULD_NOT_READ) === READ_READ_AHEAD) {
              stream._duplexState |= READ_ACTIVE_AND_NEEDS_PUSH;
              stream._read(this.afterRead);
              this.drain();
            }
            if ((stream._duplexState & READ_READABLE_STATUS) === READ_EMIT_READABLE_AND_QUEUED) {
              stream._duplexState |= READ_EMITTED_READABLE;
              stream.emit("readable");
            }
            if ((stream._duplexState & READ_PRIMARY_AND_ACTIVE) === 0) this.updateNonPrimary();
          } while (this.continueUpdate() === true);
          stream._duplexState &= READ_NOT_UPDATING;
        }
        updateNonPrimary() {
          const stream = this.stream;
          if ((stream._duplexState & READ_ENDING_STATUS) === READ_ENDING) {
            stream._duplexState = (stream._duplexState | READ_DONE) & READ_NOT_ENDING;
            stream.emit("end");
            if ((stream._duplexState & AUTO_DESTROY) === DONE) stream._duplexState |= DESTROYING;
            if (this.pipeTo !== null) this.pipeTo.end();
          }
          if ((stream._duplexState & DESTROY_STATUS) === DESTROYING) {
            if ((stream._duplexState & ACTIVE_OR_TICKING) === 0) {
              stream._duplexState |= ACTIVE;
              stream._destroy(afterDestroy.bind(this));
            }
            return;
          }
          if ((stream._duplexState & IS_OPENING) === OPENING) {
            stream._duplexState = (stream._duplexState | ACTIVE) & NOT_OPENING;
            stream._open(afterOpen.bind(this));
          }
        }
        continueUpdate() {
          if ((this.stream._duplexState & READ_NEXT_TICK) === 0) return false;
          this.stream._duplexState &= READ_NOT_NEXT_TICK;
          return true;
        }
        updateCallback() {
          if ((this.stream._duplexState & READ_UPDATE_SYNC_STATUS) === READ_PRIMARY) this.update();
          else this.updateNextTick();
        }
        updateNextTickIfOpen() {
          if ((this.stream._duplexState & READ_NEXT_TICK_OR_OPENING) !== 0) return;
          this.stream._duplexState |= READ_NEXT_TICK;
          if ((this.stream._duplexState & READ_UPDATING) === 0) qmt(this.afterUpdateNextTick);
        }
        updateNextTick() {
          if ((this.stream._duplexState & READ_NEXT_TICK) !== 0) return;
          this.stream._duplexState |= READ_NEXT_TICK;
          if ((this.stream._duplexState & READ_UPDATING) === 0) qmt(this.afterUpdateNextTick);
        }
      };
      var TransformState = class {
        constructor(stream) {
          this.data = null;
          this.afterTransform = afterTransform.bind(stream);
          this.afterFinal = null;
        }
      };
      var Pipeline = class {
        constructor(src, dst, cb) {
          this.from = src;
          this.to = dst;
          this.afterPipe = cb;
          this.error = null;
          this.pipeToFinished = false;
        }
        finished() {
          this.pipeToFinished = true;
        }
        done(stream, err) {
          if (err) this.error = err;
          if (stream === this.to) {
            this.to = null;
            if (this.from !== null) {
              if ((this.from._duplexState & READ_DONE) === 0 || !this.pipeToFinished) {
                this.from.destroy(this.error || new Error("Writable stream closed prematurely"));
              }
              return;
            }
          }
          if (stream === this.from) {
            this.from = null;
            if (this.to !== null) {
              if ((stream._duplexState & READ_DONE) === 0) {
                this.to.destroy(this.error || new Error("Readable stream closed before ending"));
              }
              return;
            }
          }
          if (this.afterPipe !== null) this.afterPipe(this.error);
          this.to = this.from = this.afterPipe = null;
        }
      };
      function afterDrain() {
        this.stream._duplexState |= READ_PIPE_DRAINED;
        this.updateCallback();
      }
      function afterFinal(err) {
        const stream = this.stream;
        if (err) stream.destroy(err);
        if ((stream._duplexState & DESTROY_STATUS) === 0) {
          stream._duplexState |= WRITE_DONE;
          stream.emit("finish");
        }
        if ((stream._duplexState & AUTO_DESTROY) === DONE) {
          stream._duplexState |= DESTROYING;
        }
        stream._duplexState &= WRITE_NOT_FINISHING;
        if ((stream._duplexState & WRITE_UPDATING) === 0) this.update();
        else this.updateNextTick();
      }
      function afterDestroy(err) {
        const stream = this.stream;
        if (!err && this.error !== STREAM_DESTROYED) err = this.error;
        if (err) stream.emit("error", err);
        stream._duplexState |= DESTROYED;
        stream.emit("close");
        const rs = stream._readableState;
        const ws = stream._writableState;
        if (rs !== null && rs.pipeline !== null) rs.pipeline.done(stream, err);
        if (ws !== null) {
          while (ws.drains !== null && ws.drains.length > 0) ws.drains.shift().resolve(false);
          if (ws.pipeline !== null) ws.pipeline.done(stream, err);
        }
      }
      function afterWrite(err) {
        const stream = this.stream;
        if (err) stream.destroy(err);
        stream._duplexState &= WRITE_NOT_ACTIVE;
        if (this.drains !== null) tickDrains(this.drains);
        if ((stream._duplexState & WRITE_DRAIN_STATUS) === WRITE_UNDRAINED) {
          stream._duplexState &= WRITE_DRAINED;
          if ((stream._duplexState & WRITE_EMIT_DRAIN) === WRITE_EMIT_DRAIN) {
            stream.emit("drain");
          }
        }
        this.updateCallback();
      }
      function afterRead(err) {
        if (err) this.stream.destroy(err);
        this.stream._duplexState &= READ_NOT_ACTIVE;
        if (this.readAhead === false && (this.stream._duplexState & READ_RESUMED) === 0)
          this.stream._duplexState &= READ_NO_READ_AHEAD;
        this.updateCallback();
      }
      function updateReadNT() {
        if ((this.stream._duplexState & READ_UPDATING) === 0) {
          this.stream._duplexState &= READ_NOT_NEXT_TICK;
          this.update();
        }
      }
      function updateWriteNT() {
        if ((this.stream._duplexState & WRITE_UPDATING) === 0) {
          this.stream._duplexState &= WRITE_NOT_NEXT_TICK;
          this.update();
        }
      }
      function tickDrains(drains) {
        for (let i = 0; i < drains.length; i++) {
          if (--drains[i].writes === 0) {
            drains.shift().resolve(true);
            i--;
          }
        }
      }
      function afterOpen(err) {
        const stream = this.stream;
        if (err) stream.destroy(err);
        if ((stream._duplexState & DESTROYING) === 0) {
          if ((stream._duplexState & READ_PRIMARY_STATUS) === 0) stream._duplexState |= READ_PRIMARY;
          if ((stream._duplexState & WRITE_PRIMARY_STATUS) === 0) stream._duplexState |= WRITE_PRIMARY;
          stream.emit("open");
        }
        stream._duplexState &= NOT_ACTIVE;
        if (stream._writableState !== null) {
          stream._writableState.updateCallback();
        }
        if (stream._readableState !== null) {
          stream._readableState.updateCallback();
        }
      }
      function afterTransform(err, data) {
        if (data !== void 0 && data !== null) this.push(data);
        this._writableState.afterWrite(err);
      }
      function newListener(name) {
        if (this._readableState !== null) {
          if (name === "data") {
            this._duplexState |= READ_EMIT_DATA | READ_RESUMED_READ_AHEAD;
            this._readableState.updateNextTick();
          }
          if (name === "readable") {
            this._duplexState |= READ_EMIT_READABLE;
            this._readableState.updateNextTick();
          }
        }
        if (this._writableState !== null) {
          if (name === "drain") {
            this._duplexState |= WRITE_EMIT_DRAIN;
            this._writableState.updateNextTick();
          }
        }
      }
      var Stream = class extends EventEmitter {
        constructor(opts) {
          super();
          this._duplexState = 0;
          this._readableState = null;
          this._writableState = null;
          if (opts) {
            if (opts.open) this._open = opts.open;
            if (opts.destroy) this._destroy = opts.destroy;
            if (opts.predestroy) this._predestroy = opts.predestroy;
            if (opts.signal) {
              opts.signal.addEventListener("abort", abort.bind(this));
            }
          }
          this.on("newListener", newListener);
        }
        _open(cb) {
          cb(null);
        }
        _destroy(cb) {
          cb(null);
        }
        _predestroy() {
        }
        get readable() {
          return this._readableState !== null ? true : void 0;
        }
        get writable() {
          return this._writableState !== null ? true : void 0;
        }
        get destroyed() {
          return (this._duplexState & DESTROYED) !== 0;
        }
        get destroying() {
          return (this._duplexState & DESTROY_STATUS) !== 0;
        }
        destroy(err) {
          if ((this._duplexState & DESTROY_STATUS) === 0) {
            if (!err) err = STREAM_DESTROYED;
            this._duplexState = (this._duplexState | DESTROYING) & NON_PRIMARY;
            if (this._readableState !== null) {
              this._readableState.highWaterMark = 0;
              this._readableState.error = err;
            }
            if (this._writableState !== null) {
              this._writableState.highWaterMark = 0;
              this._writableState.error = err;
            }
            this._duplexState |= PREDESTROYING;
            this._predestroy();
            this._duplexState &= NOT_PREDESTROYING;
            if (this._readableState !== null) this._readableState.updateNextTick();
            if (this._writableState !== null) this._writableState.updateNextTick();
          }
        }
      };
      var Readable = class _Readable extends Stream {
        constructor(opts) {
          super(opts);
          this._duplexState |= OPENING | WRITE_DONE | READ_READ_AHEAD;
          this._readableState = new ReadableState(this, opts);
          if (opts) {
            if (this._readableState.readAhead === false) this._duplexState &= READ_NO_READ_AHEAD;
            if (opts.read) this._read = opts.read;
            if (opts.eagerOpen) this._readableState.updateNextTick();
            if (opts.encoding) this.setEncoding(opts.encoding);
          }
        }
        setEncoding(encoding) {
          const dec = new TextDecoder(encoding);
          const map = this._readableState.map || echo;
          this._readableState.map = mapOrSkip;
          return this;
          function mapOrSkip(data) {
            const next = dec.push(data);
            return next === "" && (data.byteLength !== 0 || dec.remaining > 0) ? null : map(next);
          }
        }
        _read(cb) {
          cb(null);
        }
        pipe(dest, cb) {
          this._readableState.updateNextTick();
          this._readableState.pipe(dest, cb);
          return dest;
        }
        read() {
          this._readableState.updateNextTick();
          return this._readableState.read();
        }
        push(data) {
          this._readableState.updateNextTickIfOpen();
          return this._readableState.push(data);
        }
        unshift(data) {
          this._readableState.updateNextTickIfOpen();
          return this._readableState.unshift(data);
        }
        resume() {
          this._duplexState |= READ_RESUMED_READ_AHEAD;
          this._readableState.updateNextTick();
          return this;
        }
        pause() {
          this._duplexState &= this._readableState.readAhead === false ? READ_PAUSED_NO_READ_AHEAD : READ_PAUSED;
          return this;
        }
        static _fromAsyncIterator(ite, opts) {
          let destroy;
          const rs = new _Readable({
            ...opts,
            read(cb) {
              ite.next().then(push).then(cb.bind(null, null)).catch(cb);
            },
            predestroy() {
              destroy = ite.return();
            },
            destroy(cb) {
              if (!destroy) return cb(null);
              destroy.then(cb.bind(null, null)).catch(cb);
            }
          });
          return rs;
          function push(data) {
            if (data.done) rs.push(null);
            else rs.push(data.value);
          }
        }
        static from(data, opts) {
          if (isReadStreamx(data)) return data;
          if (data[asyncIterator]) return this._fromAsyncIterator(data[asyncIterator](), opts);
          if (!Array.isArray(data)) data = data === void 0 ? [] : [data];
          let i = 0;
          return new _Readable({
            ...opts,
            read(cb) {
              this.push(i === data.length ? null : data[i++]);
              cb(null);
            }
          });
        }
        static isBackpressured(rs) {
          return (rs._duplexState & READ_BACKPRESSURE_STATUS) !== 0 || rs._readableState.buffered >= rs._readableState.highWaterMark;
        }
        static isPaused(rs) {
          return (rs._duplexState & READ_RESUMED) === 0;
        }
        [asyncIterator]() {
          const stream = this;
          let error = null;
          let promiseResolve = null;
          let promiseReject = null;
          this.on("error", (err) => {
            error = err;
          });
          this.on("readable", onreadable);
          this.on("close", onclose);
          return {
            [asyncIterator]() {
              return this;
            },
            next() {
              return new Promise(function(resolve, reject) {
                promiseResolve = resolve;
                promiseReject = reject;
                const data = stream.read();
                if (data !== null) ondata(data);
                else if ((stream._duplexState & DESTROYED) !== 0) ondata(null);
              });
            },
            return() {
              return destroy(null);
            },
            throw(err) {
              return destroy(err);
            }
          };
          function onreadable() {
            if (promiseResolve !== null) ondata(stream.read());
          }
          function onclose() {
            if (promiseResolve !== null) ondata(null);
          }
          function ondata(data) {
            if (promiseReject === null) return;
            if (error) promiseReject(error);
            else if (data === null && (stream._duplexState & READ_DONE) === 0)
              promiseReject(STREAM_DESTROYED);
            else promiseResolve({ value: data, done: data === null });
            promiseReject = promiseResolve = null;
          }
          function destroy(err) {
            stream.destroy(err);
            return new Promise((resolve, reject) => {
              if (stream._duplexState & DESTROYED) return resolve({ value: void 0, done: true });
              stream.once("close", function() {
                if (err) reject(err);
                else resolve({ value: void 0, done: true });
              });
            });
          }
        }
      };
      var Writable = class extends Stream {
        constructor(opts) {
          super(opts);
          this._duplexState |= OPENING | READ_DONE;
          this._writableState = new WritableState(this, opts);
          if (opts) {
            if (opts.writev) this._writev = opts.writev;
            if (opts.write) this._write = opts.write;
            if (opts.final) this._final = opts.final;
            if (opts.eagerOpen) this._writableState.updateNextTick();
          }
        }
        cork() {
          this._duplexState |= WRITE_CORKED;
        }
        uncork() {
          this._duplexState &= WRITE_NOT_CORKED;
          this._writableState.updateNextTick();
        }
        _writev(batch, cb) {
          cb(null);
        }
        _write(data, cb) {
          this._writableState.autoBatch(data, cb);
        }
        _final(cb) {
          cb(null);
        }
        static isBackpressured(ws) {
          return (ws._duplexState & WRITE_BACKPRESSURE_STATUS) !== 0;
        }
        static drained(ws) {
          if (ws.destroyed) return Promise.resolve(false);
          const state = ws._writableState;
          const pending = isWritev(ws) ? Math.min(1, state.queue.length) : state.queue.length;
          const writes = pending + (ws._duplexState & WRITE_WRITING ? 1 : 0);
          if (writes === 0) return Promise.resolve(true);
          if (state.drains === null) state.drains = [];
          return new Promise((resolve) => {
            state.drains.push({ writes, resolve });
          });
        }
        write(data) {
          this._writableState.updateNextTick();
          return this._writableState.push(data);
        }
        end(data) {
          this._writableState.updateNextTick();
          this._writableState.end(data);
          return this;
        }
      };
      var Duplex = class extends Readable {
        // and Writable
        constructor(opts) {
          super(opts);
          this._duplexState = OPENING | this._duplexState & READ_READ_AHEAD;
          this._writableState = new WritableState(this, opts);
          if (opts) {
            if (opts.writev) this._writev = opts.writev;
            if (opts.write) this._write = opts.write;
            if (opts.final) this._final = opts.final;
          }
        }
        cork() {
          this._duplexState |= WRITE_CORKED;
        }
        uncork() {
          this._duplexState &= WRITE_NOT_CORKED;
          this._writableState.updateNextTick();
        }
        _writev(batch, cb) {
          cb(null);
        }
        _write(data, cb) {
          this._writableState.autoBatch(data, cb);
        }
        _final(cb) {
          cb(null);
        }
        write(data) {
          this._writableState.updateNextTick();
          return this._writableState.push(data);
        }
        end(data) {
          this._writableState.updateNextTick();
          this._writableState.end(data);
          return this;
        }
      };
      var Transform = class extends Duplex {
        constructor(opts) {
          super(opts);
          this._transformState = new TransformState(this);
          if (opts) {
            if (opts.transform) this._transform = opts.transform;
            if (opts.flush) this._flush = opts.flush;
          }
        }
        _write(data, cb) {
          if (this._readableState.buffered >= this._readableState.highWaterMark) {
            this._transformState.data = data;
          } else {
            this._transform(data, this._transformState.afterTransform);
          }
        }
        _read(cb) {
          if (this._transformState.data !== null) {
            const data = this._transformState.data;
            this._transformState.data = null;
            cb(null);
            this._transform(data, this._transformState.afterTransform);
          } else {
            cb(null);
          }
        }
        destroy(err) {
          super.destroy(err);
          if (this._transformState.data !== null) {
            this._transformState.data = null;
            this._transformState.afterTransform();
          }
        }
        _transform(data, cb) {
          cb(null, data);
        }
        _flush(cb) {
          cb(null);
        }
        _final(cb) {
          this._transformState.afterFinal = cb;
          this._flush(transformAfterFlush.bind(this));
        }
      };
      var PassThrough = class extends Transform {
      };
      function transformAfterFlush(err, data) {
        const cb = this._transformState.afterFinal;
        if (err) return cb(err);
        if (data !== null && data !== void 0) this.push(data);
        this.push(null);
        cb(null);
      }
      function pipelinePromise(...streams) {
        return new Promise((resolve, reject) => {
          return pipeline(...streams, (err) => {
            if (err) return reject(err);
            resolve();
          });
        });
      }
      function pipeline(stream, ...streams) {
        const all = Array.isArray(stream) ? [...stream, ...streams] : [stream, ...streams];
        const done = all.length && typeof all[all.length - 1] === "function" ? all.pop() : null;
        if (all.length < 2) throw new Error("Pipeline requires at least 2 streams");
        let src = all[0];
        let dest = null;
        let error = null;
        for (let i = 1; i < all.length; i++) {
          dest = all[i];
          if (isStreamx(src)) {
            src.pipe(dest, onerror);
          } else {
            errorHandle(src, true, i > 1, onerror);
            src.pipe(dest);
          }
          src = dest;
        }
        if (done) {
          let fin = false;
          const autoDestroy = isStreamx(dest) || !!(dest._writableState && dest._writableState.autoDestroy);
          dest.on("error", (err) => {
            if (error === null) error = err;
          });
          dest.on("finish", () => {
            fin = true;
            if (!autoDestroy) done(error);
          });
          if (autoDestroy) {
            dest.on("close", () => done(error || (fin ? null : PREMATURE_CLOSE)));
          }
        }
        return dest;
        function errorHandle(s, rd, wr, onerror2) {
          s.on("error", onerror2);
          s.on("close", onclose);
          function onclose() {
            if (rd && s._readableState && !s._readableState.ended) return onerror2(PREMATURE_CLOSE);
            if (wr && s._writableState && !s._writableState.ended) return onerror2(PREMATURE_CLOSE);
          }
        }
        function onerror(err) {
          if (!err || error) return;
          error = err;
          for (const s of all) {
            s.destroy(err);
          }
        }
      }
      function echo(s) {
        return s;
      }
      function isStream(stream) {
        return !!stream._readableState || !!stream._writableState;
      }
      function isStreamx(stream) {
        return typeof stream._duplexState === "number" && isStream(stream);
      }
      function isEnding(stream) {
        return !!stream._readableState && stream._readableState.ending;
      }
      function isEnded(stream) {
        return !!stream._readableState && stream._readableState.ended;
      }
      function isFinishing(stream) {
        return !!stream._writableState && stream._writableState.ending;
      }
      function isFinished(stream) {
        return !!stream._writableState && stream._writableState.ended;
      }
      function getStreamError(stream, opts = {}) {
        const err = stream._readableState && stream._readableState.error || stream._writableState && stream._writableState.error;
        return !opts.all && err === STREAM_DESTROYED ? null : err;
      }
      function isReadStreamx(stream) {
        return isStreamx(stream) && stream.readable;
      }
      function isDisturbed(stream) {
        return (stream._duplexState & OPENING) !== OPENING || (stream._duplexState & DESTROYING) === DESTROYING || (stream._duplexState & ACTIVE_OR_TICKING) !== 0;
      }
      function isTypedArray(data) {
        return typeof data === "object" && data !== null && typeof data.byteLength === "number";
      }
      function defaultByteLength(data) {
        return isTypedArray(data) ? data.byteLength : 1024;
      }
      function noop() {
      }
      function abort() {
        this.destroy(new Error("Stream aborted."));
      }
      function isWritev(s) {
        return s._writev !== Writable.prototype._writev && s._writev !== Duplex.prototype._writev;
      }
      module.exports = {
        pipeline,
        pipelinePromise,
        isStream,
        isStreamx,
        isEnding,
        isEnded,
        isFinishing,
        isFinished,
        isDisturbed,
        getStreamError,
        Stream,
        Writable,
        Readable,
        Duplex,
        Transform,
        // Export PassThrough for compatibility with Node.js core's stream module
        PassThrough
      };
    }
  });

  // ../../node_modules/teex/index.js
  var require_teex = __commonJS({
    "../../node_modules/teex/index.js"(exports, module) {
      var { Readable } = require_streamx();
      module.exports = function(s, forks = 2) {
        const streams = new Array(forks);
        const status = new Array(forks).fill(true);
        let ended = false;
        for (let i = 0; i < forks; i++) {
          streams[i] = new Readable({
            read(cb) {
              const check = !status[i];
              status[i] = true;
              if (check && allReadable()) s.resume();
              cb(null);
            }
          });
        }
        s.on("end", function() {
          ended = true;
          for (const stream of streams) stream.push(null);
        });
        s.on("error", function(err) {
          for (const stream of streams) stream.destroy(err);
        });
        s.on("close", function() {
          if (ended) return;
          for (const stream of streams) stream.destroy();
        });
        s.on("data", function(data) {
          let needsPause = false;
          for (let i = 0; i < streams.length; i++) {
            if (!(status[i] = streams[i].push(data))) {
              needsPause = true;
            }
          }
          if (needsPause) s.pause();
        });
        return streams;
        function allReadable() {
          for (let j = 0; j < status.length; j++) {
            if (!status[j]) return false;
          }
          return true;
        }
      };
    }
  });

  // ../../node_modules/bare-stream/web.js
  var require_web = __commonJS({
    "../../node_modules/bare-stream/web.js"(exports) {
      var { Readable, Writable, Transform, getStreamError, isStreamx, isDisturbed } = require_streamx();
      var tee = require_teex();
      var readableKind = Symbol.for("bare.stream.readable.kind");
      var writableKind = Symbol.for("bare.stream.writable.kind");
      var transformKind = Symbol.for("bare.stream.transform.kind");
      exports.ReadableStreamDefaultReader = class ReadableStreamDefaultReader {
        constructor(stream) {
          this._stream = stream;
          this._stream._stream.once("close", onclose).once("error", onerror);
          const closed = Promise.withResolvers();
          closed.promise.catch(noop);
          this._closed = closed;
          function onclose() {
            closed.resolve();
          }
          function onerror(err) {
            closed.reject(err);
          }
        }
        get closed() {
          return this._closed.promise;
        }
        read() {
          const stream = this._stream._stream;
          return new Promise((resolve, reject) => {
            const err = getStreamError(stream);
            if (err) return reject(err);
            if (stream.destroyed) {
              return resolve({ value: void 0, done: true });
            }
            const value = stream.read();
            if (value !== null) {
              return resolve({ value, done: false });
            }
            stream.once("readable", onreadable).once("close", onclose).once("error", onerror);
            function onreadable() {
              const value2 = stream.read();
              ondone(null, value2 === null ? { value: void 0, done: true } : { value: value2, done: false });
            }
            function onclose() {
              ondone(null, { value: void 0, done: true });
            }
            function onerror(err2) {
              ondone(err2, null);
            }
            function ondone(err2, value2) {
              stream.off("readable", onreadable).off("close", onclose).off("error", onerror);
              if (err2) reject(err2);
              else resolve(value2);
            }
          });
        }
        releaseLock() {
          this._closed.reject(new TypeError("Reader was released"));
          this._stream._releaseLock();
          this._stream = null;
        }
        cancel(reason = new TypeError("Stream was cancelled")) {
          const stream = this._stream._stream;
          if (stream.destroyed) return Promise.resolve();
          return new Promise(
            (resolve) => stream.once("close", resolve).once("error", noop).destroy(reason)
          );
        }
      };
      exports.ReadableStreamDefaultController = class ReadableStreamDefaultController {
        constructor(stream) {
          this._stream = stream;
        }
        get desiredSize() {
          const stream = this._stream._stream;
          return stream._readableState.highWaterMark - stream._readableState.buffered;
        }
        enqueue(data) {
          this._stream._stream.push(data);
        }
        close() {
          this._stream._stream.push(null);
        }
        error(err) {
          this._stream._stream.destroy(err);
        }
      };
      var ReadableStream = class _ReadableStream {
        static get [readableKind]() {
          return 0;
        }
        static from(iterable) {
          return new _ReadableStream(Readable.from(iterable));
        }
        constructor(underlyingSource = {}, queuingStrategy) {
          if (isStreamx(underlyingSource)) {
            this._stream = underlyingSource;
          } else {
            if (queuingStrategy === void 0) {
              queuingStrategy = new exports.CountQueuingStrategy();
            }
            const { start, pull, cancel } = underlyingSource;
            const { highWaterMark = 1, size = defaultSize } = queuingStrategy;
            this._stream = new Readable({ highWaterMark, byteLength: size });
            const controller = new exports.ReadableStreamDefaultController(this);
            if (start) {
              this._stream._open = this._open.bind(this, start.call(this, controller));
            }
            if (pull) {
              this._stream._read = this._read.bind(this, pull.bind(this, controller));
            }
            if (cancel) {
              this._stream.once("error", cancel);
            }
          }
          this._reader = null;
        }
        get [readableKind]() {
          return _ReadableStream[readableKind];
        }
        get locked() {
          return this._reader !== null;
        }
        getReader() {
          if (this.locked) throw new TypeError("Stream is locked");
          this._reader = new exports.ReadableStreamDefaultReader(this);
          return this._reader;
        }
        cancel(reason = new TypeError("Stream was cancelled")) {
          const stream = this._stream;
          if (stream.destroyed) return Promise.resolve();
          if (this.locked) return Promise.reject(new TypeError("Stream is locked"));
          return new Promise(
            (resolve) => stream.once("close", resolve).once("error", noop).destroy(reason)
          );
        }
        tee() {
          const [a, b] = tee(this._stream);
          return [new _ReadableStream(a), new _ReadableStream(b)];
        }
        pipeTo(destination) {
          return new Promise(
            (resolve, reject) => this._stream.pipe(destination._stream, (err) => {
              err ? reject(err) : resolve();
            })
          );
        }
        [Symbol.asyncIterator]() {
          return this._stream[Symbol.asyncIterator]();
        }
        _releaseLock() {
          this._reader = null;
        }
        async _open(starting, cb) {
          let err = null;
          try {
            await starting;
          } catch (e) {
            err = e;
          }
          cb(err);
        }
        async _read(pull, cb) {
          let err = null;
          try {
            await pull();
          } catch (e) {
            err = e;
          }
          cb(err);
        }
      };
      function defaultSize() {
        return 1;
      }
      exports.ReadableStream = ReadableStream;
      exports.CountQueuingStrategy = class CountQueuingStrategy {
        constructor(opts = {}) {
          const { highWaterMark = 1 } = opts;
          this.highWaterMark = highWaterMark;
        }
        size(chunk) {
          return 1;
        }
      };
      exports.ByteLengthQueuingStrategy = class ByteLengthQueuingStrategy {
        constructor(opts = {}) {
          const { highWaterMark = 16384 } = opts;
          this.highWaterMark = highWaterMark;
        }
        size(chunk) {
          return chunk.byteLength;
        }
      };
      exports.isReadableStream = function isReadableStream(value) {
        if (value instanceof ReadableStream) return true;
        return typeof value === "object" && value !== null && value[readableKind] === ReadableStream[readableKind];
      };
      exports.isReadableStreamErrored = function isReadableStreamErrored(stream) {
        return getStreamError(stream._stream) !== null;
      };
      exports.isReadableStreamDisturbed = function isReadableStreamDisturbed(stream) {
        return isDisturbed(stream._stream);
      };
      exports.WritableStreamDefaultWriter = class WritableStreamDefaultWriter {
        constructor(stream) {
          this._stream = stream;
          this._stream._stream.once("close", onclose).once("error", onerror);
          const closed = Promise.withResolvers();
          closed.promise.catch(noop);
          this._closed = closed;
          function onclose() {
            closed.resolve();
          }
          function onerror(err) {
            closed.reject(err);
          }
        }
        get desiredSize() {
          const stream = this._stream._stream;
          return stream._writableState.highWaterMark - stream._writableState.buffered;
        }
        get closed() {
          return this._closed.promise;
        }
        get ready() {
          const stream = this._stream._stream;
          if (getStreamError(stream)) return Promise.reject();
          return Writable.drained(stream).then();
        }
        async write(chunk) {
          const stream = this._stream._stream;
          let err = getStreamError(stream);
          if (err) return Promise.reject(err);
          stream.write(chunk);
          await Writable.drained(stream);
          err = getStreamError(stream);
          if (err) return Promise.reject(err);
        }
        releaseLock() {
          this._closed.reject(new TypeError("Writer was released"));
          this._stream._releaseLock();
          this._stream = null;
        }
        close() {
          const stream = this._stream._stream;
          if (stream.destroyed) return Promise.resolve();
          return new Promise((resolve) => stream.once("close", resolve).end());
        }
        abort(reason = new TypeError("Stream was aborted")) {
          const stream = this._stream._stream;
          if (stream.destroyed) return Promise.resolve();
          return new Promise((resolve) => stream.once("close", resolve).destroy(reason));
        }
      };
      exports.WritableStreamDefaultController = class WritableStreamDefaultController {
        constructor(stream) {
          this._stream = stream;
        }
        error(err) {
          this._stream._stream.destroy(err);
        }
      };
      var WritableStream = class _WritableStream {
        static get [writableKind]() {
          return 0;
        }
        constructor(underlyingSink = {}, queuingStrategy = {}) {
          if (isStreamx(underlyingSink)) {
            this._stream = underlyingSink;
          } else {
            if (queuingStrategy === void 0) {
              queuingStrategy = new exports.CountQueuingStrategy();
            }
            const { start, write, close, abort } = underlyingSink;
            const { highWaterMark = 1, size = defaultSize } = queuingStrategy;
            this._stream = new Writable({ highWaterMark, byteLength: size });
            this._controller = new exports.WritableStreamDefaultController(this);
            if (start) {
              this._stream._open = this._open.bind(this, start.call(this, this._controller));
            }
            if (write) {
              this._stream._write = this._write.bind(this, write);
            }
            if (close) {
              this._stream._destroy = this._destroy.bind(this, close.call(this));
            }
            if (abort) {
              this._stream.once("error", abort);
            }
          }
          this._writer = null;
        }
        get [writableKind]() {
          return _WritableStream[writableKind];
        }
        get locked() {
          return this._writer !== null;
        }
        getWriter() {
          if (this.locked) throw new TypeError("Stream is locked");
          this._writer = new exports.WritableStreamDefaultWriter(this);
          return this._writer;
        }
        abort(reason = new TypeError("Stream was aborted")) {
          if (this._stream.destroyed) return Promise.resolve();
          if (this.locked) return Promise.reject(new TypeError("Stream is locked"));
          return new Promise((resolve) => this._stream.once("close", resolve).destroy(reason));
        }
        close() {
          if (this._stream.destroyed) return Promise.resolve();
          if (this.locked) return Promise.reject(new TypeError("Stream is locked"));
          return new Promise((resolve) => this._stream.once("close", resolve).end());
        }
        _releaseLock() {
          this._writer = null;
        }
        async _open(starting, cb) {
          let err = null;
          try {
            await starting;
          } catch (e) {
            err = e;
          }
          cb(err);
        }
        async _write(write, data, cb) {
          let err = null;
          try {
            await write(data, this._controller);
          } catch (e) {
            err = e;
          }
          cb(err);
        }
        async _destroy(closing, cb) {
          let err = null;
          try {
            await closing;
          } catch (e) {
            err = e;
          }
          cb(err);
        }
      };
      exports.WritableStream = WritableStream;
      exports.isWritableStream = function isWritableStream(value) {
        if (value instanceof WritableStream) return true;
        return typeof value === "object" && value !== null && value[writableKind] === WritableStream[writableKind];
      };
      exports.TransformStreamDefaultController = class TransformStreamDefaultController {
        constructor(stream) {
          this._stream = stream;
        }
        get desiredSize() {
          const stream = this._stream._stream;
          return stream._readableState.highWaterMark - stream._readableState.buffered;
        }
        enqueue(data) {
          this._stream._stream.push(data);
        }
        error(err) {
          this._stream._stream.destroy(err);
        }
        terminate() {
          const stream = this._stream._stream;
          stream.push(null);
          stream.destroy(new TypeError("Stream has been terminated"));
        }
      };
      var TransformStream = class _TransformStream {
        static get [transformKind]() {
          return 0;
        }
        constructor(transformer = {}, writableStrategy = {}, readableStrategy = {}) {
          const { start, transform, flush } = transformer;
          this._stream = new Transform({ ...writableStrategy, ...readableStrategy });
          this._writable = new WritableStream(this._stream);
          this._readable = new ReadableStream(this._stream);
          this._controller = new exports.TransformStreamDefaultController(this);
          if (start) {
            this._stream._open = this._open.bind(this, start.call(this, this._controller));
          }
          if (transform) {
            this._stream._write = this._transform.bind(this, transform);
          }
          if (flush) {
            this._stream._flush = this._flush.bind(this, flush.call(this, this._controller));
          }
        }
        get [transformKind]() {
          return _TransformStream[transformKind];
        }
        get writable() {
          return this._writable;
        }
        get readable() {
          return this._readable;
        }
        async _open(starting, cb) {
          let err = null;
          try {
            await starting;
          } catch (e) {
            err = e;
          }
          cb(err);
        }
        async _transform(transform, data, cb) {
          let err = null;
          try {
            await transform(data, this._controller);
          } catch (e) {
            err = e;
          }
          cb(err);
        }
        async _flush(flush, cb) {
          let err = null;
          try {
            await flush;
          } catch (e) {
            err = e;
          }
          cb(err);
        }
      };
      exports.TransformStream = TransformStream;
      exports.isTransformStream = function isTransformStream(value) {
        if (value instanceof TransformStream) return true;
        return typeof value === "object" && value !== null && value[transformKind] === TransformStream[transformKind];
      };
      function noop() {
      }
    }
  });

  // ../../node_modules/bare-stream/index.js
  var require_bare_stream = __commonJS({
    "../../node_modules/bare-stream/index.js"(exports, module) {
      var stream = require_streamx();
      var { ReadableStream, WritableStream } = require_web();
      var defaultEncoding = "utf8";
      module.exports = exports = stream.Stream;
      exports.pipeline = stream.pipeline;
      exports.isStream = stream.isStream;
      exports.isEnding = stream.isEnding;
      exports.isEnded = stream.isEnded;
      exports.isFinishing = stream.isFinishing;
      exports.isFinished = stream.isFinished;
      exports.isDisturbed = stream.isDisturbed;
      exports.isErrored = function isErrored(stream2) {
        return exports.getStreamError(stream2) !== null;
      };
      exports.isReadable = function isReadable(stream2) {
        return stream2.readable && !stream2.destroying && !exports.isEnded(stream2);
      };
      exports.isWritable = function isWritable(stream2) {
        return stream2.writable && !stream2.destroying && !exports.isFinishing(stream2);
      };
      exports.getStreamError = stream.getStreamError;
      exports.addAbortSignal = function addAbortSignal(signal, stream2) {
        function onAbort() {
          stream2.destroy(signal.reason);
        }
        if (signal.aborted) onAbort();
        else signal.addEventListener("abort", onAbort);
        return stream2;
      };
      exports.Stream = exports;
      exports.Readable = class Readable extends stream.Readable {
        constructor(opts = {}) {
          super({
            ...opts,
            byteLength: null,
            byteLengthReadable: null,
            map: null,
            mapReadable: null
          });
          if (this._construct) this._open = this._construct;
          if (this._read !== stream.Readable.prototype._read) {
            this._read = read.bind(this, this._read);
          }
          if (this._destroy !== stream.Stream.prototype._destroy) {
            this._destroy = destroy.bind(this, this._destroy);
          }
        }
        get closed() {
          return !exports.isReadable(this);
        }
        get errored() {
          return stream.getStreamError(this);
        }
        push(chunk, encoding) {
          if (typeof chunk === "string") {
            chunk = Buffer.from(chunk, encoding || defaultEncoding);
          }
          return super.push(chunk);
        }
        unshift(chunk, encoding) {
          if (typeof chunk === "string") {
            chunk = Buffer.from(chunk, encoding || defaultEncoding);
          }
          super.unshift(chunk);
        }
        static fromWeb(readableStream, opts = {}) {
          const stream2 = readableStream._stream;
          if (opts.encoding) stream2.setEncoding(opts.encoding);
          if (opts.signal) exports.addAbortSignal(opts.signal, stream2);
          return stream2;
        }
        static toWeb(readable, opts = {}) {
          return new ReadableStream(readable, opts.strategy);
        }
        async [Symbol.asyncDispose]() {
          if (!this.destroyed) this.destroy();
          await new Promise((resolve) => exports.finished(this, resolve));
        }
      };
      exports.Writable = class Writable extends stream.Writable {
        constructor(opts = {}) {
          super({
            ...opts,
            byteLength: null,
            byteLengthWritable,
            map: null,
            mapWritable: null
          });
          if (this._construct) this._open = this._construct;
          if (this._write !== stream.Writable.prototype._write) {
            this._write = write.bind(this, this._write);
          }
          if (this._destroy !== stream.Stream.prototype._destroy) {
            this._destroy = destroy.bind(this, this._destroy);
          }
        }
        get closed() {
          return !exports.isWritable(this);
        }
        get errored() {
          return stream.getStreamError(this);
        }
        write(chunk, encoding, cb) {
          if (typeof encoding === "function") {
            cb = encoding;
            encoding = null;
          }
          if (typeof chunk === "string") {
            encoding = encoding || defaultEncoding;
            chunk = Buffer.from(chunk, encoding);
          } else {
            encoding = "buffer";
          }
          const result = super.write({ chunk, encoding });
          if (cb) stream.Writable.drained(this).then(() => cb(null), cb);
          return result;
        }
        end(chunk, encoding, cb) {
          if (typeof chunk === "function") {
            cb = chunk;
            chunk = null;
          } else if (typeof encoding === "function") {
            cb = encoding;
            encoding = null;
          }
          if (typeof chunk === "string") {
            encoding = encoding || defaultEncoding;
            chunk = Buffer.from(chunk, encoding || defaultEncoding);
          } else {
            encoding = "buffer";
          }
          const result = chunk !== void 0 && chunk !== null ? super.end({ chunk, encoding }) : super.end();
          if (cb) this.once("finish", () => cb(null));
          return result;
        }
        static fromWeb(writableStream, opts = {}) {
          const stream2 = writableStream._stream;
          if (opts.signal) exports.addAbortSignal(opts.signal, stream2);
          return stream2;
        }
        static toWeb(writable) {
          return new WritableStream(writable);
        }
        async [Symbol.asyncDispose]() {
          if (!this.destroyed) this.destroy();
          await new Promise((resolve) => exports.finished(this, resolve));
        }
      };
      exports.Duplex = class Duplex extends stream.Duplex {
        constructor(opts = {}) {
          super({
            ...opts,
            byteLength: null,
            byteLengthReadable: null,
            byteLengthWritable,
            map: null,
            mapReadable: null,
            mapWritable: null
          });
          if (this._construct) this._open = this._construct;
          if (this._read !== stream.Readable.prototype._read) {
            this._read = read.bind(this, this._read);
          }
          if (this._write !== stream.Duplex.prototype._write) {
            this._write = write.bind(this, this._write);
          }
          if (this._destroy !== stream.Stream.prototype._destroy) {
            this._destroy = destroy.bind(this, this._destroy);
          }
        }
        push(chunk, encoding) {
          if (typeof chunk === "string") {
            chunk = Buffer.from(chunk, encoding || defaultEncoding);
          }
          return super.push(chunk);
        }
        unshift(chunk, encoding) {
          if (typeof chunk === "string") {
            chunk = Buffer.from(chunk, encoding || defaultEncoding);
          }
          super.unshift(chunk);
        }
        write(chunk, encoding, cb) {
          if (typeof encoding === "function") {
            cb = encoding;
            encoding = null;
          }
          if (typeof chunk === "string") {
            encoding = encoding || defaultEncoding;
            chunk = Buffer.from(chunk, encoding);
          } else {
            encoding = "buffer";
          }
          const result = super.write({ chunk, encoding });
          if (cb) stream.Writable.drained(this).then(() => cb(null), cb);
          return result;
        }
        end(chunk, encoding, cb) {
          if (typeof chunk === "function") {
            cb = chunk;
            chunk = null;
          } else if (typeof encoding === "function") {
            cb = encoding;
            encoding = null;
          }
          if (typeof chunk === "string") {
            encoding = encoding || defaultEncoding;
            chunk = Buffer.from(chunk, encoding);
          } else {
            encoding = "buffer";
          }
          const result = chunk !== void 0 && chunk !== null ? super.end({ chunk, encoding }) : super.end();
          if (cb) this.once("finish", () => cb(null));
          return result;
        }
        static fromWeb({ readable: readableStream, writable: writableStream }, opts) {
          const readable = exports.Readable.fromWeb(readableStream, opts);
          const writable = exports.Readable.fromWeb(writableStream, opts);
          const duplex = new exports.Duplex({
            write(data, encoding, cb) {
              writable.write(data, encoding, cb);
            }
          });
          readable.on("data", (data) => duplex.push(data)).on("end", () => duplex.push(null)).on("error", (err) => duplex.destroy(err));
          writable.on("finish", () => duplex.end()).on("error", (err) => duplex.destroy(err));
          return duplex;
        }
        static toWeb(duplex) {
          const readableStream = exports.Readable.toWeb(duplex);
          const writableStream = exports.Writable.toWeb(duplex);
          return { readable: readableStream, writable: writableStream };
        }
      };
      var DuplexSide = class extends exports.Duplex {
        constructor(opts) {
          super(opts);
          this._otherSide = null;
          this._cb = null;
        }
        _read() {
          const cb = this._cb;
          if (!cb) return;
          this._cb = null;
          cb();
        }
        _write(chunk, encoding, cb) {
          this._otherSide.push(chunk, encoding);
          this._otherSide._cb = cb;
        }
        _final(cb) {
          this._otherSide.on("end", cb);
          this._otherSide.push(null);
        }
      };
      exports.duplexPair = function duplexPair(opts) {
        const sideA = new DuplexSide(opts);
        const sideB = new DuplexSide(opts);
        sideA._otherSide = sideB;
        sideB._otherSide = sideA;
        return [sideA, sideB];
      };
      exports.Transform = class Transform extends stream.Transform {
        constructor(opts = {}) {
          super({
            ...opts,
            byteLength: null,
            byteLengthReadable: null,
            byteLengthWritable,
            map: null,
            mapReadable: null,
            mapWritable: null
          });
          if (this._transform !== stream.Transform.prototype._transform) {
            this._transform = transform.bind(this, this._transform);
          } else {
            this._transform = passthrough;
          }
        }
        push(chunk, encoding) {
          if (typeof chunk === "string") {
            chunk = Buffer.from(chunk, encoding || defaultEncoding);
          }
          return super.push(chunk);
        }
        unshift(chunk, encoding) {
          if (typeof chunk === "string") {
            chunk = Buffer.from(chunk, encoding || defaultEncoding);
          }
          super.unshift(chunk);
        }
        write(chunk, encoding, cb) {
          if (typeof encoding === "function") {
            cb = encoding;
            encoding = null;
          }
          if (typeof chunk === "string") {
            encoding = encoding || defaultEncoding;
            chunk = Buffer.from(chunk, encoding);
          } else {
            encoding = "buffer";
          }
          const result = super.write({ chunk, encoding });
          if (cb) stream.Writable.drained(this).then(() => cb(null), cb);
          return result;
        }
        end(chunk, encoding, cb) {
          if (typeof chunk === "function") {
            cb = chunk;
            chunk = null;
          } else if (typeof encoding === "function") {
            cb = encoding;
            encoding = null;
          }
          if (typeof chunk === "string") {
            encoding = encoding || defaultEncoding;
            chunk = Buffer.from(chunk, encoding);
          } else {
            encoding = "buffer";
          }
          const result = chunk !== void 0 && chunk !== null ? super.end({ chunk, encoding }) : super.end();
          if (cb) this.once("finish", () => cb(null));
          return result;
        }
      };
      exports.PassThrough = class PassThrough extends exports.Transform {
      };
      exports.finished = function finished(stream2, opts, cb) {
        if (typeof opts === "function") {
          cb = opts;
          opts = {};
        }
        if (!opts) opts = {};
        const { cleanup = false } = opts;
        const done = () => {
          cb(exports.getStreamError(stream2, { all: true }));
          if (cleanup) detach();
        };
        const detach = () => {
          stream2.off("close", done);
          stream2.off("error", noop);
        };
        if (stream2.destroyed) {
          done();
        } else {
          stream2.on("close", done);
          stream2.on("error", noop);
        }
        return detach;
      };
      function read(read2, cb) {
        read2.call(this, 65536);
        cb(null);
      }
      function write(write2, data, cb) {
        write2.call(this, data.chunk, data.encoding, cb);
      }
      function transform(transform2, data, cb) {
        transform2.call(this, data.chunk, data.encoding, cb);
      }
      function destroy(destroy2, cb) {
        destroy2.call(this, exports.getStreamError(this), cb);
      }
      function passthrough(data, cb) {
        cb(null, data.chunk);
      }
      function byteLengthWritable(data) {
        return data.chunk.byteLength;
      }
      function noop() {
      }
    }
  });

  // ../../node_modules/bare-fs/binding.js
  var require_binding3 = __commonJS({
    "../../node_modules/bare-fs/binding.js"(exports, module) {
      module.exports = __require.addon();
    }
  });

  // ../../node_modules/bare-fs/lib/constants.js
  var require_constants3 = __commonJS({
    "../../node_modules/bare-fs/lib/constants.js"(exports, module) {
      var binding = require_binding3();
      module.exports = {
        O_RDWR: binding.O_RDWR,
        O_RDONLY: binding.O_RDONLY,
        O_WRONLY: binding.O_WRONLY,
        O_CREAT: binding.O_CREAT,
        O_TRUNC: binding.O_TRUNC,
        O_APPEND: binding.O_APPEND,
        F_OK: binding.F_OK || 0,
        R_OK: binding.R_OK || 0,
        W_OK: binding.W_OK || 0,
        X_OK: binding.X_OK || 0,
        S_IFMT: binding.S_IFMT,
        S_IFREG: binding.S_IFREG,
        S_IFDIR: binding.S_IFDIR,
        S_IFCHR: binding.S_IFCHR,
        S_IFLNK: binding.S_IFLNK,
        S_IFBLK: binding.S_IFBLK || 0,
        S_IFIFO: binding.S_IFIFO || 0,
        S_IFSOCK: binding.S_IFSOCK || 0,
        S_IRUSR: binding.S_IRUSR || 0,
        S_IWUSR: binding.S_IWUSR || 0,
        S_IXUSR: binding.S_IXUSR || 0,
        S_IRGRP: binding.S_IRGRP || 0,
        S_IWGRP: binding.S_IWGRP || 0,
        S_IXGRP: binding.S_IXGRP || 0,
        S_IROTH: binding.S_IROTH || 0,
        S_IWOTH: binding.S_IWOTH || 0,
        S_IXOTH: binding.S_IXOTH || 0,
        UV_DIRENT_UNKNOWN: binding.UV_DIRENT_UNKNOWN,
        UV_DIRENT_FILE: binding.UV_DIRENT_FILE,
        UV_DIRENT_DIR: binding.UV_DIRENT_DIR,
        UV_DIRENT_LINK: binding.UV_DIRENT_LINK,
        UV_DIRENT_FIFO: binding.UV_DIRENT_FIFO,
        UV_DIRENT_SOCKET: binding.UV_DIRENT_SOCKET,
        UV_DIRENT_CHAR: binding.UV_DIRENT_CHAR,
        UV_DIRENT_BLOCK: binding.UV_DIRENT_BLOCK,
        COPYFILE_EXCL: binding.UV_FS_COPYFILE_EXCL,
        COPYFILE_FICLONE: binding.UV_FS_COPYFILE_FICLONE,
        COPYFILE_FICLONE_FORCE: binding.UV_FS_COPYFILE_FICLONE_FORCE,
        UV_FS_SYMLINK_DIR: binding.UV_FS_SYMLINK_DIR,
        UV_FS_SYMLINK_JUNCTION: binding.UV_FS_SYMLINK_JUNCTION
      };
    }
  });

  // ../../node_modules/bare-fs/lib/errors.js
  var require_errors4 = __commonJS({
    "../../node_modules/bare-fs/lib/errors.js"(exports, module) {
      var os = require_bare_os();
      module.exports = class FileError extends Error {
        constructor(msg, opts = {}) {
          const { code, operation = null, path = null, destination = null, fd = -1 } = opts;
          if (operation !== null) msg += describe(operation, opts);
          super(`${code}: ${msg}`);
          this.code = code;
          if (operation !== null) this.operation = operation;
          if (path !== null) this.path = path;
          if (destination !== null) this.destination = destination;
          if (fd !== -1) this.fd = fd;
        }
        get name() {
          return "FileError";
        }
        // For Node.js compatibility
        get errno() {
          return os.constants.errnos[this.code];
        }
        // For Node.js compatibility
        get syscall() {
          return this.operation;
        }
        // For Node.js compatibility
        get dest() {
          return this.destination;
        }
      };
      function describe(operation, opts) {
        const { path = null, destination = null, fd = -1 } = opts;
        let result = `, ${operation}`;
        if (path !== null) {
          result += ` ${JSON.stringify(path)}`;
          if (destination !== null) {
            result += ` -> ${JSON.stringify(destination)}`;
          }
        } else if (fd !== -1) {
          result += ` ${fd}`;
        }
        return result;
      }
    }
  });

  // ../../node_modules/bare-fs/promises.js
  var require_promises = __commonJS({
    "../../node_modules/bare-fs/promises.js"(exports) {
      var EventEmitter = require_bare_events();
      var fs = require_bare_fs();
      var FileHandle = class extends EventEmitter {
        constructor(fd) {
          super();
          this.fd = fd;
        }
        async close() {
          await fs.close(this.fd);
          this.fd = -1;
          this.emit("close");
        }
        async read(buffer, ...args) {
          return {
            bytesRead: await fs.read(this.fd, buffer, ...args),
            buffer
          };
        }
        async readv(buffers, ...args) {
          return {
            bytesRead: await fs.readv(this.fd, buffers, ...args),
            buffers
          };
        }
        async write(buffer, ...args) {
          return {
            bytesWritten: await fs.write(this.fd, buffer, ...args),
            buffer
          };
        }
        async writev(buffers, ...args) {
          return {
            bytesWritten: await fs.writev(this.fd, buffers, ...args),
            buffers
          };
        }
        async stat() {
          return fs.fstat(this.fd);
        }
        async chmod(mode) {
          await fs.fchmod(this.fd, mode);
        }
        createReadStream(opts) {
          return fs.createReadStream(null, { ...opts, fd: this.fd });
        }
        createWriteStream(opts) {
          return fs.createWriteStream(null, { ...opts, fd: this.fd });
        }
        async [Symbol.asyncDispose]() {
          await this.close();
        }
      };
      exports.open = async function open(filepath, flags, mode) {
        return new FileHandle(await fs.open(filepath, flags, mode));
      };
      exports.access = fs.access;
      exports.appendFile = fs.appendFile;
      exports.chmod = fs.chmod;
      exports.constants = fs.constants;
      exports.copyFile = fs.copyFile;
      exports.cp = fs.cp;
      exports.lstat = fs.lstat;
      exports.mkdir = fs.mkdir;
      exports.opendir = fs.opendir;
      exports.readFile = fs.readFile;
      exports.readdir = fs.readdir;
      exports.readlink = fs.readlink;
      exports.realpath = fs.realpath;
      exports.rename = fs.rename;
      exports.rm = fs.rm;
      exports.rmdir = fs.rmdir;
      exports.stat = fs.stat;
      exports.symlink = fs.symlink;
      exports.unlink = fs.unlink;
      exports.utimes = fs.utimes;
      exports.watch = fs.watch;
      exports.writeFile = fs.writeFile;
    }
  });

  // ../../node_modules/bare-fs/index.js
  var require_bare_fs = __commonJS({
    "../../node_modules/bare-fs/index.js"(exports) {
      var FIFO = require_fast_fifo();
      var EventEmitter = require_bare_events();
      var path = require_bare_path();
      var { isURL, fileURLToPath } = require_bare_url();
      var { Readable, Writable } = require_bare_stream();
      var binding = require_binding3();
      var constants = require_constants3();
      var FileError = require_errors4();
      var isWindows = Bare.platform === "win32";
      exports.constants = constants;
      var FileRequest = class _FileRequest {
        static borrow() {
          if (this._free.length > 0) return this._free.pop();
          return new _FileRequest();
        }
        static return(req) {
          if (this._free.length < 32) this._free.push(req.reset());
          else req.destroy();
        }
        constructor() {
          this._reset();
          this._handle = binding.requestInit(this, this._onresult);
        }
        get handle() {
          return this._handle;
        }
        retain(value) {
          this._retain = value;
        }
        reset() {
          if (this._handle === null) return this;
          binding.requestReset(this._handle);
          this._reset();
          return this;
        }
        destroy() {
          if (this._handle === null) return this;
          binding.requestDestroy(this._handle);
          this._reset();
          this._handle = null;
          return this;
        }
        then(resolve, reject) {
          return this._promise.then(resolve, reject);
        }
        return() {
          if (this._handle === null) return this;
          _FileRequest.return(this);
          return this;
        }
        _reset() {
          this._promise = new Promise((resolve, reject) => {
            this._resolve = resolve;
            this._reject = reject;
          });
          this._retain = null;
        }
        _onresult(err, status) {
          if (err) this._reject(err);
          else this._resolve(status);
        }
      };
      FileRequest._free = [];
      function ok(result, cb) {
        if (typeof result === "function") {
          cb = result;
          result = void 0;
        }
        if (cb) cb(null, result);
        else return result;
      }
      function fail(err, cb) {
        if (cb) cb(err);
        else throw err;
      }
      function done(err, result, cb) {
        if (typeof result === "function") {
          cb = result;
          result = void 0;
        }
        if (err) fail(err, cb);
        else return ok(result, cb);
      }
      async function open(filepath, flags = "r", mode = 438, cb) {
        if (typeof flags === "function") {
          cb = flags;
          flags = "r";
          mode = 438;
        } else if (typeof mode === "function") {
          cb = mode;
          mode = 438;
        }
        if (typeof flags === "string") flags = toFlags(flags);
        if (typeof mode === "string") mode = toMode(mode);
        filepath = toNamespacedPath(filepath);
        const req = FileRequest.borrow();
        let fd;
        let err = null;
        try {
          binding.open(req.handle, filepath, flags, mode);
          fd = await req;
        } catch (e) {
          err = new FileError(e.message, {
            operation: "open",
            code: e.code,
            path: filepath
          });
        } finally {
          req.return();
        }
        return done(err, fd, cb);
      }
      function openSync(filepath, flags = "r", mode = 438) {
        if (typeof flags === "string") flags = toFlags(flags);
        if (typeof mode === "string") mode = toMode(mode);
        filepath = toNamespacedPath(filepath);
        const req = FileRequest.borrow();
        try {
          return binding.openSync(req.handle, filepath, flags, mode);
        } catch (e) {
          throw new FileError(e.message, {
            operation: "open",
            code: e.code,
            path: filepath
          });
        } finally {
          req.return();
        }
      }
      async function close(fd, cb) {
        const req = FileRequest.borrow();
        let err = null;
        try {
          binding.close(req.handle, fd);
          await req;
        } catch (e) {
          err = new FileError(e.message, { operation: "close", code: e.code, fd });
        } finally {
          req.return();
        }
        return done(err, cb);
      }
      function closeSync(fd) {
        const req = FileRequest.borrow();
        try {
          binding.closeSync(req.handle, fd);
        } catch (e) {
          throw new FileError(e.message, { operation: "close", code: e.code, fd });
        } finally {
          req.return();
        }
      }
      async function access(filepath, mode = constants.F_OK, cb) {
        if (typeof mode === "function") {
          cb = mode;
          mode = constants.F_OK;
        }
        filepath = toNamespacedPath(filepath);
        const req = FileRequest.borrow();
        let err = null;
        try {
          binding.access(req.handle, filepath, mode);
          await req;
        } catch (e) {
          err = new FileError(e.message, {
            operation: "access",
            code: e.code,
            path: filepath
          });
        } finally {
          req.return();
        }
        return done(err, cb);
      }
      function accessSync(filepath, mode = constants.F_OK) {
        filepath = toNamespacedPath(filepath);
        const req = FileRequest.borrow();
        try {
          binding.accessSync(req.handle, filepath, mode);
        } catch (e) {
          throw new FileError(e.message, {
            operation: "access",
            code: e.code,
            path: filepath
          });
        } finally {
          req.return();
        }
      }
      async function exists(filepath, cb) {
        let ok2 = true;
        try {
          await access(filepath);
        } catch {
          ok2 = false;
        }
        return done(null, ok2, cb);
      }
      function existsSync(filepath) {
        try {
          accessSync(filepath);
        } catch {
          return false;
        }
        return true;
      }
      async function read(fd, buffer, offset = 0, len = buffer.byteLength - offset, pos = -1, cb) {
        if (typeof offset === "function") {
          cb = offset;
          offset = 0;
          len = buffer.byteLength;
          pos = -1;
        } else if (typeof len === "function") {
          cb = len;
          len = buffer.byteLength - offset;
          pos = -1;
        } else if (typeof pos === "function") {
          cb = pos;
          pos = -1;
        }
        if (typeof pos !== "number") pos = -1;
        const req = FileRequest.borrow();
        let bytes;
        let err = null;
        try {
          binding.read(req.handle, fd, buffer, offset, len, pos);
          bytes = await req;
        } catch (e) {
          err = new FileError(e.message, { operation: "read", code: e.code, fd });
        } finally {
          req.return();
        }
        return done(err, bytes, cb);
      }
      function readSync(fd, buffer, offset = 0, len = buffer.byteLength - offset, pos = -1) {
        const req = FileRequest.borrow();
        try {
          return binding.readSync(req.handle, fd, buffer, offset, len, pos);
        } catch (e) {
          throw new FileError(e.message, { operation: "read", code: e.code, fd });
        } finally {
          req.return();
        }
      }
      async function readv(fd, buffers, pos = -1, cb) {
        if (typeof pos === "function") {
          cb = pos;
          pos = -1;
        }
        if (typeof pos !== "number") pos = -1;
        const req = FileRequest.borrow();
        let bytes;
        let err = null;
        try {
          binding.readv(req.handle, fd, buffers, pos);
          bytes = await req;
        } catch (e) {
          err = new FileError(e.message, { operation: "readv", code: e.code, fd });
        } finally {
          req.return();
        }
        return done(err, bytes, cb);
      }
      function readvSync(fd, buffers, pos = -1) {
        if (typeof pos !== "number") pos = -1;
        const req = FileRequest.borrow();
        try {
          return binding.readvSync(req.handle, fd, buffers, pos);
        } catch (e) {
          throw new FileError(e.message, { operation: "readv", code: e.code, fd });
        } finally {
          req.return();
        }
      }
      async function write(fd, data, offset, len, pos = -1, cb) {
        if (typeof data === "string") {
          let encoding = len;
          cb = pos;
          pos = offset;
          if (typeof pos === "function") {
            cb = pos;
            pos = -1;
            encoding = "utf8";
          } else if (typeof encoding === "function") {
            cb = encoding;
            encoding = "utf8";
          }
          if (typeof pos === "string") {
            encoding = pos;
            pos = -1;
          }
          data = Buffer.from(data, encoding);
          offset = 0;
          len = data.byteLength;
        } else if (typeof offset === "function") {
          cb = offset;
          offset = 0;
          len = data.byteLength;
          pos = -1;
        } else if (typeof len === "function") {
          cb = len;
          len = data.byteLength - offset;
          pos = -1;
        } else if (typeof pos === "function") {
          cb = pos;
          pos = -1;
        }
        if (typeof offset !== "number") offset = 0;
        if (typeof len !== "number") len = data.byteLength - offset;
        if (typeof pos !== "number") pos = -1;
        const req = FileRequest.borrow();
        let bytes;
        let err = null;
        try {
          binding.write(req.handle, fd, data, offset, len, pos);
          bytes = await req;
        } catch (e) {
          err = new FileError(e.message, { operation: "write", code: e.code, fd });
        } finally {
          req.return();
        }
        return done(err, bytes, cb);
      }
      function writeSync(fd, data, offset, len, pos = -1) {
        if (typeof data === "string") {
          let encoding = len;
          pos = offset;
          if (typeof pos === "string") {
            encoding = pos;
            pos = -1;
          }
          data = Buffer.from(data, encoding);
          offset = 0;
          len = data.byteLength;
        }
        if (typeof offset !== "number") offset = 0;
        if (typeof len !== "number") len = data.byteLength - offset;
        if (typeof pos !== "number") pos = -1;
        const req = FileRequest.borrow();
        try {
          return binding.writeSync(req.handle, fd, data, offset, len, pos);
        } catch (e) {
          throw new FileError(e.message, { operation: "write", code: e.code, fd });
        } finally {
          req.return();
        }
      }
      async function writev(fd, buffers, pos = -1, cb) {
        if (typeof pos === "function") {
          cb = pos;
          pos = -1;
        }
        if (typeof pos !== "number") pos = -1;
        const req = FileRequest.borrow();
        let bytes;
        let err = null;
        try {
          binding.writev(req.handle, fd, buffers, pos);
          bytes = await req;
        } catch (e) {
          err = new FileError(e.message, { operation: "writev", code: e.code, fd });
        } finally {
          req.return();
        }
        return done(err, bytes, cb);
      }
      function writevSync(fd, buffers, pos = -1) {
        if (typeof pos !== "number") pos = -1;
        const req = FileRequest.borrow();
        try {
          return binding.writevSync(req.handle, fd, buffers, pos);
        } catch (e) {
          throw new FileError(e.message, { operation: "writev", code: e.code, fd });
        } finally {
          req.return();
        }
      }
      async function stat(filepath, cb) {
        filepath = toNamespacedPath(filepath);
        const req = FileRequest.borrow();
        let st;
        let err = null;
        try {
          binding.stat(req.handle, filepath);
          await req;
          st = new Stats(...binding.requestResultStat(req.handle));
        } catch (e) {
          err = new FileError(e.message, {
            operation: "stat",
            code: e.code,
            path: filepath
          });
        } finally {
          req.return();
        }
        return done(err, st, cb);
      }
      function statSync(filepath) {
        filepath = toNamespacedPath(filepath);
        const req = FileRequest.borrow();
        try {
          binding.statSync(req.handle, filepath);
          return new Stats(...binding.requestResultStat(req.handle));
        } catch (e) {
          throw new FileError(e.message, {
            operation: "stat",
            code: e.code,
            path: filepath
          });
        } finally {
          req.return();
        }
      }
      async function lstat(filepath, cb) {
        filepath = toNamespacedPath(filepath);
        const req = FileRequest.borrow();
        let st;
        let err = null;
        try {
          binding.lstat(req.handle, filepath);
          await req;
          st = new Stats(...binding.requestResultStat(req.handle));
        } catch (e) {
          err = new FileError(e.message, {
            operation: "lstat",
            code: e.code,
            path: filepath
          });
        } finally {
          req.return();
        }
        return done(err, st, cb);
      }
      function lstatSync(filepath) {
        filepath = toNamespacedPath(filepath);
        const req = FileRequest.borrow();
        try {
          binding.lstatSync(req.handle, filepath);
          return new Stats(...binding.requestResultStat(req.handle));
        } catch (e) {
          throw new FileError(e.message, {
            operation: "lstat",
            code: e.code,
            path: filepath
          });
        } finally {
          req.return();
        }
      }
      async function fstat(fd, cb) {
        const req = FileRequest.borrow();
        let st;
        let err = null;
        try {
          binding.fstat(req.handle, fd);
          await req;
          st = new Stats(...binding.requestResultStat(req.handle));
        } catch (e) {
          err = new FileError(e.message, { operation: "fstat", code: e.code, fd });
        } finally {
          req.return();
        }
        return done(err, st, cb);
      }
      function fstatSync(fd) {
        const req = FileRequest.borrow();
        try {
          binding.fstatSync(req.handle, fd);
          return new Stats(...binding.requestResultStat(req.handle));
        } catch (e) {
          throw new FileError(e.message, { operation: "fstat", code: e.code, fd });
        } finally {
          req.return();
        }
      }
      async function ftruncate(fd, len = 0, cb) {
        if (typeof len === "function") {
          cb = len;
          len = 0;
        }
        if (typeof len !== "number") len = 0;
        const req = FileRequest.borrow();
        let err = null;
        try {
          binding.ftruncate(req.handle, fd, len);
          await req;
        } catch (e) {
          err = new FileError(e.message, { operation: "ftruncate", code: e.code, fd });
        } finally {
          req.return();
        }
        return done(err, cb);
      }
      function ftruncateSync(fd, len = 0) {
        if (typeof len !== "number") len = 0;
        const req = FileRequest.borrow();
        try {
          binding.ftruncateSync(req.handle, fd, len);
        } catch (e) {
          throw new FileError(e.message, { operation: "ftruncate", code: e.code, fd });
        } finally {
          req.return();
        }
      }
      async function chmod(filepath, mode, cb) {
        if (typeof mode === "string") mode = toMode(mode);
        filepath = toNamespacedPath(filepath);
        const req = FileRequest.borrow();
        let err = null;
        try {
          binding.chmod(req.handle, filepath, mode);
          await req;
        } catch (e) {
          err = new FileError(e.message, {
            operation: "chmod",
            code: e.code,
            path: filepath
          });
        } finally {
          req.return();
        }
        return done(err, cb);
      }
      function chmodSync(filepath, mode) {
        if (typeof mode === "string") mode = toMode(mode);
        filepath = toNamespacedPath(filepath);
        const req = FileRequest.borrow();
        try {
          binding.chmodSync(req.handle, filepath, mode);
        } catch (e) {
          throw new FileError(e.message, {
            operation: "chmod",
            code: e.code,
            path: filepath
          });
        } finally {
          req.return();
        }
      }
      async function fchmod(fd, mode, cb) {
        if (typeof mode === "string") mode = toMode(mode);
        const req = FileRequest.borrow();
        let err = null;
        try {
          binding.fchmod(req.handle, fd, mode);
          await req;
        } catch (e) {
          err = new FileError(e.message, { operation: "fchmod", code: e.code, fd });
        } finally {
          req.return();
        }
        return done(err, cb);
      }
      function fchmodSync(fd, mode) {
        if (typeof mode === "string") mode = toMode(mode);
        const req = FileRequest.borrow();
        try {
          binding.fchmodSync(req.handle, fd, mode);
        } catch (e) {
          throw new FileError(e.message, { operation: "fchmod", code: e.code, fd });
        } finally {
          req.return();
        }
      }
      async function utimes(filepath, atime, mtime, cb) {
        if (typeof atime !== "number") atime = atime.getTime() / 1e3;
        if (typeof mtime !== "number") mtime = mtime.getTime() / 1e3;
        filepath = toNamespacedPath(filepath);
        const req = FileRequest.borrow();
        let err = null;
        try {
          binding.utimes(req.handle, filepath, atime, mtime);
          await req;
        } catch (e) {
          err = new FileError(e.message, {
            operation: "utimes",
            code: e.code,
            path: filepath
          });
        } finally {
          req.return();
        }
        return done(err, cb);
      }
      function utimesSync(filepath, atime, mtime) {
        if (typeof atime !== "number") atime = atime.getTime() / 1e3;
        if (typeof mtime !== "number") mtime = mtime.getTime() / 1e3;
        filepath = toNamespacedPath(filepath);
        const req = FileRequest.borrow();
        try {
          binding.utimesSync(req.handle, filepath, atime, mtime);
        } catch (e) {
          throw new FileError(e.message, {
            operation: "utimes",
            code: e.code,
            path: filepath
          });
        } finally {
          req.return();
        }
      }
      async function mkdir(filepath, opts, cb) {
        if (typeof opts === "function") {
          cb = opts;
          opts = { mode: 511 };
        }
        if (typeof opts === "number") opts = { mode: opts };
        else if (!opts) opts = {};
        const mode = typeof opts.mode === "number" ? opts.mode : 511;
        filepath = toNamespacedPath(filepath);
        if (opts.recursive) {
          let err2 = null;
          try {
            try {
              await mkdir(filepath, { mode });
            } catch (err3) {
              if (err3.code !== "ENOENT") {
                if (!(await stat(filepath)).isDirectory()) throw err3;
              } else {
                while (filepath.endsWith(path.sep)) filepath = filepath.slice(0, -1);
                const i = filepath.lastIndexOf(path.sep);
                if (i <= 0) throw err3;
                await mkdir(filepath.slice(0, i), { mode, recursive: true });
                try {
                  await mkdir(filepath, { mode });
                } catch (err4) {
                  if (!(await stat(filepath)).isDirectory()) throw err4;
                }
              }
            }
          } catch (e) {
            err2 = e;
          }
          return done(err2, cb);
        }
        const req = FileRequest.borrow();
        let err = null;
        try {
          binding.mkdir(req.handle, filepath, mode);
          await req;
        } catch (e) {
          err = new FileError(e.message, {
            operation: "mkdir",
            code: e.code,
            path: filepath
          });
        } finally {
          req.return();
        }
        return done(err, cb);
      }
      function mkdirSync(filepath, opts) {
        if (typeof opts === "number") opts = { mode: opts };
        else if (!opts) opts = {};
        const mode = typeof opts.mode === "number" ? opts.mode : 511;
        filepath = toNamespacedPath(filepath);
        if (opts.recursive) {
          try {
            mkdirSync(filepath, { mode });
          } catch (err) {
            if (err.code !== "ENOENT") {
              if (!statSync(filepath).isDirectory()) throw err;
            } else {
              while (filepath.endsWith(path.sep)) filepath = filepath.slice(0, -1);
              const i = filepath.lastIndexOf(path.sep);
              if (i <= 0) throw err;
              mkdirSync(filepath.slice(0, i), { mode, recursive: true });
              try {
                mkdirSync(filepath, { mode });
              } catch (err2) {
                if (!statSync(filepath).isDirectory()) throw err2;
              }
            }
          }
          return;
        }
        const req = FileRequest.borrow();
        try {
          binding.mkdirSync(req.handle, filepath, mode);
        } catch (e) {
          throw new FileError(e.message, {
            operation: "mkdir",
            code: e.code,
            path: filepath
          });
        } finally {
          req.return();
        }
      }
      async function rmdir(filepath, cb) {
        filepath = toNamespacedPath(filepath);
        const req = FileRequest.borrow();
        let err = null;
        try {
          binding.rmdir(req.handle, filepath);
          await req;
        } catch (e) {
          err = new FileError(e.message, {
            operation: "rmdir",
            code: e.code,
            path: filepath
          });
        } finally {
          req.return();
        }
        return done(err, cb);
      }
      function rmdirSync(filepath) {
        filepath = toNamespacedPath(filepath);
        const req = FileRequest.borrow();
        try {
          binding.rmdirSync(req.handle, filepath);
        } catch (e) {
          throw new FileError(e.message, {
            operation: "rmdir",
            code: e.code,
            path: filepath
          });
        } finally {
          req.return();
        }
      }
      async function rm(filepath, opts, cb) {
        if (typeof opts === "function") {
          cb = opts;
          opts = {};
        }
        if (!opts) opts = {};
        filepath = toNamespacedPath(filepath);
        let err = null;
        try {
          const st = await lstat(filepath);
          if (st.isDirectory()) {
            if (opts.recursive) {
              try {
                await rmdir(filepath);
              } catch (err2) {
                if (err2.code !== "ENOTEMPTY") throw err2;
                const files = await readdir(filepath);
                for (const file of files) {
                  await rm(filepath + path.sep + file, opts);
                }
                await rmdir(filepath);
              }
            } else {
              throw new FileError("is a directory", {
                operation: "rm",
                code: "EISDIR",
                path: filepath
              });
            }
          } else {
            await unlink(filepath);
          }
        } catch (e) {
          if (e.code !== "ENOENT" || !opts.force) err = e;
        }
        return done(err, cb);
      }
      function rmSync(filepath, opts) {
        if (!opts) opts = {};
        filepath = toNamespacedPath(filepath);
        try {
          const st = lstatSync(filepath);
          if (st.isDirectory()) {
            if (opts.recursive) {
              try {
                rmdirSync(filepath);
              } catch (err) {
                if (err.code !== "ENOTEMPTY") throw err;
                const files = readdirSync(filepath);
                for (const file of files) {
                  rmSync(filepath + path.sep + file, opts);
                }
                rmdirSync(filepath);
              }
            } else {
              throw new FileError("is a directory", {
                operation: "rm",
                code: "EISDIR",
                path: filepath
              });
            }
          } else {
            unlinkSync(filepath);
          }
        } catch (err) {
          if (err.code !== "ENOENT" || !opts.force) throw err;
        }
      }
      async function unlink(filepath, cb) {
        filepath = toNamespacedPath(filepath);
        const req = FileRequest.borrow();
        let err = null;
        try {
          binding.unlink(req.handle, filepath);
          await req;
        } catch (e) {
          err = new FileError(e.message, {
            operation: "unlink",
            code: e.code,
            path: filepath
          });
        } finally {
          req.return();
        }
        return done(err, cb);
      }
      function unlinkSync(filepath) {
        filepath = toNamespacedPath(filepath);
        const req = FileRequest.borrow();
        try {
          binding.unlinkSync(req.handle, filepath);
        } catch (e) {
          throw new FileError(e.message, {
            operation: "unlink",
            code: e.code,
            path: filepath
          });
        } finally {
          req.return();
        }
      }
      async function rename(src, dst, cb) {
        src = toNamespacedPath(src);
        dst = toNamespacedPath(dst);
        const req = FileRequest.borrow();
        let err = null;
        try {
          binding.rename(req.handle, src, dst);
          await req;
        } catch (e) {
          err = new FileError(e.message, {
            operation: "rename",
            code: e.code,
            path: src,
            destination: dst
          });
        } finally {
          req.return();
        }
        return done(err, cb);
      }
      function renameSync(src, dst) {
        src = toNamespacedPath(src);
        dst = toNamespacedPath(dst);
        const req = FileRequest.borrow();
        try {
          binding.renameSync(req.handle, src, dst);
        } catch (e) {
          throw new FileError(e.message, {
            operation: "rename",
            code: e.code,
            path: src,
            destination: dst
          });
        } finally {
          req.return();
        }
      }
      async function copyFile(src, dst, mode = 0, cb) {
        if (typeof mode === "function") {
          cb = mode;
          mode = 0;
        }
        src = toNamespacedPath(src);
        dst = toNamespacedPath(dst);
        const req = FileRequest.borrow();
        let err = null;
        try {
          binding.copyfile(req.handle, src, dst, mode);
          await req;
        } catch (e) {
          err = new FileError(e.message, {
            operation: "copyfile",
            code: e.code,
            path: src,
            destination: dst
          });
        } finally {
          req.return();
        }
        return done(err, cb);
      }
      function copyFileSync(src, dst, mode = 0) {
        src = toNamespacedPath(src);
        dst = toNamespacedPath(dst);
        const req = FileRequest.borrow();
        try {
          binding.copyfileSync(req.handle, src, dst, mode);
        } catch (e) {
          throw new FileError(e.message, {
            operation: "copyfile",
            code: e.code,
            path: src,
            destination: dst
          });
        } finally {
          req.return();
        }
      }
      async function cp(src, dst, opts, cb) {
        if (typeof opts === "function") {
          cb = opts;
          opts = {};
        }
        if (!opts) opts = {};
        src = toNamespacedPath(src);
        dst = toNamespacedPath(dst);
        let err = null;
        try {
          const st = await lstat(src);
          if (st.isDirectory()) {
            if (opts.recursive !== true) {
              throw new FileError("is a directory", { operation: "cp", code: "EISDIR", path: src });
            }
            try {
              await lstat(dst);
            } catch (e) {
              if (e.code !== "ENOENT") throw e;
              await mkdir(dst, { mode: st.mode, recursive: true });
            }
            const dir = await opendir(src);
            for await (const { name } of dir) {
              await cp(path.join(src, name), path.join(dst, name), opts);
            }
          } else if (st.isFile()) {
            await copyFile(src, dst);
            await chmod(dst, st.mode);
          }
        } catch (e) {
          err = e;
        }
        return done(err, cb);
      }
      function cpSync(src, dst, opts = {}) {
        src = toNamespacedPath(src);
        dst = toNamespacedPath(dst);
        const st = lstatSync(src);
        if (st.isDirectory()) {
          if (opts.recursive !== true) {
            throw new FileError("is a directory", { operation: "cp", code: "EISDIR", path: src });
          }
          try {
            lstatSync(dst);
          } catch (e) {
            if (e.code !== "ENOENT") throw e;
            mkdirSync(dst, { mode: st.mode, recursive: true });
          }
          const dir = opendirSync(src);
          for (const { name } of dir) {
            cpSync(path.join(src, name), path.join(dst, name), opts);
          }
        } else if (st.isFile()) {
          copyFileSync(src, dst);
          chmodSync(dst, st.mode);
        }
      }
      async function realpath(filepath, opts, cb) {
        if (typeof opts === "function") {
          cb = opts;
          opts = {};
        }
        if (typeof opts === "string") opts = { encoding: opts };
        else if (!opts) opts = {};
        const { encoding = "utf8" } = opts;
        filepath = toNamespacedPath(filepath);
        const req = FileRequest.borrow();
        let res;
        let err = null;
        try {
          binding.realpath(req.handle, filepath);
          await req;
          res = Buffer.from(binding.requestResultString(req.handle));
          if (encoding !== "buffer") res = res.toString(encoding);
        } catch (e) {
          err = new FileError(e.message, {
            operation: "realpath",
            code: e.code,
            path: filepath
          });
        } finally {
          req.return();
        }
        return done(err, res, cb);
      }
      function realpathSync(filepath, opts) {
        if (typeof opts === "string") opts = { encoding: opts };
        else if (!opts) opts = {};
        const { encoding = "utf8" } = opts;
        filepath = toNamespacedPath(filepath);
        const req = FileRequest.borrow();
        try {
          binding.realpathSync(req.handle, filepath);
          let res = Buffer.from(binding.requestResultString(req.handle));
          if (encoding !== "buffer") res = res.toString(encoding);
          return res;
        } catch (e) {
          throw new FileError(e.message, {
            operation: "realpath",
            code: e.code,
            path: filepath
          });
        } finally {
          req.return();
        }
      }
      async function readlink(filepath, opts, cb) {
        if (typeof opts === "function") {
          cb = opts;
          opts = {};
        }
        if (typeof opts === "string") opts = { encoding: opts };
        else if (!opts) opts = {};
        const { encoding = "utf8" } = opts;
        filepath = toNamespacedPath(filepath);
        const req = FileRequest.borrow();
        let res;
        let err = null;
        try {
          binding.readlink(req.handle, filepath);
          await req;
          res = Buffer.from(binding.requestResultString(req.handle));
          if (encoding !== "buffer") res = res.toString(encoding);
        } catch (e) {
          err = new FileError(e.message, {
            operation: "readlink",
            code: e.code,
            path: filepath
          });
        } finally {
          req.return();
        }
        return done(err, res, cb);
      }
      function readlinkSync(filepath, opts) {
        if (typeof opts === "string") opts = { encoding: opts };
        else if (!opts) opts = {};
        const { encoding = "utf8" } = opts;
        filepath = toNamespacedPath(filepath);
        const req = FileRequest.borrow();
        try {
          binding.readlinkSync(req.handle, filepath);
          let res = Buffer.from(binding.requestResultString(req.handle));
          if (encoding !== "buffer") res = res.toString(encoding);
          return res;
        } catch (e) {
          throw new FileError(e.message, {
            operation: "readlink",
            code: e.code,
            path: filepath
          });
        } finally {
          req.return();
        }
      }
      function normalizeSymlinkTarget(target, type, filepath) {
        if (isWindows) {
          if (type === constants.UV_FS_SYMLINK_JUNCTION) target = path.resolve(filepath, "..", target);
          if (path.isAbsolute(target)) return path.toNamespacedPath(target);
          return target.replace(/\//g, path.sep);
        }
        return target;
      }
      async function symlink(target, filepath, type, cb) {
        if (typeof type === "function") {
          cb = type;
          type = null;
        }
        filepath = toNamespacedPath(filepath);
        if (typeof type === "string") {
          switch (type) {
            case "dir":
              type = constants.UV_FS_SYMLINK_DIR;
              break;
            case "junction":
              type = constants.UV_FS_SYMLINK_JUNCTION;
              break;
            case "file":
            default:
              type = 0;
              break;
          }
        } else if (typeof type !== "number") {
          if (isWindows) {
            target = path.resolve(filepath, "..", target);
            try {
              type = (await stat(target)).isDirectory() ? constants.UV_FS_SYMLINK_DIR : constants.UV_FS_SYMLINK_JUNCTION;
            } catch {
              type = 0;
            }
          } else {
            type = 0;
          }
        }
        target = normalizeSymlinkTarget(target, type, filepath);
        const req = FileRequest.borrow();
        let err = null;
        try {
          binding.symlink(req.handle, target, filepath, type);
          await req;
        } catch (e) {
          err = new FileError(e.message, {
            operation: "symlink",
            code: e.code,
            path: target,
            destination: filepath
          });
        } finally {
          req.return();
        }
        return done(err, cb);
      }
      function symlinkSync(target, filepath, type) {
        filepath = toNamespacedPath(filepath);
        if (typeof type === "string") {
          switch (type) {
            case "dir":
              type = constants.UV_FS_SYMLINK_DIR;
              break;
            case "junction":
              type = constants.UV_FS_SYMLINK_JUNCTION;
              break;
            case "file":
            default:
              type = 0;
              break;
          }
        } else if (typeof type !== "number") {
          if (isWindows) {
            target = path.resolve(filepath, "..", target);
            try {
              type = statSync(target).isDirectory() ? constants.UV_FS_SYMLINK_DIR : constants.UV_FS_SYMLINK_JUNCTION;
            } catch {
              type = 0;
            }
          } else {
            type = 0;
          }
        }
        target = normalizeSymlinkTarget(target, type, filepath);
        const req = FileRequest.borrow();
        try {
          binding.symlinkSync(req.handle, target, filepath, type);
        } catch (e) {
          throw new FileError(e.message, {
            operation: "symlink",
            code: e.code,
            path: target,
            destination: filepath
          });
        } finally {
          req.return();
        }
      }
      async function opendir(filepath, opts, cb) {
        if (typeof opts === "function") {
          cb = opts;
          opts = {};
        }
        if (typeof opts === "string") opts = { encoding: opts };
        else if (!opts) opts = {};
        filepath = toNamespacedPath(filepath);
        const req = FileRequest.borrow();
        let dir;
        let err = null;
        try {
          binding.opendir(req.handle, filepath);
          await req;
          dir = new Dir(filepath, binding.requestResultDir(req.handle), opts);
        } catch (e) {
          err = new FileError(e.message, {
            operation: "opendir",
            code: e.code,
            path: filepath
          });
        } finally {
          req.return();
        }
        return done(err, dir, cb);
      }
      function opendirSync(filepath, opts) {
        if (typeof opts === "string") opts = { encoding: opts };
        else if (!opts) opts = {};
        filepath = toNamespacedPath(filepath);
        const req = FileRequest.borrow();
        try {
          binding.opendirSync(req.handle, filepath);
          return new Dir(filepath, binding.requestResultDir(req.handle), opts);
        } catch (e) {
          throw new FileError(e.message, {
            operation: "opendir",
            code: e.code,
            path: filepath
          });
        } finally {
          req.return();
        }
      }
      async function readdir(filepath, opts, cb) {
        if (typeof opts === "function") {
          cb = opts;
          opts = {};
        }
        if (typeof opts === "string") opts = { encoding: opts };
        else if (!opts) opts = {};
        const { withFileTypes = false } = opts;
        filepath = toNamespacedPath(filepath);
        let result = [];
        let err = null;
        try {
          const dir = await opendir(filepath);
          for await (const entry of dir) {
            result.push(withFileTypes ? entry : entry.name);
          }
        } catch (e) {
          result = [];
          err = e;
        }
        return done(err, result, cb);
      }
      function readdirSync(filepath, opts) {
        if (typeof opts === "string") opts = { encoding: opts };
        else if (!opts) opts = {};
        const { withFileTypes = false } = opts;
        filepath = toNamespacedPath(filepath);
        const dir = opendirSync(filepath, opts);
        const result = [];
        for (const entry of dir) {
          result.push(withFileTypes ? entry : entry.name);
        }
        return result;
      }
      async function readFile(filepath, opts, cb) {
        if (typeof opts === "function") {
          cb = opts;
          opts = {};
        }
        if (typeof opts === "string") opts = { encoding: opts };
        else if (!opts) opts = {};
        const { encoding = "buffer" } = opts;
        let fd = -1;
        let buffer = null;
        let err = null;
        try {
          fd = await open(filepath, opts.flag || "r");
          const st = await fstat(fd);
          let len = 0;
          if (st.size === 0) {
            const buffers = [];
            while (true) {
              buffer = Buffer.allocUnsafe(8192);
              const r = await read(fd, buffer);
              len += r;
              if (r === 0) break;
              buffers.push(buffer.subarray(0, r));
            }
            buffer = Buffer.concat(buffers);
          } else {
            buffer = Buffer.allocUnsafe(st.size);
            while (true) {
              const r = await read(fd, len ? buffer.subarray(len) : buffer);
              len += r;
              if (r === 0 || len === buffer.byteLength) break;
            }
            if (len !== buffer.byteLength) buffer = buffer.subarray(0, len);
          }
          if (encoding !== "buffer") buffer = buffer.toString(encoding);
        } catch (e) {
          err = e;
        } finally {
          if (fd !== -1) await close(fd);
        }
        return done(err, buffer, cb);
      }
      function readFileSync(filepath, opts) {
        if (typeof opts === "string") opts = { encoding: opts };
        else if (!opts) opts = {};
        const { encoding = "buffer" } = opts;
        let fd = -1;
        try {
          fd = openSync(filepath, opts.flag || "r");
          const st = fstatSync(fd);
          let buffer;
          let len = 0;
          if (st.size === 0) {
            const buffers = [];
            while (true) {
              buffer = Buffer.allocUnsafe(8192);
              const r = readSync(fd, buffer);
              len += r;
              if (r === 0) break;
              buffers.push(buffer.subarray(0, r));
            }
            buffer = Buffer.concat(buffers);
          } else {
            buffer = Buffer.allocUnsafe(st.size);
            while (true) {
              const r = readSync(fd, len ? buffer.subarray(len) : buffer);
              len += r;
              if (r === 0 || len === buffer.byteLength) break;
            }
            if (len !== buffer.byteLength) buffer = buffer.subarray(0, len);
          }
          if (encoding !== "buffer") buffer = buffer.toString(encoding);
          return buffer;
        } finally {
          if (fd !== -1) closeSync(fd);
        }
      }
      async function writeFile(filepath, data, opts, cb) {
        if (typeof opts === "function") {
          cb = opts;
          opts = {};
        }
        if (typeof opts === "string") opts = { encoding: opts };
        else if (!opts) opts = {};
        if (typeof data === "string") data = Buffer.from(data, opts.encoding);
        let fd = -1;
        let len = 0;
        let err = null;
        try {
          fd = await open(filepath, opts.flag || "w", opts.mode || 438);
          while (true) {
            len += await write(fd, len ? data.subarray(len) : data);
            if (len === data.byteLength) break;
          }
        } catch (e) {
          err = e;
        } finally {
          if (fd !== -1) await close(fd);
        }
        return done(err, len, cb);
      }
      function writeFileSync(filepath, data, opts) {
        if (typeof opts === "string") opts = { encoding: opts };
        else if (!opts) opts = {};
        if (typeof data === "string") data = Buffer.from(data, opts.encoding);
        let fd = -1;
        try {
          fd = openSync(filepath, opts.flag || "w", opts.mode || 438);
          let len = 0;
          while (true) {
            len += writeSync(fd, len ? data.subarray(len) : data);
            if (len === data.byteLength) break;
          }
        } finally {
          if (fd !== -1) closeSync(fd);
        }
      }
      function appendFile(filepath, data, opts, cb) {
        if (typeof opts === "function") {
          cb = opts;
          opts = {};
        }
        if (typeof opts === "string") opts = { encoding: opts };
        else if (!opts) opts = {};
        if (!opts.flag) opts = { ...opts, flag: "a" };
        return writeFile(filepath, data, opts, cb);
      }
      function appendFileSync(filepath, data, opts) {
        if (typeof opts === "string") opts = { encoding: opts };
        else if (!opts) opts = {};
        if (!opts.flag) opts = { ...opts, flag: "a" };
        return writeFileSync(filepath, data, opts);
      }
      function watch(filepath, opts, cb) {
        if (typeof opts === "function") {
          cb = opts;
          opts = {};
        }
        if (typeof opts === "string") opts = { encoding: opts };
        else if (!opts) opts = {};
        filepath = toNamespacedPath(filepath);
        return new Watcher(filepath, opts, cb);
      }
      var Stats = class {
        constructor(dev, mode, nlink, uid, gid, rdev, blksize, ino, size, blocks, atimeMs, mtimeMs, ctimeMs, birthtimeMs) {
          this.dev = dev;
          this.mode = mode;
          this.nlink = nlink;
          this.uid = uid;
          this.gid = gid;
          this.rdev = rdev;
          this.blksize = blksize;
          this.ino = ino;
          this.size = size;
          this.blocks = blocks;
          this.atimeMs = atimeMs;
          this.mtimeMs = mtimeMs;
          this.ctimeMs = ctimeMs;
          this.birthtimeMs = birthtimeMs;
          this.atime = new Date(atimeMs);
          this.mtime = new Date(mtimeMs);
          this.ctime = new Date(ctimeMs);
          this.birthtime = new Date(birthtimeMs);
        }
        isDirectory() {
          return (this.mode & constants.S_IFMT) === constants.S_IFDIR;
        }
        isFile() {
          return (this.mode & constants.S_IFMT) === constants.S_IFREG;
        }
        isBlockDevice() {
          return (this.mode & constants.S_IFMT) === constants.S_IFBLK;
        }
        isCharacterDevice() {
          return (this.mode & constants.S_IFMT) === constants.S_IFCHR;
        }
        isFIFO() {
          return (this.mode & constants.S_IFMT) === constants.S_IFIFO;
        }
        isSymbolicLink() {
          return (this.mode & constants.S_IFMT) === constants.S_IFLNK;
        }
        isSocket() {
          return (this.mode & constants.S_IFMT) === constants.S_IFSOCK;
        }
      };
      var Dir = class {
        constructor(path2, handle, opts = {}) {
          const { encoding = "utf8", bufferSize = 32 } = opts;
          this.path = path2;
          this._encoding = encoding;
          this._capacity = bufferSize;
          this._buffer = new FIFO();
          this._ended = false;
          this._handle = handle;
        }
        async read(cb) {
          if (this._buffer.length) return ok(this._buffer.shift(), cb);
          if (this._ended) return ok(null, cb);
          const req = FileRequest.borrow();
          let entries;
          let err = null;
          try {
            req.retain(binding.readdir(req.handle, this._handle, this._capacity));
            await req;
            entries = binding.requestResultDirents(req.handle);
          } catch (e) {
            err = new FileError(e.message, {
              operation: "readdir",
              code: e.code,
              path: this.path
            });
          } finally {
            req.return();
          }
          if (err) return fail(err, cb);
          if (entries.length === 0) {
            this._ended = true;
            return ok(null, cb);
          }
          for (const entry of entries) {
            let name = Buffer.from(entry.name);
            if (this._encoding !== "buffer") name = name.toString(this._encoding);
            this._buffer.push(new Dirent(this.path, name, entry.type));
          }
          return ok(this._buffer.shift(), cb);
        }
        readSync() {
          if (this._buffer.length) return this._buffer.shift();
          if (this._ended) return null;
          const req = FileRequest.borrow();
          let entries;
          try {
            req.retain(binding.readdirSync(req.handle, this._handle, this._capacity));
            entries = binding.requestResultDirents(req.handle);
          } catch (e) {
            throw new FileError(e.message, {
              operation: "readdir",
              code: e.code,
              path: this.path
            });
          } finally {
            req.return();
          }
          if (entries.length === 0) {
            this._ended = true;
            return null;
          }
          for (const entry of entries) {
            let name = Buffer.from(entry.name);
            if (this._encoding !== "buffer") name = name.toString(this._encoding);
            this._buffer.push(new Dirent(this.path, name, entry.type));
          }
          return this._buffer.shift();
        }
        async close(cb) {
          const req = FileRequest.borrow();
          let err = null;
          try {
            binding.closedir(req.handle, this._handle);
            await req;
          } catch (e) {
            err = new FileError(e.message, {
              operation: "closedir",
              code: e.code,
              path: this.path
            });
          } finally {
            req.return();
          }
          this._handle = null;
          return done(err, cb);
        }
        closeSync() {
          const req = FileRequest.borrow();
          try {
            binding.closedirSync(req.handle, this._handle);
          } catch (e) {
            throw new FileError(e.message, {
              operation: "closedir",
              code: e.code,
              path: this.path
            });
          } finally {
            req.return();
          }
          this._handle = null;
        }
        [Symbol.dispose]() {
          this.closeSync();
        }
        async [Symbol.asyncDispose]() {
          await this.close();
        }
        *[Symbol.iterator]() {
          while (true) {
            const entry = this.readSync();
            if (entry === null) break;
            yield entry;
          }
          this.closeSync();
        }
        async *[Symbol.asyncIterator]() {
          while (true) {
            const entry = await this.read();
            if (entry === null) break;
            yield entry;
          }
          await this.close();
        }
      };
      var Dirent = class {
        constructor(parentPath, name, type) {
          this.parentPath = parentPath;
          this.name = name;
          this.type = type;
        }
        isFile() {
          return this.type === constants.UV_DIRENT_FILE;
        }
        isDirectory() {
          return this.type === constants.UV_DIRENT_DIR;
        }
        isSymbolicLink() {
          return this.type === constants.UV_DIRENT_LINK;
        }
        isFIFO() {
          return this.type === constants.UV_DIRENT_FIFO;
        }
        isSocket() {
          return this.type === constants.UV_DIRENT_SOCKET;
        }
        isCharacterDevice() {
          return this.type === constants.UV_DIRENT_CHAR;
        }
        isBlockDevice() {
          return this.type === constants.UV_DIRENT_BLOCK;
        }
      };
      var FileReadStream = class extends Readable {
        constructor(path2, opts = {}) {
          const { eagerOpen = true } = opts;
          super({ eagerOpen, ...opts });
          this.path = path2;
          this.fd = typeof opts.fd === "number" ? opts.fd : -1;
          this.flags = opts.flags || "r";
          this.mode = opts.mode || 438;
          this._offset = opts.start || 0;
          this._missing = 0;
          if (opts.length) {
            this._missing = opts.length;
          } else if (typeof opts.end === "number") {
            this._missing = opts.end - this._offset + 1;
          } else {
            this._missing = -1;
          }
        }
        async _open(cb) {
          let err;
          if (this.fd === -1) {
            err = null;
            try {
              this.fd = await open(this.path, this.flags, this.mode);
            } catch (e) {
              err = e;
            }
            if (err) return cb(err);
          }
          let st;
          err = null;
          try {
            st = await fstat(this.fd);
          } catch (e) {
            err = e;
          }
          if (err) return cb(err);
          if (this._missing === -1) this._missing = st.size;
          if (st.size < this._offset) {
            this._offset = st.size;
            this._missing = 0;
          } else if (st.size < this._offset + this._missing) {
            this._missing = st.size - this._offset;
          }
          cb(null);
        }
        async _read(size) {
          if (this._missing <= 0) return this.push(null);
          const data = Buffer.allocUnsafe(Math.min(this._missing, size));
          let len;
          let err = null;
          try {
            len = await read(this.fd, data, 0, data.byteLength, this._offset);
          } catch (e) {
            err = e;
          }
          if (err) return this.destroy(err);
          if (len === 0) return this.push(null);
          if (this._missing < len) len = this._missing;
          this._missing -= len;
          this._offset += len;
          this.push(data.subarray(0, len));
        }
        async _destroy(err, cb) {
          if (this.fd === -1) return cb(err);
          try {
            await close(this.fd);
          } catch (e) {
            err = err || e;
          }
          cb(err);
        }
      };
      var FileWriteStream = class extends Writable {
        constructor(path2, opts = {}) {
          const { eagerOpen = true } = opts;
          super({ eagerOpen, ...opts });
          this.path = path2;
          this.fd = typeof opts.fd === "number" ? opts.fd : -1;
          this.flags = opts.flags || "w";
          this.mode = opts.mode || 438;
        }
        async _open(cb) {
          if (this.fd !== -1) return cb(null);
          let err = null;
          try {
            this.fd = await open(this.path, this.flags, this.mode);
          } catch (e) {
            err = e;
          }
          cb(err);
        }
        async _writev(batch, cb) {
          let err = null;
          try {
            await writev(
              this.fd,
              batch.map(({ chunk }) => chunk)
            );
          } catch (e) {
            err = e;
          }
          cb(err);
        }
        async _destroy(err, cb) {
          if (this.fd === -1) return cb(err);
          try {
            await close(this.fd);
          } catch (e) {
            err = err || e;
          }
          cb(err);
        }
      };
      var Watcher = class extends EventEmitter {
        constructor(path2, opts, onchange) {
          if (typeof opts === "function") {
            onchange = opts;
            opts = {};
          }
          if (!opts) opts = {};
          const { persistent = true, recursive = false, encoding = "utf8" } = opts;
          super();
          this._closed = false;
          this._encoding = encoding;
          this._handle = binding.watcherInit(path2, recursive, this, this._onevent, this._onclose);
          if (!persistent) this.unref();
          if (onchange) this.on("change", onchange);
        }
        close() {
          if (this._closed) return;
          this._closed = true;
          binding.watcherClose(this._handle);
        }
        ref() {
          if (this._handle) binding.watcherRef(this._handle);
          return this;
        }
        unref() {
          if (this._handle) binding.watcherUnref(this._handle);
          return this;
        }
        [Symbol.asyncIterator]() {
          const buffer = [];
          let done2 = false;
          let error = null;
          let next = null;
          this.on("change", (eventType, filename) => {
            if (next) {
              next.resolve({ done: false, value: { eventType, filename } });
              next = null;
            } else {
              buffer.push({ eventType, filename });
            }
          }).on("error", (err) => {
            done2 = true;
            error = err;
            if (next) {
              next.reject(error);
              next = null;
            }
          }).on("close", () => {
            done2 = true;
            if (next) {
              next.resolve({ done: done2 });
              next = null;
            }
          });
          return {
            next: () => new Promise((resolve, reject) => {
              if (error) return reject(error);
              if (buffer.length) return resolve({ done: false, value: buffer.shift() });
              if (done2) return resolve({ done: done2 });
              next = { resolve, reject };
            })
          };
        }
        _onevent(err, events, filename) {
          if (err) {
            this.close();
            this.emit("error", err);
          } else {
            const path2 = this._encoding === "buffer" ? Buffer.from(filename) : Buffer.from(filename).toString(this._encoding);
            if (events & binding.UV_RENAME) {
              this.emit("change", "rename", path2);
            }
            if (events & binding.UV_CHANGE) {
              this.emit("change", "change", path2);
            }
          }
        }
        _onclose() {
          this._handle = null;
          this.emit("close");
        }
      };
      exports.access = access;
      exports.appendFile = appendFile;
      exports.chmod = chmod;
      exports.close = close;
      exports.copyFile = copyFile;
      exports.cp = cp;
      exports.exists = exists;
      exports.fchmod = fchmod;
      exports.fstat = fstat;
      exports.ftruncate = ftruncate;
      exports.lstat = lstat;
      exports.mkdir = mkdir;
      exports.open = open;
      exports.opendir = opendir;
      exports.read = read;
      exports.readFile = readFile;
      exports.readdir = readdir;
      exports.readlink = readlink;
      exports.readv = readv;
      exports.realpath = realpath;
      exports.rename = rename;
      exports.rm = rm;
      exports.rmdir = rmdir;
      exports.stat = stat;
      exports.symlink = symlink;
      exports.unlink = unlink;
      exports.utimes = utimes;
      exports.watch = watch;
      exports.write = write;
      exports.writeFile = writeFile;
      exports.writev = writev;
      exports.accessSync = accessSync;
      exports.appendFileSync = appendFileSync;
      exports.chmodSync = chmodSync;
      exports.closeSync = closeSync;
      exports.copyFileSync = copyFileSync;
      exports.cpSync = cpSync;
      exports.existsSync = existsSync;
      exports.fchmodSync = fchmodSync;
      exports.fstatSync = fstatSync;
      exports.ftruncateSync = ftruncateSync;
      exports.lstatSync = lstatSync;
      exports.mkdirSync = mkdirSync;
      exports.openSync = openSync;
      exports.opendirSync = opendirSync;
      exports.readFileSync = readFileSync;
      exports.readSync = readSync;
      exports.readdirSync = readdirSync;
      exports.readlinkSync = readlinkSync;
      exports.readvSync = readvSync;
      exports.realpathSync = realpathSync;
      exports.renameSync = renameSync;
      exports.rmSync = rmSync;
      exports.rmdirSync = rmdirSync;
      exports.statSync = statSync;
      exports.symlinkSync = symlinkSync;
      exports.unlinkSync = unlinkSync;
      exports.utimesSync = utimesSync;
      exports.writeFileSync = writeFileSync;
      exports.writeSync = writeSync;
      exports.writevSync = writevSync;
      exports.promises = require_promises();
      exports.Stats = Stats;
      exports.Dir = Dir;
      exports.Dirent = Dirent;
      exports.Watcher = Watcher;
      exports.ReadStream = FileReadStream;
      exports.createReadStream = function createReadStream(path2, opts) {
        return new FileReadStream(path2, opts);
      };
      exports.WriteStream = FileWriteStream;
      exports.createWriteStream = function createWriteStream(path2, opts) {
        return new FileWriteStream(path2, opts);
      };
      function toNamespacedPath(filepath) {
        if (typeof filepath !== "string") {
          if (isURL(filepath)) filepath = fileURLToPath(filepath);
          else filepath = filepath.toString();
        }
        return path.toNamespacedPath(filepath);
      }
      function toFlags(flags) {
        switch (flags) {
          case "r":
            return constants.O_RDONLY;
          case "rs":
          // Fall through.
          case "sr":
            return constants.O_RDONLY | constants.O_SYNC;
          case "r+":
            return constants.O_RDWR;
          case "rs+":
          // Fall through.
          case "sr+":
            return constants.O_RDWR | constants.O_SYNC;
          case "w":
            return constants.O_TRUNC | constants.O_CREAT | constants.O_WRONLY;
          case "wx":
          // Fall through.
          case "xw":
            return constants.O_TRUNC | constants.O_CREAT | constants.O_WRONLY | constants.O_EXCL;
          case "w+":
            return constants.O_TRUNC | constants.O_CREAT | constants.O_RDWR;
          case "wx+":
          // Fall through.
          case "xw+":
            return constants.O_TRUNC | constants.O_CREAT | constants.O_RDWR | constants.O_EXCL;
          case "a":
            return constants.O_APPEND | constants.O_CREAT | constants.O_WRONLY;
          case "ax":
          // Fall through.
          case "xa":
            return constants.O_APPEND | constants.O_CREAT | constants.O_WRONLY | constants.O_EXCL;
          case "as":
          // Fall through.
          case "sa":
            return constants.O_APPEND | constants.O_CREAT | constants.O_WRONLY | constants.O_SYNC;
          case "a+":
            return constants.O_APPEND | constants.O_CREAT | constants.O_RDWR;
          case "ax+":
          // Fall through.
          case "xa+":
            return constants.O_APPEND | constants.O_CREAT | constants.O_RDWR | constants.O_EXCL;
          case "as+":
          // Fall through.
          case "sa+":
            return constants.O_APPEND | constants.O_CREAT | constants.O_RDWR | constants.O_SYNC;
          default:
            return 0;
        }
      }
      function toMode(mode) {
        return parseInt(mode, 8);
      }
    }
  });

  // ../bare-os-openssh/vendor/bare-node-shims/bare-node-fs/index.js
  var require_bare_node_fs = __commonJS({
    "../bare-os-openssh/vendor/bare-node-shims/bare-node-fs/index.js"(exports, module) {
      module.exports = require_bare_fs();
    }
  });

  // ../../node_modules/bare-which/lib/executable.js
  var require_executable = __commonJS({
    "../../node_modules/bare-which/lib/executable.js"(exports, module) {
      var fs = require_bare_node_fs();
      var process2 = __require("process");
      var { isWindows } = require_which_runtime();
      function isExecutableSync(path, options) {
        try {
          const stat = fs.statSync(path);
          const checker = isWindows ? isWin32Executable : isPosixExecutableSync;
          return stat.isFile() && checker({ path, options });
        } catch (err) {
          if (options.ignoreErrors || ["ENOENT", "EACCES"].includes(err.code)) return false;
          throw err;
        }
      }
      async function isExecutable(path, options) {
        try {
          const stat = await fs.promises.stat(path);
          const checker = isWindows ? isWin32Executable : isPosixExecutable;
          return stat.isFile() && await checker({ path, options });
        } catch (err) {
          if (options.ignoreErrors || ["ENOENT", "EACCES"].includes(err.code)) return false;
          throw err;
        }
      }
      function isWin32Executable({ path, options }) {
        const { pathExt = process2.env.PATHEXT || "" } = options;
        const exts = pathExt.split(";");
        if (exts.includes("")) return true;
        return exts.some((ext) => path.toLowerCase().endsWith(ext.toLowerCase()));
      }
      async function isPosixExecutable({ path }) {
        await fs.promises.access(path, fs.constants.X_OK);
        return true;
      }
      function isPosixExecutableSync({ path }) {
        fs.accessSync(path, fs.constants.X_OK);
        return true;
      }
      isExecutable.sync = isExecutableSync;
      module.exports = isExecutable;
    }
  });

  // ../../node_modules/bare-which/index.js
  var require_bare_which = __commonJS({
    "../../node_modules/bare-which/index.js"(exports, module) {
      var { join, delimiter } = __require("path");
      var process2 = __require("process");
      var { isWindows } = require_which_runtime();
      var isExecutable = require_executable();
      var pathMatcher = isWindows ? /[/\\]/ : /\//;
      var relativePathMatcher = new RegExp(`^\\.${pathMatcher.source}`);
      var isPath = (path) => pathMatcher.test(path);
      var isRelative = (path) => relativePathMatcher.test(path);
      var ErrorNotFound = class extends Error {
        constructor(command) {
          super(`Command not found: ${command}`);
          this.code = "ENOENT";
        }
      };
      function getPathInfo(cmd, {
        path: optPath = process2.env.PATH,
        pathExt: optPathExt = process2.env.PATHEXT,
        delimiter: optDelimiter = delimiter
      }) {
        const pathEnv = !isPath(cmd) ? [...isWindows ? [process2.cwd()] : [], ...(optPath || "").split(optDelimiter)] : [""];
        if (!isWindows) return { pathEnv, pathExt: [""] };
        const pathExtExe = optPathExt || [".EXE", ".CMD", ".BAT", ".COM"].join(optDelimiter);
        const pathExt = pathExtExe.split(optDelimiter).flatMap((item) => [item, item.toLowerCase()]);
        if (cmd.includes(".") && pathExt[0] !== "") pathExt.unshift("");
        return { pathEnv, pathExt, pathExtExe };
      }
      function joinPathCommand(path, cmd) {
        const pathPart = /^".*"$/.test(path) ? path.slice(1, -1) : path;
        const prefix = !pathPart && isRelative(cmd) ? cmd.slice(0, 2) : "";
        return prefix + join(pathPart, cmd);
      }
      function whichSync(cmd, options = {}) {
        const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, options);
        const { all, nothrow } = options;
        const found = [];
        for (const pathEnvPart of pathEnv) {
          const pathCommand = joinPathCommand(pathEnvPart, cmd);
          for (const ext of pathExt) {
            const withExt = pathCommand + ext;
            if (isExecutable.sync(
              withExt,
              { pathExt: pathExtExe, ignoreErrors: true }
            )) {
              if (!all) return withExt;
              found.push(withExt);
            }
          }
        }
        if (all && found.length) return found;
        if (nothrow) return null;
        throw new ErrorNotFound(cmd);
      }
      async function whichAsync(cmd, options = {}) {
        const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, options);
        const { all, nothrow } = options;
        const foundPromises = [];
        for (const pathEnvPart of pathEnv) {
          const pathCommand = joinPathCommand(pathEnvPart, cmd);
          for (const ext of pathExt) {
            const withExt = pathCommand + ext;
            if (all) {
              foundPromises.push(
                isExecutable(withExt, { pathExt: pathExtExe, ignoreErrors: true }).then((isExec) => isExec ? withExt : null)
              );
            } else if (await isExecutable(
              withExt,
              { pathExt: pathExtExe, ignoreErrors: true }
            )) return withExt;
          }
        }
        const found = (await Promise.all(foundPromises)).filter((item) => item !== null);
        if (all && found.length > 0) return found;
        if (nothrow) return null;
        throw new ErrorNotFound(cmd);
      }
      whichAsync.sync = whichSync;
      module.exports = whichAsync;
    }
  });

  // ../../node_modules/bare-dev/lib/shared/exec.js
  var require_exec = __commonJS({
    "../../node_modules/bare-dev/lib/shared/exec.js"(exports, module) {
      var process2 = __require("process");
      var path = __require("path");
      var childProcess = __require("child_process");
      module.exports = function exec(file, args = [], opts = {}) {
        const {
          env = process2.env,
          cwd = path.resolve("."),
          input,
          quiet = true,
          stdio = [input ? null : "ignore", "pipe", quiet ? "ignore" : "inherit"],
          shell = requiresShell(file),
          verbose = false
        } = opts;
        if (verbose) {
          if (cwd !== path.resolve(".")) process2.stderr.write(`# cd ${cwd}
`);
          process2.stderr.write(`# ${file} ${args.join(" ")}
`);
        }
        return childProcess.execFileSync(file, args, {
          encoding: "utf-8",
          stdio,
          env,
          cwd,
          input,
          shell
        });
      };
      function requiresShell(cmd) {
        if (process2.platform !== "win32") return false;
        const ext = path.extname(cmd).toLowerCase();
        return ext === ".bat" || ext === ".cmd";
      }
    }
  });

  // ../../node_modules/bare-dev/lib/android/shared/sdk.js
  var require_sdk = __commonJS({
    "../../node_modules/bare-dev/lib/android/shared/sdk.js"(exports) {
      var process2 = __require("process");
      var path = __require("path");
      var os = __require("os");
      var which = require_bare_which();
      var exec = require_exec();
      exports.path = process2.env.ANDROID_HOME || path.join(os.homedir(), ".android/sdk");
      var manager = exports.manager = function manager2() {
        return which.sync("sdkmanager", {
          path: path.join(exports.path, "cmdline-tools/latest/bin")
        });
      };
      manager.install = function install(pkg, version, opts = {}) {
        if (typeof version === "object") {
          opts = version;
          version = null;
        }
        pkg = Array.isArray(pkg) ? pkg.join(";") : pkg;
        if (version) pkg += `;${version}`;
        exec(manager(), ["--install", pkg], opts);
      };
      manager.uninstall = function install(pkg, version, opts = {}) {
        if (typeof version === "object") {
          opts = version;
          version = null;
        }
        pkg = Array.isArray(pkg) ? pkg.join(";") : pkg;
        if (version) pkg += `;${version}`;
        exec(manager(), ["--uninstall", pkg], opts);
      };
    }
  });

  // ../../node_modules/bare-dev/lib/android/shared/avd.js
  var require_avd = __commonJS({
    "../../node_modules/bare-dev/lib/android/shared/avd.js"(exports) {
      var os = __require("os");
      var path = __require("path");
      var which = require_bare_which();
      var exec = require_exec();
      var sdk = require_sdk();
      var manager = exports.manager = function manager2() {
        return which.sync("avdmanager", {
          path: path.join(sdk.path, "cmdline-tools/latest/bin")
        });
      };
      manager.create = function create(name, version, opts = {}) {
        const {
          arch = os.arch(),
          tag = "default",
          force
        } = opts;
        const abi = toABI(arch);
        const pkg = ["system-images", `android-${version}`, tag, abi];
        sdk.manager.install(pkg, opts);
        const args = [
          "create",
          "avd",
          "--name",
          name,
          "--package",
          pkg.join(";"),
          "--tag",
          tag,
          "--abi",
          abi
        ];
        if (force) args.push("--force");
        exec(manager(), args, { ...opts, input: "no" });
      };
      manager.remove = function remove(name, opts = {}) {
        exec(manager(), ["delete", "avd", "--name", name], opts);
      };
      function toABI(arch) {
        switch (arch) {
          case "arm64":
            return "arm64-v8a";
          case "arm":
            return "armeabi-v7a";
          case "x64":
            return "x86_64";
          case "ia32":
            return "x86";
        }
        throw new Error(`unsupported architecture "${arch}"`);
      }
    }
  });

  // ../../node_modules/bare-dev/lib/android/device/create.js
  var require_create = __commonJS({
    "../../node_modules/bare-dev/lib/android/device/create.js"(exports, module) {
      var avd = require_avd();
      module.exports = function create(name, version, opts) {
        avd.manager.create(name, version, opts);
      };
    }
  });

  // ../../node_modules/bare-dev/lib/shared/spawn.js
  var require_spawn = __commonJS({
    "../../node_modules/bare-dev/lib/shared/spawn.js"(exports, module) {
      var process2 = __require("process");
      var path = __require("path");
      var childProcess = __require("child_process");
      module.exports = function spawn(cmd, args = [], opts = {}) {
        const {
          env = process2.env,
          cwd = path.resolve("."),
          detached = false,
          quiet = true,
          stdio = quiet || detached ? "ignore" : "inherit",
          shell = requiresShell(cmd),
          verbose = false
        } = opts;
        if (verbose) {
          if (cwd !== path.resolve(".")) process2.stderr.write(`# cd ${cwd}
`);
          process2.stderr.write(`# ${cmd} ${args.join(" ")}
`);
        }
        let proc;
        if (detached) {
          proc = childProcess.spawn(cmd, args, {
            stdio,
            detached,
            env,
            cwd,
            shell
          });
          proc.unref();
        } else {
          proc = childProcess.spawnSync(cmd, args, {
            stdio,
            env,
            cwd,
            shell
          });
          if (proc.status) throw new Error("spawn() failed");
        }
        return proc;
      };
      function requiresShell(cmd) {
        if (process2.platform !== "win32") return false;
        const ext = path.extname(cmd).toLowerCase();
        return ext === ".bat" || ext === ".cmd";
      }
    }
  });

  // ../../node_modules/bare-dev/lib/android/shared/apkanalyzer.js
  var require_apkanalyzer = __commonJS({
    "../../node_modules/bare-dev/lib/android/shared/apkanalyzer.js"(exports, module) {
      var path = __require("path");
      var which = require_bare_which();
      var exec = require_exec();
      var sdk = require_sdk();
      var apkanalyzer = module.exports = function apkanalyzer2() {
        return which.sync("apkanalyzer", {
          path: path.join(sdk.path, "cmdline-tools/latest/bin")
        });
      };
      apkanalyzer.manifest = function manifest(apk, key, opts = {}) {
        const {
          cwd = path.resolve(".")
        } = opts;
        apk = path.resolve(cwd, apk);
        return exec(apkanalyzer(), ["manifest", key, apk], opts).trim();
      };
    }
  });

  // ../../node_modules/bare-dev/lib/android/shared/adb.js
  var require_adb = __commonJS({
    "../../node_modules/bare-dev/lib/android/shared/adb.js"(exports, module) {
      var path = __require("path");
      var os = __require("os");
      var which = require_bare_which();
      var exec = require_exec();
      var spawn = require_spawn();
      var sdk = require_sdk();
      var apkanalyzer = require_apkanalyzer();
      var adb = module.exports = function adb2() {
        return which.sync("adb", {
          path: path.join(sdk.path, "platform-tools")
        });
      };
      adb.devices = function devices(opts = {}) {
        const lines = exec(adb(), ["devices", "-l"], opts).split(os.EOL).filter(Boolean).slice(1);
        const devices2 = [];
        for (const line of lines) {
          const [id, kind] = line.split(/[\s,]+/).filter(Boolean);
          if (kind !== "device") continue;
          const type = id.startsWith("emulator-") ? "emulator" : "device";
          devices2.push({
            id,
            type,
            name: name(id, { type }),
            state: "booted"
          });
        }
        return devices2;
      };
      adb.install = function install(device, apk, opts = {}) {
        const {
          cwd = path.resolve(".")
        } = opts;
        if (device === "number") device = `emulator-${device}`;
        apk = path.resolve(cwd, apk);
        spawn(adb(), ["-s", device, "install", "-r", apk], opts);
      };
      adb.start = function start(device, apk, opts = {}) {
        const {
          activity = ".MainActivity",
          waitForDebugger = false
        } = opts;
        if (device === "number") device = `emulator-${device}`;
        const namespace = apkanalyzer.manifest(apk, "application-id", opts);
        const args = [
          "-s",
          device,
          "shell",
          "am",
          "start",
          "-n",
          `${namespace}/${activity}`,
          "-S"
        ];
        if (waitForDebugger) args.push("-D");
        spawn(adb(), args, opts);
      };
      adb.wait = function wait(device, opts = {}) {
        const {
          state = "device"
        } = opts;
        if (typeof device === "number") device = `emulator-${device}`;
        spawn(adb(), [
          "-s",
          device,
          `wait-for-${state}`,
          "shell",
          "while [[ -z $(getprop sys.boot_completed) ]]; do sleep 1; done"
        ], opts);
      };
      function name(device, opts = {}) {
        const {
          type = "emulator"
        } = opts;
        if (typeof device === "number") device = `emulator-${device}`;
        let name2;
        switch (type) {
          case "device":
            [name2] = exec(adb(), ["-s", device, "shell", "getprop", "ro.product.model"], opts).split(os.EOL);
            break;
          case "emulator":
            [name2] = exec(adb(), ["-s", device, "emu", "avd", "name"], opts).split(os.EOL);
        }
        return name2.trim();
      }
    }
  });

  // ../../node_modules/bare-dev/lib/android/shared/emulator.js
  var require_emulator = __commonJS({
    "../../node_modules/bare-dev/lib/android/shared/emulator.js"(exports, module) {
      var path = __require("path");
      var os = __require("os");
      var which = require_bare_which();
      var exec = require_exec();
      var spawn = require_spawn();
      var sdk = require_sdk();
      var adb = require_adb();
      var emulator = module.exports = function emulator2() {
        return which.sync("emulator", {
          path: path.join(sdk.path, "emulator")
        });
      };
      emulator.list = function list(opts) {
        return exec(emulator(), ["-list-avds"], opts).split(os.EOL).filter(Boolean);
      };
      emulator.launch = function launch(device, opts = {}) {
        const {
          port = 5554
        } = opts;
        spawn(emulator(), [`@${device}`, "-port", port], { ...opts, detached: true });
        adb.wait(port, opts);
        return `emulator-${port}`;
      };
    }
  });

  // ../../node_modules/bare-dev/lib/android/device/list.js
  var require_list = __commonJS({
    "../../node_modules/bare-dev/lib/android/device/list.js"(exports, module) {
      var process2 = __require("process");
      var adb = require_adb();
      var emulator = require_emulator();
      module.exports = function list(opts = {}) {
        const {
          separator = "\n",
          quiet = true
        } = opts;
        const devices = adb.devices(opts);
        for (const name of emulator.list(opts)) {
          if (devices.some((device) => device.name === name)) continue;
          devices.push({
            id: null,
            type: "emulator",
            name,
            state: "shutdown"
          });
        }
        if (!quiet) {
          let first = true;
          for (const device of devices) {
            let out = device.name;
            if (/^\s+$/.test(separator)) {
              out += separator;
            } else {
              first ? first = false : out = separator + out;
            }
            process2.stdout.write(out);
          }
        }
        return devices;
      };
    }
  });

  // ../../node_modules/bare-dev/lib/android/device/launch.js
  var require_launch = __commonJS({
    "../../node_modules/bare-dev/lib/android/device/launch.js"(exports, module) {
      var emulator = require_emulator();
      var list = require_list();
      module.exports = function launch(name = null, opts) {
        if (typeof name === "object" && name !== null) {
          opts = name;
          name = null;
        }
        const [device = null] = list().filter((candidate) => name ? candidate.name === name : true);
        if (device === null) {
          throw new Error(`launch() could not find device "${device}"`);
        }
        if (device.state !== "booted") {
          device.id = emulator.launch(device.name, opts);
        }
        return device.id;
      };
    }
  });

  // ../../node_modules/bare-dev/lib/android/device/remove.js
  var require_remove = __commonJS({
    "../../node_modules/bare-dev/lib/android/device/remove.js"(exports, module) {
      var avd = require_avd();
      module.exports = function remove(name, opts) {
        avd.manager.remove(name, opts);
      };
    }
  });

  // ../../node_modules/bare-dev/lib/android/device.js
  var require_device = __commonJS({
    "../../node_modules/bare-dev/lib/android/device.js"(exports) {
      exports.create = require_create();
      exports.launch = require_launch();
      exports.list = require_list();
      exports.remove = require_remove();
    }
  });

  // ../../node_modules/balanced-match/index.js
  var require_balanced_match = __commonJS({
    "../../node_modules/balanced-match/index.js"(exports, module) {
      "use strict";
      module.exports = balanced;
      function balanced(a, b, str) {
        if (a instanceof RegExp) a = maybeMatch(a, str);
        if (b instanceof RegExp) b = maybeMatch(b, str);
        var r = range(a, b, str);
        return r && {
          start: r[0],
          end: r[1],
          pre: str.slice(0, r[0]),
          body: str.slice(r[0] + a.length, r[1]),
          post: str.slice(r[1] + b.length)
        };
      }
      function maybeMatch(reg, str) {
        var m = str.match(reg);
        return m ? m[0] : null;
      }
      balanced.range = range;
      function range(a, b, str) {
        var begs, beg, left, right, result;
        var ai = str.indexOf(a);
        var bi = str.indexOf(b, ai + 1);
        var i = ai;
        if (ai >= 0 && bi > 0) {
          if (a === b) {
            return [ai, bi];
          }
          begs = [];
          left = str.length;
          while (i >= 0 && !result) {
            if (i == ai) {
              begs.push(i);
              ai = str.indexOf(a, i + 1);
            } else if (begs.length == 1) {
              result = [begs.pop(), bi];
            } else {
              beg = begs.pop();
              if (beg < left) {
                left = beg;
                right = bi;
              }
              bi = str.indexOf(b, i + 1);
            }
            i = ai < bi && ai >= 0 ? ai : bi;
          }
          if (begs.length) {
            result = [left, right];
          }
        }
        return result;
      }
    }
  });

  // ../../node_modules/brace-expansion/index.js
  var require_brace_expansion = __commonJS({
    "../../node_modules/brace-expansion/index.js"(exports, module) {
      var balanced = require_balanced_match();
      module.exports = expandTop;
      var escSlash = "\0SLASH" + Math.random() + "\0";
      var escOpen = "\0OPEN" + Math.random() + "\0";
      var escClose = "\0CLOSE" + Math.random() + "\0";
      var escComma = "\0COMMA" + Math.random() + "\0";
      var escPeriod = "\0PERIOD" + Math.random() + "\0";
      function numeric(str) {
        return parseInt(str, 10) == str ? parseInt(str, 10) : str.charCodeAt(0);
      }
      function escapeBraces(str) {
        return str.split("\\\\").join(escSlash).split("\\{").join(escOpen).split("\\}").join(escClose).split("\\,").join(escComma).split("\\.").join(escPeriod);
      }
      function unescapeBraces(str) {
        return str.split(escSlash).join("\\").split(escOpen).join("{").split(escClose).join("}").split(escComma).join(",").split(escPeriod).join(".");
      }
      function parseCommaParts(str) {
        if (!str)
          return [""];
        var parts = [];
        var m = balanced("{", "}", str);
        if (!m)
          return str.split(",");
        var pre = m.pre;
        var body = m.body;
        var post = m.post;
        var p = pre.split(",");
        p[p.length - 1] += "{" + body + "}";
        var postParts = parseCommaParts(post);
        if (post.length) {
          p[p.length - 1] += postParts.shift();
          p.push.apply(p, postParts);
        }
        parts.push.apply(parts, p);
        return parts;
      }
      function expandTop(str) {
        if (!str)
          return [];
        if (str.substr(0, 2) === "{}") {
          str = "\\{\\}" + str.substr(2);
        }
        return expand(escapeBraces(str), true).map(unescapeBraces);
      }
      function embrace(str) {
        return "{" + str + "}";
      }
      function isPadded(el) {
        return /^-?0\d/.test(el);
      }
      function lte(i, y) {
        return i <= y;
      }
      function gte(i, y) {
        return i >= y;
      }
      function expand(str, isTop) {
        var expansions = [];
        var m = balanced("{", "}", str);
        if (!m) return [str];
        var pre = m.pre;
        var post = m.post.length ? expand(m.post, false) : [""];
        if (/\$$/.test(m.pre)) {
          for (var k = 0; k < post.length; k++) {
            var expansion = pre + "{" + m.body + "}" + post[k];
            expansions.push(expansion);
          }
        } else {
          var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
          var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
          var isSequence = isNumericSequence || isAlphaSequence;
          var isOptions = m.body.indexOf(",") >= 0;
          if (!isSequence && !isOptions) {
            if (m.post.match(/,(?!,).*\}/)) {
              str = m.pre + "{" + m.body + escClose + m.post;
              return expand(str);
            }
            return [str];
          }
          var n;
          if (isSequence) {
            n = m.body.split(/\.\./);
          } else {
            n = parseCommaParts(m.body);
            if (n.length === 1) {
              n = expand(n[0], false).map(embrace);
              if (n.length === 1) {
                return post.map(function(p) {
                  return m.pre + n[0] + p;
                });
              }
            }
          }
          var N;
          if (isSequence) {
            var x = numeric(n[0]);
            var y = numeric(n[1]);
            var width = Math.max(n[0].length, n[1].length);
            var incr = n.length == 3 ? Math.max(Math.abs(numeric(n[2])), 1) : 1;
            var test = lte;
            var reverse = y < x;
            if (reverse) {
              incr *= -1;
              test = gte;
            }
            var pad = n.some(isPadded);
            N = [];
            for (var i = x; test(i, y); i += incr) {
              var c;
              if (isAlphaSequence) {
                c = String.fromCharCode(i);
                if (c === "\\")
                  c = "";
              } else {
                c = String(i);
                if (pad) {
                  var need = width - c.length;
                  if (need > 0) {
                    var z = new Array(need + 1).join("0");
                    if (i < 0)
                      c = "-" + z + c.slice(1);
                    else
                      c = z + c;
                  }
                }
              }
              N.push(c);
            }
          } else {
            N = [];
            for (var j = 0; j < n.length; j++) {
              N.push.apply(N, expand(n[j], false));
            }
          }
          for (var j = 0; j < N.length; j++) {
            for (var k = 0; k < post.length; k++) {
              var expansion = pre + N[j] + post[k];
              if (!isTop || isSequence || expansion)
                expansions.push(expansion);
            }
          }
        }
        return expansions;
      }
    }
  });

  // ../../node_modules/minimatch/dist/commonjs/assert-valid-pattern.js
  var require_assert_valid_pattern = __commonJS({
    "../../node_modules/minimatch/dist/commonjs/assert-valid-pattern.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.assertValidPattern = void 0;
      var MAX_PATTERN_LENGTH = 1024 * 64;
      var assertValidPattern = (pattern) => {
        if (typeof pattern !== "string") {
          throw new TypeError("invalid pattern");
        }
        if (pattern.length > MAX_PATTERN_LENGTH) {
          throw new TypeError("pattern is too long");
        }
      };
      exports.assertValidPattern = assertValidPattern;
    }
  });

  // ../../node_modules/minimatch/dist/commonjs/brace-expressions.js
  var require_brace_expressions = __commonJS({
    "../../node_modules/minimatch/dist/commonjs/brace-expressions.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.parseClass = void 0;
      var posixClasses = {
        "[:alnum:]": ["\\p{L}\\p{Nl}\\p{Nd}", true],
        "[:alpha:]": ["\\p{L}\\p{Nl}", true],
        "[:ascii:]": ["\\x00-\\x7f", false],
        "[:blank:]": ["\\p{Zs}\\t", true],
        "[:cntrl:]": ["\\p{Cc}", true],
        "[:digit:]": ["\\p{Nd}", true],
        "[:graph:]": ["\\p{Z}\\p{C}", true, true],
        "[:lower:]": ["\\p{Ll}", true],
        "[:print:]": ["\\p{C}", true],
        "[:punct:]": ["\\p{P}", true],
        "[:space:]": ["\\p{Z}\\t\\r\\n\\v\\f", true],
        "[:upper:]": ["\\p{Lu}", true],
        "[:word:]": ["\\p{L}\\p{Nl}\\p{Nd}\\p{Pc}", true],
        "[:xdigit:]": ["A-Fa-f0-9", false]
      };
      var braceEscape = (s) => s.replace(/[[\]\\-]/g, "\\$&");
      var regexpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
      var rangesToString = (ranges) => ranges.join("");
      var parseClass = (glob, position) => {
        const pos = position;
        if (glob.charAt(pos) !== "[") {
          throw new Error("not in a brace expression");
        }
        const ranges = [];
        const negs = [];
        let i = pos + 1;
        let sawStart = false;
        let uflag = false;
        let escaping = false;
        let negate = false;
        let endPos = pos;
        let rangeStart = "";
        WHILE: while (i < glob.length) {
          const c = glob.charAt(i);
          if ((c === "!" || c === "^") && i === pos + 1) {
            negate = true;
            i++;
            continue;
          }
          if (c === "]" && sawStart && !escaping) {
            endPos = i + 1;
            break;
          }
          sawStart = true;
          if (c === "\\") {
            if (!escaping) {
              escaping = true;
              i++;
              continue;
            }
          }
          if (c === "[" && !escaping) {
            for (const [cls, [unip, u, neg]] of Object.entries(posixClasses)) {
              if (glob.startsWith(cls, i)) {
                if (rangeStart) {
                  return ["$.", false, glob.length - pos, true];
                }
                i += cls.length;
                if (neg)
                  negs.push(unip);
                else
                  ranges.push(unip);
                uflag = uflag || u;
                continue WHILE;
              }
            }
          }
          escaping = false;
          if (rangeStart) {
            if (c > rangeStart) {
              ranges.push(braceEscape(rangeStart) + "-" + braceEscape(c));
            } else if (c === rangeStart) {
              ranges.push(braceEscape(c));
            }
            rangeStart = "";
            i++;
            continue;
          }
          if (glob.startsWith("-]", i + 1)) {
            ranges.push(braceEscape(c + "-"));
            i += 2;
            continue;
          }
          if (glob.startsWith("-", i + 1)) {
            rangeStart = c;
            i += 2;
            continue;
          }
          ranges.push(braceEscape(c));
          i++;
        }
        if (endPos < i) {
          return ["", false, 0, false];
        }
        if (!ranges.length && !negs.length) {
          return ["$.", false, glob.length - pos, true];
        }
        if (negs.length === 0 && ranges.length === 1 && /^\\?.$/.test(ranges[0]) && !negate) {
          const r = ranges[0].length === 2 ? ranges[0].slice(-1) : ranges[0];
          return [regexpEscape(r), false, endPos - pos, false];
        }
        const sranges = "[" + (negate ? "^" : "") + rangesToString(ranges) + "]";
        const snegs = "[" + (negate ? "" : "^") + rangesToString(negs) + "]";
        const comb = ranges.length && negs.length ? "(" + sranges + "|" + snegs + ")" : ranges.length ? sranges : snegs;
        return [comb, uflag, endPos - pos, true];
      };
      exports.parseClass = parseClass;
    }
  });

  // ../../node_modules/minimatch/dist/commonjs/unescape.js
  var require_unescape = __commonJS({
    "../../node_modules/minimatch/dist/commonjs/unescape.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.unescape = void 0;
      var unescape = (s, { windowsPathsNoEscape = false } = {}) => {
        return windowsPathsNoEscape ? s.replace(/\[([^\/\\])\]/g, "$1") : s.replace(/((?!\\).|^)\[([^\/\\])\]/g, "$1$2").replace(/\\([^\/])/g, "$1");
      };
      exports.unescape = unescape;
    }
  });

  // ../../node_modules/minimatch/dist/commonjs/ast.js
  var require_ast = __commonJS({
    "../../node_modules/minimatch/dist/commonjs/ast.js"(exports) {
      "use strict";
      var _a;
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.AST = void 0;
      var brace_expressions_js_1 = require_brace_expressions();
      var unescape_js_1 = require_unescape();
      var types = /* @__PURE__ */ new Set(["!", "?", "+", "*", "@"]);
      var isExtglobType = (c) => types.has(c);
      var isExtglobAST = (c) => isExtglobType(c.type);
      var adoptionMap = /* @__PURE__ */ new Map([
        ["!", ["@"]],
        ["?", ["?", "@"]],
        ["@", ["@"]],
        ["*", ["*", "+", "?", "@"]],
        ["+", ["+", "@"]]
      ]);
      var adoptionWithSpaceMap = /* @__PURE__ */ new Map([
        ["!", ["?"]],
        ["@", ["?"]],
        ["+", ["?", "*"]]
      ]);
      var adoptionAnyMap = /* @__PURE__ */ new Map([
        ["!", ["?", "@"]],
        ["?", ["?", "@"]],
        ["@", ["?", "@"]],
        ["*", ["*", "+", "?", "@"]],
        ["+", ["+", "@", "?", "*"]]
      ]);
      var usurpMap = /* @__PURE__ */ new Map([
        ["!", /* @__PURE__ */ new Map([["!", "@"]])],
        ["?", /* @__PURE__ */ new Map([["*", "*"], ["+", "*"]])],
        ["@", /* @__PURE__ */ new Map([["!", "!"], ["?", "?"], ["@", "@"], ["*", "*"], ["+", "+"]])],
        ["+", /* @__PURE__ */ new Map([["?", "*"], ["*", "*"]])]
      ]);
      var startNoTraversal = "(?!(?:^|/)\\.\\.?(?:$|/))";
      var startNoDot = "(?!\\.)";
      var addPatternStart = /* @__PURE__ */ new Set(["[", "."]);
      var justDots = /* @__PURE__ */ new Set(["..", "."]);
      var reSpecials = new Set("().*{}+?[]^$\\!");
      var regExpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
      var qmark = "[^/]";
      var star = qmark + "*?";
      var starNoEmpty = qmark + "+?";
      var AST = class {
        type;
        #root;
        #hasMagic;
        #uflag = false;
        #parts = [];
        #parent;
        #parentIndex;
        #negs;
        #filledNegs = false;
        #options;
        #toString;
        // set to true if it's an extglob with no children
        // (which really means one child of '')
        #emptyExt = false;
        constructor(type, parent, options = {}) {
          this.type = type;
          if (type)
            this.#hasMagic = true;
          this.#parent = parent;
          this.#root = this.#parent ? this.#parent.#root : this;
          this.#options = this.#root === this ? options : this.#root.#options;
          this.#negs = this.#root === this ? [] : this.#root.#negs;
          if (type === "!" && !this.#root.#filledNegs)
            this.#negs.push(this);
          this.#parentIndex = this.#parent ? this.#parent.#parts.length : 0;
        }
        get hasMagic() {
          if (this.#hasMagic !== void 0)
            return this.#hasMagic;
          for (const p of this.#parts) {
            if (typeof p === "string")
              continue;
            if (p.type || p.hasMagic)
              return this.#hasMagic = true;
          }
          return this.#hasMagic;
        }
        // reconstructs the pattern
        toString() {
          if (this.#toString !== void 0)
            return this.#toString;
          if (!this.type) {
            return this.#toString = this.#parts.map((p) => String(p)).join("");
          } else {
            return this.#toString = this.type + "(" + this.#parts.map((p) => String(p)).join("|") + ")";
          }
        }
        #fillNegs() {
          if (this !== this.#root)
            throw new Error("should only call on root");
          if (this.#filledNegs)
            return this;
          this.toString();
          this.#filledNegs = true;
          let n;
          while (n = this.#negs.pop()) {
            if (n.type !== "!")
              continue;
            let p = n;
            let pp = p.#parent;
            while (pp) {
              for (let i = p.#parentIndex + 1; !pp.type && i < pp.#parts.length; i++) {
                for (const part of n.#parts) {
                  if (typeof part === "string") {
                    throw new Error("string part in extglob AST??");
                  }
                  part.copyIn(pp.#parts[i]);
                }
              }
              p = pp;
              pp = p.#parent;
            }
          }
          return this;
        }
        push(...parts) {
          for (const p of parts) {
            if (p === "")
              continue;
            if (typeof p !== "string" && !(p instanceof _a && p.#parent === this)) {
              throw new Error("invalid part: " + p);
            }
            this.#parts.push(p);
          }
        }
        toJSON() {
          const ret = this.type === null ? this.#parts.slice().map((p) => typeof p === "string" ? p : p.toJSON()) : [this.type, ...this.#parts.map((p) => p.toJSON())];
          if (this.isStart() && !this.type)
            ret.unshift([]);
          if (this.isEnd() && (this === this.#root || this.#root.#filledNegs && this.#parent?.type === "!")) {
            ret.push({});
          }
          return ret;
        }
        isStart() {
          if (this.#root === this)
            return true;
          if (!this.#parent?.isStart())
            return false;
          if (this.#parentIndex === 0)
            return true;
          const p = this.#parent;
          for (let i = 0; i < this.#parentIndex; i++) {
            const pp = p.#parts[i];
            if (!(pp instanceof _a && pp.type === "!")) {
              return false;
            }
          }
          return true;
        }
        isEnd() {
          if (this.#root === this)
            return true;
          if (this.#parent?.type === "!")
            return true;
          if (!this.#parent?.isEnd())
            return false;
          if (!this.type)
            return this.#parent?.isEnd();
          const pl = this.#parent ? this.#parent.#parts.length : 0;
          return this.#parentIndex === pl - 1;
        }
        copyIn(part) {
          if (typeof part === "string")
            this.push(part);
          else
            this.push(part.clone(this));
        }
        clone(parent) {
          const c = new _a(this.type, parent);
          for (const p of this.#parts) {
            c.copyIn(p);
          }
          return c;
        }
        static #parseAST(str, ast, pos, opt, extDepth) {
          const maxDepth = opt.maxExtglobRecursion ?? 2;
          let escaping = false;
          let inBrace = false;
          let braceStart = -1;
          let braceNeg = false;
          if (ast.type === null) {
            let i2 = pos;
            let acc2 = "";
            while (i2 < str.length) {
              const c = str.charAt(i2++);
              if (escaping || c === "\\") {
                escaping = !escaping;
                acc2 += c;
                continue;
              }
              if (inBrace) {
                if (i2 === braceStart + 1) {
                  if (c === "^" || c === "!") {
                    braceNeg = true;
                  }
                } else if (c === "]" && !(i2 === braceStart + 2 && braceNeg)) {
                  inBrace = false;
                }
                acc2 += c;
                continue;
              } else if (c === "[") {
                inBrace = true;
                braceStart = i2;
                braceNeg = false;
                acc2 += c;
                continue;
              }
              const doRecurse = !opt.noext && isExtglobType(c) && str.charAt(i2) === "(" && extDepth <= maxDepth;
              if (doRecurse) {
                ast.push(acc2);
                acc2 = "";
                const ext = new _a(c, ast);
                i2 = _a.#parseAST(str, ext, i2, opt, extDepth + 1);
                ast.push(ext);
                continue;
              }
              acc2 += c;
            }
            ast.push(acc2);
            return i2;
          }
          let i = pos + 1;
          let part = new _a(null, ast);
          const parts = [];
          let acc = "";
          while (i < str.length) {
            const c = str.charAt(i++);
            if (escaping || c === "\\") {
              escaping = !escaping;
              acc += c;
              continue;
            }
            if (inBrace) {
              if (i === braceStart + 1) {
                if (c === "^" || c === "!") {
                  braceNeg = true;
                }
              } else if (c === "]" && !(i === braceStart + 2 && braceNeg)) {
                inBrace = false;
              }
              acc += c;
              continue;
            } else if (c === "[") {
              inBrace = true;
              braceStart = i;
              braceNeg = false;
              acc += c;
              continue;
            }
            const doRecurse = isExtglobType(c) && str.charAt(i) === "(" && /* c8 ignore start - the maxDepth is sufficient here */
            (extDepth <= maxDepth || ast && ast.#canAdoptType(c));
            if (doRecurse) {
              const depthAdd = ast && ast.#canAdoptType(c) ? 0 : 1;
              part.push(acc);
              acc = "";
              const ext = new _a(c, part);
              part.push(ext);
              i = _a.#parseAST(str, ext, i, opt, extDepth + depthAdd);
              continue;
            }
            if (c === "|") {
              part.push(acc);
              acc = "";
              parts.push(part);
              part = new _a(null, ast);
              continue;
            }
            if (c === ")") {
              if (acc === "" && ast.#parts.length === 0) {
                ast.#emptyExt = true;
              }
              part.push(acc);
              acc = "";
              ast.push(...parts, part);
              return i;
            }
            acc += c;
          }
          ast.type = null;
          ast.#hasMagic = void 0;
          ast.#parts = [str.substring(pos - 1)];
          return i;
        }
        #canAdoptWithSpace(child) {
          return this.#canAdopt(child, adoptionWithSpaceMap);
        }
        #canAdopt(child, map = adoptionMap) {
          if (!child || typeof child !== "object" || child.type !== null || child.#parts.length !== 1 || this.type === null) {
            return false;
          }
          const gc = child.#parts[0];
          if (!gc || typeof gc !== "object" || gc.type === null) {
            return false;
          }
          return this.#canAdoptType(gc.type, map);
        }
        #canAdoptType(c, map = adoptionAnyMap) {
          return !!map.get(this.type)?.includes(c);
        }
        #adoptWithSpace(child, index) {
          const gc = child.#parts[0];
          const blank = new _a(null, gc, this.options);
          blank.#parts.push("");
          gc.push(blank);
          this.#adopt(child, index);
        }
        #adopt(child, index) {
          const gc = child.#parts[0];
          this.#parts.splice(index, 1, ...gc.#parts);
          for (const p of gc.#parts) {
            if (typeof p === "object")
              p.#parent = this;
          }
          this.#toString = void 0;
        }
        #canUsurpType(c) {
          const m = usurpMap.get(this.type);
          return !!m?.has(c);
        }
        #canUsurp(child) {
          if (!child || typeof child !== "object" || child.type !== null || child.#parts.length !== 1 || this.type === null || this.#parts.length !== 1) {
            return false;
          }
          const gc = child.#parts[0];
          if (!gc || typeof gc !== "object" || gc.type === null) {
            return false;
          }
          return this.#canUsurpType(gc.type);
        }
        #usurp(child) {
          const m = usurpMap.get(this.type);
          const gc = child.#parts[0];
          const nt = m?.get(gc.type);
          if (!nt)
            return false;
          this.#parts = gc.#parts;
          for (const p of this.#parts) {
            if (typeof p === "object")
              p.#parent = this;
          }
          this.type = nt;
          this.#toString = void 0;
          this.#emptyExt = false;
        }
        #flatten() {
          if (!isExtglobAST(this)) {
            for (const p of this.#parts) {
              if (typeof p === "object")
                p.#flatten();
            }
          } else {
            let iterations = 0;
            let done = false;
            do {
              done = true;
              for (let i = 0; i < this.#parts.length; i++) {
                const c = this.#parts[i];
                if (typeof c === "object") {
                  c.#flatten();
                  if (this.#canAdopt(c)) {
                    done = false;
                    this.#adopt(c, i);
                  } else if (this.#canAdoptWithSpace(c)) {
                    done = false;
                    this.#adoptWithSpace(c, i);
                  } else if (this.#canUsurp(c)) {
                    done = false;
                    this.#usurp(c);
                  }
                }
              }
            } while (!done && ++iterations < 10);
          }
          this.#toString = void 0;
        }
        static fromGlob(pattern, options = {}) {
          const ast = new _a(null, void 0, options);
          _a.#parseAST(pattern, ast, 0, options, 0);
          return ast;
        }
        // returns the regular expression if there's magic, or the unescaped
        // string if not.
        toMMPattern() {
          if (this !== this.#root)
            return this.#root.toMMPattern();
          const glob = this.toString();
          const [re, body, hasMagic, uflag] = this.toRegExpSource();
          const anyMagic = hasMagic || this.#hasMagic || this.#options.nocase && !this.#options.nocaseMagicOnly && glob.toUpperCase() !== glob.toLowerCase();
          if (!anyMagic) {
            return body;
          }
          const flags = (this.#options.nocase ? "i" : "") + (uflag ? "u" : "");
          return Object.assign(new RegExp(`^${re}$`, flags), {
            _src: re,
            _glob: glob
          });
        }
        get options() {
          return this.#options;
        }
        // returns the string match, the regexp source, whether there's magic
        // in the regexp (so a regular expression is required) and whether or
        // not the uflag is needed for the regular expression (for posix classes)
        // NOTE: instead of injecting the start/end at this point, just return
        // the BODY of the regexp, along with the start/end portions suitable
        // for binding the start/end in either a joined full-path makeRe context
        // (where we bind to (^|/), or a standalone matchPart context (where
        // we bind to ^, and not /).  Otherwise slashes get duped!
        //
        // In part-matching mode, the start is:
        // - if not isStart: nothing
        // - if traversal possible, but not allowed: ^(?!\.\.?$)
        // - if dots allowed or not possible: ^
        // - if dots possible and not allowed: ^(?!\.)
        // end is:
        // - if not isEnd(): nothing
        // - else: $
        //
        // In full-path matching mode, we put the slash at the START of the
        // pattern, so start is:
        // - if first pattern: same as part-matching mode
        // - if not isStart(): nothing
        // - if traversal possible, but not allowed: /(?!\.\.?(?:$|/))
        // - if dots allowed or not possible: /
        // - if dots possible and not allowed: /(?!\.)
        // end is:
        // - if last pattern, same as part-matching mode
        // - else nothing
        //
        // Always put the (?:$|/) on negated tails, though, because that has to be
        // there to bind the end of the negated pattern portion, and it's easier to
        // just stick it in now rather than try to inject it later in the middle of
        // the pattern.
        //
        // We can just always return the same end, and leave it up to the caller
        // to know whether it's going to be used joined or in parts.
        // And, if the start is adjusted slightly, can do the same there:
        // - if not isStart: nothing
        // - if traversal possible, but not allowed: (?:/|^)(?!\.\.?$)
        // - if dots allowed or not possible: (?:/|^)
        // - if dots possible and not allowed: (?:/|^)(?!\.)
        //
        // But it's better to have a simpler binding without a conditional, for
        // performance, so probably better to return both start options.
        //
        // Then the caller just ignores the end if it's not the first pattern,
        // and the start always gets applied.
        //
        // But that's always going to be $ if it's the ending pattern, or nothing,
        // so the caller can just attach $ at the end of the pattern when building.
        //
        // So the next step is:
        // - better detect what kind of start is needed
        // - return both flavors of starting pattern
        // - attach $ at the end of the pattern when creating the actual RegExp
        //
        // Ah, but wait, no, that all only applies to the root when the first pattern
        // is not an extglob. If the first pattern IS an extglob, then we need all
        // that dot prevention biz to live in the extglob portions, because eg
        // +(*|.x*) can match .xy but not .yx.
        //
        // So, return the two flavors if it's #root and the first child is not an
        // AST, otherwise leave it to the child AST to handle it, and there,
        // use the (?:^|/) style of start binding.
        //
        // Even simplified further:
        // - Since the start for a join is eg /(?!\.) and the start for a part
        // is ^(?!\.), we can just prepend (?!\.) to the pattern (either root
        // or start or whatever) and prepend ^ or / at the Regexp construction.
        toRegExpSource(allowDot) {
          const dot = allowDot ?? !!this.#options.dot;
          if (this.#root === this) {
            this.#flatten();
            this.#fillNegs();
          }
          if (!isExtglobAST(this)) {
            const noEmpty = this.isStart() && this.isEnd();
            const src = this.#parts.map((p) => {
              const [re, _, hasMagic, uflag] = typeof p === "string" ? _a.#parseGlob(p, this.#hasMagic, noEmpty) : p.toRegExpSource(allowDot);
              this.#hasMagic = this.#hasMagic || hasMagic;
              this.#uflag = this.#uflag || uflag;
              return re;
            }).join("");
            let start2 = "";
            if (this.isStart()) {
              if (typeof this.#parts[0] === "string") {
                const dotTravAllowed = this.#parts.length === 1 && justDots.has(this.#parts[0]);
                if (!dotTravAllowed) {
                  const aps = addPatternStart;
                  const needNoTrav = (
                    // dots are allowed, and the pattern starts with [ or .
                    dot && aps.has(src.charAt(0)) || // the pattern starts with \., and then [ or .
                    src.startsWith("\\.") && aps.has(src.charAt(2)) || // the pattern starts with \.\., and then [ or .
                    src.startsWith("\\.\\.") && aps.has(src.charAt(4))
                  );
                  const needNoDot = !dot && !allowDot && aps.has(src.charAt(0));
                  start2 = needNoTrav ? startNoTraversal : needNoDot ? startNoDot : "";
                }
              }
            }
            let end = "";
            if (this.isEnd() && this.#root.#filledNegs && this.#parent?.type === "!") {
              end = "(?:$|\\/)";
            }
            const final2 = start2 + src + end;
            return [
              final2,
              (0, unescape_js_1.unescape)(src),
              this.#hasMagic = !!this.#hasMagic,
              this.#uflag
            ];
          }
          const repeated = this.type === "*" || this.type === "+";
          const start = this.type === "!" ? "(?:(?!(?:" : "(?:";
          let body = this.#partsToRegExp(dot);
          if (this.isStart() && this.isEnd() && !body && this.type !== "!") {
            const s = this.toString();
            const me = this;
            me.#parts = [s];
            me.type = null;
            me.#hasMagic = void 0;
            return [s, (0, unescape_js_1.unescape)(this.toString()), false, false];
          }
          let bodyDotAllowed = !repeated || allowDot || dot || !startNoDot ? "" : this.#partsToRegExp(true);
          if (bodyDotAllowed === body) {
            bodyDotAllowed = "";
          }
          if (bodyDotAllowed) {
            body = `(?:${body})(?:${bodyDotAllowed})*?`;
          }
          let final = "";
          if (this.type === "!" && this.#emptyExt) {
            final = (this.isStart() && !dot ? startNoDot : "") + starNoEmpty;
          } else {
            const close = this.type === "!" ? (
              // !() must match something,but !(x) can match ''
              "))" + (this.isStart() && !dot && !allowDot ? startNoDot : "") + star + ")"
            ) : this.type === "@" ? ")" : this.type === "?" ? ")?" : this.type === "+" && bodyDotAllowed ? ")" : this.type === "*" && bodyDotAllowed ? `)?` : `)${this.type}`;
            final = start + body + close;
          }
          return [
            final,
            (0, unescape_js_1.unescape)(body),
            this.#hasMagic = !!this.#hasMagic,
            this.#uflag
          ];
        }
        #partsToRegExp(dot) {
          return this.#parts.map((p) => {
            if (typeof p === "string") {
              throw new Error("string type in extglob ast??");
            }
            const [re, _, _hasMagic, uflag] = p.toRegExpSource(dot);
            this.#uflag = this.#uflag || uflag;
            return re;
          }).filter((p) => !(this.isStart() && this.isEnd()) || !!p).join("|");
        }
        static #parseGlob(glob, hasMagic, noEmpty = false) {
          let escaping = false;
          let re = "";
          let uflag = false;
          let inStar = false;
          for (let i = 0; i < glob.length; i++) {
            const c = glob.charAt(i);
            if (escaping) {
              escaping = false;
              re += (reSpecials.has(c) ? "\\" : "") + c;
              inStar = false;
              continue;
            }
            if (c === "\\") {
              if (i === glob.length - 1) {
                re += "\\\\";
              } else {
                escaping = true;
              }
              continue;
            }
            if (c === "[") {
              const [src, needUflag, consumed, magic] = (0, brace_expressions_js_1.parseClass)(glob, i);
              if (consumed) {
                re += src;
                uflag = uflag || needUflag;
                i += consumed - 1;
                hasMagic = hasMagic || magic;
                inStar = false;
                continue;
              }
            }
            if (c === "*") {
              if (inStar)
                continue;
              inStar = true;
              re += noEmpty && /^[*]+$/.test(glob) ? starNoEmpty : star;
              hasMagic = true;
              continue;
            } else {
              inStar = false;
            }
            if (c === "?") {
              re += qmark;
              hasMagic = true;
              continue;
            }
            re += regExpEscape(c);
          }
          return [re, (0, unescape_js_1.unescape)(glob), !!hasMagic, uflag];
        }
      };
      exports.AST = AST;
      _a = AST;
    }
  });

  // ../../node_modules/minimatch/dist/commonjs/escape.js
  var require_escape = __commonJS({
    "../../node_modules/minimatch/dist/commonjs/escape.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.escape = void 0;
      var escape = (s, { windowsPathsNoEscape = false } = {}) => {
        return windowsPathsNoEscape ? s.replace(/[?*()[\]]/g, "[$&]") : s.replace(/[?*()[\]\\]/g, "\\$&");
      };
      exports.escape = escape;
    }
  });

  // ../../node_modules/minimatch/dist/commonjs/index.js
  var require_commonjs = __commonJS({
    "../../node_modules/minimatch/dist/commonjs/index.js"(exports) {
      "use strict";
      var __importDefault = exports && exports.__importDefault || function(mod) {
        return mod && mod.__esModule ? mod : { "default": mod };
      };
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.unescape = exports.escape = exports.AST = exports.Minimatch = exports.match = exports.makeRe = exports.braceExpand = exports.defaults = exports.filter = exports.GLOBSTAR = exports.sep = exports.minimatch = void 0;
      var brace_expansion_1 = __importDefault(require_brace_expansion());
      var assert_valid_pattern_js_1 = require_assert_valid_pattern();
      var ast_js_1 = require_ast();
      var escape_js_1 = require_escape();
      var unescape_js_1 = require_unescape();
      var minimatch = (p, pattern, options = {}) => {
        (0, assert_valid_pattern_js_1.assertValidPattern)(pattern);
        if (!options.nocomment && pattern.charAt(0) === "#") {
          return false;
        }
        return new Minimatch(pattern, options).match(p);
      };
      exports.minimatch = minimatch;
      var starDotExtRE = /^\*+([^+@!?\*\[\(]*)$/;
      var starDotExtTest = (ext2) => (f) => !f.startsWith(".") && f.endsWith(ext2);
      var starDotExtTestDot = (ext2) => (f) => f.endsWith(ext2);
      var starDotExtTestNocase = (ext2) => {
        ext2 = ext2.toLowerCase();
        return (f) => !f.startsWith(".") && f.toLowerCase().endsWith(ext2);
      };
      var starDotExtTestNocaseDot = (ext2) => {
        ext2 = ext2.toLowerCase();
        return (f) => f.toLowerCase().endsWith(ext2);
      };
      var starDotStarRE = /^\*+\.\*+$/;
      var starDotStarTest = (f) => !f.startsWith(".") && f.includes(".");
      var starDotStarTestDot = (f) => f !== "." && f !== ".." && f.includes(".");
      var dotStarRE = /^\.\*+$/;
      var dotStarTest = (f) => f !== "." && f !== ".." && f.startsWith(".");
      var starRE = /^\*+$/;
      var starTest = (f) => f.length !== 0 && !f.startsWith(".");
      var starTestDot = (f) => f.length !== 0 && f !== "." && f !== "..";
      var qmarksRE = /^\?+([^+@!?\*\[\(]*)?$/;
      var qmarksTestNocase = ([$0, ext2 = ""]) => {
        const noext = qmarksTestNoExt([$0]);
        if (!ext2)
          return noext;
        ext2 = ext2.toLowerCase();
        return (f) => noext(f) && f.toLowerCase().endsWith(ext2);
      };
      var qmarksTestNocaseDot = ([$0, ext2 = ""]) => {
        const noext = qmarksTestNoExtDot([$0]);
        if (!ext2)
          return noext;
        ext2 = ext2.toLowerCase();
        return (f) => noext(f) && f.toLowerCase().endsWith(ext2);
      };
      var qmarksTestDot = ([$0, ext2 = ""]) => {
        const noext = qmarksTestNoExtDot([$0]);
        return !ext2 ? noext : (f) => noext(f) && f.endsWith(ext2);
      };
      var qmarksTest = ([$0, ext2 = ""]) => {
        const noext = qmarksTestNoExt([$0]);
        return !ext2 ? noext : (f) => noext(f) && f.endsWith(ext2);
      };
      var qmarksTestNoExt = ([$0]) => {
        const len = $0.length;
        return (f) => f.length === len && !f.startsWith(".");
      };
      var qmarksTestNoExtDot = ([$0]) => {
        const len = $0.length;
        return (f) => f.length === len && f !== "." && f !== "..";
      };
      var defaultPlatform = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
      var path = {
        win32: { sep: "\\" },
        posix: { sep: "/" }
      };
      exports.sep = defaultPlatform === "win32" ? path.win32.sep : path.posix.sep;
      exports.minimatch.sep = exports.sep;
      exports.GLOBSTAR = Symbol("globstar **");
      exports.minimatch.GLOBSTAR = exports.GLOBSTAR;
      var qmark = "[^/]";
      var star = qmark + "*?";
      var twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
      var twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?";
      var filter = (pattern, options = {}) => (p) => (0, exports.minimatch)(p, pattern, options);
      exports.filter = filter;
      exports.minimatch.filter = exports.filter;
      var ext = (a, b = {}) => Object.assign({}, a, b);
      var defaults = (def) => {
        if (!def || typeof def !== "object" || !Object.keys(def).length) {
          return exports.minimatch;
        }
        const orig = exports.minimatch;
        const m = (p, pattern, options = {}) => orig(p, pattern, ext(def, options));
        return Object.assign(m, {
          Minimatch: class Minimatch extends orig.Minimatch {
            constructor(pattern, options = {}) {
              super(pattern, ext(def, options));
            }
            static defaults(options) {
              return orig.defaults(ext(def, options)).Minimatch;
            }
          },
          AST: class AST extends orig.AST {
            /* c8 ignore start */
            constructor(type, parent, options = {}) {
              super(type, parent, ext(def, options));
            }
            /* c8 ignore stop */
            static fromGlob(pattern, options = {}) {
              return orig.AST.fromGlob(pattern, ext(def, options));
            }
          },
          unescape: (s, options = {}) => orig.unescape(s, ext(def, options)),
          escape: (s, options = {}) => orig.escape(s, ext(def, options)),
          filter: (pattern, options = {}) => orig.filter(pattern, ext(def, options)),
          defaults: (options) => orig.defaults(ext(def, options)),
          makeRe: (pattern, options = {}) => orig.makeRe(pattern, ext(def, options)),
          braceExpand: (pattern, options = {}) => orig.braceExpand(pattern, ext(def, options)),
          match: (list, pattern, options = {}) => orig.match(list, pattern, ext(def, options)),
          sep: orig.sep,
          GLOBSTAR: exports.GLOBSTAR
        });
      };
      exports.defaults = defaults;
      exports.minimatch.defaults = exports.defaults;
      var braceExpand = (pattern, options = {}) => {
        (0, assert_valid_pattern_js_1.assertValidPattern)(pattern);
        if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
          return [pattern];
        }
        return (0, brace_expansion_1.default)(pattern);
      };
      exports.braceExpand = braceExpand;
      exports.minimatch.braceExpand = exports.braceExpand;
      var makeRe = (pattern, options = {}) => new Minimatch(pattern, options).makeRe();
      exports.makeRe = makeRe;
      exports.minimatch.makeRe = exports.makeRe;
      var match = (list, pattern, options = {}) => {
        const mm = new Minimatch(pattern, options);
        list = list.filter((f) => mm.match(f));
        if (mm.options.nonull && !list.length) {
          list.push(pattern);
        }
        return list;
      };
      exports.match = match;
      exports.minimatch.match = exports.match;
      var globMagic = /[?*]|[+@!]\(.*?\)|\[|\]/;
      var regExpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
      var Minimatch = class {
        options;
        set;
        pattern;
        windowsPathsNoEscape;
        nonegate;
        negate;
        comment;
        empty;
        preserveMultipleSlashes;
        partial;
        globSet;
        globParts;
        nocase;
        isWindows;
        platform;
        windowsNoMagicRoot;
        maxGlobstarRecursion;
        regexp;
        constructor(pattern, options = {}) {
          (0, assert_valid_pattern_js_1.assertValidPattern)(pattern);
          options = options || {};
          this.options = options;
          this.maxGlobstarRecursion = options.maxGlobstarRecursion ?? 200;
          this.pattern = pattern;
          this.platform = options.platform || defaultPlatform;
          this.isWindows = this.platform === "win32";
          this.windowsPathsNoEscape = !!options.windowsPathsNoEscape || options.allowWindowsEscape === false;
          if (this.windowsPathsNoEscape) {
            this.pattern = this.pattern.replace(/\\/g, "/");
          }
          this.preserveMultipleSlashes = !!options.preserveMultipleSlashes;
          this.regexp = null;
          this.negate = false;
          this.nonegate = !!options.nonegate;
          this.comment = false;
          this.empty = false;
          this.partial = !!options.partial;
          this.nocase = !!this.options.nocase;
          this.windowsNoMagicRoot = options.windowsNoMagicRoot !== void 0 ? options.windowsNoMagicRoot : !!(this.isWindows && this.nocase);
          this.globSet = [];
          this.globParts = [];
          this.set = [];
          this.make();
        }
        hasMagic() {
          if (this.options.magicalBraces && this.set.length > 1) {
            return true;
          }
          for (const pattern of this.set) {
            for (const part of pattern) {
              if (typeof part !== "string")
                return true;
            }
          }
          return false;
        }
        debug(..._) {
        }
        make() {
          const pattern = this.pattern;
          const options = this.options;
          if (!options.nocomment && pattern.charAt(0) === "#") {
            this.comment = true;
            return;
          }
          if (!pattern) {
            this.empty = true;
            return;
          }
          this.parseNegate();
          this.globSet = [...new Set(this.braceExpand())];
          if (options.debug) {
            this.debug = (...args) => console.error(...args);
          }
          this.debug(this.pattern, this.globSet);
          const rawGlobParts = this.globSet.map((s) => this.slashSplit(s));
          this.globParts = this.preprocess(rawGlobParts);
          this.debug(this.pattern, this.globParts);
          let set = this.globParts.map((s, _, __) => {
            if (this.isWindows && this.windowsNoMagicRoot) {
              const isUNC = s[0] === "" && s[1] === "" && (s[2] === "?" || !globMagic.test(s[2])) && !globMagic.test(s[3]);
              const isDrive = /^[a-z]:/i.test(s[0]);
              if (isUNC) {
                return [...s.slice(0, 4), ...s.slice(4).map((ss) => this.parse(ss))];
              } else if (isDrive) {
                return [s[0], ...s.slice(1).map((ss) => this.parse(ss))];
              }
            }
            return s.map((ss) => this.parse(ss));
          });
          this.debug(this.pattern, set);
          this.set = set.filter((s) => s.indexOf(false) === -1);
          if (this.isWindows) {
            for (let i = 0; i < this.set.length; i++) {
              const p = this.set[i];
              if (p[0] === "" && p[1] === "" && this.globParts[i][2] === "?" && typeof p[3] === "string" && /^[a-z]:$/i.test(p[3])) {
                p[2] = "?";
              }
            }
          }
          this.debug(this.pattern, this.set);
        }
        // various transforms to equivalent pattern sets that are
        // faster to process in a filesystem walk.  The goal is to
        // eliminate what we can, and push all ** patterns as far
        // to the right as possible, even if it increases the number
        // of patterns that we have to process.
        preprocess(globParts) {
          if (this.options.noglobstar) {
            for (let i = 0; i < globParts.length; i++) {
              for (let j = 0; j < globParts[i].length; j++) {
                if (globParts[i][j] === "**") {
                  globParts[i][j] = "*";
                }
              }
            }
          }
          const { optimizationLevel = 1 } = this.options;
          if (optimizationLevel >= 2) {
            globParts = this.firstPhasePreProcess(globParts);
            globParts = this.secondPhasePreProcess(globParts);
          } else if (optimizationLevel >= 1) {
            globParts = this.levelOneOptimize(globParts);
          } else {
            globParts = this.adjascentGlobstarOptimize(globParts);
          }
          return globParts;
        }
        // just get rid of adjascent ** portions
        adjascentGlobstarOptimize(globParts) {
          return globParts.map((parts) => {
            let gs = -1;
            while (-1 !== (gs = parts.indexOf("**", gs + 1))) {
              let i = gs;
              while (parts[i + 1] === "**") {
                i++;
              }
              if (i !== gs) {
                parts.splice(gs, i - gs);
              }
            }
            return parts;
          });
        }
        // get rid of adjascent ** and resolve .. portions
        levelOneOptimize(globParts) {
          return globParts.map((parts) => {
            parts = parts.reduce((set, part) => {
              const prev = set[set.length - 1];
              if (part === "**" && prev === "**") {
                return set;
              }
              if (part === "..") {
                if (prev && prev !== ".." && prev !== "." && prev !== "**") {
                  set.pop();
                  return set;
                }
              }
              set.push(part);
              return set;
            }, []);
            return parts.length === 0 ? [""] : parts;
          });
        }
        levelTwoFileOptimize(parts) {
          if (!Array.isArray(parts)) {
            parts = this.slashSplit(parts);
          }
          let didSomething = false;
          do {
            didSomething = false;
            if (!this.preserveMultipleSlashes) {
              for (let i = 1; i < parts.length - 1; i++) {
                const p = parts[i];
                if (i === 1 && p === "" && parts[0] === "")
                  continue;
                if (p === "." || p === "") {
                  didSomething = true;
                  parts.splice(i, 1);
                  i--;
                }
              }
              if (parts[0] === "." && parts.length === 2 && (parts[1] === "." || parts[1] === "")) {
                didSomething = true;
                parts.pop();
              }
            }
            let dd = 0;
            while (-1 !== (dd = parts.indexOf("..", dd + 1))) {
              const p = parts[dd - 1];
              if (p && p !== "." && p !== ".." && p !== "**") {
                didSomething = true;
                parts.splice(dd - 1, 2);
                dd -= 2;
              }
            }
          } while (didSomething);
          return parts.length === 0 ? [""] : parts;
        }
        // First phase: single-pattern processing
        // <pre> is 1 or more portions
        // <rest> is 1 or more portions
        // <p> is any portion other than ., .., '', or **
        // <e> is . or ''
        //
        // **/.. is *brutal* for filesystem walking performance, because
        // it effectively resets the recursive walk each time it occurs,
        // and ** cannot be reduced out by a .. pattern part like a regexp
        // or most strings (other than .., ., and '') can be.
        //
        // <pre>/**/../<p>/<p>/<rest> -> {<pre>/../<p>/<p>/<rest>,<pre>/**/<p>/<p>/<rest>}
        // <pre>/<e>/<rest> -> <pre>/<rest>
        // <pre>/<p>/../<rest> -> <pre>/<rest>
        // **/**/<rest> -> **/<rest>
        //
        // **/*/<rest> -> */**/<rest> <== not valid because ** doesn't follow
        // this WOULD be allowed if ** did follow symlinks, or * didn't
        firstPhasePreProcess(globParts) {
          let didSomething = false;
          do {
            didSomething = false;
            for (let parts of globParts) {
              let gs = -1;
              while (-1 !== (gs = parts.indexOf("**", gs + 1))) {
                let gss = gs;
                while (parts[gss + 1] === "**") {
                  gss++;
                }
                if (gss > gs) {
                  parts.splice(gs + 1, gss - gs);
                }
                let next = parts[gs + 1];
                const p = parts[gs + 2];
                const p2 = parts[gs + 3];
                if (next !== "..")
                  continue;
                if (!p || p === "." || p === ".." || !p2 || p2 === "." || p2 === "..") {
                  continue;
                }
                didSomething = true;
                parts.splice(gs, 1);
                const other = parts.slice(0);
                other[gs] = "**";
                globParts.push(other);
                gs--;
              }
              if (!this.preserveMultipleSlashes) {
                for (let i = 1; i < parts.length - 1; i++) {
                  const p = parts[i];
                  if (i === 1 && p === "" && parts[0] === "")
                    continue;
                  if (p === "." || p === "") {
                    didSomething = true;
                    parts.splice(i, 1);
                    i--;
                  }
                }
                if (parts[0] === "." && parts.length === 2 && (parts[1] === "." || parts[1] === "")) {
                  didSomething = true;
                  parts.pop();
                }
              }
              let dd = 0;
              while (-1 !== (dd = parts.indexOf("..", dd + 1))) {
                const p = parts[dd - 1];
                if (p && p !== "." && p !== ".." && p !== "**") {
                  didSomething = true;
                  const needDot = dd === 1 && parts[dd + 1] === "**";
                  const splin = needDot ? ["."] : [];
                  parts.splice(dd - 1, 2, ...splin);
                  if (parts.length === 0)
                    parts.push("");
                  dd -= 2;
                }
              }
            }
          } while (didSomething);
          return globParts;
        }
        // second phase: multi-pattern dedupes
        // {<pre>/*/<rest>,<pre>/<p>/<rest>} -> <pre>/*/<rest>
        // {<pre>/<rest>,<pre>/<rest>} -> <pre>/<rest>
        // {<pre>/**/<rest>,<pre>/<rest>} -> <pre>/**/<rest>
        //
        // {<pre>/**/<rest>,<pre>/**/<p>/<rest>} -> <pre>/**/<rest>
        // ^-- not valid because ** doens't follow symlinks
        secondPhasePreProcess(globParts) {
          for (let i = 0; i < globParts.length - 1; i++) {
            for (let j = i + 1; j < globParts.length; j++) {
              const matched = this.partsMatch(globParts[i], globParts[j], !this.preserveMultipleSlashes);
              if (matched) {
                globParts[i] = [];
                globParts[j] = matched;
                break;
              }
            }
          }
          return globParts.filter((gs) => gs.length);
        }
        partsMatch(a, b, emptyGSMatch = false) {
          let ai = 0;
          let bi = 0;
          let result = [];
          let which = "";
          while (ai < a.length && bi < b.length) {
            if (a[ai] === b[bi]) {
              result.push(which === "b" ? b[bi] : a[ai]);
              ai++;
              bi++;
            } else if (emptyGSMatch && a[ai] === "**" && b[bi] === a[ai + 1]) {
              result.push(a[ai]);
              ai++;
            } else if (emptyGSMatch && b[bi] === "**" && a[ai] === b[bi + 1]) {
              result.push(b[bi]);
              bi++;
            } else if (a[ai] === "*" && b[bi] && (this.options.dot || !b[bi].startsWith(".")) && b[bi] !== "**") {
              if (which === "b")
                return false;
              which = "a";
              result.push(a[ai]);
              ai++;
              bi++;
            } else if (b[bi] === "*" && a[ai] && (this.options.dot || !a[ai].startsWith(".")) && a[ai] !== "**") {
              if (which === "a")
                return false;
              which = "b";
              result.push(b[bi]);
              ai++;
              bi++;
            } else {
              return false;
            }
          }
          return a.length === b.length && result;
        }
        parseNegate() {
          if (this.nonegate)
            return;
          const pattern = this.pattern;
          let negate = false;
          let negateOffset = 0;
          for (let i = 0; i < pattern.length && pattern.charAt(i) === "!"; i++) {
            negate = !negate;
            negateOffset++;
          }
          if (negateOffset)
            this.pattern = pattern.slice(negateOffset);
          this.negate = negate;
        }
        // set partial to true to test if, for example,
        // "/a/b" matches the start of "/*/b/*/d"
        // Partial means, if you run out of file before you run
        // out of pattern, then that's fine, as long as all
        // the parts match.
        matchOne(file, pattern, partial = false) {
          let fileStartIndex = 0;
          let patternStartIndex = 0;
          if (this.isWindows) {
            const fileDrive = typeof file[0] === "string" && /^[a-z]:$/i.test(file[0]);
            const fileUNC = !fileDrive && file[0] === "" && file[1] === "" && file[2] === "?" && /^[a-z]:$/i.test(file[3]);
            const patternDrive = typeof pattern[0] === "string" && /^[a-z]:$/i.test(pattern[0]);
            const patternUNC = !patternDrive && pattern[0] === "" && pattern[1] === "" && pattern[2] === "?" && typeof pattern[3] === "string" && /^[a-z]:$/i.test(pattern[3]);
            const fdi = fileUNC ? 3 : fileDrive ? 0 : void 0;
            const pdi = patternUNC ? 3 : patternDrive ? 0 : void 0;
            if (typeof fdi === "number" && typeof pdi === "number") {
              const [fd, pd] = [
                file[fdi],
                pattern[pdi]
              ];
              if (fd.toLowerCase() === pd.toLowerCase()) {
                pattern[pdi] = fd;
                patternStartIndex = pdi;
                fileStartIndex = fdi;
              }
            }
          }
          const { optimizationLevel = 1 } = this.options;
          if (optimizationLevel >= 2) {
            file = this.levelTwoFileOptimize(file);
          }
          if (pattern.includes(exports.GLOBSTAR)) {
            return this.#matchGlobstar(file, pattern, partial, fileStartIndex, patternStartIndex);
          }
          return this.#matchOne(file, pattern, partial, fileStartIndex, patternStartIndex);
        }
        #matchGlobstar(file, pattern, partial, fileIndex, patternIndex) {
          const firstgs = pattern.indexOf(exports.GLOBSTAR, patternIndex);
          const lastgs = pattern.lastIndexOf(exports.GLOBSTAR);
          const [head, body, tail] = partial ? [
            pattern.slice(patternIndex, firstgs),
            pattern.slice(firstgs + 1),
            []
          ] : [
            pattern.slice(patternIndex, firstgs),
            pattern.slice(firstgs + 1, lastgs),
            pattern.slice(lastgs + 1)
          ];
          if (head.length) {
            const fileHead = file.slice(fileIndex, fileIndex + head.length);
            if (!this.#matchOne(fileHead, head, partial, 0, 0))
              return false;
            fileIndex += head.length;
          }
          let fileTailMatch = 0;
          if (tail.length) {
            if (tail.length + fileIndex > file.length)
              return false;
            let tailStart = file.length - tail.length;
            if (this.#matchOne(file, tail, partial, tailStart, 0)) {
              fileTailMatch = tail.length;
            } else {
              if (file[file.length - 1] !== "" || fileIndex + tail.length === file.length) {
                return false;
              }
              tailStart--;
              if (!this.#matchOne(file, tail, partial, tailStart, 0))
                return false;
              fileTailMatch = tail.length + 1;
            }
          }
          if (!body.length) {
            let sawSome = !!fileTailMatch;
            for (let i2 = fileIndex; i2 < file.length - fileTailMatch; i2++) {
              const f = String(file[i2]);
              sawSome = true;
              if (f === "." || f === ".." || !this.options.dot && f.startsWith(".")) {
                return false;
              }
            }
            return partial || sawSome;
          }
          const bodySegments = [[[], 0]];
          let currentBody = bodySegments[0];
          let nonGsParts = 0;
          const nonGsPartsSums = [0];
          for (const b of body) {
            if (b === exports.GLOBSTAR) {
              nonGsPartsSums.push(nonGsParts);
              currentBody = [[], 0];
              bodySegments.push(currentBody);
            } else {
              currentBody[0].push(b);
              nonGsParts++;
            }
          }
          let i = bodySegments.length - 1;
          const fileLength = file.length - fileTailMatch;
          for (const b of bodySegments) {
            b[1] = fileLength - (nonGsPartsSums[i--] + b[0].length);
          }
          return !!this.#matchGlobStarBodySections(file, bodySegments, fileIndex, 0, partial, 0, !!fileTailMatch);
        }
        #matchGlobStarBodySections(file, bodySegments, fileIndex, bodyIndex, partial, globStarDepth, sawTail) {
          const bs = bodySegments[bodyIndex];
          if (!bs) {
            for (let i = fileIndex; i < file.length; i++) {
              sawTail = true;
              const f = file[i];
              if (f === "." || f === ".." || !this.options.dot && f.startsWith(".")) {
                return false;
              }
            }
            return sawTail;
          }
          const [body, after] = bs;
          while (fileIndex <= after) {
            const m = this.#matchOne(file.slice(0, fileIndex + body.length), body, partial, fileIndex, 0);
            if (m && globStarDepth < this.maxGlobstarRecursion) {
              const sub = this.#matchGlobStarBodySections(file, bodySegments, fileIndex + body.length, bodyIndex + 1, partial, globStarDepth + 1, sawTail);
              if (sub !== false)
                return sub;
            }
            const f = file[fileIndex];
            if (f === "." || f === ".." || !this.options.dot && f.startsWith(".")) {
              return false;
            }
            fileIndex++;
          }
          return partial || null;
        }
        #matchOne(file, pattern, partial, fileIndex, patternIndex) {
          let fi;
          let pi;
          let pl;
          let fl;
          for (fi = fileIndex, pi = patternIndex, fl = file.length, pl = pattern.length; fi < fl && pi < pl; fi++, pi++) {
            this.debug("matchOne loop");
            let p = pattern[pi];
            let f = file[fi];
            this.debug(pattern, p, f);
            if (p === false || p === exports.GLOBSTAR)
              return false;
            let hit;
            if (typeof p === "string") {
              hit = f === p;
              this.debug("string match", p, f, hit);
            } else {
              hit = p.test(f);
              this.debug("pattern match", p, f, hit);
            }
            if (!hit)
              return false;
          }
          if (fi === fl && pi === pl) {
            return true;
          } else if (fi === fl) {
            return partial;
          } else if (pi === pl) {
            return fi === fl - 1 && file[fi] === "";
          } else {
            throw new Error("wtf?");
          }
        }
        braceExpand() {
          return (0, exports.braceExpand)(this.pattern, this.options);
        }
        parse(pattern) {
          (0, assert_valid_pattern_js_1.assertValidPattern)(pattern);
          const options = this.options;
          if (pattern === "**")
            return exports.GLOBSTAR;
          if (pattern === "")
            return "";
          let m;
          let fastTest = null;
          if (m = pattern.match(starRE)) {
            fastTest = options.dot ? starTestDot : starTest;
          } else if (m = pattern.match(starDotExtRE)) {
            fastTest = (options.nocase ? options.dot ? starDotExtTestNocaseDot : starDotExtTestNocase : options.dot ? starDotExtTestDot : starDotExtTest)(m[1]);
          } else if (m = pattern.match(qmarksRE)) {
            fastTest = (options.nocase ? options.dot ? qmarksTestNocaseDot : qmarksTestNocase : options.dot ? qmarksTestDot : qmarksTest)(m);
          } else if (m = pattern.match(starDotStarRE)) {
            fastTest = options.dot ? starDotStarTestDot : starDotStarTest;
          } else if (m = pattern.match(dotStarRE)) {
            fastTest = dotStarTest;
          }
          const re = ast_js_1.AST.fromGlob(pattern, this.options).toMMPattern();
          if (fastTest && typeof re === "object") {
            Reflect.defineProperty(re, "test", { value: fastTest });
          }
          return re;
        }
        makeRe() {
          if (this.regexp || this.regexp === false)
            return this.regexp;
          const set = this.set;
          if (!set.length) {
            this.regexp = false;
            return this.regexp;
          }
          const options = this.options;
          const twoStar = options.noglobstar ? star : options.dot ? twoStarDot : twoStarNoDot;
          const flags = new Set(options.nocase ? ["i"] : []);
          let re = set.map((pattern) => {
            const pp = pattern.map((p) => {
              if (p instanceof RegExp) {
                for (const f of p.flags.split(""))
                  flags.add(f);
              }
              return typeof p === "string" ? regExpEscape(p) : p === exports.GLOBSTAR ? exports.GLOBSTAR : p._src;
            });
            pp.forEach((p, i) => {
              const next = pp[i + 1];
              const prev = pp[i - 1];
              if (p !== exports.GLOBSTAR || prev === exports.GLOBSTAR) {
                return;
              }
              if (prev === void 0) {
                if (next !== void 0 && next !== exports.GLOBSTAR) {
                  pp[i + 1] = "(?:\\/|" + twoStar + "\\/)?" + next;
                } else {
                  pp[i] = twoStar;
                }
              } else if (next === void 0) {
                pp[i - 1] = prev + "(?:\\/|" + twoStar + ")?";
              } else if (next !== exports.GLOBSTAR) {
                pp[i - 1] = prev + "(?:\\/|\\/" + twoStar + "\\/)" + next;
                pp[i + 1] = exports.GLOBSTAR;
              }
            });
            return pp.filter((p) => p !== exports.GLOBSTAR).join("/");
          }).join("|");
          const [open, close] = set.length > 1 ? ["(?:", ")"] : ["", ""];
          re = "^" + open + re + close + "$";
          if (this.negate)
            re = "^(?!" + re + ").+$";
          try {
            this.regexp = new RegExp(re, [...flags].join(""));
          } catch (ex) {
            this.regexp = false;
          }
          return this.regexp;
        }
        slashSplit(p) {
          if (this.preserveMultipleSlashes) {
            return p.split("/");
          } else if (this.isWindows && /^\/\/[^\/]+/.test(p)) {
            return ["", ...p.split(/\/+/)];
          } else {
            return p.split(/\/+/);
          }
        }
        match(f, partial = this.partial) {
          this.debug("match", f, this.pattern);
          if (this.comment) {
            return false;
          }
          if (this.empty) {
            return f === "";
          }
          if (f === "/" && partial) {
            return true;
          }
          const options = this.options;
          if (this.isWindows) {
            f = f.split("\\").join("/");
          }
          const ff = this.slashSplit(f);
          this.debug(this.pattern, "split", ff);
          const set = this.set;
          this.debug(this.pattern, "set", set);
          let filename = ff[ff.length - 1];
          if (!filename) {
            for (let i = ff.length - 2; !filename && i >= 0; i--) {
              filename = ff[i];
            }
          }
          for (let i = 0; i < set.length; i++) {
            const pattern = set[i];
            let file = ff;
            if (options.matchBase && pattern.length === 1) {
              file = [filename];
            }
            const hit = this.matchOne(file, pattern, partial);
            if (hit) {
              if (options.flipNegate) {
                return true;
              }
              return !this.negate;
            }
          }
          if (options.flipNegate) {
            return false;
          }
          return this.negate;
        }
        static defaults(def) {
          return exports.minimatch.defaults(def).Minimatch;
        }
      };
      exports.Minimatch = Minimatch;
      var ast_js_2 = require_ast();
      Object.defineProperty(exports, "AST", { enumerable: true, get: function() {
        return ast_js_2.AST;
      } });
      var escape_js_2 = require_escape();
      Object.defineProperty(exports, "escape", { enumerable: true, get: function() {
        return escape_js_2.escape;
      } });
      var unescape_js_2 = require_unescape();
      Object.defineProperty(exports, "unescape", { enumerable: true, get: function() {
        return unescape_js_2.unescape;
      } });
      exports.minimatch.AST = ast_js_1.AST;
      exports.minimatch.Minimatch = Minimatch;
      exports.minimatch.escape = escape_js_1.escape;
      exports.minimatch.unescape = unescape_js_1.unescape;
    }
  });

  // ../../node_modules/lru-cache/dist/commonjs/index.js
  var require_commonjs2 = __commonJS({
    "../../node_modules/lru-cache/dist/commonjs/index.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.LRUCache = void 0;
      var perf = typeof performance === "object" && performance && typeof performance.now === "function" ? performance : Date;
      var warned = /* @__PURE__ */ new Set();
      var PROCESS = typeof process === "object" && !!process ? process : {};
      var emitWarning = (msg, type, code, fn) => {
        typeof PROCESS.emitWarning === "function" ? PROCESS.emitWarning(msg, type, code, fn) : console.error(`[${code}] ${type}: ${msg}`);
      };
      var AC = globalThis.AbortController;
      var AS = globalThis.AbortSignal;
      if (typeof AC === "undefined") {
        AS = class AbortSignal {
          onabort;
          _onabort = [];
          reason;
          aborted = false;
          addEventListener(_, fn) {
            this._onabort.push(fn);
          }
        };
        AC = class AbortController {
          constructor() {
            warnACPolyfill();
          }
          signal = new AS();
          abort(reason) {
            if (this.signal.aborted)
              return;
            this.signal.reason = reason;
            this.signal.aborted = true;
            for (const fn of this.signal._onabort) {
              fn(reason);
            }
            this.signal.onabort?.(reason);
          }
        };
        let printACPolyfillWarning = PROCESS.env?.LRU_CACHE_IGNORE_AC_WARNING !== "1";
        const warnACPolyfill = () => {
          if (!printACPolyfillWarning)
            return;
          printACPolyfillWarning = false;
          emitWarning("AbortController is not defined. If using lru-cache in node 14, load an AbortController polyfill from the `node-abort-controller` package. A minimal polyfill is provided for use by LRUCache.fetch(), but it should not be relied upon in other contexts (eg, passing it to other APIs that use AbortController/AbortSignal might have undesirable effects). You may disable this with LRU_CACHE_IGNORE_AC_WARNING=1 in the env.", "NO_ABORT_CONTROLLER", "ENOTSUP", warnACPolyfill);
        };
      }
      var shouldWarn = (code) => !warned.has(code);
      var TYPE = Symbol("type");
      var isPosInt = (n) => n && n === Math.floor(n) && n > 0 && isFinite(n);
      var getUintArray = (max) => !isPosInt(max) ? null : max <= Math.pow(2, 8) ? Uint8Array : max <= Math.pow(2, 16) ? Uint16Array : max <= Math.pow(2, 32) ? Uint32Array : max <= Number.MAX_SAFE_INTEGER ? ZeroArray : null;
      var ZeroArray = class extends Array {
        constructor(size) {
          super(size);
          this.fill(0);
        }
      };
      var Stack = class _Stack {
        heap;
        length;
        // private constructor
        static #constructing = false;
        static create(max) {
          const HeapCls = getUintArray(max);
          if (!HeapCls)
            return [];
          _Stack.#constructing = true;
          const s = new _Stack(max, HeapCls);
          _Stack.#constructing = false;
          return s;
        }
        constructor(max, HeapCls) {
          if (!_Stack.#constructing) {
            throw new TypeError("instantiate Stack using Stack.create(n)");
          }
          this.heap = new HeapCls(max);
          this.length = 0;
        }
        push(n) {
          this.heap[this.length++] = n;
        }
        pop() {
          return this.heap[--this.length];
        }
      };
      var LRUCache = class _LRUCache {
        // options that cannot be changed without disaster
        #max;
        #maxSize;
        #dispose;
        #disposeAfter;
        #fetchMethod;
        #memoMethod;
        /**
         * {@link LRUCache.OptionsBase.ttl}
         */
        ttl;
        /**
         * {@link LRUCache.OptionsBase.ttlResolution}
         */
        ttlResolution;
        /**
         * {@link LRUCache.OptionsBase.ttlAutopurge}
         */
        ttlAutopurge;
        /**
         * {@link LRUCache.OptionsBase.updateAgeOnGet}
         */
        updateAgeOnGet;
        /**
         * {@link LRUCache.OptionsBase.updateAgeOnHas}
         */
        updateAgeOnHas;
        /**
         * {@link LRUCache.OptionsBase.allowStale}
         */
        allowStale;
        /**
         * {@link LRUCache.OptionsBase.noDisposeOnSet}
         */
        noDisposeOnSet;
        /**
         * {@link LRUCache.OptionsBase.noUpdateTTL}
         */
        noUpdateTTL;
        /**
         * {@link LRUCache.OptionsBase.maxEntrySize}
         */
        maxEntrySize;
        /**
         * {@link LRUCache.OptionsBase.sizeCalculation}
         */
        sizeCalculation;
        /**
         * {@link LRUCache.OptionsBase.noDeleteOnFetchRejection}
         */
        noDeleteOnFetchRejection;
        /**
         * {@link LRUCache.OptionsBase.noDeleteOnStaleGet}
         */
        noDeleteOnStaleGet;
        /**
         * {@link LRUCache.OptionsBase.allowStaleOnFetchAbort}
         */
        allowStaleOnFetchAbort;
        /**
         * {@link LRUCache.OptionsBase.allowStaleOnFetchRejection}
         */
        allowStaleOnFetchRejection;
        /**
         * {@link LRUCache.OptionsBase.ignoreFetchAbort}
         */
        ignoreFetchAbort;
        // computed properties
        #size;
        #calculatedSize;
        #keyMap;
        #keyList;
        #valList;
        #next;
        #prev;
        #head;
        #tail;
        #free;
        #disposed;
        #sizes;
        #starts;
        #ttls;
        #hasDispose;
        #hasFetchMethod;
        #hasDisposeAfter;
        /**
         * Do not call this method unless you need to inspect the
         * inner workings of the cache.  If anything returned by this
         * object is modified in any way, strange breakage may occur.
         *
         * These fields are private for a reason!
         *
         * @internal
         */
        static unsafeExposeInternals(c) {
          return {
            // properties
            starts: c.#starts,
            ttls: c.#ttls,
            sizes: c.#sizes,
            keyMap: c.#keyMap,
            keyList: c.#keyList,
            valList: c.#valList,
            next: c.#next,
            prev: c.#prev,
            get head() {
              return c.#head;
            },
            get tail() {
              return c.#tail;
            },
            free: c.#free,
            // methods
            isBackgroundFetch: (p) => c.#isBackgroundFetch(p),
            backgroundFetch: (k, index, options, context) => c.#backgroundFetch(k, index, options, context),
            moveToTail: (index) => c.#moveToTail(index),
            indexes: (options) => c.#indexes(options),
            rindexes: (options) => c.#rindexes(options),
            isStale: (index) => c.#isStale(index)
          };
        }
        // Protected read-only members
        /**
         * {@link LRUCache.OptionsBase.max} (read-only)
         */
        get max() {
          return this.#max;
        }
        /**
         * {@link LRUCache.OptionsBase.maxSize} (read-only)
         */
        get maxSize() {
          return this.#maxSize;
        }
        /**
         * The total computed size of items in the cache (read-only)
         */
        get calculatedSize() {
          return this.#calculatedSize;
        }
        /**
         * The number of items stored in the cache (read-only)
         */
        get size() {
          return this.#size;
        }
        /**
         * {@link LRUCache.OptionsBase.fetchMethod} (read-only)
         */
        get fetchMethod() {
          return this.#fetchMethod;
        }
        get memoMethod() {
          return this.#memoMethod;
        }
        /**
         * {@link LRUCache.OptionsBase.dispose} (read-only)
         */
        get dispose() {
          return this.#dispose;
        }
        /**
         * {@link LRUCache.OptionsBase.disposeAfter} (read-only)
         */
        get disposeAfter() {
          return this.#disposeAfter;
        }
        constructor(options) {
          const { max = 0, ttl, ttlResolution = 1, ttlAutopurge, updateAgeOnGet, updateAgeOnHas, allowStale, dispose, disposeAfter, noDisposeOnSet, noUpdateTTL, maxSize = 0, maxEntrySize = 0, sizeCalculation, fetchMethod, memoMethod, noDeleteOnFetchRejection, noDeleteOnStaleGet, allowStaleOnFetchRejection, allowStaleOnFetchAbort, ignoreFetchAbort } = options;
          if (max !== 0 && !isPosInt(max)) {
            throw new TypeError("max option must be a nonnegative integer");
          }
          const UintArray = max ? getUintArray(max) : Array;
          if (!UintArray) {
            throw new Error("invalid max value: " + max);
          }
          this.#max = max;
          this.#maxSize = maxSize;
          this.maxEntrySize = maxEntrySize || this.#maxSize;
          this.sizeCalculation = sizeCalculation;
          if (this.sizeCalculation) {
            if (!this.#maxSize && !this.maxEntrySize) {
              throw new TypeError("cannot set sizeCalculation without setting maxSize or maxEntrySize");
            }
            if (typeof this.sizeCalculation !== "function") {
              throw new TypeError("sizeCalculation set to non-function");
            }
          }
          if (memoMethod !== void 0 && typeof memoMethod !== "function") {
            throw new TypeError("memoMethod must be a function if defined");
          }
          this.#memoMethod = memoMethod;
          if (fetchMethod !== void 0 && typeof fetchMethod !== "function") {
            throw new TypeError("fetchMethod must be a function if specified");
          }
          this.#fetchMethod = fetchMethod;
          this.#hasFetchMethod = !!fetchMethod;
          this.#keyMap = /* @__PURE__ */ new Map();
          this.#keyList = new Array(max).fill(void 0);
          this.#valList = new Array(max).fill(void 0);
          this.#next = new UintArray(max);
          this.#prev = new UintArray(max);
          this.#head = 0;
          this.#tail = 0;
          this.#free = Stack.create(max);
          this.#size = 0;
          this.#calculatedSize = 0;
          if (typeof dispose === "function") {
            this.#dispose = dispose;
          }
          if (typeof disposeAfter === "function") {
            this.#disposeAfter = disposeAfter;
            this.#disposed = [];
          } else {
            this.#disposeAfter = void 0;
            this.#disposed = void 0;
          }
          this.#hasDispose = !!this.#dispose;
          this.#hasDisposeAfter = !!this.#disposeAfter;
          this.noDisposeOnSet = !!noDisposeOnSet;
          this.noUpdateTTL = !!noUpdateTTL;
          this.noDeleteOnFetchRejection = !!noDeleteOnFetchRejection;
          this.allowStaleOnFetchRejection = !!allowStaleOnFetchRejection;
          this.allowStaleOnFetchAbort = !!allowStaleOnFetchAbort;
          this.ignoreFetchAbort = !!ignoreFetchAbort;
          if (this.maxEntrySize !== 0) {
            if (this.#maxSize !== 0) {
              if (!isPosInt(this.#maxSize)) {
                throw new TypeError("maxSize must be a positive integer if specified");
              }
            }
            if (!isPosInt(this.maxEntrySize)) {
              throw new TypeError("maxEntrySize must be a positive integer if specified");
            }
            this.#initializeSizeTracking();
          }
          this.allowStale = !!allowStale;
          this.noDeleteOnStaleGet = !!noDeleteOnStaleGet;
          this.updateAgeOnGet = !!updateAgeOnGet;
          this.updateAgeOnHas = !!updateAgeOnHas;
          this.ttlResolution = isPosInt(ttlResolution) || ttlResolution === 0 ? ttlResolution : 1;
          this.ttlAutopurge = !!ttlAutopurge;
          this.ttl = ttl || 0;
          if (this.ttl) {
            if (!isPosInt(this.ttl)) {
              throw new TypeError("ttl must be a positive integer if specified");
            }
            this.#initializeTTLTracking();
          }
          if (this.#max === 0 && this.ttl === 0 && this.#maxSize === 0) {
            throw new TypeError("At least one of max, maxSize, or ttl is required");
          }
          if (!this.ttlAutopurge && !this.#max && !this.#maxSize) {
            const code = "LRU_CACHE_UNBOUNDED";
            if (shouldWarn(code)) {
              warned.add(code);
              const msg = "TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.";
              emitWarning(msg, "UnboundedCacheWarning", code, _LRUCache);
            }
          }
        }
        /**
         * Return the number of ms left in the item's TTL. If item is not in cache,
         * returns `0`. Returns `Infinity` if item is in cache without a defined TTL.
         */
        getRemainingTTL(key) {
          return this.#keyMap.has(key) ? Infinity : 0;
        }
        #initializeTTLTracking() {
          const ttls = new ZeroArray(this.#max);
          const starts = new ZeroArray(this.#max);
          this.#ttls = ttls;
          this.#starts = starts;
          this.#setItemTTL = (index, ttl, start = perf.now()) => {
            starts[index] = ttl !== 0 ? start : 0;
            ttls[index] = ttl;
            if (ttl !== 0 && this.ttlAutopurge) {
              const t = setTimeout(() => {
                if (this.#isStale(index)) {
                  this.#delete(this.#keyList[index], "expire");
                }
              }, ttl + 1);
              if (t.unref) {
                t.unref();
              }
            }
          };
          this.#updateItemAge = (index) => {
            starts[index] = ttls[index] !== 0 ? perf.now() : 0;
          };
          this.#statusTTL = (status, index) => {
            if (ttls[index]) {
              const ttl = ttls[index];
              const start = starts[index];
              if (!ttl || !start)
                return;
              status.ttl = ttl;
              status.start = start;
              status.now = cachedNow || getNow();
              const age = status.now - start;
              status.remainingTTL = ttl - age;
            }
          };
          let cachedNow = 0;
          const getNow = () => {
            const n = perf.now();
            if (this.ttlResolution > 0) {
              cachedNow = n;
              const t = setTimeout(() => cachedNow = 0, this.ttlResolution);
              if (t.unref) {
                t.unref();
              }
            }
            return n;
          };
          this.getRemainingTTL = (key) => {
            const index = this.#keyMap.get(key);
            if (index === void 0) {
              return 0;
            }
            const ttl = ttls[index];
            const start = starts[index];
            if (!ttl || !start) {
              return Infinity;
            }
            const age = (cachedNow || getNow()) - start;
            return ttl - age;
          };
          this.#isStale = (index) => {
            const s = starts[index];
            const t = ttls[index];
            return !!t && !!s && (cachedNow || getNow()) - s > t;
          };
        }
        // conditionally set private methods related to TTL
        #updateItemAge = () => {
        };
        #statusTTL = () => {
        };
        #setItemTTL = () => {
        };
        /* c8 ignore stop */
        #isStale = () => false;
        #initializeSizeTracking() {
          const sizes = new ZeroArray(this.#max);
          this.#calculatedSize = 0;
          this.#sizes = sizes;
          this.#removeItemSize = (index) => {
            this.#calculatedSize -= sizes[index];
            sizes[index] = 0;
          };
          this.#requireSize = (k, v, size, sizeCalculation) => {
            if (this.#isBackgroundFetch(v)) {
              return 0;
            }
            if (!isPosInt(size)) {
              if (sizeCalculation) {
                if (typeof sizeCalculation !== "function") {
                  throw new TypeError("sizeCalculation must be a function");
                }
                size = sizeCalculation(v, k);
                if (!isPosInt(size)) {
                  throw new TypeError("sizeCalculation return invalid (expect positive integer)");
                }
              } else {
                throw new TypeError("invalid size value (must be positive integer). When maxSize or maxEntrySize is used, sizeCalculation or size must be set.");
              }
            }
            return size;
          };
          this.#addItemSize = (index, size, status) => {
            sizes[index] = size;
            if (this.#maxSize) {
              const maxSize = this.#maxSize - sizes[index];
              while (this.#calculatedSize > maxSize) {
                this.#evict(true);
              }
            }
            this.#calculatedSize += sizes[index];
            if (status) {
              status.entrySize = size;
              status.totalCalculatedSize = this.#calculatedSize;
            }
          };
        }
        #removeItemSize = (_i) => {
        };
        #addItemSize = (_i, _s, _st) => {
        };
        #requireSize = (_k, _v, size, sizeCalculation) => {
          if (size || sizeCalculation) {
            throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache");
          }
          return 0;
        };
        *#indexes({ allowStale = this.allowStale } = {}) {
          if (this.#size) {
            for (let i = this.#tail; true; ) {
              if (!this.#isValidIndex(i)) {
                break;
              }
              if (allowStale || !this.#isStale(i)) {
                yield i;
              }
              if (i === this.#head) {
                break;
              } else {
                i = this.#prev[i];
              }
            }
          }
        }
        *#rindexes({ allowStale = this.allowStale } = {}) {
          if (this.#size) {
            for (let i = this.#head; true; ) {
              if (!this.#isValidIndex(i)) {
                break;
              }
              if (allowStale || !this.#isStale(i)) {
                yield i;
              }
              if (i === this.#tail) {
                break;
              } else {
                i = this.#next[i];
              }
            }
          }
        }
        #isValidIndex(index) {
          return index !== void 0 && this.#keyMap.get(this.#keyList[index]) === index;
        }
        /**
         * Return a generator yielding `[key, value]` pairs,
         * in order from most recently used to least recently used.
         */
        *entries() {
          for (const i of this.#indexes()) {
            if (this.#valList[i] !== void 0 && this.#keyList[i] !== void 0 && !this.#isBackgroundFetch(this.#valList[i])) {
              yield [this.#keyList[i], this.#valList[i]];
            }
          }
        }
        /**
         * Inverse order version of {@link LRUCache.entries}
         *
         * Return a generator yielding `[key, value]` pairs,
         * in order from least recently used to most recently used.
         */
        *rentries() {
          for (const i of this.#rindexes()) {
            if (this.#valList[i] !== void 0 && this.#keyList[i] !== void 0 && !this.#isBackgroundFetch(this.#valList[i])) {
              yield [this.#keyList[i], this.#valList[i]];
            }
          }
        }
        /**
         * Return a generator yielding the keys in the cache,
         * in order from most recently used to least recently used.
         */
        *keys() {
          for (const i of this.#indexes()) {
            const k = this.#keyList[i];
            if (k !== void 0 && !this.#isBackgroundFetch(this.#valList[i])) {
              yield k;
            }
          }
        }
        /**
         * Inverse order version of {@link LRUCache.keys}
         *
         * Return a generator yielding the keys in the cache,
         * in order from least recently used to most recently used.
         */
        *rkeys() {
          for (const i of this.#rindexes()) {
            const k = this.#keyList[i];
            if (k !== void 0 && !this.#isBackgroundFetch(this.#valList[i])) {
              yield k;
            }
          }
        }
        /**
         * Return a generator yielding the values in the cache,
         * in order from most recently used to least recently used.
         */
        *values() {
          for (const i of this.#indexes()) {
            const v = this.#valList[i];
            if (v !== void 0 && !this.#isBackgroundFetch(this.#valList[i])) {
              yield this.#valList[i];
            }
          }
        }
        /**
         * Inverse order version of {@link LRUCache.values}
         *
         * Return a generator yielding the values in the cache,
         * in order from least recently used to most recently used.
         */
        *rvalues() {
          for (const i of this.#rindexes()) {
            const v = this.#valList[i];
            if (v !== void 0 && !this.#isBackgroundFetch(this.#valList[i])) {
              yield this.#valList[i];
            }
          }
        }
        /**
         * Iterating over the cache itself yields the same results as
         * {@link LRUCache.entries}
         */
        [Symbol.iterator]() {
          return this.entries();
        }
        /**
         * A String value that is used in the creation of the default string
         * description of an object. Called by the built-in method
         * `Object.prototype.toString`.
         */
        [Symbol.toStringTag] = "LRUCache";
        /**
         * Find a value for which the supplied fn method returns a truthy value,
         * similar to `Array.find()`. fn is called as `fn(value, key, cache)`.
         */
        find(fn, getOptions = {}) {
          for (const i of this.#indexes()) {
            const v = this.#valList[i];
            const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
            if (value === void 0)
              continue;
            if (fn(value, this.#keyList[i], this)) {
              return this.get(this.#keyList[i], getOptions);
            }
          }
        }
        /**
         * Call the supplied function on each item in the cache, in order from most
         * recently used to least recently used.
         *
         * `fn` is called as `fn(value, key, cache)`.
         *
         * If `thisp` is provided, function will be called in the `this`-context of
         * the provided object, or the cache if no `thisp` object is provided.
         *
         * Does not update age or recenty of use, or iterate over stale values.
         */
        forEach(fn, thisp = this) {
          for (const i of this.#indexes()) {
            const v = this.#valList[i];
            const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
            if (value === void 0)
              continue;
            fn.call(thisp, value, this.#keyList[i], this);
          }
        }
        /**
         * The same as {@link LRUCache.forEach} but items are iterated over in
         * reverse order.  (ie, less recently used items are iterated over first.)
         */
        rforEach(fn, thisp = this) {
          for (const i of this.#rindexes()) {
            const v = this.#valList[i];
            const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
            if (value === void 0)
              continue;
            fn.call(thisp, value, this.#keyList[i], this);
          }
        }
        /**
         * Delete any stale entries. Returns true if anything was removed,
         * false otherwise.
         */
        purgeStale() {
          let deleted = false;
          for (const i of this.#rindexes({ allowStale: true })) {
            if (this.#isStale(i)) {
              this.#delete(this.#keyList[i], "expire");
              deleted = true;
            }
          }
          return deleted;
        }
        /**
         * Get the extended info about a given entry, to get its value, size, and
         * TTL info simultaneously. Returns `undefined` if the key is not present.
         *
         * Unlike {@link LRUCache#dump}, which is designed to be portable and survive
         * serialization, the `start` value is always the current timestamp, and the
         * `ttl` is a calculated remaining time to live (negative if expired).
         *
         * Always returns stale values, if their info is found in the cache, so be
         * sure to check for expirations (ie, a negative {@link LRUCache.Entry#ttl})
         * if relevant.
         */
        info(key) {
          const i = this.#keyMap.get(key);
          if (i === void 0)
            return void 0;
          const v = this.#valList[i];
          const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
          if (value === void 0)
            return void 0;
          const entry = { value };
          if (this.#ttls && this.#starts) {
            const ttl = this.#ttls[i];
            const start = this.#starts[i];
            if (ttl && start) {
              const remain = ttl - (perf.now() - start);
              entry.ttl = remain;
              entry.start = Date.now();
            }
          }
          if (this.#sizes) {
            entry.size = this.#sizes[i];
          }
          return entry;
        }
        /**
         * Return an array of [key, {@link LRUCache.Entry}] tuples which can be
         * passed to {@link LRLUCache#load}.
         *
         * The `start` fields are calculated relative to a portable `Date.now()`
         * timestamp, even if `performance.now()` is available.
         *
         * Stale entries are always included in the `dump`, even if
         * {@link LRUCache.OptionsBase.allowStale} is false.
         *
         * Note: this returns an actual array, not a generator, so it can be more
         * easily passed around.
         */
        dump() {
          const arr = [];
          for (const i of this.#indexes({ allowStale: true })) {
            const key = this.#keyList[i];
            const v = this.#valList[i];
            const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
            if (value === void 0 || key === void 0)
              continue;
            const entry = { value };
            if (this.#ttls && this.#starts) {
              entry.ttl = this.#ttls[i];
              const age = perf.now() - this.#starts[i];
              entry.start = Math.floor(Date.now() - age);
            }
            if (this.#sizes) {
              entry.size = this.#sizes[i];
            }
            arr.unshift([key, entry]);
          }
          return arr;
        }
        /**
         * Reset the cache and load in the items in entries in the order listed.
         *
         * The shape of the resulting cache may be different if the same options are
         * not used in both caches.
         *
         * The `start` fields are assumed to be calculated relative to a portable
         * `Date.now()` timestamp, even if `performance.now()` is available.
         */
        load(arr) {
          this.clear();
          for (const [key, entry] of arr) {
            if (entry.start) {
              const age = Date.now() - entry.start;
              entry.start = perf.now() - age;
            }
            this.set(key, entry.value, entry);
          }
        }
        /**
         * Add a value to the cache.
         *
         * Note: if `undefined` is specified as a value, this is an alias for
         * {@link LRUCache#delete}
         *
         * Fields on the {@link LRUCache.SetOptions} options param will override
         * their corresponding values in the constructor options for the scope
         * of this single `set()` operation.
         *
         * If `start` is provided, then that will set the effective start
         * time for the TTL calculation. Note that this must be a previous
         * value of `performance.now()` if supported, or a previous value of
         * `Date.now()` if not.
         *
         * Options object may also include `size`, which will prevent
         * calling the `sizeCalculation` function and just use the specified
         * number if it is a positive integer, and `noDisposeOnSet` which
         * will prevent calling a `dispose` function in the case of
         * overwrites.
         *
         * If the `size` (or return value of `sizeCalculation`) for a given
         * entry is greater than `maxEntrySize`, then the item will not be
         * added to the cache.
         *
         * Will update the recency of the entry.
         *
         * If the value is `undefined`, then this is an alias for
         * `cache.delete(key)`. `undefined` is never stored in the cache.
         */
        set(k, v, setOptions = {}) {
          if (v === void 0) {
            this.delete(k);
            return this;
          }
          const { ttl = this.ttl, start, noDisposeOnSet = this.noDisposeOnSet, sizeCalculation = this.sizeCalculation, status } = setOptions;
          let { noUpdateTTL = this.noUpdateTTL } = setOptions;
          const size = this.#requireSize(k, v, setOptions.size || 0, sizeCalculation);
          if (this.maxEntrySize && size > this.maxEntrySize) {
            if (status) {
              status.set = "miss";
              status.maxEntrySizeExceeded = true;
            }
            this.#delete(k, "set");
            return this;
          }
          let index = this.#size === 0 ? void 0 : this.#keyMap.get(k);
          if (index === void 0) {
            index = this.#size === 0 ? this.#tail : this.#free.length !== 0 ? this.#free.pop() : this.#size === this.#max ? this.#evict(false) : this.#size;
            this.#keyList[index] = k;
            this.#valList[index] = v;
            this.#keyMap.set(k, index);
            this.#next[this.#tail] = index;
            this.#prev[index] = this.#tail;
            this.#tail = index;
            this.#size++;
            this.#addItemSize(index, size, status);
            if (status)
              status.set = "add";
            noUpdateTTL = false;
          } else {
            this.#moveToTail(index);
            const oldVal = this.#valList[index];
            if (v !== oldVal) {
              if (this.#hasFetchMethod && this.#isBackgroundFetch(oldVal)) {
                oldVal.__abortController.abort(new Error("replaced"));
                const { __staleWhileFetching: s } = oldVal;
                if (s !== void 0 && !noDisposeOnSet) {
                  if (this.#hasDispose) {
                    this.#dispose?.(s, k, "set");
                  }
                  if (this.#hasDisposeAfter) {
                    this.#disposed?.push([s, k, "set"]);
                  }
                }
              } else if (!noDisposeOnSet) {
                if (this.#hasDispose) {
                  this.#dispose?.(oldVal, k, "set");
                }
                if (this.#hasDisposeAfter) {
                  this.#disposed?.push([oldVal, k, "set"]);
                }
              }
              this.#removeItemSize(index);
              this.#addItemSize(index, size, status);
              this.#valList[index] = v;
              if (status) {
                status.set = "replace";
                const oldValue = oldVal && this.#isBackgroundFetch(oldVal) ? oldVal.__staleWhileFetching : oldVal;
                if (oldValue !== void 0)
                  status.oldValue = oldValue;
              }
            } else if (status) {
              status.set = "update";
            }
          }
          if (ttl !== 0 && !this.#ttls) {
            this.#initializeTTLTracking();
          }
          if (this.#ttls) {
            if (!noUpdateTTL) {
              this.#setItemTTL(index, ttl, start);
            }
            if (status)
              this.#statusTTL(status, index);
          }
          if (!noDisposeOnSet && this.#hasDisposeAfter && this.#disposed) {
            const dt = this.#disposed;
            let task;
            while (task = dt?.shift()) {
              this.#disposeAfter?.(...task);
            }
          }
          return this;
        }
        /**
         * Evict the least recently used item, returning its value or
         * `undefined` if cache is empty.
         */
        pop() {
          try {
            while (this.#size) {
              const val = this.#valList[this.#head];
              this.#evict(true);
              if (this.#isBackgroundFetch(val)) {
                if (val.__staleWhileFetching) {
                  return val.__staleWhileFetching;
                }
              } else if (val !== void 0) {
                return val;
              }
            }
          } finally {
            if (this.#hasDisposeAfter && this.#disposed) {
              const dt = this.#disposed;
              let task;
              while (task = dt?.shift()) {
                this.#disposeAfter?.(...task);
              }
            }
          }
        }
        #evict(free) {
          const head = this.#head;
          const k = this.#keyList[head];
          const v = this.#valList[head];
          if (this.#hasFetchMethod && this.#isBackgroundFetch(v)) {
            v.__abortController.abort(new Error("evicted"));
          } else if (this.#hasDispose || this.#hasDisposeAfter) {
            if (this.#hasDispose) {
              this.#dispose?.(v, k, "evict");
            }
            if (this.#hasDisposeAfter) {
              this.#disposed?.push([v, k, "evict"]);
            }
          }
          this.#removeItemSize(head);
          if (free) {
            this.#keyList[head] = void 0;
            this.#valList[head] = void 0;
            this.#free.push(head);
          }
          if (this.#size === 1) {
            this.#head = this.#tail = 0;
            this.#free.length = 0;
          } else {
            this.#head = this.#next[head];
          }
          this.#keyMap.delete(k);
          this.#size--;
          return head;
        }
        /**
         * Check if a key is in the cache, without updating the recency of use.
         * Will return false if the item is stale, even though it is technically
         * in the cache.
         *
         * Check if a key is in the cache, without updating the recency of
         * use. Age is updated if {@link LRUCache.OptionsBase.updateAgeOnHas} is set
         * to `true` in either the options or the constructor.
         *
         * Will return `false` if the item is stale, even though it is technically in
         * the cache. The difference can be determined (if it matters) by using a
         * `status` argument, and inspecting the `has` field.
         *
         * Will not update item age unless
         * {@link LRUCache.OptionsBase.updateAgeOnHas} is set.
         */
        has(k, hasOptions = {}) {
          const { updateAgeOnHas = this.updateAgeOnHas, status } = hasOptions;
          const index = this.#keyMap.get(k);
          if (index !== void 0) {
            const v = this.#valList[index];
            if (this.#isBackgroundFetch(v) && v.__staleWhileFetching === void 0) {
              return false;
            }
            if (!this.#isStale(index)) {
              if (updateAgeOnHas) {
                this.#updateItemAge(index);
              }
              if (status) {
                status.has = "hit";
                this.#statusTTL(status, index);
              }
              return true;
            } else if (status) {
              status.has = "stale";
              this.#statusTTL(status, index);
            }
          } else if (status) {
            status.has = "miss";
          }
          return false;
        }
        /**
         * Like {@link LRUCache#get} but doesn't update recency or delete stale
         * items.
         *
         * Returns `undefined` if the item is stale, unless
         * {@link LRUCache.OptionsBase.allowStale} is set.
         */
        peek(k, peekOptions = {}) {
          const { allowStale = this.allowStale } = peekOptions;
          const index = this.#keyMap.get(k);
          if (index === void 0 || !allowStale && this.#isStale(index)) {
            return;
          }
          const v = this.#valList[index];
          return this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
        }
        #backgroundFetch(k, index, options, context) {
          const v = index === void 0 ? void 0 : this.#valList[index];
          if (this.#isBackgroundFetch(v)) {
            return v;
          }
          const ac = new AC();
          const { signal } = options;
          signal?.addEventListener("abort", () => ac.abort(signal.reason), {
            signal: ac.signal
          });
          const fetchOpts = {
            signal: ac.signal,
            options,
            context
          };
          const cb = (v2, updateCache = false) => {
            const { aborted } = ac.signal;
            const ignoreAbort = options.ignoreFetchAbort && v2 !== void 0;
            if (options.status) {
              if (aborted && !updateCache) {
                options.status.fetchAborted = true;
                options.status.fetchError = ac.signal.reason;
                if (ignoreAbort)
                  options.status.fetchAbortIgnored = true;
              } else {
                options.status.fetchResolved = true;
              }
            }
            if (aborted && !ignoreAbort && !updateCache) {
              return fetchFail(ac.signal.reason);
            }
            const bf2 = p;
            if (this.#valList[index] === p) {
              if (v2 === void 0) {
                if (bf2.__staleWhileFetching) {
                  this.#valList[index] = bf2.__staleWhileFetching;
                } else {
                  this.#delete(k, "fetch");
                }
              } else {
                if (options.status)
                  options.status.fetchUpdated = true;
                this.set(k, v2, fetchOpts.options);
              }
            }
            return v2;
          };
          const eb = (er) => {
            if (options.status) {
              options.status.fetchRejected = true;
              options.status.fetchError = er;
            }
            return fetchFail(er);
          };
          const fetchFail = (er) => {
            const { aborted } = ac.signal;
            const allowStaleAborted = aborted && options.allowStaleOnFetchAbort;
            const allowStale = allowStaleAborted || options.allowStaleOnFetchRejection;
            const noDelete = allowStale || options.noDeleteOnFetchRejection;
            const bf2 = p;
            if (this.#valList[index] === p) {
              const del = !noDelete || bf2.__staleWhileFetching === void 0;
              if (del) {
                this.#delete(k, "fetch");
              } else if (!allowStaleAborted) {
                this.#valList[index] = bf2.__staleWhileFetching;
              }
            }
            if (allowStale) {
              if (options.status && bf2.__staleWhileFetching !== void 0) {
                options.status.returnedStale = true;
              }
              return bf2.__staleWhileFetching;
            } else if (bf2.__returned === bf2) {
              throw er;
            }
          };
          const pcall = (res, rej) => {
            const fmp = this.#fetchMethod?.(k, v, fetchOpts);
            if (fmp && fmp instanceof Promise) {
              fmp.then((v2) => res(v2 === void 0 ? void 0 : v2), rej);
            }
            ac.signal.addEventListener("abort", () => {
              if (!options.ignoreFetchAbort || options.allowStaleOnFetchAbort) {
                res(void 0);
                if (options.allowStaleOnFetchAbort) {
                  res = (v2) => cb(v2, true);
                }
              }
            });
          };
          if (options.status)
            options.status.fetchDispatched = true;
          const p = new Promise(pcall).then(cb, eb);
          const bf = Object.assign(p, {
            __abortController: ac,
            __staleWhileFetching: v,
            __returned: void 0
          });
          if (index === void 0) {
            this.set(k, bf, { ...fetchOpts.options, status: void 0 });
            index = this.#keyMap.get(k);
          } else {
            this.#valList[index] = bf;
          }
          return bf;
        }
        #isBackgroundFetch(p) {
          if (!this.#hasFetchMethod)
            return false;
          const b = p;
          return !!b && b instanceof Promise && b.hasOwnProperty("__staleWhileFetching") && b.__abortController instanceof AC;
        }
        async fetch(k, fetchOptions = {}) {
          const {
            // get options
            allowStale = this.allowStale,
            updateAgeOnGet = this.updateAgeOnGet,
            noDeleteOnStaleGet = this.noDeleteOnStaleGet,
            // set options
            ttl = this.ttl,
            noDisposeOnSet = this.noDisposeOnSet,
            size = 0,
            sizeCalculation = this.sizeCalculation,
            noUpdateTTL = this.noUpdateTTL,
            // fetch exclusive options
            noDeleteOnFetchRejection = this.noDeleteOnFetchRejection,
            allowStaleOnFetchRejection = this.allowStaleOnFetchRejection,
            ignoreFetchAbort = this.ignoreFetchAbort,
            allowStaleOnFetchAbort = this.allowStaleOnFetchAbort,
            context,
            forceRefresh = false,
            status,
            signal
          } = fetchOptions;
          if (!this.#hasFetchMethod) {
            if (status)
              status.fetch = "get";
            return this.get(k, {
              allowStale,
              updateAgeOnGet,
              noDeleteOnStaleGet,
              status
            });
          }
          const options = {
            allowStale,
            updateAgeOnGet,
            noDeleteOnStaleGet,
            ttl,
            noDisposeOnSet,
            size,
            sizeCalculation,
            noUpdateTTL,
            noDeleteOnFetchRejection,
            allowStaleOnFetchRejection,
            allowStaleOnFetchAbort,
            ignoreFetchAbort,
            status,
            signal
          };
          let index = this.#keyMap.get(k);
          if (index === void 0) {
            if (status)
              status.fetch = "miss";
            const p = this.#backgroundFetch(k, index, options, context);
            return p.__returned = p;
          } else {
            const v = this.#valList[index];
            if (this.#isBackgroundFetch(v)) {
              const stale = allowStale && v.__staleWhileFetching !== void 0;
              if (status) {
                status.fetch = "inflight";
                if (stale)
                  status.returnedStale = true;
              }
              return stale ? v.__staleWhileFetching : v.__returned = v;
            }
            const isStale = this.#isStale(index);
            if (!forceRefresh && !isStale) {
              if (status)
                status.fetch = "hit";
              this.#moveToTail(index);
              if (updateAgeOnGet) {
                this.#updateItemAge(index);
              }
              if (status)
                this.#statusTTL(status, index);
              return v;
            }
            const p = this.#backgroundFetch(k, index, options, context);
            const hasStale = p.__staleWhileFetching !== void 0;
            const staleVal = hasStale && allowStale;
            if (status) {
              status.fetch = isStale ? "stale" : "refresh";
              if (staleVal && isStale)
                status.returnedStale = true;
            }
            return staleVal ? p.__staleWhileFetching : p.__returned = p;
          }
        }
        async forceFetch(k, fetchOptions = {}) {
          const v = await this.fetch(k, fetchOptions);
          if (v === void 0)
            throw new Error("fetch() returned undefined");
          return v;
        }
        memo(k, memoOptions = {}) {
          const memoMethod = this.#memoMethod;
          if (!memoMethod) {
            throw new Error("no memoMethod provided to constructor");
          }
          const { context, forceRefresh, ...options } = memoOptions;
          const v = this.get(k, options);
          if (!forceRefresh && v !== void 0)
            return v;
          const vv = memoMethod(k, v, {
            options,
            context
          });
          this.set(k, vv, options);
          return vv;
        }
        /**
         * Return a value from the cache. Will update the recency of the cache
         * entry found.
         *
         * If the key is not found, get() will return `undefined`.
         */
        get(k, getOptions = {}) {
          const { allowStale = this.allowStale, updateAgeOnGet = this.updateAgeOnGet, noDeleteOnStaleGet = this.noDeleteOnStaleGet, status } = getOptions;
          const index = this.#keyMap.get(k);
          if (index !== void 0) {
            const value = this.#valList[index];
            const fetching = this.#isBackgroundFetch(value);
            if (status)
              this.#statusTTL(status, index);
            if (this.#isStale(index)) {
              if (status)
                status.get = "stale";
              if (!fetching) {
                if (!noDeleteOnStaleGet) {
                  this.#delete(k, "expire");
                }
                if (status && allowStale)
                  status.returnedStale = true;
                return allowStale ? value : void 0;
              } else {
                if (status && allowStale && value.__staleWhileFetching !== void 0) {
                  status.returnedStale = true;
                }
                return allowStale ? value.__staleWhileFetching : void 0;
              }
            } else {
              if (status)
                status.get = "hit";
              if (fetching) {
                return value.__staleWhileFetching;
              }
              this.#moveToTail(index);
              if (updateAgeOnGet) {
                this.#updateItemAge(index);
              }
              return value;
            }
          } else if (status) {
            status.get = "miss";
          }
        }
        #connect(p, n) {
          this.#prev[n] = p;
          this.#next[p] = n;
        }
        #moveToTail(index) {
          if (index !== this.#tail) {
            if (index === this.#head) {
              this.#head = this.#next[index];
            } else {
              this.#connect(this.#prev[index], this.#next[index]);
            }
            this.#connect(this.#tail, index);
            this.#tail = index;
          }
        }
        /**
         * Deletes a key out of the cache.
         *
         * Returns true if the key was deleted, false otherwise.
         */
        delete(k) {
          return this.#delete(k, "delete");
        }
        #delete(k, reason) {
          let deleted = false;
          if (this.#size !== 0) {
            const index = this.#keyMap.get(k);
            if (index !== void 0) {
              deleted = true;
              if (this.#size === 1) {
                this.#clear(reason);
              } else {
                this.#removeItemSize(index);
                const v = this.#valList[index];
                if (this.#isBackgroundFetch(v)) {
                  v.__abortController.abort(new Error("deleted"));
                } else if (this.#hasDispose || this.#hasDisposeAfter) {
                  if (this.#hasDispose) {
                    this.#dispose?.(v, k, reason);
                  }
                  if (this.#hasDisposeAfter) {
                    this.#disposed?.push([v, k, reason]);
                  }
                }
                this.#keyMap.delete(k);
                this.#keyList[index] = void 0;
                this.#valList[index] = void 0;
                if (index === this.#tail) {
                  this.#tail = this.#prev[index];
                } else if (index === this.#head) {
                  this.#head = this.#next[index];
                } else {
                  const pi = this.#prev[index];
                  this.#next[pi] = this.#next[index];
                  const ni = this.#next[index];
                  this.#prev[ni] = this.#prev[index];
                }
                this.#size--;
                this.#free.push(index);
              }
            }
          }
          if (this.#hasDisposeAfter && this.#disposed?.length) {
            const dt = this.#disposed;
            let task;
            while (task = dt?.shift()) {
              this.#disposeAfter?.(...task);
            }
          }
          return deleted;
        }
        /**
         * Clear the cache entirely, throwing away all values.
         */
        clear() {
          return this.#clear("delete");
        }
        #clear(reason) {
          for (const index of this.#rindexes({ allowStale: true })) {
            const v = this.#valList[index];
            if (this.#isBackgroundFetch(v)) {
              v.__abortController.abort(new Error("deleted"));
            } else {
              const k = this.#keyList[index];
              if (this.#hasDispose) {
                this.#dispose?.(v, k, reason);
              }
              if (this.#hasDisposeAfter) {
                this.#disposed?.push([v, k, reason]);
              }
            }
          }
          this.#keyMap.clear();
          this.#valList.fill(void 0);
          this.#keyList.fill(void 0);
          if (this.#ttls && this.#starts) {
            this.#ttls.fill(0);
            this.#starts.fill(0);
          }
          if (this.#sizes) {
            this.#sizes.fill(0);
          }
          this.#head = 0;
          this.#tail = 0;
          this.#free.length = 0;
          this.#calculatedSize = 0;
          this.#size = 0;
          if (this.#hasDisposeAfter && this.#disposed) {
            const dt = this.#disposed;
            let task;
            while (task = dt?.shift()) {
              this.#disposeAfter?.(...task);
            }
          }
        }
      };
      exports.LRUCache = LRUCache;
    }
  });

  // ../../node_modules/minipass/dist/commonjs/index.js
  var require_commonjs3 = __commonJS({
    "../../node_modules/minipass/dist/commonjs/index.js"(exports) {
      "use strict";
      var __importDefault = exports && exports.__importDefault || function(mod) {
        return mod && mod.__esModule ? mod : { "default": mod };
      };
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.Minipass = exports.isWritable = exports.isReadable = exports.isStream = void 0;
      var proc = typeof process === "object" && process ? process : {
        stdout: null,
        stderr: null
      };
      var node_events_1 = __require("bare-events");
      var node_stream_1 = __importDefault(__require("bare-stream"));
      var node_string_decoder_1 = __require("bare-string-decoder");
      var isStream = (s) => !!s && typeof s === "object" && (s instanceof Minipass || s instanceof node_stream_1.default || (0, exports.isReadable)(s) || (0, exports.isWritable)(s));
      exports.isStream = isStream;
      var isReadable = (s) => !!s && typeof s === "object" && s instanceof node_events_1.EventEmitter && typeof s.pipe === "function" && // node core Writable streams have a pipe() method, but it throws
      s.pipe !== node_stream_1.default.Writable.prototype.pipe;
      exports.isReadable = isReadable;
      var isWritable = (s) => !!s && typeof s === "object" && s instanceof node_events_1.EventEmitter && typeof s.write === "function" && typeof s.end === "function";
      exports.isWritable = isWritable;
      var EOF = Symbol("EOF");
      var MAYBE_EMIT_END = Symbol("maybeEmitEnd");
      var EMITTED_END = Symbol("emittedEnd");
      var EMITTING_END = Symbol("emittingEnd");
      var EMITTED_ERROR = Symbol("emittedError");
      var CLOSED = Symbol("closed");
      var READ = Symbol("read");
      var FLUSH = Symbol("flush");
      var FLUSHCHUNK = Symbol("flushChunk");
      var ENCODING = Symbol("encoding");
      var DECODER = Symbol("decoder");
      var FLOWING = Symbol("flowing");
      var PAUSED = Symbol("paused");
      var RESUME = Symbol("resume");
      var BUFFER = Symbol("buffer");
      var PIPES = Symbol("pipes");
      var BUFFERLENGTH = Symbol("bufferLength");
      var BUFFERPUSH = Symbol("bufferPush");
      var BUFFERSHIFT = Symbol("bufferShift");
      var OBJECTMODE = Symbol("objectMode");
      var DESTROYED = Symbol("destroyed");
      var ERROR = Symbol("error");
      var EMITDATA = Symbol("emitData");
      var EMITEND = Symbol("emitEnd");
      var EMITEND2 = Symbol("emitEnd2");
      var ASYNC = Symbol("async");
      var ABORT = Symbol("abort");
      var ABORTED = Symbol("aborted");
      var SIGNAL = Symbol("signal");
      var DATALISTENERS = Symbol("dataListeners");
      var DISCARDED = Symbol("discarded");
      var defer = (fn) => Promise.resolve().then(fn);
      var nodefer = (fn) => fn();
      var isEndish = (ev) => ev === "end" || ev === "finish" || ev === "prefinish";
      var isArrayBufferLike = (b) => b instanceof ArrayBuffer || !!b && typeof b === "object" && b.constructor && b.constructor.name === "ArrayBuffer" && b.byteLength >= 0;
      var isArrayBufferView = (b) => !Buffer.isBuffer(b) && ArrayBuffer.isView(b);
      var Pipe = class {
        src;
        dest;
        opts;
        ondrain;
        constructor(src, dest, opts) {
          this.src = src;
          this.dest = dest;
          this.opts = opts;
          this.ondrain = () => src[RESUME]();
          this.dest.on("drain", this.ondrain);
        }
        unpipe() {
          this.dest.removeListener("drain", this.ondrain);
        }
        // only here for the prototype
        /* c8 ignore start */
        proxyErrors(_er) {
        }
        /* c8 ignore stop */
        end() {
          this.unpipe();
          if (this.opts.end)
            this.dest.end();
        }
      };
      var PipeProxyErrors = class extends Pipe {
        unpipe() {
          this.src.removeListener("error", this.proxyErrors);
          super.unpipe();
        }
        constructor(src, dest, opts) {
          super(src, dest, opts);
          this.proxyErrors = (er) => this.dest.emit("error", er);
          src.on("error", this.proxyErrors);
        }
      };
      var isObjectModeOptions = (o) => !!o.objectMode;
      var isEncodingOptions = (o) => !o.objectMode && !!o.encoding && o.encoding !== "buffer";
      var Minipass = class extends node_events_1.EventEmitter {
        [FLOWING] = false;
        [PAUSED] = false;
        [PIPES] = [];
        [BUFFER] = [];
        [OBJECTMODE];
        [ENCODING];
        [ASYNC];
        [DECODER];
        [EOF] = false;
        [EMITTED_END] = false;
        [EMITTING_END] = false;
        [CLOSED] = false;
        [EMITTED_ERROR] = null;
        [BUFFERLENGTH] = 0;
        [DESTROYED] = false;
        [SIGNAL];
        [ABORTED] = false;
        [DATALISTENERS] = 0;
        [DISCARDED] = false;
        /**
         * true if the stream can be written
         */
        writable = true;
        /**
         * true if the stream can be read
         */
        readable = true;
        /**
         * If `RType` is Buffer, then options do not need to be provided.
         * Otherwise, an options object must be provided to specify either
         * {@link Minipass.SharedOptions.objectMode} or
         * {@link Minipass.SharedOptions.encoding}, as appropriate.
         */
        constructor(...args) {
          const options = args[0] || {};
          super();
          if (options.objectMode && typeof options.encoding === "string") {
            throw new TypeError("Encoding and objectMode may not be used together");
          }
          if (isObjectModeOptions(options)) {
            this[OBJECTMODE] = true;
            this[ENCODING] = null;
          } else if (isEncodingOptions(options)) {
            this[ENCODING] = options.encoding;
            this[OBJECTMODE] = false;
          } else {
            this[OBJECTMODE] = false;
            this[ENCODING] = null;
          }
          this[ASYNC] = !!options.async;
          this[DECODER] = this[ENCODING] ? new node_string_decoder_1.StringDecoder(this[ENCODING]) : null;
          if (options && options.debugExposeBuffer === true) {
            Object.defineProperty(this, "buffer", { get: () => this[BUFFER] });
          }
          if (options && options.debugExposePipes === true) {
            Object.defineProperty(this, "pipes", { get: () => this[PIPES] });
          }
          const { signal } = options;
          if (signal) {
            this[SIGNAL] = signal;
            if (signal.aborted) {
              this[ABORT]();
            } else {
              signal.addEventListener("abort", () => this[ABORT]());
            }
          }
        }
        /**
         * The amount of data stored in the buffer waiting to be read.
         *
         * For Buffer strings, this will be the total byte length.
         * For string encoding streams, this will be the string character length,
         * according to JavaScript's `string.length` logic.
         * For objectMode streams, this is a count of the items waiting to be
         * emitted.
         */
        get bufferLength() {
          return this[BUFFERLENGTH];
        }
        /**
         * The `BufferEncoding` currently in use, or `null`
         */
        get encoding() {
          return this[ENCODING];
        }
        /**
         * @deprecated - This is a read only property
         */
        set encoding(_enc) {
          throw new Error("Encoding must be set at instantiation time");
        }
        /**
         * @deprecated - Encoding may only be set at instantiation time
         */
        setEncoding(_enc) {
          throw new Error("Encoding must be set at instantiation time");
        }
        /**
         * True if this is an objectMode stream
         */
        get objectMode() {
          return this[OBJECTMODE];
        }
        /**
         * @deprecated - This is a read-only property
         */
        set objectMode(_om) {
          throw new Error("objectMode must be set at instantiation time");
        }
        /**
         * true if this is an async stream
         */
        get ["async"]() {
          return this[ASYNC];
        }
        /**
         * Set to true to make this stream async.
         *
         * Once set, it cannot be unset, as this would potentially cause incorrect
         * behavior.  Ie, a sync stream can be made async, but an async stream
         * cannot be safely made sync.
         */
        set ["async"](a) {
          this[ASYNC] = this[ASYNC] || !!a;
        }
        // drop everything and get out of the flow completely
        [ABORT]() {
          this[ABORTED] = true;
          this.emit("abort", this[SIGNAL]?.reason);
          this.destroy(this[SIGNAL]?.reason);
        }
        /**
         * True if the stream has been aborted.
         */
        get aborted() {
          return this[ABORTED];
        }
        /**
         * No-op setter. Stream aborted status is set via the AbortSignal provided
         * in the constructor options.
         */
        set aborted(_) {
        }
        write(chunk, encoding, cb) {
          if (this[ABORTED])
            return false;
          if (this[EOF])
            throw new Error("write after end");
          if (this[DESTROYED]) {
            this.emit("error", Object.assign(new Error("Cannot call write after a stream was destroyed"), { code: "ERR_STREAM_DESTROYED" }));
            return true;
          }
          if (typeof encoding === "function") {
            cb = encoding;
            encoding = "utf8";
          }
          if (!encoding)
            encoding = "utf8";
          const fn = this[ASYNC] ? defer : nodefer;
          if (!this[OBJECTMODE] && !Buffer.isBuffer(chunk)) {
            if (isArrayBufferView(chunk)) {
              chunk = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength);
            } else if (isArrayBufferLike(chunk)) {
              chunk = Buffer.from(chunk);
            } else if (typeof chunk !== "string") {
              throw new Error("Non-contiguous data written to non-objectMode stream");
            }
          }
          if (this[OBJECTMODE]) {
            if (this[FLOWING] && this[BUFFERLENGTH] !== 0)
              this[FLUSH](true);
            if (this[FLOWING])
              this.emit("data", chunk);
            else
              this[BUFFERPUSH](chunk);
            if (this[BUFFERLENGTH] !== 0)
              this.emit("readable");
            if (cb)
              fn(cb);
            return this[FLOWING];
          }
          if (!chunk.length) {
            if (this[BUFFERLENGTH] !== 0)
              this.emit("readable");
            if (cb)
              fn(cb);
            return this[FLOWING];
          }
          if (typeof chunk === "string" && // unless it is a string already ready for us to use
          !(encoding === this[ENCODING] && !this[DECODER]?.lastNeed)) {
            chunk = Buffer.from(chunk, encoding);
          }
          if (Buffer.isBuffer(chunk) && this[ENCODING]) {
            chunk = this[DECODER].write(chunk);
          }
          if (this[FLOWING] && this[BUFFERLENGTH] !== 0)
            this[FLUSH](true);
          if (this[FLOWING])
            this.emit("data", chunk);
          else
            this[BUFFERPUSH](chunk);
          if (this[BUFFERLENGTH] !== 0)
            this.emit("readable");
          if (cb)
            fn(cb);
          return this[FLOWING];
        }
        /**
         * Low-level explicit read method.
         *
         * In objectMode, the argument is ignored, and one item is returned if
         * available.
         *
         * `n` is the number of bytes (or in the case of encoding streams,
         * characters) to consume. If `n` is not provided, then the entire buffer
         * is returned, or `null` is returned if no data is available.
         *
         * If `n` is greater that the amount of data in the internal buffer,
         * then `null` is returned.
         */
        read(n) {
          if (this[DESTROYED])
            return null;
          this[DISCARDED] = false;
          if (this[BUFFERLENGTH] === 0 || n === 0 || n && n > this[BUFFERLENGTH]) {
            this[MAYBE_EMIT_END]();
            return null;
          }
          if (this[OBJECTMODE])
            n = null;
          if (this[BUFFER].length > 1 && !this[OBJECTMODE]) {
            this[BUFFER] = [
              this[ENCODING] ? this[BUFFER].join("") : Buffer.concat(this[BUFFER], this[BUFFERLENGTH])
            ];
          }
          const ret = this[READ](n || null, this[BUFFER][0]);
          this[MAYBE_EMIT_END]();
          return ret;
        }
        [READ](n, chunk) {
          if (this[OBJECTMODE])
            this[BUFFERSHIFT]();
          else {
            const c = chunk;
            if (n === c.length || n === null)
              this[BUFFERSHIFT]();
            else if (typeof c === "string") {
              this[BUFFER][0] = c.slice(n);
              chunk = c.slice(0, n);
              this[BUFFERLENGTH] -= n;
            } else {
              this[BUFFER][0] = c.subarray(n);
              chunk = c.subarray(0, n);
              this[BUFFERLENGTH] -= n;
            }
          }
          this.emit("data", chunk);
          if (!this[BUFFER].length && !this[EOF])
            this.emit("drain");
          return chunk;
        }
        end(chunk, encoding, cb) {
          if (typeof chunk === "function") {
            cb = chunk;
            chunk = void 0;
          }
          if (typeof encoding === "function") {
            cb = encoding;
            encoding = "utf8";
          }
          if (chunk !== void 0)
            this.write(chunk, encoding);
          if (cb)
            this.once("end", cb);
          this[EOF] = true;
          this.writable = false;
          if (this[FLOWING] || !this[PAUSED])
            this[MAYBE_EMIT_END]();
          return this;
        }
        // don't let the internal resume be overwritten
        [RESUME]() {
          if (this[DESTROYED])
            return;
          if (!this[DATALISTENERS] && !this[PIPES].length) {
            this[DISCARDED] = true;
          }
          this[PAUSED] = false;
          this[FLOWING] = true;
          this.emit("resume");
          if (this[BUFFER].length)
            this[FLUSH]();
          else if (this[EOF])
            this[MAYBE_EMIT_END]();
          else
            this.emit("drain");
        }
        /**
         * Resume the stream if it is currently in a paused state
         *
         * If called when there are no pipe destinations or `data` event listeners,
         * this will place the stream in a "discarded" state, where all data will
         * be thrown away. The discarded state is removed if a pipe destination or
         * data handler is added, if pause() is called, or if any synchronous or
         * asynchronous iteration is started.
         */
        resume() {
          return this[RESUME]();
        }
        /**
         * Pause the stream
         */
        pause() {
          this[FLOWING] = false;
          this[PAUSED] = true;
          this[DISCARDED] = false;
        }
        /**
         * true if the stream has been forcibly destroyed
         */
        get destroyed() {
          return this[DESTROYED];
        }
        /**
         * true if the stream is currently in a flowing state, meaning that
         * any writes will be immediately emitted.
         */
        get flowing() {
          return this[FLOWING];
        }
        /**
         * true if the stream is currently in a paused state
         */
        get paused() {
          return this[PAUSED];
        }
        [BUFFERPUSH](chunk) {
          if (this[OBJECTMODE])
            this[BUFFERLENGTH] += 1;
          else
            this[BUFFERLENGTH] += chunk.length;
          this[BUFFER].push(chunk);
        }
        [BUFFERSHIFT]() {
          if (this[OBJECTMODE])
            this[BUFFERLENGTH] -= 1;
          else
            this[BUFFERLENGTH] -= this[BUFFER][0].length;
          return this[BUFFER].shift();
        }
        [FLUSH](noDrain = false) {
          do {
          } while (this[FLUSHCHUNK](this[BUFFERSHIFT]()) && this[BUFFER].length);
          if (!noDrain && !this[BUFFER].length && !this[EOF])
            this.emit("drain");
        }
        [FLUSHCHUNK](chunk) {
          this.emit("data", chunk);
          return this[FLOWING];
        }
        /**
         * Pipe all data emitted by this stream into the destination provided.
         *
         * Triggers the flow of data.
         */
        pipe(dest, opts) {
          if (this[DESTROYED])
            return dest;
          this[DISCARDED] = false;
          const ended = this[EMITTED_END];
          opts = opts || {};
          if (dest === proc.stdout || dest === proc.stderr)
            opts.end = false;
          else
            opts.end = opts.end !== false;
          opts.proxyErrors = !!opts.proxyErrors;
          if (ended) {
            if (opts.end)
              dest.end();
          } else {
            this[PIPES].push(!opts.proxyErrors ? new Pipe(this, dest, opts) : new PipeProxyErrors(this, dest, opts));
            if (this[ASYNC])
              defer(() => this[RESUME]());
            else
              this[RESUME]();
          }
          return dest;
        }
        /**
         * Fully unhook a piped destination stream.
         *
         * If the destination stream was the only consumer of this stream (ie,
         * there are no other piped destinations or `'data'` event listeners)
         * then the flow of data will stop until there is another consumer or
         * {@link Minipass#resume} is explicitly called.
         */
        unpipe(dest) {
          const p = this[PIPES].find((p2) => p2.dest === dest);
          if (p) {
            if (this[PIPES].length === 1) {
              if (this[FLOWING] && this[DATALISTENERS] === 0) {
                this[FLOWING] = false;
              }
              this[PIPES] = [];
            } else
              this[PIPES].splice(this[PIPES].indexOf(p), 1);
            p.unpipe();
          }
        }
        /**
         * Alias for {@link Minipass#on}
         */
        addListener(ev, handler) {
          return this.on(ev, handler);
        }
        /**
         * Mostly identical to `EventEmitter.on`, with the following
         * behavior differences to prevent data loss and unnecessary hangs:
         *
         * - Adding a 'data' event handler will trigger the flow of data
         *
         * - Adding a 'readable' event handler when there is data waiting to be read
         *   will cause 'readable' to be emitted immediately.
         *
         * - Adding an 'endish' event handler ('end', 'finish', etc.) which has
         *   already passed will cause the event to be emitted immediately and all
         *   handlers removed.
         *
         * - Adding an 'error' event handler after an error has been emitted will
         *   cause the event to be re-emitted immediately with the error previously
         *   raised.
         */
        on(ev, handler) {
          const ret = super.on(ev, handler);
          if (ev === "data") {
            this[DISCARDED] = false;
            this[DATALISTENERS]++;
            if (!this[PIPES].length && !this[FLOWING]) {
              this[RESUME]();
            }
          } else if (ev === "readable" && this[BUFFERLENGTH] !== 0) {
            super.emit("readable");
          } else if (isEndish(ev) && this[EMITTED_END]) {
            super.emit(ev);
            this.removeAllListeners(ev);
          } else if (ev === "error" && this[EMITTED_ERROR]) {
            const h = handler;
            if (this[ASYNC])
              defer(() => h.call(this, this[EMITTED_ERROR]));
            else
              h.call(this, this[EMITTED_ERROR]);
          }
          return ret;
        }
        /**
         * Alias for {@link Minipass#off}
         */
        removeListener(ev, handler) {
          return this.off(ev, handler);
        }
        /**
         * Mostly identical to `EventEmitter.off`
         *
         * If a 'data' event handler is removed, and it was the last consumer
         * (ie, there are no pipe destinations or other 'data' event listeners),
         * then the flow of data will stop until there is another consumer or
         * {@link Minipass#resume} is explicitly called.
         */
        off(ev, handler) {
          const ret = super.off(ev, handler);
          if (ev === "data") {
            this[DATALISTENERS] = this.listeners("data").length;
            if (this[DATALISTENERS] === 0 && !this[DISCARDED] && !this[PIPES].length) {
              this[FLOWING] = false;
            }
          }
          return ret;
        }
        /**
         * Mostly identical to `EventEmitter.removeAllListeners`
         *
         * If all 'data' event handlers are removed, and they were the last consumer
         * (ie, there are no pipe destinations), then the flow of data will stop
         * until there is another consumer or {@link Minipass#resume} is explicitly
         * called.
         */
        removeAllListeners(ev) {
          const ret = super.removeAllListeners(ev);
          if (ev === "data" || ev === void 0) {
            this[DATALISTENERS] = 0;
            if (!this[DISCARDED] && !this[PIPES].length) {
              this[FLOWING] = false;
            }
          }
          return ret;
        }
        /**
         * true if the 'end' event has been emitted
         */
        get emittedEnd() {
          return this[EMITTED_END];
        }
        [MAYBE_EMIT_END]() {
          if (!this[EMITTING_END] && !this[EMITTED_END] && !this[DESTROYED] && this[BUFFER].length === 0 && this[EOF]) {
            this[EMITTING_END] = true;
            this.emit("end");
            this.emit("prefinish");
            this.emit("finish");
            if (this[CLOSED])
              this.emit("close");
            this[EMITTING_END] = false;
          }
        }
        /**
         * Mostly identical to `EventEmitter.emit`, with the following
         * behavior differences to prevent data loss and unnecessary hangs:
         *
         * If the stream has been destroyed, and the event is something other
         * than 'close' or 'error', then `false` is returned and no handlers
         * are called.
         *
         * If the event is 'end', and has already been emitted, then the event
         * is ignored. If the stream is in a paused or non-flowing state, then
         * the event will be deferred until data flow resumes. If the stream is
         * async, then handlers will be called on the next tick rather than
         * immediately.
         *
         * If the event is 'close', and 'end' has not yet been emitted, then
         * the event will be deferred until after 'end' is emitted.
         *
         * If the event is 'error', and an AbortSignal was provided for the stream,
         * and there are no listeners, then the event is ignored, matching the
         * behavior of node core streams in the presense of an AbortSignal.
         *
         * If the event is 'finish' or 'prefinish', then all listeners will be
         * removed after emitting the event, to prevent double-firing.
         */
        emit(ev, ...args) {
          const data = args[0];
          if (ev !== "error" && ev !== "close" && ev !== DESTROYED && this[DESTROYED]) {
            return false;
          } else if (ev === "data") {
            return !this[OBJECTMODE] && !data ? false : this[ASYNC] ? (defer(() => this[EMITDATA](data)), true) : this[EMITDATA](data);
          } else if (ev === "end") {
            return this[EMITEND]();
          } else if (ev === "close") {
            this[CLOSED] = true;
            if (!this[EMITTED_END] && !this[DESTROYED])
              return false;
            const ret2 = super.emit("close");
            this.removeAllListeners("close");
            return ret2;
          } else if (ev === "error") {
            this[EMITTED_ERROR] = data;
            super.emit(ERROR, data);
            const ret2 = !this[SIGNAL] || this.listeners("error").length ? super.emit("error", data) : false;
            this[MAYBE_EMIT_END]();
            return ret2;
          } else if (ev === "resume") {
            const ret2 = super.emit("resume");
            this[MAYBE_EMIT_END]();
            return ret2;
          } else if (ev === "finish" || ev === "prefinish") {
            const ret2 = super.emit(ev);
            this.removeAllListeners(ev);
            return ret2;
          }
          const ret = super.emit(ev, ...args);
          this[MAYBE_EMIT_END]();
          return ret;
        }
        [EMITDATA](data) {
          for (const p of this[PIPES]) {
            if (p.dest.write(data) === false)
              this.pause();
          }
          const ret = this[DISCARDED] ? false : super.emit("data", data);
          this[MAYBE_EMIT_END]();
          return ret;
        }
        [EMITEND]() {
          if (this[EMITTED_END])
            return false;
          this[EMITTED_END] = true;
          this.readable = false;
          return this[ASYNC] ? (defer(() => this[EMITEND2]()), true) : this[EMITEND2]();
        }
        [EMITEND2]() {
          if (this[DECODER]) {
            const data = this[DECODER].end();
            if (data) {
              for (const p of this[PIPES]) {
                p.dest.write(data);
              }
              if (!this[DISCARDED])
                super.emit("data", data);
            }
          }
          for (const p of this[PIPES]) {
            p.end();
          }
          const ret = super.emit("end");
          this.removeAllListeners("end");
          return ret;
        }
        /**
         * Return a Promise that resolves to an array of all emitted data once
         * the stream ends.
         */
        async collect() {
          const buf = Object.assign([], {
            dataLength: 0
          });
          if (!this[OBJECTMODE])
            buf.dataLength = 0;
          const p = this.promise();
          this.on("data", (c) => {
            buf.push(c);
            if (!this[OBJECTMODE])
              buf.dataLength += c.length;
          });
          await p;
          return buf;
        }
        /**
         * Return a Promise that resolves to the concatenation of all emitted data
         * once the stream ends.
         *
         * Not allowed on objectMode streams.
         */
        async concat() {
          if (this[OBJECTMODE]) {
            throw new Error("cannot concat in objectMode");
          }
          const buf = await this.collect();
          return this[ENCODING] ? buf.join("") : Buffer.concat(buf, buf.dataLength);
        }
        /**
         * Return a void Promise that resolves once the stream ends.
         */
        async promise() {
          return new Promise((resolve, reject) => {
            this.on(DESTROYED, () => reject(new Error("stream destroyed")));
            this.on("error", (er) => reject(er));
            this.on("end", () => resolve());
          });
        }
        /**
         * Asynchronous `for await of` iteration.
         *
         * This will continue emitting all chunks until the stream terminates.
         */
        [Symbol.asyncIterator]() {
          this[DISCARDED] = false;
          let stopped = false;
          const stop = async () => {
            this.pause();
            stopped = true;
            return { value: void 0, done: true };
          };
          const next = () => {
            if (stopped)
              return stop();
            const res = this.read();
            if (res !== null)
              return Promise.resolve({ done: false, value: res });
            if (this[EOF])
              return stop();
            let resolve;
            let reject;
            const onerr = (er) => {
              this.off("data", ondata);
              this.off("end", onend);
              this.off(DESTROYED, ondestroy);
              stop();
              reject(er);
            };
            const ondata = (value) => {
              this.off("error", onerr);
              this.off("end", onend);
              this.off(DESTROYED, ondestroy);
              this.pause();
              resolve({ value, done: !!this[EOF] });
            };
            const onend = () => {
              this.off("error", onerr);
              this.off("data", ondata);
              this.off(DESTROYED, ondestroy);
              stop();
              resolve({ done: true, value: void 0 });
            };
            const ondestroy = () => onerr(new Error("stream destroyed"));
            return new Promise((res2, rej) => {
              reject = rej;
              resolve = res2;
              this.once(DESTROYED, ondestroy);
              this.once("error", onerr);
              this.once("end", onend);
              this.once("data", ondata);
            });
          };
          return {
            next,
            throw: stop,
            return: stop,
            [Symbol.asyncIterator]() {
              return this;
            },
            [Symbol.asyncDispose]: async () => {
            }
          };
        }
        /**
         * Synchronous `for of` iteration.
         *
         * The iteration will terminate when the internal buffer runs out, even
         * if the stream has not yet terminated.
         */
        [Symbol.iterator]() {
          this[DISCARDED] = false;
          let stopped = false;
          const stop = () => {
            this.pause();
            this.off(ERROR, stop);
            this.off(DESTROYED, stop);
            this.off("end", stop);
            stopped = true;
            return { done: true, value: void 0 };
          };
          const next = () => {
            if (stopped)
              return stop();
            const value = this.read();
            return value === null ? stop() : { done: false, value };
          };
          this.once("end", stop);
          this.once(ERROR, stop);
          this.once(DESTROYED, stop);
          return {
            next,
            throw: stop,
            return: stop,
            [Symbol.iterator]() {
              return this;
            },
            [Symbol.dispose]: () => {
            }
          };
        }
        /**
         * Destroy a stream, preventing it from being used for any further purpose.
         *
         * If the stream has a `close()` method, then it will be called on
         * destruction.
         *
         * After destruction, any attempt to write data, read data, or emit most
         * events will be ignored.
         *
         * If an error argument is provided, then it will be emitted in an
         * 'error' event.
         */
        destroy(er) {
          if (this[DESTROYED]) {
            if (er)
              this.emit("error", er);
            else
              this.emit(DESTROYED);
            return this;
          }
          this[DESTROYED] = true;
          this[DISCARDED] = true;
          this[BUFFER].length = 0;
          this[BUFFERLENGTH] = 0;
          const wc = this;
          if (typeof wc.close === "function" && !this[CLOSED])
            wc.close();
          if (er)
            this.emit("error", er);
          else
            this.emit(DESTROYED);
          return this;
        }
        /**
         * Alias for {@link isStream}
         *
         * Former export location, maintained for backwards compatibility.
         *
         * @deprecated
         */
        static get isStream() {
          return exports.isStream;
        }
      };
      exports.Minipass = Minipass;
    }
  });

  // ../../node_modules/path-scurry/dist/commonjs/index.js
  var require_commonjs4 = __commonJS({
    "../../node_modules/path-scurry/dist/commonjs/index.js"(exports) {
      "use strict";
      var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
        if (k2 === void 0) k2 = k;
        var desc = Object.getOwnPropertyDescriptor(m, k);
        if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
          desc = { enumerable: true, get: function() {
            return m[k];
          } };
        }
        Object.defineProperty(o, k2, desc);
      }) : (function(o, m, k, k2) {
        if (k2 === void 0) k2 = k;
        o[k2] = m[k];
      }));
      var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
        Object.defineProperty(o, "default", { enumerable: true, value: v });
      }) : function(o, v) {
        o["default"] = v;
      });
      var __importStar = exports && exports.__importStar || function(mod) {
        if (mod && mod.__esModule) return mod;
        var result = {};
        if (mod != null) {
          for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
        }
        __setModuleDefault(result, mod);
        return result;
      };
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.PathScurry = exports.Path = exports.PathScurryDarwin = exports.PathScurryPosix = exports.PathScurryWin32 = exports.PathScurryBase = exports.PathPosix = exports.PathWin32 = exports.PathBase = exports.ChildrenCache = exports.ResolveCache = void 0;
      var lru_cache_1 = require_commonjs2();
      var node_path_1 = __require("bare-path");
      var node_url_1 = __require("bare-url");
      var fs_1 = require_bare_node_fs();
      var actualFS = __importStar(__require("bare-fs"));
      var realpathSync = fs_1.realpathSync.native;
      var promises_1 = __require("bare-fs/promises");
      var minipass_1 = require_commonjs3();
      var defaultFS = {
        lstatSync: fs_1.lstatSync,
        readdir: fs_1.readdir,
        readdirSync: fs_1.readdirSync,
        readlinkSync: fs_1.readlinkSync,
        realpathSync,
        promises: {
          lstat: promises_1.lstat,
          readdir: promises_1.readdir,
          readlink: promises_1.readlink,
          realpath: promises_1.realpath
        }
      };
      var fsFromOption = (fsOption) => !fsOption || fsOption === defaultFS || fsOption === actualFS ? defaultFS : {
        ...defaultFS,
        ...fsOption,
        promises: {
          ...defaultFS.promises,
          ...fsOption.promises || {}
        }
      };
      var uncDriveRegexp = /^\\\\\?\\([a-z]:)\\?$/i;
      var uncToDrive = (rootPath) => rootPath.replace(/\//g, "\\").replace(uncDriveRegexp, "$1\\");
      var eitherSep = /[\\\/]/;
      var UNKNOWN = 0;
      var IFIFO = 1;
      var IFCHR = 2;
      var IFDIR = 4;
      var IFBLK = 6;
      var IFREG = 8;
      var IFLNK = 10;
      var IFSOCK = 12;
      var IFMT = 15;
      var IFMT_UNKNOWN = ~IFMT;
      var READDIR_CALLED = 16;
      var LSTAT_CALLED = 32;
      var ENOTDIR = 64;
      var ENOENT = 128;
      var ENOREADLINK = 256;
      var ENOREALPATH = 512;
      var ENOCHILD = ENOTDIR | ENOENT | ENOREALPATH;
      var TYPEMASK = 1023;
      var entToType = (s) => s.isFile() ? IFREG : s.isDirectory() ? IFDIR : s.isSymbolicLink() ? IFLNK : s.isCharacterDevice() ? IFCHR : s.isBlockDevice() ? IFBLK : s.isSocket() ? IFSOCK : s.isFIFO() ? IFIFO : UNKNOWN;
      var normalizeCache = /* @__PURE__ */ new Map();
      var normalize = (s) => {
        const c = normalizeCache.get(s);
        if (c)
          return c;
        const n = s.normalize("NFKD");
        normalizeCache.set(s, n);
        return n;
      };
      var normalizeNocaseCache = /* @__PURE__ */ new Map();
      var normalizeNocase = (s) => {
        const c = normalizeNocaseCache.get(s);
        if (c)
          return c;
        const n = normalize(s.toLowerCase());
        normalizeNocaseCache.set(s, n);
        return n;
      };
      var ResolveCache = class extends lru_cache_1.LRUCache {
        constructor() {
          super({ max: 256 });
        }
      };
      exports.ResolveCache = ResolveCache;
      var ChildrenCache = class extends lru_cache_1.LRUCache {
        constructor(maxSize = 16 * 1024) {
          super({
            maxSize,
            // parent + children
            sizeCalculation: (a) => a.length + 1
          });
        }
      };
      exports.ChildrenCache = ChildrenCache;
      var setAsCwd = Symbol("PathScurry setAsCwd");
      var PathBase = class {
        /**
         * the basename of this path
         *
         * **Important**: *always* test the path name against any test string
         * usingthe {@link isNamed} method, and not by directly comparing this
         * string. Otherwise, unicode path strings that the system sees as identical
         * will not be properly treated as the same path, leading to incorrect
         * behavior and possible security issues.
         */
        name;
        /**
         * the Path entry corresponding to the path root.
         *
         * @internal
         */
        root;
        /**
         * All roots found within the current PathScurry family
         *
         * @internal
         */
        roots;
        /**
         * a reference to the parent path, or undefined in the case of root entries
         *
         * @internal
         */
        parent;
        /**
         * boolean indicating whether paths are compared case-insensitively
         * @internal
         */
        nocase;
        /**
         * boolean indicating that this path is the current working directory
         * of the PathScurry collection that contains it.
         */
        isCWD = false;
        // potential default fs override
        #fs;
        // Stats fields
        #dev;
        get dev() {
          return this.#dev;
        }
        #mode;
        get mode() {
          return this.#mode;
        }
        #nlink;
        get nlink() {
          return this.#nlink;
        }
        #uid;
        get uid() {
          return this.#uid;
        }
        #gid;
        get gid() {
          return this.#gid;
        }
        #rdev;
        get rdev() {
          return this.#rdev;
        }
        #blksize;
        get blksize() {
          return this.#blksize;
        }
        #ino;
        get ino() {
          return this.#ino;
        }
        #size;
        get size() {
          return this.#size;
        }
        #blocks;
        get blocks() {
          return this.#blocks;
        }
        #atimeMs;
        get atimeMs() {
          return this.#atimeMs;
        }
        #mtimeMs;
        get mtimeMs() {
          return this.#mtimeMs;
        }
        #ctimeMs;
        get ctimeMs() {
          return this.#ctimeMs;
        }
        #birthtimeMs;
        get birthtimeMs() {
          return this.#birthtimeMs;
        }
        #atime;
        get atime() {
          return this.#atime;
        }
        #mtime;
        get mtime() {
          return this.#mtime;
        }
        #ctime;
        get ctime() {
          return this.#ctime;
        }
        #birthtime;
        get birthtime() {
          return this.#birthtime;
        }
        #matchName;
        #depth;
        #fullpath;
        #fullpathPosix;
        #relative;
        #relativePosix;
        #type;
        #children;
        #linkTarget;
        #realpath;
        /**
         * This property is for compatibility with the Dirent class as of
         * Node v20, where Dirent['parentPath'] refers to the path of the
         * directory that was passed to readdir. For root entries, it's the path
         * to the entry itself.
         */
        get parentPath() {
          return (this.parent || this).fullpath();
        }
        /**
         * Deprecated alias for Dirent['parentPath'] Somewhat counterintuitively,
         * this property refers to the *parent* path, not the path object itself.
         */
        get path() {
          return this.parentPath;
        }
        /**
         * Do not create new Path objects directly.  They should always be accessed
         * via the PathScurry class or other methods on the Path class.
         *
         * @internal
         */
        constructor(name, type = UNKNOWN, root, roots, nocase, children, opts) {
          this.name = name;
          this.#matchName = nocase ? normalizeNocase(name) : normalize(name);
          this.#type = type & TYPEMASK;
          this.nocase = nocase;
          this.roots = roots;
          this.root = root || this;
          this.#children = children;
          this.#fullpath = opts.fullpath;
          this.#relative = opts.relative;
          this.#relativePosix = opts.relativePosix;
          this.parent = opts.parent;
          if (this.parent) {
            this.#fs = this.parent.#fs;
          } else {
            this.#fs = fsFromOption(opts.fs);
          }
        }
        /**
         * Returns the depth of the Path object from its root.
         *
         * For example, a path at `/foo/bar` would have a depth of 2.
         */
        depth() {
          if (this.#depth !== void 0)
            return this.#depth;
          if (!this.parent)
            return this.#depth = 0;
          return this.#depth = this.parent.depth() + 1;
        }
        /**
         * @internal
         */
        childrenCache() {
          return this.#children;
        }
        /**
         * Get the Path object referenced by the string path, resolved from this Path
         */
        resolve(path) {
          if (!path) {
            return this;
          }
          const rootPath = this.getRootString(path);
          const dir = path.substring(rootPath.length);
          const dirParts = dir.split(this.splitSep);
          const result = rootPath ? this.getRoot(rootPath).#resolveParts(dirParts) : this.#resolveParts(dirParts);
          return result;
        }
        #resolveParts(dirParts) {
          let p = this;
          for (const part of dirParts) {
            p = p.child(part);
          }
          return p;
        }
        /**
         * Returns the cached children Path objects, if still available.  If they
         * have fallen out of the cache, then returns an empty array, and resets the
         * READDIR_CALLED bit, so that future calls to readdir() will require an fs
         * lookup.
         *
         * @internal
         */
        children() {
          const cached = this.#children.get(this);
          if (cached) {
            return cached;
          }
          const children = Object.assign([], { provisional: 0 });
          this.#children.set(this, children);
          this.#type &= ~READDIR_CALLED;
          return children;
        }
        /**
         * Resolves a path portion and returns or creates the child Path.
         *
         * Returns `this` if pathPart is `''` or `'.'`, or `parent` if pathPart is
         * `'..'`.
         *
         * This should not be called directly.  If `pathPart` contains any path
         * separators, it will lead to unsafe undefined behavior.
         *
         * Use `Path.resolve()` instead.
         *
         * @internal
         */
        child(pathPart, opts) {
          if (pathPart === "" || pathPart === ".") {
            return this;
          }
          if (pathPart === "..") {
            return this.parent || this;
          }
          const children = this.children();
          const name = this.nocase ? normalizeNocase(pathPart) : normalize(pathPart);
          for (const p of children) {
            if (p.#matchName === name) {
              return p;
            }
          }
          const s = this.parent ? this.sep : "";
          const fullpath = this.#fullpath ? this.#fullpath + s + pathPart : void 0;
          const pchild = this.newChild(pathPart, UNKNOWN, {
            ...opts,
            parent: this,
            fullpath
          });
          if (!this.canReaddir()) {
            pchild.#type |= ENOENT;
          }
          children.push(pchild);
          return pchild;
        }
        /**
         * The relative path from the cwd. If it does not share an ancestor with
         * the cwd, then this ends up being equivalent to the fullpath()
         */
        relative() {
          if (this.isCWD)
            return "";
          if (this.#relative !== void 0) {
            return this.#relative;
          }
          const name = this.name;
          const p = this.parent;
          if (!p) {
            return this.#relative = this.name;
          }
          const pv = p.relative();
          return pv + (!pv || !p.parent ? "" : this.sep) + name;
        }
        /**
         * The relative path from the cwd, using / as the path separator.
         * If it does not share an ancestor with
         * the cwd, then this ends up being equivalent to the fullpathPosix()
         * On posix systems, this is identical to relative().
         */
        relativePosix() {
          if (this.sep === "/")
            return this.relative();
          if (this.isCWD)
            return "";
          if (this.#relativePosix !== void 0)
            return this.#relativePosix;
          const name = this.name;
          const p = this.parent;
          if (!p) {
            return this.#relativePosix = this.fullpathPosix();
          }
          const pv = p.relativePosix();
          return pv + (!pv || !p.parent ? "" : "/") + name;
        }
        /**
         * The fully resolved path string for this Path entry
         */
        fullpath() {
          if (this.#fullpath !== void 0) {
            return this.#fullpath;
          }
          const name = this.name;
          const p = this.parent;
          if (!p) {
            return this.#fullpath = this.name;
          }
          const pv = p.fullpath();
          const fp = pv + (!p.parent ? "" : this.sep) + name;
          return this.#fullpath = fp;
        }
        /**
         * On platforms other than windows, this is identical to fullpath.
         *
         * On windows, this is overridden to return the forward-slash form of the
         * full UNC path.
         */
        fullpathPosix() {
          if (this.#fullpathPosix !== void 0)
            return this.#fullpathPosix;
          if (this.sep === "/")
            return this.#fullpathPosix = this.fullpath();
          if (!this.parent) {
            const p2 = this.fullpath().replace(/\\/g, "/");
            if (/^[a-z]:\//i.test(p2)) {
              return this.#fullpathPosix = `//?/${p2}`;
            } else {
              return this.#fullpathPosix = p2;
            }
          }
          const p = this.parent;
          const pfpp = p.fullpathPosix();
          const fpp = pfpp + (!pfpp || !p.parent ? "" : "/") + this.name;
          return this.#fullpathPosix = fpp;
        }
        /**
         * Is the Path of an unknown type?
         *
         * Note that we might know *something* about it if there has been a previous
         * filesystem operation, for example that it does not exist, or is not a
         * link, or whether it has child entries.
         */
        isUnknown() {
          return (this.#type & IFMT) === UNKNOWN;
        }
        isType(type) {
          return this[`is${type}`]();
        }
        getType() {
          return this.isUnknown() ? "Unknown" : this.isDirectory() ? "Directory" : this.isFile() ? "File" : this.isSymbolicLink() ? "SymbolicLink" : this.isFIFO() ? "FIFO" : this.isCharacterDevice() ? "CharacterDevice" : this.isBlockDevice() ? "BlockDevice" : (
            /* c8 ignore start */
            this.isSocket() ? "Socket" : "Unknown"
          );
        }
        /**
         * Is the Path a regular file?
         */
        isFile() {
          return (this.#type & IFMT) === IFREG;
        }
        /**
         * Is the Path a directory?
         */
        isDirectory() {
          return (this.#type & IFMT) === IFDIR;
        }
        /**
         * Is the path a character device?
         */
        isCharacterDevice() {
          return (this.#type & IFMT) === IFCHR;
        }
        /**
         * Is the path a block device?
         */
        isBlockDevice() {
          return (this.#type & IFMT) === IFBLK;
        }
        /**
         * Is the path a FIFO pipe?
         */
        isFIFO() {
          return (this.#type & IFMT) === IFIFO;
        }
        /**
         * Is the path a socket?
         */
        isSocket() {
          return (this.#type & IFMT) === IFSOCK;
        }
        /**
         * Is the path a symbolic link?
         */
        isSymbolicLink() {
          return (this.#type & IFLNK) === IFLNK;
        }
        /**
         * Return the entry if it has been subject of a successful lstat, or
         * undefined otherwise.
         *
         * Does not read the filesystem, so an undefined result *could* simply
         * mean that we haven't called lstat on it.
         */
        lstatCached() {
          return this.#type & LSTAT_CALLED ? this : void 0;
        }
        /**
         * Return the cached link target if the entry has been the subject of a
         * successful readlink, or undefined otherwise.
         *
         * Does not read the filesystem, so an undefined result *could* just mean we
         * don't have any cached data. Only use it if you are very sure that a
         * readlink() has been called at some point.
         */
        readlinkCached() {
          return this.#linkTarget;
        }
        /**
         * Returns the cached realpath target if the entry has been the subject
         * of a successful realpath, or undefined otherwise.
         *
         * Does not read the filesystem, so an undefined result *could* just mean we
         * don't have any cached data. Only use it if you are very sure that a
         * realpath() has been called at some point.
         */
        realpathCached() {
          return this.#realpath;
        }
        /**
         * Returns the cached child Path entries array if the entry has been the
         * subject of a successful readdir(), or [] otherwise.
         *
         * Does not read the filesystem, so an empty array *could* just mean we
         * don't have any cached data. Only use it if you are very sure that a
         * readdir() has been called recently enough to still be valid.
         */
        readdirCached() {
          const children = this.children();
          return children.slice(0, children.provisional);
        }
        /**
         * Return true if it's worth trying to readlink.  Ie, we don't (yet) have
         * any indication that readlink will definitely fail.
         *
         * Returns false if the path is known to not be a symlink, if a previous
         * readlink failed, or if the entry does not exist.
         */
        canReadlink() {
          if (this.#linkTarget)
            return true;
          if (!this.parent)
            return false;
          const ifmt = this.#type & IFMT;
          return !(ifmt !== UNKNOWN && ifmt !== IFLNK || this.#type & ENOREADLINK || this.#type & ENOENT);
        }
        /**
         * Return true if readdir has previously been successfully called on this
         * path, indicating that cachedReaddir() is likely valid.
         */
        calledReaddir() {
          return !!(this.#type & READDIR_CALLED);
        }
        /**
         * Returns true if the path is known to not exist. That is, a previous lstat
         * or readdir failed to verify its existence when that would have been
         * expected, or a parent entry was marked either enoent or enotdir.
         */
        isENOENT() {
          return !!(this.#type & ENOENT);
        }
        /**
         * Return true if the path is a match for the given path name.  This handles
         * case sensitivity and unicode normalization.
         *
         * Note: even on case-sensitive systems, it is **not** safe to test the
         * equality of the `.name` property to determine whether a given pathname
         * matches, due to unicode normalization mismatches.
         *
         * Always use this method instead of testing the `path.name` property
         * directly.
         */
        isNamed(n) {
          return !this.nocase ? this.#matchName === normalize(n) : this.#matchName === normalizeNocase(n);
        }
        /**
         * Return the Path object corresponding to the target of a symbolic link.
         *
         * If the Path is not a symbolic link, or if the readlink call fails for any
         * reason, `undefined` is returned.
         *
         * Result is cached, and thus may be outdated if the filesystem is mutated.
         */
        async readlink() {
          const target = this.#linkTarget;
          if (target) {
            return target;
          }
          if (!this.canReadlink()) {
            return void 0;
          }
          if (!this.parent) {
            return void 0;
          }
          try {
            const read = await this.#fs.promises.readlink(this.fullpath());
            const linkTarget = (await this.parent.realpath())?.resolve(read);
            if (linkTarget) {
              return this.#linkTarget = linkTarget;
            }
          } catch (er) {
            this.#readlinkFail(er.code);
            return void 0;
          }
        }
        /**
         * Synchronous {@link PathBase.readlink}
         */
        readlinkSync() {
          const target = this.#linkTarget;
          if (target) {
            return target;
          }
          if (!this.canReadlink()) {
            return void 0;
          }
          if (!this.parent) {
            return void 0;
          }
          try {
            const read = this.#fs.readlinkSync(this.fullpath());
            const linkTarget = this.parent.realpathSync()?.resolve(read);
            if (linkTarget) {
              return this.#linkTarget = linkTarget;
            }
          } catch (er) {
            this.#readlinkFail(er.code);
            return void 0;
          }
        }
        #readdirSuccess(children) {
          this.#type |= READDIR_CALLED;
          for (let p = children.provisional; p < children.length; p++) {
            const c = children[p];
            if (c)
              c.#markENOENT();
          }
        }
        #markENOENT() {
          if (this.#type & ENOENT)
            return;
          this.#type = (this.#type | ENOENT) & IFMT_UNKNOWN;
          this.#markChildrenENOENT();
        }
        #markChildrenENOENT() {
          const children = this.children();
          children.provisional = 0;
          for (const p of children) {
            p.#markENOENT();
          }
        }
        #markENOREALPATH() {
          this.#type |= ENOREALPATH;
          this.#markENOTDIR();
        }
        // save the information when we know the entry is not a dir
        #markENOTDIR() {
          if (this.#type & ENOTDIR)
            return;
          let t = this.#type;
          if ((t & IFMT) === IFDIR)
            t &= IFMT_UNKNOWN;
          this.#type = t | ENOTDIR;
          this.#markChildrenENOENT();
        }
        #readdirFail(code = "") {
          if (code === "ENOTDIR" || code === "EPERM") {
            this.#markENOTDIR();
          } else if (code === "ENOENT") {
            this.#markENOENT();
          } else {
            this.children().provisional = 0;
          }
        }
        #lstatFail(code = "") {
          if (code === "ENOTDIR") {
            const p = this.parent;
            p.#markENOTDIR();
          } else if (code === "ENOENT") {
            this.#markENOENT();
          }
        }
        #readlinkFail(code = "") {
          let ter = this.#type;
          ter |= ENOREADLINK;
          if (code === "ENOENT")
            ter |= ENOENT;
          if (code === "EINVAL" || code === "UNKNOWN") {
            ter &= IFMT_UNKNOWN;
          }
          this.#type = ter;
          if (code === "ENOTDIR" && this.parent) {
            this.parent.#markENOTDIR();
          }
        }
        #readdirAddChild(e, c) {
          return this.#readdirMaybePromoteChild(e, c) || this.#readdirAddNewChild(e, c);
        }
        #readdirAddNewChild(e, c) {
          const type = entToType(e);
          const child = this.newChild(e.name, type, { parent: this });
          const ifmt = child.#type & IFMT;
          if (ifmt !== IFDIR && ifmt !== IFLNK && ifmt !== UNKNOWN) {
            child.#type |= ENOTDIR;
          }
          c.unshift(child);
          c.provisional++;
          return child;
        }
        #readdirMaybePromoteChild(e, c) {
          for (let p = c.provisional; p < c.length; p++) {
            const pchild = c[p];
            const name = this.nocase ? normalizeNocase(e.name) : normalize(e.name);
            if (name !== pchild.#matchName) {
              continue;
            }
            return this.#readdirPromoteChild(e, pchild, p, c);
          }
        }
        #readdirPromoteChild(e, p, index, c) {
          const v = p.name;
          p.#type = p.#type & IFMT_UNKNOWN | entToType(e);
          if (v !== e.name)
            p.name = e.name;
          if (index !== c.provisional) {
            if (index === c.length - 1)
              c.pop();
            else
              c.splice(index, 1);
            c.unshift(p);
          }
          c.provisional++;
          return p;
        }
        /**
         * Call lstat() on this Path, and update all known information that can be
         * determined.
         *
         * Note that unlike `fs.lstat()`, the returned value does not contain some
         * information, such as `mode`, `dev`, `nlink`, and `ino`.  If that
         * information is required, you will need to call `fs.lstat` yourself.
         *
         * If the Path refers to a nonexistent file, or if the lstat call fails for
         * any reason, `undefined` is returned.  Otherwise the updated Path object is
         * returned.
         *
         * Results are cached, and thus may be out of date if the filesystem is
         * mutated.
         */
        async lstat() {
          if ((this.#type & ENOENT) === 0) {
            try {
              this.#applyStat(await this.#fs.promises.lstat(this.fullpath()));
              return this;
            } catch (er) {
              this.#lstatFail(er.code);
            }
          }
        }
        /**
         * synchronous {@link PathBase.lstat}
         */
        lstatSync() {
          if ((this.#type & ENOENT) === 0) {
            try {
              this.#applyStat(this.#fs.lstatSync(this.fullpath()));
              return this;
            } catch (er) {
              this.#lstatFail(er.code);
            }
          }
        }
        #applyStat(st) {
          const { atime, atimeMs, birthtime, birthtimeMs, blksize, blocks, ctime, ctimeMs, dev, gid, ino, mode, mtime, mtimeMs, nlink, rdev, size, uid } = st;
          this.#atime = atime;
          this.#atimeMs = atimeMs;
          this.#birthtime = birthtime;
          this.#birthtimeMs = birthtimeMs;
          this.#blksize = blksize;
          this.#blocks = blocks;
          this.#ctime = ctime;
          this.#ctimeMs = ctimeMs;
          this.#dev = dev;
          this.#gid = gid;
          this.#ino = ino;
          this.#mode = mode;
          this.#mtime = mtime;
          this.#mtimeMs = mtimeMs;
          this.#nlink = nlink;
          this.#rdev = rdev;
          this.#size = size;
          this.#uid = uid;
          const ifmt = entToType(st);
          this.#type = this.#type & IFMT_UNKNOWN | ifmt | LSTAT_CALLED;
          if (ifmt !== UNKNOWN && ifmt !== IFDIR && ifmt !== IFLNK) {
            this.#type |= ENOTDIR;
          }
        }
        #onReaddirCB = [];
        #readdirCBInFlight = false;
        #callOnReaddirCB(children) {
          this.#readdirCBInFlight = false;
          const cbs = this.#onReaddirCB.slice();
          this.#onReaddirCB.length = 0;
          cbs.forEach((cb) => cb(null, children));
        }
        /**
         * Standard node-style callback interface to get list of directory entries.
         *
         * If the Path cannot or does not contain any children, then an empty array
         * is returned.
         *
         * Results are cached, and thus may be out of date if the filesystem is
         * mutated.
         *
         * @param cb The callback called with (er, entries).  Note that the `er`
         * param is somewhat extraneous, as all readdir() errors are handled and
         * simply result in an empty set of entries being returned.
         * @param allowZalgo Boolean indicating that immediately known results should
         * *not* be deferred with `queueMicrotask`. Defaults to `false`. Release
         * zalgo at your peril, the dark pony lord is devious and unforgiving.
         */
        readdirCB(cb, allowZalgo = false) {
          if (!this.canReaddir()) {
            if (allowZalgo)
              cb(null, []);
            else
              queueMicrotask(() => cb(null, []));
            return;
          }
          const children = this.children();
          if (this.calledReaddir()) {
            const c = children.slice(0, children.provisional);
            if (allowZalgo)
              cb(null, c);
            else
              queueMicrotask(() => cb(null, c));
            return;
          }
          this.#onReaddirCB.push(cb);
          if (this.#readdirCBInFlight) {
            return;
          }
          this.#readdirCBInFlight = true;
          const fullpath = this.fullpath();
          this.#fs.readdir(fullpath, { withFileTypes: true }, (er, entries) => {
            if (er) {
              this.#readdirFail(er.code);
              children.provisional = 0;
            } else {
              for (const e of entries) {
                this.#readdirAddChild(e, children);
              }
              this.#readdirSuccess(children);
            }
            this.#callOnReaddirCB(children.slice(0, children.provisional));
            return;
          });
        }
        #asyncReaddirInFlight;
        /**
         * Return an array of known child entries.
         *
         * If the Path cannot or does not contain any children, then an empty array
         * is returned.
         *
         * Results are cached, and thus may be out of date if the filesystem is
         * mutated.
         */
        async readdir() {
          if (!this.canReaddir()) {
            return [];
          }
          const children = this.children();
          if (this.calledReaddir()) {
            return children.slice(0, children.provisional);
          }
          const fullpath = this.fullpath();
          if (this.#asyncReaddirInFlight) {
            await this.#asyncReaddirInFlight;
          } else {
            let resolve = () => {
            };
            this.#asyncReaddirInFlight = new Promise((res) => resolve = res);
            try {
              for (const e of await this.#fs.promises.readdir(fullpath, {
                withFileTypes: true
              })) {
                this.#readdirAddChild(e, children);
              }
              this.#readdirSuccess(children);
            } catch (er) {
              this.#readdirFail(er.code);
              children.provisional = 0;
            }
            this.#asyncReaddirInFlight = void 0;
            resolve();
          }
          return children.slice(0, children.provisional);
        }
        /**
         * synchronous {@link PathBase.readdir}
         */
        readdirSync() {
          if (!this.canReaddir()) {
            return [];
          }
          const children = this.children();
          if (this.calledReaddir()) {
            return children.slice(0, children.provisional);
          }
          const fullpath = this.fullpath();
          try {
            for (const e of this.#fs.readdirSync(fullpath, {
              withFileTypes: true
            })) {
              this.#readdirAddChild(e, children);
            }
            this.#readdirSuccess(children);
          } catch (er) {
            this.#readdirFail(er.code);
            children.provisional = 0;
          }
          return children.slice(0, children.provisional);
        }
        canReaddir() {
          if (this.#type & ENOCHILD)
            return false;
          const ifmt = IFMT & this.#type;
          if (!(ifmt === UNKNOWN || ifmt === IFDIR || ifmt === IFLNK)) {
            return false;
          }
          return true;
        }
        shouldWalk(dirs, walkFilter) {
          return (this.#type & IFDIR) === IFDIR && !(this.#type & ENOCHILD) && !dirs.has(this) && (!walkFilter || walkFilter(this));
        }
        /**
         * Return the Path object corresponding to path as resolved
         * by realpath(3).
         *
         * If the realpath call fails for any reason, `undefined` is returned.
         *
         * Result is cached, and thus may be outdated if the filesystem is mutated.
         * On success, returns a Path object.
         */
        async realpath() {
          if (this.#realpath)
            return this.#realpath;
          if ((ENOREALPATH | ENOREADLINK | ENOENT) & this.#type)
            return void 0;
          try {
            const rp = await this.#fs.promises.realpath(this.fullpath());
            return this.#realpath = this.resolve(rp);
          } catch (_) {
            this.#markENOREALPATH();
          }
        }
        /**
         * Synchronous {@link realpath}
         */
        realpathSync() {
          if (this.#realpath)
            return this.#realpath;
          if ((ENOREALPATH | ENOREADLINK | ENOENT) & this.#type)
            return void 0;
          try {
            const rp = this.#fs.realpathSync(this.fullpath());
            return this.#realpath = this.resolve(rp);
          } catch (_) {
            this.#markENOREALPATH();
          }
        }
        /**
         * Internal method to mark this Path object as the scurry cwd,
         * called by {@link PathScurry#chdir}
         *
         * @internal
         */
        [setAsCwd](oldCwd) {
          if (oldCwd === this)
            return;
          oldCwd.isCWD = false;
          this.isCWD = true;
          const changed = /* @__PURE__ */ new Set([]);
          let rp = [];
          let p = this;
          while (p && p.parent) {
            changed.add(p);
            p.#relative = rp.join(this.sep);
            p.#relativePosix = rp.join("/");
            p = p.parent;
            rp.push("..");
          }
          p = oldCwd;
          while (p && p.parent && !changed.has(p)) {
            p.#relative = void 0;
            p.#relativePosix = void 0;
            p = p.parent;
          }
        }
      };
      exports.PathBase = PathBase;
      var PathWin32 = class _PathWin32 extends PathBase {
        /**
         * Separator for generating path strings.
         */
        sep = "\\";
        /**
         * Separator for parsing path strings.
         */
        splitSep = eitherSep;
        /**
         * Do not create new Path objects directly.  They should always be accessed
         * via the PathScurry class or other methods on the Path class.
         *
         * @internal
         */
        constructor(name, type = UNKNOWN, root, roots, nocase, children, opts) {
          super(name, type, root, roots, nocase, children, opts);
        }
        /**
         * @internal
         */
        newChild(name, type = UNKNOWN, opts = {}) {
          return new _PathWin32(name, type, this.root, this.roots, this.nocase, this.childrenCache(), opts);
        }
        /**
         * @internal
         */
        getRootString(path) {
          return node_path_1.win32.parse(path).root;
        }
        /**
         * @internal
         */
        getRoot(rootPath) {
          rootPath = uncToDrive(rootPath.toUpperCase());
          if (rootPath === this.root.name) {
            return this.root;
          }
          for (const [compare, root] of Object.entries(this.roots)) {
            if (this.sameRoot(rootPath, compare)) {
              return this.roots[rootPath] = root;
            }
          }
          return this.roots[rootPath] = new PathScurryWin32(rootPath, this).root;
        }
        /**
         * @internal
         */
        sameRoot(rootPath, compare = this.root.name) {
          rootPath = rootPath.toUpperCase().replace(/\//g, "\\").replace(uncDriveRegexp, "$1\\");
          return rootPath === compare;
        }
      };
      exports.PathWin32 = PathWin32;
      var PathPosix = class _PathPosix extends PathBase {
        /**
         * separator for parsing path strings
         */
        splitSep = "/";
        /**
         * separator for generating path strings
         */
        sep = "/";
        /**
         * Do not create new Path objects directly.  They should always be accessed
         * via the PathScurry class or other methods on the Path class.
         *
         * @internal
         */
        constructor(name, type = UNKNOWN, root, roots, nocase, children, opts) {
          super(name, type, root, roots, nocase, children, opts);
        }
        /**
         * @internal
         */
        getRootString(path) {
          return path.startsWith("/") ? "/" : "";
        }
        /**
         * @internal
         */
        getRoot(_rootPath) {
          return this.root;
        }
        /**
         * @internal
         */
        newChild(name, type = UNKNOWN, opts = {}) {
          return new _PathPosix(name, type, this.root, this.roots, this.nocase, this.childrenCache(), opts);
        }
      };
      exports.PathPosix = PathPosix;
      var PathScurryBase = class {
        /**
         * The root Path entry for the current working directory of this Scurry
         */
        root;
        /**
         * The string path for the root of this Scurry's current working directory
         */
        rootPath;
        /**
         * A collection of all roots encountered, referenced by rootPath
         */
        roots;
        /**
         * The Path entry corresponding to this PathScurry's current working directory.
         */
        cwd;
        #resolveCache;
        #resolvePosixCache;
        #children;
        /**
         * Perform path comparisons case-insensitively.
         *
         * Defaults true on Darwin and Windows systems, false elsewhere.
         */
        nocase;
        #fs;
        /**
         * This class should not be instantiated directly.
         *
         * Use PathScurryWin32, PathScurryDarwin, PathScurryPosix, or PathScurry
         *
         * @internal
         */
        constructor(cwd = process.cwd(), pathImpl, sep, { nocase, childrenCacheSize = 16 * 1024, fs = defaultFS } = {}) {
          this.#fs = fsFromOption(fs);
          if (cwd instanceof URL || cwd.startsWith("file://")) {
            cwd = (0, node_url_1.fileURLToPath)(cwd);
          }
          const cwdPath = pathImpl.resolve(cwd);
          this.roots = /* @__PURE__ */ Object.create(null);
          this.rootPath = this.parseRootPath(cwdPath);
          this.#resolveCache = new ResolveCache();
          this.#resolvePosixCache = new ResolveCache();
          this.#children = new ChildrenCache(childrenCacheSize);
          const split = cwdPath.substring(this.rootPath.length).split(sep);
          if (split.length === 1 && !split[0]) {
            split.pop();
          }
          if (nocase === void 0) {
            throw new TypeError("must provide nocase setting to PathScurryBase ctor");
          }
          this.nocase = nocase;
          this.root = this.newRoot(this.#fs);
          this.roots[this.rootPath] = this.root;
          let prev = this.root;
          let len = split.length - 1;
          const joinSep = pathImpl.sep;
          let abs = this.rootPath;
          let sawFirst = false;
          for (const part of split) {
            const l = len--;
            prev = prev.child(part, {
              relative: new Array(l).fill("..").join(joinSep),
              relativePosix: new Array(l).fill("..").join("/"),
              fullpath: abs += (sawFirst ? "" : joinSep) + part
            });
            sawFirst = true;
          }
          this.cwd = prev;
        }
        /**
         * Get the depth of a provided path, string, or the cwd
         */
        depth(path = this.cwd) {
          if (typeof path === "string") {
            path = this.cwd.resolve(path);
          }
          return path.depth();
        }
        /**
         * Return the cache of child entries.  Exposed so subclasses can create
         * child Path objects in a platform-specific way.
         *
         * @internal
         */
        childrenCache() {
          return this.#children;
        }
        /**
         * Resolve one or more path strings to a resolved string
         *
         * Same interface as require('path').resolve.
         *
         * Much faster than path.resolve() when called multiple times for the same
         * path, because the resolved Path objects are cached.  Much slower
         * otherwise.
         */
        resolve(...paths) {
          let r = "";
          for (let i = paths.length - 1; i >= 0; i--) {
            const p = paths[i];
            if (!p || p === ".")
              continue;
            r = r ? `${p}/${r}` : p;
            if (this.isAbsolute(p)) {
              break;
            }
          }
          const cached = this.#resolveCache.get(r);
          if (cached !== void 0) {
            return cached;
          }
          const result = this.cwd.resolve(r).fullpath();
          this.#resolveCache.set(r, result);
          return result;
        }
        /**
         * Resolve one or more path strings to a resolved string, returning
         * the posix path.  Identical to .resolve() on posix systems, but on
         * windows will return a forward-slash separated UNC path.
         *
         * Same interface as require('path').resolve.
         *
         * Much faster than path.resolve() when called multiple times for the same
         * path, because the resolved Path objects are cached.  Much slower
         * otherwise.
         */
        resolvePosix(...paths) {
          let r = "";
          for (let i = paths.length - 1; i >= 0; i--) {
            const p = paths[i];
            if (!p || p === ".")
              continue;
            r = r ? `${p}/${r}` : p;
            if (this.isAbsolute(p)) {
              break;
            }
          }
          const cached = this.#resolvePosixCache.get(r);
          if (cached !== void 0) {
            return cached;
          }
          const result = this.cwd.resolve(r).fullpathPosix();
          this.#resolvePosixCache.set(r, result);
          return result;
        }
        /**
         * find the relative path from the cwd to the supplied path string or entry
         */
        relative(entry = this.cwd) {
          if (typeof entry === "string") {
            entry = this.cwd.resolve(entry);
          }
          return entry.relative();
        }
        /**
         * find the relative path from the cwd to the supplied path string or
         * entry, using / as the path delimiter, even on Windows.
         */
        relativePosix(entry = this.cwd) {
          if (typeof entry === "string") {
            entry = this.cwd.resolve(entry);
          }
          return entry.relativePosix();
        }
        /**
         * Return the basename for the provided string or Path object
         */
        basename(entry = this.cwd) {
          if (typeof entry === "string") {
            entry = this.cwd.resolve(entry);
          }
          return entry.name;
        }
        /**
         * Return the dirname for the provided string or Path object
         */
        dirname(entry = this.cwd) {
          if (typeof entry === "string") {
            entry = this.cwd.resolve(entry);
          }
          return (entry.parent || entry).fullpath();
        }
        async readdir(entry = this.cwd, opts = {
          withFileTypes: true
        }) {
          if (typeof entry === "string") {
            entry = this.cwd.resolve(entry);
          } else if (!(entry instanceof PathBase)) {
            opts = entry;
            entry = this.cwd;
          }
          const { withFileTypes } = opts;
          if (!entry.canReaddir()) {
            return [];
          } else {
            const p = await entry.readdir();
            return withFileTypes ? p : p.map((e) => e.name);
          }
        }
        readdirSync(entry = this.cwd, opts = {
          withFileTypes: true
        }) {
          if (typeof entry === "string") {
            entry = this.cwd.resolve(entry);
          } else if (!(entry instanceof PathBase)) {
            opts = entry;
            entry = this.cwd;
          }
          const { withFileTypes = true } = opts;
          if (!entry.canReaddir()) {
            return [];
          } else if (withFileTypes) {
            return entry.readdirSync();
          } else {
            return entry.readdirSync().map((e) => e.name);
          }
        }
        /**
         * Call lstat() on the string or Path object, and update all known
         * information that can be determined.
         *
         * Note that unlike `fs.lstat()`, the returned value does not contain some
         * information, such as `mode`, `dev`, `nlink`, and `ino`.  If that
         * information is required, you will need to call `fs.lstat` yourself.
         *
         * If the Path refers to a nonexistent file, or if the lstat call fails for
         * any reason, `undefined` is returned.  Otherwise the updated Path object is
         * returned.
         *
         * Results are cached, and thus may be out of date if the filesystem is
         * mutated.
         */
        async lstat(entry = this.cwd) {
          if (typeof entry === "string") {
            entry = this.cwd.resolve(entry);
          }
          return entry.lstat();
        }
        /**
         * synchronous {@link PathScurryBase.lstat}
         */
        lstatSync(entry = this.cwd) {
          if (typeof entry === "string") {
            entry = this.cwd.resolve(entry);
          }
          return entry.lstatSync();
        }
        async readlink(entry = this.cwd, { withFileTypes } = {
          withFileTypes: false
        }) {
          if (typeof entry === "string") {
            entry = this.cwd.resolve(entry);
          } else if (!(entry instanceof PathBase)) {
            withFileTypes = entry.withFileTypes;
            entry = this.cwd;
          }
          const e = await entry.readlink();
          return withFileTypes ? e : e?.fullpath();
        }
        readlinkSync(entry = this.cwd, { withFileTypes } = {
          withFileTypes: false
        }) {
          if (typeof entry === "string") {
            entry = this.cwd.resolve(entry);
          } else if (!(entry instanceof PathBase)) {
            withFileTypes = entry.withFileTypes;
            entry = this.cwd;
          }
          const e = entry.readlinkSync();
          return withFileTypes ? e : e?.fullpath();
        }
        async realpath(entry = this.cwd, { withFileTypes } = {
          withFileTypes: false
        }) {
          if (typeof entry === "string") {
            entry = this.cwd.resolve(entry);
          } else if (!(entry instanceof PathBase)) {
            withFileTypes = entry.withFileTypes;
            entry = this.cwd;
          }
          const e = await entry.realpath();
          return withFileTypes ? e : e?.fullpath();
        }
        realpathSync(entry = this.cwd, { withFileTypes } = {
          withFileTypes: false
        }) {
          if (typeof entry === "string") {
            entry = this.cwd.resolve(entry);
          } else if (!(entry instanceof PathBase)) {
            withFileTypes = entry.withFileTypes;
            entry = this.cwd;
          }
          const e = entry.realpathSync();
          return withFileTypes ? e : e?.fullpath();
        }
        async walk(entry = this.cwd, opts = {}) {
          if (typeof entry === "string") {
            entry = this.cwd.resolve(entry);
          } else if (!(entry instanceof PathBase)) {
            opts = entry;
            entry = this.cwd;
          }
          const { withFileTypes = true, follow = false, filter, walkFilter } = opts;
          const results = [];
          if (!filter || filter(entry)) {
            results.push(withFileTypes ? entry : entry.fullpath());
          }
          const dirs = /* @__PURE__ */ new Set();
          const walk = (dir, cb) => {
            dirs.add(dir);
            dir.readdirCB((er, entries) => {
              if (er) {
                return cb(er);
              }
              let len = entries.length;
              if (!len)
                return cb();
              const next = () => {
                if (--len === 0) {
                  cb();
                }
              };
              for (const e of entries) {
                if (!filter || filter(e)) {
                  results.push(withFileTypes ? e : e.fullpath());
                }
                if (follow && e.isSymbolicLink()) {
                  e.realpath().then((r) => r?.isUnknown() ? r.lstat() : r).then((r) => r?.shouldWalk(dirs, walkFilter) ? walk(r, next) : next());
                } else {
                  if (e.shouldWalk(dirs, walkFilter)) {
                    walk(e, next);
                  } else {
                    next();
                  }
                }
              }
            }, true);
          };
          const start = entry;
          return new Promise((res, rej) => {
            walk(start, (er) => {
              if (er)
                return rej(er);
              res(results);
            });
          });
        }
        walkSync(entry = this.cwd, opts = {}) {
          if (typeof entry === "string") {
            entry = this.cwd.resolve(entry);
          } else if (!(entry instanceof PathBase)) {
            opts = entry;
            entry = this.cwd;
          }
          const { withFileTypes = true, follow = false, filter, walkFilter } = opts;
          const results = [];
          if (!filter || filter(entry)) {
            results.push(withFileTypes ? entry : entry.fullpath());
          }
          const dirs = /* @__PURE__ */ new Set([entry]);
          for (const dir of dirs) {
            const entries = dir.readdirSync();
            for (const e of entries) {
              if (!filter || filter(e)) {
                results.push(withFileTypes ? e : e.fullpath());
              }
              let r = e;
              if (e.isSymbolicLink()) {
                if (!(follow && (r = e.realpathSync())))
                  continue;
                if (r.isUnknown())
                  r.lstatSync();
              }
              if (r.shouldWalk(dirs, walkFilter)) {
                dirs.add(r);
              }
            }
          }
          return results;
        }
        /**
         * Support for `for await`
         *
         * Alias for {@link PathScurryBase.iterate}
         *
         * Note: As of Node 19, this is very slow, compared to other methods of
         * walking.  Consider using {@link PathScurryBase.stream} if memory overhead
         * and backpressure are concerns, or {@link PathScurryBase.walk} if not.
         */
        [Symbol.asyncIterator]() {
          return this.iterate();
        }
        iterate(entry = this.cwd, options = {}) {
          if (typeof entry === "string") {
            entry = this.cwd.resolve(entry);
          } else if (!(entry instanceof PathBase)) {
            options = entry;
            entry = this.cwd;
          }
          return this.stream(entry, options)[Symbol.asyncIterator]();
        }
        /**
         * Iterating over a PathScurry performs a synchronous walk.
         *
         * Alias for {@link PathScurryBase.iterateSync}
         */
        [Symbol.iterator]() {
          return this.iterateSync();
        }
        *iterateSync(entry = this.cwd, opts = {}) {
          if (typeof entry === "string") {
            entry = this.cwd.resolve(entry);
          } else if (!(entry instanceof PathBase)) {
            opts = entry;
            entry = this.cwd;
          }
          const { withFileTypes = true, follow = false, filter, walkFilter } = opts;
          if (!filter || filter(entry)) {
            yield withFileTypes ? entry : entry.fullpath();
          }
          const dirs = /* @__PURE__ */ new Set([entry]);
          for (const dir of dirs) {
            const entries = dir.readdirSync();
            for (const e of entries) {
              if (!filter || filter(e)) {
                yield withFileTypes ? e : e.fullpath();
              }
              let r = e;
              if (e.isSymbolicLink()) {
                if (!(follow && (r = e.realpathSync())))
                  continue;
                if (r.isUnknown())
                  r.lstatSync();
              }
              if (r.shouldWalk(dirs, walkFilter)) {
                dirs.add(r);
              }
            }
          }
        }
        stream(entry = this.cwd, opts = {}) {
          if (typeof entry === "string") {
            entry = this.cwd.resolve(entry);
          } else if (!(entry instanceof PathBase)) {
            opts = entry;
            entry = this.cwd;
          }
          const { withFileTypes = true, follow = false, filter, walkFilter } = opts;
          const results = new minipass_1.Minipass({ objectMode: true });
          if (!filter || filter(entry)) {
            results.write(withFileTypes ? entry : entry.fullpath());
          }
          const dirs = /* @__PURE__ */ new Set();
          const queue = [entry];
          let processing = 0;
          const process2 = () => {
            let paused = false;
            while (!paused) {
              const dir = queue.shift();
              if (!dir) {
                if (processing === 0)
                  results.end();
                return;
              }
              processing++;
              dirs.add(dir);
              const onReaddir = (er, entries, didRealpaths = false) => {
                if (er)
                  return results.emit("error", er);
                if (follow && !didRealpaths) {
                  const promises = [];
                  for (const e of entries) {
                    if (e.isSymbolicLink()) {
                      promises.push(e.realpath().then((r) => r?.isUnknown() ? r.lstat() : r));
                    }
                  }
                  if (promises.length) {
                    Promise.all(promises).then(() => onReaddir(null, entries, true));
                    return;
                  }
                }
                for (const e of entries) {
                  if (e && (!filter || filter(e))) {
                    if (!results.write(withFileTypes ? e : e.fullpath())) {
                      paused = true;
                    }
                  }
                }
                processing--;
                for (const e of entries) {
                  const r = e.realpathCached() || e;
                  if (r.shouldWalk(dirs, walkFilter)) {
                    queue.push(r);
                  }
                }
                if (paused && !results.flowing) {
                  results.once("drain", process2);
                } else if (!sync) {
                  process2();
                }
              };
              let sync = true;
              dir.readdirCB(onReaddir, true);
              sync = false;
            }
          };
          process2();
          return results;
        }
        streamSync(entry = this.cwd, opts = {}) {
          if (typeof entry === "string") {
            entry = this.cwd.resolve(entry);
          } else if (!(entry instanceof PathBase)) {
            opts = entry;
            entry = this.cwd;
          }
          const { withFileTypes = true, follow = false, filter, walkFilter } = opts;
          const results = new minipass_1.Minipass({ objectMode: true });
          const dirs = /* @__PURE__ */ new Set();
          if (!filter || filter(entry)) {
            results.write(withFileTypes ? entry : entry.fullpath());
          }
          const queue = [entry];
          let processing = 0;
          const process2 = () => {
            let paused = false;
            while (!paused) {
              const dir = queue.shift();
              if (!dir) {
                if (processing === 0)
                  results.end();
                return;
              }
              processing++;
              dirs.add(dir);
              const entries = dir.readdirSync();
              for (const e of entries) {
                if (!filter || filter(e)) {
                  if (!results.write(withFileTypes ? e : e.fullpath())) {
                    paused = true;
                  }
                }
              }
              processing--;
              for (const e of entries) {
                let r = e;
                if (e.isSymbolicLink()) {
                  if (!(follow && (r = e.realpathSync())))
                    continue;
                  if (r.isUnknown())
                    r.lstatSync();
                }
                if (r.shouldWalk(dirs, walkFilter)) {
                  queue.push(r);
                }
              }
            }
            if (paused && !results.flowing)
              results.once("drain", process2);
          };
          process2();
          return results;
        }
        chdir(path = this.cwd) {
          const oldCwd = this.cwd;
          this.cwd = typeof path === "string" ? this.cwd.resolve(path) : path;
          this.cwd[setAsCwd](oldCwd);
        }
      };
      exports.PathScurryBase = PathScurryBase;
      var PathScurryWin32 = class extends PathScurryBase {
        /**
         * separator for generating path strings
         */
        sep = "\\";
        constructor(cwd = process.cwd(), opts = {}) {
          const { nocase = true } = opts;
          super(cwd, node_path_1.win32, "\\", { ...opts, nocase });
          this.nocase = nocase;
          for (let p = this.cwd; p; p = p.parent) {
            p.nocase = this.nocase;
          }
        }
        /**
         * @internal
         */
        parseRootPath(dir) {
          return node_path_1.win32.parse(dir).root.toUpperCase();
        }
        /**
         * @internal
         */
        newRoot(fs) {
          return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs });
        }
        /**
         * Return true if the provided path string is an absolute path
         */
        isAbsolute(p) {
          return p.startsWith("/") || p.startsWith("\\") || /^[a-z]:(\/|\\)/i.test(p);
        }
      };
      exports.PathScurryWin32 = PathScurryWin32;
      var PathScurryPosix = class extends PathScurryBase {
        /**
         * separator for generating path strings
         */
        sep = "/";
        constructor(cwd = process.cwd(), opts = {}) {
          const { nocase = false } = opts;
          super(cwd, node_path_1.posix, "/", { ...opts, nocase });
          this.nocase = nocase;
        }
        /**
         * @internal
         */
        parseRootPath(_dir) {
          return "/";
        }
        /**
         * @internal
         */
        newRoot(fs) {
          return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs });
        }
        /**
         * Return true if the provided path string is an absolute path
         */
        isAbsolute(p) {
          return p.startsWith("/");
        }
      };
      exports.PathScurryPosix = PathScurryPosix;
      var PathScurryDarwin = class extends PathScurryPosix {
        constructor(cwd = process.cwd(), opts = {}) {
          const { nocase = true } = opts;
          super(cwd, { ...opts, nocase });
        }
      };
      exports.PathScurryDarwin = PathScurryDarwin;
      exports.Path = process.platform === "win32" ? PathWin32 : PathPosix;
      exports.PathScurry = process.platform === "win32" ? PathScurryWin32 : process.platform === "darwin" ? PathScurryDarwin : PathScurryPosix;
    }
  });

  // ../../node_modules/glob/dist/commonjs/pattern.js
  var require_pattern = __commonJS({
    "../../node_modules/glob/dist/commonjs/pattern.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.Pattern = void 0;
      var minimatch_1 = require_commonjs();
      var isPatternList = (pl) => pl.length >= 1;
      var isGlobList = (gl) => gl.length >= 1;
      var Pattern = class _Pattern {
        #patternList;
        #globList;
        #index;
        length;
        #platform;
        #rest;
        #globString;
        #isDrive;
        #isUNC;
        #isAbsolute;
        #followGlobstar = true;
        constructor(patternList, globList, index, platform) {
          if (!isPatternList(patternList)) {
            throw new TypeError("empty pattern list");
          }
          if (!isGlobList(globList)) {
            throw new TypeError("empty glob list");
          }
          if (globList.length !== patternList.length) {
            throw new TypeError("mismatched pattern list and glob list lengths");
          }
          this.length = patternList.length;
          if (index < 0 || index >= this.length) {
            throw new TypeError("index out of range");
          }
          this.#patternList = patternList;
          this.#globList = globList;
          this.#index = index;
          this.#platform = platform;
          if (this.#index === 0) {
            if (this.isUNC()) {
              const [p0, p1, p2, p3, ...prest] = this.#patternList;
              const [g0, g1, g2, g3, ...grest] = this.#globList;
              if (prest[0] === "") {
                prest.shift();
                grest.shift();
              }
              const p = [p0, p1, p2, p3, ""].join("/");
              const g = [g0, g1, g2, g3, ""].join("/");
              this.#patternList = [p, ...prest];
              this.#globList = [g, ...grest];
              this.length = this.#patternList.length;
            } else if (this.isDrive() || this.isAbsolute()) {
              const [p1, ...prest] = this.#patternList;
              const [g1, ...grest] = this.#globList;
              if (prest[0] === "") {
                prest.shift();
                grest.shift();
              }
              const p = p1 + "/";
              const g = g1 + "/";
              this.#patternList = [p, ...prest];
              this.#globList = [g, ...grest];
              this.length = this.#patternList.length;
            }
          }
        }
        /**
         * The first entry in the parsed list of patterns
         */
        pattern() {
          return this.#patternList[this.#index];
        }
        /**
         * true of if pattern() returns a string
         */
        isString() {
          return typeof this.#patternList[this.#index] === "string";
        }
        /**
         * true of if pattern() returns GLOBSTAR
         */
        isGlobstar() {
          return this.#patternList[this.#index] === minimatch_1.GLOBSTAR;
        }
        /**
         * true if pattern() returns a regexp
         */
        isRegExp() {
          return this.#patternList[this.#index] instanceof RegExp;
        }
        /**
         * The /-joined set of glob parts that make up this pattern
         */
        globString() {
          return this.#globString = this.#globString || (this.#index === 0 ? this.isAbsolute() ? this.#globList[0] + this.#globList.slice(1).join("/") : this.#globList.join("/") : this.#globList.slice(this.#index).join("/"));
        }
        /**
         * true if there are more pattern parts after this one
         */
        hasMore() {
          return this.length > this.#index + 1;
        }
        /**
         * The rest of the pattern after this part, or null if this is the end
         */
        rest() {
          if (this.#rest !== void 0)
            return this.#rest;
          if (!this.hasMore())
            return this.#rest = null;
          this.#rest = new _Pattern(this.#patternList, this.#globList, this.#index + 1, this.#platform);
          this.#rest.#isAbsolute = this.#isAbsolute;
          this.#rest.#isUNC = this.#isUNC;
          this.#rest.#isDrive = this.#isDrive;
          return this.#rest;
        }
        /**
         * true if the pattern represents a //unc/path/ on windows
         */
        isUNC() {
          const pl = this.#patternList;
          return this.#isUNC !== void 0 ? this.#isUNC : this.#isUNC = this.#platform === "win32" && this.#index === 0 && pl[0] === "" && pl[1] === "" && typeof pl[2] === "string" && !!pl[2] && typeof pl[3] === "string" && !!pl[3];
        }
        // pattern like C:/...
        // split = ['C:', ...]
        // Enhancement: handle patterns like `c:*` to test the cwd
        // in c: for *, but I don't know of a way to even figure out what that
        // cwd is without actually chdir'ing into it?
        /**
         * True if the pattern starts with a drive letter on Windows
         */
        isDrive() {
          const pl = this.#patternList;
          return this.#isDrive !== void 0 ? this.#isDrive : this.#isDrive = this.#platform === "win32" && this.#index === 0 && this.length > 1 && typeof pl[0] === "string" && /^[a-z]:$/i.test(pl[0]);
        }
        // pattern = '/' or '/...' or '/x/...'
        // split = ['', ''] or ['', ...] or ['', 'x', ...]
        // Drive and UNC both considered absolute on windows
        /**
         * True if the pattern is rooted on an absolute path
         */
        isAbsolute() {
          const pl = this.#patternList;
          return this.#isAbsolute !== void 0 ? this.#isAbsolute : this.#isAbsolute = pl[0] === "" && pl.length > 1 || this.isDrive() || this.isUNC();
        }
        /**
         * consume the root of the pattern, and return it
         */
        root() {
          const p = this.#patternList[0];
          return typeof p === "string" && this.isAbsolute() && this.#index === 0 ? p : "";
        }
        /**
         * Check to see if the current globstar pattern is allowed to follow
         * a symbolic link.
         */
        checkFollowGlobstar() {
          return !(this.#index === 0 || !this.isGlobstar() || !this.#followGlobstar);
        }
        /**
         * Mark that the current globstar pattern is following a symbolic link
         */
        markFollowGlobstar() {
          if (this.#index === 0 || !this.isGlobstar() || !this.#followGlobstar)
            return false;
          this.#followGlobstar = false;
          return true;
        }
      };
      exports.Pattern = Pattern;
    }
  });

  // ../../node_modules/glob/dist/commonjs/ignore.js
  var require_ignore = __commonJS({
    "../../node_modules/glob/dist/commonjs/ignore.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.Ignore = void 0;
      var minimatch_1 = require_commonjs();
      var pattern_js_1 = require_pattern();
      var defaultPlatform = typeof process === "object" && process && typeof process.platform === "string" ? process.platform : "linux";
      var Ignore = class {
        relative;
        relativeChildren;
        absolute;
        absoluteChildren;
        platform;
        mmopts;
        constructor(ignored, { nobrace, nocase, noext, noglobstar, platform = defaultPlatform }) {
          this.relative = [];
          this.absolute = [];
          this.relativeChildren = [];
          this.absoluteChildren = [];
          this.platform = platform;
          this.mmopts = {
            dot: true,
            nobrace,
            nocase,
            noext,
            noglobstar,
            optimizationLevel: 2,
            platform,
            nocomment: true,
            nonegate: true
          };
          for (const ign of ignored)
            this.add(ign);
        }
        add(ign) {
          const mm = new minimatch_1.Minimatch(ign, this.mmopts);
          for (let i = 0; i < mm.set.length; i++) {
            const parsed = mm.set[i];
            const globParts = mm.globParts[i];
            if (!parsed || !globParts) {
              throw new Error("invalid pattern object");
            }
            while (parsed[0] === "." && globParts[0] === ".") {
              parsed.shift();
              globParts.shift();
            }
            const p = new pattern_js_1.Pattern(parsed, globParts, 0, this.platform);
            const m = new minimatch_1.Minimatch(p.globString(), this.mmopts);
            const children = globParts[globParts.length - 1] === "**";
            const absolute = p.isAbsolute();
            if (absolute)
              this.absolute.push(m);
            else
              this.relative.push(m);
            if (children) {
              if (absolute)
                this.absoluteChildren.push(m);
              else
                this.relativeChildren.push(m);
            }
          }
        }
        ignored(p) {
          const fullpath = p.fullpath();
          const fullpaths = `${fullpath}/`;
          const relative = p.relative() || ".";
          const relatives = `${relative}/`;
          for (const m of this.relative) {
            if (m.match(relative) || m.match(relatives))
              return true;
          }
          for (const m of this.absolute) {
            if (m.match(fullpath) || m.match(fullpaths))
              return true;
          }
          return false;
        }
        childrenIgnored(p) {
          const fullpath = p.fullpath() + "/";
          const relative = (p.relative() || ".") + "/";
          for (const m of this.relativeChildren) {
            if (m.match(relative))
              return true;
          }
          for (const m of this.absoluteChildren) {
            if (m.match(fullpath))
              return true;
          }
          return false;
        }
      };
      exports.Ignore = Ignore;
    }
  });

  // ../../node_modules/glob/dist/commonjs/processor.js
  var require_processor = __commonJS({
    "../../node_modules/glob/dist/commonjs/processor.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.Processor = exports.SubWalks = exports.MatchRecord = exports.HasWalkedCache = void 0;
      var minimatch_1 = require_commonjs();
      var HasWalkedCache = class _HasWalkedCache {
        store;
        constructor(store = /* @__PURE__ */ new Map()) {
          this.store = store;
        }
        copy() {
          return new _HasWalkedCache(new Map(this.store));
        }
        hasWalked(target, pattern) {
          return this.store.get(target.fullpath())?.has(pattern.globString());
        }
        storeWalked(target, pattern) {
          const fullpath = target.fullpath();
          const cached = this.store.get(fullpath);
          if (cached)
            cached.add(pattern.globString());
          else
            this.store.set(fullpath, /* @__PURE__ */ new Set([pattern.globString()]));
        }
      };
      exports.HasWalkedCache = HasWalkedCache;
      var MatchRecord = class {
        store = /* @__PURE__ */ new Map();
        add(target, absolute, ifDir) {
          const n = (absolute ? 2 : 0) | (ifDir ? 1 : 0);
          const current = this.store.get(target);
          this.store.set(target, current === void 0 ? n : n & current);
        }
        // match, absolute, ifdir
        entries() {
          return [...this.store.entries()].map(([path, n]) => [
            path,
            !!(n & 2),
            !!(n & 1)
          ]);
        }
      };
      exports.MatchRecord = MatchRecord;
      var SubWalks = class {
        store = /* @__PURE__ */ new Map();
        add(target, pattern) {
          if (!target.canReaddir()) {
            return;
          }
          const subs = this.store.get(target);
          if (subs) {
            if (!subs.find((p) => p.globString() === pattern.globString())) {
              subs.push(pattern);
            }
          } else
            this.store.set(target, [pattern]);
        }
        get(target) {
          const subs = this.store.get(target);
          if (!subs) {
            throw new Error("attempting to walk unknown path");
          }
          return subs;
        }
        entries() {
          return this.keys().map((k) => [k, this.store.get(k)]);
        }
        keys() {
          return [...this.store.keys()].filter((t) => t.canReaddir());
        }
      };
      exports.SubWalks = SubWalks;
      var Processor = class _Processor {
        hasWalkedCache;
        matches = new MatchRecord();
        subwalks = new SubWalks();
        patterns;
        follow;
        dot;
        opts;
        constructor(opts, hasWalkedCache) {
          this.opts = opts;
          this.follow = !!opts.follow;
          this.dot = !!opts.dot;
          this.hasWalkedCache = hasWalkedCache ? hasWalkedCache.copy() : new HasWalkedCache();
        }
        processPatterns(target, patterns) {
          this.patterns = patterns;
          const processingSet = patterns.map((p) => [target, p]);
          for (let [t, pattern] of processingSet) {
            this.hasWalkedCache.storeWalked(t, pattern);
            const root = pattern.root();
            const absolute = pattern.isAbsolute() && this.opts.absolute !== false;
            if (root) {
              t = t.resolve(root === "/" && this.opts.root !== void 0 ? this.opts.root : root);
              const rest2 = pattern.rest();
              if (!rest2) {
                this.matches.add(t, true, false);
                continue;
              } else {
                pattern = rest2;
              }
            }
            if (t.isENOENT())
              continue;
            let p;
            let rest;
            let changed = false;
            while (typeof (p = pattern.pattern()) === "string" && (rest = pattern.rest())) {
              const c = t.resolve(p);
              t = c;
              pattern = rest;
              changed = true;
            }
            p = pattern.pattern();
            rest = pattern.rest();
            if (changed) {
              if (this.hasWalkedCache.hasWalked(t, pattern))
                continue;
              this.hasWalkedCache.storeWalked(t, pattern);
            }
            if (typeof p === "string") {
              const ifDir = p === ".." || p === "" || p === ".";
              this.matches.add(t.resolve(p), absolute, ifDir);
              continue;
            } else if (p === minimatch_1.GLOBSTAR) {
              if (!t.isSymbolicLink() || this.follow || pattern.checkFollowGlobstar()) {
                this.subwalks.add(t, pattern);
              }
              const rp = rest?.pattern();
              const rrest = rest?.rest();
              if (!rest || (rp === "" || rp === ".") && !rrest) {
                this.matches.add(t, absolute, rp === "" || rp === ".");
              } else {
                if (rp === "..") {
                  const tp = t.parent || t;
                  if (!rrest)
                    this.matches.add(tp, absolute, true);
                  else if (!this.hasWalkedCache.hasWalked(tp, rrest)) {
                    this.subwalks.add(tp, rrest);
                  }
                }
              }
            } else if (p instanceof RegExp) {
              this.subwalks.add(t, pattern);
            }
          }
          return this;
        }
        subwalkTargets() {
          return this.subwalks.keys();
        }
        child() {
          return new _Processor(this.opts, this.hasWalkedCache);
        }
        // return a new Processor containing the subwalks for each
        // child entry, and a set of matches, and
        // a hasWalkedCache that's a copy of this one
        // then we're going to call
        filterEntries(parent, entries) {
          const patterns = this.subwalks.get(parent);
          const results = this.child();
          for (const e of entries) {
            for (const pattern of patterns) {
              const absolute = pattern.isAbsolute();
              const p = pattern.pattern();
              const rest = pattern.rest();
              if (p === minimatch_1.GLOBSTAR) {
                results.testGlobstar(e, pattern, rest, absolute);
              } else if (p instanceof RegExp) {
                results.testRegExp(e, p, rest, absolute);
              } else {
                results.testString(e, p, rest, absolute);
              }
            }
          }
          return results;
        }
        testGlobstar(e, pattern, rest, absolute) {
          if (this.dot || !e.name.startsWith(".")) {
            if (!pattern.hasMore()) {
              this.matches.add(e, absolute, false);
            }
            if (e.canReaddir()) {
              if (this.follow || !e.isSymbolicLink()) {
                this.subwalks.add(e, pattern);
              } else if (e.isSymbolicLink()) {
                if (rest && pattern.checkFollowGlobstar()) {
                  this.subwalks.add(e, rest);
                } else if (pattern.markFollowGlobstar()) {
                  this.subwalks.add(e, pattern);
                }
              }
            }
          }
          if (rest) {
            const rp = rest.pattern();
            if (typeof rp === "string" && // dots and empty were handled already
            rp !== ".." && rp !== "" && rp !== ".") {
              this.testString(e, rp, rest.rest(), absolute);
            } else if (rp === "..") {
              const ep = e.parent || e;
              this.subwalks.add(ep, rest);
            } else if (rp instanceof RegExp) {
              this.testRegExp(e, rp, rest.rest(), absolute);
            }
          }
        }
        testRegExp(e, p, rest, absolute) {
          if (!p.test(e.name))
            return;
          if (!rest) {
            this.matches.add(e, absolute, false);
          } else {
            this.subwalks.add(e, rest);
          }
        }
        testString(e, p, rest, absolute) {
          if (!e.isNamed(p))
            return;
          if (!rest) {
            this.matches.add(e, absolute, false);
          } else {
            this.subwalks.add(e, rest);
          }
        }
      };
      exports.Processor = Processor;
    }
  });

  // ../../node_modules/glob/dist/commonjs/walker.js
  var require_walker = __commonJS({
    "../../node_modules/glob/dist/commonjs/walker.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.GlobStream = exports.GlobWalker = exports.GlobUtil = void 0;
      var minipass_1 = require_commonjs3();
      var ignore_js_1 = require_ignore();
      var processor_js_1 = require_processor();
      var makeIgnore = (ignore, opts) => typeof ignore === "string" ? new ignore_js_1.Ignore([ignore], opts) : Array.isArray(ignore) ? new ignore_js_1.Ignore(ignore, opts) : ignore;
      var GlobUtil = class {
        path;
        patterns;
        opts;
        seen = /* @__PURE__ */ new Set();
        paused = false;
        aborted = false;
        #onResume = [];
        #ignore;
        #sep;
        signal;
        maxDepth;
        includeChildMatches;
        constructor(patterns, path, opts) {
          this.patterns = patterns;
          this.path = path;
          this.opts = opts;
          this.#sep = !opts.posix && opts.platform === "win32" ? "\\" : "/";
          this.includeChildMatches = opts.includeChildMatches !== false;
          if (opts.ignore || !this.includeChildMatches) {
            this.#ignore = makeIgnore(opts.ignore ?? [], opts);
            if (!this.includeChildMatches && typeof this.#ignore.add !== "function") {
              const m = "cannot ignore child matches, ignore lacks add() method.";
              throw new Error(m);
            }
          }
          this.maxDepth = opts.maxDepth || Infinity;
          if (opts.signal) {
            this.signal = opts.signal;
            this.signal.addEventListener("abort", () => {
              this.#onResume.length = 0;
            });
          }
        }
        #ignored(path) {
          return this.seen.has(path) || !!this.#ignore?.ignored?.(path);
        }
        #childrenIgnored(path) {
          return !!this.#ignore?.childrenIgnored?.(path);
        }
        // backpressure mechanism
        pause() {
          this.paused = true;
        }
        resume() {
          if (this.signal?.aborted)
            return;
          this.paused = false;
          let fn = void 0;
          while (!this.paused && (fn = this.#onResume.shift())) {
            fn();
          }
        }
        onResume(fn) {
          if (this.signal?.aborted)
            return;
          if (!this.paused) {
            fn();
          } else {
            this.#onResume.push(fn);
          }
        }
        // do the requisite realpath/stat checking, and return the path
        // to add or undefined to filter it out.
        async matchCheck(e, ifDir) {
          if (ifDir && this.opts.nodir)
            return void 0;
          let rpc;
          if (this.opts.realpath) {
            rpc = e.realpathCached() || await e.realpath();
            if (!rpc)
              return void 0;
            e = rpc;
          }
          const needStat = e.isUnknown() || this.opts.stat;
          const s = needStat ? await e.lstat() : e;
          if (this.opts.follow && this.opts.nodir && s?.isSymbolicLink()) {
            const target = await s.realpath();
            if (target && (target.isUnknown() || this.opts.stat)) {
              await target.lstat();
            }
          }
          return this.matchCheckTest(s, ifDir);
        }
        matchCheckTest(e, ifDir) {
          return e && (this.maxDepth === Infinity || e.depth() <= this.maxDepth) && (!ifDir || e.canReaddir()) && (!this.opts.nodir || !e.isDirectory()) && (!this.opts.nodir || !this.opts.follow || !e.isSymbolicLink() || !e.realpathCached()?.isDirectory()) && !this.#ignored(e) ? e : void 0;
        }
        matchCheckSync(e, ifDir) {
          if (ifDir && this.opts.nodir)
            return void 0;
          let rpc;
          if (this.opts.realpath) {
            rpc = e.realpathCached() || e.realpathSync();
            if (!rpc)
              return void 0;
            e = rpc;
          }
          const needStat = e.isUnknown() || this.opts.stat;
          const s = needStat ? e.lstatSync() : e;
          if (this.opts.follow && this.opts.nodir && s?.isSymbolicLink()) {
            const target = s.realpathSync();
            if (target && (target?.isUnknown() || this.opts.stat)) {
              target.lstatSync();
            }
          }
          return this.matchCheckTest(s, ifDir);
        }
        matchFinish(e, absolute) {
          if (this.#ignored(e))
            return;
          if (!this.includeChildMatches && this.#ignore?.add) {
            const ign = `${e.relativePosix()}/**`;
            this.#ignore.add(ign);
          }
          const abs = this.opts.absolute === void 0 ? absolute : this.opts.absolute;
          this.seen.add(e);
          const mark = this.opts.mark && e.isDirectory() ? this.#sep : "";
          if (this.opts.withFileTypes) {
            this.matchEmit(e);
          } else if (abs) {
            const abs2 = this.opts.posix ? e.fullpathPosix() : e.fullpath();
            this.matchEmit(abs2 + mark);
          } else {
            const rel = this.opts.posix ? e.relativePosix() : e.relative();
            const pre = this.opts.dotRelative && !rel.startsWith(".." + this.#sep) ? "." + this.#sep : "";
            this.matchEmit(!rel ? "." + mark : pre + rel + mark);
          }
        }
        async match(e, absolute, ifDir) {
          const p = await this.matchCheck(e, ifDir);
          if (p)
            this.matchFinish(p, absolute);
        }
        matchSync(e, absolute, ifDir) {
          const p = this.matchCheckSync(e, ifDir);
          if (p)
            this.matchFinish(p, absolute);
        }
        walkCB(target, patterns, cb) {
          if (this.signal?.aborted)
            cb();
          this.walkCB2(target, patterns, new processor_js_1.Processor(this.opts), cb);
        }
        walkCB2(target, patterns, processor, cb) {
          if (this.#childrenIgnored(target))
            return cb();
          if (this.signal?.aborted)
            cb();
          if (this.paused) {
            this.onResume(() => this.walkCB2(target, patterns, processor, cb));
            return;
          }
          processor.processPatterns(target, patterns);
          let tasks = 1;
          const next = () => {
            if (--tasks === 0)
              cb();
          };
          for (const [m, absolute, ifDir] of processor.matches.entries()) {
            if (this.#ignored(m))
              continue;
            tasks++;
            this.match(m, absolute, ifDir).then(() => next());
          }
          for (const t of processor.subwalkTargets()) {
            if (this.maxDepth !== Infinity && t.depth() >= this.maxDepth) {
              continue;
            }
            tasks++;
            const childrenCached = t.readdirCached();
            if (t.calledReaddir())
              this.walkCB3(t, childrenCached, processor, next);
            else {
              t.readdirCB((_, entries) => this.walkCB3(t, entries, processor, next), true);
            }
          }
          next();
        }
        walkCB3(target, entries, processor, cb) {
          processor = processor.filterEntries(target, entries);
          let tasks = 1;
          const next = () => {
            if (--tasks === 0)
              cb();
          };
          for (const [m, absolute, ifDir] of processor.matches.entries()) {
            if (this.#ignored(m))
              continue;
            tasks++;
            this.match(m, absolute, ifDir).then(() => next());
          }
          for (const [target2, patterns] of processor.subwalks.entries()) {
            tasks++;
            this.walkCB2(target2, patterns, processor.child(), next);
          }
          next();
        }
        walkCBSync(target, patterns, cb) {
          if (this.signal?.aborted)
            cb();
          this.walkCB2Sync(target, patterns, new processor_js_1.Processor(this.opts), cb);
        }
        walkCB2Sync(target, patterns, processor, cb) {
          if (this.#childrenIgnored(target))
            return cb();
          if (this.signal?.aborted)
            cb();
          if (this.paused) {
            this.onResume(() => this.walkCB2Sync(target, patterns, processor, cb));
            return;
          }
          processor.processPatterns(target, patterns);
          let tasks = 1;
          const next = () => {
            if (--tasks === 0)
              cb();
          };
          for (const [m, absolute, ifDir] of processor.matches.entries()) {
            if (this.#ignored(m))
              continue;
            this.matchSync(m, absolute, ifDir);
          }
          for (const t of processor.subwalkTargets()) {
            if (this.maxDepth !== Infinity && t.depth() >= this.maxDepth) {
              continue;
            }
            tasks++;
            const children = t.readdirSync();
            this.walkCB3Sync(t, children, processor, next);
          }
          next();
        }
        walkCB3Sync(target, entries, processor, cb) {
          processor = processor.filterEntries(target, entries);
          let tasks = 1;
          const next = () => {
            if (--tasks === 0)
              cb();
          };
          for (const [m, absolute, ifDir] of processor.matches.entries()) {
            if (this.#ignored(m))
              continue;
            this.matchSync(m, absolute, ifDir);
          }
          for (const [target2, patterns] of processor.subwalks.entries()) {
            tasks++;
            this.walkCB2Sync(target2, patterns, processor.child(), next);
          }
          next();
        }
      };
      exports.GlobUtil = GlobUtil;
      var GlobWalker = class extends GlobUtil {
        matches = /* @__PURE__ */ new Set();
        constructor(patterns, path, opts) {
          super(patterns, path, opts);
        }
        matchEmit(e) {
          this.matches.add(e);
        }
        async walk() {
          if (this.signal?.aborted)
            throw this.signal.reason;
          if (this.path.isUnknown()) {
            await this.path.lstat();
          }
          await new Promise((res, rej) => {
            this.walkCB(this.path, this.patterns, () => {
              if (this.signal?.aborted) {
                rej(this.signal.reason);
              } else {
                res(this.matches);
              }
            });
          });
          return this.matches;
        }
        walkSync() {
          if (this.signal?.aborted)
            throw this.signal.reason;
          if (this.path.isUnknown()) {
            this.path.lstatSync();
          }
          this.walkCBSync(this.path, this.patterns, () => {
            if (this.signal?.aborted)
              throw this.signal.reason;
          });
          return this.matches;
        }
      };
      exports.GlobWalker = GlobWalker;
      var GlobStream = class extends GlobUtil {
        results;
        constructor(patterns, path, opts) {
          super(patterns, path, opts);
          this.results = new minipass_1.Minipass({
            signal: this.signal,
            objectMode: true
          });
          this.results.on("drain", () => this.resume());
          this.results.on("resume", () => this.resume());
        }
        matchEmit(e) {
          this.results.write(e);
          if (!this.results.flowing)
            this.pause();
        }
        stream() {
          const target = this.path;
          if (target.isUnknown()) {
            target.lstat().then(() => {
              this.walkCB(target, this.patterns, () => this.results.end());
            });
          } else {
            this.walkCB(target, this.patterns, () => this.results.end());
          }
          return this.results;
        }
        streamSync() {
          if (this.path.isUnknown()) {
            this.path.lstatSync();
          }
          this.walkCBSync(this.path, this.patterns, () => this.results.end());
          return this.results;
        }
      };
      exports.GlobStream = GlobStream;
    }
  });

  // ../../node_modules/glob/dist/commonjs/glob.js
  var require_glob = __commonJS({
    "../../node_modules/glob/dist/commonjs/glob.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.Glob = void 0;
      var minimatch_1 = require_commonjs();
      var node_url_1 = __require("bare-url");
      var path_scurry_1 = require_commonjs4();
      var pattern_js_1 = require_pattern();
      var walker_js_1 = require_walker();
      var defaultPlatform = typeof process === "object" && process && typeof process.platform === "string" ? process.platform : "linux";
      var Glob = class {
        absolute;
        cwd;
        root;
        dot;
        dotRelative;
        follow;
        ignore;
        magicalBraces;
        mark;
        matchBase;
        maxDepth;
        nobrace;
        nocase;
        nodir;
        noext;
        noglobstar;
        pattern;
        platform;
        realpath;
        scurry;
        stat;
        signal;
        windowsPathsNoEscape;
        withFileTypes;
        includeChildMatches;
        /**
         * The options provided to the constructor.
         */
        opts;
        /**
         * An array of parsed immutable {@link Pattern} objects.
         */
        patterns;
        /**
         * All options are stored as properties on the `Glob` object.
         *
         * See {@link GlobOptions} for full options descriptions.
         *
         * Note that a previous `Glob` object can be passed as the
         * `GlobOptions` to another `Glob` instantiation to re-use settings
         * and caches with a new pattern.
         *
         * Traversal functions can be called multiple times to run the walk
         * again.
         */
        constructor(pattern, opts) {
          if (!opts)
            throw new TypeError("glob options required");
          this.withFileTypes = !!opts.withFileTypes;
          this.signal = opts.signal;
          this.follow = !!opts.follow;
          this.dot = !!opts.dot;
          this.dotRelative = !!opts.dotRelative;
          this.nodir = !!opts.nodir;
          this.mark = !!opts.mark;
          if (!opts.cwd) {
            this.cwd = "";
          } else if (opts.cwd instanceof URL || opts.cwd.startsWith("file://")) {
            opts.cwd = (0, node_url_1.fileURLToPath)(opts.cwd);
          }
          this.cwd = opts.cwd || "";
          this.root = opts.root;
          this.magicalBraces = !!opts.magicalBraces;
          this.nobrace = !!opts.nobrace;
          this.noext = !!opts.noext;
          this.realpath = !!opts.realpath;
          this.absolute = opts.absolute;
          this.includeChildMatches = opts.includeChildMatches !== false;
          this.noglobstar = !!opts.noglobstar;
          this.matchBase = !!opts.matchBase;
          this.maxDepth = typeof opts.maxDepth === "number" ? opts.maxDepth : Infinity;
          this.stat = !!opts.stat;
          this.ignore = opts.ignore;
          if (this.withFileTypes && this.absolute !== void 0) {
            throw new Error("cannot set absolute and withFileTypes:true");
          }
          if (typeof pattern === "string") {
            pattern = [pattern];
          }
          this.windowsPathsNoEscape = !!opts.windowsPathsNoEscape || opts.allowWindowsEscape === false;
          if (this.windowsPathsNoEscape) {
            pattern = pattern.map((p) => p.replace(/\\/g, "/"));
          }
          if (this.matchBase) {
            if (opts.noglobstar) {
              throw new TypeError("base matching requires globstar");
            }
            pattern = pattern.map((p) => p.includes("/") ? p : `./**/${p}`);
          }
          this.pattern = pattern;
          this.platform = opts.platform || defaultPlatform;
          this.opts = { ...opts, platform: this.platform };
          if (opts.scurry) {
            this.scurry = opts.scurry;
            if (opts.nocase !== void 0 && opts.nocase !== opts.scurry.nocase) {
              throw new Error("nocase option contradicts provided scurry option");
            }
          } else {
            const Scurry = opts.platform === "win32" ? path_scurry_1.PathScurryWin32 : opts.platform === "darwin" ? path_scurry_1.PathScurryDarwin : opts.platform ? path_scurry_1.PathScurryPosix : path_scurry_1.PathScurry;
            this.scurry = new Scurry(this.cwd, {
              nocase: opts.nocase,
              fs: opts.fs
            });
          }
          this.nocase = this.scurry.nocase;
          const nocaseMagicOnly = this.platform === "darwin" || this.platform === "win32";
          const mmo = {
            // default nocase based on platform
            ...opts,
            dot: this.dot,
            matchBase: this.matchBase,
            nobrace: this.nobrace,
            nocase: this.nocase,
            nocaseMagicOnly,
            nocomment: true,
            noext: this.noext,
            nonegate: true,
            optimizationLevel: 2,
            platform: this.platform,
            windowsPathsNoEscape: this.windowsPathsNoEscape,
            debug: !!this.opts.debug
          };
          const mms = this.pattern.map((p) => new minimatch_1.Minimatch(p, mmo));
          const [matchSet, globParts] = mms.reduce((set, m) => {
            set[0].push(...m.set);
            set[1].push(...m.globParts);
            return set;
          }, [[], []]);
          this.patterns = matchSet.map((set, i) => {
            const g = globParts[i];
            if (!g)
              throw new Error("invalid pattern object");
            return new pattern_js_1.Pattern(set, g, 0, this.platform);
          });
        }
        async walk() {
          return [
            ...await new walker_js_1.GlobWalker(this.patterns, this.scurry.cwd, {
              ...this.opts,
              maxDepth: this.maxDepth !== Infinity ? this.maxDepth + this.scurry.cwd.depth() : Infinity,
              platform: this.platform,
              nocase: this.nocase,
              includeChildMatches: this.includeChildMatches
            }).walk()
          ];
        }
        walkSync() {
          return [
            ...new walker_js_1.GlobWalker(this.patterns, this.scurry.cwd, {
              ...this.opts,
              maxDepth: this.maxDepth !== Infinity ? this.maxDepth + this.scurry.cwd.depth() : Infinity,
              platform: this.platform,
              nocase: this.nocase,
              includeChildMatches: this.includeChildMatches
            }).walkSync()
          ];
        }
        stream() {
          return new walker_js_1.GlobStream(this.patterns, this.scurry.cwd, {
            ...this.opts,
            maxDepth: this.maxDepth !== Infinity ? this.maxDepth + this.scurry.cwd.depth() : Infinity,
            platform: this.platform,
            nocase: this.nocase,
            includeChildMatches: this.includeChildMatches
          }).stream();
        }
        streamSync() {
          return new walker_js_1.GlobStream(this.patterns, this.scurry.cwd, {
            ...this.opts,
            maxDepth: this.maxDepth !== Infinity ? this.maxDepth + this.scurry.cwd.depth() : Infinity,
            platform: this.platform,
            nocase: this.nocase,
            includeChildMatches: this.includeChildMatches
          }).streamSync();
        }
        /**
         * Default sync iteration function. Returns a Generator that
         * iterates over the results.
         */
        iterateSync() {
          return this.streamSync()[Symbol.iterator]();
        }
        [Symbol.iterator]() {
          return this.iterateSync();
        }
        /**
         * Default async iteration function. Returns an AsyncGenerator that
         * iterates over the results.
         */
        iterate() {
          return this.stream()[Symbol.asyncIterator]();
        }
        [Symbol.asyncIterator]() {
          return this.iterate();
        }
      };
      exports.Glob = Glob;
    }
  });

  // ../../node_modules/glob/dist/commonjs/has-magic.js
  var require_has_magic = __commonJS({
    "../../node_modules/glob/dist/commonjs/has-magic.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.hasMagic = void 0;
      var minimatch_1 = require_commonjs();
      var hasMagic = (pattern, options = {}) => {
        if (!Array.isArray(pattern)) {
          pattern = [pattern];
        }
        for (const p of pattern) {
          if (new minimatch_1.Minimatch(p, options).hasMagic())
            return true;
        }
        return false;
      };
      exports.hasMagic = hasMagic;
    }
  });

  // ../../node_modules/glob/dist/commonjs/index.js
  var require_commonjs5 = __commonJS({
    "../../node_modules/glob/dist/commonjs/index.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.glob = exports.sync = exports.iterate = exports.iterateSync = exports.stream = exports.streamSync = exports.Ignore = exports.hasMagic = exports.Glob = exports.unescape = exports.escape = void 0;
      exports.globStreamSync = globStreamSync;
      exports.globStream = globStream;
      exports.globSync = globSync;
      exports.globIterateSync = globIterateSync;
      exports.globIterate = globIterate;
      var minimatch_1 = require_commonjs();
      var glob_js_1 = require_glob();
      var has_magic_js_1 = require_has_magic();
      var minimatch_2 = require_commonjs();
      Object.defineProperty(exports, "escape", { enumerable: true, get: function() {
        return minimatch_2.escape;
      } });
      Object.defineProperty(exports, "unescape", { enumerable: true, get: function() {
        return minimatch_2.unescape;
      } });
      var glob_js_2 = require_glob();
      Object.defineProperty(exports, "Glob", { enumerable: true, get: function() {
        return glob_js_2.Glob;
      } });
      var has_magic_js_2 = require_has_magic();
      Object.defineProperty(exports, "hasMagic", { enumerable: true, get: function() {
        return has_magic_js_2.hasMagic;
      } });
      var ignore_js_1 = require_ignore();
      Object.defineProperty(exports, "Ignore", { enumerable: true, get: function() {
        return ignore_js_1.Ignore;
      } });
      function globStreamSync(pattern, options = {}) {
        return new glob_js_1.Glob(pattern, options).streamSync();
      }
      function globStream(pattern, options = {}) {
        return new glob_js_1.Glob(pattern, options).stream();
      }
      function globSync(pattern, options = {}) {
        return new glob_js_1.Glob(pattern, options).walkSync();
      }
      async function glob_(pattern, options = {}) {
        return new glob_js_1.Glob(pattern, options).walk();
      }
      function globIterateSync(pattern, options = {}) {
        return new glob_js_1.Glob(pattern, options).iterateSync();
      }
      function globIterate(pattern, options = {}) {
        return new glob_js_1.Glob(pattern, options).iterate();
      }
      exports.streamSync = globStreamSync;
      exports.stream = Object.assign(globStream, { sync: globStreamSync });
      exports.iterateSync = globIterateSync;
      exports.iterate = Object.assign(globIterate, {
        sync: globIterateSync
      });
      exports.sync = Object.assign(globSync, {
        stream: globStreamSync,
        iterate: globIterateSync
      });
      exports.glob = Object.assign(glob_, {
        glob: glob_,
        globSync,
        sync: exports.sync,
        globStream,
        stream: exports.stream,
        globStreamSync,
        streamSync: exports.streamSync,
        globIterate,
        iterate: exports.iterate,
        globIterateSync,
        iterateSync: exports.iterateSync,
        Glob: glob_js_1.Glob,
        hasMagic: has_magic_js_1.hasMagic,
        escape: minimatch_1.escape,
        unescape: minimatch_1.unescape
      });
      exports.glob.glob = exports.glob;
    }
  });

  // ../../node_modules/bare-dev/lib/android/run.js
  var require_run = __commonJS({
    "../../node_modules/bare-dev/lib/android/run.js"(exports, module) {
      var path = __require("path");
      var { globSync } = require_commonjs5();
      var launch = require_launch();
      var adb = require_adb();
      module.exports = function run(apk, opts = {}) {
        const {
          device = null,
          cwd = path.resolve(".")
        } = opts;
        if (apk === null) {
          [apk = null] = globSync(path.join(cwd, "**/*.apk"), {
            ignore: [
              "**/vendor/**",
              // Ignore unsigned packages
              "**/*-unsigned.apk"
            ]
          });
          if (apk === null) {
            throw new Error("no .apk found");
          }
        }
        const id = launch(device, opts);
        apk = path.resolve(cwd, apk);
        adb.install(id, apk, opts);
        adb.start(id, apk, opts);
      };
    }
  });

  // ../../node_modules/bare-ansi-escapes/index.js
  var require_bare_ansi_escapes = __commonJS({
    "../../node_modules/bare-ansi-escapes/index.js"(exports) {
      var ESC = "\x1B";
      var CSI = ESC + "[";
      var SGR = (n) => CSI + n + "m";
      exports.constants = {
        ESC,
        CSI,
        SGR
      };
      exports.cursorHide = CSI + "?25l";
      exports.cursorShow = CSI + "?25h";
      exports.cursorUp = function cursorUp(n = 1) {
        return CSI + n + "A";
      };
      exports.cursorDown = function cursorDown(n = 1) {
        return CSI + n + "B";
      };
      exports.cursorForward = function cursorForward(n = 1) {
        return CSI + n + "C";
      };
      exports.cursorBack = function cursorBack(n = 1) {
        return CSI + n + "D";
      };
      exports.cursorNextLine = function cursorNextLine(n = 1) {
        return CSI + n + "E";
      };
      exports.cursorPreviousLine = function cursorPreviousLine(n = 1) {
        return CSI + n + "F";
      };
      exports.cursorPosition = function cursorPosition(column, row = 0) {
        if (row === 0) return CSI + (column + 1) + "G";
        return CSI + (row + 1) + ";" + (column + 1) + "H";
      };
      exports.eraseDisplayEnd = CSI + "J";
      exports.eraseDisplayStart = CSI + "1J";
      exports.eraseDisplay = CSI + "2J";
      exports.eraseLineEnd = CSI + "K";
      exports.eraseLineStart = CSI + "1K";
      exports.eraseLine = CSI + "2K";
      exports.scrollUp = function scrollUp(n = 1) {
        return CSI + n + "S";
      };
      exports.scrollDown = function scrollDown(n = 1) {
        return CSI + n + "T";
      };
      exports.modifierReset = SGR(0);
      exports.modifierBold = SGR(1);
      exports.modifierDim = SGR(2);
      exports.modifierItalic = SGR(3);
      exports.modifierUnderline = SGR(4);
      exports.modifierNormal = SGR(22);
      exports.modifierNotItalic = SGR(23);
      exports.modifierNotUnderline = SGR(24);
      exports.colorBlack = SGR(30);
      exports.colorRed = SGR(31);
      exports.colorGreen = SGR(32);
      exports.colorYellow = SGR(33);
      exports.colorBlue = SGR(34);
      exports.colorMagenta = SGR(35);
      exports.colorCyan = SGR(36);
      exports.colorWhite = SGR(37);
      exports.colorDefault = SGR(39);
      exports.colorBrightBlack = SGR(90);
      exports.colorBrightRed = SGR(91);
      exports.colorBrightGreen = SGR(92);
      exports.colorBrightYellow = SGR(93);
      exports.colorBrightBlue = SGR(94);
      exports.colorBrightMagenta = SGR(95);
      exports.colorBrightCyan = SGR(96);
      exports.colorBrightWhite = SGR(97);
    }
  });

  // ../../node_modules/bare-type/binding.js
  var require_binding4 = __commonJS({
    "../../node_modules/bare-type/binding.js"(exports, module) {
      module.exports = __require.addon();
    }
  });

  // ../../node_modules/bare-type/index.js
  var require_bare_type = __commonJS({
    "../../node_modules/bare-type/index.js"(exports, module) {
      var binding = require_binding4();
      var t = binding.constants;
      var Type = class {
        constructor(type) {
          this._type = type;
        }
        isUndefined() {
          return this._type === t.UNDEFINED;
        }
        isNull() {
          return this._type === t.NULL;
        }
        isBoolean() {
          return this._type === t.BOOLEAN;
        }
        isNumber() {
          return (this._type & 255) === t.NUMBER;
        }
        isInt32() {
          return (this._type & (255 | t.INT32)) === (t.NUMBER | t.INT32);
        }
        isUint32() {
          return (this._type & (255 | t.UINT32)) === (t.NUMBER | t.UINT32);
        }
        isString() {
          return this._type === t.STRING;
        }
        isSymbol() {
          return this._type === t.SYMBOL;
        }
        isObject() {
          return (this._type & 255) === t.OBJECT;
        }
        isArray() {
          return this._type === (t.OBJECT | t.ARRAY);
        }
        isArguments() {
          return this._type === (t.OBJECT | t.ARGUMENTS);
        }
        isDate() {
          return this._type === (t.OBJECT | t.DATE);
        }
        isRegExp() {
          return this._type === (t.OBJECT | t.REGEXP);
        }
        isError() {
          return this._type === (t.OBJECT | t.ERROR);
        }
        isPromise() {
          return this._type === (t.OBJECT | t.PROMISE);
        }
        isProxy() {
          return this._type === (t.OBJECT | t.PROXY);
        }
        isGenerator() {
          return this._type === (t.OBJECT | t.GENERATOR);
        }
        isMap() {
          return this._type === (t.OBJECT | t.MAP);
        }
        isSet() {
          return this._type === (t.OBJECT | t.SET);
        }
        isWeakMap() {
          return this._type === (t.OBJECT | t.WEAK_MAP);
        }
        isWeakSet() {
          return this._type === (t.OBJECT | t.WEAK_SET);
        }
        isWeakRef() {
          return this._type === (t.OBJECT | t.WEAK_REF);
        }
        isArrayBuffer() {
          return this._type === (t.OBJECT | t.ARRAYBUFFER);
        }
        isSharedArrayBuffer() {
          return this._type === (t.OBJECT | t.SHAREDARRAYBUFFER);
        }
        isTypedArray() {
          return (this._type & 65535) === (t.OBJECT | t.TYPEDARRAY);
        }
        isInt8Array() {
          return this._type === (t.OBJECT | t.TYPEDARRAY | t.INT8ARRAY);
        }
        isUint8Array() {
          return this._type === (t.OBJECT | t.TYPEDARRAY | t.UINT8ARRAY);
        }
        isUint8ClampedArray() {
          return this._type === (t.OBJECT | t.TYPEDARRAY | t.UINT8CLAMPEDARRAY);
        }
        isInt16Array() {
          return this._type === (t.OBJECT | t.TYPEDARRAY | t.INT16ARRAY);
        }
        isUint16Array() {
          return this._type === (t.OBJECT | t.TYPEDARRAY | t.UINT16ARRAY);
        }
        isInt32Array() {
          return this._type === (t.OBJECT | t.TYPEDARRAY | t.INT32ARRAY);
        }
        isUint32Array() {
          return this._type === (t.OBJECT | t.TYPEDARRAY | t.UINT32ARRAY);
        }
        isFloat16Array() {
          return this._type === (t.OBJECT | t.TYPEDARRAY | t.FLOAT16ARRAY);
        }
        isFloat32Array() {
          return this._type === (t.OBJECT | t.TYPEDARRAY | t.FLOAT32ARRAY);
        }
        isFloat64Array() {
          return this._type === (t.OBJECT | t.TYPEDARRAY | t.FLOAT64ARRAY);
        }
        isBigInt64Array() {
          return this._type === (t.OBJECT | t.TYPEDARRAY | t.BIGINT64ARRAY);
        }
        isBigUint64Array() {
          return this._type === (t.OBJECT | t.TYPEDARRAY | t.BIGUINT64ARRAY);
        }
        isDataView() {
          return this._type === (t.OBJECT | t.DATAVIEW);
        }
        isModuleNamespace() {
          return this._type === (t.OBJECT | t.MODULE_NAMESPACE);
        }
        isFunction() {
          return (this._type & 255) === t.FUNCTION;
        }
        isAsyncFunction() {
          return (this._type & (255 | t.ASYNC_FUNCTION)) === (t.FUNCTION | t.ASYNC_FUNCTION);
        }
        isGeneratorFunction() {
          return (this._type & (255 | t.GENERATOR_FUNCTION)) === (t.FUNCTION | t.GENERATOR_FUNCTION);
        }
        isExternal() {
          return this._type === t.EXTERNAL;
        }
        isBigInt() {
          return this._type === t.BIGINT;
        }
      };
      module.exports = exports = function type(value) {
        switch (typeof value) {
          case "undefined":
            return new Type(t.UNDEFINED);
          case "boolean":
            return new Type(t.BOOLEAN);
          case "number":
            return new Type(
              Number.isSafeInteger(value) ? binding.type(value) : t.NUMBER
            );
          case "string":
            return new Type(t.STRING);
          case "symbol":
            return new Type(t.SYMBOL);
          case "object":
            return new Type(value === null ? t.NULL : binding.type(value));
          case "function":
            return new Type(binding.type(value));
          case "bigint":
            return new Type(t.BIGINT);
        }
      };
      exports.createTag = function createTag(...components) {
        const tag = new Uint32Array(4);
        for (let i = 0; i < 4; i++) tag[i] = components[i] || 0;
        return tag;
      };
      exports.addTag = function addTag(object, tag) {
        binding.addTag(object, tag);
      };
      exports.checkTag = function checkTag(object, tag) {
        return binding.checkTag(object, tag);
      };
    }
  });

  // ../../node_modules/bare-inspect/binding.js
  var require_binding5 = __commonJS({
    "../../node_modules/bare-inspect/binding.js"(exports, module) {
      module.exports = __require.addon();
    }
  });

  // ../../node_modules/bare-inspect/index.js
  var require_bare_inspect = __commonJS({
    "../../node_modules/bare-inspect/index.js"(exports, module) {
      var ansiEscapes = require_bare_ansi_escapes();
      var getType = require_bare_type();
      var binding = require_binding5();
      var PLAIN_KEY = /^[a-zA-Z_][a-zA-Z_0-9]*$/;
      var defaultDepth = 2;
      var defaultBreakLength = 80;
      var defaultMaxArrayLength = 40;
      module.exports = exports = function inspect(value, opts = {}) {
        const {
          colors = false,
          depth = defaultDepth,
          breakLength = defaultBreakLength,
          stylize = defaultStylize(colors)
        } = opts;
        const references = new InspectRefMap();
        const tree = inspectValue(value, 0, {
          colors,
          depth,
          breakLength,
          stylize,
          references
        });
        return tree.toString();
      };
      exports.styles = {
        bigint: ansiEscapes.colorYellow,
        boolean: ansiEscapes.colorYellow,
        date: ansiEscapes.colorMagenta,
        module: ansiEscapes.modifierUnderline,
        name: ansiEscapes.modifierReset,
        null: ansiEscapes.modifierBold,
        number: ansiEscapes.colorYellow,
        regexp: ansiEscapes.colorRed,
        special: ansiEscapes.colorCyan,
        string: ansiEscapes.colorGreen,
        symbol: ansiEscapes.colorGreen,
        undefined: ansiEscapes.colorBrightBlack
      };
      var styles = exports.styles;
      function defaultStylize(colors) {
        return function stylize(value, style) {
          const color = colors && styles[style];
          if (color) return color + value + ansiEscapes.modifierReset;
          return value;
        };
      }
      var InspectRefMap = class {
        constructor() {
          this.refs = /* @__PURE__ */ new WeakMap();
          this.ids = /* @__PURE__ */ new WeakMap();
          this.nextId = 1;
        }
        has(object) {
          return this.refs.has(object);
        }
        get(object) {
          return this.refs.get(object) || null;
        }
        set(object, ref) {
          this.refs.set(object, ref);
        }
        id(object) {
          let id = this.ids.get(object);
          if (id) return id;
          id = this.nextId++;
          this.ids.set(object, id);
          return id;
        }
      };
      var InspectNode = class {
        constructor(depth, length, opts) {
          const { breakLength = defaultBreakLength, breakAlways = false } = opts;
          this.depth = depth;
          this.length = length;
          this.breakLength = breakLength;
          this.breakAlways = breakAlways;
        }
        pad(n, string) {
          return string.padStart(n, " ");
        }
        indent(n, string) {
          return "  ".repeat(n) + string;
        }
      };
      var InspectRef = class extends InspectNode {
        constructor(depth, opts) {
          super(depth, "[circular *]".length, opts);
          this.refs = opts.references;
          this.count = 0;
          this.circular = false;
          this.color = opts.colors && styles.special;
        }
        get id() {
          return this.refs.id(this);
        }
        increment() {
          return ++this.count;
        }
        decrement() {
          return --this.count;
        }
        toString(opts = {}) {
          const { offset = 0, pad = 0, indent = 0 } = opts;
          let value = this.pad(pad, "[circular *" + this.id + "]");
          if (this.color) value = this.color + value + ansiEscapes.modifierReset;
          return offset ? value : this.indent(indent, value);
        }
      };
      var InspectLeaf = class extends InspectNode {
        constructor(value, color, depth, opts) {
          const length = value.length;
          if (value.includes("\n")) {
            value = value.replaceAll("\n", "\n" + "  ".repeat(depth));
            opts = { ...opts, breakAlways: true };
          }
          super(depth, length, opts);
          this.value = value;
          this.color = opts.colors && color;
        }
        toString(opts = {}) {
          const { offset = 0, pad = 0, indent = 0 } = opts;
          let value = this.pad(pad, this.value);
          if (this.color) value = this.color + value + ansiEscapes.modifierReset;
          return offset ? value : this.indent(indent, value);
        }
      };
      var InspectPair = class extends InspectNode {
        constructor(delim, left, right, depth, opts) {
          const length = left.length + delim.length + right.length;
          if (left.breakAlways || right.breakAlways) {
            opts = { ...opts, breakAlways: true };
          }
          super(depth, length, opts);
          this.delim = delim;
          this.left = left;
          this.right = right;
        }
        toString(opts = {}) {
          const { indent = 0 } = opts;
          return this.indent(
            indent,
            this.left + this.delim + this.right.toString({
              indent,
              offset: this.left.length + this.delim.length
            })
          );
        }
      };
      var InspectSuspension = class extends InspectNode {
        constructor(overflow, depth, opts) {
          const label = `... ${overflow} more`;
          super(depth, label.length, opts);
          this.label = label;
        }
        toString(opts = {}) {
          const { indent = 0 } = opts;
          return this.indent(indent, this.label);
        }
      };
      var InspectSequence = class extends InspectNode {
        constructor(header, footer, delim, values, ref, depth, opts) {
          const { tabulate = false } = opts;
          const length = (ref.circular ? "<ref *>".length + 1 : 0) + header.length + values.reduce(
            (length2, value, i) => length2 + value.length + (i === 0 ? 0 : delim.length),
            0
          ) + footer.length;
          if (values.some((value) => value.breakAlways)) {
            opts = { ...opts, breakAlways: true };
          }
          super(depth, length, opts);
          this.header = header;
          this.footer = footer;
          this.delim = delim;
          this.values = values;
          this.ref = ref;
          this.tabulate = tabulate;
        }
        toString(opts = {}) {
          const { offset = 0, indent = 0 } = opts;
          const split = this.breakAlways || this.values.length && (offset + this.length > this.breakLength || indent * 2 + this.length > this.breakLength);
          let header = this.header;
          if (this.ref.circular) {
            header = "<ref *" + this.ref.id + "> " + header;
          }
          if (this.values.length === 0) {
            header = header.trimEnd();
          }
          if (offset === 0) {
            header = this.indent(indent, header);
          }
          if (split) {
            header = header.trimEnd() + "\n";
          }
          let string = header;
          let columns = 1;
          let pad = 0;
          if (this.tabulate) {
            const widest = this.values.reduce(
              (length, value) => value.breakAlways ? length : Math.max(length, value.length),
              0
            );
            if (widest) {
              columns = Math.max(
                columns,
                Math.floor(
                  (this.breakLength - indent * 2) / (widest + this.delim.length)
                )
              );
              if (columns > 1) pad = widest;
            }
          }
          for (let i = 0, n = this.values.length, offset2 = 0; i < n; i++) {
            const value = this.values[i];
            if (split) {
              let part;
              if (i % columns === 0 || value.breakAlways) {
                part = value.toString({ indent: indent + 1, pad });
              } else {
                part = value.toString({ pad });
              }
              string += part;
              if (i < n - 1) {
                if (i % columns === columns - 1 || this.values[i + 1].breakAlways) {
                  string += this.delim.trimEnd() + "\n";
                } else {
                  string += this.delim;
                }
              }
            } else {
              if (i > 0) string += this.delim;
              string += value.toString({ offset: offset2 });
              offset2 += value.length;
            }
          }
          let footer = this.footer;
          if (this.values.length === 0) {
            footer = footer.trimStart();
          }
          if (split) {
            string += "\n" + this.indent(indent, footer.trimStart());
          } else {
            string += footer;
          }
          return string;
        }
      };
      function inspectValue(value, depth, opts) {
        const type = getType(value);
        if (type.isUndefined()) return inspectUndefined(depth, opts);
        if (type.isNull()) return inspectNull(depth, opts);
        if (type.isBoolean()) return inspectBoolean(value, depth, opts);
        if (type.isNumber()) return inspectNumber(value, depth, opts);
        if (type.isBigInt()) return inspectBigInt(value, depth, opts);
        if (type.isString()) return inspectString(value, depth, opts);
        if (type.isSymbol()) return inspectSymbol(value, depth, opts);
        if (type.isObject()) return inspectObject(type, value, depth, opts);
        if (type.isFunction()) return inspectFunction(type, value, depth, opts);
        if (type.isExternal()) return inspectExternal(value, opts, opts);
      }
      function inspectUndefined(depth, opts) {
        return new InspectLeaf("undefined", styles.undefined, depth, opts);
      }
      function inspectNull(depth, opts) {
        return new InspectLeaf("null", styles.null, depth, opts);
      }
      function inspectBoolean(value, depth, opts) {
        return new InspectLeaf(value.toString(), styles.boolean, depth, opts);
      }
      function inspectNumber(value, depth, opts) {
        let string;
        if (Object.is(value, -0)) {
          string = "-0";
        } else {
          string = value.toString(10);
        }
        return new InspectLeaf(string, styles.number, depth, opts);
      }
      function inspectBigInt(value, depth, opts) {
        return new InspectLeaf(value.toString(10) + "n", styles.bigint, depth, opts);
      }
      var STRING_ESCAPES = /[\ud800-\udbff][\udc00-\udfff]|[\u0000-\u001f'\\\ud800-\udfff]/g;
      function inspectString(value, depth, opts) {
        const string = value.replace(STRING_ESCAPES, (match) => {
          if (match.length === 2) return match;
          switch (match) {
            case "'":
              return "\\'";
            case "\\":
              return "\\\\";
            case "\b":
              return "\\b";
            case "	":
              return "\\t";
            case "\n":
              return "\\n";
            case "\f":
              return "\\f";
            case "\r":
              return "\\r";
            default:
              return "\\u" + match.charCodeAt(0).toString(16).padStart(4, "0");
          }
        });
        return new InspectLeaf("'" + string + "'", styles.string, depth, opts);
      }
      function inspectSymbol(value, depth, opts) {
        return new InspectLeaf(value.toString(), styles.symbol, depth, opts);
      }
      function inspectKey(value, depth, opts) {
        if (PLAIN_KEY.test(value)) {
          return new InspectLeaf(value, null, depth, opts);
        } else {
          return inspectValue(value, depth, opts);
        }
      }
      function inspectObject(type, object, depth, opts) {
        const refs = opts.references;
        let ref = refs.get(object);
        if (ref === null) {
          ref = new InspectRef(depth, opts);
          refs.set(object, ref);
        } else if (ref.count) {
          ref.circular = true;
          return ref;
        }
        const maxDepth = typeof opts.depth === "number" ? opts.depth : Infinity;
        if (maxDepth < depth) {
          const constructor = object.constructor;
          return new InspectLeaf(
            "[" + (constructor && constructor.name ? constructor.name : "Object") + "]",
            styles.special,
            depth,
            opts
          );
        }
        const inspect = object[Symbol.for("bare.inspect")] || object[Symbol.for("nodejs.util.inspect.custom")];
        if (typeof inspect === "function") {
          const value = inspect.call(
            object,
            typeof opts.depth === "number" ? opts.depth - depth : null,
            {
              colors: opts.colors,
              breakLength: opts.breakLength,
              stylize: opts.stylize
            },
            exports
          );
          if (typeof value === "object" && value !== null) {
            refs.set(value, ref);
          }
          if (typeof value !== "string") {
            return inspectValue(value, depth, opts);
          }
          return new InspectLeaf(value, null, depth, opts);
        }
        if (type.isArray()) return inspectArray(object, ref, depth, opts);
        if (type.isDate()) return inspectDate(object, ref, depth, opts);
        if (type.isRegExp()) return inspectRegExp(object, ref, depth, opts);
        if (type.isError()) return inspectError(object, ref, depth, opts);
        if (type.isPromise()) return inspectPromise(object, ref, depth, opts);
        if (type.isMap()) return inspectMap(object, ref, depth, opts);
        if (type.isSet()) return inspectSet(object, ref, depth, opts);
        if (type.isWeakMap()) return inspectWeakMap(object, ref, depth, opts);
        if (type.isWeakSet()) return inspectWeakSet(object, ref, depth, opts);
        if (type.isWeakRef()) return inspectWeakRef(object, ref, depth, opts);
        if (type.isArrayBuffer()) return inspectArrayBuffer(object, ref, depth, opts);
        if (type.isSharedArrayBuffer())
          return inspectSharedArrayBuffer(object, ref, depth, opts);
        if (type.isTypedArray()) return inspectTypedArray(object, ref, depth, opts);
        if (type.isDataView()) return inspectDataView(object, ref, depth, opts);
        ref.increment();
        const values = [];
        for (const key in object) {
          if (key === "constructor") continue;
          values.push(
            new InspectPair(
              ": ",
              inspectKey(key, depth + 1, opts),
              inspectValue(object[key], depth + 1, opts),
              depth + 1,
              opts
            )
          );
        }
        ref.decrement();
        let header = "{ ";
        const tag = object[Symbol.toStringTag];
        if (tag) header = "[" + tag + "] " + header;
        if (object.constructor) {
          const name = object.constructor.name;
          if (name && name !== "Object") {
            header = object.constructor.name + " " + header;
          }
        }
        return new InspectSequence(header, " }", ", ", values, ref, depth, opts);
      }
      function inspectArray(array, ref, depth, opts) {
        const { maxArrayLength = defaultMaxArrayLength } = opts;
        ref.increment();
        const values = [];
        let remaining = Math.max(maxArrayLength, 0);
        for (let i = 0, n = array.length; i < n; i++) {
          if (remaining-- === 0) {
            values.push(
              new InspectSuspension(array.length - values.length, depth + 1, {
                ...opts,
                breakAlways: true
              })
            );
            break;
          }
          values.push(inspectValue(array[i], depth + 1, opts));
        }
        for (const key of binding.getOwnNonIndexPropertyNames(array)) {
          values.push(
            new InspectPair(
              ": ",
              inspectKey(key, depth + 1, opts),
              inspectValue(array[key], depth + 1, opts),
              depth + 1,
              { ...opts, breakAlways: remaining < 0 }
            )
          );
        }
        ref.decrement();
        let header = "[ ";
        if (array.constructor.name !== "Array") {
          header = array.constructor.name + "(" + array.length + ") " + header;
        }
        return new InspectSequence(header, " ]", ", ", values, ref, depth, {
          ...opts,
          tabulate: true
        });
      }
      function inspectDate(date, ref, depth, opts) {
        return new InspectLeaf(date.toISOString(), styles.date, depth, opts);
      }
      function inspectRegExp(regExp, ref, depth, opts) {
        return new InspectLeaf(regExp.toString(), styles.regexp, depth, opts);
      }
      function inspectError(error, ref, depth, opts) {
        let header;
        if ("stack" in error) {
          header = error.stack;
          if (depth > 0) {
            header = header.replaceAll("\n", "\n" + "  ".repeat(depth));
          }
        } else {
          header = error.toString();
        }
        const builtins = ["cause"];
        if (error.name === "AggregateError") {
          builtins.push("errors");
        } else if (error.name === "SuppressedError") {
          builtins.push("error", "suppressed");
        }
        const values = [];
        for (const key of builtins) {
          if (key in error === false) continue;
          values.push(
            new InspectPair(
              ": ",
              new InspectLeaf("[" + key + "]", null, depth + 1, opts),
              inspectValue(error[key], depth + 1, opts),
              depth + 1,
              opts
            )
          );
        }
        for (const key in error) {
          if (key === "constructor" || builtins.includes(key)) continue;
          values.push(
            new InspectPair(
              ": ",
              inspectKey(key, depth + 1, opts),
              inspectValue(error[key], depth + 1, opts),
              depth + 1,
              opts
            )
          );
        }
        if (values.length === 0) return new InspectLeaf(header, null, depth, opts);
        return new InspectSequence(
          header + " {",
          " }",
          ", ",
          values,
          ref,
          depth,
          opts
        );
      }
      function inspectPromise(promise, ref, depth, opts) {
        ref.increment();
        const state = binding.getPromiseState(promise);
        const values = [];
        switch (state) {
          case 0:
            values.push(new InspectLeaf("<pending>", styles.special, depth, opts));
            break;
          case 1:
            values.push(inspectValue(binding.getPromiseResult(promise), depth, opts));
            break;
          case 2:
            values.push(
              new InspectLeaf("<rejected>", styles.special, depth, opts),
              inspectValue(binding.getPromiseResult(promise), depth, opts)
            );
        }
        ref.decrement();
        const header = promise.constructor.name + " { ";
        return new InspectSequence(header, " }", " ", values, ref, depth, opts);
      }
      function inspectMap(map, ref, depth, opts) {
        const {
          maxArrayLength = defaultMaxArrayLength,
          maxMapLength = maxArrayLength
        } = opts;
        ref.increment();
        const values = [];
        let remaining = maxMapLength;
        for (const entry of map) {
          if (remaining-- === 0) {
            values.push(
              new InspectSuspension(map.size - values.length, depth + 1, {
                ...opts,
                breakAlways: true
              })
            );
            break;
          }
          values.push(
            new InspectPair(
              " => ",
              inspectValue(entry[0], depth + 1, opts),
              inspectValue(entry[1], depth + 1, opts),
              depth + 1,
              opts
            )
          );
        }
        for (const key in map) {
          if (key === "constructor") continue;
          const value = inspectValue(map[key], depth + 1, opts);
          values.push(
            new InspectPair(
              ": ",
              inspectKey(key, depth + 1, opts),
              value,
              depth + 1,
              { ...opts, breakAlways: remaining < 0 }
            )
          );
        }
        ref.decrement();
        const header = map.constructor.name + "(" + map.size + ") { ";
        return new InspectSequence(header, " }", ", ", values, ref, depth, {
          ...opts,
          tabulate: true
        });
      }
      function inspectSet(set, ref, depth, opts) {
        const {
          maxArrayLength = defaultMaxArrayLength,
          maxSetLength = maxArrayLength
        } = opts;
        ref.increment();
        const values = [];
        let remaining = maxSetLength;
        for (const entry of set) {
          if (remaining-- === 0) {
            values.push(
              new InspectSuspension(set.size - values.length, depth + 1, {
                ...opts,
                breakAlways: true
              })
            );
            break;
          }
          values.push(inspectValue(entry, depth + 1, opts));
        }
        for (const key in set) {
          if (key === "constructor") continue;
          const value = inspectValue(set[key], depth + 1, opts);
          values.push(
            new InspectPair(
              ": ",
              inspectKey(key, depth + 1, opts),
              value,
              depth + 1,
              { ...opts, breakAlways: remaining < 0 }
            )
          );
        }
        ref.decrement();
        const header = set.constructor.name + "(" + set.size + ") { ";
        return new InspectSequence(header, " }", ", ", values, ref, depth, {
          ...opts,
          tabulate: true
        });
      }
      function inspectWeakMap(weakMap, ref, depth, opts) {
        const header = weakMap.constructor.name + " { ";
        return new InspectSequence(
          header,
          " }",
          " ",
          [new InspectLeaf("<items unknown>", styles.special, depth + 1, opts)],
          ref,
          depth,
          opts
        );
      }
      function inspectWeakSet(weakSet, ref, depth, opts) {
        const header = weakSet.constructor.name + " { ";
        return new InspectSequence(
          header,
          " }",
          " ",
          [new InspectLeaf("<items unknown>", styles.special, depth + 1, opts)],
          ref,
          depth,
          opts
        );
      }
      function inspectWeakRef(weakRef, ref, depth, opts) {
        const target = weakRef.deref();
        let value;
        if (target === void 0) {
          value = new InspectLeaf("<cleared>", styles.special, depth + 1, opts);
        } else {
          value = inspectValue(target, depth + 1, opts);
        }
        const header = weakRef.constructor.name + " { ";
        return new InspectSequence(header, " }", " ", [value], ref, depth, opts);
      }
      function inspectArrayBuffer(arrayBuffer, ref, depth, opts) {
        ref.increment();
        const values = [];
        for (const key of ["byteLength"]) {
          values.push(
            new InspectPair(
              ": ",
              inspectKey(key, depth + 1, opts),
              inspectValue(arrayBuffer[key], depth + 1, opts),
              depth + 1,
              opts
            )
          );
        }
        ref.decrement();
        const header = arrayBuffer.constructor.name + " { ";
        return new InspectSequence(header, " }", ", ", values, ref, depth, opts);
      }
      function inspectSharedArrayBuffer(sharedArrayBuffer, ref, depth, opts) {
        ref.increment();
        const values = [];
        for (const key of ["byteLength"]) {
          values.push(
            new InspectPair(
              ": ",
              inspectKey(key, depth + 1, opts),
              inspectValue(sharedArrayBuffer[key], depth + 1, opts),
              depth + 1,
              opts
            )
          );
        }
        ref.decrement();
        const header = sharedArrayBuffer.constructor.name + " { ";
        return new InspectSequence(header, " }", ", ", values, ref, depth, opts);
      }
      function inspectTypedArray(typedArray, ref, depth, opts) {
        if (Buffer.isBuffer(typedArray)) {
          return inspectBuffer(typedArray, ref, depth, opts);
        }
        const {
          maxArrayLength = defaultMaxArrayLength,
          maxTypedArrayLength = maxArrayLength
        } = opts;
        ref.increment();
        const values = [];
        let remaining = Math.max(maxTypedArrayLength, 0);
        for (let i = 0, n = typedArray.length; i < n; i++) {
          if (remaining-- === 0) {
            values.push(
              new InspectSuspension(typedArray.length - values.length, depth + 1, {
                ...opts,
                breakAlways: true
              })
            );
            break;
          }
          values.push(inspectValue(typedArray[i], depth + 1, opts));
        }
        for (const key of binding.getOwnNonIndexPropertyNames(typedArray)) {
          values.push(
            new InspectPair(
              ": ",
              inspectKey(key, depth + 1, opts),
              inspectValue(typedArray[key], depth + 1, opts),
              depth + 1,
              { ...opts, breakAlways: remaining < 0 }
            )
          );
        }
        ref.decrement();
        const header = typedArray.constructor.name + "(" + typedArray.length + ") [ ";
        return new InspectSequence(header, " ]", ", ", values, ref, depth, {
          ...opts,
          tabulate: true
        });
      }
      function inspectBuffer(buffer, ref, depth, opts) {
        const {
          maxArrayLength = defaultMaxArrayLength,
          maxBufferLength = maxArrayLength
        } = opts;
        ref.increment();
        const values = [];
        let remaining = Math.max(maxBufferLength, 0);
        for (let i = 0, n = buffer.byteLength; i < n; i++) {
          if (remaining-- === 0) {
            values.push(
              new InspectSuspension(buffer.length - values.length, depth + 1, {
                ...opts,
                breakAlways: true
              })
            );
            break;
          }
          values.push(
            new InspectLeaf(
              buffer[i].toString(16).padStart(2, "0"),
              null,
              depth + 1,
              opts
            )
          );
        }
        for (const key of binding.getOwnNonIndexPropertyNames(buffer)) {
          values.push(
            new InspectPair(
              ": ",
              inspectKey(key, depth + 1, opts),
              inspectValue(buffer[key], depth + 1, opts),
              depth + 1,
              { ...opts, breakAlways: remaining < 0 }
            )
          );
        }
        ref.decrement();
        return new InspectSequence("<Buffer ", ">", " ", values, ref, depth, {
          ...opts,
          tabulate: true
        });
      }
      function inspectDataView(dataView, ref, depth, opts) {
        ref.increment();
        const values = [];
        for (const key of ["byteLength", "byteOffset", "buffer"]) {
          values.push(
            new InspectPair(
              ": ",
              inspectKey(key, depth + 1, opts),
              inspectValue(dataView[key], depth + 1, opts),
              depth + 1,
              opts
            )
          );
        }
        for (const key of binding.getOwnNonIndexPropertyNames(dataView)) {
          values.push(
            new InspectPair(
              ": ",
              inspectKey(key, depth + 1, opts),
              inspectValue(dataView[key], depth + 1, opts),
              depth + 1,
              opts
            )
          );
        }
        ref.decrement();
        const header = dataView.constructor.name + " { ";
        return new InspectSequence(header, " }", ", ", values, ref, depth, opts);
      }
      function inspectFunction(type, fn, depth, opts) {
        if (fn.toString().startsWith("class")) return inspectClass(fn, depth, opts);
        let tag = "function";
        if (type.isGeneratorFunction()) tag = "generator " + tag;
        if (type.isAsyncFunction()) tag = "async " + tag;
        return new InspectLeaf(
          "[" + tag + " " + (fn.name ? fn.name : "(anonymous)") + "]",
          styles.special,
          depth,
          opts
        );
      }
      function inspectClass(ctor, depth, opts) {
        return new InspectLeaf(
          "[class " + (ctor.name ? ctor.name : "(anonymous)") + "]",
          styles.special,
          depth,
          opts
        );
      }
      function inspectExternal(external, depth, opts) {
        return new InspectLeaf(
          "[external 0x" + binding.getExternal(external).toString(16) + "]",
          styles.special,
          depth,
          opts
        );
      }
    }
  });

  // ../../node_modules/bare-assert/index.js
  var require_bare_assert = __commonJS({
    "../../node_modules/bare-assert/index.js"(exports, module) {
      var inspect = require_bare_inspect();
      var AssertionError = class extends Error {
        constructor(opts = {}) {
          let { message = null, actual, expected, operator } = opts;
          if (message === null) {
            message = `${inspect(actual)} ${operator} ${inspect(expected)}`;
          }
          super(message);
          this.actual = actual;
          this.expected = expected;
          this.operator = operator;
        }
        get name() {
          return "AssertionError";
        }
        get code() {
          "ASSERTION";
        }
      };
      function assertFail(opts, fn) {
        if (opts.message instanceof Error) throw opts.message;
        const err = new AssertionError(opts);
        if (Error.captureStackTrace) Error.captureStackTrace(err, fn);
        throw err;
      }
      module.exports = exports = function assert(actual, message) {
        if (actual) return;
        assertFail({ message, actual, expected: true, operator: "==" }, assert);
      };
      exports.AssertionError = AssertionError;
      exports.fail = function fail(message) {
        if (message === void 0) message = "Failed";
        assertFail({ message, operator: "fail" }, fail);
      };
      exports.ok = function ok(actual, message) {
        if (actual) return;
        assertFail({ message, actual, expected: true, operator: "==" }, ok);
      };
      exports.notOk = function ok(actual, message) {
        if (!actual) return;
        assertFail({ message, actual, expected: false, operator: "==" }, ok);
      };
      exports.equal = function equal(actual, expected, message) {
        if (actual == expected || actual !== actual && expected !== expected) {
          return;
        }
        assertFail({ message, actual, expected, operator: "==" }, equal);
      };
      exports.notEqual = function notEqual(actual, expected, message) {
        if (actual != expected && (actual === actual || expected === expected)) {
          return;
        }
        assertFail({ message, actual, expected, operator: "!=" }, notEqual);
      };
      exports.strictEqual = function strictEqual(actual, expected, message) {
        if (Object.is(actual, expected)) return;
        assertFail(
          { message, actual, expected, operator: "strictEqual" },
          strictEqual
        );
      };
      exports.notStrictEqual = function notStrictEqual(actual, expected, message) {
        if (!Object.is(actual, expected)) return;
        assertFail(
          { message, actual, expected, operator: "notStrictEqual" },
          notStrictEqual
        );
      };
    }
  });

  // ../../node_modules/bare-crypto/binding.js
  var require_binding6 = __commonJS({
    "../../node_modules/bare-crypto/binding.js"(exports, module) {
      module.exports = __require.addon();
    }
  });

  // ../../node_modules/bare-crypto/lib/errors.js
  var require_errors5 = __commonJS({
    "../../node_modules/bare-crypto/lib/errors.js"(exports, module) {
      module.exports = class CryptoError extends Error {
        constructor(msg, fn = CryptoError, code = fn.name) {
          super(`${code}: ${msg}`);
          this.code = code;
          if (Error.captureStackTrace) {
            Error.captureStackTrace(this, fn);
          }
        }
        get name() {
          return "CryptoError";
        }
        static UNKNOWN_HASH(msg) {
          return new CryptoError(msg, CryptoError.UNKNOWN_HASH);
        }
        static UNKNOWN_CIPHER(msg) {
          return new CryptoError(msg, CryptoError.UNKNOWN_CIPHER);
        }
        static UNKNOWN_KEY_TYPE(msg) {
          return new CryptoError(msg, CryptoError.UNKNOWN_KEY_TYPE);
        }
        static INVALID_ACCESS(msg) {
          return new CryptoError(msg, CryptoError.INVALID_ACCESS);
        }
        static INVALID_DATA(msg) {
          return new CryptoError(msg, CryptoError.INVALID_DATA);
        }
        static OPERATION_ERROR(msg) {
          return new CryptoError(msg, CryptoError.OPERATION_ERROR);
        }
        static NOT_SUPPORTED(msg) {
          return new CryptoError(msg, CryptoError.NOT_SUPPORTED);
        }
      };
    }
  });

  // ../../node_modules/bare-crypto/lib/constants.js
  var require_constants4 = __commonJS({
    "../../node_modules/bare-crypto/lib/constants.js"(exports, module) {
      var { fail } = require_bare_assert();
      var binding = require_binding6();
      var errors = require_errors5();
      module.exports = exports = {
        hash: {
          MD5: binding.MD5,
          SHA1: binding.SHA1,
          SHA256: binding.SHA256,
          SHA384: binding.SHA384,
          SHA512: binding.SHA512,
          BLAKE2B256: binding.BLAKE2B256,
          RIPEMD160: binding.RIPEMD160
        },
        signature: {
          ED25519: binding.ED25519
        },
        cipher: {
          AES128ECB: binding.AES128ECB,
          AES128CBC: binding.AES128CBC,
          AES128CTR: binding.AES128CTR,
          AES128OFB: binding.AES128OFB,
          AES256ECB: binding.AES256ECB,
          AES256CBC: binding.AES256CBC,
          AES256CTR: binding.AES256CTR,
          AES256OFB: binding.AES256OFB,
          AES128GCM: binding.AES128GCM,
          AES256GCM: binding.AES256GCM,
          CHACHA20POLY1305: binding.CHACHA20POLY1305,
          XCHACHA20POLY1305: binding.XCHACHA20POLY1305
        },
        keyType: {
          ED25519: binding.ED25519
        }
      };
      exports.toHash = function toHash(hash) {
        if (typeof hash === "number" && !isNaN(hash)) return hash;
        if (typeof hash === "string") {
          hash = hash.replace(/-/g, "");
          if (hash in exports.hash === false) {
            hash = hash.toUpperCase();
            if (hash in exports.hash === false) {
              throw errors.UNKNOWN_HASH(`Unknown hash '${hash}'`);
            }
          }
          return exports.hash[hash];
        }
        fail(`Hash must be a number or string. Received ${isNaN(hash) ? "NaN" : typeof hash} (${hash})`);
      };
      exports.toCipher = function toCiper(cipher) {
        if (typeof cipher === "number" && !isNaN(cipher)) return cipher;
        if (typeof cipher === "string") {
          cipher = cipher.replace(/-/g, "");
          if (cipher in exports.cipher === false) {
            cipher = cipher.toUpperCase();
            if (cipher in exports.cipher === false) {
              throw errors.UNKNOWN_CIPHER(`Unknown cipher '${cipher}'`);
            }
          }
          return exports.cipher[cipher];
        }
        fail(
          `Cipher must be a number or string. Received ${isNaN(cipher) ? "NaN" : typeof cipher} (${cipher})`
        );
      };
      exports.toKeyType = function toKeyType(type) {
        if (typeof type === "number" && !isNaN(type)) return type;
        if (typeof type === "string") {
          type = type.replace(/-/g, "");
          if (type in exports.keyType === false) {
            type = type.toUpperCase();
            if (type in exports.keyType === false) {
              throw errors.UNKNOWN_KEY_TYPE(`Unknown key type '${type}'`);
            }
          }
          return exports.keyType[type];
        }
        fail(
          `Key type must be a number or string. Received ${isNaN(type) ? "NaN" : typeof type} (${type})`
        );
      };
    }
  });

  // ../../node_modules/bare-crypto/lib/hash.js
  var require_hash = __commonJS({
    "../../node_modules/bare-crypto/lib/hash.js"(exports, module) {
      var { Transform } = require_bare_stream();
      var assert = require_bare_assert();
      var binding = require_binding6();
      var constants = require_constants4();
      var {
        hash: { RIPEMD160 }
      } = constants;
      var CryptoDigest = class {
        constructor(algorithm) {
          this._handle = binding.digestInit(algorithm);
        }
        update(data) {
          if (this._handle === null) {
            throw new Error("Digest has already been finalized");
          }
          binding.digestUpdate(this._handle, data.buffer, data.byteOffset, data.byteLength);
        }
        final() {
          if (this._handle === null) {
            throw new Error("Digest has already been finalized");
          }
          const result = Buffer.from(binding.digestFinal(this._handle));
          this._handle = null;
          return result;
        }
      };
      var CryptoRIPEMD160Digest = class {
        constructor() {
          this._handle = binding.ripemd160Init();
        }
        update(data) {
          if (this._handle === null) {
            throw new Error("Digest has already been finalized");
          }
          binding.ripemd160Update(this._handle, data.buffer, data.byteOffset, data.byteLength);
        }
        final() {
          if (this._handle === null) {
            throw new Error("Digest has already been finalized");
          }
          const result = Buffer.from(binding.ripemd160Final(this._handle));
          this._handle = null;
          return result;
        }
      };
      module.exports = class CryptoHash extends Transform {
        constructor(algorithm, opts = {}) {
          super(opts);
          algorithm = constants.toHash(algorithm);
          switch (algorithm) {
            case RIPEMD160:
              this._digest = new CryptoRIPEMD160Digest();
              break;
            default:
              this._digest = new CryptoDigest(algorithm);
              break;
          }
        }
        update(data, encoding = "utf8") {
          if (typeof data === "string") data = Buffer.from(data, encoding);
          assert(ArrayBuffer.isView(data));
          this._digest.update(data);
          return this;
        }
        digest(encoding) {
          const digest = this._digest.final();
          return encoding && encoding !== "buffer" ? digest.toString(encoding) : digest;
        }
        _transform(data, encoding, cb) {
          this.update(data);
          cb(null);
        }
        _flush(cb) {
          this.push(this.digest());
          cb(null);
        }
      };
    }
  });

  // ../../node_modules/bare-crypto/lib/hmac.js
  var require_hmac = __commonJS({
    "../../node_modules/bare-crypto/lib/hmac.js"(exports, module) {
      var { Transform } = require_bare_stream();
      var assert = require_bare_assert();
      var binding = require_binding6();
      var constants = require_constants4();
      module.exports = class CryptoHmac extends Transform {
        constructor(algorithm, key, opts = {}) {
          super(opts);
          const { encoding = "utf8" } = opts;
          if (typeof key === "string") key = Buffer.from(key, encoding);
          assert(ArrayBuffer.isView(key));
          this._handle = binding.hmacInit(
            constants.toHash(algorithm),
            key.buffer,
            key.byteOffset,
            key.byteLength
          );
        }
        update(data, encoding = "utf8") {
          if (this._handle === null) {
            throw new Error("Hmac has already been finalized");
          }
          if (typeof data === "string") data = Buffer.from(data, encoding);
          assert(ArrayBuffer.isView(data));
          binding.hmacUpdate(this._handle, data.buffer, data.byteOffset, data.byteLength);
          return this;
        }
        digest(encoding) {
          if (this._handle === null) {
            throw new Error("Hmac has already been finalized");
          }
          const digest = Buffer.from(binding.hmacFinal(this._handle));
          this._handle = null;
          return encoding && encoding !== "buffer" ? digest.toString(encoding) : digest;
        }
        _transform(data, encoding, cb) {
          this.update(data);
          cb(null);
        }
        _flush(cb) {
          this.push(this.digest());
          cb(null);
        }
      };
    }
  });

  // ../../node_modules/bare-crypto/lib/cipher.js
  var require_cipher = __commonJS({
    "../../node_modules/bare-crypto/lib/cipher.js"(exports) {
      var { Transform } = require_bare_stream();
      var assert = require_bare_assert();
      var binding = require_binding6();
      var constants = require_constants4();
      var {
        cipher: {
          AES128ECB,
          AES128CBC,
          AES128CTR,
          AES128OFB,
          AES256ECB,
          AES256CBC,
          AES256CTR,
          AES256OFB,
          AES128GCM,
          AES256GCM,
          CHACHA20POLY1305,
          XCHACHA20POLY1305
        }
      } = constants;
      var CryptoCipher = class {
        constructor(algorithm, key, iv, encrypt, opts = {}) {
          const { encoding = "utf8" } = opts;
          if (typeof key === "string") key = Buffer.from(key, encoding);
          if (typeof iv === "string") iv = Buffer.from(iv, encoding);
          assert(ArrayBuffer.isView(key));
          assert(ArrayBuffer.isView(iv));
          if (key.byteLength !== binding.cipherKeyLength(algorithm)) {
            throw new RangeError("Invalid key length");
          }
          if (iv.byteLength < binding.cipherIVLength(algorithm)) {
            throw new RangeError("Invalid iv length");
          }
          this._handle = binding.cipherInit(
            algorithm,
            key.buffer,
            key.byteOffset,
            key.byteLength,
            iv.buffer,
            iv.byteOffset,
            iv.byteLength,
            encrypt
          );
        }
        update(data, inputEncoding = "utf8", outputEncoding) {
          if (this._handle === null) {
            throw new Error("Cipher has already been finalized");
          }
          if (typeof data === "string") data = Buffer.from(data, inputEncoding);
          assert(ArrayBuffer.isView(data));
          const out = new ArrayBuffer(data.byteLength + binding.cipherBlockSize(this._handle));
          const written = binding.cipherUpdate(
            this._handle,
            data.buffer,
            data.byteOffset,
            data.byteLength,
            out
          );
          const result = Buffer.from(out, 0, written);
          return outputEncoding ? result.toString(outputEncoding) : result;
        }
        final(outputEncoding) {
          if (this._handle === null) {
            throw new Error("Cipher has already been finalized");
          }
          const out = new ArrayBuffer(binding.cipherBlockSize(this._handle));
          const written = binding.cipherFinal(this._handle, out);
          this._handle = null;
          const result = Buffer.from(out, 0, written);
          return outputEncoding ? result.toString(outputEncoding) : result;
        }
        setAutoPadding(pad) {
          if (this._handle === null) {
            throw new Error("Cipher has already been finalized");
          }
          binding.cipherSetPadding(this._handle, pad);
        }
      };
      var CryptoAuthenticatedCipher = class {
        constructor(algorithm, key, nonce, opts = {}) {
          const { encoding = "utf8", authTagLength = 16 } = opts;
          if (typeof key === "string") key = Buffer.from(key, encoding);
          if (typeof nonce === "string") nonce = Buffer.from(nonce, encoding);
          assert(ArrayBuffer.isView(key));
          assert(ArrayBuffer.isView(nonce));
          if (key.byteLength !== binding.aeadKeyLength(algorithm)) {
            throw new RangeError("Invalid key length");
          }
          if (nonce.byteLength < binding.aeadNonceLength(algorithm)) {
            throw new RangeError("Invalid nonce length");
          }
          this._buffer = [];
          this._nonce = nonce;
          this._authTag = null;
          this._authTagLength = authTagLength;
          this._additionalData = null;
          this._handle = binding.aeadInit(
            algorithm,
            key.buffer,
            key.byteOffset,
            key.byteLength,
            authTagLength
          );
        }
        update(data, inputEncoding = "utf8", outputEncoding) {
          if (typeof data === "string") data = Buffer.from(data, inputEncoding);
          assert(ArrayBuffer.isView(data));
          this._buffer.push(data);
          return outputEncoding ? "" : Buffer.alloc(0);
        }
        setAAD(buffer, opts = {}) {
          const { encoding = "utf8" } = opts;
          if (typeof buffer === "string") buffer = Buffer.from(buffer, encoding);
          assert(ArrayBuffer.isView(buffer));
          this._additionalData = buffer;
        }
        getAuthTag() {
          return this._authTag;
        }
        setAuthTag(authTag, encoding) {
          if (typeof authTag === "string") authTag = Buffer.from(authTag, encoding);
          assert(ArrayBuffer.isView(authTag));
          this._authTag = authTag;
        }
      };
      var CryptoAuthenticatedSeal = class extends CryptoAuthenticatedCipher {
        final(outputEncoding) {
          if (this._handle === null) {
            throw new Error("Cipher has already been finalized");
          }
          const data = this._buffer.length === 1 ? this._buffer[0] : Buffer.concat(this._buffer);
          const nonce = this._nonce;
          const ad = this._additionalData || Buffer.alloc(0);
          const out = new ArrayBuffer(data.byteLength + binding.aeadMaxOverhead(this._handle));
          const written = binding.aeadSeal(
            this._handle,
            data.buffer,
            data.byteOffset,
            data.byteLength,
            nonce.buffer,
            nonce.byteOffset,
            nonce.byteLength,
            ad.buffer,
            ad.byteOffset,
            ad.byteLength,
            out
          );
          this._handle = null;
          const cipherLength = written - this._authTagLength;
          this._authTag = Buffer.from(out, cipherLength);
          const result = Buffer.from(out, 0, cipherLength);
          return outputEncoding ? result.toString(outputEncoding) : result;
        }
      };
      var CryptoAuthenticatedOpen = class extends CryptoAuthenticatedCipher {
        final(outputEncoding) {
          if (this._handle === null) {
            throw new Error("Decipher has already been finalized");
          }
          this._buffer.push(this._authTag);
          const data = Buffer.concat(this._buffer);
          const nonce = this._nonce;
          const ad = this._additionalData || Buffer.alloc(0);
          const out = new ArrayBuffer(data.byteLength);
          const written = binding.aeadOpen(
            this._handle,
            data.buffer,
            data.byteOffset,
            data.byteLength,
            nonce.buffer,
            nonce.byteOffset,
            nonce.byteLength,
            ad.buffer,
            ad.byteOffset,
            ad.byteLength,
            out
          );
          this._handle = null;
          const result = Buffer.from(out, 0, written);
          return outputEncoding ? result.toString(outputEncoding) : result;
        }
      };
      exports.Cipheriv = class CryptoCipheriv extends Transform {
        constructor(algorithm, key, iv, opts = {}) {
          super(opts);
          algorithm = constants.toCipher(algorithm);
          switch (algorithm) {
            case AES128ECB:
            case AES128CBC:
            case AES128CTR:
            case AES128OFB:
            case AES256ECB:
            case AES256CBC:
            case AES256CTR:
            case AES256OFB:
              this._cipher = new CryptoCipher(algorithm, key, iv, true, opts);
              break;
            case AES128GCM:
            case AES256GCM:
            case CHACHA20POLY1305:
            case XCHACHA20POLY1305:
              this._cipher = new CryptoAuthenticatedSeal(algorithm, key, iv, opts);
              break;
          }
        }
        update(data, inputEncoding, outputEncoding) {
          return this._cipher.update(data, inputEncoding, outputEncoding);
        }
        final(outputEncoding) {
          return this._cipher.final(outputEncoding);
        }
        setAutoPadding(pad) {
          this._cipher.setAutoPadding(pad);
          return this;
        }
        setAAD(buffer, opts) {
          this._cipher.setAAD(buffer, opts);
          return this;
        }
        getAuthTag() {
          return this._cipher.getAuthTag();
        }
        _transform(data, encoding, cb) {
          this.push(this.update(data));
          cb(null);
        }
        _flush(cb) {
          this.push(this.final());
          cb(null);
        }
      };
      exports.Decipheriv = class CryptoDeipheriv extends Transform {
        constructor(algorithm, key, iv, opts = {}) {
          super(opts);
          algorithm = constants.toCipher(algorithm);
          switch (algorithm) {
            case AES128ECB:
            case AES128CBC:
            case AES128CTR:
            case AES128OFB:
            case AES256ECB:
            case AES256CBC:
            case AES256CTR:
            case AES256OFB:
              this._cipher = new CryptoCipher(algorithm, key, iv, false, opts);
              break;
            case AES128GCM:
            case AES256GCM:
            case CHACHA20POLY1305:
            case XCHACHA20POLY1305:
              this._cipher = new CryptoAuthenticatedOpen(algorithm, key, iv, opts);
              break;
          }
        }
        update(data, inputEncoding, outputEncoding) {
          return this._cipher.update(data, inputEncoding, outputEncoding);
        }
        final(outputEncoding) {
          return this._cipher.final(outputEncoding);
        }
        setAutoPadding(pad) {
          this._cipher.setAutoPadding(pad);
          return this;
        }
        setAAD(buffer, opts) {
          this._cipher.setAAD(buffer, opts);
          return this;
        }
        setAuthTag(authTag, encoding) {
          this._cipher.setAuthTag(authTag, encoding);
          return this;
        }
        _transform(data, encoding, cb) {
          this.push(this.update(data));
          cb(null);
        }
        _flush(cb) {
          this.push(this.final());
          cb(null);
        }
      };
    }
  });

  // ../../node_modules/bare-crypto/lib/random.js
  var require_random = __commonJS({
    "../../node_modules/bare-crypto/lib/random.js"(exports) {
      var assert = require_bare_assert();
      var binding = require_binding6();
      exports.randomBytes = function randomBytes(size, cb) {
        assert(typeof size === "number" && !isNaN(size));
        const buffer = Buffer.allocUnsafe(size);
        exports.randomFill(buffer);
        if (cb) queueMicrotask(() => cb(null, buffer));
        else return buffer;
      };
      exports.randomFill = function randomFill(buffer, offset, size, cb) {
        if (typeof offset === "function") {
          cb = offset;
          offset = void 0;
        } else if (typeof size === "function") {
          cb = size;
          size = void 0;
        }
        assert(buffer instanceof ArrayBuffer || ArrayBuffer.isView(buffer));
        assert(size === void 0 || typeof size === "number" && !isNaN(size));
        assert(offset === void 0 || typeof offset === "number" && !isNaN(offset));
        const elementSize = buffer.BYTES_PER_ELEMENT || 1;
        if (offset === void 0) offset = 0;
        else offset *= elementSize;
        if (size === void 0) size = buffer.byteLength - offset;
        else size *= elementSize;
        if (offset < 0 || offset > buffer.byteLength) {
          throw new RangeError("offset is out of range");
        }
        if (size < 0 || size > buffer.byteLength) {
          throw new RangeError("size is out of range");
        }
        if (offset + size > buffer.byteLength) {
          throw new RangeError("offset + size is out of range");
        }
        let arraybuffer;
        if (ArrayBuffer.isView(buffer)) {
          offset += buffer.byteOffset;
          arraybuffer = buffer.buffer;
        } else {
          arraybuffer = buffer;
        }
        binding.randomFill(arraybuffer, offset, size);
        if (cb) queueMicrotask(() => cb(null, buffer));
        else return buffer;
      };
      exports.randomUUID = function randomUUID() {
        const uuid = exports.randomBytes(16);
        uuid[6] = uuid[6] >>> 4 | 64;
        uuid[8] = uuid[8] >>> 2 | 128;
        return uuid.subarray(0, 4).toString("hex") + "-" + uuid.subarray(4, 6).toString("hex") + "-" + uuid.subarray(6, 8).toString("hex") + "-" + uuid.subarray(8, 10).toString("hex") + "-" + uuid.subarray(10, 16).toString("hex");
      };
    }
  });

  // ../../node_modules/bare-crypto/lib/pbkdf2.js
  var require_pbkdf2 = __commonJS({
    "../../node_modules/bare-crypto/lib/pbkdf2.js"(exports, module) {
      var assert = require_bare_assert();
      var binding = require_binding6();
      var constants = require_constants4();
      module.exports = function pbkdf2(password, salt, iterations, keylen, digest, cb) {
        if (iterations <= 0) {
          throw new RangeError("iterations is out of range");
        }
        assert(typeof iterations === "number" && !isNaN(iterations));
        assert(typeof keylen === "number" && !isNaN(keylen));
        if (typeof password === "string") password = Buffer.from(password);
        if (typeof salt === "string") salt = Buffer.from(salt);
        assert(ArrayBuffer.isView(password));
        assert(ArrayBuffer.isView(salt));
        const buffer = Buffer.from(
          binding.pbkdf2(
            password.buffer,
            password.byteOffset,
            password.byteLength,
            salt.buffer,
            salt.byteOffset,
            salt.byteLength,
            iterations,
            constants.toHash(digest),
            keylen
          )
        );
        if (cb) queueMicrotask(() => cb(null, buffer));
        else return buffer;
      };
    }
  });

  // ../../node_modules/bare-crypto/lib/key.js
  var require_key = __commonJS({
    "../../node_modules/bare-crypto/lib/key.js"(exports) {
      var binding = require_binding6();
      var constants = require_constants4();
      var {
        keyType: { ED25519 }
      } = constants;
      var CryptoKey = class {
        constructor(keyType) {
          this._keyType = keyType;
        }
      };
      exports.Key = CryptoKey;
      var CryptoEd25519Key = class extends CryptoKey {
        constructor(key) {
          super(ED25519);
          this._key = key;
        }
        get asymmetricKeyType() {
          return "ed25519";
        }
      };
      var CryptoEd25519PublicKey = class extends CryptoEd25519Key {
        get type() {
          return "public";
        }
      };
      exports.Ed25519PublicKey = CryptoEd25519PublicKey;
      var CryptoEd25519PrivateKey = class extends CryptoEd25519Key {
        get type() {
          return "private";
        }
      };
      exports.Ed25519PrivateKey = CryptoEd25519PrivateKey;
      exports.generateKeyPair = function generateKeyPair(type, opts = {}) {
        type = constants.toKeyType(type);
        switch (type) {
          case ED25519: {
            const { publicKey, privateKey } = binding.ed25519GenerateKeypair();
            return {
              publicKey: new CryptoEd25519PublicKey(publicKey),
              privateKey: new CryptoEd25519PrivateKey(privateKey)
            };
          }
        }
      };
    }
  });

  // ../../node_modules/bare-crypto/lib/signature.js
  var require_signature = __commonJS({
    "../../node_modules/bare-crypto/lib/signature.js"(exports) {
      var assert = require_bare_assert();
      var binding = require_binding6();
      var { Key } = require_key();
      var constants = require_constants4();
      var {
        keyType: { ED25519 }
      } = constants;
      exports.sign = function sign(algorithm, data, key) {
        assert(data instanceof ArrayBuffer || ArrayBuffer.isView(data));
        if (ArrayBuffer.isView(data)) {
          data = Buffer.coerce(data);
        } else {
          data = Buffer.from(data);
        }
        assert(key instanceof Key);
        switch (key._keyType) {
          case ED25519:
            return Buffer.from(
              binding.ed25519Sign(data.buffer, data.byteOffset, data.byteLength, key._key)
            );
        }
      };
      exports.verify = function verify(algorithm, data, key, signature) {
        assert(data instanceof ArrayBuffer || ArrayBuffer.isView(data));
        if (ArrayBuffer.isView(data)) {
          data = Buffer.coerce(data);
        } else {
          data = Buffer.from(data);
        }
        assert(signature instanceof ArrayBuffer || ArrayBuffer.isView(signature));
        if (ArrayBuffer.isView(signature)) {
          signature = Buffer.coerce(signature);
        } else {
          signature = Buffer.from(signature);
        }
        assert(key instanceof Key);
        switch (key._keyType) {
          case ED25519:
            assert(signature.byteLength === 64);
            return binding.ed25519Verify(
              data.buffer,
              data.byteOffset,
              data.byteLength,
              signature.buffer,
              signature.byteOffset,
              key._key
            );
        }
      };
    }
  });

  // ../../node_modules/bare-crypto/lib/web/crypto-key.js
  var require_crypto_key = __commonJS({
    "../../node_modules/bare-crypto/lib/web/crypto-key.js"(exports, module) {
      module.exports = class CryptoKey {
        constructor(type, extractable, algorithm, usages, handle = null) {
          this._type = type;
          this._extractable = extractable;
          this._algorithm = algorithm;
          this._usages = usages;
          this._handle = handle;
        }
        // https://w3c.github.io/webcrypto/#dom-cryptokey-type
        get type() {
          return this._type;
        }
        // https://w3c.github.io/webcrypto/#dom-cryptokey-extractable
        get extractable() {
          return this._extractable;
        }
        // https://w3c.github.io/webcrypto/#dom-cryptokey-algorithm
        get algorithm() {
          return this._algorithm;
        }
        // https://w3c.github.io/webcrypto/#dom-cryptokey-usages
        get usages() {
          return this._usages;
        }
        [Symbol.for("bare.inspect")]() {
          return {
            __proto__: { constructor: CryptoKey },
            type: this.type,
            extractable: this.extractable,
            algorithm: this.algorithm,
            usages: this.usages
          };
        }
      };
    }
  });

  // ../../node_modules/bare-crypto/lib/web/algorithm/hmac.js
  var require_hmac2 = __commonJS({
    "../../node_modules/bare-crypto/lib/web/algorithm/hmac.js"(exports) {
      var crypto = require_bare_crypto();
      var errors = require_errors5();
      var CryptoKey = require_crypto_key();
      exports.sign = function sign(algorithm, key, data) {
        const digest = crypto.createHmac(key.algorithm.hash.name, key._handle).update(data).digest();
        return digest.buffer.slice(0, digest.byteLength);
      };
      exports.verify = function verify(algorithm, key, signature, data) {
        const digest = crypto.createHmac(key.algorithm.hash.name, key._handle).update(data).digest();
        if (ArrayBuffer.isView(signature)) {
          signature = Buffer.coerce(signature);
        } else {
          signature = Buffer.from(signature);
        }
        return signature.equals(digest);
      };
      exports.generateKey = function generateKey(algorithm, extractable, usages) {
        for (const usage of usages) {
          if (usage !== "sign" && usage !== "verify") {
            throw new SyntaxError(`Usage '${usage}' cannot be used for the HMAC generateKey() operation`);
          }
        }
        const { length = exports.getKeyLength(algorithm) } = algorithm.length;
        let hash = algorithm.hash;
        if (typeof hash === "string") hash = { name: hash };
        const key = crypto.createHmac(hash.name, crypto.randomBytes(length)).digest();
        return new CryptoKey(
          "secret",
          extractable,
          {
            name: "HMAC",
            length,
            hash: {
              name: hash.name.toUpperCase()
            }
          },
          usages,
          key
        );
      };
      exports.importKey = function importKey(format, keyData, algorithm, extractable, usages) {
        for (const usage of usages) {
          if (usage !== "sign" && usage !== "verify") {
            throw new SyntaxError(`Invalid usage ${usage}`);
          }
        }
        let hash = algorithm.hash;
        if (typeof hash === "string") hash = { name: hash };
        let data;
        switch (format) {
          case "raw":
            data = keyData;
            break;
          case "jwk":
            const jwk = keyData;
            if (jwk.kty !== "oct") {
              throw errors.INVALID_DATA("JWK key must be an octet sequence");
            }
            data = Buffer.from(jwk.k, "base64url");
            switch (hash.name.toLowerCase()) {
              case "sha-1":
                if (jwk.alg === "HS1") break;
                else throw errors.INVALID_DATA("Invalid JWK key algorithm");
              case "sha-256":
                if (jwk.alg === "HS256") break;
                else throw errors.INVALID_DATA("Invalid JWK key algorithm");
              case "sha-384":
                if (jwk.alg === "HS384") break;
                else throw errors.INVALID_DATA("Invalid JWK key algorithm");
              case "sha-512":
                if (jwk.alg === "HS512") break;
                else throw errors.INVALID_DATA("Invalid JWK key algorithm");
            }
            if (usages.length && "use" in jwk && jwk.use !== "sign") {
              throw errors.INVALID_DATA("JWK cannot be used for signing");
            }
            if ("ext" in jwk && jwk.ext !== extractable && extractable) {
              throw errors.INVALID_DATA("JWK is not extractable");
            }
            break;
          default:
            throw errors.NOT_SUPPORTED(
              `Format '${format}' cannot be used for the HMAC importKey() operation`
            );
        }
        const length = data.byteLength * 8;
        if (length === 0) {
          throw errors.INVALID_DATA("Key cannot be empty");
        }
        return new CryptoKey(
          "secret",
          extractable,
          {
            name: "HMAC",
            length,
            hash: {
              name: hash.name.toUpperCase()
            }
          },
          usages,
          data
        );
      };
      exports.exportKey = function exportKey(format, key) {
        const data = key._handle;
        switch (format) {
          case "raw":
            return data.buffer.slice(0, data.byteLength);
          case "jwk": {
            const jwk = {
              kty: "oct",
              k: data.toString("base64url"),
              alg: null,
              key_ops: key.usages,
              ext: key.extractable
            };
            switch (key.algorithm.hash.name) {
              case "SHA-1":
                jwk.alg = "HS1";
                break;
              case "SHA-256":
                jwk.alg = "HS256";
                break;
              case "SHA-384":
                jwk.alg = "HS384";
                break;
              case "SHA-512":
                jwk.alg = "HS512";
                break;
            }
            return jwk;
          }
          default:
            throw errors.NOT_SUPPORTED(
              `Format '${format}' cannot be used for the HMAC exportKey() operation`
            );
        }
      };
      exports.getKeyLength = function getKeyLength(algorithm) {
        const { length, hash } = algorithm;
        if (length === void 0) {
          if (hash === "SHA-1" || hash === "SHA-256") return 512;
          if (hash === "SHA-512") return 1024;
          throw errors.OPERATION_ERROR(`Invalid hash '${hash}'`);
        }
        if (length === 0) {
          throw errors.OPERATION_ERROR(`Invalid length ${length}`);
        }
        return length;
      };
    }
  });

  // ../../node_modules/bare-crypto/lib/web/algorithm/pbkdf2.js
  var require_pbkdf22 = __commonJS({
    "../../node_modules/bare-crypto/lib/web/algorithm/pbkdf2.js"(exports) {
      var crypto = require_bare_crypto();
      var errors = require_errors5();
      var CryptoKey = require_crypto_key();
      exports.deriveBits = function deriveBits(algorithm, key, length) {
        if (length === void 0 || length % 8) {
          throw errors.OPERATION_ERROR("Length must be multiple of 8");
        }
        if (algorithm.iterations === 0) {
          throw errors.OPERATION_ERROR("Iterations must be non-0");
        }
        if (length === 0) {
          return new ArrayBuffer(0);
        }
        let hash = algorithm.hash;
        if (typeof hash === "string") hash = { name: hash };
        const result = crypto.pbkdf2(
          key._handle,
          algorithm.salt,
          algorithm.iterations,
          length / 8,
          hash.name
        );
        return result.buffer;
      };
      exports.importKey = function importKey(format, keyData, algorithm, extractable, usages) {
        if (format !== "raw") {
          throw errors.NOT_SUPPORTED(
            `Format '${format}' cannot be used for the PBKDF2 importKey() operation`
          );
        }
        for (const usage of usages) {
          if (usage !== "deriveKey" && usage !== "deriveBits") {
            throw new SyntaxError(`Invalid usage ${usage}`);
          }
        }
        if (extractable) {
          throw new SyntaxError("Extractable must be false");
        }
        return new CryptoKey(
          "secret",
          extractable,
          {
            name: "PBKDF2"
          },
          usages,
          keyData
        );
      };
    }
  });

  // ../../node_modules/bare-crypto/lib/web/algorithm/ed25519.js
  var require_ed25519 = __commonJS({
    "../../node_modules/bare-crypto/lib/web/algorithm/ed25519.js"(exports) {
      var crypto = require_bare_crypto();
      var binding = require_binding6();
      var errors = require_errors5();
      var { Ed25519PublicKey, Ed25519PrivateKey } = require_key();
      var CryptoKey = require_crypto_key();
      exports.sign = function sign(algorithm, key, data) {
        if (key.type !== "private") {
          throw errors.INVALID_ACCESS("Must pass private key for Ed25519 signing");
        }
        const signature = crypto.sign(null, data, key._handle);
        return signature.buffer.slice(0, signature.byteLength);
      };
      exports.verify = function verify(algorithm, key, signature, data) {
        if (key.type !== "public") {
          throw errors.INVALID_ACCESS("Must pass public key for Ed25519 verification");
        }
        return crypto.verify(null, data, key._handle, signature);
      };
      exports.generateKey = function generateKey(algorithm, extractable, usages) {
        for (const usage of usages) {
          if (usage !== "sign" && usage !== "verify") {
            throw new SyntaxError(
              `Usage '${usage}' cannot be used for the Ed25519 generateKey() operation`
            );
          }
        }
        const keys = crypto.generateKeyPair("ed25519");
        algorithm = { name: "Ed25519" };
        return {
          publicKey: new CryptoKey("public", true, algorithm, ["verify"], keys.publicKey),
          privateKey: new CryptoKey("private", extractable, algorithm, ["sign"], keys.privateKey)
        };
      };
      exports.importKey = function importKey(format, keyData, algorithm, extractable, usages) {
        switch (format) {
          case "spki":
            for (const usage of usages) {
              if (usage !== "verify") {
                throw new SyntaxError(
                  `Usage '${usage}' cannot be used for the Ed25519 importKey() operation`
                );
              }
            }
            keyData = binding.ed25519FromSPKI(keyData.buffer, keyData.byteOffset, keyData.byteLength);
            return new CryptoKey(
              "public",
              extractable,
              {
                name: "Ed25519"
              },
              usages,
              new Ed25519PublicKey(keyData)
            );
          case "pkcs8":
            for (const usage of usages) {
              if (usage !== "sign") {
                throw new SyntaxError(
                  `Usage '${usage}' cannot be used for the Ed25519 importKey() operation`
                );
              }
            }
            keyData = binding.ed25519FromPKCS8(keyData.buffer, keyData.byteOffset, keyData.byteLength);
            return new CryptoKey(
              "private",
              extractable,
              {
                name: "Ed25519"
              },
              usages,
              new Ed25519PrivateKey(keyData)
            );
          case "raw":
            for (const usage of usages) {
              if (usage !== "verify") {
                throw new SyntaxError(
                  `Usage '${usage}' cannot be used for the Ed25519 importKey() operation`
                );
              }
            }
            if (keyData.byteLength * 8 !== 256) {
              throw errors.INVALID_DATA("Key must be 256 bits");
            }
            return new CryptoKey(
              "public",
              extractable,
              {
                name: "Ed25519"
              },
              usages,
              new Ed25519PublicKey(keyData.buffer)
            );
          case "jwk":
            const jwk = keyData;
            if ("d" in jwk) {
              if (usages.some((usage) => usage !== "sign")) {
                throw new SyntaxError("JWK must be valid for signing");
              }
            } else {
              if (usages.some((usage) => usage !== "verify")) {
                throw new SyntaxError("JWK must be valid for verification");
              }
            }
            if (jwk.kty !== "OKP") {
              throw errors.INVALID_DATA("JWK key must be an octet key-pair");
            }
            if (jwk.crv !== "Ed25519") {
              throw errors.INVALID_DATA("JWK must use the Ed25519 curve");
            }
            if ("alg" in jwk && jwk.alg !== "Ed25519" && jwk.alg !== "EdDSA") {
              throw errors.INVALID_DATA("JWK must use the Ed25519 curve");
            }
            if (usages.length && "use" in jwk && jwk.use !== "sig") {
              throw errors.INVALID_DATA("JWK cannot be used for signatures");
            }
            if ("ext" in jwk && jwk.ext !== extractable && extractable) {
              throw errors.INVALID_DATA("JWK is not extractable");
            }
            if ("d" in jwk) {
              const key2 = Buffer.concat([
                Buffer.from(jwk.d, "base64url"),
                Buffer.from(jwk.x, "base64url")
              ]);
              if (key2.byteLength * 8 !== 512) {
                throw errors.INVALID_DATA("Key must be 512 bits");
              }
              return new CryptoKey(
                "private",
                extractable,
                {
                  name: "Ed25519"
                },
                usages,
                new Ed25519PrivateKey(key2.buffer)
              );
            }
            const key = Buffer.from(jwk.x, "base64url");
            if (key.byteLength * 8 !== 256) {
              throw errors.INVALID_DATA("Key must be 256 bits");
            }
            return new CryptoKey(
              "public",
              extractable,
              {
                name: "Ed25519"
              },
              usages,
              new Ed25519PublicKey(key.buffer)
            );
          default:
            throw errors.NOT_SUPPORTED(
              `Format '${format}' cannot be used for the Ed25519 importKey() operation`
            );
        }
      };
      exports.exportKey = function exportKey(format, key) {
        const data = key._handle;
        switch (format) {
          case "spki":
            if (key.type !== "public") {
              throw errors.INVALID_ACCESS(
                `Key of type '${key.type}' cannot be used for the Ed25519 exportKey() operation`
              );
            }
            return binding.ed25519ToSPKI(data._key);
          case "pkcs8":
            if (key.type !== "private") {
              throw errors.INVALID_ACCESS(
                `Key of type '${key.type}' cannot be used for the Ed25519 exportKey() operation`
              );
            }
            return binding.ed25519ToPKCS8(data._key);
          case "raw": {
            if (key.type !== "public") {
              throw errors.INVALID_ACCESS(
                `Key of type '${key.type}' cannot be used for the Ed25519 exportKey() operation`
              );
            }
            return data._key.slice();
          }
          case "jwk": {
            const buffer = Buffer.from(data._key);
            if (key.type === "private") {
              const d = buffer.subarray(0, 32).toString("base64url");
              const x = buffer.subarray(32).toString("base64url");
              return {
                kty: "OKP",
                alg: "Ed25519",
                crv: "Ed25519",
                x,
                d,
                key_ops: key.usages,
                ext: key.extractable
              };
            }
            return {
              kty: "OKP",
              alg: "Ed25519",
              crv: "Ed25519",
              x: buffer.toString("base64url"),
              key_ops: key.usages,
              ext: key.extractable
            };
          }
          default:
            throw errors.NOT_SUPPORTED(
              `Format '${format}' cannot be used for the HMAC exportKey() operation`
            );
        }
      };
    }
  });

  // ../../node_modules/bare-crypto/lib/web/algorithm/sha.js
  var require_sha = __commonJS({
    "../../node_modules/bare-crypto/lib/web/algorithm/sha.js"(exports) {
      var crypto = require_bare_crypto();
      exports.digest = function digest(name, data) {
        const digest2 = crypto.createHash(name).update(data).digest();
        return digest2.buffer.slice(0, digest2.byteLength);
      };
    }
  });

  // ../../node_modules/bare-crypto/web.js
  var require_web2 = __commonJS({
    "../../node_modules/bare-crypto/web.js"(exports) {
      var crypto = require_bare_crypto();
      var errors = require_errors5();
      var CryptoKey = require_crypto_key();
      var hmac = require_hmac2();
      var pbkdf2 = require_pbkdf22();
      var ed25519 = require_ed25519();
      var sha = require_sha();
      exports.CryptoKey = CryptoKey;
      exports.getRandomValues = function getRandomValues(array) {
        return crypto.randomFillSync(array);
      };
      exports.randomUUID = crypto.randomUUID;
      exports.SubtleCrypto = class SubtleCrypto {
        // https://w3c.github.io/webcrypto/#SubtleCrypto-method-generateKey
        async generateKey(algorithm, extractable, usages) {
          if (typeof algorithm === "string") algorithm = { name: algorithm };
          switch (algorithm.name.toLowerCase()) {
            case "hmac":
              return hmac.generateKey(algorithm, extractable, usages);
            case "ed25519":
              return ed25519.generateKey(algorithm, extractable, usages);
            default:
              throw errors.NOT_SUPPORTED(
                `Algorithm '${algorithm.name}' does not support the generateKey() operation`
              );
          }
        }
        // https://w3c.github.io/webcrypto/#SubtleCrypto-method-importKey
        async importKey(format, keyData, algorithm, extractable, usages) {
          if (typeof algorithm === "string") algorithm = { name: algorithm };
          switch (format) {
            case "raw":
            case "pkcs8":
            case "spki":
              if (ArrayBuffer.isView(keyData)) {
                keyData = Buffer.from(keyData);
              } else {
                keyData = Buffer.from(keyData.slice());
              }
              break;
          }
          switch (algorithm.name.toLowerCase()) {
            case "hmac":
              return hmac.importKey(format, keyData, algorithm, extractable, usages);
            case "ed25519":
              return ed25519.importKey(format, keyData, algorithm, extractable, usages);
            case "pbkdf2":
              return pbkdf2.importKey(format, keyData, algorithm, extractable, usages);
            default:
              throw errors.NOT_SUPPORTED(
                `Algorithm '${algorithm.name}' does not support the importKey() operation`
              );
          }
        }
        // https://w3c.github.io/webcrypto/#SubtleCrypto-method-exportKey
        async exportKey(format, key) {
          if (!key.extractable) {
            throw errors.INVALID_ACCESS("Key is not extractable");
          }
          switch (key.algorithm.name.toLowerCase()) {
            case "hmac":
              return hmac.exportKey(format, key);
            case "ed25519":
              return ed25519.exportKey(format, key);
            default:
              throw errors.NOT_SUPPORTED(
                `Algorithm '${key.algorithm.name}' does not support the exportKey() operation`
              );
          }
        }
        // https://w3c.github.io/webcrypto/#SubtleCrypto-method-sign
        async sign(algorithm, key, data) {
          if (typeof algorithm === "string") algorithm = { name: algorithm };
          if (algorithm.name.toLowerCase() !== key.algorithm.name.toLowerCase()) {
            throw errors.INVALID_ACCESS(`Algorithm '${algorithm.name}' does not match key'`);
          }
          if (!key.usages.includes("sign")) {
            throw errors.INVALID_ACCESS("Key cannot be used for signing");
          }
          switch (algorithm.name.toLowerCase()) {
            case "hmac":
              return hmac.sign(algorithm, key, data);
            case "ed25519":
              return ed25519.sign(algorithm, key, data);
            default:
              throw errors.NOT_SUPPORTED(
                `Algorithm '${algorithm.name}' does not support the sign() operation`
              );
          }
        }
        // https://w3c.github.io/webcrypto/#SubtleCrypto-method-verify
        async verify(algorithm, key, signature, data) {
          if (typeof algorithm === "string") algorithm = { name: algorithm };
          if (algorithm.name.toLowerCase() !== key.algorithm.name.toLowerCase()) {
            throw errors.INVALID_ACCESS(`Algorithm '${algorithm.name}' does not match key'`);
          }
          if (!key.usages.includes("verify")) {
            throw errors.INVALID_ACCESS("Key cannot be used for verification");
          }
          switch (algorithm.name.toLowerCase()) {
            case "hmac":
              return hmac.verify(algorithm, key, signature, data);
            case "ed25519":
              return ed25519.verify(algorithm, key, signature, data);
            default:
              throw errors.NOT_SUPPORTED(
                `Algorithm '${algorithm.name}' does not support the verify() operation`
              );
          }
        }
        // https://w3c.github.io/webcrypto/#SubtleCrypto-method-deriveBits
        async deriveBits(algorithm, key, length) {
          if (typeof algorithm === "string") algorithm = { name: algorithm };
          if (algorithm.name.toLowerCase() !== key.algorithm.name.toLowerCase()) {
            throw errors.INVALID_ACCESS(`Algorithm '${algorithm.name}' does not match key'`);
          }
          if (!key.usages.includes("deriveBits")) {
            throw errors.INVALID_ACCESS("Key cannot be used to derive bits");
          }
          switch (algorithm.name.toLowerCase()) {
            case "pbkdf2":
              return pbkdf2.deriveBits(algorithm, key, length);
            default:
              throw errors.NOT_SUPPORTED(
                `Algorithm '${algorithm.name}' does not support the deriveBits() operation`
              );
          }
        }
        // https://w3c.github.io/webcrypto/#SubtleCrypto-method-deriveKey
        async deriveKey(algorithm, baseKey, derivedKeyType, extractable, usages) {
          if (typeof algorithm === "string") algorithm = { name: algorithm };
          if (typeof derivedKeyType === "string") {
            derivedKeyType = { name: derivedKeyType };
          }
          if (algorithm.name.toLowerCase() !== baseKey.algorithm.name.toLowerCase()) {
            throw errors.INVALID_ACCESS(`Algorithm '${algorithm.name}' does not match key'`);
          }
          if (!baseKey.usages.includes("deriveKey")) {
            throw errors.INVALID_ACCESS("Key cannot be used to derive key");
          }
          let length;
          switch (derivedKeyType.name.toLowerCase()) {
            case "hmac":
              length = hmac.getKeyLength(derivedKeyType);
              break;
            default:
              throw errors.NOT_SUPPORTED(
                `Algorithm '${derivedKeyType.name}' does not support the getKeyLength() operation`
              );
          }
          let secret;
          switch (algorithm.name.toLowerCase()) {
            case "pbkdf2":
              secret = pbkdf2.deriveBits(algorithm, baseKey, length);
              break;
            default:
              throw errors.NOT_SUPPORTED(
                `Algorithm '${algorithm.name}' does not support the deriveBits() operation`
              );
          }
          return this.importKey("raw", secret, derivedKeyType, extractable, usages);
        }
        // https://w3c.github.io/webcrypto/#SubtleCrypto-method-digest
        async digest(algorithm, data) {
          if (typeof algorithm === "string") algorithm = { name: algorithm };
          switch (algorithm.name.toLowerCase()) {
            case "sha-1":
              return sha.digest(crypto.constants.hash.SHA1, data);
            case "sha-256":
              return sha.digest(crypto.constants.hash.SHA256, data);
            case "sha-384":
              return sha.digest(crypto.constants.hash.SHA384, data);
            case "sha-512":
              return sha.digest(crypto.constants.hash.SHA512, data);
            default:
              throw errors.NOT_SUPPORTED(
                `Algorithm '${algorithm.name}' does not support the digest() operation`
              );
          }
        }
      };
      exports.subtle = new exports.SubtleCrypto();
      exports.Crypto = class Crypto {
        get subtle() {
          return exports.subtle;
        }
        getRandomValues(array) {
          return exports.getRandomValues(array);
        }
        randomUUID() {
          return exports.randomUUID();
        }
      };
    }
  });

  // ../../node_modules/bare-crypto/index.js
  var require_bare_crypto = __commonJS({
    "../../node_modules/bare-crypto/index.js"(exports) {
      var constants = require_constants4();
      var Hash = require_hash();
      var Hmac = require_hmac();
      var { Cipheriv, Decipheriv } = require_cipher();
      var { randomBytes, randomFill, randomUUID } = require_random();
      var pbkdf2 = require_pbkdf2();
      var { generateKeyPair } = require_key();
      var { sign, verify } = require_signature();
      exports.constants = constants;
      exports.Hash = Hash;
      exports.createHash = function createHash(algorithm, opts) {
        return new Hash(algorithm, opts);
      };
      exports.Hmac = Hmac;
      exports.createHmac = function createHmac(algorithm, key, opts) {
        return new Hmac(algorithm, key, opts);
      };
      exports.Cipheriv = Cipheriv;
      exports.createCipheriv = function createCipheriv(algorithm, key, iv, opts) {
        return new Cipheriv(algorithm, key, iv, opts);
      };
      exports.Decipheriv = Decipheriv;
      exports.createDecipheriv = function createDecipheriv(algorithm, key, iv, opts) {
        return new Decipheriv(algorithm, key, iv, opts);
      };
      exports.randomBytes = randomBytes;
      exports.randomFill = randomFill;
      exports.randomFillSync = function randomFillSync(buffer, offset, size) {
        return exports.randomFill(buffer, offset, size);
      };
      exports.randomUUID = randomUUID;
      exports.pbkdf2 = pbkdf2;
      exports.pbkdf2Sync = function pbkdf2Sync(password, salt, iterations, keylen, digest) {
        return exports.pbkdf2(password, salt, iterations, keylen, digest);
      };
      exports.generateKeyPair = generateKeyPair;
      exports.sign = sign;
      exports.verify = verify;
      exports.webcrypto = require_web2();
    }
  });

  // ../../node_modules/graceful-fs/polyfills.js
  var require_polyfills = __commonJS({
    "../../node_modules/graceful-fs/polyfills.js"(exports, module) {
      var constants = __require("constants");
      var origCwd = process.cwd;
      var cwd = null;
      var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform;
      process.cwd = function() {
        if (!cwd)
          cwd = origCwd.call(process);
        return cwd;
      };
      try {
        process.cwd();
      } catch (er) {
      }
      if (typeof process.chdir === "function") {
        chdir = process.chdir;
        process.chdir = function(d) {
          cwd = null;
          chdir.call(process, d);
        };
        if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, chdir);
      }
      var chdir;
      module.exports = patch;
      function patch(fs) {
        if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
          patchLchmod(fs);
        }
        if (!fs.lutimes) {
          patchLutimes(fs);
        }
        fs.chown = chownFix(fs.chown);
        fs.fchown = chownFix(fs.fchown);
        fs.lchown = chownFix(fs.lchown);
        fs.chmod = chmodFix(fs.chmod);
        fs.fchmod = chmodFix(fs.fchmod);
        fs.lchmod = chmodFix(fs.lchmod);
        fs.chownSync = chownFixSync(fs.chownSync);
        fs.fchownSync = chownFixSync(fs.fchownSync);
        fs.lchownSync = chownFixSync(fs.lchownSync);
        fs.chmodSync = chmodFixSync(fs.chmodSync);
        fs.fchmodSync = chmodFixSync(fs.fchmodSync);
        fs.lchmodSync = chmodFixSync(fs.lchmodSync);
        fs.stat = statFix(fs.stat);
        fs.fstat = statFix(fs.fstat);
        fs.lstat = statFix(fs.lstat);
        fs.statSync = statFixSync(fs.statSync);
        fs.fstatSync = statFixSync(fs.fstatSync);
        fs.lstatSync = statFixSync(fs.lstatSync);
        if (fs.chmod && !fs.lchmod) {
          fs.lchmod = function(path, mode, cb) {
            if (cb) process.nextTick(cb);
          };
          fs.lchmodSync = function() {
          };
        }
        if (fs.chown && !fs.lchown) {
          fs.lchown = function(path, uid, gid, cb) {
            if (cb) process.nextTick(cb);
          };
          fs.lchownSync = function() {
          };
        }
        if (platform === "win32") {
          fs.rename = typeof fs.rename !== "function" ? fs.rename : (function(fs$rename) {
            function rename(from, to, cb) {
              var start = Date.now();
              var backoff = 0;
              fs$rename(from, to, function CB(er) {
                if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) {
                  setTimeout(function() {
                    fs.stat(to, function(stater, st) {
                      if (stater && stater.code === "ENOENT")
                        fs$rename(from, to, CB);
                      else
                        cb(er);
                    });
                  }, backoff);
                  if (backoff < 100)
                    backoff += 10;
                  return;
                }
                if (cb) cb(er);
              });
            }
            if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
            return rename;
          })(fs.rename);
        }
        fs.read = typeof fs.read !== "function" ? fs.read : (function(fs$read) {
          function read(fd, buffer, offset, length, position, callback_) {
            var callback;
            if (callback_ && typeof callback_ === "function") {
              var eagCounter = 0;
              callback = function(er, _, __) {
                if (er && er.code === "EAGAIN" && eagCounter < 10) {
                  eagCounter++;
                  return fs$read.call(fs, fd, buffer, offset, length, position, callback);
                }
                callback_.apply(this, arguments);
              };
            }
            return fs$read.call(fs, fd, buffer, offset, length, position, callback);
          }
          if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
          return read;
        })(fs.read);
        fs.readSync = typeof fs.readSync !== "function" ? fs.readSync : /* @__PURE__ */ (function(fs$readSync) {
          return function(fd, buffer, offset, length, position) {
            var eagCounter = 0;
            while (true) {
              try {
                return fs$readSync.call(fs, fd, buffer, offset, length, position);
              } catch (er) {
                if (er.code === "EAGAIN" && eagCounter < 10) {
                  eagCounter++;
                  continue;
                }
                throw er;
              }
            }
          };
        })(fs.readSync);
        function patchLchmod(fs2) {
          fs2.lchmod = function(path, mode, callback) {
            fs2.open(
              path,
              constants.O_WRONLY | constants.O_SYMLINK,
              mode,
              function(err, fd) {
                if (err) {
                  if (callback) callback(err);
                  return;
                }
                fs2.fchmod(fd, mode, function(err2) {
                  fs2.close(fd, function(err22) {
                    if (callback) callback(err2 || err22);
                  });
                });
              }
            );
          };
          fs2.lchmodSync = function(path, mode) {
            var fd = fs2.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode);
            var threw = true;
            var ret;
            try {
              ret = fs2.fchmodSync(fd, mode);
              threw = false;
            } finally {
              if (threw) {
                try {
                  fs2.closeSync(fd);
                } catch (er) {
                }
              } else {
                fs2.closeSync(fd);
              }
            }
            return ret;
          };
        }
        function patchLutimes(fs2) {
          if (constants.hasOwnProperty("O_SYMLINK") && fs2.futimes) {
            fs2.lutimes = function(path, at, mt, cb) {
              fs2.open(path, constants.O_SYMLINK, function(er, fd) {
                if (er) {
                  if (cb) cb(er);
                  return;
                }
                fs2.futimes(fd, at, mt, function(er2) {
                  fs2.close(fd, function(er22) {
                    if (cb) cb(er2 || er22);
                  });
                });
              });
            };
            fs2.lutimesSync = function(path, at, mt) {
              var fd = fs2.openSync(path, constants.O_SYMLINK);
              var ret;
              var threw = true;
              try {
                ret = fs2.futimesSync(fd, at, mt);
                threw = false;
              } finally {
                if (threw) {
                  try {
                    fs2.closeSync(fd);
                  } catch (er) {
                  }
                } else {
                  fs2.closeSync(fd);
                }
              }
              return ret;
            };
          } else if (fs2.futimes) {
            fs2.lutimes = function(_a, _b, _c, cb) {
              if (cb) process.nextTick(cb);
            };
            fs2.lutimesSync = function() {
            };
          }
        }
        function chmodFix(orig) {
          if (!orig) return orig;
          return function(target, mode, cb) {
            return orig.call(fs, target, mode, function(er) {
              if (chownErOk(er)) er = null;
              if (cb) cb.apply(this, arguments);
            });
          };
        }
        function chmodFixSync(orig) {
          if (!orig) return orig;
          return function(target, mode) {
            try {
              return orig.call(fs, target, mode);
            } catch (er) {
              if (!chownErOk(er)) throw er;
            }
          };
        }
        function chownFix(orig) {
          if (!orig) return orig;
          return function(target, uid, gid, cb) {
            return orig.call(fs, target, uid, gid, function(er) {
              if (chownErOk(er)) er = null;
              if (cb) cb.apply(this, arguments);
            });
          };
        }
        function chownFixSync(orig) {
          if (!orig) return orig;
          return function(target, uid, gid) {
            try {
              return orig.call(fs, target, uid, gid);
            } catch (er) {
              if (!chownErOk(er)) throw er;
            }
          };
        }
        function statFix(orig) {
          if (!orig) return orig;
          return function(target, options, cb) {
            if (typeof options === "function") {
              cb = options;
              options = null;
            }
            function callback(er, stats) {
              if (stats) {
                if (stats.uid < 0) stats.uid += 4294967296;
                if (stats.gid < 0) stats.gid += 4294967296;
              }
              if (cb) cb.apply(this, arguments);
            }
            return options ? orig.call(fs, target, options, callback) : orig.call(fs, target, callback);
          };
        }
        function statFixSync(orig) {
          if (!orig) return orig;
          return function(target, options) {
            var stats = options ? orig.call(fs, target, options) : orig.call(fs, target);
            if (stats) {
              if (stats.uid < 0) stats.uid += 4294967296;
              if (stats.gid < 0) stats.gid += 4294967296;
            }
            return stats;
          };
        }
        function chownErOk(er) {
          if (!er)
            return true;
          if (er.code === "ENOSYS")
            return true;
          var nonroot = !process.getuid || process.getuid() !== 0;
          if (nonroot) {
            if (er.code === "EINVAL" || er.code === "EPERM")
              return true;
          }
          return false;
        }
      }
    }
  });

  // ../../node_modules/graceful-fs/legacy-streams.js
  var require_legacy_streams = __commonJS({
    "../../node_modules/graceful-fs/legacy-streams.js"(exports, module) {
      var Stream = __require("stream").Stream;
      module.exports = legacy;
      function legacy(fs) {
        return {
          ReadStream,
          WriteStream
        };
        function ReadStream(path, options) {
          if (!(this instanceof ReadStream)) return new ReadStream(path, options);
          Stream.call(this);
          var self2 = this;
          this.path = path;
          this.fd = null;
          this.readable = true;
          this.paused = false;
          this.flags = "r";
          this.mode = 438;
          this.bufferSize = 64 * 1024;
          options = options || {};
          var keys = Object.keys(options);
          for (var index = 0, length = keys.length; index < length; index++) {
            var key = keys[index];
            this[key] = options[key];
          }
          if (this.encoding) this.setEncoding(this.encoding);
          if (this.start !== void 0) {
            if ("number" !== typeof this.start) {
              throw TypeError("start must be a Number");
            }
            if (this.end === void 0) {
              this.end = Infinity;
            } else if ("number" !== typeof this.end) {
              throw TypeError("end must be a Number");
            }
            if (this.start > this.end) {
              throw new Error("start must be <= end");
            }
            this.pos = this.start;
          }
          if (this.fd !== null) {
            process.nextTick(function() {
              self2._read();
            });
            return;
          }
          fs.open(this.path, this.flags, this.mode, function(err, fd) {
            if (err) {
              self2.emit("error", err);
              self2.readable = false;
              return;
            }
            self2.fd = fd;
            self2.emit("open", fd);
            self2._read();
          });
        }
        function WriteStream(path, options) {
          if (!(this instanceof WriteStream)) return new WriteStream(path, options);
          Stream.call(this);
          this.path = path;
          this.fd = null;
          this.writable = true;
          this.flags = "w";
          this.encoding = "binary";
          this.mode = 438;
          this.bytesWritten = 0;
          options = options || {};
          var keys = Object.keys(options);
          for (var index = 0, length = keys.length; index < length; index++) {
            var key = keys[index];
            this[key] = options[key];
          }
          if (this.start !== void 0) {
            if ("number" !== typeof this.start) {
              throw TypeError("start must be a Number");
            }
            if (this.start < 0) {
              throw new Error("start must be >= zero");
            }
            this.pos = this.start;
          }
          this.busy = false;
          this._queue = [];
          if (this.fd === null) {
            this._open = fs.open;
            this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
            this.flush();
          }
        }
      }
    }
  });

  // ../../node_modules/graceful-fs/clone.js
  var require_clone = __commonJS({
    "../../node_modules/graceful-fs/clone.js"(exports, module) {
      "use strict";
      module.exports = clone;
      var getPrototypeOf = Object.getPrototypeOf || function(obj) {
        return obj.__proto__;
      };
      function clone(obj) {
        if (obj === null || typeof obj !== "object")
          return obj;
        if (obj instanceof Object)
          var copy = { __proto__: getPrototypeOf(obj) };
        else
          var copy = /* @__PURE__ */ Object.create(null);
        Object.getOwnPropertyNames(obj).forEach(function(key) {
          Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key));
        });
        return copy;
      }
    }
  });

  // ../../node_modules/graceful-fs/graceful-fs.js
  var require_graceful_fs = __commonJS({
    "../../node_modules/graceful-fs/graceful-fs.js"(exports, module) {
      var fs = require_bare_node_fs();
      var polyfills = require_polyfills();
      var legacy = require_legacy_streams();
      var clone = require_clone();
      var util = __require("util");
      var gracefulQueue;
      var previousSymbol;
      if (typeof Symbol === "function" && typeof Symbol.for === "function") {
        gracefulQueue = Symbol.for("graceful-fs.queue");
        previousSymbol = Symbol.for("graceful-fs.previous");
      } else {
        gracefulQueue = "___graceful-fs.queue";
        previousSymbol = "___graceful-fs.previous";
      }
      function noop() {
      }
      function publishQueue(context, queue2) {
        Object.defineProperty(context, gracefulQueue, {
          get: function() {
            return queue2;
          }
        });
      }
      var debug = noop;
      if (util.debuglog)
        debug = util.debuglog("gfs4");
      else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ""))
        debug = function() {
          var m = util.format.apply(util, arguments);
          m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
          console.error(m);
        };
      if (!fs[gracefulQueue]) {
        queue = global[gracefulQueue] || [];
        publishQueue(fs, queue);
        fs.close = (function(fs$close) {
          function close(fd, cb) {
            return fs$close.call(fs, fd, function(err) {
              if (!err) {
                resetQueue();
              }
              if (typeof cb === "function")
                cb.apply(this, arguments);
            });
          }
          Object.defineProperty(close, previousSymbol, {
            value: fs$close
          });
          return close;
        })(fs.close);
        fs.closeSync = (function(fs$closeSync) {
          function closeSync(fd) {
            fs$closeSync.apply(fs, arguments);
            resetQueue();
          }
          Object.defineProperty(closeSync, previousSymbol, {
            value: fs$closeSync
          });
          return closeSync;
        })(fs.closeSync);
        if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
          process.on("exit", function() {
            debug(fs[gracefulQueue]);
            require_bare_assert().equal(fs[gracefulQueue].length, 0);
          });
        }
      }
      var queue;
      if (!global[gracefulQueue]) {
        publishQueue(global, fs[gracefulQueue]);
      }
      module.exports = patch(clone(fs));
      if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs.__patched) {
        module.exports = patch(fs);
        fs.__patched = true;
      }
      function patch(fs2) {
        polyfills(fs2);
        fs2.gracefulify = patch;
        fs2.createReadStream = createReadStream;
        fs2.createWriteStream = createWriteStream;
        var fs$readFile = fs2.readFile;
        fs2.readFile = readFile;
        function readFile(path, options, cb) {
          if (typeof options === "function")
            cb = options, options = null;
          return go$readFile(path, options, cb);
          function go$readFile(path2, options2, cb2, startTime) {
            return fs$readFile(path2, options2, function(err) {
              if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
                enqueue([go$readFile, [path2, options2, cb2], err, startTime || Date.now(), Date.now()]);
              else {
                if (typeof cb2 === "function")
                  cb2.apply(this, arguments);
              }
            });
          }
        }
        var fs$writeFile = fs2.writeFile;
        fs2.writeFile = writeFile;
        function writeFile(path, data, options, cb) {
          if (typeof options === "function")
            cb = options, options = null;
          return go$writeFile(path, data, options, cb);
          function go$writeFile(path2, data2, options2, cb2, startTime) {
            return fs$writeFile(path2, data2, options2, function(err) {
              if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
                enqueue([go$writeFile, [path2, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
              else {
                if (typeof cb2 === "function")
                  cb2.apply(this, arguments);
              }
            });
          }
        }
        var fs$appendFile = fs2.appendFile;
        if (fs$appendFile)
          fs2.appendFile = appendFile;
        function appendFile(path, data, options, cb) {
          if (typeof options === "function")
            cb = options, options = null;
          return go$appendFile(path, data, options, cb);
          function go$appendFile(path2, data2, options2, cb2, startTime) {
            return fs$appendFile(path2, data2, options2, function(err) {
              if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
                enqueue([go$appendFile, [path2, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
              else {
                if (typeof cb2 === "function")
                  cb2.apply(this, arguments);
              }
            });
          }
        }
        var fs$copyFile = fs2.copyFile;
        if (fs$copyFile)
          fs2.copyFile = copyFile;
        function copyFile(src, dest, flags, cb) {
          if (typeof flags === "function") {
            cb = flags;
            flags = 0;
          }
          return go$copyFile(src, dest, flags, cb);
          function go$copyFile(src2, dest2, flags2, cb2, startTime) {
            return fs$copyFile(src2, dest2, flags2, function(err) {
              if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
                enqueue([go$copyFile, [src2, dest2, flags2, cb2], err, startTime || Date.now(), Date.now()]);
              else {
                if (typeof cb2 === "function")
                  cb2.apply(this, arguments);
              }
            });
          }
        }
        var fs$readdir = fs2.readdir;
        fs2.readdir = readdir;
        var noReaddirOptionVersions = /^v[0-5]\./;
        function readdir(path, options, cb) {
          if (typeof options === "function")
            cb = options, options = null;
          var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path2, options2, cb2, startTime) {
            return fs$readdir(path2, fs$readdirCallback(
              path2,
              options2,
              cb2,
              startTime
            ));
          } : function go$readdir2(path2, options2, cb2, startTime) {
            return fs$readdir(path2, options2, fs$readdirCallback(
              path2,
              options2,
              cb2,
              startTime
            ));
          };
          return go$readdir(path, options, cb);
          function fs$readdirCallback(path2, options2, cb2, startTime) {
            return function(err, files) {
              if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
                enqueue([
                  go$readdir,
                  [path2, options2, cb2],
                  err,
                  startTime || Date.now(),
                  Date.now()
                ]);
              else {
                if (files && files.sort)
                  files.sort();
                if (typeof cb2 === "function")
                  cb2.call(this, err, files);
              }
            };
          }
        }
        if (process.version.substr(0, 4) === "v0.8") {
          var legStreams = legacy(fs2);
          ReadStream = legStreams.ReadStream;
          WriteStream = legStreams.WriteStream;
        }
        var fs$ReadStream = fs2.ReadStream;
        if (fs$ReadStream) {
          ReadStream.prototype = Object.create(fs$ReadStream.prototype);
          ReadStream.prototype.open = ReadStream$open;
        }
        var fs$WriteStream = fs2.WriteStream;
        if (fs$WriteStream) {
          WriteStream.prototype = Object.create(fs$WriteStream.prototype);
          WriteStream.prototype.open = WriteStream$open;
        }
        Object.defineProperty(fs2, "ReadStream", {
          get: function() {
            return ReadStream;
          },
          set: function(val) {
            ReadStream = val;
          },
          enumerable: true,
          configurable: true
        });
        Object.defineProperty(fs2, "WriteStream", {
          get: function() {
            return WriteStream;
          },
          set: function(val) {
            WriteStream = val;
          },
          enumerable: true,
          configurable: true
        });
        var FileReadStream = ReadStream;
        Object.defineProperty(fs2, "FileReadStream", {
          get: function() {
            return FileReadStream;
          },
          set: function(val) {
            FileReadStream = val;
          },
          enumerable: true,
          configurable: true
        });
        var FileWriteStream = WriteStream;
        Object.defineProperty(fs2, "FileWriteStream", {
          get: function() {
            return FileWriteStream;
          },
          set: function(val) {
            FileWriteStream = val;
          },
          enumerable: true,
          configurable: true
        });
        function ReadStream(path, options) {
          if (this instanceof ReadStream)
            return fs$ReadStream.apply(this, arguments), this;
          else
            return ReadStream.apply(Object.create(ReadStream.prototype), arguments);
        }
        function ReadStream$open() {
          var that = this;
          open(that.path, that.flags, that.mode, function(err, fd) {
            if (err) {
              if (that.autoClose)
                that.destroy();
              that.emit("error", err);
            } else {
              that.fd = fd;
              that.emit("open", fd);
              that.read();
            }
          });
        }
        function WriteStream(path, options) {
          if (this instanceof WriteStream)
            return fs$WriteStream.apply(this, arguments), this;
          else
            return WriteStream.apply(Object.create(WriteStream.prototype), arguments);
        }
        function WriteStream$open() {
          var that = this;
          open(that.path, that.flags, that.mode, function(err, fd) {
            if (err) {
              that.destroy();
              that.emit("error", err);
            } else {
              that.fd = fd;
              that.emit("open", fd);
            }
          });
        }
        function createReadStream(path, options) {
          return new fs2.ReadStream(path, options);
        }
        function createWriteStream(path, options) {
          return new fs2.WriteStream(path, options);
        }
        var fs$open = fs2.open;
        fs2.open = open;
        function open(path, flags, mode, cb) {
          if (typeof mode === "function")
            cb = mode, mode = null;
          return go$open(path, flags, mode, cb);
          function go$open(path2, flags2, mode2, cb2, startTime) {
            return fs$open(path2, flags2, mode2, function(err, fd) {
              if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
                enqueue([go$open, [path2, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
              else {
                if (typeof cb2 === "function")
                  cb2.apply(this, arguments);
              }
            });
          }
        }
        return fs2;
      }
      function enqueue(elem) {
        debug("ENQUEUE", elem[0].name, elem[1]);
        fs[gracefulQueue].push(elem);
        retry();
      }
      var retryTimer;
      function resetQueue() {
        var now = Date.now();
        for (var i = 0; i < fs[gracefulQueue].length; ++i) {
          if (fs[gracefulQueue][i].length > 2) {
            fs[gracefulQueue][i][3] = now;
            fs[gracefulQueue][i][4] = now;
          }
        }
        retry();
      }
      function retry() {
        clearTimeout(retryTimer);
        retryTimer = void 0;
        if (fs[gracefulQueue].length === 0)
          return;
        var elem = fs[gracefulQueue].shift();
        var fn = elem[0];
        var args = elem[1];
        var err = elem[2];
        var startTime = elem[3];
        var lastTime = elem[4];
        if (startTime === void 0) {
          debug("RETRY", fn.name, args);
          fn.apply(null, args);
        } else if (Date.now() - startTime >= 6e4) {
          debug("TIMEOUT", fn.name, args);
          var cb = args.pop();
          if (typeof cb === "function")
            cb.call(null, err);
        } else {
          var sinceAttempt = Date.now() - lastTime;
          var sinceStart = Math.max(lastTime - startTime, 1);
          var desiredDelay = Math.min(sinceStart * 1.2, 100);
          if (sinceAttempt >= desiredDelay) {
            debug("RETRY", fn.name, args);
            fn.apply(null, args.concat([startTime]));
          } else {
            fs[gracefulQueue].push(elem);
          }
        }
        if (retryTimer === void 0) {
          retryTimer = setTimeout(retry, 0);
        }
      }
    }
  });

  // ../../node_modules/file-type/index.js
  var require_file_type = __commonJS({
    "../../node_modules/file-type/index.js"(exports, module) {
      "use strict";
      module.exports = (input) => {
        const buf = new Uint8Array(input);
        if (!(buf && buf.length > 1)) {
          return null;
        }
        const check = (header, opts) => {
          opts = Object.assign({
            offset: 0
          }, opts);
          for (let i = 0; i < header.length; i++) {
            if (header[i] !== buf[i + opts.offset]) {
              return false;
            }
          }
          return true;
        };
        if (check([255, 216, 255])) {
          return {
            ext: "jpg",
            mime: "image/jpeg"
          };
        }
        if (check([137, 80, 78, 71, 13, 10, 26, 10])) {
          return {
            ext: "png",
            mime: "image/png"
          };
        }
        if (check([71, 73, 70])) {
          return {
            ext: "gif",
            mime: "image/gif"
          };
        }
        if (check([87, 69, 66, 80], { offset: 8 })) {
          return {
            ext: "webp",
            mime: "image/webp"
          };
        }
        if (check([70, 76, 73, 70])) {
          return {
            ext: "flif",
            mime: "image/flif"
          };
        }
        if ((check([73, 73, 42, 0]) || check([77, 77, 0, 42])) && check([67, 82], { offset: 8 })) {
          return {
            ext: "cr2",
            mime: "image/x-canon-cr2"
          };
        }
        if (check([73, 73, 42, 0]) || check([77, 77, 0, 42])) {
          return {
            ext: "tif",
            mime: "image/tiff"
          };
        }
        if (check([66, 77])) {
          return {
            ext: "bmp",
            mime: "image/bmp"
          };
        }
        if (check([73, 73, 188])) {
          return {
            ext: "jxr",
            mime: "image/vnd.ms-photo"
          };
        }
        if (check([56, 66, 80, 83])) {
          return {
            ext: "psd",
            mime: "image/vnd.adobe.photoshop"
          };
        }
        if (check([80, 75, 3, 4]) && check([109, 105, 109, 101, 116, 121, 112, 101, 97, 112, 112, 108, 105, 99, 97, 116, 105, 111, 110, 47, 101, 112, 117, 98, 43, 122, 105, 112], { offset: 30 })) {
          return {
            ext: "epub",
            mime: "application/epub+zip"
          };
        }
        if (check([80, 75, 3, 4]) && check([77, 69, 84, 65, 45, 73, 78, 70, 47, 109, 111, 122, 105, 108, 108, 97, 46, 114, 115, 97], { offset: 30 })) {
          return {
            ext: "xpi",
            mime: "application/x-xpinstall"
          };
        }
        if (check([80, 75]) && (buf[2] === 3 || buf[2] === 5 || buf[2] === 7) && (buf[3] === 4 || buf[3] === 6 || buf[3] === 8)) {
          return {
            ext: "zip",
            mime: "application/zip"
          };
        }
        if (check([117, 115, 116, 97, 114], { offset: 257 })) {
          return {
            ext: "tar",
            mime: "application/x-tar"
          };
        }
        if (check([82, 97, 114, 33, 26, 7]) && (buf[6] === 0 || buf[6] === 1)) {
          return {
            ext: "rar",
            mime: "application/x-rar-compressed"
          };
        }
        if (check([31, 139, 8])) {
          return {
            ext: "gz",
            mime: "application/gzip"
          };
        }
        if (check([66, 90, 104])) {
          return {
            ext: "bz2",
            mime: "application/x-bzip2"
          };
        }
        if (check([55, 122, 188, 175, 39, 28])) {
          return {
            ext: "7z",
            mime: "application/x-7z-compressed"
          };
        }
        if (check([120, 1])) {
          return {
            ext: "dmg",
            mime: "application/x-apple-diskimage"
          };
        }
        if (check([0, 0, 0]) && (buf[3] === 24 || buf[3] === 32) && check([102, 116, 121, 112], { offset: 4 }) || check([51, 103, 112, 53]) || check([0, 0, 0, 28, 102, 116, 121, 112, 109, 112, 52, 50]) && check([109, 112, 52, 49, 109, 112, 52, 50, 105, 115, 111, 109], { offset: 16 }) || check([0, 0, 0, 28, 102, 116, 121, 112, 105, 115, 111, 109]) || check([0, 0, 0, 28, 102, 116, 121, 112, 109, 112, 52, 50, 0, 0, 0, 0])) {
          return {
            ext: "mp4",
            mime: "video/mp4"
          };
        }
        if (check([0, 0, 0, 28, 102, 116, 121, 112, 77, 52, 86])) {
          return {
            ext: "m4v",
            mime: "video/x-m4v"
          };
        }
        if (check([77, 84, 104, 100])) {
          return {
            ext: "mid",
            mime: "audio/midi"
          };
        }
        if (check([26, 69, 223, 163])) {
          const sliced = buf.subarray(4, 4 + 4096);
          const idPos = sliced.findIndex((el, i, arr) => arr[i] === 66 && arr[i + 1] === 130);
          if (idPos >= 0) {
            const docTypePos = idPos + 3;
            const findDocType = (type) => Array.from(type).every((c, i) => sliced[docTypePos + i] === c.charCodeAt(0));
            if (findDocType("matroska")) {
              return {
                ext: "mkv",
                mime: "video/x-matroska"
              };
            }
            if (findDocType("webm")) {
              return {
                ext: "webm",
                mime: "video/webm"
              };
            }
          }
        }
        if (check([0, 0, 0, 20, 102, 116, 121, 112, 113, 116, 32, 32]) || check([102, 114, 101, 101], { offset: 4 }) || check([102, 116, 121, 112, 113, 116, 32, 32], { offset: 4 }) || check([109, 100, 97, 116], { offset: 4 }) || // MJPEG
        check([119, 105, 100, 101], { offset: 4 })) {
          return {
            ext: "mov",
            mime: "video/quicktime"
          };
        }
        if (check([82, 73, 70, 70]) && check([65, 86, 73], { offset: 8 })) {
          return {
            ext: "avi",
            mime: "video/x-msvideo"
          };
        }
        if (check([48, 38, 178, 117, 142, 102, 207, 17, 166, 217])) {
          return {
            ext: "wmv",
            mime: "video/x-ms-wmv"
          };
        }
        if (check([0, 0, 1, 186])) {
          return {
            ext: "mpg",
            mime: "video/mpeg"
          };
        }
        if (check([73, 68, 51]) || check([255, 251])) {
          return {
            ext: "mp3",
            mime: "audio/mpeg"
          };
        }
        if (check([102, 116, 121, 112, 77, 52, 65], { offset: 4 }) || check([77, 52, 65, 32])) {
          return {
            ext: "m4a",
            mime: "audio/m4a"
          };
        }
        if (check([79, 112, 117, 115, 72, 101, 97, 100], { offset: 28 })) {
          return {
            ext: "opus",
            mime: "audio/opus"
          };
        }
        if (check([79, 103, 103, 83])) {
          return {
            ext: "ogg",
            mime: "audio/ogg"
          };
        }
        if (check([102, 76, 97, 67])) {
          return {
            ext: "flac",
            mime: "audio/x-flac"
          };
        }
        if (check([82, 73, 70, 70]) && check([87, 65, 86, 69], { offset: 8 })) {
          return {
            ext: "wav",
            mime: "audio/x-wav"
          };
        }
        if (check([35, 33, 65, 77, 82, 10])) {
          return {
            ext: "amr",
            mime: "audio/amr"
          };
        }
        if (check([37, 80, 68, 70])) {
          return {
            ext: "pdf",
            mime: "application/pdf"
          };
        }
        if (check([77, 90])) {
          return {
            ext: "exe",
            mime: "application/x-msdownload"
          };
        }
        if ((buf[0] === 67 || buf[0] === 70) && check([87, 83], { offset: 1 })) {
          return {
            ext: "swf",
            mime: "application/x-shockwave-flash"
          };
        }
        if (check([123, 92, 114, 116, 102])) {
          return {
            ext: "rtf",
            mime: "application/rtf"
          };
        }
        if (check([0, 97, 115, 109])) {
          return {
            ext: "wasm",
            mime: "application/wasm"
          };
        }
        if (check([119, 79, 70, 70]) && (check([0, 1, 0, 0], { offset: 4 }) || check([79, 84, 84, 79], { offset: 4 }))) {
          return {
            ext: "woff",
            mime: "font/woff"
          };
        }
        if (check([119, 79, 70, 50]) && (check([0, 1, 0, 0], { offset: 4 }) || check([79, 84, 84, 79], { offset: 4 }))) {
          return {
            ext: "woff2",
            mime: "font/woff2"
          };
        }
        if (check([76, 80], { offset: 34 }) && (check([0, 0, 1], { offset: 8 }) || check([1, 0, 2], { offset: 8 }) || check([2, 0, 2], { offset: 8 }))) {
          return {
            ext: "eot",
            mime: "application/octet-stream"
          };
        }
        if (check([0, 1, 0, 0, 0])) {
          return {
            ext: "ttf",
            mime: "font/ttf"
          };
        }
        if (check([79, 84, 84, 79, 0])) {
          return {
            ext: "otf",
            mime: "font/otf"
          };
        }
        if (check([0, 0, 1, 0])) {
          return {
            ext: "ico",
            mime: "image/x-icon"
          };
        }
        if (check([70, 76, 86, 1])) {
          return {
            ext: "flv",
            mime: "video/x-flv"
          };
        }
        if (check([37, 33])) {
          return {
            ext: "ps",
            mime: "application/postscript"
          };
        }
        if (check([253, 55, 122, 88, 90, 0])) {
          return {
            ext: "xz",
            mime: "application/x-xz"
          };
        }
        if (check([83, 81, 76, 105])) {
          return {
            ext: "sqlite",
            mime: "application/x-sqlite3"
          };
        }
        if (check([78, 69, 83, 26])) {
          return {
            ext: "nes",
            mime: "application/x-nintendo-nes-rom"
          };
        }
        if (check([67, 114, 50, 52])) {
          return {
            ext: "crx",
            mime: "application/x-google-chrome-extension"
          };
        }
        if (check([77, 83, 67, 70]) || check([73, 83, 99, 40])) {
          return {
            ext: "cab",
            mime: "application/vnd.ms-cab-compressed"
          };
        }
        if (check([33, 60, 97, 114, 99, 104, 62, 10, 100, 101, 98, 105, 97, 110, 45, 98, 105, 110, 97, 114, 121])) {
          return {
            ext: "deb",
            mime: "application/x-deb"
          };
        }
        if (check([33, 60, 97, 114, 99, 104, 62])) {
          return {
            ext: "ar",
            mime: "application/x-unix-archive"
          };
        }
        if (check([237, 171, 238, 219])) {
          return {
            ext: "rpm",
            mime: "application/x-rpm"
          };
        }
        if (check([31, 160]) || check([31, 157])) {
          return {
            ext: "Z",
            mime: "application/x-compress"
          };
        }
        if (check([76, 90, 73, 80])) {
          return {
            ext: "lz",
            mime: "application/x-lzip"
          };
        }
        if (check([208, 207, 17, 224, 161, 177, 26, 225])) {
          return {
            ext: "msi",
            mime: "application/x-msi"
          };
        }
        if (check([6, 14, 43, 52, 2, 5, 1, 1, 13, 1, 2, 1, 1, 2])) {
          return {
            ext: "mxf",
            mime: "application/mxf"
          };
        }
        if (check([71], { offset: 4 }) && (check([71], { offset: 192 }) || check([71], { offset: 196 }))) {
          return {
            ext: "mts",
            mime: "video/mp2t"
          };
        }
        if (check([66, 76, 69, 78, 68, 69, 82])) {
          return {
            ext: "blend",
            mime: "application/x-blender"
          };
        }
        if (check([66, 80, 71, 251])) {
          return {
            ext: "bpg",
            mime: "image/bpg"
          };
        }
        return null;
      };
    }
  });

  // ../../node_modules/is-stream/index.js
  var require_is_stream = __commonJS({
    "../../node_modules/is-stream/index.js"(exports, module) {
      "use strict";
      var isStream = module.exports = function(stream) {
        return stream !== null && typeof stream === "object" && typeof stream.pipe === "function";
      };
      isStream.writable = function(stream) {
        return isStream(stream) && stream.writable !== false && typeof stream._write === "function" && typeof stream._writableState === "object";
      };
      isStream.readable = function(stream) {
        return isStream(stream) && stream.readable !== false && typeof stream._read === "function" && typeof stream._readableState === "object";
      };
      isStream.duplex = function(stream) {
        return isStream.writable(stream) && isStream.readable(stream);
      };
      isStream.transform = function(stream) {
        return isStream.duplex(stream) && typeof stream._transform === "function" && typeof stream._transformState === "object";
      };
    }
  });

  // ../../node_modules/process-nextick-args/index.js
  var require_process_nextick_args = __commonJS({
    "../../node_modules/process-nextick-args/index.js"(exports, module) {
      "use strict";
      if (typeof process === "undefined" || !process.version || process.version.indexOf("v0.") === 0 || process.version.indexOf("v1.") === 0 && process.version.indexOf("v1.8.") !== 0) {
        module.exports = { nextTick };
      } else {
        module.exports = process;
      }
      function nextTick(fn, arg1, arg2, arg3) {
        if (typeof fn !== "function") {
          throw new TypeError('"callback" argument must be a function');
        }
        var len = arguments.length;
        var args, i;
        switch (len) {
          case 0:
          case 1:
            return process.nextTick(fn);
          case 2:
            return process.nextTick(function afterTickOne() {
              fn.call(null, arg1);
            });
          case 3:
            return process.nextTick(function afterTickTwo() {
              fn.call(null, arg1, arg2);
            });
          case 4:
            return process.nextTick(function afterTickThree() {
              fn.call(null, arg1, arg2, arg3);
            });
          default:
            args = new Array(len - 1);
            i = 0;
            while (i < args.length) {
              args[i++] = arguments[i];
            }
            return process.nextTick(function afterTick() {
              fn.apply(null, args);
            });
        }
      }
    }
  });

  // ../../node_modules/bl/node_modules/isarray/index.js
  var require_isarray = __commonJS({
    "../../node_modules/bl/node_modules/isarray/index.js"(exports, module) {
      var toString = {}.toString;
      module.exports = Array.isArray || function(arr) {
        return toString.call(arr) == "[object Array]";
      };
    }
  });

  // ../../node_modules/bl/node_modules/readable-stream/lib/internal/streams/stream.js
  var require_stream = __commonJS({
    "../../node_modules/bl/node_modules/readable-stream/lib/internal/streams/stream.js"(exports, module) {
      module.exports = __require("stream");
    }
  });

  // ../../node_modules/bl/node_modules/safe-buffer/index.js
  var require_safe_buffer = __commonJS({
    "../../node_modules/bl/node_modules/safe-buffer/index.js"(exports, module) {
      var buffer = __require("buffer");
      var Buffer2 = buffer.Buffer;
      function copyProps(src, dst) {
        for (var key in src) {
          dst[key] = src[key];
        }
      }
      if (Buffer2.from && Buffer2.alloc && Buffer2.allocUnsafe && Buffer2.allocUnsafeSlow) {
        module.exports = buffer;
      } else {
        copyProps(buffer, exports);
        exports.Buffer = SafeBuffer;
      }
      function SafeBuffer(arg, encodingOrOffset, length) {
        return Buffer2(arg, encodingOrOffset, length);
      }
      copyProps(Buffer2, SafeBuffer);
      SafeBuffer.from = function(arg, encodingOrOffset, length) {
        if (typeof arg === "number") {
          throw new TypeError("Argument must not be a number");
        }
        return Buffer2(arg, encodingOrOffset, length);
      };
      SafeBuffer.alloc = function(size, fill, encoding) {
        if (typeof size !== "number") {
          throw new TypeError("Argument must be a number");
        }
        var buf = Buffer2(size);
        if (fill !== void 0) {
          if (typeof encoding === "string") {
            buf.fill(fill, encoding);
          } else {
            buf.fill(fill);
          }
        } else {
          buf.fill(0);
        }
        return buf;
      };
      SafeBuffer.allocUnsafe = function(size) {
        if (typeof size !== "number") {
          throw new TypeError("Argument must be a number");
        }
        return Buffer2(size);
      };
      SafeBuffer.allocUnsafeSlow = function(size) {
        if (typeof size !== "number") {
          throw new TypeError("Argument must be a number");
        }
        return buffer.SlowBuffer(size);
      };
    }
  });

  // ../../node_modules/core-util-is/lib/util.js
  var require_util = __commonJS({
    "../../node_modules/core-util-is/lib/util.js"(exports) {
      function isArray(arg) {
        if (Array.isArray) {
          return Array.isArray(arg);
        }
        return objectToString(arg) === "[object Array]";
      }
      exports.isArray = isArray;
      function isBoolean(arg) {
        return typeof arg === "boolean";
      }
      exports.isBoolean = isBoolean;
      function isNull(arg) {
        return arg === null;
      }
      exports.isNull = isNull;
      function isNullOrUndefined(arg) {
        return arg == null;
      }
      exports.isNullOrUndefined = isNullOrUndefined;
      function isNumber(arg) {
        return typeof arg === "number";
      }
      exports.isNumber = isNumber;
      function isString(arg) {
        return typeof arg === "string";
      }
      exports.isString = isString;
      function isSymbol(arg) {
        return typeof arg === "symbol";
      }
      exports.isSymbol = isSymbol;
      function isUndefined(arg) {
        return arg === void 0;
      }
      exports.isUndefined = isUndefined;
      function isRegExp(re) {
        return objectToString(re) === "[object RegExp]";
      }
      exports.isRegExp = isRegExp;
      function isObject(arg) {
        return typeof arg === "object" && arg !== null;
      }
      exports.isObject = isObject;
      function isDate(d) {
        return objectToString(d) === "[object Date]";
      }
      exports.isDate = isDate;
      function isError(e) {
        return objectToString(e) === "[object Error]" || e instanceof Error;
      }
      exports.isError = isError;
      function isFunction(arg) {
        return typeof arg === "function";
      }
      exports.isFunction = isFunction;
      function isPrimitive(arg) {
        return arg === null || typeof arg === "boolean" || typeof arg === "number" || typeof arg === "string" || typeof arg === "symbol" || // ES6 symbol
        typeof arg === "undefined";
      }
      exports.isPrimitive = isPrimitive;
      exports.isBuffer = __require("buffer").Buffer.isBuffer;
      function objectToString(o) {
        return Object.prototype.toString.call(o);
      }
    }
  });

  // ../../node_modules/inherits/inherits_browser.js
  var require_inherits_browser = __commonJS({
    "../../node_modules/inherits/inherits_browser.js"(exports, module) {
      if (typeof Object.create === "function") {
        module.exports = function inherits(ctor, superCtor) {
          if (superCtor) {
            ctor.super_ = superCtor;
            ctor.prototype = Object.create(superCtor.prototype, {
              constructor: {
                value: ctor,
                enumerable: false,
                writable: true,
                configurable: true
              }
            });
          }
        };
      } else {
        module.exports = function inherits(ctor, superCtor) {
          if (superCtor) {
            ctor.super_ = superCtor;
            var TempCtor = function() {
            };
            TempCtor.prototype = superCtor.prototype;
            ctor.prototype = new TempCtor();
            ctor.prototype.constructor = ctor;
          }
        };
      }
    }
  });

  // ../../node_modules/inherits/inherits.js
  var require_inherits = __commonJS({
    "../../node_modules/inherits/inherits.js"(exports, module) {
      try {
        util = __require("util");
        if (typeof util.inherits !== "function") throw "";
        module.exports = util.inherits;
      } catch (e) {
        module.exports = require_inherits_browser();
      }
      var util;
    }
  });

  // ../../node_modules/bl/node_modules/readable-stream/lib/internal/streams/BufferList.js
  var require_BufferList = __commonJS({
    "../../node_modules/bl/node_modules/readable-stream/lib/internal/streams/BufferList.js"(exports, module) {
      "use strict";
      function _classCallCheck(instance, Constructor) {
        if (!(instance instanceof Constructor)) {
          throw new TypeError("Cannot call a class as a function");
        }
      }
      var Buffer2 = require_safe_buffer().Buffer;
      var util = __require("util");
      function copyBuffer(src, target, offset) {
        src.copy(target, offset);
      }
      module.exports = (function() {
        function BufferList() {
          _classCallCheck(this, BufferList);
          this.head = null;
          this.tail = null;
          this.length = 0;
        }
        BufferList.prototype.push = function push(v) {
          var entry = { data: v, next: null };
          if (this.length > 0) this.tail.next = entry;
          else this.head = entry;
          this.tail = entry;
          ++this.length;
        };
        BufferList.prototype.unshift = function unshift(v) {
          var entry = { data: v, next: this.head };
          if (this.length === 0) this.tail = entry;
          this.head = entry;
          ++this.length;
        };
        BufferList.prototype.shift = function shift() {
          if (this.length === 0) return;
          var ret = this.head.data;
          if (this.length === 1) this.head = this.tail = null;
          else this.head = this.head.next;
          --this.length;
          return ret;
        };
        BufferList.prototype.clear = function clear() {
          this.head = this.tail = null;
          this.length = 0;
        };
        BufferList.prototype.join = function join(s) {
          if (this.length === 0) return "";
          var p = this.head;
          var ret = "" + p.data;
          while (p = p.next) {
            ret += s + p.data;
          }
          return ret;
        };
        BufferList.prototype.concat = function concat(n) {
          if (this.length === 0) return Buffer2.alloc(0);
          var ret = Buffer2.allocUnsafe(n >>> 0);
          var p = this.head;
          var i = 0;
          while (p) {
            copyBuffer(p.data, ret, i);
            i += p.data.length;
            p = p.next;
          }
          return ret;
        };
        return BufferList;
      })();
      if (util && util.inspect && util.inspect.custom) {
        module.exports.prototype[util.inspect.custom] = function() {
          var obj = util.inspect({ length: this.length });
          return this.constructor.name + " " + obj;
        };
      }
    }
  });

  // ../../node_modules/bl/node_modules/readable-stream/lib/internal/streams/destroy.js
  var require_destroy = __commonJS({
    "../../node_modules/bl/node_modules/readable-stream/lib/internal/streams/destroy.js"(exports, module) {
      "use strict";
      var pna = require_process_nextick_args();
      function destroy(err, cb) {
        var _this = this;
        var readableDestroyed = this._readableState && this._readableState.destroyed;
        var writableDestroyed = this._writableState && this._writableState.destroyed;
        if (readableDestroyed || writableDestroyed) {
          if (cb) {
            cb(err);
          } else if (err) {
            if (!this._writableState) {
              pna.nextTick(emitErrorNT, this, err);
            } else if (!this._writableState.errorEmitted) {
              this._writableState.errorEmitted = true;
              pna.nextTick(emitErrorNT, this, err);
            }
          }
          return this;
        }
        if (this._readableState) {
          this._readableState.destroyed = true;
        }
        if (this._writableState) {
          this._writableState.destroyed = true;
        }
        this._destroy(err || null, function(err2) {
          if (!cb && err2) {
            if (!_this._writableState) {
              pna.nextTick(emitErrorNT, _this, err2);
            } else if (!_this._writableState.errorEmitted) {
              _this._writableState.errorEmitted = true;
              pna.nextTick(emitErrorNT, _this, err2);
            }
          } else if (cb) {
            cb(err2);
          }
        });
        return this;
      }
      function undestroy() {
        if (this._readableState) {
          this._readableState.destroyed = false;
          this._readableState.reading = false;
          this._readableState.ended = false;
          this._readableState.endEmitted = false;
        }
        if (this._writableState) {
          this._writableState.destroyed = false;
          this._writableState.ended = false;
          this._writableState.ending = false;
          this._writableState.finalCalled = false;
          this._writableState.prefinished = false;
          this._writableState.finished = false;
          this._writableState.errorEmitted = false;
        }
      }
      function emitErrorNT(self2, err) {
        self2.emit("error", err);
      }
      module.exports = {
        destroy,
        undestroy
      };
    }
  });

  // ../../node_modules/util-deprecate/node.js
  var require_node = __commonJS({
    "../../node_modules/util-deprecate/node.js"(exports, module) {
      module.exports = __require("util").deprecate;
    }
  });

  // ../../node_modules/bl/node_modules/readable-stream/lib/_stream_writable.js
  var require_stream_writable = __commonJS({
    "../../node_modules/bl/node_modules/readable-stream/lib/_stream_writable.js"(exports, module) {
      "use strict";
      var pna = require_process_nextick_args();
      module.exports = Writable;
      function CorkedRequest(state) {
        var _this = this;
        this.next = null;
        this.entry = null;
        this.finish = function() {
          onCorkedFinish(_this, state);
        };
      }
      var asyncWrite = !process.browser && ["v0.10", "v0.9."].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : pna.nextTick;
      var Duplex;
      Writable.WritableState = WritableState;
      var util = Object.create(require_util());
      util.inherits = require_inherits();
      var internalUtil = {
        deprecate: require_node()
      };
      var Stream = require_stream();
      var Buffer2 = require_safe_buffer().Buffer;
      var OurUint8Array = (typeof global !== "undefined" ? global : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : {}).Uint8Array || function() {
      };
      function _uint8ArrayToBuffer(chunk) {
        return Buffer2.from(chunk);
      }
      function _isUint8Array(obj) {
        return Buffer2.isBuffer(obj) || obj instanceof OurUint8Array;
      }
      var destroyImpl = require_destroy();
      util.inherits(Writable, Stream);
      function nop() {
      }
      function WritableState(options, stream) {
        Duplex = Duplex || require_stream_duplex();
        options = options || {};
        var isDuplex = stream instanceof Duplex;
        this.objectMode = !!options.objectMode;
        if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode;
        var hwm = options.highWaterMark;
        var writableHwm = options.writableHighWaterMark;
        var defaultHwm = this.objectMode ? 16 : 16 * 1024;
        if (hwm || hwm === 0) this.highWaterMark = hwm;
        else if (isDuplex && (writableHwm || writableHwm === 0)) this.highWaterMark = writableHwm;
        else this.highWaterMark = defaultHwm;
        this.highWaterMark = Math.floor(this.highWaterMark);
        this.finalCalled = false;
        this.needDrain = false;
        this.ending = false;
        this.ended = false;
        this.finished = false;
        this.destroyed = false;
        var noDecode = options.decodeStrings === false;
        this.decodeStrings = !noDecode;
        this.defaultEncoding = options.defaultEncoding || "utf8";
        this.length = 0;
        this.writing = false;
        this.corked = 0;
        this.sync = true;
        this.bufferProcessing = false;
        this.onwrite = function(er) {
          onwrite(stream, er);
        };
        this.writecb = null;
        this.writelen = 0;
        this.bufferedRequest = null;
        this.lastBufferedRequest = null;
        this.pendingcb = 0;
        this.prefinished = false;
        this.errorEmitted = false;
        this.bufferedRequestCount = 0;
        this.corkedRequestsFree = new CorkedRequest(this);
      }
      WritableState.prototype.getBuffer = function getBuffer() {
        var current = this.bufferedRequest;
        var out = [];
        while (current) {
          out.push(current);
          current = current.next;
        }
        return out;
      };
      (function() {
        try {
          Object.defineProperty(WritableState.prototype, "buffer", {
            get: internalUtil.deprecate(function() {
              return this.getBuffer();
            }, "_writableState.buffer is deprecated. Use _writableState.getBuffer instead.", "DEP0003")
          });
        } catch (_) {
        }
      })();
      var realHasInstance;
      if (typeof Symbol === "function" && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === "function") {
        realHasInstance = Function.prototype[Symbol.hasInstance];
        Object.defineProperty(Writable, Symbol.hasInstance, {
          value: function(object) {
            if (realHasInstance.call(this, object)) return true;
            if (this !== Writable) return false;
            return object && object._writableState instanceof WritableState;
          }
        });
      } else {
        realHasInstance = function(object) {
          return object instanceof this;
        };
      }
      function Writable(options) {
        Duplex = Duplex || require_stream_duplex();
        if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) {
          return new Writable(options);
        }
        this._writableState = new WritableState(options, this);
        this.writable = true;
        if (options) {
          if (typeof options.write === "function") this._write = options.write;
          if (typeof options.writev === "function") this._writev = options.writev;
          if (typeof options.destroy === "function") this._destroy = options.destroy;
          if (typeof options.final === "function") this._final = options.final;
        }
        Stream.call(this);
      }
      Writable.prototype.pipe = function() {
        this.emit("error", new Error("Cannot pipe, not readable"));
      };
      function writeAfterEnd(stream, cb) {
        var er = new Error("write after end");
        stream.emit("error", er);
        pna.nextTick(cb, er);
      }
      function validChunk(stream, state, chunk, cb) {
        var valid = true;
        var er = false;
        if (chunk === null) {
          er = new TypeError("May not write null values to stream");
        } else if (typeof chunk !== "string" && chunk !== void 0 && !state.objectMode) {
          er = new TypeError("Invalid non-string/buffer chunk");
        }
        if (er) {
          stream.emit("error", er);
          pna.nextTick(cb, er);
          valid = false;
        }
        return valid;
      }
      Writable.prototype.write = function(chunk, encoding, cb) {
        var state = this._writableState;
        var ret = false;
        var isBuf = !state.objectMode && _isUint8Array(chunk);
        if (isBuf && !Buffer2.isBuffer(chunk)) {
          chunk = _uint8ArrayToBuffer(chunk);
        }
        if (typeof encoding === "function") {
          cb = encoding;
          encoding = null;
        }
        if (isBuf) encoding = "buffer";
        else if (!encoding) encoding = state.defaultEncoding;
        if (typeof cb !== "function") cb = nop;
        if (state.ended) writeAfterEnd(this, cb);
        else if (isBuf || validChunk(this, state, chunk, cb)) {
          state.pendingcb++;
          ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);
        }
        return ret;
      };
      Writable.prototype.cork = function() {
        var state = this._writableState;
        state.corked++;
      };
      Writable.prototype.uncork = function() {
        var state = this._writableState;
        if (state.corked) {
          state.corked--;
          if (!state.writing && !state.corked && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);
        }
      };
      Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
        if (typeof encoding === "string") encoding = encoding.toLowerCase();
        if (!(["hex", "utf8", "utf-8", "ascii", "binary", "base64", "ucs2", "ucs-2", "utf16le", "utf-16le", "raw"].indexOf((encoding + "").toLowerCase()) > -1)) throw new TypeError("Unknown encoding: " + encoding);
        this._writableState.defaultEncoding = encoding;
        return this;
      };
      function decodeChunk(state, chunk, encoding) {
        if (!state.objectMode && state.decodeStrings !== false && typeof chunk === "string") {
          chunk = Buffer2.from(chunk, encoding);
        }
        return chunk;
      }
      Object.defineProperty(Writable.prototype, "writableHighWaterMark", {
        // making it explicit this property is not enumerable
        // because otherwise some prototype manipulation in
        // userland will fail
        enumerable: false,
        get: function() {
          return this._writableState.highWaterMark;
        }
      });
      function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {
        if (!isBuf) {
          var newChunk = decodeChunk(state, chunk, encoding);
          if (chunk !== newChunk) {
            isBuf = true;
            encoding = "buffer";
            chunk = newChunk;
          }
        }
        var len = state.objectMode ? 1 : chunk.length;
        state.length += len;
        var ret = state.length < state.highWaterMark;
        if (!ret) state.needDrain = true;
        if (state.writing || state.corked) {
          var last = state.lastBufferedRequest;
          state.lastBufferedRequest = {
            chunk,
            encoding,
            isBuf,
            callback: cb,
            next: null
          };
          if (last) {
            last.next = state.lastBufferedRequest;
          } else {
            state.bufferedRequest = state.lastBufferedRequest;
          }
          state.bufferedRequestCount += 1;
        } else {
          doWrite(stream, state, false, len, chunk, encoding, cb);
        }
        return ret;
      }
      function doWrite(stream, state, writev, len, chunk, encoding, cb) {
        state.writelen = len;
        state.writecb = cb;
        state.writing = true;
        state.sync = true;
        if (writev) stream._writev(chunk, state.onwrite);
        else stream._write(chunk, encoding, state.onwrite);
        state.sync = false;
      }
      function onwriteError(stream, state, sync, er, cb) {
        --state.pendingcb;
        if (sync) {
          pna.nextTick(cb, er);
          pna.nextTick(finishMaybe, stream, state);
          stream._writableState.errorEmitted = true;
          stream.emit("error", er);
        } else {
          cb(er);
          stream._writableState.errorEmitted = true;
          stream.emit("error", er);
          finishMaybe(stream, state);
        }
      }
      function onwriteStateUpdate(state) {
        state.writing = false;
        state.writecb = null;
        state.length -= state.writelen;
        state.writelen = 0;
      }
      function onwrite(stream, er) {
        var state = stream._writableState;
        var sync = state.sync;
        var cb = state.writecb;
        onwriteStateUpdate(state);
        if (er) onwriteError(stream, state, sync, er, cb);
        else {
          var finished = needFinish(state);
          if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {
            clearBuffer(stream, state);
          }
          if (sync) {
            asyncWrite(afterWrite, stream, state, finished, cb);
          } else {
            afterWrite(stream, state, finished, cb);
          }
        }
      }
      function afterWrite(stream, state, finished, cb) {
        if (!finished) onwriteDrain(stream, state);
        state.pendingcb--;
        cb();
        finishMaybe(stream, state);
      }
      function onwriteDrain(stream, state) {
        if (state.length === 0 && state.needDrain) {
          state.needDrain = false;
          stream.emit("drain");
        }
      }
      function clearBuffer(stream, state) {
        state.bufferProcessing = true;
        var entry = state.bufferedRequest;
        if (stream._writev && entry && entry.next) {
          var l = state.bufferedRequestCount;
          var buffer = new Array(l);
          var holder = state.corkedRequestsFree;
          holder.entry = entry;
          var count = 0;
          var allBuffers = true;
          while (entry) {
            buffer[count] = entry;
            if (!entry.isBuf) allBuffers = false;
            entry = entry.next;
            count += 1;
          }
          buffer.allBuffers = allBuffers;
          doWrite(stream, state, true, state.length, buffer, "", holder.finish);
          state.pendingcb++;
          state.lastBufferedRequest = null;
          if (holder.next) {
            state.corkedRequestsFree = holder.next;
            holder.next = null;
          } else {
            state.corkedRequestsFree = new CorkedRequest(state);
          }
          state.bufferedRequestCount = 0;
        } else {
          while (entry) {
            var chunk = entry.chunk;
            var encoding = entry.encoding;
            var cb = entry.callback;
            var len = state.objectMode ? 1 : chunk.length;
            doWrite(stream, state, false, len, chunk, encoding, cb);
            entry = entry.next;
            state.bufferedRequestCount--;
            if (state.writing) {
              break;
            }
          }
          if (entry === null) state.lastBufferedRequest = null;
        }
        state.bufferedRequest = entry;
        state.bufferProcessing = false;
      }
      Writable.prototype._write = function(chunk, encoding, cb) {
        cb(new Error("_write() is not overridden in subclass"));
      };
      Writable.prototype._writev = null;
      Writable.prototype.end = function(chunk, encoding, cb) {
        var state = this._writableState;
        if (typeof chunk === "function") {
          cb = chunk;
          chunk = null;
          encoding = null;
        } else if (typeof encoding === "function") {
          cb = encoding;
          encoding = null;
        }
        if (chunk !== null && chunk !== void 0) this.write(chunk, encoding);
        if (state.corked) {
          state.corked = 1;
          this.uncork();
        }
        if (!state.ending) endWritable(this, state, cb);
      };
      function needFinish(state) {
        return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;
      }
      function callFinal(stream, state) {
        stream._final(function(err) {
          state.pendingcb--;
          if (err) {
            stream.emit("error", err);
          }
          state.prefinished = true;
          stream.emit("prefinish");
          finishMaybe(stream, state);
        });
      }
      function prefinish(stream, state) {
        if (!state.prefinished && !state.finalCalled) {
          if (typeof stream._final === "function") {
            state.pendingcb++;
            state.finalCalled = true;
            pna.nextTick(callFinal, stream, state);
          } else {
            state.prefinished = true;
            stream.emit("prefinish");
          }
        }
      }
      function finishMaybe(stream, state) {
        var need = needFinish(state);
        if (need) {
          prefinish(stream, state);
          if (state.pendingcb === 0) {
            state.finished = true;
            stream.emit("finish");
          }
        }
        return need;
      }
      function endWritable(stream, state, cb) {
        state.ending = true;
        finishMaybe(stream, state);
        if (cb) {
          if (state.finished) pna.nextTick(cb);
          else stream.once("finish", cb);
        }
        state.ended = true;
        stream.writable = false;
      }
      function onCorkedFinish(corkReq, state, err) {
        var entry = corkReq.entry;
        corkReq.entry = null;
        while (entry) {
          var cb = entry.callback;
          state.pendingcb--;
          cb(err);
          entry = entry.next;
        }
        state.corkedRequestsFree.next = corkReq;
      }
      Object.defineProperty(Writable.prototype, "destroyed", {
        get: function() {
          if (this._writableState === void 0) {
            return false;
          }
          return this._writableState.destroyed;
        },
        set: function(value) {
          if (!this._writableState) {
            return;
          }
          this._writableState.destroyed = value;
        }
      });
      Writable.prototype.destroy = destroyImpl.destroy;
      Writable.prototype._undestroy = destroyImpl.undestroy;
      Writable.prototype._destroy = function(err, cb) {
        this.end();
        cb(err);
      };
    }
  });

  // ../../node_modules/bl/node_modules/readable-stream/lib/_stream_duplex.js
  var require_stream_duplex = __commonJS({
    "../../node_modules/bl/node_modules/readable-stream/lib/_stream_duplex.js"(exports, module) {
      "use strict";
      var pna = require_process_nextick_args();
      var objectKeys = Object.keys || function(obj) {
        var keys2 = [];
        for (var key in obj) {
          keys2.push(key);
        }
        return keys2;
      };
      module.exports = Duplex;
      var util = Object.create(require_util());
      util.inherits = require_inherits();
      var Readable = require_stream_readable();
      var Writable = require_stream_writable();
      util.inherits(Duplex, Readable);
      {
        keys = objectKeys(Writable.prototype);
        for (v = 0; v < keys.length; v++) {
          method = keys[v];
          if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];
        }
      }
      var keys;
      var method;
      var v;
      function Duplex(options) {
        if (!(this instanceof Duplex)) return new Duplex(options);
        Readable.call(this, options);
        Writable.call(this, options);
        if (options && options.readable === false) this.readable = false;
        if (options && options.writable === false) this.writable = false;
        this.allowHalfOpen = true;
        if (options && options.allowHalfOpen === false) this.allowHalfOpen = false;
        this.once("end", onend);
      }
      Object.defineProperty(Duplex.prototype, "writableHighWaterMark", {
        // making it explicit this property is not enumerable
        // because otherwise some prototype manipulation in
        // userland will fail
        enumerable: false,
        get: function() {
          return this._writableState.highWaterMark;
        }
      });
      function onend() {
        if (this.allowHalfOpen || this._writableState.ended) return;
        pna.nextTick(onEndNT, this);
      }
      function onEndNT(self2) {
        self2.end();
      }
      Object.defineProperty(Duplex.prototype, "destroyed", {
        get: function() {
          if (this._readableState === void 0 || this._writableState === void 0) {
            return false;
          }
          return this._readableState.destroyed && this._writableState.destroyed;
        },
        set: function(value) {
          if (this._readableState === void 0 || this._writableState === void 0) {
            return;
          }
          this._readableState.destroyed = value;
          this._writableState.destroyed = value;
        }
      });
      Duplex.prototype._destroy = function(err, cb) {
        this.push(null);
        this.end();
        pna.nextTick(cb, err);
      };
    }
  });

  // ../../node_modules/bl/node_modules/string_decoder/lib/string_decoder.js
  var require_string_decoder = __commonJS({
    "../../node_modules/bl/node_modules/string_decoder/lib/string_decoder.js"(exports) {
      "use strict";
      var Buffer2 = require_safe_buffer().Buffer;
      var isEncoding = Buffer2.isEncoding || function(encoding) {
        encoding = "" + encoding;
        switch (encoding && encoding.toLowerCase()) {
          case "hex":
          case "utf8":
          case "utf-8":
          case "ascii":
          case "binary":
          case "base64":
          case "ucs2":
          case "ucs-2":
          case "utf16le":
          case "utf-16le":
          case "raw":
            return true;
          default:
            return false;
        }
      };
      function _normalizeEncoding(enc) {
        if (!enc) return "utf8";
        var retried;
        while (true) {
          switch (enc) {
            case "utf8":
            case "utf-8":
              return "utf8";
            case "ucs2":
            case "ucs-2":
            case "utf16le":
            case "utf-16le":
              return "utf16le";
            case "latin1":
            case "binary":
              return "latin1";
            case "base64":
            case "ascii":
            case "hex":
              return enc;
            default:
              if (retried) return;
              enc = ("" + enc).toLowerCase();
              retried = true;
          }
        }
      }
      function normalizeEncoding(enc) {
        var nenc = _normalizeEncoding(enc);
        if (typeof nenc !== "string" && (Buffer2.isEncoding === isEncoding || !isEncoding(enc))) throw new Error("Unknown encoding: " + enc);
        return nenc || enc;
      }
      exports.StringDecoder = StringDecoder;
      function StringDecoder(encoding) {
        this.encoding = normalizeEncoding(encoding);
        var nb;
        switch (this.encoding) {
          case "utf16le":
            this.text = utf16Text;
            this.end = utf16End;
            nb = 4;
            break;
          case "utf8":
            this.fillLast = utf8FillLast;
            nb = 4;
            break;
          case "base64":
            this.text = base64Text;
            this.end = base64End;
            nb = 3;
            break;
          default:
            this.write = simpleWrite;
            this.end = simpleEnd;
            return;
        }
        this.lastNeed = 0;
        this.lastTotal = 0;
        this.lastChar = Buffer2.allocUnsafe(nb);
      }
      StringDecoder.prototype.write = function(buf) {
        if (buf.length === 0) return "";
        var r;
        var i;
        if (this.lastNeed) {
          r = this.fillLast(buf);
          if (r === void 0) return "";
          i = this.lastNeed;
          this.lastNeed = 0;
        } else {
          i = 0;
        }
        if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);
        return r || "";
      };
      StringDecoder.prototype.end = utf8End;
      StringDecoder.prototype.text = utf8Text;
      StringDecoder.prototype.fillLast = function(buf) {
        if (this.lastNeed <= buf.length) {
          buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);
          return this.lastChar.toString(this.encoding, 0, this.lastTotal);
        }
        buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);
        this.lastNeed -= buf.length;
      };
      function utf8CheckByte(byte) {
        if (byte <= 127) return 0;
        else if (byte >> 5 === 6) return 2;
        else if (byte >> 4 === 14) return 3;
        else if (byte >> 3 === 30) return 4;
        return byte >> 6 === 2 ? -1 : -2;
      }
      function utf8CheckIncomplete(self2, buf, i) {
        var j = buf.length - 1;
        if (j < i) return 0;
        var nb = utf8CheckByte(buf[j]);
        if (nb >= 0) {
          if (nb > 0) self2.lastNeed = nb - 1;
          return nb;
        }
        if (--j < i || nb === -2) return 0;
        nb = utf8CheckByte(buf[j]);
        if (nb >= 0) {
          if (nb > 0) self2.lastNeed = nb - 2;
          return nb;
        }
        if (--j < i || nb === -2) return 0;
        nb = utf8CheckByte(buf[j]);
        if (nb >= 0) {
          if (nb > 0) {
            if (nb === 2) nb = 0;
            else self2.lastNeed = nb - 3;
          }
          return nb;
        }
        return 0;
      }
      function utf8CheckExtraBytes(self2, buf, p) {
        if ((buf[0] & 192) !== 128) {
          self2.lastNeed = 0;
          return "\uFFFD";
        }
        if (self2.lastNeed > 1 && buf.length > 1) {
          if ((buf[1] & 192) !== 128) {
            self2.lastNeed = 1;
            return "\uFFFD";
          }
          if (self2.lastNeed > 2 && buf.length > 2) {
            if ((buf[2] & 192) !== 128) {
              self2.lastNeed = 2;
              return "\uFFFD";
            }
          }
        }
      }
      function utf8FillLast(buf) {
        var p = this.lastTotal - this.lastNeed;
        var r = utf8CheckExtraBytes(this, buf, p);
        if (r !== void 0) return r;
        if (this.lastNeed <= buf.length) {
          buf.copy(this.lastChar, p, 0, this.lastNeed);
          return this.lastChar.toString(this.encoding, 0, this.lastTotal);
        }
        buf.copy(this.lastChar, p, 0, buf.length);
        this.lastNeed -= buf.length;
      }
      function utf8Text(buf, i) {
        var total = utf8CheckIncomplete(this, buf, i);
        if (!this.lastNeed) return buf.toString("utf8", i);
        this.lastTotal = total;
        var end = buf.length - (total - this.lastNeed);
        buf.copy(this.lastChar, 0, end);
        return buf.toString("utf8", i, end);
      }
      function utf8End(buf) {
        var r = buf && buf.length ? this.write(buf) : "";
        if (this.lastNeed) return r + "\uFFFD";
        return r;
      }
      function utf16Text(buf, i) {
        if ((buf.length - i) % 2 === 0) {
          var r = buf.toString("utf16le", i);
          if (r) {
            var c = r.charCodeAt(r.length - 1);
            if (c >= 55296 && c <= 56319) {
              this.lastNeed = 2;
              this.lastTotal = 4;
              this.lastChar[0] = buf[buf.length - 2];
              this.lastChar[1] = buf[buf.length - 1];
              return r.slice(0, -1);
            }
          }
          return r;
        }
        this.lastNeed = 1;
        this.lastTotal = 2;
        this.lastChar[0] = buf[buf.length - 1];
        return buf.toString("utf16le", i, buf.length - 1);
      }
      function utf16End(buf) {
        var r = buf && buf.length ? this.write(buf) : "";
        if (this.lastNeed) {
          var end = this.lastTotal - this.lastNeed;
          return r + this.lastChar.toString("utf16le", 0, end);
        }
        return r;
      }
      function base64Text(buf, i) {
        var n = (buf.length - i) % 3;
        if (n === 0) return buf.toString("base64", i);
        this.lastNeed = 3 - n;
        this.lastTotal = 3;
        if (n === 1) {
          this.lastChar[0] = buf[buf.length - 1];
        } else {
          this.lastChar[0] = buf[buf.length - 2];
          this.lastChar[1] = buf[buf.length - 1];
        }
        return buf.toString("base64", i, buf.length - n);
      }
      function base64End(buf) {
        var r = buf && buf.length ? this.write(buf) : "";
        if (this.lastNeed) return r + this.lastChar.toString("base64", 0, 3 - this.lastNeed);
        return r;
      }
      function simpleWrite(buf) {
        return buf.toString(this.encoding);
      }
      function simpleEnd(buf) {
        return buf && buf.length ? this.write(buf) : "";
      }
    }
  });

  // ../../node_modules/bl/node_modules/readable-stream/lib/_stream_readable.js
  var require_stream_readable = __commonJS({
    "../../node_modules/bl/node_modules/readable-stream/lib/_stream_readable.js"(exports, module) {
      "use strict";
      var pna = require_process_nextick_args();
      module.exports = Readable;
      var isArray = require_isarray();
      var Duplex;
      Readable.ReadableState = ReadableState;
      var EE = require_bare_node_events().EventEmitter;
      var EElistenerCount = function(emitter, type) {
        return emitter.listeners(type).length;
      };
      var Stream = require_stream();
      var Buffer2 = require_safe_buffer().Buffer;
      var OurUint8Array = (typeof global !== "undefined" ? global : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : {}).Uint8Array || function() {
      };
      function _uint8ArrayToBuffer(chunk) {
        return Buffer2.from(chunk);
      }
      function _isUint8Array(obj) {
        return Buffer2.isBuffer(obj) || obj instanceof OurUint8Array;
      }
      var util = Object.create(require_util());
      util.inherits = require_inherits();
      var debugUtil = __require("util");
      var debug = void 0;
      if (debugUtil && debugUtil.debuglog) {
        debug = debugUtil.debuglog("stream");
      } else {
        debug = function() {
        };
      }
      var BufferList = require_BufferList();
      var destroyImpl = require_destroy();
      var StringDecoder;
      util.inherits(Readable, Stream);
      var kProxyEvents = ["error", "close", "destroy", "pause", "resume"];
      function prependListener(emitter, event, fn) {
        if (typeof emitter.prependListener === "function") return emitter.prependListener(event, fn);
        if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);
        else if (isArray(emitter._events[event])) emitter._events[event].unshift(fn);
        else emitter._events[event] = [fn, emitter._events[event]];
      }
      function ReadableState(options, stream) {
        Duplex = Duplex || require_stream_duplex();
        options = options || {};
        var isDuplex = stream instanceof Duplex;
        this.objectMode = !!options.objectMode;
        if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode;
        var hwm = options.highWaterMark;
        var readableHwm = options.readableHighWaterMark;
        var defaultHwm = this.objectMode ? 16 : 16 * 1024;
        if (hwm || hwm === 0) this.highWaterMark = hwm;
        else if (isDuplex && (readableHwm || readableHwm === 0)) this.highWaterMark = readableHwm;
        else this.highWaterMark = defaultHwm;
        this.highWaterMark = Math.floor(this.highWaterMark);
        this.buffer = new BufferList();
        this.length = 0;
        this.pipes = null;
        this.pipesCount = 0;
        this.flowing = null;
        this.ended = false;
        this.endEmitted = false;
        this.reading = false;
        this.sync = true;
        this.needReadable = false;
        this.emittedReadable = false;
        this.readableListening = false;
        this.resumeScheduled = false;
        this.destroyed = false;
        this.defaultEncoding = options.defaultEncoding || "utf8";
        this.awaitDrain = 0;
        this.readingMore = false;
        this.decoder = null;
        this.encoding = null;
        if (options.encoding) {
          if (!StringDecoder) StringDecoder = require_string_decoder().StringDecoder;
          this.decoder = new StringDecoder(options.encoding);
          this.encoding = options.encoding;
        }
      }
      function Readable(options) {
        Duplex = Duplex || require_stream_duplex();
        if (!(this instanceof Readable)) return new Readable(options);
        this._readableState = new ReadableState(options, this);
        this.readable = true;
        if (options) {
          if (typeof options.read === "function") this._read = options.read;
          if (typeof options.destroy === "function") this._destroy = options.destroy;
        }
        Stream.call(this);
      }
      Object.defineProperty(Readable.prototype, "destroyed", {
        get: function() {
          if (this._readableState === void 0) {
            return false;
          }
          return this._readableState.destroyed;
        },
        set: function(value) {
          if (!this._readableState) {
            return;
          }
          this._readableState.destroyed = value;
        }
      });
      Readable.prototype.destroy = destroyImpl.destroy;
      Readable.prototype._undestroy = destroyImpl.undestroy;
      Readable.prototype._destroy = function(err, cb) {
        this.push(null);
        cb(err);
      };
      Readable.prototype.push = function(chunk, encoding) {
        var state = this._readableState;
        var skipChunkCheck;
        if (!state.objectMode) {
          if (typeof chunk === "string") {
            encoding = encoding || state.defaultEncoding;
            if (encoding !== state.encoding) {
              chunk = Buffer2.from(chunk, encoding);
              encoding = "";
            }
            skipChunkCheck = true;
          }
        } else {
          skipChunkCheck = true;
        }
        return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);
      };
      Readable.prototype.unshift = function(chunk) {
        return readableAddChunk(this, chunk, null, true, false);
      };
      function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {
        var state = stream._readableState;
        if (chunk === null) {
          state.reading = false;
          onEofChunk(stream, state);
        } else {
          var er;
          if (!skipChunkCheck) er = chunkInvalid(state, chunk);
          if (er) {
            stream.emit("error", er);
          } else if (state.objectMode || chunk && chunk.length > 0) {
            if (typeof chunk !== "string" && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer2.prototype) {
              chunk = _uint8ArrayToBuffer(chunk);
            }
            if (addToFront) {
              if (state.endEmitted) stream.emit("error", new Error("stream.unshift() after end event"));
              else addChunk(stream, state, chunk, true);
            } else if (state.ended) {
              stream.emit("error", new Error("stream.push() after EOF"));
            } else {
              state.reading = false;
              if (state.decoder && !encoding) {
                chunk = state.decoder.write(chunk);
                if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);
                else maybeReadMore(stream, state);
              } else {
                addChunk(stream, state, chunk, false);
              }
            }
          } else if (!addToFront) {
            state.reading = false;
          }
        }
        return needMoreData(state);
      }
      function addChunk(stream, state, chunk, addToFront) {
        if (state.flowing && state.length === 0 && !state.sync) {
          stream.emit("data", chunk);
          stream.read(0);
        } else {
          state.length += state.objectMode ? 1 : chunk.length;
          if (addToFront) state.buffer.unshift(chunk);
          else state.buffer.push(chunk);
          if (state.needReadable) emitReadable(stream);
        }
        maybeReadMore(stream, state);
      }
      function chunkInvalid(state, chunk) {
        var er;
        if (!_isUint8Array(chunk) && typeof chunk !== "string" && chunk !== void 0 && !state.objectMode) {
          er = new TypeError("Invalid non-string/buffer chunk");
        }
        return er;
      }
      function needMoreData(state) {
        return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);
      }
      Readable.prototype.isPaused = function() {
        return this._readableState.flowing === false;
      };
      Readable.prototype.setEncoding = function(enc) {
        if (!StringDecoder) StringDecoder = require_string_decoder().StringDecoder;
        this._readableState.decoder = new StringDecoder(enc);
        this._readableState.encoding = enc;
        return this;
      };
      var MAX_HWM = 8388608;
      function computeNewHighWaterMark(n) {
        if (n >= MAX_HWM) {
          n = MAX_HWM;
        } else {
          n--;
          n |= n >>> 1;
          n |= n >>> 2;
          n |= n >>> 4;
          n |= n >>> 8;
          n |= n >>> 16;
          n++;
        }
        return n;
      }
      function howMuchToRead(n, state) {
        if (n <= 0 || state.length === 0 && state.ended) return 0;
        if (state.objectMode) return 1;
        if (n !== n) {
          if (state.flowing && state.length) return state.buffer.head.data.length;
          else return state.length;
        }
        if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);
        if (n <= state.length) return n;
        if (!state.ended) {
          state.needReadable = true;
          return 0;
        }
        return state.length;
      }
      Readable.prototype.read = function(n) {
        debug("read", n);
        n = parseInt(n, 10);
        var state = this._readableState;
        var nOrig = n;
        if (n !== 0) state.emittedReadable = false;
        if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) {
          debug("read: emitReadable", state.length, state.ended);
          if (state.length === 0 && state.ended) endReadable(this);
          else emitReadable(this);
          return null;
        }
        n = howMuchToRead(n, state);
        if (n === 0 && state.ended) {
          if (state.length === 0) endReadable(this);
          return null;
        }
        var doRead = state.needReadable;
        debug("need readable", doRead);
        if (state.length === 0 || state.length - n < state.highWaterMark) {
          doRead = true;
          debug("length less than watermark", doRead);
        }
        if (state.ended || state.reading) {
          doRead = false;
          debug("reading or ended", doRead);
        } else if (doRead) {
          debug("do read");
          state.reading = true;
          state.sync = true;
          if (state.length === 0) state.needReadable = true;
          this._read(state.highWaterMark);
          state.sync = false;
          if (!state.reading) n = howMuchToRead(nOrig, state);
        }
        var ret;
        if (n > 0) ret = fromList(n, state);
        else ret = null;
        if (ret === null) {
          state.needReadable = true;
          n = 0;
        } else {
          state.length -= n;
        }
        if (state.length === 0) {
          if (!state.ended) state.needReadable = true;
          if (nOrig !== n && state.ended) endReadable(this);
        }
        if (ret !== null) this.emit("data", ret);
        return ret;
      };
      function onEofChunk(stream, state) {
        if (state.ended) return;
        if (state.decoder) {
          var chunk = state.decoder.end();
          if (chunk && chunk.length) {
            state.buffer.push(chunk);
            state.length += state.objectMode ? 1 : chunk.length;
          }
        }
        state.ended = true;
        emitReadable(stream);
      }
      function emitReadable(stream) {
        var state = stream._readableState;
        state.needReadable = false;
        if (!state.emittedReadable) {
          debug("emitReadable", state.flowing);
          state.emittedReadable = true;
          if (state.sync) pna.nextTick(emitReadable_, stream);
          else emitReadable_(stream);
        }
      }
      function emitReadable_(stream) {
        debug("emit readable");
        stream.emit("readable");
        flow(stream);
      }
      function maybeReadMore(stream, state) {
        if (!state.readingMore) {
          state.readingMore = true;
          pna.nextTick(maybeReadMore_, stream, state);
        }
      }
      function maybeReadMore_(stream, state) {
        var len = state.length;
        while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) {
          debug("maybeReadMore read 0");
          stream.read(0);
          if (len === state.length)
            break;
          else len = state.length;
        }
        state.readingMore = false;
      }
      Readable.prototype._read = function(n) {
        this.emit("error", new Error("_read() is not overridden in subclass"));
      };
      Readable.prototype.pipe = function(dest, pipeOpts) {
        var src = this;
        var state = this._readableState;
        switch (state.pipesCount) {
          case 0:
            state.pipes = dest;
            break;
          case 1:
            state.pipes = [state.pipes, dest];
            break;
          default:
            state.pipes.push(dest);
            break;
        }
        state.pipesCount += 1;
        debug("pipe count=%d opts=%j", state.pipesCount, pipeOpts);
        var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;
        var endFn = doEnd ? onend : unpipe;
        if (state.endEmitted) pna.nextTick(endFn);
        else src.once("end", endFn);
        dest.on("unpipe", onunpipe);
        function onunpipe(readable, unpipeInfo) {
          debug("onunpipe");
          if (readable === src) {
            if (unpipeInfo && unpipeInfo.hasUnpiped === false) {
              unpipeInfo.hasUnpiped = true;
              cleanup();
            }
          }
        }
        function onend() {
          debug("onend");
          dest.end();
        }
        var ondrain = pipeOnDrain(src);
        dest.on("drain", ondrain);
        var cleanedUp = false;
        function cleanup() {
          debug("cleanup");
          dest.removeListener("close", onclose);
          dest.removeListener("finish", onfinish);
          dest.removeListener("drain", ondrain);
          dest.removeListener("error", onerror);
          dest.removeListener("unpipe", onunpipe);
          src.removeListener("end", onend);
          src.removeListener("end", unpipe);
          src.removeListener("data", ondata);
          cleanedUp = true;
          if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();
        }
        var increasedAwaitDrain = false;
        src.on("data", ondata);
        function ondata(chunk) {
          debug("ondata");
          increasedAwaitDrain = false;
          var ret = dest.write(chunk);
          if (false === ret && !increasedAwaitDrain) {
            if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {
              debug("false write response, pause", state.awaitDrain);
              state.awaitDrain++;
              increasedAwaitDrain = true;
            }
            src.pause();
          }
        }
        function onerror(er) {
          debug("onerror", er);
          unpipe();
          dest.removeListener("error", onerror);
          if (EElistenerCount(dest, "error") === 0) dest.emit("error", er);
        }
        prependListener(dest, "error", onerror);
        function onclose() {
          dest.removeListener("finish", onfinish);
          unpipe();
        }
        dest.once("close", onclose);
        function onfinish() {
          debug("onfinish");
          dest.removeListener("close", onclose);
          unpipe();
        }
        dest.once("finish", onfinish);
        function unpipe() {
          debug("unpipe");
          src.unpipe(dest);
        }
        dest.emit("pipe", src);
        if (!state.flowing) {
          debug("pipe resume");
          src.resume();
        }
        return dest;
      };
      function pipeOnDrain(src) {
        return function() {
          var state = src._readableState;
          debug("pipeOnDrain", state.awaitDrain);
          if (state.awaitDrain) state.awaitDrain--;
          if (state.awaitDrain === 0 && EElistenerCount(src, "data")) {
            state.flowing = true;
            flow(src);
          }
        };
      }
      Readable.prototype.unpipe = function(dest) {
        var state = this._readableState;
        var unpipeInfo = { hasUnpiped: false };
        if (state.pipesCount === 0) return this;
        if (state.pipesCount === 1) {
          if (dest && dest !== state.pipes) return this;
          if (!dest) dest = state.pipes;
          state.pipes = null;
          state.pipesCount = 0;
          state.flowing = false;
          if (dest) dest.emit("unpipe", this, unpipeInfo);
          return this;
        }
        if (!dest) {
          var dests = state.pipes;
          var len = state.pipesCount;
          state.pipes = null;
          state.pipesCount = 0;
          state.flowing = false;
          for (var i = 0; i < len; i++) {
            dests[i].emit("unpipe", this, { hasUnpiped: false });
          }
          return this;
        }
        var index = indexOf(state.pipes, dest);
        if (index === -1) return this;
        state.pipes.splice(index, 1);
        state.pipesCount -= 1;
        if (state.pipesCount === 1) state.pipes = state.pipes[0];
        dest.emit("unpipe", this, unpipeInfo);
        return this;
      };
      Readable.prototype.on = function(ev, fn) {
        var res = Stream.prototype.on.call(this, ev, fn);
        if (ev === "data") {
          if (this._readableState.flowing !== false) this.resume();
        } else if (ev === "readable") {
          var state = this._readableState;
          if (!state.endEmitted && !state.readableListening) {
            state.readableListening = state.needReadable = true;
            state.emittedReadable = false;
            if (!state.reading) {
              pna.nextTick(nReadingNextTick, this);
            } else if (state.length) {
              emitReadable(this);
            }
          }
        }
        return res;
      };
      Readable.prototype.addListener = Readable.prototype.on;
      function nReadingNextTick(self2) {
        debug("readable nexttick read 0");
        self2.read(0);
      }
      Readable.prototype.resume = function() {
        var state = this._readableState;
        if (!state.flowing) {
          debug("resume");
          state.flowing = true;
          resume(this, state);
        }
        return this;
      };
      function resume(stream, state) {
        if (!state.resumeScheduled) {
          state.resumeScheduled = true;
          pna.nextTick(resume_, stream, state);
        }
      }
      function resume_(stream, state) {
        if (!state.reading) {
          debug("resume read 0");
          stream.read(0);
        }
        state.resumeScheduled = false;
        state.awaitDrain = 0;
        stream.emit("resume");
        flow(stream);
        if (state.flowing && !state.reading) stream.read(0);
      }
      Readable.prototype.pause = function() {
        debug("call pause flowing=%j", this._readableState.flowing);
        if (false !== this._readableState.flowing) {
          debug("pause");
          this._readableState.flowing = false;
          this.emit("pause");
        }
        return this;
      };
      function flow(stream) {
        var state = stream._readableState;
        debug("flow", state.flowing);
        while (state.flowing && stream.read() !== null) {
        }
      }
      Readable.prototype.wrap = function(stream) {
        var _this = this;
        var state = this._readableState;
        var paused = false;
        stream.on("end", function() {
          debug("wrapped end");
          if (state.decoder && !state.ended) {
            var chunk = state.decoder.end();
            if (chunk && chunk.length) _this.push(chunk);
          }
          _this.push(null);
        });
        stream.on("data", function(chunk) {
          debug("wrapped data");
          if (state.decoder) chunk = state.decoder.write(chunk);
          if (state.objectMode && (chunk === null || chunk === void 0)) return;
          else if (!state.objectMode && (!chunk || !chunk.length)) return;
          var ret = _this.push(chunk);
          if (!ret) {
            paused = true;
            stream.pause();
          }
        });
        for (var i in stream) {
          if (this[i] === void 0 && typeof stream[i] === "function") {
            this[i] = /* @__PURE__ */ (function(method) {
              return function() {
                return stream[method].apply(stream, arguments);
              };
            })(i);
          }
        }
        for (var n = 0; n < kProxyEvents.length; n++) {
          stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));
        }
        this._read = function(n2) {
          debug("wrapped _read", n2);
          if (paused) {
            paused = false;
            stream.resume();
          }
        };
        return this;
      };
      Object.defineProperty(Readable.prototype, "readableHighWaterMark", {
        // making it explicit this property is not enumerable
        // because otherwise some prototype manipulation in
        // userland will fail
        enumerable: false,
        get: function() {
          return this._readableState.highWaterMark;
        }
      });
      Readable._fromList = fromList;
      function fromList(n, state) {
        if (state.length === 0) return null;
        var ret;
        if (state.objectMode) ret = state.buffer.shift();
        else if (!n || n >= state.length) {
          if (state.decoder) ret = state.buffer.join("");
          else if (state.buffer.length === 1) ret = state.buffer.head.data;
          else ret = state.buffer.concat(state.length);
          state.buffer.clear();
        } else {
          ret = fromListPartial(n, state.buffer, state.decoder);
        }
        return ret;
      }
      function fromListPartial(n, list, hasStrings) {
        var ret;
        if (n < list.head.data.length) {
          ret = list.head.data.slice(0, n);
          list.head.data = list.head.data.slice(n);
        } else if (n === list.head.data.length) {
          ret = list.shift();
        } else {
          ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list);
        }
        return ret;
      }
      function copyFromBufferString(n, list) {
        var p = list.head;
        var c = 1;
        var ret = p.data;
        n -= ret.length;
        while (p = p.next) {
          var str = p.data;
          var nb = n > str.length ? str.length : n;
          if (nb === str.length) ret += str;
          else ret += str.slice(0, n);
          n -= nb;
          if (n === 0) {
            if (nb === str.length) {
              ++c;
              if (p.next) list.head = p.next;
              else list.head = list.tail = null;
            } else {
              list.head = p;
              p.data = str.slice(nb);
            }
            break;
          }
          ++c;
        }
        list.length -= c;
        return ret;
      }
      function copyFromBuffer(n, list) {
        var ret = Buffer2.allocUnsafe(n);
        var p = list.head;
        var c = 1;
        p.data.copy(ret);
        n -= p.data.length;
        while (p = p.next) {
          var buf = p.data;
          var nb = n > buf.length ? buf.length : n;
          buf.copy(ret, ret.length - n, 0, nb);
          n -= nb;
          if (n === 0) {
            if (nb === buf.length) {
              ++c;
              if (p.next) list.head = p.next;
              else list.head = list.tail = null;
            } else {
              list.head = p;
              p.data = buf.slice(nb);
            }
            break;
          }
          ++c;
        }
        list.length -= c;
        return ret;
      }
      function endReadable(stream) {
        var state = stream._readableState;
        if (state.length > 0) throw new Error('"endReadable()" called on non-empty stream');
        if (!state.endEmitted) {
          state.ended = true;
          pna.nextTick(endReadableNT, state, stream);
        }
      }
      function endReadableNT(state, stream) {
        if (!state.endEmitted && state.length === 0) {
          state.endEmitted = true;
          stream.readable = false;
          stream.emit("end");
        }
      }
      function indexOf(xs, x) {
        for (var i = 0, l = xs.length; i < l; i++) {
          if (xs[i] === x) return i;
        }
        return -1;
      }
    }
  });

  // ../../node_modules/bl/node_modules/readable-stream/lib/_stream_transform.js
  var require_stream_transform = __commonJS({
    "../../node_modules/bl/node_modules/readable-stream/lib/_stream_transform.js"(exports, module) {
      "use strict";
      module.exports = Transform;
      var Duplex = require_stream_duplex();
      var util = Object.create(require_util());
      util.inherits = require_inherits();
      util.inherits(Transform, Duplex);
      function afterTransform(er, data) {
        var ts = this._transformState;
        ts.transforming = false;
        var cb = ts.writecb;
        if (!cb) {
          return this.emit("error", new Error("write callback called multiple times"));
        }
        ts.writechunk = null;
        ts.writecb = null;
        if (data != null)
          this.push(data);
        cb(er);
        var rs = this._readableState;
        rs.reading = false;
        if (rs.needReadable || rs.length < rs.highWaterMark) {
          this._read(rs.highWaterMark);
        }
      }
      function Transform(options) {
        if (!(this instanceof Transform)) return new Transform(options);
        Duplex.call(this, options);
        this._transformState = {
          afterTransform: afterTransform.bind(this),
          needTransform: false,
          transforming: false,
          writecb: null,
          writechunk: null,
          writeencoding: null
        };
        this._readableState.needReadable = true;
        this._readableState.sync = false;
        if (options) {
          if (typeof options.transform === "function") this._transform = options.transform;
          if (typeof options.flush === "function") this._flush = options.flush;
        }
        this.on("prefinish", prefinish);
      }
      function prefinish() {
        var _this = this;
        if (typeof this._flush === "function") {
          this._flush(function(er, data) {
            done(_this, er, data);
          });
        } else {
          done(this, null, null);
        }
      }
      Transform.prototype.push = function(chunk, encoding) {
        this._transformState.needTransform = false;
        return Duplex.prototype.push.call(this, chunk, encoding);
      };
      Transform.prototype._transform = function(chunk, encoding, cb) {
        throw new Error("_transform() is not overridden in subclass");
      };
      Transform.prototype._write = function(chunk, encoding, cb) {
        var ts = this._transformState;
        ts.writecb = cb;
        ts.writechunk = chunk;
        ts.writeencoding = encoding;
        if (!ts.transforming) {
          var rs = this._readableState;
          if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);
        }
      };
      Transform.prototype._read = function(n) {
        var ts = this._transformState;
        if (ts.writechunk !== null && ts.writecb && !ts.transforming) {
          ts.transforming = true;
          this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
        } else {
          ts.needTransform = true;
        }
      };
      Transform.prototype._destroy = function(err, cb) {
        var _this2 = this;
        Duplex.prototype._destroy.call(this, err, function(err2) {
          cb(err2);
          _this2.emit("close");
        });
      };
      function done(stream, er, data) {
        if (er) return stream.emit("error", er);
        if (data != null)
          stream.push(data);
        if (stream._writableState.length) throw new Error("Calling transform done when ws.length != 0");
        if (stream._transformState.transforming) throw new Error("Calling transform done when still transforming");
        return stream.push(null);
      }
    }
  });

  // ../../node_modules/bl/node_modules/readable-stream/lib/_stream_passthrough.js
  var require_stream_passthrough = __commonJS({
    "../../node_modules/bl/node_modules/readable-stream/lib/_stream_passthrough.js"(exports, module) {
      "use strict";
      module.exports = PassThrough;
      var Transform = require_stream_transform();
      var util = Object.create(require_util());
      util.inherits = require_inherits();
      util.inherits(PassThrough, Transform);
      function PassThrough(options) {
        if (!(this instanceof PassThrough)) return new PassThrough(options);
        Transform.call(this, options);
      }
      PassThrough.prototype._transform = function(chunk, encoding, cb) {
        cb(null, chunk);
      };
    }
  });

  // ../../node_modules/bl/node_modules/readable-stream/readable.js
  var require_readable = __commonJS({
    "../../node_modules/bl/node_modules/readable-stream/readable.js"(exports, module) {
      var Stream = __require("stream");
      if (process.env.READABLE_STREAM === "disable" && Stream) {
        module.exports = Stream;
        exports = module.exports = Stream.Readable;
        exports.Readable = Stream.Readable;
        exports.Writable = Stream.Writable;
        exports.Duplex = Stream.Duplex;
        exports.Transform = Stream.Transform;
        exports.PassThrough = Stream.PassThrough;
        exports.Stream = Stream;
      } else {
        exports = module.exports = require_stream_readable();
        exports.Stream = Stream || exports;
        exports.Readable = exports;
        exports.Writable = require_stream_writable();
        exports.Duplex = require_stream_duplex();
        exports.Transform = require_stream_transform();
        exports.PassThrough = require_stream_passthrough();
      }
    }
  });

  // ../../node_modules/bl/node_modules/readable-stream/duplex.js
  var require_duplex = __commonJS({
    "../../node_modules/bl/node_modules/readable-stream/duplex.js"(exports, module) {
      module.exports = require_readable().Duplex;
    }
  });

  // ../../node_modules/bl/bl.js
  var require_bl = __commonJS({
    "../../node_modules/bl/bl.js"(exports, module) {
      var DuplexStream = require_duplex();
      var util = __require("util");
      var Buffer2 = require_safe_buffer().Buffer;
      function BufferList(callback) {
        if (!(this instanceof BufferList))
          return new BufferList(callback);
        this._bufs = [];
        this.length = 0;
        if (typeof callback == "function") {
          this._callback = callback;
          var piper = function piper2(err) {
            if (this._callback) {
              this._callback(err);
              this._callback = null;
            }
          }.bind(this);
          this.on("pipe", function onPipe(src) {
            src.on("error", piper);
          });
          this.on("unpipe", function onUnpipe(src) {
            src.removeListener("error", piper);
          });
        } else {
          this.append(callback);
        }
        DuplexStream.call(this);
      }
      util.inherits(BufferList, DuplexStream);
      BufferList.prototype._offset = function _offset(offset) {
        var tot = 0, i = 0, _t;
        if (offset === 0) return [0, 0];
        for (; i < this._bufs.length; i++) {
          _t = tot + this._bufs[i].length;
          if (offset < _t || i == this._bufs.length - 1)
            return [i, offset - tot];
          tot = _t;
        }
      };
      BufferList.prototype.append = function append(buf) {
        var i = 0;
        if (Buffer2.isBuffer(buf)) {
          this._appendBuffer(buf);
        } else if (Array.isArray(buf)) {
          for (; i < buf.length; i++)
            this.append(buf[i]);
        } else if (buf instanceof BufferList) {
          for (; i < buf._bufs.length; i++)
            this.append(buf._bufs[i]);
        } else if (buf != null) {
          if (typeof buf == "number")
            buf = buf.toString();
          this._appendBuffer(Buffer2.from(buf));
        }
        return this;
      };
      BufferList.prototype._appendBuffer = function appendBuffer(buf) {
        this._bufs.push(buf);
        this.length += buf.length;
      };
      BufferList.prototype._write = function _write(buf, encoding, callback) {
        this._appendBuffer(buf);
        if (typeof callback == "function")
          callback();
      };
      BufferList.prototype._read = function _read(size) {
        if (!this.length)
          return this.push(null);
        size = Math.min(size, this.length);
        this.push(this.slice(0, size));
        this.consume(size);
      };
      BufferList.prototype.end = function end(chunk) {
        DuplexStream.prototype.end.call(this, chunk);
        if (this._callback) {
          this._callback(null, this.slice());
          this._callback = null;
        }
      };
      BufferList.prototype.get = function get(index) {
        return this.slice(index, index + 1)[0];
      };
      BufferList.prototype.slice = function slice(start, end) {
        if (typeof start == "number" && start < 0)
          start += this.length;
        if (typeof end == "number" && end < 0)
          end += this.length;
        return this.copy(null, 0, start, end);
      };
      BufferList.prototype.copy = function copy(dst, dstStart, srcStart, srcEnd) {
        if (typeof srcStart != "number" || srcStart < 0)
          srcStart = 0;
        if (typeof srcEnd != "number" || srcEnd > this.length)
          srcEnd = this.length;
        if (srcStart >= this.length)
          return dst || Buffer2.alloc(0);
        if (srcEnd <= 0)
          return dst || Buffer2.alloc(0);
        var copy2 = !!dst, off = this._offset(srcStart), len = srcEnd - srcStart, bytes = len, bufoff = copy2 && dstStart || 0, start = off[1], l, i;
        if (srcStart === 0 && srcEnd == this.length) {
          if (!copy2) {
            return this._bufs.length === 1 ? this._bufs[0] : Buffer2.concat(this._bufs, this.length);
          }
          for (i = 0; i < this._bufs.length; i++) {
            this._bufs[i].copy(dst, bufoff);
            bufoff += this._bufs[i].length;
          }
          return dst;
        }
        if (bytes <= this._bufs[off[0]].length - start) {
          return copy2 ? this._bufs[off[0]].copy(dst, dstStart, start, start + bytes) : this._bufs[off[0]].slice(start, start + bytes);
        }
        if (!copy2)
          dst = Buffer2.allocUnsafe(len);
        for (i = off[0]; i < this._bufs.length; i++) {
          l = this._bufs[i].length - start;
          if (bytes > l) {
            this._bufs[i].copy(dst, bufoff, start);
            bufoff += l;
          } else {
            this._bufs[i].copy(dst, bufoff, start, start + bytes);
            bufoff += l;
            break;
          }
          bytes -= l;
          if (start)
            start = 0;
        }
        if (dst.length > bufoff) return dst.slice(0, bufoff);
        return dst;
      };
      BufferList.prototype.shallowSlice = function shallowSlice(start, end) {
        start = start || 0;
        end = end || this.length;
        if (start < 0)
          start += this.length;
        if (end < 0)
          end += this.length;
        var startOffset = this._offset(start), endOffset = this._offset(end), buffers = this._bufs.slice(startOffset[0], endOffset[0] + 1);
        if (endOffset[1] == 0)
          buffers.pop();
        else
          buffers[buffers.length - 1] = buffers[buffers.length - 1].slice(0, endOffset[1]);
        if (startOffset[1] != 0)
          buffers[0] = buffers[0].slice(startOffset[1]);
        return new BufferList(buffers);
      };
      BufferList.prototype.toString = function toString(encoding, start, end) {
        return this.slice(start, end).toString(encoding);
      };
      BufferList.prototype.consume = function consume(bytes) {
        bytes = Math.trunc(bytes);
        if (Number.isNaN(bytes) || bytes <= 0) return this;
        while (this._bufs.length) {
          if (bytes >= this._bufs[0].length) {
            bytes -= this._bufs[0].length;
            this.length -= this._bufs[0].length;
            this._bufs.shift();
          } else {
            this._bufs[0] = this._bufs[0].slice(bytes);
            this.length -= bytes;
            break;
          }
        }
        return this;
      };
      BufferList.prototype.duplicate = function duplicate() {
        var i = 0, copy = new BufferList();
        for (; i < this._bufs.length; i++)
          copy.append(this._bufs[i]);
        return copy;
      };
      BufferList.prototype.destroy = function destroy() {
        this._bufs.length = 0;
        this.length = 0;
        this.push(null);
      };
      (function() {
        var methods = {
          "readDoubleBE": 8,
          "readDoubleLE": 8,
          "readFloatBE": 4,
          "readFloatLE": 4,
          "readInt32BE": 4,
          "readInt32LE": 4,
          "readUInt32BE": 4,
          "readUInt32LE": 4,
          "readInt16BE": 2,
          "readInt16LE": 2,
          "readUInt16BE": 2,
          "readUInt16LE": 2,
          "readInt8": 1,
          "readUInt8": 1
        };
        for (var m in methods) {
          (function(m2) {
            BufferList.prototype[m2] = function(offset) {
              return this.slice(offset, offset + methods[m2])[m2](0);
            };
          })(m);
        }
      })();
      module.exports = BufferList;
    }
  });

  // ../../node_modules/xtend/immutable.js
  var require_immutable = __commonJS({
    "../../node_modules/xtend/immutable.js"(exports, module) {
      module.exports = extend;
      var hasOwnProperty = Object.prototype.hasOwnProperty;
      function extend() {
        var target = {};
        for (var i = 0; i < arguments.length; i++) {
          var source = arguments[i];
          for (var key in source) {
            if (hasOwnProperty.call(source, key)) {
              target[key] = source[key];
            }
          }
        }
        return target;
      }
    }
  });

  // ../../node_modules/safe-buffer/index.js
  var require_safe_buffer2 = __commonJS({
    "../../node_modules/safe-buffer/index.js"(exports, module) {
      var buffer = __require("buffer");
      var Buffer2 = buffer.Buffer;
      function copyProps(src, dst) {
        for (var key in src) {
          dst[key] = src[key];
        }
      }
      if (Buffer2.from && Buffer2.alloc && Buffer2.allocUnsafe && Buffer2.allocUnsafeSlow) {
        module.exports = buffer;
      } else {
        copyProps(buffer, exports);
        exports.Buffer = SafeBuffer;
      }
      function SafeBuffer(arg, encodingOrOffset, length) {
        return Buffer2(arg, encodingOrOffset, length);
      }
      SafeBuffer.prototype = Object.create(Buffer2.prototype);
      copyProps(Buffer2, SafeBuffer);
      SafeBuffer.from = function(arg, encodingOrOffset, length) {
        if (typeof arg === "number") {
          throw new TypeError("Argument must not be a number");
        }
        return Buffer2(arg, encodingOrOffset, length);
      };
      SafeBuffer.alloc = function(size, fill, encoding) {
        if (typeof size !== "number") {
          throw new TypeError("Argument must be a number");
        }
        var buf = Buffer2(size);
        if (fill !== void 0) {
          if (typeof encoding === "string") {
            buf.fill(fill, encoding);
          } else {
            buf.fill(fill);
          }
        } else {
          buf.fill(0);
        }
        return buf;
      };
      SafeBuffer.allocUnsafe = function(size) {
        if (typeof size !== "number") {
          throw new TypeError("Argument must be a number");
        }
        return Buffer2(size);
      };
      SafeBuffer.allocUnsafeSlow = function(size) {
        if (typeof size !== "number") {
          throw new TypeError("Argument must be a number");
        }
        return buffer.SlowBuffer(size);
      };
    }
  });

  // ../../node_modules/isarray/index.js
  var require_isarray2 = __commonJS({
    "../../node_modules/isarray/index.js"(exports, module) {
      var toString = {}.toString;
      module.exports = Array.isArray || function(arr) {
        return toString.call(arr) == "[object Array]";
      };
    }
  });

  // ../../node_modules/es-errors/type.js
  var require_type = __commonJS({
    "../../node_modules/es-errors/type.js"(exports, module) {
      "use strict";
      module.exports = TypeError;
    }
  });

  // ../../node_modules/es-object-atoms/index.js
  var require_es_object_atoms = __commonJS({
    "../../node_modules/es-object-atoms/index.js"(exports, module) {
      "use strict";
      module.exports = Object;
    }
  });

  // ../../node_modules/es-errors/index.js
  var require_es_errors = __commonJS({
    "../../node_modules/es-errors/index.js"(exports, module) {
      "use strict";
      module.exports = Error;
    }
  });

  // ../../node_modules/es-errors/eval.js
  var require_eval = __commonJS({
    "../../node_modules/es-errors/eval.js"(exports, module) {
      "use strict";
      module.exports = EvalError;
    }
  });

  // ../../node_modules/es-errors/range.js
  var require_range = __commonJS({
    "../../node_modules/es-errors/range.js"(exports, module) {
      "use strict";
      module.exports = RangeError;
    }
  });

  // ../../node_modules/es-errors/ref.js
  var require_ref = __commonJS({
    "../../node_modules/es-errors/ref.js"(exports, module) {
      "use strict";
      module.exports = ReferenceError;
    }
  });

  // ../../node_modules/es-errors/syntax.js
  var require_syntax = __commonJS({
    "../../node_modules/es-errors/syntax.js"(exports, module) {
      "use strict";
      module.exports = SyntaxError;
    }
  });

  // ../../node_modules/es-errors/uri.js
  var require_uri = __commonJS({
    "../../node_modules/es-errors/uri.js"(exports, module) {
      "use strict";
      module.exports = URIError;
    }
  });

  // ../../node_modules/math-intrinsics/abs.js
  var require_abs = __commonJS({
    "../../node_modules/math-intrinsics/abs.js"(exports, module) {
      "use strict";
      module.exports = Math.abs;
    }
  });

  // ../../node_modules/math-intrinsics/floor.js
  var require_floor = __commonJS({
    "../../node_modules/math-intrinsics/floor.js"(exports, module) {
      "use strict";
      module.exports = Math.floor;
    }
  });

  // ../../node_modules/math-intrinsics/max.js
  var require_max = __commonJS({
    "../../node_modules/math-intrinsics/max.js"(exports, module) {
      "use strict";
      module.exports = Math.max;
    }
  });

  // ../../node_modules/math-intrinsics/min.js
  var require_min = __commonJS({
    "../../node_modules/math-intrinsics/min.js"(exports, module) {
      "use strict";
      module.exports = Math.min;
    }
  });

  // ../../node_modules/math-intrinsics/pow.js
  var require_pow = __commonJS({
    "../../node_modules/math-intrinsics/pow.js"(exports, module) {
      "use strict";
      module.exports = Math.pow;
    }
  });

  // ../../node_modules/math-intrinsics/round.js
  var require_round = __commonJS({
    "../../node_modules/math-intrinsics/round.js"(exports, module) {
      "use strict";
      module.exports = Math.round;
    }
  });

  // ../../node_modules/math-intrinsics/isNaN.js
  var require_isNaN = __commonJS({
    "../../node_modules/math-intrinsics/isNaN.js"(exports, module) {
      "use strict";
      module.exports = Number.isNaN || function isNaN2(a) {
        return a !== a;
      };
    }
  });

  // ../../node_modules/math-intrinsics/sign.js
  var require_sign = __commonJS({
    "../../node_modules/math-intrinsics/sign.js"(exports, module) {
      "use strict";
      var $isNaN = require_isNaN();
      module.exports = function sign(number) {
        if ($isNaN(number) || number === 0) {
          return number;
        }
        return number < 0 ? -1 : 1;
      };
    }
  });

  // ../../node_modules/gopd/gOPD.js
  var require_gOPD = __commonJS({
    "../../node_modules/gopd/gOPD.js"(exports, module) {
      "use strict";
      module.exports = Object.getOwnPropertyDescriptor;
    }
  });

  // ../../node_modules/gopd/index.js
  var require_gopd = __commonJS({
    "../../node_modules/gopd/index.js"(exports, module) {
      "use strict";
      var $gOPD = require_gOPD();
      if ($gOPD) {
        try {
          $gOPD([], "length");
        } catch (e) {
          $gOPD = null;
        }
      }
      module.exports = $gOPD;
    }
  });

  // ../../node_modules/es-define-property/index.js
  var require_es_define_property = __commonJS({
    "../../node_modules/es-define-property/index.js"(exports, module) {
      "use strict";
      var $defineProperty = Object.defineProperty || false;
      if ($defineProperty) {
        try {
          $defineProperty({}, "a", { value: 1 });
        } catch (e) {
          $defineProperty = false;
        }
      }
      module.exports = $defineProperty;
    }
  });

  // ../../node_modules/has-symbols/shams.js
  var require_shams = __commonJS({
    "../../node_modules/has-symbols/shams.js"(exports, module) {
      "use strict";
      module.exports = function hasSymbols() {
        if (typeof Symbol !== "function" || typeof Object.getOwnPropertySymbols !== "function") {
          return false;
        }
        if (typeof Symbol.iterator === "symbol") {
          return true;
        }
        var obj = {};
        var sym = Symbol("test");
        var symObj = Object(sym);
        if (typeof sym === "string") {
          return false;
        }
        if (Object.prototype.toString.call(sym) !== "[object Symbol]") {
          return false;
        }
        if (Object.prototype.toString.call(symObj) !== "[object Symbol]") {
          return false;
        }
        var symVal = 42;
        obj[sym] = symVal;
        for (var _ in obj) {
          return false;
        }
        if (typeof Object.keys === "function" && Object.keys(obj).length !== 0) {
          return false;
        }
        if (typeof Object.getOwnPropertyNames === "function" && Object.getOwnPropertyNames(obj).length !== 0) {
          return false;
        }
        var syms = Object.getOwnPropertySymbols(obj);
        if (syms.length !== 1 || syms[0] !== sym) {
          return false;
        }
        if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) {
          return false;
        }
        if (typeof Object.getOwnPropertyDescriptor === "function") {
          var descriptor = (
            /** @type {PropertyDescriptor} */
            Object.getOwnPropertyDescriptor(obj, sym)
          );
          if (descriptor.value !== symVal || descriptor.enumerable !== true) {
            return false;
          }
        }
        return true;
      };
    }
  });

  // ../../node_modules/has-symbols/index.js
  var require_has_symbols = __commonJS({
    "../../node_modules/has-symbols/index.js"(exports, module) {
      "use strict";
      var origSymbol = typeof Symbol !== "undefined" && Symbol;
      var hasSymbolSham = require_shams();
      module.exports = function hasNativeSymbols() {
        if (typeof origSymbol !== "function") {
          return false;
        }
        if (typeof Symbol !== "function") {
          return false;
        }
        if (typeof origSymbol("foo") !== "symbol") {
          return false;
        }
        if (typeof Symbol("bar") !== "symbol") {
          return false;
        }
        return hasSymbolSham();
      };
    }
  });

  // ../../node_modules/get-proto/Reflect.getPrototypeOf.js
  var require_Reflect_getPrototypeOf = __commonJS({
    "../../node_modules/get-proto/Reflect.getPrototypeOf.js"(exports, module) {
      "use strict";
      module.exports = typeof Reflect !== "undefined" && Reflect.getPrototypeOf || null;
    }
  });

  // ../../node_modules/get-proto/Object.getPrototypeOf.js
  var require_Object_getPrototypeOf = __commonJS({
    "../../node_modules/get-proto/Object.getPrototypeOf.js"(exports, module) {
      "use strict";
      var $Object = require_es_object_atoms();
      module.exports = $Object.getPrototypeOf || null;
    }
  });

  // ../../node_modules/function-bind/implementation.js
  var require_implementation = __commonJS({
    "../../node_modules/function-bind/implementation.js"(exports, module) {
      "use strict";
      var ERROR_MESSAGE = "Function.prototype.bind called on incompatible ";
      var toStr = Object.prototype.toString;
      var max = Math.max;
      var funcType = "[object Function]";
      var concatty = function concatty2(a, b) {
        var arr = [];
        for (var i = 0; i < a.length; i += 1) {
          arr[i] = a[i];
        }
        for (var j = 0; j < b.length; j += 1) {
          arr[j + a.length] = b[j];
        }
        return arr;
      };
      var slicy = function slicy2(arrLike, offset) {
        var arr = [];
        for (var i = offset || 0, j = 0; i < arrLike.length; i += 1, j += 1) {
          arr[j] = arrLike[i];
        }
        return arr;
      };
      var joiny = function(arr, joiner) {
        var str = "";
        for (var i = 0; i < arr.length; i += 1) {
          str += arr[i];
          if (i + 1 < arr.length) {
            str += joiner;
          }
        }
        return str;
      };
      module.exports = function bind(that) {
        var target = this;
        if (typeof target !== "function" || toStr.apply(target) !== funcType) {
          throw new TypeError(ERROR_MESSAGE + target);
        }
        var args = slicy(arguments, 1);
        var bound;
        var binder = function() {
          if (this instanceof bound) {
            var result = target.apply(
              this,
              concatty(args, arguments)
            );
            if (Object(result) === result) {
              return result;
            }
            return this;
          }
          return target.apply(
            that,
            concatty(args, arguments)
          );
        };
        var boundLength = max(0, target.length - args.length);
        var boundArgs = [];
        for (var i = 0; i < boundLength; i++) {
          boundArgs[i] = "$" + i;
        }
        bound = Function("binder", "return function (" + joiny(boundArgs, ",") + "){ return binder.apply(this,arguments); }")(binder);
        if (target.prototype) {
          var Empty = function Empty2() {
          };
          Empty.prototype = target.prototype;
          bound.prototype = new Empty();
          Empty.prototype = null;
        }
        return bound;
      };
    }
  });

  // ../../node_modules/function-bind/index.js
  var require_function_bind = __commonJS({
    "../../node_modules/function-bind/index.js"(exports, module) {
      "use strict";
      var implementation = require_implementation();
      module.exports = Function.prototype.bind || implementation;
    }
  });

  // ../../node_modules/call-bind-apply-helpers/functionCall.js
  var require_functionCall = __commonJS({
    "../../node_modules/call-bind-apply-helpers/functionCall.js"(exports, module) {
      "use strict";
      module.exports = Function.prototype.call;
    }
  });

  // ../../node_modules/call-bind-apply-helpers/functionApply.js
  var require_functionApply = __commonJS({
    "../../node_modules/call-bind-apply-helpers/functionApply.js"(exports, module) {
      "use strict";
      module.exports = Function.prototype.apply;
    }
  });

  // ../../node_modules/call-bind-apply-helpers/reflectApply.js
  var require_reflectApply = __commonJS({
    "../../node_modules/call-bind-apply-helpers/reflectApply.js"(exports, module) {
      "use strict";
      module.exports = typeof Reflect !== "undefined" && Reflect && Reflect.apply;
    }
  });

  // ../../node_modules/call-bind-apply-helpers/actualApply.js
  var require_actualApply = __commonJS({
    "../../node_modules/call-bind-apply-helpers/actualApply.js"(exports, module) {
      "use strict";
      var bind = require_function_bind();
      var $apply = require_functionApply();
      var $call = require_functionCall();
      var $reflectApply = require_reflectApply();
      module.exports = $reflectApply || bind.call($call, $apply);
    }
  });

  // ../../node_modules/call-bind-apply-helpers/index.js
  var require_call_bind_apply_helpers = __commonJS({
    "../../node_modules/call-bind-apply-helpers/index.js"(exports, module) {
      "use strict";
      var bind = require_function_bind();
      var $TypeError = require_type();
      var $call = require_functionCall();
      var $actualApply = require_actualApply();
      module.exports = function callBindBasic(args) {
        if (args.length < 1 || typeof args[0] !== "function") {
          throw new $TypeError("a function is required");
        }
        return $actualApply(bind, $call, args);
      };
    }
  });

  // ../../node_modules/dunder-proto/get.js
  var require_get = __commonJS({
    "../../node_modules/dunder-proto/get.js"(exports, module) {
      "use strict";
      var callBind = require_call_bind_apply_helpers();
      var gOPD = require_gopd();
      var hasProtoAccessor;
      try {
        hasProtoAccessor = /** @type {{ __proto__?: typeof Array.prototype }} */
        [].__proto__ === Array.prototype;
      } catch (e) {
        if (!e || typeof e !== "object" || !("code" in e) || e.code !== "ERR_PROTO_ACCESS") {
          throw e;
        }
      }
      var desc = !!hasProtoAccessor && gOPD && gOPD(
        Object.prototype,
        /** @type {keyof typeof Object.prototype} */
        "__proto__"
      );
      var $Object = Object;
      var $getPrototypeOf = $Object.getPrototypeOf;
      module.exports = desc && typeof desc.get === "function" ? callBind([desc.get]) : typeof $getPrototypeOf === "function" ? (
        /** @type {import('./get')} */
        function getDunder(value) {
          return $getPrototypeOf(value == null ? value : $Object(value));
        }
      ) : false;
    }
  });

  // ../../node_modules/get-proto/index.js
  var require_get_proto = __commonJS({
    "../../node_modules/get-proto/index.js"(exports, module) {
      "use strict";
      var reflectGetProto = require_Reflect_getPrototypeOf();
      var originalGetProto = require_Object_getPrototypeOf();
      var getDunderProto = require_get();
      module.exports = reflectGetProto ? function getProto(O) {
        return reflectGetProto(O);
      } : originalGetProto ? function getProto(O) {
        if (!O || typeof O !== "object" && typeof O !== "function") {
          throw new TypeError("getProto: not an object");
        }
        return originalGetProto(O);
      } : getDunderProto ? function getProto(O) {
        return getDunderProto(O);
      } : null;
    }
  });

  // ../../node_modules/hasown/index.js
  var require_hasown = __commonJS({
    "../../node_modules/hasown/index.js"(exports, module) {
      "use strict";
      var call = Function.prototype.call;
      var $hasOwn = Object.prototype.hasOwnProperty;
      var bind = require_function_bind();
      module.exports = bind.call(call, $hasOwn);
    }
  });

  // ../../node_modules/get-intrinsic/index.js
  var require_get_intrinsic = __commonJS({
    "../../node_modules/get-intrinsic/index.js"(exports, module) {
      "use strict";
      var undefined2;
      var $Object = require_es_object_atoms();
      var $Error = require_es_errors();
      var $EvalError = require_eval();
      var $RangeError = require_range();
      var $ReferenceError = require_ref();
      var $SyntaxError = require_syntax();
      var $TypeError = require_type();
      var $URIError = require_uri();
      var abs = require_abs();
      var floor = require_floor();
      var max = require_max();
      var min = require_min();
      var pow = require_pow();
      var round = require_round();
      var sign = require_sign();
      var $Function = Function;
      var getEvalledConstructor = function(expressionSyntax) {
        try {
          return $Function('"use strict"; return (' + expressionSyntax + ").constructor;")();
        } catch (e) {
        }
      };
      var $gOPD = require_gopd();
      var $defineProperty = require_es_define_property();
      var throwTypeError = function() {
        throw new $TypeError();
      };
      var ThrowTypeError = $gOPD ? (function() {
        try {
          arguments.callee;
          return throwTypeError;
        } catch (calleeThrows) {
          try {
            return $gOPD(arguments, "callee").get;
          } catch (gOPDthrows) {
            return throwTypeError;
          }
        }
      })() : throwTypeError;
      var hasSymbols = require_has_symbols()();
      var getProto = require_get_proto();
      var $ObjectGPO = require_Object_getPrototypeOf();
      var $ReflectGPO = require_Reflect_getPrototypeOf();
      var $apply = require_functionApply();
      var $call = require_functionCall();
      var needsEval = {};
      var TypedArray = typeof Uint8Array === "undefined" || !getProto ? undefined2 : getProto(Uint8Array);
      var INTRINSICS = {
        __proto__: null,
        "%AggregateError%": typeof AggregateError === "undefined" ? undefined2 : AggregateError,
        "%Array%": Array,
        "%ArrayBuffer%": typeof ArrayBuffer === "undefined" ? undefined2 : ArrayBuffer,
        "%ArrayIteratorPrototype%": hasSymbols && getProto ? getProto([][Symbol.iterator]()) : undefined2,
        "%AsyncFromSyncIteratorPrototype%": undefined2,
        "%AsyncFunction%": needsEval,
        "%AsyncGenerator%": needsEval,
        "%AsyncGeneratorFunction%": needsEval,
        "%AsyncIteratorPrototype%": needsEval,
        "%Atomics%": typeof Atomics === "undefined" ? undefined2 : Atomics,
        "%BigInt%": typeof BigInt === "undefined" ? undefined2 : BigInt,
        "%BigInt64Array%": typeof BigInt64Array === "undefined" ? undefined2 : BigInt64Array,
        "%BigUint64Array%": typeof BigUint64Array === "undefined" ? undefined2 : BigUint64Array,
        "%Boolean%": Boolean,
        "%DataView%": typeof DataView === "undefined" ? undefined2 : DataView,
        "%Date%": Date,
        "%decodeURI%": decodeURI,
        "%decodeURIComponent%": decodeURIComponent,
        "%encodeURI%": encodeURI,
        "%encodeURIComponent%": encodeURIComponent,
        "%Error%": $Error,
        "%eval%": eval,
        // eslint-disable-line no-eval
        "%EvalError%": $EvalError,
        "%Float16Array%": typeof Float16Array === "undefined" ? undefined2 : Float16Array,
        "%Float32Array%": typeof Float32Array === "undefined" ? undefined2 : Float32Array,
        "%Float64Array%": typeof Float64Array === "undefined" ? undefined2 : Float64Array,
        "%FinalizationRegistry%": typeof FinalizationRegistry === "undefined" ? undefined2 : FinalizationRegistry,
        "%Function%": $Function,
        "%GeneratorFunction%": needsEval,
        "%Int8Array%": typeof Int8Array === "undefined" ? undefined2 : Int8Array,
        "%Int16Array%": typeof Int16Array === "undefined" ? undefined2 : Int16Array,
        "%Int32Array%": typeof Int32Array === "undefined" ? undefined2 : Int32Array,
        "%isFinite%": isFinite,
        "%isNaN%": isNaN,
        "%IteratorPrototype%": hasSymbols && getProto ? getProto(getProto([][Symbol.iterator]())) : undefined2,
        "%JSON%": typeof JSON === "object" ? JSON : undefined2,
        "%Map%": typeof Map === "undefined" ? undefined2 : Map,
        "%MapIteratorPrototype%": typeof Map === "undefined" || !hasSymbols || !getProto ? undefined2 : getProto((/* @__PURE__ */ new Map())[Symbol.iterator]()),
        "%Math%": Math,
        "%Number%": Number,
        "%Object%": $Object,
        "%Object.getOwnPropertyDescriptor%": $gOPD,
        "%parseFloat%": parseFloat,
        "%parseInt%": parseInt,
        "%Promise%": typeof Promise === "undefined" ? undefined2 : Promise,
        "%Proxy%": typeof Proxy === "undefined" ? undefined2 : Proxy,
        "%RangeError%": $RangeError,
        "%ReferenceError%": $ReferenceError,
        "%Reflect%": typeof Reflect === "undefined" ? undefined2 : Reflect,
        "%RegExp%": RegExp,
        "%Set%": typeof Set === "undefined" ? undefined2 : Set,
        "%SetIteratorPrototype%": typeof Set === "undefined" || !hasSymbols || !getProto ? undefined2 : getProto((/* @__PURE__ */ new Set())[Symbol.iterator]()),
        "%SharedArrayBuffer%": typeof SharedArrayBuffer === "undefined" ? undefined2 : SharedArrayBuffer,
        "%String%": String,
        "%StringIteratorPrototype%": hasSymbols && getProto ? getProto(""[Symbol.iterator]()) : undefined2,
        "%Symbol%": hasSymbols ? Symbol : undefined2,
        "%SyntaxError%": $SyntaxError,
        "%ThrowTypeError%": ThrowTypeError,
        "%TypedArray%": TypedArray,
        "%TypeError%": $TypeError,
        "%Uint8Array%": typeof Uint8Array === "undefined" ? undefined2 : Uint8Array,
        "%Uint8ClampedArray%": typeof Uint8ClampedArray === "undefined" ? undefined2 : Uint8ClampedArray,
        "%Uint16Array%": typeof Uint16Array === "undefined" ? undefined2 : Uint16Array,
        "%Uint32Array%": typeof Uint32Array === "undefined" ? undefined2 : Uint32Array,
        "%URIError%": $URIError,
        "%WeakMap%": typeof WeakMap === "undefined" ? undefined2 : WeakMap,
        "%WeakRef%": typeof WeakRef === "undefined" ? undefined2 : WeakRef,
        "%WeakSet%": typeof WeakSet === "undefined" ? undefined2 : WeakSet,
        "%Function.prototype.call%": $call,
        "%Function.prototype.apply%": $apply,
        "%Object.defineProperty%": $defineProperty,
        "%Object.getPrototypeOf%": $ObjectGPO,
        "%Math.abs%": abs,
        "%Math.floor%": floor,
        "%Math.max%": max,
        "%Math.min%": min,
        "%Math.pow%": pow,
        "%Math.round%": round,
        "%Math.sign%": sign,
        "%Reflect.getPrototypeOf%": $ReflectGPO
      };
      if (getProto) {
        try {
          null.error;
        } catch (e) {
          errorProto = getProto(getProto(e));
          INTRINSICS["%Error.prototype%"] = errorProto;
        }
      }
      var errorProto;
      var doEval = function doEval2(name) {
        var value;
        if (name === "%AsyncFunction%") {
          value = getEvalledConstructor("async function () {}");
        } else if (name === "%GeneratorFunction%") {
          value = getEvalledConstructor("function* () {}");
        } else if (name === "%AsyncGeneratorFunction%") {
          value = getEvalledConstructor("async function* () {}");
        } else if (name === "%AsyncGenerator%") {
          var fn = doEval2("%AsyncGeneratorFunction%");
          if (fn) {
            value = fn.prototype;
          }
        } else if (name === "%AsyncIteratorPrototype%") {
          var gen = doEval2("%AsyncGenerator%");
          if (gen && getProto) {
            value = getProto(gen.prototype);
          }
        }
        INTRINSICS[name] = value;
        return value;
      };
      var LEGACY_ALIASES = {
        __proto__: null,
        "%ArrayBufferPrototype%": ["ArrayBuffer", "prototype"],
        "%ArrayPrototype%": ["Array", "prototype"],
        "%ArrayProto_entries%": ["Array", "prototype", "entries"],
        "%ArrayProto_forEach%": ["Array", "prototype", "forEach"],
        "%ArrayProto_keys%": ["Array", "prototype", "keys"],
        "%ArrayProto_values%": ["Array", "prototype", "values"],
        "%AsyncFunctionPrototype%": ["AsyncFunction", "prototype"],
        "%AsyncGenerator%": ["AsyncGeneratorFunction", "prototype"],
        "%AsyncGeneratorPrototype%": ["AsyncGeneratorFunction", "prototype", "prototype"],
        "%BooleanPrototype%": ["Boolean", "prototype"],
        "%DataViewPrototype%": ["DataView", "prototype"],
        "%DatePrototype%": ["Date", "prototype"],
        "%ErrorPrototype%": ["Error", "prototype"],
        "%EvalErrorPrototype%": ["EvalError", "prototype"],
        "%Float32ArrayPrototype%": ["Float32Array", "prototype"],
        "%Float64ArrayPrototype%": ["Float64Array", "prototype"],
        "%FunctionPrototype%": ["Function", "prototype"],
        "%Generator%": ["GeneratorFunction", "prototype"],
        "%GeneratorPrototype%": ["GeneratorFunction", "prototype", "prototype"],
        "%Int8ArrayPrototype%": ["Int8Array", "prototype"],
        "%Int16ArrayPrototype%": ["Int16Array", "prototype"],
        "%Int32ArrayPrototype%": ["Int32Array", "prototype"],
        "%JSONParse%": ["JSON", "parse"],
        "%JSONStringify%": ["JSON", "stringify"],
        "%MapPrototype%": ["Map", "prototype"],
        "%NumberPrototype%": ["Number", "prototype"],
        "%ObjectPrototype%": ["Object", "prototype"],
        "%ObjProto_toString%": ["Object", "prototype", "toString"],
        "%ObjProto_valueOf%": ["Object", "prototype", "valueOf"],
        "%PromisePrototype%": ["Promise", "prototype"],
        "%PromiseProto_then%": ["Promise", "prototype", "then"],
        "%Promise_all%": ["Promise", "all"],
        "%Promise_reject%": ["Promise", "reject"],
        "%Promise_resolve%": ["Promise", "resolve"],
        "%RangeErrorPrototype%": ["RangeError", "prototype"],
        "%ReferenceErrorPrototype%": ["ReferenceError", "prototype"],
        "%RegExpPrototype%": ["RegExp", "prototype"],
        "%SetPrototype%": ["Set", "prototype"],
        "%SharedArrayBufferPrototype%": ["SharedArrayBuffer", "prototype"],
        "%StringPrototype%": ["String", "prototype"],
        "%SymbolPrototype%": ["Symbol", "prototype"],
        "%SyntaxErrorPrototype%": ["SyntaxError", "prototype"],
        "%TypedArrayPrototype%": ["TypedArray", "prototype"],
        "%TypeErrorPrototype%": ["TypeError", "prototype"],
        "%Uint8ArrayPrototype%": ["Uint8Array", "prototype"],
        "%Uint8ClampedArrayPrototype%": ["Uint8ClampedArray", "prototype"],
        "%Uint16ArrayPrototype%": ["Uint16Array", "prototype"],
        "%Uint32ArrayPrototype%": ["Uint32Array", "prototype"],
        "%URIErrorPrototype%": ["URIError", "prototype"],
        "%WeakMapPrototype%": ["WeakMap", "prototype"],
        "%WeakSetPrototype%": ["WeakSet", "prototype"]
      };
      var bind = require_function_bind();
      var hasOwn = require_hasown();
      var $concat = bind.call($call, Array.prototype.concat);
      var $spliceApply = bind.call($apply, Array.prototype.splice);
      var $replace = bind.call($call, String.prototype.replace);
      var $strSlice = bind.call($call, String.prototype.slice);
      var $exec = bind.call($call, RegExp.prototype.exec);
      var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g;
      var reEscapeChar = /\\(\\)?/g;
      var stringToPath = function stringToPath2(string) {
        var first = $strSlice(string, 0, 1);
        var last = $strSlice(string, -1);
        if (first === "%" && last !== "%") {
          throw new $SyntaxError("invalid intrinsic syntax, expected closing `%`");
        } else if (last === "%" && first !== "%") {
          throw new $SyntaxError("invalid intrinsic syntax, expected opening `%`");
        }
        var result = [];
        $replace(string, rePropName, function(match, number, quote, subString) {
          result[result.length] = quote ? $replace(subString, reEscapeChar, "$1") : number || match;
        });
        return result;
      };
      var getBaseIntrinsic = function getBaseIntrinsic2(name, allowMissing) {
        var intrinsicName = name;
        var alias;
        if (hasOwn(LEGACY_ALIASES, intrinsicName)) {
          alias = LEGACY_ALIASES[intrinsicName];
          intrinsicName = "%" + alias[0] + "%";
        }
        if (hasOwn(INTRINSICS, intrinsicName)) {
          var value = INTRINSICS[intrinsicName];
          if (value === needsEval) {
            value = doEval(intrinsicName);
          }
          if (typeof value === "undefined" && !allowMissing) {
            throw new $TypeError("intrinsic " + name + " exists, but is not available. Please file an issue!");
          }
          return {
            alias,
            name: intrinsicName,
            value
          };
        }
        throw new $SyntaxError("intrinsic " + name + " does not exist!");
      };
      module.exports = function GetIntrinsic(name, allowMissing) {
        if (typeof name !== "string" || name.length === 0) {
          throw new $TypeError("intrinsic name must be a non-empty string");
        }
        if (arguments.length > 1 && typeof allowMissing !== "boolean") {
          throw new $TypeError('"allowMissing" argument must be a boolean');
        }
        if ($exec(/^%?[^%]*%?$/, name) === null) {
          throw new $SyntaxError("`%` may not be present anywhere but at the beginning and end of the intrinsic name");
        }
        var parts = stringToPath(name);
        var intrinsicBaseName = parts.length > 0 ? parts[0] : "";
        var intrinsic = getBaseIntrinsic("%" + intrinsicBaseName + "%", allowMissing);
        var intrinsicRealName = intrinsic.name;
        var value = intrinsic.value;
        var skipFurtherCaching = false;
        var alias = intrinsic.alias;
        if (alias) {
          intrinsicBaseName = alias[0];
          $spliceApply(parts, $concat([0, 1], alias));
        }
        for (var i = 1, isOwn = true; i < parts.length; i += 1) {
          var part = parts[i];
          var first = $strSlice(part, 0, 1);
          var last = $strSlice(part, -1);
          if ((first === '"' || first === "'" || first === "`" || (last === '"' || last === "'" || last === "`")) && first !== last) {
            throw new $SyntaxError("property names with quotes must have matching quotes");
          }
          if (part === "constructor" || !isOwn) {
            skipFurtherCaching = true;
          }
          intrinsicBaseName += "." + part;
          intrinsicRealName = "%" + intrinsicBaseName + "%";
          if (hasOwn(INTRINSICS, intrinsicRealName)) {
            value = INTRINSICS[intrinsicRealName];
          } else if (value != null) {
            if (!(part in value)) {
              if (!allowMissing) {
                throw new $TypeError("base intrinsic for " + name + " exists, but the property is not available.");
              }
              return void undefined2;
            }
            if ($gOPD && i + 1 >= parts.length) {
              var desc = $gOPD(value, part);
              isOwn = !!desc;
              if (isOwn && "get" in desc && !("originalValue" in desc.get)) {
                value = desc.get;
              } else {
                value = value[part];
              }
            } else {
              isOwn = hasOwn(value, part);
              value = value[part];
            }
            if (isOwn && !skipFurtherCaching) {
              INTRINSICS[intrinsicRealName] = value;
            }
          }
        }
        return value;
      };
    }
  });

  // ../../node_modules/call-bound/index.js
  var require_call_bound = __commonJS({
    "../../node_modules/call-bound/index.js"(exports, module) {
      "use strict";
      var GetIntrinsic = require_get_intrinsic();
      var callBindBasic = require_call_bind_apply_helpers();
      var $indexOf = callBindBasic([GetIntrinsic("%String.prototype.indexOf%")]);
      module.exports = function callBoundIntrinsic(name, allowMissing) {
        var intrinsic = (
          /** @type {(this: unknown, ...args: unknown[]) => unknown} */
          GetIntrinsic(name, !!allowMissing)
        );
        if (typeof intrinsic === "function" && $indexOf(name, ".prototype.") > -1) {
          return callBindBasic(
            /** @type {const} */
            [intrinsic]
          );
        }
        return intrinsic;
      };
    }
  });

  // ../../node_modules/is-callable/index.js
  var require_is_callable = __commonJS({
    "../../node_modules/is-callable/index.js"(exports, module) {
      "use strict";
      var fnToStr = Function.prototype.toString;
      var reflectApply = typeof Reflect === "object" && Reflect !== null && Reflect.apply;
      var badArrayLike;
      var isCallableMarker;
      if (typeof reflectApply === "function" && typeof Object.defineProperty === "function") {
        try {
          badArrayLike = Object.defineProperty({}, "length", {
            get: function() {
              throw isCallableMarker;
            }
          });
          isCallableMarker = {};
          reflectApply(function() {
            throw 42;
          }, null, badArrayLike);
        } catch (_) {
          if (_ !== isCallableMarker) {
            reflectApply = null;
          }
        }
      } else {
        reflectApply = null;
      }
      var constructorRegex = /^\s*class\b/;
      var isES6ClassFn = function isES6ClassFunction(value) {
        try {
          var fnStr = fnToStr.call(value);
          return constructorRegex.test(fnStr);
        } catch (e) {
          return false;
        }
      };
      var tryFunctionObject = function tryFunctionToStr(value) {
        try {
          if (isES6ClassFn(value)) {
            return false;
          }
          fnToStr.call(value);
          return true;
        } catch (e) {
          return false;
        }
      };
      var toStr = Object.prototype.toString;
      var objectClass = "[object Object]";
      var fnClass = "[object Function]";
      var genClass = "[object GeneratorFunction]";
      var ddaClass = "[object HTMLAllCollection]";
      var ddaClass2 = "[object HTML document.all class]";
      var ddaClass3 = "[object HTMLCollection]";
      var hasToStringTag = typeof Symbol === "function" && !!Symbol.toStringTag;
      var isIE68 = !(0 in [,]);
      var isDDA = function isDocumentDotAll() {
        return false;
      };
      if (typeof document === "object") {
        all = document.all;
        if (toStr.call(all) === toStr.call(document.all)) {
          isDDA = function isDocumentDotAll(value) {
            if ((isIE68 || !value) && (typeof value === "undefined" || typeof value === "object")) {
              try {
                var str = toStr.call(value);
                return (str === ddaClass || str === ddaClass2 || str === ddaClass3 || str === objectClass) && value("") == null;
              } catch (e) {
              }
            }
            return false;
          };
        }
      }
      var all;
      module.exports = reflectApply ? function isCallable(value) {
        if (isDDA(value)) {
          return true;
        }
        if (!value) {
          return false;
        }
        if (typeof value !== "function" && typeof value !== "object") {
          return false;
        }
        try {
          reflectApply(value, null, badArrayLike);
        } catch (e) {
          if (e !== isCallableMarker) {
            return false;
          }
        }
        return !isES6ClassFn(value) && tryFunctionObject(value);
      } : function isCallable(value) {
        if (isDDA(value)) {
          return true;
        }
        if (!value) {
          return false;
        }
        if (typeof value !== "function" && typeof value !== "object") {
          return false;
        }
        if (hasToStringTag) {
          return tryFunctionObject(value);
        }
        if (isES6ClassFn(value)) {
          return false;
        }
        var strClass = toStr.call(value);
        if (strClass !== fnClass && strClass !== genClass && !/^\[object HTML/.test(strClass)) {
          return false;
        }
        return tryFunctionObject(value);
      };
    }
  });

  // ../../node_modules/for-each/index.js
  var require_for_each = __commonJS({
    "../../node_modules/for-each/index.js"(exports, module) {
      "use strict";
      var isCallable = require_is_callable();
      var toStr = Object.prototype.toString;
      var hasOwnProperty = Object.prototype.hasOwnProperty;
      var forEachArray = function forEachArray2(array, iterator, receiver) {
        for (var i = 0, len = array.length; i < len; i++) {
          if (hasOwnProperty.call(array, i)) {
            if (receiver == null) {
              iterator(array[i], i, array);
            } else {
              iterator.call(receiver, array[i], i, array);
            }
          }
        }
      };
      var forEachString = function forEachString2(string, iterator, receiver) {
        for (var i = 0, len = string.length; i < len; i++) {
          if (receiver == null) {
            iterator(string.charAt(i), i, string);
          } else {
            iterator.call(receiver, string.charAt(i), i, string);
          }
        }
      };
      var forEachObject = function forEachObject2(object, iterator, receiver) {
        for (var k in object) {
          if (hasOwnProperty.call(object, k)) {
            if (receiver == null) {
              iterator(object[k], k, object);
            } else {
              iterator.call(receiver, object[k], k, object);
            }
          }
        }
      };
      function isArray(x) {
        return toStr.call(x) === "[object Array]";
      }
      module.exports = function forEach(list, iterator, thisArg) {
        if (!isCallable(iterator)) {
          throw new TypeError("iterator must be a function");
        }
        var receiver;
        if (arguments.length >= 3) {
          receiver = thisArg;
        }
        if (isArray(list)) {
          forEachArray(list, iterator, receiver);
        } else if (typeof list === "string") {
          forEachString(list, iterator, receiver);
        } else {
          forEachObject(list, iterator, receiver);
        }
      };
    }
  });

  // ../../node_modules/possible-typed-array-names/index.js
  var require_possible_typed_array_names = __commonJS({
    "../../node_modules/possible-typed-array-names/index.js"(exports, module) {
      "use strict";
      module.exports = [
        "Float16Array",
        "Float32Array",
        "Float64Array",
        "Int8Array",
        "Int16Array",
        "Int32Array",
        "Uint8Array",
        "Uint8ClampedArray",
        "Uint16Array",
        "Uint32Array",
        "BigInt64Array",
        "BigUint64Array"
      ];
    }
  });

  // ../../node_modules/available-typed-arrays/index.js
  var require_available_typed_arrays = __commonJS({
    "../../node_modules/available-typed-arrays/index.js"(exports, module) {
      "use strict";
      var possibleNames = require_possible_typed_array_names();
      var g = typeof globalThis === "undefined" ? global : globalThis;
      module.exports = function availableTypedArrays() {
        var out = [];
        for (var i = 0; i < possibleNames.length; i++) {
          if (typeof g[possibleNames[i]] === "function") {
            out[out.length] = possibleNames[i];
          }
        }
        return out;
      };
    }
  });

  // ../../node_modules/define-data-property/index.js
  var require_define_data_property = __commonJS({
    "../../node_modules/define-data-property/index.js"(exports, module) {
      "use strict";
      var $defineProperty = require_es_define_property();
      var $SyntaxError = require_syntax();
      var $TypeError = require_type();
      var gopd = require_gopd();
      module.exports = function defineDataProperty(obj, property, value) {
        if (!obj || typeof obj !== "object" && typeof obj !== "function") {
          throw new $TypeError("`obj` must be an object or a function`");
        }
        if (typeof property !== "string" && typeof property !== "symbol") {
          throw new $TypeError("`property` must be a string or a symbol`");
        }
        if (arguments.length > 3 && typeof arguments[3] !== "boolean" && arguments[3] !== null) {
          throw new $TypeError("`nonEnumerable`, if provided, must be a boolean or null");
        }
        if (arguments.length > 4 && typeof arguments[4] !== "boolean" && arguments[4] !== null) {
          throw new $TypeError("`nonWritable`, if provided, must be a boolean or null");
        }
        if (arguments.length > 5 && typeof arguments[5] !== "boolean" && arguments[5] !== null) {
          throw new $TypeError("`nonConfigurable`, if provided, must be a boolean or null");
        }
        if (arguments.length > 6 && typeof arguments[6] !== "boolean") {
          throw new $TypeError("`loose`, if provided, must be a boolean");
        }
        var nonEnumerable = arguments.length > 3 ? arguments[3] : null;
        var nonWritable = arguments.length > 4 ? arguments[4] : null;
        var nonConfigurable = arguments.length > 5 ? arguments[5] : null;
        var loose = arguments.length > 6 ? arguments[6] : false;
        var desc = !!gopd && gopd(obj, property);
        if ($defineProperty) {
          $defineProperty(obj, property, {
            configurable: nonConfigurable === null && desc ? desc.configurable : !nonConfigurable,
            enumerable: nonEnumerable === null && desc ? desc.enumerable : !nonEnumerable,
            value,
            writable: nonWritable === null && desc ? desc.writable : !nonWritable
          });
        } else if (loose || !nonEnumerable && !nonWritable && !nonConfigurable) {
          obj[property] = value;
        } else {
          throw new $SyntaxError("This environment does not support defining a property as non-configurable, non-writable, or non-enumerable.");
        }
      };
    }
  });

  // ../../node_modules/has-property-descriptors/index.js
  var require_has_property_descriptors = __commonJS({
    "../../node_modules/has-property-descriptors/index.js"(exports, module) {
      "use strict";
      var $defineProperty = require_es_define_property();
      var hasPropertyDescriptors = function hasPropertyDescriptors2() {
        return !!$defineProperty;
      };
      hasPropertyDescriptors.hasArrayLengthDefineBug = function hasArrayLengthDefineBug() {
        if (!$defineProperty) {
          return null;
        }
        try {
          return $defineProperty([], "length", { value: 1 }).length !== 1;
        } catch (e) {
          return true;
        }
      };
      module.exports = hasPropertyDescriptors;
    }
  });

  // ../../node_modules/set-function-length/index.js
  var require_set_function_length = __commonJS({
    "../../node_modules/set-function-length/index.js"(exports, module) {
      "use strict";
      var GetIntrinsic = require_get_intrinsic();
      var define = require_define_data_property();
      var hasDescriptors = require_has_property_descriptors()();
      var gOPD = require_gopd();
      var $TypeError = require_type();
      var $floor = GetIntrinsic("%Math.floor%");
      module.exports = function setFunctionLength(fn, length) {
        if (typeof fn !== "function") {
          throw new $TypeError("`fn` is not a function");
        }
        if (typeof length !== "number" || length < 0 || length > 4294967295 || $floor(length) !== length) {
          throw new $TypeError("`length` must be a positive 32-bit integer");
        }
        var loose = arguments.length > 2 && !!arguments[2];
        var functionLengthIsConfigurable = true;
        var functionLengthIsWritable = true;
        if ("length" in fn && gOPD) {
          var desc = gOPD(fn, "length");
          if (desc && !desc.configurable) {
            functionLengthIsConfigurable = false;
          }
          if (desc && !desc.writable) {
            functionLengthIsWritable = false;
          }
        }
        if (functionLengthIsConfigurable || functionLengthIsWritable || !loose) {
          if (hasDescriptors) {
            define(
              /** @type {Parameters<define>[0]} */
              fn,
              "length",
              length,
              true,
              true
            );
          } else {
            define(
              /** @type {Parameters<define>[0]} */
              fn,
              "length",
              length
            );
          }
        }
        return fn;
      };
    }
  });

  // ../../node_modules/call-bind-apply-helpers/applyBind.js
  var require_applyBind = __commonJS({
    "../../node_modules/call-bind-apply-helpers/applyBind.js"(exports, module) {
      "use strict";
      var bind = require_function_bind();
      var $apply = require_functionApply();
      var actualApply = require_actualApply();
      module.exports = function applyBind() {
        return actualApply(bind, $apply, arguments);
      };
    }
  });

  // ../../node_modules/call-bind/index.js
  var require_call_bind = __commonJS({
    "../../node_modules/call-bind/index.js"(exports, module) {
      "use strict";
      var setFunctionLength = require_set_function_length();
      var $defineProperty = require_es_define_property();
      var callBindBasic = require_call_bind_apply_helpers();
      var applyBind = require_applyBind();
      module.exports = function callBind(originalFunction) {
        var func = callBindBasic(arguments);
        var adjustedLength = originalFunction.length - (arguments.length - 1);
        return setFunctionLength(
          func,
          1 + (adjustedLength > 0 ? adjustedLength : 0),
          true
        );
      };
      if ($defineProperty) {
        $defineProperty(module.exports, "apply", { value: applyBind });
      } else {
        module.exports.apply = applyBind;
      }
    }
  });

  // ../../node_modules/has-tostringtag/shams.js
  var require_shams2 = __commonJS({
    "../../node_modules/has-tostringtag/shams.js"(exports, module) {
      "use strict";
      var hasSymbols = require_shams();
      module.exports = function hasToStringTagShams() {
        return hasSymbols() && !!Symbol.toStringTag;
      };
    }
  });

  // ../../node_modules/which-typed-array/index.js
  var require_which_typed_array = __commonJS({
    "../../node_modules/which-typed-array/index.js"(exports, module) {
      "use strict";
      var forEach = require_for_each();
      var availableTypedArrays = require_available_typed_arrays();
      var callBind = require_call_bind();
      var callBound = require_call_bound();
      var gOPD = require_gopd();
      var getProto = require_get_proto();
      var $toString = callBound("Object.prototype.toString");
      var hasToStringTag = require_shams2()();
      var g = typeof globalThis === "undefined" ? global : globalThis;
      var typedArrays = availableTypedArrays();
      var $slice = callBound("String.prototype.slice");
      var $indexOf = callBound("Array.prototype.indexOf", true) || function indexOf(array, value) {
        for (var i = 0; i < array.length; i += 1) {
          if (array[i] === value) {
            return i;
          }
        }
        return -1;
      };
      var cache = { __proto__: null };
      if (hasToStringTag && gOPD && getProto) {
        forEach(typedArrays, function(typedArray) {
          var arr = new g[typedArray]();
          if (Symbol.toStringTag in arr && getProto) {
            var proto = getProto(arr);
            var descriptor = gOPD(proto, Symbol.toStringTag);
            if (!descriptor && proto) {
              var superProto = getProto(proto);
              descriptor = gOPD(superProto, Symbol.toStringTag);
            }
            if (descriptor && descriptor.get) {
              var bound = callBind(descriptor.get);
              cache[
                /** @type {`$${import('.').TypedArrayName}`} */
                "$" + typedArray
              ] = bound;
            }
          }
        });
      } else {
        forEach(typedArrays, function(typedArray) {
          var arr = new g[typedArray]();
          var fn = arr.slice || arr.set;
          if (fn) {
            var bound = (
              /** @type {import('./types').BoundSlice | import('./types').BoundSet} */
              // @ts-expect-error upstream-type-bridge
              callBind(fn)
            );
            cache[
              /** @type {`$${import('.').TypedArrayName}`} */
              "$" + typedArray
            ] = bound;
          }
        });
      }
      var tryTypedArrays = function tryAllTypedArrays(value) {
        var found = false;
        forEach(
          /** @type {Record<`\$${import('.').TypedArrayName}`, Getter>} */
          cache,
          /** @type {(getter: Getter, name: `\$${import('.').TypedArrayName}`) => void} */
          function(getter, typedArray) {
            if (!found) {
              try {
                if ("$" + getter(value) === typedArray) {
                  found = /** @type {import('.').TypedArrayName} */
                  $slice(typedArray, 1);
                }
              } catch (e) {
              }
            }
          }
        );
        return found;
      };
      var trySlices = function tryAllSlices(value) {
        var found = false;
        forEach(
          /** @type {Record<`\$${import('.').TypedArrayName}`, Getter>} */
          cache,
          /** @type {(getter: Getter, name: `\$${import('.').TypedArrayName}`) => void} */
          function(getter, name) {
            if (!found) {
              try {
                getter(value);
                found = /** @type {import('.').TypedArrayName} */
                $slice(name, 1);
              } catch (e) {
              }
            }
          }
        );
        return found;
      };
      module.exports = function whichTypedArray(value) {
        if (!value || typeof value !== "object") {
          return false;
        }
        if (!hasToStringTag) {
          var tag = $slice($toString(value), 8, -1);
          if ($indexOf(typedArrays, tag) > -1) {
            return tag;
          }
          if (tag !== "Object") {
            return false;
          }
          return trySlices(value);
        }
        if (!gOPD) {
          return null;
        }
        return tryTypedArrays(value);
      };
    }
  });

  // ../../node_modules/is-typed-array/index.js
  var require_is_typed_array = __commonJS({
    "../../node_modules/is-typed-array/index.js"(exports, module) {
      "use strict";
      var whichTypedArray = require_which_typed_array();
      module.exports = function isTypedArray(value) {
        return !!whichTypedArray(value);
      };
    }
  });

  // ../../node_modules/typed-array-buffer/index.js
  var require_typed_array_buffer = __commonJS({
    "../../node_modules/typed-array-buffer/index.js"(exports, module) {
      "use strict";
      var $TypeError = require_type();
      var callBound = require_call_bound();
      var $typedArrayBuffer = callBound("TypedArray.prototype.buffer", true);
      var isTypedArray = require_is_typed_array();
      module.exports = $typedArrayBuffer || function typedArrayBuffer(x) {
        if (!isTypedArray(x)) {
          throw new $TypeError("Not a Typed Array");
        }
        return x.buffer;
      };
    }
  });

  // ../../node_modules/to-buffer/index.js
  var require_to_buffer = __commonJS({
    "../../node_modules/to-buffer/index.js"(exports, module) {
      "use strict";
      var Buffer2 = require_safe_buffer2().Buffer;
      var isArray = require_isarray2();
      var typedArrayBuffer = require_typed_array_buffer();
      var isView = ArrayBuffer.isView || function isView2(obj) {
        try {
          typedArrayBuffer(obj);
          return true;
        } catch (e) {
          return false;
        }
      };
      var useUint8Array = typeof Uint8Array !== "undefined";
      var useArrayBuffer = typeof ArrayBuffer !== "undefined" && typeof Uint8Array !== "undefined";
      var useFromArrayBuffer = useArrayBuffer && (Buffer2.prototype instanceof Uint8Array || Buffer2.TYPED_ARRAY_SUPPORT);
      module.exports = function toBuffer(data, encoding) {
        if (Buffer2.isBuffer(data)) {
          if (data.constructor && !("isBuffer" in data)) {
            return Buffer2.from(data);
          }
          return data;
        }
        if (typeof data === "string") {
          return Buffer2.from(data, encoding);
        }
        if (useArrayBuffer && isView(data)) {
          if (data.byteLength === 0) {
            return Buffer2.alloc(0);
          }
          if (useFromArrayBuffer) {
            var res = Buffer2.from(data.buffer, data.byteOffset, data.byteLength);
            if (res.byteLength === data.byteLength) {
              return res;
            }
          }
          var uint8 = data instanceof Uint8Array ? data : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
          var result = Buffer2.from(uint8);
          if (result.length === data.byteLength) {
            return result;
          }
        }
        if (useUint8Array && data instanceof Uint8Array) {
          return Buffer2.from(data);
        }
        var isArr = isArray(data);
        if (isArr) {
          for (var i = 0; i < data.length; i += 1) {
            var x = data[i];
            if (typeof x !== "number" || x < 0 || x > 255 || ~~x !== x) {
              throw new RangeError("Array items must be numbers in the range 0-255.");
            }
          }
        }
        if (isArr || Buffer2.isBuffer(data) && data.constructor && typeof data.constructor.isBuffer === "function" && data.constructor.isBuffer(data)) {
          return Buffer2.from(data);
        }
        throw new TypeError('The "data" argument must be a string, an Array, a Buffer, a Uint8Array, or a DataView.');
      };
    }
  });

  // ../../node_modules/buffer-fill/index.js
  var require_buffer_fill = __commonJS({
    "../../node_modules/buffer-fill/index.js"(exports, module) {
      var hasFullSupport = (function() {
        try {
          if (!Buffer.isEncoding("latin1")) {
            return false;
          }
          var buf = Buffer.alloc ? Buffer.alloc(4) : new Buffer(4);
          buf.fill("ab", "ucs2");
          return buf.toString("hex") === "61006200";
        } catch (_) {
          return false;
        }
      })();
      function isSingleByte(val) {
        return val.length === 1 && val.charCodeAt(0) < 256;
      }
      function fillWithNumber(buffer, val, start, end) {
        if (start < 0 || end > buffer.length) {
          throw new RangeError("Out of range index");
        }
        start = start >>> 0;
        end = end === void 0 ? buffer.length : end >>> 0;
        if (end > start) {
          buffer.fill(val, start, end);
        }
        return buffer;
      }
      function fillWithBuffer(buffer, val, start, end) {
        if (start < 0 || end > buffer.length) {
          throw new RangeError("Out of range index");
        }
        if (end <= start) {
          return buffer;
        }
        start = start >>> 0;
        end = end === void 0 ? buffer.length : end >>> 0;
        var pos = start;
        var len = val.length;
        while (pos <= end - len) {
          val.copy(buffer, pos);
          pos += len;
        }
        if (pos !== end) {
          val.copy(buffer, pos, 0, end - pos);
        }
        return buffer;
      }
      function fill(buffer, val, start, end, encoding) {
        if (hasFullSupport) {
          return buffer.fill(val, start, end, encoding);
        }
        if (typeof val === "number") {
          return fillWithNumber(buffer, val, start, end);
        }
        if (typeof val === "string") {
          if (typeof start === "string") {
            encoding = start;
            start = 0;
            end = buffer.length;
          } else if (typeof end === "string") {
            encoding = end;
            end = buffer.length;
          }
          if (encoding !== void 0 && typeof encoding !== "string") {
            throw new TypeError("encoding must be a string");
          }
          if (encoding === "latin1") {
            encoding = "binary";
          }
          if (typeof encoding === "string" && !Buffer.isEncoding(encoding)) {
            throw new TypeError("Unknown encoding: " + encoding);
          }
          if (val === "") {
            return fillWithNumber(buffer, 0, start, end);
          }
          if (isSingleByte(val)) {
            return fillWithNumber(buffer, val.charCodeAt(0), start, end);
          }
          val = new Buffer(val, encoding);
        }
        if (Buffer.isBuffer(val)) {
          return fillWithBuffer(buffer, val, start, end);
        }
        return fillWithNumber(buffer, 0, start, end);
      }
      module.exports = fill;
    }
  });

  // ../../node_modules/buffer-alloc-unsafe/index.js
  var require_buffer_alloc_unsafe = __commonJS({
    "../../node_modules/buffer-alloc-unsafe/index.js"(exports, module) {
      function allocUnsafe(size) {
        if (typeof size !== "number") {
          throw new TypeError('"size" argument must be a number');
        }
        if (size < 0) {
          throw new RangeError('"size" argument must not be negative');
        }
        if (Buffer.allocUnsafe) {
          return Buffer.allocUnsafe(size);
        } else {
          return new Buffer(size);
        }
      }
      module.exports = allocUnsafe;
    }
  });

  // ../../node_modules/buffer-alloc/index.js
  var require_buffer_alloc = __commonJS({
    "../../node_modules/buffer-alloc/index.js"(exports, module) {
      var bufferFill = require_buffer_fill();
      var allocUnsafe = require_buffer_alloc_unsafe();
      module.exports = function alloc(size, fill, encoding) {
        if (typeof size !== "number") {
          throw new TypeError('"size" argument must be a number');
        }
        if (size < 0) {
          throw new RangeError('"size" argument must not be negative');
        }
        if (Buffer.alloc) {
          return Buffer.alloc(size, fill, encoding);
        }
        var buffer = allocUnsafe(size);
        if (size === 0) {
          return buffer;
        }
        if (fill === void 0) {
          return bufferFill(buffer, 0);
        }
        if (typeof encoding !== "string") {
          encoding = void 0;
        }
        return bufferFill(buffer, fill, encoding);
      };
    }
  });

  // ../../node_modules/tar-stream/headers.js
  var require_headers = __commonJS({
    "../../node_modules/tar-stream/headers.js"(exports) {
      var toBuffer = require_to_buffer();
      var alloc = require_buffer_alloc();
      var ZEROS = "0000000000000000000";
      var SEVENS = "7777777777777777777";
      var ZERO_OFFSET = "0".charCodeAt(0);
      var USTAR = "ustar\x0000";
      var MASK = parseInt("7777", 8);
      var clamp = function(index, len, defaultValue) {
        if (typeof index !== "number") return defaultValue;
        index = ~~index;
        if (index >= len) return len;
        if (index >= 0) return index;
        index += len;
        if (index >= 0) return index;
        return 0;
      };
      var toType = function(flag) {
        switch (flag) {
          case 0:
            return "file";
          case 1:
            return "link";
          case 2:
            return "symlink";
          case 3:
            return "character-device";
          case 4:
            return "block-device";
          case 5:
            return "directory";
          case 6:
            return "fifo";
          case 7:
            return "contiguous-file";
          case 72:
            return "pax-header";
          case 55:
            return "pax-global-header";
          case 27:
            return "gnu-long-link-path";
          case 28:
          case 30:
            return "gnu-long-path";
        }
        return null;
      };
      var toTypeflag = function(flag) {
        switch (flag) {
          case "file":
            return 0;
          case "link":
            return 1;
          case "symlink":
            return 2;
          case "character-device":
            return 3;
          case "block-device":
            return 4;
          case "directory":
            return 5;
          case "fifo":
            return 6;
          case "contiguous-file":
            return 7;
          case "pax-header":
            return 72;
        }
        return 0;
      };
      var indexOf = function(block, num, offset, end) {
        for (; offset < end; offset++) {
          if (block[offset] === num) return offset;
        }
        return end;
      };
      var cksum = function(block) {
        var sum = 8 * 32;
        for (var i = 0; i < 148; i++) sum += block[i];
        for (var j = 156; j < 512; j++) sum += block[j];
        return sum;
      };
      var encodeOct = function(val, n) {
        val = val.toString(8);
        if (val.length > n) return SEVENS.slice(0, n) + " ";
        else return ZEROS.slice(0, n - val.length) + val + " ";
      };
      function parse256(buf) {
        var positive;
        if (buf[0] === 128) positive = true;
        else if (buf[0] === 255) positive = false;
        else return null;
        var zero = false;
        var tuple = [];
        for (var i = buf.length - 1; i > 0; i--) {
          var byte = buf[i];
          if (positive) tuple.push(byte);
          else if (zero && byte === 0) tuple.push(0);
          else if (zero) {
            zero = false;
            tuple.push(256 - byte);
          } else tuple.push(255 - byte);
        }
        var sum = 0;
        var l = tuple.length;
        for (i = 0; i < l; i++) {
          sum += tuple[i] * Math.pow(256, i);
        }
        return positive ? sum : -1 * sum;
      }
      var decodeOct = function(val, offset, length) {
        val = val.slice(offset, offset + length);
        offset = 0;
        if (val[offset] & 128) {
          return parse256(val);
        } else {
          while (offset < val.length && val[offset] === 32) offset++;
          var end = clamp(indexOf(val, 32, offset, val.length), val.length, val.length);
          while (offset < end && val[offset] === 0) offset++;
          if (end === offset) return 0;
          return parseInt(val.slice(offset, end).toString(), 8);
        }
      };
      var decodeStr = function(val, offset, length, encoding) {
        return val.slice(offset, indexOf(val, 0, offset, offset + length)).toString(encoding);
      };
      var addLength = function(str) {
        var len = Buffer.byteLength(str);
        var digits = Math.floor(Math.log(len) / Math.log(10)) + 1;
        if (len + digits >= Math.pow(10, digits)) digits++;
        return len + digits + str;
      };
      exports.decodeLongPath = function(buf, encoding) {
        return decodeStr(buf, 0, buf.length, encoding);
      };
      exports.encodePax = function(opts) {
        var result = "";
        if (opts.name) result += addLength(" path=" + opts.name + "\n");
        if (opts.linkname) result += addLength(" linkpath=" + opts.linkname + "\n");
        var pax = opts.pax;
        if (pax) {
          for (var key in pax) {
            result += addLength(" " + key + "=" + pax[key] + "\n");
          }
        }
        return toBuffer(result);
      };
      exports.decodePax = function(buf) {
        var result = {};
        while (buf.length) {
          var i = 0;
          while (i < buf.length && buf[i] !== 32) i++;
          var len = parseInt(buf.slice(0, i).toString(), 10);
          if (!len) return result;
          var b = buf.slice(i + 1, len - 1).toString();
          var keyIndex = b.indexOf("=");
          if (keyIndex === -1) return result;
          result[b.slice(0, keyIndex)] = b.slice(keyIndex + 1);
          buf = buf.slice(len);
        }
        return result;
      };
      exports.encode = function(opts) {
        var buf = alloc(512);
        var name = opts.name;
        var prefix = "";
        if (opts.typeflag === 5 && name[name.length - 1] !== "/") name += "/";
        if (Buffer.byteLength(name) !== name.length) return null;
        while (Buffer.byteLength(name) > 100) {
          var i = name.indexOf("/");
          if (i === -1) return null;
          prefix += prefix ? "/" + name.slice(0, i) : name.slice(0, i);
          name = name.slice(i + 1);
        }
        if (Buffer.byteLength(name) > 100 || Buffer.byteLength(prefix) > 155) return null;
        if (opts.linkname && Buffer.byteLength(opts.linkname) > 100) return null;
        buf.write(name);
        buf.write(encodeOct(opts.mode & MASK, 6), 100);
        buf.write(encodeOct(opts.uid, 6), 108);
        buf.write(encodeOct(opts.gid, 6), 116);
        buf.write(encodeOct(opts.size, 11), 124);
        buf.write(encodeOct(opts.mtime.getTime() / 1e3 | 0, 11), 136);
        buf[156] = ZERO_OFFSET + toTypeflag(opts.type);
        if (opts.linkname) buf.write(opts.linkname, 157);
        buf.write(USTAR, 257);
        if (opts.uname) buf.write(opts.uname, 265);
        if (opts.gname) buf.write(opts.gname, 297);
        buf.write(encodeOct(opts.devmajor || 0, 6), 329);
        buf.write(encodeOct(opts.devminor || 0, 6), 337);
        if (prefix) buf.write(prefix, 345);
        buf.write(encodeOct(cksum(buf), 6), 148);
        return buf;
      };
      exports.decode = function(buf, filenameEncoding) {
        var typeflag = buf[156] === 0 ? 0 : buf[156] - ZERO_OFFSET;
        var name = decodeStr(buf, 0, 100, filenameEncoding);
        var mode = decodeOct(buf, 100, 8);
        var uid = decodeOct(buf, 108, 8);
        var gid = decodeOct(buf, 116, 8);
        var size = decodeOct(buf, 124, 12);
        var mtime = decodeOct(buf, 136, 12);
        var type = toType(typeflag);
        var linkname = buf[157] === 0 ? null : decodeStr(buf, 157, 100, filenameEncoding);
        var uname = decodeStr(buf, 265, 32);
        var gname = decodeStr(buf, 297, 32);
        var devmajor = decodeOct(buf, 329, 8);
        var devminor = decodeOct(buf, 337, 8);
        if (buf[345]) name = decodeStr(buf, 345, 155, filenameEncoding) + "/" + name;
        if (typeflag === 0 && name && name[name.length - 1] === "/") typeflag = 5;
        var c = cksum(buf);
        if (c === 8 * 32) return null;
        if (c !== decodeOct(buf, 148, 8)) throw new Error("Invalid tar header. Maybe the tar is corrupted or it needs to be gunzipped?");
        return {
          name,
          mode,
          uid,
          gid,
          size,
          mtime: new Date(1e3 * mtime),
          type,
          linkname,
          uname,
          gname,
          devmajor,
          devminor
        };
      };
    }
  });

  // ../../node_modules/tar-stream/node_modules/isarray/index.js
  var require_isarray3 = __commonJS({
    "../../node_modules/tar-stream/node_modules/isarray/index.js"(exports, module) {
      var toString = {}.toString;
      module.exports = Array.isArray || function(arr) {
        return toString.call(arr) == "[object Array]";
      };
    }
  });

  // ../../node_modules/tar-stream/node_modules/readable-stream/lib/internal/streams/stream.js
  var require_stream2 = __commonJS({
    "../../node_modules/tar-stream/node_modules/readable-stream/lib/internal/streams/stream.js"(exports, module) {
      module.exports = __require("stream");
    }
  });

  // ../../node_modules/tar-stream/node_modules/safe-buffer/index.js
  var require_safe_buffer3 = __commonJS({
    "../../node_modules/tar-stream/node_modules/safe-buffer/index.js"(exports, module) {
      var buffer = __require("buffer");
      var Buffer2 = buffer.Buffer;
      function copyProps(src, dst) {
        for (var key in src) {
          dst[key] = src[key];
        }
      }
      if (Buffer2.from && Buffer2.alloc && Buffer2.allocUnsafe && Buffer2.allocUnsafeSlow) {
        module.exports = buffer;
      } else {
        copyProps(buffer, exports);
        exports.Buffer = SafeBuffer;
      }
      function SafeBuffer(arg, encodingOrOffset, length) {
        return Buffer2(arg, encodingOrOffset, length);
      }
      copyProps(Buffer2, SafeBuffer);
      SafeBuffer.from = function(arg, encodingOrOffset, length) {
        if (typeof arg === "number") {
          throw new TypeError("Argument must not be a number");
        }
        return Buffer2(arg, encodingOrOffset, length);
      };
      SafeBuffer.alloc = function(size, fill, encoding) {
        if (typeof size !== "number") {
          throw new TypeError("Argument must be a number");
        }
        var buf = Buffer2(size);
        if (fill !== void 0) {
          if (typeof encoding === "string") {
            buf.fill(fill, encoding);
          } else {
            buf.fill(fill);
          }
        } else {
          buf.fill(0);
        }
        return buf;
      };
      SafeBuffer.allocUnsafe = function(size) {
        if (typeof size !== "number") {
          throw new TypeError("Argument must be a number");
        }
        return Buffer2(size);
      };
      SafeBuffer.allocUnsafeSlow = function(size) {
        if (typeof size !== "number") {
          throw new TypeError("Argument must be a number");
        }
        return buffer.SlowBuffer(size);
      };
    }
  });

  // ../../node_modules/tar-stream/node_modules/readable-stream/lib/internal/streams/BufferList.js
  var require_BufferList2 = __commonJS({
    "../../node_modules/tar-stream/node_modules/readable-stream/lib/internal/streams/BufferList.js"(exports, module) {
      "use strict";
      function _classCallCheck(instance, Constructor) {
        if (!(instance instanceof Constructor)) {
          throw new TypeError("Cannot call a class as a function");
        }
      }
      var Buffer2 = require_safe_buffer3().Buffer;
      var util = __require("util");
      function copyBuffer(src, target, offset) {
        src.copy(target, offset);
      }
      module.exports = (function() {
        function BufferList() {
          _classCallCheck(this, BufferList);
          this.head = null;
          this.tail = null;
          this.length = 0;
        }
        BufferList.prototype.push = function push(v) {
          var entry = { data: v, next: null };
          if (this.length > 0) this.tail.next = entry;
          else this.head = entry;
          this.tail = entry;
          ++this.length;
        };
        BufferList.prototype.unshift = function unshift(v) {
          var entry = { data: v, next: this.head };
          if (this.length === 0) this.tail = entry;
          this.head = entry;
          ++this.length;
        };
        BufferList.prototype.shift = function shift() {
          if (this.length === 0) return;
          var ret = this.head.data;
          if (this.length === 1) this.head = this.tail = null;
          else this.head = this.head.next;
          --this.length;
          return ret;
        };
        BufferList.prototype.clear = function clear() {
          this.head = this.tail = null;
          this.length = 0;
        };
        BufferList.prototype.join = function join(s) {
          if (this.length === 0) return "";
          var p = this.head;
          var ret = "" + p.data;
          while (p = p.next) {
            ret += s + p.data;
          }
          return ret;
        };
        BufferList.prototype.concat = function concat(n) {
          if (this.length === 0) return Buffer2.alloc(0);
          var ret = Buffer2.allocUnsafe(n >>> 0);
          var p = this.head;
          var i = 0;
          while (p) {
            copyBuffer(p.data, ret, i);
            i += p.data.length;
            p = p.next;
          }
          return ret;
        };
        return BufferList;
      })();
      if (util && util.inspect && util.inspect.custom) {
        module.exports.prototype[util.inspect.custom] = function() {
          var obj = util.inspect({ length: this.length });
          return this.constructor.name + " " + obj;
        };
      }
    }
  });

  // ../../node_modules/tar-stream/node_modules/readable-stream/lib/internal/streams/destroy.js
  var require_destroy2 = __commonJS({
    "../../node_modules/tar-stream/node_modules/readable-stream/lib/internal/streams/destroy.js"(exports, module) {
      "use strict";
      var pna = require_process_nextick_args();
      function destroy(err, cb) {
        var _this = this;
        var readableDestroyed = this._readableState && this._readableState.destroyed;
        var writableDestroyed = this._writableState && this._writableState.destroyed;
        if (readableDestroyed || writableDestroyed) {
          if (cb) {
            cb(err);
          } else if (err) {
            if (!this._writableState) {
              pna.nextTick(emitErrorNT, this, err);
            } else if (!this._writableState.errorEmitted) {
              this._writableState.errorEmitted = true;
              pna.nextTick(emitErrorNT, this, err);
            }
          }
          return this;
        }
        if (this._readableState) {
          this._readableState.destroyed = true;
        }
        if (this._writableState) {
          this._writableState.destroyed = true;
        }
        this._destroy(err || null, function(err2) {
          if (!cb && err2) {
            if (!_this._writableState) {
              pna.nextTick(emitErrorNT, _this, err2);
            } else if (!_this._writableState.errorEmitted) {
              _this._writableState.errorEmitted = true;
              pna.nextTick(emitErrorNT, _this, err2);
            }
          } else if (cb) {
            cb(err2);
          }
        });
        return this;
      }
      function undestroy() {
        if (this._readableState) {
          this._readableState.destroyed = false;
          this._readableState.reading = false;
          this._readableState.ended = false;
          this._readableState.endEmitted = false;
        }
        if (this._writableState) {
          this._writableState.destroyed = false;
          this._writableState.ended = false;
          this._writableState.ending = false;
          this._writableState.finalCalled = false;
          this._writableState.prefinished = false;
          this._writableState.finished = false;
          this._writableState.errorEmitted = false;
        }
      }
      function emitErrorNT(self2, err) {
        self2.emit("error", err);
      }
      module.exports = {
        destroy,
        undestroy
      };
    }
  });

  // ../../node_modules/tar-stream/node_modules/readable-stream/lib/_stream_writable.js
  var require_stream_writable2 = __commonJS({
    "../../node_modules/tar-stream/node_modules/readable-stream/lib/_stream_writable.js"(exports, module) {
      "use strict";
      var pna = require_process_nextick_args();
      module.exports = Writable;
      function CorkedRequest(state) {
        var _this = this;
        this.next = null;
        this.entry = null;
        this.finish = function() {
          onCorkedFinish(_this, state);
        };
      }
      var asyncWrite = !process.browser && ["v0.10", "v0.9."].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : pna.nextTick;
      var Duplex;
      Writable.WritableState = WritableState;
      var util = Object.create(require_util());
      util.inherits = require_inherits();
      var internalUtil = {
        deprecate: require_node()
      };
      var Stream = require_stream2();
      var Buffer2 = require_safe_buffer3().Buffer;
      var OurUint8Array = (typeof global !== "undefined" ? global : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : {}).Uint8Array || function() {
      };
      function _uint8ArrayToBuffer(chunk) {
        return Buffer2.from(chunk);
      }
      function _isUint8Array(obj) {
        return Buffer2.isBuffer(obj) || obj instanceof OurUint8Array;
      }
      var destroyImpl = require_destroy2();
      util.inherits(Writable, Stream);
      function nop() {
      }
      function WritableState(options, stream) {
        Duplex = Duplex || require_stream_duplex2();
        options = options || {};
        var isDuplex = stream instanceof Duplex;
        this.objectMode = !!options.objectMode;
        if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode;
        var hwm = options.highWaterMark;
        var writableHwm = options.writableHighWaterMark;
        var defaultHwm = this.objectMode ? 16 : 16 * 1024;
        if (hwm || hwm === 0) this.highWaterMark = hwm;
        else if (isDuplex && (writableHwm || writableHwm === 0)) this.highWaterMark = writableHwm;
        else this.highWaterMark = defaultHwm;
        this.highWaterMark = Math.floor(this.highWaterMark);
        this.finalCalled = false;
        this.needDrain = false;
        this.ending = false;
        this.ended = false;
        this.finished = false;
        this.destroyed = false;
        var noDecode = options.decodeStrings === false;
        this.decodeStrings = !noDecode;
        this.defaultEncoding = options.defaultEncoding || "utf8";
        this.length = 0;
        this.writing = false;
        this.corked = 0;
        this.sync = true;
        this.bufferProcessing = false;
        this.onwrite = function(er) {
          onwrite(stream, er);
        };
        this.writecb = null;
        this.writelen = 0;
        this.bufferedRequest = null;
        this.lastBufferedRequest = null;
        this.pendingcb = 0;
        this.prefinished = false;
        this.errorEmitted = false;
        this.bufferedRequestCount = 0;
        this.corkedRequestsFree = new CorkedRequest(this);
      }
      WritableState.prototype.getBuffer = function getBuffer() {
        var current = this.bufferedRequest;
        var out = [];
        while (current) {
          out.push(current);
          current = current.next;
        }
        return out;
      };
      (function() {
        try {
          Object.defineProperty(WritableState.prototype, "buffer", {
            get: internalUtil.deprecate(function() {
              return this.getBuffer();
            }, "_writableState.buffer is deprecated. Use _writableState.getBuffer instead.", "DEP0003")
          });
        } catch (_) {
        }
      })();
      var realHasInstance;
      if (typeof Symbol === "function" && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === "function") {
        realHasInstance = Function.prototype[Symbol.hasInstance];
        Object.defineProperty(Writable, Symbol.hasInstance, {
          value: function(object) {
            if (realHasInstance.call(this, object)) return true;
            if (this !== Writable) return false;
            return object && object._writableState instanceof WritableState;
          }
        });
      } else {
        realHasInstance = function(object) {
          return object instanceof this;
        };
      }
      function Writable(options) {
        Duplex = Duplex || require_stream_duplex2();
        if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) {
          return new Writable(options);
        }
        this._writableState = new WritableState(options, this);
        this.writable = true;
        if (options) {
          if (typeof options.write === "function") this._write = options.write;
          if (typeof options.writev === "function") this._writev = options.writev;
          if (typeof options.destroy === "function") this._destroy = options.destroy;
          if (typeof options.final === "function") this._final = options.final;
        }
        Stream.call(this);
      }
      Writable.prototype.pipe = function() {
        this.emit("error", new Error("Cannot pipe, not readable"));
      };
      function writeAfterEnd(stream, cb) {
        var er = new Error("write after end");
        stream.emit("error", er);
        pna.nextTick(cb, er);
      }
      function validChunk(stream, state, chunk, cb) {
        var valid = true;
        var er = false;
        if (chunk === null) {
          er = new TypeError("May not write null values to stream");
        } else if (typeof chunk !== "string" && chunk !== void 0 && !state.objectMode) {
          er = new TypeError("Invalid non-string/buffer chunk");
        }
        if (er) {
          stream.emit("error", er);
          pna.nextTick(cb, er);
          valid = false;
        }
        return valid;
      }
      Writable.prototype.write = function(chunk, encoding, cb) {
        var state = this._writableState;
        var ret = false;
        var isBuf = !state.objectMode && _isUint8Array(chunk);
        if (isBuf && !Buffer2.isBuffer(chunk)) {
          chunk = _uint8ArrayToBuffer(chunk);
        }
        if (typeof encoding === "function") {
          cb = encoding;
          encoding = null;
        }
        if (isBuf) encoding = "buffer";
        else if (!encoding) encoding = state.defaultEncoding;
        if (typeof cb !== "function") cb = nop;
        if (state.ended) writeAfterEnd(this, cb);
        else if (isBuf || validChunk(this, state, chunk, cb)) {
          state.pendingcb++;
          ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);
        }
        return ret;
      };
      Writable.prototype.cork = function() {
        var state = this._writableState;
        state.corked++;
      };
      Writable.prototype.uncork = function() {
        var state = this._writableState;
        if (state.corked) {
          state.corked--;
          if (!state.writing && !state.corked && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);
        }
      };
      Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
        if (typeof encoding === "string") encoding = encoding.toLowerCase();
        if (!(["hex", "utf8", "utf-8", "ascii", "binary", "base64", "ucs2", "ucs-2", "utf16le", "utf-16le", "raw"].indexOf((encoding + "").toLowerCase()) > -1)) throw new TypeError("Unknown encoding: " + encoding);
        this._writableState.defaultEncoding = encoding;
        return this;
      };
      function decodeChunk(state, chunk, encoding) {
        if (!state.objectMode && state.decodeStrings !== false && typeof chunk === "string") {
          chunk = Buffer2.from(chunk, encoding);
        }
        return chunk;
      }
      Object.defineProperty(Writable.prototype, "writableHighWaterMark", {
        // making it explicit this property is not enumerable
        // because otherwise some prototype manipulation in
        // userland will fail
        enumerable: false,
        get: function() {
          return this._writableState.highWaterMark;
        }
      });
      function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {
        if (!isBuf) {
          var newChunk = decodeChunk(state, chunk, encoding);
          if (chunk !== newChunk) {
            isBuf = true;
            encoding = "buffer";
            chunk = newChunk;
          }
        }
        var len = state.objectMode ? 1 : chunk.length;
        state.length += len;
        var ret = state.length < state.highWaterMark;
        if (!ret) state.needDrain = true;
        if (state.writing || state.corked) {
          var last = state.lastBufferedRequest;
          state.lastBufferedRequest = {
            chunk,
            encoding,
            isBuf,
            callback: cb,
            next: null
          };
          if (last) {
            last.next = state.lastBufferedRequest;
          } else {
            state.bufferedRequest = state.lastBufferedRequest;
          }
          state.bufferedRequestCount += 1;
        } else {
          doWrite(stream, state, false, len, chunk, encoding, cb);
        }
        return ret;
      }
      function doWrite(stream, state, writev, len, chunk, encoding, cb) {
        state.writelen = len;
        state.writecb = cb;
        state.writing = true;
        state.sync = true;
        if (writev) stream._writev(chunk, state.onwrite);
        else stream._write(chunk, encoding, state.onwrite);
        state.sync = false;
      }
      function onwriteError(stream, state, sync, er, cb) {
        --state.pendingcb;
        if (sync) {
          pna.nextTick(cb, er);
          pna.nextTick(finishMaybe, stream, state);
          stream._writableState.errorEmitted = true;
          stream.emit("error", er);
        } else {
          cb(er);
          stream._writableState.errorEmitted = true;
          stream.emit("error", er);
          finishMaybe(stream, state);
        }
      }
      function onwriteStateUpdate(state) {
        state.writing = false;
        state.writecb = null;
        state.length -= state.writelen;
        state.writelen = 0;
      }
      function onwrite(stream, er) {
        var state = stream._writableState;
        var sync = state.sync;
        var cb = state.writecb;
        onwriteStateUpdate(state);
        if (er) onwriteError(stream, state, sync, er, cb);
        else {
          var finished = needFinish(state);
          if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {
            clearBuffer(stream, state);
          }
          if (sync) {
            asyncWrite(afterWrite, stream, state, finished, cb);
          } else {
            afterWrite(stream, state, finished, cb);
          }
        }
      }
      function afterWrite(stream, state, finished, cb) {
        if (!finished) onwriteDrain(stream, state);
        state.pendingcb--;
        cb();
        finishMaybe(stream, state);
      }
      function onwriteDrain(stream, state) {
        if (state.length === 0 && state.needDrain) {
          state.needDrain = false;
          stream.emit("drain");
        }
      }
      function clearBuffer(stream, state) {
        state.bufferProcessing = true;
        var entry = state.bufferedRequest;
        if (stream._writev && entry && entry.next) {
          var l = state.bufferedRequestCount;
          var buffer = new Array(l);
          var holder = state.corkedRequestsFree;
          holder.entry = entry;
          var count = 0;
          var allBuffers = true;
          while (entry) {
            buffer[count] = entry;
            if (!entry.isBuf) allBuffers = false;
            entry = entry.next;
            count += 1;
          }
          buffer.allBuffers = allBuffers;
          doWrite(stream, state, true, state.length, buffer, "", holder.finish);
          state.pendingcb++;
          state.lastBufferedRequest = null;
          if (holder.next) {
            state.corkedRequestsFree = holder.next;
            holder.next = null;
          } else {
            state.corkedRequestsFree = new CorkedRequest(state);
          }
          state.bufferedRequestCount = 0;
        } else {
          while (entry) {
            var chunk = entry.chunk;
            var encoding = entry.encoding;
            var cb = entry.callback;
            var len = state.objectMode ? 1 : chunk.length;
            doWrite(stream, state, false, len, chunk, encoding, cb);
            entry = entry.next;
            state.bufferedRequestCount--;
            if (state.writing) {
              break;
            }
          }
          if (entry === null) state.lastBufferedRequest = null;
        }
        state.bufferedRequest = entry;
        state.bufferProcessing = false;
      }
      Writable.prototype._write = function(chunk, encoding, cb) {
        cb(new Error("_write() is not overridden in subclass"));
      };
      Writable.prototype._writev = null;
      Writable.prototype.end = function(chunk, encoding, cb) {
        var state = this._writableState;
        if (typeof chunk === "function") {
          cb = chunk;
          chunk = null;
          encoding = null;
        } else if (typeof encoding === "function") {
          cb = encoding;
          encoding = null;
        }
        if (chunk !== null && chunk !== void 0) this.write(chunk, encoding);
        if (state.corked) {
          state.corked = 1;
          this.uncork();
        }
        if (!state.ending) endWritable(this, state, cb);
      };
      function needFinish(state) {
        return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;
      }
      function callFinal(stream, state) {
        stream._final(function(err) {
          state.pendingcb--;
          if (err) {
            stream.emit("error", err);
          }
          state.prefinished = true;
          stream.emit("prefinish");
          finishMaybe(stream, state);
        });
      }
      function prefinish(stream, state) {
        if (!state.prefinished && !state.finalCalled) {
          if (typeof stream._final === "function") {
            state.pendingcb++;
            state.finalCalled = true;
            pna.nextTick(callFinal, stream, state);
          } else {
            state.prefinished = true;
            stream.emit("prefinish");
          }
        }
      }
      function finishMaybe(stream, state) {
        var need = needFinish(state);
        if (need) {
          prefinish(stream, state);
          if (state.pendingcb === 0) {
            state.finished = true;
            stream.emit("finish");
          }
        }
        return need;
      }
      function endWritable(stream, state, cb) {
        state.ending = true;
        finishMaybe(stream, state);
        if (cb) {
          if (state.finished) pna.nextTick(cb);
          else stream.once("finish", cb);
        }
        state.ended = true;
        stream.writable = false;
      }
      function onCorkedFinish(corkReq, state, err) {
        var entry = corkReq.entry;
        corkReq.entry = null;
        while (entry) {
          var cb = entry.callback;
          state.pendingcb--;
          cb(err);
          entry = entry.next;
        }
        state.corkedRequestsFree.next = corkReq;
      }
      Object.defineProperty(Writable.prototype, "destroyed", {
        get: function() {
          if (this._writableState === void 0) {
            return false;
          }
          return this._writableState.destroyed;
        },
        set: function(value) {
          if (!this._writableState) {
            return;
          }
          this._writableState.destroyed = value;
        }
      });
      Writable.prototype.destroy = destroyImpl.destroy;
      Writable.prototype._undestroy = destroyImpl.undestroy;
      Writable.prototype._destroy = function(err, cb) {
        this.end();
        cb(err);
      };
    }
  });

  // ../../node_modules/tar-stream/node_modules/readable-stream/lib/_stream_duplex.js
  var require_stream_duplex2 = __commonJS({
    "../../node_modules/tar-stream/node_modules/readable-stream/lib/_stream_duplex.js"(exports, module) {
      "use strict";
      var pna = require_process_nextick_args();
      var objectKeys = Object.keys || function(obj) {
        var keys2 = [];
        for (var key in obj) {
          keys2.push(key);
        }
        return keys2;
      };
      module.exports = Duplex;
      var util = Object.create(require_util());
      util.inherits = require_inherits();
      var Readable = require_stream_readable2();
      var Writable = require_stream_writable2();
      util.inherits(Duplex, Readable);
      {
        keys = objectKeys(Writable.prototype);
        for (v = 0; v < keys.length; v++) {
          method = keys[v];
          if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];
        }
      }
      var keys;
      var method;
      var v;
      function Duplex(options) {
        if (!(this instanceof Duplex)) return new Duplex(options);
        Readable.call(this, options);
        Writable.call(this, options);
        if (options && options.readable === false) this.readable = false;
        if (options && options.writable === false) this.writable = false;
        this.allowHalfOpen = true;
        if (options && options.allowHalfOpen === false) this.allowHalfOpen = false;
        this.once("end", onend);
      }
      Object.defineProperty(Duplex.prototype, "writableHighWaterMark", {
        // making it explicit this property is not enumerable
        // because otherwise some prototype manipulation in
        // userland will fail
        enumerable: false,
        get: function() {
          return this._writableState.highWaterMark;
        }
      });
      function onend() {
        if (this.allowHalfOpen || this._writableState.ended) return;
        pna.nextTick(onEndNT, this);
      }
      function onEndNT(self2) {
        self2.end();
      }
      Object.defineProperty(Duplex.prototype, "destroyed", {
        get: function() {
          if (this._readableState === void 0 || this._writableState === void 0) {
            return false;
          }
          return this._readableState.destroyed && this._writableState.destroyed;
        },
        set: function(value) {
          if (this._readableState === void 0 || this._writableState === void 0) {
            return;
          }
          this._readableState.destroyed = value;
          this._writableState.destroyed = value;
        }
      });
      Duplex.prototype._destroy = function(err, cb) {
        this.push(null);
        this.end();
        pna.nextTick(cb, err);
      };
    }
  });

  // ../../node_modules/tar-stream/node_modules/string_decoder/lib/string_decoder.js
  var require_string_decoder2 = __commonJS({
    "../../node_modules/tar-stream/node_modules/string_decoder/lib/string_decoder.js"(exports) {
      "use strict";
      var Buffer2 = require_safe_buffer3().Buffer;
      var isEncoding = Buffer2.isEncoding || function(encoding) {
        encoding = "" + encoding;
        switch (encoding && encoding.toLowerCase()) {
          case "hex":
          case "utf8":
          case "utf-8":
          case "ascii":
          case "binary":
          case "base64":
          case "ucs2":
          case "ucs-2":
          case "utf16le":
          case "utf-16le":
          case "raw":
            return true;
          default:
            return false;
        }
      };
      function _normalizeEncoding(enc) {
        if (!enc) return "utf8";
        var retried;
        while (true) {
          switch (enc) {
            case "utf8":
            case "utf-8":
              return "utf8";
            case "ucs2":
            case "ucs-2":
            case "utf16le":
            case "utf-16le":
              return "utf16le";
            case "latin1":
            case "binary":
              return "latin1";
            case "base64":
            case "ascii":
            case "hex":
              return enc;
            default:
              if (retried) return;
              enc = ("" + enc).toLowerCase();
              retried = true;
          }
        }
      }
      function normalizeEncoding(enc) {
        var nenc = _normalizeEncoding(enc);
        if (typeof nenc !== "string" && (Buffer2.isEncoding === isEncoding || !isEncoding(enc))) throw new Error("Unknown encoding: " + enc);
        return nenc || enc;
      }
      exports.StringDecoder = StringDecoder;
      function StringDecoder(encoding) {
        this.encoding = normalizeEncoding(encoding);
        var nb;
        switch (this.encoding) {
          case "utf16le":
            this.text = utf16Text;
            this.end = utf16End;
            nb = 4;
            break;
          case "utf8":
            this.fillLast = utf8FillLast;
            nb = 4;
            break;
          case "base64":
            this.text = base64Text;
            this.end = base64End;
            nb = 3;
            break;
          default:
            this.write = simpleWrite;
            this.end = simpleEnd;
            return;
        }
        this.lastNeed = 0;
        this.lastTotal = 0;
        this.lastChar = Buffer2.allocUnsafe(nb);
      }
      StringDecoder.prototype.write = function(buf) {
        if (buf.length === 0) return "";
        var r;
        var i;
        if (this.lastNeed) {
          r = this.fillLast(buf);
          if (r === void 0) return "";
          i = this.lastNeed;
          this.lastNeed = 0;
        } else {
          i = 0;
        }
        if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);
        return r || "";
      };
      StringDecoder.prototype.end = utf8End;
      StringDecoder.prototype.text = utf8Text;
      StringDecoder.prototype.fillLast = function(buf) {
        if (this.lastNeed <= buf.length) {
          buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);
          return this.lastChar.toString(this.encoding, 0, this.lastTotal);
        }
        buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);
        this.lastNeed -= buf.length;
      };
      function utf8CheckByte(byte) {
        if (byte <= 127) return 0;
        else if (byte >> 5 === 6) return 2;
        else if (byte >> 4 === 14) return 3;
        else if (byte >> 3 === 30) return 4;
        return byte >> 6 === 2 ? -1 : -2;
      }
      function utf8CheckIncomplete(self2, buf, i) {
        var j = buf.length - 1;
        if (j < i) return 0;
        var nb = utf8CheckByte(buf[j]);
        if (nb >= 0) {
          if (nb > 0) self2.lastNeed = nb - 1;
          return nb;
        }
        if (--j < i || nb === -2) return 0;
        nb = utf8CheckByte(buf[j]);
        if (nb >= 0) {
          if (nb > 0) self2.lastNeed = nb - 2;
          return nb;
        }
        if (--j < i || nb === -2) return 0;
        nb = utf8CheckByte(buf[j]);
        if (nb >= 0) {
          if (nb > 0) {
            if (nb === 2) nb = 0;
            else self2.lastNeed = nb - 3;
          }
          return nb;
        }
        return 0;
      }
      function utf8CheckExtraBytes(self2, buf, p) {
        if ((buf[0] & 192) !== 128) {
          self2.lastNeed = 0;
          return "\uFFFD";
        }
        if (self2.lastNeed > 1 && buf.length > 1) {
          if ((buf[1] & 192) !== 128) {
            self2.lastNeed = 1;
            return "\uFFFD";
          }
          if (self2.lastNeed > 2 && buf.length > 2) {
            if ((buf[2] & 192) !== 128) {
              self2.lastNeed = 2;
              return "\uFFFD";
            }
          }
        }
      }
      function utf8FillLast(buf) {
        var p = this.lastTotal - this.lastNeed;
        var r = utf8CheckExtraBytes(this, buf, p);
        if (r !== void 0) return r;
        if (this.lastNeed <= buf.length) {
          buf.copy(this.lastChar, p, 0, this.lastNeed);
          return this.lastChar.toString(this.encoding, 0, this.lastTotal);
        }
        buf.copy(this.lastChar, p, 0, buf.length);
        this.lastNeed -= buf.length;
      }
      function utf8Text(buf, i) {
        var total = utf8CheckIncomplete(this, buf, i);
        if (!this.lastNeed) return buf.toString("utf8", i);
        this.lastTotal = total;
        var end = buf.length - (total - this.lastNeed);
        buf.copy(this.lastChar, 0, end);
        return buf.toString("utf8", i, end);
      }
      function utf8End(buf) {
        var r = buf && buf.length ? this.write(buf) : "";
        if (this.lastNeed) return r + "\uFFFD";
        return r;
      }
      function utf16Text(buf, i) {
        if ((buf.length - i) % 2 === 0) {
          var r = buf.toString("utf16le", i);
          if (r) {
            var c = r.charCodeAt(r.length - 1);
            if (c >= 55296 && c <= 56319) {
              this.lastNeed = 2;
              this.lastTotal = 4;
              this.lastChar[0] = buf[buf.length - 2];
              this.lastChar[1] = buf[buf.length - 1];
              return r.slice(0, -1);
            }
          }
          return r;
        }
        this.lastNeed = 1;
        this.lastTotal = 2;
        this.lastChar[0] = buf[buf.length - 1];
        return buf.toString("utf16le", i, buf.length - 1);
      }
      function utf16End(buf) {
        var r = buf && buf.length ? this.write(buf) : "";
        if (this.lastNeed) {
          var end = this.lastTotal - this.lastNeed;
          return r + this.lastChar.toString("utf16le", 0, end);
        }
        return r;
      }
      function base64Text(buf, i) {
        var n = (buf.length - i) % 3;
        if (n === 0) return buf.toString("base64", i);
        this.lastNeed = 3 - n;
        this.lastTotal = 3;
        if (n === 1) {
          this.lastChar[0] = buf[buf.length - 1];
        } else {
          this.lastChar[0] = buf[buf.length - 2];
          this.lastChar[1] = buf[buf.length - 1];
        }
        return buf.toString("base64", i, buf.length - n);
      }
      function base64End(buf) {
        var r = buf && buf.length ? this.write(buf) : "";
        if (this.lastNeed) return r + this.lastChar.toString("base64", 0, 3 - this.lastNeed);
        return r;
      }
      function simpleWrite(buf) {
        return buf.toString(this.encoding);
      }
      function simpleEnd(buf) {
        return buf && buf.length ? this.write(buf) : "";
      }
    }
  });

  // ../../node_modules/tar-stream/node_modules/readable-stream/lib/_stream_readable.js
  var require_stream_readable2 = __commonJS({
    "../../node_modules/tar-stream/node_modules/readable-stream/lib/_stream_readable.js"(exports, module) {
      "use strict";
      var pna = require_process_nextick_args();
      module.exports = Readable;
      var isArray = require_isarray3();
      var Duplex;
      Readable.ReadableState = ReadableState;
      var EE = require_bare_node_events().EventEmitter;
      var EElistenerCount = function(emitter, type) {
        return emitter.listeners(type).length;
      };
      var Stream = require_stream2();
      var Buffer2 = require_safe_buffer3().Buffer;
      var OurUint8Array = (typeof global !== "undefined" ? global : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : {}).Uint8Array || function() {
      };
      function _uint8ArrayToBuffer(chunk) {
        return Buffer2.from(chunk);
      }
      function _isUint8Array(obj) {
        return Buffer2.isBuffer(obj) || obj instanceof OurUint8Array;
      }
      var util = Object.create(require_util());
      util.inherits = require_inherits();
      var debugUtil = __require("util");
      var debug = void 0;
      if (debugUtil && debugUtil.debuglog) {
        debug = debugUtil.debuglog("stream");
      } else {
        debug = function() {
        };
      }
      var BufferList = require_BufferList2();
      var destroyImpl = require_destroy2();
      var StringDecoder;
      util.inherits(Readable, Stream);
      var kProxyEvents = ["error", "close", "destroy", "pause", "resume"];
      function prependListener(emitter, event, fn) {
        if (typeof emitter.prependListener === "function") return emitter.prependListener(event, fn);
        if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);
        else if (isArray(emitter._events[event])) emitter._events[event].unshift(fn);
        else emitter._events[event] = [fn, emitter._events[event]];
      }
      function ReadableState(options, stream) {
        Duplex = Duplex || require_stream_duplex2();
        options = options || {};
        var isDuplex = stream instanceof Duplex;
        this.objectMode = !!options.objectMode;
        if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode;
        var hwm = options.highWaterMark;
        var readableHwm = options.readableHighWaterMark;
        var defaultHwm = this.objectMode ? 16 : 16 * 1024;
        if (hwm || hwm === 0) this.highWaterMark = hwm;
        else if (isDuplex && (readableHwm || readableHwm === 0)) this.highWaterMark = readableHwm;
        else this.highWaterMark = defaultHwm;
        this.highWaterMark = Math.floor(this.highWaterMark);
        this.buffer = new BufferList();
        this.length = 0;
        this.pipes = null;
        this.pipesCount = 0;
        this.flowing = null;
        this.ended = false;
        this.endEmitted = false;
        this.reading = false;
        this.sync = true;
        this.needReadable = false;
        this.emittedReadable = false;
        this.readableListening = false;
        this.resumeScheduled = false;
        this.destroyed = false;
        this.defaultEncoding = options.defaultEncoding || "utf8";
        this.awaitDrain = 0;
        this.readingMore = false;
        this.decoder = null;
        this.encoding = null;
        if (options.encoding) {
          if (!StringDecoder) StringDecoder = require_string_decoder2().StringDecoder;
          this.decoder = new StringDecoder(options.encoding);
          this.encoding = options.encoding;
        }
      }
      function Readable(options) {
        Duplex = Duplex || require_stream_duplex2();
        if (!(this instanceof Readable)) return new Readable(options);
        this._readableState = new ReadableState(options, this);
        this.readable = true;
        if (options) {
          if (typeof options.read === "function") this._read = options.read;
          if (typeof options.destroy === "function") this._destroy = options.destroy;
        }
        Stream.call(this);
      }
      Object.defineProperty(Readable.prototype, "destroyed", {
        get: function() {
          if (this._readableState === void 0) {
            return false;
          }
          return this._readableState.destroyed;
        },
        set: function(value) {
          if (!this._readableState) {
            return;
          }
          this._readableState.destroyed = value;
        }
      });
      Readable.prototype.destroy = destroyImpl.destroy;
      Readable.prototype._undestroy = destroyImpl.undestroy;
      Readable.prototype._destroy = function(err, cb) {
        this.push(null);
        cb(err);
      };
      Readable.prototype.push = function(chunk, encoding) {
        var state = this._readableState;
        var skipChunkCheck;
        if (!state.objectMode) {
          if (typeof chunk === "string") {
            encoding = encoding || state.defaultEncoding;
            if (encoding !== state.encoding) {
              chunk = Buffer2.from(chunk, encoding);
              encoding = "";
            }
            skipChunkCheck = true;
          }
        } else {
          skipChunkCheck = true;
        }
        return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);
      };
      Readable.prototype.unshift = function(chunk) {
        return readableAddChunk(this, chunk, null, true, false);
      };
      function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {
        var state = stream._readableState;
        if (chunk === null) {
          state.reading = false;
          onEofChunk(stream, state);
        } else {
          var er;
          if (!skipChunkCheck) er = chunkInvalid(state, chunk);
          if (er) {
            stream.emit("error", er);
          } else if (state.objectMode || chunk && chunk.length > 0) {
            if (typeof chunk !== "string" && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer2.prototype) {
              chunk = _uint8ArrayToBuffer(chunk);
            }
            if (addToFront) {
              if (state.endEmitted) stream.emit("error", new Error("stream.unshift() after end event"));
              else addChunk(stream, state, chunk, true);
            } else if (state.ended) {
              stream.emit("error", new Error("stream.push() after EOF"));
            } else {
              state.reading = false;
              if (state.decoder && !encoding) {
                chunk = state.decoder.write(chunk);
                if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);
                else maybeReadMore(stream, state);
              } else {
                addChunk(stream, state, chunk, false);
              }
            }
          } else if (!addToFront) {
            state.reading = false;
          }
        }
        return needMoreData(state);
      }
      function addChunk(stream, state, chunk, addToFront) {
        if (state.flowing && state.length === 0 && !state.sync) {
          stream.emit("data", chunk);
          stream.read(0);
        } else {
          state.length += state.objectMode ? 1 : chunk.length;
          if (addToFront) state.buffer.unshift(chunk);
          else state.buffer.push(chunk);
          if (state.needReadable) emitReadable(stream);
        }
        maybeReadMore(stream, state);
      }
      function chunkInvalid(state, chunk) {
        var er;
        if (!_isUint8Array(chunk) && typeof chunk !== "string" && chunk !== void 0 && !state.objectMode) {
          er = new TypeError("Invalid non-string/buffer chunk");
        }
        return er;
      }
      function needMoreData(state) {
        return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);
      }
      Readable.prototype.isPaused = function() {
        return this._readableState.flowing === false;
      };
      Readable.prototype.setEncoding = function(enc) {
        if (!StringDecoder) StringDecoder = require_string_decoder2().StringDecoder;
        this._readableState.decoder = new StringDecoder(enc);
        this._readableState.encoding = enc;
        return this;
      };
      var MAX_HWM = 8388608;
      function computeNewHighWaterMark(n) {
        if (n >= MAX_HWM) {
          n = MAX_HWM;
        } else {
          n--;
          n |= n >>> 1;
          n |= n >>> 2;
          n |= n >>> 4;
          n |= n >>> 8;
          n |= n >>> 16;
          n++;
        }
        return n;
      }
      function howMuchToRead(n, state) {
        if (n <= 0 || state.length === 0 && state.ended) return 0;
        if (state.objectMode) return 1;
        if (n !== n) {
          if (state.flowing && state.length) return state.buffer.head.data.length;
          else return state.length;
        }
        if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);
        if (n <= state.length) return n;
        if (!state.ended) {
          state.needReadable = true;
          return 0;
        }
        return state.length;
      }
      Readable.prototype.read = function(n) {
        debug("read", n);
        n = parseInt(n, 10);
        var state = this._readableState;
        var nOrig = n;
        if (n !== 0) state.emittedReadable = false;
        if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) {
          debug("read: emitReadable", state.length, state.ended);
          if (state.length === 0 && state.ended) endReadable(this);
          else emitReadable(this);
          return null;
        }
        n = howMuchToRead(n, state);
        if (n === 0 && state.ended) {
          if (state.length === 0) endReadable(this);
          return null;
        }
        var doRead = state.needReadable;
        debug("need readable", doRead);
        if (state.length === 0 || state.length - n < state.highWaterMark) {
          doRead = true;
          debug("length less than watermark", doRead);
        }
        if (state.ended || state.reading) {
          doRead = false;
          debug("reading or ended", doRead);
        } else if (doRead) {
          debug("do read");
          state.reading = true;
          state.sync = true;
          if (state.length === 0) state.needReadable = true;
          this._read(state.highWaterMark);
          state.sync = false;
          if (!state.reading) n = howMuchToRead(nOrig, state);
        }
        var ret;
        if (n > 0) ret = fromList(n, state);
        else ret = null;
        if (ret === null) {
          state.needReadable = true;
          n = 0;
        } else {
          state.length -= n;
        }
        if (state.length === 0) {
          if (!state.ended) state.needReadable = true;
          if (nOrig !== n && state.ended) endReadable(this);
        }
        if (ret !== null) this.emit("data", ret);
        return ret;
      };
      function onEofChunk(stream, state) {
        if (state.ended) return;
        if (state.decoder) {
          var chunk = state.decoder.end();
          if (chunk && chunk.length) {
            state.buffer.push(chunk);
            state.length += state.objectMode ? 1 : chunk.length;
          }
        }
        state.ended = true;
        emitReadable(stream);
      }
      function emitReadable(stream) {
        var state = stream._readableState;
        state.needReadable = false;
        if (!state.emittedReadable) {
          debug("emitReadable", state.flowing);
          state.emittedReadable = true;
          if (state.sync) pna.nextTick(emitReadable_, stream);
          else emitReadable_(stream);
        }
      }
      function emitReadable_(stream) {
        debug("emit readable");
        stream.emit("readable");
        flow(stream);
      }
      function maybeReadMore(stream, state) {
        if (!state.readingMore) {
          state.readingMore = true;
          pna.nextTick(maybeReadMore_, stream, state);
        }
      }
      function maybeReadMore_(stream, state) {
        var len = state.length;
        while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) {
          debug("maybeReadMore read 0");
          stream.read(0);
          if (len === state.length)
            break;
          else len = state.length;
        }
        state.readingMore = false;
      }
      Readable.prototype._read = function(n) {
        this.emit("error", new Error("_read() is not overridden in subclass"));
      };
      Readable.prototype.pipe = function(dest, pipeOpts) {
        var src = this;
        var state = this._readableState;
        switch (state.pipesCount) {
          case 0:
            state.pipes = dest;
            break;
          case 1:
            state.pipes = [state.pipes, dest];
            break;
          default:
            state.pipes.push(dest);
            break;
        }
        state.pipesCount += 1;
        debug("pipe count=%d opts=%j", state.pipesCount, pipeOpts);
        var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;
        var endFn = doEnd ? onend : unpipe;
        if (state.endEmitted) pna.nextTick(endFn);
        else src.once("end", endFn);
        dest.on("unpipe", onunpipe);
        function onunpipe(readable, unpipeInfo) {
          debug("onunpipe");
          if (readable === src) {
            if (unpipeInfo && unpipeInfo.hasUnpiped === false) {
              unpipeInfo.hasUnpiped = true;
              cleanup();
            }
          }
        }
        function onend() {
          debug("onend");
          dest.end();
        }
        var ondrain = pipeOnDrain(src);
        dest.on("drain", ondrain);
        var cleanedUp = false;
        function cleanup() {
          debug("cleanup");
          dest.removeListener("close", onclose);
          dest.removeListener("finish", onfinish);
          dest.removeListener("drain", ondrain);
          dest.removeListener("error", onerror);
          dest.removeListener("unpipe", onunpipe);
          src.removeListener("end", onend);
          src.removeListener("end", unpipe);
          src.removeListener("data", ondata);
          cleanedUp = true;
          if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();
        }
        var increasedAwaitDrain = false;
        src.on("data", ondata);
        function ondata(chunk) {
          debug("ondata");
          increasedAwaitDrain = false;
          var ret = dest.write(chunk);
          if (false === ret && !increasedAwaitDrain) {
            if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {
              debug("false write response, pause", state.awaitDrain);
              state.awaitDrain++;
              increasedAwaitDrain = true;
            }
            src.pause();
          }
        }
        function onerror(er) {
          debug("onerror", er);
          unpipe();
          dest.removeListener("error", onerror);
          if (EElistenerCount(dest, "error") === 0) dest.emit("error", er);
        }
        prependListener(dest, "error", onerror);
        function onclose() {
          dest.removeListener("finish", onfinish);
          unpipe();
        }
        dest.once("close", onclose);
        function onfinish() {
          debug("onfinish");
          dest.removeListener("close", onclose);
          unpipe();
        }
        dest.once("finish", onfinish);
        function unpipe() {
          debug("unpipe");
          src.unpipe(dest);
        }
        dest.emit("pipe", src);
        if (!state.flowing) {
          debug("pipe resume");
          src.resume();
        }
        return dest;
      };
      function pipeOnDrain(src) {
        return function() {
          var state = src._readableState;
          debug("pipeOnDrain", state.awaitDrain);
          if (state.awaitDrain) state.awaitDrain--;
          if (state.awaitDrain === 0 && EElistenerCount(src, "data")) {
            state.flowing = true;
            flow(src);
          }
        };
      }
      Readable.prototype.unpipe = function(dest) {
        var state = this._readableState;
        var unpipeInfo = { hasUnpiped: false };
        if (state.pipesCount === 0) return this;
        if (state.pipesCount === 1) {
          if (dest && dest !== state.pipes) return this;
          if (!dest) dest = state.pipes;
          state.pipes = null;
          state.pipesCount = 0;
          state.flowing = false;
          if (dest) dest.emit("unpipe", this, unpipeInfo);
          return this;
        }
        if (!dest) {
          var dests = state.pipes;
          var len = state.pipesCount;
          state.pipes = null;
          state.pipesCount = 0;
          state.flowing = false;
          for (var i = 0; i < len; i++) {
            dests[i].emit("unpipe", this, { hasUnpiped: false });
          }
          return this;
        }
        var index = indexOf(state.pipes, dest);
        if (index === -1) return this;
        state.pipes.splice(index, 1);
        state.pipesCount -= 1;
        if (state.pipesCount === 1) state.pipes = state.pipes[0];
        dest.emit("unpipe", this, unpipeInfo);
        return this;
      };
      Readable.prototype.on = function(ev, fn) {
        var res = Stream.prototype.on.call(this, ev, fn);
        if (ev === "data") {
          if (this._readableState.flowing !== false) this.resume();
        } else if (ev === "readable") {
          var state = this._readableState;
          if (!state.endEmitted && !state.readableListening) {
            state.readableListening = state.needReadable = true;
            state.emittedReadable = false;
            if (!state.reading) {
              pna.nextTick(nReadingNextTick, this);
            } else if (state.length) {
              emitReadable(this);
            }
          }
        }
        return res;
      };
      Readable.prototype.addListener = Readable.prototype.on;
      function nReadingNextTick(self2) {
        debug("readable nexttick read 0");
        self2.read(0);
      }
      Readable.prototype.resume = function() {
        var state = this._readableState;
        if (!state.flowing) {
          debug("resume");
          state.flowing = true;
          resume(this, state);
        }
        return this;
      };
      function resume(stream, state) {
        if (!state.resumeScheduled) {
          state.resumeScheduled = true;
          pna.nextTick(resume_, stream, state);
        }
      }
      function resume_(stream, state) {
        if (!state.reading) {
          debug("resume read 0");
          stream.read(0);
        }
        state.resumeScheduled = false;
        state.awaitDrain = 0;
        stream.emit("resume");
        flow(stream);
        if (state.flowing && !state.reading) stream.read(0);
      }
      Readable.prototype.pause = function() {
        debug("call pause flowing=%j", this._readableState.flowing);
        if (false !== this._readableState.flowing) {
          debug("pause");
          this._readableState.flowing = false;
          this.emit("pause");
        }
        return this;
      };
      function flow(stream) {
        var state = stream._readableState;
        debug("flow", state.flowing);
        while (state.flowing && stream.read() !== null) {
        }
      }
      Readable.prototype.wrap = function(stream) {
        var _this = this;
        var state = this._readableState;
        var paused = false;
        stream.on("end", function() {
          debug("wrapped end");
          if (state.decoder && !state.ended) {
            var chunk = state.decoder.end();
            if (chunk && chunk.length) _this.push(chunk);
          }
          _this.push(null);
        });
        stream.on("data", function(chunk) {
          debug("wrapped data");
          if (state.decoder) chunk = state.decoder.write(chunk);
          if (state.objectMode && (chunk === null || chunk === void 0)) return;
          else if (!state.objectMode && (!chunk || !chunk.length)) return;
          var ret = _this.push(chunk);
          if (!ret) {
            paused = true;
            stream.pause();
          }
        });
        for (var i in stream) {
          if (this[i] === void 0 && typeof stream[i] === "function") {
            this[i] = /* @__PURE__ */ (function(method) {
              return function() {
                return stream[method].apply(stream, arguments);
              };
            })(i);
          }
        }
        for (var n = 0; n < kProxyEvents.length; n++) {
          stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));
        }
        this._read = function(n2) {
          debug("wrapped _read", n2);
          if (paused) {
            paused = false;
            stream.resume();
          }
        };
        return this;
      };
      Object.defineProperty(Readable.prototype, "readableHighWaterMark", {
        // making it explicit this property is not enumerable
        // because otherwise some prototype manipulation in
        // userland will fail
        enumerable: false,
        get: function() {
          return this._readableState.highWaterMark;
        }
      });
      Readable._fromList = fromList;
      function fromList(n, state) {
        if (state.length === 0) return null;
        var ret;
        if (state.objectMode) ret = state.buffer.shift();
        else if (!n || n >= state.length) {
          if (state.decoder) ret = state.buffer.join("");
          else if (state.buffer.length === 1) ret = state.buffer.head.data;
          else ret = state.buffer.concat(state.length);
          state.buffer.clear();
        } else {
          ret = fromListPartial(n, state.buffer, state.decoder);
        }
        return ret;
      }
      function fromListPartial(n, list, hasStrings) {
        var ret;
        if (n < list.head.data.length) {
          ret = list.head.data.slice(0, n);
          list.head.data = list.head.data.slice(n);
        } else if (n === list.head.data.length) {
          ret = list.shift();
        } else {
          ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list);
        }
        return ret;
      }
      function copyFromBufferString(n, list) {
        var p = list.head;
        var c = 1;
        var ret = p.data;
        n -= ret.length;
        while (p = p.next) {
          var str = p.data;
          var nb = n > str.length ? str.length : n;
          if (nb === str.length) ret += str;
          else ret += str.slice(0, n);
          n -= nb;
          if (n === 0) {
            if (nb === str.length) {
              ++c;
              if (p.next) list.head = p.next;
              else list.head = list.tail = null;
            } else {
              list.head = p;
              p.data = str.slice(nb);
            }
            break;
          }
          ++c;
        }
        list.length -= c;
        return ret;
      }
      function copyFromBuffer(n, list) {
        var ret = Buffer2.allocUnsafe(n);
        var p = list.head;
        var c = 1;
        p.data.copy(ret);
        n -= p.data.length;
        while (p = p.next) {
          var buf = p.data;
          var nb = n > buf.length ? buf.length : n;
          buf.copy(ret, ret.length - n, 0, nb);
          n -= nb;
          if (n === 0) {
            if (nb === buf.length) {
              ++c;
              if (p.next) list.head = p.next;
              else list.head = list.tail = null;
            } else {
              list.head = p;
              p.data = buf.slice(nb);
            }
            break;
          }
          ++c;
        }
        list.length -= c;
        return ret;
      }
      function endReadable(stream) {
        var state = stream._readableState;
        if (state.length > 0) throw new Error('"endReadable()" called on non-empty stream');
        if (!state.endEmitted) {
          state.ended = true;
          pna.nextTick(endReadableNT, state, stream);
        }
      }
      function endReadableNT(state, stream) {
        if (!state.endEmitted && state.length === 0) {
          state.endEmitted = true;
          stream.readable = false;
          stream.emit("end");
        }
      }
      function indexOf(xs, x) {
        for (var i = 0, l = xs.length; i < l; i++) {
          if (xs[i] === x) return i;
        }
        return -1;
      }
    }
  });

  // ../../node_modules/tar-stream/node_modules/readable-stream/lib/_stream_transform.js
  var require_stream_transform2 = __commonJS({
    "../../node_modules/tar-stream/node_modules/readable-stream/lib/_stream_transform.js"(exports, module) {
      "use strict";
      module.exports = Transform;
      var Duplex = require_stream_duplex2();
      var util = Object.create(require_util());
      util.inherits = require_inherits();
      util.inherits(Transform, Duplex);
      function afterTransform(er, data) {
        var ts = this._transformState;
        ts.transforming = false;
        var cb = ts.writecb;
        if (!cb) {
          return this.emit("error", new Error("write callback called multiple times"));
        }
        ts.writechunk = null;
        ts.writecb = null;
        if (data != null)
          this.push(data);
        cb(er);
        var rs = this._readableState;
        rs.reading = false;
        if (rs.needReadable || rs.length < rs.highWaterMark) {
          this._read(rs.highWaterMark);
        }
      }
      function Transform(options) {
        if (!(this instanceof Transform)) return new Transform(options);
        Duplex.call(this, options);
        this._transformState = {
          afterTransform: afterTransform.bind(this),
          needTransform: false,
          transforming: false,
          writecb: null,
          writechunk: null,
          writeencoding: null
        };
        this._readableState.needReadable = true;
        this._readableState.sync = false;
        if (options) {
          if (typeof options.transform === "function") this._transform = options.transform;
          if (typeof options.flush === "function") this._flush = options.flush;
        }
        this.on("prefinish", prefinish);
      }
      function prefinish() {
        var _this = this;
        if (typeof this._flush === "function") {
          this._flush(function(er, data) {
            done(_this, er, data);
          });
        } else {
          done(this, null, null);
        }
      }
      Transform.prototype.push = function(chunk, encoding) {
        this._transformState.needTransform = false;
        return Duplex.prototype.push.call(this, chunk, encoding);
      };
      Transform.prototype._transform = function(chunk, encoding, cb) {
        throw new Error("_transform() is not overridden in subclass");
      };
      Transform.prototype._write = function(chunk, encoding, cb) {
        var ts = this._transformState;
        ts.writecb = cb;
        ts.writechunk = chunk;
        ts.writeencoding = encoding;
        if (!ts.transforming) {
          var rs = this._readableState;
          if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);
        }
      };
      Transform.prototype._read = function(n) {
        var ts = this._transformState;
        if (ts.writechunk !== null && ts.writecb && !ts.transforming) {
          ts.transforming = true;
          this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
        } else {
          ts.needTransform = true;
        }
      };
      Transform.prototype._destroy = function(err, cb) {
        var _this2 = this;
        Duplex.prototype._destroy.call(this, err, function(err2) {
          cb(err2);
          _this2.emit("close");
        });
      };
      function done(stream, er, data) {
        if (er) return stream.emit("error", er);
        if (data != null)
          stream.push(data);
        if (stream._writableState.length) throw new Error("Calling transform done when ws.length != 0");
        if (stream._transformState.transforming) throw new Error("Calling transform done when still transforming");
        return stream.push(null);
      }
    }
  });

  // ../../node_modules/tar-stream/node_modules/readable-stream/lib/_stream_passthrough.js
  var require_stream_passthrough2 = __commonJS({
    "../../node_modules/tar-stream/node_modules/readable-stream/lib/_stream_passthrough.js"(exports, module) {
      "use strict";
      module.exports = PassThrough;
      var Transform = require_stream_transform2();
      var util = Object.create(require_util());
      util.inherits = require_inherits();
      util.inherits(PassThrough, Transform);
      function PassThrough(options) {
        if (!(this instanceof PassThrough)) return new PassThrough(options);
        Transform.call(this, options);
      }
      PassThrough.prototype._transform = function(chunk, encoding, cb) {
        cb(null, chunk);
      };
    }
  });

  // ../../node_modules/tar-stream/node_modules/readable-stream/readable.js
  var require_readable2 = __commonJS({
    "../../node_modules/tar-stream/node_modules/readable-stream/readable.js"(exports, module) {
      var Stream = __require("stream");
      if (process.env.READABLE_STREAM === "disable" && Stream) {
        module.exports = Stream;
        exports = module.exports = Stream.Readable;
        exports.Readable = Stream.Readable;
        exports.Writable = Stream.Writable;
        exports.Duplex = Stream.Duplex;
        exports.Transform = Stream.Transform;
        exports.PassThrough = Stream.PassThrough;
        exports.Stream = Stream;
      } else {
        exports = module.exports = require_stream_readable2();
        exports.Stream = Stream || exports;
        exports.Readable = exports;
        exports.Writable = require_stream_writable2();
        exports.Duplex = require_stream_duplex2();
        exports.Transform = require_stream_transform2();
        exports.PassThrough = require_stream_passthrough2();
      }
    }
  });

  // ../../node_modules/tar-stream/extract.js
  var require_extract = __commonJS({
    "../../node_modules/tar-stream/extract.js"(exports, module) {
      var util = __require("util");
      var bl = require_bl();
      var xtend = require_immutable();
      var headers = require_headers();
      var Writable = require_readable2().Writable;
      var PassThrough = require_readable2().PassThrough;
      var noop = function() {
      };
      var overflow = function(size) {
        size &= 511;
        return size && 512 - size;
      };
      var emptyStream = function(self2, offset) {
        var s = new Source(self2, offset);
        s.end();
        return s;
      };
      var mixinPax = function(header, pax) {
        if (pax.path) header.name = pax.path;
        if (pax.linkpath) header.linkname = pax.linkpath;
        if (pax.size) header.size = parseInt(pax.size, 10);
        header.pax = pax;
        return header;
      };
      var Source = function(self2, offset) {
        this._parent = self2;
        this.offset = offset;
        PassThrough.call(this);
      };
      util.inherits(Source, PassThrough);
      Source.prototype.destroy = function(err) {
        this._parent.destroy(err);
      };
      var Extract = function(opts) {
        if (!(this instanceof Extract)) return new Extract(opts);
        Writable.call(this, opts);
        opts = opts || {};
        this._offset = 0;
        this._buffer = bl();
        this._missing = 0;
        this._partial = false;
        this._onparse = noop;
        this._header = null;
        this._stream = null;
        this._overflow = null;
        this._cb = null;
        this._locked = false;
        this._destroyed = false;
        this._pax = null;
        this._paxGlobal = null;
        this._gnuLongPath = null;
        this._gnuLongLinkPath = null;
        var self2 = this;
        var b = self2._buffer;
        var oncontinue = function() {
          self2._continue();
        };
        var onunlock = function(err) {
          self2._locked = false;
          if (err) return self2.destroy(err);
          if (!self2._stream) oncontinue();
        };
        var onstreamend = function() {
          self2._stream = null;
          var drain = overflow(self2._header.size);
          if (drain) self2._parse(drain, ondrain);
          else self2._parse(512, onheader);
          if (!self2._locked) oncontinue();
        };
        var ondrain = function() {
          self2._buffer.consume(overflow(self2._header.size));
          self2._parse(512, onheader);
          oncontinue();
        };
        var onpaxglobalheader = function() {
          var size = self2._header.size;
          self2._paxGlobal = headers.decodePax(b.slice(0, size));
          b.consume(size);
          onstreamend();
        };
        var onpaxheader = function() {
          var size = self2._header.size;
          self2._pax = headers.decodePax(b.slice(0, size));
          if (self2._paxGlobal) self2._pax = xtend(self2._paxGlobal, self2._pax);
          b.consume(size);
          onstreamend();
        };
        var ongnulongpath = function() {
          var size = self2._header.size;
          this._gnuLongPath = headers.decodeLongPath(b.slice(0, size), opts.filenameEncoding);
          b.consume(size);
          onstreamend();
        };
        var ongnulonglinkpath = function() {
          var size = self2._header.size;
          this._gnuLongLinkPath = headers.decodeLongPath(b.slice(0, size), opts.filenameEncoding);
          b.consume(size);
          onstreamend();
        };
        var onheader = function() {
          var offset = self2._offset;
          var header;
          try {
            header = self2._header = headers.decode(b.slice(0, 512), opts.filenameEncoding);
          } catch (err) {
            self2.emit("error", err);
          }
          b.consume(512);
          if (!header) {
            self2._parse(512, onheader);
            oncontinue();
            return;
          }
          if (header.type === "gnu-long-path") {
            self2._parse(header.size, ongnulongpath);
            oncontinue();
            return;
          }
          if (header.type === "gnu-long-link-path") {
            self2._parse(header.size, ongnulonglinkpath);
            oncontinue();
            return;
          }
          if (header.type === "pax-global-header") {
            self2._parse(header.size, onpaxglobalheader);
            oncontinue();
            return;
          }
          if (header.type === "pax-header") {
            self2._parse(header.size, onpaxheader);
            oncontinue();
            return;
          }
          if (self2._gnuLongPath) {
            header.name = self2._gnuLongPath;
            self2._gnuLongPath = null;
          }
          if (self2._gnuLongLinkPath) {
            header.linkname = self2._gnuLongLinkPath;
            self2._gnuLongLinkPath = null;
          }
          if (self2._pax) {
            self2._header = header = mixinPax(header, self2._pax);
            self2._pax = null;
          }
          self2._locked = true;
          if (!header.size || header.type === "directory") {
            self2._parse(512, onheader);
            self2.emit("entry", header, emptyStream(self2, offset), onunlock);
            return;
          }
          self2._stream = new Source(self2, offset);
          self2.emit("entry", header, self2._stream, onunlock);
          self2._parse(header.size, onstreamend);
          oncontinue();
        };
        this._onheader = onheader;
        this._parse(512, onheader);
      };
      util.inherits(Extract, Writable);
      Extract.prototype.destroy = function(err) {
        if (this._destroyed) return;
        this._destroyed = true;
        if (err) this.emit("error", err);
        this.emit("close");
        if (this._stream) this._stream.emit("close");
      };
      Extract.prototype._parse = function(size, onparse) {
        if (this._destroyed) return;
        this._offset += size;
        this._missing = size;
        if (onparse === this._onheader) this._partial = false;
        this._onparse = onparse;
      };
      Extract.prototype._continue = function() {
        if (this._destroyed) return;
        var cb = this._cb;
        this._cb = noop;
        if (this._overflow) this._write(this._overflow, void 0, cb);
        else cb();
      };
      Extract.prototype._write = function(data, enc, cb) {
        if (this._destroyed) return;
        var s = this._stream;
        var b = this._buffer;
        var missing = this._missing;
        if (data.length) this._partial = true;
        if (data.length < missing) {
          this._missing -= data.length;
          this._overflow = null;
          if (s) return s.write(data, cb);
          b.append(data);
          return cb();
        }
        this._cb = cb;
        this._missing = 0;
        var overflow2 = null;
        if (data.length > missing) {
          overflow2 = data.slice(missing);
          data = data.slice(0, missing);
        }
        if (s) s.end(data);
        else b.append(data);
        this._overflow = overflow2;
        this._onparse();
      };
      Extract.prototype._final = function(cb) {
        if (this._partial) return this.destroy(new Error("Unexpected end of data"));
        cb();
      };
      module.exports = Extract;
    }
  });

  // ../../node_modules/fs-constants/index.js
  var require_fs_constants = __commonJS({
    "../../node_modules/fs-constants/index.js"(exports, module) {
      module.exports = require_bare_node_fs().constants || __require("constants");
    }
  });

  // ../../node_modules/wrappy/wrappy.js
  var require_wrappy = __commonJS({
    "../../node_modules/wrappy/wrappy.js"(exports, module) {
      module.exports = wrappy;
      function wrappy(fn, cb) {
        if (fn && cb) return wrappy(fn)(cb);
        if (typeof fn !== "function")
          throw new TypeError("need wrapper function");
        Object.keys(fn).forEach(function(k) {
          wrapper[k] = fn[k];
        });
        return wrapper;
        function wrapper() {
          var args = new Array(arguments.length);
          for (var i = 0; i < args.length; i++) {
            args[i] = arguments[i];
          }
          var ret = fn.apply(this, args);
          var cb2 = args[args.length - 1];
          if (typeof ret === "function" && ret !== cb2) {
            Object.keys(cb2).forEach(function(k) {
              ret[k] = cb2[k];
            });
          }
          return ret;
        }
      }
    }
  });

  // ../../node_modules/once/once.js
  var require_once = __commonJS({
    "../../node_modules/once/once.js"(exports, module) {
      var wrappy = require_wrappy();
      module.exports = wrappy(once);
      module.exports.strict = wrappy(onceStrict);
      once.proto = once(function() {
        Object.defineProperty(Function.prototype, "once", {
          value: function() {
            return once(this);
          },
          configurable: true
        });
        Object.defineProperty(Function.prototype, "onceStrict", {
          value: function() {
            return onceStrict(this);
          },
          configurable: true
        });
      });
      function once(fn) {
        var f = function() {
          if (f.called) return f.value;
          f.called = true;
          return f.value = fn.apply(this, arguments);
        };
        f.called = false;
        return f;
      }
      function onceStrict(fn) {
        var f = function() {
          if (f.called)
            throw new Error(f.onceError);
          f.called = true;
          return f.value = fn.apply(this, arguments);
        };
        var name = fn.name || "Function wrapped with `once`";
        f.onceError = name + " shouldn't be called more than once";
        f.called = false;
        return f;
      }
    }
  });

  // ../../node_modules/end-of-stream/index.js
  var require_end_of_stream = __commonJS({
    "../../node_modules/end-of-stream/index.js"(exports, module) {
      var once = require_once();
      var noop = function() {
      };
      var qnt = global.Bare ? queueMicrotask : process.nextTick.bind(process);
      var isRequest = function(stream) {
        return stream.setHeader && typeof stream.abort === "function";
      };
      var isChildProcess = function(stream) {
        return stream.stdio && Array.isArray(stream.stdio) && stream.stdio.length === 3;
      };
      var eos = function(stream, opts, callback) {
        if (typeof opts === "function") return eos(stream, null, opts);
        if (!opts) opts = {};
        callback = once(callback || noop);
        var ws = stream._writableState;
        var rs = stream._readableState;
        var readable = opts.readable || opts.readable !== false && stream.readable;
        var writable = opts.writable || opts.writable !== false && stream.writable;
        var cancelled = false;
        var onlegacyfinish = function() {
          if (!stream.writable) onfinish();
        };
        var onfinish = function() {
          writable = false;
          if (!readable) callback.call(stream);
        };
        var onend = function() {
          readable = false;
          if (!writable) callback.call(stream);
        };
        var onexit = function(exitCode) {
          callback.call(stream, exitCode ? new Error("exited with error code: " + exitCode) : null);
        };
        var onerror = function(err) {
          callback.call(stream, err);
        };
        var onclose = function() {
          qnt(onclosenexttick);
        };
        var onclosenexttick = function() {
          if (cancelled) return;
          if (readable && !(rs && (rs.ended && !rs.destroyed))) return callback.call(stream, new Error("premature close"));
          if (writable && !(ws && (ws.ended && !ws.destroyed))) return callback.call(stream, new Error("premature close"));
        };
        var onrequest = function() {
          stream.req.on("finish", onfinish);
        };
        if (isRequest(stream)) {
          stream.on("complete", onfinish);
          stream.on("abort", onclose);
          if (stream.req) onrequest();
          else stream.on("request", onrequest);
        } else if (writable && !ws) {
          stream.on("end", onlegacyfinish);
          stream.on("close", onlegacyfinish);
        }
        if (isChildProcess(stream)) stream.on("exit", onexit);
        stream.on("end", onend);
        stream.on("finish", onfinish);
        if (opts.error !== false) stream.on("error", onerror);
        stream.on("close", onclose);
        return function() {
          cancelled = true;
          stream.removeListener("complete", onfinish);
          stream.removeListener("abort", onclose);
          stream.removeListener("request", onrequest);
          if (stream.req) stream.req.removeListener("finish", onfinish);
          stream.removeListener("end", onlegacyfinish);
          stream.removeListener("close", onlegacyfinish);
          stream.removeListener("finish", onfinish);
          stream.removeListener("exit", onexit);
          stream.removeListener("end", onend);
          stream.removeListener("error", onerror);
          stream.removeListener("close", onclose);
        };
      };
      module.exports = eos;
    }
  });

  // ../../node_modules/tar-stream/pack.js
  var require_pack = __commonJS({
    "../../node_modules/tar-stream/pack.js"(exports, module) {
      var constants = require_fs_constants();
      var eos = require_end_of_stream();
      var util = __require("util");
      var alloc = require_buffer_alloc();
      var toBuffer = require_to_buffer();
      var Readable = require_readable2().Readable;
      var Writable = require_readable2().Writable;
      var StringDecoder = __require("string_decoder").StringDecoder;
      var headers = require_headers();
      var DMODE = parseInt("755", 8);
      var FMODE = parseInt("644", 8);
      var END_OF_TAR = alloc(1024);
      var noop = function() {
      };
      var overflow = function(self2, size) {
        size &= 511;
        if (size) self2.push(END_OF_TAR.slice(0, 512 - size));
      };
      function modeToType(mode) {
        switch (mode & constants.S_IFMT) {
          case constants.S_IFBLK:
            return "block-device";
          case constants.S_IFCHR:
            return "character-device";
          case constants.S_IFDIR:
            return "directory";
          case constants.S_IFIFO:
            return "fifo";
          case constants.S_IFLNK:
            return "symlink";
        }
        return "file";
      }
      var Sink = function(to) {
        Writable.call(this);
        this.written = 0;
        this._to = to;
        this._destroyed = false;
      };
      util.inherits(Sink, Writable);
      Sink.prototype._write = function(data, enc, cb) {
        this.written += data.length;
        if (this._to.push(data)) return cb();
        this._to._drain = cb;
      };
      Sink.prototype.destroy = function() {
        if (this._destroyed) return;
        this._destroyed = true;
        this.emit("close");
      };
      var LinkSink = function() {
        Writable.call(this);
        this.linkname = "";
        this._decoder = new StringDecoder("utf-8");
        this._destroyed = false;
      };
      util.inherits(LinkSink, Writable);
      LinkSink.prototype._write = function(data, enc, cb) {
        this.linkname += this._decoder.write(data);
        cb();
      };
      LinkSink.prototype.destroy = function() {
        if (this._destroyed) return;
        this._destroyed = true;
        this.emit("close");
      };
      var Void = function() {
        Writable.call(this);
        this._destroyed = false;
      };
      util.inherits(Void, Writable);
      Void.prototype._write = function(data, enc, cb) {
        cb(new Error("No body allowed for this entry"));
      };
      Void.prototype.destroy = function() {
        if (this._destroyed) return;
        this._destroyed = true;
        this.emit("close");
      };
      var Pack = function(opts) {
        if (!(this instanceof Pack)) return new Pack(opts);
        Readable.call(this, opts);
        this._drain = noop;
        this._finalized = false;
        this._finalizing = false;
        this._destroyed = false;
        this._stream = null;
      };
      util.inherits(Pack, Readable);
      Pack.prototype.entry = function(header, buffer, callback) {
        if (this._stream) throw new Error("already piping an entry");
        if (this._finalized || this._destroyed) return;
        if (typeof buffer === "function") {
          callback = buffer;
          buffer = null;
        }
        if (!callback) callback = noop;
        var self2 = this;
        if (!header.size || header.type === "symlink") header.size = 0;
        if (!header.type) header.type = modeToType(header.mode);
        if (!header.mode) header.mode = header.type === "directory" ? DMODE : FMODE;
        if (!header.uid) header.uid = 0;
        if (!header.gid) header.gid = 0;
        if (!header.mtime) header.mtime = /* @__PURE__ */ new Date();
        if (typeof buffer === "string") buffer = toBuffer(buffer);
        if (Buffer.isBuffer(buffer)) {
          header.size = buffer.length;
          this._encode(header);
          this.push(buffer);
          overflow(self2, header.size);
          process.nextTick(callback);
          return new Void();
        }
        if (header.type === "symlink" && !header.linkname) {
          var linkSink = new LinkSink();
          eos(linkSink, function(err) {
            if (err) {
              self2.destroy();
              return callback(err);
            }
            header.linkname = linkSink.linkname;
            self2._encode(header);
            callback();
          });
          return linkSink;
        }
        this._encode(header);
        if (header.type !== "file" && header.type !== "contiguous-file") {
          process.nextTick(callback);
          return new Void();
        }
        var sink = new Sink(this);
        this._stream = sink;
        eos(sink, function(err) {
          self2._stream = null;
          if (err) {
            self2.destroy();
            return callback(err);
          }
          if (sink.written !== header.size) {
            self2.destroy();
            return callback(new Error("size mismatch"));
          }
          overflow(self2, header.size);
          if (self2._finalizing) self2.finalize();
          callback();
        });
        return sink;
      };
      Pack.prototype.finalize = function() {
        if (this._stream) {
          this._finalizing = true;
          return;
        }
        if (this._finalized) return;
        this._finalized = true;
        this.push(END_OF_TAR);
        this.push(null);
      };
      Pack.prototype.destroy = function(err) {
        if (this._destroyed) return;
        this._destroyed = true;
        if (err) this.emit("error", err);
        this.emit("close");
        if (this._stream && this._stream.destroy) this._stream.destroy();
      };
      Pack.prototype._encode = function(header) {
        if (!header.pax) {
          var buf = headers.encode(header);
          if (buf) {
            this.push(buf);
            return;
          }
        }
        this._encodePax(header);
      };
      Pack.prototype._encodePax = function(header) {
        var paxHeader = headers.encodePax({
          name: header.name,
          linkname: header.linkname,
          pax: header.pax
        });
        var newHeader = {
          name: "PaxHeader",
          mode: header.mode,
          uid: header.uid,
          gid: header.gid,
          size: paxHeader.length,
          mtime: header.mtime,
          type: "pax-header",
          linkname: header.linkname && "PaxHeader",
          uname: header.uname,
          gname: header.gname,
          devmajor: header.devmajor,
          devminor: header.devminor
        };
        this.push(headers.encode(newHeader));
        this.push(paxHeader);
        overflow(this, paxHeader.length);
        newHeader.size = header.size;
        newHeader.type = header.type;
        this.push(headers.encode(newHeader));
      };
      Pack.prototype._read = function(n) {
        var drain = this._drain;
        this._drain = noop;
        drain();
      };
      module.exports = Pack;
    }
  });

  // ../../node_modules/tar-stream/index.js
  var require_tar_stream = __commonJS({
    "../../node_modules/tar-stream/index.js"(exports) {
      exports.extract = require_extract();
      exports.pack = require_pack();
    }
  });

  // ../../node_modules/decompress-tar/index.js
  var require_decompress_tar = __commonJS({
    "../../node_modules/decompress-tar/index.js"(exports, module) {
      "use strict";
      var fileType = require_file_type();
      var isStream = require_is_stream();
      var tarStream = require_tar_stream();
      module.exports = () => (input) => {
        if (!Buffer.isBuffer(input) && !isStream(input)) {
          return Promise.reject(new TypeError(`Expected a Buffer or Stream, got ${typeof input}`));
        }
        if (Buffer.isBuffer(input) && (!fileType(input) || fileType(input).ext !== "tar")) {
          return Promise.resolve([]);
        }
        const extract = tarStream.extract();
        const files = [];
        extract.on("entry", (header, stream, cb) => {
          const chunk = [];
          stream.on("data", (data) => chunk.push(data));
          stream.on("end", () => {
            const file = {
              data: Buffer.concat(chunk),
              mode: header.mode,
              mtime: header.mtime,
              path: header.name,
              type: header.type
            };
            if (header.type === "symlink" || header.type === "link") {
              file.linkname = header.linkname;
            }
            files.push(file);
            cb();
          });
        });
        const promise = new Promise((resolve, reject) => {
          if (!Buffer.isBuffer(input)) {
            input.on("error", reject);
          }
          extract.on("finish", () => resolve(files));
          extract.on("error", reject);
        });
        extract.then = promise.then.bind(promise);
        extract.catch = promise.catch.bind(promise);
        if (Buffer.isBuffer(input)) {
          extract.end(input);
        } else {
          input.pipe(extract);
        }
        return extract;
      };
    }
  });

  // ../../node_modules/decompress-tarbz2/node_modules/file-type/index.js
  var require_file_type2 = __commonJS({
    "../../node_modules/decompress-tarbz2/node_modules/file-type/index.js"(exports, module) {
      "use strict";
      var toBytes = (s) => Array.from(s).map((c) => c.charCodeAt(0));
      var xpiZipFilename = toBytes("META-INF/mozilla.rsa");
      var oxmlContentTypes = toBytes("[Content_Types].xml");
      var oxmlRels = toBytes("_rels/.rels");
      module.exports = (input) => {
        const buf = new Uint8Array(input);
        if (!(buf && buf.length > 1)) {
          return null;
        }
        const check = (header, opts) => {
          opts = Object.assign({
            offset: 0
          }, opts);
          for (let i = 0; i < header.length; i++) {
            if (opts.mask) {
              if (header[i] !== (opts.mask[i] & buf[i + opts.offset])) {
                return false;
              }
            } else if (header[i] !== buf[i + opts.offset]) {
              return false;
            }
          }
          return true;
        };
        if (check([255, 216, 255])) {
          return {
            ext: "jpg",
            mime: "image/jpeg"
          };
        }
        if (check([137, 80, 78, 71, 13, 10, 26, 10])) {
          return {
            ext: "png",
            mime: "image/png"
          };
        }
        if (check([71, 73, 70])) {
          return {
            ext: "gif",
            mime: "image/gif"
          };
        }
        if (check([87, 69, 66, 80], { offset: 8 })) {
          return {
            ext: "webp",
            mime: "image/webp"
          };
        }
        if (check([70, 76, 73, 70])) {
          return {
            ext: "flif",
            mime: "image/flif"
          };
        }
        if ((check([73, 73, 42, 0]) || check([77, 77, 0, 42])) && check([67, 82], { offset: 8 })) {
          return {
            ext: "cr2",
            mime: "image/x-canon-cr2"
          };
        }
        if (check([73, 73, 42, 0]) || check([77, 77, 0, 42])) {
          return {
            ext: "tif",
            mime: "image/tiff"
          };
        }
        if (check([66, 77])) {
          return {
            ext: "bmp",
            mime: "image/bmp"
          };
        }
        if (check([73, 73, 188])) {
          return {
            ext: "jxr",
            mime: "image/vnd.ms-photo"
          };
        }
        if (check([56, 66, 80, 83])) {
          return {
            ext: "psd",
            mime: "image/vnd.adobe.photoshop"
          };
        }
        if (check([80, 75, 3, 4])) {
          if (check([109, 105, 109, 101, 116, 121, 112, 101, 97, 112, 112, 108, 105, 99, 97, 116, 105, 111, 110, 47, 101, 112, 117, 98, 43, 122, 105, 112], { offset: 30 })) {
            return {
              ext: "epub",
              mime: "application/epub+zip"
            };
          }
          if (check(xpiZipFilename, { offset: 30 })) {
            return {
              ext: "xpi",
              mime: "application/x-xpinstall"
            };
          }
          if (check(oxmlContentTypes, { offset: 30 }) || check(oxmlRels, { offset: 30 })) {
            const sliced = buf.subarray(4, 4 + 2e3);
            const nextZipHeaderIndex = (arr) => arr.findIndex((el, i, arr2) => arr2[i] === 80 && arr2[i + 1] === 75 && arr2[i + 2] === 3 && arr2[i + 3] === 4);
            const header2Pos = nextZipHeaderIndex(sliced);
            if (header2Pos !== -1) {
              const slicedAgain = buf.subarray(header2Pos + 8, header2Pos + 8 + 1e3);
              const header3Pos = nextZipHeaderIndex(slicedAgain);
              if (header3Pos !== -1) {
                const offset = 8 + header2Pos + header3Pos + 30;
                if (check(toBytes("word/"), { offset })) {
                  return {
                    ext: "docx",
                    mime: "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
                  };
                }
                if (check(toBytes("ppt/"), { offset })) {
                  return {
                    ext: "pptx",
                    mime: "application/vnd.openxmlformats-officedocument.presentationml.presentation"
                  };
                }
                if (check(toBytes("xl/"), { offset })) {
                  return {
                    ext: "xlsx",
                    mime: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
                  };
                }
              }
            }
          }
        }
        if (check([80, 75]) && (buf[2] === 3 || buf[2] === 5 || buf[2] === 7) && (buf[3] === 4 || buf[3] === 6 || buf[3] === 8)) {
          return {
            ext: "zip",
            mime: "application/zip"
          };
        }
        if (check([117, 115, 116, 97, 114], { offset: 257 })) {
          return {
            ext: "tar",
            mime: "application/x-tar"
          };
        }
        if (check([82, 97, 114, 33, 26, 7]) && (buf[6] === 0 || buf[6] === 1)) {
          return {
            ext: "rar",
            mime: "application/x-rar-compressed"
          };
        }
        if (check([31, 139, 8])) {
          return {
            ext: "gz",
            mime: "application/gzip"
          };
        }
        if (check([66, 90, 104])) {
          return {
            ext: "bz2",
            mime: "application/x-bzip2"
          };
        }
        if (check([55, 122, 188, 175, 39, 28])) {
          return {
            ext: "7z",
            mime: "application/x-7z-compressed"
          };
        }
        if (check([120, 1])) {
          return {
            ext: "dmg",
            mime: "application/x-apple-diskimage"
          };
        }
        if (check([51, 103, 112, 53]) || // 3gp5
        check([0, 0, 0]) && check([102, 116, 121, 112], { offset: 4 }) && (check([109, 112, 52, 49], { offset: 8 }) || // MP41
        check([109, 112, 52, 50], { offset: 8 }) || // MP42
        check([105, 115, 111, 109], { offset: 8 }) || // ISOM
        check([105, 115, 111, 50], { offset: 8 }) || // ISO2
        check([109, 109, 112, 52], { offset: 8 }) || // MMP4
        check([77, 52, 86], { offset: 8 }) || // M4V
        check([100, 97, 115, 104], { offset: 8 }))) {
          return {
            ext: "mp4",
            mime: "video/mp4"
          };
        }
        if (check([77, 84, 104, 100])) {
          return {
            ext: "mid",
            mime: "audio/midi"
          };
        }
        if (check([26, 69, 223, 163])) {
          const sliced = buf.subarray(4, 4 + 4096);
          const idPos = sliced.findIndex((el, i, arr) => arr[i] === 66 && arr[i + 1] === 130);
          if (idPos !== -1) {
            const docTypePos = idPos + 3;
            const findDocType = (type) => Array.from(type).every((c, i) => sliced[docTypePos + i] === c.charCodeAt(0));
            if (findDocType("matroska")) {
              return {
                ext: "mkv",
                mime: "video/x-matroska"
              };
            }
            if (findDocType("webm")) {
              return {
                ext: "webm",
                mime: "video/webm"
              };
            }
          }
        }
        if (check([0, 0, 0, 20, 102, 116, 121, 112, 113, 116, 32, 32]) || check([102, 114, 101, 101], { offset: 4 }) || check([102, 116, 121, 112, 113, 116, 32, 32], { offset: 4 }) || check([109, 100, 97, 116], { offset: 4 }) || // MJPEG
        check([119, 105, 100, 101], { offset: 4 })) {
          return {
            ext: "mov",
            mime: "video/quicktime"
          };
        }
        if (check([82, 73, 70, 70]) && check([65, 86, 73], { offset: 8 })) {
          return {
            ext: "avi",
            mime: "video/x-msvideo"
          };
        }
        if (check([48, 38, 178, 117, 142, 102, 207, 17, 166, 217])) {
          return {
            ext: "wmv",
            mime: "video/x-ms-wmv"
          };
        }
        if (check([0, 0, 1, 186])) {
          return {
            ext: "mpg",
            mime: "video/mpeg"
          };
        }
        for (let start = 0; start < 2 && start < buf.length - 16; start++) {
          if (check([73, 68, 51], { offset: start }) || // ID3 header
          check([255, 226], { offset: start, mask: [255, 226] })) {
            return {
              ext: "mp3",
              mime: "audio/mpeg"
            };
          }
        }
        if (check([102, 116, 121, 112, 77, 52, 65], { offset: 4 }) || check([77, 52, 65, 32])) {
          return {
            ext: "m4a",
            mime: "audio/m4a"
          };
        }
        if (check([79, 112, 117, 115, 72, 101, 97, 100], { offset: 28 })) {
          return {
            ext: "opus",
            mime: "audio/opus"
          };
        }
        if (check([79, 103, 103, 83])) {
          return {
            ext: "ogg",
            mime: "audio/ogg"
          };
        }
        if (check([102, 76, 97, 67])) {
          return {
            ext: "flac",
            mime: "audio/x-flac"
          };
        }
        if (check([82, 73, 70, 70]) && check([87, 65, 86, 69], { offset: 8 })) {
          return {
            ext: "wav",
            mime: "audio/x-wav"
          };
        }
        if (check([35, 33, 65, 77, 82, 10])) {
          return {
            ext: "amr",
            mime: "audio/amr"
          };
        }
        if (check([37, 80, 68, 70])) {
          return {
            ext: "pdf",
            mime: "application/pdf"
          };
        }
        if (check([77, 90])) {
          return {
            ext: "exe",
            mime: "application/x-msdownload"
          };
        }
        if ((buf[0] === 67 || buf[0] === 70) && check([87, 83], { offset: 1 })) {
          return {
            ext: "swf",
            mime: "application/x-shockwave-flash"
          };
        }
        if (check([123, 92, 114, 116, 102])) {
          return {
            ext: "rtf",
            mime: "application/rtf"
          };
        }
        if (check([0, 97, 115, 109])) {
          return {
            ext: "wasm",
            mime: "application/wasm"
          };
        }
        if (check([119, 79, 70, 70]) && (check([0, 1, 0, 0], { offset: 4 }) || check([79, 84, 84, 79], { offset: 4 }))) {
          return {
            ext: "woff",
            mime: "font/woff"
          };
        }
        if (check([119, 79, 70, 50]) && (check([0, 1, 0, 0], { offset: 4 }) || check([79, 84, 84, 79], { offset: 4 }))) {
          return {
            ext: "woff2",
            mime: "font/woff2"
          };
        }
        if (check([76, 80], { offset: 34 }) && (check([0, 0, 1], { offset: 8 }) || check([1, 0, 2], { offset: 8 }) || check([2, 0, 2], { offset: 8 }))) {
          return {
            ext: "eot",
            mime: "application/octet-stream"
          };
        }
        if (check([0, 1, 0, 0, 0])) {
          return {
            ext: "ttf",
            mime: "font/ttf"
          };
        }
        if (check([79, 84, 84, 79, 0])) {
          return {
            ext: "otf",
            mime: "font/otf"
          };
        }
        if (check([0, 0, 1, 0])) {
          return {
            ext: "ico",
            mime: "image/x-icon"
          };
        }
        if (check([70, 76, 86, 1])) {
          return {
            ext: "flv",
            mime: "video/x-flv"
          };
        }
        if (check([37, 33])) {
          return {
            ext: "ps",
            mime: "application/postscript"
          };
        }
        if (check([253, 55, 122, 88, 90, 0])) {
          return {
            ext: "xz",
            mime: "application/x-xz"
          };
        }
        if (check([83, 81, 76, 105])) {
          return {
            ext: "sqlite",
            mime: "application/x-sqlite3"
          };
        }
        if (check([78, 69, 83, 26])) {
          return {
            ext: "nes",
            mime: "application/x-nintendo-nes-rom"
          };
        }
        if (check([67, 114, 50, 52])) {
          return {
            ext: "crx",
            mime: "application/x-google-chrome-extension"
          };
        }
        if (check([77, 83, 67, 70]) || check([73, 83, 99, 40])) {
          return {
            ext: "cab",
            mime: "application/vnd.ms-cab-compressed"
          };
        }
        if (check([33, 60, 97, 114, 99, 104, 62, 10, 100, 101, 98, 105, 97, 110, 45, 98, 105, 110, 97, 114, 121])) {
          return {
            ext: "deb",
            mime: "application/x-deb"
          };
        }
        if (check([33, 60, 97, 114, 99, 104, 62])) {
          return {
            ext: "ar",
            mime: "application/x-unix-archive"
          };
        }
        if (check([237, 171, 238, 219])) {
          return {
            ext: "rpm",
            mime: "application/x-rpm"
          };
        }
        if (check([31, 160]) || check([31, 157])) {
          return {
            ext: "Z",
            mime: "application/x-compress"
          };
        }
        if (check([76, 90, 73, 80])) {
          return {
            ext: "lz",
            mime: "application/x-lzip"
          };
        }
        if (check([208, 207, 17, 224, 161, 177, 26, 225])) {
          return {
            ext: "msi",
            mime: "application/x-msi"
          };
        }
        if (check([6, 14, 43, 52, 2, 5, 1, 1, 13, 1, 2, 1, 1, 2])) {
          return {
            ext: "mxf",
            mime: "application/mxf"
          };
        }
        if (check([71], { offset: 4 }) && (check([71], { offset: 192 }) || check([71], { offset: 196 }))) {
          return {
            ext: "mts",
            mime: "video/mp2t"
          };
        }
        if (check([66, 76, 69, 78, 68, 69, 82])) {
          return {
            ext: "blend",
            mime: "application/x-blender"
          };
        }
        if (check([66, 80, 71, 251])) {
          return {
            ext: "bpg",
            mime: "image/bpg"
          };
        }
        return null;
      };
    }
  });

  // ../../node_modules/seek-bzip/lib/bitreader.js
  var require_bitreader = __commonJS({
    "../../node_modules/seek-bzip/lib/bitreader.js"(exports, module) {
      var BITMASK = [0, 1, 3, 7, 15, 31, 63, 127, 255];
      var BitReader = function(stream) {
        this.stream = stream;
        this.bitOffset = 0;
        this.curByte = 0;
        this.hasByte = false;
      };
      BitReader.prototype._ensureByte = function() {
        if (!this.hasByte) {
          this.curByte = this.stream.readByte();
          this.hasByte = true;
        }
      };
      BitReader.prototype.read = function(bits) {
        var result = 0;
        while (bits > 0) {
          this._ensureByte();
          var remaining = 8 - this.bitOffset;
          if (bits >= remaining) {
            result <<= remaining;
            result |= BITMASK[remaining] & this.curByte;
            this.hasByte = false;
            this.bitOffset = 0;
            bits -= remaining;
          } else {
            result <<= bits;
            var shift = remaining - bits;
            result |= (this.curByte & BITMASK[bits] << shift) >> shift;
            this.bitOffset += bits;
            bits = 0;
          }
        }
        return result;
      };
      BitReader.prototype.seek = function(pos) {
        var n_bit = pos % 8;
        var n_byte = (pos - n_bit) / 8;
        this.bitOffset = n_bit;
        this.stream.seek(n_byte);
        this.hasByte = false;
      };
      BitReader.prototype.pi = function() {
        var buf = new Buffer(6), i;
        for (i = 0; i < buf.length; i++) {
          buf[i] = this.read(8);
        }
        return buf.toString("hex");
      };
      module.exports = BitReader;
    }
  });

  // ../../node_modules/seek-bzip/lib/stream.js
  var require_stream3 = __commonJS({
    "../../node_modules/seek-bzip/lib/stream.js"(exports, module) {
      var Stream = function() {
      };
      Stream.prototype.readByte = function() {
        throw new Error("abstract method readByte() missing in subclass");
      };
      Stream.prototype.read = function(buffer, bufOffset, length) {
        var bytesRead = 0;
        while (bytesRead < length) {
          var c = this.readByte();
          if (c < 0) {
            return bytesRead === 0 ? -1 : bytesRead;
          }
          buffer[bufOffset++] = c;
          bytesRead++;
        }
        return bytesRead;
      };
      Stream.prototype.seek = function(new_pos) {
        throw new Error("abstract method seek() missing in subclass");
      };
      Stream.prototype.writeByte = function(_byte) {
        throw new Error("abstract method readByte() missing in subclass");
      };
      Stream.prototype.write = function(buffer, bufOffset, length) {
        var i;
        for (i = 0; i < length; i++) {
          this.writeByte(buffer[bufOffset++]);
        }
        return length;
      };
      Stream.prototype.flush = function() {
      };
      module.exports = Stream;
    }
  });

  // ../../node_modules/seek-bzip/lib/crc32.js
  var require_crc32 = __commonJS({
    "../../node_modules/seek-bzip/lib/crc32.js"(exports, module) {
      module.exports = (function() {
        var crc32Lookup = new Uint32Array([
          0,
          79764919,
          159529838,
          222504665,
          319059676,
          398814059,
          445009330,
          507990021,
          638119352,
          583659535,
          797628118,
          726387553,
          890018660,
          835552979,
          1015980042,
          944750013,
          1276238704,
          1221641927,
          1167319070,
          1095957929,
          1595256236,
          1540665371,
          1452775106,
          1381403509,
          1780037320,
          1859660671,
          1671105958,
          1733955601,
          2031960084,
          2111593891,
          1889500026,
          1952343757,
          2552477408,
          2632100695,
          2443283854,
          2506133561,
          2334638140,
          2414271883,
          2191915858,
          2254759653,
          3190512472,
          3135915759,
          3081330742,
          3009969537,
          2905550212,
          2850959411,
          2762807018,
          2691435357,
          3560074640,
          3505614887,
          3719321342,
          3648080713,
          3342211916,
          3287746299,
          3467911202,
          3396681109,
          4063920168,
          4143685023,
          4223187782,
          4286162673,
          3779000052,
          3858754371,
          3904687514,
          3967668269,
          881225847,
          809987520,
          1023691545,
          969234094,
          662832811,
          591600412,
          771767749,
          717299826,
          311336399,
          374308984,
          453813921,
          533576470,
          25881363,
          88864420,
          134795389,
          214552010,
          2023205639,
          2086057648,
          1897238633,
          1976864222,
          1804852699,
          1867694188,
          1645340341,
          1724971778,
          1587496639,
          1516133128,
          1461550545,
          1406951526,
          1302016099,
          1230646740,
          1142491917,
          1087903418,
          2896545431,
          2825181984,
          2770861561,
          2716262478,
          3215044683,
          3143675388,
          3055782693,
          3001194130,
          2326604591,
          2389456536,
          2200899649,
          2280525302,
          2578013683,
          2640855108,
          2418763421,
          2498394922,
          3769900519,
          3832873040,
          3912640137,
          3992402750,
          4088425275,
          4151408268,
          4197601365,
          4277358050,
          3334271071,
          3263032808,
          3476998961,
          3422541446,
          3585640067,
          3514407732,
          3694837229,
          3640369242,
          1762451694,
          1842216281,
          1619975040,
          1682949687,
          2047383090,
          2127137669,
          1938468188,
          2001449195,
          1325665622,
          1271206113,
          1183200824,
          1111960463,
          1543535498,
          1489069629,
          1434599652,
          1363369299,
          622672798,
          568075817,
          748617968,
          677256519,
          907627842,
          853037301,
          1067152940,
          995781531,
          51762726,
          131386257,
          177728840,
          240578815,
          269590778,
          349224269,
          429104020,
          491947555,
          4046411278,
          4126034873,
          4172115296,
          4234965207,
          3794477266,
          3874110821,
          3953728444,
          4016571915,
          3609705398,
          3555108353,
          3735388376,
          3664026991,
          3290680682,
          3236090077,
          3449943556,
          3378572211,
          3174993278,
          3120533705,
          3032266256,
          2961025959,
          2923101090,
          2868635157,
          2813903052,
          2742672763,
          2604032198,
          2683796849,
          2461293480,
          2524268063,
          2284983834,
          2364738477,
          2175806836,
          2238787779,
          1569362073,
          1498123566,
          1409854455,
          1355396672,
          1317987909,
          1246755826,
          1192025387,
          1137557660,
          2072149281,
          2135122070,
          1912620623,
          1992383480,
          1753615357,
          1816598090,
          1627664531,
          1707420964,
          295390185,
          358241886,
          404320391,
          483945776,
          43990325,
          106832002,
          186451547,
          266083308,
          932423249,
          861060070,
          1041341759,
          986742920,
          613929101,
          542559546,
          756411363,
          701822548,
          3316196985,
          3244833742,
          3425377559,
          3370778784,
          3601682597,
          3530312978,
          3744426955,
          3689838204,
          3819031489,
          3881883254,
          3928223919,
          4007849240,
          4037393693,
          4100235434,
          4180117107,
          4259748804,
          2310601993,
          2373574846,
          2151335527,
          2231098320,
          2596047829,
          2659030626,
          2470359227,
          2550115596,
          2947551409,
          2876312838,
          2788305887,
          2733848168,
          3165939309,
          3094707162,
          3040238851,
          2985771188
        ]);
        var CRC32 = function() {
          var crc = 4294967295;
          this.getCRC = function() {
            return ~crc >>> 0;
          };
          this.updateCRC = function(value) {
            crc = crc << 8 ^ crc32Lookup[(crc >>> 24 ^ value) & 255];
          };
          this.updateCRCRun = function(value, count) {
            while (count-- > 0) {
              crc = crc << 8 ^ crc32Lookup[(crc >>> 24 ^ value) & 255];
            }
          };
        };
        return CRC32;
      })();
    }
  });

  // ../../node_modules/seek-bzip/package.json
  var require_package = __commonJS({
    "../../node_modules/seek-bzip/package.json"(exports, module) {
      module.exports = {
        name: "seek-bzip",
        version: "1.0.6",
        contributors: [
          "C. Scott Ananian (http://cscott.net)",
          "Eli Skeggs",
          "Kevin Kwok",
          "Rob Landley (http://landley.net)"
        ],
        description: "a pure-JavaScript Node.JS module for random-access decoding bzip2 data",
        main: "./lib/index.js",
        repository: {
          type: "git",
          url: "https://github.com/cscott/seek-bzip.git"
        },
        license: "MIT",
        bin: {
          "seek-bunzip": "./bin/seek-bunzip",
          "seek-table": "./bin/seek-bzip-table"
        },
        directories: {
          test: "test"
        },
        dependencies: {
          commander: "^2.8.1"
        },
        devDependencies: {
          fibers: "~1.0.6",
          mocha: "~2.2.5"
        },
        scripts: {
          test: "mocha"
        }
      };
    }
  });

  // ../../node_modules/seek-bzip/lib/index.js
  var require_lib = __commonJS({
    "../../node_modules/seek-bzip/lib/index.js"(exports, module) {
      var BitReader = require_bitreader();
      var Stream = require_stream3();
      var CRC32 = require_crc32();
      var pjson = require_package();
      var MAX_HUFCODE_BITS = 20;
      var MAX_SYMBOLS = 258;
      var SYMBOL_RUNA = 0;
      var SYMBOL_RUNB = 1;
      var MIN_GROUPS = 2;
      var MAX_GROUPS = 6;
      var GROUP_SIZE = 50;
      var WHOLEPI = "314159265359";
      var SQRTPI = "177245385090";
      var mtf = function(array, index) {
        var src = array[index], i;
        for (i = index; i > 0; i--) {
          array[i] = array[i - 1];
        }
        array[0] = src;
        return src;
      };
      var Err = {
        OK: 0,
        LAST_BLOCK: -1,
        NOT_BZIP_DATA: -2,
        UNEXPECTED_INPUT_EOF: -3,
        UNEXPECTED_OUTPUT_EOF: -4,
        DATA_ERROR: -5,
        OUT_OF_MEMORY: -6,
        OBSOLETE_INPUT: -7,
        END_OF_BLOCK: -8
      };
      var ErrorMessages = {};
      ErrorMessages[Err.LAST_BLOCK] = "Bad file checksum";
      ErrorMessages[Err.NOT_BZIP_DATA] = "Not bzip data";
      ErrorMessages[Err.UNEXPECTED_INPUT_EOF] = "Unexpected input EOF";
      ErrorMessages[Err.UNEXPECTED_OUTPUT_EOF] = "Unexpected output EOF";
      ErrorMessages[Err.DATA_ERROR] = "Data error";
      ErrorMessages[Err.OUT_OF_MEMORY] = "Out of memory";
      ErrorMessages[Err.OBSOLETE_INPUT] = "Obsolete (pre 0.9.5) bzip format not supported.";
      var _throw = function(status, optDetail) {
        var msg = ErrorMessages[status] || "unknown error";
        if (optDetail) {
          msg += ": " + optDetail;
        }
        var e = new TypeError(msg);
        e.errorCode = status;
        throw e;
      };
      var Bunzip = function(inputStream, outputStream) {
        this.writePos = this.writeCurrent = this.writeCount = 0;
        this._start_bunzip(inputStream, outputStream);
      };
      Bunzip.prototype._init_block = function() {
        var moreBlocks = this._get_next_block();
        if (!moreBlocks) {
          this.writeCount = -1;
          return false;
        }
        this.blockCRC = new CRC32();
        return true;
      };
      Bunzip.prototype._start_bunzip = function(inputStream, outputStream) {
        var buf = new Buffer(4);
        if (inputStream.read(buf, 0, 4) !== 4 || String.fromCharCode(buf[0], buf[1], buf[2]) !== "BZh")
          _throw(Err.NOT_BZIP_DATA, "bad magic");
        var level = buf[3] - 48;
        if (level < 1 || level > 9)
          _throw(Err.NOT_BZIP_DATA, "level out of range");
        this.reader = new BitReader(inputStream);
        this.dbufSize = 1e5 * level;
        this.nextoutput = 0;
        this.outputStream = outputStream;
        this.streamCRC = 0;
      };
      Bunzip.prototype._get_next_block = function() {
        var i, j, k;
        var reader = this.reader;
        var h = reader.pi();
        if (h === SQRTPI) {
          return false;
        }
        if (h !== WHOLEPI)
          _throw(Err.NOT_BZIP_DATA);
        this.targetBlockCRC = reader.read(32) >>> 0;
        this.streamCRC = (this.targetBlockCRC ^ (this.streamCRC << 1 | this.streamCRC >>> 31)) >>> 0;
        if (reader.read(1))
          _throw(Err.OBSOLETE_INPUT);
        var origPointer = reader.read(24);
        if (origPointer > this.dbufSize)
          _throw(Err.DATA_ERROR, "initial position out of bounds");
        var t = reader.read(16);
        var symToByte = new Buffer(256), symTotal = 0;
        for (i = 0; i < 16; i++) {
          if (t & 1 << 15 - i) {
            var o = i * 16;
            k = reader.read(16);
            for (j = 0; j < 16; j++)
              if (k & 1 << 15 - j)
                symToByte[symTotal++] = o + j;
          }
        }
        var groupCount = reader.read(3);
        if (groupCount < MIN_GROUPS || groupCount > MAX_GROUPS)
          _throw(Err.DATA_ERROR);
        var nSelectors = reader.read(15);
        if (nSelectors === 0)
          _throw(Err.DATA_ERROR);
        var mtfSymbol = new Buffer(256);
        for (i = 0; i < groupCount; i++)
          mtfSymbol[i] = i;
        var selectors = new Buffer(nSelectors);
        for (i = 0; i < nSelectors; i++) {
          for (j = 0; reader.read(1); j++)
            if (j >= groupCount) _throw(Err.DATA_ERROR);
          selectors[i] = mtf(mtfSymbol, j);
        }
        var symCount = symTotal + 2;
        var groups = [], hufGroup;
        for (j = 0; j < groupCount; j++) {
          var length = new Buffer(symCount), temp = new Uint16Array(MAX_HUFCODE_BITS + 1);
          t = reader.read(5);
          for (i = 0; i < symCount; i++) {
            for (; ; ) {
              if (t < 1 || t > MAX_HUFCODE_BITS) _throw(Err.DATA_ERROR);
              if (!reader.read(1))
                break;
              if (!reader.read(1))
                t++;
              else
                t--;
            }
            length[i] = t;
          }
          var minLen, maxLen;
          minLen = maxLen = length[0];
          for (i = 1; i < symCount; i++) {
            if (length[i] > maxLen)
              maxLen = length[i];
            else if (length[i] < minLen)
              minLen = length[i];
          }
          hufGroup = {};
          groups.push(hufGroup);
          hufGroup.permute = new Uint16Array(MAX_SYMBOLS);
          hufGroup.limit = new Uint32Array(MAX_HUFCODE_BITS + 2);
          hufGroup.base = new Uint32Array(MAX_HUFCODE_BITS + 1);
          hufGroup.minLen = minLen;
          hufGroup.maxLen = maxLen;
          var pp = 0;
          for (i = minLen; i <= maxLen; i++) {
            temp[i] = hufGroup.limit[i] = 0;
            for (t = 0; t < symCount; t++)
              if (length[t] === i)
                hufGroup.permute[pp++] = t;
          }
          for (i = 0; i < symCount; i++)
            temp[length[i]]++;
          pp = t = 0;
          for (i = minLen; i < maxLen; i++) {
            pp += temp[i];
            hufGroup.limit[i] = pp - 1;
            pp <<= 1;
            t += temp[i];
            hufGroup.base[i + 1] = pp - t;
          }
          hufGroup.limit[maxLen + 1] = Number.MAX_VALUE;
          hufGroup.limit[maxLen] = pp + temp[maxLen] - 1;
          hufGroup.base[minLen] = 0;
        }
        var byteCount = new Uint32Array(256);
        for (i = 0; i < 256; i++)
          mtfSymbol[i] = i;
        var runPos = 0, dbufCount = 0, selector = 0, uc;
        var dbuf = this.dbuf = new Uint32Array(this.dbufSize);
        symCount = 0;
        for (; ; ) {
          if (!symCount--) {
            symCount = GROUP_SIZE - 1;
            if (selector >= nSelectors) {
              _throw(Err.DATA_ERROR);
            }
            hufGroup = groups[selectors[selector++]];
          }
          i = hufGroup.minLen;
          j = reader.read(i);
          for (; ; i++) {
            if (i > hufGroup.maxLen) {
              _throw(Err.DATA_ERROR);
            }
            if (j <= hufGroup.limit[i])
              break;
            j = j << 1 | reader.read(1);
          }
          j -= hufGroup.base[i];
          if (j < 0 || j >= MAX_SYMBOLS) {
            _throw(Err.DATA_ERROR);
          }
          var nextSym = hufGroup.permute[j];
          if (nextSym === SYMBOL_RUNA || nextSym === SYMBOL_RUNB) {
            if (!runPos) {
              runPos = 1;
              t = 0;
            }
            if (nextSym === SYMBOL_RUNA)
              t += runPos;
            else
              t += 2 * runPos;
            runPos <<= 1;
            continue;
          }
          if (runPos) {
            runPos = 0;
            if (dbufCount + t > this.dbufSize) {
              _throw(Err.DATA_ERROR);
            }
            uc = symToByte[mtfSymbol[0]];
            byteCount[uc] += t;
            while (t--)
              dbuf[dbufCount++] = uc;
          }
          if (nextSym > symTotal)
            break;
          if (dbufCount >= this.dbufSize) {
            _throw(Err.DATA_ERROR);
          }
          i = nextSym - 1;
          uc = mtf(mtfSymbol, i);
          uc = symToByte[uc];
          byteCount[uc]++;
          dbuf[dbufCount++] = uc;
        }
        if (origPointer < 0 || origPointer >= dbufCount) {
          _throw(Err.DATA_ERROR);
        }
        j = 0;
        for (i = 0; i < 256; i++) {
          k = j + byteCount[i];
          byteCount[i] = j;
          j = k;
        }
        for (i = 0; i < dbufCount; i++) {
          uc = dbuf[i] & 255;
          dbuf[byteCount[uc]] |= i << 8;
          byteCount[uc]++;
        }
        var pos = 0, current = 0, run = 0;
        if (dbufCount) {
          pos = dbuf[origPointer];
          current = pos & 255;
          pos >>= 8;
          run = -1;
        }
        this.writePos = pos;
        this.writeCurrent = current;
        this.writeCount = dbufCount;
        this.writeRun = run;
        return true;
      };
      Bunzip.prototype._read_bunzip = function(outputBuffer, len) {
        var copies, previous, outbyte;
        if (this.writeCount < 0) {
          return 0;
        }
        var gotcount = 0;
        var dbuf = this.dbuf, pos = this.writePos, current = this.writeCurrent;
        var dbufCount = this.writeCount, outputsize = this.outputsize;
        var run = this.writeRun;
        while (dbufCount) {
          dbufCount--;
          previous = current;
          pos = dbuf[pos];
          current = pos & 255;
          pos >>= 8;
          if (run++ === 3) {
            copies = current;
            outbyte = previous;
            current = -1;
          } else {
            copies = 1;
            outbyte = current;
          }
          this.blockCRC.updateCRCRun(outbyte, copies);
          while (copies--) {
            this.outputStream.writeByte(outbyte);
            this.nextoutput++;
          }
          if (current != previous)
            run = 0;
        }
        this.writeCount = dbufCount;
        if (this.blockCRC.getCRC() !== this.targetBlockCRC) {
          _throw(Err.DATA_ERROR, "Bad block CRC (got " + this.blockCRC.getCRC().toString(16) + " expected " + this.targetBlockCRC.toString(16) + ")");
        }
        return this.nextoutput;
      };
      var coerceInputStream = function(input) {
        if ("readByte" in input) {
          return input;
        }
        var inputStream = new Stream();
        inputStream.pos = 0;
        inputStream.readByte = function() {
          return input[this.pos++];
        };
        inputStream.seek = function(pos) {
          this.pos = pos;
        };
        inputStream.eof = function() {
          return this.pos >= input.length;
        };
        return inputStream;
      };
      var coerceOutputStream = function(output) {
        var outputStream = new Stream();
        var resizeOk = true;
        if (output) {
          if (typeof output === "number") {
            outputStream.buffer = new Buffer(output);
            resizeOk = false;
          } else if ("writeByte" in output) {
            return output;
          } else {
            outputStream.buffer = output;
            resizeOk = false;
          }
        } else {
          outputStream.buffer = new Buffer(16384);
        }
        outputStream.pos = 0;
        outputStream.writeByte = function(_byte) {
          if (resizeOk && this.pos >= this.buffer.length) {
            var newBuffer = new Buffer(this.buffer.length * 2);
            this.buffer.copy(newBuffer);
            this.buffer = newBuffer;
          }
          this.buffer[this.pos++] = _byte;
        };
        outputStream.getBuffer = function() {
          if (this.pos !== this.buffer.length) {
            if (!resizeOk)
              throw new TypeError("outputsize does not match decoded input");
            var newBuffer = new Buffer(this.pos);
            this.buffer.copy(newBuffer, 0, 0, this.pos);
            this.buffer = newBuffer;
          }
          return this.buffer;
        };
        outputStream._coerced = true;
        return outputStream;
      };
      Bunzip.Err = Err;
      Bunzip.decode = function(input, output, multistream) {
        var inputStream = coerceInputStream(input);
        var outputStream = coerceOutputStream(output);
        var bz = new Bunzip(inputStream, outputStream);
        while (true) {
          if ("eof" in inputStream && inputStream.eof()) break;
          if (bz._init_block()) {
            bz._read_bunzip();
          } else {
            var targetStreamCRC = bz.reader.read(32) >>> 0;
            if (targetStreamCRC !== bz.streamCRC) {
              _throw(Err.DATA_ERROR, "Bad stream CRC (got " + bz.streamCRC.toString(16) + " expected " + targetStreamCRC.toString(16) + ")");
            }
            if (multistream && "eof" in inputStream && !inputStream.eof()) {
              bz._start_bunzip(inputStream, outputStream);
            } else break;
          }
        }
        if ("getBuffer" in outputStream)
          return outputStream.getBuffer();
      };
      Bunzip.decodeBlock = function(input, pos, output) {
        var inputStream = coerceInputStream(input);
        var outputStream = coerceOutputStream(output);
        var bz = new Bunzip(inputStream, outputStream);
        bz.reader.seek(pos);
        var moreBlocks = bz._get_next_block();
        if (moreBlocks) {
          bz.blockCRC = new CRC32();
          bz.writeCopies = 0;
          bz._read_bunzip();
        }
        if ("getBuffer" in outputStream)
          return outputStream.getBuffer();
      };
      Bunzip.table = function(input, callback, multistream) {
        var inputStream = new Stream();
        inputStream.delegate = coerceInputStream(input);
        inputStream.pos = 0;
        inputStream.readByte = function() {
          this.pos++;
          return this.delegate.readByte();
        };
        if (inputStream.delegate.eof) {
          inputStream.eof = inputStream.delegate.eof.bind(inputStream.delegate);
        }
        var outputStream = new Stream();
        outputStream.pos = 0;
        outputStream.writeByte = function() {
          this.pos++;
        };
        var bz = new Bunzip(inputStream, outputStream);
        var blockSize = bz.dbufSize;
        while (true) {
          if ("eof" in inputStream && inputStream.eof()) break;
          var position = inputStream.pos * 8 + bz.reader.bitOffset;
          if (bz.reader.hasByte) {
            position -= 8;
          }
          if (bz._init_block()) {
            var start = outputStream.pos;
            bz._read_bunzip();
            callback(position, outputStream.pos - start);
          } else {
            var crc = bz.reader.read(32);
            if (multistream && "eof" in inputStream && !inputStream.eof()) {
              bz._start_bunzip(inputStream, outputStream);
              console.assert(
                bz.dbufSize === blockSize,
                "shouldn't change block size within multistream file"
              );
            } else break;
          }
        }
      };
      Bunzip.Stream = Stream;
      Bunzip.version = pjson.version;
      Bunzip.license = pjson.license;
      module.exports = Bunzip;
    }
  });

  // ../../node_modules/through/index.js
  var require_through = __commonJS({
    "../../node_modules/through/index.js"(exports, module) {
      var Stream = __require("stream");
      exports = module.exports = through;
      through.through = through;
      function through(write, end, opts) {
        write = write || function(data) {
          this.queue(data);
        };
        end = end || function() {
          this.queue(null);
        };
        var ended = false, destroyed = false, buffer = [], _ended = false;
        var stream = new Stream();
        stream.readable = stream.writable = true;
        stream.paused = false;
        stream.autoDestroy = !(opts && opts.autoDestroy === false);
        stream.write = function(data) {
          write.call(this, data);
          return !stream.paused;
        };
        function drain() {
          while (buffer.length && !stream.paused) {
            var data = buffer.shift();
            if (null === data)
              return stream.emit("end");
            else
              stream.emit("data", data);
          }
        }
        stream.queue = stream.push = function(data) {
          if (_ended) return stream;
          if (data === null) _ended = true;
          buffer.push(data);
          drain();
          return stream;
        };
        stream.on("end", function() {
          stream.readable = false;
          if (!stream.writable && stream.autoDestroy)
            process.nextTick(function() {
              stream.destroy();
            });
        });
        function _end() {
          stream.writable = false;
          end.call(stream);
          if (!stream.readable && stream.autoDestroy)
            stream.destroy();
        }
        stream.end = function(data) {
          if (ended) return;
          ended = true;
          if (arguments.length) stream.write(data);
          _end();
          return stream;
        };
        stream.destroy = function() {
          if (destroyed) return;
          destroyed = true;
          ended = true;
          buffer.length = 0;
          stream.writable = stream.readable = false;
          stream.emit("close");
          return stream;
        };
        stream.pause = function() {
          if (stream.paused) return;
          stream.paused = true;
          return stream;
        };
        stream.resume = function() {
          if (stream.paused) {
            stream.paused = false;
            stream.emit("resume");
          }
          drain();
          if (!stream.paused)
            stream.emit("drain");
          return stream;
        };
        return stream;
      }
    }
  });

  // ../../node_modules/unbzip2-stream/lib/bzip2.js
  var require_bzip2 = __commonJS({
    "../../node_modules/unbzip2-stream/lib/bzip2.js"(exports, module) {
      function Bzip2Error(message2) {
        this.name = "Bzip2Error";
        this.message = message2;
        this.stack = new Error().stack;
      }
      Bzip2Error.prototype = new Error();
      var message = {
        Error: function(message2) {
          throw new Bzip2Error(message2);
        }
      };
      var bzip2 = {};
      bzip2.Bzip2Error = Bzip2Error;
      bzip2.crcTable = [
        0,
        79764919,
        159529838,
        222504665,
        319059676,
        398814059,
        445009330,
        507990021,
        638119352,
        583659535,
        797628118,
        726387553,
        890018660,
        835552979,
        1015980042,
        944750013,
        1276238704,
        1221641927,
        1167319070,
        1095957929,
        1595256236,
        1540665371,
        1452775106,
        1381403509,
        1780037320,
        1859660671,
        1671105958,
        1733955601,
        2031960084,
        2111593891,
        1889500026,
        1952343757,
        2552477408,
        2632100695,
        2443283854,
        2506133561,
        2334638140,
        2414271883,
        2191915858,
        2254759653,
        3190512472,
        3135915759,
        3081330742,
        3009969537,
        2905550212,
        2850959411,
        2762807018,
        2691435357,
        3560074640,
        3505614887,
        3719321342,
        3648080713,
        3342211916,
        3287746299,
        3467911202,
        3396681109,
        4063920168,
        4143685023,
        4223187782,
        4286162673,
        3779000052,
        3858754371,
        3904687514,
        3967668269,
        881225847,
        809987520,
        1023691545,
        969234094,
        662832811,
        591600412,
        771767749,
        717299826,
        311336399,
        374308984,
        453813921,
        533576470,
        25881363,
        88864420,
        134795389,
        214552010,
        2023205639,
        2086057648,
        1897238633,
        1976864222,
        1804852699,
        1867694188,
        1645340341,
        1724971778,
        1587496639,
        1516133128,
        1461550545,
        1406951526,
        1302016099,
        1230646740,
        1142491917,
        1087903418,
        2896545431,
        2825181984,
        2770861561,
        2716262478,
        3215044683,
        3143675388,
        3055782693,
        3001194130,
        2326604591,
        2389456536,
        2200899649,
        2280525302,
        2578013683,
        2640855108,
        2418763421,
        2498394922,
        3769900519,
        3832873040,
        3912640137,
        3992402750,
        4088425275,
        4151408268,
        4197601365,
        4277358050,
        3334271071,
        3263032808,
        3476998961,
        3422541446,
        3585640067,
        3514407732,
        3694837229,
        3640369242,
        1762451694,
        1842216281,
        1619975040,
        1682949687,
        2047383090,
        2127137669,
        1938468188,
        2001449195,
        1325665622,
        1271206113,
        1183200824,
        1111960463,
        1543535498,
        1489069629,
        1434599652,
        1363369299,
        622672798,
        568075817,
        748617968,
        677256519,
        907627842,
        853037301,
        1067152940,
        995781531,
        51762726,
        131386257,
        177728840,
        240578815,
        269590778,
        349224269,
        429104020,
        491947555,
        4046411278,
        4126034873,
        4172115296,
        4234965207,
        3794477266,
        3874110821,
        3953728444,
        4016571915,
        3609705398,
        3555108353,
        3735388376,
        3664026991,
        3290680682,
        3236090077,
        3449943556,
        3378572211,
        3174993278,
        3120533705,
        3032266256,
        2961025959,
        2923101090,
        2868635157,
        2813903052,
        2742672763,
        2604032198,
        2683796849,
        2461293480,
        2524268063,
        2284983834,
        2364738477,
        2175806836,
        2238787779,
        1569362073,
        1498123566,
        1409854455,
        1355396672,
        1317987909,
        1246755826,
        1192025387,
        1137557660,
        2072149281,
        2135122070,
        1912620623,
        1992383480,
        1753615357,
        1816598090,
        1627664531,
        1707420964,
        295390185,
        358241886,
        404320391,
        483945776,
        43990325,
        106832002,
        186451547,
        266083308,
        932423249,
        861060070,
        1041341759,
        986742920,
        613929101,
        542559546,
        756411363,
        701822548,
        3316196985,
        3244833742,
        3425377559,
        3370778784,
        3601682597,
        3530312978,
        3744426955,
        3689838204,
        3819031489,
        3881883254,
        3928223919,
        4007849240,
        4037393693,
        4100235434,
        4180117107,
        4259748804,
        2310601993,
        2373574846,
        2151335527,
        2231098320,
        2596047829,
        2659030626,
        2470359227,
        2550115596,
        2947551409,
        2876312838,
        2788305887,
        2733848168,
        3165939309,
        3094707162,
        3040238851,
        2985771188
      ];
      bzip2.array = function(bytes) {
        var bit = 0, byte = 0;
        var BITMASK = [0, 1, 3, 7, 15, 31, 63, 127, 255];
        return function(n) {
          var result = 0;
          while (n > 0) {
            var left = 8 - bit;
            if (n >= left) {
              result <<= left;
              result |= BITMASK[left] & bytes[byte++];
              bit = 0;
              n -= left;
            } else {
              result <<= n;
              result |= (bytes[byte] & BITMASK[n] << 8 - n - bit) >> 8 - n - bit;
              bit += n;
              n = 0;
            }
          }
          return result;
        };
      };
      bzip2.simple = function(srcbuffer, stream) {
        var bits = bzip2.array(srcbuffer);
        var size = bzip2.header(bits);
        var ret = false;
        var bufsize = 1e5 * size;
        var buf = new Int32Array(bufsize);
        do {
          ret = bzip2.decompress(bits, stream, buf, bufsize);
        } while (!ret);
      };
      bzip2.header = function(bits) {
        this.byteCount = new Int32Array(256);
        this.symToByte = new Uint8Array(256);
        this.mtfSymbol = new Int32Array(256);
        this.selectors = new Uint8Array(32768);
        if (bits(8 * 3) != 4348520) message.Error("No magic number found");
        var i = bits(8) - 48;
        if (i < 1 || i > 9) message.Error("Not a BZIP archive");
        return i;
      };
      bzip2.decompress = function(bits, stream, buf, bufsize, streamCRC) {
        var MAX_HUFCODE_BITS = 20;
        var MAX_SYMBOLS = 258;
        var SYMBOL_RUNA = 0;
        var SYMBOL_RUNB = 1;
        var GROUP_SIZE = 50;
        var crc = 0 ^ -1;
        for (var h = "", i = 0; i < 6; i++) h += bits(8).toString(16);
        if (h == "177245385090") {
          var finalCRC = bits(32) | 0;
          if (finalCRC !== streamCRC) message.Error("Error in bzip2: crc32 do not match");
          bits(null);
          return null;
        }
        if (h != "314159265359") message.Error("eek not valid bzip data");
        var crcblock = bits(32) | 0;
        if (bits(1)) message.Error("unsupported obsolete version");
        var origPtr = bits(24);
        if (origPtr > bufsize) message.Error("Initial position larger than buffer size");
        var t = bits(16);
        var symTotal = 0;
        for (i = 0; i < 16; i++) {
          if (t & 1 << 15 - i) {
            var k = bits(16);
            for (j = 0; j < 16; j++) {
              if (k & 1 << 15 - j) {
                this.symToByte[symTotal++] = 16 * i + j;
              }
            }
          }
        }
        var groupCount = bits(3);
        if (groupCount < 2 || groupCount > 6) message.Error("another error");
        var nSelectors = bits(15);
        if (nSelectors == 0) message.Error("meh");
        for (var i = 0; i < groupCount; i++) this.mtfSymbol[i] = i;
        for (var i = 0; i < nSelectors; i++) {
          for (var j = 0; bits(1); j++) if (j >= groupCount) message.Error("whoops another error");
          var uc = this.mtfSymbol[j];
          for (var k = j - 1; k >= 0; k--) {
            this.mtfSymbol[k + 1] = this.mtfSymbol[k];
          }
          this.mtfSymbol[0] = uc;
          this.selectors[i] = uc;
        }
        var symCount = symTotal + 2;
        var groups = [];
        var length = new Uint8Array(MAX_SYMBOLS), temp = new Uint16Array(MAX_HUFCODE_BITS + 1);
        var hufGroup;
        for (var j = 0; j < groupCount; j++) {
          t = bits(5);
          for (var i = 0; i < symCount; i++) {
            while (true) {
              if (t < 1 || t > MAX_HUFCODE_BITS) message.Error("I gave up a while ago on writing error messages");
              if (!bits(1)) break;
              if (!bits(1)) t++;
              else t--;
            }
            length[i] = t;
          }
          var minLen, maxLen;
          minLen = maxLen = length[0];
          for (var i = 1; i < symCount; i++) {
            if (length[i] > maxLen) maxLen = length[i];
            else if (length[i] < minLen) minLen = length[i];
          }
          hufGroup = groups[j] = {};
          hufGroup.permute = new Int32Array(MAX_SYMBOLS);
          hufGroup.limit = new Int32Array(MAX_HUFCODE_BITS + 1);
          hufGroup.base = new Int32Array(MAX_HUFCODE_BITS + 1);
          hufGroup.minLen = minLen;
          hufGroup.maxLen = maxLen;
          var base = hufGroup.base;
          var limit = hufGroup.limit;
          var pp = 0;
          for (var i = minLen; i <= maxLen; i++)
            for (var t = 0; t < symCount; t++)
              if (length[t] == i) hufGroup.permute[pp++] = t;
          for (i = minLen; i <= maxLen; i++) temp[i] = limit[i] = 0;
          for (i = 0; i < symCount; i++) temp[length[i]]++;
          pp = t = 0;
          for (i = minLen; i < maxLen; i++) {
            pp += temp[i];
            limit[i] = pp - 1;
            pp <<= 1;
            base[i + 1] = pp - (t += temp[i]);
          }
          limit[maxLen] = pp + temp[maxLen] - 1;
          base[minLen] = 0;
        }
        for (var i = 0; i < 256; i++) {
          this.mtfSymbol[i] = i;
          this.byteCount[i] = 0;
        }
        var runPos, count, symCount, selector;
        runPos = count = symCount = selector = 0;
        while (true) {
          if (!symCount--) {
            symCount = GROUP_SIZE - 1;
            if (selector >= nSelectors) message.Error("meow i'm a kitty, that's an error");
            hufGroup = groups[this.selectors[selector++]];
            base = hufGroup.base;
            limit = hufGroup.limit;
          }
          i = hufGroup.minLen;
          j = bits(i);
          while (true) {
            if (i > hufGroup.maxLen) message.Error("rawr i'm a dinosaur");
            if (j <= limit[i]) break;
            i++;
            j = j << 1 | bits(1);
          }
          j -= base[i];
          if (j < 0 || j >= MAX_SYMBOLS) message.Error("moo i'm a cow");
          var nextSym = hufGroup.permute[j];
          if (nextSym == SYMBOL_RUNA || nextSym == SYMBOL_RUNB) {
            if (!runPos) {
              runPos = 1;
              t = 0;
            }
            if (nextSym == SYMBOL_RUNA) t += runPos;
            else t += 2 * runPos;
            runPos <<= 1;
            continue;
          }
          if (runPos) {
            runPos = 0;
            if (count + t > bufsize) message.Error("Boom.");
            uc = this.symToByte[this.mtfSymbol[0]];
            this.byteCount[uc] += t;
            while (t--) buf[count++] = uc;
          }
          if (nextSym > symTotal) break;
          if (count >= bufsize) message.Error("I can't think of anything. Error");
          i = nextSym - 1;
          uc = this.mtfSymbol[i];
          for (var k = i - 1; k >= 0; k--) {
            this.mtfSymbol[k + 1] = this.mtfSymbol[k];
          }
          this.mtfSymbol[0] = uc;
          uc = this.symToByte[uc];
          this.byteCount[uc]++;
          buf[count++] = uc;
        }
        if (origPtr < 0 || origPtr >= count) message.Error("I'm a monkey and I'm throwing something at someone, namely you");
        var j = 0;
        for (var i = 0; i < 256; i++) {
          k = j + this.byteCount[i];
          this.byteCount[i] = j;
          j = k;
        }
        for (var i = 0; i < count; i++) {
          uc = buf[i] & 255;
          buf[this.byteCount[uc]] |= i << 8;
          this.byteCount[uc]++;
        }
        var pos = 0, current = 0, run = 0;
        if (count) {
          pos = buf[origPtr];
          current = pos & 255;
          pos >>= 8;
          run = -1;
        }
        count = count;
        var copies, previous, outbyte;
        while (count) {
          count--;
          previous = current;
          pos = buf[pos];
          current = pos & 255;
          pos >>= 8;
          if (run++ == 3) {
            copies = current;
            outbyte = previous;
            current = -1;
          } else {
            copies = 1;
            outbyte = current;
          }
          while (copies--) {
            crc = (crc << 8 ^ this.crcTable[(crc >> 24 ^ outbyte) & 255]) & 4294967295;
            stream(outbyte);
          }
          if (current != previous) run = 0;
        }
        crc = (crc ^ -1) >>> 0;
        if ((crc | 0) != (crcblock | 0)) message.Error("Error in bzip2: crc32 do not match");
        streamCRC = (crc ^ (streamCRC << 1 | streamCRC >>> 31)) & 4294967295;
        return streamCRC;
      };
      module.exports = bzip2;
    }
  });

  // ../../node_modules/unbzip2-stream/lib/bit_iterator.js
  var require_bit_iterator = __commonJS({
    "../../node_modules/unbzip2-stream/lib/bit_iterator.js"(exports, module) {
      var BITMASK = [0, 1, 3, 7, 15, 31, 63, 127, 255];
      module.exports = function bitIterator(nextBuffer) {
        var bit = 0, byte = 0;
        var bytes = nextBuffer();
        var f = function(n) {
          if (n === null && bit != 0) {
            bit = 0;
            byte++;
            return;
          }
          var result = 0;
          while (n > 0) {
            if (byte >= bytes.length) {
              byte = 0;
              bytes = nextBuffer();
            }
            var left = 8 - bit;
            if (bit === 0 && n > 0)
              f.bytesRead++;
            if (n >= left) {
              result <<= left;
              result |= BITMASK[left] & bytes[byte++];
              bit = 0;
              n -= left;
            } else {
              result <<= n;
              result |= (bytes[byte] & BITMASK[n] << 8 - n - bit) >> 8 - n - bit;
              bit += n;
              n = 0;
            }
          }
          return result;
        };
        f.bytesRead = 0;
        return f;
      };
    }
  });

  // ../../node_modules/unbzip2-stream/index.js
  var require_unbzip2_stream = __commonJS({
    "../../node_modules/unbzip2-stream/index.js"(exports, module) {
      var through = require_through();
      var bz2 = require_bzip2();
      var bitIterator = require_bit_iterator();
      module.exports = unbzip2Stream;
      function unbzip2Stream() {
        var bufferQueue = [];
        var hasBytes = 0;
        var blockSize = 0;
        var broken = false;
        var done = false;
        var bitReader = null;
        var streamCRC = null;
        function decompressBlock(push) {
          if (!blockSize) {
            blockSize = bz2.header(bitReader);
            streamCRC = 0;
            return true;
          } else {
            var bufsize = 1e5 * blockSize;
            var buf = new Int32Array(bufsize);
            var chunk = [];
            var f = function(b) {
              chunk.push(b);
            };
            streamCRC = bz2.decompress(bitReader, f, buf, bufsize, streamCRC);
            if (streamCRC === null) {
              blockSize = 0;
              return false;
            } else {
              push(Buffer.from(chunk));
              return true;
            }
          }
        }
        var outlength = 0;
        function decompressAndQueue(stream) {
          if (broken) return;
          try {
            return decompressBlock(function(d) {
              stream.queue(d);
              if (d !== null) {
                outlength += d.length;
              } else {
              }
            });
          } catch (e) {
            stream.emit("error", e);
            broken = true;
            return false;
          }
        }
        return through(
          function write(data) {
            bufferQueue.push(data);
            hasBytes += data.length;
            if (bitReader === null) {
              bitReader = bitIterator(function() {
                return bufferQueue.shift();
              });
            }
            while (!broken && hasBytes - bitReader.bytesRead + 1 >= (25e3 + 1e5 * blockSize || 4)) {
              decompressAndQueue(this);
            }
          },
          function end(x) {
            while (!broken && bitReader && hasBytes > bitReader.bytesRead) {
              decompressAndQueue(this);
            }
            if (!broken) {
              if (streamCRC !== null)
                this.emit("error", new Error("input stream ended prematurely"));
              this.queue(null);
            }
          }
        );
      }
    }
  });

  // ../../node_modules/decompress-tarbz2/index.js
  var require_decompress_tarbz2 = __commonJS({
    "../../node_modules/decompress-tarbz2/index.js"(exports, module) {
      "use strict";
      var decompressTar = require_decompress_tar();
      var fileType = require_file_type2();
      var isStream = require_is_stream();
      var seekBzip = require_lib();
      var unbzip2Stream = require_unbzip2_stream();
      module.exports = () => (input) => {
        if (!Buffer.isBuffer(input) && !isStream(input)) {
          return Promise.reject(new TypeError(`Expected a Buffer or Stream, got ${typeof input}`));
        }
        if (Buffer.isBuffer(input) && (!fileType(input) || fileType(input).ext !== "bz2")) {
          return Promise.resolve([]);
        }
        if (Buffer.isBuffer(input)) {
          return decompressTar()(seekBzip.decode(input));
        }
        return decompressTar()(input.pipe(unbzip2Stream()));
      };
    }
  });

  // ../../node_modules/decompress-targz/index.js
  var require_decompress_targz = __commonJS({
    "../../node_modules/decompress-targz/index.js"(exports, module) {
      "use strict";
      var zlib = __require("zlib");
      var decompressTar = require_decompress_tar();
      var fileType = require_file_type();
      var isStream = require_is_stream();
      module.exports = () => (input) => {
        if (!Buffer.isBuffer(input) && !isStream(input)) {
          return Promise.reject(new TypeError(`Expected a Buffer or Stream, got ${typeof input}`));
        }
        if (Buffer.isBuffer(input) && (!fileType(input) || fileType(input).ext !== "gz")) {
          return Promise.resolve([]);
        }
        const unzip = zlib.createGunzip();
        const result = decompressTar()(unzip);
        if (Buffer.isBuffer(input)) {
          unzip.end(input);
        } else {
          input.pipe(unzip);
        }
        return result;
      };
    }
  });

  // ../../node_modules/decompress-unzip/node_modules/file-type/index.js
  var require_file_type3 = __commonJS({
    "../../node_modules/decompress-unzip/node_modules/file-type/index.js"(exports, module) {
      "use strict";
      module.exports = function(buf) {
        if (!(buf && buf.length > 1)) {
          return null;
        }
        if (buf[0] === 255 && buf[1] === 216 && buf[2] === 255) {
          return {
            ext: "jpg",
            mime: "image/jpeg"
          };
        }
        if (buf[0] === 137 && buf[1] === 80 && buf[2] === 78 && buf[3] === 71) {
          return {
            ext: "png",
            mime: "image/png"
          };
        }
        if (buf[0] === 71 && buf[1] === 73 && buf[2] === 70) {
          return {
            ext: "gif",
            mime: "image/gif"
          };
        }
        if (buf[8] === 87 && buf[9] === 69 && buf[10] === 66 && buf[11] === 80) {
          return {
            ext: "webp",
            mime: "image/webp"
          };
        }
        if (buf[0] === 70 && buf[1] === 76 && buf[2] === 73 && buf[3] === 70) {
          return {
            ext: "flif",
            mime: "image/flif"
          };
        }
        if ((buf[0] === 73 && buf[1] === 73 && buf[2] === 42 && buf[3] === 0 || buf[0] === 77 && buf[1] === 77 && buf[2] === 0 && buf[3] === 42) && buf[8] === 67 && buf[9] === 82) {
          return {
            ext: "cr2",
            mime: "image/x-canon-cr2"
          };
        }
        if (buf[0] === 73 && buf[1] === 73 && buf[2] === 42 && buf[3] === 0 || buf[0] === 77 && buf[1] === 77 && buf[2] === 0 && buf[3] === 42) {
          return {
            ext: "tif",
            mime: "image/tiff"
          };
        }
        if (buf[0] === 66 && buf[1] === 77) {
          return {
            ext: "bmp",
            mime: "image/bmp"
          };
        }
        if (buf[0] === 73 && buf[1] === 73 && buf[2] === 188) {
          return {
            ext: "jxr",
            mime: "image/vnd.ms-photo"
          };
        }
        if (buf[0] === 56 && buf[1] === 66 && buf[2] === 80 && buf[3] === 83) {
          return {
            ext: "psd",
            mime: "image/vnd.adobe.photoshop"
          };
        }
        if (buf[0] === 80 && buf[1] === 75 && buf[2] === 3 && buf[3] === 4 && buf[30] === 109 && buf[31] === 105 && buf[32] === 109 && buf[33] === 101 && buf[34] === 116 && buf[35] === 121 && buf[36] === 112 && buf[37] === 101 && buf[38] === 97 && buf[39] === 112 && buf[40] === 112 && buf[41] === 108 && buf[42] === 105 && buf[43] === 99 && buf[44] === 97 && buf[45] === 116 && buf[46] === 105 && buf[47] === 111 && buf[48] === 110 && buf[49] === 47 && buf[50] === 101 && buf[51] === 112 && buf[52] === 117 && buf[53] === 98 && buf[54] === 43 && buf[55] === 122 && buf[56] === 105 && buf[57] === 112) {
          return {
            ext: "epub",
            mime: "application/epub+zip"
          };
        }
        if (buf[0] === 80 && buf[1] === 75 && buf[2] === 3 && buf[3] === 4 && buf[30] === 77 && buf[31] === 69 && buf[32] === 84 && buf[33] === 65 && buf[34] === 45 && buf[35] === 73 && buf[36] === 78 && buf[37] === 70 && buf[38] === 47 && buf[39] === 109 && buf[40] === 111 && buf[41] === 122 && buf[42] === 105 && buf[43] === 108 && buf[44] === 108 && buf[45] === 97 && buf[46] === 46 && buf[47] === 114 && buf[48] === 115 && buf[49] === 97) {
          return {
            ext: "xpi",
            mime: "application/x-xpinstall"
          };
        }
        if (buf[0] === 80 && buf[1] === 75 && (buf[2] === 3 || buf[2] === 5 || buf[2] === 7) && (buf[3] === 4 || buf[3] === 6 || buf[3] === 8)) {
          return {
            ext: "zip",
            mime: "application/zip"
          };
        }
        if (buf[257] === 117 && buf[258] === 115 && buf[259] === 116 && buf[260] === 97 && buf[261] === 114) {
          return {
            ext: "tar",
            mime: "application/x-tar"
          };
        }
        if (buf[0] === 82 && buf[1] === 97 && buf[2] === 114 && buf[3] === 33 && buf[4] === 26 && buf[5] === 7 && (buf[6] === 0 || buf[6] === 1)) {
          return {
            ext: "rar",
            mime: "application/x-rar-compressed"
          };
        }
        if (buf[0] === 31 && buf[1] === 139 && buf[2] === 8) {
          return {
            ext: "gz",
            mime: "application/gzip"
          };
        }
        if (buf[0] === 66 && buf[1] === 90 && buf[2] === 104) {
          return {
            ext: "bz2",
            mime: "application/x-bzip2"
          };
        }
        if (buf[0] === 55 && buf[1] === 122 && buf[2] === 188 && buf[3] === 175 && buf[4] === 39 && buf[5] === 28) {
          return {
            ext: "7z",
            mime: "application/x-7z-compressed"
          };
        }
        if (buf[0] === 120 && buf[1] === 1) {
          return {
            ext: "dmg",
            mime: "application/x-apple-diskimage"
          };
        }
        if (buf[0] === 0 && buf[1] === 0 && buf[2] === 0 && (buf[3] === 24 || buf[3] === 32) && buf[4] === 102 && buf[5] === 116 && buf[6] === 121 && buf[7] === 112 || buf[0] === 51 && buf[1] === 103 && buf[2] === 112 && buf[3] === 53 || buf[0] === 0 && buf[1] === 0 && buf[2] === 0 && buf[3] === 28 && buf[4] === 102 && buf[5] === 116 && buf[6] === 121 && buf[7] === 112 && buf[8] === 109 && buf[9] === 112 && buf[10] === 52 && buf[11] === 50 && buf[16] === 109 && buf[17] === 112 && buf[18] === 52 && buf[19] === 49 && buf[20] === 109 && buf[21] === 112 && buf[22] === 52 && buf[23] === 50 && buf[24] === 105 && buf[25] === 115 && buf[26] === 111 && buf[27] === 109 || buf[0] === 0 && buf[1] === 0 && buf[2] === 0 && buf[3] === 28 && buf[4] === 102 && buf[5] === 116 && buf[6] === 121 && buf[7] === 112 && buf[8] === 105 && buf[9] === 115 && buf[10] === 111 && buf[11] === 109 || buf[0] === 0 && buf[1] === 0 && buf[2] === 0 && buf[3] === 28 && buf[4] === 102 && buf[5] === 116 && buf[6] === 121 && buf[7] === 112 && buf[8] === 109 && buf[9] === 112 && buf[10] === 52 && buf[11] === 50 && buf[12] === 0 && buf[13] === 0 && buf[14] === 0 && buf[15] === 0) {
          return {
            ext: "mp4",
            mime: "video/mp4"
          };
        }
        if (buf[0] === 0 && buf[1] === 0 && buf[2] === 0 && buf[3] === 28 && buf[4] === 102 && buf[5] === 116 && buf[6] === 121 && buf[7] === 112 && buf[8] === 77 && buf[9] === 52 && buf[10] === 86) {
          return {
            ext: "m4v",
            mime: "video/x-m4v"
          };
        }
        if (buf[0] === 77 && buf[1] === 84 && buf[2] === 104 && buf[3] === 100) {
          return {
            ext: "mid",
            mime: "audio/midi"
          };
        }
        if (buf[31] === 109 && buf[32] === 97 && buf[33] === 116 && buf[34] === 114 && buf[35] === 111 && buf[36] === 115 && buf[37] === 107 && buf[38] === 97) {
          return {
            ext: "mkv",
            mime: "video/x-matroska"
          };
        }
        if (buf[0] === 26 && buf[1] === 69 && buf[2] === 223 && buf[3] === 163) {
          return {
            ext: "webm",
            mime: "video/webm"
          };
        }
        if (buf[0] === 0 && buf[1] === 0 && buf[2] === 0 && buf[3] === 20 && buf[4] === 102 && buf[5] === 116 && buf[6] === 121 && buf[7] === 112) {
          return {
            ext: "mov",
            mime: "video/quicktime"
          };
        }
        if (buf[0] === 82 && buf[1] === 73 && buf[2] === 70 && buf[3] === 70 && buf[8] === 65 && buf[9] === 86 && buf[10] === 73) {
          return {
            ext: "avi",
            mime: "video/x-msvideo"
          };
        }
        if (buf[0] === 48 && buf[1] === 38 && buf[2] === 178 && buf[3] === 117 && buf[4] === 142 && buf[5] === 102 && buf[6] === 207 && buf[7] === 17 && buf[8] === 166 && buf[9] === 217) {
          return {
            ext: "wmv",
            mime: "video/x-ms-wmv"
          };
        }
        if (buf[0] === 0 && buf[1] === 0 && buf[2] === 1 && buf[3].toString(16)[0] === "b") {
          return {
            ext: "mpg",
            mime: "video/mpeg"
          };
        }
        if (buf[0] === 73 && buf[1] === 68 && buf[2] === 51 || buf[0] === 255 && buf[1] === 251) {
          return {
            ext: "mp3",
            mime: "audio/mpeg"
          };
        }
        if (buf[4] === 102 && buf[5] === 116 && buf[6] === 121 && buf[7] === 112 && buf[8] === 77 && buf[9] === 52 && buf[10] === 65 || buf[0] === 77 && buf[1] === 52 && buf[2] === 65 && buf[3] === 32) {
          return {
            ext: "m4a",
            mime: "audio/m4a"
          };
        }
        if (buf[28] === 79 && buf[29] === 112 && buf[30] === 117 && buf[31] === 115 && buf[32] === 72 && buf[33] === 101 && buf[34] === 97 && buf[35] === 100) {
          return {
            ext: "opus",
            mime: "audio/opus"
          };
        }
        if (buf[0] === 79 && buf[1] === 103 && buf[2] === 103 && buf[3] === 83) {
          return {
            ext: "ogg",
            mime: "audio/ogg"
          };
        }
        if (buf[0] === 102 && buf[1] === 76 && buf[2] === 97 && buf[3] === 67) {
          return {
            ext: "flac",
            mime: "audio/x-flac"
          };
        }
        if (buf[0] === 82 && buf[1] === 73 && buf[2] === 70 && buf[3] === 70 && buf[8] === 87 && buf[9] === 65 && buf[10] === 86 && buf[11] === 69) {
          return {
            ext: "wav",
            mime: "audio/x-wav"
          };
        }
        if (buf[0] === 35 && buf[1] === 33 && buf[2] === 65 && buf[3] === 77 && buf[4] === 82 && buf[5] === 10) {
          return {
            ext: "amr",
            mime: "audio/amr"
          };
        }
        if (buf[0] === 37 && buf[1] === 80 && buf[2] === 68 && buf[3] === 70) {
          return {
            ext: "pdf",
            mime: "application/pdf"
          };
        }
        if (buf[0] === 77 && buf[1] === 90) {
          return {
            ext: "exe",
            mime: "application/x-msdownload"
          };
        }
        if ((buf[0] === 67 || buf[0] === 70) && buf[1] === 87 && buf[2] === 83) {
          return {
            ext: "swf",
            mime: "application/x-shockwave-flash"
          };
        }
        if (buf[0] === 123 && buf[1] === 92 && buf[2] === 114 && buf[3] === 116 && buf[4] === 102) {
          return {
            ext: "rtf",
            mime: "application/rtf"
          };
        }
        if (buf[0] === 119 && buf[1] === 79 && buf[2] === 70 && buf[3] === 70 && (buf[4] === 0 && buf[5] === 1 && buf[6] === 0 && buf[7] === 0 || buf[4] === 79 && buf[5] === 84 && buf[6] === 84 && buf[7] === 79)) {
          return {
            ext: "woff",
            mime: "application/font-woff"
          };
        }
        if (buf[0] === 119 && buf[1] === 79 && buf[2] === 70 && buf[3] === 50 && (buf[4] === 0 && buf[5] === 1 && buf[6] === 0 && buf[7] === 0 || buf[4] === 79 && buf[5] === 84 && buf[6] === 84 && buf[7] === 79)) {
          return {
            ext: "woff2",
            mime: "application/font-woff"
          };
        }
        if (buf[34] === 76 && buf[35] === 80 && (buf[8] === 0 && buf[9] === 0 && buf[10] === 1 || buf[8] === 1 && buf[9] === 0 && buf[10] === 2 || buf[8] === 2 && buf[9] === 0 && buf[10] === 2)) {
          return {
            ext: "eot",
            mime: "application/octet-stream"
          };
        }
        if (buf[0] === 0 && buf[1] === 1 && buf[2] === 0 && buf[3] === 0 && buf[4] === 0) {
          return {
            ext: "ttf",
            mime: "application/font-sfnt"
          };
        }
        if (buf[0] === 79 && buf[1] === 84 && buf[2] === 84 && buf[3] === 79 && buf[4] === 0) {
          return {
            ext: "otf",
            mime: "application/font-sfnt"
          };
        }
        if (buf[0] === 0 && buf[1] === 0 && buf[2] === 1 && buf[3] === 0) {
          return {
            ext: "ico",
            mime: "image/x-icon"
          };
        }
        if (buf[0] === 70 && buf[1] === 76 && buf[2] === 86 && buf[3] === 1) {
          return {
            ext: "flv",
            mime: "video/x-flv"
          };
        }
        if (buf[0] === 37 && buf[1] === 33) {
          return {
            ext: "ps",
            mime: "application/postscript"
          };
        }
        if (buf[0] === 253 && buf[1] === 55 && buf[2] === 122 && buf[3] === 88 && buf[4] === 90 && buf[5] === 0) {
          return {
            ext: "xz",
            mime: "application/x-xz"
          };
        }
        if (buf[0] === 83 && buf[1] === 81 && buf[2] === 76 && buf[3] === 105) {
          return {
            ext: "sqlite",
            mime: "application/x-sqlite3"
          };
        }
        if (buf[0] === 78 && buf[1] === 69 && buf[2] === 83 && buf[3] === 26) {
          return {
            ext: "nes",
            mime: "application/x-nintendo-nes-rom"
          };
        }
        if (buf[0] === 67 && buf[1] === 114 && buf[2] === 50 && buf[3] === 52) {
          return {
            ext: "crx",
            mime: "application/x-google-chrome-extension"
          };
        }
        if (buf[0] === 77 && buf[1] === 83 && buf[2] === 67 && buf[3] === 70 || buf[0] === 73 && buf[1] === 83 && buf[2] === 99 && buf[3] === 40) {
          return {
            ext: "cab",
            mime: "application/vnd.ms-cab-compressed"
          };
        }
        if (buf[0] === 33 && buf[1] === 60 && buf[2] === 97 && buf[3] === 114 && buf[4] === 99 && buf[5] === 104 && buf[6] === 62 && buf[7] === 10 && buf[8] === 100 && buf[9] === 101 && buf[10] === 98 && buf[11] === 105 && buf[12] === 97 && buf[13] === 110 && buf[14] === 45 && buf[15] === 98 && buf[16] === 105 && buf[17] === 110 && buf[18] === 97 && buf[19] === 114 && buf[20] === 121) {
          return {
            ext: "deb",
            mime: "application/x-deb"
          };
        }
        if (buf[0] === 33 && buf[1] === 60 && buf[2] === 97 && buf[3] === 114 && buf[4] === 99 && buf[5] === 104 && buf[6] === 62) {
          return {
            ext: "ar",
            mime: "application/x-unix-archive"
          };
        }
        if (buf[0] === 237 && buf[1] === 171 && buf[2] === 238 && buf[3] === 219) {
          return {
            ext: "rpm",
            mime: "application/x-rpm"
          };
        }
        if (buf[0] === 31 && buf[1] === 160 || buf[0] === 31 && buf[1] === 157) {
          return {
            ext: "Z",
            mime: "application/x-compress"
          };
        }
        if (buf[0] === 76 && buf[1] === 90 && buf[2] === 73 && buf[3] === 80) {
          return {
            ext: "lz",
            mime: "application/x-lzip"
          };
        }
        if (buf[0] === 208 && buf[1] === 207 && buf[2] === 17 && buf[3] === 224 && buf[4] === 161 && buf[5] === 177 && buf[6] === 26 && buf[7] === 225) {
          return {
            ext: "msi",
            mime: "application/x-msi"
          };
        }
        return null;
      };
    }
  });

  // ../../node_modules/pinkie/index.js
  var require_pinkie = __commonJS({
    "../../node_modules/pinkie/index.js"(exports, module) {
      "use strict";
      var PENDING = "pending";
      var SETTLED = "settled";
      var FULFILLED = "fulfilled";
      var REJECTED = "rejected";
      var NOOP = function() {
      };
      var isNode = typeof global !== "undefined" && typeof global.process !== "undefined" && typeof global.process.emit === "function";
      var asyncSetTimer = typeof setImmediate === "undefined" ? setTimeout : setImmediate;
      var asyncQueue = [];
      var asyncTimer;
      function asyncFlush() {
        for (var i = 0; i < asyncQueue.length; i++) {
          asyncQueue[i][0](asyncQueue[i][1]);
        }
        asyncQueue = [];
        asyncTimer = false;
      }
      function asyncCall(callback, arg) {
        asyncQueue.push([callback, arg]);
        if (!asyncTimer) {
          asyncTimer = true;
          asyncSetTimer(asyncFlush, 0);
        }
      }
      function invokeResolver(resolver, promise) {
        function resolvePromise(value) {
          resolve(promise, value);
        }
        function rejectPromise(reason) {
          reject(promise, reason);
        }
        try {
          resolver(resolvePromise, rejectPromise);
        } catch (e) {
          rejectPromise(e);
        }
      }
      function invokeCallback(subscriber) {
        var owner = subscriber.owner;
        var settled = owner._state;
        var value = owner._data;
        var callback = subscriber[settled];
        var promise = subscriber.then;
        if (typeof callback === "function") {
          settled = FULFILLED;
          try {
            value = callback(value);
          } catch (e) {
            reject(promise, e);
          }
        }
        if (!handleThenable(promise, value)) {
          if (settled === FULFILLED) {
            resolve(promise, value);
          }
          if (settled === REJECTED) {
            reject(promise, value);
          }
        }
      }
      function handleThenable(promise, value) {
        var resolved;
        try {
          if (promise === value) {
            throw new TypeError("A promises callback cannot return that same promise.");
          }
          if (value && (typeof value === "function" || typeof value === "object")) {
            var then = value.then;
            if (typeof then === "function") {
              then.call(value, function(val) {
                if (!resolved) {
                  resolved = true;
                  if (value === val) {
                    fulfill(promise, val);
                  } else {
                    resolve(promise, val);
                  }
                }
              }, function(reason) {
                if (!resolved) {
                  resolved = true;
                  reject(promise, reason);
                }
              });
              return true;
            }
          }
        } catch (e) {
          if (!resolved) {
            reject(promise, e);
          }
          return true;
        }
        return false;
      }
      function resolve(promise, value) {
        if (promise === value || !handleThenable(promise, value)) {
          fulfill(promise, value);
        }
      }
      function fulfill(promise, value) {
        if (promise._state === PENDING) {
          promise._state = SETTLED;
          promise._data = value;
          asyncCall(publishFulfillment, promise);
        }
      }
      function reject(promise, reason) {
        if (promise._state === PENDING) {
          promise._state = SETTLED;
          promise._data = reason;
          asyncCall(publishRejection, promise);
        }
      }
      function publish(promise) {
        promise._then = promise._then.forEach(invokeCallback);
      }
      function publishFulfillment(promise) {
        promise._state = FULFILLED;
        publish(promise);
      }
      function publishRejection(promise) {
        promise._state = REJECTED;
        publish(promise);
        if (!promise._handled && isNode) {
          global.process.emit("unhandledRejection", promise._data, promise);
        }
      }
      function notifyRejectionHandled(promise) {
        global.process.emit("rejectionHandled", promise);
      }
      function Promise2(resolver) {
        if (typeof resolver !== "function") {
          throw new TypeError("Promise resolver " + resolver + " is not a function");
        }
        if (this instanceof Promise2 === false) {
          throw new TypeError("Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function.");
        }
        this._then = [];
        invokeResolver(resolver, this);
      }
      Promise2.prototype = {
        constructor: Promise2,
        _state: PENDING,
        _then: null,
        _data: void 0,
        _handled: false,
        then: function(onFulfillment, onRejection) {
          var subscriber = {
            owner: this,
            then: new this.constructor(NOOP),
            fulfilled: onFulfillment,
            rejected: onRejection
          };
          if ((onRejection || onFulfillment) && !this._handled) {
            this._handled = true;
            if (this._state === REJECTED && isNode) {
              asyncCall(notifyRejectionHandled, this);
            }
          }
          if (this._state === FULFILLED || this._state === REJECTED) {
            asyncCall(invokeCallback, subscriber);
          } else {
            this._then.push(subscriber);
          }
          return subscriber.then;
        },
        catch: function(onRejection) {
          return this.then(null, onRejection);
        }
      };
      Promise2.all = function(promises) {
        if (!Array.isArray(promises)) {
          throw new TypeError("You must pass an array to Promise.all().");
        }
        return new Promise2(function(resolve2, reject2) {
          var results = [];
          var remaining = 0;
          function resolver(index) {
            remaining++;
            return function(value) {
              results[index] = value;
              if (!--remaining) {
                resolve2(results);
              }
            };
          }
          for (var i = 0, promise; i < promises.length; i++) {
            promise = promises[i];
            if (promise && typeof promise.then === "function") {
              promise.then(resolver(i), reject2);
            } else {
              results[i] = promise;
            }
          }
          if (!remaining) {
            resolve2(results);
          }
        });
      };
      Promise2.race = function(promises) {
        if (!Array.isArray(promises)) {
          throw new TypeError("You must pass an array to Promise.race().");
        }
        return new Promise2(function(resolve2, reject2) {
          for (var i = 0, promise; i < promises.length; i++) {
            promise = promises[i];
            if (promise && typeof promise.then === "function") {
              promise.then(resolve2, reject2);
            } else {
              resolve2(promise);
            }
          }
        });
      };
      Promise2.resolve = function(value) {
        if (value && typeof value === "object" && value.constructor === Promise2) {
          return value;
        }
        return new Promise2(function(resolve2) {
          resolve2(value);
        });
      };
      Promise2.reject = function(reason) {
        return new Promise2(function(resolve2, reject2) {
          reject2(reason);
        });
      };
      module.exports = Promise2;
    }
  });

  // ../../node_modules/pinkie-promise/index.js
  var require_pinkie_promise = __commonJS({
    "../../node_modules/pinkie-promise/index.js"(exports, module) {
      "use strict";
      module.exports = typeof Promise === "function" ? Promise : require_pinkie();
    }
  });

  // ../../node_modules/object-assign/index.js
  var require_object_assign = __commonJS({
    "../../node_modules/object-assign/index.js"(exports, module) {
      "use strict";
      var getOwnPropertySymbols = Object.getOwnPropertySymbols;
      var hasOwnProperty = Object.prototype.hasOwnProperty;
      var propIsEnumerable = Object.prototype.propertyIsEnumerable;
      function toObject(val) {
        if (val === null || val === void 0) {
          throw new TypeError("Object.assign cannot be called with null or undefined");
        }
        return Object(val);
      }
      function shouldUseNative() {
        try {
          if (!Object.assign) {
            return false;
          }
          var test1 = new String("abc");
          test1[5] = "de";
          if (Object.getOwnPropertyNames(test1)[0] === "5") {
            return false;
          }
          var test2 = {};
          for (var i = 0; i < 10; i++) {
            test2["_" + String.fromCharCode(i)] = i;
          }
          var order2 = Object.getOwnPropertyNames(test2).map(function(n) {
            return test2[n];
          });
          if (order2.join("") !== "0123456789") {
            return false;
          }
          var test3 = {};
          "abcdefghijklmnopqrst".split("").forEach(function(letter) {
            test3[letter] = letter;
          });
          if (Object.keys(Object.assign({}, test3)).join("") !== "abcdefghijklmnopqrst") {
            return false;
          }
          return true;
        } catch (err) {
          return false;
        }
      }
      module.exports = shouldUseNative() ? Object.assign : function(target, source) {
        var from;
        var to = toObject(target);
        var symbols;
        for (var s = 1; s < arguments.length; s++) {
          from = Object(arguments[s]);
          for (var key in from) {
            if (hasOwnProperty.call(from, key)) {
              to[key] = from[key];
            }
          }
          if (getOwnPropertySymbols) {
            symbols = getOwnPropertySymbols(from);
            for (var i = 0; i < symbols.length; i++) {
              if (propIsEnumerable.call(from, symbols[i])) {
                to[symbols[i]] = from[symbols[i]];
              }
            }
          }
        }
        return to;
      };
    }
  });

  // ../../node_modules/get-stream/buffer-stream.js
  var require_buffer_stream = __commonJS({
    "../../node_modules/get-stream/buffer-stream.js"(exports, module) {
      var PassThrough = __require("stream").PassThrough;
      var objectAssign = require_object_assign();
      module.exports = function(opts) {
        opts = objectAssign({}, opts);
        var array = opts.array;
        var encoding = opts.encoding;
        var buffer = encoding === "buffer";
        var objectMode = false;
        if (array) {
          objectMode = !(encoding || buffer);
        } else {
          encoding = encoding || "utf8";
        }
        if (buffer) {
          encoding = null;
        }
        var len = 0;
        var ret = [];
        var stream = new PassThrough({ objectMode });
        if (encoding) {
          stream.setEncoding(encoding);
        }
        stream.on("data", function(chunk) {
          ret.push(chunk);
          if (objectMode) {
            len = ret.length;
          } else {
            len += chunk.length;
          }
        });
        stream.getBufferedValue = function() {
          if (array) {
            return ret;
          }
          return buffer ? Buffer.concat(ret, len) : ret.join("");
        };
        stream.getBufferedLength = function() {
          return len;
        };
        return stream;
      };
    }
  });

  // ../../node_modules/get-stream/index.js
  var require_get_stream = __commonJS({
    "../../node_modules/get-stream/index.js"(exports, module) {
      "use strict";
      var Promise2 = require_pinkie_promise();
      var objectAssign = require_object_assign();
      var bufferStream = require_buffer_stream();
      function getStream(inputStream, opts) {
        if (!inputStream) {
          return Promise2.reject(new Error("Expected a stream"));
        }
        opts = objectAssign({ maxBuffer: Infinity }, opts);
        var maxBuffer = opts.maxBuffer;
        var stream;
        var clean;
        var p = new Promise2(function(resolve, reject) {
          stream = bufferStream(opts);
          inputStream.once("error", error);
          inputStream.pipe(stream);
          stream.on("data", function() {
            if (stream.getBufferedLength() > maxBuffer) {
              reject(new Error("maxBuffer exceeded"));
            }
          });
          stream.once("error", error);
          stream.on("end", resolve);
          clean = function() {
            if (inputStream.unpipe) {
              inputStream.unpipe(stream);
            }
          };
          function error(err) {
            if (err) {
              err.bufferedData = stream.getBufferedValue();
            }
            reject(err);
          }
        });
        p.then(clean, clean);
        return p.then(function() {
          return stream.getBufferedValue();
        });
      }
      module.exports = getStream;
      module.exports.buffer = function(stream, opts) {
        return getStream(stream, objectAssign({}, opts, { encoding: "buffer" }));
      };
      module.exports.array = function(stream, opts) {
        return getStream(stream, objectAssign({}, opts, { array: true }));
      };
    }
  });

  // ../../node_modules/decompress-unzip/node_modules/pify/index.js
  var require_pify = __commonJS({
    "../../node_modules/decompress-unzip/node_modules/pify/index.js"(exports, module) {
      "use strict";
      var processFn = function(fn, P, opts) {
        return function() {
          var that = this;
          var args = new Array(arguments.length);
          for (var i = 0; i < arguments.length; i++) {
            args[i] = arguments[i];
          }
          return new P(function(resolve, reject) {
            args.push(function(err, result) {
              if (err) {
                reject(err);
              } else if (opts.multiArgs) {
                var results = new Array(arguments.length - 1);
                for (var i2 = 1; i2 < arguments.length; i2++) {
                  results[i2 - 1] = arguments[i2];
                }
                resolve(results);
              } else {
                resolve(result);
              }
            });
            fn.apply(that, args);
          });
        };
      };
      var pify = module.exports = function(obj, P, opts) {
        if (typeof P !== "function") {
          opts = P;
          P = Promise;
        }
        opts = opts || {};
        opts.exclude = opts.exclude || [/.+Sync$/];
        var filter = function(key) {
          var match = function(pattern) {
            return typeof pattern === "string" ? key === pattern : pattern.test(key);
          };
          return opts.include ? opts.include.some(match) : !opts.exclude.some(match);
        };
        var ret = typeof obj === "function" ? function() {
          if (opts.excludeMain) {
            return obj.apply(this, arguments);
          }
          return processFn(obj, P, opts).apply(this, arguments);
        } : {};
        return Object.keys(obj).reduce(function(ret2, key) {
          var x = obj[key];
          ret2[key] = typeof x === "function" && filter(key) ? processFn(x, P, opts) : x;
          return ret2;
        }, ret);
      };
      pify.all = pify;
    }
  });

  // ../../node_modules/pend/index.js
  var require_pend = __commonJS({
    "../../node_modules/pend/index.js"(exports, module) {
      module.exports = Pend;
      function Pend() {
        this.pending = 0;
        this.max = Infinity;
        this.listeners = [];
        this.waiting = [];
        this.error = null;
      }
      Pend.prototype.go = function(fn) {
        if (this.pending < this.max) {
          pendGo(this, fn);
        } else {
          this.waiting.push(fn);
        }
      };
      Pend.prototype.wait = function(cb) {
        if (this.pending === 0) {
          cb(this.error);
        } else {
          this.listeners.push(cb);
        }
      };
      Pend.prototype.hold = function() {
        return pendHold(this);
      };
      function pendHold(self2) {
        self2.pending += 1;
        var called = false;
        return onCb;
        function onCb(err) {
          if (called) throw new Error("callback called twice");
          called = true;
          self2.error = self2.error || err;
          self2.pending -= 1;
          if (self2.waiting.length > 0 && self2.pending < self2.max) {
            pendGo(self2, self2.waiting.shift());
          } else if (self2.pending === 0) {
            var listeners = self2.listeners;
            self2.listeners = [];
            listeners.forEach(cbListener);
          }
        }
        function cbListener(listener) {
          listener(self2.error);
        }
      }
      function pendGo(self2, fn) {
        fn(pendHold(self2));
      }
    }
  });

  // ../../node_modules/fd-slicer/index.js
  var require_fd_slicer = __commonJS({
    "../../node_modules/fd-slicer/index.js"(exports) {
      var fs = require_bare_node_fs();
      var util = __require("util");
      var stream = __require("stream");
      var Readable = stream.Readable;
      var Writable = stream.Writable;
      var PassThrough = stream.PassThrough;
      var Pend = require_pend();
      var EventEmitter = require_bare_node_events().EventEmitter;
      exports.createFromBuffer = createFromBuffer;
      exports.createFromFd = createFromFd;
      exports.BufferSlicer = BufferSlicer;
      exports.FdSlicer = FdSlicer;
      util.inherits(FdSlicer, EventEmitter);
      function FdSlicer(fd, options) {
        options = options || {};
        EventEmitter.call(this);
        this.fd = fd;
        this.pend = new Pend();
        this.pend.max = 1;
        this.refCount = 0;
        this.autoClose = !!options.autoClose;
      }
      FdSlicer.prototype.read = function(buffer, offset, length, position, callback) {
        var self2 = this;
        self2.pend.go(function(cb) {
          fs.read(self2.fd, buffer, offset, length, position, function(err, bytesRead, buffer2) {
            cb();
            callback(err, bytesRead, buffer2);
          });
        });
      };
      FdSlicer.prototype.write = function(buffer, offset, length, position, callback) {
        var self2 = this;
        self2.pend.go(function(cb) {
          fs.write(self2.fd, buffer, offset, length, position, function(err, written, buffer2) {
            cb();
            callback(err, written, buffer2);
          });
        });
      };
      FdSlicer.prototype.createReadStream = function(options) {
        return new ReadStream(this, options);
      };
      FdSlicer.prototype.createWriteStream = function(options) {
        return new WriteStream(this, options);
      };
      FdSlicer.prototype.ref = function() {
        this.refCount += 1;
      };
      FdSlicer.prototype.unref = function() {
        var self2 = this;
        self2.refCount -= 1;
        if (self2.refCount > 0) return;
        if (self2.refCount < 0) throw new Error("invalid unref");
        if (self2.autoClose) {
          fs.close(self2.fd, onCloseDone);
        }
        function onCloseDone(err) {
          if (err) {
            self2.emit("error", err);
          } else {
            self2.emit("close");
          }
        }
      };
      util.inherits(ReadStream, Readable);
      function ReadStream(context, options) {
        options = options || {};
        Readable.call(this, options);
        this.context = context;
        this.context.ref();
        this.start = options.start || 0;
        this.endOffset = options.end;
        this.pos = this.start;
        this.destroyed = false;
      }
      ReadStream.prototype._read = function(n) {
        var self2 = this;
        if (self2.destroyed) return;
        var toRead = Math.min(self2._readableState.highWaterMark, n);
        if (self2.endOffset != null) {
          toRead = Math.min(toRead, self2.endOffset - self2.pos);
        }
        if (toRead <= 0) {
          self2.destroyed = true;
          self2.push(null);
          self2.context.unref();
          return;
        }
        self2.context.pend.go(function(cb) {
          if (self2.destroyed) return cb();
          var buffer = new Buffer(toRead);
          fs.read(self2.context.fd, buffer, 0, toRead, self2.pos, function(err, bytesRead) {
            if (err) {
              self2.destroy(err);
            } else if (bytesRead === 0) {
              self2.destroyed = true;
              self2.push(null);
              self2.context.unref();
            } else {
              self2.pos += bytesRead;
              self2.push(buffer.slice(0, bytesRead));
            }
            cb();
          });
        });
      };
      ReadStream.prototype.destroy = function(err) {
        if (this.destroyed) return;
        err = err || new Error("stream destroyed");
        this.destroyed = true;
        this.emit("error", err);
        this.context.unref();
      };
      util.inherits(WriteStream, Writable);
      function WriteStream(context, options) {
        options = options || {};
        Writable.call(this, options);
        this.context = context;
        this.context.ref();
        this.start = options.start || 0;
        this.endOffset = options.end == null ? Infinity : +options.end;
        this.bytesWritten = 0;
        this.pos = this.start;
        this.destroyed = false;
        this.on("finish", this.destroy.bind(this));
      }
      WriteStream.prototype._write = function(buffer, encoding, callback) {
        var self2 = this;
        if (self2.destroyed) return;
        if (self2.pos + buffer.length > self2.endOffset) {
          var err = new Error("maximum file length exceeded");
          err.code = "ETOOBIG";
          self2.destroy();
          callback(err);
          return;
        }
        self2.context.pend.go(function(cb) {
          if (self2.destroyed) return cb();
          fs.write(self2.context.fd, buffer, 0, buffer.length, self2.pos, function(err2, bytes) {
            if (err2) {
              self2.destroy();
              cb();
              callback(err2);
            } else {
              self2.bytesWritten += bytes;
              self2.pos += bytes;
              self2.emit("progress");
              cb();
              callback();
            }
          });
        });
      };
      WriteStream.prototype.destroy = function() {
        if (this.destroyed) return;
        this.destroyed = true;
        this.context.unref();
      };
      util.inherits(BufferSlicer, EventEmitter);
      function BufferSlicer(buffer, options) {
        EventEmitter.call(this);
        options = options || {};
        this.refCount = 0;
        this.buffer = buffer;
        this.maxChunkSize = options.maxChunkSize || Number.MAX_SAFE_INTEGER;
      }
      BufferSlicer.prototype.read = function(buffer, offset, length, position, callback) {
        var end = position + length;
        var delta = end - this.buffer.length;
        var written = delta > 0 ? delta : length;
        this.buffer.copy(buffer, offset, position, end);
        setImmediate(function() {
          callback(null, written);
        });
      };
      BufferSlicer.prototype.write = function(buffer, offset, length, position, callback) {
        buffer.copy(this.buffer, position, offset, offset + length);
        setImmediate(function() {
          callback(null, length, buffer);
        });
      };
      BufferSlicer.prototype.createReadStream = function(options) {
        options = options || {};
        var readStream = new PassThrough(options);
        readStream.destroyed = false;
        readStream.start = options.start || 0;
        readStream.endOffset = options.end;
        readStream.pos = readStream.endOffset || this.buffer.length;
        var entireSlice = this.buffer.slice(readStream.start, readStream.pos);
        var offset = 0;
        while (true) {
          var nextOffset = offset + this.maxChunkSize;
          if (nextOffset >= entireSlice.length) {
            if (offset < entireSlice.length) {
              readStream.write(entireSlice.slice(offset, entireSlice.length));
            }
            break;
          }
          readStream.write(entireSlice.slice(offset, nextOffset));
          offset = nextOffset;
        }
        readStream.end();
        readStream.destroy = function() {
          readStream.destroyed = true;
        };
        return readStream;
      };
      BufferSlicer.prototype.createWriteStream = function(options) {
        var bufferSlicer = this;
        options = options || {};
        var writeStream = new Writable(options);
        writeStream.start = options.start || 0;
        writeStream.endOffset = options.end == null ? this.buffer.length : +options.end;
        writeStream.bytesWritten = 0;
        writeStream.pos = writeStream.start;
        writeStream.destroyed = false;
        writeStream._write = function(buffer, encoding, callback) {
          if (writeStream.destroyed) return;
          var end = writeStream.pos + buffer.length;
          if (end > writeStream.endOffset) {
            var err = new Error("maximum file length exceeded");
            err.code = "ETOOBIG";
            writeStream.destroyed = true;
            callback(err);
            return;
          }
          buffer.copy(bufferSlicer.buffer, writeStream.pos, 0, buffer.length);
          writeStream.bytesWritten += buffer.length;
          writeStream.pos = end;
          writeStream.emit("progress");
          callback();
        };
        writeStream.destroy = function() {
          writeStream.destroyed = true;
        };
        return writeStream;
      };
      BufferSlicer.prototype.ref = function() {
        this.refCount += 1;
      };
      BufferSlicer.prototype.unref = function() {
        this.refCount -= 1;
        if (this.refCount < 0) {
          throw new Error("invalid unref");
        }
      };
      function createFromBuffer(buffer, options) {
        return new BufferSlicer(buffer, options);
      }
      function createFromFd(fd, options) {
        return new FdSlicer(fd, options);
      }
    }
  });

  // ../../node_modules/buffer-crc32/index.js
  var require_buffer_crc32 = __commonJS({
    "../../node_modules/buffer-crc32/index.js"(exports, module) {
      var Buffer2 = __require("buffer").Buffer;
      var CRC_TABLE = [
        0,
        1996959894,
        3993919788,
        2567524794,
        124634137,
        1886057615,
        3915621685,
        2657392035,
        249268274,
        2044508324,
        3772115230,
        2547177864,
        162941995,
        2125561021,
        3887607047,
        2428444049,
        498536548,
        1789927666,
        4089016648,
        2227061214,
        450548861,
        1843258603,
        4107580753,
        2211677639,
        325883990,
        1684777152,
        4251122042,
        2321926636,
        335633487,
        1661365465,
        4195302755,
        2366115317,
        997073096,
        1281953886,
        3579855332,
        2724688242,
        1006888145,
        1258607687,
        3524101629,
        2768942443,
        901097722,
        1119000684,
        3686517206,
        2898065728,
        853044451,
        1172266101,
        3705015759,
        2882616665,
        651767980,
        1373503546,
        3369554304,
        3218104598,
        565507253,
        1454621731,
        3485111705,
        3099436303,
        671266974,
        1594198024,
        3322730930,
        2970347812,
        795835527,
        1483230225,
        3244367275,
        3060149565,
        1994146192,
        31158534,
        2563907772,
        4023717930,
        1907459465,
        112637215,
        2680153253,
        3904427059,
        2013776290,
        251722036,
        2517215374,
        3775830040,
        2137656763,
        141376813,
        2439277719,
        3865271297,
        1802195444,
        476864866,
        2238001368,
        4066508878,
        1812370925,
        453092731,
        2181625025,
        4111451223,
        1706088902,
        314042704,
        2344532202,
        4240017532,
        1658658271,
        366619977,
        2362670323,
        4224994405,
        1303535960,
        984961486,
        2747007092,
        3569037538,
        1256170817,
        1037604311,
        2765210733,
        3554079995,
        1131014506,
        879679996,
        2909243462,
        3663771856,
        1141124467,
        855842277,
        2852801631,
        3708648649,
        1342533948,
        654459306,
        3188396048,
        3373015174,
        1466479909,
        544179635,
        3110523913,
        3462522015,
        1591671054,
        702138776,
        2966460450,
        3352799412,
        1504918807,
        783551873,
        3082640443,
        3233442989,
        3988292384,
        2596254646,
        62317068,
        1957810842,
        3939845945,
        2647816111,
        81470997,
        1943803523,
        3814918930,
        2489596804,
        225274430,
        2053790376,
        3826175755,
        2466906013,
        167816743,
        2097651377,
        4027552580,
        2265490386,
        503444072,
        1762050814,
        4150417245,
        2154129355,
        426522225,
        1852507879,
        4275313526,
        2312317920,
        282753626,
        1742555852,
        4189708143,
        2394877945,
        397917763,
        1622183637,
        3604390888,
        2714866558,
        953729732,
        1340076626,
        3518719985,
        2797360999,
        1068828381,
        1219638859,
        3624741850,
        2936675148,
        906185462,
        1090812512,
        3747672003,
        2825379669,
        829329135,
        1181335161,
        3412177804,
        3160834842,
        628085408,
        1382605366,
        3423369109,
        3138078467,
        570562233,
        1426400815,
        3317316542,
        2998733608,
        733239954,
        1555261956,
        3268935591,
        3050360625,
        752459403,
        1541320221,
        2607071920,
        3965973030,
        1969922972,
        40735498,
        2617837225,
        3943577151,
        1913087877,
        83908371,
        2512341634,
        3803740692,
        2075208622,
        213261112,
        2463272603,
        3855990285,
        2094854071,
        198958881,
        2262029012,
        4057260610,
        1759359992,
        534414190,
        2176718541,
        4139329115,
        1873836001,
        414664567,
        2282248934,
        4279200368,
        1711684554,
        285281116,
        2405801727,
        4167216745,
        1634467795,
        376229701,
        2685067896,
        3608007406,
        1308918612,
        956543938,
        2808555105,
        3495958263,
        1231636301,
        1047427035,
        2932959818,
        3654703836,
        1088359270,
        936918e3,
        2847714899,
        3736837829,
        1202900863,
        817233897,
        3183342108,
        3401237130,
        1404277552,
        615818150,
        3134207493,
        3453421203,
        1423857449,
        601450431,
        3009837614,
        3294710456,
        1567103746,
        711928724,
        3020668471,
        3272380065,
        1510334235,
        755167117
      ];
      if (typeof Int32Array !== "undefined") {
        CRC_TABLE = new Int32Array(CRC_TABLE);
      }
      function ensureBuffer(input) {
        if (Buffer2.isBuffer(input)) {
          return input;
        }
        var hasNewBufferAPI = typeof Buffer2.alloc === "function" && typeof Buffer2.from === "function";
        if (typeof input === "number") {
          return hasNewBufferAPI ? Buffer2.alloc(input) : new Buffer2(input);
        } else if (typeof input === "string") {
          return hasNewBufferAPI ? Buffer2.from(input) : new Buffer2(input);
        } else {
          throw new Error("input must be buffer, number, or string, received " + typeof input);
        }
      }
      function bufferizeInt(num) {
        var tmp = ensureBuffer(4);
        tmp.writeInt32BE(num, 0);
        return tmp;
      }
      function _crc32(buf, previous) {
        buf = ensureBuffer(buf);
        if (Buffer2.isBuffer(previous)) {
          previous = previous.readUInt32BE(0);
        }
        var crc = ~~previous ^ -1;
        for (var n = 0; n < buf.length; n++) {
          crc = CRC_TABLE[(crc ^ buf[n]) & 255] ^ crc >>> 8;
        }
        return crc ^ -1;
      }
      function crc32() {
        return bufferizeInt(_crc32.apply(null, arguments));
      }
      crc32.signed = function() {
        return _crc32.apply(null, arguments);
      };
      crc32.unsigned = function() {
        return _crc32.apply(null, arguments) >>> 0;
      };
      module.exports = crc32;
    }
  });

  // ../../node_modules/yauzl/index.js
  var require_yauzl = __commonJS({
    "../../node_modules/yauzl/index.js"(exports) {
      var fs = require_bare_node_fs();
      var zlib = __require("zlib");
      var fd_slicer = require_fd_slicer();
      var crc32 = require_buffer_crc32();
      var util = __require("util");
      var EventEmitter = require_bare_node_events().EventEmitter;
      var Transform = __require("stream").Transform;
      var PassThrough = __require("stream").PassThrough;
      var Writable = __require("stream").Writable;
      exports.open = open;
      exports.fromFd = fromFd;
      exports.fromBuffer = fromBuffer;
      exports.fromRandomAccessReader = fromRandomAccessReader;
      exports.dosDateTimeToDate = dosDateTimeToDate;
      exports.validateFileName = validateFileName;
      exports.ZipFile = ZipFile;
      exports.Entry = Entry;
      exports.RandomAccessReader = RandomAccessReader;
      function open(path, options, callback) {
        if (typeof options === "function") {
          callback = options;
          options = null;
        }
        if (options == null) options = {};
        if (options.autoClose == null) options.autoClose = true;
        if (options.lazyEntries == null) options.lazyEntries = false;
        if (options.decodeStrings == null) options.decodeStrings = true;
        if (options.validateEntrySizes == null) options.validateEntrySizes = true;
        if (options.strictFileNames == null) options.strictFileNames = false;
        if (callback == null) callback = defaultCallback;
        fs.open(path, "r", function(err, fd) {
          if (err) return callback(err);
          fromFd(fd, options, function(err2, zipfile) {
            if (err2) fs.close(fd, defaultCallback);
            callback(err2, zipfile);
          });
        });
      }
      function fromFd(fd, options, callback) {
        if (typeof options === "function") {
          callback = options;
          options = null;
        }
        if (options == null) options = {};
        if (options.autoClose == null) options.autoClose = false;
        if (options.lazyEntries == null) options.lazyEntries = false;
        if (options.decodeStrings == null) options.decodeStrings = true;
        if (options.validateEntrySizes == null) options.validateEntrySizes = true;
        if (options.strictFileNames == null) options.strictFileNames = false;
        if (callback == null) callback = defaultCallback;
        fs.fstat(fd, function(err, stats) {
          if (err) return callback(err);
          var reader = fd_slicer.createFromFd(fd, { autoClose: true });
          fromRandomAccessReader(reader, stats.size, options, callback);
        });
      }
      function fromBuffer(buffer, options, callback) {
        if (typeof options === "function") {
          callback = options;
          options = null;
        }
        if (options == null) options = {};
        options.autoClose = false;
        if (options.lazyEntries == null) options.lazyEntries = false;
        if (options.decodeStrings == null) options.decodeStrings = true;
        if (options.validateEntrySizes == null) options.validateEntrySizes = true;
        if (options.strictFileNames == null) options.strictFileNames = false;
        var reader = fd_slicer.createFromBuffer(buffer, { maxChunkSize: 65536 });
        fromRandomAccessReader(reader, buffer.length, options, callback);
      }
      function fromRandomAccessReader(reader, totalSize, options, callback) {
        if (typeof options === "function") {
          callback = options;
          options = null;
        }
        if (options == null) options = {};
        if (options.autoClose == null) options.autoClose = true;
        if (options.lazyEntries == null) options.lazyEntries = false;
        if (options.decodeStrings == null) options.decodeStrings = true;
        var decodeStrings = !!options.decodeStrings;
        if (options.validateEntrySizes == null) options.validateEntrySizes = true;
        if (options.strictFileNames == null) options.strictFileNames = false;
        if (callback == null) callback = defaultCallback;
        if (typeof totalSize !== "number") throw new Error("expected totalSize parameter to be a number");
        if (totalSize > Number.MAX_SAFE_INTEGER) {
          throw new Error("zip file too large. only file sizes up to 2^52 are supported due to JavaScript's Number type being an IEEE 754 double.");
        }
        reader.ref();
        var eocdrWithoutCommentSize = 22;
        var maxCommentSize = 65535;
        var bufferSize = Math.min(eocdrWithoutCommentSize + maxCommentSize, totalSize);
        var buffer = newBuffer(bufferSize);
        var bufferReadStart = totalSize - buffer.length;
        readAndAssertNoEof(reader, buffer, 0, bufferSize, bufferReadStart, function(err) {
          if (err) return callback(err);
          for (var i = bufferSize - eocdrWithoutCommentSize; i >= 0; i -= 1) {
            if (buffer.readUInt32LE(i) !== 101010256) continue;
            var eocdrBuffer = buffer.slice(i);
            var diskNumber = eocdrBuffer.readUInt16LE(4);
            if (diskNumber !== 0) {
              return callback(new Error("multi-disk zip files are not supported: found disk number: " + diskNumber));
            }
            var entryCount = eocdrBuffer.readUInt16LE(10);
            var centralDirectoryOffset = eocdrBuffer.readUInt32LE(16);
            var commentLength = eocdrBuffer.readUInt16LE(20);
            var expectedCommentLength = eocdrBuffer.length - eocdrWithoutCommentSize;
            if (commentLength !== expectedCommentLength) {
              return callback(new Error("invalid comment length. expected: " + expectedCommentLength + ". found: " + commentLength));
            }
            var comment = decodeStrings ? decodeBuffer(eocdrBuffer, 22, eocdrBuffer.length, false) : eocdrBuffer.slice(22);
            if (!(entryCount === 65535 || centralDirectoryOffset === 4294967295)) {
              return callback(null, new ZipFile(reader, centralDirectoryOffset, totalSize, entryCount, comment, options.autoClose, options.lazyEntries, decodeStrings, options.validateEntrySizes, options.strictFileNames));
            }
            var zip64EocdlBuffer = newBuffer(20);
            var zip64EocdlOffset = bufferReadStart + i - zip64EocdlBuffer.length;
            readAndAssertNoEof(reader, zip64EocdlBuffer, 0, zip64EocdlBuffer.length, zip64EocdlOffset, function(err2) {
              if (err2) return callback(err2);
              if (zip64EocdlBuffer.readUInt32LE(0) !== 117853008) {
                return callback(new Error("invalid zip64 end of central directory locator signature"));
              }
              var zip64EocdrOffset = readUInt64LE(zip64EocdlBuffer, 8);
              var zip64EocdrBuffer = newBuffer(56);
              readAndAssertNoEof(reader, zip64EocdrBuffer, 0, zip64EocdrBuffer.length, zip64EocdrOffset, function(err3) {
                if (err3) return callback(err3);
                if (zip64EocdrBuffer.readUInt32LE(0) !== 101075792) {
                  return callback(new Error("invalid zip64 end of central directory record signature"));
                }
                entryCount = readUInt64LE(zip64EocdrBuffer, 32);
                centralDirectoryOffset = readUInt64LE(zip64EocdrBuffer, 48);
                return callback(null, new ZipFile(reader, centralDirectoryOffset, totalSize, entryCount, comment, options.autoClose, options.lazyEntries, decodeStrings, options.validateEntrySizes, options.strictFileNames));
              });
            });
            return;
          }
          callback(new Error("end of central directory record signature not found"));
        });
      }
      util.inherits(ZipFile, EventEmitter);
      function ZipFile(reader, centralDirectoryOffset, fileSize, entryCount, comment, autoClose, lazyEntries, decodeStrings, validateEntrySizes, strictFileNames) {
        var self2 = this;
        EventEmitter.call(self2);
        self2.reader = reader;
        self2.reader.on("error", function(err) {
          emitError(self2, err);
        });
        self2.reader.once("close", function() {
          self2.emit("close");
        });
        self2.readEntryCursor = centralDirectoryOffset;
        self2.fileSize = fileSize;
        self2.entryCount = entryCount;
        self2.comment = comment;
        self2.entriesRead = 0;
        self2.autoClose = !!autoClose;
        self2.lazyEntries = !!lazyEntries;
        self2.decodeStrings = !!decodeStrings;
        self2.validateEntrySizes = !!validateEntrySizes;
        self2.strictFileNames = !!strictFileNames;
        self2.isOpen = true;
        self2.emittedError = false;
        if (!self2.lazyEntries) self2._readEntry();
      }
      ZipFile.prototype.close = function() {
        if (!this.isOpen) return;
        this.isOpen = false;
        this.reader.unref();
      };
      function emitErrorAndAutoClose(self2, err) {
        if (self2.autoClose) self2.close();
        emitError(self2, err);
      }
      function emitError(self2, err) {
        if (self2.emittedError) return;
        self2.emittedError = true;
        self2.emit("error", err);
      }
      ZipFile.prototype.readEntry = function() {
        if (!this.lazyEntries) throw new Error("readEntry() called without lazyEntries:true");
        this._readEntry();
      };
      ZipFile.prototype._readEntry = function() {
        var self2 = this;
        if (self2.entryCount === self2.entriesRead) {
          setImmediate(function() {
            if (self2.autoClose) self2.close();
            if (self2.emittedError) return;
            self2.emit("end");
          });
          return;
        }
        if (self2.emittedError) return;
        var buffer = newBuffer(46);
        readAndAssertNoEof(self2.reader, buffer, 0, buffer.length, self2.readEntryCursor, function(err) {
          if (err) return emitErrorAndAutoClose(self2, err);
          if (self2.emittedError) return;
          var entry = new Entry();
          var signature = buffer.readUInt32LE(0);
          if (signature !== 33639248) return emitErrorAndAutoClose(self2, new Error("invalid central directory file header signature: 0x" + signature.toString(16)));
          entry.versionMadeBy = buffer.readUInt16LE(4);
          entry.versionNeededToExtract = buffer.readUInt16LE(6);
          entry.generalPurposeBitFlag = buffer.readUInt16LE(8);
          entry.compressionMethod = buffer.readUInt16LE(10);
          entry.lastModFileTime = buffer.readUInt16LE(12);
          entry.lastModFileDate = buffer.readUInt16LE(14);
          entry.crc32 = buffer.readUInt32LE(16);
          entry.compressedSize = buffer.readUInt32LE(20);
          entry.uncompressedSize = buffer.readUInt32LE(24);
          entry.fileNameLength = buffer.readUInt16LE(28);
          entry.extraFieldLength = buffer.readUInt16LE(30);
          entry.fileCommentLength = buffer.readUInt16LE(32);
          entry.internalFileAttributes = buffer.readUInt16LE(36);
          entry.externalFileAttributes = buffer.readUInt32LE(38);
          entry.relativeOffsetOfLocalHeader = buffer.readUInt32LE(42);
          if (entry.generalPurposeBitFlag & 64) return emitErrorAndAutoClose(self2, new Error("strong encryption is not supported"));
          self2.readEntryCursor += 46;
          buffer = newBuffer(entry.fileNameLength + entry.extraFieldLength + entry.fileCommentLength);
          readAndAssertNoEof(self2.reader, buffer, 0, buffer.length, self2.readEntryCursor, function(err2) {
            if (err2) return emitErrorAndAutoClose(self2, err2);
            if (self2.emittedError) return;
            var isUtf8 = (entry.generalPurposeBitFlag & 2048) !== 0;
            entry.fileName = self2.decodeStrings ? decodeBuffer(buffer, 0, entry.fileNameLength, isUtf8) : buffer.slice(0, entry.fileNameLength);
            var fileCommentStart = entry.fileNameLength + entry.extraFieldLength;
            var extraFieldBuffer = buffer.slice(entry.fileNameLength, fileCommentStart);
            entry.extraFields = [];
            var i = 0;
            while (i < extraFieldBuffer.length - 3) {
              var headerId = extraFieldBuffer.readUInt16LE(i + 0);
              var dataSize = extraFieldBuffer.readUInt16LE(i + 2);
              var dataStart = i + 4;
              var dataEnd = dataStart + dataSize;
              if (dataEnd > extraFieldBuffer.length) return emitErrorAndAutoClose(self2, new Error("extra field length exceeds extra field buffer size"));
              var dataBuffer = newBuffer(dataSize);
              extraFieldBuffer.copy(dataBuffer, 0, dataStart, dataEnd);
              entry.extraFields.push({
                id: headerId,
                data: dataBuffer
              });
              i = dataEnd;
            }
            entry.fileComment = self2.decodeStrings ? decodeBuffer(buffer, fileCommentStart, fileCommentStart + entry.fileCommentLength, isUtf8) : buffer.slice(fileCommentStart, fileCommentStart + entry.fileCommentLength);
            entry.comment = entry.fileComment;
            self2.readEntryCursor += buffer.length;
            self2.entriesRead += 1;
            if (entry.uncompressedSize === 4294967295 || entry.compressedSize === 4294967295 || entry.relativeOffsetOfLocalHeader === 4294967295) {
              var zip64EiefBuffer = null;
              for (var i = 0; i < entry.extraFields.length; i++) {
                var extraField = entry.extraFields[i];
                if (extraField.id === 1) {
                  zip64EiefBuffer = extraField.data;
                  break;
                }
              }
              if (zip64EiefBuffer == null) {
                return emitErrorAndAutoClose(self2, new Error("expected zip64 extended information extra field"));
              }
              var index = 0;
              if (entry.uncompressedSize === 4294967295) {
                if (index + 8 > zip64EiefBuffer.length) {
                  return emitErrorAndAutoClose(self2, new Error("zip64 extended information extra field does not include uncompressed size"));
                }
                entry.uncompressedSize = readUInt64LE(zip64EiefBuffer, index);
                index += 8;
              }
              if (entry.compressedSize === 4294967295) {
                if (index + 8 > zip64EiefBuffer.length) {
                  return emitErrorAndAutoClose(self2, new Error("zip64 extended information extra field does not include compressed size"));
                }
                entry.compressedSize = readUInt64LE(zip64EiefBuffer, index);
                index += 8;
              }
              if (entry.relativeOffsetOfLocalHeader === 4294967295) {
                if (index + 8 > zip64EiefBuffer.length) {
                  return emitErrorAndAutoClose(self2, new Error("zip64 extended information extra field does not include relative header offset"));
                }
                entry.relativeOffsetOfLocalHeader = readUInt64LE(zip64EiefBuffer, index);
                index += 8;
              }
            }
            if (self2.decodeStrings) {
              for (var i = 0; i < entry.extraFields.length; i++) {
                var extraField = entry.extraFields[i];
                if (extraField.id === 28789) {
                  if (extraField.data.length < 6) {
                    continue;
                  }
                  if (extraField.data.readUInt8(0) !== 1) {
                    continue;
                  }
                  var oldNameCrc32 = extraField.data.readUInt32LE(1);
                  if (crc32.unsigned(buffer.slice(0, entry.fileNameLength)) !== oldNameCrc32) {
                    continue;
                  }
                  entry.fileName = decodeBuffer(extraField.data, 5, extraField.data.length, true);
                  break;
                }
              }
            }
            if (self2.validateEntrySizes && entry.compressionMethod === 0) {
              var expectedCompressedSize = entry.uncompressedSize;
              if (entry.isEncrypted()) {
                expectedCompressedSize += 12;
              }
              if (entry.compressedSize !== expectedCompressedSize) {
                var msg = "compressed/uncompressed size mismatch for stored file: " + entry.compressedSize + " != " + entry.uncompressedSize;
                return emitErrorAndAutoClose(self2, new Error(msg));
              }
            }
            if (self2.decodeStrings) {
              if (!self2.strictFileNames) {
                entry.fileName = entry.fileName.replace(/\\/g, "/");
              }
              var errorMessage = validateFileName(entry.fileName, self2.validateFileNameOptions);
              if (errorMessage != null) return emitErrorAndAutoClose(self2, new Error(errorMessage));
            }
            self2.emit("entry", entry);
            if (!self2.lazyEntries) self2._readEntry();
          });
        });
      };
      ZipFile.prototype.openReadStream = function(entry, options, callback) {
        var self2 = this;
        var relativeStart = 0;
        var relativeEnd = entry.compressedSize;
        if (callback == null) {
          callback = options;
          options = {};
        } else {
          if (options.decrypt != null) {
            if (!entry.isEncrypted()) {
              throw new Error("options.decrypt can only be specified for encrypted entries");
            }
            if (options.decrypt !== false) throw new Error("invalid options.decrypt value: " + options.decrypt);
            if (entry.isCompressed()) {
              if (options.decompress !== false) throw new Error("entry is encrypted and compressed, and options.decompress !== false");
            }
          }
          if (options.decompress != null) {
            if (!entry.isCompressed()) {
              throw new Error("options.decompress can only be specified for compressed entries");
            }
            if (!(options.decompress === false || options.decompress === true)) {
              throw new Error("invalid options.decompress value: " + options.decompress);
            }
          }
          if (options.start != null || options.end != null) {
            if (entry.isCompressed() && options.decompress !== false) {
              throw new Error("start/end range not allowed for compressed entry without options.decompress === false");
            }
            if (entry.isEncrypted() && options.decrypt !== false) {
              throw new Error("start/end range not allowed for encrypted entry without options.decrypt === false");
            }
          }
          if (options.start != null) {
            relativeStart = options.start;
            if (relativeStart < 0) throw new Error("options.start < 0");
            if (relativeStart > entry.compressedSize) throw new Error("options.start > entry.compressedSize");
          }
          if (options.end != null) {
            relativeEnd = options.end;
            if (relativeEnd < 0) throw new Error("options.end < 0");
            if (relativeEnd > entry.compressedSize) throw new Error("options.end > entry.compressedSize");
            if (relativeEnd < relativeStart) throw new Error("options.end < options.start");
          }
        }
        if (!self2.isOpen) return callback(new Error("closed"));
        if (entry.isEncrypted()) {
          if (options.decrypt !== false) return callback(new Error("entry is encrypted, and options.decrypt !== false"));
        }
        self2.reader.ref();
        var buffer = newBuffer(30);
        readAndAssertNoEof(self2.reader, buffer, 0, buffer.length, entry.relativeOffsetOfLocalHeader, function(err) {
          try {
            if (err) return callback(err);
            var signature = buffer.readUInt32LE(0);
            if (signature !== 67324752) {
              return callback(new Error("invalid local file header signature: 0x" + signature.toString(16)));
            }
            var fileNameLength = buffer.readUInt16LE(26);
            var extraFieldLength = buffer.readUInt16LE(28);
            var localFileHeaderEnd = entry.relativeOffsetOfLocalHeader + buffer.length + fileNameLength + extraFieldLength;
            var decompress;
            if (entry.compressionMethod === 0) {
              decompress = false;
            } else if (entry.compressionMethod === 8) {
              decompress = options.decompress != null ? options.decompress : true;
            } else {
              return callback(new Error("unsupported compression method: " + entry.compressionMethod));
            }
            var fileDataStart = localFileHeaderEnd;
            var fileDataEnd = fileDataStart + entry.compressedSize;
            if (entry.compressedSize !== 0) {
              if (fileDataEnd > self2.fileSize) {
                return callback(new Error("file data overflows file bounds: " + fileDataStart + " + " + entry.compressedSize + " > " + self2.fileSize));
              }
            }
            var readStream = self2.reader.createReadStream({
              start: fileDataStart + relativeStart,
              end: fileDataStart + relativeEnd
            });
            var endpointStream = readStream;
            if (decompress) {
              var destroyed = false;
              var inflateFilter = zlib.createInflateRaw();
              readStream.on("error", function(err2) {
                setImmediate(function() {
                  if (!destroyed) inflateFilter.emit("error", err2);
                });
              });
              readStream.pipe(inflateFilter);
              if (self2.validateEntrySizes) {
                endpointStream = new AssertByteCountStream(entry.uncompressedSize);
                inflateFilter.on("error", function(err2) {
                  setImmediate(function() {
                    if (!destroyed) endpointStream.emit("error", err2);
                  });
                });
                inflateFilter.pipe(endpointStream);
              } else {
                endpointStream = inflateFilter;
              }
              endpointStream.destroy = function() {
                destroyed = true;
                if (inflateFilter !== endpointStream) inflateFilter.unpipe(endpointStream);
                readStream.unpipe(inflateFilter);
                readStream.destroy();
              };
            }
            callback(null, endpointStream);
          } finally {
            self2.reader.unref();
          }
        });
      };
      function Entry() {
      }
      Entry.prototype.getLastModDate = function() {
        return dosDateTimeToDate(this.lastModFileDate, this.lastModFileTime);
      };
      Entry.prototype.isEncrypted = function() {
        return (this.generalPurposeBitFlag & 1) !== 0;
      };
      Entry.prototype.isCompressed = function() {
        return this.compressionMethod === 8;
      };
      function dosDateTimeToDate(date, time) {
        var day = date & 31;
        var month = (date >> 5 & 15) - 1;
        var year = (date >> 9 & 127) + 1980;
        var millisecond = 0;
        var second = (time & 31) * 2;
        var minute = time >> 5 & 63;
        var hour = time >> 11 & 31;
        return new Date(year, month, day, hour, minute, second, millisecond);
      }
      function validateFileName(fileName) {
        if (fileName.indexOf("\\") !== -1) {
          return "invalid characters in fileName: " + fileName;
        }
        if (/^[a-zA-Z]:/.test(fileName) || /^\//.test(fileName)) {
          return "absolute path: " + fileName;
        }
        if (fileName.split("/").indexOf("..") !== -1) {
          return "invalid relative path: " + fileName;
        }
        return null;
      }
      function readAndAssertNoEof(reader, buffer, offset, length, position, callback) {
        if (length === 0) {
          return setImmediate(function() {
            callback(null, newBuffer(0));
          });
        }
        reader.read(buffer, offset, length, position, function(err, bytesRead) {
          if (err) return callback(err);
          if (bytesRead < length) {
            return callback(new Error("unexpected EOF"));
          }
          callback();
        });
      }
      util.inherits(AssertByteCountStream, Transform);
      function AssertByteCountStream(byteCount) {
        Transform.call(this);
        this.actualByteCount = 0;
        this.expectedByteCount = byteCount;
      }
      AssertByteCountStream.prototype._transform = function(chunk, encoding, cb) {
        this.actualByteCount += chunk.length;
        if (this.actualByteCount > this.expectedByteCount) {
          var msg = "too many bytes in the stream. expected " + this.expectedByteCount + ". got at least " + this.actualByteCount;
          return cb(new Error(msg));
        }
        cb(null, chunk);
      };
      AssertByteCountStream.prototype._flush = function(cb) {
        if (this.actualByteCount < this.expectedByteCount) {
          var msg = "not enough bytes in the stream. expected " + this.expectedByteCount + ". got only " + this.actualByteCount;
          return cb(new Error(msg));
        }
        cb();
      };
      util.inherits(RandomAccessReader, EventEmitter);
      function RandomAccessReader() {
        EventEmitter.call(this);
        this.refCount = 0;
      }
      RandomAccessReader.prototype.ref = function() {
        this.refCount += 1;
      };
      RandomAccessReader.prototype.unref = function() {
        var self2 = this;
        self2.refCount -= 1;
        if (self2.refCount > 0) return;
        if (self2.refCount < 0) throw new Error("invalid unref");
        self2.close(onCloseDone);
        function onCloseDone(err) {
          if (err) return self2.emit("error", err);
          self2.emit("close");
        }
      };
      RandomAccessReader.prototype.createReadStream = function(options) {
        var start = options.start;
        var end = options.end;
        if (start === end) {
          var emptyStream = new PassThrough();
          setImmediate(function() {
            emptyStream.end();
          });
          return emptyStream;
        }
        var stream = this._readStreamForRange(start, end);
        var destroyed = false;
        var refUnrefFilter = new RefUnrefFilter(this);
        stream.on("error", function(err) {
          setImmediate(function() {
            if (!destroyed) refUnrefFilter.emit("error", err);
          });
        });
        refUnrefFilter.destroy = function() {
          stream.unpipe(refUnrefFilter);
          refUnrefFilter.unref();
          stream.destroy();
        };
        var byteCounter = new AssertByteCountStream(end - start);
        refUnrefFilter.on("error", function(err) {
          setImmediate(function() {
            if (!destroyed) byteCounter.emit("error", err);
          });
        });
        byteCounter.destroy = function() {
          destroyed = true;
          refUnrefFilter.unpipe(byteCounter);
          refUnrefFilter.destroy();
        };
        return stream.pipe(refUnrefFilter).pipe(byteCounter);
      };
      RandomAccessReader.prototype._readStreamForRange = function(start, end) {
        throw new Error("bare-os: RandomAccessReader range stream unavailable");
      };
      RandomAccessReader.prototype.read = function(buffer, offset, length, position, callback) {
        var readStream = this.createReadStream({ start: position, end: position + length });
        var writeStream = new Writable();
        var written = 0;
        writeStream._write = function(chunk, encoding, cb) {
          chunk.copy(buffer, offset + written, 0, chunk.length);
          written += chunk.length;
          cb();
        };
        writeStream.on("finish", callback);
        readStream.on("error", function(error) {
          callback(error);
        });
        readStream.pipe(writeStream);
      };
      RandomAccessReader.prototype.close = function(callback) {
        setImmediate(callback);
      };
      util.inherits(RefUnrefFilter, PassThrough);
      function RefUnrefFilter(context) {
        PassThrough.call(this);
        this.context = context;
        this.context.ref();
        this.unreffedYet = false;
      }
      RefUnrefFilter.prototype._flush = function(cb) {
        this.unref();
        cb();
      };
      RefUnrefFilter.prototype.unref = function(cb) {
        if (this.unreffedYet) return;
        this.unreffedYet = true;
        this.context.unref();
      };
      var cp437 = "\0\u263A\u263B\u2665\u2666\u2663\u2660\u2022\u25D8\u25CB\u25D9\u2642\u2640\u266A\u266B\u263C\u25BA\u25C4\u2195\u203C\xB6\xA7\u25AC\u21A8\u2191\u2193\u2192\u2190\u221F\u2194\u25B2\u25BC !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\u2302\xC7\xFC\xE9\xE2\xE4\xE0\xE5\xE7\xEA\xEB\xE8\xEF\xEE\xEC\xC4\xC5\xC9\xE6\xC6\xF4\xF6\xF2\xFB\xF9\xFF\xD6\xDC\xA2\xA3\xA5\u20A7\u0192\xE1\xED\xF3\xFA\xF1\xD1\xAA\xBA\xBF\u2310\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0";
      function decodeBuffer(buffer, start, end, isUtf8) {
        if (isUtf8) {
          return buffer.toString("utf8", start, end);
        } else {
          var result = "";
          for (var i = start; i < end; i++) {
            result += cp437[buffer[i]];
          }
          return result;
        }
      }
      function readUInt64LE(buffer, offset) {
        var lower32 = buffer.readUInt32LE(offset);
        var upper32 = buffer.readUInt32LE(offset + 4);
        return upper32 * 4294967296 + lower32;
      }
      var newBuffer;
      if (typeof Buffer.allocUnsafe === "function") {
        newBuffer = function(len) {
          return Buffer.allocUnsafe(len);
        };
      } else {
        newBuffer = function(len) {
          return new Buffer(len);
        };
      }
      function defaultCallback(err) {
        if (err) throw err;
      }
    }
  });

  // ../../node_modules/decompress-unzip/index.js
  var require_decompress_unzip = __commonJS({
    "../../node_modules/decompress-unzip/index.js"(exports, module) {
      "use strict";
      var fileType = require_file_type3();
      var getStream = require_get_stream();
      var pify = require_pify();
      var yauzl = require_yauzl();
      var getType = (entry, mode) => {
        const IFMT = 61440;
        const IFDIR = 16384;
        const IFLNK = 40960;
        const madeBy = entry.versionMadeBy >> 8;
        if ((mode & IFMT) === IFLNK) {
          return "symlink";
        }
        if ((mode & IFMT) === IFDIR || madeBy === 0 && entry.externalFileAttributes === 16) {
          return "directory";
        }
        return "file";
      };
      var extractEntry = (entry, zip) => {
        const file = {
          mode: entry.externalFileAttributes >> 16 & 65535,
          mtime: entry.getLastModDate(),
          path: entry.fileName
        };
        file.type = getType(entry, file.mode);
        if (file.mode === 0 && file.type === "directory") {
          file.mode = 493;
        }
        if (file.mode === 0) {
          file.mode = 420;
        }
        return pify(zip.openReadStream.bind(zip))(entry).then(getStream.buffer).then((buf) => {
          file.data = buf;
          if (file.type === "symlink") {
            file.linkname = buf.toString();
          }
          return file;
        }).catch((err) => {
          zip.close();
          throw err;
        });
      };
      var extractFile = (zip) => new Promise((resolve, reject) => {
        const files = [];
        zip.readEntry();
        zip.on("entry", (entry) => {
          extractEntry(entry, zip).catch(reject).then((file) => {
            files.push(file);
            zip.readEntry();
          });
        });
        zip.on("error", reject);
        zip.on("end", () => resolve(files));
      });
      module.exports = () => (buf) => {
        if (!Buffer.isBuffer(buf)) {
          return Promise.reject(new TypeError(`Expected a Buffer, got ${typeof buf}`));
        }
        if (!fileType(buf) || fileType(buf).ext !== "zip") {
          return Promise.resolve([]);
        }
        return pify(yauzl.fromBuffer)(buf, { lazyEntries: true }).then(extractFile);
      };
    }
  });

  // ../../node_modules/make-dir/node_modules/pify/index.js
  var require_pify2 = __commonJS({
    "../../node_modules/make-dir/node_modules/pify/index.js"(exports, module) {
      "use strict";
      var processFn = (fn, opts) => function() {
        const P = opts.promiseModule;
        const args = new Array(arguments.length);
        for (let i = 0; i < arguments.length; i++) {
          args[i] = arguments[i];
        }
        return new P((resolve, reject) => {
          if (opts.errorFirst) {
            args.push(function(err, result) {
              if (opts.multiArgs) {
                const results = new Array(arguments.length - 1);
                for (let i = 1; i < arguments.length; i++) {
                  results[i - 1] = arguments[i];
                }
                if (err) {
                  results.unshift(err);
                  reject(results);
                } else {
                  resolve(results);
                }
              } else if (err) {
                reject(err);
              } else {
                resolve(result);
              }
            });
          } else {
            args.push(function(result) {
              if (opts.multiArgs) {
                const results = new Array(arguments.length - 1);
                for (let i = 0; i < arguments.length; i++) {
                  results[i] = arguments[i];
                }
                resolve(results);
              } else {
                resolve(result);
              }
            });
          }
          fn.apply(this, args);
        });
      };
      module.exports = (obj, opts) => {
        opts = Object.assign({
          exclude: [/.+(Sync|Stream)$/],
          errorFirst: true,
          promiseModule: Promise
        }, opts);
        const filter = (key) => {
          const match = (pattern) => typeof pattern === "string" ? key === pattern : pattern.test(key);
          return opts.include ? opts.include.some(match) : !opts.exclude.some(match);
        };
        let ret;
        if (typeof obj === "function") {
          ret = function() {
            if (opts.excludeMain) {
              return obj.apply(this, arguments);
            }
            return processFn(obj, opts).apply(this, arguments);
          };
        } else {
          ret = Object.create(Object.getPrototypeOf(obj));
        }
        for (const key in obj) {
          const x = obj[key];
          ret[key] = typeof x === "function" && filter(key) ? processFn(x, opts) : x;
        }
        return ret;
      };
    }
  });

  // ../../node_modules/make-dir/index.js
  var require_make_dir = __commonJS({
    "../../node_modules/make-dir/index.js"(exports, module) {
      "use strict";
      var fs = require_bare_node_fs();
      var path = __require("path");
      var pify = require_pify2();
      var defaults = {
        mode: 511 & ~process.umask(),
        fs
      };
      var checkPath = (pth) => {
        if (process.platform === "win32") {
          const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path.parse(pth).root, ""));
          if (pathHasInvalidWinCharacters) {
            const err = new Error(`Path contains invalid characters: ${pth}`);
            err.code = "EINVAL";
            throw err;
          }
        }
      };
      module.exports = (input, opts) => Promise.resolve().then(() => {
        checkPath(input);
        opts = Object.assign({}, defaults, opts);
        const mkdir = pify(opts.fs.mkdir);
        const stat = pify(opts.fs.stat);
        const make = (pth) => {
          return mkdir(pth, opts.mode).then(() => pth).catch((err) => {
            if (err.code === "ENOENT") {
              if (err.message.includes("null bytes") || path.dirname(pth) === pth) {
                throw err;
              }
              return make(path.dirname(pth)).then(() => make(pth));
            }
            return stat(pth).then((stats) => stats.isDirectory() ? pth : Promise.reject()).catch(() => {
              throw err;
            });
          });
        };
        return make(path.resolve(input));
      });
      module.exports.sync = (input, opts) => {
        checkPath(input);
        opts = Object.assign({}, defaults, opts);
        const make = (pth) => {
          try {
            opts.fs.mkdirSync(pth, opts.mode);
          } catch (err) {
            if (err.code === "ENOENT") {
              if (err.message.includes("null bytes") || path.dirname(pth) === pth) {
                throw err;
              }
              make(path.dirname(pth));
              return make(pth);
            }
            try {
              if (!opts.fs.statSync(pth).isDirectory()) {
                throw new Error("The path is not a directory");
              }
            } catch (_) {
              throw err;
            }
          }
          return pth;
        };
        return make(path.resolve(input));
      };
    }
  });

  // ../../node_modules/decompress/node_modules/pify/index.js
  var require_pify3 = __commonJS({
    "../../node_modules/decompress/node_modules/pify/index.js"(exports, module) {
      "use strict";
      var processFn = function(fn, P, opts) {
        return function() {
          var that = this;
          var args = new Array(arguments.length);
          for (var i = 0; i < arguments.length; i++) {
            args[i] = arguments[i];
          }
          return new P(function(resolve, reject) {
            args.push(function(err, result) {
              if (err) {
                reject(err);
              } else if (opts.multiArgs) {
                var results = new Array(arguments.length - 1);
                for (var i2 = 1; i2 < arguments.length; i2++) {
                  results[i2 - 1] = arguments[i2];
                }
                resolve(results);
              } else {
                resolve(result);
              }
            });
            fn.apply(that, args);
          });
        };
      };
      var pify = module.exports = function(obj, P, opts) {
        if (typeof P !== "function") {
          opts = P;
          P = Promise;
        }
        opts = opts || {};
        opts.exclude = opts.exclude || [/.+Sync$/];
        var filter = function(key) {
          var match = function(pattern) {
            return typeof pattern === "string" ? key === pattern : pattern.test(key);
          };
          return opts.include ? opts.include.some(match) : !opts.exclude.some(match);
        };
        var ret = typeof obj === "function" ? function() {
          if (opts.excludeMain) {
            return obj.apply(this, arguments);
          }
          return processFn(obj, P, opts).apply(this, arguments);
        } : {};
        return Object.keys(obj).reduce(function(ret2, key) {
          var x = obj[key];
          ret2[key] = typeof x === "function" && filter(key) ? processFn(x, P, opts) : x;
          return ret2;
        }, ret);
      };
      pify.all = pify;
    }
  });

  // ../../node_modules/is-natural-number/index.js
  var require_is_natural_number = __commonJS({
    "../../node_modules/is-natural-number/index.js"(exports, module) {
      "use strict";
      module.exports = function isNaturalNumber(val, option) {
        if (option) {
          if (typeof option !== "object") {
            throw new TypeError(
              String(option) + " is not an object. Expected an object that has boolean `includeZero` property."
            );
          }
          if ("includeZero" in option) {
            if (typeof option.includeZero !== "boolean") {
              throw new TypeError(
                String(option.includeZero) + " is neither true nor false. `includeZero` option must be a Boolean value."
              );
            }
            if (option.includeZero && val === 0) {
              return true;
            }
          }
        }
        return Number.isSafeInteger(val) && val >= 1;
      };
    }
  });

  // ../../node_modules/strip-dirs/index.js
  var require_strip_dirs = __commonJS({
    "../../node_modules/strip-dirs/index.js"(exports, module) {
      "use strict";
      var path = __require("path");
      var util = __require("util");
      var isNaturalNumber = require_is_natural_number();
      module.exports = function stripDirs(pathStr, count, option) {
        if (typeof pathStr !== "string") {
          throw new TypeError(
            util.inspect(pathStr) + " is not a string. First argument to strip-dirs must be a path string."
          );
        }
        if (path.posix.isAbsolute(pathStr) || path.win32.isAbsolute(pathStr)) {
          throw new Error(`${pathStr} is an absolute path. strip-dirs requires a relative path.`);
        }
        if (!isNaturalNumber(count, { includeZero: true })) {
          throw new Error(
            "The Second argument of strip-dirs must be a natural number or 0, but received " + util.inspect(count) + "."
          );
        }
        if (option) {
          if (typeof option !== "object") {
            throw new TypeError(
              util.inspect(option) + " is not an object. Expected an object with a boolean `disallowOverflow` property."
            );
          }
          if (Array.isArray(option)) {
            throw new TypeError(
              util.inspect(option) + " is an array. Expected an object with a boolean `disallowOverflow` property."
            );
          }
          if ("disallowOverflow" in option && typeof option.disallowOverflow !== "boolean") {
            throw new TypeError(
              util.inspect(option.disallowOverflow) + " is neither true nor false. `disallowOverflow` option must be a Boolean value."
            );
          }
        } else {
          option = { disallowOverflow: false };
        }
        const pathComponents = path.normalize(pathStr).split(path.sep);
        if (pathComponents.length > 1 && pathComponents[0] === ".") {
          pathComponents.shift();
        }
        if (count > pathComponents.length - 1) {
          if (option.disallowOverflow) {
            throw new RangeError("Cannot strip more directories than there are.");
          }
          count = pathComponents.length - 1;
        }
        return path.join.apply(null, pathComponents.slice(count));
      };
    }
  });

  // ../../node_modules/decompress/index.js
  var require_decompress = __commonJS({
    "../../node_modules/decompress/index.js"(exports, module) {
      "use strict";
      var path = __require("path");
      var fs = require_graceful_fs();
      var decompressTar = require_decompress_tar();
      var decompressTarbz2 = require_decompress_tarbz2();
      var decompressTargz = require_decompress_targz();
      var decompressUnzip = require_decompress_unzip();
      var makeDir = require_make_dir();
      var pify = require_pify3();
      var stripDirs = require_strip_dirs();
      var fsP = pify(fs);
      var runPlugins = (input, opts) => {
        if (opts.plugins.length === 0) {
          return Promise.resolve([]);
        }
        return Promise.all(opts.plugins.map((x) => x(input, opts))).then((files) => files.reduce((a, b) => a.concat(b)));
      };
      var safeMakeDir = (dir, realOutputPath) => {
        return fsP.realpath(dir).catch((_) => {
          const parent = path.dirname(dir);
          return safeMakeDir(parent, realOutputPath);
        }).then((realParentPath) => {
          if (realParentPath.indexOf(realOutputPath) !== 0) {
            throw new Error("Refusing to create a directory outside the output path.");
          }
          return makeDir(dir).then(fsP.realpath);
        });
      };
      var preventWritingThroughSymlink = (destination, realOutputPath) => {
        return fsP.readlink(destination).catch((_) => {
          return null;
        }).then((symlinkPointsTo) => {
          if (symlinkPointsTo) {
            throw new Error("Refusing to write into a symlink");
          }
          return realOutputPath;
        });
      };
      var extractFile = (input, output, opts) => runPlugins(input, opts).then((files) => {
        if (opts.strip > 0) {
          files = files.map((x) => {
            x.path = stripDirs(x.path, opts.strip);
            return x;
          }).filter((x) => x.path !== ".");
        }
        if (typeof opts.filter === "function") {
          files = files.filter(opts.filter);
        }
        if (typeof opts.map === "function") {
          files = files.map(opts.map);
        }
        if (!output) {
          return files;
        }
        return Promise.all(files.map((x) => {
          const dest = path.join(output, x.path);
          const mode = x.mode & ~process.umask();
          const now = /* @__PURE__ */ new Date();
          if (x.type === "directory") {
            return makeDir(output).then((outputPath) => fsP.realpath(outputPath)).then((realOutputPath) => safeMakeDir(dest, realOutputPath)).then(() => fsP.utimes(dest, now, x.mtime)).then(() => x);
          }
          return makeDir(output).then((outputPath) => fsP.realpath(outputPath)).then((realOutputPath) => {
            return safeMakeDir(path.dirname(dest), realOutputPath).then(() => realOutputPath);
          }).then((realOutputPath) => {
            if (x.type === "file") {
              return preventWritingThroughSymlink(dest, realOutputPath);
            }
            return realOutputPath;
          }).then((realOutputPath) => {
            return fsP.realpath(path.dirname(dest)).then((realDestinationDir) => {
              if (realDestinationDir.indexOf(realOutputPath) !== 0) {
                throw new Error("Refusing to write outside output directory: " + realDestinationDir);
              }
            });
          }).then(() => {
            if (x.type === "link") {
              return fsP.link(x.linkname, dest);
            }
            if (x.type === "symlink" && process.platform === "win32") {
              return fsP.link(x.linkname, dest);
            }
            if (x.type === "symlink") {
              return fsP.symlink(x.linkname, dest);
            }
            return fsP.writeFile(dest, x.data, { mode });
          }).then(() => x.type === "file" && fsP.utimes(dest, now, x.mtime)).then(() => x);
        }));
      });
      module.exports = (input, output, opts) => {
        if (typeof input !== "string" && !Buffer.isBuffer(input)) {
          return Promise.reject(new TypeError("Input file required"));
        }
        if (typeof output === "object") {
          opts = output;
          output = null;
        }
        opts = Object.assign({ plugins: [
          decompressTar(),
          decompressTarbz2(),
          decompressTargz(),
          decompressUnzip()
        ] }, opts);
        const read = typeof input === "string" ? fsP.readFile(input) : Promise.resolve(input);
        return read.then((buf) => extractFile(buf, output, opts));
      };
    }
  });

  // ../../node_modules/bare-dev/lib/android/sdk/setup.js
  var require_setup = __commonJS({
    "../../node_modules/bare-dev/lib/android/sdk/setup.js"(exports, module) {
      var fs = require_bare_node_fs();
      var os = __require("os");
      var process2 = __require("process");
      var path = __require("path");
      var crypto = require_bare_crypto();
      var decompress = require_decompress();
      module.exports = async function setup(opts = {}) {
        const {
          sdk = require_sdk().path,
          tools = defaults().tools,
          integrity = defaults().integrity,
          force = false,
          quiet = true
        } = opts;
        const destination = path.join(sdk, "cmdline-tools/latest");
        if (!fs.existsSync(destination) || force) {
          const response = await fetch(tools);
          const input = Buffer.from(await response.arrayBuffer());
          const digest = crypto.createHash("sha256").update(input).digest("hex");
          if (integrity && digest !== integrity) throw new Error("integrity mismatch");
          await decompress(input, destination, {
            map(file) {
              file.path = path.relative("cmdline-tools", file.path);
              return file;
            }
          });
        }
        if (!quiet) process2.stdout.write(`export ANDROID_HOME=${sdk}
`);
      };
      function defaults() {
        const release = "11076708";
        switch (os.platform()) {
          case "darwin":
            return {
              tools: `https://dl.google.com/android/repository/commandlinetools-mac-${release}_latest.zip`,
              integrity: "7bc5c72ba0275c80a8f19684fb92793b83a6b5c94d4d179fc5988930282d7e64"
            };
          case "linux":
            return {
              tools: `https://dl.google.com/android/repository/commandlinetools-linux-${release}_latest.zip`,
              integrity: "2d2d50857e4eb553af5a6dc3ad507a17adf43d115264b1afc116f95c92e5e258"
            };
          case "win32":
            return {
              tools: `https://dl.google.com/android/repository/commandlinetools-win-${release}_latest.zip`,
              integrity: "4d6931209eebb1bfb7c7e8b240a6a3cb3ab24479ea294f3539429574b1eec862"
            };
          default:
            throw new Error(`unsupported platform ${os.platform()}`);
        }
      }
    }
  });

  // ../../node_modules/bare-dev/lib/android/sdk/licenses.js
  var require_licenses = __commonJS({
    "../../node_modules/bare-dev/lib/android/sdk/licenses.js"(exports) {
      var exec = require_exec();
      var sdk = require_sdk();
      var yes = Buffer.from("y\r\n".repeat(
        7
        /* Review + 6 licenses */
      ));
      exports.accept = function accept(opts = {}) {
        exec(sdk.manager(), ["--licenses"], { ...opts, input: yes });
      };
    }
  });

  // ../../node_modules/bare-dev/lib/android/sdk.js
  var require_sdk2 = __commonJS({
    "../../node_modules/bare-dev/lib/android/sdk.js"(exports) {
      exports.setup = require_setup();
      exports.licenses = require_licenses();
    }
  });

  // ../../node_modules/bare-dev/lib/android.js
  var require_android = __commonJS({
    "../../node_modules/bare-dev/lib/android.js"(exports) {
      exports.device = require_device();
      exports.run = require_run();
      exports.sdk = require_sdk2();
    }
  });

  // ../../node_modules/cmake-runtime/index.js
  var require_cmake_runtime = __commonJS({
    "../../node_modules/cmake-runtime/index.js"(exports, module) {
      var os = __require("os");
      var path = __require("path");
      module.exports = function runtime(referrer, opts) {
        if (typeof referrer === "object" && referrer !== null) {
          opts = referrer;
          referrer = "cmake";
        } else if (typeof referrer !== "string") {
          referrer = "cmake";
        }
        if (!opts) opts = {};
        const {
          platform = os.platform(),
          arch = platform === "darwin" ? "universal" : os.arch()
        } = opts;
        const filename = path.basename(referrer);
        let mod;
        try {
          mod = __require(`cmake-runtime-${platform}-${arch}`);
        } catch (err) {
          if (err.code === "MODULE_NOT_FOUND") {
            throw new Error(`No binaries found for target '${platform}-${arch}'`);
          } else {
            throw err;
          }
        }
        if (filename in mod === false) {
          throw new Error(`No binary found for target '${platform}-${arch}' for referrer '${referrer}'`);
        }
        return mod[filename];
      };
    }
  });

  // ../../node_modules/bare-dev/lib/shared/cmake.js
  var require_cmake = __commonJS({
    "../../node_modules/bare-dev/lib/shared/cmake.js"(exports, module) {
      var path = __require("path");
      var runtime = require_cmake_runtime();
      module.exports = exports = function cmake() {
        return runtime("cmake");
      };
      exports.ctest = function ctest() {
        return runtime("ctest");
      };
      exports.toPath = function toPath(input, opts = {}) {
        const {
          normalize = true
        } = opts;
        if (normalize) input = path.normalize(input);
        return input.replace(/\\/g, "/");
      };
    }
  });

  // ../../node_modules/bare-dev/lib/shared/gradle.js
  var require_gradle = __commonJS({
    "../../node_modules/bare-dev/lib/shared/gradle.js"(exports, module) {
      var path = __require("path");
      var which = require_bare_which();
      module.exports = function gradle(opts = {}) {
        const {
          cwd = path.resolve(".")
        } = opts;
        try {
          return which.sync("gradlew", { path: cwd });
        } catch {
          return which.sync("gradle");
        }
      };
    }
  });

  // ../../node_modules/bare-dev/lib/paths.js
  var require_paths = __commonJS({
    "../../node_modules/bare-dev/lib/paths.js"(exports, module) {
      var path = __require("path");
      var root = path.join(__dirname, "..");
      var compat = path.join(root, "compat");
      module.exports = {
        cmake: path.join(root, "cmake"),
        // Compatibility paths
        "compat/napi": path.join(compat, "napi")
      };
    }
  });

  // ../../node_modules/bare-dev/lib/build.js
  var require_build = __commonJS({
    "../../node_modules/bare-dev/lib/build.js"(exports, module) {
      var path = __require("path");
      var fs = require_bare_node_fs();
      var spawn = require_spawn();
      var cmake = require_cmake();
      var gradle = require_gradle();
      var paths = require_paths();
      module.exports = exports = function build(opts = {}) {
        const {
          cwd = path.resolve("."),
          cmake: cmake2 = fs.existsSync(path.join(cwd, "CMakeLists.txt")),
          gradle: gradle2 = fs.existsSync(path.join(cwd, "build.gradle"))
        } = opts;
        if (cmake2) return exports.cmake(opts);
        if (gradle2) return exports.gradle(opts);
        throw new Error("no build system recognized");
      };
      exports.cmake = function(opts = {}) {
        const {
          build = "build",
          target = null,
          debug = false,
          cwd = path.resolve("."),
          verbose = false,
          parallel = 0
        } = opts;
        const args = ["--build", path.resolve(cwd, build), "--config", debug ? "Debug" : "Release"];
        if (target) args.push("--target", target);
        if (parallel > 0) args.push("--parallel", parallel);
        if (verbose) args.push("--verbose");
        return spawn(cmake(), args, opts);
      };
      exports.gradle = function(opts = {}) {
        const {
          target = "build",
          env = process.env
        } = opts;
        return spawn(gradle(opts), [target], {
          ...opts,
          env: {
            ...env,
            CMAKE_MODULE_PATH: cmake.toPath(paths.cmake)
          }
        });
      };
    }
  });

  // ../bare-os-openssh/vendor/bare-node-shims/bare-node-fs/promises.js
  var require_promises2 = __commonJS({
    "../bare-os-openssh/vendor/bare-node-shims/bare-node-fs/promises.js"(exports, module) {
      module.exports = require_promises();
    }
  });

  // ../../node_modules/unix-path-resolve/index.js
  var require_unix_path_resolve = __commonJS({
    "../../node_modules/unix-path-resolve/index.js"(exports, module) {
      module.exports = resolve;
      function parse2(addr) {
        const names = addr.split(/[/\\]/);
        const r = {
          isAbsolute: false,
          names
        };
        if (names.length === 0) return r;
        if (names.length > 1 && names[0].endsWith(":")) {
          r.isAbsolute = true;
          if (names[0].length === 2) {
            r.names = names.slice(1);
            return r;
          }
          if (names[0] === "file:") {
            r.names = names.slice(1);
            return r;
          }
          r.names = names.slice(3);
          return r;
        }
        r.isAbsolute = addr.startsWith("/") || addr.startsWith("\\");
        return r;
      }
      function resolve(a, b = "") {
        const ap = parse2(a);
        const bp = parse2(b);
        if (bp.isAbsolute) {
          return resolveNames([], bp.names);
        }
        if (!ap.isAbsolute) {
          throw new Error("One of the two paths must be absolute");
        }
        return resolveNames(ap.names, bp.names);
      }
      function toString(p, names) {
        for (let i = 0; i < names.length; i++) {
          if (names[i] === "") continue;
          if (names[i] === ".") continue;
          if (names[i] === "..") {
            if (p.length === 1) throw new Error("Path cannot be resolved, too many '..'");
            p = p.slice(0, p.lastIndexOf("/")) || "/";
            continue;
          }
          p += p.length === 1 ? names[i] : "/" + names[i];
        }
        return p;
      }
      function resolveNames(a, b) {
        return toString(toString("/", a), b);
      }
    }
  });

  // ../../node_modules/include-static/index.js
  var require_include_static = __commonJS({
    "../../node_modules/include-static/index.js"(exports, module) {
      module.exports = function includeStatic(name, buf) {
        let s = "unsigned char " + name + "[] = {\n  ";
        for (let i = 0; i < buf.byteLength; i++) {
          s += "0x" + buf[i].toString(16).padStart(2, "0");
          if (i < buf.byteLength - 1) s += ",";
          if (i % 16 === 15) s += "\n  ";
          else s += " ";
        }
        s = s.trim() + "\n};\n\n";
        s += "size_t " + name + "_len = " + buf.byteLength + ";\n";
        return s;
      };
    }
  });

  // ../../node_modules/bare-bundle/lib/errors.js
  var require_errors6 = __commonJS({
    "../../node_modules/bare-bundle/lib/errors.js"(exports, module) {
      module.exports = class BundleError extends Error {
        constructor(msg, fn = BundleError, opts = {}) {
          const { cause, code = fn.name } = opts;
          super(`${code}: ${msg}`, { cause });
          this.code = code;
          if (Error.captureStackTrace) {
            Error.captureStackTrace(this, fn);
          }
        }
        get name() {
          return "BundleError";
        }
        static INVALID_BUNDLE_HEADER(msg, cause) {
          return new BundleError(msg, BundleError.INVALID_BUNDLE_HEADER, { cause });
        }
      };
    }
  });

  // ../../node_modules/bare-bundle/index.js
  var require_bare_bundle = __commonJS({
    "../../node_modules/bare-bundle/index.js"(exports, module) {
      var errors = require_errors6();
      var kind = Symbol.for("bare.bundle.kind");
      var MemoryFile = class _MemoryFile {
        constructor(data, opts = {}) {
          const { executable = false, mode = executable ? 493 : 420 } = opts;
          this._data = typeof data === "string" ? Buffer.from(data) : data;
          this._mode = mode;
        }
        size() {
          return this._data.byteLength;
        }
        mode() {
          return this._mode;
        }
        read() {
          return this._data;
        }
        inspect() {
          return {
            __proto__: { constructor: _MemoryFile },
            data: this._data,
            mode: this._mode.toString(8)
          };
        }
        [Symbol.for("bare.inspect")]() {
          return this.inspect();
        }
        [Symbol.for("nodejs.util.inspect.custom")]() {
          return this.inspect();
        }
      };
      module.exports = exports = class Bundle2 {
        static get [kind]() {
          return 0;
        }
        static get version() {
          return 0;
        }
        constructor(opts = {}) {
          const { File = MemoryFile } = opts;
          this._File = File;
          this._id = null;
          this._main = null;
          this._imports = {};
          this._resolutions = {};
          this._addons = [];
          this._assets = [];
          this._files = /* @__PURE__ */ new Map();
        }
        get [kind]() {
          return Bundle2[kind];
        }
        get version() {
          return Bundle2.version;
        }
        get id() {
          return this._id;
        }
        set id(value) {
          if (typeof value !== "string" && value !== null) {
            throw new TypeError(`ID must be a string or null. Received type ${typeof value} (${value})`);
          }
          this._id = value;
        }
        get main() {
          return this._main;
        }
        set main(value) {
          if (typeof value !== "string" && value !== null) {
            throw new TypeError(`Main must be a string or null. Received type ${typeof value} (${value})`);
          }
          this._main = value;
        }
        get imports() {
          return this._imports;
        }
        set imports(value) {
          this._imports = cloneImportsMap(value);
        }
        get resolutions() {
          return this._resolutions;
        }
        set resolutions(value) {
          this._resolutions = cloneResolutionsMap(value);
        }
        get addons() {
          return this._addons;
        }
        set addons(value) {
          this._addons = cloneFilesList(value, "Addons");
        }
        get assets() {
          return this._assets;
        }
        set assets(value) {
          this._assets = cloneFilesList(value, "Assets");
        }
        get files() {
          return Object.fromEntries(this._files.entries());
        }
        *[Symbol.iterator]() {
          for (const [key, file] of this._files) {
            yield [key, file.read(), file.mode()];
          }
        }
        empty() {
          return this._files.size === 0;
        }
        keys() {
          return this._files.keys();
        }
        exists(key) {
          return this._files.has(key);
        }
        size(key) {
          const file = this._files.get(key) || null;
          if (file === null) return 0;
          return file.size();
        }
        mode(key) {
          const file = this._files.get(key) || null;
          if (file === null) return 0;
          return file.mode();
        }
        read(key) {
          const file = this._files.get(key) || null;
          if (file === null) return null;
          return file.read();
        }
        write(key, data, opts = {}) {
          if (typeof key !== "string") {
            throw new TypeError(`File path must be a string. Received type ${typeof key} (${key})`);
          }
          const { main = false, alias = null, imports = null, addon = false, asset = false } = opts;
          this._files.set(key, new MemoryFile(data, opts));
          if (main) this._main = key;
          if (alias) this._imports[alias] = key;
          if (imports) this._resolutions[key] = cloneImportsMap(imports);
          if (addon) this._addons.push(key);
          if (asset) this._assets.push(key);
          return this;
        }
        mount(root, opts = {}) {
          const bundle = new Bundle2();
          bundle._File = this._File;
          bundle._id = this._id;
          if (this._main) bundle._main = mountSpecifier(this._main, root);
          bundle._imports = transformImportsMap(this._imports, root, null, opts, mountSpecifier);
          bundle._resolutions = transformResolutionsMap(this._resolutions, root, opts, mountSpecifier);
          for (const [key, file] of this._files) {
            bundle._files.set(mountSpecifier(key, root), file);
          }
          bundle._addons = transformFilesList(this._addons, root, mountSpecifier);
          bundle._assets = transformFilesList(this._assets, root, mountSpecifier);
          return bundle;
        }
        unmount(root, opts = {}) {
          const bundle = new Bundle2();
          bundle._File = this._File;
          bundle._id = this._id;
          if (this._main) bundle._main = unmountSpecifier(this._main, root);
          bundle._imports = transformImportsMap(this._imports, root, null, opts, unmountSpecifier);
          bundle._resolutions = transformResolutionsMap(this._resolutions, root, opts, unmountSpecifier);
          for (const [key, file] of this._files) {
            bundle._files.set(unmountSpecifier(key, root), file);
          }
          bundle._addons = transformFilesList(this._addons, root, unmountSpecifier);
          bundle._assets = transformFilesList(this._assets, root, unmountSpecifier);
          return bundle;
        }
        toBuffer(opts = {}) {
          const { indent = 0, shared = false } = opts;
          const header = {
            version: Bundle2.version,
            id: this._id,
            main: this._main,
            imports: cloneImportsMap(this._imports),
            resolutions: cloneResolutionsMap(this._resolutions),
            addons: cloneFilesList(this._addons, "Addons"),
            assets: cloneFilesList(this._assets, "Assets"),
            files: {}
          };
          const keys = [...this._files.keys()].sort();
          let offset = 0;
          for (const key of keys) {
            const length2 = this.size(key);
            header.files[key] = { offset, length: length2, mode: this.mode(key) };
            offset += length2;
          }
          const json = Buffer.from(`
${JSON.stringify(header, null, indent)}
`);
          const length = Buffer.from(json.byteLength.toString(10));
          const total = length.byteLength + json.byteLength + offset;
          const storage = shared ? new SharedArrayBuffer(total) : new ArrayBuffer(total);
          const buffer = Buffer.from(storage);
          offset = 0;
          buffer.set(length, offset);
          offset += length.byteLength;
          buffer.set(json, offset);
          offset += json.byteLength;
          for (const key of keys) {
            buffer.set(this.read(key), offset);
            offset += this.size(key);
          }
          return buffer;
        }
        inspect() {
          return {
            __proto__: { constructor: Bundle2 },
            version: this.version,
            id: this.id,
            main: this.main,
            imports: this.imports,
            resolutions: this.resolutions,
            addons: this.addons,
            assets: this.assets,
            files: this.files
          };
        }
        [Symbol.for("bare.inspect")]() {
          return this.inspect();
        }
        [Symbol.for("nodejs.util.inspect.custom")]() {
          return this.inspect();
        }
      };
      var Bundle = exports;
      exports.errors = errors;
      exports.isBundle = function isBundle(value) {
        if (value instanceof Bundle) return true;
        return typeof value === "object" && value !== null && value[kind] === Bundle[kind];
      };
      exports.from = function from(value) {
        if (typeof value === "string") return fromString(value);
        if (Buffer.isBuffer(value)) return fromBuffer(value);
        return value;
      };
      function fromString(string) {
        return fromBuffer(Buffer.from(string));
      }
      function fromBuffer(buffer) {
        if (buffer[0] === 35 && buffer[1] === 33) {
          let end2 = 2;
          while (buffer[end2] !== 10) end2++;
          buffer = buffer.subarray(end2 + 1);
        }
        let end = 0;
        while (isDecimal(buffer[end])) end++;
        const len = parseInt(buffer.toString("utf8", 0, end), 10);
        let header;
        try {
          header = JSON.parse(buffer.toString("utf8", end, end + len));
        } catch (err) {
          throw errors.INVALID_BUNDLE_HEADER("Invalid bundle header", err);
        }
        const bundle = new Bundle();
        if (header.id) bundle.id = header.id;
        if (header.main) bundle.main = header.main;
        if (header.imports) bundle.imports = header.imports;
        if (header.resolutions) bundle.resolutions = header.resolutions;
        if (header.addons) bundle.addons = header.addons;
        if (header.assets) bundle.assets = header.assets;
        let offset = end + len;
        for (const [file, info] of Object.entries(header.files)) {
          bundle.write(file, buffer.subarray(offset, offset + info.length), {
            mode: info.mode || 420
          });
          offset += info.length;
        }
        return bundle;
      }
      function isDecimal(c) {
        return c >= 48 && c <= 57;
      }
      function compareKeys([a], [b]) {
        return a > b ? 1 : a < b ? -1 : 0;
      }
      function cloneImportsMap(value) {
        if (typeof value === "object" && value !== null) {
          const imports = {};
          for (const entry of Object.entries(value).sort(compareKeys)) {
            imports[entry[0]] = cloneImportsMapEntry(entry[1]);
          }
          return imports;
        }
        throw new TypeError(`Imports map must be an object. Received type ${typeof value} (${value})`);
      }
      function cloneImportsMapEntry(value) {
        if (typeof value === "string") return value;
        if (typeof value === "object" && value !== null) {
          const imports = {};
          for (const entry of Object.entries(value)) {
            imports[entry[0]] = cloneImportsMapEntry(entry[1]);
          }
          return imports;
        }
        throw new TypeError(
          `Imports map entry must be a string or object. Received type ${typeof value} (${value})`
        );
      }
      function cloneResolutionsMap(value) {
        if (typeof value === "object" && value !== null) {
          const resolutions = {};
          for (const entry of Object.entries(value).sort(compareKeys)) {
            resolutions[entry[0]] = cloneImportsMap(entry[1]);
          }
          return resolutions;
        }
        throw new TypeError(`Resolutions map must be an object. Received type ${typeof value} (${value})`);
      }
      function cloneFilesList(value, name) {
        if (Array.isArray(value)) {
          const files = [];
          for (const entry of value) {
            if (typeof entry !== "string") {
              throw new TypeError(
                `${name} entry must be a string. Received type ${typeof entry} (${entry})`
              );
            }
            files.push(entry);
          }
          return files.sort();
        }
        throw new TypeError(`${name} list must be an array. Received type ${typeof value} (${value})`);
      }
      function transformImportsMap(value, root, conditionalRoot, opts, fn) {
        const { conditions = {} } = opts;
        const imports = {};
        for (const entry of Object.entries(value)) {
          const condition = entry[0];
          imports[condition] = transformImportsMapEntry(
            entry[1],
            root,
            conditionalRoot || conditions[condition],
            opts,
            fn
          );
        }
        return imports;
      }
      function transformImportsMapEntry(value, root, conditionalRoot, opts, fn) {
        const { conditions = {} } = opts;
        if (typeof value === "string") {
          return fn(value, conditionalRoot || conditions.default || root);
        }
        return transformImportsMap(value, root, conditionalRoot, opts, fn);
      }
      function transformResolutionsMap(value, root, opts, fn) {
        const resolutions = {};
        for (const entry of Object.entries(value)) {
          resolutions[fn(entry[0], root)] = transformImportsMap(entry[1], root, null, opts, fn);
        }
        return resolutions;
      }
      function transformFilesList(value, root, fn) {
        const files = [];
        for (const entry of value) {
          files.push(fn(entry, root));
        }
        return files;
      }
      function mountSpecifier(specifier, root) {
        if (startsWithWindowsDriveLetter(specifier)) {
          specifier = "/" + specifier;
        }
        if (specifier[0] === "/" || specifier[0] === "\\") {
          specifier = "." + specifier;
        }
        if (specifier.startsWith("./") || specifier.startsWith(".\\")) {
          return new URL(specifier, root).href;
        }
        return specifier;
      }
      function unmountSpecifier(specifier, root) {
        specifier = new URL(specifier);
        if (typeof root === "string") root = new URL(root);
        if (specifier.protocol !== root.protocol || specifier.host !== root.host || specifier.port !== root.port) {
          return specifier.href;
        }
        const specifierPath = splitPath(specifier.pathname);
        const rootPath = splitPath(root.pathname);
        while (specifierPath.length > 0 && rootPath[0] === specifierPath[0]) {
          specifierPath.shift();
          rootPath.shift();
        }
        rootPath.fill("..");
        return "/" + rootPath.concat(specifierPath).join("/");
      }
      function splitPath(path) {
        const parts = path.split("/");
        if (!parts[0]) parts.shift();
        if (!parts[parts.length - 1]) parts.pop();
        return parts;
      }
      function isASCIIUpperAlpha(c) {
        return c >= 65 && c <= 90;
      }
      function isASCIILowerAlpha(c) {
        return c >= 97 && c <= 122;
      }
      function isASCIIAlpha(c) {
        return isASCIIUpperAlpha(c) || isASCIILowerAlpha(c);
      }
      function isWindowsDriveLetter(input) {
        return input.length >= 2 && isASCIIAlpha(input.charCodeAt(0)) && (input.charCodeAt(1) === 58 || input.charCodeAt(1) === 124);
      }
      function startsWithWindowsDriveLetter(input) {
        return input.length >= 2 && isWindowsDriveLetter(input) && (input.length === 2 || input.charCodeAt(2) === 47 || input.charCodeAt(2) === 92 || input.charCodeAt(2) === 63 || input.charCodeAt(2) === 35);
      }
    }
  });

  // ../../node_modules/localdrive/streams.js
  var require_streams = __commonJS({
    "../../node_modules/localdrive/streams.js"(exports, module) {
      var { Readable, Writable } = require_streamx();
      var fs = require_bare_node_fs();
      var fsp = require_promises2();
      var path = __require("path");
      var b4a = require_b4a();
      var FileWriteStream = class extends Writable {
        constructor(filename, key, drive, opts = {}) {
          super({ map });
          this.filename = filename;
          this.atomicFilename = this.filename;
          this.key = key;
          this.drive = drive;
          this.executable = !!opts.executable;
          this.metadata = opts.metadata || null;
          this.fd = 0;
        }
        _open(cb) {
          this._openp().then(cb, cb);
        }
        _final(cb) {
          this._finalp().then(cb, cb);
        }
        _destroy(cb) {
          this._destroyp().then(cb, cb);
        }
        async _openp() {
          this.atomicFilename = this.drive._alloc(this.filename);
          const release = await this.drive._lock();
          const mode = this.executable ? 484 : 420;
          try {
            await fsp.mkdir(path.dirname(this.filename), { recursive: true });
            this.fd = await openFilePromise(this.atomicFilename, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_TRUNC | fs.constants.O_APPEND, mode);
          } finally {
            release();
          }
          const st = await fstatPromise(this.fd);
          if (this.executable !== !!(st.mode & fs.constants.S_IXUSR)) {
            await fchmodPromise(this.fd, mode);
          }
        }
        _writev(datas, cb) {
          fs.writev(this.fd, datas, cb);
        }
        async _destroyp(cb) {
          if (this.fd) await closeFilePromise(this.fd);
          if (this.atomicFilename !== this.filename) {
            await unlinkSafe(this.atomicFilename);
            this._free();
          }
        }
        async _finalp() {
          if (this.metadata === null) {
            if (this.drive.metadata.del) {
              await this.drive.metadata.del(this.key);
            }
          } else if (this.drive.metadata.put) {
            await this.drive.metadata.put(this.key, this.metadata);
          }
          const fd = this.fd;
          this.fd = 0;
          await closeFilePromise(fd);
          if (this.atomicFilename !== this.filename) {
            await renameFilePromise(this.atomicFilename, this.filename);
            this._free();
          }
        }
        _free() {
          if (this.atomicFilename === this.filename) return;
          this.drive._free(this.atomicFilename);
          this.atomicFilename = this.filename;
        }
      };
      var FileReadStream = class extends Readable {
        constructor(filename, opts = {}) {
          super();
          this.filename = filename;
          this.fd = 0;
          this._offset = opts.start || 0;
          this._missing = 0;
          if (opts.length) this._missing = opts.length;
          else if (typeof opts.end === "number") this._missing = opts.end - this._offset + 1;
          else this._missing = -1;
        }
        _open(cb) {
          fs.open(this.filename, fs.constants.O_RDONLY, (err, fd) => {
            if (err) return cb(err);
            const onerror = (err2) => fs.close(fd, () => cb(err2));
            fs.fstat(fd, (err2, st) => {
              if (err2) return onerror(err2);
              if (!st.isFile()) return onerror(new Error(this.filename + " is not a file"));
              this.fd = fd;
              if (this._missing === -1) this._missing = st.size;
              if (st.size < this._offset) {
                this._offset = st.size;
                this._missing = 0;
                return cb(null);
              }
              if (st.size < this._offset + this._missing) {
                this._missing = st.size - this._offset;
                return cb(null);
              }
              cb(null);
            });
          });
        }
        _read(cb) {
          if (!this._missing) {
            this.push(null);
            return cb(null);
          }
          const data = b4a.allocUnsafe(Math.min(this._missing, 65536));
          fs.read(this.fd, data, 0, data.byteLength, this._offset, (err, read) => {
            if (err) return cb(err);
            if (!read) {
              this.push(null);
              return cb(null);
            }
            if (this._missing < read) read = this._missing;
            this.push(data.subarray(0, read));
            this._missing -= read;
            this._offset += read;
            if (!this._missing) this.push(null);
            cb(null);
          });
        }
        _destroy(cb) {
          if (!this.fd) return cb(null);
          fs.close(this.fd, () => cb(null));
        }
      };
      module.exports = { FileWriteStream, FileReadStream };
      function map(s) {
        return typeof s === "string" ? b4a.from(s) : s;
      }
      function openFilePromise(filename, flags, mode) {
        return new Promise((resolve, reject) => {
          fs.open(filename, flags, mode, function(error, fd) {
            if (error) reject(error);
            else resolve(fd);
          });
        });
      }
      function fstatPromise(fd) {
        return new Promise((resolve, reject) => {
          fs.fstat(fd, function(error, stats) {
            if (error) reject(error);
            else resolve(stats);
          });
        });
      }
      function fchmodPromise(fd, mode) {
        return new Promise((resolve, reject) => {
          fs.fchmod(fd, mode, function(error) {
            if (error) reject(error);
            else resolve();
          });
        });
      }
      function closeFilePromise(fd) {
        return new Promise((resolve, reject) => {
          fs.close(fd, function(error) {
            if (error) reject(error);
            else resolve();
          });
        });
      }
      function renameFilePromise(oldPath, newPath) {
        return new Promise((resolve, reject) => {
          fs.rename(oldPath, newPath, function(err) {
            if (err) reject(err);
            else resolve();
          });
        });
      }
      async function unlinkSafe(filename) {
        try {
          await fsp.unlink(filename);
        } catch (err) {
          if (err.code !== "ENOENT") throw err;
        }
      }
    }
  });

  // ../../node_modules/queue-tick/queue-microtask.js
  var require_queue_microtask = __commonJS({
    "../../node_modules/queue-tick/queue-microtask.js"(exports, module) {
      module.exports = typeof queueMicrotask === "function" ? queueMicrotask : (fn) => Promise.resolve().then(fn);
    }
  });

  // ../../node_modules/queue-tick/process-next-tick.js
  var require_process_next_tick = __commonJS({
    "../../node_modules/queue-tick/process-next-tick.js"(exports, module) {
      module.exports = typeof process !== "undefined" && typeof process.nextTick === "function" ? process.nextTick.bind(process) : require_queue_microtask();
    }
  });

  // ../../node_modules/mutexify/index.js
  var require_mutexify = __commonJS({
    "../../node_modules/mutexify/index.js"(exports, module) {
      var queueTick = require_process_next_tick();
      var mutexify = function() {
        var queue = [];
        var used = null;
        var call = function() {
          used(release);
        };
        var acquire = function(fn) {
          if (used) return queue.push(fn);
          used = fn;
          acquire.locked = true;
          queueTick(call);
          return 0;
        };
        acquire.locked = false;
        var release = function(fn, err, value) {
          used = null;
          acquire.locked = false;
          if (queue.length) acquire(queue.shift());
          if (fn) fn(err, value);
        };
        return acquire;
      };
      module.exports = mutexify;
    }
  });

  // ../../node_modules/mutexify/promise.js
  var require_promise = __commonJS({
    "../../node_modules/mutexify/promise.js"(exports, module) {
      var mutexify = require_mutexify();
      var mutexifyPromise = function() {
        var lock = mutexify();
        var acquire = function() {
          return new Promise(lock);
        };
        Object.defineProperty(acquire, "locked", {
          get: function() {
            return lock.locked;
          },
          enumerable: true
        });
        return acquire;
      };
      module.exports = mutexifyPromise;
    }
  });

  // ../../node_modules/same-data/index.js
  var require_same_data = __commonJS({
    "../../node_modules/same-data/index.js"(exports, module) {
      module.exports = sameData;
      function type(o) {
        const t = typeof o;
        return t === "object" ? Array.isArray(o) ? "array" : isTypedArray(o) ? typeof o.equals === "function" ? "buffer" : "array" : o === null ? "null" : "object" : t;
      }
      function isTypedArray(a) {
        return !!a && typeof a.length === "number" && ArrayBuffer.isView(a.array);
      }
      function sameData(a, b) {
        if (a === b) return true;
        const ta = type(a);
        const tb = type(b);
        if (ta !== tb) return false;
        if (ta === "buffer") return a.equals(b);
        if (ta === "array") {
          if (a.length !== b.length) return false;
          for (let i = 0; i < a.length; i++) {
            if (!sameData(a[i], b[i])) return false;
          }
          return true;
        }
        if (ta !== "object") return false;
        const ea = Object.entries(a);
        const eb = Object.entries(b);
        if (ea.length !== eb.length) return false;
        ea.sort(cmp);
        eb.sort(cmp);
        for (let i = 0; i < ea.length; i++) {
          if (ea[i][0] !== eb[i][0] || !sameData(ea[i][1], eb[i][1])) return false;
        }
        return true;
      }
      function cmp(a, b) {
        return a[0] === b[0] ? 0 : a[0] < b[0] ? -1 : 1;
      }
    }
  });

  // ../../node_modules/binary-stream-equals/index.js
  var require_binary_stream_equals = __commonJS({
    "../../node_modules/binary-stream-equals/index.js"(exports, module) {
      var b4a = require_b4a();
      module.exports = function(a, b) {
        return new Promise((resolve, reject) => binaryEquals(a, b, resolve, reject));
      };
      function binaryEquals(a, b, resolve, reject) {
        let aBuf = null;
        let aEnded = false;
        let bBuf = null;
        let bEnded = false;
        let closed = 0;
        let done = false;
        let error = null;
        let equals = false;
        a.on("readable", tick);
        a.on("end", onend);
        a.on("error", onerror);
        a.on("close", onclose);
        b.on("readable", tick);
        b.on("end", onend);
        b.on("error", onerror);
        b.on("close", onclose);
        function onerror(err) {
          error = err;
          a.destroy();
          b.destroy();
        }
        function onclose() {
          if (++closed !== 2) return;
          if (error !== null && done === false) reject(error);
          else resolve(equals);
        }
        function ondone(eq) {
          if (done) return;
          done = true;
          equals = eq;
          a.destroy();
          b.destroy();
        }
        function onend() {
          if (this === a) aEnded = true;
          else bEnded = true;
          tick();
        }
        function tick() {
          while (done === false) {
            if (aBuf === null) aBuf = a.read();
            if (bBuf === null) bBuf = b.read();
            if (aBuf === null && bBuf === null && aEnded && bEnded) {
              ondone(true);
              return;
            }
            if (aBuf !== null && (bBuf === null && bEnded)) {
              ondone(false);
              return;
            }
            if (bBuf !== null && (aBuf === null && aEnded)) {
              ondone(false);
              return;
            }
            if (aBuf === null || bBuf === null) return;
            if (aBuf.byteLength === bBuf.byteLength) {
              if (b4a.equals(aBuf, bBuf)) {
                aBuf = bBuf = null;
                continue;
              }
              ondone(false);
              return;
            }
            const min = Math.min(aBuf.byteLength, bBuf.byteLength);
            if (b4a.equals(aBuf.subarray(0, min), bBuf.subarray(0, min))) {
              aBuf = aBuf.byteLength === min ? null : aBuf.subarray(min);
              bBuf = bBuf.byteLength === min ? null : bBuf.subarray(min);
              continue;
            }
            ondone(false);
            return;
          }
        }
      }
    }
  });

  // ../../node_modules/speedometer/index.js
  var require_speedometer = __commonJS({
    "../../node_modules/speedometer/index.js"(exports, module) {
      var tick = 1;
      var maxTick = 65535;
      var resolution = 4;
      var timer;
      var inc = function() {
        tick = tick + 1 & maxTick;
      };
      module.exports = function(seconds) {
        if (!timer) {
          timer = setInterval(inc, 1e3 / resolution | 0);
          if (timer.unref) timer.unref();
        }
        var size = resolution * (seconds || 5);
        var buffer = [0];
        var pointer = 1;
        var last = tick - 1 & maxTick;
        return function(delta) {
          var dist = tick - last & maxTick;
          if (dist > size) dist = size;
          last = tick;
          while (dist--) {
            if (pointer === size) pointer = 0;
            buffer[pointer] = buffer[pointer === 0 ? size - 1 : pointer - 1];
            pointer++;
          }
          if (delta) buffer[pointer - 1] += delta;
          var top = buffer[pointer - 1];
          var btm = buffer.length < size ? 0 : buffer[pointer === size ? 0 : pointer];
          return buffer.length < resolution ? top : (top - btm) * resolution / buffer.length;
        };
      };
    }
  });

  // ../../node_modules/bare-semver/lib/constants.js
  var require_constants5 = __commonJS({
    "../../node_modules/bare-semver/lib/constants.js"(exports, module) {
      module.exports = {
        EQ: 1,
        LT: 2,
        LTE: 3,
        GT: 4,
        GTE: 5
      };
    }
  });

  // ../../node_modules/bare-semver/lib/errors.js
  var require_errors7 = __commonJS({
    "../../node_modules/bare-semver/lib/errors.js"(exports, module) {
      module.exports = class SemVerError extends Error {
        constructor(msg, code, fn = SemVerError) {
          super(`${code}: ${msg}`);
          this.code = code;
          if (Error.captureStackTrace) {
            Error.captureStackTrace(this, fn);
          }
        }
        get name() {
          return "SemVerError";
        }
        static INVALID_VERSION(msg, fn = SemVerError.INVALID_VERSION) {
          return new SemVerError(msg, "INVALID_VERSION", fn);
        }
        static INVALID_RANGE(msg, fn = SemVerError.INVALID_RANGE) {
          return new SemVerError(msg, "INVALID_RANGE", fn);
        }
      };
    }
  });

  // ../../node_modules/bare-semver/lib/version.js
  var require_version = __commonJS({
    "../../node_modules/bare-semver/lib/version.js"(exports, module) {
      var errors = require_errors7();
      var Version = class {
        constructor(major, minor, patch, opts = {}) {
          const { prerelease = [], build = [] } = opts;
          this.major = major;
          this.minor = minor;
          this.patch = patch;
          this.prerelease = prerelease;
          this.build = build;
        }
        compare(version) {
          return exports.compare(this, version);
        }
        toString() {
          let result = `${this.major}.${this.minor}.${this.patch}`;
          if (this.prerelease.length) {
            result += "-" + this.prerelease.join(".");
          }
          if (this.build.length) {
            result += "+" + this.build.join(".");
          }
          return result;
        }
      };
      module.exports = exports = Version;
      exports.parse = function parse2(input, state = { position: 0, partial: false, range: false }) {
        let i = state.position;
        let c;
        const unexpected = (expected) => {
          let msg;
          if (i >= input.length) {
            msg = `Unexpected end of input in '${input}'`;
          } else {
            msg = `Unexpected token '${input[i]}' in '${input}' at position ${i}`;
          }
          if (expected) msg += `, ${expected}`;
          throw errors.INVALID_VERSION(msg, unexpected);
        };
        const components = [0, 0, 0];
        let k = 0;
        while (k < 3) {
          c = input[i];
          if (k > 0) {
            if (c === ".") c = input[++i];
            else if (state.range) break;
            else unexpected("expected '.'");
          }
          if (c === "0") {
            i++;
            k++;
          } else if (c >= "1" && c <= "9") {
            let j = 0;
            do
              c = input[i + ++j];
            while (c >= "0" && c <= "9");
            components[k++] = parseInt(input.substring(i, i + j));
            i += j;
          } else unexpected("expected /[0-9]/");
        }
        const prerelease = [];
        if (k === 3 && input[i] === "-") {
          i++;
          while (true) {
            c = input[i];
            let tag = "";
            let j = 0;
            while (c >= "0" && c <= "9") c = input[i + ++j];
            let isNumeric = false;
            if (j) {
              tag += input.substring(i, i + j);
              c = input[i += j];
              isNumeric = tag[0] !== "0" || tag.length === 1;
            }
            j = 0;
            while (c >= "0" && c <= "9" || c >= "a" && c <= "z" || c >= "A" && c <= "Z" || c === "-")
              c = input[i + ++j];
            if (j) {
              tag += input.substring(i, i + j);
              c = input[i += j];
            } else if (!isNumeric) unexpected("expected /[a-zA-Z-]/");
            prerelease.push(tag);
            if (c === ".") c = input[++i];
            else break;
          }
        }
        const build = [];
        if (k === 3 && input[i] === "+") {
          i++;
          while (true) {
            c = input[i];
            let tag = "";
            let j = 0;
            while (c >= "0" && c <= "9" || c >= "a" && c <= "z" || c >= "A" && c <= "Z" || c === "-")
              c = input[i + ++j];
            if (j) {
              tag += input.substring(i, i + j);
              c = input[i += j];
            } else unexpected("expected /[0-9a-zA-Z-]/");
            build.push(tag);
            if (c === ".") c = input[++i];
            else break;
          }
        }
        if (i < input.length && state.partial === false) {
          unexpected("expected end of input");
        }
        state.position = i;
        return new Version(...components, { prerelease, build });
      };
      var integer = /^[0-9]+$/;
      exports.compare = function compare(a, b) {
        if (a.major > b.major) return 1;
        if (a.major < b.major) return -1;
        if (a.minor > b.minor) return 1;
        if (a.minor < b.minor) return -1;
        if (a.patch > b.patch) return 1;
        if (a.patch < b.patch) return -1;
        if (a.prerelease.length === 0) return b.prerelease.length === 0 ? 0 : 1;
        if (b.prerelease.length === 0) return -1;
        let i = 0;
        do {
          let x = a.prerelease[i];
          let y = b.prerelease[i];
          if (x === void 0) return y === void 0 ? 0 : -1;
          if (y === void 0) return 1;
          if (x === y) continue;
          const xInt = integer.test(x);
          const yInt = integer.test(y);
          if (xInt && yInt) {
            x = +x;
            y = +y;
          } else {
            if (xInt) return -1;
            if (yInt) return 1;
          }
          return x > y ? 1 : -1;
        } while (++i);
      };
    }
  });

  // ../../node_modules/bare-semver/lib/comparator.js
  var require_comparator = __commonJS({
    "../../node_modules/bare-semver/lib/comparator.js"(exports, module) {
      var constants = require_constants5();
      var symbols = {
        [constants.EQ]: "=",
        [constants.LT]: "<",
        [constants.LTE]: "<=",
        [constants.GT]: ">",
        [constants.GTE]: ">="
      };
      module.exports = class Comparator {
        constructor(operator, version) {
          this.operator = operator;
          this.version = version;
        }
        test(version) {
          const result = version.compare(this.version);
          switch (this.operator) {
            case constants.LT:
              return result < 0;
            case constants.LTE:
              return result <= 0;
            case constants.GT:
              return result > 0;
            case constants.GTE:
              return result >= 0;
            default:
              return result === 0;
          }
        }
        toString() {
          return symbols[this.operator] + this.version;
        }
      };
    }
  });

  // ../../node_modules/bare-semver/lib/range.js
  var require_range2 = __commonJS({
    "../../node_modules/bare-semver/lib/range.js"(exports, module) {
      var constants = require_constants5();
      var errors = require_errors7();
      var Version = require_version();
      var Comparator = require_comparator();
      var Range = class {
        constructor(comparators = []) {
          this.comparators = comparators;
        }
        test(version) {
          for (const set of this.comparators) {
            let matches = true;
            for (const comparator of set) {
              if (comparator.test(version)) continue;
              matches = false;
              break;
            }
            if (matches) return true;
          }
          return false;
        }
        toString() {
          let result = "";
          let first = true;
          for (const set of this.comparators) {
            if (first) first = false;
            else result += " || ";
            result += set.join(" ");
          }
          return result;
        }
      };
      module.exports = exports = Range;
      exports.parse = function parse2(input, state = { position: 0, partial: false }) {
        let i = state.position;
        let c;
        const unexpected = (expected) => {
          let msg;
          if (i >= input.length) {
            msg = `Unexpected end of input in '${input}'`;
          } else {
            msg = `Unexpected token '${input[i]}' in '${input}' at position ${i}`;
          }
          if (expected) msg += `, ${expected}`;
          throw errors.INVALID_VERSION(msg, unexpected);
        };
        const comparators = [];
        while (i < input.length) {
          const set = [];
          while (i < input.length) {
            c = input[i];
            let operator = constants.EQ;
            if (c === "<") {
              operator = constants.LT;
              c = input[++i];
              if (c === "=") {
                operator = constants.LTE;
                c = input[++i];
              }
            } else if (c === ">") {
              operator = constants.GT;
              c = input[++i];
              if (c === "=") {
                operator = constants.GTE;
                c = input[++i];
              }
            } else if (c === "=") {
              c = input[++i];
            }
            const state2 = { position: i, partial: true, range: true };
            set.push(new Comparator(operator, Version.parse(input, state2)));
            c = input[i = state2.position];
            while (c === " ") c = input[++i];
            if (c === "|" && input[i + 1] === "|") {
              c = input[i += 2];
              while (c === " ") c = input[++i];
              break;
            }
            if (c && c !== "<" && c !== ">") unexpected("expected '||', '<', or '>'");
          }
          if (set.length) comparators.push(set);
        }
        if (i < input.length && state.partial === false) {
          unexpected("expected end of input");
        }
        state.position = i;
        return new Range(comparators);
      };
    }
  });

  // ../../node_modules/bare-semver/index.js
  var require_bare_semver = __commonJS({
    "../../node_modules/bare-semver/index.js"(exports) {
      exports.constants = require_constants5();
      exports.errors = require_errors7();
      var Version = exports.Version = require_version();
      var Range = exports.Range = require_range2();
      exports.Comparator = require_comparator();
      exports.satisfies = function satisfies(version, range) {
        if (typeof version === "string") version = Version.parse(version);
        if (typeof range === "string") range = Range.parse(range);
        return range.test(version);
      };
    }
  });

  // ../../node_modules/bare-module-resolve/lib/errors.js
  var require_errors8 = __commonJS({
    "../../node_modules/bare-module-resolve/lib/errors.js"(exports, module) {
      module.exports = class ModuleResolveError extends Error {
        constructor(msg, code, fn = ModuleResolveError) {
          super(`${code}: ${msg}`);
          this.code = code;
          if (Error.captureStackTrace) {
            Error.captureStackTrace(this, fn);
          }
        }
        get name() {
          return "ModuleResolveError";
        }
        static INVALID_MODULE_SPECIFIER(msg) {
          return new ModuleResolveError(
            msg,
            "INVALID_MODULE_SPECIFIER",
            ModuleResolveError.INVALID_MODULE_SPECIFIER
          );
        }
        static INVALID_PACKAGE_TARGET(msg) {
          return new ModuleResolveError(
            msg,
            "INVALID_PACKAGE_TARGET",
            ModuleResolveError.INVALID_PACKAGE_TARGET
          );
        }
        static PACKAGE_PATH_NOT_EXPORTED(msg) {
          return new ModuleResolveError(
            msg,
            "PACKAGE_PATH_NOT_EXPORTED",
            ModuleResolveError.PACKAGE_PATH_NOT_EXPORTED
          );
        }
        static PACKAGE_IMPORT_NOT_DEFINED(msg) {
          return new ModuleResolveError(
            msg,
            "PACKAGE_IMPORT_NOT_DEFINED",
            ModuleResolveError.PACKAGE_IMPORT_NOT_DEFINED
          );
        }
        static UNSUPPORTED_ENGINE(msg) {
          return new ModuleResolveError(msg, "UNSUPPORTED_ENGINE", ModuleResolveError.UNSUPPORTED_ENGINE);
        }
      };
    }
  });

  // ../../node_modules/bare-module-resolve/index.js
  var require_bare_module_resolve = __commonJS({
    "../../node_modules/bare-module-resolve/index.js"(exports, module) {
      var { satisfies } = require_bare_semver();
      var errors = require_errors8();
      module.exports = exports = function resolve(specifier, parentURL, opts, readPackage) {
        if (typeof opts === "function") {
          readPackage = opts;
          opts = {};
        } else if (typeof readPackage !== "function") {
          readPackage = defaultReadPackage;
        }
        return {
          *[Symbol.iterator]() {
            const generator = exports.module(specifier, parentURL, opts);
            let next = generator.next();
            while (next.done !== true) {
              const value = next.value;
              if (value.package) {
                next = generator.next(readPackage(value.package));
              } else {
                next = generator.next(yield value.resolution);
              }
            }
            return next.value;
          },
          async *[Symbol.asyncIterator]() {
            const generator = exports.module(specifier, parentURL, opts);
            let next = generator.next();
            while (next.done !== true) {
              const value = next.value;
              if (value.package) {
                next = generator.next(await readPackage(value.package));
              } else {
                next = generator.next(yield value.resolution);
              }
            }
            return next.value;
          }
        };
      };
      function defaultReadPackage() {
        return null;
      }
      var UNRESOLVED = 0;
      var YIELDED = 1;
      var RESOLVED = YIELDED | 2;
      exports.constants = {
        UNRESOLVED,
        YIELDED,
        RESOLVED
      };
      exports.module = function* (specifier, parentURL, opts = {}) {
        const { resolutions = null, imports = null } = opts;
        if (exports.startsWithWindowsDriveLetter(specifier)) {
          specifier = "/" + specifier;
        }
        let status;
        if (resolutions) {
          status = yield* exports.preresolved(specifier, resolutions, parentURL, opts);
          if (status) return status;
        }
        status = yield* exports.url(specifier, parentURL, opts);
        if (status) return status;
        status = yield* exports.packageImports(specifier, parentURL, opts);
        if (status) return status;
        if (specifier === "." || specifier === ".." || specifier[0] === "/" || specifier[0] === "\\" || specifier.startsWith("./") || specifier.startsWith(".\\") || specifier.startsWith("../") || specifier.startsWith("..\\")) {
          if (imports) {
            status = yield* exports.packageImportsExports(specifier, imports, parentURL, true, opts);
            if (status) return status;
          }
          status = yield* exports.deferred(specifier, opts);
          if (status) return status;
          status = yield* exports.file(specifier, parentURL, false, opts);
          if (status === RESOLVED) return status;
          return yield* exports.directory(specifier, parentURL, opts);
        }
        return yield* exports.package(specifier, parentURL, opts);
      };
      exports.url = function* (url, parentURL, opts = {}) {
        const { imports = null, deferredProtocol = "deferred:", resolutions = null } = opts;
        let resolution;
        try {
          resolution = new URL(url);
        } catch {
          return UNRESOLVED;
        }
        if (imports) {
          const status = yield* exports.packageImportsExports(
            resolution.href,
            imports,
            parentURL,
            true,
            opts
          );
          if (status) return status;
        }
        if (resolution.protocol === deferredProtocol) {
          const specifier = resolution.pathname;
          if (resolutions) {
            const imports2 = resolutions[parentURL.href];
            if (typeof imports2 === "object" && imports2 !== null) {
              opts = {
                ...opts,
                resolutions: { ...resolutions, [parentURL.href]: { ...imports2, [specifier]: null } }
              };
            }
          }
          return yield* exports.module(specifier, parentURL, opts);
        }
        if (resolution.protocol === "node:") {
          const specifier = resolution.pathname;
          if (specifier === "." || specifier === ".." || specifier[0] === "/" || specifier.startsWith("./") || specifier.startsWith("../")) {
            throw errors.INVALID_MODULE_SPECIFIER(`Module specifier '${url}' is not a valid package name`);
          }
          return yield* exports.package(specifier, parentURL, opts);
        }
        const resolved = yield { resolution };
        return resolved ? RESOLVED : YIELDED;
      };
      exports.preresolved = function* (specifier, resolutions, parentURL, opts = {}) {
        const imports = resolutions[parentURL.href];
        if (typeof imports === "object" && imports !== null) {
          return yield* exports.packageImportsExports(specifier, imports, parentURL, true, opts);
        }
        return UNRESOLVED;
      };
      exports.deferred = function* (specifier, opts = {}) {
        const { deferredProtocol = "deferred:", defer = [] } = opts;
        if (defer.includes(specifier)) {
          const resolved = yield { resolution: new URL(deferredProtocol + specifier) };
          return resolved ? RESOLVED : YIELDED;
        }
        return UNRESOLVED;
      };
      exports.package = function* (packageSpecifier, parentURL, opts = {}) {
        const { builtins = [] } = opts;
        if (packageSpecifier === "") {
          throw errors.INVALID_MODULE_SPECIFIER(
            `Module specifier '${packageSpecifier}' is not a valid package name`
          );
        }
        let packageName;
        if (packageSpecifier[0] !== "@") {
          packageName = packageSpecifier.split("/", 1).join();
        } else {
          if (!packageSpecifier.includes("/")) {
            throw errors.INVALID_MODULE_SPECIFIER(
              `Module specifier '${packageSpecifier}' is not a valid package name`
            );
          }
          packageName = packageSpecifier.split("/", 2).join("/");
        }
        if (packageName[0] === "." || packageName.includes("\\") || packageName.includes("%")) {
          throw errors.INVALID_MODULE_SPECIFIER(
            `Module specifier '${packageSpecifier}' is not a valid package name`
          );
        }
        let status;
        status = yield* exports.builtinTarget(packageSpecifier, null, builtins, opts);
        if (status) return status;
        status = yield* exports.deferred(packageSpecifier, opts);
        if (status) return status;
        let packageSubpath = "." + packageSpecifier.substring(packageName.length);
        status = yield* exports.packageSelf(packageName, packageSubpath, parentURL, opts);
        if (status) return status;
        parentURL = new URL(parentURL.href);
        for (const packageURL of exports.lookupPackageRoot(packageName, parentURL)) {
          const info = yield { package: packageURL };
          if (info) {
            if (info.engines) exports.validateEngines(packageURL, info.engines, opts);
            if (info.exports) {
              return yield* exports.packageExports(packageURL, packageSubpath, info.exports, opts);
            }
            if (packageSubpath === ".") {
              if (typeof info.main === "string" && info.main !== "") {
                packageSubpath = info.main;
              } else {
                return yield* exports.file("index", packageURL, true, opts);
              }
            }
            status = yield* exports.file(packageSubpath, packageURL, false, opts);
            if (status === RESOLVED) return status;
            return yield* exports.directory(packageSubpath, packageURL, opts);
          }
        }
        return UNRESOLVED;
      };
      exports.packageSelf = function* (packageName, packageSubpath, parentURL, opts = {}) {
        for (const packageURL of exports.lookupPackageScope(parentURL, opts)) {
          const info = yield { package: packageURL };
          if (info) {
            if (info.name !== packageName) return false;
            if (info.exports) {
              return yield* exports.packageExports(packageURL, packageSubpath, info.exports, opts);
            }
            if (packageSubpath === ".") {
              if (typeof info.main === "string" && info.main !== "") {
                packageSubpath = info.main;
              } else {
                return yield* exports.file("index", packageURL, true, opts);
              }
            }
            const status = yield* exports.file(packageSubpath, packageURL, false, opts);
            if (status === RESOLVED) return status;
            return yield* exports.directory(packageSubpath, packageURL, opts);
          }
        }
        return UNRESOLVED;
      };
      exports.packageExports = function* (packageURL, subpath, packageExports, opts = {}) {
        if (subpath === ".") {
          let mainExport;
          if (typeof packageExports === "string" || Array.isArray(packageExports)) {
            mainExport = packageExports;
          } else if (typeof packageExports === "object" && packageExports !== null) {
            const keys = Object.keys(packageExports);
            if (keys.some((key) => key.startsWith("."))) {
              if ("." in packageExports) mainExport = packageExports["."];
            } else {
              mainExport = packageExports;
            }
          }
          if (mainExport) {
            const status = yield* exports.packageTarget(packageURL, mainExport, null, false, opts);
            if (status) return status;
          }
        } else if (typeof packageExports === "object" && packageExports !== null) {
          const keys = Object.keys(packageExports);
          if (keys.every((key) => key.startsWith("."))) {
            const status = yield* exports.packageImportsExports(
              subpath,
              packageExports,
              packageURL,
              false,
              opts
            );
            if (status) return status;
          }
        }
        throw errors.PACKAGE_PATH_NOT_EXPORTED(
          `Package subpath '${subpath}' is not defined by "exports" in '${packageURL}'`
        );
      };
      exports.packageImports = function* (specifier, parentURL, opts = {}) {
        const { imports = null } = opts;
        if (specifier === "#" || specifier.startsWith("#/")) {
          throw errors.INVALID_MODULE_SPECIFIER(
            `Module specifier '${specifier}' is not a valid internal imports specifier`
          );
        }
        for (const packageURL of exports.lookupPackageScope(parentURL, opts)) {
          const info = yield { package: packageURL };
          if (info) {
            if (info.imports) {
              const status = yield* exports.packageImportsExports(
                specifier,
                info.imports,
                packageURL,
                true,
                opts
              );
              if (status) return status;
            }
            if (specifier.startsWith("#")) {
              throw errors.PACKAGE_IMPORT_NOT_DEFINED(
                `Package import specifier '${specifier}' is not defined by "imports" in '${packageURL}'`
              );
            }
            break;
          }
        }
        if (imports) {
          const status = yield* exports.packageImportsExports(specifier, imports, parentURL, true, opts);
          if (status) return status;
        }
        return UNRESOLVED;
      };
      exports.packageImportsExports = function* (matchKey, matchObject, packageURL, isImports, opts = {}) {
        if (matchKey in matchObject && !matchKey.includes("*")) {
          const target = matchObject[matchKey];
          return yield* exports.packageTarget(packageURL, target, null, isImports, opts);
        }
        const expansionKeys = Object.keys(matchObject).filter((key) => key.includes("*")).sort(exports.patternKeyCompare);
        for (const expansionKey of expansionKeys) {
          const patternIndex = expansionKey.indexOf("*");
          const patternBase = expansionKey.substring(0, patternIndex);
          if (matchKey.startsWith(patternBase) && matchKey !== patternBase) {
            const patternTrailer = expansionKey.substring(patternIndex + 1);
            if (patternTrailer === "" || matchKey.endsWith(patternTrailer) && matchKey.length >= expansionKey.length) {
              const target = matchObject[expansionKey];
              const patternMatch = matchKey.substring(
                patternBase.length,
                matchKey.length - patternTrailer.length
              );
              return yield* exports.packageTarget(packageURL, target, patternMatch, isImports, opts);
            }
          }
        }
        return UNRESOLVED;
      };
      exports.validateEngines = function validateEngines(packageURL, packageEngines, opts = {}) {
        const { engines = {} } = opts;
        for (const [engine, range] of Object.entries(packageEngines)) {
          if (engine in engines) {
            const version = engines[engine];
            if (!satisfies(version, range)) {
              throw errors.UNSUPPORTED_ENGINE(
                `Package not compatible with engine '${engine}' ${version}, requires range '${range}' defined by "engines" in '${packageURL}'`
              );
            }
          }
        }
      };
      exports.patternKeyCompare = function patternKeyCompare(keyA, keyB) {
        const patternIndexA = keyA.indexOf("*");
        const patternIndexB = keyB.indexOf("*");
        const baseLengthA = patternIndexA === -1 ? keyA.length : patternIndexA + 1;
        const baseLengthB = patternIndexB === -1 ? keyB.length : patternIndexB + 1;
        if (baseLengthA > baseLengthB) return -1;
        if (baseLengthB > baseLengthA) return 1;
        if (patternIndexA === -1) return 1;
        if (patternIndexB === -1) return -1;
        if (keyA.length > keyB.length) return -1;
        if (keyB.length > keyA.length) return 1;
        return 0;
      };
      exports.packageTarget = function* (packageURL, target, patternMatch, isImports, opts = {}) {
        const { conditions = [], matchedConditions = [] } = opts;
        if (typeof target === "string") {
          if (!target.startsWith("./") && !isImports) {
            throw errors.INVALID_PACKAGE_TARGET(
              `Invalid target '${target}' defined by "exports" in '${packageURL}'`
            );
          }
          if (patternMatch !== null) {
            target = target.replaceAll("*", patternMatch);
          }
          const status = yield* exports.url(target, packageURL, opts);
          if (status) return status;
          if (target === "." || target === ".." || target[0] === "/" || target.startsWith("./") || target.startsWith("../")) {
            const resolved = yield { resolution: new URL(target, packageURL) };
            return resolved ? RESOLVED : YIELDED;
          }
          return yield* exports.package(target, packageURL, opts);
        }
        if (Array.isArray(target)) {
          for (const targetValue of target) {
            const status = yield* exports.packageTarget(
              packageURL,
              targetValue,
              patternMatch,
              isImports,
              opts
            );
            if (status) return status;
          }
        } else if (typeof target === "object" && target !== null) {
          let status = UNRESOLVED;
          for (const [condition, targetValue, subset] of exports.conditionMatches(
            target,
            conditions,
            opts
          )) {
            matchedConditions.push(condition);
            status |= yield* exports.packageTarget(packageURL, targetValue, patternMatch, isImports, {
              ...opts,
              conditions: subset
            });
            matchedConditions.pop();
          }
          if (status) return status;
        }
        return UNRESOLVED;
      };
      exports.builtinTarget = function* (packageSpecifier, packageVersion, target, opts = {}) {
        const { builtinProtocol = "builtin:", conditions = [], matchedConditions = [] } = opts;
        if (typeof target === "string") {
          const targetParts = target.split("@");
          let targetName;
          let targetVersion;
          if (target[0] !== "@") {
            targetName = targetParts[0];
            targetVersion = targetParts[1] || null;
          } else {
            targetName = targetParts.slice(0, 2).join("@");
            targetVersion = targetParts[2] || null;
          }
          if (packageSpecifier === targetName) {
            if (packageVersion === null && targetVersion === null) {
              const resolved = yield {
                resolution: new URL(builtinProtocol + packageSpecifier)
              };
              return resolved ? RESOLVED : YIELDED;
            }
            let version = null;
            if (packageVersion === null) {
              version = targetVersion;
            } else if (targetVersion === null || packageVersion === targetVersion) {
              version = packageVersion;
            }
            if (version !== null) {
              const resolved = yield {
                resolution: new URL(builtinProtocol + packageSpecifier + "@" + version)
              };
              return resolved ? RESOLVED : YIELDED;
            }
          }
        } else if (Array.isArray(target)) {
          for (const targetValue of target) {
            const status = yield* exports.builtinTarget(
              packageSpecifier,
              packageVersion,
              targetValue,
              opts
            );
            if (status) return status;
          }
        } else if (typeof target === "object" && target !== null) {
          let status = UNRESOLVED;
          for (const [condition, targetValue, subset] of exports.conditionMatches(
            target,
            conditions,
            opts
          )) {
            matchedConditions.push(condition);
            status |= yield* exports.builtinTarget(packageSpecifier, packageVersion, targetValue, {
              ...opts,
              conditions: subset
            });
            matchedConditions.pop();
          }
          if (status) return status;
        }
        return UNRESOLVED;
      };
      exports.conditionMatches = function* conditionMatches(target, conditions, opts = {}) {
        if (conditions.every((condition) => typeof condition === "string")) {
          const keys = Object.keys(target);
          for (const condition of keys) {
            if (condition === "default" || conditions.includes(condition)) {
              yield [condition, target[condition], conditions];
              return true;
            }
          }
          return false;
        }
        let yielded = false;
        for (const subset of conditions) {
          if (yield* conditionMatches(target, subset, opts)) {
            yielded = true;
          }
        }
        return yielded;
      };
      exports.lookupPackageRoot = function* (packageName, parentURL) {
        parentURL = new URL(parentURL.href);
        do {
          const packageURL = new URL("node_modules/" + packageName + "/", parentURL);
          const info = yield new URL("package.json", packageURL);
          if (info) return info;
          parentURL.pathname = parentURL.pathname.substring(0, parentURL.pathname.lastIndexOf("/"));
          if (parentURL.pathname.length === 3 && exports.isWindowsDriveLetter(parentURL.pathname.substring(1))) {
            break;
          }
        } while (parentURL.pathname !== "" && parentURL.pathname !== "/");
        return null;
      };
      exports.lookupPackageScope = function* lookupPackageScope(scopeURL, opts = {}) {
        const { resolutions = null } = opts;
        if (resolutions) {
          for (const { resolution } of exports.preresolved("#package", resolutions, scopeURL, opts)) {
            if (resolution) return yield resolution;
          }
        }
        scopeURL = new URL(scopeURL.href);
        do {
          if (scopeURL.pathname.endsWith("/node_modules")) break;
          const info = yield new URL("package.json", scopeURL);
          if (info) return info;
          scopeURL.pathname = scopeURL.pathname.substring(0, scopeURL.pathname.lastIndexOf("/"));
          if (scopeURL.pathname.length === 3 && exports.isWindowsDriveLetter(scopeURL.pathname.substring(1))) {
            break;
          }
        } while (scopeURL.pathname !== "" && scopeURL.pathname !== "/");
        return null;
      };
      exports.file = function* (filename, parentURL, isIndex, opts = {}) {
        if (filename === "." || filename === ".." || filename[filename.length - 1] === "/" || filename[filename.length - 1] === "\\") {
          return UNRESOLVED;
        }
        if (parentURL.protocol === "file:" && /%2f|%5c/i.test(filename)) {
          throw errors.INVALID_MODULE_SPECIFIER(`Module specifier '${filename}' is invalid`);
        }
        const { extensions = [] } = opts;
        let status = UNRESOLVED;
        if (!isIndex) {
          if (yield { resolution: new URL(filename, parentURL) }) {
            return RESOLVED;
          }
          status = YIELDED;
        }
        for (const ext of extensions) {
          if (filename.endsWith(ext)) continue;
          if (yield { resolution: new URL(filename + ext, parentURL) }) {
            return RESOLVED;
          }
          status = YIELDED;
        }
        return status;
      };
      exports.directory = function* (dirname, parentURL, opts = {}) {
        let directoryURL;
        if (dirname[dirname.length - 1] === "/" || dirname[dirname.length - 1] === "\\") {
          directoryURL = new URL(dirname, parentURL);
        } else {
          directoryURL = new URL(dirname + "/", parentURL);
        }
        const info = yield { package: new URL("package.json", directoryURL) };
        if (info) {
          if (info.exports) {
            return yield* exports.packageExports(directoryURL, ".", info.exports, opts);
          }
          if (typeof info.main === "string" && info.main !== "") {
            const status = yield* exports.file(info.main, directoryURL, false, opts);
            if (status === RESOLVED) return status;
            return yield* exports.directory(info.main, directoryURL, opts);
          }
        }
        return yield* exports.file("index", directoryURL, true, opts);
      };
      function isASCIIUpperAlpha(c) {
        return c >= 65 && c <= 90;
      }
      function isASCIILowerAlpha(c) {
        return c >= 97 && c <= 122;
      }
      function isASCIIAlpha(c) {
        return isASCIIUpperAlpha(c) || isASCIILowerAlpha(c);
      }
      exports.isWindowsDriveLetter = function isWindowsDriveLetter(input) {
        return input.length >= 2 && isASCIIAlpha(input.charCodeAt(0)) && (input.charCodeAt(1) === 58 || input.charCodeAt(1) === 124);
      };
      exports.startsWithWindowsDriveLetter = function startsWithWindowsDriveLetter(input) {
        return input.length >= 2 && exports.isWindowsDriveLetter(input) && (input.length === 2 || input.charCodeAt(2) === 47 || input.charCodeAt(2) === 92 || input.charCodeAt(2) === 63 || input.charCodeAt(2) === 35);
      };
    }
  });

  // ../../node_modules/bare-addon-resolve/lib/errors.js
  var require_errors9 = __commonJS({
    "../../node_modules/bare-addon-resolve/lib/errors.js"(exports, module) {
      module.exports = class AddonResolveError extends Error {
        constructor(msg, code, fn = AddonResolveError) {
          super(`${code}: ${msg}`);
          this.code = code;
          if (Error.captureStackTrace) {
            Error.captureStackTrace(this, fn);
          }
        }
        get name() {
          return "AddonResolveError";
        }
        static INVALID_ADDON_SPECIFIER(msg) {
          return new AddonResolveError(
            msg,
            "INVALID_ADDON_SPECIFIER",
            AddonResolveError.INVALID_ADDON_SPECIFIER
          );
        }
        static INVALID_PACKAGE_NAME(msg) {
          return new AddonResolveError(
            msg,
            "INVALID_PACKAGE_NAME",
            AddonResolveError.INVALID_PACKAGE_NAME
          );
        }
      };
    }
  });

  // ../../node_modules/bare-addon-resolve/index.js
  var require_bare_addon_resolve = __commonJS({
    "../../node_modules/bare-addon-resolve/index.js"(exports, module) {
      var resolve = require_bare_module_resolve();
      var { Version } = require_bare_semver();
      var errors = require_errors9();
      module.exports = exports = function resolve2(specifier, parentURL, opts, readPackage) {
        if (typeof opts === "function") {
          readPackage = opts;
          opts = {};
        } else if (typeof readPackage !== "function") {
          readPackage = defaultReadPackage;
        }
        return {
          *[Symbol.iterator]() {
            const generator = exports.addon(specifier, parentURL, opts);
            let next = generator.next();
            while (next.done !== true) {
              const value = next.value;
              if (value.package) {
                next = generator.next(readPackage(value.package));
              } else {
                next = generator.next(yield value.resolution);
              }
            }
            return next.value;
          },
          async *[Symbol.asyncIterator]() {
            const generator = exports.addon(specifier, parentURL, opts);
            let next = generator.next();
            while (next.done !== true) {
              const value = next.value;
              if (value.package) {
                next = generator.next(await readPackage(value.package));
              } else {
                next = generator.next(yield value.resolution);
              }
            }
            return next.value;
          }
        };
      };
      function defaultReadPackage() {
        return null;
      }
      var { UNRESOLVED, YIELDED, RESOLVED } = resolve.constants;
      exports.constants = {
        UNRESOLVED,
        YIELDED,
        RESOLVED
      };
      exports.addon = function* (specifier, parentURL, opts = {}) {
        const { resolutions = null } = opts;
        if (exports.startsWithWindowsDriveLetter(specifier)) {
          specifier = "/" + specifier;
        }
        let status;
        if (resolutions) {
          status = yield* resolve.preresolved(specifier, resolutions, parentURL, opts);
          if (status) return status;
        }
        status = yield* exports.url(specifier, parentURL, opts);
        if (status) return status;
        let version = null;
        const i = specifier.lastIndexOf("@");
        if (i > 0) {
          version = specifier.substring(i + 1);
          try {
            Version.parse(version);
            specifier = specifier.substring(0, i);
          } catch {
            version = null;
          }
        }
        if (specifier === "." || specifier === ".." || specifier[0] === "/" || specifier[0] === "\\" || specifier.startsWith("./") || specifier.startsWith(".\\") || specifier.startsWith("../") || specifier.startsWith("..\\")) {
          status = yield* exports.file(specifier, parentURL, opts);
          if (status === RESOLVED) return status;
          return yield* exports.directory(specifier, version, parentURL, opts);
        }
        return yield* exports.package(specifier, version, parentURL, opts);
      };
      exports.url = function* (url, parentURL, opts = {}) {
        let resolution;
        try {
          resolution = new URL(url);
        } catch {
          return UNRESOLVED;
        }
        const resolved = yield { resolution };
        return resolved ? RESOLVED : YIELDED;
      };
      exports.package = function* (packageSpecifier, packageVersion, parentURL, opts = {}) {
        if (packageSpecifier === "") {
          throw errors.INVALID_ADDON_SPECIFIER(
            `Addon specifier '${packageSpecifier}' is not a valid package name`
          );
        }
        let packageName;
        if (packageSpecifier[0] !== "@") {
          packageName = packageSpecifier.split("/", 1).join();
        } else {
          if (!packageSpecifier.includes("/")) {
            throw errors.INVALID_ADDON_SPECIFIER(
              `Addon specifier '${packageSpecifier}' is not a valid package name`
            );
          }
          packageName = packageSpecifier.split("/", 2).join("/");
        }
        if (packageName[0] === "." || packageName.includes("\\") || packageName.includes("%")) {
          throw errors.INVALID_ADDON_SPECIFIER(
            `Addon specifier '${packageSpecifier}' is not a valid package name`
          );
        }
        const packageSubpath = "." + packageSpecifier.substring(packageName.length);
        const status = yield* exports.packageSelf(
          packageName,
          packageSubpath,
          packageVersion,
          parentURL,
          opts
        );
        if (status) return status;
        parentURL = new URL(parentURL.href);
        do {
          const packageURL = new URL("node_modules/" + packageName + "/", parentURL);
          parentURL.pathname = parentURL.pathname.substring(0, parentURL.pathname.lastIndexOf("/"));
          const info = yield { package: new URL("package.json", packageURL) };
          if (info) {
            return yield* exports.directory(packageSubpath, packageVersion, packageURL, opts);
          }
        } while (parentURL.pathname !== "" && parentURL.pathname !== "/");
        return UNRESOLVED;
      };
      exports.packageSelf = function* (packageName, packageSubpath, packageVersion, parentURL, opts = {}) {
        for (const packageURL of resolve.lookupPackageScope(parentURL, opts)) {
          const info = yield { package: packageURL };
          if (info) {
            if (info.name === packageName) {
              return yield* exports.directory(packageSubpath, packageVersion, packageURL, opts);
            }
            break;
          }
        }
        return UNRESOLVED;
      };
      exports.lookupPrebuildsScope = function* lookupPrebuildsScope(url, opts = {}) {
        const scopeURL = new URL(url.href);
        do {
          yield new URL("prebuilds/", scopeURL);
          scopeURL.pathname = scopeURL.pathname.substring(0, scopeURL.pathname.lastIndexOf("/"));
          if (scopeURL.pathname.length === 3 && exports.isWindowsDriveLetter(scopeURL.pathname.substring(1))) {
            break;
          }
        } while (scopeURL.pathname !== "" && scopeURL.pathname !== "/");
      };
      exports.file = function* (filename, parentURL, opts = {}) {
        if (filename === "." || filename === ".." || filename[filename.length - 1] === "/" || filename[filename.length - 1] === "\\") {
          return UNRESOLVED;
        }
        if (parentURL.protocol === "file:" && /%2f|%5c/i.test(filename)) {
          throw errors.INVALID_ADDON_SPECIFIER(`Addon specifier '${filename}' is invalid`);
        }
        const { extensions = [] } = opts;
        let status = UNRESOLVED;
        for (let ext of extensions) {
          if (filename.endsWith(ext)) ext = "";
          if (yield { resolution: new URL(filename + ext, parentURL) }) {
            return RESOLVED;
          }
          status = YIELDED;
        }
        return status;
      };
      exports.directory = function* (dirname, version, parentURL, opts = {}) {
        const {
          host = null,
          // Shorthand for single host resolution
          hosts = host !== null ? [host] : [],
          builtins = [],
          matchedConditions = []
        } = opts;
        let directoryURL;
        if (dirname[dirname.length - 1] === "/" || dirname[dirname.length - 1] === "\\") {
          directoryURL = new URL(dirname, parentURL);
        } else {
          directoryURL = new URL(dirname + "/", parentURL);
        }
        const unversioned = version === null;
        let name = null;
        const info = yield { package: new URL("package.json", directoryURL) };
        if (info) {
          if (typeof info.name === "string" && info.name !== "") {
            if (info.name.includes("__")) {
              throw errors.INVALID_PACKAGE_NAME(`Package name '${info.name}' is invalid`);
            }
            name = info.name.replace(/\//g, "__").replace(/^@/, "");
          } else {
            return UNRESOLVED;
          }
          if (typeof info.version === "string" && info.version !== "") {
            if (version !== null && info.version !== version) return UNRESOLVED;
            version = info.version;
          }
        } else {
          return UNRESOLVED;
        }
        let status;
        status = yield* resolve.builtinTarget(name, version, builtins, opts);
        if (status) return status;
        for (const prebuildsURL of exports.lookupPrebuildsScope(directoryURL, opts)) {
          status = UNRESOLVED;
          for (const host2 of hosts) {
            const conditions = host2.split("-");
            const universal = supportsUniversalPrebuilds(host2) ? conditions.with(1, "universal").join("-") : null;
            matchedConditions.push(...conditions);
            if (version !== null) {
              status |= yield* exports.file(host2 + "/" + name + "@" + version, prebuildsURL, opts);
              if (universal) {
                status |= yield* exports.file(universal + "/" + name + "@" + version, prebuildsURL, opts);
              }
            }
            if (unversioned) {
              status |= yield* exports.file(host2 + "/" + name, prebuildsURL, opts);
              if (universal) {
                status |= yield* exports.file(universal + "/" + name, prebuildsURL, opts);
              }
            }
            for (const _ of conditions) matchedConditions.pop();
          }
          if (status === RESOLVED) return status;
        }
        return yield* exports.linked(name, version, opts);
      };
      exports.linked = function* (name, version = null, opts = {}) {
        const {
          linked = true,
          host = null,
          // Shorthand for single host resolution
          hosts = host !== null ? [host] : [],
          matchedConditions = []
        } = opts;
        if (linked === false || hosts.length === 0) return UNRESOLVED;
        let status = UNRESOLVED;
        for (const host2 of hosts) {
          const [platform = null] = host2.split("-", 1);
          if (platform === null) continue;
          matchedConditions.push(platform);
          status |= yield* platformArtefact(name, version, platform, opts);
          matchedConditions.pop();
        }
        return status;
      };
      function* platformArtefact(name, version = null, platform, opts = {}) {
        const { linkedProtocol = "linked:" } = opts;
        if (platform === "darwin" || platform === "ios") {
          if (version !== null) {
            if (yield {
              resolution: new URL(`${linkedProtocol}${name}.${version}.framework/${name}.${version}`)
            }) {
              return RESOLVED;
            }
            if (platform === "darwin") {
              if (yield {
                resolution: new URL(`${linkedProtocol}lib${name}.${version}.dylib`)
              }) {
                return RESOLVED;
              }
            }
          }
          if (yield {
            resolution: new URL(`${linkedProtocol}${name}.framework/${name}`)
          }) {
            return RESOLVED;
          }
          if (platform === "darwin") {
            if (yield {
              resolution: new URL(`${linkedProtocol}lib${name}.dylib`)
            }) {
              return RESOLVED;
            }
          }
          return YIELDED;
        }
        if (platform === "linux" || platform === "android") {
          if (version !== null) {
            if (yield {
              resolution: new URL(`${linkedProtocol}lib${name}.${version}.so`)
            }) {
              return RESOLVED;
            }
          }
          if (yield {
            resolution: new URL(`${linkedProtocol}lib${name}.so`)
          }) {
            return RESOLVED;
          }
          return YIELDED;
        }
        if (platform === "win32") {
          if (version !== null) {
            if (yield {
              resolution: new URL(`${linkedProtocol}${name}-${version}.dll`)
            }) {
              return RESOLVED;
            }
          }
          if (yield {
            resolution: new URL(`${linkedProtocol}${name}.dll`)
          }) {
            return RESOLVED;
          }
        }
        return UNRESOLVED;
      }
      exports.isWindowsDriveLetter = resolve.isWindowsDriveLetter;
      exports.startsWithWindowsDriveLetter = resolve.startsWithWindowsDriveLetter;
      function supportsUniversalPrebuilds(host) {
        return host === "darwin-arm64" || host === "darwin-x64" || host === "ios-arm64-simulator" || host === "ios-x64-simulator";
      }
    }
  });

  // ../../node_modules/require-addon/lib/node.js
  var require_node2 = __commonJS({
    "../../node_modules/require-addon/lib/node.js"(exports, module) {
      if (typeof __require.addon === "function") {
        module.exports = __require.addon.bind(__require);
      } else {
        let readPackage2 = function(packageURL) {
          try {
            return __require(url.fileURLToPath(packageURL));
          } catch (err) {
            return null;
          }
        }, isAlpine2 = function() {
          return process.platform === "linux" && fs.existsSync("/etc/alpine-release");
        };
        readPackage = readPackage2, isAlpine = isAlpine2;
        const url = require_bare_url();
        const fs = require_bare_node_fs();
        const resolve = require_bare_addon_resolve();
        let host = process.platform + "-" + process.arch;
        const conditions = ["addon", "node", process.platform, process.arch];
        const extensions = [".node"];
        if (isAlpine2()) {
          host += "-musl";
          conditions.push("musl");
        }
        module.exports = function addon(specifier, parentURL) {
          if (typeof parentURL === "string") parentURL = url.pathToFileURL(parentURL);
          const candidates = [];
          let cause;
          for (const resolution of resolve(
            specifier,
            parentURL,
            { host, conditions, extensions },
            readPackage2
          )) {
            candidates.push(resolution);
            switch (resolution.protocol) {
              case "file:":
                try {
                  return __require(url.fileURLToPath(resolution));
                } catch (err2) {
                  cause = err2;
                  continue;
                }
            }
          }
          let message = `Cannot find addon '${specifier}' imported from '${parentURL.href}'`;
          if (candidates.length > 0) {
            message += "\nCandidates:";
            message += "\n" + candidates.map((url2) => "- " + url2.href).join("\n");
          }
          const err = new Error(message, cause ? { cause } : {});
          err.code = "ADDON_NOT_FOUND";
          err.specifier = specifier;
          err.referrer = parentURL;
          err.candidates = candidates;
          throw err;
        };
      }
      var readPackage;
      var isAlpine;
    }
  });

  // ../../node_modules/rabin-native/binding.js
  var require_binding7 = __commonJS({
    "../../node_modules/rabin-native/binding.js"(exports, module) {
      __require.addon = require_node2();
      module.exports = __require.addon(".", __filename);
    }
  });

  // ../../node_modules/rabin-native/index.js
  var require_rabin_native = __commonJS({
    "../../node_modules/rabin-native/index.js"(exports) {
      var binding = require_binding7();
      var RabinChunker = class {
        constructor(opts = {}) {
          const {
            minSize = 512 * 1024,
            // 512 KiB
            maxSize = 8 * 1024 * 1024
            // 8 MiB
          } = opts;
          this._handle = binding.init(minSize, maxSize);
        }
        *push(data) {
          while (true) {
            const length = binding.push(this._handle, data.buffer, data.byteOffset, data.byteLength);
            if (length === 0) return;
            data = data.subarray(length);
            yield binding.lastChunk(this._handle);
          }
        }
        end() {
          const length = binding.end(this._handle);
          if (length === 0) return null;
          return binding.lastChunk(this._handle);
        }
      };
      exports.Chunker = RabinChunker;
    }
  });

  // ../../node_modules/rabin-stream/index.js
  var require_rabin_stream = __commonJS({
    "../../node_modules/rabin-stream/index.js"(exports, module) {
      var { Transform } = require_streamx();
      var rabin = require_rabin_native();
      module.exports = class RabinStream extends Transform {
        constructor(opts = {}) {
          super();
          this._rabin = new rabin.Chunker(opts);
          this._buffer = [];
        }
        _transform(data, cb) {
          if (typeof data === "string") data = Buffer.from(data);
          this._buffer.push(data);
          const chunks = this._rabin.push(data);
          for (const chunk of chunks) {
            let data2 = this._buffer[0];
            if (data2.byteLength < chunk.length) {
              data2 = Buffer.concat(this._buffer);
              this._buffer = [];
            } else {
              this._buffer.pop();
            }
            this.push(data2.subarray(0, chunk.length));
            data2 = data2.subarray(chunk.length);
            if (data2.byteLength) this._buffer.unshift(data2);
          }
          cb(null);
        }
        _flush(cb) {
          if (this._buffer.length) {
            this.push(Buffer.concat(this._buffer));
          }
          this._buffer = [];
          cb(null);
        }
      };
    }
  });

  // ../../node_modules/mirror-drive/index.js
  var require_mirror_drive = __commonJS({
    "../../node_modules/mirror-drive/index.js"(exports, module) {
      var EventEmitter = require_bare_node_events();
      var sameData = require_same_data();
      var unixPathResolve = require_unix_path_resolve();
      var streamEquals = require_binary_stream_equals();
      var speedometer = require_speedometer();
      var { pipelinePromise, isStream } = require_streamx();
      var RabinStream = require_rabin_stream();
      var SAME = 0;
      var DIFF = 1;
      var DIFF_META = 2;
      var Monitor = class extends EventEmitter {
        constructor(mirror, { interval = 250 } = {}) {
          super();
          this.mirror = mirror;
          this.interval = setInterval(this.update.bind(this), interval);
          this.stats = null;
          this.index = mirror.monitors.push(this) - 1;
          this.update();
        }
        get preloaded() {
          return this.mirror.preloaded;
        }
        get destroyed() {
          return this.index === -1;
        }
        update() {
          if (this.index === -1) return;
          this.stats = {
            peers: this.mirror.peers.length,
            download: {
              bytes: this.mirror.downloadedBytes,
              blocks: this.mirror.downloadedBlocks,
              speed: this.mirror.downloadSpeed(),
              progress: this.mirror.downloadProgress
            },
            upload: {
              bytes: this.mirror.uploadedBytes,
              blocks: this.mirror.uploadedBlocks,
              speed: this.mirror.uploadSpeed()
            }
          };
          this.emit("update", this.stats);
        }
        destroy() {
          if (this.index === -1) return;
          clearInterval(this.interval);
          const head = this.mirror.monitors.pop();
          if (head !== this) {
            this.mirror.monitors[this.index] = head;
            head.index = this.index;
          }
          this.index = -1;
          this.emit("destroy");
        }
      };
      module.exports = class MirrorDrive {
        constructor(src, dst, opts = {}) {
          this.src = src;
          this.dst = dst;
          this.prefix = toArray(opts.prefix || "/");
          this.dedup = !!opts.dedup;
          this.dryRun = !!opts.dryRun;
          this.prune = opts.prune !== false;
          this.preload = opts.preload !== false && !!src.getBlobs;
          this.preloaded = false;
          this.includeProgress = !!opts.progress && !!src.getBlobs;
          this.includeEquals = !!opts.includeEquals;
          this.filter = opts.filter || null;
          this.metadataEquals = opts.metadataEquals || null;
          this.batch = !!opts.batch;
          this.entries = opts.entries || null;
          this.transformers = opts.transformers || [];
          this.count = { files: 0, add: 0, remove: 0, change: 0 };
          this.bytesRemoved = 0;
          this.bytesAdded = 0;
          this.ignore = opts.ignore ? toIgnoreFunction(opts.ignore) : null;
          this.finished = false;
          this.downloadedBlocks = 0;
          this.downloadedBlocksEstimate = 0;
          this.downloadedBytes = 0;
          this.downloadSpeed = this.includeProgress ? speedometer() : null;
          this.uploadedBlocks = 0;
          this.uploadedBytes = 0;
          this.uploadSpeed = this.includeProgress ? speedometer() : null;
          this.monitors = [];
          this.iterator = this._init();
        }
        [Symbol.asyncIterator]() {
          return this.iterator;
        }
        get peers() {
          return this.src.core?.peers || [];
        }
        get downloadProgress() {
          if (this.finished) return 1;
          if (!this.downloadedBlocksEstimate) return 0;
          return Math.min(0.99, this.downloadedBlocks / this.downloadedBlocksEstimate);
        }
        monitor(opts) {
          this.includeProgress = true;
          if (this.downloadSpeed === null) this.downloadSpeed = speedometer();
          if (this.uploadSpeed === null) this.uploadSpeed = speedometer();
          return new Monitor(this, opts);
        }
        async done() {
          while (true) {
            const { done } = await this.iterator.next();
            if (done) break;
          }
        }
        _onupload(index, byteLength) {
          this.uploadedBlocks++;
          this.uploadedBytes += byteLength;
          this.uploadSpeed(byteLength);
        }
        _ondownload(index, byteLength) {
          this.downloadedBlocks++;
          this.downloadedBytes += byteLength;
          this.downloadSpeed(byteLength);
        }
        async _getBlobRange(blobs, entry) {
          const blob = entry.value.blob;
          if (!blob || !blob.byteLength) return null;
          if (!blob.byteLength) {
            const dl2 = blobs.core.download({ start: blob.blockOffset, length: blob.blockLength });
            await dl2.ready();
            return dl2;
          }
          const map = await blobs.getBlockMap(blob);
          if (!map) return null;
          const blocks = [];
          for (const b of map.blocks) blocks.push(b.index);
          const dl = blobs.core.download({ blocks });
          await dl.ready();
          return dl;
        }
        async _flushPreload(entries) {
          const blobs = await this.src.getBlobs();
          const promises = [];
          for (const entry of entries) {
            promises.push(this._getBlobRange(blobs, entry));
          }
          const ranges = await Promise.all(promises);
          this.downloadedBlocksEstimate = this.downloadedBlocks;
          for (const dl of ranges) {
            if (!dl || !dl.request.context) continue;
            this.downloadedBlocksEstimate += dl.request.context.end - dl.request.context.start;
          }
          this.preloaded = true;
          for (const m of this.monitors) {
            m.emit("preloaded");
          }
          for (const dl of ranges) {
            if (!dl) continue;
            await dl.done();
          }
        }
        async *_init() {
          try {
            for await (const out of this._mirror()) yield out;
          } finally {
            while (this.monitors.length) {
              this.monitors[this.monitors.length - 1].destroy();
            }
          }
        }
        async *_mirror() {
          await this.src.ready();
          await this.dst.ready();
          if (this.dst.core && !this.dst.core.writable) throw new Error("Destination must be writable");
          const blobs = this.includeProgress ? await this.src.getBlobs() : null;
          const onupload = this._onupload.bind(this);
          const ondownload = this._ondownload.bind(this);
          if (blobs) {
            blobs.core.on("upload", onupload);
            blobs.core.on("download", ondownload);
          }
          const dst = this.batch ? this.dst.batch() : this.dst;
          const dstBlobs = dst.getBlobs ? await dst.getBlobs() : null;
          const srcBlobs = this.src.getBlobs ? await this.src.getBlobs() : null;
          if (this.preload) {
            const entries = [];
            const maps = [];
            const inflight = srcBlobs.core.replicator.inflightRange;
            for await (const [, srcEntry] of this._list(this.src, null, this.filter)) {
              entries.push(srcEntry);
              const blob = srcEntry.value.blob;
              if (blob && blob.blockMap && blob.blockLength) {
                if (maps.length === 0) {
                  srcBlobs.core.replicator.setInflightRange(256, 512);
                }
                maps.push(srcBlobs.core.download({ start: blob.blockOffset, length: blob.blockLength }));
              }
            }
            for (const m of maps) await m.done();
            srcBlobs.core.replicator.setInflightRange(inflight);
            this._flushPreload(entries).catch(noop);
          }
          if (this.prune) {
            for await (const [key, dstEntry, srcEntry] of this._list(this.dst, this.src, null)) {
              if (srcEntry) continue;
              const removed = await blobLength(dstEntry, dstBlobs);
              this.count.remove++;
              this.bytesRemoved += removed;
              yield { op: "remove", key, bytesRemoved: removed, bytesAdded: 0 };
              if (!this.dryRun) await dst.del(key);
            }
          }
          for await (const [key, srcEntry, dstEntry] of this._list(this.src, dst, this.filter)) {
            if (!srcEntry) continue;
            this.count.files++;
            const hasTransformers = this.transformers && this.transformers.length > 0;
            const s = hasTransformers === false ? await same(this, srcEntry, dstEntry) : DIFF;
            if (s === SAME) {
              if (this.includeEquals) {
                yield { op: "equal", key, bytesRemoved: 0, bytesAdded: 0 };
              }
              continue;
            }
            const onlyMetadata = s === DIFF_META && !!dst.putEntry;
            const dedup = !!dst.putEntry && this.dedup;
            if (dstEntry) {
              const removed = onlyMetadata ? 0 : await blobLength(dstEntry, dstBlobs);
              const added = onlyMetadata ? 0 : await blobLength(srcEntry, srcBlobs);
              this.count.change++;
              this.bytesRemoved += removed;
              this.bytesAdded += added;
              yield {
                op: "change",
                key,
                bytesRemoved: removed,
                bytesAdded: added
              };
            } else {
              const added = await blobLength(srcEntry, srcBlobs);
              this.count.add++;
              this.bytesAdded += added;
              yield { op: "add", key, bytesRemoved: 0, bytesAdded: added };
            }
            if (this.dryRun) {
              continue;
            }
            const transformers = [];
            for (const transformer of this.transformers) {
              if (typeof transformer !== "function") throw new Error("transformer must be a function");
              const stream = transformer(key);
              if (stream === null) continue;
              if (!isStream(stream)) throw new Error("transformer must return a stream");
              transformers.push(stream);
            }
            if (srcEntry.value.linkname) {
              await dst.symlink(key, srcEntry.value.linkname);
            } else if (!onlyMetadata) {
              if (dedup) transformers.push(new RabinStream());
              await pipelinePromise(
                this.src.createReadStream(srcEntry),
                ...transformers,
                dst.createWriteStream(key, {
                  dedup,
                  executable: srcEntry.value.executable,
                  metadata: srcEntry.value.metadata
                })
              );
            } else {
              await dst.putEntry(key, {
                executable: srcEntry.value.executable,
                linkname: srcEntry.value.linkname,
                blob: dstEntry.value.blob,
                metadata: srcEntry.value.metadata
              });
            }
          }
          if (this.batch) await dst.flush();
          if (blobs) {
            blobs.core.off("upload", onupload);
            blobs.core.off("download", ondownload);
          }
          this.finished = true;
        }
        async *_list(a, b, filter) {
          const lists = [];
          for (const prefix of this.prefix) {
            if (this.entries) {
              lists.push(this.entries);
            } else {
              const stream = a.list(prefix, { ignore: this.ignore });
              if (stream.on) {
                stream.on("error", noop);
                stream.resume();
                stream.pause();
              }
              lists.push(stream);
            }
          }
          for (let i = 0; i < this.prefix.length; i++) {
            const prefix = this.prefix[i];
            const list = lists[i];
            for await (const entry of list) {
              const key = typeof entry === "object" ? entry.key : entry;
              if (filter && !filter(key)) continue;
              const entryA = await a.entry(entry);
              const entryB = b ? await b.entry(key) : null;
              yield [key, entryA, entryB];
            }
            if (prefix !== "/" && (!filter || filter(prefix))) {
              const entryA = await a.entry(prefix);
              const entryB = b ? await b.entry(prefix) : null;
              if (!entryA && !entryB) continue;
              yield [prefix, entryA, entryB];
            }
          }
        }
      };
      function blobLength(entry, blobs) {
        const blob = entry.value.blob;
        if (!blob) return 0;
        if (!blob.blockMap) return blob.byteLength;
        return blobs.getByteLength(blob);
      }
      async function same(m, srcEntry, dstEntry) {
        if (!dstEntry) return DIFF;
        if (srcEntry.value.linkname || dstEntry.value.linkname) {
          return srcEntry.value.linkname === dstEntry.value.linkname ? SAME : DIFF;
        }
        if (!maybeEquals(srcEntry, dstEntry)) return DIFF;
        const eq = await streamEquals(m.src.createReadStream(srcEntry), m.dst.createReadStream(dstEntry));
        const diff = eq ? DIFF_META : DIFF;
        if (srcEntry.value.executable !== dstEntry.value.executable) return diff;
        if (!metadataEquals(m, srcEntry, dstEntry)) return diff;
        return eq ? SAME : DIFF;
      }
      function maybeEquals(srcEntry, dstEntry) {
        const srcBlob = srcEntry.value.blob;
        const dstBlob = dstEntry.value.blob;
        if (!srcBlob && !dstBlob) return true;
        if (!srcBlob || !dstBlob) return false;
        if (srcBlob.blockMap || dstBlob.blockMap) return true;
        return srcBlob.byteLength === dstBlob.byteLength;
      }
      function metadataEquals(m, srcEntry, dstEntry) {
        if (!m.src.supportsMetadata || !m.dst.supportsMetadata) return true;
        const srcMetadata = srcEntry.value.metadata;
        const dstMetadata = dstEntry.value.metadata;
        if (m.metadataEquals) {
          return m.metadataEquals(srcMetadata, dstMetadata);
        }
        const noMetadata = !srcMetadata && !dstMetadata;
        const identicalMetadata = !!(srcMetadata && dstMetadata && sameData(srcMetadata, dstMetadata));
        return noMetadata || identicalMetadata;
      }
      function toIgnoreFunction(ignore) {
        if (typeof ignore === "function") return ignore;
        const all = [].concat(ignore).map((e) => unixPathResolve("/", e));
        return (key) => all.some((path) => path === key || key.startsWith(path + "/"));
      }
      function toArray(prefix) {
        return Array.isArray(prefix) ? prefix : [prefix];
      }
      function noop() {
      }
    }
  });

  // ../../node_modules/localdrive/index.js
  var require_localdrive = __commonJS({
    "../../node_modules/localdrive/index.js"(exports, module) {
      var fs = require_bare_node_fs();
      var fsp = require_promises2();
      var path = __require("path");
      var b4a = require_b4a();
      var unixPathResolve = require_unix_path_resolve();
      var { FileReadStream, FileWriteStream } = require_streams();
      var mutexify = require_promise();
      var MirrorDrive = require_mirror_drive();
      module.exports = class Localdrive {
        constructor(root, opts = {}) {
          this.root = path.resolve(root);
          this.metadata = handleMetadataHooks(opts.metadata) || {};
          this.supportsMetadata = !!opts.metadata;
          this._roots = [];
          this._stat = opts.followLinks ? stat : lstat;
          this._lock = mutexify();
          this._atomics = opts.atomic ? /* @__PURE__ */ new Set() : null;
          if (opts.roots) {
            for (const prefix of Object.keys(opts.roots)) {
              this._roots.push({
                from: unixPathResolve("/", prefix),
                to: path.resolve(opts.roots[prefix])
              });
            }
          }
        }
        _root(keyname) {
          for (const { from, to } of this._roots) {
            if (keyname.startsWith(from)) return { prefix: from, root: to };
          }
          return { prefix: null, root: this.root };
        }
        _resolve(key) {
          const keyname = unixPathResolve("/", key);
          const { prefix, root } = this._root(keyname);
          const filename = path.join(root, prefix ? keyname.replace(prefix, "") : keyname);
          return { root, keyname, filename };
        }
        async ready() {
        }
        async close() {
        }
        async flush() {
        }
        batch() {
          return this;
        }
        checkout() {
          return this;
        }
        toPath(key) {
          return this._resolve(key).filename;
        }
        async entry(name, opts) {
          if (!opts || !opts.follow) return this._entry(name);
          for (let i = 0; i < 16; i++) {
            const node = await this._entry(name);
            if (!node || !node.value.linkname) return node;
            name = unixPathResolve(node.key, node.value.linkname);
          }
          throw new Error("Recursive symlink");
        }
        async _entry(key) {
          if (typeof key === "object") key = key.key;
          const { root, keyname, filename } = this._resolve(key);
          const st = await this._stat(filename);
          if (!st || st.isDirectory()) {
            return null;
          }
          const entry = {
            key: keyname,
            value: {
              executable: false,
              linkname: null,
              blob: null,
              metadata: null
            },
            mtime: st.mtimeMs
          };
          if (st.isSymbolicLink()) {
            let link = await fsp.readlink(filename);
            if (link.startsWith(root)) link = link.slice(root.length);
            entry.value.linkname = link.replace(/\\/g, "/");
            return entry;
          }
          entry.value.executable = isExecutable(st.mode);
          if (this.metadata.get) entry.value.metadata = await this.metadata.get(keyname);
          if (st.isFile()) {
            const blockLength = st.blocks || Math.ceil(st.size / st.blksize) * 8;
            entry.value.blob = { byteOffset: 0, blockOffset: 0, blockLength, byteLength: st.size };
            return entry;
          }
          return null;
        }
        async get(key, opts) {
          const entry = await this.entry(key, opts);
          if (!entry || !entry.value.blob) return null;
          const rs = this.createReadStream(key);
          const chunks = [];
          for await (const chunk of rs) {
            chunks.push(chunk);
          }
          return b4a.concat(chunks);
        }
        put(key, buffer, opts) {
          return new Promise((resolve, reject) => {
            const ws = this.createWriteStream(key, opts);
            let error = null;
            ws.on("error", (err) => {
              error = err;
            });
            ws.on("close", () => {
              if (error) reject(error);
              else resolve();
            });
            ws.end(buffer);
          });
        }
        async del(key) {
          const { root, keyname, filename } = this._resolve(key);
          try {
            await fsp.unlink(filename);
          } catch (error) {
            if (error.code === "ENOENT") return;
            throw error;
          }
          const release = await this._lock();
          try {
            await gcEmptyFolders(root, path.dirname(filename));
          } finally {
            release();
          }
          if (this.metadata.del) await this.metadata.del(keyname);
        }
        async symlink(key, linkname) {
          const entry = await this.entry(key);
          if (entry) await this.del(key);
          const { filename: pointer } = this._resolve(key);
          const release = await this._lock();
          try {
            await fsp.mkdir(path.dirname(pointer), { recursive: true });
            const target = linkname.startsWith("/") ? this._resolve(linkname).filename : linkname.replace(/\//g, path.sep);
            const st = await this._stat(target);
            const type = st && st.isDirectory() ? "junction" : null;
            await fsp.symlink(target, pointer, type);
          } finally {
            release();
          }
        }
        compare(a, b) {
          const diff = a.mtime - b.mtime;
          return diff > 0 ? 1 : diff < 0 ? -1 : 0;
        }
        async *list(folder, opts = {}) {
          if (typeof folder === "object") {
            opts = folder;
            folder = void 0;
          }
          const ignore = opts.ignore ? [].concat(opts.ignore).map((e) => unixPathResolve("/", e)) : [];
          const { keyname, filename: fulldir } = this._resolve(folder || "/");
          const iterator = await opendir(fulldir);
          if (!iterator) return;
          for await (const dirent of iterator) {
            const key = unixPathResolve(keyname, dirent.name);
            if (ignore.includes(key)) continue;
            if (dirent.isDirectory()) {
              yield* this.list(key, opts);
              continue;
            }
            const entry = await this.entry(key);
            if (entry) yield entry;
          }
        }
        async *readdir(folder) {
          const { keyname, filename: fulldir } = this._resolve(folder || "/");
          const iterator = await readdir(fulldir);
          if (!iterator) return;
          for await (const dirent of iterator) {
            const key = unixPathResolve(keyname, dirent.name);
            let suffix = key.slice(keyname.length);
            const i = suffix.indexOf("/");
            if (i > -1) suffix = suffix.slice(i + 1);
            if (dirent.isDirectory()) {
              if (!await isEmptyDirectory(this, key)) {
                yield suffix;
              }
              continue;
            }
            const entry = await this.entry(key);
            if (entry) yield suffix;
          }
        }
        mirror(out, opts) {
          return new MirrorDrive(this, out, opts);
        }
        createReadStream(key, opts) {
          if (typeof key === "object") key = key.key;
          const { filename } = this._resolve(key);
          return new FileReadStream(filename, opts);
        }
        createWriteStream(key, opts) {
          const { keyname, filename } = this._resolve(key);
          return new FileWriteStream(filename, keyname, this, opts);
        }
        _alloc(filename) {
          if (!this._atomics) return filename;
          let c = 0;
          while (this._atomics.has(filename + "." + c + ".localdrive.tmp")) c++;
          filename += "." + c + ".localdrive.tmp";
          this._atomics.add(filename);
          return filename;
        }
        _free(atomicFilename) {
          this._atomics.delete(atomicFilename);
        }
      };
      function handleMetadataHooks(metadata) {
        if (metadata instanceof Map) {
          return {
            get: (key) => metadata.has(key) ? metadata.get(key) : null,
            put: (key, value) => metadata.set(key, value),
            del: (key) => metadata.delete(key)
          };
        }
        return metadata;
      }
      function isExecutable(mode) {
        return !!(mode & fs.constants.S_IXUSR);
      }
      async function lstat(filename) {
        try {
          return await fsp.lstat(filename);
        } catch {
          return null;
        }
      }
      async function stat(filename) {
        try {
          return await fsp.stat(filename);
        } catch {
          return null;
        }
      }
      async function opendir(dir) {
        try {
          return await fsp.opendir(dir);
        } catch {
          return null;
        }
      }
      async function readdir(dir) {
        try {
          return await fsp.readdir(dir, { withFileTypes: true });
        } catch {
          return null;
        }
      }
      async function gcEmptyFolders(root, dir) {
        try {
          while (dir !== root) {
            await fsp.rmdir(dir);
            dir = path.dirname(dir);
          }
        } catch {
        }
      }
      async function isEmptyDirectory(drive, key) {
        for await (const entry of drive.list(key)) {
          return false;
        }
        return true;
      }
    }
  });

  // ../../node_modules/es-module-lexer/dist/lexer.js
  var lexer_exports = {};
  __export(lexer_exports, {
    ImportType: () => ImportType,
    init: () => init,
    initSync: () => initSync,
    parse: () => parse
  });
  function parse(E2, g = "@") {
    if (!C) return init.then((() => parse(E2)));
    const I = E2.length + 1, w = (C.__heap_base.value || C.__heap_base) + 4 * I - C.memory.buffer.byteLength;
    w > 0 && C.memory.grow(Math.ceil(w / 65536));
    const K = C.sa(I - 1);
    if ((A ? B : Q)(E2, new Uint16Array(C.memory.buffer, K, I)), !C.parse()) throw Object.assign(new Error(`Parse error ${g}:${E2.slice(0, C.e()).split("\n").length}:${C.e() - E2.lastIndexOf("\n", C.e() - 1)}`), { idx: C.e() });
    const o = [], D = [];
    for (; C.ri(); ) {
      const A2 = C.is(), Q2 = C.ie(), B2 = C.it(), g2 = C.ai(), I2 = C.id(), w2 = C.ss(), K2 = C.se();
      let D2;
      C.ip() && (D2 = k(E2.slice(-1 === I2 ? A2 - 1 : A2, -1 === I2 ? Q2 + 1 : Q2))), o.push({ n: D2, t: B2, s: A2, e: Q2, ss: w2, se: K2, d: I2, a: g2 });
    }
    for (; C.re(); ) {
      const A2 = C.es(), Q2 = C.ee(), B2 = C.els(), g2 = C.ele(), I2 = E2.slice(A2, Q2), w2 = I2[0], K2 = B2 < 0 ? void 0 : E2.slice(B2, g2), o2 = K2 ? K2[0] : "";
      D.push({ s: A2, e: Q2, ls: B2, le: g2, n: '"' === w2 || "'" === w2 ? k(I2) : I2, ln: '"' === o2 || "'" === o2 ? k(K2) : K2 });
    }
    function k(A2) {
      try {
        return (0, eval)(A2);
      } catch (A3) {
      }
    }
    return [o, D, !!C.f(), !!C.ms()];
  }
  function Q(A2, Q2) {
    const B2 = A2.length;
    let C2 = 0;
    for (; C2 < B2; ) {
      const B3 = A2.charCodeAt(C2);
      Q2[C2++] = (255 & B3) << 8 | B3 >>> 8;
    }
  }
  function B(A2, Q2) {
    const B2 = A2.length;
    let C2 = 0;
    for (; C2 < B2; ) Q2[C2] = A2.charCodeAt(C2++);
  }
  var ImportType, A, C, E, init, initSync;
  var init_lexer = __esm({
    "../../node_modules/es-module-lexer/dist/lexer.js"() {
      !(function(A2) {
        A2[A2.Static = 1] = "Static", A2[A2.Dynamic = 2] = "Dynamic", A2[A2.ImportMeta = 3] = "ImportMeta", A2[A2.StaticSourcePhase = 4] = "StaticSourcePhase", A2[A2.DynamicSourcePhase = 5] = "DynamicSourcePhase", A2[A2.StaticDeferPhase = 6] = "StaticDeferPhase", A2[A2.DynamicDeferPhase = 7] = "DynamicDeferPhase";
      })(ImportType || (ImportType = {}));
      A = 1 === new Uint8Array(new Uint16Array([1]).buffer)[0];
      E = () => {
        return A2 = "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", "undefined" != typeof Buffer ? Buffer.from(A2, "base64") : Uint8Array.from(atob(A2), ((A3) => A3.charCodeAt(0)));
        var A2;
      };
      init = WebAssembly.compile(E()).then(WebAssembly.instantiate).then((({ exports: A2 }) => {
        C = A2;
      }));
      initSync = () => {
        if (C) return;
        const A2 = new WebAssembly.Module(E());
        C = new WebAssembly.Instance(A2).exports;
      };
    }
  });

  // ../../node_modules/cjs-module-lexer/lexer.js
  var require_lexer = __commonJS({
    "../../node_modules/cjs-module-lexer/lexer.js"(exports, module) {
      var source;
      var pos;
      var end;
      var openTokenDepth;
      var templateDepth;
      var lastTokenPos;
      var lastSlashWasDivision;
      var templateStack;
      var templateStackDepth;
      var openTokenPosStack;
      var openClassPosStack;
      var nextBraceIsClass;
      var starExportMap;
      var lastStarExportSpecifier;
      var _exports;
      var unsafeGetters;
      var reexports;
      function resetState() {
        openTokenDepth = 0;
        templateDepth = -1;
        lastTokenPos = -1;
        lastSlashWasDivision = false;
        templateStack = new Array(1024);
        templateStackDepth = 0;
        openTokenPosStack = new Array(1024);
        openClassPosStack = new Array(1024);
        nextBraceIsClass = false;
        starExportMap = /* @__PURE__ */ Object.create(null);
        lastStarExportSpecifier = null;
        _exports = /* @__PURE__ */ new Set();
        unsafeGetters = /* @__PURE__ */ new Set();
        reexports = /* @__PURE__ */ new Set();
      }
      var Import = 0;
      var ExportAssign = 1;
      var ExportStar = 2;
      function parseCJS(source2, name = "@") {
        resetState();
        try {
          parseSource(source2);
        } catch (e) {
          e.message += `
  at ${name}:${source2.slice(0, pos).split("\n").length}:${pos - source2.lastIndexOf("\n", pos - 1)}`;
          e.loc = pos;
          throw e;
        }
        const result = { exports: [..._exports].filter((expt) => expt !== void 0 && !unsafeGetters.has(expt)), reexports: [...reexports].filter((reexpt) => reexpt !== void 0) };
        resetState();
        return result;
      }
      function decode(str) {
        if (str[0] === '"' || str[0] === "'") {
          try {
            const decoded = (0, eval)(str);
            for (let i = 0; i < decoded.length; i++) {
              const surrogatePrefix = decoded.charCodeAt(i) & 64512;
              if (surrogatePrefix < 55296) {
                continue;
              } else if (surrogatePrefix === 55296) {
                if ((decoded.charCodeAt(++i) & 64512) !== 56320)
                  return;
              } else {
                return;
              }
            }
            return decoded;
          } catch {
          }
        } else {
          return str;
        }
      }
      function parseSource(cjsSource) {
        source = cjsSource;
        pos = -1;
        end = source.length - 1;
        let ch2 = 0;
        if (source.charCodeAt(0) === 35 && source.charCodeAt(1) === 33) {
          if (source.length === 2)
            return true;
          pos += 2;
          while (pos++ < end) {
            ch2 = source.charCodeAt(pos);
            if (ch2 === 10 || ch2 === 13)
              break;
          }
        }
        while (pos++ < end) {
          ch2 = source.charCodeAt(pos);
          if (ch2 === 32 || ch2 < 14 && ch2 > 8)
            continue;
          if (openTokenDepth === 0) {
            switch (ch2) {
              case 105:
                if (source.startsWith("mport", pos + 1) && keywordStart(pos))
                  throwIfImportStatement();
                lastTokenPos = pos;
                continue;
              case 114:
                const startPos = pos;
                if (tryParseRequire(Import) && keywordStart(startPos))
                  tryBacktrackAddStarExportBinding(startPos - 1);
                lastTokenPos = pos;
                continue;
              case 95:
                if (source.startsWith("interopRequireWildcard", pos + 1) && (keywordStart(pos) || source.charCodeAt(pos - 1) === 46)) {
                  const startPos2 = pos;
                  pos += 23;
                  if (source.charCodeAt(pos) === 40) {
                    pos++;
                    openTokenPosStack[openTokenDepth++] = lastTokenPos;
                    if (tryParseRequire(Import) && keywordStart(startPos2)) {
                      tryBacktrackAddStarExportBinding(startPos2 - 1);
                    }
                  }
                } else if (source.startsWith("_export", pos + 1) && (keywordStart(pos) || source.charCodeAt(pos - 1) === 46)) {
                  pos += 8;
                  if (source.startsWith("Star", pos))
                    pos += 4;
                  if (source.charCodeAt(pos) === 40) {
                    openTokenPosStack[openTokenDepth++] = lastTokenPos;
                    if (source.charCodeAt(++pos) === 114)
                      tryParseRequire(ExportStar);
                  }
                }
                lastTokenPos = pos;
                continue;
            }
          }
          switch (ch2) {
            case 101:
              if (source.startsWith("xport", pos + 1) && keywordStart(pos)) {
                if (source.charCodeAt(pos + 6) === 115)
                  tryParseExportsDotAssign(false);
                else if (openTokenDepth === 0)
                  throwIfExportStatement();
              }
              break;
            case 99:
              if (keywordStart(pos) && source.startsWith("lass", pos + 1) && isBrOrWs(source.charCodeAt(pos + 5)))
                nextBraceIsClass = true;
              break;
            case 109:
              if (source.startsWith("odule", pos + 1) && keywordStart(pos))
                tryParseModuleExportsDotAssign();
              break;
            case 79:
              if (source.startsWith("bject", pos + 1) && keywordStart(pos))
                tryParseObjectDefineOrKeys(openTokenDepth === 0);
              break;
            case 40:
              openTokenPosStack[openTokenDepth++] = lastTokenPos;
              break;
            case 41:
              if (openTokenDepth === 0)
                throw new Error("Unexpected closing bracket.");
              openTokenDepth--;
              break;
            case 123:
              openClassPosStack[openTokenDepth] = nextBraceIsClass;
              nextBraceIsClass = false;
              openTokenPosStack[openTokenDepth++] = lastTokenPos;
              break;
            case 125:
              if (openTokenDepth === 0)
                throw new Error("Unexpected closing brace.");
              if (openTokenDepth-- === templateDepth) {
                templateDepth = templateStack[--templateStackDepth];
                templateString();
              } else {
                if (templateDepth !== -1 && openTokenDepth < templateDepth)
                  throw new Error("Unexpected closing brace.");
              }
              break;
            case 60:
              break;
            case 39:
            case 34:
              stringLiteral(ch2);
              break;
            case 47: {
              const next_ch = source.charCodeAt(pos + 1);
              if (next_ch === 47) {
                lineComment();
                continue;
              } else if (next_ch === 42) {
                blockComment();
                continue;
              } else {
                const lastToken = source.charCodeAt(lastTokenPos);
                if (isExpressionPunctuator(lastToken) && !(lastToken === 46 && (source.charCodeAt(lastTokenPos - 1) >= 48 && source.charCodeAt(lastTokenPos - 1) <= 57)) && !(lastToken === 43 && source.charCodeAt(lastTokenPos - 1) === 43) && !(lastToken === 45 && source.charCodeAt(lastTokenPos - 1) === 45) || lastToken === 41 && isParenKeyword(openTokenPosStack[openTokenDepth]) || lastToken === 125 && (isExpressionTerminator(openTokenPosStack[openTokenDepth]) || openClassPosStack[openTokenDepth]) || lastToken === 47 && lastSlashWasDivision || isExpressionKeyword(lastTokenPos) || !lastToken) {
                  regularExpression();
                  lastSlashWasDivision = false;
                } else {
                  lastSlashWasDivision = true;
                }
              }
              break;
            }
            case 96:
              templateString();
              break;
          }
          lastTokenPos = pos;
        }
        if (templateDepth !== -1)
          throw new Error("Unterminated template.");
        if (openTokenDepth)
          throw new Error("Unterminated braces.");
      }
      function tryBacktrackAddStarExportBinding(bPos) {
        while (source.charCodeAt(bPos) === 32 && bPos >= 0)
          bPos--;
        if (source.charCodeAt(bPos) === 61) {
          bPos--;
          while (source.charCodeAt(bPos) === 32 && bPos >= 0)
            bPos--;
          let codePoint;
          const id_end = bPos;
          let identifierStart = false;
          while ((codePoint = codePointAtLast(bPos)) && bPos >= 0) {
            if (codePoint === 92)
              return;
            if (!isIdentifierChar(codePoint, true))
              break;
            identifierStart = isIdentifierStart(codePoint, true);
            bPos -= codePointLen(codePoint);
          }
          if (identifierStart && source.charCodeAt(bPos) === 32) {
            const starExportId = source.slice(bPos + 1, id_end + 1);
            while (source.charCodeAt(bPos) === 32 && bPos >= 0)
              bPos--;
            switch (source.charCodeAt(bPos)) {
              case 114:
                if (!source.startsWith("va", bPos - 2))
                  return;
                break;
              case 116:
                if (!source.startsWith("le", bPos - 2) && !source.startsWith("cons", bPos - 4))
                  return;
                break;
              default:
                return;
            }
            starExportMap[starExportId] = lastStarExportSpecifier;
          }
        }
      }
      function tryParseObjectHasOwnProperty(it_id) {
        ch = commentWhitespace();
        if (ch !== 79 || !source.startsWith("bject", pos + 1)) return false;
        pos += 6;
        ch = commentWhitespace();
        if (ch !== 46) return false;
        pos++;
        ch = commentWhitespace();
        if (ch === 112) {
          if (!source.startsWith("rototype", pos + 1)) return false;
          pos += 9;
          ch = commentWhitespace();
          if (ch !== 46) return false;
          pos++;
          ch = commentWhitespace();
        }
        if (ch !== 104 || !source.startsWith("asOwnProperty", pos + 1)) return false;
        pos += 14;
        ch = commentWhitespace();
        if (ch !== 46) return false;
        pos++;
        ch = commentWhitespace();
        if (ch !== 99 || !source.startsWith("all", pos + 1)) return false;
        pos += 4;
        ch = commentWhitespace();
        if (ch !== 40) return false;
        pos++;
        ch = commentWhitespace();
        if (!identifier()) return false;
        ch = commentWhitespace();
        if (ch !== 44) return false;
        pos++;
        ch = commentWhitespace();
        if (!source.startsWith(it_id, pos)) return false;
        pos += it_id.length;
        ch = commentWhitespace();
        if (ch !== 41) return false;
        pos++;
        return true;
      }
      function tryParseObjectDefineOrKeys(keys) {
        pos += 6;
        let revertPos = pos - 1;
        let ch2 = commentWhitespace();
        if (ch2 === 46) {
          pos++;
          ch2 = commentWhitespace();
          if (ch2 === 100 && source.startsWith("efineProperty", pos + 1)) {
            let expt;
            while (true) {
              pos += 14;
              revertPos = pos - 1;
              ch2 = commentWhitespace();
              if (ch2 !== 40) break;
              pos++;
              ch2 = commentWhitespace();
              if (!readExportsOrModuleDotExports(ch2)) break;
              ch2 = commentWhitespace();
              if (ch2 !== 44) break;
              pos++;
              ch2 = commentWhitespace();
              if (ch2 !== 39 && ch2 !== 34) break;
              const exportPos = pos;
              stringLiteral(ch2);
              expt = source.slice(exportPos, ++pos);
              ch2 = commentWhitespace();
              if (ch2 !== 44) break;
              pos++;
              ch2 = commentWhitespace();
              if (ch2 !== 123) break;
              pos++;
              ch2 = commentWhitespace();
              if (ch2 === 101) {
                if (!source.startsWith("numerable", pos + 1)) break;
                pos += 10;
                ch2 = commentWhitespace();
                if (ch2 !== 58) break;
                pos++;
                ch2 = commentWhitespace();
                if (ch2 !== 116 || !source.startsWith("rue", pos + 1)) break;
                pos += 4;
                ch2 = commentWhitespace();
                if (ch2 !== 44) break;
                pos++;
                ch2 = commentWhitespace();
              }
              if (ch2 === 118) {
                if (!source.startsWith("alue", pos + 1)) break;
                pos += 5;
                ch2 = commentWhitespace();
                if (ch2 !== 58) break;
                _exports.add(decode(expt));
                pos = revertPos;
                return;
              } else if (ch2 === 103) {
                if (!source.startsWith("et", pos + 1)) break;
                pos += 3;
                ch2 = commentWhitespace();
                if (ch2 === 58) {
                  pos++;
                  ch2 = commentWhitespace();
                  if (ch2 !== 102) break;
                  if (!source.startsWith("unction", pos + 1)) break;
                  pos += 8;
                  let lastPos = pos;
                  ch2 = commentWhitespace();
                  if (ch2 !== 40 && (lastPos === pos || !identifier())) break;
                  ch2 = commentWhitespace();
                }
                if (ch2 !== 40) break;
                pos++;
                ch2 = commentWhitespace();
                if (ch2 !== 41) break;
                pos++;
                ch2 = commentWhitespace();
                if (ch2 !== 123) break;
                pos++;
                ch2 = commentWhitespace();
                if (ch2 !== 114) break;
                if (!source.startsWith("eturn", pos + 1)) break;
                pos += 6;
                ch2 = commentWhitespace();
                if (!identifier()) break;
                ch2 = commentWhitespace();
                if (ch2 === 46) {
                  pos++;
                  commentWhitespace();
                  if (!identifier()) break;
                  ch2 = commentWhitespace();
                } else if (ch2 === 91) {
                  pos++;
                  ch2 = commentWhitespace();
                  if (ch2 === 39 || ch2 === 34) stringLiteral(ch2);
                  else break;
                  pos++;
                  ch2 = commentWhitespace();
                  if (ch2 !== 93) break;
                  pos++;
                  ch2 = commentWhitespace();
                }
                if (ch2 === 59) {
                  pos++;
                  ch2 = commentWhitespace();
                }
                if (ch2 !== 125) break;
                pos++;
                ch2 = commentWhitespace();
                if (ch2 === 44) {
                  pos++;
                  ch2 = commentWhitespace();
                }
                if (ch2 !== 125) break;
                pos++;
                ch2 = commentWhitespace();
                if (ch2 !== 41) break;
                _exports.add(decode(expt));
                return;
              }
              break;
            }
            if (expt) {
              unsafeGetters.add(decode(expt));
            }
          } else if (keys && ch2 === 107 && source.startsWith("eys", pos + 1)) {
            while (true) {
              pos += 4;
              revertPos = pos - 1;
              ch2 = commentWhitespace();
              if (ch2 !== 40) break;
              pos++;
              ch2 = commentWhitespace();
              const id_start = pos;
              if (!identifier()) break;
              const id = source.slice(id_start, pos);
              ch2 = commentWhitespace();
              if (ch2 !== 41) break;
              revertPos = pos++;
              ch2 = commentWhitespace();
              if (ch2 !== 46) break;
              pos++;
              ch2 = commentWhitespace();
              if (ch2 !== 102 || !source.startsWith("orEach", pos + 1)) break;
              pos += 7;
              ch2 = commentWhitespace();
              revertPos = pos - 1;
              if (ch2 !== 40) break;
              pos++;
              ch2 = commentWhitespace();
              if (ch2 !== 102 || !source.startsWith("unction", pos + 1)) break;
              pos += 8;
              ch2 = commentWhitespace();
              if (ch2 !== 40) break;
              pos++;
              ch2 = commentWhitespace();
              const it_id_start = pos;
              if (!identifier()) break;
              const it_id = source.slice(it_id_start, pos);
              ch2 = commentWhitespace();
              if (ch2 !== 41) break;
              pos++;
              ch2 = commentWhitespace();
              if (ch2 !== 123) break;
              pos++;
              ch2 = commentWhitespace();
              if (ch2 !== 105 || source.charCodeAt(pos + 1) !== 102) break;
              pos += 2;
              ch2 = commentWhitespace();
              if (ch2 !== 40) break;
              pos++;
              ch2 = commentWhitespace();
              if (!source.startsWith(it_id, pos)) break;
              pos += it_id.length;
              ch2 = commentWhitespace();
              if (ch2 === 61) {
                if (!source.startsWith("==", pos + 1)) break;
                pos += 3;
                ch2 = commentWhitespace();
                if (ch2 !== 34 && ch2 !== 39) break;
                let quot = ch2;
                if (!source.startsWith("default", pos + 1)) break;
                pos += 8;
                ch2 = commentWhitespace();
                if (ch2 !== quot) break;
                pos += 1;
                ch2 = commentWhitespace();
                if (ch2 !== 124 || source.charCodeAt(pos + 1) !== 124) break;
                pos += 2;
                ch2 = commentWhitespace();
                if (source.slice(pos, pos + it_id.length) !== it_id) break;
                pos += it_id.length;
                ch2 = commentWhitespace();
                if (ch2 !== 61 || source.slice(pos + 1, pos + 3) !== "==") break;
                pos += 3;
                ch2 = commentWhitespace();
                if (ch2 !== 34 && ch2 !== 39) break;
                quot = ch2;
                if (!source.startsWith("__esModule", pos + 1)) break;
                pos += 11;
                ch2 = commentWhitespace();
                if (ch2 !== quot) break;
                pos += 1;
                ch2 = commentWhitespace();
                if (ch2 !== 41) break;
                pos += 1;
                ch2 = commentWhitespace();
                if (ch2 !== 114 || !source.startsWith("eturn", pos + 1)) break;
                pos += 6;
                ch2 = commentWhitespace();
                if (ch2 === 59)
                  pos++;
                ch2 = commentWhitespace();
                if (ch2 === 105 && source.charCodeAt(pos + 1) === 102) {
                  let inIf = true;
                  pos += 2;
                  ch2 = commentWhitespace();
                  if (ch2 !== 40) break;
                  pos++;
                  const ifInnerPos = pos;
                  if (tryParseObjectHasOwnProperty(it_id)) {
                    ch2 = commentWhitespace();
                    if (ch2 !== 41) break;
                    pos++;
                    ch2 = commentWhitespace();
                    if (ch2 !== 114 || !source.startsWith("eturn", pos + 1)) break;
                    pos += 6;
                    ch2 = commentWhitespace();
                    if (ch2 === 59)
                      pos++;
                    ch2 = commentWhitespace();
                    if (ch2 === 105 && source.charCodeAt(pos + 1) === 102) {
                      pos += 2;
                      ch2 = commentWhitespace();
                      if (ch2 !== 40) break;
                      pos++;
                    } else {
                      inIf = false;
                    }
                  } else {
                    pos = ifInnerPos;
                  }
                  if (inIf) {
                    if (!source.startsWith(it_id, pos)) break;
                    pos += it_id.length;
                    ch2 = commentWhitespace();
                    if (ch2 !== 105 || !source.startsWith("n ", pos + 1)) break;
                    pos += 3;
                    ch2 = commentWhitespace();
                    if (!readExportsOrModuleDotExports(ch2)) break;
                    ch2 = commentWhitespace();
                    if (ch2 !== 38 || source.charCodeAt(pos + 1) !== 38) break;
                    pos += 2;
                    ch2 = commentWhitespace();
                    if (!readExportsOrModuleDotExports(ch2)) break;
                    ch2 = commentWhitespace();
                    if (ch2 !== 91) break;
                    pos++;
                    ch2 = commentWhitespace();
                    if (!source.startsWith(it_id, pos)) break;
                    pos += it_id.length;
                    ch2 = commentWhitespace();
                    if (ch2 !== 93) break;
                    pos++;
                    ch2 = commentWhitespace();
                    if (ch2 !== 61 || !source.startsWith("==", pos + 1)) break;
                    pos += 3;
                    ch2 = commentWhitespace();
                    if (!source.startsWith(id, pos)) break;
                    pos += id.length;
                    ch2 = commentWhitespace();
                    if (ch2 !== 91) break;
                    pos++;
                    ch2 = commentWhitespace();
                    if (!source.startsWith(it_id, pos)) break;
                    pos += it_id.length;
                    ch2 = commentWhitespace();
                    if (ch2 !== 93) break;
                    pos++;
                    ch2 = commentWhitespace();
                    if (ch2 !== 41) break;
                    pos++;
                    ch2 = commentWhitespace();
                    if (ch2 !== 114 || !source.startsWith("eturn", pos + 1)) break;
                    pos += 6;
                    ch2 = commentWhitespace();
                    if (ch2 === 59)
                      pos++;
                    ch2 = commentWhitespace();
                  }
                }
              } else if (ch2 === 33) {
                if (!source.startsWith("==", pos + 1)) break;
                pos += 3;
                ch2 = commentWhitespace();
                if (ch2 !== 34 && ch2 !== 39) break;
                const quot = ch2;
                if (!source.startsWith("default", pos + 1)) break;
                pos += 8;
                ch2 = commentWhitespace();
                if (ch2 !== quot) break;
                pos += 1;
                ch2 = commentWhitespace();
                if (ch2 === 38) {
                  if (source.charCodeAt(pos + 1) !== 38) break;
                  pos += 2;
                  ch2 = commentWhitespace();
                  if (ch2 !== 33) break;
                  pos += 1;
                  ch2 = commentWhitespace();
                  if (ch2 === 79 && source.startsWith("bject", pos + 1) && source[pos + 6] === ".") {
                    if (!tryParseObjectHasOwnProperty(it_id)) break;
                  } else if (identifier()) {
                    ch2 = commentWhitespace();
                    if (ch2 !== 46) break;
                    pos++;
                    ch2 = commentWhitespace();
                    if (ch2 !== 104 || !source.startsWith("asOwnProperty", pos + 1)) break;
                    pos += 14;
                    ch2 = commentWhitespace();
                    if (ch2 !== 40) break;
                    pos += 1;
                    ch2 = commentWhitespace();
                    if (!source.startsWith(it_id, pos)) break;
                    pos += it_id.length;
                    ch2 = commentWhitespace();
                    if (ch2 !== 41) break;
                    pos += 1;
                  } else break;
                  ch2 = commentWhitespace();
                }
                if (ch2 !== 41) break;
                pos += 1;
                ch2 = commentWhitespace();
              } else break;
              if (readExportsOrModuleDotExports(ch2)) {
                ch2 = commentWhitespace();
                if (ch2 !== 91) break;
                pos++;
                ch2 = commentWhitespace();
                if (source.slice(pos, pos + it_id.length) !== it_id) break;
                pos += it_id.length;
                ch2 = commentWhitespace();
                if (ch2 !== 93) break;
                pos++;
                ch2 = commentWhitespace();
                if (ch2 !== 61) break;
                pos++;
                ch2 = commentWhitespace();
                if (source.slice(pos, pos + id.length) !== id) break;
                pos += id.length;
                ch2 = commentWhitespace();
                if (ch2 !== 91) break;
                pos++;
                ch2 = commentWhitespace();
                if (source.slice(pos, pos + it_id.length) !== it_id) break;
                pos += it_id.length;
                ch2 = commentWhitespace();
                if (ch2 !== 93) break;
                pos++;
                ch2 = commentWhitespace();
                if (ch2 === 59) {
                  pos++;
                  ch2 = commentWhitespace();
                }
              } else if (ch2 === 79) {
                if (source.slice(pos + 1, pos + 6) !== "bject") break;
                pos += 6;
                ch2 = commentWhitespace();
                if (ch2 !== 46) break;
                pos++;
                ch2 = commentWhitespace();
                if (ch2 !== 100 || !source.startsWith("efineProperty", pos + 1)) break;
                pos += 14;
                ch2 = commentWhitespace();
                if (ch2 !== 40) break;
                pos++;
                ch2 = commentWhitespace();
                if (!readExportsOrModuleDotExports(ch2)) break;
                ch2 = commentWhitespace();
                if (ch2 !== 44) break;
                pos++;
                ch2 = commentWhitespace();
                if (!source.startsWith(it_id, pos)) break;
                pos += it_id.length;
                ch2 = commentWhitespace();
                if (ch2 !== 44) break;
                pos++;
                ch2 = commentWhitespace();
                if (ch2 !== 123) break;
                pos++;
                ch2 = commentWhitespace();
                if (ch2 !== 101 || !source.startsWith("numerable", pos + 1)) break;
                pos += 10;
                ch2 = commentWhitespace();
                if (ch2 !== 58) break;
                pos++;
                ch2 = commentWhitespace();
                if (ch2 !== 116 && !source.startsWith("rue", pos + 1)) break;
                pos += 4;
                ch2 = commentWhitespace();
                if (ch2 !== 44) break;
                pos++;
                ch2 = commentWhitespace();
                if (ch2 !== 103 || !source.startsWith("et", pos + 1)) break;
                pos += 3;
                ch2 = commentWhitespace();
                if (ch2 === 58) {
                  pos++;
                  ch2 = commentWhitespace();
                  if (ch2 !== 102) break;
                  if (!source.startsWith("unction", pos + 1)) break;
                  pos += 8;
                  let lastPos = pos;
                  ch2 = commentWhitespace();
                  if (ch2 !== 40 && (lastPos === pos || !identifier())) break;
                  ch2 = commentWhitespace();
                }
                if (ch2 !== 40) break;
                pos++;
                ch2 = commentWhitespace();
                if (ch2 !== 41) break;
                pos++;
                ch2 = commentWhitespace();
                if (ch2 !== 123) break;
                pos++;
                ch2 = commentWhitespace();
                if (ch2 !== 114 || !source.startsWith("eturn", pos + 1)) break;
                pos += 6;
                ch2 = commentWhitespace();
                if (!source.startsWith(id, pos)) break;
                pos += id.length;
                ch2 = commentWhitespace();
                if (ch2 !== 91) break;
                pos++;
                ch2 = commentWhitespace();
                if (!source.startsWith(it_id, pos)) break;
                pos += it_id.length;
                ch2 = commentWhitespace();
                if (ch2 !== 93) break;
                pos++;
                ch2 = commentWhitespace();
                if (ch2 === 59) {
                  pos++;
                  ch2 = commentWhitespace();
                }
                if (ch2 !== 125) break;
                pos++;
                ch2 = commentWhitespace();
                if (ch2 === 44) {
                  pos++;
                  ch2 = commentWhitespace();
                }
                if (ch2 !== 125) break;
                pos++;
                ch2 = commentWhitespace();
                if (ch2 !== 41) break;
                pos++;
                ch2 = commentWhitespace();
                if (ch2 === 59) {
                  pos++;
                  ch2 = commentWhitespace();
                }
              } else break;
              if (ch2 !== 125) break;
              pos++;
              ch2 = commentWhitespace();
              if (ch2 !== 41) break;
              const starExportSpecifier = starExportMap[id];
              if (starExportSpecifier) {
                reexports.add(decode(starExportSpecifier));
                pos = revertPos;
                return;
              }
              return;
            }
          }
        }
        pos = revertPos;
      }
      function readExportsOrModuleDotExports(ch2) {
        const revertPos = pos;
        if (ch2 === 109 && source.startsWith("odule", pos + 1)) {
          pos += 6;
          ch2 = commentWhitespace();
          if (ch2 !== 46) {
            pos = revertPos;
            return false;
          }
          pos++;
          ch2 = commentWhitespace();
        }
        if (ch2 === 101 && source.startsWith("xports", pos + 1)) {
          pos += 7;
          return true;
        } else {
          pos = revertPos;
          return false;
        }
      }
      function tryParseModuleExportsDotAssign() {
        pos += 6;
        const revertPos = pos - 1;
        let ch2 = commentWhitespace();
        if (ch2 === 46) {
          pos++;
          ch2 = commentWhitespace();
          if (ch2 === 101 && source.startsWith("xports", pos + 1)) {
            tryParseExportsDotAssign(true);
            return;
          }
        }
        pos = revertPos;
      }
      function tryParseExportsDotAssign(assign) {
        pos += 7;
        const revertPos = pos - 1;
        let ch2 = commentWhitespace();
        switch (ch2) {
          // exports.asdf
          case 46: {
            pos++;
            ch2 = commentWhitespace();
            const startPos = pos;
            if (identifier()) {
              const endPos = pos;
              ch2 = commentWhitespace();
              if (ch2 === 61) {
                _exports.add(decode(source.slice(startPos, endPos)));
                return;
              }
            }
            break;
          }
          // exports['asdf']
          case 91: {
            pos++;
            ch2 = commentWhitespace();
            if (ch2 === 39 || ch2 === 34) {
              const startPos = pos;
              stringLiteral(ch2);
              const endPos = ++pos;
              ch2 = commentWhitespace();
              if (ch2 !== 93) break;
              pos++;
              ch2 = commentWhitespace();
              if (ch2 !== 61) break;
              _exports.add(decode(source.slice(startPos, endPos)));
            }
            break;
          }
          // module.exports =
          case 61: {
            if (assign) {
              if (reexports.size)
                reexports = /* @__PURE__ */ new Set();
              pos++;
              ch2 = commentWhitespace();
              if (ch2 === 123) {
                tryParseLiteralExports();
                return;
              }
              if (ch2 === 114)
                tryParseRequire(ExportAssign);
            }
          }
        }
        pos = revertPos;
      }
      function tryParseRequire(requireType) {
        const revertPos = pos;
        if (source.startsWith("equire", pos + 1)) {
          pos += 7;
          let ch2 = commentWhitespace();
          if (ch2 === 40) {
            pos++;
            ch2 = commentWhitespace();
            const reexportStart = pos;
            if (ch2 === 39 || ch2 === 34) {
              stringLiteral(ch2);
              const reexportEnd = ++pos;
              ch2 = commentWhitespace();
              if (ch2 === 41) {
                switch (requireType) {
                  case ExportAssign:
                    reexports.add(decode(source.slice(reexportStart, reexportEnd)));
                    return true;
                  case ExportStar:
                    reexports.add(decode(source.slice(reexportStart, reexportEnd)));
                    return true;
                  default:
                    lastStarExportSpecifier = decode(source.slice(reexportStart, reexportEnd));
                    return true;
                }
              }
            }
          }
          pos = revertPos;
        }
        return false;
      }
      function tryParseLiteralExports() {
        const revertPos = pos - 1;
        while (pos++ < end) {
          let ch2 = commentWhitespace();
          const startPos = pos;
          if (identifier()) {
            const endPos = pos;
            ch2 = commentWhitespace();
            if (ch2 === 58) {
              pos++;
              ch2 = commentWhitespace();
              if (!identifier()) {
                pos = revertPos;
                return;
              }
              ch2 = source.charCodeAt(pos);
            }
            _exports.add(decode(source.slice(startPos, endPos)));
          } else if (ch2 === 46 && source.startsWith("..", pos + 1)) {
            pos += 3;
            if (source.charCodeAt(pos) === 114 && tryParseRequire(ExportAssign)) {
              pos++;
            } else if (!identifier()) {
              pos = revertPos;
              return;
            }
            ch2 = commentWhitespace();
          } else if (ch2 === 39 || ch2 === 34) {
            const startPos2 = pos;
            stringLiteral(ch2);
            const endPos = ++pos;
            ch2 = commentWhitespace();
            if (ch2 === 58) {
              pos++;
              ch2 = commentWhitespace();
              if (!identifier()) {
                pos = revertPos;
                return;
              }
              ch2 = source.charCodeAt(pos);
              _exports.add(decode(source.slice(startPos2, endPos)));
            }
          } else {
            pos = revertPos;
            return;
          }
          if (ch2 === 125)
            return;
          if (ch2 !== 44) {
            pos = revertPos;
            return;
          }
        }
      }
      var nonASCIIidentifierStartChars = "\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0560-\u0588\u05D0-\u05EA\u05EF-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u0860-\u086A\u08A0-\u08B4\u08B6-\u08C7\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u09FC\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D04-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E86-\u0E8A\u0E8C-\u0EA3\u0EA5\u0EA7-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1878\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1C80-\u1C88\u1C90-\u1CBA\u1CBD-\u1CBF\u1CE9-\u1CEC\u1CEE-\u1CF3\u1CF5\u1CF6\u1CFA\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309B-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312F\u3131-\u318E\u31A0-\u31BF\u31F0-\u31FF\u3400-\u4DBF\u4E00-\u9FFC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7BF\uA7C2-\uA7CA\uA7F5-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA8FE\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB69\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC";
      var nonASCIIidentifierChars = "\u200C\u200D\xB7\u0300-\u036F\u0387\u0483-\u0487\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u0669\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u06F0-\u06F9\u0711\u0730-\u074A\u07A6-\u07B0\u07C0-\u07C9\u07EB-\u07F3\u07FD\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u08D3-\u08E1\u08E3-\u0903\u093A-\u093C\u093E-\u094F\u0951-\u0957\u0962\u0963\u0966-\u096F\u0981-\u0983\u09BC\u09BE-\u09C4\u09C7\u09C8\u09CB-\u09CD\u09D7\u09E2\u09E3\u09E6-\u09EF\u09FE\u0A01-\u0A03\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A66-\u0A71\u0A75\u0A81-\u0A83\u0ABC\u0ABE-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AE2\u0AE3\u0AE6-\u0AEF\u0AFA-\u0AFF\u0B01-\u0B03\u0B3C\u0B3E-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B55-\u0B57\u0B62\u0B63\u0B66-\u0B6F\u0B82\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD7\u0BE6-\u0BEF\u0C00-\u0C04\u0C3E-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C66-\u0C6F\u0C81-\u0C83\u0CBC\u0CBE-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CE2\u0CE3\u0CE6-\u0CEF\u0D00-\u0D03\u0D3B\u0D3C\u0D3E-\u0D44\u0D46-\u0D48\u0D4A-\u0D4D\u0D57\u0D62\u0D63\u0D66-\u0D6F\u0D81-\u0D83\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0E50-\u0E59\u0EB1\u0EB4-\u0EBC\u0EC8-\u0ECD\u0ED0-\u0ED9\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E\u0F3F\u0F71-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102B-\u103E\u1040-\u1049\u1056-\u1059\u105E-\u1060\u1062-\u1064\u1067-\u106D\u1071-\u1074\u1082-\u108D\u108F-\u109D\u135D-\u135F\u1369-\u1371\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4-\u17D3\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u18A9\u1920-\u192B\u1930-\u193B\u1946-\u194F\u19D0-\u19DA\u1A17-\u1A1B\u1A55-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AB0-\u1ABD\u1ABF\u1AC0\u1B00-\u1B04\u1B34-\u1B44\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1B82\u1BA1-\u1BAD\u1BB0-\u1BB9\u1BE6-\u1BF3\u1C24-\u1C37\u1C40-\u1C49\u1C50-\u1C59\u1CD0-\u1CD2\u1CD4-\u1CE8\u1CED\u1CF4\u1CF7-\u1CF9\u1DC0-\u1DF9\u1DFB-\u1DFF\u203F\u2040\u2054\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302F\u3099\u309A\uA620-\uA629\uA66F\uA674-\uA67D\uA69E\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA823-\uA827\uA82C\uA880\uA881\uA8B4-\uA8C5\uA8D0-\uA8D9\uA8E0-\uA8F1\uA8FF-\uA909\uA926-\uA92D\uA947-\uA953\uA980-\uA983\uA9B3-\uA9C0\uA9D0-\uA9D9\uA9E5\uA9F0-\uA9F9\uAA29-\uAA36\uAA43\uAA4C\uAA4D\uAA50-\uAA59\uAA7B-\uAA7D\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEB-\uAAEF\uAAF5\uAAF6\uABE3-\uABEA\uABEC\uABED\uABF0-\uABF9\uFB1E\uFE00-\uFE0F\uFE20-\uFE2F\uFE33\uFE34\uFE4D-\uFE4F\uFF10-\uFF19\uFF3F";
      var nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
      var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
      nonASCIIidentifierStartChars = nonASCIIidentifierChars = null;
      var astralIdentifierStartCodes = [0, 11, 2, 25, 2, 18, 2, 1, 2, 14, 3, 13, 35, 122, 70, 52, 268, 28, 4, 48, 48, 31, 14, 29, 6, 37, 11, 29, 3, 35, 5, 7, 2, 4, 43, 157, 19, 35, 5, 35, 5, 39, 9, 51, 157, 310, 10, 21, 11, 7, 153, 5, 3, 0, 2, 43, 2, 1, 4, 0, 3, 22, 11, 22, 10, 30, 66, 18, 2, 1, 11, 21, 11, 25, 71, 55, 7, 1, 65, 0, 16, 3, 2, 2, 2, 28, 43, 28, 4, 28, 36, 7, 2, 27, 28, 53, 11, 21, 11, 18, 14, 17, 111, 72, 56, 50, 14, 50, 14, 35, 349, 41, 7, 1, 79, 28, 11, 0, 9, 21, 107, 20, 28, 22, 13, 52, 76, 44, 33, 24, 27, 35, 30, 0, 3, 0, 9, 34, 4, 0, 13, 47, 15, 3, 22, 0, 2, 0, 36, 17, 2, 24, 85, 6, 2, 0, 2, 3, 2, 14, 2, 9, 8, 46, 39, 7, 3, 1, 3, 21, 2, 6, 2, 1, 2, 4, 4, 0, 19, 0, 13, 4, 159, 52, 19, 3, 21, 2, 31, 47, 21, 1, 2, 0, 185, 46, 42, 3, 37, 47, 21, 0, 60, 42, 14, 0, 72, 26, 230, 43, 117, 63, 32, 7, 3, 0, 3, 7, 2, 1, 2, 23, 16, 0, 2, 0, 95, 7, 3, 38, 17, 0, 2, 0, 29, 0, 11, 39, 8, 0, 22, 0, 12, 45, 20, 0, 35, 56, 264, 8, 2, 36, 18, 0, 50, 29, 113, 6, 2, 1, 2, 37, 22, 0, 26, 5, 2, 1, 2, 31, 15, 0, 328, 18, 190, 0, 80, 921, 103, 110, 18, 195, 2749, 1070, 4050, 582, 8634, 568, 8, 30, 114, 29, 19, 47, 17, 3, 32, 20, 6, 18, 689, 63, 129, 74, 6, 0, 67, 12, 65, 1, 2, 0, 29, 6135, 9, 1237, 43, 8, 8952, 286, 50, 2, 18, 3, 9, 395, 2309, 106, 6, 12, 4, 8, 8, 9, 5991, 84, 2, 70, 2, 1, 3, 0, 3, 1, 3, 3, 2, 11, 2, 0, 2, 6, 2, 64, 2, 3, 3, 7, 2, 6, 2, 27, 2, 3, 2, 4, 2, 0, 4, 6, 2, 339, 3, 24, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 7, 2357, 44, 11, 6, 17, 0, 370, 43, 1301, 196, 60, 67, 8, 0, 1205, 3, 2, 26, 2, 1, 2, 0, 3, 0, 2, 9, 2, 3, 2, 0, 2, 0, 7, 0, 5, 0, 2, 0, 2, 0, 2, 2, 2, 1, 2, 0, 3, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 1, 2, 0, 3, 3, 2, 6, 2, 3, 2, 3, 2, 0, 2, 9, 2, 16, 6, 2, 2, 4, 2, 16, 4421, 42717, 35, 4148, 12, 221, 3, 5761, 15, 7472, 3104, 541, 1507, 4938];
      var astralIdentifierCodes = [509, 0, 227, 0, 150, 4, 294, 9, 1368, 2, 2, 1, 6, 3, 41, 2, 5, 0, 166, 1, 574, 3, 9, 9, 370, 1, 154, 10, 176, 2, 54, 14, 32, 9, 16, 3, 46, 10, 54, 9, 7, 2, 37, 13, 2, 9, 6, 1, 45, 0, 13, 2, 49, 13, 9, 3, 2, 11, 83, 11, 7, 0, 161, 11, 6, 9, 7, 3, 56, 1, 2, 6, 3, 1, 3, 2, 10, 0, 11, 1, 3, 6, 4, 4, 193, 17, 10, 9, 5, 0, 82, 19, 13, 9, 214, 6, 3, 8, 28, 1, 83, 16, 16, 9, 82, 12, 9, 9, 84, 14, 5, 9, 243, 14, 166, 9, 71, 5, 2, 1, 3, 3, 2, 0, 2, 1, 13, 9, 120, 6, 3, 6, 4, 0, 29, 9, 41, 6, 2, 3, 9, 0, 10, 10, 47, 15, 406, 7, 2, 7, 17, 9, 57, 21, 2, 13, 123, 5, 4, 0, 2, 1, 2, 6, 2, 0, 9, 9, 49, 4, 2, 1, 2, 4, 9, 9, 330, 3, 19306, 9, 135, 4, 60, 6, 26, 9, 1014, 0, 2, 54, 8, 3, 82, 0, 12, 1, 19628, 1, 5319, 4, 4, 5, 9, 7, 3, 6, 31, 3, 149, 2, 1418, 49, 513, 54, 5, 49, 9, 0, 15, 0, 23, 4, 2, 14, 1361, 6, 2, 16, 3, 6, 2, 1, 2, 4, 262, 6, 10, 9, 419, 13, 1495, 6, 110, 6, 6, 9, 4759, 9, 787719, 239];
      function isInAstralSet(code, set) {
        let pos2 = 65536;
        for (let i = 0; i < set.length; i += 2) {
          pos2 += set[i];
          if (pos2 > code) return false;
          pos2 += set[i + 1];
          if (pos2 >= code) return true;
        }
      }
      function isIdentifierStart(code, astral) {
        if (code < 65) return code === 36;
        if (code < 91) return true;
        if (code < 97) return code === 95;
        if (code < 123) return true;
        if (code <= 65535) return code >= 170 && nonASCIIidentifierStart.test(String.fromCharCode(code));
        if (astral === false) return false;
        return isInAstralSet(code, astralIdentifierStartCodes);
      }
      function isIdentifierChar(code, astral) {
        if (code < 48) return code === 36;
        if (code < 58) return true;
        if (code < 65) return false;
        if (code < 91) return true;
        if (code < 97) return code === 95;
        if (code < 123) return true;
        if (code <= 65535) return code >= 170 && nonASCIIidentifier.test(String.fromCharCode(code));
        if (astral === false) return false;
        return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes);
      }
      function identifier() {
        let ch2 = source.codePointAt(pos);
        if (!isIdentifierStart(ch2, true) || ch2 === "\\")
          return false;
        pos += codePointLen(ch2);
        while (ch2 = source.codePointAt(pos)) {
          if (isIdentifierChar(ch2, true)) {
            pos += codePointLen(ch2);
          } else if (ch2 === "\\") {
            return false;
          } else {
            break;
          }
        }
        return true;
      }
      function codePointLen(ch2) {
        if (ch2 < 65536) return 1;
        return 2;
      }
      function codePointAtLast(bPos) {
        const ch2 = source.charCodeAt(bPos);
        if ((ch2 & 64512) === 56320)
          return ((source.charCodeAt(bPos - 1) & 1023) << 10 | ch2 & 1023) + 65536;
        return ch2;
      }
      function esmSyntaxErr(msg) {
        return Object.assign(new Error(msg), { code: "ERR_LEXER_ESM_SYNTAX" });
      }
      function throwIfImportStatement() {
        const startPos = pos;
        pos += 6;
        const ch2 = commentWhitespace();
        switch (ch2) {
          // dynamic import
          case 40:
            openTokenPosStack[openTokenDepth++] = startPos;
            return;
          // import.meta
          case 46:
            throw esmSyntaxErr("Unexpected import.meta in CJS module.");
          default:
            if (pos === startPos + 6)
              break;
          case 34:
          case 39:
          case 123:
          case 42:
            if (openTokenDepth !== 0) {
              pos--;
              return;
            }
            throw esmSyntaxErr("Unexpected import statement in CJS module.");
        }
      }
      function throwIfExportStatement() {
        pos += 6;
        const curPos = pos;
        const ch2 = commentWhitespace();
        if (pos === curPos && !isPunctuator(ch2))
          return;
        throw esmSyntaxErr("Unexpected export statement in CJS module.");
      }
      function commentWhitespace() {
        let ch2;
        do {
          ch2 = source.charCodeAt(pos);
          if (ch2 === 47) {
            const next_ch = source.charCodeAt(pos + 1);
            if (next_ch === 47)
              lineComment();
            else if (next_ch === 42)
              blockComment();
            else
              return ch2;
          } else if (!isBrOrWs(ch2)) {
            return ch2;
          }
        } while (pos++ < end);
        return ch2;
      }
      function templateString() {
        while (pos++ < end) {
          const ch2 = source.charCodeAt(pos);
          if (ch2 === 36 && source.charCodeAt(pos + 1) === 123) {
            pos++;
            templateStack[templateStackDepth++] = templateDepth;
            templateDepth = ++openTokenDepth;
            return;
          }
          if (ch2 === 96)
            return;
          if (ch2 === 92)
            pos++;
        }
        syntaxError();
      }
      function blockComment() {
        pos++;
        while (pos++ < end) {
          const ch2 = source.charCodeAt(pos);
          if (ch2 === 42 && source.charCodeAt(pos + 1) === 47) {
            pos++;
            return;
          }
        }
      }
      function lineComment() {
        while (pos++ < end) {
          const ch2 = source.charCodeAt(pos);
          if (ch2 === 10 || ch2 === 13)
            return;
        }
      }
      function stringLiteral(quote) {
        while (pos++ < end) {
          let ch2 = source.charCodeAt(pos);
          if (ch2 === quote)
            return;
          if (ch2 === 92) {
            ch2 = source.charCodeAt(++pos);
            if (ch2 === 13 && source.charCodeAt(pos + 1) === 10)
              pos++;
          } else if (isBr(ch2))
            break;
        }
        throw new Error("Unterminated string.");
      }
      function regexCharacterClass() {
        while (pos++ < end) {
          let ch2 = source.charCodeAt(pos);
          if (ch2 === 93)
            return ch2;
          if (ch2 === 92)
            pos++;
          else if (ch2 === 10 || ch2 === 13)
            break;
        }
        throw new Error("Syntax error reading regular expression class.");
      }
      function regularExpression() {
        while (pos++ < end) {
          let ch2 = source.charCodeAt(pos);
          if (ch2 === 47)
            return;
          if (ch2 === 91)
            ch2 = regexCharacterClass();
          else if (ch2 === 92)
            pos++;
          else if (ch2 === 10 || ch2 === 13)
            break;
        }
        throw new Error("Syntax error reading regular expression.");
      }
      function isBr(c) {
        return c === 13 || c === 10;
      }
      function isBrOrWs(c) {
        return c > 8 && c < 14 || c === 32 || c === 160;
      }
      function isBrOrWsOrPunctuatorNotDot(c) {
        return c > 8 && c < 14 || c === 32 || c === 160 || isPunctuator(c) && c !== 46;
      }
      function keywordStart(pos2) {
        return pos2 === 0 || isBrOrWsOrPunctuatorNotDot(source.charCodeAt(pos2 - 1));
      }
      function readPrecedingKeyword(pos2, match) {
        if (pos2 < match.length - 1)
          return false;
        return source.startsWith(match, pos2 - match.length + 1) && (pos2 === 0 || isBrOrWsOrPunctuatorNotDot(source.charCodeAt(pos2 - match.length)));
      }
      function readPrecedingKeyword1(pos2, ch2) {
        return source.charCodeAt(pos2) === ch2 && (pos2 === 0 || isBrOrWsOrPunctuatorNotDot(source.charCodeAt(pos2 - 1)));
      }
      function isExpressionKeyword(pos2) {
        switch (source.charCodeAt(pos2)) {
          case 100:
            switch (source.charCodeAt(pos2 - 1)) {
              case 105:
                return readPrecedingKeyword(pos2 - 2, "vo");
              case 108:
                return readPrecedingKeyword(pos2 - 2, "yie");
              default:
                return false;
            }
          case 101:
            switch (source.charCodeAt(pos2 - 1)) {
              case 115:
                switch (source.charCodeAt(pos2 - 2)) {
                  case 108:
                    return readPrecedingKeyword1(
                      pos2 - 3,
                      101
                      /*e*/
                    );
                  case 97:
                    return readPrecedingKeyword1(
                      pos2 - 3,
                      99
                      /*c*/
                    );
                  default:
                    return false;
                }
              case 116:
                return readPrecedingKeyword(pos2 - 2, "dele");
              default:
                return false;
            }
          case 102:
            if (source.charCodeAt(pos2 - 1) !== 111 || source.charCodeAt(pos2 - 2) !== 101)
              return false;
            switch (source.charCodeAt(pos2 - 3)) {
              case 99:
                return readPrecedingKeyword(pos2 - 4, "instan");
              case 112:
                return readPrecedingKeyword(pos2 - 4, "ty");
              default:
                return false;
            }
          case 110:
            return readPrecedingKeyword1(
              pos2 - 1,
              105
              /*i*/
            ) || readPrecedingKeyword(pos2 - 1, "retur");
          case 111:
            return readPrecedingKeyword1(
              pos2 - 1,
              100
              /*d*/
            );
          case 114:
            return readPrecedingKeyword(pos2 - 1, "debugge");
          case 116:
            return readPrecedingKeyword(pos2 - 1, "awai");
          case 119:
            switch (source.charCodeAt(pos2 - 1)) {
              case 101:
                return readPrecedingKeyword1(
                  pos2 - 2,
                  110
                  /*n*/
                );
              case 111:
                return readPrecedingKeyword(pos2 - 2, "thr");
              default:
                return false;
            }
        }
        return false;
      }
      function isParenKeyword(curPos) {
        return source.charCodeAt(curPos) === 101 && source.startsWith("whil", curPos - 4) || source.charCodeAt(curPos) === 114 && source.startsWith("fo", curPos - 2) || source.charCodeAt(curPos - 1) === 105 && source.charCodeAt(curPos) === 102;
      }
      function isPunctuator(ch2) {
        return ch2 === 33 || ch2 === 37 || ch2 === 38 || ch2 > 39 && ch2 < 48 || ch2 > 57 && ch2 < 64 || ch2 === 91 || ch2 === 93 || ch2 === 94 || ch2 > 122 && ch2 < 127;
      }
      function isExpressionPunctuator(ch2) {
        return ch2 === 33 || ch2 === 37 || ch2 === 38 || ch2 > 39 && ch2 < 47 && ch2 !== 41 || ch2 > 57 && ch2 < 64 || ch2 === 91 || ch2 === 94 || ch2 > 122 && ch2 < 127 && ch2 !== 125;
      }
      function isExpressionTerminator(curPos) {
        switch (source.charCodeAt(curPos)) {
          case 62:
            return source.charCodeAt(curPos - 1) === 61;
          case 59:
          case 41:
            return true;
          case 104:
            return source.startsWith("catc", curPos - 4);
          case 121:
            return source.startsWith("finall", curPos - 6);
          case 101:
            return source.startsWith("els", curPos - 3);
        }
        return false;
      }
      var initPromise = Promise.resolve();
      module.exports.init = () => initPromise;
      module.exports.initSync = () => {
      };
      module.exports.parse = parseCJS;
    }
  });

  // ../../node_modules/sloppy-module-parser/sloppy-require-parser.js
  var require_sloppy_require_parser = __commonJS({
    "../../node_modules/sloppy-module-parser/sloppy-require-parser.js"(exports, module) {
      var CALL_WITH_STRING = /^\s*\(\s*('[^']+'|"[^"]+"|`[^`]+`)\s*\)/;
      var IS_EXTENSION = /^\s*\.(addon|addon\.resolve|asset|resolve)\s*\(\s*(?:('[^']+'|"[^"]+"|`[^`]+`)(?:,\s*__filename)?)?\s*\)/;
      module.exports = parseCJS;
      function parseCJS(src, result) {
        const seenRequires = [];
        const seenAddons = [];
        const seenAssets = [];
        let i = src.indexOf("require");
        let j = i > -1 ? src.indexOf("/*") : -1;
        while (i > -1) {
          if (j > -1 && i > j) {
            j = src.indexOf("*/", j + 2);
            if (j === -1) continue;
            if (i < j) i = src.indexOf("require", j + 2);
            j = src.indexOf("/*", j + 2);
            continue;
          }
          if ((newWord(src, i) || isSpread(src, i)) && !inComment(src, i)) {
            const suffix = src.slice(i + 7);
            const m = suffix.match(CALL_WITH_STRING);
            if (m) {
              const req = m[1].slice(1, -1);
              if (seenRequires.indexOf(req) === -1) {
                seenRequires.push(req);
                result.resolutions.push({ isImport: false, position: null, input: req, output: null });
              }
            } else {
              const m2 = suffix.match(IS_EXTENSION);
              if (m2) {
                const ext = m2[1];
                const isAddon = ext === "addon" || ext === "addon.resolve";
                const isAsset = ext === "asset";
                const isResolve = ext === "resolve";
                const req = m2[2] ? m2[2].slice(1, -1) : ".";
                if (isAddon) {
                  if (seenAddons.indexOf(req) === -1) {
                    seenAddons.push(req);
                    result.addons.push({ input: req, output: null });
                  }
                } else if (isAsset && m2[2]) {
                  if (seenAssets.indexOf(req) === -1) {
                    seenAssets.push(req);
                    result.assets.push({ input: req, output: null });
                  }
                } else if (isResolve && m2[2]) {
                  if (seenRequires.indexOf(req) === -1) {
                    seenRequires.push(req);
                    result.resolutions.push({ isImport: false, position: null, input: req, output: null });
                  }
                }
              }
            }
          }
          i = src.indexOf("require", i + 7);
        }
      }
      function newWord(src, i) {
        const s = i > 0 ? src.slice(i - 1, i) : "";
        return !/^\w|["'`._]/.test(s);
      }
      function isSpread(src, i) {
        const s = i > 0 ? src.slice(i - 3, i) : "";
        return s === "...";
      }
      function inComment(src, i) {
        const pre = src.slice(i > 100 ? i - 100 : 0, i);
        return pre.indexOf("//", Math.max(pre.lastIndexOf("\n"), 0)) > -1 && src.slice(i, i + 100).indexOf("\n") > -1;
      }
    }
  });

  // ../../node_modules/sloppy-module-parser/parse.js
  var require_parse = __commonJS({
    "../../node_modules/sloppy-module-parser/parse.js"(exports) {
      var mjs = (init_lexer(), __toCommonJS(lexer_exports));
      var cjs = require_lexer();
      var srp = require_sloppy_require_parser();
      exports.init = async function init2() {
        await mjs.init;
      };
      exports.parse = function parse2(src, type = "module", strictMode = false) {
        const result = {
          type,
          resolutions: [],
          namedImports: [],
          exports: null,
          addons: [],
          assets: []
        };
        if (type === "json") {
          result.exports = [];
          return result;
        }
        const [imp, exp] = mjsParse(src);
        const esm = type === "module";
        if (!esm && exp.length > 0) {
          if (!strictMode) return parse2(src, "module", true);
          throw new Error("Export expression not allowed in cjs");
        }
        for (const i of imp) {
          if (i.d === -1 && !esm) {
            if (!strictMode) return parse2(src, "module", true);
            throw new Error("Import statement not allowed in cjs");
          }
          if (i.n) {
            const q = i.d > -1 ? 0 : 1;
            const names = [];
            const isWildcard = i.d === -1 && parseNames(src.slice(i.ss + 6, i.s), names);
            const resolution = {
              isImport: true,
              position: [i.ss, i.s - q, i.e + q],
              input: i.n,
              output: null
            };
            result.resolutions.push(resolution);
            if (names.length || isWildcard) {
              result.namedImports.push({
                isWildcard,
                isExport: src.slice(i.ss, i.ss + 6) === "export",
                names,
                from: resolution
              });
            }
          } else if (i.ss !== i.s) {
            result.resolutions.push({
              isImport: true,
              position: [i.ss, i.s - 1, -1],
              input: null,
              output: null
            });
          }
        }
        if (esm) {
          result.exports = exp;
          return result;
        }
        srp(src, result);
        return result;
      };
      exports.exports = function exports2(src, type) {
        if (type === "module") return mjs.parse(src)[1];
        return type === "json" ? [] : cjs.parse(src).exports;
      };
      function mjsParse(src) {
        try {
          return mjs.parse(src);
        } catch {
          return [[], []];
        }
      }
      function parseNames(imp, result) {
        imp = imp.replace(/\/\/[^n]+/g, "").replace(/\/\*[^*]*\*\//g, "");
        const bs = imp.indexOf("{");
        if (bs === -1) {
          return imp.indexOf("*") > -1;
        }
        const be = imp.indexOf("}", bs);
        if (be === -1) return false;
        for (const part of imp.slice(bs + 1, be).split(",")) {
          const name = part.split(/\sas\s/)[0].trim();
          if (!name) break;
          result.push(name);
        }
        return imp.indexOf("*", be + 1) > -1;
      }
    }
  });

  // ../../node_modules/dependency-stream/index.js
  var require_dependency_stream = __commonJS({
    "../../node_modules/dependency-stream/index.js"(exports, module) {
      var parse2 = require_parse();
      var b4a = require_b4a();
      var resolveModule = require_bare_module_resolve();
      var resolveAddon = require_bare_addon_resolve();
      var FIFO = require_fast_fifo();
      var runtime = require_which_runtime();
      var { Readable } = require_streamx();
      module.exports = class DependencyStream extends Readable {
        constructor(drive, {
          entrypoint = ".",
          preload = true,
          source = false,
          strict = false,
          packages = false,
          builtins = [],
          runtimes = ["bare", "node"],
          extensions = [".js", ".cjs", ".json", ".mjs"],
          host = runtime.platform + "-" + runtime.arch,
          conditions = runtimes
        } = {}) {
          super({ highWaterMark: 64 * 1024, byteLength: objectByteLength });
          this.drive = drive;
          this.entrypoint = entrypoint;
          this.preload = preload;
          this.source = source;
          this.modules = /* @__PURE__ */ new Map();
          this.strict = strict;
          this.builtins = Array.isArray(builtins) ? new Set(builtins) : builtins;
          this.packages = packages;
          this.extensions = extensions;
          this.host = host;
          this._importConditions = ["module", "import", ...conditions];
          this._requireConditions = ["require", ...conditions];
          this._addonConditions = ["addon", ...conditions];
          this._pending = /* @__PURE__ */ new Map();
          this._packages = /* @__PURE__ */ new Map();
          this._queue = new FIFO();
        }
        async _open(cb) {
          try {
            const entrypoint = /^[./]/.test(this.entrypoint) ? this.entrypoint : "./" + this.entrypoint;
            const entry = entrypoint[0] === "/" && entrypoint !== "/" ? await this.drive.entry(entrypoint) : null;
            await parse2.init();
            const pkg = await this._readPackageCached("/package.json");
            const imp = entry && entry.value && entry.value.metadata && entry.value.metadata.imports;
            const key = await this._resolveModule(entrypoint, "/", !!pkg && pkg.type === "module", imp);
            this._queue.push(key);
          } catch (err) {
            return cb(err);
          }
          cb(null);
        }
        _readPackageCached(key) {
          let p = this._packages.get(key);
          if (p) return p;
          p = this._readPackage(key);
          this._packages.set(key, p);
          return p;
        }
        async _readPackage(key) {
          const buf = await this.drive.get(key);
          if (!buf) return null;
          try {
            return JSON.parse(b4a.toString(buf));
          } catch {
            return null;
          }
        }
        async _resolvePackage(key, resolutions) {
          if (resolutions && resolutions["#package"]) {
            const k = resolutions["#package"];
            const pkg = await this._readPackageCached(k);
            if (pkg) return { key: k, package: pkg };
          }
          const basedir = key.slice(0, key.lastIndexOf("/") + 1);
          for (const url of resolveModule.lookupPackageScope(toFileURL(basedir))) {
            const k = fromFileURL(url);
            const pkg = await this._readPackageCached(k);
            if (!pkg) continue;
            return { key: k, package: pkg };
          }
          return null;
        }
        async _resolveAddon(id, basedir, imports) {
          const conditions = this._addonConditions;
          const readPackage = (packageURL) => this._readPackageCached(fromFileURL(packageURL));
          const parentURL = toFileURL(basedir);
          const resolutions = imports ? { [parentURL]: imports } : null;
          for await (const addonURL of resolveAddon(
            id,
            parentURL,
            { host: this.host, extensions: [".node", ".bare"], conditions, resolutions },
            readPackage
          )) {
            const key = fromFileURL(addonURL);
            if (await this.drive.entry(key)) return key;
          }
          const err = new Error(`Cannot find addon '${id}'`);
          err.code = "ADDON_NOT_FOUND";
          throw err;
        }
        async _resolveModule(id, basedir, isImport, imports) {
          const conditions = isImport ? this._importConditions : this._requireConditions;
          const readPackage = (packageURL) => this._readPackageCached(fromFileURL(packageURL));
          const parentURL = toFileURL(basedir);
          const resolutions = imports ? { [parentURL]: imports } : null;
          for await (const moduleURL of resolveModule(
            id,
            parentURL,
            { extensions: this.extensions, conditions, resolutions },
            readPackage
          )) {
            const key = fromFileURL(moduleURL);
            if (await this.drive.entry(key)) return key;
          }
          const err = new Error(`Cannot find module '${id}'`);
          err.code = "MODULE_NOT_FOUND";
          throw err;
        }
        async _read(cb) {
          try {
            while (this._queue.length > 0) {
              const key = this._queue.shift();
              if (this.modules.has(key)) continue;
              const data = await this._addOnce(key);
              this.modules.set(key, data);
              this._pending.delete(key);
              if (this.push(data) === false) break;
            }
          } catch (err) {
            return cb(err);
          }
          if (this._queue.length === 0) {
            this.push(null);
            return cb(null);
          }
          cb(null);
        }
        async _addOnce(key) {
          if (this._pending.has(key)) return this._pending.get(key);
          const p = this._add(key);
          this._pending.set(key, p);
          await p;
          return p;
        }
        async _add(key) {
          const entry = await this.drive.entry(key);
          if (entry === null) throw new Error("Key not found: " + key);
          const data = await this.drive.get(entry);
          const source = b4a.toString(data);
          const type = key.endsWith(".json") ? "json" : key.endsWith(".mjs") ? "module" : "script";
          const deps = parse2.parse(source, type, type !== "script");
          const resolutions = entry.value && entry.value.metadata && entry.value.metadata.imports;
          const result = {
            key,
            source: this.source ? source : null,
            type: deps.type,
            resolutions: deps.resolutions,
            namedImports: deps.namedImports,
            exports: deps.exports,
            addons: deps.addons,
            assets: deps.assets
          };
          if (this.packages && type !== "json") {
            const p2 = await this._resolvePackage(key, resolutions);
            if (p2) {
              result.resolutions.push(
                {
                  isImport: deps.type === "module",
                  position: null,
                  input: "bare:package",
                  output: p2.key
                },
                {
                  isImport: deps.type === "module",
                  position: null,
                  input: "#package",
                  output: p2.key
                }
              );
            }
          }
          const basedir = key.slice(0, key.lastIndexOf("/") + 1);
          const all = [];
          if (deps.importsAttributes) {
            for (const attrInput of deps.importsAttributes) {
              const attrOutput = await this._resolveModule(attrInput, basedir, true, resolutions);
              const data2 = await this.drive.get(attrOutput);
              if (data2 === null) throw new Error("Key not found: " + key);
              const source2 = b4a.toString(data2);
              let imports = {};
              try {
                const obj = JSON.parse(source2);
                if (obj === null || typeof obj !== "object" || Array.isArray(obj)) {
                  throw new Error(`Invalid import attribute json file: ${key}`);
                }
                if ("imports" in obj) imports = obj.imports;
                else imports = obj;
              } catch (err) {
                const jsonErr = new Error(`Invalid import attribute json file: ${key}`);
                jsonErr.code = "INVALID_JSON";
                throw jsonErr;
              }
              const modules = Object.values(imports);
              const resolvedModules = [];
              for (const item of modules) {
                try {
                  const res = await this._resolveModule(item, basedir);
                  resolvedModules.push(res);
                } catch (err) {
                  const resolveErr = new Error(`Failed to resolve module ${item}`);
                  resolveErr.code = "MODULE_NOT_FOUND";
                  throw resolveErr;
                }
              }
              for (const resolvedModule of resolvedModules) {
                if (!result.resolutions.some((item) => item.input === resolvedModule)) {
                  result.resolutions.push({
                    isImport: false,
                    position: null,
                    input: resolvedModule,
                    output: null
                  });
                }
              }
            }
          }
          for (const res of result.resolutions) {
            if (isAddonPolyfill(res.input)) {
              result.addons.push({
                input: ".",
                output: null,
                referrer: res.input
              });
            }
          }
          for (const dep of result.addons) {
            if (dep.referrer === "node-gyp-build") {
              dep.input = fromFileURL(toFileURL(basedir + dep.input));
              if (dep.input.endsWith("/")) dep.input = dep.input.slice(0, -1);
            } else if (dep.input === null) {
              continue;
            }
            all.push(this._resolveAddon(dep.input, basedir, resolutions));
          }
          for (const res of result.resolutions) {
            if (res.input === null) continue;
            all.push(res.output || this._resolveModule(res.input, basedir, res.isImport, resolutions));
          }
          const outputs = await Promise.allSettled(all);
          let p = 0;
          for (const dep of result.addons) {
            const { value, reason } = outputs[p++];
            if (reason) {
              if (!this.strict) continue;
              throw reason;
            }
            dep.output = value;
          }
          for (const res of result.resolutions) {
            if (res.input === null) continue;
            const { value, reason } = outputs[p++];
            if (reason) {
              if (!this.strict) continue;
              throw reason;
            }
            res.output = value;
            if (!this.modules.has(res.output)) {
              if (this.preload) this._addOnce(res.output).catch(noop);
              this._queue.push(res.output);
            }
          }
          return result;
        }
      };
      function noop() {
      }
      function objectByteLength() {
        return 1024;
      }
      function toFileURL(path) {
        return new URL("file://" + encodeURI(path));
      }
      function fromFileURL(url) {
        return decodeURI(url.pathname);
      }
      function isAddonPolyfill(name) {
        return name === "node-gyp-build" || name === "require-addon";
      }
    }
  });

  // ../../node_modules/sodium-native/binding.js
  var require_binding8 = __commonJS({
    "../../node_modules/sodium-native/binding.js"(exports, module) {
      __require.addon = require_node2();
      module.exports = __require.addon(".", __filename);
    }
  });

  // ../../node_modules/sodium-native/index.js
  var require_sodium_native = __commonJS({
    "../../node_modules/sodium-native/index.js"(exports, module) {
      var assert = require_bare_assert();
      var binding = require_binding8();
      var { isNode } = require_which_runtime();
      var OPTIONAL = Buffer.from(new ArrayBuffer(0));
      module.exports = exports = { ...binding };
      exports.sodium_memzero = function(buf) {
        assert(ArrayBuffer.isView(buf), "buf must be a typed array");
        binding.sodium_memzero(buf);
      };
      exports.sodium_mlock = function(buf) {
        assert(ArrayBuffer.isView(buf), "buf must be a typed array");
        const res = binding.sodium_mlock(buf);
        if (res !== 0) throw new Error("memory lock failed");
      };
      exports.sodium_munlock = function(buf) {
        assert(ArrayBuffer.isView(buf), "buf must be a typed array");
        const res = binding.sodium_munlock(buf);
        if (res !== 0) throw new Error("memory unlock failed");
      };
      exports.sodium_malloc = function(size) {
        assert(size >= 0, "invalid size");
        const buf = Buffer.from(binding.sodium_malloc(size));
        buf.secure = true;
        return buf;
      };
      exports.sodium_free = function(buf) {
        if (!buf || !buf.secure) return;
        binding.sodium_free(buf.buffer);
      };
      exports.sodium_mprotect_noaccess = function(buf) {
        const res = binding.sodium_mprotect_noaccess(buf.buffer);
        if (res !== 0) throw new Error("failed to lock buffer");
      };
      exports.sodium_mprotect_readonly = function(buf) {
        const res = binding.sodium_mprotect_readonly(buf.buffer);
        if (res !== 0) throw new Error("failed to unlock buffer");
      };
      exports.sodium_mprotect_readwrite = function(buf) {
        const res = binding.sodium_mprotect_readwrite(buf.buffer);
        if (res !== 0) throw new Error("failed to unlock buffer");
      };
      exports.randombytes_buf = function(buffer) {
        assert(ArrayBuffer.isView(buffer), "buffer must be a typed array");
        binding.randombytes_buf(buffer.buffer, buffer.byteOffset, buffer.byteLength);
      };
      exports.randombytes_buf_deterministic = function(buffer, seed) {
        assert(ArrayBuffer.isView(buffer), "buffer must be a typed array");
        assert(ArrayBuffer.isView(seed), "seed must be a typed array");
        assert(
          seed.byteLength === binding.randombytes_SEEDBYTES,
          "seed must be 'randombytes_SEEDBYTES' bytes"
        );
        binding.randombytes_buf_deterministic(
          buffer.buffer,
          buffer.byteOffset,
          buffer.byteLength,
          seed.buffer,
          seed.byteOffset,
          seed.byteLength
        );
      };
      exports.sodium_memcmp = function(a, b) {
        assert(ArrayBuffer.isView(a), "a must be a typed array");
        assert(ArrayBuffer.isView(b), "b must be a typed array");
        assert(a.byteLength === b.byteLength, "buffers must be of same length");
        return binding.sodium_memcmp(a, b);
      };
      exports.sodium_add = function(a, b) {
        assert(ArrayBuffer.isView(a), "a must be a typed array");
        assert(ArrayBuffer.isView(b), "b must be a typed array");
        assert(a.byteLength === b.byteLength, "buffers must be of same length");
        binding.sodium_add(a, b);
      };
      exports.sodium_sub = function(a, b) {
        assert(ArrayBuffer.isView(a), "a must be a typed array");
        assert(ArrayBuffer.isView(b), "b must be a typed array");
        assert(a.byteLength === b.byteLength, "buffers must be of same length");
        binding.sodium_sub(a, b);
      };
      exports.sodium_compare = function(a, b) {
        assert(ArrayBuffer.isView(a), "a must be a typed array");
        assert(ArrayBuffer.isView(b), "b must be a typed array");
        assert(a.byteLength === b.byteLength, "buffers must be of same length");
        return binding.sodium_compare(a, b);
      };
      exports.sodium_is_zero = function(buffer, length) {
        if (length === void 0) length = buffer.byteLength;
        assert(ArrayBuffer.isView(buffer), "buffer must be a typed array");
        assert(length >= 0 && length <= buffer.byteLength, "invalid length");
        return binding.sodium_is_zero(buffer, length);
      };
      exports.sodium_pad = function(buffer, unpaddedBuflen, blockSize) {
        assert(ArrayBuffer.isView(buffer), "buffer must be a typed array");
        assert(unpaddedBuflen <= buffer.byteLength, "unpadded length cannot exceed buffer length");
        assert(blockSize <= buffer.byteLength, "block size cannot exceed buffer length");
        assert(blockSize >= 1, "block size must be at least 1 byte");
        assert(
          buffer.byteLength >= unpaddedBuflen + (blockSize - unpaddedBuflen % blockSize),
          "buf not long enough"
        );
        return binding.sodium_pad(buffer, unpaddedBuflen, blockSize);
      };
      exports.sodium_unpad = function(buffer, paddedBuflen, blockSize) {
        assert(ArrayBuffer.isView(buffer), "buffer must be a typed array");
        assert(paddedBuflen <= buffer.byteLength, "unpadded length cannot exceed buffer length");
        assert(blockSize <= buffer.byteLength, "block size cannot exceed buffer length");
        assert(blockSize >= 1, "block size must be at least 1 byte");
        return binding.sodium_unpad(buffer, paddedBuflen, blockSize);
      };
      exports.crypto_sign_keypair = function(pk, sk) {
        assert(ArrayBuffer.isView(pk), "pk must be a typed array");
        assert(ArrayBuffer.isView(sk), "sk must be a typed array");
        assert(
          pk.byteLength === binding.crypto_sign_PUBLICKEYBYTES,
          "pk must be 'crypto_sign_PUBLICKEYBYTES' bytes"
        );
        assert(
          sk.byteLength === binding.crypto_sign_SECRETKEYBYTES,
          "sk must be 'crypto_sign_SECRETKEYBYTES' bytes"
        );
        const res = binding.crypto_sign_keypair(pk, sk);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_sign_seed_keypair = function(pk, sk, seed) {
        assert(ArrayBuffer.isView(pk), "pk must be a typed array");
        assert(ArrayBuffer.isView(sk), "sk must be a typed array");
        assert(ArrayBuffer.isView(seed), "seed must be a typed array");
        assert(
          pk.byteLength === binding.crypto_sign_PUBLICKEYBYTES,
          "pk must be 'crypto_sign_PUBLICKEYBYTES' bytes"
        );
        assert(
          sk.byteLength === binding.crypto_sign_SECRETKEYBYTES,
          "sk must be 'crypto_sign_SECRETKEYBYTES' bytes"
        );
        assert(
          seed.byteLength === binding.crypto_sign_SEEDBYTES,
          "seed must be 'crypto_sign_SEEDBYTES' bytes"
        );
        const res = binding.crypto_sign_seed_keypair(pk, sk, seed);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_sign = function(sm, m, sk) {
        assert(ArrayBuffer.isView(sm), "sm must be a typed array");
        assert(ArrayBuffer.isView(m), "m must be a typed array");
        assert(ArrayBuffer.isView(sk), "sk must be a typed array");
        assert(
          sm.byteLength === binding.crypto_sign_BYTES + m.byteLength,
          "sm must be 'm.byteLength + crypto_sign_BYTES' bytes"
        );
        assert(
          sk.byteLength === binding.crypto_sign_SECRETKEYBYTES,
          "sk must be 'crypto_sign_SECRETKEYBYTES' bytes"
        );
        const res = binding.crypto_sign(sm, m, sk);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_sign_open = function(m, sm, pk) {
        assert(ArrayBuffer.isView(m), "m must be a typed array");
        assert(ArrayBuffer.isView(sm), "sm must be a typed array");
        assert(ArrayBuffer.isView(pk), "pk must be a typed array");
        assert(
          sm.byteLength >= binding.crypto_sign_BYTES,
          "sm must be at least 'crypto_sign_BYTES' bytes"
        );
        assert(
          m.byteLength === sm.byteLength - binding.crypto_sign_BYTES,
          "m must be 'sm.byteLength - crypto_sign_BYTES' bytes"
        );
        assert(
          pk.byteLength === binding.crypto_sign_PUBLICKEYBYTES,
          "pk must be 'crypto_sign_PUBLICKEYBYTES' bytes"
        );
        const res = binding.crypto_sign_open(m, sm, pk);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_sign_open = function(m, sm, pk) {
        assert(ArrayBuffer.isView(m), "m must be a typed array");
        assert(ArrayBuffer.isView(sm), "sm must be a typed array");
        assert(ArrayBuffer.isView(pk), "pk must be a typed array");
        assert(
          sm.byteLength >= binding.crypto_sign_BYTES,
          "sm must be at least 'crypto_sign_BYTES' bytes"
        );
        assert(
          m.byteLength === sm.byteLength - binding.crypto_sign_BYTES,
          "m must be 'sm.byteLength - crypto_sign_BYTES' bytes"
        );
        assert(
          pk.byteLength === binding.crypto_sign_PUBLICKEYBYTES,
          "pk must be 'crypto_sign_PUBLICKEYBYTES' bytes"
        );
        return binding.crypto_sign_open(m, sm, pk);
      };
      exports.crypto_sign_detached = function(sig, m, sk) {
        assert(ArrayBuffer.isView(sig), "sig must be a typed array");
        assert(ArrayBuffer.isView(m), "m must be a typed array");
        assert(ArrayBuffer.isView(sk), "sk must be a typed array");
        assert(sig.byteLength === binding.crypto_sign_BYTES, "sig must be 'crypto_sign_BYTES' bytes");
        assert(
          sk.byteLength === binding.crypto_sign_SECRETKEYBYTES,
          "sk must be 'crypto_sign_SECRETKEYBYTES' bytes"
        );
        const res = binding.crypto_sign_detached(sig, m, sk);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_sign_verify_detached = function(sig, m, pk) {
        assert(ArrayBuffer.isView(sig), "sig must be a typed array");
        assert(ArrayBuffer.isView(m), "m must be a typed array");
        assert(ArrayBuffer.isView(pk), "pk must be a typed array");
        assert(
          sig.byteLength >= binding.crypto_sign_BYTES,
          "sig must be at least 'crypto_sign_BYTES' bytes"
        );
        assert(
          pk.byteLength === binding.crypto_sign_PUBLICKEYBYTES,
          "pk must be 'crypto_sign_PUBLICKEYBYTES' bytes"
        );
        return binding.crypto_sign_verify_detached(
          sig.buffer,
          sig.byteOffset,
          sig.byteLength,
          m.buffer,
          m.byteOffset,
          m.byteLength,
          pk.buffer,
          pk.byteOffset,
          pk.byteLength
        );
      };
      exports.crypto_sign_ed25519_sk_to_pk = function(pk, sk) {
        assert(ArrayBuffer.isView(pk), "pk must be a typed array");
        assert(ArrayBuffer.isView(sk), "sk must be a typed array");
        assert(
          pk.byteLength === binding.crypto_sign_PUBLICKEYBYTES,
          "pk must be 'crypto_sign_PUBLICKEYBYTES' bytes"
        );
        assert(
          sk.byteLength === binding.crypto_sign_SECRETKEYBYTES,
          "sk must be 'crypto_sign_SECRETKEYBYTES' bytes"
        );
        const res = binding.crypto_sign_ed25519_sk_to_pk(pk, sk);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_sign_ed25519_pk_to_curve25519 = function(x25519pk, ed25519pk) {
        assert(ArrayBuffer.isView(x25519pk), "x25519pk must be a typed array");
        assert(ArrayBuffer.isView(ed25519pk), "ed25519pk must be a typed array");
        assert(
          x25519pk.byteLength === binding.crypto_box_PUBLICKEYBYTES,
          "x25519pk must be 'crypto_box_PUBLICKEYBYTES' bytes"
        );
        assert(
          ed25519pk.byteLength === binding.crypto_sign_PUBLICKEYBYTES,
          "ed25519pk must be 'crypto_sign_PUBLICKEYBYTES' bytes"
        );
        const res = binding.crypto_sign_ed25519_pk_to_curve25519(x25519pk, ed25519pk);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_sign_ed25519_sk_to_curve25519 = function(x25519sk, ed25519sk) {
        assert(ArrayBuffer.isView(x25519sk), "x25519sk must be a typed array");
        assert(ArrayBuffer.isView(ed25519sk), "ed25519sk must be a typed array");
        assert(
          x25519sk.byteLength === binding.crypto_box_SECRETKEYBYTES,
          "x25519sk must be 'crypto_box_SECRETKEYBYTES' bytes"
        );
        const edLen = ed25519sk.byteLength;
        assert(
          edLen === binding.crypto_sign_SECRETKEYBYTES || edLen === binding.crypto_box_SECRETKEYBYTES,
          "ed25519sk must be 'crypto_sign_SECRETKEYBYTES' or 'crypto_sign_SECRETKEYBYTES - crypto_sign_PUBLICKEYBYTES' bytes"
        );
        const res = binding.crypto_sign_ed25519_sk_to_curve25519(x25519sk, ed25519sk);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_box_keypair = function(pk, sk) {
        assert(ArrayBuffer.isView(pk), "pk must be a typed array");
        assert(
          pk.byteLength === binding.crypto_box_PUBLICKEYBYTES,
          "pk must be 'crypto_box_PUBLICKEYBYTES' bytes"
        );
        assert(ArrayBuffer.isView(sk), "sk must be a typed array");
        assert(
          sk.byteLength === binding.crypto_box_SECRETKEYBYTES,
          "sk must be 'crypto_box_SECRETKEYBYTES' bytes"
        );
        const res = binding.crypto_box_keypair(pk, sk);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_box_seed_keypair = function(pk, sk, seed) {
        assert(ArrayBuffer.isView(pk), "pk must be a typed array");
        assert(
          pk.byteLength === binding.crypto_box_PUBLICKEYBYTES,
          "pk must be 'crypto_box_PUBLICKEYBYTES' bytes"
        );
        assert(ArrayBuffer.isView(sk), "sk must be a typed array");
        assert(
          sk.byteLength === binding.crypto_box_SECRETKEYBYTES,
          "sk must be 'crypto_box_SECRETKEYBYTES' bytes"
        );
        assert(ArrayBuffer.isView(seed), "seed must be a typed array");
        assert(
          seed.byteLength === binding.crypto_box_SEEDBYTES,
          "seed must be 'crypto_box_SEEDBYTES' bytes"
        );
        const res = binding.crypto_box_seed_keypair(pk, sk, seed);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_box_easy = function(c, m, n, pk, sk) {
        assert(ArrayBuffer.isView(c), "c must be a typed array");
        assert(ArrayBuffer.isView(m), "m must be a typed array");
        assert(ArrayBuffer.isView(n), "n must be a typed array");
        assert(ArrayBuffer.isView(pk), "pk must be a typed array");
        assert(ArrayBuffer.isView(sk), "sk must be a typed array");
        assert(
          c.byteLength === m.byteLength + exports.crypto_box_MACBYTES,
          "c must be 'm.byteLength + crypto_box_MACBYTES' bytes"
        );
        assert(n.byteLength === exports.crypto_box_NONCEBYTES, "n must be 'crypto_box_NONCEBYTES' bytes");
        assert(
          pk.byteLength === exports.crypto_box_PUBLICKEYBYTES,
          "pk must be 'crypto_box_PUBLICKEYBYTES' bytes"
        );
        assert(
          sk.byteLength === exports.crypto_box_SECRETKEYBYTES,
          "sk must be 'crypto_box_SECRETKEYBYTES' bytes"
        );
        const res = binding.crypto_box_easy(c, m, n, pk, sk);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_box_detached = function(c, mac, m, n, pk, sk) {
        assert(ArrayBuffer.isView(c), "c must be a typed array");
        assert(ArrayBuffer.isView(mac), "mac must be a typed array");
        assert(ArrayBuffer.isView(m), "m must be a typed array");
        assert(ArrayBuffer.isView(n), "n must be a typed array");
        assert(ArrayBuffer.isView(pk), "pk must be a typed array");
        assert(ArrayBuffer.isView(sk), "sk must be a typed array");
        assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes");
        assert(mac.byteLength === exports.crypto_box_MACBYTES, "mac must be 'crypto_box_MACBYTES' bytes");
        assert(n.byteLength === exports.crypto_box_NONCEBYTES, "n must be 'crypto_box_NONCEBYTES' bytes");
        assert(
          pk.byteLength === exports.crypto_box_PUBLICKEYBYTES,
          "pk must be 'crypto_box_PUBLICKEYBYTES' bytes"
        );
        assert(
          sk.byteLength === exports.crypto_box_SECRETKEYBYTES,
          "sk must be 'crypto_box_SECRETKEYBYTES' bytes"
        );
        const res = binding.crypto_box_detached(c, mac, m, n, pk, sk);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_box_open_easy = function(m, c, n, pk, sk) {
        assert(ArrayBuffer.isView(m), "m must be a typed array");
        assert(ArrayBuffer.isView(c), "c must be a typed array");
        assert(ArrayBuffer.isView(n), "n must be a typed array");
        assert(ArrayBuffer.isView(pk), "pk must be a typed array");
        assert(ArrayBuffer.isView(sk), "sk must be a typed array");
        assert(
          c.byteLength >= exports.crypto_box_MACBYTES,
          "c must be at least 'crypto_box_MACBYTES' bytes"
        );
        assert(
          m.byteLength === c.byteLength - exports.crypto_box_MACBYTES,
          "m must be 'c.byteLength - crypto_box_MACBYTES' bytes"
        );
        assert(n.byteLength === exports.crypto_box_NONCEBYTES, "n must be 'crypto_box_NONCEBYTES' bytes");
        assert(
          pk.byteLength === exports.crypto_box_PUBLICKEYBYTES,
          "pk must be 'crypto_box_PUBLICKEYBYTES' bytes"
        );
        assert(
          sk.byteLength === exports.crypto_box_SECRETKEYBYTES,
          "sk must be 'crypto_box_SECRETKEYBYTES' bytes"
        );
        return binding.crypto_box_open_easy(m, c, n, pk, sk);
      };
      exports.crypto_box_open_detached = function(m, c, mac, n, pk, sk) {
        assert(ArrayBuffer.isView(m), "m must be a typed array");
        assert(ArrayBuffer.isView(c), "c must be a typed array");
        assert(ArrayBuffer.isView(mac), "mac must be a typed array");
        assert(ArrayBuffer.isView(n), "n must be a typed array");
        assert(ArrayBuffer.isView(pk), "pk must be a typed array");
        assert(ArrayBuffer.isView(sk), "sk must be a typed array");
        assert(m.byteLength === c.byteLength, "m must be 'c.byteLength' bytes");
        assert(mac.byteLength === exports.crypto_box_MACBYTES, "mac must be 'crypto_box_MACBYTES' bytes");
        assert(n.byteLength === exports.crypto_box_NONCEBYTES, "n must be 'crypto_box_NONCEBYTES' bytes");
        assert(
          pk.byteLength === exports.crypto_box_PUBLICKEYBYTES,
          "pk must be 'crypto_box_PUBLICKEYBYTES' bytes"
        );
        assert(
          sk.byteLength === exports.crypto_box_SECRETKEYBYTES,
          "sk must be 'crypto_box_SECRETKEYBYTES' bytes"
        );
        return binding.crypto_box_open_detached(m, c, mac, n, pk, sk);
      };
      exports.crypto_box_seal = function(c, m, pk) {
        assert(ArrayBuffer.isView(c), "c must be a typed array");
        assert(ArrayBuffer.isView(m), "m must be a typed array");
        assert(ArrayBuffer.isView(pk), "pk must be a typed array");
        assert(
          c.byteLength === m.byteLength + exports.crypto_box_SEALBYTES,
          "c must be 'm.byteLength + crypto_box_SEALBYTES' bytes"
        );
        assert(
          pk.byteLength === exports.crypto_box_PUBLICKEYBYTES,
          "pk must be 'crypto_box_PUBLICKEYBYTES' bytes"
        );
        const res = binding.crypto_box_seal(c, m, pk);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_box_seal_open = function(m, c, pk, sk) {
        assert(ArrayBuffer.isView(m), "m must be a typed array");
        assert(ArrayBuffer.isView(c), "c must be a typed array");
        assert(ArrayBuffer.isView(pk), "pk must be a typed array");
        assert(ArrayBuffer.isView(sk), "sk must be a typed array");
        assert(
          c.byteLength >= exports.crypto_box_SEALBYTES,
          "c must be at least 'crypto_box_SEALBYTES' bytes"
        );
        assert(
          m.byteLength === c.byteLength - exports.crypto_box_SEALBYTES,
          "m must be 'c.byteLength - crypto_box_SEALBYTES' bytes"
        );
        assert(
          pk.byteLength === exports.crypto_box_PUBLICKEYBYTES,
          "pk must be 'crypto_box_PUBLICKEYBYTES' bytes"
        );
        assert(
          sk.byteLength === exports.crypto_box_SECRETKEYBYTES,
          "sk must be 'crypto_box_SECRETKEYBYTES' bytes"
        );
        return binding.crypto_box_seal_open(
          m.buffer,
          m.byteOffset,
          m.byteLength,
          c.buffer,
          c.byteOffset,
          c.byteLength,
          pk.buffer,
          pk.byteOffset,
          pk.byteLength,
          sk.buffer,
          sk.byteOffset,
          sk.byteLength
        );
      };
      exports.crypto_secretbox_easy = function(c, m, n, k) {
        assert(ArrayBuffer.isView(c), "c must be a typed array");
        assert(ArrayBuffer.isView(m), "m must be a typed array");
        assert(ArrayBuffer.isView(n), "n must be a typed array");
        assert(ArrayBuffer.isView(k), "k must be a typed array");
        assert(
          c.byteLength === m.byteLength + binding.crypto_secretbox_MACBYTES,
          "c must be 'm.byteLength + crypto_secretbox_MACBYTES' bytes"
        );
        assert(
          n.byteLength === binding.crypto_secretbox_NONCEBYTES,
          "n must be 'crypto_secretbox_NONCEBYTES' bytes"
        );
        assert(
          k.byteLength === binding.crypto_secretbox_KEYBYTES,
          "k must be 'crypto_secretbox_KEYBYTES' bytes"
        );
        const res = binding.crypto_secretbox_easy(c, m, n, k);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_secretbox_open_easy = function(m, c, n, k) {
        assert(ArrayBuffer.isView(m), "m must be a typed array");
        assert(ArrayBuffer.isView(c), "c must be a typed array");
        assert(ArrayBuffer.isView(n), "n must be a typed array");
        assert(ArrayBuffer.isView(k), "k must be a typed array");
        assert(
          c.byteLength >= binding.crypto_secretbox_MACBYTES,
          "c must be at least 'crypto_secretbox_MACBYTES' bytes"
        );
        assert(
          m.byteLength === c.byteLength - binding.crypto_secretbox_MACBYTES,
          "m must be 'c.byteLength - crypto_secretbox_MACBYTES' bytes"
        );
        assert(
          n.byteLength === binding.crypto_secretbox_NONCEBYTES,
          "n must be 'crypto_secretbox_NONCEBYTES' bytes"
        );
        assert(
          k.byteLength === binding.crypto_secretbox_KEYBYTES,
          "k must be 'crypto_secretbox_KEYBYTES' bytes"
        );
        return binding.crypto_secretbox_open_easy(m, c, n, k);
      };
      exports.crypto_secretbox_detached = function(c, mac, m, n, k) {
        assert(ArrayBuffer.isView(c), "c must be a typed array");
        assert(ArrayBuffer.isView(mac), "mac must be a typed array");
        assert(ArrayBuffer.isView(m), "m must be a typed array");
        assert(ArrayBuffer.isView(n), "n must be a typed array");
        assert(ArrayBuffer.isView(k), "k must be a typed array");
        assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes");
        assert(
          mac.byteLength === binding.crypto_secretbox_MACBYTES,
          "mac must be 'crypto_secretbox_MACBYTES' bytes"
        );
        assert(
          n.byteLength === binding.crypto_secretbox_NONCEBYTES,
          "n must be 'crypto_secretbox_NONCEBYTES' bytes"
        );
        assert(
          k.byteLength === binding.crypto_secretbox_KEYBYTES,
          "k must be 'crypto_secretbox_KEYBYTES' bytes"
        );
        const res = binding.crypto_secretbox_detached(c, mac, m, n, k);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_secretbox_open_detached = function(m, c, mac, n, k) {
        assert(ArrayBuffer.isView(m), "m must be a typed array");
        assert(ArrayBuffer.isView(c), "c must be a typed array");
        assert(ArrayBuffer.isView(mac), "mac must be a typed array");
        assert(ArrayBuffer.isView(n), "n must be a typed array");
        assert(ArrayBuffer.isView(k), "k must be a typed array");
        assert(m.byteLength === c.byteLength, "m must be 'c.byteLength' bytes");
        assert(
          mac.byteLength === binding.crypto_secretbox_MACBYTES,
          "mac must be 'crypto_secretbox_MACBYTES' bytes"
        );
        assert(
          n.byteLength === binding.crypto_secretbox_NONCEBYTES,
          "n must be 'crypto_secretbox_NONCEBYTES' bytes"
        );
        assert(
          k.byteLength === binding.crypto_secretbox_KEYBYTES,
          "k must be 'crypto_secretbox_KEYBYTES' bytes"
        );
        return binding.crypto_secretbox_open_detached(m, c, mac, n, k);
      };
      exports.crypto_generichash = function(output, input, key) {
        if (!key) key = OPTIONAL;
        assert(ArrayBuffer.isView(output), "output must be a typed array");
        assert(ArrayBuffer.isView(input), "input must be a typed array");
        assert(
          output.byteLength >= binding.crypto_generichash_BYTES_MIN && output.byteLength <= binding.crypto_generichash_BYTES_MAX,
          "output must be between crypto_generichash_BYTES_MIN and crypto_generichash_BYTES_MAX bytes"
        );
        if (key !== OPTIONAL) {
          assert(ArrayBuffer.isView(key), "key must be a typed array");
          assert(
            key.byteLength >= binding.crypto_generichash_KEYBYTES_MIN && key.byteLength <= binding.crypto_generichash_KEYBYTES_MAX,
            "key must be between crypto_generichash_KEYBYTES_MIN and crypto_generichash_KEYBYTES_MAX bytes"
          );
        }
        const res = binding.crypto_generichash(
          output.buffer,
          output.byteOffset,
          output.byteLength,
          input.buffer,
          input.byteOffset,
          input.byteLength,
          key.buffer,
          key.byteOffset,
          key.byteLength
        );
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_generichash_batch = function(output, batch, key) {
        assert(ArrayBuffer.isView(output), "output must be a typed array");
        if (isNode || batch.length < 4) {
          const res = binding.crypto_generichash_batch(output, batch, !!key, key || OPTIONAL);
          if (res !== 0) throw new Error("status: " + res);
        } else {
          const state = Buffer.alloc(binding.crypto_generichash_STATEBYTES);
          exports.crypto_generichash_init(state, key, output.byteLength);
          for (const buf of batch) {
            exports.crypto_generichash_update(state, buf);
          }
          exports.crypto_generichash_final(state, output);
        }
      };
      exports.crypto_generichash_keygen = function(key) {
        assert(ArrayBuffer.isView(key), "key must be a typed array");
        assert(
          key.byteLength === binding.crypto_generichash_KEYBYTES,
          "key must be 'crypto_generichash_KEYBYTES' bytes"
        );
        const res = binding.crypto_generichash_keygen(key.buffer, key.byteOffset, key.byteLength);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_generichash_init = function(state, key, outputLength) {
        if (!key) key = OPTIONAL;
        assert(ArrayBuffer.isView(state), "state must be a typed array");
        assert(
          state.byteLength === binding.crypto_generichash_STATEBYTES,
          "state must be 'crypto_generichash_STATEBYTES' bytes"
        );
        const res = binding.crypto_generichash_init(
          state.buffer,
          state.byteOffset,
          state.byteLength,
          key.buffer,
          key.byteOffset,
          key.byteLength,
          outputLength
        );
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_generichash_update = function(state, input) {
        assert(ArrayBuffer.isView(state), "state must be a typed array");
        assert(ArrayBuffer.isView(input), "input must be a typed array");
        assert(
          state.byteLength === binding.crypto_generichash_STATEBYTES,
          "state must be 'crypto_generichash_STATEBYTES' bytes"
        );
        const res = binding.crypto_generichash_update(
          state.buffer,
          state.byteOffset,
          state.byteLength,
          input.buffer,
          input.byteOffset,
          input.byteLength
        );
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_generichash_final = function(state, output) {
        assert(ArrayBuffer.isView(state), "state must be a typed array");
        assert(ArrayBuffer.isView(output), "output must be a typed array");
        assert(
          state.byteLength === binding.crypto_generichash_STATEBYTES,
          "state must be 'crypto_generichash_STATEBYTES' bytes"
        );
        const res = binding.crypto_generichash_final(
          state.buffer,
          state.byteOffset,
          state.byteLength,
          output.buffer,
          output.byteOffset,
          output.byteLength
        );
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_secretstream_xchacha20poly1305_keygen = function(k) {
        assert(ArrayBuffer.isView(k), "k must be a typed array");
        assert(
          k.byteLength === binding.crypto_secretstream_xchacha20poly1305_KEYBYTES,
          "k must be 'crypto_secretstream_xchacha20poly1305_KEYBYTES' bytes"
        );
        binding.crypto_secretstream_xchacha20poly1305_keygen(k.buffer, k.byteOffset, k.byteLength);
      };
      exports.crypto_secretstream_xchacha20poly1305_init_push = function(state, header, k) {
        assert(ArrayBuffer.isView(state), "state must be a typed array");
        assert(ArrayBuffer.isView(header), "header must be a typed array");
        assert(ArrayBuffer.isView(k), "k must be a typed array");
        assert(
          state.byteLength === binding.crypto_secretstream_xchacha20poly1305_STATEBYTES,
          "state must be 'crypto_secretstream_xchacha20poly1305_STATEBYTES' bytes"
        );
        assert(
          header.byteLength === binding.crypto_secretstream_xchacha20poly1305_HEADERBYTES,
          "header must be 'crypto_secretstream_xchacha20poly1305_HEADERBYTES' bytes"
        );
        assert(
          k.byteLength === binding.crypto_secretstream_xchacha20poly1305_KEYBYTES,
          "k must be 'crypto_secretstream_xchacha20poly1305_KEYBYTES' bytes"
        );
        const res = binding.crypto_secretstream_xchacha20poly1305_init_push(
          state.buffer,
          state.byteOffset,
          state.byteLength,
          header.buffer,
          header.byteOffset,
          header.byteLength,
          k.buffer,
          k.byteOffset,
          k.byteLength
        );
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_secretstream_xchacha20poly1305_init_pull = function(state, header, k) {
        assert(ArrayBuffer.isView(state), "state must be a typed array");
        assert(ArrayBuffer.isView(header), "header must be a typed array");
        assert(ArrayBuffer.isView(k), "k must be a typed array");
        assert(
          state.byteLength === binding.crypto_secretstream_xchacha20poly1305_STATEBYTES,
          "state must be 'crypto_secretstream_xchacha20poly1305_STATEBYTES' bytes"
        );
        assert(
          header.byteLength === binding.crypto_secretstream_xchacha20poly1305_HEADERBYTES,
          "header must be 'crypto_secretstream_xchacha20poly1305_HEADERBYTES' bytes"
        );
        assert(
          k.byteLength === binding.crypto_secretstream_xchacha20poly1305_KEYBYTES,
          "k must be 'crypto_secretstream_xchacha20poly1305_KEYBYTES' bytes"
        );
        const res = binding.crypto_secretstream_xchacha20poly1305_init_pull(
          state.buffer,
          state.byteOffset,
          state.byteLength,
          header.buffer,
          header.byteOffset,
          header.byteLength,
          k.buffer,
          k.byteOffset,
          k.byteLength
        );
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_secretstream_xchacha20poly1305_push = function(state, c, m, ad, tag) {
        if (!ad) ad = OPTIONAL;
        assert(ArrayBuffer.isView(state), "state must be a typed array");
        assert(ArrayBuffer.isView(c), "c must be a typed array");
        assert(ArrayBuffer.isView(m), "m must be a typed array");
        assert(
          state.byteLength === binding.crypto_secretstream_xchacha20poly1305_STATEBYTES,
          "state must be 'crypto_secretstream_xchacha20poly1305_STATEBYTES' bytes"
        );
        assert(
          c.byteLength === m.byteLength + binding.crypto_secretstream_xchacha20poly1305_ABYTES,
          "c must be 'm.byteLength + crypto_secretstream_xchacha20poly1305_ABYTES' bytes"
        );
        const res = binding.crypto_secretstream_xchacha20poly1305_push(
          state.buffer,
          state.byteOffset,
          state.byteLength,
          c.buffer,
          c.byteOffset,
          c.byteLength,
          m.buffer,
          m.byteOffset,
          m.byteLength,
          ad.buffer,
          ad.byteOffset,
          ad.byteLength,
          tag
        );
        if (res < 0) throw new Error("push failed");
        return res;
      };
      exports.crypto_secretstream_xchacha20poly1305_pull = function(state, m, tag, c, ad) {
        if (!ad) ad = OPTIONAL;
        assert(ArrayBuffer.isView(state), "state must be a typed array");
        assert(
          state.byteLength === binding.crypto_secretstream_xchacha20poly1305_STATEBYTES,
          "state must be 'crypto_secretstream_xchacha20poly1305_STATEBYTES' bytes"
        );
        assert(ArrayBuffer.isView(tag), "tag must be a typed array");
        assert(tag.byteLength === 1, "tag must be 1 byte");
        assert(ArrayBuffer.isView(c), "c must be a typed array");
        assert(
          c.byteLength >= binding.crypto_secretstream_xchacha20poly1305_ABYTES,
          "c must be at least 'crypto_secretstream_xchacha20poly1305_ABYTES' bytes"
        );
        assert(ArrayBuffer.isView(m), "m must be a typed array");
        assert(
          m.byteLength === c.byteLength - binding.crypto_secretstream_xchacha20poly1305_ABYTES,
          "m must be 'c.byteLength - crypto_secretstream_xchacha20poly1305_ABYTES' bytes"
        );
        const res = binding.crypto_secretstream_xchacha20poly1305_pull(
          state.buffer,
          state.byteOffset,
          state.byteLength,
          m.buffer,
          m.byteOffset,
          m.byteLength,
          tag.buffer,
          tag.byteOffset,
          tag.byteLength,
          c.buffer,
          c.byteOffset,
          c.byteLength,
          ad.buffer,
          ad.byteOffset,
          ad.byteLength
        );
        if (res < 0) throw new Error("pull failed");
        return res;
      };
      exports.crypto_secretstream_xchacha20poly1305_rekey = function(state) {
        assert(ArrayBuffer.isView(state), "state must be a typed array");
        assert(
          state.byteLength === binding.crypto_secretstream_xchacha20poly1305_STATEBYTES,
          "state must be 'crypto_secretstream_xchacha20poly1305_STATEBYTES' bytes"
        );
        binding.crypto_secretstream_xchacha20poly1305_rekey(
          state.buffer,
          state.byteOffset,
          state.byteLength
        );
      };
      exports.crypto_stream = function(c, n, k) {
        assert(ArrayBuffer.isView(c), "c must be a typed array");
        assert(ArrayBuffer.isView(n), "n must be a typed array");
        assert(ArrayBuffer.isView(k), "k must be a typed array");
        assert(
          n.byteLength === binding.crypto_stream_NONCEBYTES,
          "n must be 'crypto_stream_NONCEBYTES' bytes"
        );
        assert(
          k.byteLength === binding.crypto_stream_KEYBYTES,
          "k must be 'crypto_stream_KEYBYTES' bytes"
        );
        const res = binding.crypto_stream(c, n, k);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_stream_xor = function(c, m, n, k) {
        assert(ArrayBuffer.isView(c), "c must be a typed array");
        assert(ArrayBuffer.isView(m), "m must be a typed array");
        assert(ArrayBuffer.isView(n), "n must be a typed array");
        assert(ArrayBuffer.isView(k), "k must be a typed array");
        assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes");
        assert(
          n.byteLength === binding.crypto_stream_NONCEBYTES,
          "n must be 'crypto_stream_NONCEBYTES' bytes"
        );
        assert(
          k.byteLength === binding.crypto_stream_KEYBYTES,
          "k must be 'crypto_stream_KEYBYTES' bytes"
        );
        const res = binding.crypto_stream_xor(
          c.buffer,
          c.byteOffset,
          c.byteLength,
          m.buffer,
          m.byteOffset,
          m.byteLength,
          n.buffer,
          n.byteOffset,
          n.byteLength,
          k.buffer,
          k.byteOffset,
          k.byteLength
        );
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_stream_chacha20 = function(c, n, k) {
        assert(ArrayBuffer.isView(c), "c must be a typed array");
        assert(ArrayBuffer.isView(n), "n must be a typed array");
        assert(ArrayBuffer.isView(k), "k must be a typed array");
        assert(
          n.byteLength === binding.crypto_stream_chacha20_NONCEBYTES,
          "n must be 'crypto_stream_chacha20_NONCEBYTES' bytes"
        );
        assert(
          k.byteLength === binding.crypto_stream_chacha20_KEYBYTES,
          "k must be 'crypto_stream_chacha20_KEYBYTES' bytes"
        );
        const res = binding.crypto_stream_chacha20(c, n, k);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_stream_chacha20_xor = function(c, m, n, k) {
        assert(ArrayBuffer.isView(c), "c must be a typed array");
        assert(ArrayBuffer.isView(m), "m must be a typed array");
        assert(ArrayBuffer.isView(n), "n must be a typed array");
        assert(ArrayBuffer.isView(k), "k must be a typed array");
        assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes");
        assert(
          n.byteLength === binding.crypto_stream_chacha20_NONCEBYTES,
          "n must be 'crypto_stream_chacha20_NONCEBYTES' bytes"
        );
        assert(
          k.byteLength === binding.crypto_stream_chacha20_KEYBYTES,
          "k must be 'crypto_stream_chacha20_KEYBYTES' bytes"
        );
        const res = binding.crypto_stream_chacha20_xor(c, m, n, k);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_stream_chacha20_xor_ic = function(c, m, n, ic, k) {
        assert(ArrayBuffer.isView(c), "c must be a typed array");
        assert(ArrayBuffer.isView(m), "m must be a typed array");
        assert(ArrayBuffer.isView(n), "n must be a typed array");
        assert(ArrayBuffer.isView(k), "k must be a typed array");
        assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes");
        assert(
          n.byteLength === binding.crypto_stream_chacha20_NONCEBYTES,
          "n must be 'crypto_stream_chacha20_NONCEBYTES' bytes"
        );
        assert(
          k.byteLength === binding.crypto_stream_chacha20_KEYBYTES,
          "k must be 'crypto_stream_chacha20_KEYBYTES' bytes"
        );
        const res = binding.crypto_stream_chacha20_xor_ic(c, m, n, ic, k);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_stream_chacha20_ietf = function(c, n, k) {
        assert(ArrayBuffer.isView(c), "c must be a typed array");
        assert(ArrayBuffer.isView(n), "n must be a typed array");
        assert(ArrayBuffer.isView(k), "k must be a typed array");
        assert(
          n.byteLength === binding.crypto_stream_chacha20_ietf_NONCEBYTES,
          "n must be 'crypto_stream_chacha20_ietf_NONCEBYTES' bytes"
        );
        assert(
          k.byteLength === binding.crypto_stream_chacha20_ietf_KEYBYTES,
          "k must be 'crypto_stream_chacha20_ietf_KEYBYTES' bytes"
        );
        const res = binding.crypto_stream_chacha20_ietf(c, n, k);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_stream_chacha20_ietf_xor = function(c, m, n, k) {
        assert(ArrayBuffer.isView(c), "c must be a typed array");
        assert(ArrayBuffer.isView(m), "m must be a typed array");
        assert(ArrayBuffer.isView(n), "n must be a typed array");
        assert(ArrayBuffer.isView(k), "k must be a typed array");
        assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes");
        assert(
          n.byteLength === binding.crypto_stream_chacha20_ietf_NONCEBYTES,
          "n must be 'crypto_stream_chacha20_ietf_NONCEBYTES' bytes"
        );
        assert(
          k.byteLength === binding.crypto_stream_chacha20_ietf_KEYBYTES,
          "k must be 'crypto_stream_chacha20_ietf_KEYBYTES' bytes"
        );
        const res = binding.crypto_stream_chacha20_ietf_xor(c, m, n, k);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_stream_chacha20_ietf_xor_ic = function(c, m, n, ic, k) {
        assert(ArrayBuffer.isView(c), "c must be a typed array");
        assert(ArrayBuffer.isView(m), "m must be a typed array");
        assert(ArrayBuffer.isView(n), "n must be a typed array");
        assert(ArrayBuffer.isView(k), "k must be a typed array");
        assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes");
        assert(
          n.byteLength === binding.crypto_stream_chacha20_ietf_NONCEBYTES,
          "n must be 'crypto_stream_chacha20_ietf_NONCEBYTES' bytes"
        );
        assert(
          k.byteLength === binding.crypto_stream_chacha20_ietf_KEYBYTES,
          "k must be 'crypto_stream_chacha20_ietf_KEYBYTES' bytes"
        );
        const res = binding.crypto_stream_chacha20_ietf_xor_ic(c, m, n, ic, k);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_stream_xchacha20 = function(c, n, k) {
        assert(ArrayBuffer.isView(c), "c must be a typed array");
        assert(ArrayBuffer.isView(n), "n must be a typed array");
        assert(ArrayBuffer.isView(k), "k must be a typed array");
        assert(
          n.byteLength === binding.crypto_stream_xchacha20_NONCEBYTES,
          "n must be 'crypto_stream_xchacha20_NONCEBYTES' bytes"
        );
        assert(
          k.byteLength === binding.crypto_stream_xchacha20_KEYBYTES,
          "k must be 'crypto_stream_xchacha20_KEYBYTES' bytes"
        );
        const res = binding.crypto_stream_xchacha20(c, n, k);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_stream_xchacha20_xor = function(c, m, n, k) {
        assert(ArrayBuffer.isView(c), "c must be a typed array");
        assert(ArrayBuffer.isView(m), "m must be a typed array");
        assert(ArrayBuffer.isView(n), "n must be a typed array");
        assert(ArrayBuffer.isView(k), "k must be a typed array");
        assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes");
        assert(
          n.byteLength === binding.crypto_stream_xchacha20_NONCEBYTES,
          "n must be 'crypto_stream_xchacha20_NONCEBYTES' bytes"
        );
        assert(
          k.byteLength === binding.crypto_stream_xchacha20_KEYBYTES,
          "k must be 'crypto_stream_xchacha20_KEYBYTES' bytes"
        );
        const res = binding.crypto_stream_xchacha20_xor(c, m, n, k);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_stream_xchacha20_xor_ic = function(c, m, n, ic, k) {
        assert(ArrayBuffer.isView(c), "c must be a typed array");
        assert(ArrayBuffer.isView(m), "m must be a typed array");
        assert(ArrayBuffer.isView(n), "n must be a typed array");
        assert(ArrayBuffer.isView(k), "k must be a typed array");
        assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes");
        assert(
          n.byteLength === binding.crypto_stream_xchacha20_NONCEBYTES,
          "n must be 'crypto_stream_xchacha20_NONCEBYTES' bytes"
        );
        assert(
          k.byteLength === binding.crypto_stream_xchacha20_KEYBYTES,
          "k must be 'crypto_stream_xchacha20_KEYBYTES' bytes"
        );
        const res = binding.crypto_stream_xchacha20_xor_ic(c, m, n, ic, k);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_stream_salsa20 = function(c, n, k) {
        assert(ArrayBuffer.isView(c), "c must be a typed array");
        assert(ArrayBuffer.isView(n), "n must be a typed array");
        assert(ArrayBuffer.isView(k), "k must be a typed array");
        assert(
          n.byteLength === binding.crypto_stream_salsa20_NONCEBYTES,
          "n must be 'crypto_stream_salsa20_NONCEBYTES' bytes"
        );
        assert(
          k.byteLength === binding.crypto_stream_salsa20_KEYBYTES,
          "k must be 'crypto_stream_salsa20_KEYBYTES' bytes"
        );
        const res = binding.crypto_stream_salsa20(c, n, k);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_stream_salsa20_xor = function(c, m, n, k) {
        assert(ArrayBuffer.isView(c), "c must be a typed array");
        assert(ArrayBuffer.isView(m), "m must be a typed array");
        assert(ArrayBuffer.isView(n), "n must be a typed array");
        assert(ArrayBuffer.isView(k), "k must be a typed array");
        assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes");
        assert(
          n.byteLength === binding.crypto_stream_salsa20_NONCEBYTES,
          "n must be 'crypto_stream_salsa20_NONCEBYTES' bytes"
        );
        assert(
          k.byteLength === binding.crypto_stream_salsa20_KEYBYTES,
          "k must be 'crypto_stream_salsa20_KEYBYTES' bytes"
        );
        const res = binding.crypto_stream_salsa20_xor(c, m, n, k);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_stream_salsa20_xor_ic = function(c, m, n, ic, k) {
        assert(ArrayBuffer.isView(c), "c must be a typed array");
        assert(ArrayBuffer.isView(m), "m must be a typed array");
        assert(ArrayBuffer.isView(n), "n must be a typed array");
        assert(ArrayBuffer.isView(k), "k must be a typed array");
        assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes");
        assert(
          n.byteLength === binding.crypto_stream_salsa20_NONCEBYTES,
          "n must be 'crypto_stream_salsa20_NONCEBYTES' bytes"
        );
        assert(
          k.byteLength === binding.crypto_stream_salsa20_KEYBYTES,
          "k must be 'crypto_stream_salsa20_KEYBYTES' bytes"
        );
        const res = binding.crypto_stream_salsa20_xor_ic(c, m, n, ic, k);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_auth = function(out, input, k) {
        assert(ArrayBuffer.isView(out), "out must be a typed array");
        assert(ArrayBuffer.isView(input), "input must be a typed array");
        assert(ArrayBuffer.isView(k), "k must be a typed array");
        assert(out.byteLength === binding.crypto_auth_BYTES, "out must be 'crypto_auth_BYTES' bytes");
        assert(k.byteLength === binding.crypto_auth_KEYBYTES, "k must be 'crypto_auth_KEYBYTES' bytes");
        const res = binding.crypto_auth(out, input, k);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_auth_verify = function(h, input, k) {
        assert(ArrayBuffer.isView(h), "h must be a typed array");
        assert(ArrayBuffer.isView(input), "input must be a typed array");
        assert(ArrayBuffer.isView(k), "k must be a typed array");
        assert(h.byteLength === binding.crypto_auth_BYTES, "h must be 'crypto_auth_BYTES' bytes");
        assert(k.byteLength === binding.crypto_auth_KEYBYTES, "k must be 'crypto_auth_KEYBYTES' bytes");
        return binding.crypto_auth_verify(h, input, k);
      };
      exports.crypto_onetimeauth = function(out, input, k) {
        assert(ArrayBuffer.isView(out), "out must be a typed array");
        assert(ArrayBuffer.isView(input), "input must be a typed array");
        assert(ArrayBuffer.isView(k), "k must be a typed array");
        assert(
          out.byteLength === binding.crypto_onetimeauth_BYTES,
          "out must be 'crypto_onetimeauth_BYTES' bytes"
        );
        assert(
          k.byteLength === binding.crypto_onetimeauth_KEYBYTES,
          "k must be 'crypto_onetimeauth_KEYBYTES' bytes"
        );
        const res = binding.crypto_onetimeauth(out, input, k);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_onetimeauth_init = function(state, k) {
        assert(ArrayBuffer.isView(state), "state must be a typed array");
        assert(ArrayBuffer.isView(k), "k must be a typed array");
        assert(
          state.byteLength === binding.crypto_onetimeauth_STATEBYTES,
          "state must be 'crypto_onetimeauth_STATEBYTES' bytes"
        );
        assert(
          k.byteLength === binding.crypto_onetimeauth_KEYBYTES,
          "k must be 'crypto_onetimeauth_KEYBYTES' bytes"
        );
        const res = binding.crypto_onetimeauth_init(state, k);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_onetimeauth_update = function(state, input) {
        assert(ArrayBuffer.isView(state), "state must be a typed array");
        assert(ArrayBuffer.isView(input), "input must be a typed array");
        assert(
          state.byteLength === binding.crypto_onetimeauth_STATEBYTES,
          "state must be 'crypto_onetimeauth_STATEBYTES' bytes"
        );
        const res = binding.crypto_onetimeauth_update(state, input);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_onetimeauth_final = function(state, out) {
        assert(ArrayBuffer.isView(state), "state must be a typed array");
        assert(ArrayBuffer.isView(out), "out must be a typed array");
        assert(
          state.byteLength === binding.crypto_onetimeauth_STATEBYTES,
          "state must be 'crypto_onetimeauth_STATEBYTES' bytes"
        );
        assert(
          out.byteLength === binding.crypto_onetimeauth_BYTES,
          "out must be 'crypto_onetimeauth_BYTES' bytes"
        );
        const res = binding.crypto_onetimeauth_final(state, out);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_onetimeauth_verify = function(h, input, k) {
        assert(ArrayBuffer.isView(h), "h must be a typed array");
        assert(ArrayBuffer.isView(input), "input must be a typed array");
        assert(ArrayBuffer.isView(k), "k must be a typed array");
        assert(
          h.byteLength === binding.crypto_onetimeauth_BYTES,
          "h must be 'crypto_onetimeauth_BYTES' bytes"
        );
        assert(
          k.byteLength === binding.crypto_onetimeauth_KEYBYTES,
          "k must be 'crypto_onetimeauth_KEYBYTES' bytes"
        );
        return binding.crypto_onetimeauth_verify(h, input, k);
      };
      exports.crypto_pwhash = function(out, passwd, salt, opslimit, memlimit, alg) {
        assert(ArrayBuffer.isView(out), "out must be a typed array");
        assert(ArrayBuffer.isView(passwd), "passwd must be a typed array");
        assert(ArrayBuffer.isView(salt), "salt must be a typed array");
        assert(
          out.byteLength >= binding.crypto_pwhash_BYTES_MIN,
          "out must be at least 'crypto_pwhash_BYTES_MIN' bytes"
        );
        assert(
          out.byteLength <= binding.crypto_pwhash_BYTES_MAX,
          "out must be at most 'crypto_pwhash_BYTES_MAX' bytes"
        );
        assert(
          salt.byteLength === binding.crypto_pwhash_SALTBYTES,
          "salt must be 'crypto_pwhash_SALTBYTES' bytes"
        );
        assert(
          opslimit >= binding.crypto_pwhash_OPSLIMIT_MIN,
          "opslimit must be at least 'crypto_pwhash_OPSLIMIT_MIN'"
        );
        assert(
          opslimit <= binding.crypto_pwhash_OPSLIMIT_MAX,
          "opslimit must be at most 'crypto_pwhash_OPSLIMIT_MAX'"
        );
        assert(
          memlimit >= binding.crypto_pwhash_MEMLIMIT_MIN,
          "memlimit must be at least 'crypto_pwhash_MEMLIMIT_MIN'"
        );
        assert(
          memlimit <= binding.crypto_pwhash_MEMLIMIT_MAX,
          "memlimit must be at most 'crypto_pwhash_MEMLIMIT_MAX'"
        );
        assert(alg >= 1 && alg <= 2, "alg must be either Argon2i 1.3 or Argon2id 1.3");
        const res = binding.crypto_pwhash(out, passwd, salt, opslimit, memlimit, alg);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_pwhash_async = function(out, passwd, salt, opslimit, memlimit, alg, callback = void 0) {
        assert(ArrayBuffer.isView(out), "out must be a typed array");
        assert(ArrayBuffer.isView(passwd), "passwd must be a typed array");
        assert(ArrayBuffer.isView(salt), "salt must be a typed array");
        assert(
          out.byteLength >= binding.crypto_pwhash_BYTES_MIN,
          "out must be at least 'crypto_pwhash_BYTES_MIN' bytes"
        );
        assert(
          out.byteLength <= binding.crypto_pwhash_BYTES_MAX,
          "out must be at most 'crypto_pwhash_BYTES_MAX' bytes"
        );
        assert(
          salt.byteLength === binding.crypto_pwhash_SALTBYTES,
          "salt must be 'crypto_pwhash_SALTBYTES' bytes"
        );
        assert(
          opslimit >= binding.crypto_pwhash_OPSLIMIT_MIN,
          "opslimit must be at least 'crypto_pwhash_OPSLIMIT_MIN'"
        );
        assert(
          opslimit <= binding.crypto_pwhash_OPSLIMIT_MAX,
          "opslimit must be at most 'crypto_pwhash_OPSLIMIT_MAX'"
        );
        assert(
          memlimit >= binding.crypto_pwhash_MEMLIMIT_MIN,
          "memlimit must be at least 'crypto_pwhash_MEMLIMIT_MIN'"
        );
        assert(
          memlimit <= binding.crypto_pwhash_MEMLIMIT_MAX,
          "memlimit must be at most 'crypto_pwhash_MEMLIMIT_MAX'"
        );
        assert(alg >= 1 && alg <= 2, "alg must be either Argon2i 1.3 or Argon2id 1.3");
        const [done, promise] = checkStatus(callback);
        binding.crypto_pwhash_async(
          out.buffer,
          out.byteOffset,
          out.byteLength,
          passwd.buffer,
          passwd.byteOffset,
          passwd.byteLength,
          salt.buffer,
          salt.byteOffset,
          salt.byteLength,
          opslimit,
          memlimit,
          alg,
          done
        );
        return promise;
      };
      exports.crypto_pwhash_str = function(out, passwd, opslimit, memlimit) {
        assert(ArrayBuffer.isView(out), "out must be a typed array");
        assert(ArrayBuffer.isView(passwd), "passwd must be a typed array");
        assert(
          out.byteLength === binding.crypto_pwhash_STRBYTES,
          "out must be 'crypto_pwhash_STRBYTES' bytes"
        );
        assert(typeof opslimit === "number", "opslimit must be a number");
        assert(
          opslimit >= binding.crypto_pwhash_OPSLIMIT_MIN,
          "opslimit must be at least 'crypto_pwhash_OPSLIMIT_MIN'"
        );
        assert(
          opslimit <= binding.crypto_pwhash_OPSLIMIT_MAX,
          "opslimit must be at most 'crypto_pwhash_OPSLIMIT_MAX'"
        );
        assert(typeof memlimit === "number", "memlimit must be a number");
        assert(
          memlimit >= binding.crypto_pwhash_MEMLIMIT_MIN,
          "memlimit must be at least 'crypto_pwhash_MEMLIMIT_MIN'"
        );
        assert(
          memlimit <= binding.crypto_pwhash_MEMLIMIT_MAX,
          "memlimit must be at most 'crypto_pwhash_MEMLIMIT_MAX'"
        );
        const res = binding.crypto_pwhash_str(out, passwd, opslimit, memlimit);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_pwhash_str_async = function(out, passwd, opslimit, memlimit, callback = void 0) {
        assert(ArrayBuffer.isView(out), "out must be a typed array");
        assert(ArrayBuffer.isView(passwd), "passwd must be a typed array");
        assert(
          out.byteLength === binding.crypto_pwhash_STRBYTES,
          "out must be 'crypto_pwhash_STRBYTES' bytes"
        );
        assert(passwd.byteLength > 0, "passwd must not be empty");
        assert(typeof opslimit === "number", "opslimit must be a number");
        assert(
          opslimit >= binding.crypto_pwhash_OPSLIMIT_MIN,
          "opslimit must be at least 'crypto_pwhash_OPSLIMIT_MIN'"
        );
        assert(
          opslimit <= binding.crypto_pwhash_OPSLIMIT_MAX,
          "opslimit must be at most 'crypto_pwhash_OPSLIMIT_MAX'"
        );
        assert(typeof memlimit === "number", "memlimit must be a number");
        assert(
          memlimit >= binding.crypto_pwhash_MEMLIMIT_MIN,
          "memlimit must be at least 'crypto_pwhash_MEMLIMIT_MIN'"
        );
        assert(
          memlimit <= binding.crypto_pwhash_MEMLIMIT_MAX,
          "memlimit must be at most 'crypto_pwhash_MEMLIMIT_MAX'"
        );
        const [done, promise] = checkStatus(callback);
        binding.crypto_pwhash_str_async(
          out.buffer,
          out.byteOffset,
          out.byteLength,
          passwd.buffer,
          passwd.byteOffset,
          passwd.byteLength,
          opslimit,
          memlimit,
          done
        );
        return promise;
      };
      exports.crypto_pwhash_str_verify = function(str, passwd) {
        assert(ArrayBuffer.isView(str), "str must be a typed array");
        assert(ArrayBuffer.isView(passwd), "passwd must be a typed array");
        assert(
          str.byteLength === binding.crypto_pwhash_STRBYTES,
          "str must be 'crypto_pwhash_STRBYTES' bytes"
        );
        return binding.crypto_pwhash_str_verify(str, passwd);
      };
      exports.crypto_pwhash_str_verify_async = function(str, passwd, callback = void 0) {
        assert(ArrayBuffer.isView(str), "str must be a typed array");
        assert(ArrayBuffer.isView(passwd), "passwd must be a typed array");
        assert(
          str.byteLength === binding.crypto_pwhash_STRBYTES,
          "str must be 'crypto_pwhash_STRBYTES' bytes"
        );
        assert(passwd.byteLength > 0, "passwd must not be empty");
        const [done, promise] = checkStatus(callback, true);
        binding.crypto_pwhash_str_verify_async(
          str.buffer,
          str.byteOffset,
          str.byteLength,
          passwd.buffer,
          passwd.byteOffset,
          passwd.byteLength,
          done
        );
        return promise;
      };
      exports.crypto_pwhash_str_needs_rehash = function(str, opslimit, memlimit) {
        assert(ArrayBuffer.isView(str), "str must be a typed array");
        assert(
          str.byteLength === binding.crypto_pwhash_STRBYTES,
          "str must be 'crypto_pwhash_STRBYTES' bytes"
        );
        assert(
          opslimit >= binding.crypto_pwhash_OPSLIMIT_MIN,
          "opslimit must be at least 'crypto_pwhash_OPSLIMIT_MIN'"
        );
        assert(
          opslimit <= binding.crypto_pwhash_OPSLIMIT_MAX,
          "opslimit must be at most 'crypto_pwhash_OPSLIMIT_MAX'"
        );
        assert(
          memlimit >= binding.crypto_pwhash_MEMLIMIT_MIN,
          "memlimit must be at least 'crypto_pwhash_MEMLIMIT_MIN'"
        );
        assert(
          memlimit <= binding.crypto_pwhash_MEMLIMIT_MAX,
          "memlimit must be at most 'crypto_pwhash_MEMLIMIT_MAX'"
        );
        return binding.crypto_pwhash_str_needs_rehash(str, opslimit, memlimit);
      };
      exports.crypto_pwhash_scryptsalsa208sha256 = function(out, passwd, salt, opslimit, memlimit) {
        assert(ArrayBuffer.isView(out), "out must be a typed array");
        assert(ArrayBuffer.isView(passwd), "passwd must be a typed array");
        assert(ArrayBuffer.isView(salt), "salt must be a typed array");
        assert(
          out.byteLength >= binding.crypto_pwhash_scryptsalsa208sha256_BYTES_MIN,
          "out must be at least 'crypto_pwhash_scryptsalsa208sha256_BYTES_MIN' bytes"
        );
        assert(
          out.byteLength <= binding.crypto_pwhash_scryptsalsa208sha256_BYTES_MAX,
          "out must be at most 'crypto_pwhash_scryptsalsa208sha256_BYTES_MAX' bytes"
        );
        assert(
          salt.byteLength === binding.crypto_pwhash_scryptsalsa208sha256_SALTBYTES,
          "salt must be 'crypto_pwhash_scryptsalsa208sha256_SALTBYTES' bytes"
        );
        assert(
          opslimit >= binding.crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN,
          "opslimit must be at least 'crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN'"
        );
        assert(
          opslimit <= binding.crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX,
          "opslimit must be at most 'crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX'"
        );
        assert(
          memlimit >= binding.crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN,
          "memlimit must be at least 'crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN'"
        );
        assert(
          memlimit <= binding.crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX,
          "memlimit must be at most 'crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX'"
        );
        const res = binding.crypto_pwhash_scryptsalsa208sha256(out, passwd, salt, opslimit, memlimit);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_pwhash_scryptsalsa208sha256_async = function(out, passwd, salt, opslimit, memlimit, callback = void 0) {
        assert(ArrayBuffer.isView(out), "out must be a typed array");
        assert(ArrayBuffer.isView(passwd), "passwd must be a typed array");
        assert(ArrayBuffer.isView(salt), "salt must be a typed array");
        assert(
          out.byteLength >= binding.crypto_pwhash_scryptsalsa208sha256_BYTES_MIN,
          "out must be at least 'crypto_pwhash_scryptsalsa208sha256_BYTES_MIN' bytes"
        );
        assert(
          out.byteLength <= binding.crypto_pwhash_scryptsalsa208sha256_BYTES_MAX,
          "out must be at most 'crypto_pwhash_scryptsalsa208sha256_BYTES_MAX' bytes"
        );
        assert(passwd.byteLength > 0, "passwd must not be empty");
        assert(
          salt.byteLength === binding.crypto_pwhash_scryptsalsa208sha256_SALTBYTES,
          "salt must be 'crypto_pwhash_scryptsalsa208sha256_SALTBYTES' bytes"
        );
        assert(
          opslimit >= binding.crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN,
          "opslimit must be at least 'crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN'"
        );
        assert(
          opslimit <= binding.crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX,
          "opslimit must be at most 'crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX'"
        );
        assert(
          memlimit >= binding.crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN,
          "memlimit must be at least 'crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN'"
        );
        assert(
          memlimit <= binding.crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX,
          "memlimit must be at most 'crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX'"
        );
        const [done, promise] = checkStatus(callback);
        binding.crypto_pwhash_scryptsalsa208sha256_async(
          out.buffer,
          out.byteOffset,
          out.byteLength,
          passwd.buffer,
          passwd.byteOffset,
          passwd.byteLength,
          salt.buffer,
          salt.byteOffset,
          salt.byteLength,
          opslimit,
          memlimit,
          done
        );
        return promise;
      };
      exports.crypto_pwhash_scryptsalsa208sha256_str_async = function(out, passwd, opslimit, memlimit, callback = void 0) {
        assert(ArrayBuffer.isView(out), "out must be a typed array");
        assert(ArrayBuffer.isView(passwd), "passwd must be a typed array");
        assert(
          out.byteLength === binding.crypto_pwhash_scryptsalsa208sha256_STRBYTES,
          "out must be 'crypto_pwhash_scryptsalsa208sha256_STRBYTES' bytes"
        );
        assert(passwd.byteLength > 0, "passwd must not be empty");
        assert(
          opslimit >= binding.crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN,
          "opslimit must be at least 'crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN'"
        );
        assert(
          opslimit <= binding.crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX,
          "opslimit must be at most 'crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX'"
        );
        assert(
          memlimit >= binding.crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN,
          "memlimit must be at least 'crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN'"
        );
        assert(
          memlimit <= binding.crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX,
          "memlimit must be at most 'crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX'"
        );
        const [done, promise] = checkStatus(callback);
        binding.crypto_pwhash_scryptsalsa208sha256_str_async(
          out.buffer,
          out.byteOffset,
          out.byteLength,
          passwd.buffer,
          passwd.byteOffset,
          passwd.byteLength,
          opslimit,
          memlimit,
          done
        );
        return promise;
      };
      exports.crypto_pwhash_scryptsalsa208sha256_str = function(out, passwd, opslimit, memlimit) {
        assert(ArrayBuffer.isView(out), "out must be a typed array");
        assert(ArrayBuffer.isView(passwd), "passwd must be a typed array");
        assert(
          out.byteLength === binding.crypto_pwhash_scryptsalsa208sha256_STRBYTES,
          "out must be 'crypto_pwhash_scryptsalsa208sha256_STRBYTES' bytes"
        );
        assert(passwd.byteLength > 0, "passwd must not be empty");
        assert(
          opslimit >= binding.crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN,
          "opslimit must be at least 'crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN'"
        );
        assert(
          opslimit <= binding.crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX,
          "opslimit must be at most 'crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX'"
        );
        assert(
          memlimit >= binding.crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN,
          "memlimit must be at least 'crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN'"
        );
        assert(
          memlimit <= binding.crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX,
          "memlimit must be at most 'crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX'"
        );
        const res = binding.crypto_pwhash_scryptsalsa208sha256_str(out, passwd, opslimit, memlimit);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_pwhash_scryptsalsa208sha256_str_verify_async = function(str, passwd, callback = void 0) {
        assert(ArrayBuffer.isView(str), "str must be a typed array");
        assert(ArrayBuffer.isView(passwd), "passwd must be a typed array");
        assert(
          str.byteLength === binding.crypto_pwhash_scryptsalsa208sha256_STRBYTES,
          "str must be 'crypto_pwhash_scryptsalsa208sha256_STRBYTES' bytes"
        );
        assert(passwd.byteLength > 0, "passwd must not be empty");
        const [done, promise] = checkStatus(callback, true);
        binding.crypto_pwhash_scryptsalsa208sha256_str_verify_async(
          str.buffer,
          str.byteOffset,
          str.byteLength,
          passwd.buffer,
          passwd.byteOffset,
          passwd.byteLength,
          done
        );
        return promise;
      };
      exports.crypto_pwhash_scryptsalsa208sha256_str_verify = function(str, passwd) {
        assert(ArrayBuffer.isView(str), "str must be a typed array");
        assert(ArrayBuffer.isView(passwd), "passwd must be a typed array");
        assert(
          str.byteLength === binding.crypto_pwhash_scryptsalsa208sha256_STRBYTES,
          "str must be 'crypto_pwhash_scryptsalsa208sha256_STRBYTES' bytes"
        );
        assert(passwd.byteLength > 0, "passwd must not be empty");
        return binding.crypto_pwhash_scryptsalsa208sha256_str_verify(str, passwd);
      };
      exports.crypto_pwhash_scryptsalsa208sha256_str_needs_rehash = function(str, opslimit, memlimit) {
        assert(ArrayBuffer.isView(str), "str must be a typed array");
        assert(
          str.byteLength === binding.crypto_pwhash_scryptsalsa208sha256_STRBYTES,
          "str must be 'crypto_pwhash_scryptsalsa208sha256_STRBYTES' bytes"
        );
        assert(
          opslimit >= binding.crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN,
          "opslimit must be at least 'crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN'"
        );
        assert(
          opslimit <= binding.crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX,
          "opslimit must be at most 'crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX'"
        );
        assert(
          memlimit >= binding.crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN,
          "memlimit must be at least 'crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN'"
        );
        assert(
          memlimit <= binding.crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX,
          "memlimit must be at most 'crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX'"
        );
        return binding.crypto_pwhash_scryptsalsa208sha256_str_needs_rehash(str, opslimit, memlimit);
      };
      exports.crypto_kx_keypair = function(pk, sk) {
        assert(ArrayBuffer.isView(pk), "pk must be a typed array");
        assert(ArrayBuffer.isView(sk), "sk must be a typed array");
        assert(
          pk.byteLength === binding.crypto_kx_PUBLICKEYBYTES,
          "pk must be 'crypto_kx_PUBLICKEYBYTES' bytes"
        );
        assert(
          sk.byteLength === binding.crypto_kx_SECRETKEYBYTES,
          "sk must be 'crypto_kx_SECRETKEYBYTES' bytes"
        );
        const res = binding.crypto_kx_keypair(pk, sk);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_kx_seed_keypair = function(pk, sk, seed) {
        assert(ArrayBuffer.isView(pk), "pk must be a typed array");
        assert(ArrayBuffer.isView(sk), "sk must be a typed array");
        assert(ArrayBuffer.isView(seed), "seed must be a typed array");
        assert(
          pk.byteLength === binding.crypto_kx_PUBLICKEYBYTES,
          "pk must be 'crypto_kx_PUBLICKEYBYTES' bytes"
        );
        assert(
          sk.byteLength === binding.crypto_kx_SECRETKEYBYTES,
          "sk must be 'crypto_kx_SECRETKEYBYTES' bytes"
        );
        assert(
          seed.byteLength === binding.crypto_kx_SEEDBYTES,
          "seed must be 'crypto_kx_SEEDBYTES' bytes"
        );
        const res = binding.crypto_kx_seed_keypair(pk, sk, seed);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_kx_client_session_keys = function(rx, tx, clientPk, clientSk, serverPk) {
        if (!rx) rx = void 0;
        if (!tx) tx = void 0;
        assert(rx || tx, "at least one session key must be specified");
        if (rx) {
          assert(ArrayBuffer.isView(rx), "rx must be a typed array");
          assert(
            rx.byteLength === binding.crypto_kx_SESSIONKEYBYTES,
            "rx must be 'crypto_kx_SESSIONKEYBYTES' bytes"
          );
        }
        if (tx) {
          assert(ArrayBuffer.isView(tx), "tx must be a typed array");
          assert(
            tx.byteLength === binding.crypto_kx_SESSIONKEYBYTES,
            "tx must be 'crypto_kx_SESSIONKEYBYTES' bytes"
          );
        }
        assert(ArrayBuffer.isView(clientPk), "clientPk must be a typed array");
        assert(ArrayBuffer.isView(clientSk), "clientSk must be a typed array");
        assert(ArrayBuffer.isView(serverPk), "serverPk must be a typed array");
        assert(
          clientPk.byteLength === binding.crypto_kx_PUBLICKEYBYTES,
          "clientPk must be 'crypto_kx_PUBLICKEYBYTES' bytes"
        );
        assert(
          clientSk.byteLength === binding.crypto_kx_SECRETKEYBYTES,
          "clientSk must be 'crypto_kx_SECRETKEYBYTES' bytes"
        );
        assert(
          serverPk.byteLength === binding.crypto_kx_PUBLICKEYBYTES,
          "serverPk must be 'crypto_kx_PUBLICKEYBYTES' bytes"
        );
        const res = binding.crypto_kx_client_session_keys(rx, tx, clientPk, clientSk, serverPk);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_kx_server_session_keys = function(rx, tx, serverPk, serverSk, clientPk) {
        if (!rx) rx = void 0;
        if (!tx) tx = void 0;
        assert(rx || tx, "at least one session key must be specified");
        if (rx) {
          assert(ArrayBuffer.isView(rx), "rx must be a typed array");
          assert(
            rx.byteLength === binding.crypto_kx_SESSIONKEYBYTES,
            "rx must be 'crypto_kx_SESSIONKEYBYTES' bytes"
          );
        }
        if (tx) {
          assert(ArrayBuffer.isView(tx), "tx must be a typed array");
          assert(
            tx.byteLength === binding.crypto_kx_SESSIONKEYBYTES,
            "tx must be 'crypto_kx_SESSIONKEYBYTES' bytes"
          );
        }
        assert(ArrayBuffer.isView(serverPk), "serverPk must be a typed array");
        assert(ArrayBuffer.isView(serverSk), "serverSk must be a typed array");
        assert(ArrayBuffer.isView(clientPk), "clientPk must be a typed array");
        assert(
          serverPk.byteLength === binding.crypto_kx_PUBLICKEYBYTES,
          "serverPk must be 'crypto_kx_PUBLICKEYBYTES' bytes"
        );
        assert(
          serverSk.byteLength === binding.crypto_kx_SECRETKEYBYTES,
          "serverSk must be 'crypto_kx_SECRETKEYBYTES' bytes"
        );
        assert(
          clientPk.byteLength === binding.crypto_kx_PUBLICKEYBYTES,
          "clientPk must be 'crypto_kx_PUBLICKEYBYTES' bytes"
        );
        const res = binding.crypto_kx_server_session_keys(rx, tx, serverPk, serverSk, clientPk);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_scalarmult_base = function(q, n) {
        assert(ArrayBuffer.isView(q), "q must be a typed array");
        assert(
          q.byteLength === binding.crypto_scalarmult_BYTES,
          "q must be 'crypto_scalarmult_BYTES' bytes"
        );
        assert(ArrayBuffer.isView(n), "n must be a typed array");
        assert(
          n.byteLength === binding.crypto_scalarmult_SCALARBYTES,
          "n must be 'crypto_scalarmult_SCALARBYTES' bytes"
        );
        const res = binding.crypto_scalarmult_base(q, n);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_scalarmult = function(q, n, p) {
        assert(ArrayBuffer.isView(q), "q must be a typed array");
        assert(
          q.byteLength === binding.crypto_scalarmult_BYTES,
          "q must be 'crypto_scalarmult_BYTES' bytes"
        );
        assert(ArrayBuffer.isView(n), "n must be a typed array");
        assert(
          n.byteLength === binding.crypto_scalarmult_SCALARBYTES,
          "n must be 'crypto_scalarmult_SCALARBYTES' bytes"
        );
        assert(ArrayBuffer.isView(p), "p must be a typed array");
        assert(
          p.byteLength === binding.crypto_scalarmult_BYTES,
          "p must be 'crypto_scalarmult_BYTES' bytes"
        );
        const res = binding.crypto_scalarmult(q, n, p);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_scalarmult_ed25519_base = function(q, n) {
        assert(ArrayBuffer.isView(q), "q must be a typed array");
        assert(
          q.byteLength === binding.crypto_scalarmult_ed25519_BYTES,
          "q must be 'crypto_scalarmult_ed25519_BYTES' bytes"
        );
        assert(ArrayBuffer.isView(n), "n must be a typed array");
        assert(
          n.byteLength === binding.crypto_scalarmult_ed25519_SCALARBYTES,
          "n must be 'crypto_scalarmult_ed25519_SCALARBYTES' bytes"
        );
        const res = binding.crypto_scalarmult_ed25519_base(q, n);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_scalarmult_ed25519 = function(q, n, p) {
        assert(ArrayBuffer.isView(q), "q must be a typed array");
        assert(
          q.byteLength === binding.crypto_scalarmult_ed25519_BYTES,
          "q must be 'crypto_scalarmult_ed25519_BYTES' bytes"
        );
        assert(ArrayBuffer.isView(n), "n must be a typed array");
        assert(
          n.byteLength === binding.crypto_scalarmult_ed25519_SCALARBYTES,
          "n must be 'crypto_scalarmult_ed25519_SCALARBYTES' bytes"
        );
        assert(ArrayBuffer.isView(p), "p must be a typed array");
        assert(
          p.byteLength === binding.crypto_scalarmult_ed25519_BYTES,
          "p must be 'crypto_scalarmult_ed25519_BYTES' bytes"
        );
        const res = binding.crypto_scalarmult_ed25519(q, n, p);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_core_ed25519_is_valid_point = function(p) {
        assert(ArrayBuffer.isView(p), "p must be a typed array");
        assert(
          p.byteLength === binding.crypto_core_ed25519_BYTES,
          "p must be 'crypto_core_ed25519_BYTES' bytes"
        );
        return binding.crypto_core_ed25519_is_valid_point(p);
      };
      exports.crypto_core_ed25519_from_uniform = function(p, r) {
        assert(ArrayBuffer.isView(p), "p must be a typed array");
        assert(
          p.byteLength === binding.crypto_core_ed25519_BYTES,
          "p must be 'crypto_core_ed25519_BYTES' bytes"
        );
        assert(ArrayBuffer.isView(r), "r must be a typed array");
        assert(
          r.byteLength === binding.crypto_core_ed25519_UNIFORMBYTES,
          "r must be 'crypto_core_ed25519_UNIFORMBYTES' bytes"
        );
        const res = binding.crypto_core_ed25519_from_uniform(p, r);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_scalarmult_ed25519_base_noclamp = function(q, n) {
        assert(ArrayBuffer.isView(q), "q must be a typed array");
        assert(
          q.byteLength === binding.crypto_scalarmult_ed25519_BYTES,
          "q must be 'crypto_scalarmult_ed25519_BYTES' bytes"
        );
        assert(ArrayBuffer.isView(n), "n must be a typed array");
        assert(
          n.byteLength === binding.crypto_scalarmult_ed25519_SCALARBYTES,
          "n must be 'crypto_scalarmult_ed25519_SCALARBYTES' bytes"
        );
        const res = binding.crypto_scalarmult_ed25519_base_noclamp(q, n);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_scalarmult_ed25519_noclamp = function(q, n, p) {
        assert(ArrayBuffer.isView(q), "q must be a typed array");
        assert(
          q.byteLength === binding.crypto_scalarmult_ed25519_BYTES,
          "q must be 'crypto_scalarmult_ed25519_BYTES' bytes"
        );
        assert(ArrayBuffer.isView(n), "n must be a typed array");
        assert(
          n.byteLength === binding.crypto_scalarmult_ed25519_SCALARBYTES,
          "n must be 'crypto_scalarmult_ed25519_SCALARBYTES' bytes"
        );
        assert(ArrayBuffer.isView(p), "p must be a typed array");
        assert(
          p.byteLength === binding.crypto_scalarmult_ed25519_BYTES,
          "p must be 'crypto_scalarmult_ed25519_BYTES' bytes"
        );
        const res = binding.crypto_scalarmult_ed25519_noclamp(q, n, p);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_core_ed25519_add = function(r, p, q) {
        assert(ArrayBuffer.isView(r), "r must be a typed array");
        assert(
          r.byteLength === binding.crypto_core_ed25519_BYTES,
          "r must be 'crypto_core_ed25519_BYTES' bytes"
        );
        assert(ArrayBuffer.isView(p), "p must be a typed array");
        assert(
          p.byteLength === binding.crypto_core_ed25519_BYTES,
          "p must be 'crypto_core_ed25519_BYTES' bytes"
        );
        assert(ArrayBuffer.isView(q), "q must be a typed array");
        assert(
          q.byteLength === binding.crypto_core_ed25519_BYTES,
          "q must be 'crypto_core_ed25519_BYTES' bytes"
        );
        const res = binding.crypto_core_ed25519_add(r, p, q);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_core_ed25519_sub = function(r, p, q) {
        assert(ArrayBuffer.isView(r), "r must be a typed array");
        assert(
          r.byteLength === binding.crypto_core_ed25519_BYTES,
          "r must be 'crypto_core_ed25519_BYTES' bytes"
        );
        assert(ArrayBuffer.isView(p), "p must be a typed array");
        assert(
          p.byteLength === binding.crypto_core_ed25519_BYTES,
          "p must be 'crypto_core_ed25519_BYTES' bytes"
        );
        assert(ArrayBuffer.isView(q), "q must be a typed array");
        assert(
          q.byteLength === binding.crypto_core_ed25519_BYTES,
          "q must be 'crypto_core_ed25519_BYTES' bytes"
        );
        const res = binding.crypto_core_ed25519_sub(r, p, q);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_core_ed25519_scalar_random = function(r) {
        assert(ArrayBuffer.isView(r), "r must be a typed array");
        assert(
          r.byteLength === binding.crypto_core_ed25519_SCALARBYTES,
          "r must be 'crypto_core_ed25519_SCALARBYTES' bytes"
        );
        binding.crypto_core_ed25519_scalar_random(r);
      };
      exports.crypto_core_ed25519_scalar_reduce = function(r, s) {
        assert(ArrayBuffer.isView(r), "r must be a typed array");
        assert(
          r.byteLength === binding.crypto_core_ed25519_SCALARBYTES,
          "r must be 'crypto_core_ed25519_SCALARBYTES' bytes"
        );
        assert(ArrayBuffer.isView(s), "s must be a typed array");
        assert(
          s.byteLength === binding.crypto_core_ed25519_NONREDUCEDSCALARBYTES,
          "s must be 'crypto_core_ed25519_NONREDUCEDSCALARBYTES' bytes"
        );
        binding.crypto_core_ed25519_scalar_reduce(r, s);
      };
      exports.crypto_core_ed25519_scalar_invert = function(recip, s) {
        assert(ArrayBuffer.isView(recip), "recip must be a typed array");
        assert(
          recip.byteLength === binding.crypto_core_ed25519_SCALARBYTES,
          "recip must be 'crypto_core_ed25519_SCALARBYTES' bytes"
        );
        assert(ArrayBuffer.isView(s), "s must be a typed array");
        assert(
          s.byteLength === binding.crypto_core_ed25519_SCALARBYTES,
          "s must be 'crypto_core_ed25519_SCALARBYTES' bytes"
        );
        binding.crypto_core_ed25519_scalar_invert(recip, s);
      };
      exports.crypto_core_ed25519_scalar_negate = function(neg, s) {
        assert(ArrayBuffer.isView(neg), "neg must be a typed array");
        assert(
          neg.byteLength === binding.crypto_core_ed25519_SCALARBYTES,
          "neg must be 'crypto_core_ed25519_SCALARBYTES' bytes"
        );
        assert(ArrayBuffer.isView(s), "s must be a typed array");
        assert(
          s.byteLength === binding.crypto_core_ed25519_SCALARBYTES,
          "s must be 'crypto_core_ed25519_SCALARBYTES' bytes"
        );
        binding.crypto_core_ed25519_scalar_negate(neg, s);
      };
      exports.crypto_core_ed25519_scalar_complement = function(comp, s) {
        assert(ArrayBuffer.isView(comp), "comp must be a typed array");
        assert(
          comp.byteLength === binding.crypto_core_ed25519_SCALARBYTES,
          "comp must be 'crypto_core_ed25519_SCALARBYTES' bytes"
        );
        assert(ArrayBuffer.isView(s), "s must be a typed array");
        assert(
          s.byteLength === binding.crypto_core_ed25519_SCALARBYTES,
          "s must be 'crypto_core_ed25519_SCALARBYTES' bytes"
        );
        binding.crypto_core_ed25519_scalar_complement(comp, s);
      };
      exports.crypto_core_ed25519_scalar_add = function(z, x, y) {
        assert(ArrayBuffer.isView(z), "z must be a typed array");
        assert(
          z.byteLength === binding.crypto_core_ed25519_SCALARBYTES,
          "z must be 'crypto_core_ed25519_SCALARBYTES' bytes"
        );
        assert(ArrayBuffer.isView(x), "x must be a typed array");
        assert(
          x.byteLength === binding.crypto_core_ed25519_SCALARBYTES,
          "x must be 'crypto_core_ed25519_SCALARBYTES' bytes"
        );
        assert(ArrayBuffer.isView(y), "y must be a typed array");
        assert(
          y.byteLength === binding.crypto_core_ed25519_SCALARBYTES,
          "y must be 'crypto_core_ed25519_SCALARBYTES' bytes"
        );
        binding.crypto_core_ed25519_scalar_add(z, x, y);
      };
      exports.crypto_core_ed25519_scalar_sub = function(z, x, y) {
        assert(ArrayBuffer.isView(z), "z must be a typed array");
        assert(
          z.byteLength === binding.crypto_core_ed25519_SCALARBYTES,
          "z must be 'crypto_core_ed25519_SCALARBYTES' bytes"
        );
        assert(ArrayBuffer.isView(x), "x must be a typed array");
        assert(
          x.byteLength === binding.crypto_core_ed25519_SCALARBYTES,
          "x must be 'crypto_core_ed25519_SCALARBYTES' bytes"
        );
        assert(ArrayBuffer.isView(y), "y must be a typed array");
        assert(
          y.byteLength === binding.crypto_core_ed25519_SCALARBYTES,
          "y must be 'crypto_core_ed25519_SCALARBYTES' bytes"
        );
        binding.crypto_core_ed25519_scalar_sub(z, x, y);
      };
      exports.crypto_shorthash = function(out, input, k) {
        assert(ArrayBuffer.isView(out), "out must be a typed array");
        assert(ArrayBuffer.isView(input), "input must be a typed array");
        assert(
          out.byteLength === binding.crypto_shorthash_BYTES,
          "out must be 'crypto_shorthash_BYTES' bytes"
        );
        assert(ArrayBuffer.isView(k), "k must be a typed array");
        assert(
          k.byteLength === binding.crypto_shorthash_KEYBYTES,
          "k must be 'crypto_shorthash_KEYBYTES' bytes"
        );
        const res = binding.crypto_shorthash(out, input, k);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_kdf_keygen = function(key) {
        assert(ArrayBuffer.isView(key), "key must be a typed array");
        assert(key.byteLength === binding.crypto_kdf_KEYBYTES, "key must be 'crypto_kdf_KEYBYTES' bytes");
        binding.crypto_kdf_keygen(key);
      };
      exports.crypto_kdf_derive_from_key = function(subkey, subkeyId, ctx, key) {
        assert(ArrayBuffer.isView(subkey), "subkey must be a typed array");
        assert(
          subkey.byteLength >= binding.crypto_kdf_BYTES_MIN,
          "subkey must be at least 'crypto_kdf_BYTES_MIN' bytes"
        );
        assert(
          subkey.byteLength <= binding.crypto_kdf_BYTES_MAX,
          "subkey must be at most 'crypto_kdf_BYTES_MAX' bytes"
        );
        assert(ArrayBuffer.isView(ctx), "ctx must be a typed array");
        assert(
          ctx.byteLength === binding.crypto_kdf_CONTEXTBYTES,
          "ctx must be 'crypto_kdf_CONTEXTBYTES' bytes"
        );
        assert(ArrayBuffer.isView(key), "key must be a typed array");
        assert(key.byteLength === binding.crypto_kdf_KEYBYTES, "key must be 'crypto_kdf_KEYBYTES' bytes");
        const res = binding.crypto_kdf_derive_from_key(subkey, subkeyId, ctx, key);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_hash = function(out, input) {
        assert(ArrayBuffer.isView(out), "out must be a typed array");
        assert(ArrayBuffer.isView(input), "input must be a typed array");
        assert(out.byteLength === binding.crypto_hash_BYTES, "out must be 'crypto_hash_BYTES' bytes");
        const res = binding.crypto_hash(out, input);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_hash_sha256 = function(out, input) {
        assert(ArrayBuffer.isView(out), "out must be a typed array");
        assert(ArrayBuffer.isView(input), "input must be a typed array");
        assert(
          out.byteLength === binding.crypto_hash_sha256_BYTES,
          "out must be 'crypto_hash_sha256_BYTES' bytes"
        );
        const res = binding.crypto_hash_sha256(out, input);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_hash_sha256_init = function(state) {
        assert(ArrayBuffer.isView(state), "state must be a typed array");
        assert(
          state.byteLength === binding.crypto_hash_sha256_STATEBYTES,
          "state must be 'crypto_hash_sha256_STATEBYTES' bytes"
        );
        const res = binding.crypto_hash_sha256_init(state);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_hash_sha256_update = function(state, input) {
        assert(ArrayBuffer.isView(state), "state must be a typed array");
        assert(ArrayBuffer.isView(input), "input must be a typed array");
        assert(
          state.byteLength === binding.crypto_hash_sha256_STATEBYTES,
          "state must be 'crypto_hash_sha256_STATEBYTES' bytes"
        );
        const res = binding.crypto_hash_sha256_update(state, input);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_hash_sha256_final = function(state, out) {
        assert(ArrayBuffer.isView(state), "state must be a typed array");
        assert(
          state.byteLength === binding.crypto_hash_sha256_STATEBYTES,
          "state must be 'crypto_hash_sha256_STATEBYTES' bytes"
        );
        assert(ArrayBuffer.isView(out), "out must be a typed array");
        assert(
          out.byteLength === binding.crypto_hash_sha256_BYTES,
          "out must be 'crypto_hash_sha256_BYTES' bytes"
        );
        const res = binding.crypto_hash_sha256_final(state, out);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_hash_sha512 = function(out, input) {
        assert(ArrayBuffer.isView(out), "out must be a typed array");
        assert(ArrayBuffer.isView(input), "input must be a typed array");
        assert(
          out.byteLength === binding.crypto_hash_sha512_BYTES,
          "out must be 'crypto_hash_sha512_BYTES' bytes"
        );
        const res = binding.crypto_hash_sha512(out, input);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_hash_sha512_init = function(state) {
        assert(ArrayBuffer.isView(state), "state must be a typed array");
        assert(
          state.byteLength === binding.crypto_hash_sha512_STATEBYTES,
          "state must be 'crypto_hash_sha512_STATEBYTES' bytes"
        );
        const res = binding.crypto_hash_sha512_init(state);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_hash_sha512_update = function(state, input) {
        assert(ArrayBuffer.isView(state), "state must be a typed array");
        assert(ArrayBuffer.isView(input), "input must be a typed array");
        assert(
          state.byteLength === binding.crypto_hash_sha512_STATEBYTES,
          "state must be 'crypto_hash_sha512_STATEBYTES' bytes"
        );
        const res = binding.crypto_hash_sha512_update(state, input);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_hash_sha512_final = function(state, out) {
        assert(ArrayBuffer.isView(state), "state must be a typed array");
        assert(
          state.byteLength === binding.crypto_hash_sha512_STATEBYTES,
          "state must be 'crypto_hash_sha512_STATEBYTES' bytes"
        );
        assert(ArrayBuffer.isView(out), "out must be a typed array");
        assert(
          out.byteLength === binding.crypto_hash_sha512_BYTES,
          "out must be 'crypto_hash_sha512_BYTES' bytes"
        );
        const res = binding.crypto_hash_sha512_final(state, out);
        if (res !== 0) throw new Error("status: " + res);
      };
      exports.crypto_aead_xchacha20poly1305_ietf_keygen = function(k) {
        assert(ArrayBuffer.isView(k), "k must be a typed array");
        assert(
          k.byteLength === binding.crypto_aead_xchacha20poly1305_ietf_KEYBYTES,
          "k must be 'crypto_aead_xchacha20poly1305_ietf_KEYBYTES' bytes"
        );
        binding.crypto_aead_xchacha20poly1305_ietf_keygen(k);
      };
      exports.crypto_aead_xchacha20poly1305_ietf_encrypt = function(c, m, ad, nsec, npub, k) {
        if (!ad) ad = void 0;
        assert(nsec === null, "nsec must always be set to null");
        assert(ArrayBuffer.isView(c), "c must be a typed array");
        assert(ArrayBuffer.isView(m), "m must be a typed array");
        assert(
          c.byteLength === m.byteLength + binding.crypto_aead_xchacha20poly1305_ietf_ABYTES,
          "c must be 'm.byteLength + crypto_aead_xchacha20poly1305_ietf_ABYTES' bytes"
        );
        assert(c.byteLength <= 4294967295, "c.byteLength must be a 32bit integer");
        assert(ArrayBuffer.isView(npub), "npub must be a typed array");
        assert(
          npub.byteLength === binding.crypto_aead_xchacha20poly1305_ietf_NPUBBYTES,
          "npub must be 'crypto_aead_xchacha20poly1305_ietf_NPUBBYTES' bytes"
        );
        assert(ArrayBuffer.isView(k), "k must be a typed array");
        assert(
          k.byteLength === binding.crypto_aead_xchacha20poly1305_ietf_KEYBYTES,
          "k must be 'crypto_aead_xchacha20poly1305_ietf_KEYBYTES' bytes"
        );
        const res = binding.crypto_aead_xchacha20poly1305_ietf_encrypt(c, m, ad, npub, k);
        if (res < 0) throw new Error("could not encrypt data");
        return res;
      };
      exports.crypto_aead_xchacha20poly1305_ietf_decrypt = function(m, nsec, c, ad, npub, k) {
        if (!ad) ad = void 0;
        assert(nsec === null, "nsec must always be set to null");
        assert(ArrayBuffer.isView(m), "m must be a typed array");
        assert(ArrayBuffer.isView(c), "c must be a typed array");
        assert(
          m.byteLength === c.byteLength - binding.crypto_aead_xchacha20poly1305_ietf_ABYTES,
          "m must be 'c.byteLength - crypto_aead_xchacha20poly1305_ietf_ABYTES' bytes"
        );
        assert(m.byteLength <= 4294967295, "m.byteLength must be a 32bit integer");
        assert(ArrayBuffer.isView(npub), "npub must be a typed array");
        assert(
          npub.byteLength === binding.crypto_aead_xchacha20poly1305_ietf_NPUBBYTES,
          "npub must be 'crypto_aead_xchacha20poly1305_ietf_NPUBBYTES' bytes"
        );
        assert(ArrayBuffer.isView(k), "k must be a typed array");
        assert(
          k.byteLength === binding.crypto_aead_xchacha20poly1305_ietf_KEYBYTES,
          "k must be 'crypto_aead_xchacha20poly1305_ietf_KEYBYTES' bytes"
        );
        const res = binding.crypto_aead_xchacha20poly1305_ietf_decrypt(m, c, ad, npub, k);
        if (res < 0) throw new Error("could not verify data");
        return res;
      };
      exports.crypto_aead_xchacha20poly1305_ietf_encrypt_detached = function(c, mac, m, ad, nsec, npub, k) {
        if (!ad) ad = void 0;
        assert(nsec === null, "nsec must always be set to null");
        assert(ArrayBuffer.isView(c), "c must be a typed array");
        assert(ArrayBuffer.isView(m), "m must be a typed array");
        assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes");
        assert(ArrayBuffer.isView(mac), "mac must be a typed array");
        assert(
          mac.byteLength === binding.crypto_aead_xchacha20poly1305_ietf_ABYTES,
          "mac must be 'crypto_aead_xchacha20poly1305_ietf_ABYTES' bytes"
        );
        assert(ArrayBuffer.isView(npub), "npub must be a typed array");
        assert(
          npub.byteLength === binding.crypto_aead_xchacha20poly1305_ietf_NPUBBYTES,
          "npub must be 'crypto_aead_xchacha20poly1305_ietf_NPUBBYTES' bytes"
        );
        assert(ArrayBuffer.isView(k), "k must be a typed array");
        assert(
          k.byteLength === binding.crypto_aead_xchacha20poly1305_ietf_KEYBYTES,
          "k must be 'crypto_aead_xchacha20poly1305_ietf_KEYBYTES' bytes"
        );
        const res = binding.crypto_aead_xchacha20poly1305_ietf_encrypt_detached(c, mac, m, ad, npub, k);
        if (res < 0) throw new Error("could not encrypt data");
        return res;
      };
      exports.crypto_aead_xchacha20poly1305_ietf_decrypt_detached = function(m, nsec, c, mac, ad, npub, k) {
        if (!ad) ad = void 0;
        assert(nsec === null, "nsec must always be set to null");
        assert(ArrayBuffer.isView(m), "m must be a typed array");
        assert(ArrayBuffer.isView(c), "c must be a typed array");
        assert(m.byteLength === c.byteLength, "m must be 'c.byteLength' bytes");
        assert(ArrayBuffer.isView(mac), "mac must be a typed array");
        assert(
          mac.byteLength === binding.crypto_aead_xchacha20poly1305_ietf_ABYTES,
          "mac must be 'crypto_aead_xchacha20poly1305_ietf_ABYTES' bytes"
        );
        assert(ArrayBuffer.isView(npub), "npub must be a typed array");
        assert(
          npub.byteLength === binding.crypto_aead_xchacha20poly1305_ietf_NPUBBYTES,
          "npub must be 'crypto_aead_xchacha20poly1305_ietf_NPUBBYTES' bytes"
        );
        assert(ArrayBuffer.isView(k), "k must be a typed array");
        assert(
          k.byteLength === binding.crypto_aead_xchacha20poly1305_ietf_KEYBYTES,
          "k must be 'crypto_aead_xchacha20poly1305_ietf_KEYBYTES' bytes"
        );
        const res = binding.crypto_aead_xchacha20poly1305_ietf_decrypt_detached(m, c, mac, ad, npub, k);
        if (res !== 0) throw new Error("could not verify data");
      };
      exports.crypto_aead_chacha20poly1305_ietf_keygen = function(k) {
        assert(ArrayBuffer.isView(k), "k must be a typed array");
        assert(
          k.byteLength === binding.crypto_aead_chacha20poly1305_ietf_KEYBYTES,
          "k must be 'crypto_aead_chacha20poly1305_ietf_KEYBYTES' bytes"
        );
        binding.crypto_aead_chacha20poly1305_ietf_keygen(k);
      };
      exports.crypto_aead_chacha20poly1305_ietf_encrypt = function(c, m, ad, nsec, npub, k) {
        if (!ad) ad = void 0;
        assert(nsec === null, "nsec must always be set to null");
        assert(ArrayBuffer.isView(c), "c must be a typed array");
        assert(ArrayBuffer.isView(m), "m must be a typed array");
        assert(
          c.byteLength === m.byteLength + binding.crypto_aead_chacha20poly1305_ietf_ABYTES,
          "c must be 'm.byteLength + crypto_aead_chacha20poly1305_ietf_ABYTES' bytes"
        );
        assert(c.byteLength <= 4294967295, "c.byteLength must be a 32bit integer");
        assert(ArrayBuffer.isView(npub), "npub must be a typed array");
        assert(
          npub.byteLength === binding.crypto_aead_chacha20poly1305_ietf_NPUBBYTES,
          "npub must be 'crypto_aead_chacha20poly1305_ietf_NPUBBYTES' bytes"
        );
        assert(ArrayBuffer.isView(k), "k must be a typed array");
        assert(
          k.byteLength === binding.crypto_aead_chacha20poly1305_ietf_KEYBYTES,
          "k must be 'crypto_aead_chacha20poly1305_ietf_KEYBYTES' bytes"
        );
        const res = binding.crypto_aead_chacha20poly1305_ietf_encrypt(c, m, ad, npub, k);
        if (res < 0) throw new Error("could not encrypt data");
        return res;
      };
      exports.crypto_aead_chacha20poly1305_ietf_decrypt = function(m, nsec, c, ad, npub, k) {
        if (!ad) ad = void 0;
        assert(nsec === null, "nsec must always be set to null");
        assert(ArrayBuffer.isView(m), "m must be a typed array");
        assert(ArrayBuffer.isView(c), "c must be a typed array");
        assert(
          m.byteLength === c.byteLength - binding.crypto_aead_chacha20poly1305_ietf_ABYTES,
          "m must be 'c.byteLength - crypto_aead_chacha20poly1305_ietf_ABYTES' bytes"
        );
        assert(m.byteLength <= 4294967295, "m.byteLength must be a 32bit integer");
        assert(ArrayBuffer.isView(npub), "npub must be a typed array");
        assert(
          npub.byteLength === binding.crypto_aead_chacha20poly1305_ietf_NPUBBYTES,
          "npub must be 'crypto_aead_chacha20poly1305_ietf_NPUBBYTES' bytes"
        );
        assert(ArrayBuffer.isView(k), "k must be a typed array");
        assert(
          k.byteLength === binding.crypto_aead_chacha20poly1305_ietf_KEYBYTES,
          "k must be 'crypto_aead_chacha20poly1305_ietf_KEYBYTES' bytes"
        );
        const res = binding.crypto_aead_chacha20poly1305_ietf_decrypt(m, c, ad, npub, k);
        if (res < 0) throw new Error("could not verify data");
        return res;
      };
      exports.crypto_aead_chacha20poly1305_ietf_encrypt_detached = function(c, mac, m, ad, nsec, npub, k) {
        if (!ad) ad = void 0;
        assert(nsec === null, "nsec must always be set to null");
        assert(ArrayBuffer.isView(c), "c must be a typed array");
        assert(ArrayBuffer.isView(m), "m must be a typed array");
        assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes");
        assert(ArrayBuffer.isView(mac), "mac must be a typed array");
        assert(
          mac.byteLength === binding.crypto_aead_chacha20poly1305_ietf_ABYTES,
          "mac must be 'crypto_aead_chacha20poly1305_ietf_ABYTES' bytes"
        );
        assert(ArrayBuffer.isView(npub), "npub must be a typed array");
        assert(
          npub.byteLength === binding.crypto_aead_chacha20poly1305_ietf_NPUBBYTES,
          "npub must be 'crypto_aead_chacha20poly1305_ietf_NPUBBYTES' bytes"
        );
        assert(ArrayBuffer.isView(k), "k must be a typed array");
        assert(
          k.byteLength === binding.crypto_aead_chacha20poly1305_ietf_KEYBYTES,
          "k must be 'crypto_aead_chacha20poly1305_ietf_KEYBYTES' bytes"
        );
        const res = binding.crypto_aead_chacha20poly1305_ietf_encrypt_detached(c, mac, m, ad, npub, k);
        if (res < 0) throw new Error("could not encrypt data");
        return res;
      };
      exports.crypto_aead_chacha20poly1305_ietf_decrypt_detached = function(m, nsec, c, mac, ad, npub, k) {
        if (!ad) ad = void 0;
        assert(nsec === null, "nsec must always be set to null");
        assert(ArrayBuffer.isView(m), "m must be a typed array");
        assert(ArrayBuffer.isView(c), "c must be a typed array");
        assert(m.byteLength === c.byteLength, "m must be 'c.byteLength' bytes");
        assert(ArrayBuffer.isView(mac), "mac must be a typed array");
        assert(
          mac.byteLength === binding.crypto_aead_chacha20poly1305_ietf_ABYTES,
          "mac must be 'crypto_aead_chacha20poly1305_ietf_ABYTES' bytes"
        );
        assert(ArrayBuffer.isView(npub), "npub must be a typed array");
        assert(
          npub.byteLength === binding.crypto_aead_chacha20poly1305_ietf_NPUBBYTES,
          "npub must be 'crypto_aead_chacha20poly1305_ietf_NPUBBYTES' bytes"
        );
        assert(ArrayBuffer.isView(k), "k must be a typed array");
        assert(
          k.byteLength === binding.crypto_aead_chacha20poly1305_ietf_KEYBYTES,
          "k must be 'crypto_aead_chacha20poly1305_ietf_KEYBYTES' bytes"
        );
        const res = binding.crypto_aead_chacha20poly1305_ietf_decrypt_detached(m, c, mac, ad, npub, k);
        if (res !== 0) throw new Error("could not verify data");
      };
      exports.crypto_stream_xor_wrap_init = function(state, n, k) {
        assert(ArrayBuffer.isView(state), "state must be a typed array");
        assert(
          state.byteLength === binding.sn_crypto_stream_xor_STATEBYTES,
          "state must be 'sn_crypto_stream_xor_STATEBYTES' bytes"
        );
        assert(ArrayBuffer.isView(n), "n must be a typed array");
        assert(
          n.byteLength === binding.crypto_stream_NONCEBYTES,
          "n must be 'crypto_stream_NONCEBYTES' bytes"
        );
        assert(ArrayBuffer.isView(k), "k must be a typed array");
        assert(
          k.byteLength === binding.crypto_stream_KEYBYTES,
          "k must be 'crypto_stream_KEYBYTES' bytes"
        );
        binding.crypto_stream_xor_wrap_init(state, n, k);
      };
      exports.crypto_stream_xor_wrap_update = function(state, c, m) {
        assert(ArrayBuffer.isView(state), "state must be a typed array");
        assert(
          state.byteLength === binding.sn_crypto_stream_xor_STATEBYTES,
          "state must be 'sn_crypto_stream_xor_STATEBYTES' bytes"
        );
        assert(ArrayBuffer.isView(c), "c must be a typed array");
        assert(ArrayBuffer.isView(m), "m must be a typed array");
        assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes");
        binding.crypto_stream_xor_wrap_update(state, c, m);
      };
      exports.crypto_stream_xor_wrap_final = function(state) {
        assert(ArrayBuffer.isView(state), "state must be a typed array");
        assert(
          state.byteLength === binding.sn_crypto_stream_xor_STATEBYTES,
          "state must be 'sn_crypto_stream_xor_STATEBYTES' bytes"
        );
        binding.crypto_stream_xor_wrap_final(state);
      };
      exports.crypto_stream_chacha20_xor_wrap_init = function(state, n, k) {
        assert(ArrayBuffer.isView(state), "state must be a typed array");
        assert(
          state.byteLength === binding.crypto_stream_chacha20_xor_STATEBYTES,
          "state must be 'crypto_stream_chacha20_xor_STATEBYTES' bytes"
        );
        assert(ArrayBuffer.isView(n), "n must be a typed array");
        assert(
          n.byteLength === binding.crypto_stream_chacha20_NONCEBYTES,
          "n must be 'crypto_stream_chacha20_NONCEBYTES' bytes"
        );
        assert(ArrayBuffer.isView(k), "k must be a typed array");
        assert(
          k.byteLength === binding.crypto_stream_chacha20_KEYBYTES,
          "k must be 'crypto_stream_chacha20_KEYBYTES' bytes"
        );
        binding.crypto_stream_chacha20_xor_wrap_init(state, n, k);
      };
      exports.crypto_stream_chacha20_xor_wrap_update = function(state, c, m) {
        assert(ArrayBuffer.isView(state), "state must be a typed array");
        assert(
          state.byteLength === binding.crypto_stream_chacha20_xor_STATEBYTES,
          "state must be 'crypto_stream_chacha20_xor_STATEBYTES' bytes"
        );
        assert(ArrayBuffer.isView(c), "c must be a typed array");
        assert(ArrayBuffer.isView(m), "m must be a typed array");
        assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes");
        binding.crypto_stream_chacha20_xor_wrap_update(state, c, m);
      };
      exports.crypto_stream_chacha20_xor_wrap_final = function(state) {
        assert(ArrayBuffer.isView(state), "state must be a typed array");
        assert(
          state.byteLength === binding.crypto_stream_chacha20_xor_STATEBYTES,
          "state must be 'crypto_stream_chacha20_xor_STATEBYTES' bytes"
        );
        binding.crypto_stream_chacha20_xor_wrap_final(state);
      };
      exports.crypto_stream_chacha20_ietf_xor_wrap_init = function(state, n, k) {
        assert(ArrayBuffer.isView(state), "state must be a typed array");
        assert(
          state.byteLength === binding.crypto_stream_chacha20_ietf_xor_STATEBYTES,
          "state must be 'crypto_stream_chacha20_ietf_xor_STATEBYTES' bytes"
        );
        assert(ArrayBuffer.isView(n), "n must be a typed array");
        assert(
          n.byteLength === binding.crypto_stream_chacha20_ietf_NONCEBYTES,
          "n must be 'crypto_stream_chacha20_ietf_NONCEBYTES' bytes"
        );
        assert(ArrayBuffer.isView(k), "k must be a typed array");
        assert(
          k.byteLength === binding.crypto_stream_chacha20_ietf_KEYBYTES,
          "k must be 'crypto_stream_chacha20_ietf_KEYBYTES' bytes"
        );
        binding.crypto_stream_chacha20_ietf_xor_wrap_init(state, n, k);
      };
      exports.crypto_stream_chacha20_ietf_xor_wrap_update = function(state, c, m) {
        assert(ArrayBuffer.isView(state), "state must be a typed array");
        assert(
          state.byteLength === binding.crypto_stream_chacha20_ietf_xor_STATEBYTES,
          "state must be 'crypto_stream_chacha20_ietf_xor_STATEBYTES' bytes"
        );
        assert(ArrayBuffer.isView(c), "c must be a typed array");
        assert(ArrayBuffer.isView(m), "m must be a typed array");
        assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes");
        binding.crypto_stream_chacha20_ietf_xor_wrap_update(state, c, m);
      };
      exports.crypto_stream_chacha20_ietf_xor_wrap_final = function(state) {
        assert(ArrayBuffer.isView(state), "state must be a typed array");
        assert(
          state.byteLength === binding.crypto_stream_chacha20_ietf_xor_STATEBYTES,
          "state must be 'crypto_stream_chacha20_ietf_xor_STATEBYTES' bytes"
        );
        binding.crypto_stream_chacha20_ietf_xor_wrap_final(state);
      };
      exports.crypto_stream_xchacha20_xor_wrap_init = function(state, n, k) {
        assert(ArrayBuffer.isView(state), "state must be a typed array");
        assert(
          state.byteLength === binding.crypto_stream_xchacha20_xor_STATEBYTES,
          "state must be 'crypto_stream_xchacha20_xor_STATEBYTES' bytes"
        );
        assert(ArrayBuffer.isView(n), "n must be a typed array");
        assert(
          n.byteLength === binding.crypto_stream_xchacha20_NONCEBYTES,
          "n must be 'crypto_stream_xchacha20_NONCEBYTES' bytes"
        );
        assert(ArrayBuffer.isView(k), "k must be a typed array");
        assert(
          k.byteLength === binding.crypto_stream_xchacha20_KEYBYTES,
          "k must be 'crypto_stream_xchacha20_KEYBYTES' bytes"
        );
        binding.crypto_stream_xchacha20_xor_wrap_init(state, n, k);
      };
      exports.crypto_stream_xchacha20_xor_wrap_update = function(state, c, m) {
        assert(ArrayBuffer.isView(state), "state must be a typed array");
        assert(
          state.byteLength === binding.crypto_stream_xchacha20_xor_STATEBYTES,
          "state must be 'crypto_stream_xchacha20_xor_STATEBYTES' bytes"
        );
        assert(ArrayBuffer.isView(c), "c must be a typed array");
        assert(ArrayBuffer.isView(m), "m must be a typed array");
        assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes");
        binding.crypto_stream_xchacha20_xor_wrap_update(state, c, m);
      };
      exports.crypto_stream_xchacha20_xor_wrap_final = function(state) {
        assert(ArrayBuffer.isView(state), "state must be a typed array");
        assert(
          state.byteLength === binding.crypto_stream_xchacha20_xor_STATEBYTES,
          "state must be 'crypto_stream_xchacha20_xor_STATEBYTES' bytes"
        );
        binding.crypto_stream_xchacha20_xor_wrap_final(state);
      };
      exports.crypto_stream_salsa20_xor_wrap_init = function(state, n, k) {
        assert(ArrayBuffer.isView(state), "state must be a typed array");
        assert(
          state.byteLength === binding.crypto_stream_salsa20_xor_STATEBYTES,
          "state must be 'crypto_stream_salsa20_xor_STATEBYTES' bytes"
        );
        assert(ArrayBuffer.isView(n), "n must be a typed array");
        assert(
          n.byteLength === binding.crypto_stream_salsa20_NONCEBYTES,
          "n must be 'crypto_stream_salsa20_NONCEBYTES' bytes"
        );
        assert(ArrayBuffer.isView(k), "k must be a typed array");
        assert(
          k.byteLength === binding.crypto_stream_salsa20_KEYBYTES,
          "k must be 'crypto_stream_salsa20_KEYBYTES' bytes"
        );
        binding.crypto_stream_salsa20_xor_wrap_init(state, n, k);
      };
      exports.crypto_stream_salsa20_xor_wrap_update = function(state, c, m) {
        assert(ArrayBuffer.isView(state), "state must be a typed array");
        assert(
          state.byteLength === binding.crypto_stream_salsa20_xor_STATEBYTES,
          "state must be 'crypto_stream_salsa20_xor_STATEBYTES' bytes"
        );
        assert(ArrayBuffer.isView(c), "c must be a typed array");
        assert(ArrayBuffer.isView(m), "m must be a typed array");
        assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes");
        binding.crypto_stream_salsa20_xor_wrap_update(state, c, m);
      };
      exports.crypto_stream_salsa20_xor_wrap_final = function(state) {
        assert(ArrayBuffer.isView(state), "state must be a typed array");
        assert(
          state.byteLength === binding.crypto_stream_salsa20_xor_STATEBYTES,
          "state must be 'crypto_stream_salsa20_xor_STATEBYTES' bytes"
        );
        binding.crypto_stream_salsa20_xor_wrap_final(state);
      };
      exports.extension_tweak_ed25519_base = function(n, p, ns) {
        assert(ArrayBuffer.isView(n), "n must be a typed array");
        assert(
          n.byteLength === binding.extension_tweak_ed25519_SCALARBYTES,
          "n must be 'extension_tweak_ed25519_SCALARBYTES' bytes"
        );
        assert(ArrayBuffer.isView(p), "p must be a typed array");
        assert(
          p.byteLength === binding.extension_tweak_ed25519_BYTES,
          "p must be 'extension_tweak_ed25519_BYTES' bytes"
        );
        binding.extension_tweak_ed25519_base(n, p, ns);
      };
      exports.extension_tweak_ed25519_sign_detached = function(sig, m, scalar, pk) {
        assert(ArrayBuffer.isView(sig), "sig must be a typed array");
        assert(sig.byteLength === binding.crypto_sign_BYTES, "sig must be 'crypto_sign_BYTES' bytes");
        assert(ArrayBuffer.isView(m), "m must be a typed array");
        assert(ArrayBuffer.isView(scalar), "scalar must be a typed array");
        assert(
          scalar.byteLength === binding.extension_tweak_ed25519_SCALARBYTES,
          "scalar must be 'extension_tweak_ed25519_SCALARBYTES' bytes"
        );
        if (pk) {
          assert(ArrayBuffer.isView(pk), "pk must be a typed array");
          assert(
            pk.byteLength === binding.crypto_sign_PUBLICKEYBYTES,
            "pk must be 'crypto_sign_PUBLICKEYBYTES' bytes"
          );
        }
        const res = binding.extension_tweak_ed25519_sign_detached(sig, m, scalar, pk);
        if (res !== 0) throw new Error("failed to compute signature");
      };
      exports.extension_tweak_ed25519_sk_to_scalar = function(n, sk) {
        assert(ArrayBuffer.isView(n), "n must be a typed array");
        assert(
          n.byteLength === binding.extension_tweak_ed25519_SCALARBYTES,
          "n must be 'extension_tweak_ed25519_SCALARBYTES' bytes"
        );
        assert(ArrayBuffer.isView(sk), "sk must be a typed array");
        assert(
          sk.byteLength === binding.crypto_sign_SECRETKEYBYTES,
          "sk must be 'crypto_sign_SECRETKEYBYTES' bytes"
        );
        binding.extension_tweak_ed25519_sk_to_scalar(n, sk);
      };
      exports.extension_tweak_ed25519_scalar = function(scalarOut, scalar, ns) {
        assert(ArrayBuffer.isView(scalarOut), "scalarOut must be a typed array");
        assert(
          scalarOut.byteLength === binding.extension_tweak_ed25519_SCALARBYTES,
          "scalarOut must be 'extension_tweak_ed25519_SCALARBYTES' bytes"
        );
        assert(ArrayBuffer.isView(scalar), "scalar must be a typed array");
        assert(
          scalar.byteLength === binding.extension_tweak_ed25519_SCALARBYTES,
          "scalar must be 'extension_tweak_ed25519_SCALARBYTES' bytes"
        );
        binding.extension_tweak_ed25519_scalar(scalarOut, scalar, ns);
      };
      exports.extension_tweak_ed25519_pk = function(tpk, pk, ns) {
        assert(ArrayBuffer.isView(tpk), "tpk must be a typed array");
        assert(
          tpk.byteLength === binding.crypto_sign_PUBLICKEYBYTES,
          "tpk must be 'crypto_sign_PUBLICKEYBYTES' bytes"
        );
        assert(ArrayBuffer.isView(pk), "pk must be a typed array");
        assert(
          pk.byteLength === binding.crypto_sign_PUBLICKEYBYTES,
          "pk must be 'crypto_sign_PUBLICKEYBYTES' bytes"
        );
        const res = binding.extension_tweak_ed25519_pk(tpk, pk, ns);
        if (res !== 0) throw new Error("failed to tweak public key");
      };
      exports.extension_tweak_ed25519_keypair = function(pk, scalarOut, scalarIn, ns) {
        assert(ArrayBuffer.isView(pk), "pk must be a typed array");
        assert(
          pk.byteLength === binding.extension_tweak_ed25519_BYTES,
          "pk must be 'extension_tweak_ed25519_BYTES' bytes"
        );
        assert(ArrayBuffer.isView(scalarOut), "scalarOut must be a typed array");
        assert(
          scalarOut.byteLength === binding.extension_tweak_ed25519_SCALARBYTES,
          "scalarOut must be 'extension_tweak_ed25519_SCALARBYTES' bytes"
        );
        assert(ArrayBuffer.isView(scalarIn), "scalarIn must be a typed array");
        assert(
          scalarIn.byteLength === binding.extension_tweak_ed25519_SCALARBYTES,
          "scalarIn must be 'extension_tweak_ed25519_SCALARBYTES' bytes"
        );
        binding.extension_tweak_ed25519_keypair(pk, scalarOut, scalarIn, ns);
      };
      exports.extension_tweak_ed25519_scalar_add = function(scalarOut, scalar, n) {
        assert(ArrayBuffer.isView(scalarOut), "scalarOut must be a typed array");
        assert(
          scalarOut.byteLength === binding.extension_tweak_ed25519_SCALARBYTES,
          "scalarOut must be 'extension_tweak_ed25519_SCALARBYTES' bytes"
        );
        assert(ArrayBuffer.isView(scalar), "scalar must be a typed array");
        assert(
          scalar.byteLength === binding.extension_tweak_ed25519_SCALARBYTES,
          "scalar must be 'extension_tweak_ed25519_SCALARBYTES' bytes"
        );
        assert(ArrayBuffer.isView(n), "n must be a typed array");
        assert(
          n.byteLength === binding.extension_tweak_ed25519_SCALARBYTES,
          "n must be 'extension_tweak_ed25519_SCALARBYTES' bytes"
        );
        binding.extension_tweak_ed25519_scalar_add(scalarOut, scalar, n);
      };
      exports.extension_tweak_ed25519_pk_add = function(tpk, pk, p) {
        assert(ArrayBuffer.isView(tpk), "tpk must be a typed array");
        assert(
          tpk.byteLength === binding.crypto_sign_PUBLICKEYBYTES,
          "tpk must be 'crypto_sign_PUBLICKEYBYTES' bytes"
        );
        assert(ArrayBuffer.isView(pk), "pk must be a typed array");
        assert(
          pk.byteLength === binding.crypto_sign_PUBLICKEYBYTES,
          "pk must be 'crypto_sign_PUBLICKEYBYTES' bytes"
        );
        assert(ArrayBuffer.isView(p), "p must be a typed array");
        assert(
          p.byteLength === binding.crypto_sign_PUBLICKEYBYTES,
          "p must be 'crypto_sign_PUBLICKEYBYTES' bytes"
        );
        const res = binding.extension_tweak_ed25519_pk_add(tpk, pk, p);
        if (res !== 0) throw new Error("failed to add tweak to public key");
      };
      exports.extension_tweak_ed25519_keypair_add = function(pk, scalarOut, scalarIn, tweak) {
        assert(ArrayBuffer.isView(pk), "pk must be a typed array");
        assert(
          pk.byteLength === binding.extension_tweak_ed25519_BYTES,
          "pk must be 'extension_tweak_ed25519_BYTES' bytes"
        );
        assert(ArrayBuffer.isView(scalarOut), "scalarOut must be a typed array");
        assert(
          scalarOut.byteLength === binding.extension_tweak_ed25519_SCALARBYTES,
          "scalarOut must be 'extension_tweak_ed25519_SCALARBYTES' bytes"
        );
        assert(ArrayBuffer.isView(scalarIn), "scalarIn must be a typed array");
        assert(
          scalarIn.byteLength === binding.extension_tweak_ed25519_SCALARBYTES,
          "scalarIn must be 'extension_tweak_ed25519_SCALARBYTES' bytes"
        );
        assert(ArrayBuffer.isView(tweak), "tweak must be a typed array");
        assert(
          tweak.byteLength === binding.extension_tweak_ed25519_SCALARBYTES,
          "tweak must be 'extension_tweak_ed25519_SCALARBYTES' bytes"
        );
        const res = binding.extension_tweak_ed25519_keypair_add(pk, scalarOut, scalarIn, tweak);
        if (res !== 0) throw new Error("failed to add tweak to keypair");
      };
      exports.extension_pbkdf2_sha512_async = function(out, passwd, salt, iter, outlen, callback) {
        assert(
          iter >= binding.extension_pbkdf2_sha512_ITERATIONS_MIN,
          "iter must be at least 'extension_pbkdf2_sha512_ITERATIONS_MIN'"
        );
        assert(
          outlen <= binding.extension_pbkdf2_sha512_BYTES_MAX,
          "outlen must be at most 'extension_pbkdf2_sha512_BYTES_MAX'"
        );
        assert(ArrayBuffer.isView(out), "out must be a typed array");
        assert(out.byteLength >= outlen, "out must be at least 'outlen' bytes");
        assert(out.byteLength > 0, "out must not be empty");
        assert(ArrayBuffer.isView(passwd), "passwd must be a typed array");
        assert(passwd.byteLength > 0, "passwd must not be empty");
        assert(ArrayBuffer.isView(salt), "salt must be a typed array");
        assert(salt.byteLength > 0, "salt must not be empty");
        const [done, promise] = checkStatus(callback);
        binding.extension_pbkdf2_sha512_async(
          out.buffer,
          out.byteOffset,
          out.byteLength,
          passwd.buffer,
          passwd.byteOffset,
          passwd.byteLength,
          salt.buffer,
          salt.byteOffset,
          salt.byteLength,
          iter,
          outlen,
          done
        );
        return promise;
      };
      exports.extension_pbkdf2_sha512 = function(out, passwd, salt, iter, outlen) {
        assert(
          iter >= binding.extension_pbkdf2_sha512_ITERATIONS_MIN,
          "iter must be at least 'extension_pbkdf2_sha512_ITERATIONS_MIN'"
        );
        assert(
          outlen <= binding.extension_pbkdf2_sha512_BYTES_MAX,
          "outlen must be at most 'extension_pbkdf2_sha512_BYTES_MAX'"
        );
        assert(ArrayBuffer.isView(out), "out must be a typed array");
        assert(out.byteLength >= outlen, "out must be at least 'outlen' bytes");
        assert(out.byteLength > 0, "out must not be empty");
        assert(ArrayBuffer.isView(passwd), "passwd must be a typed array");
        assert(passwd.byteLength > 0, "passwd must not be empty");
        assert(ArrayBuffer.isView(salt), "salt must be a typed array");
        assert(salt.byteLength > 0, "salt must not be empty");
        const res = binding.extension_pbkdf2_sha512(out, passwd, salt, iter, outlen);
        if (res !== 0) throw new Error("failed to add tweak to public key");
      };
      function checkStatus(callback, booleanResult = false) {
        let done, promise;
        if (typeof callback === "function") {
          done = function(status) {
            if (booleanResult) callback(null, status === 0);
            else if (status === 0) callback(null);
            else callback(new Error("status: " + status));
          };
        } else {
          promise = new Promise(function(resolve, reject) {
            done = function(status) {
              if (booleanResult) resolve(status === 0);
              else if (status === 0) resolve();
              else reject(new Error("status: " + status));
            };
          });
        }
        return [done, promise];
      }
    }
  });

  // ../../node_modules/url-file-url/index.js
  var require_url_file_url = __commonJS({
    "../../node_modules/url-file-url/index.js"(exports) {
      var path = __require("path");
      var { isWindows } = require_which_runtime();
      exports.fileURLToPath = function fileURLToPath(url) {
        if (typeof url === "string") {
          url = new URL(url);
        }
        if (url.protocol !== "file:") {
          throw new Error("The URL must use the file: protocol");
        }
        if (isWindows) {
          if (/%2f|%5c/i.test(url.pathname)) {
            throw new Error("The file: URL path must not include encoded \\ or / characters");
          }
        } else {
          if (url.hostname) {
            throw new Error("The file: URL host must be 'localhost' or empty");
          }
          if (/%2f/i.test(url.pathname)) {
            throw new Error("The file: URL path must not include encoded / characters");
          }
        }
        const pathname = path.normalize(decodeURIComponent(url.pathname));
        if (isWindows) {
          if (url.hostname) return "\\\\" + url.hostname + pathname;
          const letter = pathname.charCodeAt(1) | 32;
          if (letter < 97 || letter > 122 || pathname.charCodeAt(2) !== 58) {
            throw new Error("The file: URL path must be absolute");
          }
          return pathname.slice(1);
        }
        return pathname;
      };
      exports.pathToFileURL = function pathToFileURL(pathname) {
        let resolved = path.resolve(pathname);
        if (pathname[pathname.length - 1] === "/") {
          resolved += "/";
        } else if (isWindows && pathname[pathname.length - 1] === "\\") {
          resolved += "\\";
        }
        resolved = resolved.replaceAll("%", "%25").replaceAll("#", "%23").replaceAll("?", "%3f").replaceAll("\n", "%0a").replaceAll("\r", "%0d").replaceAll("	", "%09");
        if (!isWindows) {
          resolved = resolved.replaceAll("\\", "%5c");
        }
        return new URL("file:" + resolved);
      };
    }
  });

  // ../../node_modules/drive-bundler/index.js
  var require_drive_bundler = __commonJS({
    "../../node_modules/drive-bundler/index.js"(exports, module) {
      var fs = require_bare_node_fs();
      var path = __require("path");
      var b4a = require_b4a();
      var Deps = require_dependency_stream();
      var mutex = require_promise();
      var sodium = require_sodium_native();
      var unixResolve = require_unix_path_resolve();
      var { pipelinePromise } = require_streamx();
      var { pathToFileURL } = require_url_file_url();
      module.exports = class DriveBundle {
        constructor(drive, {
          cwd = path.resolve("."),
          mount = "",
          cache = null,
          host = __require.addon ? __require.addon.host : process.platform + "-" + process.arch,
          runtimes = ["bare", "node"],
          prebuilds = true,
          assets = true,
          absoluteFiles = !!mount,
          inlineAssets = false,
          packages = true,
          entrypoint = "."
        } = {}) {
          this.drive = drive;
          this.packages = packages;
          this.cwd = cwd;
          this.prebuilds = prebuilds ? path.resolve(cwd, typeof prebuilds === "string" ? prebuilds : "prebuilds") : null;
          this.assets = assets ? path.resolve(cwd, typeof assets === "string" ? assets : "assets") : null;
          this.cache = cache;
          this.mount = typeof mount === "string" ? mount : mount.href.replace(/[/]$/, "");
          this.absoluteFiles = absoluteFiles;
          this.inlineAssets = inlineAssets;
          this.host = host;
          this.runtimes = runtimes;
          this.entrypoint = entrypoint;
          this.lock = mutex();
        }
        static async stringify(drive, opts) {
          const d = new this(drive, opts);
          return await d.stringify();
        }
        async stringify(entrypoint = this.entrypoint) {
          const b = await this.bundle(entrypoint);
          const addons = {};
          let wrap = "";
          for (const [key, source] of Object.entries(b.sources)) {
            if (wrap) wrap += ",\n";
            wrap += JSON.stringify(key) + ": { resolutions: " + JSON.stringify(b.resolutions[key] || {}) + ", ";
            wrap += "source (module, exports, __filename, __dirname, require) {";
            wrap += (key.endsWith(".json") ? "module.exports = " : "") + source;
            wrap += "\n}}";
          }
          for (const [key, map] of Object.entries(b.resolutions)) {
            if (map["bare:addon"]) addons[key] = map["bare:addon"];
          }
          return `{
      const __bundle__ = {
        builtinRequire: typeof require === 'function' ? require : null,
        cache: Object.create(null),
        addons: ${JSON.stringify(addons)},
        bundle: {${wrap}},
        require (filename) {
          let mod = __bundle__.cache[filename]
          if (mod) return mod

          const b = __bundle__.bundle[filename]
          if (!b) throw new Error('Module not found')

          mod = __bundle__.cache[filename] = {
            filename,
            dirname: filename.slice(0, filename.lastIndexOf('/')),
            exports: {},
            require
          }

          require.resolve = function (req) {
            const res = b.resolutions[req]
            if (!res) throw new Error('Could not find module "' + req + '" from "' + mod.filename + '"')
            return res
          }

          require.addon = function (dir = '.') {
            if (!__bundle__.builtinRequire || !__bundle__.builtinRequire.addon) throw new Error('Addons not supported')

            let d = dir.startsWith('/') ? dir : mod.dirname + '/' + dir
            let p = 1
            let addon = ''

            while (p < d.length) {
              let n = d.indexOf('/', p)
              if (n === -1) n = d.length

              const part = d.slice(p, n)

              p = n + 1

              if (part === '.' || part === '') continue
              if (part === '..') {
                addon = addon.slice(0, addon.lastIndexOf('/'))
                continue
              }

              addon += '/' + part
            }

            if (!addon.endsWith('/')) addon += '/'

            const mapped = __bundle__.addons[addon]
            return mapped ? __bundle__.builtinRequire(mapped) : __bundle__.builtinRequire.addon(addon)
          }

          require.asset = function () {
            const res = b.resolutions[req]
            if (!res || !res.asset) throw new Error('Could not find asset "' + req + '" from "' + mod.filename + '"')
            return res.asset
          }

          b.source(mod, mod.exports, mod.filename, mod.dirname, require)
          return mod

          function require (req) {
            return __bundle__.require(require.resolve(req)).exports
          }
        }
      }

      __bundle__.require(${JSON.stringify(b.entrypoint)})
    }`.replace(/\n[ ]{4}/g, "\n").trim() + "\n";
        }
        static async bundle(drive, opts) {
          const d = new this(drive, opts);
          return await d.bundle();
        }
        static id(bundle) {
          const buffers = [];
          buffers.push(b4a.from("sources\n"));
          for (const [key, data] of Object.entries(bundle.sources)) {
            buffers.push(b4a.from(key + "\n"));
            buffers.push(b4a.from(data));
          }
          buffers.push(b4a.from("assets\n"));
          for (const [key, data] of Object.entries(bundle.assets)) {
            buffers.push(b4a.from(key + "\n"));
            buffers.push(data.value);
          }
          const out = b4a.allocUnsafe(32);
          sodium.crypto_generichash_batch(out, buffers);
          return out;
        }
        async bundle(entrypoint = this.entrypoint) {
          let main = null;
          const resolutions = {};
          const imports = {};
          const sources = {};
          const assets = {};
          const stream = new Deps(this.drive, {
            host: this.host,
            runtimes: this.runtimes,
            packages: this.packages,
            source: true,
            entrypoint
          });
          const addonsPending = [];
          const assetsPending = [];
          for await (const data of stream) {
            const u = this._resolutionKey(data.key, false);
            if (!main) main = u;
            if (this.cache && Object.hasOwn(this.cache, u)) continue;
            const r = {};
            let save = false;
            sources[u] = data.source;
            for (const { input, output } of data.resolutions) {
              if (!input || !output) continue;
              r[input] = this._resolutionKey(output, false);
              save = true;
            }
            if (save) resolutions[u] = r;
            if (this.prebuilds) {
              for (const { input, output } of data.addons) {
                if (!input || !output) continue;
                addonsPending.push(this._mapPrebuild(data.key, input, output));
              }
            }
            if (this.assets) {
              for (const { input } of data.assets) {
                assetsPending.push(this._mapAsset(data.key, input));
              }
            }
          }
          for (const addon of await Promise.all(addonsPending)) {
            if (!addon) continue;
            const dir = this._resolutionKey(
              unixResolve(unixResolve(addon.referrer, ".."), addon.input),
              true
            );
            let r = resolutions[dir] = resolutions[dir] || {};
            r["bare:addon"] = addon.output;
            const referrer = this._resolutionKey(addon.referrer, false);
            r = resolutions[referrer] = resolutions[referrer] || {};
            const def = r[addon.input];
            r[addon.input] = { addon: addon.output };
            if (def) r[addon.input].default = def;
          }
          for (const asset of await Promise.all(assetsPending)) {
            if (!asset) continue;
            const referrer = this._resolutionKey(asset.referrer, false);
            const r = resolutions[referrer] = resolutions[referrer] || {};
            const def = r[asset.input];
            r[asset.input] = { asset: asset.output.key };
            if (def) r[asset.input].default = def;
            assets[asset.output.key] = { executable: asset.output.executable, value: asset.output.value };
          }
          return {
            entrypoint: main,
            resolutions,
            imports,
            sources,
            assets
          };
        }
        _resolutionKey(key, dir) {
          const trail = dir && !key.endsWith("/") ? "/" : "";
          return this.mount ? this.mount + encodeURI(key) + trail : key + trail;
        }
        async _extractAssetToDisk(entry) {
          const out = path.join(this.assets, entry.key);
          await fs.promises.mkdir(path.dirname(out), { recursive: true });
          const mode = entry.value.executable ? 484 : 420;
          const driveStream = this.drive.createReadStream(entry);
          const fsStream = fs.createWriteStream(out, { mode });
          await pipelinePromise(driveStream, fsStream);
          const key = this.absoluteFiles ? pathToFileURL(out).href : this._toRelative(out);
          return { key, executable: entry.value.executable, value: null };
        }
        async _extractAndInlineAsset(entry) {
          const value = await this.drive.get(entry);
          return {
            key: entry.key,
            executable: entry.value.executable,
            value
          };
        }
        async extractAsset(key) {
          try {
            const entry = await this.drive.entry(key);
            if (entry === null) return null;
            if (this.inlineAssets) return await this._extractAndInlineAsset(entry);
            if (hasToPath(this.drive)) {
              return { key: pathToFileURL(this.drive.toPath(key)).href, executable: false, value: null };
            }
            return await this._extractAssetToDisk(entry);
          } catch {
            return null;
          }
        }
        async extractPrebuild(key) {
          const m = key.match(/\/([^/@]+)(@[^/]+)?(\.node|\.bare)$/);
          if (!m) return null;
          const buf = await this.drive.get(key);
          if (!buf) return null;
          const name = hash(buf) + m[3];
          const dir = path.join(this.prebuilds, this.host);
          const out = path.join(dir, name);
          await writeAtomic(dir, out, buf, this.lock);
          return this.absoluteFiles ? pathToFileURL(out).href : this._toRelative(out);
        }
        async _mapAsset(referrer, input) {
          const dir = unixResolve(referrer, "..");
          const key = unixResolve(dir, input);
          const output = await this.extractAsset(key);
          return { referrer, input, output };
        }
        async _mapPrebuild(referrer, input, output) {
          const prebuild = await this.extractPrebuild(output);
          return { referrer, input, output: prebuild };
        }
        _toRelative(out) {
          return "/.." + unixResolve("/", path.relative(this.cwd, out));
        }
      };
      function hash(buf) {
        const out = b4a.allocUnsafe(32);
        sodium.crypto_generichash(out, buf);
        return b4a.toString(out, "hex");
      }
      async function writeAtomic(dir, out, buf, lock) {
        try {
          await fs.promises.stat(out);
          return;
        } catch {
        }
        const release = await lock();
        try {
          await writeToTmpAndSwap(dir, out, buf);
        } finally {
          release();
        }
      }
      async function writeToTmpAndSwap(dir, out, buf) {
        const tmp = out + ".tmp";
        await fs.promises.mkdir(dir, { recursive: true });
        await fs.promises.writeFile(tmp, buf);
        try {
          await fs.promises.rename(tmp, out);
        } catch {
          await fs.promises.stat(out);
          try {
            await fs.promises.unlink(tmp);
          } catch {
          }
        }
      }
      function hasToPath(drive) {
        return typeof drive.toPath === "function";
      }
    }
  });

  // ../../node_modules/bare-dev/lib/bundle.js
  var require_bundle = __commonJS({
    "../../node_modules/bare-dev/lib/bundle.js"(exports, module) {
      var fs = require_promises2();
      var os = __require("os");
      var process2 = __require("process");
      var path = __require("path");
      var pathResolve = require_unix_path_resolve();
      var includeStatic = require_include_static();
      var Bundle = require_bare_bundle();
      var Localdrive = require_localdrive();
      var DriveBundler = require_drive_bundler();
      module.exports = async function bundle(entry, opts = {}) {
        const {
          config = null,
          cwd = path.resolve(".")
        } = opts;
        if (config) {
          opts = {
            ...opts,
            ...__require(path.resolve(cwd, config))
          };
        }
        const {
          platform = os.platform(),
          arch = os.arch(),
          simulator = false,
          out = null,
          format = defaultFormat(out),
          encoding = "utf8",
          packages = true,
          prebuilds = false,
          print = false,
          indent = 2
        } = opts;
        const host = `${platform}-${arch}${simulator ? "-simulator" : ""}`;
        const drive = new Localdrive(cwd, { followLinks: true });
        const bundler = new DriveBundler(drive, {
          cwd,
          host,
          packages,
          prebuilds: prebuilds && out ? path.resolve(cwd, out, "..", "prebuilds") : false,
          inlineAssets: true
        });
        if (bundler.prebuilds) {
          await fs.mkdir(bundler.prebuilds, { recursive: true });
        }
        entry = pathResolve("/", path.relative(cwd, entry));
        let data;
        switch (format) {
          case "bundle":
          case "bundle.js":
          case "bundle.cjs":
          case "bundle.mjs":
          case "bundle.json":
          case "bundle.h": {
            const result = await bundler.bundle(entry);
            const { entrypoint, resolutions, sources, assets } = result;
            const bundle2 = new Bundle();
            bundle2.id = DriveBundler.id(result).toString("hex");
            bundle2.main = entrypoint;
            bundle2.resolutions = resolutions;
            for (const key in sources) {
              bundle2.write(key, sources[key]);
            }
            for (const key in assets) {
              const asset = assets[key];
              bundle2.write(key, asset.value, { executable: asset.executable, asset: true });
            }
            data = bundle2.toBuffer({ indent });
            break;
          }
          case "js":
          case "js.h": {
            const code = await bundler.stringify(entry);
            data = Buffer.from(code);
            break;
          }
          default:
            throw new Error(`unknown format "${format}"`);
        }
        switch (format) {
          case "bundle.js":
          case "bundle.cjs":
            data = `module.exports = ${JSON.stringify(data.toString(encoding))}
`;
            break;
          case "bundle.mjs":
            data = `export default ${JSON.stringify(data.toString(encoding))}
`;
            break;
          case "bundle.json":
            data = JSON.stringify(data.toString(encoding)) + "\n";
            break;
          case "bundle.h":
          case "js.h":
            data = includeStatic(defaultName(out), data);
            break;
        }
        if (print || out) {
          if (print) {
            process2.stdout.write(data);
          }
          if (out) {
            await fs.writeFile(path.resolve(cwd, out), data);
          }
        }
        return data;
      };
      function defaultFormat(out) {
        if (out === null) return "bundle";
        if (out.endsWith(".bundle.js")) return "bundle.js";
        if (out.endsWith(".bundle.cjs")) return "bundle.cjs";
        if (out.endsWith(".bundle.mjs")) return "bundle.mjs";
        if (out.endsWith(".bundle.json")) return "bundle.json";
        if (out.endsWith(".bundle.h")) return "bundle.h";
        if (out.endsWith(".js")) return "js";
        if (out.endsWith(".js.h")) return "js.h";
        return "bundle";
      }
      function defaultName(out) {
        if (out === null) return "bundle";
        return path.basename(out).replace(/\.h$/, "").replace(/[-.]+/g, "_").toLowerCase();
      }
    }
  });

  // ../../node_modules/bare-dev/lib/clean.js
  var require_clean = __commonJS({
    "../../node_modules/bare-dev/lib/clean.js"(exports, module) {
      module.exports = function clean(opts = {}) {
        try {
          require_build()({ ...opts, target: "clean" });
        } catch {
        }
      };
    }
  });

  // ../../node_modules/bare-dev/lib/android/shared/ndk.js
  var require_ndk = __commonJS({
    "../../node_modules/bare-dev/lib/android/shared/ndk.js"(exports) {
      var { globSync } = require_commonjs5();
      var sdk = require_sdk();
      exports.path = function path(version = "installed", opts = {}) {
        const path2 = __require("path");
        switch (version) {
          case "installed": {
            const candidates = globSync(path2.join(sdk.path, "ndk", "*"), {
              windowsPathsNoEscape: true
            });
            if (candidates.length === 0) throw new Error("no Android NDK installed");
            return candidates[0];
          }
          default:
            sdk.manager.install("ndk", version, opts);
            return path2.join(sdk.path, "ndk", version);
        }
      };
    }
  });

  // ../../node_modules/bare-dev/lib/configure.js
  var require_configure = __commonJS({
    "../../node_modules/bare-dev/lib/configure.js"(exports, module) {
      var os = __require("os");
      var path = __require("path");
      var which = require_bare_which();
      var spawn = require_spawn();
      var cmake = require_cmake();
      var paths = require_paths();
      module.exports = function configure(opts = {}) {
        const {
          source = ".",
          build = "build",
          platform = os.platform(),
          arch = os.arch(),
          simulator = false,
          cache = true,
          generator = defaultGenerator(platform),
          toolchain = null,
          toolset = null,
          sanitize = null,
          debug = !!sanitize,
          define = [],
          cwd = path.resolve("."),
          verbose
        } = opts;
        const args = [
          "-S",
          source,
          "-B",
          path.resolve(cwd, build)
        ];
        if (cache === false) {
          args.push("--fresh");
        }
        if (generator) {
          args.push("-G", toGenerator(generator));
        }
        if (toolchain) {
          args.push("--toolchain", path.resolve(cwd, toolchain));
        }
        if (toolset && generator && supportsToolsetSpecification(generator)) {
          args.push(`-DCMAKE_GENERATOR_TOOLSET=${toToolset(toolset, generator)}`);
        }
        args.push(
          `-DCMAKE_MESSAGE_LOG_LEVEL=${verbose ? "VERBOSE" : "NOTICE"}`,
          `-DCMAKE_MODULE_PATH=${cmake.toPath(path.resolve(cwd, "cmake"))};${cmake.toPath(paths.cmake)}`,
          // Export compile commands for use by external tools, such as the Clangd
          // language server (https://clangd.llvm.org).
          "-DCMAKE_EXPORT_COMPILE_COMMANDS=ON"
        );
        if (generator && supportsMultiConfiguration(generator)) {
          args.push(`-DCMAKE_CONFIGURATION_TYPES=${debug ? "Debug" : "Release"}`);
        } else {
          args.push(`-DCMAKE_BUILD_TYPE=${debug ? "Debug" : "Release"}`);
        }
        args.push(`-DCMAKE_SYSTEM_NAME=${toSystemName(platform)}`);
        const processor = toSystemProcessor(arch, platform);
        if (platform === "darwin" || platform === "ios") {
          args.push(`-DCMAKE_OSX_ARCHITECTURES=${processor}`);
        } else if (platform === "android") {
          args.push(`-DCMAKE_ANDROID_ARCH_ABI=${processor === "armv7-a" ? "armeabi-v7a" : processor === "aarch64" ? "arm64-v8a" : processor === "i686" ? "x86" : processor}`);
        } else if (generator && supportsPlatformSpecification(generator)) {
          args.push(`-DCMAKE_GENERATOR_PLATFORM=${processor}`);
        } else {
          args.push(`-DCMAKE_SYSTEM_PROCESSOR=${processor}`);
        }
        args.push(`-DCMAKE_LIBRARY_ARCHITECTURE=${arch}`);
        if (platform === "darwin") {
          const {
            darwinDeploymentTarget
          } = opts;
          if (darwinDeploymentTarget) args.push(`-DCMAKE_OSX_DEPLOYMENT_TARGET=${darwinDeploymentTarget}`);
        }
        if (platform === "ios") {
          const {
            iosDeploymentTarget
          } = opts;
          args.push(`-DCMAKE_OSX_SYSROOT=iphone${simulator ? "simulator" : "os"}`);
          if (iosDeploymentTarget) args.push(`-DCMAKE_OSX_DEPLOYMENT_TARGET=${iosDeploymentTarget}`);
        }
        if (platform === "android") {
          const ndk = require_ndk();
          const {
            androidNdk,
            androidApi,
            androidStl = "c++_static",
            androidAllowUndefinedSymbols = true
          } = opts;
          args.push(`-DCMAKE_ANDROID_NDK=${ndk.path(androidNdk, opts)}`);
          if (androidApi) args.push(`-DCMAKE_ANDROID_API=${androidApi}`);
          if (androidStl) args.push(`-DCMAKE_ANDROID_STL_TYPE=${androidStl}`);
          if (androidAllowUndefinedSymbols) args.push("-DANDROID_ALLOW_UNDEFINED_SYMBOLS=ON");
        }
        if (platform === "win32" && generator && generator.startsWith("visual-studio")) {
          args.push(`-DCMAKE_MSVC_RUNTIME_LIBRARY=MultiThreaded${debug ? "Debug" : ""}`);
        }
        const compilerFlags = [];
        const linkerFlags = [];
        if (debug || sanitize) {
          if (generator && generator.startsWith("visual-studio")) {
            compilerFlags.push("/Oy-");
          } else {
            compilerFlags.push("-fno-omit-frame-pointer");
          }
        }
        if (sanitize) {
          if (generator && generator.startsWith("visual-studio")) {
            compilerFlags.push(`/fsanitize=${sanitize}`);
          } else {
            compilerFlags.push(`-fsanitize=${sanitize}`);
            linkerFlags.push(`-fsanitize=${sanitize}`);
          }
        }
        if (compilerFlags.length) {
          for (const type of ["C"]) {
            args.push(`-DCMAKE_${type}_FLAGS=${compilerFlags.join(" ")}`);
          }
        }
        if (linkerFlags.length) {
          for (const type of ["EXE", "SHARED", "MODULE"]) {
            args.push(`-DCMAKE_${type}_LINKER_FLAGS=${linkerFlags.join(" ")}`);
          }
        }
        for (const entry of define) args.push(`-D${entry}`);
        return spawn(cmake(), args, opts);
      };
      function supportsMultiConfiguration(generator) {
        return generator === "xcode" || generator.startsWith("visual-studio");
      }
      function supportsToolsetSpecification(generator) {
        return generator === "xcode" || generator.startsWith("visual-studio");
      }
      function supportsPlatformSpecification(generator) {
        return generator.startsWith("visual-studio");
      }
      function toGenerator(generator) {
        switch (generator) {
          case "make":
            return "Unix Makefiles";
          case "ninja":
            return "Ninja";
          case "xcode":
            return "Xcode";
          case "visual-studio-2022":
            return "Visual Studio 17 2022";
          default:
            throw new Error(`unsupported generator "${generator}"`);
        }
      }
      function toToolset(toolset, generator) {
        switch (toolset) {
          case "clang-cl":
            return "ClangCL";
          default:
            throw new Error(`unsupported toolset "${toolset}" for generator "${generator}"`);
        }
      }
      function toSystemName(platform) {
        switch (platform) {
          case "darwin":
            return "Darwin";
          case "ios":
            return "iOS";
          case "linux":
            return "Linux";
          case "android":
            return "Android";
          case "win32":
            return "Windows";
          default:
            throw new Error(`unsupported platform "${platform}"`);
        }
      }
      function toSystemProcessor(arch, platform) {
        switch (arch) {
          case "arm64":
            if (platform === "darwin" || platform === "ios") return "arm64";
            if (platform === "linux") return "aarch64";
            if (platform === "android") return "arm64-v8a";
            if (platform === "win32") return "ARM64";
            break;
          case "arm":
            if (platform === "linux") return "arm";
            if (platform === "android") return "armv7-a";
            break;
          case "x64":
            if (platform === "darwin" || platform === "ios" || platform === "linux" || platform === "android") return "x86_64";
            if (platform === "win32") return "x64";
            break;
          case "ia32":
            if (platform === "linux" || platform === "android") return "i686";
            if (platform === "win32") return "X86";
            break;
        }
        throw new Error(`unsupported architecture "${arch}" for platform "${platform}"`);
      }
      function defaultGenerator(platform) {
        if (platform === "win32") return "visual-studio-2022";
        if (has("ninja")) return "ninja";
        if (platform === "darwin" || platform === "ios" || platform === "linux" || platform === "android") return "make";
        return null;
        function has(bin) {
          return which.sync(bin, { nothrow: true }) !== null;
        }
      }
    }
  });

  // ../../node_modules/bare-dev/lib/dependencies.js
  var require_dependencies = __commonJS({
    "../../node_modules/bare-dev/lib/dependencies.js"(exports, module) {
      var fs = require_promises2();
      var process2 = __require("process");
      var path = __require("path");
      var pathResolve = require_unix_path_resolve();
      var Localdrive = require_localdrive();
      var DriveBundler = require_drive_bundler();
      module.exports = async function bundle(entry, opts = {}) {
        const {
          config = null,
          cwd = path.resolve("."),
          quiet = true
        } = opts;
        if (config) {
          opts = {
            ...opts,
            ...__require(path.resolve(cwd, config))
          };
        }
        const {
          packages = true,
          print = false,
          separator = "\n",
          out = null
        } = opts;
        const drive = new Localdrive(cwd, { followLinks: true });
        const bundler = new DriveBundler(drive, { cwd, packages, prebuilds: false });
        entry = pathResolve("/", path.relative(cwd, entry));
        const { sources } = await bundler.bundle(entry);
        const result = Object.keys(sources).map((file) => path.join(cwd, path.normalize(file))).sort();
        if (out) {
          let data;
          switch (path.extname(out)) {
            case ".d":
              data = `${path.resolve(cwd, out.replace(/\.d$/, ""))}: ${result.join(" ")}
`;
              break;
            default:
              throw new Error(`unsupported extension "${out}"`);
          }
          await fs.writeFile(path.resolve(cwd, out), data);
        }
        if (quiet || !print) return result;
        let first = true;
        for (const file of result) {
          let out2 = file;
          if (/^\s+$/.test(separator)) {
            out2 += separator;
          } else {
            first ? first = false : out2 = separator + out2;
          }
          process2.stdout.write(out2);
        }
        return result;
      };
    }
  });

  // ../../node_modules/codecs/index.js
  var require_codecs = __commonJS({
    "../../node_modules/codecs/index.js"(exports, module) {
      var b4a = require_b4a();
      module.exports = codecs;
      codecs.ascii = createString("ascii");
      codecs.utf8 = createString("utf-8");
      codecs.hex = createString("hex");
      codecs.base64 = createString("base64");
      codecs.ucs2 = createString("ucs2");
      codecs.utf16le = createString("utf16le");
      codecs.ndjson = createJSON(true);
      codecs.json = createJSON(false);
      codecs.binary = {
        name: "binary",
        encode: function encodeBinary(obj) {
          return typeof obj === "string" ? b4a.from(obj, "utf-8") : b4a.toBuffer(obj);
        },
        decode: function decodeBinary(buf) {
          return b4a.toBuffer(buf);
        }
      };
      function isCompactEncoding(c) {
        return !!(c.encode && c.decode && c.preencode);
      }
      function fromCompactEncoding(c) {
        return {
          name: "compact-encoding",
          encode: function encodeWithCompact(value) {
            const state = { start: 0, end: 0, buffer: null, cache: null };
            c.preencode(state, value);
            state.buffer = b4a.allocUnsafe(state.end);
            c.encode(state, value);
            return state.buffer;
          },
          decode: function decodeWithCompact(buffer) {
            return c.decode({ start: 0, end: buffer.byteLength, buffer, cache: null });
          }
        };
      }
      function codecs(fmt, fallback) {
        if (typeof fmt === "object" && fmt) {
          return isCompactEncoding(fmt) ? fromCompactEncoding(fmt) : fmt;
        }
        switch (fmt) {
          case "ndjson":
            return codecs.ndjson;
          case "json":
            return codecs.json;
          case "ascii":
            return codecs.ascii;
          case "utf-8":
          case "utf8":
            return codecs.utf8;
          case "hex":
            return codecs.hex;
          case "base64":
            return codecs.base64;
          case "ucs-2":
          case "ucs2":
            return codecs.ucs2;
          case "utf16-le":
          case "utf16le":
            return codecs.utf16le;
        }
        return fallback !== void 0 ? fallback : codecs.binary;
      }
      function createJSON(newline) {
        return {
          name: newline ? "ndjson" : "json",
          encode: newline ? encodeNDJSON : encodeJSON,
          decode: function decodeJSON(buf) {
            return JSON.parse(b4a.toString(buf));
          }
        };
        function encodeJSON(val) {
          return b4a.from(JSON.stringify(val));
        }
        function encodeNDJSON(val) {
          return b4a.from(JSON.stringify(val) + "\n");
        }
      }
      function createString(type) {
        return {
          name: type,
          encode: function encodeString(val) {
            if (typeof val !== "string") val = val.toString();
            return b4a.from(val, type);
          },
          decode: function decodeString(buf) {
            return b4a.toString(buf, type);
          }
        };
      }
    }
  });

  // ../../node_modules/safety-catch/index.js
  var require_safety_catch = __commonJS({
    "../../node_modules/safety-catch/index.js"(exports, module) {
      module.exports = safetyCatch;
      function isActuallyUncaught(err) {
        if (!err) return false;
        return err instanceof TypeError || err instanceof SyntaxError || err instanceof ReferenceError || err instanceof EvalError || err instanceof RangeError || err instanceof URIError || err.code === "ERR_ASSERTION" || err.name === "AssertionError";
      }
      function throwErrorNT(err) {
        queueMicrotask(() => {
          throw err;
        });
      }
      function safetyCatch(err) {
        if (isActuallyUncaught(err)) {
          throwErrorNT(err);
          throw err;
        }
      }
    }
  });

  // ../../node_modules/ready-resource/index.js
  var require_ready_resource = __commonJS({
    "../../node_modules/ready-resource/index.js"(exports, module) {
      var EventEmitter = require_bare_node_events();
      module.exports = class ReadyResource extends EventEmitter {
        constructor() {
          super();
          this.opening = null;
          this.closing = null;
          this.opened = false;
          this.closed = false;
        }
        ready() {
          if (this.opening !== null) return this.opening;
          this.opening = open(this);
          return this.opening;
        }
        close() {
          if (this.closing !== null) return this.closing;
          this.closing = close(this);
          return this.closing;
        }
        async _open() {
        }
        async _close() {
        }
      };
      async function open(self2) {
        if (self2.closing !== null) return;
        try {
          await self2._open();
        } catch (err) {
          self2.close();
          throw err;
        }
        self2.opened = true;
        self2.emit("ready");
      }
      async function close(self2) {
        try {
          if (self2.opened === false && self2.opening !== null) await self2.opening;
        } catch {
        }
        if (self2.opened === true || self2.opening === null) await self2._close();
        self2.closed = true;
        self2.emit("close");
      }
    }
  });

  // ../../node_modules/debounceify/index.js
  var require_debounceify = __commonJS({
    "../../node_modules/debounceify/index.js"(exports, module) {
      module.exports = function debounce(worker, context = null) {
        debounced.running = null;
        return debounced;
        async function debounced() {
          if (debounced.running !== null) {
            try {
              await debounced.running;
            } catch (_) {
            }
          }
          if (debounced.running !== null) return debounced.running;
          debounced.running = worker.call(context);
          try {
            return await debounced.running;
          } finally {
            debounced.running = null;
          }
        }
      };
    }
  });

  // ../../node_modules/rache/index.js
  var require_rache = __commonJS({
    "../../node_modules/rache/index.js"(exports, module) {
      var CacheEntry = class {
        constructor(key, index, map) {
          this.key = key;
          this.index = index;
          this.map = map;
        }
      };
      var CacheValue = class {
        constructor(entry, value) {
          this.entry = entry;
          this.value = value;
        }
      };
      var Rache = class _Rache {
        constructor({ maxSize = 65536, parent = null } = {}) {
          this.maxSize = parent?.maxSize || maxSize;
          this._array = parent?._array || [];
          this._map = /* @__PURE__ */ new Map();
        }
        static from(cache) {
          return cache ? new this({ parent: cache }) : new this();
        }
        get globalSize() {
          return this._array.length;
        }
        get size() {
          return this._map.size;
        }
        sub() {
          return new _Rache({ parent: this });
        }
        set(key, value) {
          const existing = this._map.get(key);
          if (existing !== void 0) {
            existing.value = value;
            return;
          }
          if (this._array.length >= this.maxSize) this._gc();
          const entry = new CacheEntry(key, this._array.length, this._map);
          this._array.push(entry);
          const cacheValue = new CacheValue(entry, value);
          this._map.set(key, cacheValue);
        }
        delete(key) {
          const existing = this._map.get(key);
          if (existing === void 0) return false;
          this._delete(existing.entry.index);
          return true;
        }
        get(key) {
          const existing = this._map.get(key);
          return existing === void 0 ? void 0 : existing.value;
        }
        *[Symbol.iterator]() {
          for (const [key, { value }] of this._map) {
            yield [key, value];
          }
        }
        keys() {
          return this._map.keys();
        }
        *values() {
          for (const { value } of this._map.values()) {
            yield value;
          }
        }
        clear() {
          this._map.clear();
          this._map = /* @__PURE__ */ new Map();
        }
        destroy() {
          this._map = null;
          this._array = null;
        }
        _gc() {
          this._delete(Math.floor(Math.random() * this._array.length));
        }
        _delete(index) {
          if (index >= this._array.length) throw new Error("Cannot delete unused index (logic bug?)");
          const head = this._array.pop();
          let removed = head;
          if (index < this._array.length) {
            removed = this._array[index];
            head.index = index;
            this._array[index] = head;
          }
          removed.map.delete(removed.key);
        }
      };
      module.exports = Rache;
    }
  });

  // ../../node_modules/resolve-reject-promise/index.js
  var require_resolve_reject_promise = __commonJS({
    "../../node_modules/resolve-reject-promise/index.js"(exports, module) {
      var tmpResolve = null;
      var tmpReject = null;
      if (Promise.withResolvers) {
        module.exports = Promise.withResolvers.bind(Promise);
      } else {
        module.exports = function resolveRejectPromise() {
          const promise = new Promise(setTmp);
          const result = { promise, resolve: tmpResolve, reject: tmpReject };
          tmpResolve = tmpReject = null;
          return result;
        };
      }
      function setTmp(resolve, reject) {
        tmpResolve = resolve;
        tmpReject = reject;
      }
    }
  });

  // ../../node_modules/unslab/index.js
  var require_unslab = __commonJS({
    "../../node_modules/unslab/index.js"(exports, module) {
      var b4a = require_b4a();
      unslab.all = all;
      unslab.is = is;
      module.exports = unslab;
      function unslab(buf) {
        if (buf === null || buf.buffer.byteLength === buf.byteLength) return buf;
        const copy = b4a.allocUnsafeSlow(buf.byteLength);
        copy.set(buf, 0);
        return copy;
      }
      function is(buf) {
        return buf.buffer.byteLength !== buf.byteLength;
      }
      function all(list) {
        let size = 0;
        for (let i = 0; i < list.length; i++) {
          const buf = list[i];
          size += buf === null || buf.buffer.byteLength === buf.byteLength ? 0 : buf.byteLength;
        }
        const copy = b4a.allocUnsafeSlow(size);
        const result = new Array(list.length);
        let offset = 0;
        for (let i = 0; i < list.length; i++) {
          let buf = list[i];
          if (buf !== null && buf.buffer.byteLength !== buf.byteLength) {
            copy.set(buf, offset);
            buf = copy.subarray(offset, offset += buf.byteLength);
          }
          result[i] = buf;
        }
        return result;
      }
    }
  });

  // ../../node_modules/hyperbee/iterators/range.js
  var require_range3 = __commonJS({
    "../../node_modules/hyperbee/iterators/range.js"(exports, module) {
      var b4a = require_b4a();
      module.exports = class RangeIterator {
        constructor(batch, encoding, opts = {}) {
          this.batch = batch;
          this.stack = [];
          this.opened = false;
          this.encoding = encoding || batch.encoding;
          this._limit = typeof opts.limit === "number" ? opts.limit : -1;
          this._gIncl = !opts.gt;
          this._gKey = opts.gt || opts.gte || null;
          this._lIncl = !opts.lt;
          this._lKey = opts.lt || opts.lte || null;
          this._reverse = !!opts.reverse;
          this._version = 0;
          this._checkpoint = opts.checkpoint && opts.checkpoint.length ? opts.checkpoint : null;
          this._nexting = false;
          this._closed = false;
        }
        snapshot(version = this.batch.version) {
          const checkpoint = [];
          for (const s of this.stack) {
            let { node, i } = s;
            if (this._nexting && s === this.stack[this.stack.length - 1]) {
              i = this._reverse ? i + 1 : i - 1;
            }
            if (!node.block) continue;
            if (i < 0) continue;
            checkpoint.push(node.block.seq, node.offset, i);
          }
          return {
            version,
            gte: this._gIncl ? this._gKey : null,
            gt: this._gIncl ? null : this._gKey,
            lte: this._lIncl ? this._lKey : null,
            lt: this._lIncl ? null : this._lKey,
            limit: this._limit,
            reverse: this._reverse,
            ended: this.opened && !checkpoint.length,
            checkpoint: this.opened ? checkpoint : []
          };
        }
        async open() {
          await this._open();
          this.opened = true;
        }
        async _open() {
          if (this._checkpoint) {
            for (let j = 0; j < this._checkpoint.length; j += 3) {
              const seq = this._checkpoint[j];
              const offset = this._checkpoint[j + 1];
              const i = this._checkpoint[j + 2];
              this.stack.push({
                node: (await this.batch.getBlock(seq)).getTreeNode(offset),
                i
              });
            }
            return;
          }
          this._nexting = true;
          let node = await this.batch.getRoot(false);
          if (!node) {
            this._nexting = false;
            return;
          }
          const incl = this._reverse ? this._lIncl : this._gIncl;
          const start = this._reverse ? this._lKey : this._gKey;
          if (!start) {
            this.stack.push({ node, i: this._reverse ? node.keys.length << 1 : 0 });
            this._nexting = false;
            this._preloadQuery();
            return;
          }
          while (true) {
            const entry = { node, i: this._reverse ? node.keys.length << 1 : 0 };
            let s = 0;
            let e = node.keys.length;
            let c;
            while (s < e) {
              const mid = s + e >> 1;
              c = b4a.compare(start, await node.getKey(mid));
              if (c === 0) {
                if (incl) entry.i = mid * 2 + 1;
                else entry.i = mid * 2 + (this._reverse ? 0 : 2);
                this.stack.push(entry);
                this._nexting = false;
                this._preloadQuery();
                return;
              }
              if (c < 0) e = mid;
              else s = mid + 1;
            }
            const i = c < 0 ? e : s;
            entry.i = 2 * i + (this._reverse ? -1 : 1);
            if (entry.i >= 0 && entry.i <= node.keys.length << 1) this.stack.push(entry);
            if (!node.children.length) {
              this._nexting = false;
              this._preloadQuery();
              return;
            }
            node = await node.getChildNode(i);
          }
        }
        _preloadQuery() {
          const max = { nodes: 0, max: 2048 };
          if (this._limit === -1 && !this._reverse && this.stack.length) {
            for (const s of this.stack) {
              const k = (s.i - (s.i & 1)) / 2;
              this._preload(s.node, k + 1, this._lKey, max).catch(noop);
            }
          }
        }
        async _preload(node, i, end, max) {
          for (; i < node.keys.length; i++) {
            const key = node.keys[i];
            const block = await this.batch.getBlock(key.seq);
            if (this._closed) return;
            const c = end ? b4a.compare(block.key, end) : -1;
            if (c >= 0 || max.nodes >= max.max || i >= node.children.length) return;
            max.nodes++;
            const next = await node.getChildNode(i);
            if (this._closed) return;
            this._preload(next, 0, end, max).catch(noop);
          }
          if (node.children.length && max.nodes < max.max) {
            const next = await node.getChildNode(node.children.length - 1);
            if (this._closed) return;
            this._preload(next, 0, end, max).catch(noop);
          }
        }
        async next() {
          this._nexting = true;
          const end = this._reverse ? this._gKey : this._lKey;
          const incl = this._reverse ? this._gIncl : this._lIncl;
          while (this.stack.length && (this._limit === -1 || this._limit > 0)) {
            const top = this.stack[this.stack.length - 1];
            const isKey = (top.i & 1) === 1;
            const n = this._reverse ? top.i < 0 ? top.node.keys.length : top.i-- >> 1 : top.i++ >> 1;
            if (!isKey) {
              if (!top.node.children.length) continue;
              const node = await top.node.getChildNode(n);
              if (top.node.block.seq < this.batch.core.length) {
                top.node.children[n].value = null;
              }
              this.stack.push({ i: this._reverse ? node.keys.length << 1 : 0, node });
              continue;
            }
            if (n >= top.node.keys.length) {
              this.stack.pop();
              continue;
            }
            const key = top.node.keys[n];
            const block = await this.batch.getBlock(key.seq);
            if (end) {
              const c = b4a.compare(block.key, end);
              if (c === 0 ? !incl : this._reverse ? c < 0 : c > 0) {
                this._limit = 0;
                break;
              }
            }
            if (this._limit > 0) this._limit--;
            this._nexting = false;
            return block.final(this.encoding);
          }
          this._nexting = false;
          return null;
        }
        close() {
          this._closed = true;
          return this.batch._closeSnapshot();
        }
      };
      function noop() {
      }
    }
  });

  // ../../node_modules/hyperbee/iterators/history.js
  var require_history = __commonJS({
    "../../node_modules/hyperbee/iterators/history.js"(exports, module) {
      module.exports = class HistoryIterator {
        constructor(batch, opts = {}) {
          this.batch = batch;
          this.options = opts;
          this.live = !!opts.live;
          this.gte = 0;
          this.lt = 0;
          this.reverse = !!opts.reverse;
          this.limit = typeof opts.limit === "number" ? opts.limit : -1;
          this.encoding = opts.encoding || batch.encoding;
          if (this.live && this.reverse) {
            throw new Error("Cannot have both live and reverse enabled");
          }
        }
        async open() {
          await this.batch.getRoot(false);
          this.gte = gte(this.options, this.batch.version);
          this.lt = this.live ? Infinity : lt(this.options, this.batch.version);
        }
        async next() {
          if (this.limit === 0) return null;
          if (this.limit > 0) this.limit--;
          if (this.gte >= this.lt) return null;
          if (this.reverse) {
            if (this.lt <= 1) return null;
            return final(await this.batch.getBlock(--this.lt), this.encoding);
          }
          return final(await this.batch.getBlock(this.gte++), this.encoding);
        }
        close() {
          return this.batch._closeSnapshot();
        }
      };
      function final(node, encoding) {
        const type = node.isDeletion() ? "del" : "put";
        return { type, ...node.final(encoding) };
      }
      function gte(opts, version) {
        if (opts.gt) return (opts.gt < 0 ? opts.gt + version : opts.gt) + 1;
        const gte2 = opts.gte || opts.since || 1;
        return gte2 < 0 ? gte2 + version : gte2;
      }
      function lt(opts, version) {
        if (opts.lte === 0 || opts.lt === 0 || opts.end === 0) return 0;
        if (opts.lte) return (opts.lte < 0 ? opts.lte + version : opts.lte) + 1;
        const lt2 = opts.lt || opts.end || version;
        return lt2 < 0 ? lt2 + version : lt2;
      }
    }
  });

  // ../../node_modules/hyperbee/iterators/diff.js
  var require_diff = __commonJS({
    "../../node_modules/hyperbee/iterators/diff.js"(exports, module) {
      var b4a = require_b4a();
      var SubTree = class {
        constructor(node, parent) {
          this.node = node;
          this.parent = parent;
          this.isKey = node.children.length === 0;
          this.i = this.isKey ? 1 : 0;
          this.n = 0;
          const child = this.isKey ? null : this.node.children[0];
          this.seq = child !== null ? child.seq : this.node.keys[0].seq;
          this.offset = child !== null ? child.offset : 0;
        }
        next() {
          this.i++;
          this.isKey = (this.i & 1) === 1;
          if (!this.isKey && !this.node.children.length) this.i++;
          return this.update();
        }
        async bisect(key, incl) {
          let s = 0;
          let e = this.node.keys.length;
          let c;
          while (s < e) {
            const mid = s + e >> 1;
            c = cmp(key, await this.node.getKey(mid));
            if (c === 0) {
              if (incl) this.i = mid * 2 + 1;
              else this.i = mid * 2 + (this.node.children.length ? 2 : 3);
              return true;
            }
            if (c < 0) e = mid;
            else s = mid + 1;
          }
          const i = c < 0 ? e : s;
          this.i = 2 * i + (this.node.children.length ? 0 : 1);
          return this.node.children.length === 0;
        }
        update() {
          this.isKey = (this.i & 1) === 1;
          this.n = this.i >> 1;
          if (this.n >= (this.isKey ? this.node.keys.length : this.node.children.length)) return false;
          const child = this.isKey ? null : this.node.children[this.n];
          this.seq = child !== null ? child.seq : this.node.keys[this.n].seq;
          this.offset = child !== null ? child.offset : 0;
          return true;
        }
        async key() {
          return this.n < this.node.keys.length ? this.node.getKey(this.n) : this.parent && this.parent.key();
        }
        async compare(tree) {
          const [a, b] = await Promise.all([this.key(), tree.key()]);
          return cmp(a, b);
        }
      };
      var TreeIterator = class {
        constructor(batch, opts) {
          this.batch = batch;
          this.stack = [];
          this.lt = opts.lt || opts.lte || null;
          this.lte = !!opts.lte;
          this.gt = opts.gt || opts.gte || null;
          this.gte = !!opts.gte;
          this.seeking = !!this.gt;
          this.encoding = opts.encoding || batch.encoding;
        }
        async open() {
          const node = await this.batch.getRoot(false);
          if (!node || !node.keys.length) return;
          const tree = new SubTree(node, null);
          if (this.seeking && !await this._seek(tree)) return;
          this.stack.push(tree);
        }
        async _seek(tree) {
          const done = await tree.bisect(this.gt, this.gte);
          const oob = !tree.update();
          if (done || oob) {
            this.seeking = false;
            if (oob) return false;
          }
          return true;
        }
        peek() {
          if (!this.stack.length) return null;
          return this.stack[this.stack.length - 1];
        }
        skip() {
          if (!this.stack.length) return;
          if (!this.stack[this.stack.length - 1].next()) this.stack.pop();
        }
        async nextKey() {
          let n = null;
          while (this.stack.length && n === null) n = await this.next();
          if (n === null) return null;
          if (!this.lt) return n.final(this.encoding);
          const c = cmp(n.key, this.lt);
          if (this.lte ? c <= 0 : c < 0) return n.final(this.encoding);
          this.stack = [];
          return null;
        }
        async next() {
          if (!this.stack.length) return null;
          const top = this.stack[this.stack.length - 1];
          const { isKey, n, seq } = top;
          if (!top.next()) {
            this.stack.pop();
          }
          if (isKey) {
            this.seeking = false;
            return this.batch.getBlock(seq);
          }
          const child = await top.node.getChildNode(n);
          top.node.children[n] = null;
          const tree = new SubTree(child, top);
          if (this.seeking && !await this._seek(tree)) return null;
          this.stack.push(tree);
          return null;
        }
        close() {
          return this.batch._closeSnapshot();
        }
      };
      module.exports = class DiffIterator {
        constructor(left, right, opts = {}) {
          this.left = new TreeIterator(left, opts);
          this.right = new TreeIterator(right, opts);
          this.limit = typeof opts.limit === "number" ? opts.limit : -1;
        }
        async open() {
          await Promise.all([this.left.open(), this.right.open()]);
        }
        async next() {
          if (this.limit === 0) return null;
          const res = await this._next();
          if (!res || res.left === null && res.right === null) return null;
          this.limit--;
          return res;
        }
        async _next() {
          const a = this.left;
          const b = this.right;
          while (true) {
            const [l, r] = await Promise.all([a.peek(), b.peek()]);
            if (!l && !r) return null;
            if (!l) return { left: null, right: await b.nextKey() };
            if (!r) return { left: await a.nextKey(), right: null };
            if (l.seq === r.seq && l.isKey === r.isKey && l.offset === r.offset) {
              a.skip();
              b.skip();
              continue;
            }
            const c = await l.compare(r);
            if (l.isKey && !r.isKey) {
              await b.next();
              continue;
            }
            if (!l.isKey && r.isKey) {
              await a.next();
              continue;
            }
            if (l.isKey && r.isKey) {
              if (c === 0) return { left: await a.nextKey(), right: await b.nextKey() };
              if (c < 0) return { left: await a.nextKey(), right: null };
              return { left: null, right: await b.nextKey() };
            }
            if (c === 0) await Promise.all([a.next(), b.next()]);
            else if (c < 0) await b.next();
            else await a.next();
          }
        }
        async close() {
          await Promise.all([this.left.close(), this.right.close()]);
        }
      };
      function cmp(a, b) {
        if (!a) return b ? 1 : 0;
        if (!b) return a ? -1 : 0;
        return b4a.compare(a, b);
      }
    }
  });

  // ../../node_modules/hyperbee/iterators/local.js
  var require_local = __commonJS({
    "../../node_modules/hyperbee/iterators/local.js"(exports, module) {
      module.exports = class LocalBlocksIterator {
        constructor(batch, opts = {}) {
          this.batch = batch;
          this.options = opts;
          this.gte = 0;
          this.lt = 0;
          this.limit = typeof opts.limit === "number" ? opts.limit : -1;
        }
        async open() {
          await this.batch.getRoot(false);
          this.gte = gte(this.options, this.batch.version);
          this.lt = lt(this.options, this.batch.version);
        }
        async next() {
          if (this.limit === 0) return null;
          if (this.limit > 0) this.limit--;
          while (this.gte < this.lt) {
            try {
              return await this.batch.getBlock(this.gte++);
            } catch {
              continue;
            }
          }
          return null;
        }
        close() {
          return this.batch._closeSnapshot();
        }
      };
      function gte(opts, version) {
        if (opts.gt) return (opts.gt < 0 ? opts.gt + version : opts.gt) + 1;
        const gte2 = opts.gte || opts.since || 1;
        return gte2 < 0 ? gte2 + version : gte2;
      }
      function lt(opts, version) {
        if (opts.lte === 0 || opts.lt === 0 || opts.end === 0) return 0;
        if (opts.lte) return (opts.lte < 0 ? opts.lte + version : opts.lte) + 1;
        const lt2 = opts.lt || opts.end || version;
        return lt2 < 0 ? lt2 + version : lt2;
      }
    }
  });

  // ../../node_modules/varint/encode.js
  var require_encode = __commonJS({
    "../../node_modules/varint/encode.js"(exports, module) {
      module.exports = encode;
      var MSB = 128;
      var REST = 127;
      var MSBALL = ~REST;
      var INT = Math.pow(2, 31);
      function encode(num, out, offset) {
        out = out || [];
        offset = offset || 0;
        var oldOffset = offset;
        while (num >= INT) {
          out[offset++] = num & 255 | MSB;
          num /= 128;
        }
        while (num & MSBALL) {
          out[offset++] = num & 255 | MSB;
          num >>>= 7;
        }
        out[offset] = num | 0;
        encode.bytes = offset - oldOffset + 1;
        return out;
      }
    }
  });

  // ../../node_modules/varint/decode.js
  var require_decode = __commonJS({
    "../../node_modules/varint/decode.js"(exports, module) {
      module.exports = read;
      var MSB = 128;
      var REST = 127;
      function read(buf, offset) {
        var res = 0, offset = offset || 0, shift = 0, counter = offset, b, l = buf.length;
        do {
          if (counter >= l) {
            read.bytes = 0;
            throw new RangeError("Could not decode varint");
          }
          b = buf[counter++];
          res += shift < 28 ? (b & REST) << shift : (b & REST) * Math.pow(2, shift);
          shift += 7;
        } while (b >= MSB);
        read.bytes = counter - offset;
        return res;
      }
    }
  });

  // ../../node_modules/varint/length.js
  var require_length = __commonJS({
    "../../node_modules/varint/length.js"(exports, module) {
      var N1 = Math.pow(2, 7);
      var N2 = Math.pow(2, 14);
      var N3 = Math.pow(2, 21);
      var N4 = Math.pow(2, 28);
      var N5 = Math.pow(2, 35);
      var N6 = Math.pow(2, 42);
      var N7 = Math.pow(2, 49);
      var N8 = Math.pow(2, 56);
      var N9 = Math.pow(2, 63);
      module.exports = function(value) {
        return value < N1 ? 1 : value < N2 ? 2 : value < N3 ? 3 : value < N4 ? 4 : value < N5 ? 5 : value < N6 ? 6 : value < N7 ? 7 : value < N8 ? 8 : value < N9 ? 9 : 10;
      };
    }
  });

  // ../../node_modules/varint/index.js
  var require_varint = __commonJS({
    "../../node_modules/varint/index.js"(exports, module) {
      module.exports = {
        encode: require_encode(),
        decode: require_decode(),
        encodingLength: require_length()
      };
    }
  });

  // ../../node_modules/signed-varint/index.js
  var require_signed_varint = __commonJS({
    "../../node_modules/signed-varint/index.js"(exports) {
      var varint = require_varint();
      exports.encode = function encode(v, b, o) {
        v = v >= 0 ? v * 2 : v * -2 - 1;
        var r = varint.encode(v, b, o);
        encode.bytes = varint.encode.bytes;
        return r;
      };
      exports.decode = function decode(b, o) {
        var v = varint.decode(b, o);
        decode.bytes = varint.decode.bytes;
        return v & 1 ? (v + 1) / -2 : v / 2;
      };
      exports.encodingLength = function(v) {
        return varint.encodingLength(v >= 0 ? v * 2 : v * -2 - 1);
      };
    }
  });

  // ../../node_modules/protocol-buffers-encodings/index.js
  var require_protocol_buffers_encodings = __commonJS({
    "../../node_modules/protocol-buffers-encodings/index.js"(exports) {
      var varint = require_varint();
      var svarint = require_signed_varint();
      var b4a = require_b4a();
      exports.make = encoder;
      exports.name = function(enc) {
        var keys = Object.keys(exports);
        for (var i = 0; i < keys.length; i++) {
          if (exports[keys[i]] === enc) return keys[i];
        }
        return null;
      };
      exports.skip = function(type, buffer, offset) {
        switch (type) {
          case 0:
            varint.decode(buffer, offset);
            return offset + varint.decode.bytes;
          case 1:
            return offset + 8;
          case 2:
            var len = varint.decode(buffer, offset);
            return offset + varint.decode.bytes + len;
          case 3:
          case 4:
            throw new Error("Groups are not supported");
          case 5:
            return offset + 4;
        }
        throw new Error("Unknown wire type: " + type);
      };
      exports.bytes = encoder(
        2,
        function encode(val, buffer, offset) {
          var oldOffset = offset;
          var len = bufferLength(val);
          varint.encode(len, buffer, offset);
          offset += varint.encode.bytes;
          if (b4a.isBuffer(val)) b4a.copy(val, buffer, offset);
          else b4a.write(buffer, val, offset, len);
          offset += len;
          encode.bytes = offset - oldOffset;
          return buffer;
        },
        function decode(buffer, offset) {
          var oldOffset = offset;
          var len = varint.decode(buffer, offset);
          offset += varint.decode.bytes;
          var val = buffer.subarray(offset, offset + len);
          offset += val.length;
          decode.bytes = offset - oldOffset;
          return val;
        },
        function encodingLength(val) {
          var len = bufferLength(val);
          return varint.encodingLength(len) + len;
        }
      );
      exports.string = encoder(
        2,
        function encode(val, buffer, offset) {
          var oldOffset = offset;
          var len = b4a.byteLength(val);
          varint.encode(len, buffer, offset, "utf-8");
          offset += varint.encode.bytes;
          b4a.write(buffer, val, offset, len);
          offset += len;
          encode.bytes = offset - oldOffset;
          return buffer;
        },
        function decode(buffer, offset) {
          var oldOffset = offset;
          var len = varint.decode(buffer, offset);
          offset += varint.decode.bytes;
          var val = b4a.toString(buffer, "utf-8", offset, offset + len);
          offset += len;
          decode.bytes = offset - oldOffset;
          return val;
        },
        function encodingLength(val) {
          var len = b4a.byteLength(val);
          return varint.encodingLength(len) + len;
        }
      );
      exports.bool = encoder(
        0,
        function encode(val, buffer, offset) {
          buffer[offset] = val ? 1 : 0;
          encode.bytes = 1;
          return buffer;
        },
        function decode(buffer, offset) {
          var bool = buffer[offset] > 0;
          decode.bytes = 1;
          return bool;
        },
        function encodingLength() {
          return 1;
        }
      );
      exports.int32 = encoder(
        0,
        function encode(val, buffer, offset) {
          varint.encode(val < 0 ? val + 4294967296 : val, buffer, offset);
          encode.bytes = varint.encode.bytes;
          return buffer;
        },
        function decode(buffer, offset) {
          var val = varint.decode(buffer, offset);
          decode.bytes = varint.decode.bytes;
          return val > 2147483647 ? val - 4294967296 : val;
        },
        function encodingLength(val) {
          return varint.encodingLength(val < 0 ? val + 4294967296 : val);
        }
      );
      exports.int64 = encoder(
        0,
        function encode(val, buffer, offset) {
          if (val < 0) {
            var last = offset + 9;
            varint.encode(val * -1, buffer, offset);
            offset += varint.encode.bytes - 1;
            buffer[offset] = buffer[offset] | 128;
            while (offset < last - 1) {
              offset++;
              buffer[offset] = 255;
            }
            buffer[last] = 1;
            encode.bytes = 10;
          } else {
            varint.encode(val, buffer, offset);
            encode.bytes = varint.encode.bytes;
          }
          return buffer;
        },
        function decode(buffer, offset) {
          var val = varint.decode(buffer, offset);
          if (val >= Math.pow(2, 63)) {
            var limit = 9;
            while (buffer[offset + limit - 1] === 255) limit--;
            limit = limit || 9;
            var subset = b4a.allocUnsafe(limit);
            b4a.copy(buffer, subset, 0, offset, offset + limit);
            subset[limit - 1] = subset[limit - 1] & 127;
            val = -1 * varint.decode(subset, 0);
            decode.bytes = 10;
          } else {
            decode.bytes = varint.decode.bytes;
          }
          return val;
        },
        function encodingLength(val) {
          return val < 0 ? 10 : varint.encodingLength(val);
        }
      );
      exports.sint32 = exports.sint64 = encoder(
        0,
        svarint.encode,
        svarint.decode,
        svarint.encodingLength
      );
      exports.uint32 = exports.uint64 = exports.enum = exports.varint = encoder(
        0,
        varint.encode,
        varint.decode,
        varint.encodingLength
      );
      exports.fixed64 = exports.sfixed64 = encoder(
        1,
        function encode(val, buffer, offset) {
          b4a.copy(val, buffer, offset);
          encode.bytes = 8;
          return buffer;
        },
        function decode(buffer, offset) {
          var val = buffer.subarray(offset, offset + 8);
          decode.bytes = 8;
          return val;
        },
        function encodingLength() {
          return 8;
        }
      );
      exports.double = encoder(
        1,
        function encode(val, buffer, offset) {
          b4a.writeDoubleLE(buffer, val, offset);
          encode.bytes = 8;
          return buffer;
        },
        function decode(buffer, offset) {
          var val = b4a.readDoubleLE(buffer, offset);
          decode.bytes = 8;
          return val;
        },
        function encodingLength() {
          return 8;
        }
      );
      exports.fixed32 = encoder(
        5,
        function encode(val, buffer, offset) {
          b4a.writeUInt32LE(buffer, val, offset);
          encode.bytes = 4;
          return buffer;
        },
        function decode(buffer, offset) {
          var val = b4a.readUInt32LE(buffer, offset);
          decode.bytes = 4;
          return val;
        },
        function encodingLength() {
          return 4;
        }
      );
      exports.sfixed32 = encoder(
        5,
        function encode(val, buffer, offset) {
          b4a.writeInt32LE(buffer, val, offset);
          encode.bytes = 4;
          return buffer;
        },
        function decode(buffer, offset) {
          var val = b4a.readInt32LE(buffer, offset);
          decode.bytes = 4;
          return val;
        },
        function encodingLength() {
          return 4;
        }
      );
      exports.float = encoder(
        5,
        function encode(val, buffer, offset) {
          b4a.writeFloatLE(buffer, val, offset);
          encode.bytes = 4;
          return buffer;
        },
        function decode(buffer, offset) {
          var val = b4a.readFloatLE(buffer, offset);
          decode.bytes = 4;
          return val;
        },
        function encodingLength() {
          return 4;
        }
      );
      function encoder(type, encode, decode, encodingLength) {
        encode.bytes = decode.bytes = 0;
        return {
          type,
          encode,
          decode,
          encodingLength
        };
      }
      function bufferLength(val) {
        return b4a.isBuffer(val) ? val.length : b4a.byteLength(val);
      }
    }
  });

  // ../../node_modules/hyperbee/lib/messages.js
  var require_messages = __commonJS({
    "../../node_modules/hyperbee/lib/messages.js"(exports) {
      var encodings = require_protocol_buffers_encodings();
      var b4a = require_b4a();
      var varint = encodings.varint;
      var skip = encodings.skip;
      var YoloIndex = exports.YoloIndex = {
        buffer: true,
        encodingLength: null,
        encode: null,
        decode: null
      };
      var Header = exports.Header = {
        buffer: true,
        encodingLength: null,
        encode: null,
        decode: null
      };
      var Node = exports.Node = {
        buffer: true,
        encodingLength: null,
        encode: null,
        decode: null
      };
      var Extension = exports.Extension = {
        buffer: true,
        encodingLength: null,
        encode: null,
        decode: null
      };
      defineYoloIndex();
      defineHeader();
      defineNode();
      defineExtension();
      function defineYoloIndex() {
        var Level = YoloIndex.Level = {
          buffer: true,
          encodingLength: null,
          encode: null,
          decode: null
        };
        defineLevel();
        function defineLevel() {
          Level.encodingLength = encodingLength2;
          Level.encode = encode2;
          Level.decode = decode2;
          function encodingLength2(obj) {
            var length = 0;
            if (defined(obj.keys)) {
              var packedLen = 0;
              for (var i = 0; i < obj.keys.length; i++) {
                if (!defined(obj.keys[i])) continue;
                var len = encodings.varint.encodingLength(obj.keys[i]);
                packedLen += len;
              }
              if (packedLen) {
                length += 1 + packedLen + varint.encodingLength(packedLen);
              }
            }
            if (defined(obj.children)) {
              var packedLen = 0;
              for (var i = 0; i < obj.children.length; i++) {
                if (!defined(obj.children[i])) continue;
                var len = encodings.varint.encodingLength(obj.children[i]);
                packedLen += len;
              }
              if (packedLen) {
                length += 1 + packedLen + varint.encodingLength(packedLen);
              }
            }
            return length;
          }
          function encode2(obj, buf, offset) {
            if (!offset) offset = 0;
            if (!buf) buf = b4a.allocUnsafe(encodingLength2(obj));
            var oldOffset = offset;
            if (defined(obj.keys)) {
              var packedLen = 0;
              for (var i = 0; i < obj.keys.length; i++) {
                if (!defined(obj.keys[i])) continue;
                packedLen += encodings.varint.encodingLength(obj.keys[i]);
              }
              if (packedLen) {
                buf[offset++] = 10;
                varint.encode(packedLen, buf, offset);
                offset += varint.encode.bytes;
              }
              for (var i = 0; i < obj.keys.length; i++) {
                if (!defined(obj.keys[i])) continue;
                encodings.varint.encode(obj.keys[i], buf, offset);
                offset += encodings.varint.encode.bytes;
              }
            }
            if (defined(obj.children)) {
              var packedLen = 0;
              for (var i = 0; i < obj.children.length; i++) {
                if (!defined(obj.children[i])) continue;
                packedLen += encodings.varint.encodingLength(obj.children[i]);
              }
              if (packedLen) {
                buf[offset++] = 18;
                varint.encode(packedLen, buf, offset);
                offset += varint.encode.bytes;
              }
              for (var i = 0; i < obj.children.length; i++) {
                if (!defined(obj.children[i])) continue;
                encodings.varint.encode(obj.children[i], buf, offset);
                offset += encodings.varint.encode.bytes;
              }
            }
            encode2.bytes = offset - oldOffset;
            return buf;
          }
          function decode2(buf, offset, end) {
            if (!offset) offset = 0;
            if (!end) end = buf.length;
            if (!(end <= buf.length && offset <= buf.length)) throw new Error("Decoded message is not valid");
            var oldOffset = offset;
            var obj = {
              keys: [],
              children: []
            };
            while (true) {
              if (end <= offset) {
                decode2.bytes = offset - oldOffset;
                return obj;
              }
              var prefix = varint.decode(buf, offset);
              offset += varint.decode.bytes;
              var tag = prefix >> 3;
              switch (tag) {
                case 1:
                  var packedEnd = varint.decode(buf, offset);
                  offset += varint.decode.bytes;
                  packedEnd += offset;
                  while (offset < packedEnd) {
                    obj.keys.push(encodings.varint.decode(buf, offset));
                    offset += encodings.varint.decode.bytes;
                  }
                  break;
                case 2:
                  var packedEnd = varint.decode(buf, offset);
                  offset += varint.decode.bytes;
                  packedEnd += offset;
                  while (offset < packedEnd) {
                    obj.children.push(encodings.varint.decode(buf, offset));
                    offset += encodings.varint.decode.bytes;
                  }
                  break;
                default:
                  offset = skip(prefix & 7, buf, offset);
              }
            }
          }
        }
        YoloIndex.encodingLength = encodingLength;
        YoloIndex.encode = encode;
        YoloIndex.decode = decode;
        function encodingLength(obj) {
          var length = 0;
          if (defined(obj.levels)) {
            for (var i = 0; i < obj.levels.length; i++) {
              if (!defined(obj.levels[i])) continue;
              var len = Level.encodingLength(obj.levels[i]);
              length += varint.encodingLength(len);
              length += 1 + len;
            }
          }
          return length;
        }
        function encode(obj, buf, offset) {
          if (!offset) offset = 0;
          if (!buf) buf = b4a.allocUnsafe(encodingLength(obj));
          var oldOffset = offset;
          if (defined(obj.levels)) {
            for (var i = 0; i < obj.levels.length; i++) {
              if (!defined(obj.levels[i])) continue;
              buf[offset++] = 10;
              varint.encode(Level.encodingLength(obj.levels[i]), buf, offset);
              offset += varint.encode.bytes;
              Level.encode(obj.levels[i], buf, offset);
              offset += Level.encode.bytes;
            }
          }
          encode.bytes = offset - oldOffset;
          return buf;
        }
        function decode(buf, offset, end) {
          if (!offset) offset = 0;
          if (!end) end = buf.length;
          if (!(end <= buf.length && offset <= buf.length)) throw new Error("Decoded message is not valid");
          var oldOffset = offset;
          var obj = {
            levels: []
          };
          while (true) {
            if (end <= offset) {
              decode.bytes = offset - oldOffset;
              return obj;
            }
            var prefix = varint.decode(buf, offset);
            offset += varint.decode.bytes;
            var tag = prefix >> 3;
            switch (tag) {
              case 1:
                var len = varint.decode(buf, offset);
                offset += varint.decode.bytes;
                obj.levels.push(Level.decode(buf, offset, offset + len));
                offset += Level.decode.bytes;
                break;
              default:
                offset = skip(prefix & 7, buf, offset);
            }
          }
        }
      }
      function defineHeader() {
        var Metadata = Header.Metadata = {
          buffer: true,
          encodingLength: null,
          encode: null,
          decode: null
        };
        defineMetadata();
        function defineMetadata() {
          Metadata.encodingLength = encodingLength2;
          Metadata.encode = encode2;
          Metadata.decode = decode2;
          function encodingLength2(obj) {
            var length = 0;
            if (defined(obj.contentFeed)) {
              var len = encodings.bytes.encodingLength(obj.contentFeed);
              length += 1 + len;
            }
            if (defined(obj.userData)) {
              var len = encodings.bytes.encodingLength(obj.userData);
              length += 1 + len;
            }
            return length;
          }
          function encode2(obj, buf, offset) {
            if (!offset) offset = 0;
            if (!buf) buf = b4a.allocUnsafe(encodingLength2(obj));
            var oldOffset = offset;
            if (defined(obj.contentFeed)) {
              buf[offset++] = 10;
              encodings.bytes.encode(obj.contentFeed, buf, offset);
              offset += encodings.bytes.encode.bytes;
            }
            if (defined(obj.userData)) {
              buf[offset++] = 18;
              encodings.bytes.encode(obj.userData, buf, offset);
              offset += encodings.bytes.encode.bytes;
            }
            encode2.bytes = offset - oldOffset;
            return buf;
          }
          function decode2(buf, offset, end) {
            if (!offset) offset = 0;
            if (!end) end = buf.length;
            if (!(end <= buf.length && offset <= buf.length)) throw new Error("Decoded message is not valid");
            var oldOffset = offset;
            var obj = {
              contentFeed: null,
              userData: null
            };
            while (true) {
              if (end <= offset) {
                decode2.bytes = offset - oldOffset;
                return obj;
              }
              var prefix = varint.decode(buf, offset);
              offset += varint.decode.bytes;
              var tag = prefix >> 3;
              switch (tag) {
                case 1:
                  obj.contentFeed = encodings.bytes.decode(buf, offset);
                  offset += encodings.bytes.decode.bytes;
                  break;
                case 2:
                  obj.userData = encodings.bytes.decode(buf, offset);
                  offset += encodings.bytes.decode.bytes;
                  break;
                default:
                  offset = skip(prefix & 7, buf, offset);
              }
            }
          }
        }
        Header.encodingLength = encodingLength;
        Header.encode = encode;
        Header.decode = decode;
        function encodingLength(obj) {
          var length = 0;
          if (!defined(obj.protocol)) throw new Error("protocol is required");
          var len = encodings.string.encodingLength(obj.protocol);
          length += 1 + len;
          if (defined(obj.metadata)) {
            var len = Metadata.encodingLength(obj.metadata);
            length += varint.encodingLength(len);
            length += 1 + len;
          }
          return length;
        }
        function encode(obj, buf, offset) {
          if (!offset) offset = 0;
          if (!buf) buf = b4a.allocUnsafe(encodingLength(obj));
          var oldOffset = offset;
          if (!defined(obj.protocol)) throw new Error("protocol is required");
          buf[offset++] = 10;
          encodings.string.encode(obj.protocol, buf, offset);
          offset += encodings.string.encode.bytes;
          if (defined(obj.metadata)) {
            buf[offset++] = 18;
            varint.encode(Metadata.encodingLength(obj.metadata), buf, offset);
            offset += varint.encode.bytes;
            Metadata.encode(obj.metadata, buf, offset);
            offset += Metadata.encode.bytes;
          }
          encode.bytes = offset - oldOffset;
          return buf;
        }
        function decode(buf, offset, end) {
          if (!offset) offset = 0;
          if (!end) end = buf.length;
          if (!(end <= buf.length && offset <= buf.length)) throw new Error("Decoded message is not valid");
          var oldOffset = offset;
          var obj = {
            protocol: "",
            metadata: null
          };
          var found0 = false;
          while (true) {
            if (end <= offset) {
              if (!found0) throw new Error("Decoded message is not valid");
              decode.bytes = offset - oldOffset;
              return obj;
            }
            var prefix = varint.decode(buf, offset);
            offset += varint.decode.bytes;
            var tag = prefix >> 3;
            switch (tag) {
              case 1:
                obj.protocol = encodings.string.decode(buf, offset);
                offset += encodings.string.decode.bytes;
                found0 = true;
                break;
              case 2:
                var len = varint.decode(buf, offset);
                offset += varint.decode.bytes;
                obj.metadata = Metadata.decode(buf, offset, offset + len);
                offset += Metadata.decode.bytes;
                break;
              default:
                offset = skip(prefix & 7, buf, offset);
            }
          }
        }
      }
      function defineNode() {
        Node.encodingLength = encodingLength;
        Node.encode = encode;
        Node.decode = decode;
        function encodingLength(obj) {
          var length = 0;
          if (!defined(obj.index)) throw new Error("index is required");
          var len = encodings.bytes.encodingLength(obj.index);
          length += 1 + len;
          if (!defined(obj.key)) throw new Error("key is required");
          var len = encodings.bytes.encodingLength(obj.key);
          length += 1 + len;
          if (defined(obj.value)) {
            var len = encodings.bytes.encodingLength(obj.value);
            length += 1 + len;
          }
          return length;
        }
        function encode(obj, buf, offset) {
          if (!offset) offset = 0;
          if (!buf) buf = b4a.allocUnsafe(encodingLength(obj));
          var oldOffset = offset;
          if (!defined(obj.index)) throw new Error("index is required");
          buf[offset++] = 10;
          encodings.bytes.encode(obj.index, buf, offset);
          offset += encodings.bytes.encode.bytes;
          if (!defined(obj.key)) throw new Error("key is required");
          buf[offset++] = 18;
          encodings.bytes.encode(obj.key, buf, offset);
          offset += encodings.bytes.encode.bytes;
          if (defined(obj.value)) {
            buf[offset++] = 26;
            encodings.bytes.encode(obj.value, buf, offset);
            offset += encodings.bytes.encode.bytes;
          }
          encode.bytes = offset - oldOffset;
          return buf;
        }
        function decode(buf, offset, end) {
          if (!offset) offset = 0;
          if (!end) end = buf.length;
          if (!(end <= buf.length && offset <= buf.length)) throw new Error("Decoded message is not valid");
          var oldOffset = offset;
          var obj = {
            index: null,
            key: null,
            value: null
          };
          var found0 = false;
          var found1 = false;
          while (true) {
            if (end <= offset) {
              if (!found0 || !found1) throw new Error("Decoded message is not valid");
              decode.bytes = offset - oldOffset;
              return obj;
            }
            var prefix = varint.decode(buf, offset);
            offset += varint.decode.bytes;
            var tag = prefix >> 3;
            switch (tag) {
              case 1:
                obj.index = encodings.bytes.decode(buf, offset);
                offset += encodings.bytes.decode.bytes;
                found0 = true;
                break;
              case 2:
                obj.key = encodings.bytes.decode(buf, offset);
                offset += encodings.bytes.decode.bytes;
                found1 = true;
                break;
              case 3:
                obj.value = encodings.bytes.decode(buf, offset);
                offset += encodings.bytes.decode.bytes;
                break;
              default:
                offset = skip(prefix & 7, buf, offset);
            }
          }
        }
      }
      function defineExtension() {
        var Get = Extension.Get = {
          buffer: true,
          encodingLength: null,
          encode: null,
          decode: null
        };
        var Iterator = Extension.Iterator = {
          buffer: true,
          encodingLength: null,
          encode: null,
          decode: null
        };
        var Cache = Extension.Cache = {
          buffer: true,
          encodingLength: null,
          encode: null,
          decode: null
        };
        defineGet();
        defineIterator();
        defineCache();
        function defineGet() {
          Get.encodingLength = encodingLength2;
          Get.encode = encode2;
          Get.decode = decode2;
          function encodingLength2(obj) {
            var length = 0;
            if (defined(obj.version)) {
              var len = encodings.varint.encodingLength(obj.version);
              length += 1 + len;
            }
            if (defined(obj.key)) {
              var len = encodings.bytes.encodingLength(obj.key);
              length += 1 + len;
            }
            return length;
          }
          function encode2(obj, buf, offset) {
            if (!offset) offset = 0;
            if (!buf) buf = b4a.allocUnsafe(encodingLength2(obj));
            var oldOffset = offset;
            if (defined(obj.version)) {
              buf[offset++] = 8;
              encodings.varint.encode(obj.version, buf, offset);
              offset += encodings.varint.encode.bytes;
            }
            if (defined(obj.key)) {
              buf[offset++] = 18;
              encodings.bytes.encode(obj.key, buf, offset);
              offset += encodings.bytes.encode.bytes;
            }
            encode2.bytes = offset - oldOffset;
            return buf;
          }
          function decode2(buf, offset, end) {
            if (!offset) offset = 0;
            if (!end) end = buf.length;
            if (!(end <= buf.length && offset <= buf.length)) throw new Error("Decoded message is not valid");
            var oldOffset = offset;
            var obj = {
              version: 0,
              key: null
            };
            while (true) {
              if (end <= offset) {
                decode2.bytes = offset - oldOffset;
                return obj;
              }
              var prefix = varint.decode(buf, offset);
              offset += varint.decode.bytes;
              var tag = prefix >> 3;
              switch (tag) {
                case 1:
                  obj.version = encodings.varint.decode(buf, offset);
                  offset += encodings.varint.decode.bytes;
                  break;
                case 2:
                  obj.key = encodings.bytes.decode(buf, offset);
                  offset += encodings.bytes.decode.bytes;
                  break;
                default:
                  offset = skip(prefix & 7, buf, offset);
              }
            }
          }
        }
        function defineIterator() {
          Iterator.encodingLength = encodingLength2;
          Iterator.encode = encode2;
          Iterator.decode = decode2;
          function encodingLength2(obj) {
            var length = 0;
            if (defined(obj.version)) {
              var len = encodings.varint.encodingLength(obj.version);
              length += 1 + len;
            }
            if (defined(obj.gte)) {
              var len = encodings.bytes.encodingLength(obj.gte);
              length += 1 + len;
            }
            if (defined(obj.gt)) {
              var len = encodings.bytes.encodingLength(obj.gt);
              length += 1 + len;
            }
            if (defined(obj.lte)) {
              var len = encodings.bytes.encodingLength(obj.lte);
              length += 1 + len;
            }
            if (defined(obj.lt)) {
              var len = encodings.bytes.encodingLength(obj.lt);
              length += 1 + len;
            }
            if (defined(obj.limit)) {
              var len = encodings.varint.encodingLength(obj.limit);
              length += 1 + len;
            }
            if (defined(obj.reverse)) {
              var len = encodings.bool.encodingLength(obj.reverse);
              length += 1 + len;
            }
            if (defined(obj.checkpoint)) {
              var packedLen = 0;
              for (var i = 0; i < obj.checkpoint.length; i++) {
                if (!defined(obj.checkpoint[i])) continue;
                var len = encodings.varint.encodingLength(obj.checkpoint[i]);
                packedLen += len;
              }
              if (packedLen) {
                length += 1 + packedLen + varint.encodingLength(packedLen);
              }
            }
            return length;
          }
          function encode2(obj, buf, offset) {
            if (!offset) offset = 0;
            if (!buf) buf = b4a.allocUnsafe(encodingLength2(obj));
            var oldOffset = offset;
            if (defined(obj.version)) {
              buf[offset++] = 8;
              encodings.varint.encode(obj.version, buf, offset);
              offset += encodings.varint.encode.bytes;
            }
            if (defined(obj.gte)) {
              buf[offset++] = 18;
              encodings.bytes.encode(obj.gte, buf, offset);
              offset += encodings.bytes.encode.bytes;
            }
            if (defined(obj.gt)) {
              buf[offset++] = 26;
              encodings.bytes.encode(obj.gt, buf, offset);
              offset += encodings.bytes.encode.bytes;
            }
            if (defined(obj.lte)) {
              buf[offset++] = 34;
              encodings.bytes.encode(obj.lte, buf, offset);
              offset += encodings.bytes.encode.bytes;
            }
            if (defined(obj.lt)) {
              buf[offset++] = 42;
              encodings.bytes.encode(obj.lt, buf, offset);
              offset += encodings.bytes.encode.bytes;
            }
            if (defined(obj.limit)) {
              buf[offset++] = 48;
              encodings.varint.encode(obj.limit, buf, offset);
              offset += encodings.varint.encode.bytes;
            }
            if (defined(obj.reverse)) {
              buf[offset++] = 56;
              encodings.bool.encode(obj.reverse, buf, offset);
              offset += encodings.bool.encode.bytes;
            }
            if (defined(obj.checkpoint)) {
              var packedLen = 0;
              for (var i = 0; i < obj.checkpoint.length; i++) {
                if (!defined(obj.checkpoint[i])) continue;
                packedLen += encodings.varint.encodingLength(obj.checkpoint[i]);
              }
              if (packedLen) {
                buf[offset++] = 66;
                varint.encode(packedLen, buf, offset);
                offset += varint.encode.bytes;
              }
              for (var i = 0; i < obj.checkpoint.length; i++) {
                if (!defined(obj.checkpoint[i])) continue;
                encodings.varint.encode(obj.checkpoint[i], buf, offset);
                offset += encodings.varint.encode.bytes;
              }
            }
            encode2.bytes = offset - oldOffset;
            return buf;
          }
          function decode2(buf, offset, end) {
            if (!offset) offset = 0;
            if (!end) end = buf.length;
            if (!(end <= buf.length && offset <= buf.length)) throw new Error("Decoded message is not valid");
            var oldOffset = offset;
            var obj = {
              version: 0,
              gte: null,
              gt: null,
              lte: null,
              lt: null,
              limit: 0,
              reverse: false,
              checkpoint: []
            };
            while (true) {
              if (end <= offset) {
                decode2.bytes = offset - oldOffset;
                return obj;
              }
              var prefix = varint.decode(buf, offset);
              offset += varint.decode.bytes;
              var tag = prefix >> 3;
              switch (tag) {
                case 1:
                  obj.version = encodings.varint.decode(buf, offset);
                  offset += encodings.varint.decode.bytes;
                  break;
                case 2:
                  obj.gte = encodings.bytes.decode(buf, offset);
                  offset += encodings.bytes.decode.bytes;
                  break;
                case 3:
                  obj.gt = encodings.bytes.decode(buf, offset);
                  offset += encodings.bytes.decode.bytes;
                  break;
                case 4:
                  obj.lte = encodings.bytes.decode(buf, offset);
                  offset += encodings.bytes.decode.bytes;
                  break;
                case 5:
                  obj.lt = encodings.bytes.decode(buf, offset);
                  offset += encodings.bytes.decode.bytes;
                  break;
                case 6:
                  obj.limit = encodings.varint.decode(buf, offset);
                  offset += encodings.varint.decode.bytes;
                  break;
                case 7:
                  obj.reverse = encodings.bool.decode(buf, offset);
                  offset += encodings.bool.decode.bytes;
                  break;
                case 8:
                  var packedEnd = varint.decode(buf, offset);
                  offset += varint.decode.bytes;
                  packedEnd += offset;
                  while (offset < packedEnd) {
                    obj.checkpoint.push(encodings.varint.decode(buf, offset));
                    offset += encodings.varint.decode.bytes;
                  }
                  break;
                default:
                  offset = skip(prefix & 7, buf, offset);
              }
            }
          }
        }
        function defineCache() {
          Cache.encodingLength = encodingLength2;
          Cache.encode = encode2;
          Cache.decode = decode2;
          function encodingLength2(obj) {
            var length = 0;
            if (!defined(obj.start)) throw new Error("start is required");
            var len = encodings.varint.encodingLength(obj.start);
            length += 1 + len;
            if (!defined(obj.end)) throw new Error("end is required");
            var len = encodings.varint.encodingLength(obj.end);
            length += 1 + len;
            if (defined(obj.blocks)) {
              var packedLen = 0;
              for (var i = 0; i < obj.blocks.length; i++) {
                if (!defined(obj.blocks[i])) continue;
                var len = encodings.varint.encodingLength(obj.blocks[i]);
                packedLen += len;
              }
              if (packedLen) {
                length += 1 + packedLen + varint.encodingLength(packedLen);
              }
            }
            return length;
          }
          function encode2(obj, buf, offset) {
            if (!offset) offset = 0;
            if (!buf) buf = b4a.allocUnsafe(encodingLength2(obj));
            var oldOffset = offset;
            if (!defined(obj.start)) throw new Error("start is required");
            buf[offset++] = 8;
            encodings.varint.encode(obj.start, buf, offset);
            offset += encodings.varint.encode.bytes;
            if (!defined(obj.end)) throw new Error("end is required");
            buf[offset++] = 16;
            encodings.varint.encode(obj.end, buf, offset);
            offset += encodings.varint.encode.bytes;
            if (defined(obj.blocks)) {
              var packedLen = 0;
              for (var i = 0; i < obj.blocks.length; i++) {
                if (!defined(obj.blocks[i])) continue;
                packedLen += encodings.varint.encodingLength(obj.blocks[i]);
              }
              if (packedLen) {
                buf[offset++] = 26;
                varint.encode(packedLen, buf, offset);
                offset += varint.encode.bytes;
              }
              for (var i = 0; i < obj.blocks.length; i++) {
                if (!defined(obj.blocks[i])) continue;
                encodings.varint.encode(obj.blocks[i], buf, offset);
                offset += encodings.varint.encode.bytes;
              }
            }
            encode2.bytes = offset - oldOffset;
            return buf;
          }
          function decode2(buf, offset, end) {
            if (!offset) offset = 0;
            if (!end) end = buf.length;
            if (!(end <= buf.length && offset <= buf.length)) throw new Error("Decoded message is not valid");
            var oldOffset = offset;
            var obj = {
              start: 0,
              end: 0,
              blocks: []
            };
            var found0 = false;
            var found1 = false;
            while (true) {
              if (end <= offset) {
                if (!found0 || !found1) throw new Error("Decoded message is not valid");
                decode2.bytes = offset - oldOffset;
                return obj;
              }
              var prefix = varint.decode(buf, offset);
              offset += varint.decode.bytes;
              var tag = prefix >> 3;
              switch (tag) {
                case 1:
                  obj.start = encodings.varint.decode(buf, offset);
                  offset += encodings.varint.decode.bytes;
                  found0 = true;
                  break;
                case 2:
                  obj.end = encodings.varint.decode(buf, offset);
                  offset += encodings.varint.decode.bytes;
                  found1 = true;
                  break;
                case 3:
                  var packedEnd = varint.decode(buf, offset);
                  offset += varint.decode.bytes;
                  packedEnd += offset;
                  while (offset < packedEnd) {
                    obj.blocks.push(encodings.varint.decode(buf, offset));
                    offset += encodings.varint.decode.bytes;
                  }
                  break;
                default:
                  offset = skip(prefix & 7, buf, offset);
              }
            }
          }
        }
        Extension.encodingLength = encodingLength;
        Extension.encode = encode;
        Extension.decode = decode;
        function encodingLength(obj) {
          var length = 0;
          if (defined(obj.cache)) {
            var len = Cache.encodingLength(obj.cache);
            length += varint.encodingLength(len);
            length += 1 + len;
          }
          if (defined(obj.get)) {
            var len = Get.encodingLength(obj.get);
            length += varint.encodingLength(len);
            length += 1 + len;
          }
          if (defined(obj.iterator)) {
            var len = Iterator.encodingLength(obj.iterator);
            length += varint.encodingLength(len);
            length += 1 + len;
          }
          return length;
        }
        function encode(obj, buf, offset) {
          if (!offset) offset = 0;
          if (!buf) buf = b4a.allocUnsafe(encodingLength(obj));
          var oldOffset = offset;
          if (defined(obj.cache)) {
            buf[offset++] = 10;
            varint.encode(Cache.encodingLength(obj.cache), buf, offset);
            offset += varint.encode.bytes;
            Cache.encode(obj.cache, buf, offset);
            offset += Cache.encode.bytes;
          }
          if (defined(obj.get)) {
            buf[offset++] = 18;
            varint.encode(Get.encodingLength(obj.get), buf, offset);
            offset += varint.encode.bytes;
            Get.encode(obj.get, buf, offset);
            offset += Get.encode.bytes;
          }
          if (defined(obj.iterator)) {
            buf[offset++] = 26;
            varint.encode(Iterator.encodingLength(obj.iterator), buf, offset);
            offset += varint.encode.bytes;
            Iterator.encode(obj.iterator, buf, offset);
            offset += Iterator.encode.bytes;
          }
          encode.bytes = offset - oldOffset;
          return buf;
        }
        function decode(buf, offset, end) {
          if (!offset) offset = 0;
          if (!end) end = buf.length;
          if (!(end <= buf.length && offset <= buf.length)) throw new Error("Decoded message is not valid");
          var oldOffset = offset;
          var obj = {
            cache: null,
            get: null,
            iterator: null
          };
          while (true) {
            if (end <= offset) {
              decode.bytes = offset - oldOffset;
              return obj;
            }
            var prefix = varint.decode(buf, offset);
            offset += varint.decode.bytes;
            var tag = prefix >> 3;
            switch (tag) {
              case 1:
                var len = varint.decode(buf, offset);
                offset += varint.decode.bytes;
                obj.cache = Cache.decode(buf, offset, offset + len);
                offset += Cache.decode.bytes;
                break;
              case 2:
                var len = varint.decode(buf, offset);
                offset += varint.decode.bytes;
                obj.get = Get.decode(buf, offset, offset + len);
                offset += Get.decode.bytes;
                break;
              case 3:
                var len = varint.decode(buf, offset);
                offset += varint.decode.bytes;
                obj.iterator = Iterator.decode(buf, offset, offset + len);
                offset += Iterator.decode.bytes;
                break;
              default:
                offset = skip(prefix & 7, buf, offset);
            }
          }
        }
      }
      function defined(val) {
        return val !== null && val !== void 0 && (typeof val !== "number" || !isNaN(val));
      }
    }
  });

  // ../../node_modules/hyperbee/lib/extension.js
  var require_extension = __commonJS({
    "../../node_modules/hyperbee/lib/extension.js"(exports, module) {
      var { Extension } = require_messages();
      var FLUSH_BATCH = 128;
      var MAX_PASSIVE_BATCH = 2048;
      var MAX_ACTIVE_BATCH = MAX_PASSIVE_BATCH + FLUSH_BATCH;
      var Batch = class {
        constructor(outgoing, from) {
          this.blocks = [];
          this.start = 0;
          this.end = 0;
          this.outgoing = outgoing;
          this.from = from;
        }
        push(seq) {
          const len = this.blocks.push(seq);
          if (len === 1 || seq < this.start) this.start = seq;
          if (len === 1 || seq >= this.end) this.end = seq + 1;
          if (len >= FLUSH_BATCH) {
            this.send();
            this.clear();
          }
        }
        send() {
          if (!this.blocks.length) return;
          this.outgoing.send(
            Extension.encode({
              cache: { blocks: this.blocks, start: this.start, end: this.end }
            }),
            this.from
          );
        }
        clear() {
          this.start = this.end = 0;
          this.blocks = [];
        }
      };
      var HyperbeeExtension = class {
        constructor(db) {
          this.encoding = null;
          this.outgoing = null;
          this.db = db;
          this.active = 0;
        }
        get(version, key) {
          this.outgoing.broadcast(Extension.encode({ get: { version, key } }));
        }
        iterator(snapshot) {
          if (snapshot.ended) return;
          if (snapshot.limit === 0) return;
          if (snapshot.limit === -1) snapshot.limit = 0;
          this.outgoing.broadcast(Extension.encode({ iterator: snapshot }));
        }
        onmessage(buf, from) {
          const message = decode(buf);
          if (!message) return;
          if (message.cache) this.oncache(message.cache, from);
          if (message.get) this.onget(message.get, from);
          if (message.iterator) this.oniterator(message.iterator, from);
        }
        oncache(message, from) {
          if (!message.blocks.length) return;
          this.db.core.download(message);
        }
        onget(message, from) {
          if (!message.version || message.version > this.db.version) return;
          const b = new Batch(this.outgoing, from);
          const db = this.db.checkout(message.version);
          db.get(message.key, {
            extension: false,
            wait: false,
            update: false,
            onseq
          }).then(done, done);
          function done() {
            db.close().catch(noop);
            b.send();
          }
          function onseq(seq) {
            b.push(seq);
          }
        }
        async oniterator(message, from) {
          if (!message.version || message.version > this.db.version) return;
          const b = new Batch(this.outgoing, from);
          const seqs = /* @__PURE__ */ new Set();
          let skip = message.checkpoint.length;
          let work = 0;
          const db = this.db.checkout(message.version);
          const ite = db.createRangeIterator({
            ...message,
            wait: false,
            extension: false,
            update: false,
            limit: message.limit === 0 ? -1 : message.limit,
            onseq(seq) {
              if (skip && skip--) return;
              if (seqs.has(seq)) return;
              work++;
              seqs.add(seq);
              b.push(seq);
            }
          });
          try {
            await ite.open();
            while (work < MAX_ACTIVE_BATCH) {
              if (!await ite.next()) break;
            }
          } catch (_) {
          } finally {
            ite.close().catch(noop);
            db.close().catch(noop);
            b.send();
          }
        }
        static register(db) {
          const e = new this(db);
          e.outgoing = db.core.registerExtension("hyperbee", e);
          return e;
        }
      };
      HyperbeeExtension.BATCH_SIZE = MAX_PASSIVE_BATCH;
      module.exports = HyperbeeExtension;
      function decode(buf) {
        try {
          return Extension.decode(buf);
        } catch (err) {
          return null;
        }
      }
      function noop() {
      }
    }
  });

  // ../../node_modules/z32/index.js
  var require_z32 = __commonJS({
    "../../node_modules/z32/index.js"(exports) {
      var b4a = require_b4a();
      var ALPHABET = "ybndrfg8ejkmcpqxot1uwisza345h769";
      var MIN = 49;
      var MAX = 122;
      var REVERSE = new Int8Array(1 + MAX - MIN);
      REVERSE.fill(-1);
      for (let i = 0; i < ALPHABET.length; i++) {
        const v = ALPHABET.charCodeAt(i) - MIN;
        REVERSE[v] = i;
      }
      exports.encode = encode;
      exports.decode = decode;
      exports.ALPHABET = ALPHABET;
      function decode(s, out) {
        let pb = 0;
        let ps = 0;
        const r = s.length & 7;
        const q = (s.length - r) / 8;
        if (!out) out = b4a.allocUnsafe(Math.ceil(s.length * 5 / 8));
        for (let i = 0; i < q; i++) {
          const a2 = quintet(s, ps++);
          const b2 = quintet(s, ps++);
          const c2 = quintet(s, ps++);
          const d2 = quintet(s, ps++);
          const e2 = quintet(s, ps++);
          const f2 = quintet(s, ps++);
          const g2 = quintet(s, ps++);
          const h2 = quintet(s, ps++);
          out[pb++] = a2 << 3 | b2 >>> 2;
          out[pb++] = (b2 & 3) << 6 | c2 << 1 | d2 >>> 4;
          out[pb++] = (d2 & 15) << 4 | e2 >>> 1;
          out[pb++] = (e2 & 1) << 7 | f2 << 2 | g2 >>> 3;
          out[pb++] = (g2 & 7) << 5 | h2;
        }
        if (r === 0) return out.subarray(0, pb);
        const a = quintet(s, ps++);
        const b = quintet(s, ps++);
        out[pb++] = a << 3 | b >>> 2;
        if (r <= 2) return out.subarray(0, pb);
        const c = quintet(s, ps++);
        const d = quintet(s, ps++);
        out[pb++] = (b & 3) << 6 | c << 1 | d >>> 4;
        if (r <= 4) return out.subarray(0, pb);
        const e = quintet(s, ps++);
        out[pb++] = (d & 15) << 4 | e >>> 1;
        if (r <= 5) return out.subarray(0, pb);
        const f = quintet(s, ps++);
        const g = quintet(s, ps++);
        out[pb++] = (e & 1) << 7 | f << 2 | g >>> 3;
        if (r <= 7) return out.subarray(0, pb);
        const h = quintet(s, ps++);
        out[pb++] = (g & 7) << 5 | h;
        return out.subarray(0, pb);
      }
      function encode(buf) {
        if (typeof buf === "string") buf = b4a.from(buf);
        const max = buf.byteLength * 8;
        let s = "";
        for (let p = 0; p < max; p += 5) {
          const i = p >>> 3;
          const j = p & 7;
          if (j <= 3) {
            s += ALPHABET[buf[i] >>> 3 - j & 31];
            continue;
          }
          const of = j - 3;
          const h = buf[i] << of & 31;
          const l = (i >= buf.byteLength ? 0 : buf[i + 1]) >>> 8 - of;
          s += ALPHABET[h | l];
        }
        return s;
      }
      function quintet(s, i) {
        if (i > s.length) {
          return 0;
        }
        const v = s.charCodeAt(i);
        if (v < MIN || v > MAX) {
          throw Error('Invalid character in base32 input: "' + s[i] + '" at position ' + i);
        }
        const bits = REVERSE[v - MIN];
        if (bits === -1) {
          throw Error('Invalid character in base32 input: "' + s[i] + '" at position ' + i);
        }
        return bits;
      }
    }
  });

  // ../../node_modules/hypercore-id-encoding/index.js
  var require_hypercore_id_encoding = __commonJS({
    "../../node_modules/hypercore-id-encoding/index.js"(exports, module) {
      var z32 = require_z32();
      var b4a = require_b4a();
      module.exports = {
        encode,
        decode,
        normalize,
        isValid
      };
      function encode(key) {
        if (!b4a.isBuffer(key)) throw new Error("Key must be a Buffer");
        if (key.byteLength !== 32) throw new Error("Key must be 32-bytes long");
        return z32.encode(key);
      }
      function decode(id) {
        if (b4a.isBuffer(id)) {
          if (id.byteLength !== 32) throw new Error("ID must be 32-bytes long");
          return id;
        }
        if (typeof id === "string") {
          if (id.startsWith("pear://")) id = id.slice(7).split("/")[0];
          if (id.length === 52) return z32.decode(id);
          if (id.length === 64) {
            const buf = b4a.from(id, "hex");
            if (buf.byteLength === 32) return buf;
          }
        }
        throw new Error("Invalid Hypercore key");
      }
      function normalize(any) {
        return encode(decode(any));
      }
      function isValid(any) {
        try {
          decode(any);
          return true;
        } catch {
          return false;
        }
      }
    }
  });

  // ../../node_modules/hypercore-errors/index.js
  var require_hypercore_errors = __commonJS({
    "../../node_modules/hypercore-errors/index.js"(exports, module) {
      var IdEnc = require_hypercore_id_encoding();
      module.exports = class HypercoreError extends Error {
        constructor(msg, code, fn = HypercoreError, discoveryKey = null) {
          if (discoveryKey) msg = `${msg} (discovery key: ${IdEnc.normalize(discoveryKey)})`;
          super(`${code}: ${msg}`);
          this.code = code;
          this.discoveryKey = discoveryKey;
          if (Error.captureStackTrace) {
            Error.captureStackTrace(this, fn);
          }
        }
        get name() {
          return "HypercoreError";
        }
        static ASSERTION(msg, discoveryKey = null) {
          return new HypercoreError(msg, "ERR_ASSERTION", HypercoreError.ASSERT, discoveryKey);
        }
        static BAD_ARGUMENT(msg, discoveryKey = null) {
          return new HypercoreError(msg, "BAD_ARGUMENT", HypercoreError.BAD_ARGUMENT, discoveryKey);
        }
        static STORAGE_EMPTY(msg, discoveryKey = null) {
          return new HypercoreError(msg, "STORAGE_EMPTY", HypercoreError.STORAGE_EMPTY, discoveryKey);
        }
        static STORAGE_CONFLICT(msg, discoveryKey = null) {
          return new HypercoreError(msg, "STORAGE_CONFLICT", HypercoreError.STORAGE_CONFLICT, discoveryKey);
        }
        static INVALID_SIGNATURE(msg, discoveryKey = null) {
          return new HypercoreError(msg, "INVALID_SIGNATURE", HypercoreError.INVALID_SIGNATURE, discoveryKey);
        }
        static INVALID_CAPABILITY(msg, discoveryKey = null) {
          return new HypercoreError(msg, "INVALID_CAPABILITY", HypercoreError.INVALID_CAPABILITY, discoveryKey);
        }
        static INVALID_CHECKSUM(msg = "Invalid checksum", discoveryKey = null) {
          return new HypercoreError(msg, "INVALID_CHECKSUM", HypercoreError.INVALID_CHECKSUM, discoveryKey);
        }
        static INVALID_OPERATION(msg, discoveryKey = null) {
          return new HypercoreError(msg, "INVALID_OPERATION", HypercoreError.INVALID_OPERATION, discoveryKey);
        }
        static INVALID_PROOF(msg = "Proof not verifiable", discoveryKey = null) {
          return new HypercoreError(msg, "INVALID_PROOF", HypercoreError.INVALID_PROOF, discoveryKey);
        }
        static BLOCK_NOT_AVAILABLE(msg = "Block is not available", discoveryKey = null) {
          return new HypercoreError(msg, "BLOCK_NOT_AVAILABLE", HypercoreError.BLOCK_NOT_AVAILABLE, discoveryKey);
        }
        static SNAPSHOT_NOT_AVAILABLE(msg = "Snapshot is not available", discoveryKey = null) {
          return new HypercoreError(msg, "SNAPSHOT_NOT_AVAILABLE", HypercoreError.SNAPSHOT_NOT_AVAILABLE, discoveryKey);
        }
        static REQUEST_CANCELLED(msg = "Request was cancelled", discoveryKey = null) {
          return new HypercoreError(msg, "REQUEST_CANCELLED", HypercoreError.REQUEST_CANCELLED, discoveryKey);
        }
        static REQUEST_TIMEOUT(msg = "Request timed out", discoveryKey = null) {
          return new HypercoreError(msg, "REQUEST_TIMEOUT", HypercoreError.REQUEST_TIMEOUT, discoveryKey);
        }
        static SESSION_NOT_WRITABLE(msg = "Session is not writable", discoveryKey = null) {
          return new HypercoreError(msg, "SESSION_NOT_WRITABLE", HypercoreError.SESSION_NOT_WRITABLE, discoveryKey);
        }
        static SESSION_CLOSED(msg = "Session is closed", discoveryKey = null) {
          return new HypercoreError(msg, "SESSION_CLOSED", HypercoreError.SESSION_CLOSED, discoveryKey);
        }
        static BATCH_UNFLUSHED(msg = "Batch not yet flushed", discoveryKey = null) {
          return new HypercoreError(msg, "BATCH_UNFLUSHED", HypercoreError.BATCH_UNFLUSHED, discoveryKey);
        }
        static BATCH_ALREADY_EXISTS(msg = "Batch already exists", discoveryKey = null) {
          return new HypercoreError(msg, "BATCH_ALREADY_EXISTS", HypercoreError.BATCH_ALREADY_EXISTS, discoveryKey);
        }
        static BATCH_ALREADY_FLUSHED(msg = "Batch has already been flushed", discoveryKey = null) {
          return new HypercoreError(msg, "BATCH_ALREADY_FLUSHED", HypercoreError.BATCH_ALREADY_FLUSHED, discoveryKey);
        }
        static OPLOG_CORRUPT(msg = "Oplog file appears corrupt or out of date", discoveryKey = null) {
          return new HypercoreError(msg, "OPLOG_CORRUPT", HypercoreError.OPLOG_CORRUPT, discoveryKey);
        }
        static OPLOG_HEADER_OVERFLOW(msg = "Oplog header exceeds page size", discoveryKey = null) {
          return new HypercoreError(msg, "OPLOG_HEADER_OVERFLOW", HypercoreError.OPLOG_HEADER_OVERFLOW, discoveryKey);
        }
        static INVALID_OPLOG_VERSION(msg = "Invalid header version", discoveryKey = null) {
          return new HypercoreError(msg, "INVALID_OPLOG_VERSION", HypercoreError.INVALID_OPLOG_VERSION, discoveryKey);
        }
        static WRITE_FAILED(msg = "Write to storage failed", discoveryKey = null) {
          return new HypercoreError(msg, "WRITE_FAILED", HypercoreError.WRITE_FAILED, discoveryKey);
        }
        static DECODING_ERROR(msg = "Decoding error", discoveryKey = null) {
          return new HypercoreError(msg, "DECODING_ERROR", HypercoreError.DECODING_ERROR, discoveryKey);
        }
        static SESSION_MOVED(msg = "Session moved", discoveryKey = null) {
          return new HypercoreError(msg, "SESSION_MOVED", HypercoreError.SESSION_MOVED, discoveryKey);
        }
      };
    }
  });

  // ../../node_modules/hyperbee/index.js
  var require_hyperbee = __commonJS({
    "../../node_modules/hyperbee/index.js"(exports, module) {
      var codecs = require_codecs();
      var { Readable } = require_streamx();
      var mutexify = require_promise();
      var b4a = require_b4a();
      var safetyCatch = require_safety_catch();
      var ReadyResource = require_ready_resource();
      var debounce = require_debounceify();
      var Rache = require_rache();
      var rrp = require_resolve_reject_promise();
      var { all: unslabAll } = require_unslab();
      var RangeIterator = require_range3();
      var HistoryIterator = require_history();
      var DiffIterator = require_diff();
      var LocalBlockIterator = require_local();
      var Extension = require_extension();
      var { YoloIndex, Node, Header } = require_messages();
      var { BLOCK_NOT_AVAILABLE, DECODING_ERROR } = require_hypercore_errors();
      var T = 5;
      var MIN_KEYS = T - 1;
      var MAX_CHILDREN = MIN_KEYS * 2 + 1;
      var SEP = b4a.alloc(1);
      var EMPTY = b4a.alloc(0);
      var Key = class {
        constructor(seq, value) {
          this.seq = seq;
          this.value = value;
        }
      };
      var Child = class {
        constructor(seq, offset, value) {
          this.seq = seq;
          this.offset = offset;
          this.value = value;
        }
      };
      var Cache = class {
        constructor(rache) {
          this.keys = rache;
          this.length = 0;
        }
        get(seq) {
          return this.keys.get(seq) || null;
        }
        set(seq, key) {
          this.keys.set(seq, key);
          if (seq >= this.length) this.length = seq + 1;
        }
        gc(length) {
          if (this.length - length > 128) {
            this.keys.clear();
          } else {
            for (let i = length; i < this.length; i++) {
              this.keys.delete(i);
            }
          }
          this.length = length;
        }
        clear() {
          this.keys.clear();
        }
      };
      var Pointers = class {
        constructor(decoded) {
          this.levels = decoded.levels.map((l) => {
            const children = [];
            const keys = [];
            for (let i = 0; i < l.keys.length; i++) {
              keys.push(new Key(l.keys[i], null));
            }
            for (let i = 0; i < l.children.length; i += 2) {
              children.push(new Child(l.children[i], l.children[i + 1], null));
            }
            return { keys, children };
          });
        }
        get(i) {
          return this.levels[i];
        }
        hasKey(seq) {
          for (const lvl of this.levels) {
            for (const key of lvl.keys) {
              if (key.seq === seq) return true;
            }
          }
          return false;
        }
      };
      function inflate(entry) {
        if (entry.inflated === null) {
          entry.inflated = YoloIndex.decode(entry.index);
          entry.index = null;
        }
        return new Pointers(entry.inflated);
      }
      function deflate(index) {
        const levels = index.map((l) => {
          const keys = [];
          const children = [];
          for (let i = 0; i < l.value.keys.length; i++) {
            keys.push(l.value.keys[i].seq);
          }
          for (let i = 0; i < l.value.children.length; i++) {
            children.push(l.value.children[i].seq, l.value.children[i].offset);
          }
          return { keys, children };
        });
        return YoloIndex.encode({ levels });
      }
      var TreeNode = class _TreeNode {
        constructor(block, keys, children, offset) {
          this.block = block;
          this.offset = offset;
          this.keys = keys;
          this.children = children;
          this.changed = false;
          this.preload();
        }
        preload() {
          if (this.block === null) return;
          const core = getBackingCore(this.block.tree.core);
          if (!core) return;
          const bitfield = core.core.bitfield;
          const blocks = [];
          for (let i = 0; i < this.keys.length; i++) {
            const k = this.keys[i];
            if (k.value) continue;
            if (k.seq >= core.signedLength || bitfield && bitfield.get(k.seq)) continue;
            blocks.push(k.seq);
          }
          for (let i = 0; i < this.children.length; i++) {
            const c = this.children[i];
            if (c.value) continue;
            if (c.seq >= core.signedLength || bitfield && bitfield.get(c.seq)) continue;
            blocks.push(c.seq);
          }
          if (blocks.length) core.download({ blocks });
        }
        async insertKey(key, value, child, node, encoding, cas) {
          let s = 0;
          let e = this.keys.length;
          let c;
          while (s < e) {
            const mid = s + e >> 1;
            c = b4a.compare(key.value, await this.getKey(mid));
            if (c === 0) {
              if (cas) {
                const prev = await this.getKeyNode(mid);
                if (!await cas(prev.final(encoding), node)) return true;
              }
              if (!this.block.tree.tree.alwaysDuplicate) {
                const prev = await this.getKeyNode(mid);
                if (sameValue(prev.value, value)) return true;
              }
              this.changed = true;
              this.keys[mid] = key;
              return true;
            }
            if (c < 0) e = mid;
            else s = mid + 1;
          }
          const i = c < 0 ? e : s;
          this.keys.splice(i, 0, key);
          if (child) this.children.splice(i + 1, 0, new Child(0, 0, child));
          this.changed = true;
          return this.keys.length < MAX_CHILDREN;
        }
        removeKey(index) {
          this.keys.splice(index, 1);
          if (this.children.length) {
            this.children[index + 1].seq = 0;
            this.children.splice(index + 1, 1);
          }
          this.changed = true;
        }
        async siblings(parent) {
          for (let i = 0; i < parent.children.length; i++) {
            if (parent.children[i].value === this) {
              const [left, right] = await Promise.all([
                i ? parent.getChildNode(i - 1) : null,
                i < parent.children.length - 1 ? parent.getChildNode(i + 1) : null
              ]);
              return { left, index: i, right };
            }
          }
          throw new Error("Bad parent");
        }
        merge(node, median) {
          this.changed = true;
          this.keys.push(median);
          for (let i = 0; i < node.keys.length; i++) this.keys.push(node.keys[i]);
          for (let i = 0; i < node.children.length; i++) this.children.push(node.children[i]);
        }
        async split() {
          const len = this.keys.length >> 1;
          const right = _TreeNode.create(this.block);
          while (right.keys.length < len) right.keys.push(this.keys.pop());
          right.keys.reverse();
          await this.getKey(this.keys.length - 1);
          const median = this.keys.pop();
          if (this.children.length) {
            while (right.children.length < len + 1) right.children.push(this.children.pop());
            right.children.reverse();
          }
          this.changed = true;
          return {
            left: this,
            median,
            right
          };
        }
        getKeyNode(index) {
          return this.block.tree.getBlock(this.keys[index].seq);
        }
        async getChildNode(index) {
          const child = this.children[index];
          if (child.value) return child.value;
          const block = child.seq === this.block.seq ? this.block : await this.block.tree.getBlock(child.seq);
          return child.value = block.getTreeNode(child.offset);
        }
        setKey(index, key) {
          this.keys[index] = key;
          this.changed = true;
        }
        async getKey(index) {
          const key = this.keys[index];
          if (key.value) return key.value;
          const k = key.seq === this.block.seq ? this.block.key : await this.block.tree.getKey(key.seq);
          return key.value = k;
        }
        indexChanges(index, seq) {
          const offset = index.push(null) - 1;
          this.changed = false;
          for (const child of this.children) {
            if (!child.value || !child.value.changed) continue;
            child.seq = seq;
            child.offset = child.value.indexChanges(index, seq);
            index[child.offset] = child;
          }
          return offset;
        }
        updateChildren(seq, block) {
          for (const child of this.children) {
            if (!child.value || child.seq !== seq) continue;
            child.value.block = block;
            child.value.updateChildren(seq, block);
          }
        }
        static create(block) {
          const node = new _TreeNode(block, [], [], 0);
          node.changed = true;
          return node;
        }
      };
      var BlockEntry = class {
        constructor(seq, tree, entry) {
          this.seq = seq;
          this.tree = tree;
          this.index = null;
          this.entry = entry;
          this.key = entry.key;
          this.value = entry.value;
        }
        isTarget(key) {
          return b4a.equals(this.key, key);
        }
        inflate() {
          if (this.index === null) {
            this.index = inflate(this.entry);
          }
        }
        isDeletion() {
          if (this.value !== null) return false;
          if (this.index === null) {
            this.index = inflate(this.entry);
          }
          return !this.index.hasKey(this.seq);
        }
        final(encoding) {
          return {
            seq: this.seq,
            key: encoding.key ? encoding.key.decode(this.key) : this.key,
            value: this.value && (encoding.value ? encoding.value.decode(this.value) : this.value)
          };
        }
        getTreeNode(offset) {
          if (this.index === null) {
            this.index = inflate(this.entry);
          }
          const entry = this.index.get(offset);
          return new TreeNode(this, entry.keys, entry.children, offset);
        }
      };
      var CacheLock = class {
        constructor() {
          this.map = /* @__PURE__ */ new Map();
        }
        enter(seq) {
          const pending = this.map.get(seq);
          if (!pending) {
            this.map.set(seq, []);
            return Promise.resolve();
          }
          const { resolve, promise } = rrp();
          pending.push(resolve);
          return promise;
        }
        exit(seq) {
          const pending = this.map.get(seq);
          if (!pending.length) {
            this.map.delete(seq);
            return;
          }
          pending.pop()();
        }
      };
      var BatchEntry = class extends BlockEntry {
        constructor(seq, tree, key, value, index) {
          super(seq, tree, { key, value, index: null, inflated: null });
          this.pendingIndex = index;
        }
        isTarget(key) {
          return false;
        }
        getTreeNode(offset) {
          return this.pendingIndex[offset].value;
        }
      };
      var Hyperbee = class _Hyperbee extends ReadyResource {
        constructor(core, opts = {}) {
          super();
          this.feed = core;
          this.core = core;
          this.keyEncoding = opts.keyEncoding ? codecs(opts.keyEncoding) : null;
          this.valueEncoding = opts.valueEncoding ? codecs(opts.valueEncoding) : null;
          this.extension = opts.extension !== false ? getExtension(this, opts) : null;
          this.metadata = opts.metadata || null;
          this.lock = opts.lock || mutexify();
          this.sep = opts.sep || SEP;
          this.readonly = !!opts.readonly;
          this.prefix = opts.prefix || null;
          this.alwaysDuplicate = opts.alwaysDuplicate !== false;
          this._unprefixedKeyEncoding = this.keyEncoding;
          this._sub = !!this.prefix;
          this._checkout = opts.checkout || 0;
          this._view = !!opts._view;
          this._onappendBound = this._view ? null : this._onappend.bind(this);
          this._ontruncateBound = this._view ? null : this._ontruncate.bind(this);
          this._watchers = this._onappendBound ? [] : null;
          this._entryWatchers = this._onappendBound ? [] : null;
          this._sessions = opts.sessions !== false;
          this._keyCache = null;
          this._nodeCache = null;
          this._cacheLock = new CacheLock();
          this._batches = [];
          if (this._watchers) {
            this.core.on("append", this._onappendBound);
            this.core.on("truncate", this._ontruncateBound);
          }
          if (this.prefix && opts._sub) {
            this.keyEncoding = prefixEncoding(this.prefix, this.keyEncoding);
          }
          this.ready().catch(safetyCatch);
        }
        async _open() {
          if (this.core.opened === false) await this.core.ready();
          if (this._watchers && this.core.replicator.setInflightRange) {
            this.core.replicator.setInflightRange(256, 512);
          }
          if (this._checkout === -1) this._checkout = Math.max(1, this.core.length);
          const baseCache = Rache.from(this.core.globalCache);
          this._keyCache = new Cache(baseCache);
          this._nodeCache = new Cache(Rache.from(baseCache));
        }
        get version() {
          return Math.max(1, this._checkout || this.core.length);
        }
        get id() {
          return this.core.id;
        }
        get key() {
          return this.core.key;
        }
        get discoveryKey() {
          return this.core.discoveryKey;
        }
        get writable() {
          return this.core.writable;
        }
        get readable() {
          return this.core.readable;
        }
        replicate(isInitiator, opts) {
          return this.core.replicate(isInitiator, opts);
        }
        update(opts) {
          return this.core.update(opts);
        }
        peek(range, opts) {
          return iteratorPeek(this.createRangeIterator(range, { ...opts, limit: 1 }));
        }
        createRangeIterator(range, opts = {}) {
          opts = opts ? { ...opts, ...range } : range;
          const extension = opts.extension === false && opts.limit !== 0 ? null : this.extension;
          const keyEncoding = opts.keyEncoding ? codecs(opts.keyEncoding) : this.keyEncoding;
          if (extension) {
            const { onseq, onwait } = opts;
            let version = 0;
            let next = 0;
            opts = encRange(keyEncoding, {
              ...opts,
              sub: this._sub,
              onseq(seq) {
                if (!version) version = seq + 1;
                if (next) next--;
                if (onseq) onseq(seq);
              },
              onwait(seq) {
                if (!next) {
                  next = Extension.BATCH_SIZE;
                  extension.iterator(ite.snapshot(version));
                }
                if (onwait) onwait(seq);
              }
            });
          } else {
            opts = encRange(keyEncoding, { ...opts, sub: this._sub });
          }
          const ite = new RangeIterator(
            new Batch(this, this._makeSnapshot(), null, false, opts),
            null,
            opts
          );
          return ite;
        }
        createReadStream(range, opts) {
          const signal = opts && opts.signal || null;
          return iteratorToStream(this.createRangeIterator(range, opts), signal);
        }
        createHistoryStream(opts) {
          const session = opts && opts.live ? this.core.session() : this._makeSnapshot();
          const signal = opts && opts.signal || null;
          return iteratorToStream(
            new HistoryIterator(new Batch(this, session, null, false, opts), opts),
            signal
          );
        }
        createDiffStream(right, range, opts) {
          if (typeof right === "number") right = this.checkout(Math.max(1, right), { reuseSession: true });
          opts = opts ? { ...opts, ...range } : range;
          const signal = opts && opts.signal || null;
          const keyEncoding = opts && opts.keyEncoding ? codecs(opts.keyEncoding) : this.keyEncoding;
          if (keyEncoding) opts = encRange(keyEncoding, { ...opts, sub: this._sub });
          let done;
          let closing;
          let ite;
          const left = this;
          const rs = new Readable({
            signal,
            eagerOpen: true,
            async open(cb) {
              try {
                if (right.opened === false) await right.ready();
                if (left.opened === false) await left.ready();
              } catch (err) {
                cb(err);
                return;
              }
              if (closing) {
                cb(null);
                return;
              }
              if (left.core.closing || right.core.closing) {
                cb(new Error("Bee closed"));
                return;
              }
              const snapshot = right.version > left.version ? right._makeSnapshot() : left._makeSnapshot();
              done = cb;
              ite = new DiffIterator(
                new Batch(left, snapshot, null, false, opts),
                new Batch(right, snapshot, null, false, opts),
                opts
              );
              ite.open().then(fin, fin);
            },
            read(cb) {
              done = cb;
              ite.next().then(push, fin);
            },
            predestroy() {
              if (!ite) {
                closing = Promise.resolve();
              } else {
                closing = ite.close();
                closing.catch(noop);
              }
            },
            destroy(cb) {
              done = cb;
              if (!closing) closing = ite.close();
              closing.then(fin, fin);
            }
          });
          return rs;
          function fin(err) {
            done(err);
          }
          function push(val) {
            rs.push(val);
            done(null);
          }
        }
        get(key, opts) {
          const b = new Batch(this, this._makeSnapshot(), null, true, opts);
          return b.get(key);
        }
        getBySeq(seq, opts) {
          const b = new Batch(this, this._makeSnapshot(), null, true, opts);
          return b.getBySeq(seq);
        }
        put(key, value, opts) {
          const b = new Batch(this, this.core, null, true, opts);
          return b.put(key, value, opts);
        }
        batch(opts) {
          return new Batch(this, this.core, mutexify(), true, opts);
        }
        del(key, opts) {
          const b = new Batch(this, this.core, null, true, opts);
          return b.del(key, opts);
        }
        watch(range, opts) {
          if (!this._watchers) throw new Error("Can only watch the main bee instance");
          return new Watcher(this, range, opts);
        }
        async getAndWatch(key, opts) {
          if (!this._watchers) throw new Error("Can only watch the main bee instance");
          const watcher = new EntryWatcher(this, key, opts);
          await watcher._debouncedUpdate();
          if (this.closing) {
            await watcher.close();
            throw new Error("Bee closed");
          }
          return watcher;
        }
        _onappend() {
          for (const watcher of this._watchers) {
            watcher._onappend();
          }
          for (const watcher of this._entryWatchers) {
            watcher._onappend();
          }
        }
        _ontruncate(length) {
          for (const watcher of this._watchers) {
            watcher._ontruncate();
          }
          for (const watcher of this._entryWatchers) {
            watcher._ontruncate();
          }
          this._nodeCache.gc(length);
          this._keyCache.gc(length);
        }
        _makeSnapshot() {
          if (this._sessions === false) return this.core;
          return this._checkout <= this.core.length || this._checkout <= 1 ? this.core.snapshot() : this.core.session({ snapshot: false });
        }
        async clearUnlinked(options = {}) {
          await this.ready();
          const { gte = 0, lt = this.version - 1, batchSize = 4096, wait = true } = options;
          const checkout = this.version;
          let prev = this.batch({ wait: false, checkout: gte });
          let b = this.batch({ wait, checkout });
          const iteBatch = this.batch({ wait: false, checkout });
          const ite = new LocalBlockIterator(iteBatch, { gte, lt });
          await ite.open();
          let ticks = 0;
          while (true) {
            const data = await ite.next();
            if (!data) break;
            if (!await isLinked(b, data)) {
              if (b.core.closing || this.core.closing || this.closing) break;
              await this.core.clear(data.seq);
            }
            const prevNode = await prev.get(data.key, { finalize: false }).catch(toNull);
            if (prevNode && !await isLinked(b, prevNode)) {
              if (b.core.closing || this.core.closing || this.closing) break;
              await this.core.clear(prevNode.seq);
            }
            if (ticks++ >= batchSize) {
              ticks = 0;
              await prev.close();
              await b.close();
              prev = this.batch({ wait: false, checkout: gte });
              b = this.batch({ wait, checkout });
            }
          }
          if (b.core.closing || this.core.closing || this.closing) throw new Error("Core is closed");
          await b.close();
          await prev.close();
          await ite.close();
          await iteBatch.close();
          return lt;
        }
        checkout(version, opts = {}) {
          if (version === 0) version = 1;
          const snap = opts.reuseSession || this._sessions === false ? this.core : version <= this.core.length || version <= 1 ? this.core.snapshot() : this.core.session({ snapshot: false });
          return new _Hyperbee(snap, {
            _view: true,
            _sub: false,
            prefix: this.prefix,
            sep: this.sep,
            lock: this.lock,
            checkout: version,
            keyEncoding: opts.keyEncoding || this.keyEncoding,
            valueEncoding: opts.valueEncoding || this.valueEncoding,
            extension: this.extension !== null ? this.extension : false
          });
        }
        snapshot(opts) {
          return this.checkout(
            this.core.opened === false || this._checkout <= 0 ? -1 : Math.max(1, this.version),
            opts
          );
        }
        sub(prefix, opts = {}) {
          let sep = opts.sep || this.sep;
          if (!b4a.isBuffer(sep)) sep = b4a.from(sep);
          prefix = b4a.concat([this.prefix || EMPTY, b4a.from(prefix), sep]);
          const valueEncoding = codecs(opts.valueEncoding || this.valueEncoding);
          const keyEncoding = codecs(opts.keyEncoding || this._unprefixedKeyEncoding);
          return new _Hyperbee(this.core, {
            _view: true,
            _sub: true,
            prefix,
            sep: this.sep,
            lock: this.lock,
            checkout: this._checkout,
            valueEncoding,
            keyEncoding,
            extension: this.extension !== null ? this.extension : false,
            metadata: this.metadata
          });
        }
        async getHeader(opts) {
          const blk = await this.core.get(0, opts);
          try {
            return blk && Header.decode(blk);
          } catch {
            throw DECODING_ERROR();
          }
        }
        async _close() {
          if (!this._view) {
            if (this._keyCache) this._keyCache.clear();
            if (this._nodeCache) this._nodeCache.clear();
          }
          if (this._watchers) {
            this.core.off("append", this._onappendBound);
            this.core.off("truncate", this._ontruncateBound);
            while (this._watchers.length) {
              await this._watchers[this._watchers.length - 1].close();
            }
          }
          if (this._entryWatchers) {
            while (this._entryWatchers.length) {
              await this._entryWatchers[this._entryWatchers.length - 1].close();
            }
          }
          while (this._batches.length) {
            await this._batches[this._batches.length - 1].close();
          }
          return this.core.close();
        }
        static async isHyperbee(core, opts) {
          await core.ready();
          const blk0 = await core.get(0, opts);
          if (blk0 === null) throw BLOCK_NOT_AVAILABLE();
          try {
            return Header.decode(blk0).protocol === "hyperbee";
          } catch (err) {
            return false;
          }
        }
      };
      var Batch = class {
        constructor(tree, core, batchLock, cache, options = {}) {
          this.tree = tree;
          this.feed = core;
          this.core = core;
          this.index = tree._batches.push(this) - 1;
          this.blocks = cache ? /* @__PURE__ */ new Map() : null;
          this.autoFlush = !batchLock;
          this.maxBlocksCached = options.maxBlocksCached || 128;
          this.rootSeq = 0;
          this.root = null;
          this.length = 0;
          this.checkout = options.checkout === void 0 ? -1 : options.checkout;
          this.options = options;
          this.locked = null;
          this.batchLock = batchLock;
          this.onseq = this.options.onseq || noop;
          this.appending = null;
          this.isSnapshot = this.core !== this.tree.core;
          this.shouldUpdate = this.options.update !== false;
          this.updating = null;
          this.encoding = {
            key: options.keyEncoding ? codecs(options.keyEncoding) : tree.keyEncoding,
            value: options.valueEncoding ? codecs(options.valueEncoding) : tree.valueEncoding
          };
        }
        async ready() {
          if (this.core.opened === false) await this.core.ready();
          if (this.tree.opened === false) await this.tree.ready();
        }
        async lock() {
          if (this.tree.readonly) throw new Error("Hyperbee is marked as read-only");
          if (this.locked === null) this.locked = await this.tree.lock();
        }
        get version() {
          if (this.checkout !== -1) return Math.max(1, this.checkout);
          return Math.max(1, this.tree._checkout || this.core.length + this.length);
        }
        async getRoot(ensureHeader) {
          await this.ready();
          if (ensureHeader) {
            if (this.core.length === 0 && this.core.writable && !this.tree.readonly) {
              await this.core.append(
                Header.encode({
                  protocol: "hyperbee",
                  metadata: this.tree.metadata
                })
              );
            }
          }
          if (this.tree._checkout === 0 && this.checkout === -1 && this.shouldUpdate) {
            if (this.updating === null) this.updating = this.core.update();
            await this.updating;
          }
          if (this.version < 2) return null;
          return (await this.getBlock(this.version - 1)).getTreeNode(0);
        }
        async getKey(seq) {
          await this.tree._cacheLock.enter(seq);
          try {
            const k = this.core.fork === this.tree.core.fork ? this.tree._keyCache.get(seq) : null;
            if (k !== null) return k;
            const key = (await this._getBlock(seq)).key;
            if (this.core.fork === this.tree.core.fork) this.tree._keyCache.set(seq, key);
            return key;
          } finally {
            this.tree._cacheLock.exit(seq);
          }
        }
        async _getNode(seq) {
          const cached = this.tree._nodeCache !== null && this.core.fork === this.tree.core.fork ? this.tree._nodeCache.get(seq) : null;
          if (cached !== null) return cached;
          const entry = await this.core.get(seq, {
            ...this.options,
            valueEncoding: Node
          });
          if (entry === null) throw BLOCK_NOT_AVAILABLE();
          const wrap = copyEntry(entry);
          if (this.core.fork === this.tree.core.fork && this.tree._nodeCache !== null) {
            this.tree._nodeCache.set(seq, wrap);
          }
          return wrap;
        }
        async getBlock(seq) {
          if (this.rootSeq === 0) this.rootSeq = seq;
          await this.tree._cacheLock.enter(seq);
          try {
            return await this._getBlock(seq);
          } finally {
            this.tree._cacheLock.exit(seq);
          }
        }
        async _getBlock(seq) {
          let b = this.blocks && this.blocks.get(seq);
          if (b) return b;
          this.onseq(seq);
          const entry = await this._getNode(seq);
          b = this.blocks && this.blocks.get(seq);
          if (b) return b;
          b = new BlockEntry(seq, this, entry);
          if (this.blocks && this.blocks.size - this.length < this.maxBlocksCached) {
            this.blocks.set(seq, b);
          }
          return b;
        }
        _onwait(key) {
          this.options.onwait = null;
          this.tree.extension.get(this.rootSeq + 1, key);
        }
        _getEncoding(opts) {
          if (!opts) return this.encoding;
          return {
            key: opts.keyEncoding ? codecs(opts.keyEncoding) : this.encoding.key,
            value: opts.valueEncoding ? codecs(opts.valueEncoding) : this.encoding.value
          };
        }
        peek(range, opts) {
          return iteratorPeek(this.createRangeIterator(range, { ...opts, limit: 1 }));
        }
        createRangeIterator(range, opts = {}) {
          opts = opts ? { ...opts, ...range } : range;
          const encoding = this._getEncoding(opts);
          return new RangeIterator(
            this,
            encoding,
            encRange(encoding.key, { ...opts, sub: this.tree._sub })
          );
        }
        createReadStream(range, opts) {
          const signal = opts && opts.signal || null;
          return iteratorToStream(this.createRangeIterator(range, opts), signal);
        }
        async getBySeq(seq, opts) {
          const encoding = this._getEncoding(opts);
          try {
            const block = (await this.getBlock(seq)).final(encoding);
            return { key: block.key, value: block.value };
          } finally {
            await this._closeSnapshot();
          }
        }
        async get(key, opts) {
          const encoding = this._getEncoding(opts);
          const finalize = opts ? opts.finalize !== false : true;
          try {
            return await this._get(key, encoding, finalize);
          } finally {
            await this._closeSnapshot();
          }
        }
        async _get(key, encoding, finalize) {
          key = enc(encoding.key, key);
          if (this.tree.extension !== null && this.options.extension !== false) {
            this.options.onwait = this._onwait.bind(this, key);
          }
          let node = await this.getRoot(false);
          if (!node) return null;
          while (true) {
            if (node.block.isTarget(key)) {
              return node.block.isDeletion() ? null : finalize ? node.block.final(encoding) : node.block;
            }
            let s = 0;
            let e = node.keys.length;
            let c;
            while (s < e) {
              const mid = s + e >> 1;
              c = b4a.compare(key, await node.getKey(mid));
              if (c === 0) {
                const block = await this.getBlock(node.keys[mid].seq);
                return finalize ? block.final(encoding) : block;
              }
              if (c < 0) e = mid;
              else s = mid + 1;
            }
            if (!node.children.length) return null;
            const i = c < 0 ? e : s;
            node = await node.getChildNode(i);
          }
        }
        async links(key, seq) {
          let node = await this.getRoot(false);
          if (!node) return false;
          if (node.block.seq === seq) return true;
          while (true) {
            if (node.block.isTarget(key)) return false;
            let s = 0;
            let e = node.keys.length;
            let c;
            while (s < e) {
              const mid = s + e >> 1;
              if (node.keys[mid].seq === seq) return true;
              c = b4a.compare(key, await node.getKey(mid));
              if (c === 0) return false;
              if (c < 0) e = mid;
              else s = mid + 1;
            }
            if (!node.children.length) return false;
            const i = c < 0 ? e : s;
            node = await node.getChildNode(i);
            if (node.block.seq === seq) return true;
          }
        }
        async put(key, value, opts) {
          const release = this.batchLock ? await this.batchLock() : null;
          const cas = opts && opts.cas || null;
          const encoding = this._getEncoding(opts);
          if (!this.locked) await this.lock();
          if (!release) return this._put(key, value, encoding, cas);
          try {
            return await this._put(key, value, encoding, cas);
          } finally {
            release();
          }
        }
        async _put(key, value, encoding, cas) {
          const newNode = {
            seq: 0,
            key,
            value
          };
          key = enc(encoding.key, key);
          value = enc(encoding.value, value);
          const stack = [];
          let root;
          let node = root = await this.getRoot(true);
          if (!node) node = root = TreeNode.create(null);
          const seq = newNode.seq = this.core.length + this.length;
          const target = new Key(seq, key);
          while (node.children.length) {
            stack.push(node);
            node.changed = true;
            let s = 0;
            let e = node.keys.length;
            let c;
            while (s < e) {
              const mid = s + e >> 1;
              c = b4a.compare(target.value, await node.getKey(mid));
              if (c === 0) {
                if (cas) {
                  const prev = await node.getKeyNode(mid);
                  if (!await cas(prev.final(encoding), newNode)) return this._unlockMaybe();
                }
                if (!this.tree.alwaysDuplicate) {
                  const prev = await node.getKeyNode(mid);
                  if (sameValue(prev.value, value)) return this._unlockMaybe();
                }
                node.setKey(mid, target);
                return this._append(root, seq, key, value);
              }
              if (c < 0) e = mid;
              else s = mid + 1;
            }
            const i = c < 0 ? e : s;
            node = await node.getChildNode(i);
          }
          let needsSplit = !await node.insertKey(target, value, null, newNode, encoding, cas);
          if (!node.changed) return this._unlockMaybe();
          while (needsSplit) {
            const parent = stack.pop();
            const { median, right } = await node.split();
            if (parent) {
              needsSplit = !await parent.insertKey(median, value, right, null, encoding, null);
              node = parent;
            } else {
              root = TreeNode.create(node.block);
              root.changed = true;
              root.keys.push(median);
              root.children.push(new Child(0, 0, node), new Child(0, 0, right));
              needsSplit = false;
            }
          }
          return this._append(root, seq, key, value);
        }
        async del(key, opts) {
          const release = this.batchLock ? await this.batchLock() : null;
          const cas = opts && opts.cas || null;
          const encoding = this._getEncoding(opts);
          if (!this.locked) await this.lock();
          if (!release) return this._del(key, encoding, cas);
          try {
            return await this._del(key, encoding, cas);
          } finally {
            release();
          }
        }
        async _del(key, encoding, cas) {
          const delNode = {
            seq: 0,
            key,
            value: null
          };
          key = enc(encoding.key, key);
          const stack = [];
          let node = await this.getRoot(true);
          if (!node) return this._unlockMaybe();
          const seq = delNode.seq = this.core.length + this.length;
          while (true) {
            stack.push(node);
            let s = 0;
            let e = node.keys.length;
            let c;
            while (s < e) {
              const mid = s + e >> 1;
              c = b4a.compare(key, await node.getKey(mid));
              if (c === 0) {
                if (cas) {
                  const prev = await node.getKeyNode(mid);
                  if (!await cas(prev.final(encoding), delNode)) return this._unlockMaybe();
                }
                if (node.children.length) await setKeyToNearestLeaf(node, mid, stack);
                else node.removeKey(mid);
                for (const node2 of stack) node2.changed = true;
                return this._append(await rebalance(stack), seq, key, null);
              }
              if (c < 0) e = mid;
              else s = mid + 1;
            }
            if (!node.children.length) return this._unlockMaybe();
            const i = c < 0 ? e : s;
            node = await node.getChildNode(i);
          }
        }
        async _closeSnapshot() {
          if (this.isSnapshot) {
            await this.core.close();
            this._finalize();
          }
        }
        async close() {
          if (this.isSnapshot) return this._closeSnapshot();
          this.root = null;
          if (this.blocks) this.blocks.clear();
          this.length = 0;
          this._unlock();
        }
        destroy() {
          this.close().catch(noop);
        }
        toBlocks() {
          if (this.appending) return this.appending;
          const batch = new Array(this.length);
          for (let i = 0; i < this.length; i++) {
            const seq = this.core.length + i;
            const { pendingIndex, key, value } = this.blocks.get(seq);
            if (i < this.length - 1) {
              pendingIndex[0] = null;
              let j = 0;
              while (j < pendingIndex.length) {
                const idx = pendingIndex[j];
                if (idx !== null && idx.seq === seq) {
                  idx.offset = j++;
                  continue;
                }
                if (j === pendingIndex.length - 1) pendingIndex.pop();
                else pendingIndex[j] = pendingIndex.pop();
              }
            }
            batch[i] = Node.encode({
              key,
              value,
              index: deflate(pendingIndex)
            });
          }
          this.appending = batch;
          return batch;
        }
        flush() {
          if (!this.length) return this.close();
          const batch = this.toBlocks();
          this.root = null;
          this.blocks.clear();
          this.length = 0;
          return this._appendBatch(batch);
        }
        _unlockMaybe() {
          if (this.autoFlush) this._unlock();
        }
        _unlock() {
          const locked = this.locked;
          this.locked = null;
          if (locked !== null) locked();
          this._finalize();
        }
        _finalize() {
          if (this.index >= this.tree._batches.length || this.tree._batches[this.index] !== this) return;
          const top = this.tree._batches.pop();
          if (top === this) return;
          top.index = this.index;
          this.tree._batches[top.index] = top;
        }
        _append(root, seq, key, value) {
          const index = [];
          root.indexChanges(index, seq);
          index[0] = new Child(seq, 0, root);
          if (!this.autoFlush) {
            const block = new BatchEntry(seq, this, key, value, index);
            root.block = block;
            this.root = root;
            this.length++;
            this.blocks.set(seq, block);
            root.updateChildren(seq, block);
            return;
          }
          return this._appendBatch(
            Node.encode({
              key,
              value,
              index: deflate(index)
            })
          );
        }
        async _appendBatch(raw) {
          try {
            await this.core.append(raw);
          } finally {
            this._unlock();
          }
        }
      };
      var EntryWatcher = class extends ReadyResource {
        constructor(bee, key, opts = {}) {
          super();
          this.keyEncoding = opts.keyEncoding || bee.keyEncoding;
          this.valueEncoding = opts.valueEncoding || bee.valueEncoding;
          this.index = bee._entryWatchers.push(this) - 1;
          this.bee = bee;
          this.key = key;
          this.node = null;
          this._forceUpdate = false;
          this._debouncedUpdate = debounce(this._processUpdate.bind(this));
        }
        _close() {
          const top = this.bee._entryWatchers.pop();
          if (top !== this) {
            top.index = this.index;
            this.bee._entryWatchers[top.index] = top;
          }
        }
        _onappend() {
          this._debouncedUpdate();
        }
        _ontruncate() {
          this._forceUpdate = true;
          this._debouncedUpdate();
        }
        async _processUpdate() {
          const force = this._forceUpdate;
          this._forceUpdate = false;
          let newNode;
          try {
            newNode = await this.bee.get(this.key, {
              keyEncoding: this.keyEncoding,
              valueEncoding: this.valueEncoding
            });
          } catch (e) {
            if (e.code === "SNAPSHOT_NOT_AVAILABLE") {
              return;
            } else if (this.bee.closing) {
              this.close().catch(safetyCatch);
              return;
            }
            this.emit("error", e);
            return;
          }
          if (force || newNode?.seq !== this.node?.seq) {
            this.node = newNode;
            this.emit("update");
          }
        }
      };
      var Watcher = class extends ReadyResource {
        constructor(bee, range, opts = {}) {
          super();
          this.keyEncoding = opts.keyEncoding || bee.keyEncoding;
          this.valueEncoding = opts.valueEncoding || bee.valueEncoding;
          this.index = bee._watchers.push(this) - 1;
          this.bee = bee;
          this.core = bee.core;
          this.latestDiff = 0;
          this.range = range;
          this.map = opts.map || defaultWatchMap;
          this.current = null;
          this.previous = null;
          this.currentMapped = null;
          this.previousMapped = null;
          this.stream = null;
          this._lock = mutexify();
          this._flowing = false;
          this._resolveOnChange = null;
          this._differ = opts.differ || defaultDiffer;
          this._eager = !!opts.eager;
          this._onchange = opts.onchange || null;
          this.on("newListener", autoFlowOnUpdate);
          this.ready().catch(safetyCatch);
        }
        async _consume() {
          if (this._flowing) return;
          try {
            for await (const _ of this) {
            }
          } catch {
          }
        }
        async _open() {
          await this.bee.ready();
          const opts = {
            keyEncoding: this.keyEncoding,
            valueEncoding: this.valueEncoding
          };
          this.current = this._eager ? this.bee.checkout(1, opts) : this.bee.snapshot(opts);
          await this.current.ready();
          if (this._onchange) {
            if (this._eager) await this._onchange();
            this._consume();
          }
        }
        [Symbol.asyncIterator]() {
          this._flowing = true;
          return this;
        }
        _ontruncate() {
          this._onappend();
        }
        _onappend() {
          const resolve = this._resolveOnChange;
          this._resolveOnChange = null;
          if (resolve) resolve();
        }
        async _waitForChanges() {
          if (this.current.version < this.bee.version || this.closing) return;
          await new Promise((resolve) => {
            this._resolveOnChange = resolve;
          });
        }
        async next() {
          try {
            return await this._next();
          } catch (err) {
            if (this.closing) return { value: void 0, done: true };
            await this.close();
            throw err;
          }
        }
        async _next() {
          const release = await this._lock();
          try {
            if (this.closing) return { value: void 0, done: true };
            if (!this.opened) await this.ready();
            while (true) {
              await this._waitForChanges();
              if (this.closing) return { value: void 0, done: true };
              await this._closePrevious();
              this.previous = this.current.snapshot();
              await this._closeCurrent();
              this.current = this.bee.snapshot({
                keyEncoding: this.keyEncoding,
                valueEncoding: this.valueEncoding
              });
              await this.current.ready();
              await this.previous.ready();
              if (this.current.core.fork !== this.previous.core.fork) {
                return await this._yield();
              }
              this.stream = this._differ(this.current, this.previous, this.range);
              try {
                for await (const data of this.stream) {
                  return await this._yield();
                }
              } finally {
                this.stream = null;
              }
            }
          } finally {
            release();
          }
        }
        async _yield() {
          this.currentMapped = this.map(this.current);
          this.previousMapped = this.map(this.previous);
          if (this._onchange) {
            try {
              await this._onchange();
            } catch (err) {
              safetyCatch(err);
            }
          }
          this.emit("update");
          return { done: false, value: [this.currentMapped, this.previousMapped] };
        }
        async return() {
          await this.close();
          return { done: true };
        }
        async _close() {
          const top = this.bee._watchers.pop();
          if (top !== this) {
            top.index = this.index;
            this.bee._watchers[top.index] = top;
          }
          if (this.stream && !this.stream.destroying) {
            this.stream.destroy();
          }
          this._onappend();
          await this._closeCurrent().catch(safetyCatch);
          await this._closePrevious().catch(safetyCatch);
          const release = await this._lock();
          release();
        }
        destroy() {
          return this.close();
        }
        async _closeCurrent() {
          if (this.currentMapped) await this.currentMapped.close();
          if (this.current) await this.current.close();
          this.current = this.currentMapped = null;
        }
        async _closePrevious() {
          if (this.previousMapped) await this.previousMapped.close();
          if (this.previous) await this.previous.close();
          this.previous = this.previousMapped = null;
        }
      };
      function autoFlowOnUpdate(name) {
        if (name === "update") this._consume();
      }
      function defaultWatchMap(snapshot) {
        return snapshot;
      }
      async function leafSize(node, goLeft) {
        while (node.children.length) node = await node.getChildNode(goLeft ? 0 : node.children.length - 1);
        return node.keys.length;
      }
      async function setKeyToNearestLeaf(node, index, stack) {
        let [left, right] = await Promise.all([node.getChildNode(index), node.getChildNode(index + 1)]);
        const [ls, rs] = await Promise.all([leafSize(left, false), leafSize(right, true)]);
        if (ls < rs) {
          stack.push(right);
          while (right.children.length) stack.push(right = right.children[0].value);
          node.keys[index] = right.keys.shift();
        } else {
          stack.push(left);
          while (left.children.length) stack.push(left = left.children[left.children.length - 1].value);
          node.keys[index] = left.keys.pop();
        }
      }
      async function rebalance(stack) {
        const root = stack[0];
        while (stack.length > 1) {
          const node = stack.pop();
          const parent = stack[stack.length - 1];
          if (node.keys.length >= MIN_KEYS) return root;
          let { left, index, right } = await node.siblings(parent);
          if (left && left.keys.length > MIN_KEYS) {
            left.changed = true;
            node.keys.unshift(parent.keys[index - 1]);
            if (left.children.length) node.children.unshift(left.children.pop());
            parent.keys[index - 1] = left.keys.pop();
            return root;
          }
          if (right && right.keys.length > MIN_KEYS) {
            right.changed = true;
            node.keys.push(parent.keys[index]);
            if (right.children.length) node.children.push(right.children.shift());
            parent.keys[index] = right.keys.shift();
            return root;
          }
          if (left) {
            index--;
            right = node;
          } else {
            left = node;
          }
          left.merge(right, parent.keys[index]);
          parent.removeKey(index);
        }
        if (!root.keys.length && root.children.length) return root.getChildNode(0);
        return root;
      }
      function iteratorToStream(ite, signal) {
        let done;
        let closing;
        const rs = new Readable({
          signal,
          open(cb) {
            done = cb;
            ite.open().then(fin, fin);
          },
          read(cb) {
            done = cb;
            ite.next().then(push, fin);
          },
          predestroy() {
            closing = ite.close();
            closing.catch(noop);
          },
          destroy(cb) {
            done = cb;
            if (!closing) closing = ite.close();
            closing.then(fin, fin);
          }
        });
        return rs;
        function fin(err) {
          done(err);
        }
        function push(val) {
          rs.push(val);
          done(null);
        }
      }
      async function iteratorPeek(ite) {
        try {
          await ite.open();
          return await ite.next();
        } finally {
          await ite.close();
        }
      }
      function encRange(e, opts) {
        if (!e) return opts;
        if (e.encodeRange) {
          const r = e.encodeRange({
            gt: opts.gt,
            gte: opts.gte,
            lt: opts.lt,
            lte: opts.lte
          });
          opts.gt = r.gt;
          opts.gte = r.gte;
          opts.lt = r.lt;
          opts.lte = r.lte;
          return opts;
        }
        if (opts.gt !== void 0) opts.gt = enc(e, opts.gt);
        if (opts.gte !== void 0) opts.gte = enc(e, opts.gte);
        if (opts.lt !== void 0) opts.lt = enc(e, opts.lt);
        if (opts.lte !== void 0) opts.lte = enc(e, opts.lte);
        if (opts.sub && !opts.gt && !opts.gte) opts.gt = enc(e, SEP);
        if (opts.sub && !opts.lt && !opts.lte) opts.lt = bump(enc(e, EMPTY));
        return opts;
      }
      function bump(key) {
        key[key.length - 1]++;
        return key;
      }
      function enc(e, v) {
        if (v === void 0 || v === null) return null;
        if (e !== null) return e.encode(v);
        if (typeof v === "string") return b4a.from(v);
        return v;
      }
      function prefixEncoding(prefix, keyEncoding) {
        return {
          encode(key) {
            return b4a.concat([prefix, b4a.isBuffer(key) ? key : enc(keyEncoding, key)]);
          },
          decode(key) {
            const sliced = key.slice(prefix.length, key.length);
            return keyEncoding ? keyEncoding.decode(sliced) : sliced;
          }
        };
      }
      function copyEntry(entry) {
        let key = entry.key;
        let value = entry.value;
        let index = entry.index;
        const size = key.byteLength + (value === null ? 0 : value.byteLength) + (index === null ? 0 : index.byteLength);
        if (2 * size < key.buffer.byteLength) {
          const [newKey, newValue, newIndex] = unslabAll([entry.key, entry.value, entry.index]);
          key = newKey;
          value = newValue;
          index = newIndex;
        }
        return {
          key,
          value,
          index,
          inflated: null
        };
      }
      function defaultDiffer(currentSnap, previousSnap, opts) {
        return currentSnap.createDiffStream(previousSnap, opts);
      }
      function toNull() {
        return null;
      }
      function getBackingCore(core) {
        if (core.core) return core;
        if (core.getBackingCore) return core.getBackingCore().session;
        return null;
      }
      function sameValue(a, b) {
        return a === b || a !== null && b !== null && b4a.equals(a, b);
      }
      function noop() {
      }
      function getExtension(db, opts) {
        if (opts.extension === false) return null;
        if (opts.extension && opts.extension !== true) return opts.extension;
        return Extension.register(db);
      }
      async function isLinked(batch, block) {
        const seq = block.seq;
        block.inflate();
        const keys = [block.key];
        const wait = batch.options.wait;
        for (const l of block.index.levels) {
          if (!l.keys.length) continue;
          batch.options.wait = false;
          try {
            keys.push(await batch.getKey(l.keys[0].seq));
          } catch {
          }
          batch.options.wait = wait;
        }
        for (const k of keys) {
          if (await batch.links(k, seq)) return true;
        }
        if (batch.core.closing) throw new Error("Core is closed");
        return false;
      }
      module.exports = Hyperbee;
    }
  });

  // ../../node_modules/hyperblobs/lib/prefetcher.js
  var require_prefetcher = __commonJS({
    "../../node_modules/hyperblobs/lib/prefetcher.js"(exports, module) {
      var MAX_READAHEAD_TARGET = 0.05;
      module.exports = class Prefetcher {
        constructor(core, { max = 64, start = 0, end = core.length, linear = true } = {}) {
          this.core = core;
          this.max = max;
          this.range = null;
          this.startBound = start;
          this.endBound = end;
          this.maxReadAhead = Math.max(max * 2, Math.floor((end - start) * MAX_READAHEAD_TARGET));
          this.start = start;
          this.end = start;
          this.linear = linear;
          this.missing = 0;
          this._ondownloadBound = this._ondownload.bind(this);
          this.core.on("download", this._ondownloadBound);
        }
        _ondownload(index) {
          if (this.range && index < this.end && this.start <= index) {
            this.missing--;
            this._update();
          }
        }
        destroy() {
          this.core.off("download", this._ondownloadBound);
          if (this.range) this.range.destroy();
          this.range = null;
          this.max = 0;
        }
        update(position) {
          this.start = position;
          if (!this.range) this._update();
        }
        _update() {
          if (this.missing >= this.max) return;
          if (this.range) this.range.destroy();
          let end = this.end;
          while (end < this.endBound && this.missing < this.max) {
            end = this.core.core.bitfield.firstUnset(end) + 1;
            if (end >= this.endBound) break;
            this.missing++;
          }
          if (end > this.start + this.maxReadAhead) end = this.start + this.maxReadAhead;
          if (end >= this.endBound) end = this.endBound;
          this.end = end;
          if (this.start >= this.end) return;
          this.range = this.core.download({
            start: this.start,
            end: this.end,
            linear: this.linear
          });
        }
      };
    }
  });

  // ../../node_modules/compact-encoding/endian.js
  var require_endian = __commonJS({
    "../../node_modules/compact-encoding/endian.js"(exports) {
      var LE = exports.LE = new Uint8Array(new Uint16Array([255]).buffer)[0] === 255;
      exports.BE = !LE;
    }
  });

  // ../../node_modules/compact-encoding/raw.js
  var require_raw = __commonJS({
    "../../node_modules/compact-encoding/raw.js"(exports, module) {
      var b4a = require_b4a();
      var { BE } = require_endian();
      exports = module.exports = {
        preencode(state, b) {
          state.end += b.byteLength;
        },
        encode(state, b) {
          state.buffer.set(b, state.start);
          state.start += b.byteLength;
        },
        decode(state) {
          const b = state.buffer.subarray(state.start, state.end);
          state.start = state.end;
          return b;
        }
      };
      var buffer = exports.buffer = {
        preencode(state, b) {
          if (b) uint8array.preencode(state, b);
          else state.end++;
        },
        encode(state, b) {
          if (b) uint8array.encode(state, b);
          else state.buffer[state.start++] = 0;
        },
        decode(state) {
          const b = state.buffer.subarray(state.start);
          if (b.byteLength === 0) return null;
          state.start = state.end;
          return b;
        }
      };
      exports.binary = {
        ...buffer,
        preencode(state, b) {
          if (typeof b === "string") utf8.preencode(state, b);
          else buffer.preencode(state, b);
        },
        encode(state, b) {
          if (typeof b === "string") utf8.encode(state, b);
          else buffer.encode(state, b);
        }
      };
      exports.arraybuffer = {
        preencode(state, b) {
          state.end += b.byteLength;
        },
        encode(state, b) {
          const view = new Uint8Array(b);
          state.buffer.set(view, state.start);
          state.start += b.byteLength;
        },
        decode(state) {
          const b = new ArrayBuffer(state.end - state.start);
          const view = new Uint8Array(b);
          view.set(state.buffer.subarray(state.start));
          state.start = state.end;
          return b;
        }
      };
      function typedarray(TypedArray, swap) {
        const n = TypedArray.BYTES_PER_ELEMENT;
        return {
          preencode(state, b) {
            state.end += b.byteLength;
          },
          encode(state, b) {
            const view = new Uint8Array(b.buffer, b.byteOffset, b.byteLength);
            if (BE && swap) swap(view);
            state.buffer.set(view, state.start);
            state.start += b.byteLength;
          },
          decode(state) {
            let b = state.buffer.subarray(state.start);
            if (b.byteOffset % n !== 0) b = new Uint8Array(b);
            if (BE && swap) swap(b);
            state.start = state.end;
            return new TypedArray(b.buffer, b.byteOffset, b.byteLength / n);
          }
        };
      }
      var uint8array = exports.uint8array = typedarray(Uint8Array);
      exports.uint16array = typedarray(Uint16Array, b4a.swap16);
      exports.uint32array = typedarray(Uint32Array, b4a.swap32);
      exports.int8array = typedarray(Int8Array);
      exports.int16array = typedarray(Int16Array, b4a.swap16);
      exports.int32array = typedarray(Int32Array, b4a.swap32);
      exports.biguint64array = typedarray(BigUint64Array, b4a.swap64);
      exports.bigint64array = typedarray(BigInt64Array, b4a.swap64);
      exports.float32array = typedarray(Float32Array, b4a.swap32);
      exports.float64array = typedarray(Float64Array, b4a.swap64);
      function string(encoding) {
        return {
          preencode(state, s) {
            state.end += b4a.byteLength(s, encoding);
          },
          encode(state, s) {
            state.start += b4a.write(state.buffer, s, state.start, encoding);
          },
          decode(state) {
            const s = b4a.toString(state.buffer, encoding, state.start);
            state.start = state.end;
            return s;
          }
        };
      }
      var utf8 = exports.string = exports.utf8 = string("utf-8");
      exports.ascii = string("ascii");
      exports.hex = string("hex");
      exports.base64 = string("base64");
      exports.ucs2 = exports.utf16le = string("utf16le");
      exports.array = function array(enc) {
        return {
          preencode(state, list) {
            for (const value of list) enc.preencode(state, value);
          },
          encode(state, list) {
            for (const value of list) enc.encode(state, value);
          },
          decode(state) {
            const arr = [];
            while (state.start < state.end) arr.push(enc.decode(state));
            return arr;
          }
        };
      };
      exports.json = {
        preencode(state, v) {
          utf8.preencode(state, JSON.stringify(v));
        },
        encode(state, v) {
          utf8.encode(state, JSON.stringify(v));
        },
        decode(state) {
          return JSON.parse(utf8.decode(state));
        }
      };
      exports.ndjson = {
        preencode(state, v) {
          utf8.preencode(state, JSON.stringify(v) + "\n");
        },
        encode(state, v) {
          utf8.encode(state, JSON.stringify(v) + "\n");
        },
        decode(state) {
          return JSON.parse(utf8.decode(state));
        }
      };
    }
  });

  // ../../node_modules/compact-encoding/lexint.js
  var require_lexint = __commonJS({
    "../../node_modules/compact-encoding/lexint.js"(exports, module) {
      module.exports = {
        preencode,
        encode,
        decode
      };
      function preencode(state, num) {
        if (num < 251) {
          state.end++;
        } else if (num < 256) {
          state.end += 2;
        } else if (num < 65536) {
          state.end += 3;
        } else if (num < 16777216) {
          state.end += 4;
        } else if (num < 4294967296) {
          state.end += 5;
        } else {
          state.end++;
          const exp = Math.floor(Math.log(num) / Math.log(2)) - 32;
          preencode(state, exp);
          state.end += 6;
        }
      }
      function encode(state, num) {
        const max = 251;
        const x = num - max;
        if (num < max) {
          state.buffer[state.start++] = num;
        } else if (num < 256) {
          state.buffer[state.start++] = max;
          state.buffer[state.start++] = x;
        } else if (num < 65536) {
          state.buffer[state.start++] = max + 1;
          state.buffer[state.start++] = x >> 8 & 255;
          state.buffer[state.start++] = x & 255;
        } else if (num < 16777216) {
          state.buffer[state.start++] = max + 2;
          state.buffer[state.start++] = x >> 16;
          state.buffer[state.start++] = x >> 8 & 255;
          state.buffer[state.start++] = x & 255;
        } else if (num < 4294967296) {
          state.buffer[state.start++] = max + 3;
          state.buffer[state.start++] = x >> 24;
          state.buffer[state.start++] = x >> 16 & 255;
          state.buffer[state.start++] = x >> 8 & 255;
          state.buffer[state.start++] = x & 255;
        } else {
          const exp = Math.floor(Math.log(x) / Math.log(2)) - 32;
          state.buffer[state.start++] = 255;
          encode(state, exp);
          const rem = x / Math.pow(2, exp - 11);
          for (let i = 5; i >= 0; i--) {
            state.buffer[state.start++] = rem / Math.pow(2, 8 * i) & 255;
          }
        }
      }
      function decode(state) {
        const max = 251;
        if (state.end - state.start < 1) throw new Error("Out of bounds");
        const flag = state.buffer[state.start++];
        if (flag < max) return flag;
        if (state.end - state.start < flag - max + 1) {
          throw new Error("Out of bounds.");
        }
        if (flag < 252) {
          return state.buffer[state.start++] + max;
        }
        if (flag < 253) {
          return (state.buffer[state.start++] << 8) + state.buffer[state.start++] + max;
        }
        if (flag < 254) {
          return (state.buffer[state.start++] << 16) + (state.buffer[state.start++] << 8) + state.buffer[state.start++] + max;
        }
        if (flag < 255) {
          return state.buffer[state.start++] * 16777216 + (state.buffer[state.start++] << 16) + (state.buffer[state.start++] << 8) + state.buffer[state.start++] + max;
        }
        const exp = decode(state);
        if (state.end - state.start < 6) throw new Error("Out of bounds");
        let rem = 0;
        for (let i = 5; i >= 0; i--) {
          rem += state.buffer[state.start++] * Math.pow(2, 8 * i);
        }
        return rem * Math.pow(2, exp - 11) + max;
      }
    }
  });

  // ../../node_modules/compact-encoding/index.js
  var require_compact_encoding = __commonJS({
    "../../node_modules/compact-encoding/index.js"(exports) {
      var b4a = require_b4a();
      var { BE } = require_endian();
      exports.state = function(start = 0, end = 0, buffer2 = null) {
        return { start, end, buffer: buffer2 };
      };
      var raw = exports.raw = require_raw();
      var uint = exports.uint = {
        preencode(state, n) {
          state.end += n <= 252 ? 1 : n <= 65535 ? 3 : n <= 4294967295 ? 5 : 9;
        },
        encode(state, n) {
          if (n <= 252) uint8.encode(state, n);
          else if (n <= 65535) {
            state.buffer[state.start++] = 253;
            uint16.encode(state, n);
          } else if (n <= 4294967295) {
            state.buffer[state.start++] = 254;
            uint32.encode(state, n);
          } else {
            state.buffer[state.start++] = 255;
            uint64.encode(state, n);
          }
        },
        decode(state) {
          const a = uint8.decode(state);
          if (a <= 252) return a;
          if (a === 253) return uint16.decode(state);
          if (a === 254) return uint32.decode(state);
          return uint64.decode(state);
        }
      };
      var uint8 = exports.uint8 = {
        preencode(state, n) {
          state.end += 1;
        },
        encode(state, n) {
          validateUint(n);
          state.buffer[state.start++] = n;
        },
        decode(state) {
          if (state.start >= state.end) throw new Error("Out of bounds");
          return state.buffer[state.start++];
        }
      };
      var uint16 = exports.uint16 = {
        preencode(state, n) {
          state.end += 2;
        },
        encode(state, n) {
          validateUint(n);
          state.buffer[state.start++] = n;
          state.buffer[state.start++] = n >>> 8;
        },
        decode(state) {
          if (state.end - state.start < 2) throw new Error("Out of bounds");
          return state.buffer[state.start++] + state.buffer[state.start++] * 256;
        }
      };
      var uint24 = exports.uint24 = {
        preencode(state, n) {
          state.end += 3;
        },
        encode(state, n) {
          validateUint(n);
          state.buffer[state.start++] = n;
          state.buffer[state.start++] = n >>> 8;
          state.buffer[state.start++] = n >>> 16;
        },
        decode(state) {
          if (state.end - state.start < 3) throw new Error("Out of bounds");
          return state.buffer[state.start++] + state.buffer[state.start++] * 256 + state.buffer[state.start++] * 65536;
        }
      };
      var uint32 = exports.uint32 = {
        preencode(state, n) {
          state.end += 4;
        },
        encode(state, n) {
          validateUint(n);
          state.buffer[state.start++] = n;
          state.buffer[state.start++] = n >>> 8;
          state.buffer[state.start++] = n >>> 16;
          state.buffer[state.start++] = n >>> 24;
        },
        decode(state) {
          if (state.end - state.start < 4) throw new Error("Out of bounds");
          return state.buffer[state.start++] + state.buffer[state.start++] * 256 + state.buffer[state.start++] * 65536 + state.buffer[state.start++] * 16777216;
        }
      };
      var uint40 = exports.uint40 = {
        preencode(state, n) {
          state.end += 5;
        },
        encode(state, n) {
          validateUint(n);
          const r = Math.floor(n / 256);
          uint8.encode(state, n);
          uint32.encode(state, r);
        },
        decode(state) {
          if (state.end - state.start < 5) throw new Error("Out of bounds");
          return uint8.decode(state) + 256 * uint32.decode(state);
        }
      };
      var uint48 = exports.uint48 = {
        preencode(state, n) {
          state.end += 6;
        },
        encode(state, n) {
          validateUint(n);
          const r = Math.floor(n / 65536);
          uint16.encode(state, n);
          uint32.encode(state, r);
        },
        decode(state) {
          if (state.end - state.start < 6) throw new Error("Out of bounds");
          return uint16.decode(state) + 65536 * uint32.decode(state);
        }
      };
      var uint56 = exports.uint56 = {
        preencode(state, n) {
          state.end += 7;
        },
        encode(state, n) {
          validateUint(n);
          const r = Math.floor(n / 16777216);
          uint24.encode(state, n);
          uint32.encode(state, r);
        },
        decode(state) {
          if (state.end - state.start < 7) throw new Error("Out of bounds");
          return uint24.decode(state) + 16777216 * uint32.decode(state);
        }
      };
      var uint64 = exports.uint64 = {
        preencode(state, n) {
          state.end += 8;
        },
        encode(state, n) {
          validateUint(n);
          const r = Math.floor(n / 4294967296);
          uint32.encode(state, n);
          uint32.encode(state, r);
        },
        decode(state) {
          if (state.end - state.start < 8) throw new Error("Out of bounds");
          return uint32.decode(state) + 4294967296 * uint32.decode(state);
        }
      };
      var int = exports.int = zigZagInt(uint);
      exports.int8 = zigZagInt(uint8);
      exports.int16 = zigZagInt(uint16);
      exports.int24 = zigZagInt(uint24);
      exports.int32 = zigZagInt(uint32);
      exports.int40 = zigZagInt(uint40);
      exports.int48 = zigZagInt(uint48);
      exports.int56 = zigZagInt(uint56);
      exports.int64 = zigZagInt(uint64);
      var biguint64 = exports.biguint64 = {
        preencode(state, n) {
          state.end += 8;
        },
        encode(state, n) {
          const view = new DataView(
            state.buffer.buffer,
            state.start + state.buffer.byteOffset,
            8
          );
          view.setBigUint64(0, n, true);
          state.start += 8;
        },
        decode(state) {
          if (state.end - state.start < 8) throw new Error("Out of bounds");
          const view = new DataView(
            state.buffer.buffer,
            state.start + state.buffer.byteOffset,
            8
          );
          const n = view.getBigUint64(0, true);
          state.start += 8;
          return n;
        }
      };
      exports.bigint64 = zigZagBigInt(biguint64);
      var biguint = exports.biguint = {
        preencode(state, n) {
          let len = 0;
          for (let m = n; m; m = m >> 64n) len++;
          uint.preencode(state, len);
          state.end += 8 * len;
        },
        encode(state, n) {
          let len = 0;
          for (let m = n; m; m = m >> 64n) len++;
          uint.encode(state, len);
          const view = new DataView(
            state.buffer.buffer,
            state.start + state.buffer.byteOffset,
            8 * len
          );
          for (let m = n, i = 0; m; m = m >> 64n, i += 8) {
            view.setBigUint64(i, BigInt.asUintN(64, m), true);
          }
          state.start += 8 * len;
        },
        decode(state) {
          const len = uint.decode(state);
          if (state.end - state.start < 8 * len) throw new Error("Out of bounds");
          const view = new DataView(
            state.buffer.buffer,
            state.start + state.buffer.byteOffset,
            8 * len
          );
          let n = 0n;
          for (let i = len - 1; i >= 0; i--)
            n = (n << 64n) + view.getBigUint64(i * 8, true);
          state.start += 8 * len;
          return n;
        }
      };
      exports.bigint = zigZagBigInt(biguint);
      exports.lexint = require_lexint();
      exports.float32 = {
        preencode(state, n) {
          state.end += 4;
        },
        encode(state, n) {
          const view = new DataView(
            state.buffer.buffer,
            state.start + state.buffer.byteOffset,
            4
          );
          view.setFloat32(0, n, true);
          state.start += 4;
        },
        decode(state) {
          if (state.end - state.start < 4) throw new Error("Out of bounds");
          const view = new DataView(
            state.buffer.buffer,
            state.start + state.buffer.byteOffset,
            4
          );
          const float = view.getFloat32(0, true);
          state.start += 4;
          return float;
        }
      };
      exports.float64 = {
        preencode(state, n) {
          state.end += 8;
        },
        encode(state, n) {
          const view = new DataView(
            state.buffer.buffer,
            state.start + state.buffer.byteOffset,
            8
          );
          view.setFloat64(0, n, true);
          state.start += 8;
        },
        decode(state) {
          if (state.end - state.start < 8) throw new Error("Out of bounds");
          const view = new DataView(
            state.buffer.buffer,
            state.start + state.buffer.byteOffset,
            8
          );
          const float = view.getFloat64(0, true);
          state.start += 8;
          return float;
        }
      };
      var buffer = exports.buffer = {
        preencode(state, b) {
          if (b) uint8array.preencode(state, b);
          else state.end++;
        },
        encode(state, b) {
          if (b) uint8array.encode(state, b);
          else state.buffer[state.start++] = 0;
        },
        decode(state) {
          const len = uint.decode(state);
          if (len === 0) return null;
          if (state.end - state.start < len) throw new Error("Out of bounds");
          return state.buffer.subarray(state.start, state.start += len);
        }
      };
      exports.binary = {
        ...buffer,
        preencode(state, b) {
          if (typeof b === "string") utf8.preencode(state, b);
          else buffer.preencode(state, b);
        },
        encode(state, b) {
          if (typeof b === "string") utf8.encode(state, b);
          else buffer.encode(state, b);
        }
      };
      exports.arraybuffer = {
        preencode(state, b) {
          uint.preencode(state, b.byteLength);
          state.end += b.byteLength;
        },
        encode(state, b) {
          uint.encode(state, b.byteLength);
          const view = new Uint8Array(b);
          state.buffer.set(view, state.start);
          state.start += b.byteLength;
        },
        decode(state) {
          const len = uint.decode(state);
          const b = new ArrayBuffer(len);
          const view = new Uint8Array(b);
          view.set(state.buffer.subarray(state.start, state.start += len));
          return b;
        }
      };
      function typedarray(TypedArray, swap) {
        const n = TypedArray.BYTES_PER_ELEMENT;
        return {
          preencode(state, b) {
            uint.preencode(state, b.length);
            state.end += b.byteLength;
          },
          encode(state, b) {
            uint.encode(state, b.length);
            const view = new Uint8Array(b.buffer, b.byteOffset, b.byteLength);
            if (BE && swap) swap(view);
            state.buffer.set(view, state.start);
            state.start += b.byteLength;
          },
          decode(state) {
            const len = uint.decode(state);
            let b = state.buffer.subarray(state.start, state.start += len * n);
            if (b.byteLength !== len * n) throw new Error("Out of bounds");
            if (b.byteOffset % n !== 0) b = new Uint8Array(b);
            if (BE && swap) swap(b);
            return new TypedArray(b.buffer, b.byteOffset, b.byteLength / n);
          }
        };
      }
      var uint8array = exports.uint8array = typedarray(Uint8Array);
      exports.uint16array = typedarray(Uint16Array, b4a.swap16);
      exports.uint32array = typedarray(Uint32Array, b4a.swap32);
      exports.int8array = typedarray(Int8Array);
      exports.int16array = typedarray(Int16Array, b4a.swap16);
      exports.int32array = typedarray(Int32Array, b4a.swap32);
      exports.biguint64array = typedarray(BigUint64Array, b4a.swap64);
      exports.bigint64array = typedarray(BigInt64Array, b4a.swap64);
      exports.float32array = typedarray(Float32Array, b4a.swap32);
      exports.float64array = typedarray(Float64Array, b4a.swap64);
      function string(encoding) {
        return {
          preencode(state, s) {
            const len = b4a.byteLength(s, encoding);
            uint.preencode(state, len);
            state.end += len;
          },
          encode(state, s) {
            const len = b4a.byteLength(s, encoding);
            uint.encode(state, len);
            b4a.write(state.buffer, s, state.start, encoding);
            state.start += len;
          },
          decode(state) {
            const len = uint.decode(state);
            if (state.end - state.start < len) throw new Error("Out of bounds");
            return b4a.toString(
              state.buffer,
              encoding,
              state.start,
              state.start += len
            );
          },
          fixed(n) {
            return {
              preencode(state) {
                state.end += n;
              },
              encode(state, s) {
                b4a.write(state.buffer, s, state.start, n, encoding);
                state.start += n;
              },
              decode(state) {
                if (state.end - state.start < n) throw new Error("Out of bounds");
                return b4a.toString(
                  state.buffer,
                  encoding,
                  state.start,
                  state.start += n
                );
              }
            };
          }
        };
      }
      var utf8 = exports.string = exports.utf8 = string("utf-8");
      exports.ascii = string("ascii");
      exports.hex = string("hex");
      exports.base64 = string("base64");
      exports.ucs2 = exports.utf16le = string("utf16le");
      exports.bool = {
        preencode(state, b) {
          state.end++;
        },
        encode(state, b) {
          state.buffer[state.start++] = b ? 1 : 0;
        },
        decode(state) {
          if (state.start >= state.end) throw Error("Out of bounds");
          return state.buffer[state.start++] === 1;
        }
      };
      var fixed = exports.fixed = function fixed2(n) {
        return {
          preencode(state, s) {
            if (s.byteLength !== n) throw new Error("Incorrect buffer size");
            state.end += n;
          },
          encode(state, s) {
            state.buffer.set(s, state.start);
            state.start += n;
          },
          decode(state) {
            if (state.end - state.start < n) throw new Error("Out of bounds");
            return state.buffer.subarray(state.start, state.start += n);
          }
        };
      };
      exports.fixed32 = fixed(32);
      exports.fixed64 = fixed(64);
      exports.array = function array(enc) {
        return {
          preencode(state, list) {
            uint.preencode(state, list.length);
            for (let i = 0; i < list.length; i++) enc.preencode(state, list[i]);
          },
          encode(state, list) {
            uint.encode(state, list.length);
            for (let i = 0; i < list.length; i++) enc.encode(state, list[i]);
          },
          decode(state) {
            const len = uint.decode(state);
            if (len > 1048576) throw new Error("Array is too big");
            const arr = new Array(len);
            for (let i = 0; i < len; i++) arr[i] = enc.decode(state);
            return arr;
          }
        };
      };
      exports.frame = function frame(enc) {
        const dummy = exports.state();
        return {
          preencode(state, m) {
            const end = state.end;
            enc.preencode(state, m);
            uint.preencode(state, state.end - end);
          },
          encode(state, m) {
            dummy.end = 0;
            enc.preencode(dummy, m);
            uint.encode(state, dummy.end);
            enc.encode(state, m);
          },
          decode(state) {
            const end = state.end;
            const len = uint.decode(state);
            state.end = state.start + len;
            const m = enc.decode(state);
            state.start = state.end;
            state.end = end;
            return m;
          }
        };
      };
      exports.date = {
        preencode(state, d) {
          int.preencode(state, d.getTime());
        },
        encode(state, d) {
          int.encode(state, d.getTime());
        },
        decode(state, d) {
          return new Date(int.decode(state));
        }
      };
      exports.json = {
        preencode(state, v) {
          utf8.preencode(state, JSON.stringify(v));
        },
        encode(state, v) {
          utf8.encode(state, JSON.stringify(v));
        },
        decode(state) {
          return JSON.parse(utf8.decode(state));
        }
      };
      exports.ndjson = {
        preencode(state, v) {
          utf8.preencode(state, JSON.stringify(v) + "\n");
        },
        encode(state, v) {
          utf8.encode(state, JSON.stringify(v) + "\n");
        },
        decode(state) {
          return JSON.parse(utf8.decode(state));
        }
      };
      exports.none = {
        preencode(state, n) {
        },
        encode(state, n) {
        },
        decode(state) {
          return null;
        }
      };
      var anyArray = {
        preencode(state, arr) {
          uint.preencode(state, arr.length);
          for (let i = 0; i < arr.length; i++) {
            any.preencode(state, arr[i]);
          }
        },
        encode(state, arr) {
          uint.encode(state, arr.length);
          for (let i = 0; i < arr.length; i++) {
            any.encode(state, arr[i]);
          }
        },
        decode(state) {
          const arr = [];
          let len = uint.decode(state);
          while (len-- > 0) {
            arr.push(any.decode(state));
          }
          return arr;
        }
      };
      var anyObject = {
        preencode(state, o) {
          const keys = Object.keys(o);
          uint.preencode(state, keys.length);
          for (const key of keys) {
            utf8.preencode(state, key);
            any.preencode(state, o[key]);
          }
        },
        encode(state, o) {
          const keys = Object.keys(o);
          uint.encode(state, keys.length);
          for (const key of keys) {
            utf8.encode(state, key);
            any.encode(state, o[key]);
          }
        },
        decode(state) {
          let len = uint.decode(state);
          const o = {};
          while (len-- > 0) {
            const key = utf8.decode(state);
            o[key] = any.decode(state);
          }
          return o;
        }
      };
      var anyTypes = [
        exports.none,
        exports.bool,
        exports.string,
        exports.buffer,
        exports.uint,
        exports.int,
        exports.float64,
        anyArray,
        anyObject,
        exports.date
      ];
      var any = exports.any = {
        preencode(state, o) {
          const t = getType(o);
          uint.preencode(state, t);
          anyTypes[t].preencode(state, o);
        },
        encode(state, o) {
          const t = getType(o);
          uint.encode(state, t);
          anyTypes[t].encode(state, o);
        },
        decode(state) {
          const t = uint.decode(state);
          if (t >= anyTypes.length) throw new Error("Unknown type: " + t);
          return anyTypes[t].decode(state);
        }
      };
      var port = exports.port = uint16;
      var address = (host, family) => {
        return {
          preencode(state, m) {
            host.preencode(state, m.host);
            port.preencode(state, m.port);
          },
          encode(state, m) {
            host.encode(state, m.host);
            port.encode(state, m.port);
          },
          decode(state) {
            return {
              host: host.decode(state),
              family,
              port: port.decode(state)
            };
          }
        };
      };
      var ipv4 = exports.ipv4 = {
        preencode(state) {
          state.end += 4;
        },
        encode(state, string2) {
          const start = state.start;
          const end = start + 4;
          let i = 0;
          while (i < string2.length) {
            let n = 0;
            let c;
            while (i < string2.length && (c = string2.charCodeAt(i++)) !== /* . */
            46) {
              n = n * 10 + (c - /* 0 */
              48);
            }
            state.buffer[state.start++] = n;
          }
          state.start = end;
        },
        decode(state) {
          if (state.end - state.start < 4) throw new Error("Out of bounds");
          return state.buffer[state.start++] + "." + state.buffer[state.start++] + "." + state.buffer[state.start++] + "." + state.buffer[state.start++];
        }
      };
      exports.ipv4Address = address(ipv4, 4);
      var ipv6 = exports.ipv6 = {
        preencode(state) {
          state.end += 16;
        },
        encode(state, string2) {
          const start = state.start;
          const end = start + 16;
          let i = 0;
          let split = null;
          while (i < string2.length) {
            let n = 0;
            let c;
            while (i < string2.length && (c = string2.charCodeAt(i++)) !== /* : */
            58) {
              if (c >= 48 && c <= 57) n = n * 16 + (c - /* 0 */
              48);
              else if (c >= 65 && c <= 70) n = n * 16 + (c - /* A */
              65 + 10);
              else if (c >= 97 && c <= 102) n = n * 16 + (c - /* a */
              97 + 10);
            }
            state.buffer[state.start++] = n >>> 8;
            state.buffer[state.start++] = n;
            if (i < string2.length && string2.charCodeAt(i) === /* : */
            58) {
              i++;
              split = state.start;
            }
          }
          if (split !== null) {
            const offset = end - state.start;
            state.buffer.copyWithin(split + offset, split).fill(0, split, split + offset);
          }
          state.start = end;
        },
        decode(state) {
          if (state.end - state.start < 16) throw new Error("Out of bounds");
          return (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) + ":" + (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) + ":" + (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) + ":" + (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) + ":" + (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) + ":" + (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) + ":" + (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) + ":" + (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16);
        }
      };
      exports.ipv6Address = address(ipv6, 6);
      var ip = exports.ip = {
        preencode(state, string2) {
          const family = string2.includes(":") ? 6 : 4;
          uint8.preencode(state, family);
          if (family === 4) ipv4.preencode(state);
          else ipv6.preencode(state);
        },
        encode(state, string2) {
          const family = string2.includes(":") ? 6 : 4;
          uint8.encode(state, family);
          if (family === 4) ipv4.encode(state, string2);
          else ipv6.encode(state, string2);
        },
        decode(state) {
          const family = uint8.decode(state);
          if (family === 4) return ipv4.decode(state);
          else return ipv6.decode(state);
        }
      };
      exports.ipAddress = {
        preencode(state, m) {
          ip.preencode(state, m.host);
          port.preencode(state, m.port);
        },
        encode(state, m) {
          ip.encode(state, m.host);
          port.encode(state, m.port);
        },
        decode(state) {
          const family = uint8.decode(state);
          return {
            host: family === 4 ? ipv4.decode(state) : ipv6.decode(state),
            family,
            port: port.decode(state)
          };
        }
      };
      var record = exports.record = function(keyEncoding, valueEncoding) {
        return {
          preencode(state, v) {
            const keys = Object.keys(v);
            uint.preencode(state, keys.length);
            for (const k of keys) {
              keyEncoding.preencode(state, k);
              valueEncoding.preencode(state, v[k]);
            }
          },
          encode(state, v) {
            const keys = Object.keys(v);
            uint.encode(state, keys.length);
            for (const k of keys) {
              keyEncoding.encode(state, k);
              valueEncoding.encode(state, v[k]);
            }
          },
          decode(state) {
            const out = /* @__PURE__ */ Object.create(null);
            const keys = uint.decode(state);
            for (let i = 0; i < keys; i++) {
              out[keyEncoding.decode(state)] = valueEncoding.decode(state);
            }
            return out;
          }
        };
      };
      exports.stringRecord = record(utf8, utf8);
      function getType(o) {
        if (o === null || o === void 0) return 0;
        if (typeof o === "boolean") return 1;
        if (typeof o === "string") return 2;
        if (b4a.isBuffer(o)) return 3;
        if (typeof o === "number") {
          if (Number.isInteger(o)) return o >= 0 ? 4 : 5;
          return 6;
        }
        if (Array.isArray(o)) return 7;
        if (o instanceof Date) return 9;
        if (typeof o === "object") return 8;
        throw new Error("Unsupported type for " + o);
      }
      exports.from = function from(enc) {
        if (typeof enc === "string") return fromNamed(enc);
        if (enc.preencode) return enc;
        if (enc.encodingLength) return fromAbstractEncoder(enc);
        return fromCodec(enc);
      };
      function fromNamed(enc) {
        switch (enc) {
          case "ascii":
            return raw.ascii;
          case "utf-8":
          case "utf8":
            return raw.utf8;
          case "hex":
            return raw.hex;
          case "base64":
            return raw.base64;
          case "utf16-le":
          case "utf16le":
          case "ucs-2":
          case "ucs2":
            return raw.ucs2;
          case "ndjson":
            return raw.ndjson;
          case "json":
            return raw.json;
          case "binary":
          default:
            return raw.binary;
        }
      }
      function fromCodec(enc) {
        let tmpM = null;
        let tmpBuf = null;
        return {
          preencode(state, m) {
            tmpM = m;
            tmpBuf = enc.encode(m);
            state.end += tmpBuf.byteLength;
          },
          encode(state, m) {
            raw.encode(state, m === tmpM ? tmpBuf : enc.encode(m));
            tmpM = tmpBuf = null;
          },
          decode(state) {
            return enc.decode(raw.decode(state));
          }
        };
      }
      function fromAbstractEncoder(enc) {
        return {
          preencode(state, m) {
            state.end += enc.encodingLength(m);
          },
          encode(state, m) {
            enc.encode(m, state.buffer, state.start);
            state.start += enc.encode.bytes;
          },
          decode(state) {
            const m = enc.decode(state.buffer, state.start, state.end);
            state.start += enc.decode.bytes;
            return m;
          }
        };
      }
      exports.encode = function encode(enc, m) {
        const state = exports.state();
        enc.preencode(state, m);
        state.buffer = b4a.allocUnsafe(state.end);
        enc.encode(state, m);
        return state.buffer;
      };
      exports.decode = function decode(enc, buffer2) {
        return enc.decode(exports.state(0, buffer2.byteLength, buffer2));
      };
      function zigZagInt(enc) {
        return {
          preencode(state, n) {
            enc.preencode(state, zigZagEncodeInt(n));
          },
          encode(state, n) {
            enc.encode(state, zigZagEncodeInt(n));
          },
          decode(state) {
            return zigZagDecodeInt(enc.decode(state));
          }
        };
      }
      function zigZagDecodeInt(n) {
        return n === 0 ? n : (n & 1) === 0 ? n / 2 : -(n + 1) / 2;
      }
      function zigZagEncodeInt(n) {
        return n < 0 ? 2 * -n - 1 : n === 0 ? 0 : 2 * n;
      }
      function zigZagBigInt(enc) {
        return {
          preencode(state, n) {
            enc.preencode(state, zigZagEncodeBigInt(n));
          },
          encode(state, n) {
            enc.encode(state, zigZagEncodeBigInt(n));
          },
          decode(state) {
            return zigZagDecodeBigInt(enc.decode(state));
          }
        };
      }
      function zigZagDecodeBigInt(n) {
        return n === 0n ? n : (n & 1n) === 0n ? n / 2n : -(n + 1n) / 2n;
      }
      function zigZagEncodeBigInt(n) {
        return n < 0n ? 2n * -n - 1n : n === 0n ? 0n : 2n * n;
      }
      function validateUint(n) {
        if (n >= 0 === false)
          throw new Error("uint must be positive");
      }
    }
  });

  // ../../node_modules/sodium-universal/index.js
  var require_sodium_universal = __commonJS({
    "../../node_modules/sodium-universal/index.js"(exports, module) {
      module.exports = require_sodium_native();
    }
  });

  // ../../node_modules/hypercore-crypto/index.js
  var require_hypercore_crypto = __commonJS({
    "../../node_modules/hypercore-crypto/index.js"(exports) {
      var sodium = require_sodium_universal();
      var c = require_compact_encoding();
      var b4a = require_b4a();
      var LEAF_TYPE = b4a.from([0]);
      var PARENT_TYPE = b4a.from([1]);
      var ROOT_TYPE = b4a.from([2]);
      var HYPERCORE = b4a.from("hypercore");
      exports.keyPair = function(seed) {
        const slab = b4a.allocUnsafeSlow(sodium.crypto_sign_PUBLICKEYBYTES + sodium.crypto_sign_SECRETKEYBYTES);
        const publicKey = slab.subarray(0, sodium.crypto_sign_PUBLICKEYBYTES);
        const secretKey = slab.subarray(sodium.crypto_sign_PUBLICKEYBYTES);
        if (seed) sodium.crypto_sign_seed_keypair(publicKey, secretKey, seed);
        else sodium.crypto_sign_keypair(publicKey, secretKey);
        return {
          publicKey,
          secretKey
        };
      };
      exports.validateKeyPair = function(keyPair) {
        const pk = b4a.allocUnsafe(sodium.crypto_sign_PUBLICKEYBYTES);
        sodium.crypto_sign_ed25519_sk_to_pk(pk, keyPair.secretKey);
        return b4a.equals(pk, keyPair.publicKey);
      };
      exports.sign = function(message, secretKey) {
        const signature = b4a.allocUnsafeSlow(sodium.crypto_sign_BYTES);
        sodium.crypto_sign_detached(signature, message, secretKey);
        return signature;
      };
      exports.verify = function(message, signature, publicKey) {
        if (signature.byteLength !== sodium.crypto_sign_BYTES) return false;
        if (publicKey.byteLength !== sodium.crypto_sign_PUBLICKEYBYTES) return false;
        return sodium.crypto_sign_verify_detached(signature, message, publicKey);
      };
      exports.encrypt = function(message, publicKey) {
        const ciphertext = b4a.alloc(message.byteLength + sodium.crypto_box_SEALBYTES);
        sodium.crypto_box_seal(ciphertext, message, publicKey);
        return ciphertext;
      };
      exports.decrypt = function(ciphertext, keyPair) {
        if (ciphertext.byteLength < sodium.crypto_box_SEALBYTES) return null;
        const plaintext = b4a.alloc(ciphertext.byteLength - sodium.crypto_box_SEALBYTES);
        if (!sodium.crypto_box_seal_open(plaintext, ciphertext, keyPair.publicKey, keyPair.secretKey)) {
          return null;
        }
        return plaintext;
      };
      exports.encryptionKeyPair = function(seed) {
        const publicKey = b4a.alloc(sodium.crypto_box_PUBLICKEYBYTES);
        const secretKey = b4a.alloc(sodium.crypto_box_SECRETKEYBYTES);
        if (seed) {
          sodium.crypto_box_seed_keypair(publicKey, secretKey, seed);
        } else {
          sodium.crypto_box_keypair(publicKey, secretKey);
        }
        return {
          publicKey,
          secretKey
        };
      };
      exports.data = function(data) {
        const out = b4a.allocUnsafe(32);
        sodium.crypto_generichash_batch(out, [
          LEAF_TYPE,
          c.encode(c.uint64, data.byteLength),
          data
        ]);
        return out;
      };
      exports.parent = function(a, b) {
        if (a.index > b.index) {
          const tmp = a;
          a = b;
          b = tmp;
        }
        const out = b4a.allocUnsafe(32);
        sodium.crypto_generichash_batch(out, [
          PARENT_TYPE,
          c.encode(c.uint64, a.size + b.size),
          a.hash,
          b.hash
        ]);
        return out;
      };
      exports.tree = function(roots, out) {
        const buffers = new Array(3 * roots.length + 1);
        let j = 0;
        buffers[j++] = ROOT_TYPE;
        for (let i = 0; i < roots.length; i++) {
          const r = roots[i];
          buffers[j++] = r.hash;
          buffers[j++] = c.encode(c.uint64, r.index);
          buffers[j++] = c.encode(c.uint64, r.size);
        }
        if (!out) out = b4a.allocUnsafe(32);
        sodium.crypto_generichash_batch(out, buffers);
        return out;
      };
      exports.hash = function(data, out) {
        if (!out) out = b4a.allocUnsafe(32);
        if (!Array.isArray(data)) data = [data];
        sodium.crypto_generichash_batch(out, data);
        return out;
      };
      exports.randomBytes = function(n) {
        const buf = b4a.allocUnsafe(n);
        sodium.randombytes_buf(buf);
        return buf;
      };
      exports.discoveryKey = function(key) {
        if (!key || key.byteLength !== 32) throw new Error("Must pass a 32 byte buffer");
        const digest = b4a.allocUnsafeSlow(32);
        sodium.crypto_generichash(digest, HYPERCORE, key);
        return digest;
      };
      if (sodium.sodium_free) {
        exports.free = function(secureBuf) {
          if (secureBuf.secure) sodium.sodium_free(secureBuf);
        };
      } else {
        exports.free = function() {
        };
      }
      exports.namespace = function(name, count) {
        const ids = typeof count === "number" ? range(count) : count;
        const buf = b4a.allocUnsafeSlow(32 * ids.length);
        const list = new Array(ids.length);
        const ns = b4a.allocUnsafe(33);
        sodium.crypto_generichash(ns.subarray(0, 32), typeof name === "string" ? b4a.from(name) : name);
        for (let i = 0; i < list.length; i++) {
          list[i] = buf.subarray(32 * i, 32 * i + 32);
          ns[32] = ids[i];
          sodium.crypto_generichash(list[i], ns);
        }
        return list;
      };
      function range(count) {
        const arr = new Array(count);
        for (let i = 0; i < count; i++) arr[i] = i;
        return arr;
      }
    }
  });

  // ../../node_modules/hyperblobs/lib/block-map.js
  var require_block_map = __commonJS({
    "../../node_modules/hyperblobs/lib/block-map.js"(exports) {
      var c = require_compact_encoding();
      var b4a = require_b4a();
      var crypto = require_hypercore_crypto();
      var block = {
        preencode(state, m) {
          c.uint.preencode(state, m.index);
          c.uint.preencode(state, m.byteLength);
        },
        encode(state, m) {
          c.uint.encode(state, m.index);
          c.uint.encode(state, m.byteLength);
        },
        decode(state) {
          return {
            index: c.uint.decode(state),
            byteLength: c.uint.decode(state)
          };
        }
      };
      var list = c.array(block);
      var map = {
        preencode(state, m) {
          c.uint.preencode(state, 0);
          list.preencode(state, m.blocks);
        },
        encode(state, m) {
          c.uint.encode(state, 0);
          list.encode(state, m.blocks);
        },
        decode(state) {
          const version = c.uint.decode(state);
          if (version > 0) throw new Error("Unsupported block map version");
          return {
            version,
            blocks: list.decode(state)
          };
        }
      };
      exports.hash = hashId;
      function hashId(block2) {
        return b4a.toString(crypto.hash(block2), "hex");
      }
      exports.get = getBlockMap;
      async function inferBlockMap(core, id, opts = {}) {
        const hashes = !!opts.hashes;
        const map2 = {
          hashes: hashes ? /* @__PURE__ */ new Map() : null,
          blocks: []
        };
        for (let i = id.blockOffset; i < id.blockOffset + id.blockLength; i++) {
          const block2 = await core.get(i);
          const entry = { index: i, byteLength: block2.byteLength };
          map2.blocks.push(entry);
          if (hashes) map2.hashes.set(hashId(block2), entry);
        }
        return map2;
      }
      async function getBlockMap(core, id, opts = {}) {
        if (!id.blockMap) return inferBlockMap(core, id, opts);
        if (id.blockLength > 64) {
          throw new Error("Block map is too large");
        }
        const hashes = !!opts.hashes;
        const map2 = {
          hashes: hashes ? /* @__PURE__ */ new Map() : null,
          blocks: null
        };
        const promises = [];
        for (let i = id.blockOffset; i < id.blockOffset + id.blockLength; i++) {
          promises.push(core.get(i));
        }
        const buffers = await Promise.all(promises);
        const m = decodeBlockMap(buffers);
        if (!m) return null;
        map2.blocks = m.blocks;
        if (hashes && !core.writable) {
          const blocks = [];
          for (let i = 0; i < map2.blocks.length; i++) blocks.push(map2.blocks[i].index);
          core.download({ blocks });
        }
        if (hashes) {
          for (let i = 0; i < map2.blocks.length; i++) {
            const b = map2.blocks[i];
            const block2 = await core.get(b.index);
            if (block2 === null) return null;
            map2.hashes.set(hashId(block2), b);
          }
        }
        return map2;
      }
      exports.encode = encodeBlockMap;
      function encodeBlockMap(header) {
        const result = [];
        for (let i = 0; i < header.blocks.length; i += 8192) {
          const blocks = i === 0 && header.blocks.length < 8192 ? header.blocks : header.blocks.slice(i, i + 8192);
          const state = { start: 0, end: 0, buffer: null };
          const m = { version: 0, blocks };
          map.preencode(state, m);
          state.buffer = b4a.allocUnsafe(state.end);
          map.encode(state, m);
          result.push(state.buffer);
        }
        return result;
      }
      exports.decode = decodeBlockMap;
      function decodeBlockMap(buffers) {
        const result = {
          version: 0,
          blocks: null
        };
        for (let i = 0; i < buffers.length; i++) {
          if (!buffers[i]) return null;
          const state = { start: 0, end: buffers[i].byteLength, buffer: buffers[i] };
          const r = map.decode(state);
          result.version = r.version;
          if (result.blocks) result.blocks.push(...r.blocks);
          else result.blocks = r.blocks;
        }
        return result;
      }
    }
  });

  // ../../node_modules/hyperblobs/lib/streams.js
  var require_streams2 = __commonJS({
    "../../node_modules/hyperblobs/lib/streams.js"(exports, module) {
      var { Readable, Writable } = require_streamx();
      var { BLOCK_NOT_AVAILABLE } = require_hypercore_errors();
      var Prefetcher = require_prefetcher();
      var blockMap = require_block_map();
      var BlobWriteStream = class extends Writable {
        constructor(core, lock, opts = {}) {
          super(opts);
          this.id = { blockOffset: 0, byteOffset: 0, blockLength: 0, byteLength: 0 };
          this.core = core;
          this._dedup = !!opts.dedup;
          this._blob = opts.blob || null;
          this._hashes = null;
          this._addBlockMap = !!opts.blockMap || this._dedup;
          this._blockMap = this._addBlockMap ? { version: 0, blocks: [] } : null;
          this._lock = lock;
          this._release = null;
          this._batch = [];
          if (this._addBlockMap) this.id.blockMap = true;
        }
        async _openp() {
          await this.core.ready();
          const release = await new Promise((resolve) => this._lock(resolve));
          this._release = release;
          this.id.byteOffset = this.core.byteLength;
          this.id.blockOffset = this.core.length;
          if (!this._dedup) return;
          if (this._blob) {
            const map = await blockMap.get(this.core, this._blob, { hashes: true });
            this._hashes = map.hashes;
          } else {
            this._hashes = /* @__PURE__ */ new Map();
          }
        }
        _open(cb) {
          this._openp().then(cb, cb);
        }
        async _finalp() {
          await this._append();
          if (this._blockMap) {
            const buffers = await blockMap.encode(this._blockMap);
            this.id.blockOffset = this.core.length;
            this.id.byteOffset = this.core.byteLength;
            await this.core.append(buffers);
          }
          this.id.blockLength = this.core.length - this.id.blockOffset;
          this.id.byteLength = this.core.byteLength - this.id.byteOffset;
        }
        _final(cb) {
          this._finalp().then(cb, cb);
        }
        _destroy(cb) {
          if (this._release) this._release();
          cb(null);
        }
        async _append() {
          if (!this._batch.length) return;
          const batch = this._batch;
          this._batch = [];
          await this.core.append(batch);
        }
        _write(data, cb) {
          let dup = false;
          if (this._blockMap) {
            let entry = {
              index: this.core.length + this._batch.length,
              byteLength: data.byteLength
            };
            if (this._hashes) {
              const id = blockMap.hash(data);
              const existing = this._hashes.get(id);
              if (existing) {
                entry = existing;
                dup = true;
              } else {
                this._hashes.set(id, entry);
              }
            }
            this._blockMap.blocks.push(entry);
          }
          if (dup) return cb();
          this._batch.push(data);
          if (this._batch.length >= 16) {
            this._append().then(cb, cb);
            return;
          }
          return cb();
        }
      };
      var BlockMapReadStream = class extends Readable {
        constructor(core, id, opts = {}) {
          super(opts);
          this.id = id;
          this.core = core.session({ wait: opts.wait, timeout: opts.timeout });
          const noPrefetch = opts.wait === false || opts.prefetch === false || !core.core;
          const start = opts.start || 0;
          const end = opts.end === void 0 ? opts.length === void 0 ? -1 : start + opts.length : opts.end + 1;
          this._blockMap = null;
          this._rangeStart = start;
          this._rangeEnd = end;
          this._startIndex = 0;
          this._startOffset = 0;
          this._endIndex = -1;
          this._endOffset = -1;
          this._range = null;
          this._noPrefetch = noPrefetch;
        }
        async _openp() {
          this._blockMap = await blockMap.get(this.core, this.id);
          const [startIndex, startOffset, endIndex, endLength] = seekBlockMap(
            this._blockMap,
            this._rangeStart,
            this._rangeEnd
          );
          this._startIndex = startIndex;
          this._startOffset = startOffset;
          this._endIndex = endIndex;
          this._endOffset = endLength;
          if (this._endIndex === -1) {
            this._endIndex = this._blockMap.blocks.length;
            this._endOffset = 0;
          }
        }
        _open(cb) {
          this._openp().then(cb, cb);
        }
        _predestroy() {
          if (this._range) this._range.destroy();
          this.core.close().then(noop, noop);
        }
        _destroy(cb) {
          if (this._range) this._range.destroy();
          this.core.close().then(cb, cb);
        }
        _prefetch(index) {
          const blocks = [];
          for (; index < this._endIndex; index++) blocks.push(this._blockMap.blocks[index].index);
          this._range = this.core.download({ blocks });
        }
        async _readp() {
          if (this._startIndex >= this._endIndex) {
            this.push(null);
            return;
          }
          let block = null;
          const index = this._startIndex++;
          const b = this._blockMap.blocks[index];
          if (!this._range && !this._noPrefetch) {
            block = await this.core.get(b.index, { wait: false });
            if (!block) this._prefetch(index);
          }
          if (!block) {
            block = await this.core.get(b.index);
          }
          if (!block) throw BLOCK_NOT_AVAILABLE();
          if (this._startOffset) {
            block = block.subarray(this._startOffset);
            this._startOffset = 0;
          }
          if (this._startIndex === this._endIndex && this._endOffset) {
            block = block.subarray(0, block.byteLength - this._endOffset);
          }
          this.push(block);
        }
        _read(cb) {
          this._readp().then(cb, cb);
        }
      };
      var BlobReadStream = class extends Readable {
        constructor(core, id, opts = {}) {
          super(opts);
          this.id = id;
          this.core = core.session({ wait: opts.wait, timeout: opts.timeout });
          const start = id.blockOffset;
          const end = id.blockOffset + id.blockLength;
          const noPrefetch = opts.wait === false || opts.prefetch === false || !core.core;
          this._prefetch = noPrefetch ? null : new Prefetcher(this.core, { max: opts.prefetch, start, end });
          this._lastPrefetch = null;
          this._pos = opts.start !== void 0 ? id.byteOffset + opts.start : id.byteOffset;
          if (opts.length !== void 0) this._end = this._pos + opts.length;
          else if (opts.end !== void 0) this._end = id.byteOffset + opts.end + 1;
          else this._end = id.byteOffset + id.byteLength;
          this._index = 0;
          this._relativeOffset = 0;
          this._bytesRead = 0;
        }
        async _openp() {
          if (this._pos === this.id.byteOffset) {
            this._index = this.id.blockOffset;
            this._relativeOffset = 0;
            return;
          }
          const result = await this.core.seek(this._pos, {
            start: this.id.blockOffset,
            end: this.id.blockOffset + this.id.blockLength
          });
          if (!result) throw BLOCK_NOT_AVAILABLE();
          this._index = result[0];
          this._relativeOffset = result[1];
        }
        _open(cb) {
          this._openp().then(cb, cb);
        }
        _predestroy() {
          if (this._prefetch) this._prefetch.destroy();
          this.core.close().then(noop, noop);
        }
        _destroy(cb) {
          if (this._prefetch) this._prefetch.destroy();
          this.core.close().then(cb, cb);
        }
        async _readp() {
          if (this._pos >= this._end) {
            this.push(null);
            return;
          }
          if (this._prefetch) this._prefetch.update(this._index);
          let block = await this.core.get(this._index);
          if (!block) throw BLOCK_NOT_AVAILABLE();
          const remainder = this._end - this._pos;
          if (this._relativeOffset || remainder < block.length) {
            block = block.subarray(this._relativeOffset, this._relativeOffset + remainder);
          }
          this._index++;
          this._relativeOffset = 0;
          this._pos += block.length;
          this._bytesRead += block.length;
          this.push(block);
        }
        _read(cb) {
          this._readp().then(cb, cb);
        }
      };
      module.exports = {
        BlockMapReadStream,
        BlobReadStream,
        BlobWriteStream
      };
      function noop() {
      }
      function seekBlockMap(map, start, end) {
        let s = -1;
        let so = -1;
        let e = -1;
        let eo = -1;
        for (let i = 0; i < map.blocks.length; i++) {
          const b = map.blocks[i];
          if (s === -1) {
            if (start < b.byteLength) {
              s = i;
              so = start;
            } else {
              start -= b.byteLength;
            }
          }
          if (e === -1 && end > -1) {
            if (end <= b.byteLength) {
              e = i + 1;
              eo = b.byteLength - end;
            } else {
              end -= b.byteLength;
            }
          }
        }
        return [s, so, e, eo];
      }
    }
  });

  // ../../node_modules/hyperblobs/lib/monitor.js
  var require_monitor = __commonJS({
    "../../node_modules/hyperblobs/lib/monitor.js"(exports, module) {
      var EventEmitter = require_bare_node_events();
      var speedometer = require_speedometer();
      module.exports = class Monitor extends EventEmitter {
        constructor(blobs, id) {
          super();
          if (!id) throw new Error("id is required");
          this.blobs = blobs;
          this.id = id;
          this.peers = 0;
          this.uploadSpeedometer = null;
          this.downloadSpeedometer = null;
          const stats = {
            startTime: 0,
            percentage: 0,
            peers: 0,
            speed: 0,
            blocks: 0,
            totalBytes: 0,
            // local + bytes loaded during monitoring
            monitoringBytes: 0,
            // bytes loaded during monitoring
            targetBytes: 0,
            targetBlocks: 0
          };
          this.uploadStats = { ...stats };
          this.downloadStats = { ...stats };
          this.uploadStats.targetBytes = this.downloadStats.targetBytes = this.id.byteLength;
          this.uploadStats.targetBlocks = this.downloadStats.targetBlocks = this.id.blockLength;
          this.uploadStats.peers = this.downloadStats.peers = this.peers = this.blobs.core.peers.length;
          this.uploadSpeedometer = speedometer();
          this.downloadSpeedometer = speedometer();
        }
        // just an alias
        destroy() {
          return this.close();
        }
        close() {
          this.blobs._removeMonitor(this);
        }
        _onUpload(index, bytes, from) {
          this._updateStats(this.uploadSpeedometer, this.uploadStats, index, bytes, from);
        }
        _onDownload(index, bytes, from) {
          this._updateStats(this.downloadSpeedometer, this.downloadStats, index, bytes, from);
        }
        _updatePeers() {
          this.uploadStats.peers = this.downloadStats.peers = this.peers = this.blobs.core.peers.length;
          this.emit("update");
        }
        _updateStats(speed, stats, index, bytes) {
          if (this.closing) return;
          if (!isWithinRange(index, this.id)) return;
          if (!stats.startTime) stats.startTime = Date.now();
          stats.speed = speed(bytes);
          stats.blocks++;
          stats.totalBytes += bytes;
          stats.monitoringBytes += bytes;
          stats.percentage = toFixed(stats.blocks / stats.targetBlocks * 100);
          this.emit("update");
        }
        downloadSpeed() {
          return this.downloadSpeedometer ? this.downloadSpeedometer() : 0;
        }
        uploadSpeed() {
          return this.uploadSpeedometer ? this.uploadSpeedometer() : 0;
        }
      };
      function isWithinRange(index, { blockOffset, blockLength }) {
        return index >= blockOffset && index < blockOffset + blockLength;
      }
      function toFixed(n) {
        return Math.round(n * 100) / 100;
      }
    }
  });

  // ../../node_modules/hyperblobs/index.js
  var require_hyperblobs = __commonJS({
    "../../node_modules/hyperblobs/index.js"(exports, module) {
      var mutexify = require_mutexify();
      var b4a = require_b4a();
      var { BlockMapReadStream, BlobReadStream, BlobWriteStream } = require_streams2();
      var Monitor = require_monitor();
      var blockMap = require_block_map();
      var DEFAULT_BLOCK_SIZE = 2 ** 16;
      var HyperBlobsBatch = class {
        constructor(blobs) {
          this.blobs = blobs;
          this.blocks = [];
          this.bytes = 0;
        }
        ready() {
          return this.blobs.ready();
        }
        async put(buffer) {
          if (!this.blobs.core.opened) await this.blobs.core.ready();
          const blockSize = this.blobs.blockSize;
          const result = {
            blockOffset: this.blobs.core.length + this.blocks.length,
            blockLength: 0,
            byteOffset: this.blobs.core.byteLength + this.bytes,
            byteLength: 0
          };
          let offset = 0;
          while (offset < buffer.byteLength) {
            const blk = buffer.subarray(offset, offset + blockSize);
            offset += blockSize;
            result.blockLength++;
            result.byteLength += blk.byteLength;
            this.bytes += blk.byteLength;
            this.blocks.push(blk);
          }
          return result;
        }
        async get(id) {
          if (id.blockOffset < this.blobs.core.length) {
            return this.blobs.get(id);
          }
          const bufs = [];
          for (let i = id.blockOffset - this.blobs.core.length; i < id.blockOffset + id.blockLength; i++) {
            if (i >= this.blocks.length) return null;
            bufs.push(this.blocks[i]);
          }
          return bufs.length === 1 ? bufs[0] : b4a.concat(bufs);
        }
        async flush() {
          await this.blobs.core.append(this.blocks);
          this.blocks = [];
          this.bytes = 0;
        }
        close() {
        }
      };
      var Hyperblobs = class _Hyperblobs {
        constructor(core, opts = {}) {
          this.core = core;
          this.blockSize = opts.blockSize || DEFAULT_BLOCK_SIZE;
          this._lock = mutexify();
          this._monitors = /* @__PURE__ */ new Set();
          this._boundUpdatePeers = this._updatePeers.bind(this);
          this._boundOnUpload = this._onUpload.bind(this);
          this._boundOnDownload = this._onDownload.bind(this);
        }
        get key() {
          return this.core.key;
        }
        get discoveryKey() {
          return this.core.discoveryKey;
        }
        get feed() {
          return this.core;
        }
        get locked() {
          return this._lock.locked;
        }
        replicate(isInitiator, opts) {
          return this.core.replicate(isInitiator, opts);
        }
        ready() {
          return this.core.ready();
        }
        close() {
          return this.core.close();
        }
        batch() {
          return new HyperBlobsBatch(this);
        }
        snapshot() {
          return new _Hyperblobs(this.core.snapshot());
        }
        async put(blob, opts) {
          if (!b4a.isBuffer(blob)) blob = b4a.from(blob);
          const blockSize = opts && opts.blockSize || this.blockSize;
          const stream = this.createWriteStream(opts);
          for (let i = 0; i < blob.length; i += blockSize) {
            stream.write(blob.subarray(i, i + blockSize));
          }
          stream.end();
          return new Promise((resolve, reject) => {
            stream.once("error", reject);
            stream.once("close", () => resolve(stream.id));
          });
        }
        async _getAll(id, opts) {
          if (id.blockLength === 1) return this.core.get(id.blockOffset, opts);
          const promises = new Array(id.blockLength);
          for (let i = 0; i < id.blockLength; i++) {
            promises[i] = this.core.get(id.blockOffset + i, opts);
          }
          const blocks = await Promise.all(promises);
          for (let i = 0; i < id.blockLength; i++) {
            if (blocks[i] === null) return null;
          }
          return b4a.concat(blocks);
        }
        async get(id, opts) {
          if (isAll(id, opts)) return this._getAll(id, opts);
          const res = [];
          try {
            for await (const block of this.createReadStream(id, opts)) {
              res.push(block);
            }
          } catch (error) {
            if (error.code === "BLOCK_NOT_AVAILABLE") return null;
            throw error;
          }
          if (res.length === 1) return res[0];
          return b4a.concat(res);
        }
        getBlockMap(id) {
          return id.blockMap ? blockMap.get(this.core, id) : null;
        }
        async getByteLength(id) {
          if (!id.blockMap || id.byteLength === 0) return id.byteLength;
          const map = await this.getBlockMap(id);
          let size = 0;
          for (const b of map.blocks) size += b.byteLength;
          return size;
        }
        async clear(id, opts) {
          if (id.blockMap) {
            const map = await blockMap.get(this.core, id, { wait: false });
            if (map) {
              for (const b of map.blocks) await this.core.clear(b.index, b.index + 1, opts);
            }
          }
          return this.core.clear(id.blockOffset, id.blockOffset + id.blockLength, opts);
        }
        createReadStream(id, opts) {
          const core = opts && opts.core ? opts.core : this.core;
          return id.blockMap ? new BlockMapReadStream(core, id, opts) : new BlobReadStream(core, id, opts);
        }
        createWriteStream(opts) {
          const core = opts && opts.core ? opts.core : this.core;
          return new BlobWriteStream(core, this._lock, opts);
        }
        monitor(id) {
          const monitor = new Monitor(this, id);
          if (this._monitors.size === 0) this._startListening();
          this._monitors.add(monitor);
          return monitor;
        }
        _removeMonitor(mon) {
          this._monitors.delete(mon);
          if (this._monitors.size === 0) this._stopListening();
        }
        _updatePeers() {
          for (const m of this._monitors) m._updatePeers();
        }
        _onUpload(index, bytes, from) {
          for (const m of this._monitors) m._onUpload(index, bytes, from);
        }
        _onDownload(index, bytes, from) {
          for (const m of this._monitors) m._onDownload(index, bytes, from);
        }
        _startListening() {
          this.core.on("peer-add", this._boundUpdatePeers);
          this.core.on("peer-remove", this._boundUpdatePeers);
          this.core.on("upload", this._boundOnUpload);
          this.core.on("download", this._boundOnDownload);
        }
        _stopListening() {
          this.core.off("peer-add", this._boundUpdatePeers);
          this.core.off("peer-remove", this._boundUpdatePeers);
          this.core.off("upload", this._boundOnUpload);
          this.core.off("download", this._boundOnDownload);
        }
      };
      module.exports = Hyperblobs;
      function isAll(id, opts) {
        if (id.blockMap) return false;
        if (!opts) return true;
        if (opts.start) return false;
        if (opts.length !== void 0 || opts.end !== void 0) return false;
        if (opts.core) return false;
        return true;
      }
    }
  });

  // ../../node_modules/is-options/index.js
  var require_is_options = __commonJS({
    "../../node_modules/is-options/index.js"(exports, module) {
      var b4a = require_b4a();
      module.exports = function isOptions(opts) {
        return typeof opts === "object" && opts && !b4a.isBuffer(opts);
      };
    }
  });

  // ../../node_modules/sub-encoder/index.js
  var require_sub_encoder = __commonJS({
    "../../node_modules/sub-encoder/index.js"(exports, module) {
      var codecs = require_codecs();
      var b = require_b4a();
      var SEP = b.alloc(1);
      var SEP_BUMPED = b.from([1]);
      var EMPTY = b.alloc(0);
      module.exports = class SubEncoder {
        constructor(prefix, encoding, parent = null) {
          this.userEncoding = codecs(encoding);
          this.prefix = prefix != null ? createPrefix(prefix, parent) : null;
          this.lt = this.prefix && b.concat([this.prefix.subarray(0, this.prefix.byteLength - 1), SEP_BUMPED]);
        }
        _encodeRangeUser(r) {
          if (this.userEncoding.encodeRange) return this.userEncoding.encodeRange(r);
          const res = {};
          if (r.gt != null) res.gt = this.userEncoding.encode(r.gt);
          if (r.gte != null) res.gte = this.userEncoding.encode(r.gte);
          if (r.lte != null) res.lte = this.userEncoding.encode(r.lte);
          if (r.lt != null) res.lt = this.userEncoding.encode(r.lt);
          return res;
        }
        _addPrefix(key) {
          return this.prefix ? b.concat([this.prefix, key]) : key;
        }
        encode(key) {
          return this._addPrefix(this.userEncoding.encode(key));
        }
        encodeRange(range) {
          const r = this._encodeRangeUser(range);
          if (r.gt) r.gt = this._addPrefix(r.gt);
          else if (r.gte) r.gte = this._addPrefix(r.gte);
          else if (this.prefix) r.gte = this.prefix;
          if (r.lt) r.lt = this._addPrefix(r.lt);
          else if (r.lte) r.lte = this._addPrefix(r.lte);
          else if (this.prefix) r.lt = this.lt;
          return r;
        }
        decode(key) {
          return this.userEncoding.decode(this.prefix ? key.subarray(this.prefix.byteLength) : key);
        }
        sub(prefix, encoding) {
          return new SubEncoder(prefix || EMPTY, compat(encoding), this.prefix);
        }
      };
      function createPrefix(prefix, parent) {
        prefix = typeof prefix === "string" ? b.from(prefix) : prefix;
        if (prefix && parent) return b.concat([parent, prefix, SEP]);
        if (prefix) return b.concat([prefix, SEP]);
        if (parent) return b.concat([parent, SEP]);
        return SEP;
      }
      function compat(enc) {
        if (enc && enc.keyEncoding) return enc.keyEncoding;
        return enc;
      }
    }
  });

  // ../../node_modules/random-access-storage/index.js
  var require_random_access_storage = __commonJS({
    "../../node_modules/random-access-storage/index.js"(exports, module) {
      var EventEmitter = require_bare_node_events();
      var queueTick = require_process_next_tick();
      var NOT_READABLE = defaultImpl(new Error("Not readable"));
      var NOT_WRITABLE = defaultImpl(new Error("Not writable"));
      var NOT_DELETABLE = defaultImpl(new Error("Not deletable"));
      var NOT_STATABLE = defaultImpl(new Error("Not statable"));
      var DEFAULT_OPEN = defaultImpl(null);
      var DEFAULT_CLOSE = defaultImpl(null);
      var DEFAULT_UNLINK = defaultImpl(null);
      var READ_OP = 0;
      var WRITE_OP = 1;
      var DEL_OP = 2;
      var TRUNCATE_OP = 3;
      var STAT_OP = 4;
      var OPEN_OP = 5;
      var SUSPEND_OP = 6;
      var CLOSE_OP = 7;
      var UNLINK_OP = 8;
      module.exports = class RandomAccessStorage extends EventEmitter {
        constructor(opts) {
          super();
          this._queued = [];
          this._pending = 0;
          this._needsOpen = true;
          this.opened = false;
          this.suspended = false;
          this.closed = false;
          this.unlinked = false;
          this.writing = false;
          if (opts) {
            if (opts.open) this._open = opts.open;
            if (opts.read) this._read = opts.read;
            if (opts.write) this._write = opts.write;
            if (opts.del) this._del = opts.del;
            if (opts.truncate) this._truncate = opts.truncate;
            if (opts.stat) this._stat = opts.stat;
            if (opts.suspend) this._suspend = opts.suspend;
            if (opts.close) this._close = opts.close;
            if (opts.unlink) this._unlink = opts.unlink;
          }
          this.readable = this._read !== RandomAccessStorage.prototype._read;
          this.writable = this._write !== RandomAccessStorage.prototype._write;
          this.deletable = this._del !== RandomAccessStorage.prototype._del;
          this.truncatable = this._truncate !== RandomAccessStorage.prototype._truncate || this.deletable;
          this.statable = this._stat !== RandomAccessStorage.prototype._stat;
        }
        read(offset, size, cb) {
          this.run(new Request(this, READ_OP, offset, size, null, cb), false);
        }
        _read(req) {
          return NOT_READABLE(req);
        }
        write(offset, data, cb) {
          if (!cb) cb = noop;
          this.run(new Request(this, WRITE_OP, offset, data.length, data, cb), true);
        }
        _write(req) {
          return NOT_WRITABLE(req);
        }
        del(offset, size, cb) {
          if (!cb) cb = noop;
          this.run(new Request(this, DEL_OP, offset, size, null, cb), true);
        }
        _del(req) {
          return NOT_DELETABLE(req);
        }
        truncate(offset, cb) {
          if (!cb) cb = noop;
          this.run(new Request(this, TRUNCATE_OP, offset, 0, null, cb), true);
        }
        _truncate(req) {
          req.size = Infinity;
          this._del(req);
        }
        stat(cb) {
          this.run(new Request(this, STAT_OP, 0, 0, null, cb), false);
        }
        _stat(req) {
          return NOT_STATABLE(req);
        }
        open(cb) {
          if (!cb) cb = noop;
          if (this.opened && !this._needsOpen) return nextTickCallback(cb);
          this._needsOpen = false;
          queueAndRun(this, new Request(this, OPEN_OP, 0, 0, null, cb));
        }
        _open(req) {
          return DEFAULT_OPEN(req);
        }
        suspend(cb) {
          if (!cb) cb = noop;
          if (this.closed || this.suspended) return nextTickCallback(cb);
          this._needsOpen = true;
          queueAndRun(this, new Request(this, SUSPEND_OP, 0, 0, null, cb));
        }
        _suspend(req) {
          this._close(req);
        }
        close(cb) {
          if (!cb) cb = noop;
          if (this.closed) return nextTickCallback(cb);
          queueAndRun(this, new Request(this, CLOSE_OP, 0, 0, null, cb));
        }
        _close(req) {
          return DEFAULT_CLOSE(req);
        }
        unlink(cb) {
          if (!cb) cb = noop;
          if (!this.closed) this.close(noop);
          queueAndRun(this, new Request(this, UNLINK_OP, 0, 0, null, cb));
        }
        _unlink(req) {
          return DEFAULT_UNLINK(req);
        }
        run(req, writing) {
          if (writing && !this.writing) {
            this.writing = true;
            this._needsOpen = true;
          }
          if (this._needsOpen) this.open(noop);
          if (this._queued.length) this._queued.push(req);
          else req._run();
        }
      };
      var Request = class {
        constructor(self2, type, offset, size, data, cb) {
          this.type = type;
          this.offset = offset;
          this.size = size;
          this.data = data;
          this.storage = self2;
          this._sync = false;
          this._callback = cb;
          this._openError = null;
        }
        _maybeOpenError(err) {
          if (this.type !== OPEN_OP) return;
          const queued = this.storage._queued;
          for (let i = 1; i < queued.length; i++) {
            const q = queued[i];
            if (q.type === OPEN_OP) break;
            q._openError = err;
          }
        }
        _unqueue(err) {
          const ra = this.storage;
          const queued = ra._queued;
          if (err) {
            this._maybeOpenError(err);
          } else if (this.type > 4) {
            switch (this.type) {
              case OPEN_OP:
                if (ra.suspended) {
                  ra.suspended = false;
                  ra.emit("unsuspend");
                }
                if (!ra.opened) {
                  ra.opened = true;
                  ra.emit("open");
                }
                break;
              case SUSPEND_OP:
                if (!ra.suspended) {
                  ra.suspended = true;
                  ra.emit("suspend");
                }
                break;
              case CLOSE_OP:
                if (!ra.closed) {
                  ra.closed = true;
                  ra.emit("close");
                }
                break;
              case UNLINK_OP:
                if (!ra.unlinked) {
                  ra.unlinked = true;
                  ra.emit("unlink");
                }
                break;
            }
          }
          if (queued.length && queued[0] === this) queued.shift();
          if (!--ra._pending) drainQueue(ra);
        }
        callback(err, val) {
          if (this._sync) return nextTick(this, err, val);
          this._unqueue(err);
          this._callback(err, val);
        }
        _openAndNotClosed() {
          const ra = this.storage;
          if (ra.opened && !ra.closed && !ra.suspended) return true;
          if (!ra.opened || ra.suspended) nextTick(this, this._openError || new Error("Not opened"));
          else if (ra.closed) nextTick(this, new Error("Closed"));
          return false;
        }
        _open() {
          const ra = this.storage;
          if (ra.opened && !ra.suspended) return nextTick(this, null);
          if (ra.closed) return nextTick(this, new Error("Closed"));
          ra._open(this);
        }
        _run() {
          const ra = this.storage;
          ra._pending++;
          this._sync = true;
          switch (this.type) {
            case READ_OP:
              if (this._openAndNotClosed()) ra._read(this);
              break;
            case WRITE_OP:
              if (this._openAndNotClosed()) ra._write(this);
              break;
            case DEL_OP:
              if (this._openAndNotClosed()) ra._del(this);
              break;
            case TRUNCATE_OP:
              if (this._openAndNotClosed()) ra._truncate(this);
              break;
            case STAT_OP:
              if (this._openAndNotClosed()) ra._stat(this);
              break;
            case OPEN_OP:
              this._open();
              break;
            case SUSPEND_OP:
              if (ra.closed || !ra.opened || ra.suspended) nextTick(this, null);
              else ra._suspend(this);
              break;
            case CLOSE_OP:
              if (ra.closed || !ra.opened || ra.suspended) nextTick(this, null);
              else ra._close(this);
              break;
            case UNLINK_OP:
              if (ra.unlinked) nextTick(this, null);
              else ra._unlink(this);
              break;
          }
          this._sync = false;
        }
      };
      function queueAndRun(self2, req) {
        self2._queued.push(req);
        if (!self2._pending) req._run();
      }
      function drainQueue(self2) {
        const queued = self2._queued;
        while (queued.length > 0) {
          const blocking = queued[0].type > 4;
          if (!blocking || !self2._pending) queued[0]._run();
          if (blocking) return;
          queued.shift();
        }
      }
      function defaultImpl(err) {
        return overridable;
        function overridable(req) {
          nextTick(req, err);
        }
      }
      function nextTick(req, err, val) {
        queueTick(() => req.callback(err, val));
      }
      function nextTickCallback(cb) {
        queueTick(() => cb(null));
      }
      function noop() {
      }
    }
  });

  // ../../node_modules/fs-native-extensions/binding.js
  var require_binding9 = __commonJS({
    "../../node_modules/fs-native-extensions/binding.js"(exports, module) {
      __require.addon = require_node2();
      module.exports = __require.addon(".", __filename);
    }
  });

  // ../../node_modules/fs-native-extensions/index.js
  var require_fs_native_extensions = __commonJS({
    "../../node_modules/fs-native-extensions/index.js"(exports) {
      var { isWindows } = require_which_runtime();
      var binding = require_binding9();
      function onwork(err, result) {
        if (err) this.reject(err);
        else this.resolve(result);
      }
      exports.tryLock = function tryLock(fd, offset = 0, length = 0, opts = {}) {
        if (typeof offset === "object") {
          opts = offset;
          offset = 0;
        }
        if (typeof length === "object") {
          opts = length;
          length = 0;
        }
        if (typeof opts !== "object" || opts === null) {
          opts = {};
        }
        try {
          binding.tryLock(fd, offset, length, opts.shared !== true);
        } catch (err) {
          if (err.code === "EAGAIN") return false;
          throw err;
        }
        return true;
      };
      exports.waitForLock = function waitForLock(fd, offset = 0, length = 0, opts = {}) {
        if (typeof offset === "object") {
          opts = offset;
          offset = 0;
        }
        if (typeof length === "object") {
          opts = length;
          length = 0;
        }
        if (typeof opts !== "object" || opts === null) {
          opts = {};
        }
        const req = {
          handle: null,
          resolve: null,
          reject: null
        };
        const promise = new Promise((resolve, reject) => {
          req.resolve = resolve;
          req.reject = reject;
        });
        try {
          req.handle = binding.waitForLock(
            fd,
            offset,
            length,
            opts.shared !== true,
            req,
            onwork
          );
        } catch (err) {
          return Promise.reject(err);
        }
        return promise;
      };
      exports.tryDowngradeLock = function tryDowngradeLock(fd, offset = 0, length = 0) {
        try {
          binding.tryDowngradeLock(fd, offset, length);
        } catch (err) {
          if (err.code === "EAGAIN") return false;
          throw err;
        }
        return true;
      };
      exports.waitForDowngradeLock = function downgradeLock(fd, offset = 0, length = 0) {
        const req = {
          handle: null,
          resolve: null,
          reject: null
        };
        const promise = new Promise((resolve, reject) => {
          req.resolve = resolve;
          req.reject = reject;
        });
        try {
          req.handle = binding.waitForDowngradeLock(fd, offset, length, req, onwork);
        } catch (err) {
          return Promise.reject(err);
        }
        return promise;
      };
      exports.tryUpgradeLock = function tryUpgradeLock(fd, offset = 0, length = 0) {
        try {
          binding.tryUpgradeLock(fd, offset, length);
        } catch (err) {
          if (err.code === "EAGAIN") return false;
          throw err;
        }
        return true;
      };
      exports.waitForUpgradeLock = function upgradeLock(fd, offset = 0, length = 0) {
        const req = {
          handle: null,
          resolve: null,
          reject: null
        };
        const promise = new Promise((resolve, reject) => {
          req.resolve = resolve;
          req.reject = reject;
        });
        try {
          req.handle = binding.waitForUpgradeLock(fd, offset, length, req, onwork);
        } catch (err) {
          return Promise.reject(err);
        }
        return promise;
      };
      exports.unlock = function unlock(fd, offset = 0, length = 0) {
        binding.unlock(fd, offset, length);
      };
      exports.trim = function trim(fd, offset, length) {
        const req = {
          handle: null,
          resolve: null,
          reject: null
        };
        const promise = new Promise((resolve, reject) => {
          req.resolve = resolve;
          req.reject = reject;
        });
        try {
          req.handle = binding.trim(fd, offset, length, req, onwork);
        } catch (err) {
          return Promise.reject(err);
        }
        return promise;
      };
      exports.sparse = function sparse(fd) {
        if (!isWindows) return Promise.resolve();
        const req = {
          handle: null,
          resolve: null,
          reject: null
        };
        const promise = new Promise((resolve, reject) => {
          req.resolve = resolve;
          req.reject = reject;
        });
        try {
          req.handle = binding.sparse(fd, req, onwork);
        } catch (err) {
          return Promise.reject(err);
        }
        return promise;
      };
      exports.swap = function swap(from, to) {
        const req = {
          handle: null,
          resolve: null,
          reject: null
        };
        const promise = new Promise((resolve, reject) => {
          req.resolve = resolve;
          req.reject = reject;
        });
        try {
          req.handle = binding.swap(from, to, req, onwork);
        } catch (err) {
          return Promise.reject(err);
        }
        return promise;
      };
      exports.getAttr = function getAttr(fd, name) {
        const req = {
          handle: null,
          resolve: null,
          reject: null
        };
        const promise = new Promise((resolve, reject) => {
          req.resolve = resolve;
          req.reject = reject;
        });
        try {
          req.handle = binding.getAttr(fd, name, req, onwork);
        } catch (err) {
          return Promise.reject(err);
        }
        return promise.then(
          (buffer) => buffer === null ? null : Buffer.from(buffer)
        );
      };
      exports.setAttr = function setAttr(fd, name, value, encoding) {
        if (typeof value === "string") value = Buffer.from(value, encoding);
        const req = {
          value,
          handle: null,
          resolve: null,
          reject: null
        };
        const promise = new Promise((resolve, reject) => {
          req.resolve = resolve;
          req.reject = reject;
        });
        try {
          req.handle = binding.setAttr(
            fd,
            name,
            value.buffer,
            value.byteOffset,
            value.byteLength,
            req,
            onwork
          );
        } catch (err) {
          return Promise.reject(err);
        }
        return promise;
      };
      exports.removeAttr = function removeAttr(fd, name) {
        const req = {
          handle: null,
          resolve: null,
          reject: null
        };
        const promise = new Promise((resolve, reject) => {
          req.resolve = resolve;
          req.reject = reject;
        });
        try {
          req.handle = binding.removeAttr(fd, name, req, onwork);
        } catch (err) {
          return Promise.reject(err);
        }
        return promise;
      };
      exports.listAttrs = function listAttrs(fd) {
        const req = {
          handle: null,
          resolve: null,
          reject: null
        };
        const promise = new Promise((resolve, reject) => {
          req.resolve = resolve;
          req.reject = reject;
        });
        try {
          req.handle = binding.listAttrs(fd, req, onwork);
        } catch (err) {
          return Promise.reject(err);
        }
        return promise;
      };
    }
  });

  // ../../node_modules/random-access-file/index.js
  var require_random_access_file = __commonJS({
    "../../node_modules/random-access-file/index.js"(exports, module) {
      var RandomAccessStorage = require_random_access_storage();
      var fs = require_bare_node_fs();
      var path = __require("path");
      var constants = fs.constants;
      var fsext = null;
      try {
        fsext = require_fs_native_extensions();
      } catch {
      }
      var RDWR = constants.O_RDWR;
      var RDONLY = constants.O_RDONLY;
      var WRONLY = constants.O_WRONLY;
      var CREAT = constants.O_CREAT;
      var Pool = class {
        constructor(maxSize) {
          this.maxSize = maxSize;
          this.active = [];
        }
        _onactive(file) {
          if (this.active.length >= this.maxSize) {
            const r = Math.floor(Math.random() * this.active.length);
            this.active[r].suspend();
          }
          file._pi = this.active.push(file) - 1;
        }
        _oninactive(file) {
          const head = this.active.pop();
          if (head !== file) {
            head._pi = file._pi;
            this.active[head._pi] = head;
          }
        }
      };
      module.exports = class RandomAccessFile extends RandomAccessStorage {
        constructor(filename, opts = {}) {
          const size = opts.size || (opts.truncate ? 0 : -1);
          super();
          if (opts.directory) filename = path.join(opts.directory, path.resolve("/", filename).replace(/^\w+:\\/, ""));
          this.directory = opts.directory || null;
          this.filename = filename;
          this.fd = 0;
          const {
            readable = true,
            writable = true
          } = opts;
          this.mode = readable && writable ? RDWR : readable ? RDONLY : WRONLY;
          this._pi = 0;
          this._pool = opts.pool || null;
          this._size = size;
          this._rmdir = !!opts.rmdir;
          this._lock = opts.lock === true;
          this._sparse = opts.sparse === true;
          this._alloc = opts.alloc || Buffer.allocUnsafe;
          this._alwaysCreate = size >= 0;
        }
        static createPool(maxSize) {
          return new Pool(maxSize);
        }
        _open(req) {
          const create = this._alwaysCreate || this.writing;
          const self2 = this;
          const mode = this.mode | (create ? CREAT : 0);
          if (create) fs.mkdir(path.dirname(this.filename), { recursive: true }, ondir);
          else ondir(null);
          function ondir(err) {
            if (err) return req.callback(err);
            fs.open(self2.filename, mode, onopen);
          }
          function onopen(err, fd) {
            if (err) return onerror(err);
            self2.fd = fd;
            if (!self2._lock || !fsext) return onlock(null);
            const shared = self2.mode === RDONLY;
            if (fsext.tryLock(self2.fd, { shared })) onlock(null);
            else onlock(createLockError(self2.filename));
          }
          function onlock(err) {
            if (err) return onerrorafteropen(err);
            if (!self2._sparse || !fsext || self2.mode === RDONLY) return onsparse(null);
            fsext.sparse(self2.fd).then(onsparse, onsparse);
          }
          function onsparse(err) {
            if (err) return onerrorafteropen(err);
            if (self2._size < 0) return ontruncate(null);
            fs.ftruncate(self2.fd, self2._size, ontruncate);
          }
          function ontruncate(err) {
            if (err) return onerrorafteropen(err);
            if (self2._pool !== null) self2._pool._onactive(self2);
            req.callback(null);
          }
          function onerror(err) {
            req.callback(err);
          }
          function onerrorafteropen(err) {
            fs.close(self2.fd, function() {
              self2.fd = 0;
              onerror(err);
            });
          }
        }
        _write(req) {
          const data = req.data;
          const fd = this.fd;
          fs.write(fd, data, 0, req.size, req.offset, onwrite);
          function onwrite(err, wrote) {
            if (err) return req.callback(err);
            req.size -= wrote;
            req.offset += wrote;
            if (!req.size) return req.callback(null);
            fs.write(fd, data, data.length - req.size, req.size, req.offset, onwrite);
          }
        }
        _read(req) {
          const self2 = this;
          const data = req.data || this._alloc(req.size);
          const fd = this.fd;
          if (!req.size) return process.nextTick(readEmpty, req);
          fs.read(fd, data, 0, req.size, req.offset, onread);
          function onread(err, read) {
            if (err) return req.callback(err);
            if (!read) return req.callback(createReadError(self2.filename, req.offset, req.size));
            req.size -= read;
            req.offset += read;
            if (!req.size) return req.callback(null, data);
            fs.read(fd, data, data.length - req.size, req.size, req.offset, onread);
          }
        }
        _del(req) {
          if (req.size === Infinity) return this._truncate(req);
          if (!fsext) return req.callback(null);
          fsext.trim(this.fd, req.offset, req.size).then(ontrim, ontrim);
          function ontrim(err) {
            req.callback(err);
          }
        }
        _truncate(req) {
          fs.ftruncate(this.fd, req.offset, ontruncate);
          function ontruncate(err) {
            req.callback(err);
          }
        }
        _stat(req) {
          fs.fstat(this.fd, onstat);
          function onstat(err, st) {
            req.callback(err, st);
          }
        }
        _close(req) {
          const self2 = this;
          fs.close(this.fd, onclose);
          function onclose(err) {
            if (err) return req.callback(err);
            if (self2._pool !== null) self2._pool._oninactive(self2);
            self2.fd = 0;
            req.callback(null);
          }
        }
        _unlink(req) {
          const self2 = this;
          const root = this.directory && path.resolve(path.join(this.directory, "."));
          let dir = path.resolve(path.dirname(this.filename));
          fs.unlink(this.filename, onunlink);
          function onunlink(err) {
            if (err && err.code === "ENOENT") err = null;
            if (err || !self2._rmdir || !root || dir === root) return req.callback(err);
            fs.rmdir(dir, onrmdir);
          }
          function onrmdir(err) {
            dir = path.join(dir, "..");
            if (err || dir === root) return req.callback(null);
            fs.rmdir(dir, onrmdir);
          }
        }
      };
      function readEmpty(req) {
        req.callback(null, Buffer.alloc(0));
      }
      function createLockError(path2) {
        const err = new Error("ELOCKED: File is locked");
        err.code = "ELOCKED";
        err.path = path2;
        return err;
      }
      function createReadError(path2, offset, size) {
        const err = new Error("EPARTIALREAD: Could not satisfy length");
        err.code = "EPARTIALREAD";
        err.path = path2;
        err.offset = offset;
        err.size = size;
        return err;
      }
    }
  });

  // ../../node_modules/xache/index.js
  var require_xache = __commonJS({
    "../../node_modules/xache/index.js"(exports, module) {
      module.exports = class MaxCache {
        constructor({ maxSize, maxAge, createMap, ongc }) {
          this.maxSize = maxSize;
          this.maxAge = maxAge;
          this.ongc = ongc || null;
          this._createMap = createMap || defaultCreateMap;
          this._latest = this._createMap();
          this._oldest = this._createMap();
          this._retained = this._createMap();
          this._gced = false;
          this._interval = null;
          if (this.maxAge > 0 && this.maxAge < Infinity) {
            const tick = Math.ceil(2 / 3 * this.maxAge);
            this._interval = setInterval(this._gcAuto.bind(this), tick);
            if (this._interval.unref) this._interval.unref();
          }
        }
        *[Symbol.iterator]() {
          for (const it of [this._latest, this._oldest, this._retained]) {
            yield* it;
          }
        }
        *keys() {
          for (const it of [this._latest, this._oldest, this._retained]) {
            yield* it.keys();
          }
        }
        *values() {
          for (const it of [this._latest, this._oldest, this._retained]) {
            yield* it.values();
          }
        }
        destroy() {
          this.clear();
          clearInterval(this._interval);
          this._interval = null;
        }
        clear() {
          this._gced = true;
          this._latest.clear();
          this._oldest.clear();
          this._retained.clear();
        }
        set(k, v) {
          if (this._retained.has(k)) return this;
          this._latest.set(k, v);
          this._oldest.delete(k) || this._retained.delete(k);
          if (this._latest.size >= this.maxSize) this._gc();
          return this;
        }
        retain(k, v) {
          this._retained.set(k, v);
          this._latest.delete(k) || this._oldest.delete(k);
          return this;
        }
        delete(k) {
          return this._latest.delete(k) || this._oldest.delete(k) || this._retained.delete(k);
        }
        has(k) {
          return this._latest.has(k) || this._oldest.has(k) || this._retained.has(k);
        }
        get(k) {
          if (this._latest.has(k)) {
            return this._latest.get(k);
          }
          if (this._oldest.has(k)) {
            const v = this._oldest.get(k);
            this._latest.set(k, v);
            this._oldest.delete(k);
            return v;
          }
          if (this._retained.has(k)) {
            return this._retained.get(k);
          }
          return null;
        }
        _gcAuto() {
          if (!this._gced) this._gc();
          this._gced = false;
        }
        _gc() {
          this._gced = true;
          if (this.ongc !== null && this._oldest.size > 0) this.ongc(this._oldest);
          this._oldest = this._latest;
          this._latest = this._createMap();
        }
      };
      function defaultCreateMap() {
        return /* @__PURE__ */ new Map();
      }
    }
  });

  // ../../node_modules/sodium-secretstream/index.js
  var require_sodium_secretstream = __commonJS({
    "../../node_modules/sodium-secretstream/index.js"(exports, module) {
      var sodium = require_sodium_universal();
      var b4a = require_b4a();
      var ABYTES = sodium.crypto_secretstream_xchacha20poly1305_ABYTES;
      var TAG_MESSAGE = sodium.crypto_secretstream_xchacha20poly1305_TAG_MESSAGE;
      var TAG_FINAL = sodium.crypto_secretstream_xchacha20poly1305_TAG_FINAL;
      var STATEBYTES = sodium.crypto_secretstream_xchacha20poly1305_STATEBYTES;
      var HEADERBYTES = sodium.crypto_secretstream_xchacha20poly1305_HEADERBYTES;
      var KEYBYTES = sodium.crypto_secretstream_xchacha20poly1305_KEYBYTES;
      var TAG_FINAL_BYTE = b4a.isBuffer(TAG_FINAL) ? TAG_FINAL[0] : TAG_FINAL;
      var EMPTY = b4a.alloc(0);
      var TAG = b4a.alloc(1);
      var Push = class {
        constructor(key, state = b4a.allocUnsafeSlow(STATEBYTES), header = b4a.allocUnsafeSlow(HEADERBYTES)) {
          if (!TAG_FINAL) throw new Error("JavaScript sodium version needs to support crypto_secretstream_xchacha20poly");
          this.key = key;
          this.state = state;
          this.header = header;
          sodium.crypto_secretstream_xchacha20poly1305_init_push(this.state, this.header, this.key);
        }
        next(message, cipher = b4a.allocUnsafe(message.byteLength + ABYTES)) {
          sodium.crypto_secretstream_xchacha20poly1305_push(this.state, cipher, message, null, TAG_MESSAGE);
          return cipher;
        }
        final(message = EMPTY, cipher = b4a.allocUnsafe(ABYTES)) {
          sodium.crypto_secretstream_xchacha20poly1305_push(this.state, cipher, message, null, TAG_FINAL);
          return cipher;
        }
      };
      var Pull = class {
        constructor(key, state = b4a.allocUnsafeSlow(STATEBYTES)) {
          if (!TAG_FINAL) throw new Error("JavaScript sodium version needs to support crypto_secretstream_xchacha20poly");
          this.key = key;
          this.state = state;
          this.final = false;
        }
        init(header) {
          sodium.crypto_secretstream_xchacha20poly1305_init_pull(this.state, header, this.key);
        }
        next(cipher, message = b4a.allocUnsafe(cipher.byteLength - ABYTES)) {
          sodium.crypto_secretstream_xchacha20poly1305_pull(this.state, message, TAG, cipher, null);
          this.final = TAG[0] === TAG_FINAL_BYTE;
          return message;
        }
      };
      function keygen(buf = b4a.alloc(KEYBYTES)) {
        sodium.crypto_secretstream_xchacha20poly1305_keygen(buf);
        return buf;
      }
      module.exports = {
        keygen,
        KEYBYTES,
        ABYTES,
        STATEBYTES,
        HEADERBYTES,
        Push,
        Pull
      };
    }
  });

  // ../../node_modules/timeout-refresh/node.js
  var require_node3 = __commonJS({
    "../../node_modules/timeout-refresh/node.js"(exports, module) {
      module.exports = class Timer {
        constructor(ms, fn, ctx = null, interval = false) {
          this.ms = ms;
          this.ontimeout = fn;
          this.context = ctx;
          this.interval = interval;
          this.done = false;
          this._timer = interval ? setInterval(callInterval, ms, this) : setTimeout(callTimeout, ms, this);
        }
        unref() {
          this._timer.unref();
        }
        ref() {
          this._timer.ref();
        }
        refresh() {
          if (this.done !== true) this._timer.refresh();
        }
        destroy() {
          this.done = true;
          this.ontimeout = null;
          if (this.interval) clearInterval(this._timer);
          else clearTimeout(this._timer);
        }
        static once(ms, fn, ctx) {
          return new this(ms, fn, ctx, false);
        }
        static on(ms, fn, ctx) {
          return new this(ms, fn, ctx, true);
        }
      };
      function callTimeout(self2) {
        self2.done = true;
        self2.ontimeout.call(self2.context);
      }
      function callInterval(self2) {
        self2.ontimeout.call(self2.context);
      }
    }
  });

  // ../../node_modules/timeout-refresh/browser.js
  var require_browser = __commonJS({
    "../../node_modules/timeout-refresh/browser.js"(exports, module) {
      module.exports = class TimerBrowser {
        constructor(ms, fn, ctx = null, interval = false) {
          this.ms = ms;
          this.ontimeout = fn;
          this.context = ctx || null;
          this.interval = interval;
          this.done = false;
          this._timer = interval ? setInterval(callInterval, ms, this) : setTimeout(callTimeout, ms, this);
        }
        unref() {
        }
        ref() {
        }
        refresh() {
          if (this.done) return;
          if (this.interval) {
            clearInterval(this._timer);
            this._timer = setInterval(callInterval, this.ms, this);
          } else {
            clearTimeout(this._timer);
            this._timer = setTimeout(callTimeout, this.ms, this);
          }
        }
        destroy() {
          this.done = true;
          this.ontimeout = null;
          if (this.interval) clearInterval(this._timer);
          else clearTimeout(this._timer);
        }
        static once(ms, fn, ctx) {
          return new this(ms, fn, ctx, false);
        }
        static on(ms, fn, ctx) {
          return new this(ms, fn, ctx, true);
        }
      };
      function callTimeout(self2) {
        self2.done = true;
        self2.ontimeout.call(self2.context);
      }
      function callInterval(self2) {
        self2.ontimeout.call(self2.context);
      }
    }
  });

  // ../../node_modules/timeout-refresh/index.js
  var require_timeout_refresh = __commonJS({
    "../../node_modules/timeout-refresh/index.js"(exports, module) {
      module.exports = isNode() ? require_node3() : require_browser();
      function isNode() {
        const to = setTimeout(function() {
        }, 1e3);
        clearTimeout(to);
        return !!to.refresh;
      }
    }
  });

  // ../../node_modules/@hyperswarm/secret-stream/lib/bridge.js
  var require_bridge = __commonJS({
    "../../node_modules/@hyperswarm/secret-stream/lib/bridge.js"(exports, module) {
      var { Duplex, Writable } = require_streamx();
      var ReversePassThrough = class extends Duplex {
        constructor(s) {
          super();
          this._stream = s;
          this._ondrain = null;
        }
        _write(data, cb) {
          if (this._stream.push(data) === false) {
            this._stream._ondrain = cb;
          } else {
            cb(null);
          }
        }
        _final(cb) {
          this._stream.push(null);
          cb(null);
        }
        _read(cb) {
          const ondrain = this._ondrain;
          this._ondrain = null;
          if (ondrain) ondrain();
          cb(null);
        }
      };
      module.exports = class Bridge extends Duplex {
        constructor(noiseStream) {
          super();
          this.noiseStream = noiseStream;
          this._ondrain = null;
          this.reverse = new ReversePassThrough(this);
        }
        get publicKey() {
          return this.noiseStream.publicKey;
        }
        get remotePublicKey() {
          return this.noiseStream.remotePublicKey;
        }
        get handshakeHash() {
          return this.noiseStream.handshakeHash;
        }
        flush() {
          return Writable.drained(this);
        }
        _read(cb) {
          const ondrain = this._ondrain;
          this._ondrain = null;
          if (ondrain) ondrain();
          cb(null);
        }
        _write(data, cb) {
          if (this.reverse.push(data) === false) {
            this.reverse._ondrain = cb;
          } else {
            cb(null);
          }
        }
        _final(cb) {
          this.reverse.push(null);
          cb(null);
        }
      };
    }
  });

  // ../../node_modules/nanoassert/index.js
  var require_nanoassert = __commonJS({
    "../../node_modules/nanoassert/index.js"(exports, module) {
      module.exports = assert;
      var AssertionError = class extends Error {
      };
      AssertionError.prototype.name = "AssertionError";
      function assert(t, m) {
        if (!t) {
          var err = new AssertionError(m);
          if (Error.captureStackTrace) Error.captureStackTrace(err, assert);
          throw err;
        }
      }
    }
  });

  // ../../node_modules/noise-curve-ed/index.js
  var require_noise_curve_ed = __commonJS({
    "../../node_modules/noise-curve-ed/index.js"(exports, module) {
      var sodium = require_sodium_universal();
      var assert = require_nanoassert();
      var b4a = require_b4a();
      var DHLEN = sodium.crypto_scalarmult_ed25519_BYTES;
      var PKLEN = sodium.crypto_scalarmult_ed25519_BYTES;
      var SCALARLEN = sodium.crypto_scalarmult_ed25519_BYTES;
      var SKLEN = sodium.crypto_sign_SECRETKEYBYTES;
      var ALG = "Ed25519";
      module.exports = {
        DHLEN,
        PKLEN,
        SCALARLEN,
        SKLEN,
        ALG,
        name: ALG,
        generateKeyPair,
        dh
      };
      function generateKeyPair(privKey) {
        if (privKey) return generateSeedKeyPair(privKey.subarray(0, 32));
        const keyPair = {};
        keyPair.secretKey = b4a.alloc(SKLEN);
        keyPair.publicKey = b4a.alloc(PKLEN);
        sodium.crypto_sign_keypair(keyPair.publicKey, keyPair.secretKey);
        return keyPair;
      }
      function generateSeedKeyPair(seed) {
        const keyPair = {};
        keyPair.secretKey = b4a.alloc(SKLEN);
        keyPair.publicKey = b4a.alloc(PKLEN);
        sodium.crypto_sign_seed_keypair(keyPair.publicKey, keyPair.secretKey, seed);
        return keyPair;
      }
      function dh(publicKey, { scalar, secretKey }) {
        if (!scalar) {
          assert(secretKey.byteLength === SKLEN);
          const sk = b4a.alloc(64);
          sodium.crypto_hash_sha512(sk, secretKey.subarray(0, 32));
          sk[0] &= 248;
          sk[31] &= 127;
          sk[31] |= 64;
          scalar = sk.subarray(0, 32);
        }
        assert(scalar.byteLength === SCALARLEN);
        assert(publicKey.byteLength === PKLEN);
        const output = b4a.alloc(DHLEN);
        sodium.crypto_scalarmult_ed25519_noclamp(
          output,
          scalar,
          publicKey
        );
        return output;
      }
    }
  });

  // ../../node_modules/noise-handshake/cipher.js
  var require_cipher2 = __commonJS({
    "../../node_modules/noise-handshake/cipher.js"(exports, module) {
      var sodium = require_sodium_universal();
      var b4a = require_b4a();
      module.exports = class CipherState {
        constructor(key) {
          this.key = key || null;
          this.nonce = 0;
          this.CIPHER_ALG = "ChaChaPoly";
        }
        initialiseKey(key) {
          this.key = key;
          this.nonce = 0;
        }
        setNonce(nonce) {
          this.nonce = nonce;
        }
        encrypt(plaintext, ad) {
          if (!this.hasKey) return plaintext;
          if (!ad) ad = b4a.alloc(0);
          const ciphertext = encryptWithAD(this.key, this.nonce, ad, plaintext);
          if (ciphertext.length > 65535) throw new Error(`ciphertext length of ${ciphertext.length} exceeds maximum Noise message length of 65535`);
          this.nonce++;
          return ciphertext;
        }
        decrypt(ciphertext, ad) {
          if (!this.hasKey) return ciphertext;
          if (!ad) ad = b4a.alloc(0);
          if (ciphertext.length > 65535) throw new Error(`ciphertext length of ${ciphertext.length} exceeds maximum Noise message length of 65535`);
          const plaintext = decryptWithAD(this.key, this.nonce, ad, ciphertext);
          this.nonce++;
          return plaintext;
        }
        get hasKey() {
          return this.key !== null;
        }
        _clear() {
          sodium.sodium_memzero(this.key);
          this.key = null;
          this.nonce = null;
        }
        static get MACBYTES() {
          return 16;
        }
        static get NONCEBYTES() {
          return 8;
        }
        static get KEYBYTES() {
          return 32;
        }
      };
      function encryptWithAD(key, counter, additionalData, plaintext) {
        if (!b4a.isBuffer(additionalData)) additionalData = b4a.from(additionalData, "hex");
        if (!b4a.isBuffer(plaintext)) plaintext = b4a.from(plaintext, "hex");
        const nonce = b4a.alloc(sodium.crypto_aead_chacha20poly1305_ietf_NPUBBYTES);
        const view = new DataView(nonce.buffer, nonce.byteOffset, nonce.byteLength);
        view.setUint32(4, counter, true);
        const ciphertext = b4a.alloc(plaintext.byteLength + sodium.crypto_aead_chacha20poly1305_ietf_ABYTES);
        sodium.crypto_aead_chacha20poly1305_ietf_encrypt(ciphertext, plaintext, additionalData, null, nonce, key);
        return ciphertext;
      }
      function decryptWithAD(key, counter, additionalData, ciphertext) {
        if (!b4a.isBuffer(additionalData)) additionalData = b4a.from(additionalData, "hex");
        if (!b4a.isBuffer(ciphertext)) ciphertext = b4a.from(ciphertext, "hex");
        const nonce = b4a.alloc(sodium.crypto_aead_chacha20poly1305_ietf_NPUBBYTES);
        const view = new DataView(nonce.buffer, nonce.byteOffset, nonce.byteLength);
        view.setUint32(4, counter, true);
        const plaintext = b4a.alloc(ciphertext.byteLength - sodium.crypto_aead_chacha20poly1305_ietf_ABYTES);
        sodium.crypto_aead_chacha20poly1305_ietf_decrypt(plaintext, null, ciphertext, additionalData, nonce, key);
        return plaintext;
      }
    }
  });

  // ../../node_modules/noise-handshake/dh.js
  var require_dh = __commonJS({
    "../../node_modules/noise-handshake/dh.js"(exports, module) {
      var {
        crypto_kx_SEEDBYTES,
        crypto_kx_keypair,
        crypto_kx_seed_keypair,
        crypto_scalarmult_BYTES,
        crypto_scalarmult_SCALARBYTES,
        crypto_scalarmult,
        crypto_scalarmult_base
      } = require_sodium_universal();
      var assert = require_nanoassert();
      var b4a = require_b4a();
      var DHLEN = crypto_scalarmult_BYTES;
      var PKLEN = crypto_scalarmult_BYTES;
      var SKLEN = crypto_scalarmult_SCALARBYTES;
      var SEEDLEN = crypto_kx_SEEDBYTES;
      var ALG = "25519";
      module.exports = {
        DHLEN,
        PKLEN,
        SKLEN,
        SEEDLEN,
        ALG,
        generateKeyPair,
        generateSeedKeyPair,
        dh
      };
      function generateKeyPair(privKey) {
        const keyPair = {};
        keyPair.secretKey = privKey || b4a.alloc(SKLEN);
        keyPair.publicKey = b4a.alloc(PKLEN);
        if (privKey) {
          crypto_scalarmult_base(keyPair.publicKey, keyPair.secretKey);
        } else {
          crypto_kx_keypair(keyPair.publicKey, keyPair.secretKey);
        }
        return keyPair;
      }
      function generateSeedKeyPair(seed) {
        assert(seed.byteLength === SKLEN);
        const keyPair = {};
        keyPair.secretKey = b4a.alloc(SKLEN);
        keyPair.publicKey = b4a.alloc(PKLEN);
        crypto_kx_seed_keypair(keyPair.publicKey, keyPair.secretKey, seed);
        return keyPair;
      }
      function dh(publicKey, { secretKey }) {
        assert(secretKey.byteLength === SKLEN);
        assert(publicKey.byteLength === PKLEN);
        const output = b4a.alloc(DHLEN);
        crypto_scalarmult(
          output,
          secretKey,
          publicKey
        );
        return output;
      }
    }
  });

  // ../../node_modules/noise-handshake/hmac.js
  var require_hmac3 = __commonJS({
    "../../node_modules/noise-handshake/hmac.js"(exports, module) {
      var b4a = require_b4a();
      var { sodium_memzero, crypto_generichash, crypto_generichash_batch } = require_sodium_universal();
      var HASHLEN = 64;
      var BLOCKLEN = 128;
      var scratch = b4a.alloc(BLOCKLEN * 3);
      var HMACKey = scratch.subarray(BLOCKLEN * 0, BLOCKLEN * 1);
      var OuterKeyPad = scratch.subarray(BLOCKLEN * 1, BLOCKLEN * 2);
      var InnerKeyPad = scratch.subarray(BLOCKLEN * 2, BLOCKLEN * 3);
      module.exports = function hmac(out, batch, key) {
        if (key.byteLength > BLOCKLEN) {
          crypto_generichash(HMACKey.subarray(0, HASHLEN), key);
          sodium_memzero(HMACKey.subarray(HASHLEN));
        } else {
          HMACKey.set(key);
          sodium_memzero(HMACKey.subarray(key.byteLength));
        }
        for (let i = 0; i < HMACKey.byteLength; i++) {
          OuterKeyPad[i] = 92 ^ HMACKey[i];
          InnerKeyPad[i] = 54 ^ HMACKey[i];
        }
        sodium_memzero(HMACKey);
        crypto_generichash_batch(out, [InnerKeyPad].concat(batch));
        sodium_memzero(InnerKeyPad);
        crypto_generichash_batch(out, [OuterKeyPad, out]);
        sodium_memzero(OuterKeyPad);
      };
      module.exports.BYTES = HASHLEN;
      module.exports.KEYBYTES = BLOCKLEN;
    }
  });

  // ../../node_modules/noise-handshake/hkdf.js
  var require_hkdf = __commonJS({
    "../../node_modules/noise-handshake/hkdf.js"(exports, module) {
      var hmacBlake2b = require_hmac3();
      var b4a = require_b4a();
      var HASHLEN = 64;
      module.exports = {
        hkdf,
        HASHLEN
      };
      function hkdf(salt, inputKeyMaterial, info = "", length = 2 * HASHLEN) {
        const pseudoRandomKey = hkdfExtract(salt, inputKeyMaterial);
        return hkdfExpand(pseudoRandomKey, info, length);
      }
      function hkdfExtract(salt, inputKeyMaterial) {
        const hmac = b4a.alloc(HASHLEN);
        return hmacDigest(hmac, salt, inputKeyMaterial);
      }
      function hkdfExpand(key, info, length) {
        const buffer = b4a.allocUnsafeSlow(length);
        const infoBuf = b4a.from(info);
        let prev = infoBuf;
        const result = [];
        for (let i = 0; i < length; i += HASHLEN) {
          const pos = b4a.from([i / HASHLEN + 1]);
          const out = buffer.subarray(i, i + HASHLEN);
          result.push(out);
          prev = hmacDigest(out, key, [prev, infoBuf, pos]);
        }
        return result;
      }
      function hmacDigest(out, key, input) {
        hmacBlake2b(out, input, key);
        return out;
      }
    }
  });

  // ../../node_modules/noise-handshake/symmetric-state.js
  var require_symmetric_state = __commonJS({
    "../../node_modules/noise-handshake/symmetric-state.js"(exports, module) {
      var sodium = require_sodium_universal();
      var assert = require_nanoassert();
      var b4a = require_b4a();
      var CipherState = require_cipher2();
      var curve = require_dh();
      var { HASHLEN, hkdf } = require_hkdf();
      module.exports = class SymmetricState extends CipherState {
        constructor(opts = {}) {
          super();
          this.curve = opts.curve || curve;
          this.digest = b4a.alloc(HASHLEN);
          this.chainingKey = null;
          this.offset = 0;
          this.DH_ALG = this.curve.ALG;
        }
        mixHash(data) {
          accumulateDigest(this.digest, data);
        }
        mixKeyAndHash(key) {
          const [ck, tempH, tempK] = hkdf(this.chainingKey, key, "", 3 * HASHLEN);
          this.chainingKey = ck;
          this.mixHash(tempH);
          this.initialiseKey(tempK.subarray(0, 32));
        }
        mixKeyNormal(key) {
          const [ck, tempK] = hkdf(this.chainingKey, key);
          this.chainingKey = ck;
          this.initialiseKey(tempK.subarray(0, 32));
        }
        mixKey(remoteKey, localKey) {
          const dh = this.curve.dh(remoteKey, localKey);
          const hkdfResult = hkdf(this.chainingKey, dh);
          this.chainingKey = hkdfResult[0];
          this.initialiseKey(hkdfResult[1].subarray(0, 32));
        }
        encryptAndHash(plaintext) {
          const ciphertext = this.encrypt(plaintext, this.digest);
          accumulateDigest(this.digest, ciphertext);
          return ciphertext;
        }
        decryptAndHash(ciphertext) {
          const plaintext = this.decrypt(ciphertext, this.digest);
          accumulateDigest(this.digest, ciphertext);
          return plaintext;
        }
        getHandshakeHash(out) {
          if (!out) return this.getHandshakeHash(b4a.alloc(HASHLEN));
          assert(out.byteLength === HASHLEN, `output must be ${HASHLEN} bytes`);
          out.set(this.digest);
          return out;
        }
        split() {
          const res = hkdf(this.chainingKey, b4a.alloc(0));
          return res.map((k) => k.subarray(0, 32));
        }
        _clear() {
          super._clear();
          sodium.sodium_memzero(this.digest);
          sodium.sodium_memzero(this.chainingKey);
          this.digest = null;
          this.chainingKey = null;
          this.offset = null;
          this.curve = null;
        }
        static get alg() {
          return CipherState.alg + "_BLAKE2b";
        }
      };
      function accumulateDigest(digest, input) {
        const toHash = b4a.concat([digest, input]);
        sodium.crypto_generichash(digest, toHash);
      }
    }
  });

  // ../../node_modules/noise-handshake/noise.js
  var require_noise = __commonJS({
    "../../node_modules/noise-handshake/noise.js"(exports, module) {
      var assert = require_nanoassert();
      var b4a = require_b4a();
      var SymmetricState = require_symmetric_state();
      var { HASHLEN } = require_hkdf();
      var PRESHARE_IS = Symbol("initiator static key preshared");
      var PRESHARE_RS = Symbol("responder static key preshared");
      var TOK_PSK = Symbol("psk");
      var TOK_S = Symbol("s");
      var TOK_E = Symbol("e");
      var TOK_ES = Symbol("es");
      var TOK_SE = Symbol("se");
      var TOK_EE = Symbol("ee");
      var TOK_SS = Symbol("ss");
      var HANDSHAKES = Object.freeze({
        NN: [
          [TOK_E],
          [TOK_E, TOK_EE]
        ],
        NNpsk0: [
          [TOK_PSK, TOK_E],
          [TOK_E, TOK_EE]
        ],
        XX: [
          [TOK_E],
          [TOK_E, TOK_EE, TOK_S, TOK_ES],
          [TOK_S, TOK_SE]
        ],
        XXpsk0: [
          [TOK_PSK, TOK_E],
          [TOK_E, TOK_EE, TOK_S, TOK_ES],
          [TOK_S, TOK_SE]
        ],
        IK: [
          PRESHARE_RS,
          [TOK_E, TOK_ES, TOK_S, TOK_SS],
          [TOK_E, TOK_EE, TOK_SE]
        ],
        XK: [
          PRESHARE_RS,
          [TOK_E, TOK_ES],
          [TOK_E, TOK_EE],
          [TOK_S, TOK_SE]
        ]
      });
      var Writer = class {
        constructor() {
          this.size = 0;
          this.buffers = [];
        }
        push(b) {
          this.size += b.byteLength;
          this.buffers.push(b);
        }
        end() {
          const all = b4a.alloc(this.size);
          let offset = 0;
          for (const b of this.buffers) {
            all.set(b, offset);
            offset += b.byteLength;
          }
          return all;
        }
      };
      var Reader = class {
        constructor(buf) {
          this.offset = 0;
          this.buffer = buf;
        }
        shift(n) {
          const start = this.offset;
          const end = this.offset += n;
          if (end > this.buffer.byteLength) throw new Error("Insufficient bytes");
          return this.buffer.subarray(start, end);
        }
        end() {
          return this.shift(this.buffer.byteLength - this.offset);
        }
      };
      module.exports = class NoiseState extends SymmetricState {
        constructor(pattern, initiator, staticKeypair, opts = {}) {
          super(opts);
          this.s = staticKeypair || this.curve.generateKeyPair();
          this.e = null;
          this.psk = null;
          if (opts && opts.psk) this.psk = opts.psk;
          this.re = null;
          this.rs = null;
          this.pattern = pattern;
          this.handshake = HANDSHAKES[this.pattern].slice();
          this.isPskHandshake = !!this.psk && hasPskToken(this.handshake);
          this.protocol = b4a.from([
            "Noise",
            this.pattern,
            this.DH_ALG,
            this.CIPHER_ALG,
            "BLAKE2b"
          ].join("_"));
          this.initiator = initiator;
          this.complete = false;
          this.rx = null;
          this.tx = null;
          this.hash = null;
        }
        initialise(prologue, remoteStatic) {
          if (this.protocol.byteLength <= HASHLEN) this.digest.set(this.protocol);
          else this.mixHash(this.protocol);
          this.chainingKey = b4a.from(this.digest);
          this.mixHash(prologue);
          while (!Array.isArray(this.handshake[0])) {
            const message = this.handshake.shift();
            assert(
              message === PRESHARE_RS || message === PRESHARE_IS,
              "Unexpected pattern"
            );
            const takeRemoteKey = this.initiator ? message === PRESHARE_RS : message === PRESHARE_IS;
            if (takeRemoteKey) this.rs = remoteStatic;
            const key = takeRemoteKey ? this.rs : this.s.publicKey;
            assert(key != null, "Remote pubkey required");
            this.mixHash(key);
          }
        }
        final() {
          const [k1, k2] = this.split();
          this.tx = this.initiator ? k1 : k2;
          this.rx = this.initiator ? k2 : k1;
          this.complete = true;
          this.hash = this.getHandshakeHash();
          this._clear();
        }
        recv(buf) {
          const r = new Reader(buf);
          for (const pattern of this.handshake.shift()) {
            switch (pattern) {
              case TOK_PSK:
                this.mixKeyAndHash(this.psk);
                break;
              case TOK_E:
                this.re = r.shift(this.curve.PKLEN);
                this.mixHash(this.re);
                if (this.isPskHandshake) this.mixKeyNormal(this.re);
                break;
              case TOK_S: {
                const klen = this.hasKey ? this.curve.PKLEN + 16 : this.curve.PKLEN;
                this.rs = this.decryptAndHash(r.shift(klen));
                break;
              }
              case TOK_EE:
              case TOK_ES:
              case TOK_SE:
              case TOK_SS: {
                const useStatic = keyPattern(pattern, this.initiator);
                const localKey = useStatic.local ? this.s : this.e;
                const remoteKey = useStatic.remote ? this.rs : this.re;
                this.mixKey(remoteKey, localKey);
                break;
              }
              default:
                throw new Error("Unexpected message");
            }
          }
          const payload = this.decryptAndHash(r.end());
          if (!this.handshake.length) this.final();
          return payload;
        }
        send(payload = b4a.alloc(0)) {
          const w = new Writer();
          for (const pattern of this.handshake.shift()) {
            switch (pattern) {
              case TOK_PSK:
                this.mixKeyAndHash(this.psk);
                break;
              case TOK_E:
                if (this.e === null) this.e = this.curve.generateKeyPair();
                this.mixHash(this.e.publicKey);
                if (this.isPskHandshake) this.mixKeyNormal(this.e.publicKey);
                w.push(this.e.publicKey);
                break;
              case TOK_S:
                w.push(this.encryptAndHash(this.s.publicKey));
                break;
              case TOK_ES:
              case TOK_SE:
              case TOK_EE:
              case TOK_SS: {
                const useStatic = keyPattern(pattern, this.initiator);
                const localKey = useStatic.local ? this.s : this.e;
                const remoteKey = useStatic.remote ? this.rs : this.re;
                this.mixKey(remoteKey, localKey);
                break;
              }
              default:
                throw new Error("Unexpected message");
            }
          }
          w.push(this.encryptAndHash(payload));
          const response = w.end();
          if (!this.handshake.length) this.final();
          return response;
        }
        _clear() {
          super._clear();
          this.e.secretKey.fill(0);
          this.e.publicKey.fill(0);
          this.re.fill(0);
          this.e = null;
          this.re = null;
        }
      };
      function keyPattern(pattern, initiator) {
        const ret = {
          local: false,
          remote: false
        };
        switch (pattern) {
          case TOK_EE:
            return ret;
          case TOK_ES:
            ret.local ^= !initiator;
            ret.remote ^= initiator;
            return ret;
          case TOK_SE:
            ret.local ^= initiator;
            ret.remote ^= !initiator;
            return ret;
          case TOK_SS:
            ret.local ^= 1;
            ret.remote ^= 1;
            return ret;
        }
      }
      function hasPskToken(handshake) {
        return handshake.some((x) => {
          return Array.isArray(x) && x.indexOf(TOK_PSK) !== -1;
        });
      }
    }
  });

  // ../../node_modules/@hyperswarm/secret-stream/lib/handshake.js
  var require_handshake = __commonJS({
    "../../node_modules/@hyperswarm/secret-stream/lib/handshake.js"(exports, module) {
      var sodium = require_sodium_universal();
      var curve = require_noise_curve_ed();
      var Noise = require_noise();
      var b4a = require_b4a();
      var EMPTY = b4a.alloc(0);
      module.exports = class Handshake {
        constructor(isInitiator, keyPair, remotePublicKey, pattern) {
          this.isInitiator = isInitiator;
          this.keyPair = keyPair;
          this.noise = new Noise(pattern, isInitiator, keyPair, { curve });
          this.noise.initialise(EMPTY, remotePublicKey);
          this.destroyed = false;
        }
        static keyPair(seed) {
          const publicKey = b4a.alloc(32);
          const secretKey = b4a.alloc(64);
          if (seed) sodium.crypto_sign_seed_keypair(publicKey, secretKey, seed);
          else sodium.crypto_sign_keypair(publicKey, secretKey);
          return { publicKey, secretKey };
        }
        recv(data) {
          try {
            this.noise.recv(data);
            if (this.noise.complete) return this._return(null);
            return this.send();
          } catch {
            this.destroy();
            return null;
          }
        }
        // note that the data returned here is framed so we don't have to do an extra copy
        // when sending it...
        send() {
          try {
            const data = this.noise.send();
            const wrap = b4a.allocUnsafe(data.byteLength + 3);
            writeUint24le(data.byteLength, wrap);
            wrap.set(data, 3);
            return this._return(wrap);
          } catch {
            this.destroy();
            return null;
          }
        }
        destroy() {
          if (this.destroyed) return;
          this.destroyed = true;
        }
        _return(data) {
          const tx = this.noise.complete ? b4a.toBuffer(this.noise.tx) : null;
          const rx = this.noise.complete ? b4a.toBuffer(this.noise.rx) : null;
          const hash = this.noise.complete ? b4a.toBuffer(this.noise.hash) : null;
          const remotePublicKey = this.noise.complete ? b4a.toBuffer(this.noise.rs) : null;
          return {
            data,
            remotePublicKey,
            hash,
            tx,
            rx
          };
        }
      };
      function writeUint24le(n, buf) {
        buf[0] = n & 255;
        buf[1] = n >>> 8 & 255;
        buf[2] = n >>> 16 & 255;
      }
    }
  });

  // ../../node_modules/@hyperswarm/secret-stream/index.js
  var require_secret_stream = __commonJS({
    "../../node_modules/@hyperswarm/secret-stream/index.js"(exports, module) {
      var { Pull, Push, HEADERBYTES, KEYBYTES, ABYTES } = require_sodium_secretstream();
      var sodium = require_sodium_universal();
      var crypto = require_hypercore_crypto();
      var { Duplex, Writable, getStreamError } = require_streamx();
      var b4a = require_b4a();
      var Timeout = require_timeout_refresh();
      var unslab = require_unslab();
      var Bridge = require_bridge();
      var Handshake = require_handshake();
      var IDHEADERBYTES = HEADERBYTES + 32;
      var [NS_INITIATOR, NS_RESPONDER, NS_SEND] = crypto.namespace("hyperswarm/secret-stream", 3);
      var MAX_ATOMIC_WRITE = 256 * 256 * 256 - 1;
      module.exports = class NoiseSecretStream extends Duplex {
        constructor(isInitiator, rawStream, opts = {}) {
          super({ mapWritable: toBuffer });
          if (typeof isInitiator !== "boolean") {
            throw new Error("isInitiator should be a boolean");
          }
          this.noiseStream = this;
          this.isInitiator = isInitiator;
          this.rawStream = null;
          this.publicKey = opts.publicKey || null;
          this.remotePublicKey = opts.remotePublicKey || null;
          this.handshakeHash = null;
          this.connected = false;
          this.keepAlive = opts.keepAlive || 0;
          this.timeout = 0;
          this.enableSend = opts.enableSend !== false;
          this.userData = null;
          let openedDone = null;
          this.opened = new Promise((resolve) => {
            openedDone = resolve;
          });
          this.rawBytesWritten = 0;
          this.rawBytesRead = 0;
          this.relay = null;
          this.puncher = null;
          this._rawStream = null;
          this._handshake = null;
          this._handshakePattern = opts.pattern || null;
          this._handshakeDone = null;
          this._state = 0;
          this._len = 0;
          this._tmp = 1;
          this._message = null;
          this._openedDone = openedDone;
          this._startDone = null;
          this._drainDone = null;
          this._outgoingPlain = null;
          this._outgoingWrapped = null;
          this._utp = null;
          this._setup = true;
          this._ended = 2;
          this._encrypt = null;
          this._decrypt = null;
          this._timeoutTimer = null;
          this._keepAliveTimer = null;
          this._sendState = null;
          if (opts.autoStart !== false) this.start(rawStream, opts);
          this.resume();
          this.pause();
        }
        static keyPair(seed) {
          return Handshake.keyPair(seed);
        }
        static id(handshakeHash, isInitiator, id) {
          return streamId(handshakeHash, isInitiator, id);
        }
        setTimeout(ms) {
          if (!ms) ms = 0;
          this._clearTimeout();
          this.timeout = ms;
          if (!ms || this.rawStream === null) return;
          this._timeoutTimer = Timeout.once(ms, destroyTimeout, this);
          this._timeoutTimer.unref();
        }
        setKeepAlive(ms) {
          if (!ms) ms = 0;
          this._clearKeepAlive();
          this.keepAlive = ms;
          if (!ms || this.rawStream === null) return;
          this._keepAliveTimer = Timeout.on(ms, sendKeepAlive, this);
          this._keepAliveTimer.unref();
        }
        sendKeepAlive() {
          const empty = this.alloc(0);
          this.write(empty);
        }
        start(rawStream, opts = {}) {
          if (rawStream) {
            this.rawStream = rawStream;
            this._rawStream = rawStream;
            if (typeof this.rawStream.setContentSize === "function") {
              this._utp = rawStream;
            }
          } else {
            this.rawStream = new Bridge(this);
            this._rawStream = this.rawStream.reverse;
          }
          this.rawStream.on("error", this._onrawerror.bind(this));
          this.rawStream.on("close", this._onrawclose.bind(this));
          this._startHandshake(opts.handshake, opts.keyPair || null);
          this._continueOpen(null);
          if (this.destroying) return;
          if (opts.data) this._onrawdata(opts.data);
          if (opts.ended) this._onrawend();
          if (this.keepAlive > 0 && this._keepAliveTimer === null) {
            this.setKeepAlive(this.keepAlive);
          }
          if (this.timeout > 0 && this._timeoutTimer === null) {
            this.setTimeout(this.timeout);
          }
        }
        async flush() {
          if (await this.opened === false) return false;
          if (await Writable.drained(this) === false) return false;
          if (this.destroying) return false;
          if (this.rawStream !== null && this.rawStream.flush) {
            return await this.rawStream.flush();
          }
          return true;
        }
        _continueOpen(err) {
          if (err) this.destroy(err);
          if (this._startDone === null) return;
          const done = this._startDone;
          this._startDone = null;
          this._open(done);
        }
        _onkeypairpromise(p) {
          const self2 = this;
          const cont = this._continueOpen.bind(this);
          p.then(onkeypair, cont);
          function onkeypair(kp) {
            self2._onkeypair(kp);
            cont(null);
          }
        }
        _onkeypair(keyPair) {
          const pattern = this._handshakePattern || "XX";
          const remotePublicKey = this.remotePublicKey;
          this._handshake = new Handshake(this.isInitiator, keyPair, remotePublicKey, pattern);
          this.publicKey = this._handshake.keyPair.publicKey;
        }
        _startHandshake(handshake, keyPair) {
          if (handshake) {
            const { tx, rx, hash, publicKey, remotePublicKey } = handshake;
            this._setupSecretStream(tx, rx, hash, publicKey, remotePublicKey);
            return;
          }
          if (!keyPair) keyPair = Handshake.keyPair();
          if (typeof keyPair.then === "function") {
            this._onkeypairpromise(keyPair);
          } else {
            this._onkeypair(keyPair);
          }
        }
        _onrawerror(err) {
          this.destroy(err);
        }
        _onrawclose() {
          if (this._ended !== 0) this.destroy();
        }
        _onrawdata(data) {
          let offset = 0;
          if (this._timeoutTimer !== null) {
            this._timeoutTimer.refresh();
          }
          do {
            switch (this._state) {
              case 0: {
                while (this._tmp !== 16777216 && offset < data.byteLength) {
                  const v = data[offset++];
                  this._len += this._tmp * v;
                  this._tmp *= 256;
                }
                if (this._tmp === 16777216) {
                  this._tmp = 0;
                  this._state = 1;
                  const unprocessed = data.byteLength - offset;
                  if (unprocessed < this._len && this._utp !== null)
                    this._utp.setContentSize(this._len - unprocessed);
                }
                break;
              }
              case 1: {
                const missing = this._len - this._tmp;
                const end = missing + offset;
                if (this._message === null && end <= data.byteLength) {
                  this._message = data.subarray(offset, end);
                  offset += missing;
                  this._incoming();
                  break;
                }
                const unprocessed = data.byteLength - offset;
                if (this._message === null) {
                  this._message = b4a.allocUnsafe(this._len);
                }
                b4a.copy(data, this._message, this._tmp, offset);
                this._tmp += unprocessed;
                if (end <= data.byteLength) {
                  offset += missing;
                  this._incoming();
                } else {
                  offset += unprocessed;
                }
                break;
              }
            }
          } while (offset < data.byteLength && !this.destroying);
        }
        _onrawend() {
          this._ended--;
          this.push(null);
        }
        _onrawdrain() {
          const drain = this._drainDone;
          if (drain === null) return;
          this._drainDone = null;
          drain();
        }
        _read(cb) {
          this.rawStream.resume();
          cb(null);
        }
        _incoming() {
          const message = this._message;
          this._state = 0;
          this._len = 0;
          this._tmp = 1;
          this._message = null;
          if (this._setup === true) {
            if (this._handshake) {
              this._onhandshakert(this._handshake.recv(message));
            } else {
              if (message.byteLength !== IDHEADERBYTES) {
                this.destroy(new Error("Invalid header message received"));
                return;
              }
              const remoteId = message.subarray(0, 32);
              const expectedId = streamId(this.handshakeHash, !this.isInitiator);
              const header = message.subarray(32);
              if (!b4a.equals(expectedId, remoteId)) {
                this.destroy(new Error("Invalid header received"));
                return;
              }
              this._decrypt.init(header);
              this._setup = false;
            }
            return;
          }
          if (message.byteLength < ABYTES) {
            this.destroy(new Error("Invalid message received"));
            return;
          }
          this.rawBytesRead += message.byteLength;
          const plain = message.subarray(1, message.byteLength - ABYTES + 1);
          try {
            this._decrypt.next(message, plain);
          } catch (err) {
            this.destroy(err);
            return;
          }
          if (plain.byteLength === 0 && this.keepAlive !== 0) return;
          if (this.push(plain) === false) {
            this.rawStream.pause();
          }
        }
        _onhandshakert(h) {
          if (this._handshakeDone === null) return;
          if (h !== null) {
            if (h.data) this._rawStream.write(h.data);
            if (!h.tx) return;
          }
          const done = this._handshakeDone;
          const publicKey = this._handshake.keyPair.publicKey;
          this._handshakeDone = null;
          this._handshake = null;
          if (h === null) return done(new Error("Noise handshake failed"));
          this._setupSecretStream(h.tx, h.rx, h.hash, publicKey, h.remotePublicKey);
          this._resolveOpened(true);
          done(null);
        }
        _setupSecretStream(tx, rx, handshakeHash, publicKey, remotePublicKey) {
          const buf = b4a.allocUnsafeSlow(3 + IDHEADERBYTES);
          writeUint24le(IDHEADERBYTES, buf);
          this._encrypt = new Push(unslab(tx.subarray(0, KEYBYTES)), void 0, buf.subarray(3 + 32));
          this._decrypt = new Pull(unslab(rx.subarray(0, KEYBYTES)));
          this.publicKey = publicKey;
          this.remotePublicKey = remotePublicKey;
          this.handshakeHash = handshakeHash;
          const id = buf.subarray(3, 3 + 32);
          streamId(handshakeHash, this.isInitiator, id);
          this._setupSecretSend(handshakeHash);
          this.emit("handshake");
          if (this.rawStream !== this._rawStream) this.rawStream.emit("handshake");
          if (this.destroying) return;
          this._rawStream.write(buf);
        }
        _setupSecretSend(handshakeHash) {
          this._sendState = b4a.allocUnsafeSlow(32 + 32 + 8 + 8);
          const encrypt = this._sendState.subarray(0, 32);
          const decrypt = this._sendState.subarray(32, 64);
          const counter = this._sendState.subarray(64, 72);
          const initial = this._sendState.subarray(72);
          const inputs = this.isInitiator ? [
            [NS_INITIATOR, NS_SEND],
            [NS_RESPONDER, NS_SEND]
          ] : [
            [NS_RESPONDER, NS_SEND],
            [NS_INITIATOR, NS_SEND]
          ];
          sodium.crypto_generichash_batch(encrypt, inputs[0], handshakeHash);
          sodium.crypto_generichash_batch(decrypt, inputs[1], handshakeHash);
          sodium.randombytes_buf(initial);
          counter.set(initial);
        }
        _open(cb) {
          if (this._rawStream === null || this._handshake === null && this._encrypt === null) {
            this._startDone = cb;
            return;
          }
          this._rawStream.on("data", this._onrawdata.bind(this));
          this._rawStream.on("end", this._onrawend.bind(this));
          this._rawStream.on("drain", this._onrawdrain.bind(this));
          if (this.enableSend) this._rawStream.on("message", this._onmessage.bind(this));
          if (this._encrypt !== null) {
            this._resolveOpened(true);
            return cb(null);
          }
          this._handshakeDone = cb;
          if (this.isInitiator) this._onhandshakert(this._handshake.send());
        }
        _predestroy() {
          if (this.rawStream) {
            const error = getStreamError(this);
            this.rawStream.destroy(error);
          }
          if (this._startDone !== null) {
            const done = this._startDone;
            this._startDone = null;
            done(new Error("Stream destroyed"));
          }
          if (this._handshakeDone !== null) {
            const done = this._handshakeDone;
            this._handshakeDone = null;
            done(new Error("Stream destroyed"));
          }
          if (this._drainDone !== null) {
            const done = this._drainDone;
            this._drainDone = null;
            done(new Error("Stream destroyed"));
          }
        }
        _write(data, cb) {
          let wrapped = this._outgoingWrapped;
          if (data !== this._outgoingPlain) {
            wrapped = b4a.allocUnsafe(data.byteLength + 3 + ABYTES);
            wrapped.set(data, 4);
          } else {
            this._outgoingWrapped = this._outgoingPlain = null;
          }
          if (wrapped.byteLength - 3 > MAX_ATOMIC_WRITE) {
            return cb(
              new Error(
                "Message is too large for an atomic write. Max size is " + MAX_ATOMIC_WRITE + " bytes."
              )
            );
          }
          this.rawBytesWritten += wrapped.byteLength;
          writeUint24le(wrapped.byteLength - 3, wrapped);
          this._encrypt.next(wrapped.subarray(4, 4 + data.byteLength), wrapped.subarray(3));
          if (this._keepAliveTimer !== null) this._keepAliveTimer.refresh();
          if (this._rawStream.write(wrapped) === false) {
            this._drainDone = cb;
          } else {
            cb(null);
          }
        }
        _final(cb) {
          this._clearKeepAlive();
          this._ended--;
          this._rawStream.end();
          cb(null);
        }
        _resolveOpened(val) {
          if (this._openedDone === null) return;
          const opened = this._openedDone;
          this._openedDone = null;
          opened(val);
          if (!val) return;
          this.connected = true;
          this.emit("connect");
        }
        _clearTimeout() {
          if (this._timeoutTimer === null) return;
          this._timeoutTimer.destroy();
          this._timeoutTimer = null;
          this.timeout = 0;
        }
        _clearKeepAlive() {
          if (this._keepAliveTimer === null) return;
          this._keepAliveTimer.destroy();
          this._keepAliveTimer = null;
          this.keepAlive = 0;
        }
        _destroy(cb) {
          this._clearKeepAlive();
          this._clearTimeout();
          this._resolveOpened(false);
          cb(null);
        }
        _boxMessage(buffer) {
          const MB = sodium.crypto_secretbox_MACBYTES;
          const NB = sodium.crypto_secretbox_NONCEBYTES;
          const counter = this._sendState.subarray(64, 72);
          sodium.sodium_increment(counter);
          if (b4a.equals(counter, this._sendState.subarray(72))) {
            this.destroy(new Error("udp send nonce exchausted"));
            return;
          }
          const secret = this._sendState.subarray(0, 32);
          const envelope = b4a.allocUnsafe(8 + MB + buffer.byteLength);
          const nonce = envelope.subarray(0, NB);
          const ciphertext = envelope.subarray(8);
          b4a.fill(nonce, 0);
          nonce.set(counter);
          sodium.crypto_secretbox_easy(ciphertext, buffer, nonce, secret);
          return envelope;
        }
        send(buffer) {
          if (!this._sendState) return;
          if (!this.rawStream?.send) return;
          const message = this._boxMessage(buffer);
          return this.rawStream.send(message);
        }
        trySend(buffer) {
          if (!this._sendState) return;
          if (!this.rawStream?.trySend) return;
          const message = this._boxMessage(buffer);
          this.rawStream.trySend(message);
        }
        _onmessage(buffer) {
          if (!this._sendState) return;
          const MB = sodium.crypto_secretbox_MACBYTES;
          const NB = sodium.crypto_secretbox_NONCEBYTES;
          if (buffer.byteLength < NB) return;
          const nonce = b4a.allocUnsafe(NB);
          b4a.fill(nonce, 0);
          nonce.set(buffer.subarray(0, 8));
          const secret = this._sendState.subarray(32, 64);
          const ciphertext = buffer.subarray(8);
          const plain = buffer.subarray(8, buffer.byteLength - MB);
          if (ciphertext.byteLength < MB) return;
          const success = sodium.crypto_secretbox_open_easy(plain, ciphertext, nonce, secret);
          if (success) this.emit("message", plain);
        }
        alloc(len) {
          const buf = b4a.allocUnsafe(len + 3 + ABYTES);
          this._outgoingWrapped = buf;
          this._outgoingPlain = buf.subarray(4, buf.byteLength - ABYTES + 1);
          return this._outgoingPlain;
        }
        toJSON() {
          return {
            isInitiator: this.isInitiator,
            publicKey: this.publicKey && b4a.toString(this.publicKey, "hex"),
            remotePublicKey: this.remotePublicKey && b4a.toString(this.remotePublicKey, "hex"),
            connected: this.connected,
            destroying: this.destroying,
            destroyed: this.destroyed,
            rawStream: this.rawStream && this.rawStream.toJSON ? this.rawStream.toJSON() : null
          };
        }
      };
      function writeUint24le(n, buf) {
        buf[0] = n & 255;
        buf[1] = n >>> 8 & 255;
        buf[2] = n >>> 16 & 255;
      }
      function streamId(handshakeHash, isInitiator, out = b4a.allocUnsafe(32)) {
        sodium.crypto_generichash(out, isInitiator ? NS_INITIATOR : NS_RESPONDER, handshakeHash);
        return out;
      }
      function toBuffer(data) {
        return typeof data === "string" ? b4a.from(data) : data;
      }
      function destroyTimeout() {
        this.destroy(new Error("Stream timed out"));
      }
      function sendKeepAlive() {
        const empty = this.alloc(0);
        this.write(empty);
      }
    }
  });

  // ../../node_modules/protomux/index.js
  var require_protomux = __commonJS({
    "../../node_modules/protomux/index.js"(exports, module) {
      var b4a = require_b4a();
      var c = require_compact_encoding();
      var queueTick = require_process_next_tick();
      var safetyCatch = require_safety_catch();
      var unslab = require_unslab();
      var MAX_BUFFERED = 32768;
      var MAX_BACKLOG = Infinity;
      var MAX_BATCH = 8 * 1024 * 1024;
      var Channel = class {
        constructor(mux, info, userData, protocol, aliases, id, handshake, messages, onopen, onclose, ondestroy, ondrain) {
          this.userData = userData;
          this.protocol = protocol;
          this.aliases = aliases;
          this.id = id;
          this.handshake = null;
          this.messages = [];
          this.opened = false;
          this.closed = false;
          this.destroyed = false;
          this.onopen = onopen;
          this.onclose = onclose;
          this.ondestroy = ondestroy;
          this.ondrain = ondrain;
          this._handshake = handshake;
          this._mux = mux;
          this._info = info;
          this._localId = 0;
          this._remoteId = 0;
          this._active = 0;
          this._extensions = null;
          this._decBound = this._dec.bind(this);
          this._decAndDestroyBound = this._decAndDestroy.bind(this);
          this._openedPromise = null;
          this._openedResolve = null;
          this._destroyedPromise = null;
          this._destroyedResolve = null;
          for (const m of messages) this.addMessage(m);
        }
        get drained() {
          return this._mux.drained;
        }
        fullyOpened() {
          if (this.opened) return Promise.resolve(true);
          if (this.closed) return Promise.resolve(false);
          if (this._openedPromise) return this._openedPromise;
          this._openedPromise = new Promise((resolve) => {
            this._openedResolve = resolve;
          });
          return this._openedPromise;
        }
        fullyClosed() {
          if (this.destroyed) return Promise.resolve();
          if (this._destroyedPromise) return this._destroyedPromise;
          this._destroyedPromise = new Promise((resolve) => {
            this._destroyedResolve = resolve;
          });
          return this._destroyedPromise;
        }
        open(handshake) {
          const id = this._mux._free.length > 0 ? this._mux._free.pop() : this._mux._local.push(null) - 1;
          this._info.opened++;
          this._info.lastChannel = this;
          this._localId = id + 1;
          this._mux._local[id] = this;
          if (this._remoteId === 0) {
            this._info.outgoing.push(this._localId);
          }
          const state = { buffer: null, start: 2, end: 2 };
          c.uint.preencode(state, this._localId);
          c.string.preencode(state, this.protocol);
          c.buffer.preencode(state, this.id);
          if (this._handshake) this._handshake.preencode(state, handshake);
          state.buffer = this._mux._alloc(state.end);
          state.buffer[0] = 0;
          state.buffer[1] = 1;
          c.uint.encode(state, this._localId);
          c.string.encode(state, this.protocol);
          c.buffer.encode(state, this.id);
          if (this._handshake) this._handshake.encode(state, handshake);
          this._mux._write0(state.buffer);
        }
        _dec() {
          if (--this._active === 0 && this.closed === true) this._destroy();
        }
        _decAndDestroy(err) {
          this._dec();
          this._mux._safeDestroy(err);
        }
        _fullyOpenSoon() {
          this._mux._remote[this._remoteId - 1].session = this;
          queueTick(this._fullyOpen.bind(this));
        }
        _fullyOpen() {
          if (this.opened === true || this.closed === true) return;
          const remote = this._mux._remote[this._remoteId - 1];
          this.opened = true;
          this.handshake = this._handshake ? this._handshake.decode(remote.state) : null;
          this._track(this.onopen(this.handshake, this));
          remote.session = this;
          remote.state = null;
          if (remote.pending !== null) this._drain(remote);
          this._resolveOpen(true);
        }
        _resolveOpen(opened) {
          if (this._openedResolve !== null) {
            this._openedResolve(opened);
            this._openedResolve = this._openedPromise = null;
          }
        }
        _resolveDestroyed() {
          if (this._destroyedResolve !== null) {
            this._destroyedResolve();
            this._destroyedResolve = this._destroyedPromise = null;
          }
        }
        _drain(remote) {
          for (let i = 0; i < remote.pending.length; i++) {
            const p = remote.pending[i];
            this._mux._buffered -= byteSize(p.state);
            this._recv(p.type, p.state);
          }
          remote.pending = null;
          this._mux._resumeMaybe();
        }
        _track(p) {
          if (isPromise(p) === true) {
            this._active++;
            return p.then(this._decBound, this._decAndDestroyBound);
          }
          return null;
        }
        _close(isRemote) {
          if (this.closed === true) return;
          this.closed = true;
          this._info.opened--;
          if (this._info.lastChannel === this) this._info.lastChannel = null;
          if (this._remoteId > 0) {
            this._mux._remote[this._remoteId - 1] = null;
            this._remoteId = 0;
            this._mux._free.push(this._localId - 1);
          }
          this._mux._local[this._localId - 1] = null;
          this._localId = 0;
          this._mux._gc(this._info);
          this._track(this.onclose(isRemote, this));
          if (this._active === 0) this._destroy();
          this._resolveOpen(false);
        }
        _destroy() {
          if (this.destroyed === true) return;
          this.destroyed = true;
          this._track(this.ondestroy(this));
          this._resolveDestroyed();
        }
        _recv(type, state) {
          if (type < this.messages.length) {
            const m = this.messages[type];
            const p = m.recv(state, this);
            if (m.autoBatch === true) return p;
          }
          return null;
        }
        cork() {
          this._mux.cork();
        }
        uncork() {
          this._mux.uncork();
        }
        close() {
          if (this.closed === true) return;
          const state = { buffer: null, start: 2, end: 2 };
          c.uint.preencode(state, this._localId);
          state.buffer = this._mux._alloc(state.end);
          state.buffer[0] = 0;
          state.buffer[1] = 3;
          c.uint.encode(state, this._localId);
          this._close(false);
          this._mux._write0(state.buffer);
        }
        addMessage(opts) {
          if (!opts) return this._skipMessage();
          const type = this.messages.length;
          const autoBatch = opts.autoBatch !== false;
          const encoding = opts.encoding || c.raw;
          const onmessage = opts.onmessage || noop;
          const s = this;
          const typeLen = encodingLength(c.uint, type);
          const m = {
            type,
            autoBatch,
            encoding,
            onmessage,
            recv(state, session) {
              return session._track(m.onmessage(encoding.decode(state), session));
            },
            send(m2, session = s) {
              if (session.closed === true) return false;
              const mux = session._mux;
              const state = { buffer: null, start: 0, end: typeLen };
              if (mux._batch !== null) {
                encoding.preencode(state, m2);
                state.buffer = mux._alloc(state.end);
                c.uint.encode(state, type);
                encoding.encode(state, m2);
                mux._pushBatch(session._localId, state.buffer);
                return true;
              }
              c.uint.preencode(state, session._localId);
              encoding.preencode(state, m2);
              state.buffer = mux._alloc(state.end);
              c.uint.encode(state, session._localId);
              c.uint.encode(state, type);
              encoding.encode(state, m2);
              mux.drained = mux.stream.write(state.buffer);
              return mux.drained;
            }
          };
          this.messages.push(m);
          return m;
        }
        _skipMessage() {
          const type = this.messages.length;
          const m = {
            type,
            encoding: c.raw,
            onmessage: noop,
            recv(state, session) {
            },
            send(m2, session) {
            }
          };
          this.messages.push(m);
          return m;
        }
      };
      module.exports = class Protomux {
        constructor(stream, { alloc } = {}) {
          if (stream.userData === null) stream.userData = this;
          this.isProtomux = true;
          this.stream = stream;
          this.corked = 0;
          this.drained = true;
          this._alloc = alloc || (typeof stream.alloc === "function" ? stream.alloc.bind(stream) : b4a.allocUnsafe);
          this._safeDestroyBound = this._safeDestroy.bind(this);
          this._uncorkBound = this.uncork.bind(this);
          this._remoteBacklog = 0;
          this._buffered = 0;
          this._paused = false;
          this._remote = [];
          this._local = [];
          this._free = [];
          this._batch = null;
          this._batchState = null;
          this._infos = /* @__PURE__ */ new Map();
          this._notify = /* @__PURE__ */ new Map();
          this.stream.on("data", this._ondata.bind(this));
          this.stream.on("drain", this._ondrain.bind(this));
          this.stream.on("end", this._onend.bind(this));
          this.stream.on("error", noop);
          this.stream.on("close", this._shutdown.bind(this));
        }
        static from(stream, opts) {
          if (stream.userData && stream.userData.isProtomux) return stream.userData;
          if (stream.isProtomux) return stream;
          return new this(stream, opts);
        }
        static isProtomux(mux) {
          return typeof mux === "object" && mux.isProtomux === true;
        }
        *[Symbol.iterator]() {
          for (const session of this._local) {
            if (session !== null) yield session;
          }
        }
        isIdle() {
          return this._local.length === this._free.length;
        }
        cork() {
          if (++this.corked === 1) {
            this._batch = [];
            this._batchState = { buffer: null, start: 0, end: 1 };
          }
        }
        uncork() {
          if (--this.corked === 0) {
            this._sendBatch(this._batch, this._batchState);
            this._batch = null;
            this._batchState = null;
          }
        }
        getLastChannel({ protocol, id = null }) {
          const key = toKey(protocol, id);
          const info = this._infos.get(key);
          if (info) return info.lastChannel;
          return null;
        }
        pair({ protocol, id = null }, notify) {
          this._notify.set(toKey(protocol, id), notify);
        }
        unpair({ protocol, id = null }) {
          this._notify.delete(toKey(protocol, id));
        }
        opened({ protocol, id = null }) {
          const key = toKey(protocol, id);
          const info = this._infos.get(key);
          return info ? info.opened > 0 : false;
        }
        createChannel({ userData = null, protocol, aliases = [], id = null, unique = true, handshake = null, messages = [], onopen = noop, onclose = noop, ondestroy = noop, ondrain = noop }) {
          if (this.stream.destroyed) return null;
          const info = this._get(protocol, id, aliases);
          if (unique && info.opened > 0) return null;
          if (info.incoming.length === 0) {
            return new Channel(this, info, userData, protocol, aliases, id, handshake, messages, onopen, onclose, ondestroy, ondrain);
          }
          this._remoteBacklog--;
          const remoteId = info.incoming.shift();
          const r = this._remote[remoteId - 1];
          if (r === null) return null;
          const session = new Channel(this, info, userData, protocol, aliases, id, handshake, messages, onopen, onclose, ondestroy, ondrain);
          session._remoteId = remoteId;
          session._fullyOpenSoon();
          return session;
        }
        _pushBatch(localId, buffer) {
          if (this._batchState.end >= MAX_BATCH) {
            this._sendBatch(this._batch, this._batchState);
            this._batch = [];
            this._batchState = { buffer: null, start: 0, end: 1 };
          }
          if (this._batch.length === 0 || this._batch[this._batch.length - 1].localId !== localId) {
            this._batchState.end++;
            c.uint.preencode(this._batchState, localId);
          }
          c.buffer.preencode(this._batchState, buffer);
          this._batch.push({ localId, buffer });
        }
        _sendBatch(batch, state) {
          if (batch.length === 0) return;
          let prev = batch[0].localId;
          state.buffer = this._alloc(state.end);
          state.buffer[state.start++] = 0;
          state.buffer[state.start++] = 0;
          c.uint.encode(state, prev);
          for (let i = 0; i < batch.length; i++) {
            const b = batch[i];
            if (prev !== b.localId) {
              state.buffer[state.start++] = 0;
              c.uint.encode(state, prev = b.localId);
            }
            c.buffer.encode(state, b.buffer);
          }
          this.drained = this.stream.write(state.buffer);
        }
        _get(protocol, id, aliases = []) {
          const key = toKey(protocol, id);
          let info = this._infos.get(key);
          if (info) return info;
          info = { key, protocol, aliases: [], id, pairing: 0, opened: 0, incoming: [], outgoing: [], lastChannel: null };
          this._infos.set(key, info);
          for (const alias of aliases) {
            const key2 = toKey(alias, id);
            info.aliases.push(key2);
            this._infos.set(key2, info);
          }
          return info;
        }
        _gc(info) {
          if (info.opened === 0 && info.outgoing.length === 0 && info.incoming.length === 0) {
            this._infos.delete(info.key);
            for (const alias of info.aliases) this._infos.delete(alias);
          }
        }
        _ondata(buffer) {
          if (buffer.byteLength === 0) return;
          try {
            const state = { buffer, start: 0, end: buffer.byteLength };
            this._decode(c.uint.decode(state), state);
          } catch (err) {
            this._safeDestroy(err);
          }
        }
        _ondrain() {
          this.drained = true;
          for (const s of this._local) {
            if (s !== null) s._track(s.ondrain(s));
          }
        }
        _onend() {
          this.stream.end();
        }
        _decode(remoteId, state) {
          const type = c.uint.decode(state);
          if (remoteId === 0) {
            return this._oncontrolsession(type, state);
          }
          const r = remoteId <= this._remote.length ? this._remote[remoteId - 1] : null;
          if (r === null) return null;
          if (r.pending !== null) {
            this._bufferMessage(r, type, state);
            return null;
          }
          return r.session._recv(type, state);
        }
        _oncontrolsession(type, state) {
          switch (type) {
            case 0:
              this._onbatch(state);
              break;
            case 1:
              return this._onopensession(state);
            case 2:
              this._onrejectsession(state);
              break;
            case 3:
              this._onclosesession(state);
              break;
          }
          return null;
        }
        _bufferMessage(r, type, { buffer, start, end }) {
          const state = { buffer, start, end };
          r.pending.push({ type, state });
          this._buffered += byteSize(state);
          this._pauseMaybe();
        }
        _pauseMaybe() {
          if (this._paused === true || this._buffered <= MAX_BUFFERED) return;
          this._paused = true;
          this.stream.pause();
        }
        _resumeMaybe() {
          if (this._paused === false || this._buffered > MAX_BUFFERED) return;
          this._paused = false;
          this.stream.resume();
        }
        _onbatch(state) {
          const end = state.end;
          let remoteId = c.uint.decode(state);
          let waiting = null;
          while (state.end > state.start) {
            const len = c.uint.decode(state);
            if (len === 0) {
              remoteId = c.uint.decode(state);
              continue;
            }
            state.end = state.start + len;
            if (end !== state.end && waiting === null) {
              waiting = [];
              this.cork();
            }
            const p = this._decode(remoteId, state);
            if (waiting !== null && p !== null) waiting.push(p);
            state.start = state.end;
            state.end = end;
          }
          if (waiting !== null) {
            Promise.all(waiting).then(this._uncorkBound, this._safeDestroyBound);
          }
        }
        _onopensession(state) {
          const remoteId = c.uint.decode(state);
          const protocol = c.string.decode(state);
          const id = unslab(c.buffer.decode(state));
          if (remoteId === 0) {
            this._rejectSession(0);
            return null;
          }
          const rid = remoteId - 1;
          const info = this._get(protocol, id);
          if (this._remote.length === rid) {
            this._remote.push(null);
          }
          if (rid >= this._remote.length || this._remote[rid] !== null) {
            throw new Error("Invalid open message");
          }
          if (info.outgoing.length > 0) {
            const localId = info.outgoing.shift();
            const session = this._local[localId - 1];
            if (session === null) {
              this._free.push(localId - 1);
              return null;
            }
            this._remote[rid] = { state, pending: null, session: null };
            session._remoteId = remoteId;
            session._fullyOpen();
            return null;
          }
          const copyState = { buffer: state.buffer, start: state.start, end: state.end };
          this._remote[rid] = { state: copyState, pending: [], session: null };
          if (++this._remoteBacklog > MAX_BACKLOG) {
            throw new Error("Remote exceeded backlog");
          }
          info.pairing++;
          info.incoming.push(remoteId);
          return this._requestSession(protocol, id, info).catch(this._safeDestroyBound);
        }
        _onrejectsession(state) {
          const localId = c.uint.decode(state);
          for (const info of this._infos.values()) {
            const i = info.outgoing.indexOf(localId);
            if (i === -1) continue;
            info.outgoing.splice(i, 1);
            const session = this._local[localId - 1];
            this._free.push(localId - 1);
            if (session !== null) session._close(true);
            this._gc(info);
            return;
          }
          throw new Error("Invalid reject message");
        }
        _onclosesession(state) {
          const remoteId = c.uint.decode(state);
          if (remoteId === 0) return;
          const rid = remoteId - 1;
          const r = rid < this._remote.length ? this._remote[rid] : null;
          if (r === null) return;
          if (r.session !== null) r.session._close(true);
        }
        async _requestSession(protocol, id, info) {
          const notify = this._notify.get(toKey(protocol, id)) || this._notify.get(toKey(protocol, null));
          if (notify) await notify(id);
          if (--info.pairing > 0) return;
          while (info.incoming.length > 0) {
            this._rejectSession(info, info.incoming.shift());
          }
          this._gc(info);
        }
        _rejectSession(info, remoteId) {
          if (remoteId > 0) {
            const r = this._remote[remoteId - 1];
            if (r.pending !== null) {
              for (let i = 0; i < r.pending.length; i++) {
                this._buffered -= byteSize(r.pending[i].state);
              }
            }
            this._remote[remoteId - 1] = null;
            this._resumeMaybe();
          }
          const state = { buffer: null, start: 2, end: 2 };
          c.uint.preencode(state, remoteId);
          state.buffer = this._alloc(state.end);
          state.buffer[0] = 0;
          state.buffer[1] = 2;
          c.uint.encode(state, remoteId);
          this._write0(state.buffer);
        }
        _write0(buffer) {
          if (this._batch !== null) {
            this._pushBatch(0, buffer.subarray(1));
            return;
          }
          this.drained = this.stream.write(buffer);
        }
        destroy(err) {
          this.stream.destroy(err);
        }
        _safeDestroy(err) {
          safetyCatch(err);
          this.stream.destroy(err);
        }
        _shutdown() {
          for (const s of this._local) {
            if (s !== null) s._close(true);
          }
        }
      };
      function noop() {
      }
      function toKey(protocol, id) {
        return protocol + "##" + (id ? b4a.toString(id, "hex") : "");
      }
      function byteSize(state) {
        return 512 + (state.end - state.start);
      }
      function isPromise(p) {
        return !!(p && typeof p.then === "function");
      }
      function encodingLength(enc, val) {
        const state = { buffer: null, start: 0, end: 0 };
        enc.preencode(state, val);
        return state.end;
      }
    }
  });

  // ../../node_modules/random-array-iterator/index.js
  var require_random_array_iterator = __commonJS({
    "../../node_modules/random-array-iterator/index.js"(exports, module) {
      module.exports = class RandomArrayIterator {
        constructor(values) {
          this.values = values;
          this.start = 0;
          this.length = this.values.length;
        }
        next() {
          if (this.length === 0) {
            if (this.start === 0) return { done: true, value: void 0 };
            this.length = this.start;
            this.start = 0;
          }
          const i = this.start + (Math.random() * this.length | 0);
          const j = this.start + --this.length;
          const value = this.values[i];
          this.values[i] = this.values[j];
          this.values[j] = value;
          return { done: false, value };
        }
        dequeue() {
          this.values[this.start + this.length] = this.values[this.values.length - 1];
          this.values.pop();
        }
        requeue() {
          const i = this.start + this.length;
          const value = this.values[i];
          this.values[i] = this.values[this.start];
          this.values[this.start++] = value;
        }
        restart() {
          this.start = 0;
          this.length = this.values.length;
          return this;
        }
        [Symbol.iterator]() {
          return this;
        }
      };
    }
  });

  // ../../node_modules/flat-tree/index.js
  var require_flat_tree = __commonJS({
    "../../node_modules/flat-tree/index.js"(exports) {
      exports.fullRoots = function(index, result) {
        if (index & 1) throw new Error("You can only look up roots for depth(0) blocks");
        if (!result) result = [];
        index /= 2;
        let offset = 0;
        let factor = 1;
        while (true) {
          if (!index) return result;
          while (factor * 2 <= index) factor *= 2;
          result.push(offset + factor - 1);
          offset = offset + 2 * factor;
          index -= factor;
          factor = 1;
        }
      };
      exports.futureRoots = function(index, result) {
        if (index & 1) throw new Error("You can only look up future roots for depth(0) blocks");
        if (!result) result = [];
        let factor = 1;
        while (factor * 2 <= index) factor *= 2;
        if (factor * 2 - 2 === index) return result;
        let pos = factor / 2 - 1;
        while (pos + factor / 2 - 1 !== index) {
          pos += factor;
          while (pos + factor / 2 - 1 > index) {
            factor /= 2;
            pos -= factor / 2;
          }
          result.push(pos - factor / 2);
        }
        return result;
      };
      exports.patch = function(from, to) {
        if (from === 0 || from >= to) return [];
        const roots = exports.fullRoots(from);
        const target = exports.fullRoots(to);
        let i = 0;
        for (; i < target.length; i++) {
          if (i >= roots.length || roots[i] !== target[i]) break;
        }
        const patch = [];
        if (i < roots.length) {
          let prev = roots.length - 1;
          const ite = exports.iterator(roots[prev--]);
          while (ite.index !== target[i]) {
            ite.sibling();
            if (prev >= 0 && ite.index === roots[prev]) {
              prev--;
            } else {
              patch.push(ite.index);
            }
            patch.push(ite.parent());
          }
          i++;
        }
        for (; i < target.length; i++) patch.push(target[i]);
        return patch;
      };
      exports.depth = function(index) {
        let depth = 0;
        index += 1;
        while (!(index & 1)) {
          depth++;
          index = rightShift(index);
        }
        return depth;
      };
      exports.sibling = function(index, depth) {
        if (!depth) depth = exports.depth(index);
        const offset = exports.offset(index, depth);
        return exports.index(depth, offset & 1 ? offset - 1 : offset + 1);
      };
      exports.parent = function(index, depth) {
        if (!depth) depth = exports.depth(index);
        const offset = exports.offset(index, depth);
        return exports.index(depth + 1, rightShift(offset));
      };
      exports.leftChild = function(index, depth) {
        if (!(index & 1)) return -1;
        if (!depth) depth = exports.depth(index);
        return exports.index(depth - 1, exports.offset(index, depth) * 2);
      };
      exports.rightChild = function(index, depth) {
        if (!(index & 1)) return -1;
        if (!depth) depth = exports.depth(index);
        return exports.index(depth - 1, 1 + exports.offset(index, depth) * 2);
      };
      exports.children = function(index, depth) {
        if (!(index & 1)) return null;
        if (!depth) depth = exports.depth(index);
        const offset = exports.offset(index, depth) * 2;
        return [
          exports.index(depth - 1, offset),
          exports.index(depth - 1, offset + 1)
        ];
      };
      exports.leftSpan = function(index, depth) {
        if (!(index & 1)) return index;
        if (!depth) depth = exports.depth(index);
        return exports.offset(index, depth) * twoPow(depth + 1);
      };
      exports.rightSpan = function(index, depth) {
        if (!(index & 1)) return index;
        if (!depth) depth = exports.depth(index);
        return (exports.offset(index, depth) + 1) * twoPow(depth + 1) - 2;
      };
      exports.nextLeaf = function(index) {
        let factor = 1;
        let r = index;
        while ((r & 1) === 1) {
          r = (r - 1) / 2;
          factor *= 2;
        }
        return index + factor + 1;
      };
      exports.count = function(index, depth) {
        if (!(index & 1)) return 1;
        if (!depth) depth = exports.depth(index);
        return twoPow(depth + 1) - 1;
      };
      exports.countLeaves = function(index) {
        return (exports.count(index) + 1) / 2;
      };
      exports.spans = function(index, depth) {
        if (!(index & 1)) return [index, index];
        if (!depth) depth = exports.depth(index);
        const offset = exports.offset(index, depth);
        const width = twoPow(depth + 1);
        return [offset * width, (offset + 1) * width - 2];
      };
      exports.index = function(depth, offset) {
        return (1 + 2 * offset) * twoPow(depth) - 1;
      };
      exports.offset = function(index, depth) {
        if (!(index & 1)) return index / 2;
        if (!depth) depth = exports.depth(index);
        return ((index + 1) / twoPow(depth) - 1) / 2;
      };
      exports.iterator = function(index) {
        const ite = new Iterator();
        ite.seek(index || 0);
        return ite;
      };
      function twoPow(n) {
        return n < 31 ? 1 << n : (1 << 30) * (1 << n - 30);
      }
      function rightShift(n) {
        return (n - (n & 1)) / 2;
      }
      function Iterator() {
        this.index = 0;
        this.offset = 0;
        this.factor = 0;
      }
      Iterator.prototype.seek = function(index) {
        this.index = index;
        if (this.index & 1) {
          this.offset = exports.offset(index);
          this.factor = twoPow(exports.depth(index) + 1);
        } else {
          this.offset = index / 2;
          this.factor = 2;
        }
      };
      Iterator.prototype.isLeft = function() {
        return (this.offset & 1) === 0;
      };
      Iterator.prototype.isRight = function() {
        return (this.offset & 1) === 1;
      };
      Iterator.prototype.isRoot = function(length) {
        const currentLength = 1 + (this.index + this.factor / 2 - 1) / 2;
        if (length < currentLength) return false;
        const factor = this.factor * 2;
        const index = this.offset & 1 ? this.index - this.factor / 2 : this.index + this.factor / 2;
        const parentLength = 1 + (index + factor / 2 - 1) / 2;
        return parentLength > length;
      };
      Iterator.prototype.contains = function(index) {
        return index > this.index ? index < this.index + this.factor / 2 : index < this.index ? index > this.index - this.factor / 2 : true;
      };
      Iterator.prototype.prev = function() {
        if (!this.offset) return this.index;
        this.offset--;
        this.index -= this.factor;
        return this.index;
      };
      Iterator.prototype.next = function() {
        this.offset++;
        this.index += this.factor;
        return this.index;
      };
      Iterator.prototype.count = function() {
        if (!(this.index & 1)) return 1;
        return this.factor - 1;
      };
      Iterator.prototype.countLeaves = function() {
        return (this.count() + 1) / 2;
      };
      Iterator.prototype.sibling = function() {
        return this.isLeft() ? this.next() : this.prev();
      };
      Iterator.prototype.parent = function() {
        if (this.offset & 1) {
          this.index -= this.factor / 2;
          this.offset = (this.offset - 1) / 2;
        } else {
          this.index += this.factor / 2;
          this.offset /= 2;
        }
        this.factor *= 2;
        return this.index;
      };
      Iterator.prototype.leftSpan = function() {
        this.index = this.index - this.factor / 2 + 1;
        this.offset = this.index / 2;
        this.factor = 2;
        return this.index;
      };
      Iterator.prototype.peekLeftSpan = function() {
        return this.index - this.factor / 2 + 1;
      };
      Iterator.prototype.rightSpan = function() {
        this.index = this.index + this.factor / 2 - 1;
        this.offset = this.index / 2;
        this.factor = 2;
        return this.index;
      };
      Iterator.prototype.peekRightSpan = function() {
        return this.index + this.factor / 2 - 1;
      };
      Iterator.prototype.leftChild = function() {
        if (this.factor === 2) return this.index;
        this.factor /= 2;
        this.index -= this.factor / 2;
        this.offset *= 2;
        return this.index;
      };
      Iterator.prototype.rightChild = function() {
        if (this.factor === 2) return this.index;
        this.factor /= 2;
        this.index += this.factor / 2;
        this.offset = 2 * this.offset + 1;
        return this.index;
      };
      Iterator.prototype.nextTree = function() {
        this.index = this.index + this.factor / 2 + 1;
        this.offset = this.index / 2;
        this.factor = 2;
        return this.index;
      };
      Iterator.prototype.prevTree = function() {
        if (!this.offset) {
          this.index = 0;
          this.factor = 2;
        } else {
          this.index = this.index - this.factor / 2 - 1;
          this.offset = this.index / 2;
          this.factor = 2;
        }
        return this.index;
      };
      Iterator.prototype.fullRoot = function(index) {
        if (index <= this.index || (this.index & 1) > 0) return false;
        while (index > this.index + this.factor + this.factor / 2) {
          this.index += this.factor / 2;
          this.factor *= 2;
          this.offset /= 2;
        }
        return true;
      };
    }
  });

  // ../../node_modules/bare-dev/node_modules/hypercore/lib/receiver-queue.js
  var require_receiver_queue = __commonJS({
    "../../node_modules/bare-dev/node_modules/hypercore/lib/receiver-queue.js"(exports, module) {
      var FIFO = require_fast_fifo();
      module.exports = class ReceiverQueue {
        constructor() {
          this.queue = new FIFO();
          this.priority = [];
          this.requests = /* @__PURE__ */ new Map();
          this.length = 0;
        }
        push(req) {
          if (req.priority > 0) this.priority.push(req);
          else this.queue.push(req);
          this.requests.set(req.id, req);
          this.length++;
        }
        shift() {
          while (this.priority.length > 0) {
            const msg = this.priority.pop();
            const req = this._processRequest(msg);
            if (req !== null) return req;
          }
          while (this.queue.length > 0) {
            const msg = this.queue.shift();
            const req = this._processRequest(msg);
            if (req !== null) return req;
          }
          return null;
        }
        _processRequest(req) {
          if (req.block || req.hash || req.seek || req.upgrade || req.manifest) {
            this.requests.delete(req.id);
            this.length--;
            return req;
          }
          return null;
        }
        clear() {
          this.queue.clear();
          this.priority = [];
          this.length = 0;
          this.requests.clear();
        }
        delete(id) {
          const req = this.requests.get(id);
          if (!req) return;
          req.block = null;
          req.hash = null;
          req.seek = null;
          req.upgrade = null;
          req.manifest = false;
          this.requests.delete(id);
          this.length--;
          if (this.length === 0) {
            this.queue.clear();
            this.priority = [];
          }
        }
      };
    }
  });

  // ../../node_modules/bare-dev/node_modules/hypercore/lib/hotswap-queue.js
  var require_hotswap_queue = __commonJS({
    "../../node_modules/bare-dev/node_modules/hypercore/lib/hotswap-queue.js"(exports, module) {
      var TICKS = 16;
      module.exports = class HotswapQueue {
        constructor() {
          this.priorities = [[], [], []];
        }
        *pick(peer) {
          for (let i = 0; i < this.priorities.length; i++) {
            let ticks = (this.priorities.length - i) * TICKS;
            const queue = this.priorities[i];
            for (let j = 0; j < queue.length; j++) {
              const r = j + Math.floor(Math.random() * queue.length - j);
              const a = queue[j];
              const b = queue[r];
              if (r !== j) {
                queue[b.hotswap.index = j] = b;
                queue[a.hotswap.index = r] = a;
              }
              if (hasInflight(b, peer)) continue;
              yield b;
              if (--ticks <= 0) break;
            }
          }
        }
        add(block) {
          if (block.hotswap !== null) this.remove(block);
          if (block.inflight.length === 0 || block.inflight.length >= 3) return;
          const queue = this.priorities[block.inflight.length - 1];
          const index = queue.push(block) - 1;
          block.hotswap = { ref: this, queue, index };
        }
        remove(block) {
          const hotswap = block.hotswap;
          if (hotswap === null) return;
          block.hotswap = null;
          const head = hotswap.queue.pop();
          if (head === block) return;
          hotswap.queue[head.hotswap.index = hotswap.index] = head;
        }
      };
      function hasInflight(block, peer) {
        for (let j = 0; j < block.inflight.length; j++) {
          if (block.inflight[j].peer === peer) return true;
        }
        return false;
      }
    }
  });

  // ../../node_modules/big-sparse-array/index.js
  var require_big_sparse_array = __commonJS({
    "../../node_modules/big-sparse-array/index.js"(exports, module) {
      var FACTOR = new Uint16Array(8);
      function factor4096(i, n) {
        while (n > 0) {
          const f = i & 4095;
          FACTOR[--n] = f;
          i = (i - f) / 4096;
        }
        return FACTOR;
      }
      module.exports = class BigSparseArray {
        constructor() {
          this.tiny = new TinyArray();
          this.maxLength = 4096;
          this.factor = 1;
        }
        set(index, val) {
          if (val !== void 0) {
            while (index >= this.maxLength) {
              this.maxLength *= 4096;
              this.factor++;
              if (!this.tiny.isEmptyish()) {
                const t = new TinyArray();
                t.set(0, this.tiny);
                this.tiny = t;
              }
            }
          }
          const f = factor4096(index, this.factor);
          const last = this.factor - 1;
          let tiny = this.tiny;
          for (let i = 0; i < last; i++) {
            const next = tiny.get(f[i]);
            if (next === void 0) {
              if (val === void 0) return;
              tiny = tiny.set(f[i], new TinyArray());
            } else {
              tiny = next;
            }
          }
          return tiny.set(f[last], val);
        }
        get(index) {
          if (index >= this.maxLength) return;
          const f = factor4096(index, this.factor);
          const last = this.factor - 1;
          let tiny = this.tiny;
          for (let i = 0; i < last; i++) {
            tiny = tiny.get(f[i]);
            if (tiny === void 0) return;
          }
          return tiny.get(f[last]);
        }
      };
      var TinyArray = class {
        constructor() {
          this.s = 0;
          this.b = new Array(1);
          this.f = new Uint16Array(1);
        }
        isEmptyish() {
          return this.b.length === 1 && this.b[0] === void 0;
        }
        get(i) {
          if (this.s === 12) return this.b[i];
          const f = i >>> this.s;
          const r = i & this.b.length - 1;
          return this.f[r] === f ? this.b[r] : void 0;
        }
        set(i, v) {
          while (this.s !== 12) {
            const f = i >>> this.s;
            const r = i & this.b.length - 1;
            const o = this.b[r];
            if (o === void 0 || f === this.f[r]) {
              this.b[r] = v;
              this.f[r] = f;
              return v;
            }
            this.grow();
          }
          this.b[i] = v;
          return v;
        }
        grow() {
          const os = this.s;
          const ob = this.b;
          const of = this.f;
          this.s += 4;
          this.b = new Array(this.b.length << 4);
          this.f = this.s === 12 ? null : new Uint8Array(this.b.length);
          const m = this.b.length - 1;
          for (let or = 0; or < ob.length; or++) {
            if (ob[or] === void 0) continue;
            const i = of[or] << os | or;
            const f = i >>> this.s;
            const r = i & m;
            this.b[r] = ob[or];
            if (this.s !== 12) this.f[r] = f;
          }
        }
      };
    }
  });

  // ../../node_modules/simdle-native/binding.js
  var require_binding10 = __commonJS({
    "../../node_modules/simdle-native/binding.js"(exports, module) {
      __require.addon = require_node2();
      module.exports = __require.addon(".", __filename);
    }
  });

  // ../../node_modules/simdle-native/index.js
  var require_simdle_native = __commonJS({
    "../../node_modules/simdle-native/index.js"(exports) {
      var binding = require_binding10();
      var b4a = require_b4a();
      function predicate(u8, u16, u32) {
        return function predicate2(buf) {
          if (buf.byteLength % 16 !== 0) {
            throw new Error("Buffer length must be a multiple of 16");
          }
          const n = buf.BYTES_PER_ELEMENT;
          if (n === 1) return u8(buf);
          if (n === 2) return u16(buf);
          return u32(buf);
        };
      }
      function unary(u8, u16, u32) {
        return function unary2(buf, result = b4a.allocUnsafe(buf.byteLength)) {
          if (buf.byteLength % 16 !== 0) {
            throw new Error("Buffer length must be a multiple of 16");
          }
          if (buf.byteLength !== result.byteLength) {
            throw new Error("Length of result buffer is insufficient");
          }
          const n = buf.BYTES_PER_ELEMENT;
          if (n === 1) u8(buf, result);
          else if (n === 2) u16(buf, result);
          else u32(buf, result);
          return result;
        };
      }
      function binary(u8, u16, u32) {
        return function binary2(a, b, result = b4a.allocUnsafe(a.byteLength)) {
          if (a.byteLength % 16 !== 0) {
            throw new Error("Buffer length must be a multiple of 16");
          }
          if (a.byteLength !== b.byteLength || a.byteLength !== result.byteLength) {
            throw new Error("Buffers must be the same length");
          }
          const n = a.BYTES_PER_ELEMENT;
          if (n === 1) u8(a, b, result);
          else if (n === 2) u16(a, b, result);
          else u32(a, b, result);
          return result;
        };
      }
      function reduce(u8, u16, u32) {
        return function reduce2(buf) {
          if (buf.byteLength % 16 !== 0) {
            throw new Error("Buffer length must be a multiple of 16");
          }
          const n = buf.BYTES_PER_ELEMENT;
          if (n === 1) return u8(buf);
          if (n === 2) return u16(buf);
          return u32(buf);
        };
      }
      exports.allo = predicate(
        binding.simdle_native_allo_v128_u8,
        binding.simdle_native_allo_v128_u16,
        binding.simdle_native_allo_v128_u32
      );
      exports.allz = predicate(
        binding.simdle_native_allz_v128_u8,
        binding.simdle_native_allz_v128_u16,
        binding.simdle_native_allz_v128_u32
      );
      exports.and = binary(
        binding.simdle_native_and_v128_u8,
        binding.simdle_native_and_v128_u16,
        binding.simdle_native_and_v128_u32
      );
      exports.clear = binary(
        binding.simdle_native_clear_v128_u8,
        binding.simdle_native_clear_v128_u16,
        binding.simdle_native_clear_v128_u32
      );
      exports.clo = unary(
        binding.simdle_native_clo_v128_u8,
        binding.simdle_native_clo_v128_u16,
        binding.simdle_native_clo_v128_u32
      );
      exports.clz = unary(
        binding.simdle_native_clz_v128_u8,
        binding.simdle_native_clz_v128_u16,
        binding.simdle_native_clz_v128_u32
      );
      exports.cnt = unary(
        binding.simdle_native_cnt_v128_u8,
        binding.simdle_native_cnt_v128_u16,
        binding.simdle_native_cnt_v128_u32
      );
      exports.cto = unary(
        binding.simdle_native_cto_v128_u8,
        binding.simdle_native_cto_v128_u16,
        binding.simdle_native_cto_v128_u32
      );
      exports.ctz = unary(
        binding.simdle_native_ctz_v128_u8,
        binding.simdle_native_ctz_v128_u16,
        binding.simdle_native_ctz_v128_u32
      );
      exports.not = unary(
        binding.simdle_native_not_v128_u8,
        binding.simdle_native_not_v128_u16,
        binding.simdle_native_not_v128_u32
      );
      exports.or = binary(
        binding.simdle_native_or_v128_u8,
        binding.simdle_native_or_v128_u16,
        binding.simdle_native_or_v128_u32
      );
      exports.sum = reduce(
        binding.simdle_native_sum_v128_u8,
        binding.simdle_native_sum_v128_u16,
        binding.simdle_native_sum_v128_u32
      );
      exports.xor = binary(
        binding.simdle_native_xor_v128_u8,
        binding.simdle_native_xor_v128_u16,
        binding.simdle_native_xor_v128_u32
      );
    }
  });

  // ../../node_modules/simdle-universal/scalar.js
  var require_scalar = __commonJS({
    "../../node_modules/simdle-universal/scalar.js"(exports) {
      var clz = exports.clz = function clz2(n) {
        return Math.clz32(n);
      };
      exports.clo = function clo(n) {
        return clz(~n);
      };
      var ctz = exports.ctz = function ctz2(n) {
        return 32 - (n === 0 ? 0 : clz(n & -n) + 1);
      };
      exports.cto = function cto(n) {
        return ctz(~n);
      };
      exports.cnt = function cnt(n) {
        n = n - (n >>> 1 & 1431655765);
        n = (n & 858993459) + (n >>> 2 & 858993459);
        n = n + (n >>> 4) & 252645135;
        n = n * 16843009 >>> 24;
        return n;
      };
    }
  });

  // ../../node_modules/simdle-universal/fallback.js
  var require_fallback = __commonJS({
    "../../node_modules/simdle-universal/fallback.js"(exports) {
      var b4a = require_b4a();
      var scalar = require_scalar();
      function view(buf, n) {
        if (n === buf.BYTES_PER_ELEMENT) return buf;
        let TypedArray;
        if (n === 1) TypedArray = Uint8Array;
        else if (n === 2) TypedArray = Uint16Array;
        else TypedArray = Uint32Array;
        return new TypedArray(buf.buffer, buf.byteOffset, buf.byteLength / n);
      }
      function unary(u8, u16 = u8, u32 = u16) {
        return function unary2(buf, result = b4a.allocUnsafe(buf.byteLength)) {
          if (buf.byteLength % 16 !== 0) {
            throw new Error("Buffer length must be a multiple of 16");
          }
          if (buf.byteLength !== result.byteLength) {
            throw new Error("Length of result buffer is insufficient");
          }
          const n = buf.BYTES_PER_ELEMENT;
          if (n === 1) u8(buf, view(result, n));
          else if (n === 2) u16(buf, view(result, n));
          else u32(buf, view(result, n));
          return result;
        };
      }
      function binary(u8, u16 = u8, u32 = u16) {
        return function binary2(a, b, result = b4a.allocUnsafe(a.byteLength)) {
          if (a.byteLength % 16 !== 0) {
            throw new Error("Buffer length must be a multiple of 16");
          }
          if (a.byteLength !== b.byteLength || a.byteLength !== result.byteLength) {
            throw new Error("Buffers must be the same length");
          }
          const n = a.BYTES_PER_ELEMENT;
          if (n === 1) u8(a, b, view(result, n));
          else if (n === 2) u16(a, b, view(result, n));
          else u32(a, b, view(result, n));
          return result;
        };
      }
      function reduce(u8, u16 = u8, u32 = u16) {
        return function reduce2(buf) {
          if (buf.byteLength % 16 !== 0) {
            throw new Error("Buffer length must be a multiple of 16");
          }
          const n = buf.BYTES_PER_ELEMENT;
          if (n === 1) return u8(buf);
          if (n === 2) return u16(buf);
          return u32(buf);
        };
      }
      exports.allo = function allo(buf) {
        if (buf.byteLength % 16 !== 0) {
          throw new Error("Buffer length must be a multiple of 16");
        }
        const m = 2 ** (buf.BYTES_PER_ELEMENT * 8) - 1;
        for (let i = 0, n = buf.length; i < n; i++) {
          if (buf[i] !== m) return false;
        }
        return true;
      };
      exports.allz = function allz(buf) {
        if (buf.byteLength % 16 !== 0) {
          throw new Error("Buffer length must be a multiple of 16");
        }
        for (let i = 0, n = buf.length; i < n; i++) {
          if (buf[i] !== 0) return false;
        }
        return true;
      };
      exports.and = binary(
        (a, b, result) => {
          for (let i = 0, n = result.length; i < n; i++) {
            result[i] = a[i] & b[i];
          }
        }
      );
      exports.clear = binary(
        (a, b, result) => {
          for (let i = 0, n = result.length; i < n; i++) {
            result[i] = a[i] & ~b[i];
          }
        }
      );
      exports.clo = unary(
        (buf, result) => {
          for (let i = 0, n = buf.length; i < n; i++) {
            result[i] = 24 - scalar.clo(buf[i]);
          }
        },
        (buf, result) => {
          for (let i = 0, n = buf.length; i < n; i++) {
            result[i] = 16 - scalar.clo(buf[i]);
          }
        },
        (buf, result) => {
          for (let i = 0, n = buf.length; i < n; i++) {
            result[i] = scalar.clo(buf[i]);
          }
        }
      );
      exports.clz = unary(
        (buf, result) => {
          for (let i = 0, n = buf.length; i < n; i++) {
            result[i] = 24 - scalar.clz(buf[i]);
          }
        },
        (buf, result) => {
          for (let i = 0, n = buf.length; i < n; i++) {
            result[i] = 16 - scalar.clz(buf[i]);
          }
        },
        (buf, result) => {
          for (let i = 0, n = buf.length; i < n; i++) {
            result[i] = scalar.clz(buf[i]);
          }
        }
      );
      exports.cnt = unary(
        (buf, result) => {
          for (let i = 0, n = buf.length; i < n; i++) {
            result[i] = scalar.cnt(buf[i]) & 255;
          }
        },
        (buf, result) => {
          for (let i = 0, n = buf.length; i < n; i++) {
            result[i] = scalar.cnt(buf[i]) & 65535;
          }
        },
        (buf, result) => {
          for (let i = 0, n = buf.length; i < n; i++) {
            result[i] = scalar.cnt(buf[i]);
          }
        }
      );
      exports.cto = unary(
        (buf, result) => {
          for (let i = 0, n = buf.length; i < n; i++) {
            result[i] = Math.min(scalar.cto(buf[i]), 8);
          }
        },
        (buf, result) => {
          for (let i = 0, n = buf.length; i < n; i++) {
            result[i] = Math.min(scalar.cto(buf[i]), 16);
          }
        },
        (buf, result) => {
          for (let i = 0, n = buf.length; i < n; i++) {
            result[i] = scalar.cto(buf[i]);
          }
        }
      );
      exports.ctz = unary(
        (buf, result) => {
          for (let i = 0, n = buf.length; i < n; i++) {
            result[i] = Math.min(scalar.ctz(buf[i]), 8);
          }
        },
        (buf, result) => {
          for (let i = 0, n = buf.length; i < n; i++) {
            result[i] = Math.min(scalar.ctz(buf[i]), 16);
          }
        },
        (buf, result) => {
          for (let i = 0, n = buf.length; i < n; i++) {
            result[i] = scalar.ctz(buf[i]);
          }
        }
      );
      exports.not = unary(
        (buf, result) => {
          for (let i = 0, n = buf.length; i < n; i++) {
            result[i] = ~buf[i];
          }
        }
      );
      exports.or = binary(
        (a, b, result) => {
          for (let i = 0, n = result.length; i < n; i++) {
            result[i] = a[i] | b[i];
          }
        }
      );
      exports.sum = reduce(
        (buf) => {
          let result = 0n;
          for (let i = 0, n = buf.length; i < n; i++) {
            result += BigInt(buf[i]);
          }
          return result;
        }
      );
      exports.xor = binary(
        (a, b, result) => {
          for (let i = 0, n = result.length; i < n; i++) {
            result[i] = a[i] ^ b[i];
          }
        }
      );
    }
  });

  // ../../node_modules/simdle-universal/index.js
  var require_simdle_universal = __commonJS({
    "../../node_modules/simdle-universal/index.js"(exports, module) {
      try {
        module.exports = require_simdle_native();
      } catch {
        module.exports = require_fallback();
      }
    }
  });

  // ../../node_modules/quickbit-universal/fallback.js
  var require_fallback2 = __commonJS({
    "../../node_modules/quickbit-universal/fallback.js"(exports) {
      var simdle = require_simdle_universal();
      var INDEX_LEN = (16 + 128 * 16) * 2;
      var get = exports.get = function get2(field, bit) {
        const n = field.byteLength * 8;
        if (bit < 0) bit += n;
        if (bit < 0 || bit >= n) return false;
        const m = field.BYTES_PER_ELEMENT * 8;
        const offset = bit & m - 1;
        const i = (bit - offset) / m;
        return (field[i] & 1 << offset) !== 0;
      };
      var set = exports.set = function set2(field, bit, value = true) {
        const n = field.byteLength * 8;
        if (bit < 0) bit += n;
        if (bit < 0 || bit >= n) return false;
        const m = field.BYTES_PER_ELEMENT * 8;
        const offset = bit & m - 1;
        const i = (bit - offset) / m;
        const mask = 1 << offset;
        if (value) {
          if ((field[i] & mask) !== 0) return false;
        } else {
          if ((field[i] & mask) === 0) return false;
        }
        field[i] ^= mask;
        return true;
      };
      exports.fill = function fill(field, value, start = 0, end = field.byteLength * 8) {
        const n = field.byteLength * 8;
        if (start < 0) start += n;
        if (end < 0) end += n;
        if (start < 0 || start >= field.byteLength * 8 || start >= end) return field;
        const m = field.BYTES_PER_ELEMENT * 8;
        let i, j;
        {
          const offset = start & m - 1;
          i = (start - offset) / m;
          if (offset !== 0) {
            let shift = m - offset;
            if (end - start < shift) shift = end - start;
            const mask = (1 << shift) - 1 << offset;
            if (value) field[i] |= mask;
            else field[i] &= ~mask;
            i++;
          }
        }
        {
          const offset = end & m - 1;
          j = (end - offset) / m;
          if (offset !== 0 && j >= i) {
            const mask = (1 << offset) - 1;
            if (value) field[j] |= mask;
            else field[j] &= ~mask;
          }
        }
        if (i < j) field.fill(value ? 2 ** m - 1 : 0, i, j);
        return field;
      };
      exports.clear = function clear(field, ...chunks) {
        const n = field.byteLength;
        for (const chunk of chunks) {
          if (chunk.offset >= n) continue;
          const m = chunk.field.byteLength;
          let i = chunk.offset;
          let j = 0;
          while (((i & 15) !== 0 || (j & 15) !== 0) && i < n && j < m) {
            field[i] = field[i] & ~chunk.field[j];
            i++;
            j++;
          }
          if (i + 15 < n && j + 15 < m) {
            const len = Math.min(n - (n & 15) - i, m - (m & 15) - j);
            simdle.clear(field.subarray(i, i + len), chunk.field.subarray(j, j + len), field.subarray(i, i + len));
          }
          while (i < n && j < m) {
            field[i] = field[i] & ~chunk.field[j];
            i++;
            j++;
          }
        }
      };
      function bitOffset(bit, offset) {
        return !bit ? offset : INDEX_LEN * 8 / 2 + offset;
      }
      function byteOffset(bit, offset) {
        return !bit ? offset : INDEX_LEN / 2 + offset;
      }
      exports.findFirst = function findFirst(field, value, position = 0) {
        const n = field.byteLength * 8;
        if (position < 0) position += n;
        if (position < 0) position = 0;
        if (position >= n) return -1;
        value = !!value;
        for (let i = position; i < n; i++) {
          if (get(field, i) === value) return i;
        }
        return -1;
      };
      exports.findLast = function findLast(field, value, position = field.byteLength * 8 - 1) {
        const n = field.byteLength * 8;
        if (position < 0) position += n;
        if (position < 0) return -1;
        if (position >= n) position = n - 1;
        value = !!value;
        for (let i = position; i >= 0; i--) {
          if (get(field, i) === value) return i;
        }
        return -1;
      };
      var Index = exports.Index = class Index {
        static from(fieldOrChunks, byteLength = -1) {
          if (Array.isArray(fieldOrChunks)) {
            return new SparseIndex(fieldOrChunks, byteLength);
          } else {
            return new DenseIndex(fieldOrChunks, byteLength);
          }
        }
        constructor(byteLength) {
          this._byteLength = byteLength;
          this.handle = new Uint32Array(INDEX_LEN / 4);
        }
        get byteLength() {
          return this._byteLength;
        }
        skipFirst(value, position = 0) {
          const n = this.byteLength * 8;
          if (position < 0) position += n;
          if (position < 0) position = 0;
          if (position >= n) return n - 1;
          let i = Math.floor(position / 16384);
          if (i > 127) return position;
          while (i <= 127 && get(this.handle, bitOffset(value, i))) {
            i++;
          }
          if (i === 128) return n - 1;
          let k = i * 16384;
          let j = 0;
          if (position > k) j = Math.floor((position - k) / 128);
          while (j <= 127 && get(this.handle, bitOffset(value, i * 128 + j + 128))) {
            j++;
            k += 128;
          }
          if (j === 128 && i !== 127) return this.skipFirst(value, (i + 1) * 16384);
          if (k > position) position = k;
          return position < n ? position : n - 1;
        }
        skipLast(value, position = this.byteLength * 8 - 1) {
          const n = this.byteLength * 8;
          if (position < 0) position += n;
          if (position < 0) return 0;
          if (position >= n) position = n - 1;
          let i = Math.floor(position / 16384);
          if (i > 127) return position;
          while (i >= 0 && get(this.handle, bitOffset(value, i))) {
            i--;
          }
          if (i === -1) return 0;
          let k = (i + 1) * 16384 - 1;
          let j = 127;
          if (position < k) j = 128 - Math.ceil((k - position) / 128);
          while (j >= 0 && get(this.handle, bitOffset(value, i * 128 + j + 128))) {
            j--;
            k -= 128;
          }
          if (j === -1 && i !== 0) return this.skipLast(value, i * 16384 - 1);
          if (k < position) position = k;
          return position;
        }
      };
      var DenseIndex = class extends Index {
        constructor(field, byteLength) {
          super(byteLength);
          this.field = field;
          const m = field.BYTES_PER_ELEMENT;
          for (let i = 0; i < 128; i++) {
            for (let j = 0; j < 128; j++) {
              const offset = (i * 128 + j) * 16;
              let allz = true;
              let allo = false;
              if (offset + 16 <= this.field.byteLength) {
                const vec = this.field.subarray(offset / m, (offset + 16) / m);
                allz = simdle.allz(vec);
                allo = simdle.allo(vec);
              }
              const k = i * 128 + 128 + j;
              set(this.handle, bitOffset(false, k), allz);
              set(this.handle, bitOffset(true, k), allo);
            }
            {
              const offset = byteOffset(false, i * 16 + 16) / 4;
              const allo = simdle.allo(this.handle.subarray(offset, offset + 4));
              set(this.handle, bitOffset(false, i), allo);
            }
            {
              const offset = byteOffset(true, i * 16 + 16) / 4;
              const allo = simdle.allo(this.handle.subarray(offset, offset + 4));
              set(this.handle, bitOffset(true, i), allo);
            }
          }
        }
        get byteLength() {
          if (this._byteLength !== -1) return this._byteLength;
          return this.field.byteLength;
        }
        update(bit) {
          const n = this.byteLength * 8;
          if (bit < 0) bit += n;
          if (bit < 0 || bit >= n) return false;
          const m = this.field.BYTES_PER_ELEMENT;
          const i = Math.floor(bit / 16384);
          const j = Math.floor(bit / 128);
          const offset = j * 16 / m;
          const vec = this.field.subarray(offset, offset + 16 / m);
          const allz = simdle.allz(vec);
          const allo = simdle.allo(vec);
          let changed = false;
          if (set(this.handle, bitOffset(false, 128 + j), allz)) {
            changed = true;
            const offset2 = byteOffset(false, i * 16 + 16) / 4;
            const allo2 = simdle.allo(this.handle.subarray(offset2, offset2 + 4));
            set(this.handle, bitOffset(false, i), allo2);
          }
          if (set(this.handle, bitOffset(true, 128 + j), allo)) {
            changed = true;
            const offset2 = byteOffset(true, i * 16 + 16) / 4;
            const allo2 = simdle.allo(this.handle.subarray(offset2, offset2 + 4));
            set(this.handle, bitOffset(true, i), allo2);
          }
          return changed;
        }
      };
      function selectChunk(chunks, offset) {
        for (let i = 0; i < chunks.length; i++) {
          const next = chunks[i];
          const start = next.offset;
          const end = next.offset + next.field.byteLength;
          if (offset >= start && offset + 16 <= end) {
            return next;
          }
        }
        return null;
      }
      var SparseIndex = class extends Index {
        constructor(chunks, byteLength) {
          super(byteLength);
          this.chunks = chunks;
          for (let i = 0; i < 128; i++) {
            for (let j = 0; j < 128; j++) {
              const offset = (i * 128 + j) * 16;
              let allz = true;
              let allo = false;
              const chunk = selectChunk(this.chunks, offset);
              if (chunk !== null) {
                const m = chunk.field.BYTES_PER_ELEMENT;
                const vec = chunk.field.subarray((offset - chunk.offset) / m, (offset - chunk.offset + 16) / m);
                allz = simdle.allz(vec);
                allo = simdle.allo(vec);
              }
              const k = i * 128 + 128 + j;
              set(this.handle, bitOffset(false, k), allz);
              set(this.handle, bitOffset(true, k), allo);
            }
            {
              const offset = byteOffset(false, i * 16 + 16) / 4;
              const allo = simdle.allo(this.handle.subarray(offset, offset + 4));
              set(this.handle, bitOffset(false, i), allo);
            }
            {
              const offset = byteOffset(true, i * 16 + 16) / 4;
              const allo = simdle.allo(this.handle.subarray(offset, offset + 4));
              set(this.handle, bitOffset(true, i), allo);
            }
          }
        }
        get byteLength() {
          if (this._byteLength !== -1) return this._byteLength;
          const last = this.chunks[this.chunks.length - 1];
          return last ? last.offset + last.field.byteLength : 0;
        }
        update(bit) {
          const n = this.byteLength * 8;
          if (bit < 0) bit += n;
          if (bit < 0 || bit >= n) return false;
          const i = Math.floor(bit / 16384);
          const j = Math.floor(bit / 128);
          const offset = j * 16;
          const chunk = selectChunk(this.chunks, offset);
          if (chunk === null) return false;
          const m = chunk.field.BYTES_PER_ELEMENT;
          const vec = chunk.field.subarray((offset - chunk.offset) / m, (offset - chunk.offset + 16) / m);
          const allz = simdle.allz(vec);
          const allo = simdle.allo(vec);
          let changed = false;
          if (set(this.handle, bitOffset(false, 128 + j), allz)) {
            changed = true;
            const offset2 = byteOffset(false, i * 16 + 16) / 4;
            const allo2 = simdle.allo(this.handle.subarray(offset2, offset2 + 4));
            set(this.handle, bitOffset(false, i), allo2);
          }
          if (set(this.handle, bitOffset(true, 128 + j), allo)) {
            changed = true;
            const offset2 = byteOffset(true, i * 16 + 16) / 4;
            const allo2 = simdle.allo(this.handle.subarray(offset2, offset2 + 4));
            set(this.handle, bitOffset(true, i), allo2);
          }
          return changed;
        }
      };
    }
  });

  // ../../node_modules/quickbit-native/binding.js
  var require_binding11 = __commonJS({
    "../../node_modules/quickbit-native/binding.js"(exports, module) {
      __require.addon = require_node2();
      module.exports = __require.addon(".", __filename);
    }
  });

  // ../../node_modules/quickbit-native/index.js
  var require_quickbit_native = __commonJS({
    "../../node_modules/quickbit-native/index.js"(exports) {
      var binding = require_binding11();
      exports.get = function get(field, bit) {
        const n = field.byteLength * 8;
        if (bit < 0) bit += n;
        if (bit < 0 || bit >= n) return false;
        return binding.quickbit_napi_get(toBuffer(field), bit) !== 0;
      };
      exports.set = function set(field, bit, value = true) {
        const n = field.byteLength * 8;
        if (bit < 0) bit += n;
        if (bit < 0 || bit >= n) return false;
        return binding.quickbit_napi_set(toBuffer(field), bit, value ? 1 : 0) !== 0;
      };
      exports.fill = function fill(field, value, start = 0, end = field.byteLength * 8) {
        const n = field.byteLength * 8;
        if (start < 0) start += n;
        if (end < 0) end += n;
        if (start < 0 || start >= field.byteLength * 8 || start >= end) return field;
        binding.quickbit_napi_fill(toBuffer(field), value ? 1 : 0, start, end);
        return field;
      };
      exports.clear = function clear(field, ...chunks) {
        binding.quickbit_napi_clear(toBuffer(field), chunks.map(toBufferChunk));
      };
      exports.findFirst = function findFirst(field, value, position = 0) {
        const n = field.byteLength * 8;
        if (position < 0) position += n;
        if (position < 0) position = 0;
        if (position >= n) return -1;
        return binding.quickbit_napi_find_first(
          toBuffer(field),
          value ? 1 : 0,
          position
        );
      };
      exports.findLast = function findLast(field, value, position = field.byteLength * 8 - 1) {
        const n = field.byteLength * 8;
        if (position < 0) position += n;
        if (position < 0) return -1;
        if (position >= n) position = n - 1;
        return binding.quickbit_napi_find_last(
          toBuffer(field),
          value ? 1 : 0,
          position
        );
      };
      function toBuffer(field) {
        if (field.BYTES_PER_ELEMENT === 1) return field;
        return new Uint8Array(field.buffer, field.byteOffset, field.byteLength);
      }
      function toBufferChunk(chunk) {
        return { field: toBuffer(chunk.field), offset: chunk.offset };
      }
      var Index = class {
        static from(fieldOrChunks, byteLength = -1) {
          if (Array.isArray(fieldOrChunks)) {
            return new SparseIndex(fieldOrChunks, byteLength);
          } else {
            return new DenseIndex(fieldOrChunks, byteLength);
          }
        }
        constructor(byteLength) {
          this._byteLength = byteLength;
          this.handle = Buffer.allocUnsafe(binding.sizeof_quickbit_index_t);
        }
        get byteLength() {
          return this._byteLength;
        }
        skipFirst(value, position = 0) {
          const n = this.byteLength * 8;
          if (position < 0) position += n;
          if (position < 0) position = 0;
          if (position >= n) return n - 1;
          return binding.quickbit_napi_skip_first(
            this.handle,
            this.byteLength,
            value ? 1 : 0,
            position
          );
        }
        skipLast(value, position = this.byteLength * 8 - 1) {
          const n = this.byteLength * 8;
          if (position < 0) position += n;
          if (position < 0) return 0;
          if (position >= n) position = n - 1;
          return binding.quickbit_napi_skip_last(
            this.handle,
            this.byteLength,
            value ? 1 : 0,
            position
          );
        }
      };
      exports.Index = Index;
      var DenseIndex = class extends Index {
        constructor(field, byteLength) {
          super(byteLength);
          this.field = field;
          binding.quickbit_napi_index_init(this.handle, toBuffer(this.field));
        }
        get byteLength() {
          if (this._byteLength !== -1) return this._byteLength;
          return this.field.byteLength;
        }
        update(bit) {
          const n = this.byteLength * 8;
          if (bit < 0) bit += n;
          if (bit < 0 || bit >= n) return false;
          return binding.quickbit_napi_index_update(
            this.handle,
            toBuffer(this.field),
            bit
          ) !== 0;
        }
      };
      function selectChunk(chunks, offset) {
        for (let i = 0; i < chunks.length; i++) {
          const next = chunks[i];
          const start = next.offset;
          const end = next.offset + next.field.byteLength;
          if (offset >= start && offset + 16 <= end) {
            return next;
          }
        }
        return null;
      }
      var SparseIndex = class extends Index {
        constructor(chunks, byteLength) {
          super(byteLength);
          this.chunks = chunks;
          binding.quickbit_napi_index_init_sparse(
            this.handle,
            this.chunks.map(toBufferChunk)
          );
        }
        get byteLength() {
          if (this._byteLength !== -1) return this._byteLength;
          const last = this.chunks[this.chunks.length - 1];
          return last ? last.offset + last.field.byteLength : 0;
        }
        update(bit) {
          const n = this.byteLength * 8;
          if (bit < 0) bit += n;
          if (bit < 0 || bit >= n) return false;
          const j = Math.floor(bit / 128);
          const offset = j * 16;
          const chunk = selectChunk(this.chunks, offset);
          if (chunk === null) return false;
          return binding.quickbit_napi_index_update_sparse(
            this.handle,
            toBuffer(chunk.field),
            chunk.offset,
            bit
          ) !== 0;
        }
      };
    }
  });

  // ../../node_modules/quickbit-universal/index.js
  var require_quickbit_universal = __commonJS({
    "../../node_modules/quickbit-universal/index.js"(exports, module) {
      var fallback = require_fallback2();
      try {
        const native = require_quickbit_native();
        exports.get = fallback.get;
        exports.set = fallback.set;
        exports.fill = fallback.fill;
        exports.clear = native.clear;
        exports.findFirst = native.findFirst;
        exports.findLast = native.findLast;
        exports.Index = native.Index;
      } catch {
        module.exports = fallback;
      }
    }
  });

  // ../../node_modules/bare-dev/node_modules/hypercore/lib/compat.js
  var require_compat = __commonJS({
    "../../node_modules/bare-dev/node_modules/hypercore/lib/compat.js"(exports) {
      var quickbit = require_quickbit_universal();
      if (typeof quickbit.findFirst !== "function" || typeof quickbit.findLast !== "function" || typeof quickbit.clear !== "function") {
        quickbit = require_fallback2();
      }
      exports.quickbit = quickbit;
    }
  });

  // ../../node_modules/bare-dev/node_modules/hypercore/lib/remote-bitfield.js
  var require_remote_bitfield = __commonJS({
    "../../node_modules/bare-dev/node_modules/hypercore/lib/remote-bitfield.js"(exports, module) {
      var BigSparseArray = require_big_sparse_array();
      var quickbit = require_compat().quickbit;
      var BITS_PER_PAGE = 32768;
      var BYTES_PER_PAGE = BITS_PER_PAGE / 8;
      var WORDS_PER_PAGE = BYTES_PER_PAGE / 4;
      var BITS_PER_SEGMENT = 2097152;
      var BYTES_PER_SEGMENT = BITS_PER_SEGMENT / 8;
      var PAGES_PER_SEGMENT = BITS_PER_SEGMENT / BITS_PER_PAGE;
      var RemoteBitfieldPage = class {
        constructor(index, bitfield, segment) {
          this.index = index;
          this.offset = index * BYTES_PER_PAGE - segment.offset;
          this.bitfield = bitfield;
          this.segment = segment;
          segment.add(this);
        }
        get tree() {
          return this.segment.tree;
        }
        get(index) {
          return quickbit.get(this.bitfield, index);
        }
        set(index, val) {
          if (quickbit.set(this.bitfield, index, val)) {
            this.tree.update(this.offset * 8 + index);
          }
        }
        setRange(start, length, val) {
          quickbit.fill(this.bitfield, val, start, start + length);
          let i = Math.floor(start / 128);
          const n = i + Math.ceil(length / 128);
          while (i <= n) this.tree.update(this.offset * 8 + i++ * 128);
        }
        findFirst(val, position) {
          return quickbit.findFirst(this.bitfield, val, position);
        }
        findLast(val, position) {
          return quickbit.findLast(this.bitfield, val, position);
        }
        insert(start, bitfield) {
          this.bitfield.set(bitfield, start / 32);
          this.segment.refresh();
        }
        clear(start, bitfield) {
          quickbit.clear(this.bitfield, { field: bitfield, offset: start });
        }
      };
      var RemoteBitfieldSegment = class {
        constructor(index) {
          this.index = index;
          this.offset = index * BYTES_PER_SEGMENT;
          this.tree = quickbit.Index.from([], BYTES_PER_SEGMENT);
          this.pages = new Array(PAGES_PER_SEGMENT);
          this.pagesLength = 0;
        }
        get chunks() {
          return this.tree.chunks;
        }
        refresh() {
          this.tree = quickbit.Index.from(this.tree.chunks, BYTES_PER_SEGMENT);
        }
        add(page) {
          const pageIndex = page.index - this.index * PAGES_PER_SEGMENT;
          if (pageIndex >= this.pagesLength) this.pagesLength = pageIndex + 1;
          this.pages[pageIndex] = page;
          const chunk = { field: page.bitfield, offset: page.offset };
          this.chunks.push(chunk);
          for (let i = this.chunks.length - 2; i >= 0; i--) {
            const prev = this.chunks[i];
            if (prev.offset <= chunk.offset) break;
            this.chunks[i] = chunk;
            this.chunks[i + 1] = prev;
          }
        }
        findFirst(val, position) {
          position = this.tree.skipFirst(!val, position);
          let j = position & BITS_PER_PAGE - 1;
          let i = (position - j) / BITS_PER_PAGE;
          if (i >= PAGES_PER_SEGMENT) return -1;
          while (i < this.pagesLength) {
            const p = this.pages[i];
            let index = -1;
            if (p) index = p.findFirst(val, j);
            else if (!val) index = j;
            if (index !== -1) return i * BITS_PER_PAGE + index;
            j = 0;
            i++;
          }
          return val || this.pagesLength === PAGES_PER_SEGMENT ? -1 : this.pagesLength * BITS_PER_PAGE;
        }
        findLast(val, position) {
          position = this.tree.skipLast(!val, position);
          let j = position & BITS_PER_PAGE - 1;
          let i = (position - j) / BITS_PER_PAGE;
          if (i >= PAGES_PER_SEGMENT) return -1;
          while (i >= 0) {
            const p = this.pages[i];
            let index = -1;
            if (p) index = p.findLast(val, j);
            else if (!val) index = j;
            if (index !== -1) return i * BITS_PER_PAGE + index;
            j = BITS_PER_PAGE - 1;
            i--;
          }
          return -1;
        }
      };
      module.exports = class RemoteBitfield {
        static BITS_PER_PAGE = BITS_PER_PAGE;
        constructor() {
          this._pages = new BigSparseArray();
          this._segments = new BigSparseArray();
          this._maxSegments = 0;
        }
        getBitfield(index) {
          const j = index & BITS_PER_PAGE - 1;
          const i = (index - j) / BITS_PER_PAGE;
          const p = this._pages.get(i);
          return p || null;
        }
        get(index) {
          const j = index & BITS_PER_PAGE - 1;
          const i = (index - j) / BITS_PER_PAGE;
          const p = this._pages.get(i);
          return p ? p.get(j) : false;
        }
        set(index, val) {
          const j = index & BITS_PER_PAGE - 1;
          const i = (index - j) / BITS_PER_PAGE;
          let p = this._pages.get(i);
          if (!p && val) {
            const k = Math.floor(i / PAGES_PER_SEGMENT);
            const s = this._segments.get(k) || this._segments.set(k, new RemoteBitfieldSegment(k));
            if (this._maxSegments <= k) this._maxSegments = k + 1;
            p = this._pages.set(i, new RemoteBitfieldPage(i, new Uint32Array(WORDS_PER_PAGE), s));
          }
          if (p) p.set(j, val);
        }
        setRange(start, length, val) {
          let j = start & BITS_PER_PAGE - 1;
          let i = (start - j) / BITS_PER_PAGE;
          while (length > 0) {
            let p = this._pages.get(i);
            if (!p && val) {
              const k = Math.floor(i / PAGES_PER_SEGMENT);
              const s = this._segments.get(k) || this._segments.set(k, new RemoteBitfieldSegment(k));
              if (this._maxSegments <= k) this._maxSegments = k + 1;
              p = this._pages.set(i, new RemoteBitfieldPage(i, new Uint32Array(WORDS_PER_PAGE), s));
            }
            const end = Math.min(j + length, BITS_PER_PAGE);
            const range = end - j;
            if (p) p.setRange(j, range, val);
            j = 0;
            i++;
            length -= range;
          }
        }
        findFirst(val, position) {
          let j = position & BITS_PER_SEGMENT - 1;
          let i = (position - j) / BITS_PER_SEGMENT;
          while (i < this._maxSegments) {
            const s = this._segments.get(i);
            let index = -1;
            if (s) index = s.findFirst(val, j);
            else if (!val) index = j;
            if (index !== -1) return i * BITS_PER_SEGMENT + index;
            j = 0;
            i++;
          }
          return val ? -1 : Math.max(position, this._maxSegments * BITS_PER_SEGMENT);
        }
        firstSet(position) {
          return this.findFirst(true, position);
        }
        firstUnset(position) {
          return this.findFirst(false, position);
        }
        findLast(val, position) {
          let j = position & BITS_PER_SEGMENT - 1;
          let i = (position - j) / BITS_PER_SEGMENT;
          while (i >= 0) {
            const s = this._segments.get(i);
            let index = -1;
            if (s) index = s.findLast(val, j);
            else if (!val) index = j;
            if (index !== -1) return i * BITS_PER_SEGMENT + index;
            j = BITS_PER_SEGMENT - 1;
            i--;
          }
          return -1;
        }
        lastSet(position) {
          return this.findLast(true, position);
        }
        lastUnset(position) {
          return this.findLast(false, position);
        }
        insert(start, bitfield) {
          if (start % 32 !== 0) return false;
          let length = bitfield.byteLength * 8;
          let j = start & BITS_PER_PAGE - 1;
          let i = (start - j) / BITS_PER_PAGE;
          while (length > 0) {
            let p = this._pages.get(i);
            if (!p) {
              const k = Math.floor(i / PAGES_PER_SEGMENT);
              const s = this._segments.get(k) || this._segments.set(k, new RemoteBitfieldSegment(k));
              if (this._maxSegments <= k) this._maxSegments = k + 1;
              p = this._pages.set(i, new RemoteBitfieldPage(i, new Uint32Array(WORDS_PER_PAGE), s));
            }
            const end = Math.min(j + length, BITS_PER_PAGE);
            const range = end - j;
            p.insert(j, bitfield.subarray(0, range / 32));
            bitfield = bitfield.subarray(range / 32);
            j = 0;
            i++;
            length -= range;
          }
          return true;
        }
        clear(start, bitfield) {
          if (start % 32 !== 0) return false;
          let length = bitfield.byteLength * 8;
          let j = start & BITS_PER_PAGE - 1;
          let i = (start - j) / BITS_PER_PAGE;
          while (length > 0) {
            let p = this._pages.get(i);
            if (!p) {
              const k = Math.floor(i / PAGES_PER_SEGMENT);
              const s = this._segments.get(k) || this._segments.set(k, new RemoteBitfieldSegment(k));
              if (this._maxSegments <= k) this._maxSegments = k + 1;
              p = this._pages.set(i, new RemoteBitfieldPage(i, new Uint32Array(WORDS_PER_PAGE), s));
            }
            const end = Math.min(j + length, BITS_PER_PAGE);
            const range = end - j;
            p.clear(j, bitfield.subarray(0, range / 32));
            bitfield = bitfield.subarray(range / 32);
            j = 0;
            i++;
            length -= range;
          }
          return true;
        }
      };
    }
  });

  // ../../node_modules/bare-dev/node_modules/sodium-native/index.js
  var require_sodium_native2 = __commonJS({
    "../../node_modules/bare-dev/node_modules/sodium-native/index.js"(exports, module) {
      __require.addon = require_node2();
      module.exports = __require.addon(".", __filename);
    }
  });

  // ../../node_modules/bare-dev/node_modules/sodium-universal/index.js
  var require_sodium_universal2 = __commonJS({
    "../../node_modules/bare-dev/node_modules/sodium-universal/index.js"(exports, module) {
      module.exports = require_sodium_native2();
    }
  });

  // ../../node_modules/bare-dev/node_modules/hypercore/lib/caps.js
  var require_caps = __commonJS({
    "../../node_modules/bare-dev/node_modules/hypercore/lib/caps.js"(exports) {
      var crypto = require_hypercore_crypto();
      var sodium = require_sodium_universal2();
      var b4a = require_b4a();
      var c = require_compact_encoding();
      var [
        TREE,
        REPLICATE_INITIATOR,
        REPLICATE_RESPONDER,
        MANIFEST,
        DEFAULT_NAMESPACE,
        BLOCK_ENCRYPTION
      ] = crypto.namespace("hypercore", 6);
      exports.MANIFEST = MANIFEST;
      exports.DEFAULT_NAMESPACE = DEFAULT_NAMESPACE;
      exports.BLOCK_ENCRYPTION = BLOCK_ENCRYPTION;
      exports.replicate = function(isInitiator, key, handshakeHash) {
        const out = b4a.allocUnsafe(32);
        sodium.crypto_generichash_batch(out, [isInitiator ? REPLICATE_INITIATOR : REPLICATE_RESPONDER, key], handshakeHash);
        return out;
      };
      exports.treeSignable = function(manifestHash, treeHash, length, fork) {
        const state = { start: 0, end: 112, buffer: b4a.allocUnsafe(112) };
        c.fixed32.encode(state, TREE);
        c.fixed32.encode(state, manifestHash);
        c.fixed32.encode(state, treeHash);
        c.uint64.encode(state, length);
        c.uint64.encode(state, fork);
        return state.buffer;
      };
      exports.treeSignableCompat = function(hash, length, fork, noHeader) {
        const end = noHeader ? 48 : 80;
        const state = { start: 0, end, buffer: b4a.allocUnsafe(end) };
        if (!noHeader) c.fixed32.encode(state, TREE);
        c.fixed32.encode(state, hash);
        c.uint64.encode(state, length);
        c.uint64.encode(state, fork);
        return state.buffer;
      };
    }
  });

  // ../../node_modules/bare-dev/node_modules/hypercore/lib/messages.js
  var require_messages2 = __commonJS({
    "../../node_modules/bare-dev/node_modules/hypercore/lib/messages.js"(exports) {
      var c = require_compact_encoding();
      var b4a = require_b4a();
      var { DEFAULT_NAMESPACE } = require_caps();
      var { INVALID_OPLOG_VERSION } = require_hypercore_errors();
      var unslab = require_unslab();
      var EMPTY = b4a.alloc(0);
      var hashes = {
        preencode(state, m) {
          state.end++;
        },
        encode(state, m) {
          if (m === "blake2b") {
            c.uint.encode(state, 0);
            return;
          }
          throw new Error("Unknown hash: " + m);
        },
        decode(state) {
          const n = c.uint.decode(state);
          if (n === 0) return "blake2b";
          throw new Error("Unknown hash id: " + n);
        }
      };
      var signatures = {
        preencode(state, m) {
          state.end++;
        },
        encode(state, m) {
          if (m === "ed25519") {
            c.uint.encode(state, 0);
            return;
          }
          throw new Error("Unknown signature: " + m);
        },
        decode(state) {
          const n = c.uint.decode(state);
          if (n === 0) return "ed25519";
          throw new Error("Unknown signature id: " + n);
        }
      };
      var signer = {
        preencode(state, m) {
          signatures.preencode(state, m.signature);
          c.fixed32.preencode(state, m.namespace);
          c.fixed32.preencode(state, m.publicKey);
        },
        encode(state, m) {
          signatures.encode(state, m.signature);
          c.fixed32.encode(state, m.namespace);
          c.fixed32.encode(state, m.publicKey);
        },
        decode(state) {
          return {
            signature: signatures.decode(state),
            namespace: c.fixed32.decode(state),
            publicKey: c.fixed32.decode(state)
          };
        }
      };
      var signerArray = c.array(signer);
      var prologue = {
        preencode(state, p) {
          c.fixed32.preencode(state, p.hash);
          c.uint.preencode(state, p.length);
        },
        encode(state, p) {
          c.fixed32.encode(state, p.hash);
          c.uint.encode(state, p.length);
        },
        decode(state) {
          return {
            hash: c.fixed32.decode(state),
            length: c.uint.decode(state)
          };
        }
      };
      var manifestv0 = {
        preencode(state, m) {
          hashes.preencode(state, m.hash);
          state.end++;
          if (m.prologue && m.signers.length === 0) {
            c.fixed32.preencode(state, m.prologue.hash);
            return;
          }
          if (m.quorum === 1 && m.signers.length === 1 && !m.allowPatch) {
            signer.preencode(state, m.signers[0]);
          } else {
            state.end++;
            c.uint.preencode(state, m.quorum);
            signerArray.preencode(state, m.signers);
          }
        },
        encode(state, m) {
          hashes.encode(state, m.hash);
          if (m.prologue && m.signers.length === 0) {
            c.uint.encode(state, 0);
            c.fixed32.encode(state, m.prologue.hash);
            return;
          }
          if (m.quorum === 1 && m.signers.length === 1 && !m.allowPatch) {
            c.uint.encode(state, 1);
            signer.encode(state, m.signers[0]);
          } else {
            c.uint.encode(state, 2);
            c.uint.encode(state, m.allowPatch ? 1 : 0);
            c.uint.encode(state, m.quorum);
            signerArray.encode(state, m.signers);
          }
        },
        decode(state) {
          const hash = hashes.decode(state);
          const type = c.uint.decode(state);
          if (type > 2) throw new Error("Unknown type: " + type);
          if (type === 0) {
            return {
              version: 0,
              hash,
              allowPatch: false,
              quorum: 0,
              signers: [],
              prologue: {
                hash: c.fixed32.decode(state),
                length: 0
              }
            };
          }
          if (type === 1) {
            return {
              version: 0,
              hash,
              allowPatch: false,
              quorum: 1,
              signers: [signer.decode(state)],
              prologue: null
            };
          }
          const flags = c.uint.decode(state);
          return {
            version: 0,
            hash,
            allowPatch: (flags & 1) !== 0,
            quorum: c.uint.decode(state),
            signers: signerArray.decode(state),
            prologue: null
          };
        }
      };
      var manifest = exports.manifest = {
        preencode(state, m) {
          state.end++;
          if (m.version === 0) return manifestv0.preencode(state, m);
          state.end++;
          hashes.preencode(state, m.hash);
          c.uint.preencode(state, m.quorum);
          signerArray.preencode(state, m.signers);
          if (m.prologue) prologue.preencode(state, m.prologue);
        },
        encode(state, m) {
          c.uint.encode(state, m.version);
          if (m.version === 0) return manifestv0.encode(state, m);
          c.uint.encode(state, (m.allowPatch ? 1 : 0) | (m.prologue ? 2 : 0));
          hashes.encode(state, m.hash);
          c.uint.encode(state, m.quorum);
          signerArray.encode(state, m.signers);
          if (m.prologue) prologue.encode(state, m.prologue);
        },
        decode(state) {
          const v = c.uint.decode(state);
          if (v === 0) return manifestv0.decode(state);
          if (v !== 1) throw new Error("Unknown version: " + v);
          const flags = c.uint.decode(state);
          const hash = hashes.decode(state);
          const quorum = c.uint.decode(state);
          const signers = signerArray.decode(state);
          return {
            version: 1,
            hash,
            allowPatch: (flags & 1) !== 0,
            quorum,
            signers,
            prologue: (flags & 2) === 0 ? null : prologue.decode(state)
          };
        }
      };
      var node = {
        preencode(state, n) {
          c.uint.preencode(state, n.index);
          c.uint.preencode(state, n.size);
          c.fixed32.preencode(state, n.hash);
        },
        encode(state, n) {
          c.uint.encode(state, n.index);
          c.uint.encode(state, n.size);
          c.fixed32.encode(state, n.hash);
        },
        decode(state) {
          return {
            index: c.uint.decode(state),
            size: c.uint.decode(state),
            hash: c.fixed32.decode(state)
          };
        }
      };
      var nodeArray = c.array(node);
      var wire = exports.wire = {};
      wire.handshake = {
        preencode(state, m) {
          c.uint.preencode(state, 1);
          c.fixed32.preencode(state, m.capability);
        },
        encode(state, m) {
          c.uint.encode(state, m.seeks ? 1 : 0);
          c.fixed32.encode(state, m.capability);
        },
        decode(state) {
          const flags = c.uint.decode(state);
          return {
            seeks: (flags & 1) !== 0,
            capability: unslab(c.fixed32.decode(state))
          };
        }
      };
      var requestBlock = {
        preencode(state, b) {
          c.uint.preencode(state, b.index);
          c.uint.preencode(state, b.nodes);
        },
        encode(state, b) {
          c.uint.encode(state, b.index);
          c.uint.encode(state, b.nodes);
        },
        decode(state) {
          return {
            index: c.uint.decode(state),
            nodes: c.uint.decode(state)
          };
        }
      };
      var requestSeek = {
        preencode(state, s) {
          c.uint.preencode(state, s.bytes);
          c.uint.preencode(state, s.padding);
        },
        encode(state, s) {
          c.uint.encode(state, s.bytes);
          c.uint.encode(state, s.padding);
        },
        decode(state) {
          return {
            bytes: c.uint.decode(state),
            padding: c.uint.decode(state)
          };
        }
      };
      var requestUpgrade = {
        preencode(state, u) {
          c.uint.preencode(state, u.start);
          c.uint.preencode(state, u.length);
        },
        encode(state, u) {
          c.uint.encode(state, u.start);
          c.uint.encode(state, u.length);
        },
        decode(state) {
          return {
            start: c.uint.decode(state),
            length: c.uint.decode(state)
          };
        }
      };
      wire.request = {
        preencode(state, m) {
          state.end++;
          c.uint.preencode(state, m.id);
          c.uint.preencode(state, m.fork);
          if (m.block) requestBlock.preencode(state, m.block);
          if (m.hash) requestBlock.preencode(state, m.hash);
          if (m.seek) requestSeek.preencode(state, m.seek);
          if (m.upgrade) requestUpgrade.preencode(state, m.upgrade);
          if (m.priority) c.uint.preencode(state, m.priority);
        },
        encode(state, m) {
          const flags = (m.block ? 1 : 0) | (m.hash ? 2 : 0) | (m.seek ? 4 : 0) | (m.upgrade ? 8 : 0) | (m.manifest ? 16 : 0) | (m.priority ? 32 : 0);
          c.uint.encode(state, flags);
          c.uint.encode(state, m.id);
          c.uint.encode(state, m.fork);
          if (m.block) requestBlock.encode(state, m.block);
          if (m.hash) requestBlock.encode(state, m.hash);
          if (m.seek) requestSeek.encode(state, m.seek);
          if (m.upgrade) requestUpgrade.encode(state, m.upgrade);
          if (m.priority) c.uint.encode(state, m.priority);
        },
        decode(state) {
          const flags = c.uint.decode(state);
          return {
            id: c.uint.decode(state),
            fork: c.uint.decode(state),
            block: flags & 1 ? requestBlock.decode(state) : null,
            hash: flags & 2 ? requestBlock.decode(state) : null,
            seek: flags & 4 ? requestSeek.decode(state) : null,
            upgrade: flags & 8 ? requestUpgrade.decode(state) : null,
            manifest: (flags & 16) !== 0,
            priority: flags & 32 ? c.uint.decode(state) : 0
          };
        }
      };
      wire.cancel = {
        preencode(state, m) {
          c.uint.preencode(state, m.request);
        },
        encode(state, m) {
          c.uint.encode(state, m.request);
        },
        decode(state, m) {
          return {
            request: c.uint.decode(state)
          };
        }
      };
      var dataUpgrade = {
        preencode(state, u) {
          c.uint.preencode(state, u.start);
          c.uint.preencode(state, u.length);
          nodeArray.preencode(state, u.nodes);
          nodeArray.preencode(state, u.additionalNodes);
          c.buffer.preencode(state, u.signature);
        },
        encode(state, u) {
          c.uint.encode(state, u.start);
          c.uint.encode(state, u.length);
          nodeArray.encode(state, u.nodes);
          nodeArray.encode(state, u.additionalNodes);
          c.buffer.encode(state, u.signature);
        },
        decode(state) {
          return {
            start: c.uint.decode(state),
            length: c.uint.decode(state),
            nodes: nodeArray.decode(state),
            additionalNodes: nodeArray.decode(state),
            signature: c.buffer.decode(state)
          };
        }
      };
      var dataSeek = {
        preencode(state, s) {
          c.uint.preencode(state, s.bytes);
          nodeArray.preencode(state, s.nodes);
        },
        encode(state, s) {
          c.uint.encode(state, s.bytes);
          nodeArray.encode(state, s.nodes);
        },
        decode(state) {
          return {
            bytes: c.uint.decode(state),
            nodes: nodeArray.decode(state)
          };
        }
      };
      var dataBlock = {
        preencode(state, b) {
          c.uint.preencode(state, b.index);
          c.buffer.preencode(state, b.value);
          nodeArray.preencode(state, b.nodes);
        },
        encode(state, b) {
          c.uint.encode(state, b.index);
          c.buffer.encode(state, b.value);
          nodeArray.encode(state, b.nodes);
        },
        decode(state) {
          return {
            index: c.uint.decode(state),
            value: c.buffer.decode(state) || EMPTY,
            nodes: nodeArray.decode(state)
          };
        }
      };
      var dataHash = {
        preencode(state, b) {
          c.uint.preencode(state, b.index);
          nodeArray.preencode(state, b.nodes);
        },
        encode(state, b) {
          c.uint.encode(state, b.index);
          nodeArray.encode(state, b.nodes);
        },
        decode(state) {
          return {
            index: c.uint.decode(state),
            nodes: nodeArray.decode(state)
          };
        }
      };
      wire.data = {
        preencode(state, m) {
          state.end++;
          c.uint.preencode(state, m.request);
          c.uint.preencode(state, m.fork);
          if (m.block) dataBlock.preencode(state, m.block);
          if (m.hash) dataHash.preencode(state, m.hash);
          if (m.seek) dataSeek.preencode(state, m.seek);
          if (m.upgrade) dataUpgrade.preencode(state, m.upgrade);
          if (m.manifest) manifest.preencode(state, m.manifest);
        },
        encode(state, m) {
          const flags = (m.block ? 1 : 0) | (m.hash ? 2 : 0) | (m.seek ? 4 : 0) | (m.upgrade ? 8 : 0) | (m.manifest ? 16 : 0);
          c.uint.encode(state, flags);
          c.uint.encode(state, m.request);
          c.uint.encode(state, m.fork);
          if (m.block) dataBlock.encode(state, m.block);
          if (m.hash) dataHash.encode(state, m.hash);
          if (m.seek) dataSeek.encode(state, m.seek);
          if (m.upgrade) dataUpgrade.encode(state, m.upgrade);
          if (m.manifest) manifest.encode(state, m.manifest);
        },
        decode(state) {
          const flags = c.uint.decode(state);
          return {
            request: c.uint.decode(state),
            fork: c.uint.decode(state),
            block: flags & 1 ? dataBlock.decode(state) : null,
            hash: flags & 2 ? dataHash.decode(state) : null,
            seek: flags & 4 ? dataSeek.decode(state) : null,
            upgrade: flags & 8 ? dataUpgrade.decode(state) : null,
            manifest: flags & 16 ? manifest.decode(state) : null
          };
        }
      };
      wire.noData = {
        preencode(state, m) {
          c.uint.preencode(state, m.request);
        },
        encode(state, m) {
          c.uint.encode(state, m.request);
        },
        decode(state, m) {
          return {
            request: c.uint.decode(state)
          };
        }
      };
      wire.want = {
        preencode(state, m) {
          c.uint.preencode(state, m.start);
          c.uint.preencode(state, m.length);
        },
        encode(state, m) {
          c.uint.encode(state, m.start);
          c.uint.encode(state, m.length);
        },
        decode(state) {
          return {
            start: c.uint.decode(state),
            length: c.uint.decode(state)
          };
        }
      };
      wire.unwant = {
        preencode(state, m) {
          c.uint.preencode(state, m.start);
          c.uint.preencode(state, m.length);
        },
        encode(state, m) {
          c.uint.encode(state, m.start);
          c.uint.encode(state, m.length);
        },
        decode(state, m) {
          return {
            start: c.uint.decode(state),
            length: c.uint.decode(state)
          };
        }
      };
      wire.range = {
        preencode(state, m) {
          state.end++;
          c.uint.preencode(state, m.start);
          if (m.length !== 1) c.uint.preencode(state, m.length);
        },
        encode(state, m) {
          c.uint.encode(state, (m.drop ? 1 : 0) | (m.length === 1 ? 2 : 0));
          c.uint.encode(state, m.start);
          if (m.length !== 1) c.uint.encode(state, m.length);
        },
        decode(state) {
          const flags = c.uint.decode(state);
          return {
            drop: (flags & 1) !== 0,
            start: c.uint.decode(state),
            length: (flags & 2) !== 0 ? 1 : c.uint.decode(state)
          };
        }
      };
      wire.bitfield = {
        preencode(state, m) {
          c.uint.preencode(state, m.start);
          c.uint32array.preencode(state, m.bitfield);
        },
        encode(state, m) {
          c.uint.encode(state, m.start);
          c.uint32array.encode(state, m.bitfield);
        },
        decode(state, m) {
          return {
            start: c.uint.decode(state),
            bitfield: c.uint32array.decode(state)
          };
        }
      };
      wire.sync = {
        preencode(state, m) {
          state.end++;
          c.uint.preencode(state, m.fork);
          c.uint.preencode(state, m.length);
          c.uint.preencode(state, m.remoteLength);
        },
        encode(state, m) {
          c.uint.encode(state, (m.canUpgrade ? 1 : 0) | (m.uploading ? 2 : 0) | (m.downloading ? 4 : 0) | (m.hasManifest ? 8 : 0));
          c.uint.encode(state, m.fork);
          c.uint.encode(state, m.length);
          c.uint.encode(state, m.remoteLength);
        },
        decode(state) {
          const flags = c.uint.decode(state);
          return {
            fork: c.uint.decode(state),
            length: c.uint.decode(state),
            remoteLength: c.uint.decode(state),
            canUpgrade: (flags & 1) !== 0,
            uploading: (flags & 2) !== 0,
            downloading: (flags & 4) !== 0,
            hasManifest: (flags & 8) !== 0
          };
        }
      };
      wire.reorgHint = {
        preencode(state, m) {
          c.uint.preencode(state, m.from);
          c.uint.preencode(state, m.to);
          c.uint.preencode(state, m.ancestors);
        },
        encode(state, m) {
          c.uint.encode(state, m.from);
          c.uint.encode(state, m.to);
          c.uint.encode(state, m.ancestors);
        },
        decode(state) {
          return {
            from: c.uint.encode(state),
            to: c.uint.encode(state),
            ancestors: c.uint.encode(state)
          };
        }
      };
      wire.extension = {
        preencode(state, m) {
          c.string.preencode(state, m.name);
          c.raw.preencode(state, m.message);
        },
        encode(state, m) {
          c.string.encode(state, m.name);
          c.raw.encode(state, m.message);
        },
        decode(state) {
          return {
            name: c.string.decode(state),
            message: c.raw.decode(state)
          };
        }
      };
      var keyValue = {
        preencode(state, p) {
          c.string.preencode(state, p.key);
          c.buffer.preencode(state, p.value);
        },
        encode(state, p) {
          c.string.encode(state, p.key);
          c.buffer.encode(state, p.value);
        },
        decode(state) {
          return {
            key: c.string.decode(state),
            value: c.buffer.decode(state)
          };
        }
      };
      var treeUpgrade = {
        preencode(state, u) {
          c.uint.preencode(state, u.fork);
          c.uint.preencode(state, u.ancestors);
          c.uint.preencode(state, u.length);
          c.buffer.preencode(state, u.signature);
        },
        encode(state, u) {
          c.uint.encode(state, u.fork);
          c.uint.encode(state, u.ancestors);
          c.uint.encode(state, u.length);
          c.buffer.encode(state, u.signature);
        },
        decode(state) {
          return {
            fork: c.uint.decode(state),
            ancestors: c.uint.decode(state),
            length: c.uint.decode(state),
            signature: c.buffer.decode(state)
          };
        }
      };
      var bitfieldUpdate = {
        // NOTE: can maybe be folded into a HAVE later on with the most recent spec
        preencode(state, b) {
          state.end++;
          c.uint.preencode(state, b.start);
          c.uint.preencode(state, b.length);
        },
        encode(state, b) {
          state.buffer[state.start++] = b.drop ? 1 : 0;
          c.uint.encode(state, b.start);
          c.uint.encode(state, b.length);
        },
        decode(state) {
          const flags = c.uint.decode(state);
          return {
            drop: (flags & 1) !== 0,
            start: c.uint.decode(state),
            length: c.uint.decode(state)
          };
        }
      };
      var oplog = exports.oplog = {};
      oplog.entry = {
        preencode(state, m) {
          state.end++;
          if (m.userData) keyValue.preencode(state, m.userData);
          if (m.treeNodes) nodeArray.preencode(state, m.treeNodes);
          if (m.treeUpgrade) treeUpgrade.preencode(state, m.treeUpgrade);
          if (m.bitfield) bitfieldUpdate.preencode(state, m.bitfield);
        },
        encode(state, m) {
          const s = state.start++;
          let flags = 0;
          if (m.userData) {
            flags |= 1;
            keyValue.encode(state, m.userData);
          }
          if (m.treeNodes) {
            flags |= 2;
            nodeArray.encode(state, m.treeNodes);
          }
          if (m.treeUpgrade) {
            flags |= 4;
            treeUpgrade.encode(state, m.treeUpgrade);
          }
          if (m.bitfield) {
            flags |= 8;
            bitfieldUpdate.encode(state, m.bitfield);
          }
          state.buffer[s] = flags;
        },
        decode(state) {
          const flags = c.uint.decode(state);
          return {
            userData: (flags & 1) !== 0 ? keyValue.decode(state) : null,
            treeNodes: (flags & 2) !== 0 ? nodeArray.decode(state) : null,
            treeUpgrade: (flags & 4) !== 0 ? treeUpgrade.decode(state) : null,
            bitfield: (flags & 8) !== 0 ? bitfieldUpdate.decode(state) : null
          };
        }
      };
      var keyPair = {
        preencode(state, kp) {
          c.buffer.preencode(state, kp.publicKey);
          c.buffer.preencode(state, kp.secretKey);
        },
        encode(state, kp) {
          c.buffer.encode(state, kp.publicKey);
          c.buffer.encode(state, kp.secretKey);
        },
        decode(state) {
          return {
            publicKey: c.buffer.decode(state),
            secretKey: c.buffer.decode(state)
          };
        }
      };
      var reorgHint = {
        preencode(state, r) {
          c.uint.preencode(state, r.from);
          c.uint.preencode(state, r.to);
          c.uint.preencode(state, r.ancestors);
        },
        encode(state, r) {
          c.uint.encode(state, r.from);
          c.uint.encode(state, r.to);
          c.uint.encode(state, r.ancestors);
        },
        decode(state) {
          return {
            from: c.uint.decode(state),
            to: c.uint.decode(state),
            ancestors: c.uint.decode(state)
          };
        }
      };
      var reorgHintArray = c.array(reorgHint);
      var hints = {
        preencode(state, h) {
          reorgHintArray.preencode(state, h.reorgs);
          c.uint.preencode(state, h.contiguousLength);
        },
        encode(state, h) {
          reorgHintArray.encode(state, h.reorgs);
          c.uint.encode(state, h.contiguousLength);
        },
        decode(state) {
          return {
            reorgs: reorgHintArray.decode(state),
            contiguousLength: state.start < state.end ? c.uint.decode(state) : 0
          };
        }
      };
      var treeHeader = {
        preencode(state, t) {
          c.uint.preencode(state, t.fork);
          c.uint.preencode(state, t.length);
          c.buffer.preencode(state, t.rootHash);
          c.buffer.preencode(state, t.signature);
        },
        encode(state, t) {
          c.uint.encode(state, t.fork);
          c.uint.encode(state, t.length);
          c.buffer.encode(state, t.rootHash);
          c.buffer.encode(state, t.signature);
        },
        decode(state) {
          return {
            fork: c.uint.decode(state),
            length: c.uint.decode(state),
            rootHash: c.buffer.decode(state),
            signature: c.buffer.decode(state)
          };
        }
      };
      var types = {
        preencode(state, t) {
          c.string.preencode(state, t.tree);
          c.string.preencode(state, t.bitfield);
          c.string.preencode(state, t.signer);
        },
        encode(state, t) {
          c.string.encode(state, t.tree);
          c.string.encode(state, t.bitfield);
          c.string.encode(state, t.signer);
        },
        decode(state) {
          return {
            tree: c.string.decode(state),
            bitfield: c.string.decode(state),
            signer: c.string.decode(state)
          };
        }
      };
      var externalHeader = {
        preencode(state, m) {
          c.uint.preencode(state, m.start);
          c.uint.preencode(state, m.length);
        },
        encode(state, m) {
          c.uint.encode(state, m.start);
          c.uint.encode(state, m.length);
        },
        decode(state) {
          return {
            start: c.uint.decode(state),
            length: c.uint.decode(state)
          };
        }
      };
      var keyValueArray = c.array(keyValue);
      oplog.header = {
        preencode(state, h) {
          state.end += 2;
          if (h.external) {
            externalHeader.preencode(state, h.external);
            return;
          }
          c.fixed32.preencode(state, h.key);
          if (h.manifest) manifest.preencode(state, h.manifest);
          if (h.keyPair) keyPair.preencode(state, h.keyPair);
          keyValueArray.preencode(state, h.userData);
          treeHeader.preencode(state, h.tree);
          hints.preencode(state, h.hints);
        },
        encode(state, h) {
          c.uint.encode(state, 1);
          if (h.external) {
            c.uint.encode(state, 1);
            externalHeader.encode(state, h.external);
            return;
          }
          c.uint.encode(state, (h.manifest ? 2 : 0) | (h.keyPair ? 4 : 0));
          c.fixed32.encode(state, h.key);
          if (h.manifest) manifest.encode(state, h.manifest);
          if (h.keyPair) keyPair.encode(state, h.keyPair);
          keyValueArray.encode(state, h.userData);
          treeHeader.encode(state, h.tree);
          hints.encode(state, h.hints);
        },
        decode(state) {
          const version = c.uint.decode(state);
          if (version > 1) {
            throw INVALID_OPLOG_VERSION("Invalid header version. Expected <= 1, got " + version);
          }
          if (version === 0) {
            const old = {
              types: types.decode(state),
              userData: keyValueArray.decode(state),
              tree: treeHeader.decode(state),
              signer: keyPair.decode(state),
              hints: hints.decode(state)
            };
            return {
              external: null,
              key: old.signer.publicKey,
              manifest: {
                version: 0,
                hash: old.types.tree,
                allowPatch: false,
                quorum: 1,
                signers: [{
                  signature: old.types.signer,
                  namespace: DEFAULT_NAMESPACE,
                  publicKey: old.signer.publicKey
                }],
                prologue: null
              },
              keyPair: old.signer.secretKey ? old.signer : null,
              userData: old.userData,
              tree: old.tree,
              hints: old.hints
            };
          }
          const flags = c.uint.decode(state);
          if (flags & 1) {
            return {
              external: externalHeader.decode(state),
              key: null,
              manifest: null,
              keyPair: null,
              userData: null,
              tree: null,
              hints: null
            };
          }
          return {
            external: null,
            key: c.fixed32.decode(state),
            manifest: (flags & 2) !== 0 ? manifest.decode(state) : null,
            keyPair: (flags & 4) !== 0 ? keyPair.decode(state) : null,
            userData: keyValueArray.decode(state),
            tree: treeHeader.decode(state),
            hints: hints.decode(state)
          };
        }
      };
      var uintArray = c.array(c.uint);
      var multisigInput = {
        preencode(state, inp) {
          c.uint.preencode(state, inp.signer);
          c.fixed64.preencode(state, inp.signature);
          c.uint.preencode(state, inp.patch);
        },
        encode(state, inp) {
          c.uint.encode(state, inp.signer);
          c.fixed64.encode(state, inp.signature);
          c.uint.encode(state, inp.patch);
        },
        decode(state) {
          return {
            signer: c.uint.decode(state),
            signature: c.fixed64.decode(state),
            patch: c.uint.decode(state)
          };
        }
      };
      var patchEncodingv0 = {
        preencode(state, n) {
          c.uint.preencode(state, n.start);
          c.uint.preencode(state, n.length);
          uintArray.preencode(state, n.nodes);
        },
        encode(state, n) {
          c.uint.encode(state, n.start);
          c.uint.encode(state, n.length);
          uintArray.encode(state, n.nodes);
        },
        decode(state) {
          return {
            start: c.uint.decode(state),
            length: c.uint.decode(state),
            nodes: uintArray.decode(state)
          };
        }
      };
      var multisigInputv0 = {
        preencode(state, n) {
          state.end++;
          c.uint.preencode(state, n.signer);
          c.fixed64.preencode(state, n.signature);
          if (n.patch) patchEncodingv0.preencode(state, n.patch);
        },
        encode(state, n) {
          c.uint.encode(state, n.patch ? 1 : 0);
          c.uint.encode(state, n.signer);
          c.fixed64.encode(state, n.signature);
          if (n.patch) patchEncodingv0.encode(state, n.patch);
        },
        decode(state) {
          const flags = c.uint.decode(state);
          return {
            signer: c.uint.decode(state),
            signature: c.fixed64.decode(state),
            patch: flags & 1 ? patchEncodingv0.decode(state) : null
          };
        }
      };
      var multisigInputArrayv0 = c.array(multisigInputv0);
      var multisigInputArray = c.array(multisigInput);
      var compactNode = {
        preencode(state, n) {
          c.uint.preencode(state, n.index);
          c.uint.preencode(state, n.size);
          c.fixed32.preencode(state, n.hash);
        },
        encode(state, n) {
          c.uint.encode(state, n.index);
          c.uint.encode(state, n.size);
          c.fixed32.encode(state, n.hash);
        },
        decode(state) {
          return {
            index: c.uint.decode(state),
            size: c.uint.decode(state),
            hash: c.fixed32.decode(state)
          };
        }
      };
      var compactNodeArray = c.array(compactNode);
      exports.multiSignaturev0 = {
        preencode(state, s) {
          multisigInputArrayv0.preencode(state, s.proofs);
          compactNodeArray.preencode(state, s.patch);
        },
        encode(state, s) {
          multisigInputArrayv0.encode(state, s.proofs);
          compactNodeArray.encode(state, s.patch);
        },
        decode(state) {
          return {
            proofs: multisigInputArrayv0.decode(state),
            patch: compactNodeArray.decode(state)
          };
        }
      };
      exports.multiSignature = {
        preencode(state, s) {
          multisigInputArray.preencode(state, s.proofs);
          compactNodeArray.preencode(state, s.patch);
        },
        encode(state, s) {
          multisigInputArray.encode(state, s.proofs);
          compactNodeArray.encode(state, s.patch);
        },
        decode(state) {
          return {
            proofs: multisigInputArray.decode(state),
            patch: compactNodeArray.decode(state)
          };
        }
      };
    }
  });

  // ../../node_modules/bare-dev/node_modules/hypercore/lib/replicator.js
  var require_replicator = __commonJS({
    "../../node_modules/bare-dev/node_modules/hypercore/lib/replicator.js"(exports, module) {
      var b4a = require_b4a();
      var safetyCatch = require_safety_catch();
      var RandomIterator = require_random_array_iterator();
      var flatTree = require_flat_tree();
      var ReceiverQueue = require_receiver_queue();
      var HotswapQueue = require_hotswap_queue();
      var RemoteBitfield = require_remote_bitfield();
      var { REQUEST_CANCELLED, REQUEST_TIMEOUT, INVALID_CAPABILITY, SNAPSHOT_NOT_AVAILABLE } = require_hypercore_errors();
      var m = require_messages2();
      var caps = require_caps();
      var DEFAULT_MAX_INFLIGHT = [16, 512];
      var SCALE_LATENCY = 50;
      var DEFAULT_SEGMENT_SIZE = 256 * 1024 * 8;
      var NOT_DOWNLOADING_SLACK = 2e4 + Math.random() * 2e4 | 0;
      var MAX_PEERS_UPGRADE = 3;
      var MAX_RANGES = 64;
      var PRIORITY = {
        NORMAL: 0,
        HIGH: 1,
        VERY_HIGH: 2,
        CANCELLED: 255
        // reserved to mark cancellation
      };
      var Attachable = class {
        constructor() {
          this.resolved = false;
          this.refs = [];
        }
        attach(session) {
          const r = {
            context: this,
            session,
            sindex: 0,
            rindex: 0,
            snapshot: true,
            resolve: null,
            reject: null,
            promise: null,
            timeout: null
          };
          r.sindex = session.push(r) - 1;
          r.rindex = this.refs.push(r) - 1;
          r.promise = new Promise((resolve, reject) => {
            r.resolve = resolve;
            r.reject = reject;
          });
          return r;
        }
        detach(r, err = null) {
          if (r.context !== this) return false;
          this._detach(r);
          this._cancel(r, err);
          this.gc();
          return true;
        }
        _detach(r) {
          const rh = this.refs.pop();
          const sh = r.session.pop();
          if (r.rindex < this.refs.length) this.refs[rh.rindex = r.rindex] = rh;
          if (r.sindex < r.session.length) r.session[sh.sindex = r.sindex] = sh;
          destroyRequestTimeout(r);
          r.context = null;
          return r;
        }
        gc() {
          if (this.refs.length === 0) this._unref();
        }
        _cancel(r, err) {
          r.reject(err || REQUEST_CANCELLED());
        }
        _unref() {
        }
        resolve(val) {
          this.resolved = true;
          while (this.refs.length > 0) {
            this._detach(this.refs[this.refs.length - 1]).resolve(val);
          }
        }
        reject(err) {
          this.resolved = true;
          while (this.refs.length > 0) {
            this._detach(this.refs[this.refs.length - 1]).reject(err);
          }
        }
        setTimeout(r, ms) {
          destroyRequestTimeout(r);
          r.timeout = setTimeout(onrequesttimeout, ms, r);
        }
      };
      var BlockRequest = class extends Attachable {
        constructor(tracker, index, priority) {
          super();
          this.index = index;
          this.priority = priority;
          this.inflight = [];
          this.queued = false;
          this.hotswap = null;
          this.tracker = tracker;
        }
        _unref() {
          this.queued = false;
          for (const req of this.inflight) {
            req.peer._cancelRequest(req);
          }
          this.tracker.remove(this.index);
          removeHotswap(this);
        }
      };
      var RangeRequest = class extends Attachable {
        constructor(ranges, start, end, linear, ifAvailable, blocks) {
          super();
          this.start = start;
          this.end = end;
          this.linear = linear;
          this.ifAvailable = ifAvailable;
          this.blocks = blocks;
          this.ranges = ranges;
          this.userStart = start;
          this.userEnd = end;
        }
        _unref() {
          const i = this.ranges.indexOf(this);
          if (i === -1) return;
          const h = this.ranges.pop();
          if (i < this.ranges.length) this.ranges[i] = h;
        }
        _cancel(r) {
          r.resolve(false);
        }
      };
      var UpgradeRequest = class extends Attachable {
        constructor(replicator, fork, length) {
          super();
          this.fork = fork;
          this.length = length;
          this.inflight = [];
          this.replicator = replicator;
        }
        _unref() {
          if (this.replicator.eagerUpgrade === true || this.inflight.length > 0) return;
          this.replicator._upgrade = null;
        }
        _cancel(r) {
          r.resolve(false);
        }
      };
      var SeekRequest = class extends Attachable {
        constructor(seeks, seeker) {
          super();
          this.seeker = seeker;
          this.inflight = [];
          this.seeks = seeks;
        }
        _unref() {
          if (this.inflight.length > 0) return;
          const i = this.seeks.indexOf(this);
          if (i === -1) return;
          const h = this.seeks.pop();
          if (i < this.seeks.length) this.seeks[i] = h;
        }
      };
      var InflightTracker = class {
        constructor() {
          this._requests = [];
          this._free = [];
        }
        get idle() {
          return this._requests.length === this._free.length;
        }
        *[Symbol.iterator]() {
          for (const req of this._requests) {
            if (req !== null) yield req;
          }
        }
        add(req) {
          const id = this._free.length ? this._free.pop() : this._requests.push(null);
          req.id = id;
          this._requests[id - 1] = req;
          return req;
        }
        get(id) {
          return id <= this._requests.length ? this._requests[id - 1] : null;
        }
        remove(id, roundtrip) {
          if (id > this._requests.length) return;
          this._requests[id - 1] = null;
          if (roundtrip === true) this._free.push(id);
        }
        reusable(id) {
          this._free.push(id);
        }
      };
      var BlockTracker = class {
        constructor() {
          this._map = /* @__PURE__ */ new Map();
        }
        [Symbol.iterator]() {
          return this._map.values();
        }
        isEmpty() {
          return this._map.size === 0;
        }
        has(index) {
          return this._map.has(index);
        }
        get(index) {
          return this._map.get(index) || null;
        }
        add(index, priority) {
          let b = this._map.get(index);
          if (b) return b;
          b = new BlockRequest(this, index, priority);
          this._map.set(index, b);
          return b;
        }
        remove(index) {
          const b = this.get(index);
          this._map.delete(index);
          return b;
        }
      };
      var RoundtripQueue = class {
        constructor() {
          this.queue = [];
          this.tick = 0;
        }
        clear() {
          const ids = new Array(this.queue.length);
          for (let i = 0; i < ids.length; i++) {
            ids[i] = this.queue[i][1];
          }
          this.queue = [];
          return ids;
        }
        add(id) {
          this.queue.push([++this.tick, id]);
        }
        flush(tick) {
          let flushed = null;
          for (let i = 0; i < this.queue.length; i++) {
            if (this.queue[i][0] > tick) break;
            if (flushed === null) flushed = [];
            flushed.push(this.queue[i][1]);
          }
          if (flushed !== null) this.queue.splice(0, flushed.length);
          return flushed;
        }
      };
      var Peer = class {
        constructor(replicator, protomux, channel, useSession, inflightRange) {
          this.core = replicator.core;
          this.replicator = replicator;
          this.stream = protomux.stream;
          this.protomux = protomux;
          this.remotePublicKey = this.stream.remotePublicKey;
          this.remoteSupportsSeeks = false;
          this.inflightRange = inflightRange;
          this.paused = false;
          this.removed = false;
          this.useSession = useSession;
          this.channel = channel;
          this.channel.userData = this;
          this.wireSync = this.channel.messages[0];
          this.wireRequest = this.channel.messages[1];
          this.wireCancel = this.channel.messages[2];
          this.wireData = this.channel.messages[3];
          this.wireNoData = this.channel.messages[4];
          this.wireWant = this.channel.messages[5];
          this.wireUnwant = this.channel.messages[6];
          this.wireBitfield = this.channel.messages[7];
          this.wireRange = this.channel.messages[8];
          this.wireExtension = this.channel.messages[9];
          this.stats = {
            wireSync: { tx: 0, rx: 0 },
            wireRequest: { tx: 0, rx: 0 },
            wireCancel: { tx: 0, rx: 0 },
            wireData: { tx: 0, rx: 0 },
            wireWant: { tx: 0, rx: 0 },
            wireBitfield: { tx: 0, rx: 0 },
            wireRange: { tx: 0, rx: 0 },
            wireExtension: { tx: 0, rx: 0 },
            hotswaps: 0
          };
          this.receiverQueue = new ReceiverQueue();
          this.receiverBusy = false;
          this.roundtripQueue = null;
          this.inflight = 0;
          this.dataProcessing = 0;
          this.canUpgrade = true;
          this.needsSync = false;
          this.syncsProcessing = 0;
          this._remoteContiguousLength = 0;
          this.remoteOpened = false;
          this.remoteBitfield = new RemoteBitfield();
          this.missingBlocks = new RemoteBitfield();
          this.remoteFork = 0;
          this.remoteLength = 0;
          this.remoteCanUpgrade = false;
          this.remoteUploading = true;
          this.remoteDownloading = true;
          this.remoteSynced = false;
          this.remoteHasManifest = false;
          this.remoteRequests = /* @__PURE__ */ new Map();
          this.segmentsWanted = /* @__PURE__ */ new Set();
          this.broadcastedNonSparse = false;
          this.lengthAcked = 0;
          this.extensions = /* @__PURE__ */ new Map();
          this.lastExtensionSent = "";
          this.lastExtensionRecv = "";
          replicator._ifAvailable++;
        }
        get remoteContiguousLength() {
          return this.remoteBitfield.findFirst(false, this._remoteContiguousLength);
        }
        getMaxInflight() {
          const stream = this.stream.rawStream;
          if (!stream.udx) return Math.min(this.inflightRange[1], this.inflightRange[0] * 3);
          const scale = stream.rtt <= SCALE_LATENCY ? 1 : stream.rtt / SCALE_LATENCY * Math.min(1, 2 / this.replicator.peers.length);
          return Math.max(this.inflightRange[0], Math.round(Math.min(this.inflightRange[1], this.inflightRange[0] * scale)));
        }
        getMaxHotswapInflight() {
          const inf = this.getMaxInflight();
          return Math.max(16, inf / 2);
        }
        signalUpgrade() {
          if (this._shouldUpdateCanUpgrade() === true) this._updateCanUpgradeAndSync();
          else this.sendSync();
        }
        _markInflight(index) {
          this.missingBlocks.set(index, false);
        }
        broadcastRange(start, length, drop) {
          if (drop) this._unclearLocalRange(start, length);
          else this._clearLocalRange(start, length);
          if (!drop) {
            if (this._remoteContiguousLength >= start + length) return;
            if (length === 1) {
              if (this.remoteBitfield.get(start)) return;
            } else {
              if (this.remoteBitfield.firstUnset(start) >= start + length) return;
            }
          }
          this.wireRange.send({
            drop,
            start,
            length
          });
          incrementTx(this.stats.wireRange, this.replicator.stats.wireRange);
        }
        extension(name, message) {
          this.wireExtension.send({ name: name === this.lastExtensionSent ? "" : name, message });
          incrementTx(this.stats.wireExtension, this.replicator.stats.wireExtension);
          this.lastExtensionSent = name;
        }
        onextension(message) {
          const name = message.name || this.lastExtensionRecv;
          this.lastExtensionRecv = name;
          const ext = this.extensions.get(name);
          if (ext) ext._onmessage({ start: 0, end: message.message.byteLength, buffer: message.message }, this);
        }
        sendSync() {
          if (this.syncsProcessing !== 0) {
            this.needsSync = true;
            return;
          }
          if (this.core.tree.fork !== this.remoteFork) {
            this.canUpgrade = false;
          }
          this.needsSync = false;
          this.wireSync.send({
            fork: this.core.tree.fork,
            length: this.core.tree.length,
            remoteLength: this.core.tree.fork === this.remoteFork ? this.remoteLength : 0,
            canUpgrade: this.canUpgrade,
            uploading: true,
            downloading: this.replicator.isDownloading(),
            hasManifest: !!this.core.header.manifest && this.core.compat === false
          });
          incrementTx(this.stats.wireSync, this.replicator.stats.wireSync);
        }
        onopen({ seeks, capability }) {
          const expected = caps.replicate(this.stream.isInitiator === false, this.replicator.key, this.stream.handshakeHash);
          if (b4a.equals(capability, expected) !== true) {
            throw INVALID_CAPABILITY("Remote sent an invalid replication capability");
          }
          if (this.remoteOpened === true) return;
          this.remoteOpened = true;
          this.remoteSupportsSeeks = seeks;
          this.protomux.cork();
          this.sendSync();
          const contig = Math.min(this.core.tree.length, this.core.header.hints.contiguousLength);
          if (contig > 0) {
            this.broadcastRange(0, contig, false);
            if (contig === this.core.tree.length) {
              this.broadcastedNonSparse = true;
            }
          }
          this.replicator._ifAvailable--;
          this.replicator._addPeer(this);
          this.protomux.uncork();
        }
        onclose(isRemote) {
          const reopen = isRemote === true && this.remoteOpened === true && this.remoteDownloading === false && this.remoteUploading === true && this.replicator.downloading === true;
          if (this.remoteOpened === false) {
            if (this.useSession) {
              this.replicator._peerSessions--;
              this.replicator._closeSessionMaybe();
            }
            this.replicator._ifAvailable--;
            this.replicator.updateAll();
            return;
          }
          this.remoteOpened = false;
          this.removed = true;
          this.remoteRequests.clear();
          this.receiverQueue.clear();
          if (this.roundtripQueue !== null) {
            for (const id of this.roundtripQueue.clear()) this.replicator._inflight.reusable(id);
          }
          this.replicator._removePeer(this);
          if (reopen) {
            this.replicator._makePeer(this.protomux, this.useSession);
          }
          if (this.useSession) {
            this.replicator._peerSessions--;
            this.replicator._closeSessionMaybe();
          }
        }
        closeIfIdle() {
          if (this.remoteDownloading === false && this.replicator.isDownloading() === false) {
            this.channel.close();
            return true;
          }
          return false;
        }
        async onsync({ fork, length, remoteLength, canUpgrade, uploading, downloading, hasManifest }) {
          const lengthChanged = length !== this.remoteLength;
          const sameFork = fork === this.core.tree.fork;
          this.remoteSynced = true;
          this.remoteFork = fork;
          this.remoteLength = length;
          this.remoteCanUpgrade = canUpgrade;
          this.remoteUploading = uploading;
          this.remoteDownloading = downloading;
          this.remoteHasManifest = hasManifest;
          if (this.closeIfIdle()) return;
          this.lengthAcked = sameFork ? remoteLength : 0;
          this.syncsProcessing++;
          this.replicator._updateFork(this);
          if (this.remoteLength > this.core.tree.length && this.lengthAcked === this.core.tree.length) {
            if (this.replicator._addUpgradeMaybe() !== null) this._update();
          }
          const upgrade = lengthChanged === false || sameFork === false ? this.canUpgrade && sameFork : await this._canUpgrade(length, fork);
          if (length === this.remoteLength && fork === this.core.tree.fork) {
            this.canUpgrade = upgrade;
          }
          if (--this.syncsProcessing !== 0) return;
          if (this.needsSync === true || this.core.tree.fork === this.remoteFork && this.core.tree.length > this.remoteLength) {
            this.signalUpgrade();
          }
          this._update();
        }
        _shouldUpdateCanUpgrade() {
          return this.core.tree.fork === this.remoteFork && this.core.tree.length > this.remoteLength && this.canUpgrade === false && this.syncsProcessing === 0;
        }
        async _updateCanUpgradeAndSync() {
          const { length, fork } = this.core.tree;
          const canUpgrade = await this._canUpgrade(this.remoteLength, this.remoteFork);
          if (this.syncsProcessing > 0 || length !== this.core.tree.length || fork !== this.core.tree.fork) {
            return;
          }
          if (canUpgrade === this.canUpgrade) {
            return;
          }
          this.canUpgrade = canUpgrade;
          this.sendSync();
        }
        // Safe to call in the background - never fails
        async _canUpgrade(remoteLength, remoteFork) {
          if (remoteFork !== this.core.tree.fork) return false;
          if (remoteLength === 0) return true;
          if (remoteLength >= this.core.tree.length) return false;
          try {
            const canUpgrade = await this.core.tree.upgradeable(remoteLength);
            if (remoteFork !== this.core.tree.fork) return false;
            return canUpgrade;
          } catch {
            return false;
          }
        }
        async _getProof(msg) {
          const proof = await this.core.tree.proof(msg);
          if (proof.block) {
            const index = msg.block.index;
            if (msg.fork !== this.core.tree.fork || !this.core.bitfield.get(index)) {
              return null;
            }
            proof.block.value = await this.core.blocks.get(index);
          }
          if (msg.manifest && !this.core.compat) {
            proof.manifest = this.core.header.manifest;
          }
          return proof;
        }
        async onrequest(msg) {
          const size = this.remoteRequests.size;
          this.remoteRequests.set(msg.id, msg);
          if (size === this.remoteRequests.size) {
            this._cancel(msg.id);
            this.remoteRequests.set(msg.id, msg);
          }
          if (!this.protomux.drained || this.receiverQueue.length) {
            this.receiverQueue.push(msg);
            return;
          }
          await this._handleRequest(msg);
        }
        oncancel(msg) {
          this._cancel(msg.request);
        }
        _cancel(id) {
          this.remoteRequests.delete(id);
          this.receiverQueue.delete(id);
        }
        ondrain() {
          return this._handleRequests();
        }
        async _handleRequests() {
          if (this.receiverBusy) return;
          this.receiverBusy = true;
          this.protomux.cork();
          while (this.remoteOpened && this.protomux.drained && this.receiverQueue.length > 0 && !this.removed) {
            const msg = this.receiverQueue.shift();
            await this._handleRequest(msg);
          }
          this.protomux.uncork();
          this.receiverBusy = false;
        }
        async _handleRequest(msg) {
          let proof = null;
          if (msg.fork === this.core.tree.fork) {
            try {
              proof = await this._getProof(msg);
            } catch (err) {
              safetyCatch(err);
              if (msg.fork === this.core.tree.fork && isCriticalError(err)) throw err;
            }
          }
          if (this.remoteRequests.get(msg.id) !== msg) {
            return;
          }
          this.remoteRequests.delete(msg.id);
          if (proof === null) {
            if (msg.manifest && this.core.header.manifest) {
              const manifest = this.core.header.manifest;
              this.wireData.send({ request: msg.id, fork: this.core.tree.fork, block: null, hash: null, seek: null, upgrade: null, manifest });
              incrementTx(this.stats.wireData, this.replicator.stats.wireData);
              return;
            }
            this.wireNoData.send({ request: msg.id });
            return;
          }
          if (proof.block !== null) {
            this.replicator.onupload(proof.block.index, proof.block.value, this);
          }
          this.wireData.send({
            request: msg.id,
            fork: msg.fork,
            block: proof.block,
            hash: proof.hash,
            seek: proof.seek,
            upgrade: proof.upgrade,
            manifest: proof.manifest
          });
          incrementTx(this.stats.wireData, this.replicator.stats.wireData);
        }
        _cancelRequest(req) {
          if (req.priority === PRIORITY.CANCELLED) return;
          req.priority = PRIORITY.CANCELLED;
          this.inflight--;
          this.replicator._requestDone(req.id, false);
          if (isBlockRequest(req)) this.replicator._unmarkInflight(req.block.index);
          if (isUpgradeRequest(req)) this.replicator._clearInflightUpgrade(req);
          if (this.roundtripQueue === null) this.roundtripQueue = new RoundtripQueue();
          this.roundtripQueue.add(req.id);
          this.wireCancel.send({ request: req.id });
          incrementTx(this.stats.wireCancel, this.replicator.stats.wireCancel);
        }
        _checkIfConflict() {
          this.paused = true;
          const length = Math.min(this.core.tree.length, this.remoteLength);
          if (length === 0) return;
          this.wireRequest.send({
            id: 0,
            // NOTE: use an more explicit id for this eventually...
            fork: this.remoteFork,
            block: null,
            hash: null,
            seek: null,
            upgrade: {
              start: 0,
              length
            }
          });
          incrementTx(this.stats.wireRequest, this.replicator.stats.wireRequest);
        }
        async ondata(data) {
          if (data.request === 0 && data.upgrade && data.upgrade.start === 0) {
            if (await this.core.checkConflict(data, this)) return;
            this.paused = false;
          }
          const req = data.request > 0 ? this.replicator._inflight.get(data.request) : null;
          const reorg = data.fork > this.core.tree.fork;
          if (req === null && reorg === false) return;
          if (req !== null) {
            if (req.peer !== this) return;
            this._onrequestroundtrip(req);
          }
          try {
            if (reorg === true) return await this.replicator._onreorgdata(this, req, data);
          } catch (err) {
            safetyCatch(err);
            if (isBlockRequest(req)) this.replicator._unmarkInflight(req.block.index);
            this.paused = true;
            this.replicator.oninvalid(err, req, data, this);
            return;
          }
          this.dataProcessing++;
          try {
            if (!matchingRequest(req, data) || !await this.core.verify(data, this)) {
              this.replicator._onnodata(this, req);
              return;
            }
          } catch (err) {
            safetyCatch(err);
            if (isBlockRequest(req)) this.replicator._unmarkInflight(req.block.index);
            if (err.code === "WRITE_FAILED") {
              this.paused = true;
              return;
            }
            if (this.core.closed && !isCriticalError(err)) return;
            if (err.code !== "INVALID_OPERATION") {
              this._checkIfConflict();
            }
            this.replicator._onnodata(this, req);
            this.replicator.oninvalid(err, req, data, this);
            return;
          } finally {
            this.dataProcessing--;
          }
          this.replicator._ondata(this, req, data);
          if (this._shouldUpdateCanUpgrade() === true) {
            this._updateCanUpgradeAndSync();
          }
        }
        onnodata({ request }) {
          const req = request > 0 ? this.replicator._inflight.get(request) : null;
          if (req === null || req.peer !== this) return;
          this._onrequestroundtrip(req);
          this.replicator._onnodata(this, req);
        }
        _onrequestroundtrip(req) {
          if (req.priority === PRIORITY.CANCELLED) return;
          req.priority = PRIORITY.CANCELLED;
          this.inflight--;
          this.replicator._requestDone(req.id, true);
          if (this.roundtripQueue === null) return;
          const flushed = this.roundtripQueue.flush(req.rt);
          if (flushed === null) return;
          for (const id of flushed) this.replicator._inflight.reusable(id);
        }
        onwant({ start, length }) {
          this.replicator._onwant(this, start, length);
        }
        onunwant() {
        }
        onbitfield({ start, bitfield }) {
          if (start < this._remoteContiguousLength) this._remoteContiguousLength = start;
          this.remoteBitfield.insert(start, bitfield);
          this.missingBlocks.insert(start, bitfield);
          this._clearLocalRange(start, bitfield.byteLength * 8);
          this._update();
        }
        _clearLocalRange(start, length) {
          const bitfield = this.core.skipBitfield === null ? this.core.bitfield : this.core.skipBitfield;
          if (length === 1) {
            this.missingBlocks.set(start, this._remoteHasBlock(start) && !bitfield.get(start));
            return;
          }
          const contig = Math.min(this.core.tree.length, this.core.header.hints.contiguousLength);
          if (start + length < contig) {
            const delta = contig - start;
            this.missingBlocks.setRange(start, delta, false);
            return;
          }
          const rem = start & 32767;
          if (rem > 0) {
            start -= rem;
            length += rem;
          }
          const end = start + Math.min(length, this.core.tree.length);
          while (start < end) {
            const local = bitfield.getBitfield(start);
            if (local && local.bitfield) {
              this.missingBlocks.clear(start, local.bitfield);
            }
            start += 32768;
          }
        }
        _resetMissingBlock(index) {
          const bitfield = this.core.skipBitfield === null ? this.core.bitfield : this.core.skipBitfield;
          this.missingBlocks.set(index, this._remoteHasBlock(index) && !bitfield.get(index));
        }
        _unclearLocalRange(start, length) {
          if (length === 1) {
            this._resetMissingBlock(start);
            return;
          }
          const rem = start & 2097151;
          if (rem > 0) {
            start -= rem;
            length += rem;
          }
          const fixedStart = start;
          const end = start + Math.min(length, this.remoteLength);
          while (start < end) {
            const remote = this.remoteBitfield.getBitfield(start);
            if (remote && remote.bitfield) {
              this.missingBlocks.insert(start, remote.bitfield);
            }
            start += 2097152;
          }
          this._clearLocalRange(fixedStart, length);
        }
        onrange({ drop, start, length }) {
          const has = drop === false;
          if (drop === true && start < this._remoteContiguousLength) {
            this._remoteContiguousLength = start;
          }
          if (start === 0 && drop === false) {
            if (length > this._remoteContiguousLength) this._remoteContiguousLength = length;
          } else if (length === 1) {
            const bitfield = this.core.skipBitfield === null ? this.core.bitfield : this.core.skipBitfield;
            this.remoteBitfield.set(start, has);
            this.missingBlocks.set(start, has && !bitfield.get(start));
          } else {
            const rangeStart = this.remoteBitfield.findFirst(!has, start);
            const rangeLength = length - (rangeStart - start);
            if (rangeLength > 0) {
              this.remoteBitfield.setRange(rangeStart, rangeLength, has);
              this.missingBlocks.setRange(rangeStart, rangeLength, has);
              if (has) this._clearLocalRange(rangeStart, rangeLength);
            }
          }
          if (drop === false) this._update();
        }
        onreorghint() {
        }
        _update() {
          this.replicator.updatePeer(this);
        }
        async _onconflict() {
          this.protomux.cork();
          if (this.remoteLength > 0 && this.core.tree.fork === this.remoteFork) {
            await this.onrequest({
              id: 0,
              fork: this.core.tree.fork,
              block: null,
              hash: null,
              seek: null,
              upgrade: {
                start: 0,
                length: Math.min(this.core.tree.length, this.remoteLength)
              }
            });
          }
          this.channel.close();
          this.protomux.uncork();
        }
        _makeRequest(needsUpgrade, priority, minLength) {
          if (needsUpgrade === true && this.replicator._shouldUpgrade(this) === false) {
            return null;
          }
          if (this.remoteLength < minLength) {
            return null;
          }
          if (needsUpgrade === false && this.replicator._autoUpgrade(this) === true) {
            needsUpgrade = true;
          }
          return {
            peer: this,
            rt: this.roundtripQueue === null ? 0 : this.roundtripQueue.tick,
            id: 0,
            fork: this.remoteFork,
            block: null,
            hash: null,
            seek: null,
            upgrade: needsUpgrade === false ? null : { start: this.core.tree.length, length: this.remoteLength - this.core.tree.length },
            // remote manifest check can be removed eventually...
            manifest: this.core.header.manifest === null && this.remoteHasManifest === true,
            priority
          };
        }
        _requestManifest() {
          const req = this._makeRequest(false, 0, 0);
          this._send(req);
        }
        _requestUpgrade(u) {
          const req = this._makeRequest(true, 0, 0);
          if (req === null) return false;
          this._send(req);
          return true;
        }
        _requestSeek(s) {
          if (this.replicator._updatesPending > 0) return false;
          const { length, fork } = this.core.tree;
          if (fork !== this.remoteFork) return false;
          if (s.seeker.start >= length) {
            const req = this._makeRequest(true, 0, 0);
            if (req === null) return false;
            req.seek = this.remoteSupportsSeeks ? { bytes: s.seeker.bytes, padding: s.seeker.padding } : null;
            s.inflight.push(req);
            this._send(req);
            return true;
          }
          const len = s.seeker.end - s.seeker.start;
          const off = s.seeker.start + Math.floor(Math.random() * len);
          for (let i = 0; i < len; i++) {
            let index = off + i;
            if (index > s.seeker.end) index -= len;
            if (this._remoteHasBlock(index) === false) continue;
            if (this.core.bitfield.get(index) === true) continue;
            if (!this._hasTreeParent(index)) continue;
            const b = this.replicator._blocks.get(index);
            if (b !== null && b.inflight.length > 0) continue;
            const h = this.replicator._hashes.add(index, PRIORITY.NORMAL);
            if (h.inflight.length > 0) continue;
            const req = this._makeRequest(false, h.priority, index + 1);
            if (req === null) continue;
            const nodes = flatTree.depth(s.seeker.start + s.seeker.end - 1);
            req.hash = { index: 2 * index, nodes };
            req.seek = this.remoteSupportsSeeks ? { bytes: s.seeker.bytes, padding: s.seeker.padding } : null;
            s.inflight.push(req);
            h.inflight.push(req);
            this._send(req);
            return true;
          }
          this._maybeWant(s.seeker.start, len);
          return false;
        }
        _hasTreeParent(index) {
          if (this.remoteLength >= this.core.tree.length) return true;
          const ite = flatTree.iterator(index * 2);
          let span = 2;
          let length = 0;
          while (true) {
            ite.parent();
            const left = (ite.index - ite.factor / 2 + 1) / 2;
            length = left + span;
            if (length > this.core.tree.length) {
              if (length > this.remoteLength) return true;
              break;
            }
            if (length > this.remoteLength) break;
            span *= 2;
            const first = this.core.bitfield.findFirst(true, left);
            if (first > -1 && first < length) return true;
          }
          return false;
        }
        _remoteHasBlock(index) {
          return index < this._remoteContiguousLength || this.remoteBitfield.get(index) === true;
        }
        _sendBlockRequest(req, b) {
          req.block = { index: b.index, nodes: 0 };
          this.replicator._markInflight(b.index);
          b.inflight.push(req);
          this.replicator.hotswaps.add(b);
          this._send(req);
        }
        _requestBlock(b) {
          const { length, fork } = this.core.tree;
          if (this._remoteHasBlock(b.index) === false || fork !== this.remoteFork) {
            this._maybeWant(b.index);
            return false;
          }
          if (!this._hasTreeParent(b.index)) {
            return false;
          }
          const req = this._makeRequest(b.index >= length, b.priority, b.index + 1);
          if (req === null) return false;
          this._sendBlockRequest(req, b);
          return true;
        }
        _requestRangeBlock(index, length) {
          if (this.core.bitfield.get(index) === true || !this._hasTreeParent(index)) return false;
          const b = this.replicator._blocks.add(index, PRIORITY.NORMAL);
          if (b.inflight.length > 0) {
            this.missingBlocks.set(index, false);
            return false;
          }
          const req = this._makeRequest(index >= length, b.priority, index + 1);
          if (req === null) {
            b.gc();
            return false;
          }
          this._sendBlockRequest(req, b);
          if (b.queued) b.queued = false;
          return true;
        }
        _findNext(i) {
          if (i < this._remoteContiguousLength) {
            if (this.core.skipBitfield === null) this.replicator._openSkipBitfield();
            i = this.core.skipBitfield.findFirst(false, i);
            if (i < this._remoteContiguousLength && i > -1) return i;
            i = this._remoteContiguousLength;
          }
          return this.missingBlocks.findFirst(true, i);
        }
        _requestRange(r) {
          const { length, fork } = this.core.tree;
          if (r.blocks) {
            let min = -1;
            let max = -1;
            for (let i2 = r.start; i2 < r.end; i2++) {
              const index = r.blocks[i2];
              if (min === -1 || index < min) min = index;
              if (max === -1 || index > max) max = index;
              const has = index < this._remoteContiguousLength || this.missingBlocks.get(index) === true;
              if (has === true && this._requestRangeBlock(index, length)) return true;
            }
            if (min > -1) this._maybeWant(min, max - min);
            return false;
          }
          const end = Math.min(this.core.tree.length, Math.min(r.end === -1 ? this.remoteLength : r.end, this.remoteLength));
          if (end <= r.start || fork !== this.remoteFork) return false;
          const len = end - r.start;
          const off = r.start + (r.linear ? 0 : Math.floor(Math.random() * len));
          let i = off;
          while (true) {
            i = this._findNext(i);
            if (i === -1 || i >= end) break;
            if (this._requestRangeBlock(i, length)) return true;
            i++;
          }
          i = r.start;
          while (true) {
            i = this._findNext(i);
            if (i === -1 || i >= off) break;
            if (this._requestRangeBlock(i, length)) return true;
            i++;
          }
          this._maybeWant(r.start, len);
          return false;
        }
        _requestForkProof(f) {
          const req = this._makeRequest(false, 0, 0);
          req.upgrade = { start: 0, length: this.remoteLength };
          req.manifest = !this.core.header.manifest;
          f.inflight.push(req);
          this._send(req);
        }
        _requestForkRange(f) {
          if (f.fork !== this.remoteFork || f.batch.want === null) return false;
          const end = Math.min(f.batch.want.end, this.remoteLength);
          if (end < f.batch.want.start) return false;
          const len = end - f.batch.want.start;
          const off = f.batch.want.start + Math.floor(Math.random() * len);
          for (let i = 0; i < len; i++) {
            let index = off + i;
            if (index >= end) index -= len;
            if (this._remoteHasBlock(index) === false) continue;
            const req = this._makeRequest(false, 0, 0);
            req.hash = { index: 2 * index, nodes: f.batch.want.nodes };
            f.inflight.push(req);
            this._send(req);
            return true;
          }
          this._maybeWant(f.batch.want.start, len);
          return false;
        }
        _maybeWant(start, length = 1) {
          if (start + length <= this.remoteContiguousLength) return;
          let i = Math.floor(start / DEFAULT_SEGMENT_SIZE);
          const n = Math.ceil((start + length) / DEFAULT_SEGMENT_SIZE);
          for (; i < n; i++) {
            if (this.segmentsWanted.has(i)) continue;
            this.segmentsWanted.add(i);
            this.wireWant.send({
              start: i * DEFAULT_SEGMENT_SIZE,
              length: DEFAULT_SEGMENT_SIZE
            });
            incrementTx(this.stats.wireWant, this.replicator.stats.wireWant);
          }
        }
        isActive() {
          if (this.paused || this.removed) return false;
          return true;
        }
        async _send(req) {
          const fork = this.core.tree.fork;
          this.inflight++;
          this.replicator._inflight.add(req);
          if (req.upgrade !== null && req.fork === fork) {
            const u = this.replicator._addUpgrade();
            u.inflight.push(req);
          }
          try {
            if (req.block !== null && req.fork === fork) {
              req.block.nodes = await this.core.tree.missingNodes(2 * req.block.index);
              if (req.priority === PRIORITY.CANCELLED) return;
            }
            if (req.hash !== null && req.fork === fork && req.hash.nodes === 0) {
              req.hash.nodes = await this.core.tree.missingNodes(req.hash.index);
              if (req.priority === PRIORITY.CANCELLED) return;
              if (req.hash.nodes === 0 && (req.hash.index & 1) === 0) {
                this.inflight--;
                this.replicator._resolveHashLocally(this, req);
                return;
              }
            }
          } catch (err) {
            this.stream.destroy(err);
            return;
          }
          this.wireRequest.send(req);
          incrementTx(this.stats.wireRequest, this.replicator.stats.wireRequest);
        }
      };
      module.exports = class Replicator {
        static Peer = Peer;
        // Bridge: access Peer from outside this module
        constructor(core, key, {
          notDownloadingLinger = NOT_DOWNLOADING_SLACK,
          eagerUpgrade = true,
          allowFork = true,
          inflightRange = null,
          onpeerupdate = noop,
          onupload = noop,
          oninvalid = noop
        } = {}) {
          this.key = key;
          this.discoveryKey = core.crypto.discoveryKey(key);
          this.core = core;
          this.eagerUpgrade = eagerUpgrade;
          this.allowFork = allowFork;
          this.onpeerupdate = onpeerupdate;
          this.onupload = onupload;
          this.oninvalid = oninvalid;
          this.ondownloading = null;
          this.peers = [];
          this.findingPeers = 0;
          this.destroyed = false;
          this.downloading = false;
          this.activeSessions = 0;
          this.hotswaps = new HotswapQueue();
          this.inflightRange = inflightRange || DEFAULT_MAX_INFLIGHT;
          this.stats = {
            wireSync: { tx: 0, rx: 0 },
            wireRequest: { tx: 0, rx: 0 },
            wireCancel: { tx: 0, rx: 0 },
            wireData: { tx: 0, rx: 0 },
            wireWant: { tx: 0, rx: 0 },
            wireBitfield: { tx: 0, rx: 0 },
            wireRange: { tx: 0, rx: 0 },
            wireExtension: { tx: 0, rx: 0 },
            hotswaps: 0
          };
          this._attached = /* @__PURE__ */ new Set();
          this._inflight = new InflightTracker();
          this._blocks = new BlockTracker();
          this._hashes = new BlockTracker();
          this._queued = [];
          this._seeks = [];
          this._upgrade = null;
          this._reorgs = [];
          this._ranges = [];
          this._hadPeers = false;
          this._ifAvailable = 0;
          this._updatesPending = 0;
          this._applyingReorg = null;
          this._manifestPeer = null;
          this._hasSession = false;
          this._peerSessions = 0;
          this._notDownloadingLinger = notDownloadingLinger;
          this._downloadingTimer = null;
          const self2 = this;
          this._onstreamclose = onstreamclose;
          function onstreamclose() {
            self2.detachFrom(this.userData);
          }
        }
        updateActivity(inc, session) {
          this.activeSessions += inc;
          this.setDownloading(this.activeSessions !== 0, session);
        }
        isDownloading() {
          return this.downloading || !this._inflight.idle;
        }
        setDownloading(downloading) {
          clearTimeout(this._downloadingTimer);
          if (this.destroyed) return;
          if (downloading || this._notDownloadingLinger === 0) {
            this.setDownloadingNow(downloading);
            return;
          }
          this._downloadingTimer = setTimeout(setDownloadingLater, this._notDownloadingLinger, this, downloading);
        }
        setDownloadingNow(downloading) {
          this._downloadingTimer = null;
          if (this.downloading === downloading) return;
          this.downloading = downloading;
          if (!downloading && this.isDownloading()) return;
          for (const peer of this.peers) peer.signalUpgrade();
          if (downloading) {
            for (const protomux of this._attached) {
              if (!protomux.stream.handshakeHash) continue;
              if (protomux.opened({ protocol: "hypercore/alpha", id: this.discoveryKey })) continue;
              this._makePeer(protomux, true);
            }
          } else {
            for (const peer of this.peers) peer.closeIfIdle();
          }
          if (this.ondownloading !== null && downloading) this.ondownloading();
        }
        cork() {
          for (const peer of this.peers) peer.protomux.cork();
        }
        uncork() {
          for (const peer of this.peers) peer.protomux.uncork();
        }
        // Called externally when a range of new blocks has been processed/removed
        onhave(start, length, drop = false) {
          for (const peer of this.peers) peer.broadcastRange(start, length, drop);
        }
        // Called externally when a truncation upgrade has been processed
        ontruncate(newLength, truncated) {
          const notify = [];
          for (const blk of this._blocks) {
            if (blk.index < newLength) continue;
            notify.push(blk);
          }
          for (const blk of notify) {
            for (const r of blk.refs) {
              if (r.snapshot === false) continue;
              blk.detach(r, SNAPSHOT_NOT_AVAILABLE());
            }
          }
          for (const peer of this.peers) peer._unclearLocalRange(newLength, truncated);
        }
        // Called externally when a upgrade has been processed
        onupgrade() {
          for (const peer of this.peers) peer.signalUpgrade();
          if (this._blocks.isEmpty() === false) this._resolveBlocksLocally();
          if (this._upgrade !== null) this._resolveUpgradeRequest(null);
          if (this._ranges.length !== 0 || this._seeks.length !== 0) this._updateNonPrimary(true);
        }
        // Called externally when a conflict has been detected and verified
        async onconflict(from) {
          const all = [];
          for (const peer of this.peers) {
            all.push(peer._onconflict());
          }
          await Promise.allSettled(all);
        }
        async applyPendingReorg() {
          if (this._applyingReorg !== null) {
            await this._applyingReorg;
            return true;
          }
          for (let i = this._reorgs.length - 1; i >= 0; i--) {
            const f = this._reorgs[i];
            if (f.batch !== null && f.batch.finished) {
              await this._applyReorg(f);
              return true;
            }
          }
          return false;
        }
        addUpgrade(session) {
          if (this._upgrade !== null) {
            const ref2 = this._upgrade.attach(session);
            this._checkUpgradeIfAvailable();
            return ref2;
          }
          const ref = this._addUpgrade().attach(session);
          this.updateAll();
          return ref;
        }
        addBlock(session, index) {
          const b = this._blocks.add(index, PRIORITY.HIGH);
          const ref = b.attach(session);
          this._queueBlock(b);
          this.updateAll();
          return ref;
        }
        addSeek(session, seeker) {
          const s = new SeekRequest(this._seeks, seeker);
          const ref = s.attach(session);
          this._seeks.push(s);
          this.updateAll();
          return ref;
        }
        addRange(session, { start = 0, end = -1, length = toLength(start, end), blocks = null, linear = false, ifAvailable = false } = {}) {
          if (blocks !== null) {
            start = 0;
            end = length = blocks.length;
          }
          const r = new RangeRequest(
            this._ranges,
            start,
            length === -1 ? -1 : start + length,
            linear,
            ifAvailable,
            blocks
          );
          const ref = r.attach(session);
          clampRange(this.core, r);
          this._ranges.push(r);
          if (r.end !== -1 && r.start >= r.end) {
            this._resolveRangeRequest(r, this._ranges.length - 1);
            return ref;
          }
          this.updateAll();
          return ref;
        }
        cancel(ref) {
          ref.context.detach(ref, null);
        }
        clearRequests(session, err = null) {
          let cleared = false;
          while (session.length > 0) {
            const ref = session[session.length - 1];
            ref.context.detach(ref, err);
            cleared = true;
          }
          if (cleared) this.updateAll();
        }
        _addUpgradeMaybe() {
          return this.eagerUpgrade === true ? this._addUpgrade() : this._upgrade;
        }
        // NOTE: this function is OVER called atm, at each updatePeer/updateAll
        // instead its more efficient to only call it when the conditions in here change - ie on sync/add/remove peer
        // Do this when we have more tests.
        _checkUpgradeIfAvailable() {
          if (this._ifAvailable > 0 && this.peers.length < MAX_PEERS_UPGRADE) return;
          if (this._upgrade === null || this._upgrade.refs.length === 0) return;
          if (this._hadPeers === false && this.findingPeers > 0) return;
          const maxPeers = Math.min(this.peers.length, MAX_PEERS_UPGRADE);
          for (let i = 0; i < maxPeers; i++) {
            const peer = this.peers[i];
            if (peer.remoteSynced === false) return;
            if (this.core.tree.length === 0 && peer.remoteLength > 0) return;
            if (peer.remoteLength <= this._upgrade.length || peer.remoteFork !== this._upgrade.fork) continue;
            if (peer.syncsProcessing > 0) return;
            if (peer.lengthAcked !== this.core.tree.length && peer.remoteFork === this.core.tree.fork) return;
            if (peer.remoteCanUpgrade === true) return;
          }
          if (this._applyingReorg !== null) return;
          for (let i = 0; i < this._reorgs.length; i++) {
            const r = this._reorgs[i];
            if (r.inflight.length > 0) return;
          }
          if (this._upgrade.inflight.length > 0) return;
          const u = this._upgrade;
          this._upgrade = null;
          u.resolve(false);
        }
        _addUpgrade() {
          if (this._upgrade !== null) return this._upgrade;
          this._upgrade = new UpgradeRequest(this, this.core.tree.fork, this.core.tree.length);
          return this._upgrade;
        }
        _addReorg(fork, peer) {
          if (this.allowFork === false) return null;
          for (const f2 of this._reorgs) {
            if (f2.fork > fork && f2.batch !== null) return null;
            if (f2.fork === fork) return f2;
          }
          const f = {
            fork,
            inflight: [],
            batch: null
          };
          this._reorgs.push(f);
          let i = this._reorgs.length - 1;
          while (i > 0 && this._reorgs[i - 1].fork > fork) {
            this._reorgs[i] = this._reorgs[i - 1];
            this._reorgs[--i] = f;
          }
          return f;
        }
        _shouldUpgrade(peer) {
          if (this._upgrade !== null && this._upgrade.inflight.length > 0) return false;
          return peer.remoteCanUpgrade === true && peer.remoteLength > this.core.tree.length && peer.lengthAcked === this.core.tree.length;
        }
        _autoUpgrade(peer) {
          return this._upgrade !== null && peer.remoteFork === this.core.tree.fork && this._shouldUpgrade(peer);
        }
        _addPeer(peer) {
          this._hadPeers = true;
          this.peers.push(peer);
          this.updatePeer(peer);
          this.onpeerupdate(true, peer);
        }
        _requestDone(id, roundtrip) {
          this._inflight.remove(id, roundtrip);
          if (this.isDownloading() === true) return;
          for (const peer of this.peers) peer.signalUpgrade();
        }
        _removePeer(peer) {
          this.peers.splice(this.peers.indexOf(peer), 1);
          if (this._manifestPeer === peer) this._manifestPeer = null;
          for (const req of this._inflight) {
            if (req.peer !== peer) continue;
            this._inflight.remove(req.id, true);
            this._clearRequest(peer, req);
          }
          if (peer.useSession) this._closeSessionMaybe();
          this.onpeerupdate(false, peer);
          this.updateAll();
        }
        _queueBlock(b) {
          if (b.inflight.length > 0 || b.queued === true) return;
          b.queued = true;
          this._queued.push(b);
        }
        _resolveHashLocally(peer, req) {
          this._requestDone(req.id, false);
          this._resolveBlockRequest(this._hashes, req.hash.index / 2, null, req);
          this.updatePeer(peer);
        }
        // Runs in the background - not allowed to throw
        async _resolveBlocksLocally() {
          let clear = null;
          for (const b of this._blocks) {
            if (this.core.bitfield.get(b.index) === false) continue;
            try {
              b.resolve(await this.core.blocks.get(b.index));
            } catch (err) {
              b.reject(err);
            }
            if (clear === null) clear = [];
            clear.push(b);
          }
          if (clear === null) return;
          for (const b of clear) {
            this._blocks.remove(b.index);
            removeHotswap(b);
          }
        }
        _resolveBlockRequest(tracker, index, value, req) {
          const b = tracker.remove(index);
          if (b === null) return false;
          removeInflight(b.inflight, req);
          removeHotswap(b);
          b.queued = false;
          b.resolve(value);
          if (b.inflight.length > 0) {
            for (let i = b.inflight.length - 1; i >= 0; i--) {
              const req2 = b.inflight[i];
              req2.peer._cancelRequest(req2);
            }
          }
          return true;
        }
        _resolveUpgradeRequest(req) {
          if (req !== null) removeInflight(this._upgrade.inflight, req);
          if (this.core.tree.length === this._upgrade.length && this.core.tree.fork === this._upgrade.fork) return false;
          const u = this._upgrade;
          this._upgrade = null;
          u.resolve(true);
          return true;
        }
        _resolveRangeRequest(req, index) {
          const head = this._ranges.pop();
          if (index < this._ranges.length) this._ranges[index] = head;
          req.resolve(true);
        }
        _clearInflightBlock(tracker, req) {
          const isBlock = tracker === this._blocks;
          const index = isBlock === true ? req.block.index : req.hash.index / 2;
          const b = tracker.get(index);
          if (b === null || removeInflight(b.inflight, req) === false) return;
          if (removeHotswap(b) === true && b.inflight.length > 0) {
            this.hotswaps.add(b);
          }
          if (b.refs.length > 0 && isBlock === true) {
            this._queueBlock(b);
            return;
          }
          b.gc();
        }
        _clearInflightUpgrade(req) {
          if (removeInflight(this._upgrade.inflight, req) === false) return;
          this._upgrade.gc();
        }
        _clearInflightSeeks(req) {
          for (const s of this._seeks) {
            if (removeInflight(s.inflight, req) === false) continue;
            s.gc();
          }
        }
        _clearInflightReorgs(req) {
          for (const r of this._reorgs) {
            removeInflight(r.inflight, req);
          }
        }
        _clearOldReorgs(fork) {
          for (let i = 0; i < this._reorgs.length; i++) {
            const f = this._reorgs[i];
            if (f.fork >= fork) continue;
            if (i === this._reorgs.length - 1) this._reorgs.pop();
            else this._reorgs[i] = this._reorgs.pop();
            i--;
          }
        }
        // "slow" updates here - async but not allowed to ever throw
        async _updateNonPrimary(updateAll) {
          while (++this._updatesPending === 1) {
            let len = Math.min(MAX_RANGES, this._ranges.length);
            for (let i = 0; i < len; i++) {
              const r = this._ranges[i];
              clampRange(this.core, r);
              if (r.end !== -1 && r.start >= r.end) {
                this._resolveRangeRequest(r, i--);
                if (len > this._ranges.length) len--;
                if (this._ranges.length === MAX_RANGES) updateAll = true;
              }
            }
            for (let i = 0; i < this._seeks.length; i++) {
              const s = this._seeks[i];
              let err = null;
              let res = null;
              try {
                res = await s.seeker.update();
              } catch (error) {
                err = error;
              }
              if (!res && !err) continue;
              if (i < this._seeks.length - 1) this._seeks[i] = this._seeks.pop();
              else this._seeks.pop();
              i--;
              if (err) s.reject(err);
              else s.resolve(res);
            }
            if (--this._updatesPending === 0) break;
            this._updatesPending = 0;
          }
          if (this._inflight.idle || updateAll) this.updateAll();
        }
        _maybeResolveIfAvailableRanges() {
          if (this._ifAvailable > 0 || !this._inflight.idle || !this._ranges.length) return;
          for (let i = 0; i < this.peers.length; i++) {
            if (this.peers[i].dataProcessing > 0) return;
          }
          for (let i = 0; i < this._ranges.length; i++) {
            const r = this._ranges[i];
            if (r.ifAvailable) {
              this._resolveRangeRequest(r, i--);
            }
          }
        }
        _clearRequest(peer, req) {
          if (req.block !== null) {
            this._clearInflightBlock(this._blocks, req);
            this._unmarkInflight(req.block.index);
          }
          if (req.hash !== null) {
            this._clearInflightBlock(this._hashes, req);
          }
          if (req.upgrade !== null && this._upgrade !== null) {
            this._clearInflightUpgrade(req);
          }
          if (this._seeks.length > 0) {
            this._clearInflightSeeks(req);
          }
          if (this._reorgs.length > 0) {
            this._clearInflightReorgs(req);
          }
        }
        _onnodata(peer, req) {
          this._clearRequest(peer, req);
          this.updateAll();
        }
        _openSkipBitfield() {
          const bitfield = this.core.openSkipBitfield();
          for (const req of this._inflight) {
            if (req.block) bitfield.set(req.block.index, true);
          }
        }
        _markInflight(index) {
          if (this.core.skipBitfield !== null) this.core.skipBitfield.set(index, true);
          for (const peer of this.peers) peer._markInflight(index);
        }
        _unmarkInflight(index) {
          if (this.core.skipBitfield !== null) this.core.skipBitfield.set(index, this.core.bitfield.get(index));
          for (const peer of this.peers) peer._resetMissingBlock(index);
        }
        _ondata(peer, req, data) {
          if (data.block !== null) {
            this._resolveBlockRequest(this._blocks, data.block.index, data.block.value, req);
          }
          if (data.hash !== null && (data.hash.index & 1) === 0) {
            this._resolveBlockRequest(this._hashes, data.hash.index / 2, null, req);
          }
          if (this._upgrade !== null) {
            this._resolveUpgradeRequest(req);
          }
          if (this._seeks.length > 0) {
            this._clearInflightSeeks(req);
          }
          if (this._reorgs.length > 0) {
            this._clearInflightReorgs(req);
          }
          if (this._manifestPeer === peer && this.core.header.manifest !== null) {
            this._manifestPeer = null;
          }
          if (this._seeks.length > 0 || this._ranges.length > 0) this._updateNonPrimary(this._seeks.length > 0);
          this.updatePeer(peer);
        }
        _onwant(peer, start, length) {
          const contig = Math.min(this.core.tree.length, this.core.header.hints.contiguousLength);
          if (start + length < contig || this.core.tree.length === contig) {
            peer.wireRange.send({
              drop: false,
              start: 0,
              length: contig
            });
            incrementTx(peer.stats.wireRange, this.stats.wireRange);
            return;
          }
          length = Math.min(length, this.core.tree.length - start);
          peer.protomux.cork();
          for (const msg of this.core.bitfield.want(start, length)) {
            peer.wireBitfield.send(msg);
            incrementTx(peer.stats.wireBitfield, this.stats.wireBitfield);
          }
          peer.protomux.uncork();
        }
        async _onreorgdata(peer, req, data) {
          const newBatch = data.upgrade && await this.core.verifyReorg(data);
          const f = this._addReorg(data.fork, peer);
          if (f === null) {
            this.updateAll();
            return;
          }
          removeInflight(f.inflight, req);
          if (f.batch) {
            await f.batch.update(data);
          } else if (data.upgrade) {
            f.batch = newBatch;
            this._clearOldReorgs(f.fork);
          }
          if (f.batch && f.batch.finished) {
            if (this._addUpgradeMaybe() !== null) {
              await this._applyReorg(f);
            }
          }
          this.updateAll();
        }
        // Never throws, allowed to run in the background
        async _applyReorg(f) {
          const u = this._upgrade;
          this._reorgs = [];
          this._applyingReorg = this.core.reorg(f.batch, null);
          try {
            await this._applyingReorg;
          } catch (err) {
            this._upgrade = null;
            u.reject(err);
          }
          this._applyingReorg = null;
          if (this._upgrade !== null) {
            this._resolveUpgradeRequest(null);
          }
          for (const peer of this.peers) this._updateFork(peer);
          for (const r of this._ranges) {
            r.start = r.userStart;
            r.end = r.userEnd;
          }
          this.updateAll();
        }
        _maybeUpdate() {
          return this._upgrade !== null && this._upgrade.inflight.length === 0;
        }
        _maybeRequestManifest() {
          return this.core.header.manifest === null && this._manifestPeer === null;
        }
        _updateFork(peer) {
          if (this._applyingReorg !== null || this.allowFork === false || peer.remoteFork <= this.core.tree.fork) {
            return false;
          }
          const f = this._addReorg(peer.remoteFork, peer);
          if (f !== null && f.batch === null && f.inflight.length === 0) {
            return peer._requestForkProof(f);
          }
          return false;
        }
        _updateHotswap(peer) {
          const maxHotswaps = peer.getMaxHotswapInflight();
          if (!peer.isActive() || peer.inflight >= maxHotswaps) return;
          for (const b of this.hotswaps.pick(peer)) {
            if (peer._requestBlock(b) === false) continue;
            peer.stats.hotswaps++;
            peer.replicator.stats.hotswaps++;
            if (peer.inflight >= maxHotswaps) break;
          }
        }
        _updatePeer(peer) {
          if (!peer.isActive() || peer.inflight >= peer.getMaxInflight()) {
            return false;
          }
          if (this._maybeRequestManifest() === true && peer.remoteLength === 0 && peer.remoteHasManifest === true) {
            this._manifestPeer = peer;
            peer._requestManifest();
          }
          for (const s of this._seeks) {
            if (s.inflight.length > 0) continue;
            if (peer._requestSeek(s) === true) {
              return true;
            }
          }
          const blks = new RandomIterator(this._queued);
          for (const b of blks) {
            if (b.queued === false || peer._requestBlock(b) === true) {
              b.queued = false;
              blks.dequeue();
              return true;
            }
          }
          return false;
        }
        _updatePeerNonPrimary(peer) {
          if (!peer.isActive() || peer.inflight >= peer.getMaxInflight()) {
            return false;
          }
          const ranges = new RandomIterator(this._ranges);
          let tried = 0;
          for (const r of ranges) {
            if (peer._requestRange(r) === true) {
              return true;
            }
            if (++tried >= MAX_RANGES) break;
          }
          for (let i = this._reorgs.length - 1; i >= 0; i--) {
            const f = this._reorgs[i];
            if (f.batch !== null && f.inflight.length === 0 && peer._requestForkRange(f) === true) {
              return true;
            }
          }
          if (this._maybeUpdate() === true && peer._requestUpgrade(this._upgrade) === true) {
            return true;
          }
          return false;
        }
        updatePeer(peer) {
          if (this._applyingReorg !== null) return;
          while (this._updatePeer(peer) === true) ;
          while (this._updatePeerNonPrimary(peer) === true) ;
          if (this.peers.length > 1 && this._blocks.isEmpty() === false) {
            this._updateHotswap(peer);
          }
          this._checkUpgradeIfAvailable();
          this._maybeResolveIfAvailableRanges();
        }
        updateAll() {
          if (this._applyingReorg !== null) return;
          const peers = new RandomIterator(this.peers);
          for (const peer of peers) {
            if (this._updatePeer(peer) === true) {
              peers.requeue();
            }
          }
          if (this._maybeUpdate() === false && this._ranges.length === 0 && this._reorgs.length === 0) {
            this._checkUpgradeIfAvailable();
            return;
          }
          for (const peer of peers.restart()) {
            if (this._updatePeerNonPrimary(peer) === true) {
              peers.requeue();
            }
          }
          this._checkUpgradeIfAvailable();
          this._maybeResolveIfAvailableRanges();
        }
        _closeSessionMaybe() {
          if (this._hasSession && this._peerSessions === 0) {
            this._hasSession = false;
            this.core.active--;
          }
          if (this.core.active === 0 && this.core.sessions.length === 0) {
            this.destroy();
            this.core.close().catch(safetyCatch);
            return;
          }
          if (this.core.sessions.length === 1 && this.core.active === 1 && this.core.sessions[0].autoClose) {
            this.core.sessions[0].close().catch(safetyCatch);
          }
        }
        attached(protomux) {
          return this._attached.has(protomux);
        }
        ensureSession() {
          if (this._hasSession) return;
          this._hasSession = true;
          this.core.active++;
        }
        attachTo(protomux, useSession) {
          if (this.core.closed) return;
          if (useSession) this.ensureSession();
          const makePeer = this._makePeer.bind(this, protomux, useSession);
          this._attached.add(protomux);
          protomux.pair({ protocol: "hypercore/alpha", id: this.discoveryKey }, makePeer);
          protomux.stream.setMaxListeners(0);
          protomux.stream.on("close", this._onstreamclose);
          if (useSession) this._peerSessions++;
          this._ifAvailable++;
          protomux.stream.opened.then((opened) => {
            if (useSession) this._peerSessions--;
            this._ifAvailable--;
            if (opened && !this.destroyed) makePeer();
            else if (useSession) this._closeSessionMaybe();
            this._checkUpgradeIfAvailable();
          });
        }
        detachFrom(protomux) {
          if (this._attached.delete(protomux)) {
            protomux.stream.removeListener("close", this._onstreamclose);
            protomux.unpair({ protocol: "hypercore/alpha", id: this.discoveryKey });
          }
        }
        destroy() {
          this.destroyed = true;
          if (this._downloadingTimer) {
            clearTimeout(this._downloadingTimer);
            this._downloadingTimer = null;
          }
          const waiting = [];
          while (this.peers.length) {
            const peer = this.peers[this.peers.length - 1];
            this.detachFrom(peer.protomux);
            peer.channel.close();
            waiting.push(peer.channel.fullyClosed());
          }
          for (const protomux of this._attached) {
            this.detachFrom(protomux);
          }
          return Promise.all(waiting);
        }
        _makePeer(protomux, useSession) {
          const replicator = this;
          if (protomux.opened({ protocol: "hypercore/alpha", id: this.discoveryKey })) return onnochannel();
          const channel = protomux.createChannel({
            userData: null,
            protocol: "hypercore/alpha",
            aliases: ["hypercore"],
            id: this.discoveryKey,
            handshake: m.wire.handshake,
            messages: [
              { encoding: m.wire.sync, onmessage: onwiresync },
              { encoding: m.wire.request, onmessage: onwirerequest },
              { encoding: m.wire.cancel, onmessage: onwirecancel },
              { encoding: m.wire.data, onmessage: onwiredata },
              { encoding: m.wire.noData, onmessage: onwirenodata },
              { encoding: m.wire.want, onmessage: onwirewant },
              { encoding: m.wire.unwant, onmessage: onwireunwant },
              { encoding: m.wire.bitfield, onmessage: onwirebitfield },
              { encoding: m.wire.range, onmessage: onwirerange },
              { encoding: m.wire.extension, onmessage: onwireextension }
            ],
            onopen: onwireopen,
            onclose: onwireclose,
            ondrain: onwiredrain
          });
          if (channel === null) return onnochannel();
          const peer = new Peer(replicator, protomux, channel, useSession, this.inflightRange);
          const stream = protomux.stream;
          if (useSession) {
            replicator.ensureSession();
            replicator._peerSessions++;
          }
          peer.channel.open({
            seeks: true,
            capability: caps.replicate(stream.isInitiator, this.key, stream.handshakeHash)
          });
          return true;
          function onnochannel() {
            if (useSession) replicator._closeSessionMaybe();
            return false;
          }
        }
      };
      function matchingRequest(req, data) {
        if (data.block !== null && (req.block === null || req.block.index !== data.block.index)) return false;
        if (data.hash !== null && (req.hash === null || req.hash.index !== data.hash.index)) return false;
        if (data.seek !== null && (req.seek === null || req.seek.bytes !== data.seek.bytes)) return false;
        if (data.upgrade !== null && req.upgrade === null) return false;
        return req.fork === data.fork;
      }
      function removeHotswap(block) {
        if (block.hotswap === null) return false;
        block.hotswap.ref.remove(block);
        return true;
      }
      function removeInflight(inf, req) {
        const i = inf.indexOf(req);
        if (i === -1) return false;
        if (i < inf.length - 1) inf[i] = inf.pop();
        else inf.pop();
        return true;
      }
      function noop() {
      }
      function toLength(start, end) {
        return end === -1 ? -1 : end < start ? 0 : end - start;
      }
      function clampRange(core, r) {
        if (r.blocks === null) {
          const start = core.bitfield.firstUnset(r.start);
          if (r.end === -1) r.start = start === -1 ? core.tree.length : start;
          else if (start === -1 || start >= r.end) r.start = r.end;
          else {
            r.start = start;
            const end = core.bitfield.lastUnset(r.end - 1);
            if (end === -1 || start >= end + 1) r.end = r.start;
            else r.end = end + 1;
          }
        } else {
          while (r.start < r.end && core.bitfield.get(r.blocks[r.start])) r.start++;
          while (r.start < r.end && core.bitfield.get(r.blocks[r.end - 1])) r.end--;
        }
      }
      function onrequesttimeout(req) {
        if (req.context) req.context.detach(req, REQUEST_TIMEOUT());
      }
      function destroyRequestTimeout(req) {
        if (req.timeout !== null) {
          clearTimeout(req.timeout);
          req.timeout = null;
        }
      }
      function isCriticalError(err) {
        return err.name === "HypercoreError";
      }
      function onwireopen(m2, c) {
        return c.userData.onopen(m2);
      }
      function onwireclose(isRemote, c) {
        return c.userData.onclose(isRemote);
      }
      function onwiredrain(c) {
        return c.userData.ondrain();
      }
      function onwiresync(m2, c) {
        incrementRx(c.userData.stats.wireSync, c.userData.replicator.stats.wireSync);
        return c.userData.onsync(m2);
      }
      function onwirerequest(m2, c) {
        incrementRx(c.userData.stats.wireRequest, c.userData.replicator.stats.wireRequest);
        return c.userData.onrequest(m2);
      }
      function onwirecancel(m2, c) {
        incrementRx(c.userData.stats.wireCancel, c.userData.replicator.stats.wireCancel);
        return c.userData.oncancel(m2);
      }
      function onwiredata(m2, c) {
        incrementRx(c.userData.stats.wireData, c.userData.replicator.stats.wireData);
        return c.userData.ondata(m2);
      }
      function onwirenodata(m2, c) {
        return c.userData.onnodata(m2);
      }
      function onwirewant(m2, c) {
        incrementRx(c.userData.stats.wireWant, c.userData.replicator.stats.wireWant);
        return c.userData.onwant(m2);
      }
      function onwireunwant(m2, c) {
        return c.userData.onunwant(m2);
      }
      function onwirebitfield(m2, c) {
        incrementRx(c.userData.stats.wireBitfield, c.userData.replicator.stats.wireBitfield);
        return c.userData.onbitfield(m2);
      }
      function onwirerange(m2, c) {
        incrementRx(c.userData.stats.wireRange, c.userData.replicator.stats.wireRange);
        return c.userData.onrange(m2);
      }
      function onwireextension(m2, c) {
        incrementRx(c.userData.stats.wireExtension, c.userData.replicator.stats.wireExtension);
        return c.userData.onextension(m2);
      }
      function setDownloadingLater(repl, downloading, session) {
        repl.setDownloadingNow(downloading, session);
      }
      function isBlockRequest(req) {
        return req !== null && req.block !== null;
      }
      function isUpgradeRequest(req) {
        return req !== null && req.upgrade !== null;
      }
      function incrementTx(stats1, stats2) {
        stats1.tx++;
        stats2.tx++;
      }
      function incrementRx(stats1, stats2) {
        stats1.rx++;
        stats2.rx++;
      }
    }
  });

  // ../../node_modules/crc-universal/lookup.js
  var require_lookup = __commonJS({
    "../../node_modules/crc-universal/lookup.js"(exports, module) {
      var lookup = new Array(16);
      for (let i = 0; i < 16; i++) {
        lookup[i] = new Uint32Array(256);
      }
      for (let i = 0; i <= 255; i++) {
        let crc = i;
        for (let j = 0; j < 8; j++) {
          crc = crc >>> 1 ^ (crc & 1) * 3988292384;
        }
        lookup[0][i] = crc;
      }
      for (let i = 0; i <= 255; i++) {
        for (let j = 1; j < 16; j++) {
          lookup[j][i] = lookup[j - 1][i] >>> 8 ^ lookup[0][lookup[j - 1][i] & 255];
        }
      }
      module.exports = lookup;
    }
  });

  // ../../node_modules/crc-universal/fallback.js
  var require_fallback3 = __commonJS({
    "../../node_modules/crc-universal/fallback.js"(exports) {
      var lookup = require_lookup();
      exports.crc32 = function crc32(buffer) {
        let crc = ~0;
        let i = 0;
        let length = buffer.byteLength;
        while (length >= 16) {
          crc = lookup[15][buffer[i++] ^ crc & 255] ^ lookup[14][buffer[i++] ^ crc >>> 8 & 255] ^ lookup[13][buffer[i++] ^ crc >>> 16 & 255] ^ lookup[12][buffer[i++] ^ crc >>> 24] ^ lookup[11][buffer[i++]] ^ lookup[10][buffer[i++]] ^ lookup[9][buffer[i++]] ^ lookup[8][buffer[i++]] ^ lookup[7][buffer[i++]] ^ lookup[6][buffer[i++]] ^ lookup[5][buffer[i++]] ^ lookup[4][buffer[i++]] ^ lookup[3][buffer[i++]] ^ lookup[2][buffer[i++]] ^ lookup[1][buffer[i++]] ^ lookup[0][buffer[i++]];
          length -= 16;
        }
        while (length-- > 0) {
          crc = crc >>> 8 ^ lookup[0][crc & 255 ^ buffer[i++]];
        }
        return ~crc >>> 0;
      };
    }
  });

  // ../../node_modules/crc-native/binding.js
  var require_binding12 = __commonJS({
    "../../node_modules/crc-native/binding.js"(exports, module) {
      __require.addon = require_node2();
      module.exports = __require.addon(".", __filename);
    }
  });

  // ../../node_modules/crc-native/index.js
  var require_crc_native = __commonJS({
    "../../node_modules/crc-native/index.js"(exports) {
      var binding = require_binding12();
      exports.crc32 = function crc32(buffer) {
        return binding.crc_u32_napi(buffer);
      };
    }
  });

  // ../../node_modules/crc-universal/index.js
  var require_crc_universal = __commonJS({
    "../../node_modules/crc-universal/index.js"(exports, module) {
      var fallback = require_fallback3();
      try {
        const native = require_crc_native();
        exports.crc32 = function crc32(buffer) {
          return buffer.byteLength <= 24 ? fallback.crc32(buffer) : native.crc32(buffer);
        };
      } catch {
        module.exports = fallback;
      }
    }
  });

  // ../../node_modules/bare-dev/node_modules/hypercore/lib/oplog.js
  var require_oplog = __commonJS({
    "../../node_modules/bare-dev/node_modules/hypercore/lib/oplog.js"(exports, module) {
      var cenc = require_compact_encoding();
      var b4a = require_b4a();
      var { crc32 } = require_crc_universal();
      var { OPLOG_CORRUPT, OPLOG_HEADER_OVERFLOW, WRITE_FAILED } = require_hypercore_errors();
      module.exports = class Oplog {
        constructor(storage, { pageSize = 4096, headerEncoding = cenc.raw, entryEncoding = cenc.raw, readonly = false } = {}) {
          this.storage = storage;
          this.headerEncoding = headerEncoding;
          this.entryEncoding = entryEncoding;
          this.readonly = readonly;
          this.flushed = false;
          this.byteLength = 0;
          this.length = 0;
          this._headers = [1, 0];
          this._pageSize = pageSize;
          this._entryOffset = pageSize * 2;
        }
        _addHeader(state, len, headerBit, partialBit) {
          state.start = state.start - len - 4;
          cenc.uint32.encode(state, len << 2 | headerBit | partialBit);
          state.start -= 8;
          cenc.uint32.encode(state, crc32(state.buffer.subarray(state.start + 4, state.start + 8 + len)));
          state.start += len + 4;
        }
        _decodeEntry(state, enc) {
          if (state.end - state.start < 8) return null;
          const cksum = cenc.uint32.decode(state);
          const l = cenc.uint32.decode(state);
          const length = l >>> 2;
          const headerBit = l & 1;
          const partialBit = l & 2;
          if (state.end - state.start < length) return null;
          const end = state.start + length;
          if (crc32(state.buffer.subarray(state.start - 4, end)) !== cksum) {
            return null;
          }
          const result = { header: headerBit, partial: partialBit !== 0, byteLength: length + 8, message: null };
          try {
            result.message = enc.decode({ start: state.start, end, buffer: state.buffer });
          } catch {
            return null;
          }
          state.start = end;
          return result;
        }
        async open() {
          const buffer = await this._readAll();
          const state = { start: 0, end: buffer.byteLength, buffer };
          const result = { header: null, entries: [] };
          this.byteLength = 0;
          this.length = 0;
          const h1 = this._decodeEntry(state, this.headerEncoding);
          state.start = this._pageSize;
          const h2 = this._decodeEntry(state, this.headerEncoding);
          state.start = this._entryOffset;
          if (!h1 && !h2) {
            this.flushed = false;
            this._headers[0] = 1;
            this._headers[1] = 0;
            if (buffer.byteLength >= this._entryOffset) {
              throw OPLOG_CORRUPT();
            }
            return result;
          }
          this.flushed = true;
          if (h1 && !h2) {
            this._headers[0] = h1.header;
            this._headers[1] = h1.header;
          } else if (!h1 && h2) {
            this._headers[0] = h2.header + 1 & 1;
            this._headers[1] = h2.header;
          } else {
            this._headers[0] = h1.header;
            this._headers[1] = h2.header;
          }
          const header = this._headers[0] + this._headers[1] & 1;
          const decoded = [];
          result.header = header ? h2.message : h1.message;
          while (true) {
            const entry = this._decodeEntry(state, this.entryEncoding);
            if (!entry) break;
            if (entry.header !== header) break;
            decoded.push(entry);
          }
          while (decoded.length > 0 && decoded[decoded.length - 1].partial) decoded.pop();
          for (const e of decoded) {
            result.entries.push(e.message);
            this.byteLength += e.byteLength;
            this.length++;
          }
          const size = this.byteLength + this._entryOffset;
          if (size === buffer.byteLength) return result;
          await new Promise((resolve, reject) => {
            if (this.readonly) return resolve();
            this.storage.truncate(size, (err) => {
              if (err) return reject(err);
              resolve();
            });
          });
          return result;
        }
        _readAll() {
          return new Promise((resolve, reject) => {
            this.storage.open((err) => {
              if (err && err.code !== "ENOENT") return reject(err);
              if (err) return resolve(b4a.alloc(0));
              this.storage.stat((err2, stat) => {
                if (err2 && err2.code !== "ENOENT") return reject(err2);
                this.storage.read(0, stat.size, (err3, buf) => {
                  if (err3) return reject(err3);
                  resolve(buf);
                });
              });
            });
          });
        }
        flush(header) {
          const state = { start: 8, end: 8, buffer: null };
          const i = this._headers[0] === this._headers[1] ? 1 : 0;
          const bit = this._headers[i] + 1 & 1;
          this.headerEncoding.preencode(state, header);
          if (state.end > this._pageSize) throw OPLOG_HEADER_OVERFLOW();
          state.buffer = b4a.allocUnsafe(state.end);
          this.headerEncoding.encode(state, header);
          this._addHeader(state, state.end - 8, bit, 0);
          return this._writeHeaderAndTruncate(i, bit, state.buffer);
        }
        _writeHeaderAndTruncate(i, bit, buf) {
          return new Promise((resolve, reject) => {
            this.storage.write(i === 0 ? 0 : this._pageSize, buf, (err) => {
              if (err) return reject(err);
              this.storage.truncate(this._entryOffset, (err2) => {
                if (err2) return reject(err2);
                this._headers[i] = bit;
                this.byteLength = 0;
                this.length = 0;
                this.flushed = true;
                resolve();
              });
            });
          });
        }
        append(batch, atomic = true) {
          if (!Array.isArray(batch)) batch = [batch];
          const state = { start: 0, end: batch.length * 8, buffer: null };
          const bit = this._headers[0] + this._headers[1] & 1;
          for (let i = 0; i < batch.length; i++) {
            this.entryEncoding.preencode(state, batch[i]);
          }
          state.buffer = b4a.allocUnsafe(state.end);
          for (let i = 0; i < batch.length; i++) {
            const start = state.start += 8;
            const partial = atomic && i < batch.length - 1 ? 2 : 0;
            this.entryEncoding.encode(state, batch[i]);
            this._addHeader(state, state.start - start, bit, partial);
          }
          return this._append(state.buffer, batch.length);
        }
        close() {
          return new Promise((resolve, reject) => {
            this.storage.close((err) => {
              if (err) return reject(err);
              resolve();
            });
          });
        }
        _append(buf, count) {
          return new Promise((resolve, reject) => {
            this.storage.write(this._entryOffset + this.byteLength, buf, (err) => {
              if (err) return reject(WRITE_FAILED(err.message));
              this.byteLength += buf.byteLength;
              this.length += count;
              resolve();
            });
          });
        }
      };
    }
  });

  // ../../node_modules/bare-dev/node_modules/hypercore/lib/big-header.js
  var require_big_header = __commonJS({
    "../../node_modules/bare-dev/node_modules/hypercore/lib/big-header.js"(exports, module) {
      var c = require_compact_encoding();
      var { oplog } = require_messages2();
      module.exports = class BigHeader {
        constructor(storage) {
          this.storage = storage;
        }
        async load(external) {
          const buf = await new Promise((resolve, reject) => {
            this.storage.read(external.start, external.length, (err, buf2) => {
              if (err) return reject(err);
              resolve(buf2);
            });
          });
          const header = c.decode(oplog.header, buf);
          header.external = external;
          return header;
        }
        async flush(header) {
          const external = header.external || { start: 0, length: 0 };
          header.external = null;
          const buf = c.encode(oplog.header, header);
          let start = 0;
          if (buf.byteLength > external.start) {
            start = external.start + external.length;
            const rem = start & 4095;
            if (rem > 0) start += 4096 - rem;
          }
          header.external = { start, length: buf.byteLength };
          await new Promise((resolve, reject) => {
            this.storage.write(start, buf, (err) => {
              if (err) return reject(err);
              resolve();
            });
          });
          return header;
        }
        close() {
          return new Promise((resolve, reject) => {
            this.storage.close((err) => {
              if (err) return reject(err);
              resolve();
            });
          });
        }
      };
    }
  });

  // ../../node_modules/bare-dev/node_modules/hypercore/lib/mutex.js
  var require_mutex = __commonJS({
    "../../node_modules/bare-dev/node_modules/hypercore/lib/mutex.js"(exports, module) {
      module.exports = class Mutex {
        constructor() {
          this.locked = false;
          this.destroyed = false;
          this._destroying = null;
          this._destroyError = null;
          this._queue = [];
          this._enqueue = (resolve, reject) => this._queue.push([resolve, reject]);
        }
        lock() {
          if (this.destroyed) return Promise.reject(this._destroyError || new Error("Mutex has been destroyed"));
          if (this.locked) return new Promise(this._enqueue);
          this.locked = true;
          return Promise.resolve();
        }
        unlock() {
          if (!this._queue.length) {
            this.locked = false;
            return;
          }
          this._queue.shift()[0]();
        }
        destroy(err) {
          if (!this._destroying) this._destroying = this.locked ? this.lock().catch(() => {
          }) : Promise.resolve();
          this.destroyed = true;
          if (err) this._destroyError = err;
          if (err) {
            while (this._queue.length) this._queue.shift()[1](err);
          }
          return this._destroying;
        }
      };
    }
  });

  // ../../node_modules/bare-dev/node_modules/hypercore/lib/merkle-tree.js
  var require_merkle_tree = __commonJS({
    "../../node_modules/bare-dev/node_modules/hypercore/lib/merkle-tree.js"(exports, module) {
      var flat = require_flat_tree();
      var crypto = require_hypercore_crypto();
      var c = require_compact_encoding();
      var Xache = require_xache();
      var b4a = require_b4a();
      var unslab = require_unslab();
      var caps = require_caps();
      var { INVALID_PROOF, INVALID_CHECKSUM, INVALID_OPERATION, BAD_ARGUMENT, ASSERTION } = require_hypercore_errors();
      var BLANK_HASH = b4a.alloc(32);
      var OLD_TREE = b4a.from([5, 2, 87, 2, 0, 0, 40, 7, 66, 76, 65, 75, 69, 50, 98]);
      var TREE_CACHE = 128;
      var NodeQueue = class {
        constructor(nodes, extra = null) {
          this.i = 0;
          this.nodes = nodes;
          this.extra = extra;
          this.length = nodes.length + (this.extra === null ? 0 : 1);
        }
        shift(index) {
          if (this.extra !== null && this.extra.index === index) {
            const node2 = this.extra;
            this.extra = null;
            this.length--;
            return node2;
          }
          if (this.i >= this.nodes.length) {
            throw INVALID_OPERATION("Expected node " + index + ", got (nil)");
          }
          const node = this.nodes[this.i++];
          if (node.index !== index) {
            throw INVALID_OPERATION("Expected node " + index + ", got node " + node.index);
          }
          this.length--;
          return node;
        }
      };
      var MerkleTreeBatch = class _MerkleTreeBatch {
        constructor(tree) {
          this.fork = tree.fork;
          this.roots = [...tree.roots];
          this.length = tree.length;
          this.ancestors = tree.length;
          this.byteLength = tree.byteLength;
          this.signature = null;
          this.hashCached = null;
          this.treeLength = tree.length;
          this.treeFork = tree.fork;
          this.tree = tree;
          this.nodes = [];
          this.upgraded = false;
        }
        checkout(length, additionalRoots) {
          const roots = [];
          let r = 0;
          const head = 2 * length - 2;
          const gaps = /* @__PURE__ */ new Set();
          const all = /* @__PURE__ */ new Map();
          if (additionalRoots) {
            for (const node of additionalRoots) all.set(node.index, node);
          }
          for (const node of this.nodes) all.set(node.index, node);
          for (const index of flat.fullRoots(head + 2)) {
            const left = flat.leftSpan(index);
            if (left !== 0) gaps.add(left - 1);
            if (r < this.roots.length && this.roots[r].index === index) {
              roots.push(this.roots[r++]);
              continue;
            }
            const node = all.get(index);
            if (!node) throw new BAD_ARGUMENT("root missing for given length");
            roots.push(node);
          }
          this.roots = roots;
          this.length = length;
          this.byteLength = totalSize(roots);
          this.hashCached = null;
          this.signature = null;
          for (let i = 0; i < this.nodes.length; i++) {
            const index = this.nodes[i].index;
            if (index <= head && !gaps.has(index)) continue;
            const last = this.nodes.pop();
            if (i < this.nodes.length) this.nodes[i--] = last;
          }
        }
        prune(length) {
          if (length === 0) return;
          const head = 2 * length - 2;
          const gaps = /* @__PURE__ */ new Set();
          for (const index of flat.fullRoots(head + 2)) {
            const left = flat.leftSpan(index);
            if (left !== 0) gaps.add(left - 1);
          }
          for (let i = 0; i < this.nodes.length; i++) {
            const index = this.nodes[i].index;
            if (index > head || gaps.has(index)) continue;
            const last = this.nodes.pop();
            if (i < this.nodes.length) this.nodes[i--] = last;
          }
        }
        clone() {
          const b = new _MerkleTreeBatch(this.tree);
          b.fork = this.fork;
          b.roots = [...this.roots];
          b.length = this.length;
          b.byteLength = this.byteLength;
          b.signature = this.signature;
          b.treeLength = this.treeLength;
          b.treeFork = this.treeFork;
          b.tree = this.tree;
          b.nodes = [...this.nodes];
          b.upgraded = this.upgraded;
          return b;
        }
        hash() {
          if (this.hashCached === null) this.hashCached = unslab(this.tree.crypto.tree(this.roots));
          return this.hashCached;
        }
        signable(manifestHash) {
          return caps.treeSignable(manifestHash, this.hash(), this.length, this.fork);
        }
        signableCompat(noHeader) {
          return caps.treeSignableCompat(this.hash(), this.length, this.fork, noHeader);
        }
        get(index, error) {
          if (index >= this.length * 2) {
            return null;
          }
          for (const n of this.nodes) {
            if (n.index === index) return n;
          }
          return this.tree.get(index, error);
        }
        proof({ block, hash, seek, upgrade }) {
          return generateProof(this, block, hash, seek, upgrade);
        }
        verifyUpgrade(proof) {
          const unverified = verifyTree(proof, this.tree.crypto, this.nodes);
          if (!proof.upgrade) throw INVALID_OPERATION("Expected upgrade proof");
          return verifyUpgrade(proof, unverified, this);
        }
        append(buf) {
          const head = this.length * 2;
          const ite = flat.iterator(head);
          const node = blockNode(this.tree.crypto, head, buf);
          this.appendRoot(node, ite);
        }
        appendRoot(node, ite) {
          node = unslabNode(node);
          this.hashCached = null;
          this.upgraded = true;
          this.length += ite.factor / 2;
          this.byteLength += node.size;
          this.roots.push(node);
          this.nodes.push(node);
          while (this.roots.length > 1) {
            const a = this.roots[this.roots.length - 1];
            const b = this.roots[this.roots.length - 2];
            if (ite.sibling() !== b.index) {
              ite.sibling();
              break;
            }
            const node2 = unslabNode(parentNode(this.tree.crypto, ite.parent(), a, b));
            this.nodes.push(node2);
            this.roots.pop();
            this.roots.pop();
            this.roots.push(node2);
          }
        }
        commitable() {
          return this.treeFork === this.tree.fork && (this.upgraded ? this.treeLength === this.tree.length : this.treeLength <= this.tree.length);
        }
        commit() {
          if (!this.commitable()) throw INVALID_OPERATION("Tree was modified during batch, refusing to commit");
          if (this.upgraded) this._commitUpgrade();
          for (let i = 0; i < this.nodes.length; i++) {
            const node = this.nodes[i];
            this.tree.unflushed.set(node.index, node);
          }
        }
        _commitUpgrade() {
          if (this.ancestors < this.treeLength) {
            if (this.ancestors > 0) {
              const head = 2 * this.ancestors;
              const ite = flat.iterator(head - 2);
              while (true) {
                if (ite.contains(head) && ite.index < head) {
                  this.tree.unflushed.set(ite.index, blankNode(ite.index));
                }
                if (ite.offset === 0) break;
                ite.parent();
              }
            }
            this.tree.truncateTo = this.tree.truncated ? Math.min(this.tree.truncateTo, this.ancestors) : this.ancestors;
            this.tree.truncated = true;
            this.tree.cache = new Xache({ maxSize: this.tree.cache.maxSize });
            truncateMap(this.tree.unflushed, this.ancestors);
            if (this.tree.flushing !== null) truncateMap(this.tree.flushing, this.ancestors);
          }
          this.tree.roots = this.roots;
          this.tree.length = this.length;
          this.tree.byteLength = this.byteLength;
          this.tree.fork = this.fork;
          this.tree.signature = this.signature;
        }
        seek(bytes, padding) {
          return new ByteSeeker(this, bytes, padding);
        }
        byteRange(index) {
          return getByteRange(this, index);
        }
        byteOffset(index) {
          if (index === 2 * this.tree.length) return this.tree.byteLength;
          return getByteOffset(this, index);
        }
      };
      var ReorgBatch = class extends MerkleTreeBatch {
        constructor(tree) {
          super(tree);
          this.roots = [];
          this.length = 0;
          this.byteLength = 0;
          this.diff = null;
          this.ancestors = 0;
          this.upgraded = true;
          this.want = {
            nodes: 0,
            start: 0,
            end: 0
          };
        }
        get finished() {
          return this.want === null;
        }
        update(proof) {
          if (this.want === null) return true;
          const nodes = [];
          const root = verifyTree(proof, this.tree.crypto, nodes);
          if (root === null || !b4a.equals(root.hash, this.diff.hash)) return false;
          this.nodes.push(...nodes);
          return this._update(nodes);
        }
        async _update(nodes) {
          const n = /* @__PURE__ */ new Map();
          for (const node of nodes) n.set(node.index, node);
          let diff = null;
          const ite = flat.iterator(this.diff.index);
          const startingDiff = this.diff;
          while ((ite.index & 1) !== 0) {
            const left = n.get(ite.leftChild());
            if (!left) break;
            const existing = await this.tree.get(left.index, false);
            if (!existing || !b4a.equals(existing.hash, left.hash)) {
              diff = left;
            } else {
              diff = n.get(ite.sibling());
            }
          }
          if ((this.diff.index & 1) === 0) return true;
          if (diff === null) return false;
          if (startingDiff !== this.diff) return false;
          return this._updateDiffRoot(diff);
        }
        _updateDiffRoot(diff) {
          if (this.want === null) return true;
          const spans = flat.spans(diff.index);
          const start = spans[0] / 2;
          const end = Math.min(this.treeLength, spans[1] / 2 + 1);
          const len = end - start;
          this.ancestors = start;
          this.diff = diff;
          if ((diff.index & 1) === 0 || this.want.start >= this.treeLength || len <= 0) {
            this.want = null;
            return true;
          }
          this.want.start = start;
          this.want.end = end;
          this.want.nodes = log2(spans[1] - spans[0] + 2) - 1;
          return false;
        }
      };
      var ByteSeeker = class {
        constructor(tree, bytes, padding = 0) {
          this.tree = tree;
          this.bytes = bytes;
          this.padding = padding;
          const size = tree.byteLength - tree.length * padding;
          this.start = bytes >= size ? tree.length : 0;
          this.end = bytes < size ? tree.length : 0;
        }
        async _seek(bytes) {
          if (!bytes) return [0, 0];
          for (const node of this.tree.roots) {
            const size = getUnpaddedSize(node, this.padding, null);
            if (bytes === size) return [flat.rightSpan(node.index) + 2, 0];
            if (bytes > size) {
              bytes -= size;
              continue;
            }
            const ite = flat.iterator(node.index);
            while ((ite.index & 1) !== 0) {
              const l = await this.tree.get(ite.leftChild(), false);
              if (l) {
                const size2 = getUnpaddedSize(l, this.padding, ite);
                if (size2 === bytes) return [ite.rightSpan() + 2, 0];
                if (size2 > bytes) continue;
                bytes -= size2;
                ite.sibling();
              } else {
                ite.parent();
                return [ite.index, bytes];
              }
            }
            return [ite.index, bytes];
          }
          return null;
        }
        async update() {
          const res = await this._seek(this.bytes);
          if (!res) return null;
          if ((res[0] & 1) === 0) return [res[0] / 2, res[1]];
          const span = flat.spans(res[0]);
          this.start = span[0] / 2;
          this.end = span[1] / 2 + 1;
          return null;
        }
      };
      module.exports = class MerkleTree {
        constructor(storage, roots, fork, signature, prologue) {
          this.crypto = crypto;
          this.fork = fork;
          this.roots = roots;
          this.length = roots.length ? totalSpan(roots) / 2 : 0;
          this.byteLength = totalSize(roots);
          this.signature = signature;
          this.prologue = prologue;
          this.storage = storage;
          this.unflushed = /* @__PURE__ */ new Map();
          this.cache = new Xache({ maxSize: TREE_CACHE });
          this.flushing = null;
          this.truncated = false;
          this.truncateTo = 0;
        }
        addNode(node) {
          if (node.size === 0 && b4a.equals(node.hash, BLANK_HASH)) node = blankNode(node.index);
          this.unflushed.set(node.index, node);
        }
        batch() {
          return new MerkleTreeBatch(this);
        }
        async restoreBatch(length) {
          const batch = new MerkleTreeBatch(this);
          if (length === this.length) return batch;
          const roots = unslabNodes(await this.getRoots(length));
          batch.roots = roots;
          batch.length = length;
          batch.byteLength = 0;
          batch.ancestors = length;
          for (const node of roots) batch.byteLength += node.size;
          return batch;
        }
        seek(bytes, padding) {
          return new ByteSeeker(this, bytes, padding);
        }
        hash() {
          return unslab(this.crypto.tree(this.roots));
        }
        signable(namespace) {
          return caps.treeSignable(namespace, this.hash(), this.length, this.fork);
        }
        getRoots(length) {
          const indexes = flat.fullRoots(2 * length);
          const roots = new Array(indexes.length);
          for (let i = 0; i < indexes.length; i++) {
            roots[i] = this.get(indexes[i], true);
          }
          return Promise.all(roots);
        }
        setPrologue({ hash, length }) {
          this.prologue = { hash, length };
        }
        addNodes(nodes) {
          for (let i = 0; i < nodes.length; i++) {
            const node = nodes[i];
            this.unflushed.set(node.index, node);
          }
        }
        getNeededNodes(length, start, end) {
          const nodes = /* @__PURE__ */ new Map();
          const head = length * 2;
          for (let i = start; i < end; i++) {
            const ite = flat.iterator(i * 2);
            while (true) {
              if (nodes.has(ite.index)) break;
              nodes.set(ite.index, this.get(ite.index, true));
              const sibling = ite.sibling();
              ite.parent();
              if (ite.contains(head)) break;
              if (nodes.has(sibling)) break;
              nodes.set(sibling, this.get(sibling, true));
            }
          }
          return Promise.all([...nodes.values()]);
        }
        async upgradeable(length) {
          const indexes = flat.fullRoots(2 * length);
          const roots = new Array(indexes.length);
          for (let i = 0; i < indexes.length; i++) {
            roots[i] = this.get(indexes[i], false);
          }
          for (const node of await Promise.all(roots)) {
            if (node === null) return false;
          }
          return true;
        }
        blankNode(index) {
          return blankNode(index);
        }
        get(index, error = true) {
          const c2 = this.cache.get(index);
          if (c2) return c2;
          let node = this.unflushed.get(index);
          if (this.flushing !== null && node === void 0) {
            node = this.flushing.get(index);
          }
          if (this.truncated && node !== void 0 && node.index >= 2 * this.truncateTo) {
            node = blankNode(index);
          }
          if (node !== void 0) {
            if (node.hash === BLANK_HASH) {
              if (error) throw INVALID_OPERATION("Could not load node: " + index);
              return Promise.resolve(null);
            }
            return Promise.resolve(node);
          }
          return getStoredNode(this.storage, index, this.cache, error);
        }
        async flush() {
          this.flushing = this.unflushed;
          this.unflushed = /* @__PURE__ */ new Map();
          try {
            if (this.truncated) await this._flushTruncation();
            await this._flushNodes();
          } catch (err) {
            for (const node of this.flushing.values()) {
              if (!this.unflushed.has(node.index)) this.unflushed.set(node.index, node);
            }
            throw err;
          } finally {
            this.flushing = null;
          }
        }
        _flushTruncation() {
          return new Promise((resolve, reject) => {
            const t = this.truncateTo;
            const offset = t === 0 ? 0 : (t - 1) * 80 + 40;
            this.storage.truncate(offset, (err) => {
              if (err) return reject(err);
              if (this.truncateTo === t) {
                this.truncateTo = 0;
                this.truncated = false;
              }
              resolve();
            });
          });
        }
        _flushNodes() {
          return new Promise((resolve, reject) => {
            const slab = b4a.allocUnsafe(40 * this.flushing.size);
            let error = null;
            let missing = this.flushing.size + 1;
            let offset = 0;
            for (const node of this.flushing.values()) {
              const state = {
                start: 0,
                end: 40,
                buffer: slab.subarray(offset, offset += 40)
              };
              c.uint64.encode(state, node.size);
              c.raw.encode(state, node.hash);
              this.storage.write(node.index * 40, state.buffer, done);
            }
            done(null);
            function done(err) {
              if (err) error = err;
              if (--missing > 0) return;
              if (error) reject(error);
              else resolve();
            }
          });
        }
        clear() {
          this.cache = new Xache({ maxSize: this.cache.maxSize });
          this.truncated = true;
          this.truncateTo = 0;
          this.roots = [];
          this.length = 0;
          this.byteLength = 0;
          this.fork = 0;
          this.signature = null;
          if (this.flushing !== null) this.flushing.clear();
          this.unflushed.clear();
          return this.flush();
        }
        close() {
          return new Promise((resolve, reject) => {
            this.storage.close((err) => {
              if (err) reject(err);
              else resolve();
            });
          });
        }
        async truncate(length, fork = this.fork) {
          const head = length * 2;
          const batch = new MerkleTreeBatch(this);
          const fullRoots = flat.fullRoots(head);
          for (let i = 0; i < fullRoots.length; i++) {
            const root = fullRoots[i];
            if (i < batch.roots.length && batch.roots[i].index === root) continue;
            while (batch.roots.length > i) batch.roots.pop();
            batch.roots.push(unslabNode(await this.get(root)));
          }
          while (batch.roots.length > fullRoots.length) {
            batch.roots.pop();
          }
          batch.fork = fork;
          batch.length = length;
          batch.ancestors = length;
          batch.byteLength = totalSize(batch.roots);
          batch.upgraded = true;
          return batch;
        }
        async reorg(proof) {
          const batch = new ReorgBatch(this);
          let unverified = null;
          if (proof.block || proof.hash || proof.seek) {
            unverified = verifyTree(proof, this.crypto, batch.nodes);
          }
          if (!verifyUpgrade(proof, unverified, batch)) {
            throw INVALID_PROOF("Fork proof not verifiable");
          }
          for (const root of batch.roots) {
            const existing = await this.get(root.index, false);
            if (existing && b4a.equals(existing.hash, root.hash)) continue;
            batch._updateDiffRoot(root);
            break;
          }
          if (batch.diff !== null) {
            await batch._update(batch.nodes);
          } else {
            batch.want = null;
            batch.ancestors = batch.length;
          }
          return batch;
        }
        verifyFullyRemote(proof) {
          const batch = new MerkleTreeBatch(this);
          batch.fork = proof.fork;
          batch.roots = [];
          batch.length = 0;
          batch.ancestors = 0;
          batch.byteLength = 0;
          let unverified = verifyTree(proof, this.crypto, batch.nodes);
          if (proof.upgrade) {
            if (verifyUpgrade(proof, unverified, batch)) {
              unverified = null;
            }
          }
          return batch;
        }
        async verify(proof) {
          const batch = new MerkleTreeBatch(this);
          let unverified = verifyTree(proof, this.crypto, batch.nodes);
          if (proof.upgrade) {
            if (verifyUpgrade(proof, unverified, batch)) {
              unverified = null;
            }
          }
          if (unverified) {
            const verified = await this.get(unverified.index);
            if (!b4a.equals(verified.hash, unverified.hash)) {
              throw INVALID_CHECKSUM("Invalid checksum at node " + unverified.index);
            }
          }
          return batch;
        }
        proof({ block, hash, seek, upgrade }) {
          return generateProof(this, block, hash, seek, upgrade);
        }
        // Successor to .nodes()
        async missingNodes(index) {
          const head = 2 * this.length;
          const ite = flat.iterator(index);
          const iteRightSpan = ite.index + ite.factor / 2 - 1;
          if (iteRightSpan >= head) return 0;
          let cnt = 0;
          while (!ite.contains(head) && await this.get(ite.index, false) === null) {
            cnt++;
            ite.parent();
          }
          return cnt;
        }
        // Deprecated
        async nodes(index) {
          const head = 2 * this.length;
          const ite = flat.iterator(index);
          let cnt = 0;
          while (!ite.contains(head) && await this.get(ite.index, false) === null) {
            cnt++;
            ite.parent();
          }
          return cnt;
        }
        byteRange(index) {
          return getByteRange(this, index);
        }
        byteOffset(index) {
          return getByteOffset(this, index);
        }
        static async open(storage, opts = {}) {
          await new Promise((resolve, reject) => {
            storage.read(0, OLD_TREE.length, (err, buf) => {
              if (err) return resolve();
              if (b4a.equals(buf, OLD_TREE)) return reject(new Error("Storage contains an incompatible merkle tree"));
              resolve();
            });
          });
          const length = typeof opts.length === "number" ? opts.length : await autoLength(storage);
          const roots = [];
          for (const index of flat.fullRoots(2 * length)) {
            roots.push(unslabNode(await getStoredNode(storage, index, null, true)));
          }
          return new MerkleTree(storage, roots, opts.fork || 0, opts.signature || null, opts.prologue || null);
        }
      };
      async function getByteRange(tree, index) {
        const head = 2 * tree.length;
        if (((index & 1) === 0 ? index : flat.rightSpan(index)) >= head) {
          throw BAD_ARGUMENT("Index is out of bounds");
        }
        return [await tree.byteOffset(index), (await tree.get(index)).size];
      }
      async function getByteOffset(tree, index) {
        if (index === 2 * tree.length) return tree.byteLength;
        if ((index & 1) === 1) index = flat.leftSpan(index);
        let head = 0;
        let offset = 0;
        for (const node of tree.roots) {
          head += 2 * (node.index - head + 1);
          if (index >= head) {
            offset += node.size;
            continue;
          }
          const ite = flat.iterator(node.index);
          while (ite.index !== index) {
            if (index < ite.index) {
              ite.leftChild();
            } else {
              offset += (await tree.get(ite.leftChild())).size;
              ite.sibling();
            }
          }
          return offset;
        }
        throw ASSERTION("Failed to find offset");
      }
      function verifyTree({ block, hash, seek }, crypto2, nodes) {
        const untrustedNode = block ? { index: 2 * block.index, value: block.value, nodes: block.nodes } : hash ? { index: hash.index, value: null, nodes: hash.nodes } : null;
        if (untrustedNode === null && (!seek || !seek.nodes.length)) return null;
        let root = null;
        if (seek && seek.nodes.length) {
          const ite2 = flat.iterator(seek.nodes[0].index);
          const q2 = new NodeQueue(seek.nodes);
          root = q2.shift(ite2.index);
          nodes.push(root);
          while (q2.length > 0) {
            const node = q2.shift(ite2.sibling());
            root = parentNode(crypto2, ite2.parent(), root, node);
            nodes.push(node);
            nodes.push(root);
          }
        }
        if (untrustedNode === null) return root;
        const ite = flat.iterator(untrustedNode.index);
        const blockHash = untrustedNode.value && blockNode(crypto2, ite.index, untrustedNode.value);
        const q = new NodeQueue(untrustedNode.nodes, root);
        root = blockHash || q.shift(ite.index);
        nodes.push(root);
        while (q.length > 0) {
          const node = q.shift(ite.sibling());
          root = parentNode(crypto2, ite.parent(), root, node);
          nodes.push(node);
          nodes.push(root);
        }
        return root;
      }
      function verifyUpgrade({ fork, upgrade }, blockRoot, batch) {
        const prologue = batch.tree.prologue;
        if (prologue) {
          const { start, length } = upgrade;
          if (start < prologue.length && (start !== 0 || length < prologue.length)) {
            throw INVALID_PROOF("Upgrade does not satisfy prologue");
          }
        }
        const q = new NodeQueue(upgrade.nodes, blockRoot);
        let grow = batch.roots.length > 0;
        let i = 0;
        const to = 2 * (upgrade.start + upgrade.length);
        const ite = flat.iterator(0);
        for (; ite.fullRoot(to); ite.nextTree()) {
          if (i < batch.roots.length && batch.roots[i].index === ite.index) {
            i++;
            continue;
          }
          if (grow) {
            grow = false;
            const root = ite.index;
            if (i < batch.roots.length) {
              ite.seek(batch.roots[batch.roots.length - 1].index);
              while (ite.index !== root) {
                batch.appendRoot(q.shift(ite.sibling()), ite);
              }
              continue;
            }
          }
          batch.appendRoot(q.shift(ite.index), ite);
        }
        if (prologue && batch.length === prologue.length) {
          if (!b4a.equals(prologue.hash, batch.hash())) {
            throw INVALID_PROOF("Invalid hash");
          }
        }
        const extra = upgrade.additionalNodes;
        ite.seek(batch.roots[batch.roots.length - 1].index);
        i = 0;
        while (i < extra.length && extra[i].index === ite.sibling()) {
          batch.appendRoot(extra[i++], ite);
        }
        while (i < extra.length) {
          const node = extra[i++];
          while (node.index !== ite.index) {
            if (ite.factor === 2) throw INVALID_OPERATION("Unexpected node: " + node.index);
            ite.leftChild();
          }
          batch.appendRoot(node, ite);
          ite.sibling();
        }
        batch.signature = unslab(upgrade.signature);
        batch.fork = fork;
        return q.extra === null;
      }
      async function seekFromHead(tree, head, bytes, padding) {
        const roots = flat.fullRoots(head);
        for (let i = 0; i < roots.length; i++) {
          const root = roots[i];
          const node = await tree.get(root);
          const size = getUnpaddedSize(node, padding, null);
          if (bytes === size) return root;
          if (bytes > size) {
            bytes -= size;
            continue;
          }
          return seekTrustedTree(tree, root, bytes, padding);
        }
        return head;
      }
      async function seekTrustedTree(tree, root, bytes, padding) {
        if (!bytes) return root;
        const ite = flat.iterator(root);
        while ((ite.index & 1) !== 0) {
          const l = await tree.get(ite.leftChild(), false);
          if (l) {
            const size = getUnpaddedSize(l, padding, ite);
            if (size === bytes) return ite.index;
            if (size > bytes) continue;
            bytes -= size;
            ite.sibling();
          } else {
            ite.parent();
            return ite.index;
          }
        }
        return ite.index;
      }
      async function seekUntrustedTree(tree, root, bytes, padding) {
        const offset = await tree.byteOffset(root) - (padding ? padding * flat.leftSpan(root) / 2 : 0);
        if (offset > bytes) throw INVALID_OPERATION("Invalid seek");
        if (offset === bytes) return root;
        bytes -= offset;
        const node = await tree.get(root);
        if (getUnpaddedSize(node, padding, null) <= bytes) throw INVALID_OPERATION("Invalid seek");
        return seekTrustedTree(tree, root, bytes, padding);
      }
      function seekProof(tree, seekRoot, root, p) {
        const ite = flat.iterator(seekRoot);
        p.seek = [];
        p.seek.push(tree.get(ite.index));
        while (ite.index !== root) {
          ite.sibling();
          p.seek.push(tree.get(ite.index));
          ite.parent();
        }
      }
      function blockAndSeekProof(tree, node, seek, seekRoot, root, p) {
        if (!node) return seekProof(tree, seekRoot, root, p);
        const ite = flat.iterator(node.index);
        p.node = [];
        if (!node.value) p.node.push(tree.get(ite.index));
        while (ite.index !== root) {
          ite.sibling();
          if (seek && ite.contains(seekRoot) && ite.index !== seekRoot) {
            seekProof(tree, seekRoot, ite.index, p);
          } else {
            p.node.push(tree.get(ite.index));
          }
          ite.parent();
        }
      }
      function upgradeProof(tree, node, seek, from, to, subTree, p) {
        if (from === 0) p.upgrade = [];
        for (const ite = flat.iterator(0); ite.fullRoot(to); ite.nextTree()) {
          if (ite.index + ite.factor / 2 < from) continue;
          if (p.upgrade === null && ite.contains(from - 2)) {
            p.upgrade = [];
            const root = ite.index;
            const target = from - 2;
            ite.seek(target);
            while (ite.index !== root) {
              ite.sibling();
              if (ite.index > target) {
                if (p.node === null && p.seek === null && ite.contains(subTree)) {
                  blockAndSeekProof(tree, node, seek, subTree, ite.index, p);
                } else {
                  p.upgrade.push(tree.get(ite.index));
                }
              }
              ite.parent();
            }
            continue;
          }
          if (p.upgrade === null) {
            p.upgrade = [];
          }
          if (p.node === null && p.seek === null && ite.contains(subTree)) {
            blockAndSeekProof(tree, node, seek, subTree, ite.index, p);
            continue;
          }
          p.upgrade.push(tree.get(ite.index));
        }
      }
      function additionalUpgradeProof(tree, from, to, p) {
        if (from === 0) p.additionalUpgrade = [];
        for (const ite = flat.iterator(0); ite.fullRoot(to); ite.nextTree()) {
          if (ite.index + ite.factor / 2 < from) continue;
          if (p.additionalUpgrade === null && ite.contains(from - 2)) {
            p.additionalUpgrade = [];
            const root = ite.index;
            const target = from - 2;
            ite.seek(target);
            while (ite.index !== root) {
              ite.sibling();
              if (ite.index > target) {
                p.additionalUpgrade.push(tree.get(ite.index));
              }
              ite.parent();
            }
            continue;
          }
          if (p.additionalUpgrade === null) {
            p.additionalUpgrade = [];
          }
          p.additionalUpgrade.push(tree.get(ite.index));
        }
      }
      function nodesToRoot(index, nodes, head) {
        const ite = flat.iterator(index);
        for (let i = 0; i < nodes; i++) {
          ite.parent();
          if (ite.contains(head)) throw BAD_ARGUMENT("Nodes is out of bounds");
        }
        return ite.index;
      }
      function totalSize(nodes) {
        let s = 0;
        for (const node of nodes) s += node.size;
        return s;
      }
      function totalSpan(nodes) {
        let s = 0;
        for (const node of nodes) s += 2 * (node.index - s + 1);
        return s;
      }
      function blockNode(crypto2, index, value) {
        return { index, size: value.byteLength, hash: crypto2.data(value) };
      }
      function parentNode(crypto2, index, a, b) {
        return { index, size: a.size + b.size, hash: crypto2.parent(a, b) };
      }
      function blankNode(index) {
        return { index, size: 0, hash: BLANK_HASH };
      }
      function getStoredNode(storage, index, cache, error) {
        return new Promise((resolve, reject) => {
          storage.read(40 * index, 40, (err, data) => {
            if (err) {
              if (error) return reject(err);
              else resolve(null);
              return;
            }
            const hash = data.subarray(8);
            const size = c.decode(c.uint64, data);
            if (size === 0 && b4a.compare(hash, BLANK_HASH) === 0) {
              if (error) reject(new Error("Could not load node: " + index));
              else resolve(null);
              return;
            }
            const node = { index, size, hash };
            if (cache !== null) {
              node.hash = unslab(hash);
              cache.set(index, node);
            }
            resolve(node);
          });
        });
      }
      function storedNodes(storage) {
        return new Promise((resolve) => {
          storage.stat((_, st) => {
            if (!st) return resolve(0);
            resolve((st.size - st.size % 40) / 40);
          });
        });
      }
      async function autoLength(storage) {
        const nodes = await storedNodes(storage);
        if (!nodes) return 0;
        const ite = flat.iterator(nodes - 1);
        let index = nodes - 1;
        while (await getStoredNode(storage, ite.parent(), null, false)) index = ite.index;
        return flat.rightSpan(index) / 2 + 1;
      }
      function truncateMap(map, len) {
        for (const node of map.values()) {
          if (node.index >= 2 * len) map.delete(node.index);
        }
      }
      function log2(n) {
        let res = 1;
        while (n > 2) {
          n /= 2;
          res++;
        }
        return res;
      }
      function normalizeIndexed(block, hash) {
        if (block) return { value: true, index: block.index * 2, nodes: block.nodes, lastIndex: block.index };
        if (hash) return { value: false, index: hash.index, nodes: hash.nodes, lastIndex: flat.rightSpan(hash.index) / 2 };
        return null;
      }
      async function settleProof(p) {
        const result = [
          p.node && Promise.all(p.node),
          p.seek && Promise.all(p.seek),
          p.upgrade && Promise.all(p.upgrade),
          p.additionalUpgrade && Promise.all(p.additionalUpgrade)
        ];
        try {
          return await Promise.all(result);
        } catch (err) {
          if (p.node) await Promise.allSettled(p.node);
          if (p.seek) await Promise.allSettled(p.seek);
          if (p.upgrade) await Promise.allSettled(p.upgrade);
          if (p.additionalUpgrade) await Promise.allSettled(p.additionalUpgrade);
          throw err;
        }
      }
      async function generateProof(tree, block, hash, seek, upgrade) {
        if (tree.prologue && upgrade) {
          upgrade.start = upgrade.start < tree.prologue.length ? 0 : upgrade.start;
          upgrade.length = upgrade.start < tree.prologue.length ? tree.prologue.length : upgrade.length;
        }
        const fork = tree.fork;
        const signature = tree.signature;
        const head = 2 * tree.length;
        const from = upgrade ? upgrade.start * 2 : 0;
        const to = upgrade ? from + upgrade.length * 2 : head;
        const node = normalizeIndexed(block, hash);
        const result = { fork, block: null, hash: null, seek: null, upgrade: null, manifest: null };
        if (head === 0) return result;
        if (from >= to || to > head) {
          throw INVALID_OPERATION("Invalid upgrade");
        }
        if (seek && upgrade && node !== null && node.index >= from) {
          throw INVALID_OPERATION("Cannot both do a seek and block/hash request when upgrading");
        }
        let subTree = head;
        const p = {
          node: null,
          seek: null,
          upgrade: null,
          additionalUpgrade: null
        };
        if (node !== null && (!upgrade || node.lastIndex < upgrade.start)) {
          subTree = nodesToRoot(node.index, node.nodes, to);
          const seekRoot = seek ? await seekUntrustedTree(tree, subTree, seek.bytes, seek.padding) : head;
          blockAndSeekProof(tree, node, seek, seekRoot, subTree, p);
        } else if ((node || seek) && upgrade) {
          subTree = seek ? await seekFromHead(tree, to, seek.bytes, seek.padding) : node.index;
        }
        if (upgrade) {
          upgradeProof(tree, node, seek, from, to, subTree, p);
          if (head > to) additionalUpgradeProof(tree, to, head, p);
        }
        const [pNode, pSeek, pUpgrade, pAdditional] = await settleProof(p);
        if (block) {
          if (pNode === null) throw INVALID_OPERATION("Invalid block request");
          result.block = {
            index: block.index,
            value: null,
            // populated upstream, alloc it here for simplicity
            nodes: pNode
          };
        } else if (hash) {
          if (pNode === null) throw INVALID_OPERATION("Invalid hash request");
          result.hash = {
            index: hash.index,
            nodes: pNode
          };
        }
        if (seek && pSeek !== null) {
          result.seek = {
            bytes: seek.bytes,
            nodes: pSeek
          };
        }
        if (upgrade) {
          result.upgrade = {
            start: upgrade.start,
            length: upgrade.length,
            nodes: pUpgrade,
            additionalNodes: pAdditional || [],
            signature
          };
        }
        return result;
      }
      function getUnpaddedSize(node, padding, ite) {
        return padding === 0 ? node.size : node.size - padding * (ite ? ite.countLeaves() : flat.countLeaves(node.index));
      }
      function unslabNodes(nodes) {
        for (const node of nodes) unslabNode(node);
        return nodes;
      }
      function unslabNode(node) {
        if (node === null) return node;
        node.hash = unslab(node.hash);
        return node;
      }
    }
  });

  // ../../node_modules/bare-dev/node_modules/hypercore/lib/block-store.js
  var require_block_store = __commonJS({
    "../../node_modules/bare-dev/node_modules/hypercore/lib/block-store.js"(exports, module) {
      var b4a = require_b4a();
      var { WRITE_FAILED } = require_hypercore_errors();
      module.exports = class BlockStore {
        constructor(storage, tree) {
          this.storage = storage;
          this.tree = tree;
        }
        async get(i, tree) {
          if (!tree) tree = this.tree;
          const [offset, size] = await tree.byteRange(2 * i);
          return this._read(offset, size);
        }
        async put(i, data, offset) {
          return this._write(offset, data);
        }
        putBatch(i, batch, offset) {
          if (batch.length === 0) return Promise.resolve();
          return this.put(i, batch.length === 1 ? batch[0] : b4a.concat(batch), offset);
        }
        clear(offset = 0, length = -1) {
          return new Promise((resolve, reject) => {
            if (length === -1) this.storage.truncate(offset, done);
            else this.storage.del(offset, length, done);
            function done(err) {
              if (err) reject(err);
              else resolve();
            }
          });
        }
        close() {
          return new Promise((resolve, reject) => {
            this.storage.close((err) => {
              if (err) reject(err);
              else resolve();
            });
          });
        }
        _read(offset, size) {
          return new Promise((resolve, reject) => {
            this.storage.read(offset, size, (err, data) => {
              if (err) reject(err);
              else resolve(data);
            });
          });
        }
        _write(offset, data) {
          return new Promise((resolve, reject) => {
            this.storage.write(offset, data, (err) => {
              if (err) reject(WRITE_FAILED(err.message));
              else resolve(offset + data.byteLength);
            });
          });
        }
      };
    }
  });

  // ../../node_modules/bare-dev/node_modules/hypercore/lib/bitfield.js
  var require_bitfield = __commonJS({
    "../../node_modules/bare-dev/node_modules/hypercore/lib/bitfield.js"(exports, module) {
      var BigSparseArray = require_big_sparse_array();
      var b4a = require_b4a();
      var quickbit = require_compat().quickbit;
      var BITS_PER_PAGE = 32768;
      var BYTES_PER_PAGE = BITS_PER_PAGE / 8;
      var WORDS_PER_PAGE = BYTES_PER_PAGE / 4;
      var BITS_PER_SEGMENT = 2097152;
      var BYTES_PER_SEGMENT = BITS_PER_SEGMENT / 8;
      var WORDS_PER_SEGMENT = BYTES_PER_SEGMENT / 4;
      var INITIAL_WORDS_PER_SEGMENT = 1024;
      var PAGES_PER_SEGMENT = BITS_PER_SEGMENT / BITS_PER_PAGE;
      var SEGMENT_GROWTH_FACTOR = 4;
      var BitfieldPage = class {
        constructor(index, segment) {
          this.dirty = false;
          this.index = index;
          this.offset = index * BYTES_PER_PAGE - segment.offset;
          this.bitfield = null;
          this.segment = segment;
          segment.add(this);
        }
        get tree() {
          return this.segment.tree;
        }
        get(index) {
          return quickbit.get(this.bitfield, index);
        }
        set(index, val) {
          if (quickbit.set(this.bitfield, index, val)) {
            this.tree.update(this.offset * 8 + index);
          }
        }
        setRange(start, length, val) {
          quickbit.fill(this.bitfield, val, start, start + length);
          let i = Math.floor(start / 128);
          const n = i + Math.ceil(length / 128);
          while (i <= n) this.tree.update(this.offset * 8 + i++ * 128);
        }
        findFirst(val, position) {
          return quickbit.findFirst(this.bitfield, val, position);
        }
        findLast(val, position) {
          return quickbit.findLast(this.bitfield, val, position);
        }
        count(start, length, val) {
          const end = start + length;
          let i = start;
          let c = 0;
          while (length > 0) {
            const l = this.findFirst(val, i);
            if (l === -1 || l >= end) return c;
            const h = this.findFirst(!val, l + 1);
            if (h === -1 || h >= end) return c + end - l;
            c += h - l;
            length -= h - i;
            i = h;
          }
          return c;
        }
      };
      var BitfieldSegment = class {
        constructor(index, bitfield) {
          this.index = index;
          this.offset = index * BYTES_PER_SEGMENT;
          this.tree = quickbit.Index.from(bitfield, BYTES_PER_SEGMENT);
          this.pages = new Array(PAGES_PER_SEGMENT);
        }
        get bitfield() {
          return this.tree.field;
        }
        add(page) {
          const i = page.index - this.index * PAGES_PER_SEGMENT;
          this.pages[i] = page;
          const start = i * WORDS_PER_PAGE;
          const end = start + WORDS_PER_PAGE;
          if (end >= this.bitfield.length) this.reallocate(end);
          page.bitfield = this.bitfield.subarray(start, end);
        }
        reallocate(length) {
          let target = this.bitfield.length;
          while (target < length) target *= SEGMENT_GROWTH_FACTOR;
          const bitfield = new Uint32Array(target);
          bitfield.set(this.bitfield);
          this.tree = quickbit.Index.from(bitfield, BYTES_PER_SEGMENT);
          for (let i = 0; i < this.pages.length; i++) {
            const page = this.pages[i];
            if (!page) continue;
            const start = i * WORDS_PER_PAGE;
            const end = start + WORDS_PER_PAGE;
            page.bitfield = bitfield.subarray(start, end);
          }
        }
        findFirst(val, position) {
          position = this.tree.skipFirst(!val, position);
          let j = position & BITS_PER_PAGE - 1;
          let i = (position - j) / BITS_PER_PAGE;
          if (i >= PAGES_PER_SEGMENT) return -1;
          while (i < this.pages.length) {
            const p = this.pages[i];
            let index = -1;
            if (p) index = p.findFirst(val, j);
            else if (!val) index = j;
            if (index !== -1) return i * BITS_PER_PAGE + index;
            j = 0;
            i++;
          }
          return -1;
        }
        findLast(val, position) {
          position = this.tree.skipLast(!val, position);
          let j = position & BITS_PER_PAGE - 1;
          let i = (position - j) / BITS_PER_PAGE;
          if (i >= PAGES_PER_SEGMENT) return -1;
          while (i >= 0) {
            const p = this.pages[i];
            let index = -1;
            if (p) index = p.findLast(val, j);
            else if (!val) index = j;
            if (index !== -1) return i * BITS_PER_PAGE + index;
            j = BITS_PER_PAGE - 1;
            i--;
          }
          return -1;
        }
      };
      module.exports = class Bitfield {
        constructor(storage, buffer) {
          this.unflushed = [];
          this.storage = storage;
          this.resumed = !!(buffer && buffer.byteLength >= 4);
          this._pages = new BigSparseArray();
          this._segments = new BigSparseArray();
          const view = this.resumed ? new Uint32Array(
            buffer.buffer,
            buffer.byteOffset,
            Math.floor(buffer.byteLength / 4)
          ) : new Uint32Array(INITIAL_WORDS_PER_SEGMENT);
          for (let i = 0; i < view.length; i += WORDS_PER_SEGMENT) {
            let bitfield = view.subarray(i, i + WORDS_PER_SEGMENT);
            let length = WORDS_PER_SEGMENT;
            if (i === 0) {
              length = INITIAL_WORDS_PER_SEGMENT;
              while (length < bitfield.length) length *= SEGMENT_GROWTH_FACTOR;
            }
            if (bitfield.length !== length) {
              const copy = new Uint32Array(length);
              copy.set(bitfield, 0);
              bitfield = copy;
            }
            const segment = new BitfieldSegment(i / WORDS_PER_SEGMENT, bitfield);
            this._segments.set(segment.index, segment);
            for (let j = 0; j < bitfield.length; j += WORDS_PER_PAGE) {
              const page = new BitfieldPage((i + j) / WORDS_PER_PAGE, segment);
              this._pages.set(page.index, page);
            }
          }
        }
        toBuffer(length) {
          const pages = Math.ceil(length / BITS_PER_PAGE);
          const buffer = b4a.allocUnsafe(pages * BYTES_PER_PAGE);
          for (let i = 0; i < pages; i++) {
            const page = this._pages.get(i);
            const offset = i * BYTES_PER_PAGE;
            if (page) {
              const buf = b4a.from(
                page.bitfield.buffer,
                page.bitfield.byteOffset,
                page.bitfield.byteLength
              );
              buffer.set(buf, offset);
            } else {
              buffer.fill(0, offset, offset + BYTES_PER_PAGE);
            }
          }
          return buffer;
        }
        getBitfield(index) {
          const j = index & BITS_PER_PAGE - 1;
          const i = (index - j) / BITS_PER_PAGE;
          const p = this._pages.get(i);
          return p || null;
        }
        get(index) {
          const j = index & BITS_PER_PAGE - 1;
          const i = (index - j) / BITS_PER_PAGE;
          const p = this._pages.get(i);
          return p ? p.get(j) : false;
        }
        set(index, val) {
          const j = index & BITS_PER_PAGE - 1;
          const i = (index - j) / BITS_PER_PAGE;
          let p = this._pages.get(i);
          if (!p && val) {
            const k = Math.floor(i / PAGES_PER_SEGMENT);
            const s = this._segments.get(k) || this._segments.set(k, new BitfieldSegment(k, new Uint32Array(k === 0 ? INITIAL_WORDS_PER_SEGMENT : WORDS_PER_SEGMENT)));
            p = this._pages.set(i, new BitfieldPage(i, s));
          }
          if (p) {
            p.set(j, val);
            if (!p.dirty) {
              p.dirty = true;
              this.unflushed.push(p);
            }
          }
        }
        setRange(start, length, val) {
          let j = start & BITS_PER_PAGE - 1;
          let i = (start - j) / BITS_PER_PAGE;
          while (length > 0) {
            let p = this._pages.get(i);
            if (!p && val) {
              const k = Math.floor(i / PAGES_PER_SEGMENT);
              const s = this._segments.get(k) || this._segments.set(k, new BitfieldSegment(k, new Uint32Array(k === 0 ? INITIAL_WORDS_PER_SEGMENT : WORDS_PER_SEGMENT)));
              p = this._pages.set(i, new BitfieldPage(i, s));
            }
            const end = Math.min(j + length, BITS_PER_PAGE);
            const range = end - j;
            if (p) {
              p.setRange(j, range, val);
              if (!p.dirty) {
                p.dirty = true;
                this.unflushed.push(p);
              }
            }
            j = 0;
            i++;
            length -= range;
          }
        }
        findFirst(val, position) {
          let j = position & BITS_PER_SEGMENT - 1;
          let i = (position - j) / BITS_PER_SEGMENT;
          while (i < this._segments.maxLength) {
            const s = this._segments.get(i);
            let index = -1;
            if (s) index = s.findFirst(val, j);
            else if (!val) index = j;
            if (index !== -1) return i * BITS_PER_SEGMENT + index;
            j = 0;
            i++;
          }
          return val ? -1 : this._segments.maxLength * BITS_PER_SEGMENT;
        }
        firstSet(position) {
          return this.findFirst(true, position);
        }
        firstUnset(position) {
          return this.findFirst(false, position);
        }
        findLast(val, position) {
          let j = position & BITS_PER_SEGMENT - 1;
          let i = (position - j) / BITS_PER_SEGMENT;
          while (i >= 0) {
            const s = this._segments.get(i);
            let index = -1;
            if (s) index = s.findLast(val, j);
            else if (!val) index = j;
            if (index !== -1) return i * BITS_PER_SEGMENT + index;
            j = BITS_PER_SEGMENT - 1;
            i--;
          }
          return -1;
        }
        lastSet(position) {
          return this.findLast(true, position);
        }
        lastUnset(position) {
          return this.findLast(false, position);
        }
        count(start, length, val) {
          let j = start & BITS_PER_PAGE - 1;
          let i = (start - j) / BITS_PER_PAGE;
          let c = 0;
          while (length > 0) {
            const p = this._pages.get(i);
            const end = Math.min(j + length, BITS_PER_PAGE);
            const range = end - j;
            if (p) c += p.count(j, range, val);
            else if (!val) c += range;
            j = 0;
            i++;
            length -= range;
          }
          return c;
        }
        countSet(start, length) {
          return this.count(start, length, true);
        }
        countUnset(start, length) {
          return this.count(start, length, false);
        }
        *want(start, length) {
          const j = start & BITS_PER_SEGMENT - 1;
          let i = (start - j) / BITS_PER_SEGMENT;
          while (length > 0) {
            const s = this._segments.get(i);
            if (s) {
              const end = ceilTo(clamp(length / 8, 4096, BYTES_PER_SEGMENT), 4096);
              yield {
                start: i * BITS_PER_SEGMENT,
                bitfield: s.bitfield.subarray(0, end / 4)
              };
            }
            i++;
            length -= BITS_PER_SEGMENT;
          }
        }
        clear() {
          return new Promise((resolve, reject) => {
            this.storage.truncate(0, (err) => {
              if (err) return reject(err);
              this._pages = new BigSparseArray();
              this.unflushed = [];
              resolve();
            });
          });
        }
        close() {
          return new Promise((resolve, reject) => {
            this.storage.close((err) => {
              if (err) reject(err);
              else resolve();
            });
          });
        }
        flush() {
          return new Promise((resolve, reject) => {
            if (!this.unflushed.length) return resolve();
            const self2 = this;
            let missing = this.unflushed.length;
            let error = null;
            for (const page of this.unflushed) {
              const buf = b4a.from(
                page.bitfield.buffer,
                page.bitfield.byteOffset,
                page.bitfield.byteLength
              );
              page.dirty = false;
              this.storage.write(page.index * BYTES_PER_PAGE, buf, done);
            }
            function done(err) {
              if (err) error = err;
              if (--missing) return;
              if (error) return reject(error);
              self2.unflushed = [];
              resolve();
            }
          });
        }
        static open(storage, tree = null) {
          return new Promise((resolve, reject) => {
            storage.stat((err, st) => {
              if (err) return resolve(new Bitfield(storage, null));
              let size = st.size - (st.size & 3);
              if (!size) return resolve(new Bitfield(storage, null));
              if (tree) size = Math.min(size, ceilTo(tree.length / 8, 4096));
              storage.read(0, size, (err2, data) => {
                if (err2) return reject(err2);
                resolve(new Bitfield(storage, data));
              });
            });
          });
        }
      };
      function clamp(n, min, max) {
        return Math.min(Math.max(n, min), max);
      }
      function ceilTo(n, multiple = 1) {
        const remainder = n % multiple;
        if (remainder === 0) return n;
        return n + multiple - remainder;
      }
    }
  });

  // ../../node_modules/bare-dev/node_modules/hypercore/lib/info.js
  var require_info = __commonJS({
    "../../node_modules/bare-dev/node_modules/hypercore/lib/info.js"(exports, module) {
      module.exports = class Info {
        constructor(opts = {}) {
          this.key = opts.key;
          this.discoveryKey = opts.discoveryKey;
          this.length = opts.length || 0;
          this.contiguousLength = opts.contiguousLength || 0;
          this.byteLength = opts.byteLength || 0;
          this.fork = opts.fork || 0;
          this.padding = opts.padding || 0;
          this.storage = opts.storage || null;
        }
        static async from(session, opts = {}) {
          return new Info({
            key: session.key,
            discoveryKey: session.discoveryKey,
            length: session.length,
            contiguousLength: session.contiguousLength,
            byteLength: session.byteLength,
            fork: session.fork,
            padding: session.padding,
            storage: opts.storage ? await this.storage(session) : null
          });
        }
        static async storage(session) {
          const { oplog, tree, blocks, bitfield } = session.core;
          try {
            return {
              oplog: await Info.bytesUsed(oplog.storage),
              tree: await Info.bytesUsed(tree.storage),
              blocks: await Info.bytesUsed(blocks.storage),
              bitfield: await Info.bytesUsed(bitfield.storage)
            };
          } catch {
            return null;
          }
        }
        static bytesUsed(file) {
          return new Promise((resolve, reject) => {
            file.stat((err, st) => {
              if (err) {
                resolve(0);
              } else if (typeof st.blocks !== "number") {
                reject(new Error("cannot determine bytes used"));
              } else {
                resolve(st.blocks * 512);
              }
            });
          });
        }
      };
    }
  });

  // ../../node_modules/bare-dev/node_modules/hypercore/lib/multisig.js
  var require_multisig = __commonJS({
    "../../node_modules/bare-dev/node_modules/hypercore/lib/multisig.js"(exports, module) {
      var c = require_compact_encoding();
      var b4a = require_b4a();
      var flat = require_flat_tree();
      var { multiSignature, multiSignaturev0 } = require_messages2();
      module.exports = {
        assemblev0,
        assemble,
        inflatev0,
        inflate,
        partialSignature,
        signableLength
      };
      function inflatev0(data) {
        return c.decode(multiSignaturev0, data);
      }
      function inflate(data) {
        return c.decode(multiSignature, data);
      }
      async function partialSignature(tree, signer, from, to = tree.length, signature = tree.signature) {
        if (from > tree.length) return null;
        const nodes = to <= from ? null : await upgradeNodes(tree, from, to);
        if (signature.byteLength !== 64) signature = c.decode(multiSignature, signature).proofs[0].signature;
        return {
          signer,
          signature,
          patch: nodes ? to - from : 0,
          nodes
        };
      }
      async function upgradeNodes(tree, from, to) {
        const p = await tree.proof({ upgrade: { start: from, length: to - from } });
        return p.upgrade.nodes;
      }
      function signableLength(lengths, quorum) {
        if (quorum <= 0) quorum = 1;
        if (quorum > lengths.length) return 0;
        return lengths.sort(cmp)[quorum - 1];
      }
      function cmp(a, b) {
        return b - a;
      }
      function assemblev0(inputs) {
        const proofs = [];
        const patch = [];
        for (const u of inputs) {
          proofs.push(compressProof(u, patch));
        }
        return c.encode(multiSignaturev0, { proofs, patch });
      }
      function assemble(inputs) {
        const proofs = [];
        const patch = [];
        const seen = /* @__PURE__ */ new Set();
        for (const u of inputs) {
          if (u.nodes) {
            for (const node of u.nodes) {
              if (seen.has(node.index)) continue;
              seen.add(node.index);
              patch.push(node);
            }
          }
          proofs.push({
            signer: u.signer,
            signature: u.signature,
            patch: u.patch
          });
        }
        return c.encode(multiSignature, { proofs, patch });
      }
      function compareNode(a, b) {
        if (a.index !== b.index) return false;
        if (a.size !== b.size) return false;
        return b4a.equals(a.hash, b.hash);
      }
      function compressProof(proof, nodes) {
        return {
          signer: proof.signer,
          signature: proof.signature,
          patch: proof.patch ? compressUpgrade(proof, nodes) : null
        };
      }
      function compressUpgrade(p, nodes) {
        const u = {
          start: flat.rightSpan(p.nodes[p.nodes.length - 1].index) / 2 + 1,
          length: p.patch,
          nodes: []
        };
        for (const node of p.nodes) {
          let present = false;
          for (let i = 0; i < nodes.length; i++) {
            if (!compareNode(nodes[i], node)) continue;
            u.nodes.push(i);
            present = true;
            break;
          }
          if (present) continue;
          u.nodes.push(nodes.push(node) - 1);
        }
        return u;
      }
    }
  });

  // ../../node_modules/bare-dev/node_modules/hypercore/lib/verifier.js
  var require_verifier = __commonJS({
    "../../node_modules/bare-dev/node_modules/hypercore/lib/verifier.js"(exports, module) {
      var defaultCrypto = require_hypercore_crypto();
      var b4a = require_b4a();
      var c = require_compact_encoding();
      var flat = require_flat_tree();
      var { BAD_ARGUMENT } = require_hypercore_errors();
      var unslab = require_unslab();
      var m = require_messages2();
      var multisig = require_multisig();
      var caps = require_caps();
      var Signer = class {
        constructor(crypto, manifestHash2, version, index, { signature = "ed25519", publicKey, namespace = caps.DEFAULT_NAMESPACE } = {}) {
          if (!publicKey) throw BAD_ARGUMENT("public key is required for a signer");
          if (signature !== "ed25519") throw BAD_ARGUMENT("Only Ed25519 signatures are supported");
          this.crypto = crypto;
          this.manifestHash = manifestHash2;
          this.version = version;
          this.signer = index;
          this.signature = signature;
          this.publicKey = publicKey;
          this.namespace = namespace;
        }
        _ctx() {
          return this.version === 0 ? this.namespace : this.manifestHash;
        }
        verify(batch, signature) {
          return this.crypto.verify(batch.signable(this._ctx()), signature, this.publicKey);
        }
        sign(batch, keyPair) {
          return this.crypto.sign(batch.signable(this._ctx()), keyPair.secretKey);
        }
      };
      var CompatSigner = class extends Signer {
        constructor(crypto, index, signer, legacy) {
          super(crypto, null, 0, index, signer);
          this.legacy = legacy;
        }
        verify(batch, signature) {
          return this.crypto.verify(batch.signableCompat(this.legacy), signature, this.publicKey);
        }
        sign(batch, keyPair) {
          return this.crypto.sign(batch.signableCompat(this.legacy), keyPair.secretKey);
        }
      };
      module.exports = class Verifier {
        constructor(manifestHash2, manifest, { compat = isCompat(manifestHash2, manifest), crypto = defaultCrypto, legacy = false } = {}) {
          const self2 = this;
          this.manifestHash = manifestHash2;
          this.compat = compat || manifest === null;
          this.version = this.compat ? 0 : typeof manifest.version === "number" ? manifest.version : 1;
          this.hash = manifest.hash || "blake2b";
          this.allowPatch = !this.compat && !!manifest.allowPatch;
          this.quorum = this.compat ? 1 : defaultQuorum(manifest);
          this.signers = manifest.signers ? manifest.signers.map(createSigner) : [];
          this.prologue = this.compat ? null : manifest.prologue || null;
          function createSigner(signer, index) {
            return self2.compat ? new CompatSigner(crypto, index, signer, legacy) : new Signer(crypto, manifestHash2, self2.version, index, signer);
          }
        }
        _verifyCompat(batch, signature) {
          if (!signature) return false;
          if (this.compat || !this.allowPatch && this.signers.length === 1) {
            return !!signature && this.signers[0].verify(batch, signature);
          }
          return this._verifyMulti(batch, signature);
        }
        _inflate(signature) {
          if (this.version >= 1) return multisig.inflate(signature);
          const { proofs, patch } = multisig.inflatev0(signature);
          return {
            proofs: proofs.map(proofToVersion1),
            patch
          };
        }
        _verifyMulti(batch, signature) {
          if (!signature || this.quorum === 0) return false;
          const { proofs, patch } = this._inflate(signature);
          if (proofs.length < this.quorum) return false;
          const tried = new Uint8Array(this.signers.length);
          const nodes = this.allowPatch && patch.length ? toMap(patch) : null;
          for (let i = 0; i < this.quorum; i++) {
            const inp = proofs[i];
            let tree = batch;
            if (inp.patch && this.allowPatch) {
              tree = batch.clone();
              const upgrade = generateUpgrade(nodes, batch.length, inp.patch);
              const proof = { fork: tree.fork, block: null, hash: null, seek: null, upgrade, manifest: null };
              try {
                if (!tree.verifyUpgrade(proof)) return false;
              } catch {
                return false;
              }
            }
            if (inp.signer >= this.signers.length || tried[inp.signer]) return false;
            tried[inp.signer] = 1;
            const s = this.signers[inp.signer];
            if (!s.verify(tree, inp.signature)) return false;
          }
          return true;
        }
        verify(batch, signature) {
          if (this.version !== 1) {
            return this._verifyCompat(batch, signature);
          }
          if (this.prologue !== null && batch.length <= this.prologue.length) {
            return batch.length === this.prologue.length && b4a.equals(batch.hash(), this.prologue.hash);
          }
          return this._verifyMulti(batch, signature);
        }
        // NOTE: better api for this that is more ... multisig-ey
        sign(batch, keyPair) {
          if (!keyPair || !keyPair.secretKey) throw BAD_ARGUMENT("No key pair was passed");
          for (const s of this.signers) {
            if (b4a.equals(s.publicKey, keyPair.publicKey)) {
              const signature = s.sign(batch, keyPair);
              if (this.signers.length !== 1 || this.version === 0) return signature;
              return this.assemble([{ signer: 0, signature, patch: 0, nodes: null }]);
            }
          }
          throw BAD_ARGUMENT("Public key is not a declared signer");
        }
        assemble(inputs) {
          return this.version === 0 ? multisig.assemblev0(inputs) : multisig.assemble(inputs);
        }
        static manifestHash(manifest) {
          return manifestHash(manifest);
        }
        static defaultSignerManifest(publicKey) {
          return {
            version: 1,
            hash: "blake2b",
            allowPatch: false,
            quorum: 1,
            signers: [{
              signature: "ed25519",
              namespace: caps.DEFAULT_NAMESPACE,
              publicKey
            }],
            prologue: null
          };
        }
        static fromManifest(manifest, opts) {
          const m2 = this.createManifest(manifest);
          return new this(manifestHash(m2), m2, opts);
        }
        static createManifest(inp) {
          if (!inp) return null;
          const manifest = {
            version: typeof inp.version === "number" ? inp.version : 1,
            hash: "blake2b",
            allowPatch: !!inp.allowPatch,
            quorum: defaultQuorum(inp),
            signers: inp.signers ? inp.signers.map(parseSigner) : [],
            prologue: null
          };
          if (inp.hash && inp.hash !== "blake2b") throw BAD_ARGUMENT("Only Blake2b hashes are supported");
          if (inp.prologue) {
            if (!(b4a.isBuffer(inp.prologue.hash) && inp.prologue.hash.byteLength === 32) || !(inp.prologue.length >= 0)) {
              throw BAD_ARGUMENT("Invalid prologue");
            }
            manifest.prologue = inp.prologue;
            manifest.prologue.hash = unslab(manifest.prologue.hash);
          }
          return manifest;
        }
        static isValidManifest(key, manifest) {
          return b4a.equals(key, manifestHash(manifest));
        }
        static isCompat(key, manifest) {
          return isCompat(key, manifest);
        }
        static sign(manifest, batch, keyPair, opts) {
          return Verifier.fromManifest(manifest, opts).sign(batch, keyPair);
        }
      };
      function toMap(nodes) {
        const m2 = /* @__PURE__ */ new Map();
        for (const node of nodes) m2.set(node.index, node);
        return m2;
      }
      function isCompat(key, manifest) {
        return !!(manifest && manifest.signers.length === 1 && b4a.equals(key, manifest.signers[0].publicKey));
      }
      function defaultQuorum(man) {
        if (typeof man.quorum === "number") return man.quorum;
        if (!man.signers || !man.signers.length) return 0;
        return (man.signers.length >> 1) + 1;
      }
      function generateUpgrade(patch, start, length) {
        const upgrade = { start, length, nodes: null, additionalNodes: [], signature: null };
        const from = start * 2;
        const to = from + length * 2;
        for (const ite = flat.iterator(0); ite.fullRoot(to); ite.nextTree()) {
          if (ite.index + ite.factor / 2 < from) continue;
          if (upgrade.nodes === null && ite.contains(from - 2)) {
            upgrade.nodes = [];
            const root = ite.index;
            const target = from - 2;
            ite.seek(target);
            while (ite.index !== root) {
              ite.sibling();
              if (ite.index > target) upgrade.nodes.push(patch.get(ite.index));
              ite.parent();
            }
            continue;
          }
          if (upgrade.nodes === null) upgrade.nodes = [];
          upgrade.nodes.push(patch.get(ite.index));
        }
        if (upgrade.nodes === null) upgrade.nodes = [];
        return upgrade;
      }
      function parseSigner(signer) {
        validateSigner(signer);
        return {
          signature: "ed25519",
          namespace: unslab(signer.namespace || caps.DEFAULT_NAMESPACE),
          publicKey: unslab(signer.publicKey)
        };
      }
      function validateSigner(signer) {
        if (!signer || !signer.publicKey) throw BAD_ARGUMENT("Signer missing public key");
        if (signer.signature && signer.signature !== "ed25519") throw BAD_ARGUMENT("Only Ed25519 signatures are supported");
      }
      function manifestHash(manifest) {
        const state = { start: 0, end: 32, buffer: null };
        m.manifest.preencode(state, manifest);
        state.buffer = b4a.allocUnsafe(state.end);
        c.raw.encode(state, caps.MANIFEST);
        m.manifest.encode(state, manifest);
        return defaultCrypto.hash(state.buffer);
      }
      function proofToVersion1(proof) {
        return {
          signer: proof.signer,
          signature: proof.signature,
          patch: proof.patch ? proof.patch.length : 0
        };
      }
    }
  });

  // ../../node_modules/bare-dev/node_modules/hypercore/lib/audit.js
  var require_audit = __commonJS({
    "../../node_modules/bare-dev/node_modules/hypercore/lib/audit.js"(exports, module) {
      var hypercoreCrypto = require_hypercore_crypto();
      var flat = require_flat_tree();
      var c = require_compact_encoding();
      var b4a = require_b4a();
      var empty = b4a.alloc(32);
      module.exports = async function auditCore(core) {
        const corrections = {
          tree: 0,
          blocks: 0
        };
        const length = core.header.tree.length;
        const data = await readFullStorage(core.blocks.storage);
        const tree = await readFullStorage(core.tree.storage);
        const valid = new Uint8Array(Math.ceil(tree.byteLength / 40));
        const stack = [];
        for (const r of core.tree.roots) {
          valid[r.index] = 1;
          stack.push(r);
        }
        while (stack.length > 0) {
          const node = stack.pop();
          if ((node.index & 1) === 0) continue;
          const [left, right] = flat.children(node.index);
          const leftNode = getNode(left);
          const rightNode = getNode(right);
          if (!rightNode && !leftNode) continue;
          stack.push(leftNode, rightNode);
          if (valid[node.index]) {
            const hash = hypercoreCrypto.parent(leftNode, rightNode);
            if (b4a.equals(hash, node.hash) && node.size === leftNode.size + rightNode.size) {
              valid[leftNode.index] = 1;
              valid[rightNode.index] = 1;
              continue;
            }
          }
          if (leftNode.size) clearNode(leftNode);
          if (rightNode.size) clearNode(rightNode);
        }
        if (corrections.tree) {
          core.tree.cache.clear();
        }
        let i = 0;
        let nextOffset = -1;
        while (i < length) {
          const has = core.bitfield.get(i);
          if (!has) {
            if (i + 1 === length) break;
            i = core.bitfield.findFirst(true, i + 1);
            if (i < 0) break;
            nextOffset = -1;
            continue;
          }
          if (nextOffset === -1) {
            try {
              nextOffset = await core.tree.byteOffset(i * 2);
            } catch {
              core._setBitfield(i, false);
              corrections.blocks++;
              i++;
              continue;
            }
          }
          const node = getNode(i * 2);
          const blk = data.subarray(nextOffset, nextOffset + node.size);
          const hash = hypercoreCrypto.data(blk);
          nextOffset += blk.byteLength;
          if (!b4a.equals(hash, node.hash)) {
            core._setBitfield(i, false);
            corrections.blocks++;
          }
          i++;
        }
        return corrections;
        function getNode(index) {
          if (index * 40 + 40 > tree.byteLength) return null;
          const state = { start: index * 40, end: index * 40 + 40, buffer: tree };
          const size = c.uint64.decode(state);
          const hash = c.fixed32.decode(state);
          if (size === 0 && hash.equals(empty)) return null;
          return { index, size, hash };
        }
        function clearNode(node) {
          valid[node.index] = 0;
          if (node.size) {
            b4a.fill(tree, 0, node.index * 40, node.index * 40 + 40);
            core.tree.unflushed.set(node.index, core.tree.blankNode(node.index));
            corrections.tree++;
          }
        }
      };
      function readFullStorage(storage) {
        return new Promise((resolve, reject) => {
          storage.stat((_, st) => {
            if (!st) return resolve(b4a.alloc(0));
            storage.read(0, st.size, (err, data) => {
              if (err) reject(err);
              else resolve(data);
            });
          });
        });
      }
    }
  });

  // ../../node_modules/bare-dev/node_modules/hypercore/lib/core.js
  var require_core = __commonJS({
    "../../node_modules/bare-dev/node_modules/hypercore/lib/core.js"(exports, module) {
      var hypercoreCrypto = require_hypercore_crypto();
      var b4a = require_b4a();
      var unslab = require_unslab();
      var Oplog = require_oplog();
      var BigHeader = require_big_header();
      var Mutex = require_mutex();
      var MerkleTree = require_merkle_tree();
      var BlockStore = require_block_store();
      var Bitfield = require_bitfield();
      var RemoteBitfield = require_remote_bitfield();
      var Info = require_info();
      var { BAD_ARGUMENT, STORAGE_EMPTY, STORAGE_CONFLICT, INVALID_OPERATION, INVALID_SIGNATURE, INVALID_CHECKSUM } = require_hypercore_errors();
      var m = require_messages2();
      var Verifier = require_verifier();
      var audit = require_audit();
      module.exports = class Core {
        constructor(header, compat, crypto, oplog, bigHeader, tree, blocks, bitfield, verifier, sessions, legacy, globalCache, onupdate, onconflict) {
          this.onupdate = onupdate;
          this.onconflict = onconflict;
          this.preupdate = null;
          this.header = header;
          this.compat = compat;
          this.crypto = crypto;
          this.oplog = oplog;
          this.bigHeader = bigHeader;
          this.tree = tree;
          this.blocks = blocks;
          this.bitfield = bitfield;
          this.verifier = verifier;
          this.truncating = 0;
          this.updating = false;
          this.closed = false;
          this.skipBitfield = null;
          this.active = sessions.length;
          this.sessions = sessions;
          this.globalCache = globalCache;
          this._manifestFlushed = !!header.manifest;
          this._maxOplogSize = 65536;
          this._autoFlush = 1;
          this._verifies = null;
          this._verifiesFlushed = null;
          this._mutex = new Mutex();
          this._legacy = legacy;
        }
        static async open(storage, opts = {}) {
          const oplogFile = storage("oplog");
          const treeFile = storage("tree");
          const bitfieldFile = storage("bitfield");
          const dataFile = storage("data");
          const headerFile = storage("header");
          try {
            return await this.resume(oplogFile, treeFile, bitfieldFile, dataFile, headerFile, opts);
          } catch (err) {
            await closeAll(oplogFile, treeFile, bitfieldFile, dataFile, headerFile);
            throw err;
          }
        }
        static async resume(oplogFile, treeFile, bitfieldFile, dataFile, headerFile, opts) {
          let overwrite = opts.overwrite === true;
          const force = opts.force === true;
          const createIfMissing = opts.createIfMissing !== false;
          const crypto = opts.crypto || hypercoreCrypto;
          const legacy = !!opts.legacy;
          const oplog = new Oplog(oplogFile, {
            headerEncoding: m.oplog.header,
            entryEncoding: m.oplog.entry,
            readonly: opts.readonly
          });
          let compat = opts.compat === true || opts.compat !== false && !opts.manifest;
          let { header, entries } = await oplog.open();
          if (force && opts.key && header && !b4a.equals(header.key, opts.key)) {
            overwrite = true;
          }
          const bigHeader = new BigHeader(headerFile);
          if (!header || overwrite) {
            if (!createIfMissing) {
              throw STORAGE_EMPTY("No Hypercore is stored here");
            }
            if (compat) {
              if (opts.key && opts.keyPair && !b4a.equals(opts.key, opts.keyPair.publicKey)) {
                throw BAD_ARGUMENT("Key must match publicKey when in compat mode");
              }
            }
            const keyPair = opts.keyPair || (opts.key ? null : crypto.keyPair());
            const defaultManifest = !opts.manifest && (!!opts.compat || !opts.key || !!(keyPair && b4a.equals(opts.key, keyPair.publicKey)));
            const manifest = defaultManifest ? Verifier.defaultSignerManifest(opts.key || keyPair.publicKey) : Verifier.createManifest(opts.manifest);
            header = {
              external: null,
              key: opts.key || (compat ? manifest.signers[0].publicKey : Verifier.manifestHash(manifest)),
              manifest,
              keyPair: keyPair ? { publicKey: keyPair.publicKey, secretKey: keyPair.secretKey || null } : null,
              userData: [],
              tree: {
                fork: 0,
                length: 0,
                rootHash: null,
                signature: null
              },
              hints: {
                reorgs: [],
                contiguousLength: 0
              }
            };
            await flushHeader(oplog, bigHeader, header);
          } else if (header.external) {
            header = await bigHeader.load(header.external);
          }
          header.key = unslab(header.key);
          header.tree.rootHash = unslab(header.tree.rootHash);
          header.tree.signature = unslab(header.tree.signature);
          if (header.keyPair) {
            header.keyPair.publicKey = unslab(header.keyPair.publicKey);
            header.keyPair.secretKey = unslab(header.keyPair.secretKey);
          }
          if (opts.manifest) {
            if (!opts.key && !Verifier.isValidManifest(header.key, Verifier.createManifest(opts.manifest))) {
              throw STORAGE_CONFLICT("Manifest does not hash to provided key");
            }
            if (!header.manifest) header.manifest = opts.manifest;
          }
          if (opts.key && !b4a.equals(header.key, opts.key)) {
            throw STORAGE_CONFLICT("Another Hypercore is stored here");
          }
          if (compat && header.manifest && !Verifier.isCompat(header.key, header.manifest)) {
            compat = false;
          } else if (!compat && header.manifest && Verifier.isCompat(header.key, header.manifest)) {
            compat = true;
          }
          const prologue = header.manifest ? header.manifest.prologue : null;
          const tree = await MerkleTree.open(treeFile, { crypto, prologue, ...header.tree });
          const bitfield = await Bitfield.open(bitfieldFile);
          const blocks = new BlockStore(dataFile, tree);
          if (overwrite) {
            await tree.clear();
            await blocks.clear();
            await bitfield.clear();
            entries = [];
          }
          if (header.hints.contiguousLength === 0) {
            while (bitfield.get(header.hints.contiguousLength)) header.hints.contiguousLength++;
          }
          if (header.manifest) header.manifest = Verifier.createManifest(header.manifest);
          const verifier = header.manifest ? new Verifier(header.key, header.manifest, { crypto, legacy }) : null;
          for (const e of entries) {
            if (e.userData) {
              updateUserData(header.userData, e.userData.key, e.userData.value);
            }
            if (e.treeNodes) {
              for (const node of e.treeNodes) {
                tree.addNode(node);
              }
            }
            if (e.bitfield) {
              bitfield.setRange(e.bitfield.start, e.bitfield.length, !e.bitfield.drop);
              updateContig(header, e.bitfield, bitfield);
            }
            if (e.treeUpgrade) {
              const batch = await tree.truncate(e.treeUpgrade.length, e.treeUpgrade.fork);
              batch.ancestors = e.treeUpgrade.ancestors;
              batch.signature = unslab(e.treeUpgrade.signature);
              addReorgHint(header.hints.reorgs, tree, batch);
              batch.commit();
              header.tree.length = tree.length;
              header.tree.fork = tree.fork;
              header.tree.rootHash = tree.hash();
              header.tree.signature = tree.signature;
            }
          }
          for (const entry of header.userData) {
            entry.value = unslab(entry.value);
          }
          return new this(header, compat, crypto, oplog, bigHeader, tree, blocks, bitfield, verifier, opts.sessions || [], legacy, opts.globalCache || null, opts.onupdate || noop, opts.onconflict || noop);
        }
        async audit() {
          await this._mutex.lock();
          try {
            await this._flushOplog();
            const corrections = await audit(this);
            if (corrections.blocks || corrections.tree) await this._flushOplog();
            return corrections;
          } finally {
            await this._mutex.unlock();
          }
        }
        async setManifest(manifest) {
          await this._mutex.lock();
          try {
            if (manifest && this.header.manifest === null) {
              if (!Verifier.isValidManifest(this.header.key, manifest)) throw INVALID_CHECKSUM("Manifest hash does not match");
              this._setManifest(Verifier.createManifest(manifest), null);
              await this._flushOplog();
            }
          } finally {
            this._mutex.unlock();
          }
        }
        _setManifest(manifest, keyPair) {
          if (!manifest && b4a.equals(keyPair.publicKey, this.header.key)) manifest = Verifier.defaultSignerManifest(this.header.key);
          if (!manifest) return;
          const verifier = new Verifier(this.header.key, manifest, { crypto: this.crypto, legacy: this._legacy });
          if (verifier.prologue) this.tree.setPrologue(verifier.prologue);
          this.header.manifest = manifest;
          this.compat = verifier.compat;
          this.verifier = verifier;
          this._manifestFlushed = false;
          this.onupdate(16, null, null, null);
        }
        _shouldFlush() {
          if (--this._autoFlush <= 0 || this.oplog.byteLength >= this._maxOplogSize) {
            this._autoFlush = 4;
            return true;
          }
          if (!this._manifestFlushed && this.header.manifest) {
            this._manifestFlushed = true;
            return true;
          }
          return false;
        }
        async copyPrologue(src, { additional = [] } = {}) {
          await this._mutex.lock();
          try {
            await src._mutex.lock();
          } catch (err) {
            this._mutex.unlock();
            throw err;
          }
          try {
            const prologue = this.header.manifest && this.header.manifest.prologue;
            if (!prologue) throw INVALID_OPERATION("No prologue present");
            const srcLength = prologue.length - additional.length;
            const srcBatch = srcLength !== src.tree.length ? await src.tree.truncate(srcLength) : src.tree.batch();
            const srcRoots = srcBatch.roots.slice(0);
            const srcByteLength = srcBatch.byteLength;
            for (const blk of additional) srcBatch.append(blk);
            if (!b4a.equals(srcBatch.hash(), prologue.hash)) throw INVALID_OPERATION("Source tree is conflicting");
            const entry = {
              userData: null,
              treeNodes: srcRoots,
              treeUpgrade: null,
              bitfield: null
            };
            if (additional.length) {
              await this.blocks.putBatch(srcLength, additional, srcByteLength);
              entry.treeNodes = entry.treeNodes.concat(srcBatch.nodes);
              entry.bitfield = {
                drop: false,
                start: srcLength,
                length: additional.length
              };
            }
            await this.oplog.append([entry], false);
            this.tree.addNodes(entry.treeNodes);
            if (this.header.tree.length < srcBatch.length) {
              this.header.tree.length = srcBatch.length;
              this.header.tree.rootHash = srcBatch.hash();
              this.tree.length = srcBatch.length;
              this.tree.byteLength = srcBatch.byteLength;
              this.tree.roots = srcBatch.roots;
              this.onupdate(1, null, null, null);
            }
            if (entry.bitfield) {
              this._setBitfieldRange(entry.bitfield.start, entry.bitfield.length, true);
              this.onupdate(0, entry.bitfield, null, null);
            }
            await this._flushOplog();
            let segmentEnd = 0;
            while (segmentEnd < srcLength) {
              const segmentStart = maximumSegmentStart(segmentEnd, src.bitfield, this.bitfield);
              if (segmentStart >= srcLength || segmentStart < 0) break;
              segmentEnd = Math.min(segmentStart + 65536, srcLength, minimumSegmentEnd(segmentStart, src.bitfield, this.bitfield));
              const treeNodes = await src.tree.getNeededNodes(srcLength, segmentStart, segmentEnd);
              const bitfield = {
                drop: false,
                start: segmentStart,
                length: segmentEnd - segmentStart
              };
              const segment = [];
              for (let i = segmentStart; i < segmentEnd; i++) {
                const blk = await src.blocks.get(i);
                segment.push(blk);
              }
              const offset = await src.tree.byteOffset(2 * segmentStart);
              await this.blocks.putBatch(segmentStart, segment, offset);
              const entry2 = {
                userData: null,
                treeNodes,
                treeUpgrade: null,
                bitfield
              };
              await this.oplog.append([entry2], false);
              this.tree.addNodes(treeNodes);
              this._setBitfieldRange(bitfield.start, bitfield.length, true);
              this.onupdate(0, bitfield, null, null);
              await this._flushOplog();
            }
            this.header.userData = src.header.userData.slice(0);
            const contig = Math.min(src.header.hints.contiguousLength, srcBatch.length);
            if (this.header.hints.contiguousLength < contig) this.header.hints.contiguousLength = contig;
            await this._flushOplog();
          } finally {
            src._mutex.unlock();
            this._mutex.unlock();
          }
        }
        async flush() {
          await this._mutex.lock();
          try {
            this._manifestFlushed = true;
            this._autoFlush = 4;
            await this._flushOplog();
          } finally {
            this._mutex.unlock();
          }
        }
        async _flushOplog() {
          await this.bitfield.flush();
          await this.tree.flush();
          return flushHeader(this.oplog, this.bigHeader, this.header);
        }
        _appendBlocks(values) {
          return this.blocks.putBatch(this.tree.length, values, this.tree.byteLength);
        }
        async _writeBlock(batch, index, value) {
          const byteOffset = await batch.byteOffset(index * 2);
          await this.blocks.put(index, value, byteOffset);
        }
        async userData(key, value, flush) {
          await this._mutex.lock();
          try {
            let empty = true;
            for (const u of this.header.userData) {
              if (u.key !== key) continue;
              if (value && b4a.equals(u.value, value)) return;
              empty = false;
              break;
            }
            if (empty && !value) return;
            const entry = {
              userData: { key, value },
              treeNodes: null,
              treeUpgrade: null,
              bitfield: null
            };
            await this.oplog.append([entry], false);
            updateUserData(this.header.userData, key, value);
            if (this._shouldFlush() || flush) await this._flushOplog();
          } finally {
            this._mutex.unlock();
          }
        }
        async truncate(length, fork, { signature, keyPair = this.header.keyPair } = {}) {
          if (this.tree.prologue && length < this.tree.prologue.length) {
            throw INVALID_OPERATION("Truncation breaks prologue");
          }
          this.truncating++;
          await this._mutex.lock();
          if (this.verifier === null && keyPair) this._setManifest(null, keyPair);
          try {
            const batch = await this.tree.truncate(length, fork);
            if (length > 0) batch.signature = signature || this.verifier.sign(batch, keyPair);
            await this._truncate(batch, null);
          } finally {
            this.truncating--;
            this._mutex.unlock();
          }
        }
        async clearBatch() {
          await this._mutex.lock();
          try {
            const len = this.bitfield.findFirst(false, this.tree.length);
            if (len <= this.tree.length) return;
            const batch = await this.tree.truncate(this.tree.length, this.tree.fork);
            batch.signature = this.tree.signature;
            const entry = {
              userData: null,
              treeNodes: batch.nodes,
              treeUpgrade: batch,
              bitfield: {
                drop: true,
                start: batch.ancestors,
                length: len - batch.ancestors
              }
            };
            await this.oplog.append([entry], false);
            this._setBitfieldRange(batch.ancestors, len - batch.ancestors, false);
            batch.commit();
            await this._flushOplog();
          } finally {
            this._mutex.unlock();
          }
        }
        async clear(start, end, cleared) {
          await this._mutex.lock();
          try {
            const entry = {
              userData: null,
              treeNodes: null,
              treeUpgrade: null,
              bitfield: {
                start,
                length: end - start,
                drop: true
              }
            };
            await this.oplog.append([entry], false);
            this._setBitfieldRange(start, end - start, false);
            if (start < this.header.hints.contiguousLength) {
              this.header.hints.contiguousLength = start;
            }
            start = this.bitfield.lastSet(start) + 1;
            end = this.bitfield.firstSet(end);
            if (end === -1) end = this.tree.length;
            if (start >= end || start >= this.tree.length) return;
            const offset = await this.tree.byteOffset(start * 2);
            const endOffset = await this.tree.byteOffset(end * 2);
            const length = endOffset - offset;
            const before = cleared ? await Info.bytesUsed(this.blocks.storage) : null;
            await this.blocks.clear(offset, length);
            const after = cleared ? await Info.bytesUsed(this.blocks.storage) : null;
            if (cleared) cleared.blocks = Math.max(before - after, 0);
            this.onupdate(0, entry.bitfield, null, null);
            if (this._shouldFlush()) await this._flushOplog();
          } finally {
            this._mutex.unlock();
          }
        }
        async purge() {
          return new Promise((resolve, reject) => {
            let missing = 4;
            let error = null;
            this.oplog.storage.unlink(done);
            this.tree.storage.unlink(done);
            this.bitfield.storage.unlink(done);
            this.blocks.storage.unlink(done);
            function done(err) {
              if (err) error = err;
              if (--missing) return;
              if (error) reject(error);
              else resolve();
            }
          });
        }
        async insertBatch(batch, values, { signature, keyPair = this.header.keyPair, pending = false, treeLength = batch.treeLength } = {}) {
          await this._mutex.lock();
          try {
            if (this.verifier === null && keyPair) this._setManifest(null, keyPair);
            if (this.tree.fork !== batch.fork) return null;
            if (this.tree.length > batch.treeLength) {
              if (this.tree.length > batch.length) return null;
              for (const root of this.tree.roots) {
                const batchRoot = await batch.get(root.index);
                if (batchRoot.size !== root.size || !b4a.equals(batchRoot.hash, root.hash)) {
                  return null;
                }
              }
            }
            const adding = batch.length - treeLength;
            batch.upgraded = !pending && batch.length > this.tree.length;
            batch.treeLength = this.tree.length;
            batch.ancestors = this.tree.length;
            if (batch.upgraded && !pending) batch.signature = signature || this.verifier.sign(batch, keyPair);
            let byteOffset = batch.byteLength;
            for (let i = 0; i < adding; i++) byteOffset -= values[i].byteLength;
            if (pending === true) batch.upgraded = false;
            const entry = {
              userData: null,
              treeNodes: batch.nodes,
              treeUpgrade: batch.upgraded ? batch : null,
              bitfield: {
                drop: false,
                start: treeLength,
                length: adding
              }
            };
            await this.blocks.putBatch(treeLength, adding < values.length ? values.slice(0, adding) : values, byteOffset);
            await this.oplog.append([entry], false);
            this._setBitfieldRange(entry.bitfield.start, entry.bitfield.length, true);
            batch.commit();
            if (batch.upgraded) {
              this.header.tree.length = batch.length;
              this.header.tree.rootHash = batch.hash();
              this.header.tree.signature = batch.signature;
            }
            const status = (batch.upgraded ? 1 : 0) | updateContig(this.header, entry.bitfield, this.bitfield);
            if (!pending) {
              if (entry.treeUpgrade && treeLength > batch.treeLength) {
                entry.bitfield.start = batch.treeLength;
                entry.bitfield.length = treeLength - batch.treeLength;
              }
              this.onupdate(status, entry.bitfield, null, null);
            }
            if (this._shouldFlush()) await this._flushOplog();
          } finally {
            this._mutex.unlock();
          }
          return { length: batch.length, byteLength: batch.byteLength };
        }
        async append(values, { signature, keyPair = this.header.keyPair, preappend } = {}) {
          await this._mutex.lock();
          try {
            if (this.verifier === null && keyPair) this._setManifest(null, keyPair);
            if (preappend) await preappend(values);
            if (!values.length) {
              return { length: this.tree.length, byteLength: this.tree.byteLength };
            }
            const batch = this.tree.batch();
            for (const val of values) batch.append(val);
            if (this.tree.prologue && batch.length < this.tree.prologue.length) {
              throw INVALID_OPERATION("Append is not consistent with prologue");
            }
            batch.signature = signature || this.verifier.sign(batch, keyPair);
            const entry = {
              userData: null,
              treeNodes: batch.nodes,
              treeUpgrade: batch,
              bitfield: {
                drop: false,
                start: batch.ancestors,
                length: values.length
              }
            };
            const byteLength = await this._appendBlocks(values);
            await this.oplog.append([entry], false);
            this._setBitfieldRange(batch.ancestors, batch.length - batch.ancestors, true);
            batch.commit();
            this.header.tree.length = batch.length;
            this.header.tree.rootHash = batch.hash();
            this.header.tree.signature = batch.signature;
            const status = 1 | updateContig(this.header, entry.bitfield, this.bitfield);
            this.onupdate(status, entry.bitfield, null, null);
            if (this._shouldFlush()) await this._flushOplog();
            return { length: batch.length, byteLength };
          } finally {
            this._mutex.unlock();
          }
        }
        _verifyBatchUpgrade(batch, manifest) {
          if (!this.header.manifest) {
            if (!manifest && this.compat) manifest = Verifier.defaultSignerManifest(this.header.key);
            if (!manifest || !(Verifier.isValidManifest(this.header.key, manifest) || this.compat && Verifier.isCompat(this.header.key, manifest))) {
              throw INVALID_SIGNATURE("Proof contains an invalid manifest");
            }
          }
          manifest = Verifier.createManifest(manifest);
          const verifier = this.verifier || new Verifier(this.header.key, manifest, { crypto: this.crypto, legacy: this._legacy });
          if (!verifier.verify(batch, batch.signature)) {
            throw INVALID_SIGNATURE("Proof contains an invalid signature");
          }
          if (!this.header.manifest) {
            this.header.manifest = manifest;
            this.compat = verifier.compat;
            this.verifier = verifier;
            this.onupdate(16, null, null, null);
          }
        }
        async _verifyExclusive({ batch, bitfield, value, manifest, from }) {
          this._verifyBatchUpgrade(batch, manifest);
          await this._mutex.lock();
          try {
            if (!batch.commitable()) return false;
            this.updating = true;
            const entry = {
              userData: null,
              treeNodes: batch.nodes,
              treeUpgrade: batch,
              bitfield
            };
            if (this.preupdate !== null) await this.preupdate(batch, this.header.key);
            if (bitfield) await this._writeBlock(batch, bitfield.start, value);
            await this.oplog.append([entry], false);
            let status = 1;
            if (bitfield) {
              this._setBitfield(bitfield.start, true);
              status |= updateContig(this.header, bitfield, this.bitfield);
            }
            batch.commit();
            this.header.tree.fork = batch.fork;
            this.header.tree.length = batch.length;
            this.header.tree.rootHash = batch.hash();
            this.header.tree.signature = batch.signature;
            this.onupdate(status, bitfield, value, from);
            if (this._shouldFlush()) await this._flushOplog();
          } finally {
            this.updating = false;
            this._mutex.unlock();
          }
          return true;
        }
        async _verifyShared() {
          if (!this._verifies.length) return false;
          await this._mutex.lock();
          const verifies = this._verifies;
          this._verifies = null;
          this._verified = null;
          try {
            const entries = [];
            for (const { batch, bitfield, value } of verifies) {
              if (!batch.commitable()) continue;
              if (bitfield) {
                await this._writeBlock(batch, bitfield.start, value);
              }
              entries.push({
                userData: null,
                treeNodes: batch.nodes,
                treeUpgrade: null,
                bitfield
              });
            }
            await this.oplog.append(entries, false);
            for (let i = 0; i < verifies.length; i++) {
              const { batch, bitfield, value, manifest, from } = verifies[i];
              if (!batch.commitable()) {
                verifies[i] = null;
                continue;
              }
              let status = 0;
              if (bitfield) {
                this._setBitfield(bitfield.start, true);
                status = updateContig(this.header, bitfield, this.bitfield);
              }
              if (manifest && this.header.manifest === null) {
                if (!Verifier.isValidManifest(this.header.key, manifest)) throw INVALID_CHECKSUM("Manifest hash does not match");
                this._setManifest(manifest, null);
              }
              batch.commit();
              this.onupdate(status, bitfield, value, from);
            }
            if (this._shouldFlush()) await this._flushOplog();
          } finally {
            this._mutex.unlock();
          }
          return verifies[0] !== null;
        }
        async checkConflict(proof, from) {
          if (this.tree.length < proof.upgrade.length || proof.fork !== this.tree.fork) {
            return false;
          }
          const batch = this.tree.verifyFullyRemote(proof);
          try {
            this._verifyBatchUpgrade(batch, proof.manifest);
          } catch {
            return true;
          }
          const remoteTreeHash = this.crypto.tree(proof.upgrade.nodes);
          const localTreeHash = this.crypto.tree(await this.tree.getRoots(proof.upgrade.length));
          if (b4a.equals(localTreeHash, remoteTreeHash)) return false;
          await this.onconflict(proof);
          return true;
        }
        async verifyReorg(proof) {
          const batch = await this.tree.reorg(proof);
          this._verifyBatchUpgrade(batch, proof.manifest);
          return batch;
        }
        async verify(proof, from) {
          if (proof.fork !== this.tree.fork) return false;
          const batch = await this.tree.verify(proof);
          if (!batch.commitable()) return false;
          const value = proof.block && proof.block.value || null;
          const op = {
            batch,
            bitfield: value && { drop: false, start: proof.block.index, length: 1 },
            value,
            manifest: proof.manifest,
            from
          };
          if (batch.upgraded) return this._verifyExclusive(op);
          if (this._verifies !== null) {
            const verifies = this._verifies;
            const i = verifies.push(op);
            await this._verified;
            return verifies[i] !== null;
          }
          this._verifies = [op];
          this._verified = this._verifyShared();
          return this._verified;
        }
        async reorg(batch, from) {
          if (!batch.commitable()) return false;
          this.truncating++;
          await this._mutex.lock();
          try {
            if (!batch.commitable()) return false;
            await this._truncate(batch, from);
          } finally {
            this.truncating--;
            this._mutex.unlock();
          }
          return true;
        }
        async _truncate(batch, from) {
          const entry = {
            userData: null,
            treeNodes: batch.nodes,
            treeUpgrade: batch,
            bitfield: {
              drop: true,
              start: batch.ancestors,
              length: this.tree.length - batch.ancestors
            }
          };
          await this.oplog.append([entry], false);
          this._setBitfieldRange(batch.ancestors, this.tree.length - batch.ancestors, false);
          addReorgHint(this.header.hints.reorgs, this.tree, batch);
          batch.commit();
          const contigStatus = updateContig(this.header, entry.bitfield, this.bitfield);
          const status = (batch.length > batch.ancestors ? 3 : 2) | contigStatus;
          this.header.tree.fork = batch.fork;
          this.header.tree.length = batch.length;
          this.header.tree.rootHash = batch.hash();
          this.header.tree.signature = batch.signature;
          this.onupdate(status, entry.bitfield, null, from);
          await this._flushOplog();
        }
        openSkipBitfield() {
          if (this.skipBitfield !== null) return this.skipBitfield;
          this.skipBitfield = new RemoteBitfield();
          const buf = this.bitfield.toBuffer(this.tree.length);
          const bitfield = new Uint32Array(buf.buffer, buf.byteOffset, buf.byteLength / 4);
          this.skipBitfield.insert(0, bitfield);
          return this.skipBitfield;
        }
        _setBitfield(index, value) {
          this.bitfield.set(index, value);
          if (this.skipBitfield !== null) this.skipBitfield.set(index, value);
        }
        _setBitfieldRange(start, length, value) {
          this.bitfield.setRange(start, length, value);
          if (this.skipBitfield !== null) this.skipBitfield.setRange(start, length, value);
        }
        async close() {
          this.closed = true;
          await this._mutex.destroy();
          await Promise.allSettled([
            this.oplog.close(),
            this.bitfield.close(),
            this.tree.close(),
            this.blocks.close(),
            this.bigHeader.close()
          ]);
        }
      };
      function updateContig(header, upd, bitfield) {
        const end = upd.start + upd.length;
        let c = header.hints.contiguousLength;
        if (upd.drop) {
          if (c <= end && c > upd.start) {
            c = upd.start;
          }
        } else {
          if (c <= end && c >= upd.start) {
            c = end;
            while (bitfield.get(c)) c++;
          }
        }
        if (c === header.hints.contiguousLength) {
          return 0;
        }
        if (c > header.hints.contiguousLength) {
          header.hints.contiguousLength = c;
          return 4;
        }
        header.hints.contiguousLength = c;
        return 8;
      }
      function addReorgHint(list, tree, batch) {
        if (tree.length === 0 || tree.fork === batch.fork) return;
        while (list.length >= 4) list.shift();
        while (list.length > 0) {
          if (list[list.length - 1].ancestors > batch.ancestors) list.pop();
          else break;
        }
        list.push({ from: tree.fork, to: batch.fork, ancestors: batch.ancestors });
      }
      function updateUserData(list, key, value) {
        value = unslab(value);
        for (let i = 0; i < list.length; i++) {
          if (list[i].key === key) {
            if (value) list[i].value = value;
            else list.splice(i, 1);
            return;
          }
        }
        if (value) list.push({ key, value });
      }
      function closeAll(...storages) {
        let missing = 1;
        let error = null;
        return new Promise((resolve, reject) => {
          for (const s of storages) {
            missing++;
            s.close(done);
          }
          done(null);
          function done(err) {
            if (err) error = err;
            if (--missing) return;
            if (error) reject(error);
            else resolve();
          }
        });
      }
      async function flushHeader(oplog, bigHeader, header) {
        if (header.external) {
          await bigHeader.flush(header);
        }
        try {
          await oplog.flush(header);
        } catch (err) {
          if (err.code !== "OPLOG_HEADER_OVERFLOW") throw err;
          await bigHeader.flush(header);
          await oplog.flush(header);
        }
      }
      function noop() {
      }
      function maximumSegmentStart(start, src, dst) {
        while (true) {
          const a = src.firstSet(start);
          const b = dst.firstUnset(start);
          if (a === -1) return -1;
          if (b === -1) return a;
          if (a < b) {
            start = b;
            continue;
          }
          return a;
        }
      }
      function minimumSegmentEnd(start, src, dst) {
        const a = src.firstUnset(start);
        const b = dst.firstSet(start);
        if (a === -1) return -1;
        if (b === -1) return a;
        return a < b ? a : b;
      }
    }
  });

  // ../../node_modules/bare-dev/node_modules/hypercore/lib/block-encryption.js
  var require_block_encryption = __commonJS({
    "../../node_modules/bare-dev/node_modules/hypercore/lib/block-encryption.js"(exports, module) {
      var sodium = require_sodium_universal2();
      var c = require_compact_encoding();
      var b4a = require_b4a();
      var { BLOCK_ENCRYPTION } = require_caps();
      var nonce = b4a.alloc(sodium.crypto_stream_NONCEBYTES);
      module.exports = class BlockEncryption {
        constructor(encryptionKey, hypercoreKey, { isBlockKey = false, compat = true } = {}) {
          const subKeys = b4a.alloc(2 * sodium.crypto_stream_KEYBYTES);
          this.key = encryptionKey;
          this.blockKey = isBlockKey ? encryptionKey : subKeys.subarray(0, sodium.crypto_stream_KEYBYTES);
          this.blindingKey = subKeys.subarray(sodium.crypto_stream_KEYBYTES);
          this.padding = 8;
          this.compat = compat;
          this.isBlockKey = isBlockKey;
          if (!isBlockKey) {
            if (compat) sodium.crypto_generichash_batch(this.blockKey, [encryptionKey], hypercoreKey);
            else sodium.crypto_generichash_batch(this.blockKey, [BLOCK_ENCRYPTION, hypercoreKey, encryptionKey]);
          }
          sodium.crypto_generichash(this.blindingKey, this.blockKey);
        }
        encrypt(index, block, fork) {
          const padding = block.subarray(0, this.padding);
          block = block.subarray(this.padding);
          c.uint64.encode({ start: 0, end: 8, buffer: padding }, fork);
          c.uint64.encode({ start: 0, end: 8, buffer: nonce }, index);
          nonce.fill(0, 8, 8 + padding.byteLength);
          sodium.crypto_stream_xor(
            padding,
            padding,
            nonce,
            this.blindingKey
          );
          nonce.set(padding, 8);
          sodium.crypto_stream_xor(
            block,
            block,
            nonce,
            this.blockKey
          );
        }
        decrypt(index, block) {
          const padding = block.subarray(0, this.padding);
          block = block.subarray(this.padding);
          c.uint64.encode({ start: 0, end: 8, buffer: nonce }, index);
          nonce.set(padding, 8);
          sodium.crypto_stream_xor(
            block,
            block,
            nonce,
            this.blockKey
          );
        }
      };
    }
  });

  // ../../node_modules/bare-dev/node_modules/hypercore/lib/download.js
  var require_download = __commonJS({
    "../../node_modules/bare-dev/node_modules/hypercore/lib/download.js"(exports, module) {
      module.exports = class Download {
        constructor(req) {
          this.req = req;
        }
        async done() {
          return (await this.req).promise;
        }
        /**
         * Deprecated. Use `range.done()`.
         */
        downloaded() {
          return this.done();
        }
        destroy() {
          this.req.then((req) => req.context && req.context.detach(req), noop);
        }
      };
      function noop() {
      }
    }
  });

  // ../../node_modules/bare-dev/node_modules/hypercore/lib/batch.js
  var require_batch = __commonJS({
    "../../node_modules/bare-dev/node_modules/hypercore/lib/batch.js"(exports, module) {
      var { BLOCK_NOT_AVAILABLE, SESSION_CLOSED } = require_hypercore_errors();
      var EventEmitter = require_bare_node_events();
      var c = require_compact_encoding();
      var b4a = require_b4a();
      var safetyCatch = require_safety_catch();
      module.exports = class HypercoreBatch extends EventEmitter {
        constructor(session, checkoutLength, autoClose, restore, clear) {
          super();
          this.session = session;
          this.opened = false;
          this.closed = false;
          this.opening = null;
          this.closing = null;
          this.writable = true;
          this.autoClose = autoClose;
          this.restore = restore;
          this.fork = 0;
          this._appends = [];
          this._appendsActual = null;
          this._checkoutLength = checkoutLength;
          this._byteLength = 0;
          this._sessionLength = 0;
          this._sessionByteLength = 0;
          this._sessionBatch = null;
          this._cachedBatch = null;
          this._flushing = null;
          this._clear = clear;
          this.opening = this._open();
          this.opening.catch(safetyCatch);
        }
        get id() {
          return this.session.id;
        }
        get key() {
          return this.session.key;
        }
        get discoveryKey() {
          return this.session.discoveryKey;
        }
        get indexedLength() {
          return Math.min(this._sessionLength, this.session.core === null ? 0 : this.session.core.tree.length);
        }
        get flushedLength() {
          return this._sessionLength;
        }
        get indexedByteLength() {
          return this._sessionByteLength;
        }
        get length() {
          return this._sessionLength + this._appends.length;
        }
        get byteLength() {
          return this._sessionByteLength + this._byteLength;
        }
        get core() {
          return this.session.core;
        }
        get manifest() {
          return this.session.manifest;
        }
        ready() {
          return this.opening;
        }
        async _open() {
          await this.session.ready();
          if (this._clear) this._checkoutLength = this.core.tree.length;
          if (this._checkoutLength !== -1) {
            const batch = await this.session.core.tree.restoreBatch(this._checkoutLength);
            batch.treeLength = this._checkoutLength;
            this._sessionLength = batch.length;
            this._sessionByteLength = batch.byteLength;
            this._sessionBatch = batch;
            if (this._clear) await this.core.clearBatch();
          } else {
            const last = this.restore ? this.session.core.bitfield.findFirst(false, this.session.length) : 0;
            if (last > this.session.length) {
              const batch = await this.session.core.tree.restoreBatch(last);
              this._sessionLength = batch.length;
              this._sessionByteLength = batch.byteLength - this.session.padding * batch.length;
              this._sessionBatch = batch;
            } else {
              this._sessionLength = this.session.length;
              this._sessionByteLength = this.session.byteLength;
              this._sessionBatch = this.session.createTreeBatch();
            }
          }
          this._appendsActual = this.session.encryption ? [] : this._appends;
          this.fork = this.session.fork;
          this.opened = true;
          this.emit("ready");
        }
        async has(index) {
          if (this.opened === false) await this.ready();
          if (index >= this._sessionLength) return index < this.length;
          return this.session.has(index);
        }
        async update(opts) {
          if (this.opened === false) await this.ready();
          await this.session.update(opts);
        }
        treeHash() {
          return this._sessionBatch.hash();
        }
        setUserData(key, value, opts) {
          return this.session.setUserData(key, value, opts);
        }
        getUserData(key, opts) {
          return this.session.getUserData(key, opts);
        }
        async info(opts) {
          const session = this.session;
          const info = await session.info(opts);
          info.length = this._sessionLength;
          if (info.contiguousLength >= info.length) {
            info.contiguousLength = info.length += this._appends.length;
          } else {
            info.length += this._appends.length;
          }
          info.byteLength = this._sessionByteLength + this._byteLength;
          return info;
        }
        async seek(bytes, opts = {}) {
          if (this.opened === false) await this.opening;
          if (this.closing) throw SESSION_CLOSED();
          if (bytes < this._sessionByteLength) return await this.session.seek(bytes, { ...opts, tree: this._sessionBatch });
          bytes -= this._sessionByteLength;
          let i = 0;
          for (const blk of this._appends) {
            if (bytes < blk.byteLength) return [this._sessionLength + i, bytes];
            i++;
            bytes -= blk.byteLength;
          }
          if (bytes === 0) return [this._sessionLength + i, 0];
          throw BLOCK_NOT_AVAILABLE();
        }
        async get(index, opts = {}) {
          if (this.opened === false) await this.opening;
          if (this.closing) throw SESSION_CLOSED();
          const length = this._sessionLength;
          if (index < length) {
            return this.session.get(index, { ...opts, tree: this._sessionBatch });
          }
          if (opts && opts.raw) {
            return this._appendsActual[index - length] || null;
          }
          const buffer = this._appends[index - length] || null;
          if (!buffer) throw BLOCK_NOT_AVAILABLE();
          const encoding = opts && opts.valueEncoding && c.from(opts.valueEncoding) || this.session.valueEncoding;
          if (!encoding) return buffer;
          return c.decode(encoding, buffer);
        }
        async _waitForFlush() {
          while (this._flushing) {
            await this._flushing;
            await Promise.resolve();
          }
        }
        async restoreBatch(length, blocks) {
          if (this.opened === false) await this.opening;
          if (length >= this._sessionLength) return this.createTreeBatch(length, blocks);
          return this.session.core.tree.restoreBatch(length);
        }
        _catchupBatch(clone) {
          if (this._cachedBatch === null) this._cachedBatch = this._sessionBatch.clone();
          if (this.length > this._cachedBatch.length) {
            const offset = this._cachedBatch.length - this._sessionBatch.length;
            for (let i = offset; i < this._appendsActual.length; i++) {
              this._cachedBatch.append(this._appendsActual[i]);
            }
          }
          return clone ? this._cachedBatch.clone() : this._cachedBatch;
        }
        createTreeBatch(length, opts = {}) {
          if (Array.isArray(opts)) opts = { blocks: opts };
          const { blocks = [], clone = true } = opts;
          if (!length && length !== 0) length = this.length + blocks.length;
          const maxLength = this.length + blocks.length;
          const b = this._catchupBatch(clone || (blocks.length > 0 || length !== this.length));
          const len = Math.min(length, this.length);
          if (len < this._sessionLength || length > maxLength) return null;
          if (len < b.length) b.checkout(len, this._sessionBatch.roots);
          for (let i = 0; i < length - len; i++) {
            b.append(this._appendsActual === this._appends ? blocks[i] : this._encrypt(b.length, blocks[i]));
          }
          return b;
        }
        async truncate(newLength = 0, opts = {}) {
          if (this.opened === false) await this.opening;
          if (this.closing) throw SESSION_CLOSED();
          await this._waitForFlush();
          if (typeof opts === "number") opts = { fork: opts };
          const { fork = this.fork + 1, force = false } = opts;
          this._cachedBatch = null;
          const length = this._sessionLength;
          if (newLength < length) {
            if (!force) throw new Error("Cannot truncate committed blocks");
            this._appends.length = 0;
            this._byteLength = 0;
            await this.session.truncate(newLength, { fork, force: true, ...opts });
            this._sessionLength = this.session.length;
            this._sessionByteLength = this.session.byteLength;
            this._sessionBatch = this.session.createTreeBatch();
          } else {
            for (let i = newLength - length; i < this._appends.length; i++) this._byteLength -= this._appends[i].byteLength;
            this._appends.length = newLength - length;
          }
          this.fork = fork;
          this.emit("truncate", newLength, this.fork);
        }
        async append(blocks) {
          const session = this.session;
          if (this.opened === false) await this.opening;
          if (this.closing) throw SESSION_CLOSED();
          await this._waitForFlush();
          blocks = Array.isArray(blocks) ? blocks : [blocks];
          const buffers = session.encodeBatch !== null ? session.encodeBatch(blocks) : new Array(blocks.length);
          if (session.encodeBatch === null) {
            for (let i = 0; i < blocks.length; i++) {
              const buffer = this._encode(session.valueEncoding, blocks[i]);
              buffers[i] = buffer;
              this._byteLength += buffer.byteLength;
            }
          }
          if (this._appends !== this._appendsActual) {
            for (let i = 0; i < buffers.length; i++) {
              this._appendsActual.push(this._encrypt(this._sessionLength + this._appendsActual.length, buffers[i]));
            }
          }
          for (const b of buffers) this._appends.push(b);
          const info = { length: this.length, byteLength: this.byteLength };
          this.emit("append");
          return info;
        }
        _encode(enc, val) {
          const state = { start: 0, end: 0, buffer: null };
          if (b4a.isBuffer(val)) {
            if (state.start === 0) return val;
            state.end += val.byteLength;
          } else if (enc) {
            enc.preencode(state, val);
          } else {
            val = b4a.from(val);
            if (state.start === 0) return val;
            state.end += val.byteLength;
          }
          state.buffer = b4a.allocUnsafe(state.end);
          if (enc) enc.encode(state, val);
          else state.buffer.set(val, state.start);
          return state.buffer;
        }
        _encrypt(index, buffer) {
          const block = b4a.allocUnsafe(buffer.byteLength + 8);
          block.set(buffer, 8);
          this.session.encryption.encrypt(index, block, this.fork);
          return block;
        }
        async flush(opts = {}) {
          if (this.opened === false) await this.opening;
          if (this.closing) throw SESSION_CLOSED();
          const { length = this.length, keyPair = this.session.keyPair, signature = null, pending = !signature && !keyPair } = opts;
          while (this._flushing) await this._flushing;
          this._flushing = this._flush(length, keyPair, signature, pending);
          let flushed = false;
          try {
            flushed = await this._flushing;
          } finally {
            this._flushing = null;
          }
          if (this.autoClose) await this.close();
          return flushed;
        }
        async _flush(length, keyPair, signature, pending) {
          if (this._sessionBatch.fork !== this.session.fork) return false;
          if (this.session.replicator._upgrade) {
            for (const req of this.session.replicator._upgrade.inflight) {
              if (req.upgrade && req.upgrade.start + req.upgrade.length > length) {
                return false;
              }
            }
          }
          const flushingLength = Math.min(length - this._sessionLength, this._appends.length);
          if (flushingLength <= 0) {
            if (this._sessionLength > this.core.tree.length && length > this.core.tree.length && !pending) {
              const batch2 = await this.restoreBatch(length);
              const info2 = await this.core.insertBatch(batch2, [], { keyPair, signature, pending, treeLength: length });
              return info2 !== null;
            }
            return true;
          }
          const batch = this.createTreeBatch(this._sessionLength + flushingLength);
          if (batch === null) return false;
          const info = await this.core.insertBatch(batch, this._appendsActual, { keyPair, signature, pending, treeLength: this._sessionLength });
          if (info === null) return false;
          const delta = info.byteLength - this._sessionByteLength;
          const newBatch = info.length !== this.session.length ? await this.session.core.tree.restoreBatch(info.length) : this.session.createTreeBatch();
          this._sessionLength = info.length;
          this._sessionByteLength = info.byteLength;
          this._sessionBatch = newBatch;
          if (this._cachedBatch !== null) this._cachedBatch.prune(info.length);
          const same = this._appends === this._appendsActual;
          this._appends = this._appends.slice(flushingLength);
          this._appendsActual = same ? this._appends : this._appendsActual.slice(flushingLength);
          this._byteLength -= delta;
          this.emit("flush");
          return true;
        }
        close() {
          if (!this.closing) this.closing = this._close();
          return this.closing;
        }
        async _close() {
          this._clearAppends();
          await this.session.close();
          this.closed = true;
          this.emit("close");
        }
        _clearAppends() {
          this._appends = [];
          this._appendsActual = [];
          this._byteLength = 0;
          this.fork = 0;
        }
      };
    }
  });

  // ../../node_modules/bare-dev/node_modules/hypercore/lib/streams.js
  var require_streams3 = __commonJS({
    "../../node_modules/bare-dev/node_modules/hypercore/lib/streams.js"(exports) {
      var { Writable, Readable } = require_streamx();
      var ReadStream = class extends Readable {
        constructor(core, opts = {}) {
          super();
          this.core = core;
          this.start = opts.start || 0;
          this.end = typeof opts.end === "number" ? opts.end : -1;
          this.snapshot = !opts.live && opts.snapshot !== false;
          this.live = !!opts.live;
        }
        _open(cb) {
          this._openP().then(cb, cb);
        }
        _read(cb) {
          this._readP().then(cb, cb);
        }
        async _openP() {
          if (this.end === -1) await this.core.update();
          else await this.core.ready();
          if (this.snapshot && this.end === -1) this.end = this.core.length;
        }
        async _readP() {
          const end = this.live ? -1 : this.end === -1 ? this.core.length : this.end;
          if (end >= 0 && this.start >= end) {
            this.push(null);
            return;
          }
          this.push(await this.core.get(this.start++));
        }
      };
      exports.ReadStream = ReadStream;
      var WriteStream = class extends Writable {
        constructor(core) {
          super();
          this.core = core;
        }
        _writev(batch, cb) {
          this._writevP(batch).then(cb, cb);
        }
        async _writevP(batch) {
          await this.core.append(batch);
        }
      };
      exports.WriteStream = WriteStream;
      var ByteStream = class extends Readable {
        constructor(core, opts = {}) {
          super();
          this._core = core;
          this._index = 0;
          this._range = null;
          this._byteOffset = opts.byteOffset || 0;
          this._byteLength = typeof opts.byteLength === "number" ? opts.byteLength : -1;
          this._prefetch = typeof opts.prefetch === "number" ? opts.prefetch : 32;
          this._applyOffset = this._byteOffset > 0;
        }
        _open(cb) {
          this._openp().then(cb, cb);
        }
        _read(cb) {
          this._readp().then(cb, cb);
        }
        async _openp() {
          if (this._byteLength === -1) {
            await this._core.update();
            this._byteLength = Math.max(this._core.byteLength - this._byteOffset, 0);
          }
        }
        async _readp() {
          let data = null;
          if (this._byteLength === 0) {
            this.push(null);
            return;
          }
          let relativeOffset = 0;
          if (this._applyOffset) {
            this._applyOffset = false;
            const [block, byteOffset] = await this._core.seek(this._byteOffset);
            this._index = block;
            relativeOffset = byteOffset;
          }
          this._predownload(this._index + 1);
          data = await this._core.get(this._index++, { valueEncoding: "binary" });
          if (relativeOffset > 0) data = data.subarray(relativeOffset);
          if (data.byteLength > this._byteLength) data = data.subarray(0, this._byteLength);
          this._byteLength -= data.byteLength;
          this.push(data);
          if (this._byteLength === 0) this.push(null);
        }
        _predownload(index) {
          if (this._range) this._range.destroy();
          this._range = this._core.download({ start: index, end: index + this._prefetch, linear: true });
        }
        _destroy(cb) {
          if (this._range) this._range.destroy();
          cb(null);
        }
      };
      exports.ByteStream = ByteStream;
    }
  });

  // ../../node_modules/bare-dev/node_modules/hypercore/index.js
  var require_hypercore = __commonJS({
    "../../node_modules/bare-dev/node_modules/hypercore/index.js"(exports, module) {
      var { EventEmitter } = require_bare_node_events();
      var RAF = require_random_access_file();
      var isOptions = require_is_options();
      var hypercoreCrypto = require_hypercore_crypto();
      var c = require_compact_encoding();
      var b4a = require_b4a();
      var Xache = require_xache();
      var NoiseSecretStream = require_secret_stream();
      var Protomux = require_protomux();
      var z32 = require_z32();
      var id = require_hypercore_id_encoding();
      var safetyCatch = require_safety_catch();
      var unslab = require_unslab();
      var Replicator = require_replicator();
      var Core = require_core();
      var BlockEncryption = require_block_encryption();
      var Info = require_info();
      var Download = require_download();
      var Batch = require_batch();
      var { manifestHash, createManifest } = require_verifier();
      var { ReadStream, WriteStream, ByteStream } = require_streams3();
      var {
        ASSERTION,
        BAD_ARGUMENT,
        SESSION_CLOSED,
        SESSION_NOT_WRITABLE,
        SNAPSHOT_NOT_AVAILABLE,
        DECODING_ERROR
      } = require_hypercore_errors();
      var promises = Symbol.for("hypercore.promises");
      var inspect = Symbol.for("nodejs.util.inspect.custom");
      var MAX_SUGGESTED_BLOCK_SIZE = 15 * 1024 * 1024;
      module.exports = class Hypercore extends EventEmitter {
        constructor(storage, key, opts) {
          super();
          if (isOptions(storage)) {
            opts = storage;
            storage = null;
            key = opts.key || null;
          } else if (isOptions(key)) {
            opts = key;
            key = opts.key || null;
          }
          if (key && typeof key === "string") key = id.decode(key);
          if (!opts) opts = {};
          if (!storage) storage = opts.storage;
          this[promises] = true;
          this.storage = null;
          this.crypto = opts.crypto || hypercoreCrypto;
          this.core = null;
          this.replicator = null;
          this.encryption = null;
          this.extensions = /* @__PURE__ */ new Map();
          this.cache = createCache(opts.cache);
          this.valueEncoding = null;
          this.encodeBatch = null;
          this.activeRequests = [];
          this.id = null;
          this.key = key || null;
          this.keyPair = opts.keyPair || null;
          this.readable = true;
          this.writable = false;
          this.opened = false;
          this.closed = false;
          this.snapshotted = !!opts.snapshot;
          this.sparse = opts.sparse !== false;
          this.sessions = opts._sessions || [this];
          this.autoClose = !!opts.autoClose;
          this.onwait = opts.onwait || null;
          this.wait = opts.wait !== false;
          this.timeout = opts.timeout || 0;
          this.closing = null;
          this.opening = null;
          this._readonly = opts.writable === false;
          this._preappend = preappend.bind(this);
          this._snapshot = null;
          this._findingPeers = 0;
          this._active = opts.active !== false;
          this.opening = this._openSession(key, storage, opts);
          this.opening.catch(safetyCatch);
        }
        [inspect](depth, opts) {
          let indent = "";
          if (typeof opts.indentationLvl === "number") {
            while (indent.length < opts.indentationLvl) indent += " ";
          }
          let peers = "";
          const min = Math.min(this.peers.length, 5);
          for (let i = 0; i < min; i++) {
            const peer = this.peers[i];
            peers += indent + "    Peer(\n";
            peers += indent + "      remotePublicKey: " + opts.stylize(toHex(peer.remotePublicKey), "string") + "\n";
            peers += indent + "      remoteLength: " + opts.stylize(peer.remoteLength, "number") + "\n";
            peers += indent + "      remoteFork: " + opts.stylize(peer.remoteFork, "number") + "\n";
            peers += indent + "      remoteCanUpgrade: " + opts.stylize(peer.remoteCanUpgrade, "boolean") + "\n";
            peers += indent + "    )\n";
          }
          if (this.peers.length > 5) {
            peers += indent + "  ... and " + (this.peers.length - 5) + " more\n";
          }
          if (peers) peers = "[\n" + peers + indent + "  ]";
          else peers = "[ " + opts.stylize(0, "number") + " ]";
          return this.constructor.name + "(\n" + indent + "  id: " + opts.stylize(this.id, "string") + "\n" + indent + "  key: " + opts.stylize(toHex(this.key), "string") + "\n" + indent + "  discoveryKey: " + opts.stylize(toHex(this.discoveryKey), "string") + "\n" + indent + "  opened: " + opts.stylize(this.opened, "boolean") + "\n" + indent + "  closed: " + opts.stylize(this.closed, "boolean") + "\n" + indent + "  snapshotted: " + opts.stylize(this.snapshotted, "boolean") + "\n" + indent + "  sparse: " + opts.stylize(this.sparse, "boolean") + "\n" + indent + "  writable: " + opts.stylize(this.writable, "boolean") + "\n" + indent + "  length: " + opts.stylize(this.length, "number") + "\n" + indent + "  fork: " + opts.stylize(this.fork, "number") + "\n" + indent + "  sessions: [ " + opts.stylize(this.sessions.length, "number") + " ]\n" + indent + "  activeRequests: [ " + opts.stylize(this.activeRequests.length, "number") + " ]\n" + indent + "  peers: " + peers + "\n" + indent + ")";
        }
        static MAX_SUGGESTED_BLOCK_SIZE = MAX_SUGGESTED_BLOCK_SIZE;
        static key(manifest, { compat, version, namespace } = {}) {
          if (b4a.isBuffer(manifest)) manifest = { version, signers: [{ publicKey: manifest, namespace }] };
          return compat ? manifest.signers[0].publicKey : manifestHash(createManifest(manifest));
        }
        static discoveryKey(key) {
          return hypercoreCrypto.discoveryKey(key);
        }
        static getProtocolMuxer(stream) {
          return stream.noiseStream.userData;
        }
        static createProtocolStream(isInitiator, opts = {}) {
          let outerStream = Protomux.isProtomux(isInitiator) ? isInitiator.stream : isStream(isInitiator) ? isInitiator : opts.stream;
          let noiseStream = null;
          if (outerStream) {
            noiseStream = outerStream.noiseStream;
          } else {
            noiseStream = new NoiseSecretStream(isInitiator, null, opts);
            outerStream = noiseStream.rawStream;
          }
          if (!noiseStream) throw BAD_ARGUMENT("Invalid stream");
          if (!noiseStream.userData) {
            const protocol = Protomux.from(noiseStream);
            if (opts.keepAlive !== false) {
              noiseStream.setKeepAlive(5e3);
            }
            noiseStream.userData = protocol;
          }
          if (opts.ondiscoverykey) {
            noiseStream.userData.pair({ protocol: "hypercore/alpha" }, opts.ondiscoverykey);
          }
          return outerStream;
        }
        static defaultStorage(storage, opts = {}) {
          if (typeof storage !== "string") {
            if (!isRandomAccessClass(storage)) return storage;
            const Cls = storage;
            return (name) => new Cls(name);
          }
          const directory = storage;
          const toLock = opts.unlocked ? null : opts.lock || "oplog";
          const pool = opts.pool || (opts.poolSize ? RAF.createPool(opts.poolSize) : null);
          const rmdir = !!opts.rmdir;
          const writable = opts.writable !== false;
          return createFile;
          function createFile(name) {
            const lock = toLock === null ? false : isFile(name, toLock);
            const sparse = isFile(name, "data") || isFile(name, "bitfield") || isFile(name, "tree");
            return new RAF(name, { directory, lock, sparse, pool: lock ? null : pool, rmdir, writable });
          }
          function isFile(name, n) {
            return name === n || name.endsWith("/" + n);
          }
        }
        snapshot(opts) {
          return this.session({ ...opts, snapshot: true });
        }
        session(opts = {}) {
          if (this.closing) {
            throw SESSION_CLOSED("Cannot make sessions on a closing core");
          }
          const sparse = opts.sparse === false ? false : this.sparse;
          const wait = opts.wait === false ? false : this.wait;
          const writable = opts.writable === false ? false : !this._readonly;
          const onwait = opts.onwait === void 0 ? this.onwait : opts.onwait;
          const timeout = opts.timeout === void 0 ? this.timeout : opts.timeout;
          const Clz = opts.class || Hypercore;
          const s = new Clz(this.storage, this.key, {
            ...opts,
            sparse,
            wait,
            onwait,
            timeout,
            writable,
            _opening: this.opening,
            _sessions: this.sessions
          });
          s._passCapabilities(this);
          if (opts.cache !== false) {
            s.cache = opts.cache === true || !opts.cache ? this.cache : opts.cache;
          }
          if (this.opened) ensureEncryption(s, opts);
          this._addSession(s);
          return s;
        }
        _addSession(s) {
          this.sessions.push(s);
          if (this.core) this.core.active++;
        }
        async setEncryptionKey(encryptionKey, opts) {
          if (!this.opened) await this.opening;
          this.encryption = encryptionKey ? new BlockEncryption(encryptionKey, this.key, { compat: this.core.compat, ...opts }) : null;
        }
        setKeyPair(keyPair) {
          this.keyPair = keyPair;
          this.writable = this._isWritable();
        }
        setActive(bool) {
          const active = !!bool;
          if (active === this._active || this.closing) return;
          this._active = active;
          if (!this.opened) return;
          this.replicator.updateActivity(this._active ? 1 : -1);
        }
        _passCapabilities(o) {
          if (!this.keyPair) this.keyPair = o.keyPair;
          this.crypto = o.crypto;
          this.id = o.id;
          this.key = o.key;
          this.core = o.core;
          this.replicator = o.replicator;
          this.encryption = o.encryption;
          this.writable = this._isWritable();
          this.autoClose = o.autoClose;
          if (this.snapshotted && this.core && !this._snapshot) this._updateSnapshot();
        }
        async _openFromExisting(from, opts) {
          if (!from.opened) await from.opening;
          const sessions = this.sessions;
          for (const s of sessions) {
            s.sessions = from.sessions;
            s._passCapabilities(from);
            s._addSession(s);
          }
          this.storage = from.storage;
          this.replicator.findingPeers += this._findingPeers;
          ensureEncryption(this, opts);
          if (this.encryption && !from.encryption) {
            for (const s of sessions) s.encryption = this.encryption;
          }
        }
        async _openSession(key, storage, opts) {
          const isFirst = !opts._opening;
          if (!isFirst) {
            await opts._opening;
          }
          if (opts.preload) opts = { ...opts, ...await this._retryPreload(opts.preload) };
          if (this.cache === null && opts.cache) this.cache = createCache(opts.cache);
          if (isFirst) {
            await this._openCapabilities(key, storage, opts);
            if (!opts.from) {
              for (let i = 0; i < this.sessions.length; i++) {
                const s = this.sessions[i];
                if (s !== this) s._passCapabilities(this);
              }
            }
          } else {
            ensureEncryption(this, opts);
          }
          if (opts.manifest && !this.core.header.manifest) {
            await this.core.setManifest(opts.manifest);
          }
          this.writable = this._isWritable();
          if (opts.valueEncoding) {
            this.valueEncoding = c.from(opts.valueEncoding);
          }
          if (opts.encodeBatch) {
            this.encodeBatch = opts.encodeBatch;
          }
          if (!this.sparse) this.download({ start: 0, end: -1 });
          if (opts._preready) await opts._preready(this);
          this.replicator.updateActivity(this._active ? 1 : 0);
          this.opened = true;
          this.emit("ready");
        }
        async _retryPreload(preload) {
          while (true) {
            const result = await preload();
            const from = result && result.from;
            if (from) {
              if (!from.opened) await from.ready();
              if (from.closing) continue;
            }
            return result;
          }
        }
        async _openCapabilities(key, storage, opts) {
          if (opts.from) return this._openFromExisting(opts.from, opts);
          const unlocked = !!opts.unlocked;
          this.storage = Hypercore.defaultStorage(opts.storage || storage, { unlocked, writable: !unlocked });
          this.core = await Core.open(this.storage, {
            compat: opts.compat,
            force: opts.force,
            sessions: this.sessions,
            createIfMissing: opts.createIfMissing,
            readonly: unlocked,
            overwrite: opts.overwrite,
            key,
            keyPair: opts.keyPair,
            crypto: this.crypto,
            legacy: opts.legacy,
            manifest: opts.manifest,
            globalCache: opts.globalCache || null,
            // This is a temp option, not to be relied on unless you know what you are doing (no semver guarantees)
            onupdate: this._oncoreupdate.bind(this),
            onconflict: this._oncoreconflict.bind(this)
          });
          if (opts.userData) {
            for (const [key2, value] of Object.entries(opts.userData)) {
              await this.core.userData(key2, value);
            }
          }
          this.key = this.core.header.key;
          this.keyPair = this.core.header.keyPair;
          this.id = z32.encode(this.key);
          this.replicator = new Replicator(this.core, this.key, {
            eagerUpgrade: true,
            notDownloadingLinger: opts.notDownloadingLinger,
            allowFork: opts.allowFork !== false,
            inflightRange: opts.inflightRange,
            onpeerupdate: this._onpeerupdate.bind(this),
            onupload: this._onupload.bind(this),
            oninvalid: this._oninvalid.bind(this)
          });
          this.replicator.findingPeers += this._findingPeers;
          if (!this.encryption && opts.encryptionKey) {
            this.encryption = new BlockEncryption(opts.encryptionKey, this.key, { compat: this.core.compat, isBlockKey: opts.isBlockKey });
          }
        }
        _getSnapshot() {
          if (this.sparse) {
            return {
              length: this.core.tree.length,
              byteLength: this.core.tree.byteLength,
              fork: this.core.tree.fork,
              compatLength: this.core.tree.length
            };
          }
          return {
            length: this.core.header.hints.contiguousLength,
            byteLength: 0,
            fork: this.core.tree.fork,
            compatLength: this.core.header.hints.contiguousLength
          };
        }
        _updateSnapshot() {
          const prev = this._snapshot;
          const next = this._snapshot = this._getSnapshot();
          if (!prev) return true;
          return prev.length !== next.length || prev.fork !== next.fork;
        }
        _isWritable() {
          return !this._readonly && !!(this.keyPair && this.keyPair.secretKey);
        }
        close(err) {
          if (this.closing) return this.closing;
          this.closing = this._close(err || null);
          return this.closing;
        }
        async _close(err) {
          if (this.opened === false) await this.opening;
          const i = this.sessions.indexOf(this);
          if (i === -1) return;
          this.sessions.splice(i, 1);
          this.core.active--;
          this.readable = false;
          this.writable = false;
          this.closed = true;
          this.opened = false;
          const gc = [];
          for (const ext of this.extensions.values()) {
            if (ext.session === this) gc.push(ext);
          }
          for (const ext of gc) ext.destroy();
          if (this.replicator !== null) {
            this.replicator.findingPeers -= this._findingPeers;
            this.replicator.clearRequests(this.activeRequests, err);
            this.replicator.updateActivity(this._active ? -1 : 0);
          }
          this._findingPeers = 0;
          if (this.sessions.length || this.core.active > 0) {
            if (this.sessions.length === 1 && this.core.active === 1 && this.autoClose) await this.sessions[0].close(err);
            this.emit("close", false);
            return;
          }
          if (this.replicator !== null) {
            await this.replicator.destroy();
          }
          await this.core.close();
          this.emit("close", true);
        }
        replicate(isInitiator, opts = {}) {
          if (Protomux.isProtomux(isInitiator)) return this._attachToMuxer(isInitiator, opts);
          if (isStream(isInitiator) && this._isAttached(isInitiator)) return isInitiator;
          const protocolStream = Hypercore.createProtocolStream(isInitiator, opts);
          const noiseStream = protocolStream.noiseStream;
          const protocol = noiseStream.userData;
          const useSession = !!opts.session;
          this._attachToMuxer(protocol, useSession);
          return protocolStream;
        }
        _isAttached(stream) {
          return stream.userData && this.replicator && this.replicator.attached(stream.userData);
        }
        _attachToMuxer(mux, useSession) {
          if (this.opened) {
            this._attachToMuxerOpened(mux, useSession);
          } else {
            this.opening.then(this._attachToMuxerOpened.bind(this, mux, useSession), mux.destroy.bind(mux));
          }
          return mux;
        }
        _attachToMuxerOpened(mux, useSession) {
          this.replicator.attachTo(mux, useSession);
        }
        get discoveryKey() {
          return this.replicator === null ? null : this.replicator.discoveryKey;
        }
        get manifest() {
          return this.core === null ? null : this.core.header.manifest;
        }
        get length() {
          if (this._snapshot) return this._snapshot.length;
          if (this.core === null) return 0;
          if (!this.sparse) return this.contiguousLength;
          return this.core.tree.length;
        }
        get signedLength() {
          return this.length;
        }
        get indexedLength() {
          return this.length;
        }
        /**
         * Deprecated. Use `const { byteLength } = await core.info()`.
         */
        get byteLength() {
          if (this._snapshot) return this._snapshot.byteLength;
          if (this.core === null) return 0;
          if (!this.sparse) return this.contiguousByteLength;
          return this.core.tree.byteLength - this.core.tree.length * this.padding;
        }
        get contiguousLength() {
          return this.core === null ? 0 : Math.min(this.core.tree.length, this.core.header.hints.contiguousLength);
        }
        get contiguousByteLength() {
          return 0;
        }
        get fork() {
          return this.core === null ? 0 : this.core.tree.fork;
        }
        get peers() {
          return this.replicator === null ? [] : this.replicator.peers;
        }
        get encryptionKey() {
          return this.encryption && this.encryption.key;
        }
        get padding() {
          return this.encryption === null ? 0 : this.encryption.padding;
        }
        get globalCache() {
          return this.core && this.core.globalCache;
        }
        ready() {
          return this.opening;
        }
        _onupload(index, value, from) {
          const byteLength = value.byteLength - this.padding;
          for (let i = 0; i < this.sessions.length; i++) {
            this.sessions[i].emit("upload", index, byteLength, from);
          }
        }
        _oninvalid(err, req, res, from) {
          for (let i = 0; i < this.sessions.length; i++) {
            this.sessions[i].emit("verification-error", err, req, res, from);
          }
        }
        async _oncoreconflict(proof, from) {
          await this.replicator.onconflict(from);
          for (const s of this.sessions) s.emit("conflict", proof.upgrade.length, proof.fork, proof);
          const err = new Error("Two conflicting signatures exist for length " + proof.upgrade.length);
          await this._closeAllSessions(err);
        }
        async _closeAllSessions(err) {
          const sessions = [...this.sessions];
          const all = [];
          for (const s of sessions) all.push(s.close(err));
          await Promise.allSettled(all);
        }
        _oncoreupdate(status, bitfield, value, from) {
          if (status !== 0) {
            const truncatedNonSparse = (status & 8) !== 0;
            const appendedNonSparse = (status & 4) !== 0;
            const truncated = (status & 2) !== 0;
            const appended = (status & 1) !== 0;
            if (truncated) {
              this.replicator.ontruncate(bitfield.start, bitfield.length);
            }
            if ((status & 19) !== 0) {
              this.replicator.onupgrade();
            }
            if (status & 16) {
              for (let i = 0; i < this.sessions.length; i++) {
                const s = this.sessions[i];
                if (s.encryption && s.encryption.compat !== this.core.compat) {
                  s.encryption = new BlockEncryption(s.encryption.key, this.key, { compat: this.core.compat, isBlockKey: s.encryption.isBlockKey });
                }
              }
              for (let i = 0; i < this.sessions.length; i++) {
                this.sessions[i].emit("manifest");
              }
            }
            for (let i = 0; i < this.sessions.length; i++) {
              const s = this.sessions[i];
              if (truncated) {
                if (s.cache) s.cache.clear();
                if (s._snapshot && bitfield.start < s._snapshot.compatLength) s._snapshot.compatLength = bitfield.start;
              }
              if (s.sparse ? truncated : truncatedNonSparse) {
                s.emit("truncate", bitfield.start, this.core.tree.fork);
              }
              if (s.sparse ? appended : appendedNonSparse) {
                s.emit("append");
              }
            }
            const contig = this.core.header.hints.contiguousLength;
            if (appendedNonSparse && contig === this.core.tree.length) {
              for (const peer of this.peers) {
                if (peer.broadcastedNonSparse) continue;
                peer.broadcastRange(0, contig);
                peer.broadcastedNonSparse = true;
              }
            }
          }
          if (bitfield) {
            this.replicator.onhave(bitfield.start, bitfield.length, bitfield.drop);
          }
          if (value) {
            const byteLength = value.byteLength - this.padding;
            for (let i = 0; i < this.sessions.length; i++) {
              this.sessions[i].emit("download", bitfield.start, byteLength, from);
            }
          }
        }
        _onpeerupdate(added, peer) {
          const name = added ? "peer-add" : "peer-remove";
          for (let i = 0; i < this.sessions.length; i++) {
            this.sessions[i].emit(name, peer);
            if (added) {
              for (const ext of this.sessions[i].extensions.values()) {
                peer.extensions.set(ext.name, ext);
              }
            }
          }
        }
        async setUserData(key, value, { flush = false } = {}) {
          if (this.opened === false) await this.opening;
          return this.core.userData(key, value, flush);
        }
        async getUserData(key) {
          if (this.opened === false) await this.opening;
          for (const { key: savedKey, value } of this.core.header.userData) {
            if (key === savedKey) return value;
          }
          return null;
        }
        createTreeBatch() {
          return this.core.tree.batch();
        }
        findingPeers() {
          this._findingPeers++;
          if (this.replicator !== null && !this.closing) this.replicator.findingPeers++;
          let once = true;
          return () => {
            if (this.closing || !once) return;
            once = false;
            this._findingPeers--;
            if (this.replicator !== null && --this.replicator.findingPeers === 0) {
              this.replicator.updateAll();
            }
          };
        }
        async info(opts) {
          if (this.opened === false) await this.opening;
          return Info.from(this, opts);
        }
        async update(opts) {
          if (this.opened === false) await this.opening;
          if (this.closing !== null) return false;
          if (this.writable && (!opts || opts.force !== true)) {
            if (!this.snapshotted) return false;
            return this._updateSnapshot();
          }
          const remoteWait = this._shouldWait(opts, this.replicator.findingPeers > 0);
          let upgraded = false;
          if (await this.replicator.applyPendingReorg()) {
            upgraded = true;
          }
          if (!upgraded && remoteWait) {
            const activeRequests = opts && opts.activeRequests || this.activeRequests;
            const req = this.replicator.addUpgrade(activeRequests);
            upgraded = await req.promise;
          }
          if (!upgraded) return false;
          if (this.snapshotted) return this._updateSnapshot();
          return true;
        }
        batch({ checkout = -1, autoClose = true, session = true, restore = false, clear = false } = {}) {
          return new Batch(session ? this.session() : this, checkout, autoClose, restore, clear);
        }
        async seek(bytes, opts) {
          if (this.opened === false) await this.opening;
          if (!isValidIndex(bytes)) throw ASSERTION("seek is invalid");
          const tree = opts && opts.tree || this.core.tree;
          const s = tree.seek(bytes, this.padding);
          const offset = await s.update();
          if (offset) return offset;
          if (this.closing !== null) throw SESSION_CLOSED();
          if (!this._shouldWait(opts, this.wait)) return null;
          const activeRequests = opts && opts.activeRequests || this.activeRequests;
          const req = this.replicator.addSeek(activeRequests, s);
          const timeout = opts && opts.timeout !== void 0 ? opts.timeout : this.timeout;
          if (timeout) req.context.setTimeout(req, timeout);
          return req.promise;
        }
        async has(start, end = start + 1) {
          if (this.opened === false) await this.opening;
          if (!isValidIndex(start) || !isValidIndex(end)) throw ASSERTION("has range is invalid");
          if (end === start + 1) return this.core.bitfield.get(start);
          const i = this.core.bitfield.firstUnset(start);
          return i === -1 || i >= end;
        }
        async get(index, opts) {
          if (this.opened === false) await this.opening;
          if (!isValidIndex(index)) throw ASSERTION("block index is invalid");
          if (this.closing !== null) throw SESSION_CLOSED();
          if (this._snapshot !== null && index >= this._snapshot.compatLength) throw SNAPSHOT_NOT_AVAILABLE();
          const encoding = opts && opts.valueEncoding && c.from(opts.valueEncoding) || this.valueEncoding;
          let req = this.cache && this.cache.get(index);
          if (!req) req = this._get(index, opts);
          let block = await req;
          if (!block) return null;
          if (opts && opts.raw) return block;
          if (this.encryption && (!opts || opts.decrypt !== false)) {
            block = b4a.from(block);
            this.encryption.decrypt(index, block);
          }
          return this._decode(encoding, block);
        }
        async clear(start, end = start + 1, opts) {
          if (this.opened === false) await this.opening;
          if (this.closing !== null) throw SESSION_CLOSED();
          if (typeof end === "object") {
            opts = end;
            end = start + 1;
          }
          if (!isValidIndex(start) || !isValidIndex(end)) throw ASSERTION("clear range is invalid");
          const cleared = opts && opts.diff ? { blocks: 0 } : null;
          if (start >= end) return cleared;
          if (start >= this.length) return cleared;
          await this.core.clear(start, end, cleared);
          return cleared;
        }
        async purge() {
          await this._closeAllSessions(null);
          await this.core.purge();
        }
        async _get(index, opts) {
          let block;
          if (this.core.bitfield.get(index)) {
            const tree = opts && opts.tree || this.core.tree;
            block = this.core.blocks.get(index, tree);
            if (this.cache) this.cache.set(index, block);
          } else {
            if (!this._shouldWait(opts, this.wait)) return null;
            if (opts && opts.onwait) opts.onwait(index, this);
            if (this.onwait) this.onwait(index, this);
            const activeRequests = opts && opts.activeRequests || this.activeRequests;
            const req = this.replicator.addBlock(activeRequests, index);
            req.snapshot = index < this.length;
            const timeout = opts && opts.timeout !== void 0 ? opts.timeout : this.timeout;
            if (timeout) req.context.setTimeout(req, timeout);
            block = this._cacheOnResolve(index, req.promise, this.core.tree.fork);
          }
          return block;
        }
        async _cacheOnResolve(index, req, fork) {
          const resolved = await req;
          const block = resolved !== null && 2 * resolved.byteLength < resolved.buffer.byteLength ? unslab(resolved) : resolved;
          if (this.cache && fork === this.core.tree.fork) {
            this.cache.set(index, Promise.resolve(block));
          }
          return block;
        }
        _shouldWait(opts, defaultValue) {
          if (opts) {
            if (opts.wait === false) return false;
            if (opts.wait === true) return true;
          }
          return defaultValue;
        }
        createReadStream(opts) {
          return new ReadStream(this, opts);
        }
        createWriteStream(opts) {
          return new WriteStream(this, opts);
        }
        createByteStream(opts) {
          return new ByteStream(this, opts);
        }
        download(range) {
          const req = this._download(range);
          req.catch(safetyCatch);
          return new Download(req);
        }
        async _download(range) {
          if (this.opened === false) await this.opening;
          const activeRequests = range && range.activeRequests || this.activeRequests;
          return this.replicator.addRange(activeRequests, range);
        }
        // NOTE: get rid of this / deprecate it?
        undownload(range) {
          range.destroy(null);
        }
        // NOTE: get rid of this / deprecate it?
        cancel(request) {
        }
        async truncate(newLength = 0, opts = {}) {
          if (this.opened === false) await this.opening;
          const {
            fork = this.core.tree.fork + 1,
            keyPair = this.keyPair,
            signature = null
          } = typeof opts === "number" ? { fork: opts } : opts;
          const writable = !this._readonly && !!(signature || keyPair && keyPair.secretKey);
          if (writable === false && (newLength > 0 || fork !== this.core.tree.fork)) throw SESSION_NOT_WRITABLE();
          await this.core.truncate(newLength, fork, { keyPair, signature });
          this.replicator.updateAll();
        }
        async append(blocks, opts = {}) {
          if (this.opened === false) await this.opening;
          const { keyPair = this.keyPair, signature = null } = opts;
          const writable = !this._readonly && !!(signature || keyPair && keyPair.secretKey);
          if (writable === false) throw SESSION_NOT_WRITABLE();
          blocks = Array.isArray(blocks) ? blocks : [blocks];
          const preappend2 = this.encryption && this._preappend;
          const buffers = this.encodeBatch !== null ? this.encodeBatch(blocks) : new Array(blocks.length);
          if (this.encodeBatch === null) {
            for (let i = 0; i < blocks.length; i++) {
              buffers[i] = this._encode(this.valueEncoding, blocks[i]);
            }
          }
          for (const b of buffers) {
            if (b.byteLength > MAX_SUGGESTED_BLOCK_SIZE) {
              throw BAD_ARGUMENT("Appended block exceeds the maximum suggested block size");
            }
          }
          return this.core.append(buffers, { keyPair, signature, preappend: preappend2 });
        }
        async treeHash(length) {
          if (length === void 0) {
            await this.ready();
            length = this.core.tree.length;
          }
          const roots = await this.core.tree.getRoots(length);
          return this.crypto.tree(roots);
        }
        registerExtension(name, handlers = {}) {
          if (this.extensions.has(name)) {
            const ext2 = this.extensions.get(name);
            ext2.handlers = handlers;
            ext2.encoding = c.from(handlers.encoding || c.buffer);
            ext2.session = this;
            return ext2;
          }
          const ext = {
            name,
            handlers,
            encoding: c.from(handlers.encoding || c.buffer),
            session: this,
            send(message, peer) {
              const buffer = c.encode(this.encoding, message);
              peer.extension(name, buffer);
            },
            broadcast(message) {
              const buffer = c.encode(this.encoding, message);
              for (const peer of this.session.peers) {
                peer.extension(name, buffer);
              }
            },
            destroy() {
              for (const peer of this.session.peers) {
                if (peer.extensions.get(name) === ext) peer.extensions.delete(name);
              }
              this.session.extensions.delete(name);
            },
            _onmessage(state, peer) {
              const m = this.encoding.decode(state);
              if (this.handlers.onmessage) this.handlers.onmessage(m, peer);
            }
          };
          this.extensions.set(name, ext);
          for (const peer of this.peers) {
            peer.extensions.set(name, ext);
          }
          return ext;
        }
        _encode(enc, val) {
          const state = { start: this.padding, end: this.padding, buffer: null };
          if (b4a.isBuffer(val)) {
            if (state.start === 0) return val;
            state.end += val.byteLength;
          } else if (enc) {
            enc.preencode(state, val);
          } else {
            val = b4a.from(val);
            if (state.start === 0) return val;
            state.end += val.byteLength;
          }
          state.buffer = b4a.allocUnsafe(state.end);
          if (enc) enc.encode(state, val);
          else state.buffer.set(val, state.start);
          return state.buffer;
        }
        _decode(enc, block) {
          if (this.padding) block = block.subarray(this.padding);
          try {
            if (enc) return c.decode(enc, block);
          } catch {
            throw DECODING_ERROR();
          }
          return block;
        }
      };
      function isStream(s) {
        return typeof s === "object" && s && typeof s.pipe === "function";
      }
      function isRandomAccessClass(fn) {
        return !!(typeof fn === "function" && fn.prototype && typeof fn.prototype.open === "function");
      }
      function toHex(buf) {
        return buf && b4a.toString(buf, "hex");
      }
      function preappend(blocks) {
        const offset = this.core.tree.length;
        const fork = this.core.tree.fork;
        for (let i = 0; i < blocks.length; i++) {
          this.encryption.encrypt(offset + i, blocks[i], fork);
        }
      }
      function ensureEncryption(core, opts) {
        if (!opts.encryptionKey) return;
        if (core.encryption && b4a.equals(core.encryption.key, opts.encryptionKey) && core.encryption.compat === core.core.compat) return;
        core.encryption = new BlockEncryption(opts.encryptionKey, core.key, { compat: core.core ? core.core.compat : true, isBlockKey: opts.isBlockKey });
      }
      function createCache(cache) {
        return cache === true ? new Xache({ maxSize: 65536, maxAge: 0 }) : cache || null;
      }
      function isValidIndex(index) {
        return index === 0 || index > 0;
      }
    }
  });

  // ../../node_modules/bare-dev/node_modules/hyperdrive/lib/monitor.js
  var require_monitor2 = __commonJS({
    "../../node_modules/bare-dev/node_modules/hyperdrive/lib/monitor.js"(exports, module) {
      var ReadyResource = require_ready_resource();
      var safetyCatch = require_safety_catch();
      var speedometer = require_speedometer();
      module.exports = class Monitor extends ReadyResource {
        constructor(drive, opts = {}) {
          super();
          this.drive = drive;
          this.blobs = null;
          this.name = opts.name || null;
          this.entry = opts.entry || null;
          this.peers = 0;
          this._boundOnUpload = this._onUpload.bind(this);
          this._boundOnDownload = this._onDownload.bind(this);
          this._boundPeerUpdate = this._updatePeers.bind(this);
          const stats = {
            startTime: 0,
            percentage: 0,
            peers: 0,
            speed: 0,
            blocks: 0,
            totalBytes: 0,
            // local + bytes loaded during monitoring
            monitoringBytes: 0,
            // bytes loaded during monitoring
            targetBytes: 0,
            targetBlocks: 0
          };
          this.uploadStats = { ...stats };
          this.downloadStats = { ...stats };
          this.uploadSpeedometer = null;
          this.downloadSpeedometer = null;
          this.ready().catch(safetyCatch);
        }
        async _open() {
          await this.drive.ready();
          this.blobs = await this.drive.getBlobs();
          if (!this.entry && this.name) this.entry = await this.drive.entry(this.name);
          if (this.entry) this._setEntryInfo();
          this.uploadSpeedometer = speedometer();
          this.downloadSpeedometer = speedometer();
          this._updatePeers();
          this.blobs.core.on("peer-add", this._boundPeerUpdate);
          this.blobs.core.on("peer-remove", this._boundPeerUpdate);
          this.blobs.core.on("upload", this._boundOnUpload);
          this.blobs.core.on("download", this._boundOnDownload);
        }
        async _close() {
          this.blobs.core.off("peer-add", this._boundPeerUpdate);
          this.blobs.core.off("peer-remove", this._boundPeerUpdate);
          this.blobs.core.off("upload", this._boundOnUpload);
          this.blobs.core.off("download", this._boundOnDownload);
          this.drive.monitors.delete(this);
        }
        _setEntryInfo() {
          if (!this.downloadStats.targetBytes || !this.downloadStats.targetBlocks) {
            this.downloadStats.targetBytes = this.entry.value.blob.byteLength;
            this.downloadStats.targetBlocks = this.entry.value.blob.blockLength;
          }
          if (!this.uploadStats.targetBytes || !this.uploadStats.targetBlocks) {
            this.uploadStats.targetBytes = this.entry.value.blob.byteLength;
            this.uploadStats.targetBlocks = this.entry.value.blob.blockLength;
          }
        }
        _onUpload(index, bytes, from) {
          this._updateStats(this.uploadSpeedometer, this.uploadStats, index, bytes, from);
        }
        _onDownload(index, bytes, from) {
          this._updateStats(this.downloadSpeedometer, this.downloadStats, index, bytes, from);
        }
        _updatePeers() {
          this.uploadStats.peers = this.downloadStats.peers = this.peers = this.blobs.core.peers.length;
        }
        _updateStats(speed, stats, index, bytes, from) {
          if (!this.entry || this.closing) return;
          if (!isWithinRange(index, this.entry)) return;
          if (!stats.startTime) stats.startTime = Date.now();
          stats.speed = speed(bytes);
          stats.blocks++;
          stats.monitoringBytes += bytes;
          stats.totalBytes += bytes;
          stats.percentage = toFixed(stats.blocks / stats.targetBlocks * 100);
          this.emit("update");
        }
        downloadSpeed() {
          return this.downloadSpeedometer ? this.downloadSpeedometer() : 0;
        }
        uploadSpeed() {
          return this.uploadSpeedometer ? this.uploadSpeedometer() : 0;
        }
      };
      function isWithinRange(index, entry) {
        if (!entry || !entry.value) return;
        const { blockOffset, blockLength } = entry.value.blob;
        return index >= blockOffset && index < blockOffset + blockLength;
      }
      function toFixed(n) {
        return Math.round(n * 100) / 100;
      }
    }
  });

  // ../../node_modules/bare-dev/node_modules/hyperdrive/index.js
  var require_hyperdrive = __commonJS({
    "../../node_modules/bare-dev/node_modules/hyperdrive/index.js"(exports, module) {
      var Hyperbee = require_hyperbee();
      var Hyperblobs = require_hyperblobs();
      var isOptions = require_is_options();
      var { Writable, Readable } = require_streamx();
      var unixPathResolve = require_unix_path_resolve();
      var MirrorDrive = require_mirror_drive();
      var SubEncoder = require_sub_encoder();
      var ReadyResource = require_ready_resource();
      var safetyCatch = require_safety_catch();
      var crypto = require_hypercore_crypto();
      var Hypercore = require_hypercore();
      var { BLOCK_NOT_AVAILABLE, BAD_ARGUMENT } = require_hypercore_errors();
      var Monitor = require_monitor2();
      var keyEncoding = new SubEncoder("files", "utf-8");
      var [BLOBS] = crypto.namespace("hyperdrive", 1);
      module.exports = class Hyperdrive extends ReadyResource {
        constructor(corestore, key, opts = {}) {
          super();
          if (isOptions(key)) {
            opts = key;
            key = null;
          }
          this.corestore = corestore;
          this.db = opts._db || makeBee(key, corestore, opts);
          this.core = this.db.core;
          this.blobs = null;
          this.supportsMetadata = true;
          this.encryptionKey = opts.encryptionKey || null;
          this.monitors = /* @__PURE__ */ new Set();
          this._active = opts.active !== false;
          this._openingBlobs = null;
          this._onwait = opts.onwait || null;
          this._batching = !!(opts._checkout === null && opts._db);
          this._checkout = opts._checkout || null;
          this.ready().catch(safetyCatch);
        }
        [Symbol.asyncIterator]() {
          return this.entries()[Symbol.asyncIterator]();
        }
        static async getDriveKey(corestore) {
          const core = makeBee(void 0, corestore);
          await core.ready();
          const key = core.key;
          await core.close();
          return key;
        }
        static getContentKey(m, key) {
          if (m instanceof Hypercore) {
            if (m.core.compat) return null;
            return Hyperdrive.getContentKey(m.manifest, m.key);
          }
          const manifest = generateContentManifest(m, key);
          if (!manifest) return null;
          return Hypercore.key(manifest);
        }
        _generateBlobsManifest() {
          const m = this.db.core.manifest;
          if (this.db.core.core.compat) return null;
          return generateContentManifest(m, this.core.key);
        }
        get id() {
          return this.core.id;
        }
        get key() {
          return this.core.key;
        }
        get discoveryKey() {
          return this.core.discoveryKey;
        }
        get contentKey() {
          return this.blobs?.core.key;
        }
        get version() {
          return this.db.version;
        }
        get writable() {
          return this.core.writable;
        }
        get readable() {
          return this.core.readable;
        }
        findingPeers() {
          return this.corestore.findingPeers();
        }
        async truncate(version, { blobs = -1 } = {}) {
          if (!this.opened) await this.ready();
          if (version > this.core.length) {
            throw BAD_ARGUMENT("Bad truncation length");
          }
          const blobsVersion = blobs === -1 ? await this.getBlobsLength(version) : blobs;
          const bl = await this.getBlobs();
          if (blobsVersion > bl.core.length) {
            throw BAD_ARGUMENT("Bad truncation length");
          }
          await this.core.truncate(version);
          await bl.core.truncate(blobsVersion);
        }
        async getBlobsLength(checkout) {
          if (!this.opened) await this.ready();
          if (!checkout) checkout = this.version;
          const c = this.db.checkout(checkout);
          try {
            return await getBlobsLength(c);
          } finally {
            await c.close();
          }
        }
        replicate(isInitiator, opts) {
          return this.corestore.replicate(isInitiator, opts);
        }
        update(opts) {
          return this.db.update(opts);
        }
        _makeCheckout(snapshot) {
          return new Hyperdrive(this.corestore, this.key, {
            onwait: this._onwait,
            encryptionKey: this.encryptionKey,
            _checkout: this._checkout || this,
            _db: snapshot
          });
        }
        checkout(version) {
          return this._makeCheckout(this.db.checkout(version));
        }
        batch() {
          return new Hyperdrive(this.corestore, this.key, {
            onwait: this._onwait,
            encryptionKey: this.encryptionKey,
            _checkout: null,
            _db: this.db.batch()
          });
        }
        setActive(bool) {
          const active = !!bool;
          if (active === this._active) return;
          this._active = active;
          this.core.setActive(active);
          if (this.blobs) this.blobs.core.setActive(active);
        }
        async flush() {
          await this.db.flush();
          return this.close();
        }
        async _close() {
          if (this.blobs && (!this._checkout || this.blobs !== this._checkout.blobs)) {
            await this.blobs.core.close();
          }
          await this.db.close();
          if (!this._checkout && !this._batching) {
            await this.corestore.close();
          }
          await this.closeMonitors();
        }
        async _openBlobsFromHeader(opts) {
          if (this.blobs) return true;
          const header = await getBee(this.db).getHeader(opts);
          if (!header) return false;
          if (this.blobs) return true;
          const contentKey = header.metadata && header.metadata.contentFeed && header.metadata.contentFeed.subarray(0, 32);
          const blobsKey = contentKey || Hypercore.key(this._generateBlobsManifest());
          if (!blobsKey || blobsKey.length < 32) throw new Error("Invalid or no Blob store key set");
          const blobsCore = this.corestore.get({
            key: blobsKey,
            cache: false,
            onwait: this._onwait,
            encryptionKey: this.encryptionKey,
            keyPair: !contentKey && this.db.core.writable ? this.db.core.keyPair : null,
            active: this._active
          });
          await blobsCore.ready();
          if (this.closing) {
            await blobsCore.close();
            return false;
          }
          this.blobs = new Hyperblobs(blobsCore);
          this.emit("blobs", this.blobs);
          this.emit("content-key", blobsCore.key);
          return true;
        }
        async _open() {
          if (this._checkout) {
            await this._checkout.ready();
            this.blobs = this._checkout.blobs;
            return;
          }
          await this._openBlobsFromHeader({ wait: false });
          if (this.db.core.writable && !this.blobs) {
            const m = this._generateBlobsManifest();
            const blobsCore = this.corestore.get({
              manifest: m,
              name: m ? null : this.db.core.id + "/blobs",
              // simple trick to avoid blobs clashing if no namespace is provided...
              cache: false,
              onwait: this._onwait,
              encryptionKey: this.encryptionKey,
              compat: this.db.core.core.compat,
              active: this._active,
              keyPair: m && this.db.core.writable ? this.db.core.keyPair : null
            });
            await blobsCore.ready();
            this.blobs = new Hyperblobs(blobsCore);
            if (!m) getBee(this.db).metadata.contentFeed = this.blobs.core.key;
            this.emit("blobs", this.blobs);
            this.emit("content-key", blobsCore.key);
          }
          await this.db.ready();
          if (!this.blobs) {
            this._openingBlobs = this._openBlobsFromHeader();
            this._openingBlobs.catch(safetyCatch);
          }
        }
        async getBlobs() {
          if (this.blobs) return this.blobs;
          if (this._checkout) {
            this.blobs = await this._checkout.getBlobs();
          } else {
            await this.ready();
            await this._openingBlobs;
          }
          return this.blobs;
        }
        monitor(name, opts = {}) {
          const monitor = new Monitor(this, { name, ...opts });
          this.monitors.add(monitor);
          return monitor;
        }
        async closeMonitors() {
          const closing = [];
          for (const monitor of this.monitors) closing.push(monitor.close());
          await Promise.allSettled(closing);
        }
        async get(name, opts) {
          const node = await this.entry(name, opts);
          if (!node?.value.blob) return null;
          await this.getBlobs();
          const res = await this.blobs.get(node.value.blob, opts);
          if (res === null) throw BLOCK_NOT_AVAILABLE();
          return res;
        }
        async put(name, buf, { executable = false, metadata = null } = {}) {
          await this.getBlobs();
          const blob = await this.blobs.put(buf);
          return this.db.put(std(name, false), { executable, linkname: null, blob, metadata }, { keyEncoding });
        }
        async del(name) {
          return this.db.del(std(name, false), { keyEncoding });
        }
        compare(a, b) {
          const diff = a.seq - b.seq;
          return diff > 0 ? 1 : diff < 0 ? -1 : 0;
        }
        async clear(name, opts) {
          if (!this.opened) await this.ready();
          let node = null;
          try {
            node = await this.entry(name, { wait: false });
          } catch {
          }
          if (node === null || this.blobs === null) {
            return opts && opts.diff ? { blocks: 0 } : null;
          }
          return this.blobs.clear(node.value.blob, opts);
        }
        async clearAll(opts) {
          if (!this.opened) await this.ready();
          if (this.blobs === null) {
            return opts && opts.diff ? { blocks: 0 } : null;
          }
          return this.blobs.core.clear(0, this.blobs.core.length, opts);
        }
        async purge() {
          if (this._checkout || this._batch) throw new Error("Can only purge the main session");
          await this.ready();
          await this.close();
          const proms = [this.core.purge()];
          if (this.blobs) proms.push(this.blobs.core.purge());
          await Promise.all(proms);
        }
        async symlink(name, dst, { metadata = null } = {}) {
          return this.db.put(std(name, false), { executable: false, linkname: dst, blob: null, metadata }, { keyEncoding });
        }
        async entry(name, opts) {
          if (!opts || !opts.follow) return this._entry(name, opts);
          for (let i = 0; i < 16; i++) {
            const node = await this._entry(name, opts);
            if (!node || !node.value.linkname) return node;
            name = unixPathResolve(node.key, node.value.linkname);
          }
          throw new Error("Recursive symlink");
        }
        async _entry(name, opts) {
          if (typeof name !== "string") return name;
          return this.db.get(std(name, false), { ...opts, keyEncoding });
        }
        async exists(name) {
          return await this.entry(name) !== null;
        }
        watch(folder) {
          folder = std(folder || "/", true);
          return this.db.watch(prefixRange(folder), { keyEncoding, map: (snap) => this._makeCheckout(snap) });
        }
        diff(length, folder, opts) {
          if (typeof folder === "object" && folder && !opts) return this.diff(length, null, folder);
          folder = std(folder || "/", true);
          return this.db.createDiffStream(length, prefixRange(folder), { ...opts, keyEncoding });
        }
        async downloadDiff(length, folder, opts) {
          const dls = [];
          for await (const entry of this.diff(length, folder, opts)) {
            if (!entry.left) continue;
            const b = entry.left.value.blob;
            if (!b) continue;
            const blobs = await this.getBlobs();
            dls.push(blobs.core.download({ start: b.blockOffset, length: b.blockLength }));
          }
          const proms = [];
          for (const r of dls) proms.push(r.downloaded());
          await Promise.allSettled(proms);
        }
        async downloadRange(dbRanges, blobRanges) {
          const dls = [];
          await this.ready();
          for (const range of dbRanges) {
            dls.push(this.db.core.download(range));
          }
          const blobs = await this.getBlobs();
          for (const range of blobRanges) {
            dls.push(blobs.core.download(range));
          }
          const proms = [];
          for (const r of dls) proms.push(r.downloaded());
          await Promise.allSettled(proms);
        }
        entries(range, opts) {
          const stream = this.db.createReadStream(range, { ...opts, keyEncoding });
          if (opts && opts.ignore) stream._readableState.map = createStreamMapIgnore(opts.ignore);
          return stream;
        }
        async download(folder = "/", opts) {
          if (typeof folder === "object") return this.download(void 0, folder);
          const dls = [];
          const entry = !folder || folder.endsWith("/") ? null : await this.entry(folder);
          if (entry) {
            const b = entry.value.blob;
            if (!b) return;
            const blobs = await this.getBlobs();
            await blobs.core.download({ start: b.blockOffset, length: b.blockLength }).downloaded();
            return;
          }
          for await (const _ of this.list(folder, opts)) {
          }
          for await (const entry2 of this.list(folder, opts)) {
            const b = entry2.value.blob;
            if (!b) continue;
            const blobs = await this.getBlobs();
            dls.push(blobs.core.download({ start: b.blockOffset, length: b.blockLength }));
          }
          const proms = [];
          for (const r of dls) proms.push(r.downloaded());
          await Promise.allSettled(proms);
        }
        // atm always recursive, but we should add some depth thing to it
        list(folder, opts = {}) {
          if (typeof folder === "object") return this.list(void 0, folder);
          folder = std(folder || "/", true);
          const ignore = opts.ignore ? normalizeIgnore(opts.ignore) : null;
          const stream = opts && opts.recursive === false ? shallowReadStream(this.db, folder, false, ignore, opts) : this.entries(prefixRange(folder), { ...opts, ignore });
          return stream;
        }
        readdir(folder, opts) {
          folder = std(folder || "/", true);
          return shallowReadStream(this.db, folder, true, null, opts);
        }
        mirror(out, opts) {
          return new MirrorDrive(this, out, opts);
        }
        createReadStream(name, opts) {
          const self2 = this;
          let destroyed = false;
          let rs = null;
          const stream = new Readable({
            open(cb) {
              self2.getBlobs().then(onblobs, cb);
              function onblobs() {
                self2.entry(name).then(onnode, cb);
              }
              function onnode(node) {
                if (destroyed) return cb(null);
                if (!node) return cb(new Error("Blob does not exist"));
                if (self2.closing) return cb(new Error("Closed"));
                if (!node.value.blob) {
                  stream.push(null);
                  return cb(null);
                }
                rs = self2.blobs.createReadStream(node.value.blob, opts);
                rs.on("data", function(data) {
                  if (!stream.push(data)) rs.pause();
                });
                rs.on("end", function() {
                  stream.push(null);
                });
                rs.on("error", function(err) {
                  stream.destroy(err);
                });
                cb(null);
              }
            },
            read(cb) {
              rs.resume();
              cb(null);
            },
            predestroy() {
              destroyed = true;
              if (rs) rs.destroy();
            }
          });
          return stream;
        }
        createWriteStream(name, { executable = false, metadata = null } = {}) {
          const self2 = this;
          let destroyed = false;
          let ws = null;
          let ondrain = null;
          let onfinish = null;
          const stream = new Writable({
            open(cb) {
              self2.getBlobs().then(onblobs, cb);
              function onblobs() {
                if (destroyed) return cb(null);
                ws = self2.blobs.createWriteStream();
                ws.on("error", function(err) {
                  stream.destroy(err);
                });
                ws.on("close", function() {
                  const err = new Error("Closed");
                  callOndrain(err);
                  callOnfinish(err);
                });
                ws.on("finish", function() {
                  callOnfinish(null);
                });
                ws.on("drain", function() {
                  callOndrain(null);
                });
                cb(null);
              }
            },
            write(data, cb) {
              if (ws.write(data) === true) return cb(null);
              ondrain = cb;
            },
            final(cb) {
              onfinish = cb;
              ws.end();
            },
            predestroy() {
              destroyed = true;
              if (ws) ws.destroy();
            }
          });
          return stream;
          function callOnfinish(err) {
            if (!onfinish) return;
            const cb = onfinish;
            onfinish = null;
            if (err) return cb(err);
            self2.db.put(std(name, false), { executable, linkname: null, blob: ws.id, metadata }, { keyEncoding }).then(() => cb(null), cb);
          }
          function callOndrain(err) {
            if (ondrain) {
              const cb = ondrain;
              ondrain = null;
              cb(err);
            }
          }
        }
        static normalizePath(name) {
          return std(name, false);
        }
      };
      function shallowReadStream(files, folder, keys, ignore, opts) {
        let prev = "/";
        let prevName = "";
        return new Readable({
          async read(cb) {
            let node = null;
            try {
              node = await files.peek(prefixRange(folder, prev), { ...opts, keyEncoding });
            } catch (err) {
              return cb(err);
            }
            if (!node) {
              this.push(null);
              return cb(null);
            }
            const suffix = node.key.slice(folder.length + 1);
            const i = suffix.indexOf("/");
            const name = i === -1 ? suffix : suffix.slice(0, i);
            prev = "/" + name + (i === -1 ? "" : "0");
            if (name === prevName) {
              this._read(cb);
              return;
            }
            prevName = name;
            if (ignore && isIgnored(node.key, ignore)) {
              this._read(cb);
              return;
            }
            this.push(keys ? name : node);
            cb(null);
          }
        });
      }
      function makeBee(key, corestore, opts = {}) {
        const name = key ? void 0 : "db";
        const core = corestore.get({ key, name, exclusive: true, onwait: opts.onwait, encryptionKey: opts.encryptionKey, compat: opts.compat, active: opts.active });
        return new Hyperbee(core, {
          keyEncoding: "utf-8",
          valueEncoding: "json",
          metadata: { contentFeed: null }
        });
      }
      function getBee(bee) {
        return bee.tree || bee;
      }
      function std(name, removeSlash) {
        name = unixPathResolve("/", name);
        if (removeSlash && name.endsWith("/")) name = name.slice(0, -1);
        validateFilename(name);
        return name;
      }
      function validateFilename(name) {
        if (name === "/") throw new Error("Invalid filename: " + name);
      }
      function prefixRange(name, prev = "/") {
        return { gt: name + prev, lt: name + "0" };
      }
      function generateContentManifest(m, key) {
        if (m.version < 1) return null;
        const signers = [];
        if (!key) key = Hypercore.key(m);
        for (const s of m.signers) {
          const namespace = crypto.hash([BLOBS, key, s.namespace]);
          signers.push({ ...s, namespace });
        }
        return {
          version: m.version,
          hash: "blake2b",
          allowPatch: m.allowPatch,
          quorum: m.quorum,
          signers,
          prologue: null
          // NOTE: could be configurable through the header still...
        };
      }
      async function getBlobsLength(db) {
        let length = 0;
        for await (const { value } of db.createReadStream()) {
          const b = value && value.blob;
          if (!b) continue;
          const len = b.blockOffset + b.blockLength;
          if (len > length) length = len;
        }
        return length;
      }
      function normalizeIgnore(ignore) {
        return [].concat(ignore).map((e) => unixPathResolve("/", e));
      }
      function isIgnored(key, ignore) {
        return ignore.some((e) => e === key || key.startsWith(e + "/"));
      }
      function createStreamMapIgnore(ignore) {
        return (node) => {
          return isIgnored(node.key, ignore) ? null : node;
        };
      }
    }
  });

  // ../../node_modules/bare-dev/lib/drive/shared/open.js
  var require_open = __commonJS({
    "../../node_modules/bare-dev/lib/drive/shared/open.js"(exports, module) {
      var path = __require("path");
      var Hyperdrive = require_hyperdrive();
      var Localdrive = require_localdrive();
      var id = require_hypercore_id_encoding();
      module.exports = async function open(key, opts = {}) {
        const {
          store,
          swarm = null,
          cwd = path.resolve(".")
        } = opts;
        if (!isKey(key)) return new Localdrive(path.resolve(cwd, key));
        const drive = new Hyperdrive(store, id.decode(key));
        await drive.ready();
        if (swarm) {
          swarm.join(drive.discoveryKey);
          const done = store.findingPeers();
          swarm.flush().then(done);
          await drive.core.update();
        }
        return drive;
      };
      function isKey(key) {
        return (key.length === 52 || key.length === 64) && key.indexOf("/") === -1 && key.indexOf("\\") === -1 && key.indexOf(".") === -1;
      }
    }
  });

  // ../../node_modules/read-write-mutexify/index.js
  var require_read_write_mutexify = __commonJS({
    "../../node_modules/read-write-mutexify/index.js"(exports, module) {
      var WriteLock = class {
        constructor(parent) {
          this.writing = false;
          this._waiting = [];
          this._parent = parent;
          this._wait = pushToQueue.bind(this, this._waiting);
        }
        get locked() {
          return this.writing || this._parent.read.readers > 0;
        }
        get waiting() {
          return this._waiting.length;
        }
        lock() {
          if (this._parent._destroying) {
            return Promise.reject(this._parent._destroyError);
          }
          if (this.writing === false && this._parent.read.readers === 0) {
            this.writing = true;
            return Promise.resolve();
          }
          return new Promise(this._wait);
        }
        unlock() {
          this.writing = false;
          this._parent._bump();
        }
        async flush() {
          if (this.writing === false) return;
          try {
            await this.lock();
          } catch {
            return;
          }
          this.unlock();
        }
      };
      var ReadLock = class {
        constructor(parent) {
          this.readers = 0;
          this._waiting = [];
          this._parent = parent;
          this._wait = pushToQueue.bind(this, this._waiting);
        }
        get locked() {
          return this._parent.writing;
        }
        get waiting() {
          return this._waiting.length;
        }
        lock() {
          if (this._parent._destroying) {
            return Promise.reject(this._parent._destroyError);
          }
          if (this._parent.write.writing === false) {
            this.readers++;
            return Promise.resolve();
          }
          return new Promise(this._wait);
        }
        unlock() {
          this.readers--;
          this._parent._bump();
        }
        async flush() {
          if (this.writing === false) return;
          try {
            await this.lock();
          } catch {
            return;
          }
          this.unlock();
        }
      };
      module.exports = class ReadWriteLock {
        constructor() {
          this.read = new ReadLock(this);
          this.write = new WriteLock(this);
          this._destroyError = null;
          this._destroying = null;
        }
        get destroyed() {
          return !!this._destroying;
        }
        destroy(err) {
          if (this._destroying) return this._destroying;
          this._destroying = Promise.all([this.read.flush(), this.write.flush()]);
          this._destroyError = err || new Error("Mutex has been destroyed");
          if (err) {
            while (this.read._waiting) this._waiting.shift()[1](err);
            while (this.write._waiting) this._waiting.shift()[1](err);
          }
          return this._destroying;
        }
        _bump() {
          if (this.write.writing === false && this.read.readers === 0 && this.write._waiting.length > 0) {
            this.write.writing = true;
            this.write._waiting.shift()[0]();
          }
          while (this.write.writing === false && this.read._waiting.length > 0) {
            this.read.readers++;
            this.read._waiting.shift()[0]();
          }
        }
      };
      function pushToQueue(queue, resolve, reject) {
        queue.push([resolve, reject]);
      }
    }
  });

  // ../../node_modules/bare-dev/node_modules/corestore/index.js
  var require_corestore = __commonJS({
    "../../node_modules/bare-dev/node_modules/corestore/index.js"(exports, module) {
      var safetyCatch = require_safety_catch();
      var crypto = require_hypercore_crypto();
      var sodium = require_sodium_universal2();
      var Hypercore = require_hypercore();
      var hypercoreId = require_hypercore_id_encoding();
      var Xache = require_xache();
      var b4a = require_b4a();
      var ReadyResource = require_ready_resource();
      var RW = require_read_write_mutexify();
      var [NS] = crypto.namespace("corestore", 1);
      var DEFAULT_NAMESPACE = b4a.alloc(32);
      var CORES_DIR = "cores";
      var PRIMARY_KEY_FILE_NAME = "primary-key";
      var USERDATA_NAME_KEY = "corestore/name";
      var USERDATA_NAMESPACE_KEY = "corestore/namespace";
      var POOL_SIZE = 512;
      var DEFAULT_MANIFEST = 0;
      var DEFAULT_COMPAT = true;
      module.exports = class Corestore extends ReadyResource {
        constructor(storage, opts = {}) {
          super();
          const root = opts._root;
          this.storage = Hypercore.defaultStorage(storage, { lock: PRIMARY_KEY_FILE_NAME, poolSize: opts.poolSize || POOL_SIZE, rmdir: true });
          this.cores = root ? root.cores : /* @__PURE__ */ new Map();
          this.cache = !!opts.cache;
          this.primaryKey = opts.primaryKey || null;
          this.passive = !!opts.passive;
          this.manifestVersion = typeof opts.manifestVersion === "number" ? opts.manifestVersion : root ? root.manifestVersion : DEFAULT_MANIFEST;
          this.compat = typeof opts.compat === "boolean" ? opts.compat : root ? root.compat : DEFAULT_COMPAT;
          this.inflightRange = opts.inflightRange || null;
          this.globalCache = opts.globalCache || null;
          this._keyStorage = null;
          this._bootstrap = opts._bootstrap || null;
          this._namespace = opts.namespace || DEFAULT_NAMESPACE;
          this._noCoreCache = root ? root._noCoreCache : new Xache({ maxSize: 65536 });
          this._root = root || this;
          this._replicationStreams = root ? root._replicationStreams : [];
          this._overwrite = opts.overwrite === true;
          this._readonly = opts.writable === false;
          this._attached = opts._attached || null;
          this._notDownloadingLinger = opts.notDownloadingLinger;
          this._sessions = /* @__PURE__ */ new Set();
          this._rootStoreSessions = /* @__PURE__ */ new Set();
          this._locks = root ? root._locks : /* @__PURE__ */ new Map();
          this._findingPeersCount = 0;
          this._findingPeers = [];
          this._isCorestore = true;
          if (this._namespace.byteLength !== 32) throw new Error("Namespace must be a 32-byte Buffer or Uint8Array");
          this.ready().catch(safetyCatch);
        }
        static isCorestore(obj) {
          return !!(typeof obj === "object" && obj && obj._isCorestore);
        }
        static from(storage, opts) {
          return this.isCorestore(storage) ? storage : new this(storage, opts);
        }
        // for now just release the lock...
        async suspend() {
          if (this._root !== this) return this._root.suspend();
          await this.ready();
          if (this._keyStorage !== null) {
            await new Promise((resolve, reject) => {
              this._keyStorage.suspend((err) => {
                if (err) return reject(err);
                resolve();
              });
            });
          }
        }
        async resume() {
          if (this._root !== this) return this._root.resume();
          await this.ready();
          if (this._keyStorage !== null) {
            await new Promise((resolve, reject) => {
              this._keyStorage.open((err) => {
                if (err) return reject(err);
                resolve();
              });
            });
          }
        }
        findingPeers() {
          let done = false;
          this._incFindingPeers();
          return () => {
            if (done) return;
            done = true;
            this._decFindingPeers();
          };
        }
        _emitCore(name, core) {
          this.emit(name, core);
          for (const session of this._root._rootStoreSessions) {
            if (session !== this) {
              session.emit(name, core);
            }
          }
          if (this !== this._root) this._root.emit(name, core);
        }
        _incFindingPeers() {
          if (++this._findingPeersCount !== 1) return;
          for (const core of this._sessions) {
            this._findingPeers.push(core.findingPeers());
          }
        }
        _decFindingPeers() {
          if (--this._findingPeersCount !== 0) return;
          while (this._findingPeers.length > 0) {
            this._findingPeers.pop()();
          }
        }
        async _openNamespaceFromBootstrap() {
          const ns = await this._bootstrap.getUserData(USERDATA_NAMESPACE_KEY);
          if (ns) {
            this._namespace = ns;
          }
        }
        async _open() {
          if (this._root !== this) {
            await this._root.ready();
            if (!this.primaryKey) this.primaryKey = this._root.primaryKey;
            if (this._bootstrap) await this._openNamespaceFromBootstrap();
            return;
          }
          this._keyStorage = this.storage(PRIMARY_KEY_FILE_NAME);
          this.primaryKey = await new Promise((resolve, reject) => {
            this._keyStorage.stat((err, st) => {
              if (err && err.code !== "ENOENT") return reject(err);
              if (err || st.size < 32 || this._overwrite) {
                const key = this.primaryKey || crypto.randomBytes(32);
                return this._keyStorage.write(0, key, (err2) => {
                  if (err2) return reject(err2);
                  return resolve(key);
                });
              }
              this._keyStorage.read(0, 32, (err2, key) => {
                if (err2) return reject(err2);
                if (this.primaryKey) return resolve(this.primaryKey);
                return resolve(key);
              });
            });
          });
          if (this._bootstrap) await this._openNamespaceFromBootstrap();
        }
        async _exists(discoveryKey) {
          const id = b4a.toString(discoveryKey, "hex");
          const storageRoot = getStorageRoot(id);
          const st = this.storage(storageRoot + "/oplog");
          const exists = await new Promise((resolve) => st.stat((err, st2) => resolve(!err && st2.size > 0)));
          await new Promise((resolve) => st.close(resolve));
          return exists;
        }
        async _generateKeys(opts) {
          if (opts._discoveryKey) {
            return {
              manifest: null,
              keyPair: null,
              key: null,
              discoveryKey: opts._discoveryKey
            };
          }
          const keyPair = opts.name ? await this.createKeyPair(opts.name) : opts.secretKey ? { secretKey: opts.secretKey, publicKey: opts.publicKey } : null;
          if (opts.manifest) {
            const key = Hypercore.key(opts.manifest);
            return {
              manifest: opts.manifest,
              keyPair,
              key,
              discoveryKey: crypto.discoveryKey(key)
            };
          }
          if (opts.key) {
            return {
              manifest: null,
              keyPair,
              key: opts.key,
              discoveryKey: crypto.discoveryKey(opts.key)
            };
          }
          const publicKey = opts.publicKey || keyPair.publicKey;
          if (opts.compat === false || opts.compat !== true && !this.compat) {
            let manifest = { version: this.manifestVersion, signers: [{ publicKey }] };
            let key = Hypercore.key(manifest);
            let discoveryKey = crypto.discoveryKey(key);
            if (!await this._exists(discoveryKey) && manifest.version !== 0) {
              const manifestV0 = { version: 0, signers: [{ publicKey }] };
              const keyV0 = Hypercore.key(manifestV0);
              const discoveryKeyV0 = crypto.discoveryKey(keyV0);
              if (await this._exists(discoveryKeyV0)) {
                manifest = manifestV0;
                key = keyV0;
                discoveryKey = discoveryKeyV0;
              }
            }
            return {
              manifest,
              keyPair,
              key,
              discoveryKey
            };
          }
          return {
            manifest: null,
            keyPair,
            key: publicKey,
            discoveryKey: crypto.discoveryKey(publicKey)
          };
        }
        _getPrereadyUserData(core, key) {
          for (const { key: savedKey, value } of core.core.header.userData) {
            if (key === savedKey) return value;
          }
          return null;
        }
        async _preready(core) {
          const name = this._getPrereadyUserData(core, USERDATA_NAME_KEY);
          if (!name) return;
          const namespace = this._getPrereadyUserData(core, USERDATA_NAMESPACE_KEY);
          const keyPair = await this.createKeyPair(b4a.toString(name), namespace);
          core.setKeyPair(keyPair);
        }
        _getLock(id) {
          let rw = this._locks.get(id);
          if (!rw) {
            rw = new RW();
            this._locks.set(id, rw);
          }
          return rw;
        }
        async _preload(id, keys, opts) {
          const { manifest, keyPair, key } = keys;
          while (this.cores.has(id)) {
            const existing = this.cores.get(id);
            if (existing.opened && !existing.closing) return { from: existing, keyPair, manifest, cache: !!opts.cache };
            if (existing.closing) {
              await existing.close();
            } else {
              await existing.ready().catch(safetyCatch);
            }
          }
          const hasKeyPair = !!(keyPair && keyPair.secretKey);
          const userData = {};
          if (opts.name) {
            userData[USERDATA_NAME_KEY] = b4a.from(opts.name);
            userData[USERDATA_NAMESPACE_KEY] = this._namespace;
          }
          const storageRoot = getStorageRoot(id);
          const core = new Hypercore((p) => this.storage(storageRoot + "/" + p), {
            _preready: this._preready.bind(this),
            notDownloadingLinger: this._notDownloadingLinger,
            inflightRange: this.inflightRange,
            autoClose: true,
            active: false,
            encryptionKey: opts.encryptionKey || null,
            isBlockKey: !!opts.isBlockKey,
            userData,
            manifest,
            key,
            compat: opts.compat,
            cache: opts.cache,
            globalCache: this.globalCache,
            createIfMissing: opts.createIfMissing === false ? false : !opts._discoveryKey,
            keyPair: hasKeyPair ? keyPair : null
          });
          if (this._root.closing) {
            try {
              await core.close();
            } catch {
            }
            throw new Error("The corestore is closed");
          }
          this.cores.set(id, core);
          this._noCoreCache.delete(id);
          core.ready().then(() => {
            if (core.closing) return;
            if (hasKeyPair) core.setKeyPair(keyPair);
            this._emitCore("core-open", core);
            if (this.passive) return;
            const ondownloading = () => {
              for (const { stream } of this._replicationStreams) {
                core.replicate(stream, { session: true });
              }
            };
            core.replicator.ondownloading = ondownloading;
            if (core.replicator.downloading) ondownloading();
          }, () => {
            this._noCoreCache.set(id, true);
            this.cores.delete(id);
          });
          core.once("close", () => {
            this._emitCore("core-close", core);
            this.cores.delete(id);
          });
          core.on("conflict", (len, fork, proof) => {
            this.emit("conflict", core, len, fork, proof);
          });
          return { from: core, keyPair, manifest, cache: !!opts.cache };
        }
        async createKeyPair(name, namespace = this._namespace) {
          if (!this.opened) await this.ready();
          const keyPair = {
            publicKey: b4a.allocUnsafeSlow(sodium.crypto_sign_PUBLICKEYBYTES),
            secretKey: b4a.alloc(sodium.crypto_sign_SECRETKEYBYTES)
          };
          const seed = deriveSeed(this.primaryKey, namespace, name);
          sodium.crypto_sign_seed_keypair(keyPair.publicKey, keyPair.secretKey, seed);
          return keyPair;
        }
        get(opts = {}) {
          if (this.closing || this._root.closing) throw new Error("The corestore is closed");
          opts = validateGetOptions(opts);
          if (opts.cache !== false) {
            opts.cache = opts.cache === true || this.cache && !opts.cache ? defaultCache() : opts.cache;
          }
          if (this._readonly && opts.writable !== false) {
            opts.writable = false;
          }
          let rw = null;
          let id = null;
          const core = new Hypercore(null, {
            ...opts,
            globalCache: this.globalCache,
            name: null,
            preload: async () => {
              if (opts.preload) opts = { ...opts, ...await opts.preload() };
              if (!this.opened) await this.ready();
              const keys = await this._generateKeys(opts);
              id = b4a.toString(keys.discoveryKey, "hex");
              rw = opts.exclusive && opts.writable !== false ? this._getLock(id) : null;
              if (rw) await rw.write.lock();
              return await this._preload(id, keys, opts);
            }
          });
          this._sessions.add(core);
          if (this._findingPeersCount > 0) {
            this._findingPeers.push(core.findingPeers());
          }
          const gc = () => {
            this._sessions.delete(core);
            if (!rw) return;
            rw.write.unlock();
            if (!rw.write.locked) this._locks.delete(id);
          };
          core.ready().catch(gc);
          core.once("close", gc);
          return core;
        }
        replicate(isInitiator, opts) {
          const isExternal = isStream(isInitiator) || !!(opts && opts.stream);
          const stream = Hypercore.createProtocolStream(isInitiator, {
            ...opts,
            ondiscoverykey: async (discoveryKey) => {
              if (this.closing) return;
              const id = b4a.toString(discoveryKey, "hex");
              if (this._noCoreCache.get(id)) return;
              const core = this.get({ _discoveryKey: discoveryKey, active: false });
              try {
                await core.ready();
              } catch {
                return;
              }
              if (!core.closing) core.replicate(stream, { session: true });
              await core.close();
            }
          });
          if (!this.passive) {
            const muxer = stream.noiseStream.userData;
            muxer.cork();
            for (const core of this.cores.values()) {
              if (!core.opened || core.closing || !core.replicator.downloading) continue;
              core.replicate(stream, { session: true });
            }
            stream.noiseStream.opened.then(() => muxer.uncork());
          }
          const streamRecord = { stream, isExternal };
          this._replicationStreams.push(streamRecord);
          stream.once("close", () => {
            this._replicationStreams.splice(this._replicationStreams.indexOf(streamRecord), 1);
          });
          return stream;
        }
        namespace(name, opts) {
          if (name instanceof Hypercore) {
            return this.session({ ...opts, _bootstrap: name });
          }
          return this.session({ ...opts, namespace: generateNamespace(this._namespace, name) });
        }
        session(opts) {
          const session = new Corestore(this.storage, {
            namespace: this._namespace,
            cache: this.cache,
            writable: !this._readonly,
            _attached: opts && opts.detach === false ? this : null,
            _root: this._root,
            inflightRange: this.inflightRange,
            globalCache: this.globalCache,
            ...opts
          });
          if (this === this._root) this._rootStoreSessions.add(session);
          return session;
        }
        _closeNamespace() {
          const closePromises = [];
          for (const session of this._sessions) {
            closePromises.push(session.close());
          }
          return Promise.allSettled(closePromises);
        }
        async _closePrimaryNamespace() {
          const closePromises = [];
          for (const { stream, isExternal } of this._replicationStreams) {
            if (!isExternal) stream.destroy();
          }
          for (const core of this.cores.values()) {
            closePromises.push(forceClose(core));
          }
          await Promise.allSettled(closePromises);
          await new Promise((resolve, reject) => {
            this._keyStorage.close((err) => {
              if (err) return reject(err);
              return resolve(null);
            });
          });
        }
        async _close() {
          this._root._rootStoreSessions.delete(this);
          await this._closeNamespace();
          if (this._root === this) {
            await this._closePrimaryNamespace();
          } else if (this._attached) {
            await this._attached.close();
          }
        }
      };
      function validateGetOptions(opts) {
        const key = b4a.isBuffer(opts) || typeof opts === "string" ? hypercoreId.decode(opts) : null;
        if (key) return { key };
        if (opts.key) {
          opts.key = hypercoreId.decode(opts.key);
        }
        if (opts.keyPair) {
          opts.publicKey = opts.keyPair.publicKey;
          opts.secretKey = opts.keyPair.secretKey;
        }
        if (opts.name && typeof opts.name !== "string") throw new Error("name option must be a String");
        if (opts.name && opts.secretKey) throw new Error("Cannot provide both a name and a secret key");
        if (opts.publicKey && !b4a.isBuffer(opts.publicKey)) throw new Error("publicKey option must be a Buffer or Uint8Array");
        if (opts.secretKey && !b4a.isBuffer(opts.secretKey)) throw new Error("secretKey option must be a Buffer or Uint8Array");
        if (!opts._discoveryKey && (!opts.name && !opts.publicKey && !opts.manifest && !opts.key && !opts.preload)) throw new Error("Must provide either a name or a publicKey");
        return opts;
      }
      function generateNamespace(namespace, name) {
        if (!b4a.isBuffer(name)) name = b4a.from(name);
        const out = b4a.allocUnsafeSlow(32);
        sodium.crypto_generichash_batch(out, [namespace, name]);
        return out;
      }
      function deriveSeed(primaryKey, namespace, name) {
        if (!b4a.isBuffer(name)) name = b4a.from(name);
        const out = b4a.alloc(32);
        sodium.crypto_generichash_batch(out, [NS, namespace, name], primaryKey);
        return out;
      }
      function defaultCache() {
        return new Xache({ maxSize: 65536, maxAge: 0 });
      }
      function isStream(s) {
        return typeof s === "object" && s && typeof s.pipe === "function";
      }
      async function forceClose(core) {
        await core.ready();
        return Promise.all(core.sessions.map((s) => s.close()));
      }
      function getStorageRoot(id) {
        return CORES_DIR + "/" + id.slice(0, 2) + "/" + id.slice(2, 4) + "/" + id;
      }
    }
  });

  // ../../node_modules/bare-dev/lib/drive/shared/corestore.js
  var require_corestore2 = __commonJS({
    "../../node_modules/bare-dev/lib/drive/shared/corestore.js"(exports, module) {
      var process2 = __require("process");
      var path = __require("path");
      var Corestore = require_corestore();
      module.exports = function corestore(opts = {}) {
        const {
          corestore: corestore2 = process2.env.BARE_DEV_CORESTORE || "corestore",
          cwd = path.resolve(".")
        } = opts;
        return new Corestore(path.resolve(cwd, corestore2));
      };
    }
  });

  // ../../node_modules/kademlia-routing-table/index.js
  var require_kademlia_routing_table = __commonJS({
    "../../node_modules/kademlia-routing-table/index.js"(exports, module) {
      var { EventEmitter } = require_bare_node_events();
      module.exports = class RoutingTable extends EventEmitter {
        constructor(id, opts) {
          if (!opts) opts = {};
          super();
          this.id = id;
          this.k = opts.k || 20;
          this.size = 0;
          this.rows = new Array(id.length * 8);
        }
        add(node) {
          const i = this._diff(node.id);
          let row = this.rows[i];
          if (!row) {
            row = this.rows[i] = new Row(this, i);
            this.emit("row", row);
          }
          const len = row.nodes.length;
          if (!row.add(node, this.k)) return false;
          this.size += row.nodes.length - len;
          return true;
        }
        remove(id) {
          const i = this._diff(id);
          const row = this.rows[i];
          if (!row) return false;
          if (!row.remove(id)) return false;
          this.size--;
          return true;
        }
        get(id) {
          const i = this._diff(id);
          const row = this.rows[i];
          if (!row) return null;
          return row.get(id);
        }
        has(id) {
          return this.get(id) !== null;
        }
        random() {
          let n = Math.random() * this.size | 0;
          for (let i = 0; i < this.rows.length; i++) {
            const r = this.rows[i];
            if (!r) continue;
            if (n < r.nodes.length) return r.nodes[n];
            n -= r.nodes.length;
          }
          return null;
        }
        closest(id, k) {
          if (!k) k = this.k;
          const result = [];
          const d = this._diff(id);
          for (let i = d; i >= 0 && result.length < k; i--) this._pushNodes(i, k, result);
          for (let i = d + 1; i < this.rows.length && result.length < k; i++) this._pushNodes(i, k, result);
          return result;
        }
        _pushNodes(i, k, result) {
          const row = this.rows[i];
          if (!row) return;
          const missing = Math.min(k - result.length, row.nodes.length);
          for (let j = 0; j < missing; j++) result.push(row.nodes[j]);
        }
        toArray() {
          return this.closest(this.id, Infinity);
        }
        _diff(id) {
          for (let i = 0; i < id.length; i++) {
            const a = id[i];
            const b = this.id[i];
            if (a !== b) return i * 8 + Math.clz32(a ^ b) - 24;
          }
          return this.rows.length - 1;
        }
      };
      var Row = class extends EventEmitter {
        constructor(table, index) {
          super();
          this.data = null;
          this.byteOffset = index >> 3;
          this.index = index;
          this.table = table;
          this.nodes = [];
        }
        add(node) {
          const id = node.id;
          let l = 0;
          let r = this.nodes.length - 1;
          while (l <= r) {
            const m = l + r >> 1;
            const c = this.compare(id, this.nodes[m].id);
            if (c === 0) {
              this.nodes[m] = node;
              return true;
            }
            if (c < 0) r = m - 1;
            else l = m + 1;
          }
          if (this.nodes.length >= this.table.k) {
            this.emit("full", node);
            return false;
          }
          this.insert(l, node);
          return true;
        }
        remove(id) {
          let l = 0;
          let r = this.nodes.length - 1;
          while (l <= r) {
            const m = l + r >> 1;
            const c = this.compare(id, this.nodes[m].id);
            if (c === 0) {
              this.splice(m);
              return true;
            }
            if (c < 0) r = m - 1;
            else l = m + 1;
          }
          return false;
        }
        get(id) {
          let l = 0;
          let r = this.nodes.length - 1;
          while (l <= r) {
            const m = l + r >> 1;
            const node = this.nodes[m];
            const c = this.compare(id, node.id);
            if (c === 0) return node;
            if (c < 0) r = m - 1;
            else l = m + 1;
          }
          return null;
        }
        insert(i, node) {
          this.nodes.push(node);
          for (let j = this.nodes.length - 1; j > i; j--) this.nodes[j] = this.nodes[j - 1];
          this.nodes[i] = node;
          this.emit("add", node);
        }
        splice(i) {
          for (; i < this.nodes.length - 1; i++) this.nodes[i] = this.nodes[i + 1];
          this.emit("remove", this.nodes.pop());
        }
        // very likely they diverge after a couple of bytes so a simple impl, like this is prop fastest vs Buffer.compare
        compare(a, b) {
          for (let i = this.byteOffset; i < a.length; i++) {
            const ai = a[i];
            const bi = b[i];
            if (ai === bi) continue;
            return ai < bi ? -1 : 1;
          }
          return 0;
        }
      };
    }
  });

  // ../../node_modules/time-ordered-set/index.js
  var require_time_ordered_set = __commonJS({
    "../../node_modules/time-ordered-set/index.js"(exports, module) {
      module.exports = class TimeOrderedSet {
        constructor() {
          this.oldest = null;
          this.latest = null;
          this.length = 0;
        }
        has(node) {
          return !!(node.next || node.prev) || node === this.oldest;
        }
        add(node) {
          if (this.has(node)) this.remove(node);
          if (!this.latest && !this.oldest) {
            this.latest = this.oldest = node;
            node.prev = node.next = null;
          } else {
            this.latest.next = node;
            node.prev = this.latest;
            node.next = null;
            this.latest = node;
          }
          this.length++;
          return node;
        }
        remove(node) {
          if (!this.has(node)) return node;
          if (this.oldest !== node && this.latest !== node) {
            node.prev.next = node.next;
            node.next.prev = node.prev;
          } else {
            if (this.oldest === node) {
              this.oldest = node.next;
              if (this.oldest) this.oldest.prev = null;
            }
            if (this.latest === node) {
              this.latest = node.prev;
              if (this.latest) this.latest.next = null;
            }
          }
          node.next = node.prev = null;
          this.length--;
          return node;
        }
        toArray({ limit = Infinity, reverse = false } = {}) {
          const list = [];
          if (reverse) {
            let node = this.latest;
            while (node && limit--) {
              list.push(node);
              node = node.prev;
            }
          } else {
            let node = this.oldest;
            while (node && limit--) {
              list.push(node);
              node = node.next;
            }
          }
          return list;
        }
      };
    }
  });

  // ../../node_modules/udx-native/binding.js
  var require_binding13 = __commonJS({
    "../../node_modules/udx-native/binding.js"(exports, module) {
      __require.addon = require_node2();
      module.exports = __require.addon(".", __filename);
    }
  });

  // ../../node_modules/udx-native/lib/ip.js
  var require_ip = __commonJS({
    "../../node_modules/udx-native/lib/ip.js"(exports) {
      var v4Seg = "(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])";
      var v4Str = `(${v4Seg}[.]){3}${v4Seg}`;
      var IPv4Pattern = new RegExp(`^${v4Str}$`);
      var v6Seg = "(?:[0-9a-fA-F]{1,4})";
      var IPv6Pattern = new RegExp(
        `^((?:${v6Seg}:){7}(?:${v6Seg}|:)|(?:${v6Seg}:){6}(?:${v4Str}|:${v6Seg}|:)|(?:${v6Seg}:){5}(?::${v4Str}|(:${v6Seg}){1,2}|:)|(?:${v6Seg}:){4}(?:(:${v6Seg}){0,1}:${v4Str}|(:${v6Seg}){1,3}|:)|(?:${v6Seg}:){3}(?:(:${v6Seg}){0,2}:${v4Str}|(:${v6Seg}){1,4}|:)|(?:${v6Seg}:){2}(?:(:${v6Seg}){0,3}:${v4Str}|(:${v6Seg}){1,5}|:)|(?:${v6Seg}:){1}(?:(:${v6Seg}){0,4}:${v4Str}|(:${v6Seg}){1,6}|:)|(?::((?::${v6Seg}){0,5}:${v4Str}|(?::${v6Seg}){1,7}|:)))(%[0-9a-zA-Z-.:]{1,})?$`
      );
      var isIPv4 = exports.isIPv4 = function isIPv42(host) {
        return IPv4Pattern.test(host);
      };
      var isIPv6 = exports.isIPv6 = function isIPv62(host) {
        return IPv6Pattern.test(host);
      };
      exports.isIP = function isIP(host) {
        if (isIPv4(host)) return 4;
        if (isIPv6(host)) return 6;
        return 0;
      };
    }
  });

  // ../../node_modules/udx-native/lib/socket.js
  var require_socket = __commonJS({
    "../../node_modules/udx-native/lib/socket.js"(exports, module) {
      var events = require_bare_node_events();
      var b4a = require_b4a();
      var binding = require_binding13();
      var ip = require_ip();
      module.exports = class UDXSocket extends events.EventEmitter {
        constructor(udx, opts = {}) {
          super();
          this.udx = udx;
          this._handle = b4a.alloc(binding.sizeof_udx_napi_socket_t);
          this._inited = false;
          this._host = null;
          this._family = 0;
          this._ipv6Only = opts.ipv6Only === true;
          this._reuseAddress = opts.reuseAddress === true;
          this._port = 0;
          this._reqs = [];
          this._free = [];
          this._closing = null;
          this._closed = false;
          this._view64 = new BigUint64Array(
            this._handle.buffer,
            this._handle.byteOffset,
            this._handle.byteLength >> 3
          );
          this.streams = /* @__PURE__ */ new Set();
          this.userData = null;
        }
        get bound() {
          return this._port !== 0;
        }
        get closing() {
          return this._closing !== null;
        }
        get idle() {
          return this.streams.size === 0;
        }
        get busy() {
          return this.streams.size > 0;
        }
        get bytesTransmitted() {
          if (this._inited !== true) return 0;
          return Number(this._view64[binding.offsetof_udx_socket_t_bytes_tx >> 3]);
        }
        get packetsTransmitted() {
          if (this._inited !== true) return 0;
          return Number(this._view64[binding.offsetof_udx_socket_t_packets_tx >> 3]);
        }
        get bytesReceived() {
          if (this._inited !== true) return 0;
          return Number(this._view64[binding.offsetof_udx_socket_t_bytes_rx >> 3]);
        }
        get packetsReceived() {
          if (this._inited !== true) return 0;
          return Number(this._view64[binding.offsetof_udx_socket_t_packets_rx >> 3]);
        }
        get packetsDroppedByKernel() {
          if (this._inited !== true) return 0;
          return Number(this._view64[binding.offsetof_udx_socket_t_packets_dropped_by_kernel >> 3]);
        }
        toJSON() {
          return {
            bound: this.bound,
            closing: this.closing,
            streams: this.streams.size,
            address: this.address(),
            ipv6Only: this._ipv6Only,
            reuseAddress: this._reuseAddress,
            idle: this.idle,
            busy: this.busy
          };
        }
        _init() {
          if (this._inited) return;
          binding.udx_napi_socket_init(
            this.udx._handle,
            this._handle,
            this,
            this._onsend,
            this._onmessage,
            this._onclose,
            this._reallocMessage
          );
          this._inited = true;
        }
        _onsend(id, err) {
          const req = this._reqs[id];
          const onflush = req.onflush;
          req.buffer = null;
          req.onflush = null;
          this._free.push(id);
          onflush(err >= 0);
          if (this._free.length >= 16 && this._free.length === this._reqs.length) {
            this._free = [];
            this._reqs = [];
          }
        }
        _onmessage(len, port, host, family) {
          this.emit("message", this.udx._consumeMessage(len), { host, family, port });
          return this.udx._buffer;
        }
        _onclose() {
          this.emit("close");
        }
        _reallocMessage() {
          return this.udx._reallocMessage();
        }
        _onidle() {
          this.emit("idle");
        }
        _onbusy() {
          this.emit("busy");
        }
        _addStream(stream) {
          if (this.streams.has(stream)) return false;
          this.streams.add(stream);
          if (this.streams.size === 1) this._onbusy();
          return true;
        }
        _removeStream(stream) {
          if (!this.streams.has(stream)) return false;
          this.streams.delete(stream);
          const closed = this._closeMaybe();
          if (this.idle && !closed) this._onidle();
          return true;
        }
        address() {
          if (!this.bound) return null;
          return { host: this._host, family: this._family, port: this._port };
        }
        bind(port, host) {
          if (this.bound) throw new Error("Already bound");
          if (this.closing) throw new Error("Socket is closed");
          if (!port) port = 0;
          let flags = 0;
          if (this._ipv6Only) flags |= binding.UV_UDP_IPV6ONLY;
          if (this._reuseAddress) flags |= binding.UV_UDP_REUSEADDR;
          let family;
          if (host) {
            family = ip.isIP(host);
            if (!family) throw new Error(`${host} is not a valid IP address`);
            if (!this._inited) this._init();
            this._port = binding.udx_napi_socket_bind(this._handle, port, host, family, flags);
          } else {
            if (!this._inited) this._init();
            try {
              host = "::";
              family = 6;
              this._port = binding.udx_napi_socket_bind(this._handle, port, host, family, flags);
            } catch {
              host = "0.0.0.0";
              family = 4;
              this._port = binding.udx_napi_socket_bind(this._handle, port, host, family, flags);
            }
          }
          this._host = host;
          this._family = family;
          this.emit("listening");
        }
        async close() {
          if (this._closing) return this._closing;
          this._closing = new Promise((resolve) => this.once("close", resolve));
          this._closeMaybe();
          return this._closing;
        }
        _closeMaybe() {
          if (this._closed || this._closing === null) return this._closed;
          if (!this._inited) {
            this._closed = true;
            this.emit("close");
            return true;
          }
          if (this.idle) {
            binding.udx_napi_socket_close(this._handle);
            this._closed = true;
          }
          return this._closed;
        }
        setTTL(ttl) {
          if (!this._inited) throw new Error("Socket not active");
          binding.udx_napi_socket_set_ttl(this._handle, ttl);
        }
        getRecvBufferSize() {
          if (!this._inited) throw new Error("Socket not active");
          return binding.udx_napi_socket_get_recv_buffer_size(this._handle);
        }
        setRecvBufferSize(size) {
          if (!this._inited) throw new Error("Socket not active");
          return binding.udx_napi_socket_set_recv_buffer_size(this._handle, size);
        }
        getSendBufferSize() {
          if (!this._inited) throw new Error("Socket not active");
          return binding.udx_napi_socket_get_send_buffer_size(this._handle);
        }
        setSendBufferSize(size) {
          if (!this._inited) throw new Error("Socket not active");
          return binding.udx_napi_socket_set_send_buffer_size(this._handle, size);
        }
        addMembership(group, ifaceAddress) {
          if (!this._inited) throw new Error("Socket not active");
          return binding.udx_napi_socket_set_membership(this._handle, group, ifaceAddress || "", true);
        }
        dropMembership(group, ifaceAddress) {
          if (!this._inited) throw new Error("Socket not active");
          return binding.udx_napi_socket_set_membership(this._handle, group, ifaceAddress || "", false);
        }
        async send(buffer, port, host, ttl) {
          if (this.closing) return false;
          if (!host) host = "127.0.0.1";
          const family = ip.isIP(host);
          if (!family) throw new Error(`${host} is not a valid IP address`);
          if (!this.bound) this.bind(0);
          const id = this._allocSend();
          const req = this._reqs[id];
          req.buffer = buffer;
          const promise = new Promise((resolve) => {
            req.onflush = resolve;
          });
          binding.udx_napi_socket_send_ttl(
            this._handle,
            req.handle,
            id,
            buffer,
            port,
            host,
            family,
            ttl || 0
          );
          return promise;
        }
        trySend(buffer, port, host, ttl) {
          if (this.closing) return;
          if (!host) host = "127.0.0.1";
          const family = ip.isIP(host);
          if (!family) throw new Error(`${host} is not a valid IP address`);
          if (!this.bound) this.bind(0);
          const id = this._allocSend();
          const req = this._reqs[id];
          req.buffer = buffer;
          req.onflush = noop;
          binding.udx_napi_socket_send_ttl(
            this._handle,
            req.handle,
            id,
            buffer,
            port,
            host,
            family,
            ttl || 0
          );
        }
        _allocSend() {
          if (this._free.length > 0) return this._free.pop();
          const handle = b4a.allocUnsafe(binding.sizeof_udx_socket_send_t);
          return this._reqs.push({ handle, buffer: null, onflush: null }) - 1;
        }
      };
      function noop() {
      }
    }
  });

  // ../../node_modules/udx-native/lib/stream.js
  var require_stream4 = __commonJS({
    "../../node_modules/udx-native/lib/stream.js"(exports, module) {
      var streamx = require_streamx();
      var b4a = require_b4a();
      var binding = require_binding13();
      var ip = require_ip();
      var MAX_PACKET = 2048;
      var BUFFER_SIZE = 65536 + MAX_PACKET;
      module.exports = class UDXStream extends streamx.Duplex {
        constructor(udx, id, opts = {}) {
          super({ mapWritable: toBuffer, eagerOpen: true });
          this.udx = udx;
          this.socket = null;
          this._handle = b4a.alloc(binding.sizeof_udx_napi_stream_t);
          this._view = new Uint32Array(
            this._handle.buffer,
            this._handle.byteOffset,
            this._handle.byteLength >> 2
          );
          this._view16 = new Uint16Array(
            this._handle.buffer,
            this._handle.byteOffset,
            this._handle.byteLength >> 1
          );
          this._view64 = new BigUint64Array(
            this._handle.buffer,
            this._handle.byteOffset,
            this._handle.byteLength >> 3
          );
          this._wreqs = [];
          this._wfree = [];
          this._sreqs = [];
          this._sfree = [];
          this._closed = false;
          this._flushing = 0;
          this._flushes = [];
          this._buffer = null;
          this._reallocData();
          this._onwrite = null;
          this._ondestroy = null;
          this._firewall = opts.firewall || firewallAll;
          this._remoteChanging = null;
          this._previousSocket = null;
          this.id = id;
          this.remoteId = 0;
          this.remoteHost = null;
          this.remoteFamily = 0;
          this.remotePort = 0;
          this.userData = null;
          binding.udx_napi_stream_init(
            this.udx._handle,
            this._handle,
            id,
            opts.framed ? 1 : 0,
            this,
            this._ondata,
            this._onend,
            this._ondrain,
            this._onack,
            this._onsend,
            this._onmessage,
            this._onclose,
            this._onfirewall,
            this._onremotechanged,
            this._reallocData,
            this._reallocMessage
          );
          if (opts.seq) binding.udx_napi_stream_set_seq(this._handle, opts.seq);
          binding.udx_napi_stream_recv_start(this._handle, this._buffer);
        }
        get connected() {
          return this.socket !== null;
        }
        get mtu() {
          return this._view16[binding.offsetof_udx_stream_t_mtu >> 1];
        }
        get rtt() {
          return this._view[binding.offsetof_udx_stream_t_srtt >> 2];
        }
        get cwnd() {
          return this._view[binding.offsetof_udx_stream_t_cwnd >> 2];
        }
        get rtoCount() {
          return this._view16[binding.offsetof_udx_stream_t_rto_count >> 1];
        }
        get retransmits() {
          return this._view16[binding.offsetof_udx_stream_t_retransmit_count >> 1];
        }
        get fastRecoveries() {
          return this._view16[binding.offsetof_udx_stream_t_fast_recovery_count >> 1];
        }
        get inflight() {
          return this._view[binding.offsetof_udx_stream_t_inflight >> 2];
        }
        get bytesTransmitted() {
          return Number(this._view64[binding.offsetof_udx_stream_t_bytes_tx >> 3]);
        }
        get packetsTransmitted() {
          return Number(this._view64[binding.offsetof_udx_stream_t_packets_tx >> 3]);
        }
        get bytesReceived() {
          return Number(this._view64[binding.offsetof_udx_stream_t_bytes_rx >> 3]);
        }
        get packetsReceived() {
          return Number(this._view64[binding.offsetof_udx_stream_t_packets_rx >> 3]);
        }
        get localHost() {
          return this.socket ? this.socket.address().host : null;
        }
        get localFamily() {
          return this.socket ? this.socket.address().family : 0;
        }
        get localPort() {
          return this.socket ? this.socket.address().port : 0;
        }
        setInteractive(bool) {
          if (!this._closed) return;
          binding.udx_napi_stream_set_mode(this._handle, bool ? 0 : 1);
        }
        connect(socket, remoteId, port, host, opts = {}) {
          if (this._closed) return;
          if (this.connected) throw new Error("Already connected");
          if (socket.closing) throw new Error("Socket is closed");
          if (typeof host === "object") {
            opts = host;
            host = null;
          }
          if (!host) host = "127.0.0.1";
          const family = ip.isIP(host);
          if (!family) throw new Error(`${host} is not a valid IP address`);
          if (!(port > 0 && port < 65536)) throw new Error(`${port} is not a valid port`);
          if (!socket.bound) socket.bind(0);
          this.remoteId = remoteId;
          this.remotePort = port;
          this.remoteHost = host;
          this.remoteFamily = family;
          this.socket = socket;
          if (opts.ack) binding.udx_napi_stream_set_ack(this._handle, opts.ack);
          binding.udx_napi_stream_connect(this._handle, socket._handle, remoteId, port, host, family);
          this.socket._addStream(this);
          this.emit("connect");
        }
        changeRemote(socket, remoteId, port, host) {
          if (this._remoteChanging) throw new Error("Remote already changing");
          if (!this.connected) throw new Error("Not yet connected");
          if (socket.closing) throw new Error("Socket is closed");
          if (this.socket.udx !== socket.udx) {
            throw new Error("Cannot change to a socket on another UDX instance");
          }
          if (!host) host = "127.0.0.1";
          const family = ip.isIP(host);
          if (!family) throw new Error(`${host} is not a valid IP address`);
          if (!(port > 0 && port < 65536)) throw new Error(`${port} is not a valid port`);
          if (this.socket !== socket) this._previousSocket = this.socket;
          this.remoteId = remoteId;
          this.remotePort = port;
          this.remoteHost = host;
          this.remoteFamily = family;
          this.socket = socket;
          this._remoteChanging = new Promise((resolve, reject) => {
            const onchanged = () => {
              this.off("close", onclose);
              resolve();
            };
            const onclose = () => {
              this.off("remote-changed", onchanged);
              reject(new Error("Stream is closed"));
            };
            this.once("remote-changed", onchanged).once("close", onclose);
          });
          binding.udx_napi_stream_change_remote(
            this._handle,
            socket._handle,
            remoteId,
            port,
            host,
            family
          );
          this.socket._addStream(this);
          return this._remoteChanging;
        }
        relayTo(destination) {
          if (this._closed) return;
          binding.udx_napi_stream_relay_to(this._handle, destination._handle);
        }
        async send(buffer) {
          if (!this.connected || this._closed) return false;
          const id = this._allocSend();
          const req = this._sreqs[id];
          req.buffer = buffer;
          const promise = new Promise((resolve) => {
            req.onflush = resolve;
          });
          binding.udx_napi_stream_send(this._handle, req.handle, id, buffer);
          return promise;
        }
        trySend(buffer) {
          if (!this.connected || this._closed) return;
          const id = this._allocSend();
          const req = this._sreqs[id];
          req.buffer = buffer;
          req.onflush = noop;
          binding.udx_napi_stream_send(this._handle, req.handle, id, buffer);
        }
        async flush() {
          if (await streamx.Writable.drained(this) === false) return false;
          if (this.destroying) return false;
          const missing = this._wreqs.length - this._wfree.length;
          if (missing === 0) return true;
          return new Promise((resolve) => {
            this._flushes.push({ flush: this._flushing++, missing, resolve });
          });
        }
        toJSON() {
          return {
            id: this.id,
            connected: this.connected,
            destroying: this.destroying,
            destroyed: this.destroyed,
            remoteId: this.remoteId,
            remoteHost: this.remoteHost,
            remoteFamily: this.remoteFamily,
            remotePort: this.remotePort,
            mtu: this.mtu,
            rtt: this.rtt,
            cwnd: this.cwnd,
            inflight: this.inflight,
            socket: this.socket ? this.socket.toJSON() : null
          };
        }
        _read(cb) {
          cb(null);
        }
        _writeContinue(err) {
          if (this._onwrite === null) return;
          const cb = this._onwrite;
          this._onwrite = null;
          cb(err);
        }
        _destroyContinue(err) {
          if (this._ondestroy === null) return;
          const cb = this._ondestroy;
          this._ondestroy = null;
          cb(err);
        }
        _writev(buffers, cb) {
          if (!this.connected)
            throw customError("Writing while not connected not currently supported", "ERR_ASSERTION");
          let drained = true;
          if (buffers.length === 1) {
            const id = this._allocWrite(1);
            const req = this._wreqs[id];
            req.flush = this._flushing;
            req.buffer = buffers[0];
            drained = binding.udx_napi_stream_write(this._handle, req.handle, id, req.buffer) !== 0;
          } else {
            const id = this._allocWrite(nextBatchSize(buffers.length));
            const req = this._wreqs[id];
            req.flush = this._flushing;
            req.buffers = buffers;
            drained = binding.udx_napi_stream_writev(this._handle, req.handle, id, req.buffers) !== 0;
          }
          if (drained) cb(null);
          else this._onwrite = cb;
        }
        _final(cb) {
          const id = this._allocWrite(1);
          const req = this._wreqs[id];
          req.flush = this._flushes;
          req.buffer = b4a.allocUnsafe(0);
          const drained = binding.udx_napi_stream_write_end(this._handle, req.handle, id, req.buffer) !== 0;
          if (drained) cb(null);
          else this._onwrite = cb;
        }
        _predestroy() {
          if (!this._closed) binding.udx_napi_stream_destroy(this._handle);
          this._closed = true;
          this._writeContinue(null);
        }
        _destroy(cb) {
          if (this.connected) this._ondestroy = cb;
          else cb(null);
        }
        _ondata(read) {
          this.push(this._consumeData(read));
          return this._buffer;
        }
        _onend(read) {
          if (read > 0) this.push(this._consumeData(read));
          this.push(null);
        }
        _ondrain() {
          this._writeContinue(null);
        }
        _flushAck(flush) {
          for (let i = this._flushes.length - 1; i >= 0; i--) {
            const f = this._flushes[i];
            if (f.flush < flush) break;
            f.missing--;
          }
          while (this._flushes.length > 0 && this._flushes[0].missing === 0) {
            this._flushes.shift().resolve(true);
          }
        }
        _onack(id) {
          const req = this._wreqs[id];
          req.buffers = req.buffer = null;
          this._wfree.push(id);
          if (this._flushes.length > 0) this._flushAck(req.flush);
          if (this._wfree.length >= 64 && this._wfree.length === this._wreqs.length) {
            this._wfree = [];
            this._wreqs = [];
          }
        }
        _onsend(id, err) {
          const req = this._sreqs[id];
          const onflush = req.onflush;
          req.buffer = null;
          req.onflush = null;
          this._sfree.push(id);
          onflush(err >= 0);
          if (this._sfree.length >= 16 && this._sfree.length === this._sreqs.length) {
            this._sfree = [];
            this._sreqs = [];
          }
        }
        _onmessage(len) {
          this.emit("message", this.udx._consumeMessage(len));
          return this.udx._buffer;
        }
        _onclose(err) {
          this._closed = true;
          if (this.socket) {
            this.socket._removeStream(this);
            this.socket = null;
          }
          if (this._previousSocket) {
            this._previousSocket._removeStream(this);
            this._previousSocket = null;
          }
          if (!err) return this._destroyContinue(null);
          if (this._ondestroy === null) this.destroy(err);
          else this._destroyContinue(err);
        }
        _onfirewall(socket, port, host, family) {
          return this._firewall(socket, port, host, family) ? 1 : 0;
        }
        _onremotechanged() {
          if (this._previousSocket) {
            this._previousSocket._removeStream(this);
            this._previousSocket = null;
          }
          this._remoteChanging = null;
          this.emit("remote-changed");
        }
        _consumeData(len) {
          const next = this._buffer.subarray(0, len);
          this._buffer = this._buffer.subarray(len);
          if (this._buffer.byteLength < MAX_PACKET) this._reallocData();
          return next;
        }
        _reallocData() {
          this._buffer = b4a.allocUnsafe(BUFFER_SIZE);
          return this._buffer;
        }
        _reallocMessage() {
          return this.udx._reallocMessage();
        }
        _allocWrite(size) {
          if (this._wfree.length === 0) {
            const handle = b4a.allocUnsafe(binding.udx_napi_stream_write_sizeof(size));
            return this._wreqs.push({
              handle,
              size,
              buffers: null,
              buffer: null,
              flush: 0
            }) - 1;
          }
          const free = this._wfree.pop();
          if (size === 1) return free;
          const next = this._wreqs[free];
          if (next.size < size) {
            next.handle = b4a.allocUnsafe(binding.udx_napi_stream_write_sizeof(size));
            next.size = size;
          }
          return free;
        }
        _allocSend() {
          if (this._sfree.length > 0) return this._sfree.pop();
          const handle = b4a.allocUnsafe(binding.sizeof_udx_stream_send_t);
          return this._sreqs.push({ handle, buffer: null, resolve: null, reject: null }) - 1;
        }
      };
      function noop() {
      }
      function toBuffer(data) {
        return typeof data === "string" ? b4a.from(data) : data;
      }
      function firewallAll(socket, port, host) {
        return true;
      }
      function customError(message, code) {
        const error = new Error(message);
        error.code = code;
        return error;
      }
      function nextBatchSize(n) {
        if (n === 1) return 1;
        if (n < 8) return 8;
        if (n < 16) return 16;
        if (n < 32) return 32;
        if (n < 64) return 64;
        return n;
      }
    }
  });

  // ../../node_modules/udx-native/lib/network-interfaces.js
  var require_network_interfaces = __commonJS({
    "../../node_modules/udx-native/lib/network-interfaces.js"(exports, module) {
      var events = require_bare_node_events();
      var b4a = require_b4a();
      var binding = require_binding13();
      module.exports = class NetworkInterfaces extends events.EventEmitter {
        constructor(udx) {
          super();
          this._handle = b4a.alloc(binding.sizeof_udx_napi_interface_event_t);
          this._watching = false;
          this._destroying = null;
          binding.udx_napi_interface_event_init(
            udx._handle,
            this._handle,
            this,
            this._onevent,
            this._onclose
          );
          this.interfaces = binding.udx_napi_interface_event_get_addrs(this._handle);
        }
        _onclose() {
          this.emit("close");
        }
        _onevent() {
          this.interfaces = binding.udx_napi_interface_event_get_addrs(this._handle);
          this.emit("change", this.interfaces);
        }
        watch() {
          if (this._watching) return this;
          this._watching = true;
          binding.udx_napi_interface_event_start(this._handle);
          return this;
        }
        unwatch() {
          if (!this._watching) return this;
          this._watching = false;
          binding.udx_napi_interface_event_stop(this._handle);
          return this;
        }
        async destroy() {
          if (this._destroying) return this._destroying;
          this._destroying = events.once(this, "close");
          binding.udx_napi_interface_event_close(this._handle);
          return this._destroying;
        }
        [Symbol.iterator]() {
          return this.interfaces[Symbol.iterator]();
        }
      };
    }
  });

  // ../../node_modules/udx-native/lib/udx.js
  var require_udx = __commonJS({
    "../../node_modules/udx-native/lib/udx.js"(exports, module) {
      var b4a = require_b4a();
      var binding = require_binding13();
      var ip = require_ip();
      var Socket = require_socket();
      var Stream = require_stream4();
      var NetworkInterfaces = require_network_interfaces();
      var MAX_MESSAGE = 4096;
      var BUFFER_SIZE = 65536 + MAX_MESSAGE;
      module.exports = class UDX {
        constructor() {
          this._handle = b4a.alloc(binding.sizeof_udx_napi_t);
          this._watchers = /* @__PURE__ */ new Set();
          this._view64 = new BigUint64Array(
            this._handle.buffer,
            this._handle.byteOffset,
            this._handle.byteLength >> 3
          );
          this._buffer = null;
          this._reallocMessage();
          binding.udx_napi_init(this._handle, this._buffer);
        }
        static isIPv4(host) {
          return ip.isIPv4(host);
        }
        static isIPv6(host) {
          return ip.isIPv6(host);
        }
        static isIP(host) {
          return ip.isIP(host);
        }
        get bytesTransmitted() {
          return Number(this._view64[binding.offsetof_udx_t_bytes_tx >> 3]);
        }
        get packetsTransmitted() {
          return Number(this._view64[binding.offsetof_udx_t_packets_tx >> 3]);
        }
        get bytesReceived() {
          return Number(this._view64[binding.offsetof_udx_t_bytes_rx >> 3]);
        }
        get packetsReceived() {
          return Number(this._view64[binding.offsetof_udx_t_packets_rx >> 3]);
        }
        get packetsDroppedByKernel() {
          return Number(this._view64[binding.offsetof_udx_t_packets_dropped_by_kernel >> 3]);
        }
        _consumeMessage(len) {
          const next = this._buffer.subarray(0, len);
          this._buffer = this._buffer.subarray(len);
          if (this._buffer.byteLength < MAX_MESSAGE) this._reallocMessage();
          return next;
        }
        _reallocMessage() {
          this._buffer = b4a.allocUnsafe(BUFFER_SIZE);
          return this._buffer;
        }
        createSocket(opts) {
          return new Socket(this, opts);
        }
        createStream(id, opts) {
          return new Stream(this, id, opts);
        }
        networkInterfaces() {
          let [watcher = null] = this._watchers;
          if (watcher) return watcher.interfaces;
          watcher = new NetworkInterfaces(this);
          watcher.destroy();
          return watcher.interfaces;
        }
        watchNetworkInterfaces(onchange) {
          const watcher = new NetworkInterfaces(this);
          this._watchers.add(watcher);
          watcher.on("close", () => {
            this._watchers.delete(watcher);
          });
          if (onchange) watcher.on("change", onchange);
          return watcher.watch();
        }
        async lookup(host, opts = {}) {
          const { family = 0 } = opts;
          const req = b4a.alloc(binding.sizeof_udx_napi_lookup_t);
          const ctx = {
            req,
            resolve: null,
            reject: null
          };
          const promise = new Promise((resolve, reject) => {
            ctx.resolve = resolve;
            ctx.reject = reject;
          });
          binding.udx_napi_lookup(this._handle, req, host, family, ctx, onlookup);
          return promise;
        }
      };
      function onlookup(err, host, family) {
        if (err) this.reject(err);
        else this.resolve({ host, family });
      }
    }
  });

  // ../../node_modules/nat-sampler/index.js
  var require_nat_sampler = __commonJS({
    "../../node_modules/nat-sampler/index.js"(exports, module) {
      module.exports = class NatSampler {
        constructor() {
          this.host = null;
          this.port = 0;
          this.size = 0;
          this._a = null;
          this._b = null;
          this._threshold = 0;
          this._top = 0;
          this._samples = [];
        }
        add(host, port) {
          const a = this._bump(host, port, 2);
          const b = this._bump(host, 0, 1);
          if (this._samples.length < 32) {
            this.size++;
            this._threshold = this.size - (this.size < 4 ? 0 : this.size < 8 ? 1 : this.size < 12 ? 2 : 3);
            this._samples.push(a, b);
            this._top += 2;
          } else {
            if (this._top === 32) this._top = 0;
            const oa = this._samples[this._top];
            this._samples[this._top++] = a;
            oa.hits--;
            const ob = this._samples[this._top];
            this._samples[this._top++] = b;
            ob.hits--;
          }
          if (this._a === null || this._a.hits < a.hits) this._a = a;
          if (this._b === null || this._b.hits < b.hits) this._b = b;
          if (this._a.hits >= this._threshold) {
            this.host = this._a.host;
            this.port = this._a.port;
          } else if (this._b.hits >= this._threshold) {
            this.host = this._b.host;
            this.port = 0;
          } else {
            this.host = null;
            this.port = 0;
          }
          return a.hits;
        }
        _bump(host, port, inc) {
          for (let i = 0; i < 4; i++) {
            const j = this._top - inc - 2 * i & 31;
            if (j >= this._samples.length) return { host, port, hits: 1 };
            const s = this._samples[j];
            if (s.port === port && s.host === host) {
              s.hits++;
              return s;
            }
          }
          return { host, port, hits: 1 };
        }
      };
    }
  });

  // ../../node_modules/dht-rpc/lib/health.js
  var require_health = __commonJS({
    "../../node_modules/dht-rpc/lib/health.js"(exports, module) {
      var MAX_HEALTH_WINDOW = 4;
      var IDLE_THRESHOLD = 4;
      var DEGRADED_TIMEOUT_RATE_THRESHOLD = 0.5;
      module.exports = class NetworkHealth {
        constructor(dht) {
          this._dht = dht;
          this._window = [];
          this._head = -1;
          this._degradedTicks = 0;
          this._healthyTicks = 0;
          this.online = true;
          this.degraded = false;
        }
        get oldest() {
          return this._window[this._tail];
        }
        get previous() {
          return this._window[(this._head - 1 + MAX_HEALTH_WINDOW) % MAX_HEALTH_WINDOW];
        }
        get newest() {
          return this._window[this._head];
        }
        get responses() {
          if (!this.newest || !this.previous) return 0;
          return this.newest.responses - this.previous.responses;
        }
        get timeouts() {
          if (!this.newest || !this.previous) return 0;
          return this.newest.timeouts - this.previous.timeouts;
        }
        get timeoutsRate() {
          if (this.timeouts === 0) return 0;
          return this.timeouts / (this.responses + this.timeouts);
        }
        get cold() {
          return this._window.length < MAX_HEALTH_WINDOW;
        }
        get idle() {
          return this.responses + this.timeouts < IDLE_THRESHOLD;
        }
        get allDegraded() {
          return this._degradedTicks === MAX_HEALTH_WINDOW;
        }
        get allHealthy() {
          return this._healthyTicks === MAX_HEALTH_WINDOW;
        }
        get stats() {
          return {
            online: this.online,
            degraded: this.degraded,
            cold: this.cold,
            idle: this.idle,
            responses: this.responses,
            timeouts: this.timeouts,
            timeoutsRate: this.timeoutsRate
          };
        }
        get _tail() {
          return (this._head + 1) % MAX_HEALTH_WINDOW;
        }
        reset() {
          this._window = [];
          this._head = -1;
          this._degradedTicks = 0;
          this._healthyTicks = 0;
          this.online = true;
          this.degraded = false;
          this._dht._online();
        }
        update() {
          if (this.oldest?.degraded) this._degradedTicks--;
          else if (this.oldest?.degraded === false) this._healthyTicks--;
          this._head = this._tail;
          this._window[this._head] = {
            responses: this._dht.stats.requests.responses,
            timeouts: this._dht.stats.requests.timeouts
          };
          if (this.cold || this.idle) return;
          this.newest.degraded = this.timeoutsRate > DEGRADED_TIMEOUT_RATE_THRESHOLD;
          if (this.newest.degraded) this._degradedTicks++;
          else this._healthyTicks++;
          this.online = this.responses > 0;
          if (this.online && this.allDegraded) this.degraded = true;
          if (!this.online || this.allHealthy) this.degraded = false;
          if (this.online && !this.degraded) this._dht._online();
          else if (this.degraded) this._dht._degraded();
          else this._dht._offline();
        }
      };
    }
  });

  // ../../node_modules/adaptive-timeout/index.js
  var require_adaptive_timeout = __commonJS({
    "../../node_modules/adaptive-timeout/index.js"(exports, module) {
      var Cache = require_xache();
      module.exports = class AdaptiveTimeout {
        constructor(opts = {}) {
          this._cache = new Cache({
            maxSize: opts.maxSize || 65536,
            maxAge: opts.maxAge || 10 * 60 * 1e3
            // 10 minutes
          });
          this._fallback = opts.fallback || AdaptiveTimeout.TimeoutExponential;
          this._min = opts.min ?? 300;
          this._max = opts.max || 4e3;
          this._jitter = opts.jitter ?? 256;
        }
        // Default - aggressive ramp
        static TimeoutAggressive = [500, 750, 1e3, 1500, 2e3];
        // Linear - steady increase
        static TimeoutLinear = [500, 1e3, 1500, 2e3, 2500];
        // Exponential - slow start, rapid backoff
        static TimeoutExponential = [250, 500, 1e3, 2e3, 4e3];
        // Gentle - conservative, patient
        static TimeoutGentle = [1e3, 1250, 1500, 1750, 2e3];
        // Fast - rapid fire retries
        static TimeoutFast = [200, 400, 600, 800, 1e3];
        // U-shape - long, short, long
        static TimeoutUShape = [1500, 750, 500, 750, 1500];
        // Inverse U - short, long, short
        static TimeoutInverseU = [500, 1e3, 1500, 1e3, 500];
        // Sawtooth - alternating fast/slow
        static TimeoutSawtooth = [500, 1500, 500, 1500, 500];
        // Plateau - quick ramp then steady
        static TimeoutPlateau = [500, 1e3, 2e3, 2e3, 2e3];
        // Logarithmic - diminishing increases
        static TimeoutLogarithmic = [500, 1e3, 1300, 1500, 1600];
        getValue(key) {
          return this._cache.get(key);
        }
        put(key, value) {
          let p = this._cache.get(key);
          if (!p) {
            p = { avg: value, variance: value >> 1 };
          } else {
            p.variance += Math.abs(p.avg - value) - p.variance >> 2;
            p.avg += value - p.avg >> 3;
          }
          this._cache.set(key, p);
          return p;
        }
        get(key, attempt = 1) {
          const p = this._cache.get(key);
          const jitter = Math.random() * this._jitter | 0;
          if (p) {
            const base = p.avg + (p.variance << 1);
            const backoff = base * attempt;
            return Math.min(Math.max(backoff + jitter, this._min), this._max);
          } else {
            const base = this._fallback[Math.min(attempt - 1, this._fallback.length - 1)];
            return base + jitter;
          }
        }
        has(key) {
          return this._cache.has(key);
        }
        delete(key) {
          return this._cache.delete(key);
        }
        clear() {
          this._cache.clear();
        }
      };
    }
  });

  // ../../node_modules/compact-encoding-net/index.js
  var require_compact_encoding_net = __commonJS({
    "../../node_modules/compact-encoding-net/index.js"(exports, module) {
      var c = require_compact_encoding();
      var port = c.uint16;
      var address = (host, family) => {
        return {
          preencode(state, m) {
            host.preencode(state, m.host);
            port.preencode(state, m.port);
          },
          encode(state, m) {
            host.encode(state, m.host);
            port.encode(state, m.port);
          },
          decode(state) {
            return {
              host: host.decode(state),
              family,
              port: port.decode(state)
            };
          }
        };
      };
      var ipv4 = {
        preencode(state) {
          state.end += 4;
        },
        encode(state, string) {
          const start = state.start;
          const end = start + 4;
          let i = 0;
          while (i < string.length) {
            let n = 0;
            let c2;
            while (i < string.length && (c2 = string.charCodeAt(i++)) !== /* . */
            46) {
              n = n * 10 + (c2 - /* 0 */
              48);
            }
            state.buffer[state.start++] = n;
          }
          state.start = end;
        },
        decode(state) {
          if (state.end - state.start < 4) throw new Error("Out of bounds");
          return state.buffer[state.start++] + "." + state.buffer[state.start++] + "." + state.buffer[state.start++] + "." + state.buffer[state.start++];
        }
      };
      var ipv4Address = address(ipv4, 4);
      var ipv6 = {
        preencode(state) {
          state.end += 16;
        },
        encode(state, string) {
          const start = state.start;
          const end = start + 16;
          let i = 0;
          let split = null;
          while (i < string.length) {
            let n = 0;
            let c2;
            while (i < string.length && (c2 = string.charCodeAt(i++)) !== /* : */
            58) {
              if (c2 >= 48 && c2 <= 57) n = n * 16 + (c2 - /* 0 */
              48);
              else if (c2 >= 65 && c2 <= 70) n = n * 16 + (c2 - /* A */
              65 + 10);
              else if (c2 >= 97 && c2 <= 102) n = n * 16 + (c2 - /* a */
              97 + 10);
            }
            state.buffer[state.start++] = n >>> 8;
            state.buffer[state.start++] = n;
            if (i < string.length && string.charCodeAt(i) === /* : */
            58) {
              i++;
              split = state.start;
            }
          }
          if (split !== null) {
            const offset = end - state.start;
            state.buffer.copyWithin(split + offset, split).fill(0, split, split + offset);
          }
          state.start = end;
        },
        decode(state) {
          if (state.end - state.start < 16) throw new Error("Out of bounds");
          return (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) + ":" + (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) + ":" + (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) + ":" + (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) + ":" + (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) + ":" + (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) + ":" + (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) + ":" + (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16);
        }
      };
      var ipv6Address = address(ipv6, 6);
      var ip = {
        preencode(state, string) {
          const family = string.includes(":") ? 6 : 4;
          c.uint8.preencode(state, family);
          if (family === 4) ipv4.preencode(state);
          else ipv6.preencode(state);
        },
        encode(state, string) {
          const family = string.includes(":") ? 6 : 4;
          c.uint8.encode(state, family);
          if (family === 4) ipv4.encode(state, string);
          else ipv6.encode(state, string);
        },
        decode(state) {
          const family = c.uint8.decode(state);
          if (family === 4) return ipv4.decode(state);
          else return ipv6.decode(state);
        }
      };
      var ipAddress = {
        preencode(state, m) {
          ip.preencode(state, m.host);
          port.preencode(state, m.port);
        },
        encode(state, m) {
          ip.encode(state, m.host);
          port.encode(state, m.port);
        },
        decode(state) {
          const family = c.uint8.decode(state);
          return {
            host: family === 4 ? ipv4.decode(state) : ipv6.decode(state),
            family,
            port: port.decode(state)
          };
        }
      };
      module.exports = {
        port,
        ipv4,
        ipv4Address,
        ipv6,
        ipv6Address,
        ip,
        ipAddress
      };
    }
  });

  // ../../node_modules/dht-rpc/lib/peer.js
  var require_peer = __commonJS({
    "../../node_modules/dht-rpc/lib/peer.js"(exports, module) {
      var sodium = require_sodium_universal();
      var c = require_compact_encoding();
      var net = require_compact_encoding_net();
      var b4a = require_b4a();
      var ipv4 = {
        ...net.ipv4Address,
        decode(state) {
          const ip = net.ipv4Address.decode(state);
          return {
            id: null,
            // populated by the callee
            host: ip.host,
            port: ip.port
          };
        }
      };
      module.exports = { id, ipv4, ipv4Array: c.array(ipv4) };
      function id(host, port, out = b4a.allocUnsafeSlow(32)) {
        const addr = out.subarray(0, 6);
        ipv4.encode({ start: 0, end: 6, buffer: addr }, { host, port });
        sodium.crypto_generichash(out, addr);
        return out;
      }
    }
  });

  // ../../node_modules/dht-rpc/lib/errors.js
  var require_errors10 = __commonJS({
    "../../node_modules/dht-rpc/lib/errors.js"(exports, module) {
      module.exports = class DHTError extends Error {
        constructor(msg, code, fn = DHTError) {
          super(`${code}: ${msg}`);
          this.code = code;
          if (Error.captureStackTrace) {
            Error.captureStackTrace(this, fn);
          }
        }
        get name() {
          return "DHTError";
        }
        static UNKNOWN_COMMAND = 1;
        static INVALID_TOKEN = 2;
        static REQUEST_TIMEOUT(msg = "Request timed out") {
          return new DHTError(msg, "REQUEST_TIMEOUT", DHTError.REQUEST_TIMEOUT);
        }
        static REQUEST_DESTROYED(msg = "Request destroyed") {
          return new DHTError(msg, "REQUEST_DESTROYED", DHTError.REQUEST_DESTROYED);
        }
        static IO_SUSPENDED(msg = "I/O suspended") {
          return new DHTError(msg, "IO_SUSPENDED", DHTError.IO_SUSPENDED);
        }
      };
    }
  });

  // ../../node_modules/dht-rpc/lib/io.js
  var require_io = __commonJS({
    "../../node_modules/dht-rpc/lib/io.js"(exports, module) {
      var FIFO = require_fast_fifo();
      var sodium = require_sodium_universal();
      var c = require_compact_encoding();
      var b4a = require_b4a();
      var AdaptiveTimeout = require_adaptive_timeout();
      var peer = require_peer();
      var { INVALID_TOKEN, REQUEST_TIMEOUT, REQUEST_DESTROYED, IO_SUSPENDED } = require_errors10();
      var VERSION = 3;
      var RESPONSE_ID = 1 << 4 | VERSION;
      var REQUEST_ID = 0 << 4 | VERSION;
      var EMPTY_ARRAY = [];
      var MAX_WINDOW = 80;
      module.exports = class IO {
        constructor(table, udx, {
          maxWindow = MAX_WINDOW,
          port = 0,
          host = "0.0.0.0",
          anyPort = true,
          firewalled = true,
          onrequest,
          onresponse = noop,
          ontimeout = noop,
          adaptiveTimeout
        } = {}) {
          this.table = table;
          this.udx = udx;
          this.inflight = [];
          this.clientSocket = null;
          this.serverSocket = null;
          this.firewalled = firewalled !== false;
          this.ephemeral = true;
          this.congestion = new CongestionWindow(maxWindow);
          this.networkInterfaces = udx.watchNetworkInterfaces();
          this.suspended = false;
          this.stats = {
            requests: {
              active: 0,
              total: 0,
              responses: 0,
              timeouts: 0,
              retries: 0
            },
            commands: [
              { tx: 0, rx: 0 },
              // tx = transmitted, rx = received
              { tx: 0, rx: 0 },
              { tx: 0, rx: 0 },
              { tx: 0, rx: 0 }
            ]
          };
          this.onrequest = onrequest;
          this.onresponse = onresponse;
          this.ontimeout = ontimeout;
          this._pending = new FIFO();
          this._rotateSecrets = 10;
          this._tid = Math.random() * 65536 | 0;
          this._secrets = null;
          this._drainInterval = null;
          this._destroying = null;
          this._binding = null;
          this.portRange = port.length ? port : port === 0 ? [0, 0] : [port, port + 5];
          this._host = host;
          this._anyPort = anyPort !== false;
          this._boundServerPort = 0;
          this._boundClientPort = 0;
          this._adt = adaptiveTimeout ? new AdaptiveTimeout(adaptiveTimeout) : null;
        }
        static DEFAULT_MAX_WINDOW = MAX_WINDOW;
        onmessage(socket, buffer, { host, port }) {
          if (buffer.byteLength < 2 || !(port > 0 && port < 65536) || this.suspended === true) return;
          const from = { id: null, host, port };
          const state = { start: 1, end: buffer.byteLength, buffer };
          const expectedSocket = this.firewalled ? this.clientSocket : this.serverSocket;
          const external = socket !== expectedSocket;
          if (buffer[0] === REQUEST_ID) {
            const req = Request.decode(this, socket, from, state);
            if (req === null) return;
            if (req.token !== null && !b4a.equals(req.token, this.token(req.from, 1)) && !b4a.equals(req.token, this.token(req.from, 0))) {
              req.error(INVALID_TOKEN, { token: true });
              return;
            }
            this.onrequest(req, external);
            return;
          }
          if (buffer[0] === RESPONSE_ID) {
            const res = decodeReply(from, state);
            if (res === null) return;
            for (let i = 0; i < this.inflight.length; i++) {
              const req = this.inflight[i];
              if (req.tid !== res.tid) continue;
              res.rtt = Date.now() - req._timestamp;
              if (this._adt && req.sent <= 2) {
                this._adt.put(`${req.to.host}:${req.to.port}`, res.rtt);
              }
              if (i === this.inflight.length - 1) this.inflight.pop();
              else this.inflight[i] = this.inflight.pop();
              if (req.session) req.session._detach(req);
              if (req._timeout) {
                clearTimeout(req._timeout);
                req._timeout = null;
              }
              this.congestion.recv();
              if (req.internal && req.command < this.stats.commands.length) {
                this.stats.commands[req.command].rx++;
              }
              this.stats.requests.active--;
              this.stats.requests.responses++;
              this.onresponse(res, external);
              req.onresponse(res, req);
              break;
            }
          }
        }
        token(addr, i) {
          if (this._secrets === null) {
            const buf = b4a.alloc(64);
            this._secrets = [buf.subarray(0, 32), buf.subarray(32, 64)];
            sodium.randombytes_buf(this._secrets[0]);
            sodium.randombytes_buf(this._secrets[1]);
          }
          const token = b4a.allocUnsafe(32);
          sodium.crypto_generichash(token, b4a.from(addr.host), this._secrets[i]);
          return token;
        }
        async destroy() {
          if (this._destroying) return this._destroying;
          this._destroying = this._destroy();
          return this._destroying;
        }
        async _destroy() {
          await this.bind();
          await this._clear(false);
        }
        async _clear(suspended) {
          if (this._drainInterval) {
            clearInterval(this._drainInterval);
            this._drainInterval = null;
          }
          while (this.inflight.length) {
            const req = this.inflight.pop();
            if (req._timeout) clearTimeout(req._timeout);
            req._timeout = null;
            req.destroyed = true;
            if (req.session) req.session._detach(req);
            this.congestion.recv();
            this.stats.requests.active--;
            req.onerror(suspended ? IO_SUSPENDED() : REQUEST_DESTROYED(), req);
          }
          await Promise.allSettled([this.serverSocket.close(), this.clientSocket.close()]);
          this.networkInterfaces.destroy();
        }
        async suspend() {
          this.suspended = true;
          await this._clear(true);
          this.congestion.clear();
          if (this._drainInterval) {
            clearInterval(this._drainInterval);
            this._drainInterval = null;
          }
        }
        async _rebind(binding) {
          if (binding) await binding;
          if (this._destroying) return this._destroying;
          await this._bindSockets();
          this.networkInterfaces = this.udx.watchNetworkInterfaces();
        }
        resume() {
          this.suspended = false;
          const binding = this._binding;
          this._binding = this._rebind(binding);
          return this._binding;
        }
        bind() {
          if (this._binding) return this._binding;
          this._binding = this._bindSockets();
          return this._binding;
        }
        async _bindSockets() {
          const serverSocket = this.udx.createSocket();
          const candidatePorts = [];
          if (this._boundServerPort) candidatePorts.push(this._boundServerPort);
          for (let i = this.portRange[0]; i < this.portRange[1]; i++) candidatePorts.push(i);
          for (const port of candidatePorts) {
            if (serverSocket.bound) break;
            try {
              serverSocket.bind(port, this._host);
            } catch (err) {
              if (!this._anyPort) {
                await serverSocket.close();
                throw err;
              }
            }
          }
          if (!serverSocket.bound) {
            try {
              serverSocket.bind(0, this._host);
            } catch (err) {
              await serverSocket.close();
              throw err;
            }
          }
          const clientSocket = this.udx.createSocket();
          try {
            clientSocket.bind(this._boundClientPort || 0, this._host);
          } catch {
            try {
              clientSocket.bind(0, this._host);
            } catch (err) {
              await serverSocket.close();
              await clientSocket.close();
              throw err;
            }
          }
          this._boundServerPort = serverSocket.address().port;
          this._boundClientPort = clientSocket.address().port;
          this.clientSocket = clientSocket;
          this.serverSocket = serverSocket;
          this.serverSocket.on("message", this.onmessage.bind(this, this.serverSocket));
          this.clientSocket.on("message", this.onmessage.bind(this, this.clientSocket));
          if (this._drainInterval === null) {
            this._drainInterval = setInterval(this._drain.bind(this), 750);
            if (this._drainInterval.unref) this._drainInterval.unref();
          }
          for (const req of this.inflight) {
            if (!req.socket) req.socket = this.firewalled ? this.clientSocket : this.serverSocket;
            req.sent = 0;
            req.send(false);
          }
        }
        _drain() {
          if (this._secrets !== null && --this._rotateSecrets === 0) {
            this._rotateSecrets = 10;
            const tmp = this._secrets[0];
            this._secrets[0] = this._secrets[1];
            this._secrets[1] = tmp;
            sodium.crypto_generichash(tmp, tmp);
          }
          this.congestion.drain();
          while (!this.congestion.isFull()) {
            const p = this._pending.shift();
            if (p === void 0) return;
            p._sendNow();
          }
        }
        createRequest(to, token, internal, command, target, value, session, ttl) {
          if (this._destroying !== null) return null;
          if (this._tid === 65536) this._tid = 0;
          const tid = this._tid++;
          const socket = this.firewalled ? this.clientSocket : this.serverSocket;
          const req = new Request(
            this,
            socket,
            tid,
            null,
            to,
            token,
            internal,
            command,
            target,
            value,
            session,
            ttl || 0
          );
          this.inflight.push(req);
          if (session) session._attach(req);
          if (internal && command < this.stats.commands.length) {
            this.stats.commands[command].tx++;
          }
          this.stats.requests.active++;
          this.stats.requests.total++;
          return req;
        }
      };
      var Request = class _Request {
        constructor(io, socket, tid, from, to, token, internal, command, target, value, session, ttl) {
          this.socket = socket;
          this.tid = tid;
          this.from = from;
          this.to = to;
          this.token = token;
          this.command = command;
          this.target = target;
          this.value = value;
          this.internal = internal;
          this.session = session;
          this.ttl = ttl;
          this.index = -1;
          this.sent = 0;
          this.retries = 3;
          this.destroyed = false;
          this.timeout = 0;
          this.oncycle = noop;
          this.onerror = noop;
          this.onresponse = noop;
          this._buffer = null;
          this._io = io;
          this._timeout = null;
          this._timestamp = Date.now();
        }
        static decode(io, socket, from, state) {
          try {
            const flags = c.uint.decode(state);
            const tid = c.uint16.decode(state);
            const to = peer.ipv4.decode(state);
            const id = flags & 1 ? c.fixed32.decode(state) : null;
            const token = flags & 2 ? c.fixed32.decode(state) : null;
            const internal = (flags & 4) !== 0;
            const command = c.uint.decode(state);
            const target = flags & 8 ? c.fixed32.decode(state) : null;
            const value = flags & 16 ? c.buffer.decode(state) : null;
            if (id !== null) from.id = validateId(id, from);
            return new _Request(
              io,
              socket,
              tid,
              from,
              to,
              token,
              internal,
              command,
              target,
              value,
              null,
              0
            );
          } catch {
            return null;
          }
        }
        reply(value, opts = {}) {
          const socket = opts.socket || this.socket;
          const to = opts.to || this.from;
          this._sendReply(0, value || null, opts.token !== false, opts.closerNodes !== false, to, socket);
        }
        error(code, opts = {}) {
          const socket = opts.socket || this.socket;
          const to = opts.to || this.from;
          this._sendReply(code, null, opts.token === true, opts.closerNodes !== false, to, socket);
        }
        relay(value, to, opts) {
          const socket = opts && opts.socket || this.socket;
          const buffer = this._encodeRequest(null, value, to, socket);
          socket.trySend(buffer, to.port, to.host, this.ttl);
        }
        send(force = false) {
          if (this.destroyed) return;
          if (this.socket === null) return;
          if (this._buffer === null) {
            this._buffer = this._encodeRequest(this.token, this.value, this.to, this.socket);
          }
          if (!force && this._io.congestion.isFull()) {
            this._io._pending.push(this);
            return;
          }
          this._sendNow();
        }
        sendReply(error, value, token, hasCloserNodes) {
          this._sendReply(error, value, token, hasCloserNodes, this.from, this.socket, null);
        }
        _sendNow() {
          if (this.destroyed) return;
          this.sent++;
          this._io.congestion.send();
          this.socket.trySend(this._buffer, this.to.port, this.to.host, this.ttl);
          if (this._timeout) clearTimeout(this._timeout);
          const value = this.timeout || this._io._adt?.get(`${this.to.host}:${this.to.port}`, this.sent) || 1e3;
          this._timeout = setTimeout(oncycle, value, this);
        }
        destroy(err) {
          if (this.destroyed) return;
          this.destroyed = true;
          if (this._timeout) {
            clearTimeout(this._timeout);
            this._timeout = null;
          }
          const i = this._io.inflight.indexOf(this);
          if (i === -1) return;
          if (i === this._io.inflight.length - 1) this._io.inflight.pop();
          else this._io.inflight[i] = this._io.inflight.pop();
          if (this.session) this.session._detach(this);
          this._io.stats.requests.active--;
          this._io.congestion.recv();
          this.onerror(err || REQUEST_DESTROYED(), this);
        }
        _sendReply(error, value, token, hasCloserNodes, from, socket) {
          if (socket === null || this.destroyed) return;
          const id = this._io.ephemeral === false && socket === this._io.serverSocket;
          const closerNodes = this.target !== null && hasCloserNodes ? this._io.table.closest(this.target) : EMPTY_ARRAY;
          const state = { start: 0, end: 1 + 1 + 6 + 2, buffer: null };
          if (id) state.end += 32;
          if (token) state.end += 32;
          if (closerNodes.length > 0) peer.ipv4Array.preencode(state, closerNodes);
          if (error > 0) c.uint.preencode(state, error);
          if (value) c.buffer.preencode(state, value);
          state.buffer = b4a.allocUnsafe(state.end);
          state.buffer[state.start++] = RESPONSE_ID;
          state.buffer[state.start++] = (id ? 1 : 0) | (token ? 2 : 0) | (closerNodes.length > 0 ? 4 : 0) | (error > 0 ? 8 : 0) | (value ? 16 : 0);
          c.uint16.encode(state, this.tid);
          peer.ipv4.encode(state, from);
          if (id) c.fixed32.encode(state, this._io.table.id);
          if (token) c.fixed32.encode(state, this._io.token(from, 1));
          if (closerNodes.length > 0) peer.ipv4Array.encode(state, closerNodes);
          if (error > 0) c.uint.encode(state, error);
          if (value) c.buffer.encode(state, value);
          socket.trySend(state.buffer, from.port, from.host, this.ttl);
        }
        _encodeRequest(token, value, to, socket) {
          const id = this._io.ephemeral === false && socket === this._io.serverSocket;
          const state = { start: 0, end: 1 + 1 + 6 + 2, buffer: null };
          if (id) state.end += 32;
          if (token) state.end += 32;
          c.uint.preencode(state, this.command);
          if (this.target) state.end += 32;
          if (value) c.buffer.preencode(state, value);
          state.buffer = b4a.allocUnsafe(state.end);
          state.buffer[state.start++] = REQUEST_ID;
          state.buffer[state.start++] = (id ? 1 : 0) | (token ? 2 : 0) | (this.internal ? 4 : 0) | (this.target ? 8 : 0) | (value ? 16 : 0);
          c.uint16.encode(state, this.tid);
          peer.ipv4.encode(state, to);
          if (id) c.fixed32.encode(state, this._io.table.id);
          if (token) c.fixed32.encode(state, token);
          c.uint.encode(state, this.command);
          if (this.target) c.fixed32.encode(state, this.target);
          if (value) c.buffer.encode(state, value);
          return state.buffer;
        }
      };
      var CongestionWindow = class {
        constructor(maxWindow) {
          this._i = 0;
          this._total = 0;
          this._window = [0, 0, 0, 0];
          this._maxWindow = maxWindow;
        }
        clear() {
          this._i = 0;
          this._total = 0;
          this._window = [0, 0, 0, 0];
        }
        isFull() {
          return this._total >= 2 * this._maxWindow || this._window[this._i] >= this._maxWindow;
        }
        recv() {
          if (this._window[this._i] > 0) {
            this._window[this._i]--;
            this._total--;
          }
        }
        send() {
          this._total++;
          this._window[this._i]++;
        }
        drain() {
          this._i = this._i + 1 & 3;
          this._total -= this._window[this._i];
          this._window[this._i] = 0;
        }
      };
      function noop() {
      }
      function oncycle(req) {
        req._timeout = null;
        req.oncycle(req);
        if (req.sent > req.retries) {
          req._io.stats.requests.timeouts++;
          req.destroy(REQUEST_TIMEOUT());
          req._io.ontimeout(req);
        } else {
          req._io.stats.requests.retries++;
          req.send();
        }
      }
      function decodeReply(from, state) {
        try {
          const flags = c.uint.decode(state);
          const tid = c.uint16.decode(state);
          const to = peer.ipv4.decode(state);
          const id = flags & 1 ? c.fixed32.decode(state) : null;
          const token = flags & 2 ? c.fixed32.decode(state) : null;
          const closerNodes = flags & 4 ? peer.ipv4Array.decode(state) : null;
          const error = flags & 8 ? c.uint.decode(state) : 0;
          const value = flags & 16 ? c.buffer.decode(state) : null;
          if (id !== null) from.id = validateId(id, from);
          return { tid, rtt: 0, from, to, token, closerNodes, error, value };
        } catch {
          return null;
        }
      }
      function validateId(id, from) {
        const expected = peer.id(from.host, from.port);
        return b4a.equals(expected, id) ? expected : null;
      }
    }
  });

  // ../../node_modules/dht-rpc/lib/commands.js
  var require_commands = __commonJS({
    "../../node_modules/dht-rpc/lib/commands.js"(exports) {
      exports.PING = 0;
      exports.PING_NAT = 1;
      exports.FIND_NODE = 2;
      exports.DOWN_HINT = 3;
      exports.DELAYED_PING = 4;
    }
  });

  // ../../node_modules/dht-rpc/lib/query.js
  var require_query = __commonJS({
    "../../node_modules/dht-rpc/lib/query.js"(exports, module) {
      var { Readable, getStreamError } = require_streamx();
      var b4a = require_b4a();
      var peer = require_peer();
      var { DOWN_HINT } = require_commands();
      var DONE = [];
      var DOWN = [];
      module.exports = class Query extends Readable {
        constructor(dht, target, internal, command, value, opts = {}) {
          super();
          dht.stats.queries.total++;
          dht.stats.queries.active++;
          this.force = !!opts.force;
          this.dht = dht;
          this.k = this.dht.table.k;
          this.target = target;
          this.internal = internal;
          this.command = command;
          this.value = value;
          this.errors = 0;
          this.successes = 0;
          this.concurrency = opts.concurrency || this.dht.concurrency;
          this.inflight = 0;
          this.map = opts.map || defaultMap;
          this.retries = opts.retries === 0 ? 0 : opts.retries || (this.internal && command === DOWN_HINT ? 3 : 5);
          this.closestReplies = [];
          this._slow = 0;
          this._slowdown = false;
          this._seen = /* @__PURE__ */ new Map();
          this._pending = [];
          this._fromTable = false;
          this._commit = opts.commit === true ? autoCommit : opts.commit || null;
          this._commiting = false;
          this._session = opts.session || dht.session();
          this._autoDestroySession = !opts.session;
          this._onlyClosestNodes = false;
          this._onvisitbound = this._onvisit.bind(this);
          this._onerrorbound = this._onerror.bind(this);
          this._oncyclebound = this._oncycle.bind(this);
          const nodes = opts.nodes || opts.closestNodes;
          const replies = opts.replies || opts.closestReplies;
          if (nodes) {
            for (let i = nodes.length - 1; i >= 0; i--) {
              const node = nodes[i];
              this._addPending(
                {
                  id: node.id || peer.id(node.host, node.port),
                  host: node.host,
                  port: node.port
                },
                null
              );
            }
          } else if (replies) {
            for (let i = replies.length - 1; i >= 0; i--) {
              this._addPending(replies[i].from, null);
            }
          }
          if (opts.onlyClosestNodes) this._onlyClosestNodes = true;
        }
        get closestNodes() {
          const nodes = new Array(this.closestReplies.length);
          for (let i = 0; i < nodes.length; i++) {
            nodes[i] = this.closestReplies[i].from;
          }
          return nodes;
        }
        finished() {
          return new Promise((resolve, reject) => {
            if (this.destroyed) {
              const error2 = getStreamError(this);
              if (error2) reject(error2);
              else resolve();
              return;
            }
            const self2 = this;
            let error = null;
            this.resume();
            this.on("error", onerror);
            this.on("close", onclose);
            function onclose() {
              self2.removeListener("error", onerror);
              self2.removeListener("close", onclose);
              if (error) reject(error);
              else resolve();
            }
            function onerror(err) {
              error = err;
            }
          });
        }
        _addFromTable() {
          if (this._pending.length >= this.k) return;
          this._fromTable = true;
          const closest = this.dht.table.closest(this.target, this.k - this._pending.length);
          for (const node of closest) {
            this._addPending({ id: node.id, host: node.host, port: node.port }, null);
          }
        }
        async _open(cb) {
          this._addFromTable();
          if (this._pending.length >= this.k) return cb(null);
          for await (const node of this.dht._resolveBootstrapNodes()) {
            this._addPending(node, null);
          }
          cb(null);
        }
        _isCloser(id) {
          return this.closestReplies.length < this.k || this._compare(id, this.closestReplies[this.closestReplies.length - 1].from.id) < 0;
        }
        _addPending(node, ref) {
          if (this._onlyClosestNodes) return false;
          const addr = node.host + ":" + node.port;
          const refs = this._seen.get(addr);
          const isCloser = this._isCloser(node.id);
          if (refs === DONE) {
            return isCloser;
          }
          if (refs === DOWN) {
            if (ref) this._downHint(ref, node);
            return isCloser;
          }
          if (refs) {
            if (ref !== null) refs.push(ref);
            return isCloser;
          }
          if (!isCloser) {
            return false;
          }
          this._seen.set(addr, ref === null ? [] : [ref]);
          this._pending.push(node);
          return true;
        }
        _read(cb) {
          this._readMore();
          cb(null);
        }
        _readMore() {
          if (this.destroying || this._commiting) return;
          const concurrency = (this._slowdown ? 3 : this.concurrency) + this._slow;
          while (this.inflight < concurrency && this._pending.length > 0) {
            const next = this._pending.pop();
            if (next && next.id && !this._isCloser(next.id)) continue;
            this._visit(next);
          }
          if (!this._fromTable && this.successes === 0 && this.errors === 0) {
            this._slowdown = true;
          }
          if (this._pending.length > 0) return;
          if (this.inflight === 0 || this._slow === this.inflight && this.closestReplies.length >= this.k) {
            if (!this._fromTable && this.successes < this.k / 4) {
              this._addFromTable();
              this._readMore();
              return;
            }
            this._flush();
          }
        }
        _flush() {
          if (this._commiting) return;
          this._commiting = true;
          if (this._commit === null) {
            this.push(null);
            return;
          }
          const p = [];
          for (const m of this.closestReplies) p.push(this._commit(m, this.dht, this));
          this._endAfterCommit(p);
        }
        _endAfterCommit(ps) {
          if (!ps.length) {
            this.destroy(new Error("Too few nodes responded"));
            return;
          }
          const self2 = this;
          let pending = ps.length;
          let success = 0;
          for (const p of ps) p.then(ondone, onerror);
          function ondone() {
            success++;
            if (--pending === 0) self2.push(null);
          }
          function onerror(err) {
            if (--pending > 0) return;
            if (success) self2.push(null);
            else self2.destroy(err);
          }
        }
        _dec(req) {
          if (req.oncycle === noop) {
            this._slow--;
          } else {
            req.oncycle = noop;
          }
          this.inflight--;
        }
        _onvisit(m, req) {
          this._dec(req);
          const addr = req.to.host + ":" + req.to.port;
          this._seen.set(addr, DONE);
          if (this._commiting) return;
          if (m.error === 0) this.successes++;
          else this.errors++;
          if (m.error === 0 && m.from.id !== null && this._isCloser(m.from.id)) this._pushClosest(m);
          if (m.closerNodes !== null) {
            for (const node of m.closerNodes) {
              node.id = peer.id(node.host, node.port);
              if (this.dht._filterNode !== null && !this.dht._filterNode(node)) continue;
              if (b4a.equals(node.id, this.dht.table.id)) continue;
              if (!this._addPending(node, m.from)) break;
            }
          }
          if (!this._fromTable && this.successes + this.errors >= this.concurrency) {
            this._slowdown = false;
          }
          if (m.error !== 0) {
            this._readMore();
            return;
          }
          const data = this.map(m);
          if (!data || this.push(data) !== false) {
            this._readMore();
          }
        }
        _onerror(err, req) {
          const addr = req.to.host + ":" + req.to.port;
          const refs = this._seen.get(addr);
          if (err.code === "REQUEST_TIMEOUT") {
            this._seen.set(addr, DOWN);
            for (const node of refs) this._downHint(node, req.to);
          }
          this._dec(req);
          this.errors++;
          this._readMore();
        }
        _oncycle(req) {
          req.oncycle = noop;
          this._slow++;
          this._readMore();
        }
        _downHint(node, down) {
          if (this.dht._downHintsRateLimit !== -1 && this.dht._downHintsSentPerTick >= this.dht._downHintsRateLimit) {
            return null;
          }
          this.dht._downHintsSentPerTick++;
          const state = { start: 0, end: 6, buffer: b4a.allocUnsafe(6) };
          peer.ipv4.encode(state, down);
          this.dht._request(node, false, true, DOWN_HINT, null, state.buffer, this._session, noop, noop);
        }
        _pushClosest(m) {
          this.closestReplies.push(m);
          for (let i = this.closestReplies.length - 2; i >= 0; i--) {
            const prev = this.closestReplies[i];
            const cmp = this._compare(prev.from.id, m.from.id);
            if (cmp < 0) break;
            if (cmp === 0) {
              this.closestReplies.splice(i + 1, 1);
              break;
            }
            this.closestReplies[i + 1] = prev;
            this.closestReplies[i] = m;
          }
          if (this.closestReplies.length > this.k) this.closestReplies.pop();
        }
        _compare(a, b) {
          for (let i = 0; i < a.length; i++) {
            if (a[i] === b[i]) continue;
            const t = this.target[i];
            return (t ^ a[i]) - (t ^ b[i]);
          }
          return 0;
        }
        _visit(to) {
          this.inflight++;
          const req = this.dht._request(
            to,
            this.force,
            this.internal,
            this.command,
            this.target,
            this.value,
            this._session,
            this._onvisitbound,
            this._onerrorbound
          );
          if (req === null) {
            this.destroy(new Error("Node was destroyed"));
            return;
          }
          req.retries = this.retries;
          req.oncycle = this._oncyclebound;
          if (this.force) req.retries = 0;
        }
        _destroy(cb) {
          this.dht.stats.queries.active--;
          if (this._autoDestroySession) this._session.destroy();
          cb(null);
        }
      };
      function autoCommit(reply, dht, query) {
        if (!reply.token) return Promise.reject(new Error("No token received for closest node"));
        return dht.request(
          {
            token: reply.token,
            target: query.target,
            command: query.command,
            value: query.value
          },
          reply.from
        );
      }
      function defaultMap(m) {
        return m;
      }
      function noop() {
      }
    }
  });

  // ../../node_modules/dht-rpc/lib/session.js
  var require_session = __commonJS({
    "../../node_modules/dht-rpc/lib/session.js"(exports, module) {
      module.exports = class Session {
        constructor(dht) {
          this.dht = dht;
          this.inflight = [];
        }
        _attach(req) {
          req.index = this.inflight.push(req) - 1;
        }
        _detach(req) {
          const i = req.index;
          if (i === -1) return;
          req.index = -1;
          if (i === this.inflight.length - 1) this.inflight.pop();
          else {
            const req2 = this.inflight[i] = this.inflight.pop();
            req2.index = i;
          }
        }
        query({ target, command, value }, opts = {}) {
          return this.dht.query({ target, command, value }, { ...opts, session: this });
        }
        request({ token, command, target, value }, { host, port }, opts = {}) {
          return this.dht.request(
            { token, command, target, value },
            { host, port },
            { ...opts, session: this }
          );
        }
        ping({ host, port }, opts = {}) {
          return this.dht.ping({ host, port }, { ...opts, session: this });
        }
        destroy(err) {
          while (this.inflight.length) {
            const req = this.inflight[0];
            this.dht.io.congestion.recv();
            req.destroy(err);
          }
        }
      };
    }
  });

  // ../../node_modules/dht-rpc/index.js
  var require_dht_rpc = __commonJS({
    "../../node_modules/dht-rpc/index.js"(exports, module) {
      var { EventEmitter } = require_bare_node_events();
      var Table = require_kademlia_routing_table();
      var TOS = require_time_ordered_set();
      var UDX = require_udx();
      var sodium = require_sodium_universal();
      var c = require_compact_encoding();
      var NatSampler = require_nat_sampler();
      var b4a = require_b4a();
      var NetworkHealth = require_health();
      var IO = require_io();
      var Query = require_query();
      var Session = require_session();
      var peer = require_peer();
      var { UNKNOWN_COMMAND, INVALID_TOKEN } = require_errors10();
      var { PING, PING_NAT, FIND_NODE, DOWN_HINT, DELAYED_PING } = require_commands();
      var TMP = b4a.allocUnsafe(32);
      var TICK_INTERVAL = 5e3;
      var SLEEPING_INTERVAL = 3 * TICK_INTERVAL;
      var STABLE_TICKS = 240;
      var MORE_STABLE_TICKS = 3 * STABLE_TICKS;
      var REFRESH_TICKS = 60;
      var RECENT_NODE = 12;
      var OLD_NODE = 360;
      var DEFAULTS = {
        concurrency: 10,
        maxWindow: IO.DEFAULT_MAX_WINDOW,
        maxPingDelay: 1e4
      };
      var DHT = class extends EventEmitter {
        constructor(opts = {}) {
          super();
          this.bootstrapNodes = opts.bootstrap === false ? [] : (opts.bootstrap || []).map(parseNode);
          this.table = new Table(randomBytes(32));
          this.nodes = new TOS();
          this.udx = opts.udx || new UDX();
          this.io = new IO(this.table, this.udx, {
            ...opts,
            onrequest: this._onrequest.bind(this),
            onresponse: this._onresponse.bind(this),
            ontimeout: this._ontimeout.bind(this)
          });
          this.health = new NetworkHealth(this);
          this.concurrency = opts.concurrency || DEFAULTS.concurrency;
          this.maxPingDelay = opts.maxPingDelay || DEFAULTS.maxPingDelay;
          this.bootstrapped = false;
          this.ephemeral = true;
          this.firewalled = this.io.firewalled;
          this.adaptive = typeof opts.ephemeral !== "boolean" && opts.adaptive !== false;
          this.destroyed = false;
          this.suspended = false;
          this.online = true;
          this.degraded = false;
          this.stats = {
            queries: { active: 0, total: 0 },
            requests: this.io.stats.requests,
            commands: {
              ping: this.io.stats.commands[PING],
              pingNat: this.io.stats.commands[PING_NAT],
              findNode: this.io.stats.commands[FIND_NODE],
              downHint: this.io.stats.commands[DOWN_HINT]
            }
          };
          this._nat = new NatSampler();
          this._quickFirewall = opts.quickFirewall !== false;
          this._forcePersistent = opts.ephemeral === false;
          this._repinging = 0;
          this._checks = 0;
          this._tick = randomOffset(100);
          this._refreshTicks = randomOffset(REFRESH_TICKS);
          this._stableTicks = this.adaptive ? STABLE_TICKS : 0;
          this._tickInterval = setInterval(this._ontick.bind(this), TICK_INTERVAL);
          this._lastTick = Date.now();
          this._lastHost = null;
          this._filterNode = opts.filterNode || opts.addNode || null;
          this._onrow = (row) => row.on("full", (node) => this._onfullrow(node, row));
          this._nonePersistentSamples = [];
          this._bootstrapping = this._bootstrap();
          this._bootstrapping.catch(noop);
          this._sendDownHints = opts.sendDownHints !== false;
          this._downHintsRateLimit = opts.downHintsRateLimit !== void 0 ? opts.downHintsRateLimit : 10 * 5;
          this._downHintsSentPerTick = 0;
          this._pendingTimers = /* @__PURE__ */ new Set();
          this.table.on("row", this._onrow);
          this.io.networkInterfaces.on("change", (interfaces) => this._onnetworkchange(interfaces));
          if (opts.nodes) {
            for (let i = opts.nodes.length - 1; i >= 0; i--) {
              this.addNode(opts.nodes[i]);
            }
          }
        }
        static DEFAULTS = DEFAULTS;
        static bootstrapper(port, host, opts) {
          if (!port) throw new Error("Port is required");
          if (!host) throw new Error("Host is required");
          if (host === "0.0.0.0" || host === "::") throw new Error("Invalid host");
          if (!UDX.isIPv4(host)) throw new Error("Host must be a IPv4 address");
          const dht = new this({
            port,
            ephemeral: false,
            firewalled: false,
            anyPort: false,
            bootstrap: [],
            ...opts
          });
          dht._nat.add(host, port);
          return dht;
        }
        get id() {
          return this.ephemeral ? null : this.table.id;
        }
        get host() {
          return this._nat.host;
        }
        get port() {
          return this._nat.port;
        }
        get randomized() {
          return this._nat.host !== null && this._nat.port === 0;
        }
        get socket() {
          return this.firewalled ? this.io.clientSocket : this.io.serverSocket;
        }
        get config() {
          return {
            concurrency: this.concurrency,
            maxWindow: this.io.congestion._maxWindow,
            randomPunchInterval: this._randomPunchInterval,
            connectionKeepAlive: this.connectionKeepAlive,
            sendDownHints: this._sendDownHints,
            downHintsRateLimit: this._downHintsRateLimit
          };
        }
        onmessage(socket, buf, rinfo) {
          if (buf.byteLength > 1) this.io.onmessage(socket, buf, rinfo);
        }
        bind() {
          return this.io.bind();
        }
        async suspend({ log = noop } = {}) {
          log("Suspending waiting for io bind...");
          await this.io.bind();
          log("Done, continuing");
          if (this.suspended || this.destroyed) return;
          this.suspended = true;
          clearInterval(this._tickInterval);
          log("Done, suspending io");
          await this.io.suspend({ log });
          log("Done, dht suspended");
          this.emit("suspend");
        }
        async resume({ log = noop } = {}) {
          if (!this.suspended || this.destroyed) return;
          this.suspended = false;
          this._tickInterval = setInterval(this._ontick.bind(this), TICK_INTERVAL);
          this._onwakeup();
          log("Resuming io");
          await this.io.resume();
          log("Done, dht resumed");
          this.io.networkInterfaces.on("change", (interfaces) => this._onnetworkchange(interfaces));
          this.refresh();
          this.emit("resume");
        }
        address() {
          const socket = this.socket;
          return socket ? socket.address() : null;
        }
        localAddress() {
          if (!this.io.serverSocket) return null;
          return {
            host: localIP(this.udx),
            port: this.io.serverSocket.address().port
          };
        }
        remoteAddress() {
          if (!this.host) return null;
          if (!this.port) return null;
          if (this.firewalled) return null;
          if (!this.io.serverSocket) return null;
          const port = this.io.serverSocket.address().port;
          if (port !== this.port) return null;
          return {
            host: this.host,
            port
          };
        }
        addNode({ host, port }) {
          this._addNode({
            id: peer.id(host, port),
            port,
            host,
            token: null,
            to: null,
            sampled: 0,
            added: this._tick,
            pinged: 0,
            seen: 0,
            downHints: 0,
            prev: null,
            next: null
          });
        }
        toArray(opts) {
          const limit = opts && opts.limit;
          if (limit === 0) return [];
          return this.nodes.toArray({ limit, reverse: true }).map(({ host, port }) => ({ host, port }));
        }
        async fullyBootstrapped() {
          return this._bootstrapping;
        }
        ready() {
          return this.fullyBootstrapped();
        }
        findNode(target, opts) {
          if (this.destroyed) throw new Error("Node destroyed");
          this._refreshTicks = REFRESH_TICKS;
          return new Query(this, target, true, FIND_NODE, null, opts);
        }
        query({ target, command, value }, opts) {
          if (this.destroyed) throw new Error("Node destroyed");
          this._refreshTicks = REFRESH_TICKS;
          return new Query(this, target, false, command, value || null, opts);
        }
        ping({ host, port }, opts) {
          let value = null;
          if (opts && opts.size && opts.size > 0) value = b4a.alloc(opts.size);
          const req = this.io.createRequest(
            { id: null, host, port },
            null,
            true,
            PING,
            null,
            value,
            opts && opts.session || null,
            opts && opts.ttl
          );
          return this._requestToPromise(req, opts);
        }
        delayedPing({ host, port }, delayMs, opts) {
          if (delayMs > this.maxPingDelay) {
            throw new Error(`Delay exceeds max delay: ${this.maxPingDelay}ms`);
          }
          const value = b4a.allocUnsafe(4);
          c.uint32.encode({ start: 0, end: 4, buffer: value }, delayMs);
          const req = this.io.createRequest(
            { id: null, host, port },
            null,
            true,
            DELAYED_PING,
            null,
            value,
            opts && opts.session || null,
            opts && opts.ttl
          );
          req.timeout = delayMs + 1e3;
          return this._requestToPromise(req, opts);
        }
        async rttStats() {
          const stats = {
            successes: 0,
            errors: 0,
            responses: {
              avgRtt: 0,
              errors: 0,
              avgCloserNodes: 0
            },
            closestReplies: {
              avgRtt: 0,
              errors: 0,
              avgCloserNodes: 0
            }
          };
          if (this.nodes.latest) {
            const q = this.findNode(this.nodes.latest.id);
            let responseCount = 0;
            let closestCount = 0;
            for await (const msg of q) {
              stats.responses.avgRtt += msg.rtt;
              stats.responses.errors += msg.error;
              stats.responses.avgCloserNodes += msg.closerNodes?.length || 0;
              responseCount++;
            }
            stats.responses.avgRtt /= responseCount;
            stats.responses.avgCloserNodes /= responseCount;
            for await (const msg of q.closestReplies) {
              stats.closestReplies.avgRtt += msg.rtt;
              stats.closestReplies.errors += msg.error;
              stats.closestReplies.avgCloserNodes += msg.closerNodes?.length || 0;
              closestCount++;
            }
            stats.closestReplies.avgRtt /= closestCount;
            stats.closestReplies.avgCloserNodes /= closestCount;
            stats.successes = q.successes;
            stats.errors = q.errors;
          }
          return stats;
        }
        request({ token = null, command, target = null, value = null }, { host, port }, opts) {
          const req = this.io.createRequest(
            { id: null, host, port },
            token,
            false,
            command,
            target,
            value,
            opts && opts.session || null,
            opts && opts.ttl
          );
          return this._requestToPromise(req, opts);
        }
        session() {
          return new Session(this);
        }
        _requestToPromise(req, opts) {
          if (req === null) return Promise.reject(new Error("Node destroyed"));
          if (opts && opts.socket) req.socket = opts.socket;
          if (opts && opts.retry === false) req.retries = 0;
          return new Promise((resolve, reject) => {
            req.onresponse = resolve;
            req.onerror = reject;
            req.send();
          });
        }
        async _bootstrap() {
          const self2 = this;
          await Promise.resolve();
          await this.io.bind();
          this.emit("listening");
          let first = this.firewalled && this._quickFirewall && !this._forcePersistent;
          let testNat = false;
          const onlyFirewall = !this._forcePersistent;
          for (let i = 0; i < 2; i++) {
            await this._backgroundQuery(this.table.id).on("data", ondata).finished();
            if (this.bootstrapped || !testNat && !this._forcePersistent) break;
            if (!await this._updateNetworkState(onlyFirewall)) break;
          }
          if (this.bootstrapped) return;
          this.bootstrapped = true;
          this.emit("ready");
          function ondata(data) {
            if (!first) return;
            first = false;
            const value = b4a.allocUnsafe(2);
            c.uint16.encode({ start: 0, end: 2, buffer: value }, self2.io.serverSocket.address().port);
            self2._request(
              data.from,
              false,
              true,
              PING_NAT,
              null,
              value,
              null,
              () => {
                testNat = true;
              },
              noop
            );
          }
        }
        refresh() {
          const node = this.table.random();
          this._backgroundQuery(node ? node.id : this.table.id).on("error", noop);
        }
        async destroy() {
          const emitClose = !this.destroyed;
          this.destroyed = true;
          clearInterval(this._tickInterval);
          for (const timer of this._pendingTimers) {
            clearTimeout(timer);
          }
          await this.io.destroy();
          if (emitClose) this.emit("close");
        }
        _request(to, force, internal, command, target, value, session, onresponse, onerror) {
          if (internal && !this._sendDownHints && command === DOWN_HINT) return null;
          const req = this.io.createRequest(to, null, internal, command, target, value, session);
          if (req === null) return null;
          req.onresponse = onresponse;
          req.onerror = onerror;
          req.send(force);
          return req;
        }
        _natAdd(host, port) {
          const prevHost = this._nat.host;
          const prevPort = this._nat.port;
          this._nat.add(host, port);
          if (prevHost === this._nat.host && prevPort === this._nat.port) return;
          this.emit("nat-update", this._nat.host, this._nat.port);
        }
        // we don't check that this is a bootstrap node but we limit the sample size to very few nodes, so fine
        _sampleBootstrapMaybe(from, to) {
          if (this._nonePersistentSamples.length >= Math.max(1, this.bootstrapNodes.length)) return;
          const id = from.host + ":" + from.port;
          if (this._nonePersistentSamples.indexOf(id) > -1) return;
          this._nonePersistentSamples.push(id);
          this._natAdd(to.host, to.port);
        }
        _addNodeFromNetwork(sample, from, to) {
          if (this._filterNode !== null && !this._filterNode(from)) {
            return;
          }
          if (from.id === null) {
            this._sampleBootstrapMaybe(from, to);
            return;
          }
          const oldNode = this.table.get(from.id);
          if (oldNode) {
            if (sample && (oldNode.sampled === 0 || this._tick - oldNode.sampled >= OLD_NODE)) {
              oldNode.to = to;
              oldNode.sampled = this._tick;
              this._natAdd(to.host, to.port);
            }
            oldNode.pinged = oldNode.seen = this._tick;
            this.nodes.add(oldNode);
            return;
          }
          this._addNode({
            id: from.id,
            port: from.port,
            host: from.host,
            to,
            sampled: 0,
            added: this._tick,
            pinged: this._tick,
            // last time we interacted with them
            seen: this._tick,
            // last time we heard from them
            downHints: 0,
            prev: null,
            next: null
          });
        }
        _addNode(node) {
          if (this.nodes.has(node) || b4a.equals(node.id, this.table.id)) return;
          node.added = node.pinged = node.seen = this._tick;
          if (!this.table.add(node)) return;
          this.nodes.add(node);
          if (node.to && node.sampled === 0) {
            node.sampled = this._tick;
            this._natAdd(node.to.host, node.to.port);
          }
          this.emit("add-node", node);
        }
        _removeStaleNode(node, lastSeen) {
          if (node.seen <= lastSeen) this._removeNode(node);
        }
        _removeNode(node) {
          if (!this.nodes.has(node)) return;
          this.table.remove(node.id);
          this.nodes.remove(node);
          this.emit("remove-node", node);
        }
        _onwakeup() {
          this._tick += 2 * OLD_NODE;
          this._tick += 8 - (this._tick & 7) - 2;
          this._stableTicks = MORE_STABLE_TICKS;
          this._refreshTicks = 1;
          this._lastHost = null;
          this.health.reset();
          if (this.adaptive) {
            if (!this.ephemeral) {
              this.ephemeral = true;
              this.io.ephemeral = true;
              this.emit("ephemeral");
            }
          }
          this.emit("wakeup");
        }
        _onfullrow(newNode, row) {
          if (!this.bootstrapped || this._repinging >= 3) return;
          let oldest = null;
          for (const node of row.nodes) {
            if (node.pinged === this._tick) continue;
            if (oldest === null || oldest.pinged > node.pinged || oldest.pinged === node.pinged && oldest.added > node.added) {
              oldest = node;
            }
          }
          if (oldest === null) return;
          if (this._tick - oldest.pinged < RECENT_NODE && this._tick - oldest.added > OLD_NODE) return;
          this._repingAndSwap(newNode, oldest);
        }
        _onnetworkchange(interfaces) {
          this.emit("network-change", interfaces);
          this.emit("network-update");
        }
        _repingAndSwap(newNode, oldNode) {
          const self2 = this;
          const lastSeen = oldNode.seen;
          oldNode.pinged = this._tick;
          this._repinging++;
          this._request(
            { id: null, host: oldNode.host, port: oldNode.port },
            false,
            true,
            PING,
            null,
            null,
            null,
            onsuccess,
            onswap
          );
          function onsuccess(m) {
            if (oldNode.seen <= lastSeen) return onswap();
            self2._repinging--;
          }
          function onswap(e) {
            self2._repinging--;
            self2._removeNode(oldNode);
            self2._addNode(newNode);
          }
        }
        _onrequest(req, external) {
          if (req.from.id !== null) {
            this._addNodeFromNetwork(!external, req.from, req.to);
          }
          if (req.internal) {
            switch (req.command) {
              // standard keep alive call
              case PING: {
                req.sendReply(0, null, false, false);
                return;
              }
              case DELAYED_PING: {
                this._ondelayedping(req);
                return;
              }
              // check if the other side can receive a message to their other socket
              case PING_NAT: {
                if (req.value === null || req.value.byteLength < 2) return;
                const port = c.uint16.decode({ start: 0, end: 2, buffer: req.value });
                if (port === 0) return;
                req.from.port = port;
                req.sendReply(0, null, false, false);
                return;
              }
              // empty dht reply back
              case FIND_NODE: {
                if (!req.target) return;
                req.sendReply(0, null, false, true);
                return;
              }
              // "this is node you sent me is down" - let's try to ping it
              case DOWN_HINT: {
                if (req.value === null || req.value.byteLength < 6) return;
                if (this._checks < 10) {
                  sodium.crypto_generichash(TMP, req.value.subarray(0, 6));
                  const node = this.table.get(TMP);
                  if (node && (node.pinged < this._tick || node.downHints === 0)) {
                    node.downHints++;
                    this._check(node);
                  }
                }
                req.sendReply(0, null, false, false);
                return;
              }
            }
            req.sendReply(UNKNOWN_COMMAND, null, false, req.target !== null);
            return;
          }
          if (this.onrequest(req) === false) {
            req.sendReply(UNKNOWN_COMMAND, null, false, req.target !== null);
          }
        }
        onrequest(req) {
          return this.emit("request", req);
        }
        _ondelayedping(req) {
          if (req.value === null || req.value.byteLength < 4) return;
          const delayMs = c.uint32.decode({ start: 0, end: 4, buffer: req.value });
          if (delayMs > this.maxPingDelay) return;
          const timer = setTimeout(() => {
            if (this.destroyed) return;
            this._pendingTimers.delete(timer);
            req.sendReply(0, null, false, false);
          }, delayMs);
          this._pendingTimers.add(timer);
        }
        _onresponse(res, external) {
          this._addNodeFromNetwork(!external, res.from, res.to);
        }
        _ontimeout(req) {
          if (!req.to.id) return;
          const node = this.table.get(req.to.id);
          if (node) this._removeNode(node);
        }
        _pingSome() {
          let cnt = this.io.inflight.length > 2 ? 3 : 5;
          let oldest = this.nodes.oldest;
          if (!oldest) {
            this.refresh();
            return;
          }
          if (this._tick - oldest.pinged < RECENT_NODE) {
            cnt = 2;
          }
          while (cnt--) {
            if (!oldest || this._tick === oldest.pinged) continue;
            this._check(oldest);
            oldest = oldest.next;
          }
        }
        _check(node) {
          node.pinged = this._tick;
          const lastSeen = node.seen;
          const onresponse = () => {
            this._checks--;
            this._removeStaleNode(node, lastSeen);
          };
          const onerror = () => {
            this._checks--;
            this._removeNode(node);
          };
          this._checks++;
          this._request(
            { id: null, host: node.host, port: node.port },
            false,
            true,
            PING,
            null,
            null,
            null,
            onresponse,
            onerror
          );
        }
        _ontick() {
          const time = Date.now();
          if (time - this._lastTick > SLEEPING_INTERVAL && this.suspended === false) {
            this._onwakeup();
          } else {
            this._tick++;
          }
          this._lastTick = time;
          if (!this.bootstrapped || this.suspended) return;
          if (this.adaptive && this.ephemeral && --this._stableTicks <= 0) {
            if (this._lastHost === this._nat.host) {
              this._stableTicks = MORE_STABLE_TICKS;
            } else {
              this._updateNetworkState();
            }
          }
          if ((this._tick & 7) === 0) {
            this._pingSome();
          }
          if ((this._tick & 63) === 0 && this.nodes.length < this.table.k || --this._refreshTicks <= 0) {
            this.refresh();
          }
          this._downHintsSentPerTick = 0;
          this.health.update();
        }
        async _updateNetworkState(onlyFirewall = false) {
          if (!this.ephemeral) return false;
          if (onlyFirewall && !this.firewalled) return false;
          const { host, port } = this._nat;
          if (!onlyFirewall) {
            this._stableTicks = MORE_STABLE_TICKS;
            this._lastHost = host;
          }
          if (host === null || port === 0) {
            return false;
          }
          const natSampler = this.firewalled ? new NatSampler() : this._nat;
          const firewalled = this.firewalled && await this._checkIfFirewalled(natSampler);
          if (firewalled) return false;
          this.firewalled = this.io.firewalled = false;
          if (!this.ephemeral || host !== this._nat.host || port !== this._nat.port) return false;
          if (natSampler.host !== host || natSampler.port === 0) return false;
          const id = peer.id(natSampler.host, natSampler.port);
          if (!onlyFirewall) {
            this.ephemeral = this.io.ephemeral = false;
          }
          if (natSampler !== this._nat) {
            const prevHost = this._nat.host;
            const prevPort = this._nat.port;
            this._nonePersistentSamples = [];
            this._nat = natSampler;
            if (prevHost !== this._nat.host || prevPort !== this._nat.port) {
              this.emit("nat-update", this._nat.host, this._nat.port);
            }
          }
          if (!b4a.equals(this.table.id, id)) {
            const nodes = this.table.toArray();
            this.table = this.io.table = new Table(id);
            for (const node of nodes) {
              if (b4a.equals(node.id, id)) continue;
              if (!this.table.add(node)) this.nodes.remove(node);
            }
            this.table.on("row", this._onrow);
            if (this.bootstrapped) this.refresh();
          }
          if (!this.ephemeral) {
            this.emit("persistent");
          }
          return true;
        }
        async *_resolveBootstrapNodes() {
          for (let { host, port } of this.bootstrapNodes) {
            let doLookup = false;
            if (host.indexOf("@") === -1) {
              doLookup = true;
            } else {
              const [suggestedIP, fallbackHost] = host.split("@");
              try {
                await this.ping({ host: suggestedIP, port });
                host = suggestedIP;
              } catch {
                host = fallbackHost;
                doLookup = true;
              }
            }
            if (doLookup) {
              try {
                host = UDX.isIPv4(host) ? host : (await this.udx.lookup(host, { family: 4 })).host;
              } catch {
                continue;
              }
            }
            yield {
              id: peer.id(host, port),
              host,
              port
            };
          }
        }
        async _addBootstrapNodes(nodes) {
          for await (const node of this._resolveBootstrapNodes()) {
            nodes.push(node);
          }
        }
        async _checkIfFirewalled(natSampler = new NatSampler()) {
          const nodes = [];
          for (let node = this.nodes.latest; node && nodes.length < 5; node = node.prev) {
            nodes.push(node);
          }
          if (nodes.length < 5) await this._addBootstrapNodes(nodes);
          if (nodes.length === 0) return true;
          const hosts = /* @__PURE__ */ new Set();
          const value = b4a.allocUnsafe(2);
          c.uint16.encode({ start: 0, end: 2, buffer: value }, this.io.serverSocket.address().port);
          this.io.serverSocket.on("message", onmessage);
          const pongs = await requestAll(this, true, PING_NAT, value, nodes);
          let count = 0;
          for (const res of pongs) {
            if (hosts.has(res.from.host)) {
              count++;
              natSampler.add(res.to.host, res.to.port);
            }
          }
          this.io.serverSocket.removeListener("message", onmessage);
          if (count < (nodes.length >= 5 ? 3 : 1)) return true;
          if (natSampler.host === null || this._nat.host !== natSampler.host) return true;
          if (natSampler.port === 0 || natSampler.port !== this.io.serverSocket.address().port) {
            return true;
          }
          return false;
          function onmessage(_, { host }) {
            hosts.add(host);
          }
        }
        _backgroundQuery(target) {
          this._refreshTicks = REFRESH_TICKS;
          const backgroundCon = Math.min(this.concurrency, Math.max(2, this.concurrency / 8 | 0));
          const q = new Query(this, target, true, FIND_NODE, null, {
            concurrency: backgroundCon
          });
          q.on("data", () => {
            q.concurrency = this.io.inflight.length < 3 ? this.concurrency : backgroundCon;
          });
          return q;
        }
        // called by health
        _online() {
          if (this.online && !this.degraded) return;
          this.online = true;
          this.degraded = false;
          this.emit("network-update");
        }
        // called by health
        _degraded() {
          if (this.degraded) return;
          this.online = true;
          this.degraded = true;
          this.emit("network-update");
        }
        // called by health
        _offline() {
          if (!this.online) return;
          this.online = false;
          this.degraded = false;
          this.emit("network-update");
        }
      };
      DHT.OK = 0;
      DHT.ERROR_UNKNOWN_COMMAND = UNKNOWN_COMMAND;
      DHT.ERROR_INVALID_TOKEN = INVALID_TOKEN;
      module.exports = DHT;
      function localIP(udx, family = 4) {
        let host = null;
        for (const n of udx.networkInterfaces()) {
          if (n.family !== family || n.internal) continue;
          if (n.name === "en0") return n.host;
          if (host === null) host = n.host;
        }
        return host || (family === 4 ? "127.0.0.1" : "::1");
      }
      function parseNode(s) {
        if (typeof s === "object") return s;
        if (typeof s === "number") return { host: "127.0.0.1", port: s };
        const [host, port] = s.split(":");
        if (!port) throw new Error("Bootstrap node format is host:port");
        return {
          host,
          port: Number(port)
        };
      }
      function randomBytes(n) {
        const b = b4a.alloc(n);
        sodium.randombytes_buf(b);
        return b;
      }
      function randomOffset(n) {
        return n - (Math.random() * 0.5 * n | 0);
      }
      function requestAll(dht, internal, command, value, nodes) {
        let missing = nodes.length;
        const replies = [];
        return new Promise((resolve) => {
          for (const node of nodes) {
            const req = dht._request(
              node,
              false,
              internal,
              command,
              null,
              value,
              null,
              onsuccess,
              onerror
            );
            if (!req) return resolve(replies);
          }
          function onsuccess(res) {
            replies.push(res);
            if (--missing === 0) resolve(replies);
          }
          function onerror() {
            if (--missing === 0) resolve(replies);
          }
        });
      }
      function noop() {
      }
    }
  });

  // ../../node_modules/hyperdht/lib/messages.js
  var require_messages3 = __commonJS({
    "../../node_modules/hyperdht/lib/messages.js"(exports) {
      var c = require_compact_encoding();
      var ipv4 = {
        ...c.ipv4Address,
        decode(state) {
          const ip = c.ipv4Address.decode(state);
          return {
            host: ip.host,
            port: ip.port
          };
        }
      };
      var ipv4Array = c.array(ipv4);
      var ipv6 = {
        ...c.ipv6Address,
        decode(state) {
          const ip = c.ipv6Address.decode(state);
          return {
            host: ip.host,
            port: ip.port
          };
        }
      };
      var ipv6Array = c.array(ipv6);
      exports.handshake = {
        preencode(state, m) {
          state.end += 1 + 1 + (m.peerAddress ? 6 : 0) + (m.relayAddress ? 6 : 0);
          c.buffer.preencode(state, m.noise);
        },
        encode(state, m) {
          const flags = (m.peerAddress ? 1 : 0) | (m.relayAddress ? 2 : 0);
          c.uint.encode(state, flags);
          c.uint.encode(state, m.mode);
          c.buffer.encode(state, m.noise);
          if (m.peerAddress) ipv4.encode(state, m.peerAddress);
          if (m.relayAddress) ipv4.encode(state, m.relayAddress);
        },
        decode(state) {
          const flags = c.uint.decode(state);
          return {
            mode: c.uint.decode(state),
            noise: c.buffer.decode(state),
            peerAddress: flags & 1 ? ipv4.decode(state) : null,
            relayAddress: flags & 2 ? ipv4.decode(state) : null
          };
        }
      };
      var relayInfo = {
        preencode(state, m) {
          state.end += 12;
        },
        encode(state, m) {
          ipv4.encode(state, m.relayAddress);
          ipv4.encode(state, m.peerAddress);
        },
        decode(state) {
          return {
            relayAddress: ipv4.decode(state),
            peerAddress: ipv4.decode(state)
          };
        }
      };
      var relayInfoArray = c.array(relayInfo);
      var holepunchInfo = {
        preencode(state, m) {
          c.uint.preencode(state, m.id);
          relayInfoArray.preencode(state, m.relays);
        },
        encode(state, m) {
          c.uint.encode(state, m.id);
          relayInfoArray.encode(state, m.relays);
        },
        decode(state) {
          return {
            id: c.uint.decode(state),
            relays: relayInfoArray.decode(state)
          };
        }
      };
      var udxInfo = {
        preencode(state, m) {
          state.end += 2;
          c.uint.preencode(state, m.id);
          c.uint.preencode(state, m.seq);
        },
        encode(state, m) {
          c.uint.encode(state, 1);
          c.uint.encode(state, m.reusableSocket ? 1 : 0);
          c.uint.encode(state, m.id);
          c.uint.encode(state, m.seq);
        },
        decode(state) {
          const version = c.uint.decode(state);
          const features = c.uint.decode(state);
          return {
            version,
            reusableSocket: (features & 1) !== 0,
            id: c.uint.decode(state),
            seq: c.uint.decode(state)
          };
        }
      };
      var secretStreamInfo = {
        preencode(state, m) {
          c.uint.preencode(state, 1);
        },
        encode(state, m) {
          c.uint.encode(state, 1);
        },
        decode(state) {
          return {
            version: c.uint.decode(state)
          };
        }
      };
      var relayThroughInfo = {
        preencode(state, m) {
          c.uint.preencode(state, 1);
          c.uint.preencode(state, 0);
          c.fixed32.preencode(state, m.publicKey);
          c.fixed32.preencode(state, m.token);
        },
        encode(state, m) {
          c.uint.encode(state, 1);
          c.uint.encode(state, 0);
          c.fixed32.encode(state, m.publicKey);
          c.fixed32.encode(state, m.token);
        },
        decode(state) {
          const version = c.uint.decode(state);
          c.uint.decode(state);
          return {
            version,
            publicKey: c.fixed32.decode(state),
            token: c.fixed32.decode(state)
          };
        }
      };
      exports.noisePayload = {
        preencode(state, m) {
          state.end += 4;
          if (m.holepunch) holepunchInfo.preencode(state, m.holepunch);
          if (m.addresses4 && m.addresses4.length) ipv4Array.preencode(state, m.addresses4);
          if (m.addresses6 && m.addresses6.length) ipv6Array.preencode(state, m.addresses6);
          if (m.udx) udxInfo.preencode(state, m.udx);
          if (m.secretStream) secretStreamInfo.preencode(state, m.secretStream);
          if (m.relayThrough) relayThroughInfo.preencode(state, m.relayThrough);
          if (m.relayAddresses) ipv4Array.preencode(state, m.relayAddresses);
        },
        encode(state, m) {
          let flags = 0;
          if (m.holepunch) flags |= 1;
          if (m.addresses4 && m.addresses4.length) flags |= 2;
          if (m.addresses6 && m.addresses6.length) flags |= 4;
          if (m.udx) flags |= 8;
          if (m.secretStream) flags |= 16;
          if (m.relayThrough) flags |= 32;
          if (m.relayAddresses) flags |= 64;
          c.uint.encode(state, 1);
          c.uint.encode(state, flags);
          c.uint.encode(state, m.error);
          c.uint.encode(state, m.firewall);
          if (m.holepunch) holepunchInfo.encode(state, m.holepunch);
          if (m.addresses4 && m.addresses4.length) ipv4Array.encode(state, m.addresses4);
          if (m.addresses6 && m.addresses6.length) ipv6Array.encode(state, m.addresses6);
          if (m.udx) udxInfo.encode(state, m.udx);
          if (m.secretStream) secretStreamInfo.encode(state, m.secretStream);
          if (m.relayThrough) relayThroughInfo.encode(state, m.relayThrough);
          if (m.relayAddresses) ipv4Array.encode(state, m.relayAddresses);
        },
        decode(state) {
          const version = c.uint.decode(state);
          if (version !== 1) {
            return {
              version,
              error: 0,
              firewall: 0,
              holepunch: null,
              addresses4: [],
              addresses6: [],
              udx: null,
              secretStream: null,
              relayThrough: null,
              relayAddresses: null
            };
          }
          const flags = c.uint.decode(state);
          return {
            version,
            error: c.uint.decode(state),
            firewall: c.uint.decode(state),
            holepunch: (flags & 1) !== 0 ? holepunchInfo.decode(state) : null,
            addresses4: (flags & 2) !== 0 ? ipv4Array.decode(state) : [],
            addresses6: (flags & 4) !== 0 ? ipv6Array.decode(state) : [],
            udx: (flags & 8) !== 0 ? udxInfo.decode(state) : null,
            secretStream: (flags & 16) !== 0 ? secretStreamInfo.decode(state) : null,
            relayThrough: (flags & 32) !== 0 ? relayThroughInfo.decode(state) : null,
            relayAddresses: (flags & 64) !== 0 ? ipv4Array.decode(state) : null
          };
        }
      };
      exports.holepunch = {
        preencode(state, m) {
          state.end += 2;
          c.uint.preencode(state, m.id);
          c.buffer.preencode(state, m.payload);
          if (m.peerAddress) ipv4.preencode(state, m.peerAddress);
        },
        encode(state, m) {
          const flags = m.peerAddress ? 1 : 0;
          c.uint.encode(state, flags);
          c.uint.encode(state, m.mode);
          c.uint.encode(state, m.id);
          c.buffer.encode(state, m.payload);
          if (m.peerAddress) ipv4.encode(state, m.peerAddress);
        },
        decode(state) {
          const flags = c.uint.decode(state);
          return {
            mode: c.uint.decode(state),
            id: c.uint.decode(state),
            payload: c.buffer.decode(state),
            peerAddress: flags & 1 ? ipv4.decode(state) : null
          };
        }
      };
      exports.holepunchPayload = {
        preencode(state, m) {
          state.end += 4;
          if (m.addresses) ipv4Array.preencode(state, m.addresses);
          if (m.remoteAddress) state.end += 6;
          if (m.token) state.end += 32;
          if (m.remoteToken) state.end += 32;
        },
        encode(state, m) {
          const flags = (m.connected ? 1 : 0) | (m.punching ? 2 : 0) | (m.addresses ? 4 : 0) | (m.remoteAddress ? 8 : 0) | (m.token ? 16 : 0) | (m.remoteToken ? 32 : 0);
          c.uint.encode(state, flags);
          c.uint.encode(state, m.error);
          c.uint.encode(state, m.firewall);
          c.uint.encode(state, m.round);
          if (m.addresses) ipv4Array.encode(state, m.addresses);
          if (m.remoteAddress) ipv4.encode(state, m.remoteAddress);
          if (m.token) c.fixed32.encode(state, m.token);
          if (m.remoteToken) c.fixed32.encode(state, m.remoteToken);
        },
        decode(state) {
          const flags = c.uint.decode(state);
          return {
            error: c.uint.decode(state),
            firewall: c.uint.decode(state),
            round: c.uint.decode(state),
            connected: (flags & 1) !== 0,
            punching: (flags & 2) !== 0,
            addresses: (flags & 4) !== 0 ? ipv4Array.decode(state) : null,
            remoteAddress: (flags & 8) !== 0 ? ipv4.decode(state) : null,
            token: (flags & 16) !== 0 ? c.fixed32.decode(state) : null,
            remoteToken: (flags & 32) !== 0 ? c.fixed32.decode(state) : null
          };
        }
      };
      var peer = exports.peer = {
        preencode(state, m) {
          state.end += 32;
          ipv4Array.preencode(state, m.relayAddresses);
        },
        encode(state, m) {
          c.fixed32.encode(state, m.publicKey);
          ipv4Array.encode(state, m.relayAddresses);
        },
        decode(state) {
          return {
            publicKey: c.fixed32.decode(state),
            relayAddresses: ipv4Array.decode(state)
          };
        }
      };
      var peers = exports.peers = c.array(peer);
      var rawPeers = c.array(c.raw);
      exports.lookupRawReply = {
        preencode(state, m) {
          rawPeers.preencode(state, m.peers);
          c.uint.preencode(state, m.bump);
        },
        encode(state, m) {
          rawPeers.encode(state, m.peers);
          c.uint.encode(state, m.bump);
        },
        decode(state) {
          return {
            peers: peers.decode(state),
            bump: state.start < state.end ? c.uint.decode(state) : 0
          };
        }
      };
      exports.announce = {
        preencode(state, m) {
          state.end++;
          if (m.peer) peer.preencode(state, m.peer);
          if (m.refresh) state.end += 32;
          if (m.signature) state.end += 64;
          if (m.bump) c.uint.preencode(state, m.bump);
        },
        encode(state, m) {
          const flags = (m.peer ? 1 : 0) | (m.refresh ? 2 : 0) | (m.signature ? 4 : 0) | (m.bump ? 8 : 0);
          c.uint.encode(state, flags);
          if (m.peer) peer.encode(state, m.peer);
          if (m.refresh) c.fixed32.encode(state, m.refresh);
          if (m.signature) c.fixed64.encode(state, m.signature);
          if (m.bump) c.uint.encode(state, m.bump);
        },
        decode(state) {
          const flags = c.uint.decode(state);
          return {
            peer: (flags & 1) !== 0 ? peer.decode(state) : null,
            refresh: (flags & 2) !== 0 ? c.fixed32.decode(state) : null,
            signature: (flags & 4) !== 0 ? c.fixed64.decode(state) : null,
            bump: (flags & 8) !== 0 ? c.uint.decode(state) : 0
          };
        }
      };
      exports.mutableSignable = {
        preencode(state, m) {
          c.uint.preencode(state, m.seq);
          c.buffer.preencode(state, m.value);
        },
        encode(state, m) {
          c.uint.encode(state, m.seq);
          c.buffer.encode(state, m.value);
        },
        decode(state) {
          return {
            seq: c.uint.decode(state),
            value: c.buffer.decode(state)
          };
        }
      };
      exports.mutablePutRequest = {
        preencode(state, m) {
          c.fixed32.preencode(state, m.publicKey);
          c.uint.preencode(state, m.seq);
          c.buffer.preencode(state, m.value);
          c.fixed64.preencode(state, m.signature);
        },
        encode(state, m) {
          c.fixed32.encode(state, m.publicKey);
          c.uint.encode(state, m.seq);
          c.buffer.encode(state, m.value);
          c.fixed64.encode(state, m.signature);
        },
        decode(state) {
          return {
            publicKey: c.fixed32.decode(state),
            seq: c.uint.decode(state),
            value: c.buffer.decode(state),
            signature: c.fixed64.decode(state)
          };
        }
      };
      exports.mutableGetResponse = {
        preencode(state, m) {
          c.uint.preencode(state, m.seq);
          c.buffer.preencode(state, m.value);
          c.fixed64.preencode(state, m.signature);
        },
        encode(state, m) {
          c.uint.encode(state, m.seq);
          c.buffer.encode(state, m.value);
          c.fixed64.encode(state, m.signature);
        },
        decode(state) {
          return {
            seq: c.uint.decode(state),
            value: c.buffer.decode(state),
            signature: c.fixed64.decode(state)
          };
        }
      };
    }
  });

  // ../../node_modules/hyperdht/lib/socket-pool.js
  var require_socket_pool = __commonJS({
    "../../node_modules/hyperdht/lib/socket-pool.js"(exports, module) {
      var b4a = require_b4a();
      var LINGER_TIME = 3e3;
      module.exports = class SocketPool {
        constructor(dht, host) {
          this._dht = dht;
          this._sockets = /* @__PURE__ */ new Map();
          this._lingering = /* @__PURE__ */ new Set();
          this._host = host;
          this.routes = new SocketRoutes(this);
        }
        _onmessage(ref, data, address) {
          this._dht.onmessage(ref.socket, data, address);
        }
        _add(ref) {
          this._sockets.set(ref.socket, ref);
        }
        _remove(ref) {
          this._sockets.delete(ref.socket);
          this._lingering.delete(ref);
        }
        lookup(socket) {
          return this._sockets.get(socket) || null;
        }
        setReusable(socket, bool) {
          const ref = this.lookup(socket);
          if (ref) ref.reusable = bool;
        }
        acquire() {
          return new SocketRef(this);
        }
        async destroy() {
          const closing = [];
          for (const ref of this._sockets.values()) {
            ref._unlinger();
            closing.push(ref.socket.close());
          }
          await Promise.allSettled(closing);
        }
      };
      var SocketRoutes = class {
        constructor(pool) {
          this._pool = pool;
          this._routes = /* @__PURE__ */ new Map();
        }
        add(publicKey, rawStream) {
          if (rawStream.socket) this._onconnect(publicKey, rawStream);
          else rawStream.on("connect", this._onconnect.bind(this, publicKey, rawStream));
        }
        get(publicKey) {
          const id = b4a.toString(publicKey, "hex");
          const route = this._routes.get(id);
          if (!route) return null;
          return route;
        }
        _onconnect(publicKey, rawStream) {
          const id = b4a.toString(publicKey, "hex");
          const socket = rawStream.socket;
          let route = this._routes.get(id);
          if (!route) {
            const gc = () => {
              if (this._routes.get(id) === route) this._routes.delete(id);
              socket.removeListener("close", gc);
            };
            route = {
              socket,
              address: { host: rawStream.remoteHost, port: rawStream.remotePort },
              gc
            };
            this._routes.set(id, route);
            socket.on("close", gc);
          }
          this._pool.setReusable(socket, true);
          rawStream.on("error", () => {
            this._pool.setReusable(socket, false);
            if (!route) route = this._routes.get(id);
            if (route && route.socket === socket) route.gc();
          });
        }
      };
      var SocketRef = class {
        constructor(pool) {
          this._pool = pool;
          this.onholepunchmessage = noop;
          this.reusable = false;
          this.socket = pool._dht.udx.createSocket();
          this.socket.on("close", this._onclose.bind(this)).on("message", this._onmessage.bind(this)).on("idle", this._onidle.bind(this)).on("busy", this._onbusy.bind(this)).bind(0, this._pool._host);
          this._refs = 1;
          this._released = false;
          this._closed = false;
          this._timeout = null;
          this._wasBusy = false;
          this._pool._add(this);
        }
        _onclose() {
          this._pool._remove(this);
        }
        _onmessage(data, address) {
          if (data.byteLength > 1) {
            this._pool._onmessage(this, data, address);
          } else {
            this.onholepunchmessage(data, address, this);
          }
        }
        _onidle() {
          this._closeMaybe();
        }
        _onbusy() {
          this._wasBusy = true;
          this._unlinger();
        }
        _reset() {
          this.onholepunchmessage = noop;
        }
        _closeMaybe() {
          if (this._refs === 0 && this.socket.idle && !this._timeout) this._close();
        }
        _lingeringClose() {
          this._pool._lingering.delete(this);
          this._timeout = null;
          this._closeMaybe();
        }
        _close() {
          this._unlinger();
          if (this.reusable && this._wasBusy) {
            this._wasBusy = false;
            this._pool._lingering.add(this);
            this._timeout = setTimeout(this._lingeringClose.bind(this), LINGER_TIME);
            return;
          }
          this._closed = true;
          this.socket.close();
        }
        _unlinger() {
          if (this._timeout !== null) {
            clearTimeout(this._timeout);
            this._pool._lingering.delete(this);
            this._timeout = null;
          }
        }
        get free() {
          return this._refs === 0;
        }
        active() {
          this._refs++;
          this._unlinger();
        }
        inactive() {
          this._refs--;
          this._closeMaybe();
        }
        address() {
          return this.socket.address();
        }
        release() {
          if (this._released) return;
          this._released = true;
          this._reset();
          this._refs--;
          this._closeMaybe();
        }
      };
      function noop() {
      }
    }
  });

  // ../../node_modules/record-cache/index.js
  var require_record_cache = __commonJS({
    "../../node_modules/record-cache/index.js"(exports, module) {
      var b4a = require_b4a();
      var EMPTY = [];
      module.exports = RecordCache;
      function RecordSet() {
        this.list = [];
        this.map = /* @__PURE__ */ new Map();
      }
      RecordSet.prototype.add = function(record, value) {
        var k = toString(record);
        var r = this.map.get(k);
        if (r) return false;
        r = { index: this.list.length, record: value || record };
        this.list.push(r);
        this.map.set(k, r);
        return true;
      };
      RecordSet.prototype.remove = function(record) {
        var k = toString(record);
        var r = this.map.get(k);
        if (!r) return false;
        swap(this.list, r.index, this.list.length - 1);
        this.list.pop();
        this.map.delete(k);
        return true;
      };
      function RecordStore() {
        this.records = /* @__PURE__ */ new Map();
        this.size = 0;
      }
      RecordStore.prototype.add = function(name, record, value) {
        var r = this.records.get(name);
        if (!r) {
          r = new RecordSet();
          this.records.set(name, r);
        }
        if (r.add(record, value)) {
          this.size++;
          return true;
        }
        return false;
      };
      RecordStore.prototype.remove = function(name, record, value) {
        var r = this.records.get(name);
        if (!r) return false;
        if (r.remove(record, value)) {
          this.size--;
          if (!r.map.size) this.records.delete(name);
          return true;
        }
        return false;
      };
      RecordStore.prototype.get = function(name) {
        var r = this.records.get(name);
        return r ? r.list : EMPTY;
      };
      function RecordCache(opts) {
        if (!(this instanceof RecordCache)) return new RecordCache(opts);
        if (!opts) opts = {};
        this.maxSize = opts.maxSize || Infinity;
        this.maxAge = opts.maxAge || 0;
        this._onstale = opts.onStale || opts.onstale || null;
        this._fresh = new RecordStore();
        this._stale = new RecordStore();
        this._interval = null;
        this._gced = false;
        if (this.maxAge && this.maxAge < Infinity) {
          var tick = Math.ceil(2 / 3 * this.maxAge);
          this._interval = setInterval(this._gcAuto.bind(this), tick);
          if (this._interval.unref) this._interval.unref();
        }
      }
      Object.defineProperty(RecordCache.prototype, "size", {
        get: function() {
          return this._fresh.size + this._stale.size;
        }
      });
      RecordCache.prototype.add = function(name, record, value) {
        this._stale.remove(name, record, value);
        if (this._fresh.add(name, record, value) && this._fresh.size > this.maxSize) {
          this._gc();
        }
      };
      RecordCache.prototype.remove = function(name, record, value) {
        this._fresh.remove(name, record, value);
        this._stale.remove(name, record, value);
      };
      RecordCache.prototype.get = function(name, n) {
        var a = this._fresh.get(name);
        var b = this._stale.get(name);
        var aLen = a.length;
        var bLen = b.length;
        var len = aLen + bLen;
        if (n > len || !n) n = len;
        var result = new Array(n);
        for (var i = 0; i < n; i++) {
          var j = Math.floor(Math.random() * (aLen + bLen));
          if (j < aLen) {
            result[i] = a[j].record;
            swap(a, j, --aLen);
          } else {
            j -= aLen;
            result[i] = b[j].record;
            swap(b, j, --bLen);
          }
        }
        return result;
      };
      RecordCache.prototype._gcAuto = function() {
        if (!this._gced) this._gc();
        this._gced = false;
      };
      RecordCache.prototype._gc = function() {
        if (this._onstale && this._stale.size > 0) this._onstale(this._stale);
        this._stale = this._fresh;
        this._fresh = new RecordStore();
        this._gced = true;
      };
      RecordCache.prototype.clear = function() {
        this._gc();
        this._gc();
      };
      RecordCache.prototype.destroy = function() {
        this.clear();
        clearInterval(this._interval);
        this._interval = null;
      };
      function toString(record) {
        return b4a.isBuffer(record) ? b4a.toString(record, "hex") : record;
      }
      function swap(list, a, b) {
        var tmp = list[a];
        tmp.index = b;
        list[b].index = a;
        list[a] = list[b];
        list[b] = tmp;
      }
    }
  });

  // ../../node_modules/hyperdht/lib/encode.js
  var require_encode2 = __commonJS({
    "../../node_modules/hyperdht/lib/encode.js"(exports, module) {
      var b4a = require_b4a();
      var cenc = require_compact_encoding();
      function encodeUnslab(enc, m) {
        const state = cenc.state();
        enc.preencode(state, m);
        state.buffer = b4a.allocUnsafeSlow(state.end);
        enc.encode(state, m);
        return state.buffer;
      }
      module.exports = {
        encodeUnslab
      };
    }
  });

  // ../../node_modules/hyperdht/lib/constants.js
  var require_constants6 = __commonJS({
    "../../node_modules/hyperdht/lib/constants.js"(exports) {
      var crypto = require_hypercore_crypto();
      var COMMANDS = exports.COMMANDS = {
        PEER_HANDSHAKE: 0,
        PEER_HOLEPUNCH: 1,
        FIND_PEER: 2,
        LOOKUP: 3,
        ANNOUNCE: 4,
        UNANNOUNCE: 5,
        MUTABLE_PUT: 6,
        MUTABLE_GET: 7,
        IMMUTABLE_PUT: 8,
        IMMUTABLE_GET: 9
      };
      exports.BOOTSTRAP_NODES = global.Pear?.config.dht?.bootstrap || [
        "88.99.3.86@node1.hyperdht.org:49737",
        "142.93.90.113@node2.hyperdht.org:49737",
        "138.68.147.8@node3.hyperdht.org:49737"
      ];
      exports.KNOWN_NODES = global.Pear?.config.dht?.nodes || [];
      exports.FIREWALL = {
        UNKNOWN: 0,
        OPEN: 1,
        CONSISTENT: 2,
        RANDOM: 3
      };
      exports.ERROR = {
        // noise / connection related
        NONE: 0,
        ABORTED: 1,
        VERSION_MISMATCH: 2,
        TRY_LATER: 3,
        // dht related
        SEQ_REUSED: 16,
        SEQ_TOO_LOW: 17
      };
      var [NS_ANNOUNCE, NS_UNANNOUNCE, NS_MUTABLE_PUT, NS_PEER_HANDSHAKE, NS_PEER_HOLEPUNCH] = crypto.namespace("hyperswarm/dht", [
        COMMANDS.ANNOUNCE,
        COMMANDS.UNANNOUNCE,
        COMMANDS.MUTABLE_PUT,
        COMMANDS.PEER_HANDSHAKE,
        COMMANDS.PEER_HOLEPUNCH
      ]);
      exports.NS = {
        ANNOUNCE: NS_ANNOUNCE,
        UNANNOUNCE: NS_UNANNOUNCE,
        MUTABLE_PUT: NS_MUTABLE_PUT,
        PEER_HANDSHAKE: NS_PEER_HANDSHAKE,
        PEER_HOLEPUNCH: NS_PEER_HOLEPUNCH
      };
    }
  });

  // ../../node_modules/hyperdht/lib/persistent.js
  var require_persistent = __commonJS({
    "../../node_modules/hyperdht/lib/persistent.js"(exports, module) {
      var c = require_compact_encoding();
      var sodium = require_sodium_universal();
      var RecordCache = require_record_cache();
      var Cache = require_xache();
      var b4a = require_b4a();
      var unslab = require_unslab();
      var { encodeUnslab } = require_encode2();
      var m = require_messages3();
      var { NS, ERROR } = require_constants6();
      var EMPTY = b4a.alloc(0);
      var TMP = b4a.allocUnsafe(32);
      var MAX_BUMP_DRIFT = 6e4;
      module.exports = class Persistent {
        constructor(dht, opts) {
          this.dht = dht;
          this.records = new RecordCache(opts.records);
          this.bumps = new Cache(opts.bumps);
          this.refreshes = new Cache(opts.refreshes);
          this.mutables = new Cache(opts.mutables);
          this.immutables = new Cache(opts.immutables);
        }
        onlookup(req) {
          if (!req.target) return;
          const k = b4a.toString(req.target, "hex");
          const records = this.records.get(k, 20);
          const bump = this.bumps.get(k) || 0;
          const fwd = this.dht._router.get(k);
          if (fwd && records.length < 20) records.push(fwd.record);
          req.reply(records.length ? c.encode(m.lookupRawReply, { peers: records, bump }) : null);
        }
        onfindpeer(req) {
          if (!req.target) return;
          const fwd = this.dht._router.get(req.target);
          req.reply(fwd ? fwd.record : null);
        }
        unannounce(target, publicKey) {
          const k = b4a.toString(target, "hex");
          sodium.crypto_generichash(TMP, publicKey);
          if (b4a.equals(TMP, target)) this.dht._router.delete(k);
          this.records.remove(k, publicKey);
        }
        onunannounce(req) {
          if (!req.target || !req.token) return;
          const unann = decode(m.announce, req.value);
          if (unann === null) return;
          const { peer, signature } = unann;
          if (!peer || !signature) return;
          const signable = annSignable(req.target, req.token, this.dht.id, unann, NS.UNANNOUNCE);
          if (!sodium.crypto_sign_verify_detached(signature, signable, peer.publicKey)) {
            return;
          }
          this.unannounce(req.target, peer.publicKey);
          req.reply(null, { token: false, closerNodes: false });
        }
        _onrefresh(token, req) {
          sodium.crypto_generichash(TMP, token);
          const activeRefresh = b4a.toString(TMP, "hex");
          const r = this.refreshes.get(activeRefresh);
          if (!r) return;
          const { announceSelf, k, record } = r;
          const publicKey = record.subarray(0, 32);
          if (announceSelf) {
            this.dht._router.set(k, {
              relay: req.from,
              record,
              onconnect: null,
              onholepunch: null
            });
            this.records.remove(k, publicKey);
          } else {
            this.records.add(k, publicKey, record);
          }
          this.refreshes.delete(activeRefresh);
          this.refreshes.set(b4a.toString(token, "hex"), r);
          req.reply(null, { token: false, closerNodes: false });
        }
        onannounce(req) {
          if (!req.target || !req.token || !this.dht.id) return;
          const ann = decode(m.announce, req.value);
          if (ann === null) return;
          const { peer, refresh, signature, bump } = ann;
          if (!peer) {
            if (!refresh) return;
            this._onrefresh(refresh, req);
            return;
          }
          const signable = annSignable(req.target, req.token, this.dht.id, ann, NS.ANNOUNCE);
          if (!signature || !sodium.crypto_sign_verify_detached(signature, signable, peer.publicKey)) {
            return;
          }
          if (peer.relayAddresses.length > 3) {
            peer.relayAddresses = peer.relayAddresses.slice(0, 3);
          }
          sodium.crypto_generichash(TMP, peer.publicKey);
          const k = b4a.toString(req.target, "hex");
          const announceSelf = b4a.equals(TMP, req.target);
          const record = encodeUnslab(m.peer, peer);
          if (announceSelf) {
            this.dht._router.set(k, {
              relay: req.from,
              record,
              onconnect: null,
              onholepunch: null
            });
            this.records.remove(k, peer.publicKey);
          } else {
            const currentBump = this.bumps.get(k) || 0;
            if (bump > currentBump && bump <= Date.now() + MAX_BUMP_DRIFT) this.bumps.set(k, bump);
            this.records.add(k, peer.publicKey, record);
          }
          if (refresh) {
            this.refreshes.set(b4a.toString(refresh, "hex"), { k, record, announceSelf });
          }
          req.reply(null, { token: false, closerNodes: false });
        }
        onmutableget(req) {
          if (!req.target || !req.value) return;
          let seq = 0;
          try {
            seq = c.decode(c.uint, req.value);
          } catch {
            return;
          }
          const k = b4a.toString(req.target, "hex");
          const value = this.mutables.get(k);
          if (!value) {
            req.reply(null);
            return;
          }
          const localSeq = c.decode(c.uint, value);
          req.reply(localSeq < seq ? null : value);
        }
        onmutableput(req) {
          if (!req.target || !req.token || !req.value) return;
          const p = decode(m.mutablePutRequest, req.value);
          if (!p) return;
          const { publicKey, seq, value, signature } = p;
          const hash = b4a.allocUnsafe(32);
          sodium.crypto_generichash(hash, publicKey);
          if (!b4a.equals(hash, req.target)) return;
          if (!value || !verifyMutable(signature, seq, value, publicKey)) return;
          const k = b4a.toString(hash, "hex");
          const local = this.mutables.get(k);
          if (local) {
            const existing = c.decode(m.mutableGetResponse, local);
            if (existing.value && existing.seq === seq && b4a.compare(value, existing.value) !== 0) {
              req.error(ERROR.SEQ_REUSED);
              return;
            }
            if (seq < existing.seq) {
              req.error(ERROR.SEQ_TOO_LOW);
              return;
            }
          }
          this.mutables.set(k, encodeUnslab(m.mutableGetResponse, { seq, value, signature }));
          req.reply(null);
        }
        onimmutableget(req) {
          if (!req.target) return;
          const k = b4a.toString(req.target, "hex");
          const value = this.immutables.get(k);
          req.reply(value || null);
        }
        onimmutableput(req) {
          if (!req.target || !req.token || !req.value) return;
          const hash = b4a.alloc(32);
          sodium.crypto_generichash(hash, req.value);
          if (!b4a.equals(hash, req.target)) return;
          const k = b4a.toString(hash, "hex");
          this.immutables.set(k, unslab(req.value));
          req.reply(null);
        }
        destroy() {
          this.records.destroy();
          this.refreshes.destroy();
          this.mutables.destroy();
          this.immutables.destroy();
        }
        static signMutable(seq, value, keyPair) {
          const signable = b4a.allocUnsafe(32 + 32);
          const hash = signable.subarray(32);
          signable.set(NS.MUTABLE_PUT, 0);
          sodium.crypto_generichash(hash, c.encode(m.mutableSignable, { seq, value }));
          return sign(signable, keyPair);
        }
        static verifyMutable(signature, seq, value, publicKey) {
          return verifyMutable(signature, seq, value, publicKey);
        }
        static signAnnounce(target, token, id, ann, keyPair) {
          return sign(annSignable(target, token, id, ann, NS.ANNOUNCE), keyPair);
        }
        static signUnannounce(target, token, id, ann, keyPair) {
          return sign(annSignable(target, token, id, ann, NS.UNANNOUNCE), keyPair);
        }
      };
      function verifyMutable(signature, seq, value, publicKey) {
        const signable = b4a.allocUnsafe(32 + 32);
        const hash = signable.subarray(32);
        signable.set(NS.MUTABLE_PUT, 0);
        sodium.crypto_generichash(hash, c.encode(m.mutableSignable, { seq, value }));
        return sodium.crypto_sign_verify_detached(signature, signable, publicKey);
      }
      function annSignable(target, token, id, ann, ns) {
        const signable = b4a.allocUnsafe(32 + 32);
        const hash = signable.subarray(32);
        signable.set(ns, 0);
        sodium.crypto_generichash_batch(hash, [
          target,
          id,
          token,
          c.encode(m.peer, ann.peer),
          // note that this is the partial encoding of the announce message so we could just use that for perf
          ann.refresh || EMPTY
        ]);
        return signable;
      }
      function sign(signable, keyPair) {
        if (keyPair.sign) {
          return keyPair.sign(signable);
        }
        const secretKey = keyPair.secretKey ? keyPair.secretKey : keyPair;
        const signature = b4a.allocUnsafe(64);
        sodium.crypto_sign_detached(signature, signable, secretKey);
        return signature;
      }
      function decode(enc, val) {
        try {
          return val && c.decode(enc, val);
        } catch (err) {
          return null;
        }
      }
    }
  });

  // ../../node_modules/hyperdht/lib/errors.js
  var require_errors11 = __commonJS({
    "../../node_modules/hyperdht/lib/errors.js"(exports, module) {
      module.exports = class DHTError extends Error {
        constructor(msg, code, fn = DHTError) {
          super(`${code}: ${msg}`);
          this.code = code;
          if (Error.captureStackTrace) {
            Error.captureStackTrace(this, fn);
          }
        }
        get name() {
          return "DHTError";
        }
        static BAD_HANDSHAKE_REPLY(msg = "Bad handshake reply") {
          return new DHTError(msg, "BAD_HANDSHAKE_REPLY", DHTError.BAD_HANDSHAKE_REPLY);
        }
        static BAD_HOLEPUNCH_REPLY(msg = "Bad holepunch reply") {
          return new DHTError(msg, "BAD_HOLEPUNCH_REPLY", DHTError.BAD_HOLEPUNCH_REPLY);
        }
        static HOLEPUNCH_ABORTED(msg = "Holepunch aborted") {
          return new DHTError(msg, "HOLEPUNCH_ABORTED", DHTError.HOLEPUNCH_ABORTED);
        }
        static HOLEPUNCH_INVALID(msg = "Invalid holepunch payload") {
          return new DHTError(msg, "HOLEPUNCH_INVALID", DHTError.HOLEPUNCH_INVALID);
        }
        static HOLEPUNCH_PROBE_TIMEOUT(msg = "Holepunching probe did not finish in time") {
          return new DHTError(msg, "HOLEPUNCH_PROBE_TIMEOUT", DHTError.HOLEPUNCH_PROBE_TIMEOUT);
        }
        static HOLEPUNCH_DOUBLE_RANDOMIZED_NATS(msg = "Both remote and local NATs are randomized") {
          return new DHTError(
            msg,
            "HOLEPUNCH_DOUBLE_RANDOMIZED_NATS",
            DHTError.HOLEPUNCH_DOUBLE_RANDOMIZED_NATS
          );
        }
        static CANNOT_HOLEPUNCH(msg = "Cannot holepunch to remote") {
          return new DHTError(msg, "CANNOT_HOLEPUNCH", DHTError.CANNOT_HOLEPUNCH);
        }
        static REMOTE_NOT_HOLEPUNCHING(msg = "Remote is not holepunching") {
          return new DHTError(msg, "REMOTE_NOT_HOLEPUNCHING", DHTError.REMOTE_NOT_HOLEPUNCHING);
        }
        static REMOTE_NOT_HOLEPUNCHABLE(msg = "Remote is not holepunchable") {
          return new DHTError(msg, "REMOTE_NOT_HOLEPUNCHABLE", DHTError.REMOTE_NOT_HOLEPUNCHABLE);
        }
        static REMOTE_ABORTED(msg = "Remote aborted") {
          return new DHTError(msg, "REMOTE_ABORTED", DHTError.REMOTE_ABORTED);
        }
        static HANDSHAKE_UNFINISHED(msg = "Handshake did not finish") {
          return new DHTError(msg, "HANDSHAKE_UNFINISHED", DHTError.HANDSHAKE_UNFINISHED);
        }
        static HANDSHAKE_INVALID(msg = "Received invalid handshake") {
          return new DHTError(msg, "HANDSHAKE_INVALID", DHTError.HANDSHAKE_INVALID);
        }
        static ALREADY_LISTENING(msg = "Already listening") {
          return new DHTError(msg, "ALREADY_LISTENING", DHTError.ALREADY_LISTENING);
        }
        static KEYPAIR_ALREADY_USED(msg = "Keypair already used") {
          return new DHTError(msg, "KEYPAIR_ALREADY_USED", DHTError.KEYPAIR_ALREADY_USED);
        }
        static NODE_DESTROYED(msg = "Node destroyed") {
          return new DHTError(msg, "NODE_DESTROYED", DHTError.NODE_DESTROYED);
        }
        static PEER_CONNECTION_FAILED(msg = "Could not connect to peer") {
          return new DHTError(msg, "PEER_CONNECTION_FAILED", DHTError.PEER_CONNECTION_FAILED);
        }
        static PEER_NOT_FOUND(msg = "Peer not found") {
          return new DHTError(msg, "PEER_NOT_FOUND", DHTError.PEER_NOT_FOUND);
        }
        static STREAM_NOT_CONNECTED(msg = "Stream is not connected") {
          return new DHTError(msg, "STREAM_NOT_CONNECTED", DHTError.STREAM_DISCONNECTED);
        }
        static SERVER_INCOMPATIBLE(msg = "Server is using an incompatible version") {
          return new DHTError(msg, "SERVER_INCOMPATIBLE", DHTError.SERVER_INCOMPATIBLE);
        }
        static SERVER_ERROR(msg = "Server returned an error") {
          return new DHTError(msg, "SERVER_ERROR", DHTError.SERVER_ERROR);
        }
        static DUPLICATE_CONNECTION(msg = "Duplicate connection") {
          return new DHTError(msg, "DUPLICATE_CONNECTION", DHTError.DUPLICATE_CONNECTION);
        }
        static RELAY_ABORTED(msg = "Relay aborted") {
          return new DHTError(msg, "RELAY_ABORTED", DHTError.RELAY_ABORTED);
        }
        static SUSPENDED(msg = "Suspended") {
          return new DHTError(msg, "SUSPENDED", DHTError.SUSPENDED);
        }
      };
    }
  });

  // ../../node_modules/hyperdht/lib/router.js
  var require_router = __commonJS({
    "../../node_modules/hyperdht/lib/router.js"(exports, module) {
      var c = require_compact_encoding();
      var Cache = require_xache();
      var safetyCatch = require_safety_catch();
      var b4a = require_b4a();
      var { handshake, holepunch } = require_messages3();
      var { COMMANDS } = require_constants6();
      var { BAD_HANDSHAKE_REPLY, BAD_HOLEPUNCH_REPLY } = require_errors11();
      var FROM_CLIENT = 0;
      var FROM_SERVER = 1;
      var FROM_RELAY = 2;
      var FROM_SECOND_RELAY = 3;
      var REPLY = 4;
      module.exports = class Router {
        constructor(dht, opts) {
          this.dht = dht;
          this.forwards = new Cache(opts.forwards);
        }
        set(target, state) {
          if (state.onpeerhandshake) {
            this.forwards.retain(toString(target), state);
          } else {
            this.forwards.set(toString(target), state);
          }
        }
        get(target) {
          return this.forwards.get(toString(target));
        }
        delete(target) {
          this.forwards.delete(toString(target));
        }
        destroy() {
          this.forwards.destroy();
        }
        async peerHandshake(target, { noise, peerAddress, relayAddress, socket, session }, to) {
          const dht = this.dht;
          const requestValue = c.encode(handshake, {
            mode: FROM_CLIENT,
            noise,
            peerAddress,
            relayAddress
          });
          const res = await dht.request(
            { command: COMMANDS.PEER_HANDSHAKE, target, value: requestValue },
            to,
            { socket, session }
          );
          const hs = decode(handshake, res.value);
          if (!hs || hs.mode !== REPLY || to.host !== res.from.host || to.port !== res.from.port || !hs.noise) {
            throw BAD_HANDSHAKE_REPLY();
          }
          return {
            noise: hs.noise,
            relayed: !!hs.peerAddress,
            serverAddress: hs.peerAddress || to,
            clientAddress: res.to
          };
        }
        async onpeerhandshake(req) {
          const hs = req.value && decode(handshake, req.value);
          if (!hs) return;
          const { mode, noise, peerAddress, relayAddress } = hs;
          const state = req.target && this.get(req.target);
          const isServer = !!(state && state.onpeerhandshake);
          const relay = state && state.relay;
          if (isServer) {
            let reply = null;
            try {
              reply = noise && await state.onpeerhandshake({ noise, peerAddress }, req);
            } catch (e) {
              safetyCatch(e);
              return;
            }
            if (!reply || !reply.noise) return;
            const opts = { socket: reply.socket, closerNodes: false, token: false };
            switch (mode) {
              case FROM_CLIENT: {
                req.reply(
                  c.encode(handshake, { mode: REPLY, noise: reply.noise, peerAddress: null }),
                  opts
                );
                return;
              }
              case FROM_RELAY: {
                req.relay(
                  c.encode(handshake, { mode: FROM_SERVER, noise: reply.noise, peerAddress }),
                  req.from,
                  opts
                );
                return;
              }
              case FROM_SECOND_RELAY: {
                if (!relayAddress) return;
                req.relay(
                  c.encode(handshake, { mode: FROM_SERVER, noise: reply.noise, peerAddress }),
                  relayAddress,
                  opts
                );
                return;
              }
            }
          } else {
            switch (mode) {
              case FROM_CLIENT: {
                if (!noise) return;
                if (!relay && !relayAddress) {
                  req.reply(null, { token: false, closerNodes: true });
                  return;
                }
                req.relay(
                  c.encode(handshake, {
                    mode: FROM_RELAY,
                    noise,
                    peerAddress: req.from,
                    relayAddress: null
                  }),
                  relayAddress || relay
                );
                return;
              }
              case FROM_RELAY: {
                if (!relay || !noise) return;
                req.relay(
                  c.encode(handshake, {
                    mode: FROM_SECOND_RELAY,
                    noise,
                    peerAddress,
                    relayAddress: req.from
                  }),
                  relay
                );
                return;
              }
              case FROM_SERVER: {
                if (!peerAddress || !noise) return;
                req.reply(
                  c.encode(handshake, { mode: REPLY, noise, peerAddress: req.from, relayAddress: null }),
                  { to: peerAddress, closerNodes: false, token: false }
                );
                return;
              }
            }
          }
        }
        async peerHolepunch(target, { id, payload, peerAddress, socket, session }, to) {
          const dht = this.dht;
          const requestValue = c.encode(holepunch, {
            mode: FROM_CLIENT,
            id,
            payload,
            peerAddress
          });
          const res = await dht.request(
            { command: COMMANDS.PEER_HOLEPUNCH, target, value: requestValue },
            to,
            { socket, session }
          );
          const hp = decode(holepunch, res.value);
          if (!hp || hp.mode !== REPLY || to.host !== res.from.host || to.port !== res.from.port) {
            throw BAD_HOLEPUNCH_REPLY();
          }
          return {
            from: res.from,
            to: res.to,
            payload: hp.payload,
            peerAddress: hp.peerAddress || to
          };
        }
        async onpeerholepunch(req) {
          const hp = req.value && decode(holepunch, req.value);
          if (!hp) return;
          const { mode, id, payload, peerAddress } = hp;
          const state = req.target && this.get(req.target);
          const isServer = !!(state && state.onpeerholepunch);
          const relay = state && state.relay;
          switch (mode) {
            case FROM_CLIENT: {
              if (!peerAddress && !relay) return;
              req.relay(
                c.encode(holepunch, { mode: FROM_RELAY, id, payload, peerAddress: req.from }),
                peerAddress || relay
              );
              return;
            }
            case FROM_RELAY: {
              if (!isServer || !peerAddress) return;
              let reply = null;
              try {
                reply = await state.onpeerholepunch({ id, payload, peerAddress }, req);
              } catch (e) {
                safetyCatch(e);
                return;
              }
              if (!reply) return;
              const opts = { socket: reply.socket, closerNodes: false, token: false };
              req.relay(
                c.encode(holepunch, { mode: FROM_SERVER, id: 0, payload: reply.payload, peerAddress }),
                req.from,
                opts
              );
              return;
            }
            case FROM_SERVER: {
              req.reply(c.encode(holepunch, { mode: REPLY, id, payload, peerAddress: req.from }), {
                to: peerAddress,
                closerNodes: false,
                token: false
              });
              return;
            }
          }
        }
      };
      function decode(enc, val) {
        try {
          return c.decode(enc, val);
        } catch {
          return null;
        }
      }
      function toString(t) {
        return typeof t === "string" ? t : b4a.toString(t, "hex");
      }
    }
  });

  // ../../node_modules/compact-encoding-bitfield/index.js
  var require_compact_encoding_bitfield = __commonJS({
    "../../node_modules/compact-encoding-bitfield/index.js"(exports, module) {
      var c = require_compact_encoding();
      module.exports = function bitfield(length) {
        if (length > 64) throw new RangeError("Bitfield cannot be larger than 64 bits");
        let byteLength;
        if (length < 8) byteLength = 1;
        else if (length <= 16) byteLength = 2;
        else if (length <= 32) byteLength = 4;
        else byteLength = 8;
        return {
          preencode(state) {
            state.end++;
            if (byteLength === 1) ;
            else if (byteLength === 2) c.uint16.preencode(state);
            else if (byteLength === 4) c.uint32.preencode(state);
            else c.uint64.preencode(state);
          },
          encode(state, b) {
            if (byteLength === 1) ;
            else if (byteLength === 2) c.uint8.encode(state, 253);
            else if (byteLength === 4) c.uint8.encode(state, 254);
            else c.uint8.encode(state, 255);
            if (typeof b === "number") {
              if (byteLength === 1) c.uint8.encode(state, b);
              else if (byteLength === 2) c.uint16.encode(state, b);
              else if (byteLength === 4) c.uint32.encode(state, b);
              else c.uint64.encode(state, b);
            } else {
              state.buffer.set(b, state.start);
              if (b.byteLength < byteLength) {
                state.buffer.fill(
                  0,
                  state.start + b.byteLength,
                  state.start + byteLength
                );
              }
              state.start += byteLength;
            }
          },
          decode(state) {
            const byte = state.buffer[state.start];
            let byteLength2;
            if (byte <= 252) byteLength2 = 1;
            else if (byte === 253) byteLength2 = 2;
            else if (byte === 254) byteLength2 = 4;
            else byteLength2 = 8;
            if (byteLength2 > 1) state.start++;
            if (state.end - state.start < byteLength2) throw new Error("Out of bounds");
            const b = state.buffer.subarray(state.start, state.start += byteLength2);
            return length <= 8 ? b.subarray(0, 1) : b;
          }
        };
      };
    }
  });

  // ../../node_modules/bits-to-bytes/index.js
  var require_bits_to_bytes = __commonJS({
    "../../node_modules/bits-to-bytes/index.js"(exports, module) {
      var b4a = require_b4a();
      function byteLength(size) {
        return Math.ceil(size / 8);
      }
      function get(buffer, bit) {
        const n = buffer.BYTES_PER_ELEMENT * 8;
        const offset = bit & n - 1;
        const i = (bit - offset) / n;
        return (buffer[i] & 1 << offset) !== 0;
      }
      function set(buffer, bit, value = true) {
        const n = buffer.BYTES_PER_ELEMENT * 8;
        const offset = bit & n - 1;
        const i = (bit - offset) / n;
        const mask = 1 << offset;
        if (value) {
          if ((buffer[i] & mask) !== 0) return false;
        } else {
          if ((buffer[i] & mask) === 0) return false;
        }
        buffer[i] ^= mask;
        return true;
      }
      function setRange(buffer, start, end, value = true) {
        const n = buffer.BYTES_PER_ELEMENT * 8;
        let remaining = end - start;
        let offset = start & n - 1;
        let i = (start - offset) / n;
        let changed = false;
        while (remaining > 0) {
          const mask = 2 ** Math.min(remaining, n - offset) - 1 << offset;
          if (value) {
            if ((buffer[i] & mask) !== mask) {
              buffer[i] |= mask;
              changed = true;
            }
          } else {
            if ((buffer[i] & mask) !== 0) {
              buffer[i] &= ~mask;
              changed = true;
            }
          }
          remaining -= n - offset;
          offset = 0;
          i++;
        }
        return changed;
      }
      function fill(buffer, value, start = 0, end = buffer.byteLength * 8) {
        const n = buffer.BYTES_PER_ELEMENT * 8;
        let i, j;
        {
          const offset = start & n - 1;
          i = (start - offset) / n;
          if (offset !== 0) {
            const mask = 2 ** Math.min(n - offset, end - start) - 1 << offset;
            if (value) buffer[i] |= mask;
            else buffer[i] &= ~mask;
            i++;
          }
        }
        {
          const offset = end & n - 1;
          j = (end - offset) / n;
          if (offset !== 0 && j >= i) {
            const mask = 2 ** offset - 1;
            if (value) buffer[j] |= mask;
            else buffer[j] &= ~mask;
          }
        }
        return buffer.fill(value ? 2 ** n - 1 : 0, i, j);
      }
      function toggle(buffer, bit) {
        const n = buffer.BYTES_PER_ELEMENT * 8;
        const offset = bit & n - 1;
        const i = (bit - offset) / n;
        const mask = 1 << offset;
        buffer[i] ^= mask;
        return (buffer[i] & mask) !== 0;
      }
      function remove(buffer, bit) {
        return set(buffer, bit, false);
      }
      function removeRange(buffer, start, end) {
        return setRange(buffer, start, end, false);
      }
      function indexOf(buffer, value, position = 0) {
        for (let i = position, n = buffer.byteLength * 8; i < n; i++) {
          if (get(buffer, i) === value) return i;
        }
        return -1;
      }
      function lastIndexOf(buffer, value, position = buffer.byteLength * 8 - 1) {
        for (let i = position; i >= 0; i--) {
          if (get(buffer, i) === value) return i;
        }
        return -1;
      }
      function of(...bits) {
        return from(bits);
      }
      function from(bits) {
        const buffer = b4a.alloc(byteLength(bits.length));
        for (let i = 0; i < bits.length; i++) set(buffer, i, bits[i]);
        return buffer;
      }
      function* iterator(buffer) {
        for (let i = 0, n = buffer.byteLength * 8; i < n; i++) yield get(buffer, i);
      }
      module.exports = {
        byteLength,
        get,
        set,
        setRange,
        fill,
        toggle,
        remove,
        removeRange,
        indexOf,
        lastIndexOf,
        of,
        from,
        iterator
      };
    }
  });

  // ../../node_modules/blind-relay/lib/errors.js
  var require_errors12 = __commonJS({
    "../../node_modules/blind-relay/lib/errors.js"(exports, module) {
      module.exports = class BlindRelayError extends Error {
        constructor(msg, code, fn = BlindRelayError) {
          super(`${code}: ${msg}`);
          this.code = code;
          if (Error.captureStackTrace) {
            Error.captureStackTrace(this, fn);
          }
        }
        get name() {
          return "BlindRelayError";
        }
        static DUPLICATE_CHANNEL(msg = "Duplicate channel") {
          return new BlindRelayError(msg, "DUPLICATE_CHANNEL", BlindRelayError.DUPLICATE_CHANNEL);
        }
        static CHANNEL_CLOSED(msg = "Channel closed") {
          return new BlindRelayError(msg, "CHANNEL_CLOSED", BlindRelayError.CHANNEL_CLOSED);
        }
        static CHANNEL_DESTROYED(msg = "Channel destroyed") {
          return new BlindRelayError(msg, "CHANNEL_DESTROYED", BlindRelayError.CHANNEL_DESTROYED);
        }
        static ALREADY_PAIRING(msg = "Already pairing") {
          return new BlindRelayError(msg, "ALREADY_PAIRING", BlindRelayError.ALREADY_PAIRING);
        }
        static PAIRING_CANCELLED(msg = "Pairing cancelled") {
          return new BlindRelayError(msg, "PAIRING_CANCELLED", BlindRelayError.PAIRING_CANCELLED);
        }
      };
    }
  });

  // ../../node_modules/blind-relay/index.js
  var require_blind_relay = __commonJS({
    "../../node_modules/blind-relay/index.js"(exports) {
      var EventEmitter = require_bare_node_events();
      var Protomux = require_protomux();
      var { Readable } = require_streamx();
      var sodium = require_sodium_universal();
      var b4a = require_b4a();
      var c = require_compact_encoding();
      var bitfield = require_compact_encoding_bitfield();
      var bits = require_bits_to_bytes();
      var errors = require_errors12();
      exports.Server = class BlindRelayServer extends EventEmitter {
        constructor(opts = {}) {
          super();
          const {
            createStream
          } = opts;
          this._createStream = createStream;
          this._pairing = /* @__PURE__ */ new Map();
          this._sessions = /* @__PURE__ */ new Set();
        }
        get sessions() {
          return this._sessions[Symbol.iterator]();
        }
        accept(stream, opts) {
          const session = new BlindRelaySession(this, stream, opts);
          this._sessions.add(session);
          return session;
        }
        async close() {
          const ending = [];
          for (const session of this._sessions) {
            ending.push(session.end());
          }
          await Promise.all(ending);
          this._pairing.clear();
        }
      };
      var BlindRelaySession = class extends EventEmitter {
        constructor(server, stream, opts = {}) {
          super();
          const {
            id,
            handshake,
            handshakeEncoding
          } = opts;
          this._server = server;
          this._mux = Protomux.from(stream);
          this._channel = this._mux.createChannel({
            protocol: "blind-relay",
            id,
            handshake: handshake ? handshakeEncoding || c.raw : null,
            onopen: this._onopen.bind(this),
            onclose: this._onclose.bind(this),
            ondestroy: this._ondestroy.bind(this)
          });
          this._pair = this._channel.addMessage({
            encoding: m.pair,
            onmessage: this._onpair.bind(this)
          });
          this._unpair = this._channel.addMessage({
            encoding: m.unpair,
            onmessage: this._onunpair.bind(this)
          });
          this._ending = null;
          this._destroyed = false;
          this._error = null;
          this._pairing = /* @__PURE__ */ new Set();
          this._streams = /* @__PURE__ */ new Map();
          this._onerror = (err) => this.emit("error", err);
          this._channel.open(handshake);
        }
        get closed() {
          return this._channel.closed;
        }
        get mux() {
          return this._mux;
        }
        get stream() {
          return this._mux.stream;
        }
        _onopen() {
          this.emit("open");
        }
        _onclose() {
          this._ending = Promise.resolve();
          const err = this._error || errors.CHANNEL_CLOSED();
          for (const token of this._pairing) {
            this._server._pairing.delete(token.toString("hex"));
          }
          for (const stream of this._streams.values()) {
            stream.off("error", this._onerror).on("error", noop).destroy(err);
          }
          this._pairing.clear();
          this._streams.clear();
          this._server._sessions.delete(this);
          this.emit("close");
        }
        _ondestroy() {
          this._destroyed = true;
          this.emit("destroy");
        }
        _onpair({ isInitiator, token, id: remoteId }) {
          const keyString = token.toString("hex");
          let pair = this._server._pairing.get(keyString);
          if (pair === void 0) {
            pair = new BlindRelayPair(token);
            this._server._pairing.set(keyString, pair);
          } else if (pair.links[+isInitiator]) return;
          this._pairing.add(keyString);
          pair.links[+isInitiator] = new BlindRelayLink(this, isInitiator, remoteId);
          if (!pair.paired) return;
          this._server._pairing.delete(keyString);
          for (const link of pair.links) {
            link.createStream();
          }
          for (const { isInitiator: isInitiator2, session, stream } of pair.links) {
            const remote = pair.remote(isInitiator2);
            stream.on("error", session._onerror).on("close", () => session._streams.delete(keyString)).relayTo(remote.stream);
            session._pairing.delete(keyString);
            session._streams.set(keyString, stream);
          }
          for (const { isInitiator: isInitiator2, session, remoteId: remoteId2, stream } of pair.links) {
            session._pair.send({
              isInitiator: isInitiator2,
              token,
              id: stream.id,
              seq: 0
            });
            session._endMaybe();
            session.emit("pair", isInitiator2, token, stream, remoteId2);
          }
        }
        _onunpair({ token }) {
          const keyString = token.toString("hex");
          const pair = this._server._pairing.get(keyString);
          if (pair) {
            for (const link of pair.links) {
              if (link) link.session._pairing.delete(keyString);
            }
            return this._server._pairing.delete(keyString);
          }
          const stream = this._streams.get(keyString);
          if (stream) {
            stream.off("error", this._onerror).on("error", noop).destroy(errors.PAIRING_CANCELLED());
            this._streams.delete(keyString);
          }
        }
        cork() {
          this._channel.cork();
        }
        uncork() {
          this._channel.uncork();
        }
        async end() {
          if (this._ending) return this._ending;
          this._ending = EventEmitter.once(this, "close");
          this._endMaybe();
          return this._ending;
        }
        _endMaybe() {
          if (this._ending && this._pairing.size === 0) {
            this._channel.close();
          }
        }
        destroy(err) {
          if (this._destroyed) return;
          this._destroyed = true;
          this._error = err || errors.CHANNEL_DESTROYED();
          this._channel.close();
        }
      };
      var BlindRelayPair = class {
        constructor(token) {
          this.token = token;
          this.links = [null, null];
        }
        get paired() {
          return this.links[0] !== null && this.links[1] !== null;
        }
        remote(isInitiator) {
          return this.links[isInitiator ? 0 : 1];
        }
      };
      var BlindRelayLink = class {
        constructor(session, isInitiator, remoteId) {
          this.session = session;
          this.isInitiator = isInitiator;
          this.remoteId = remoteId;
          this.stream = null;
        }
        createStream() {
          if (this.stream) return;
          this.stream = this.session._server._createStream({
            firewall: this._onfirewall.bind(this)
          });
        }
        _onfirewall(socket, port, host) {
          this.stream.connect(socket, this.remoteId, port, host);
          return false;
        }
      };
      exports.Client = class BlindRelayClient extends EventEmitter {
        static _clients = /* @__PURE__ */ new WeakMap();
        static from(stream, opts) {
          let client = this._clients.get(stream);
          if (client) return client;
          client = new this(stream, opts);
          this._clients.set(stream, client);
          return client;
        }
        constructor(stream, opts = {}) {
          super();
          const {
            id,
            handshake,
            handshakeEncoding
          } = opts;
          this._mux = Protomux.from(stream);
          this._channel = this._mux.createChannel({
            protocol: "blind-relay",
            id,
            handshake: handshake ? handshakeEncoding || c.raw : null,
            onopen: this._onopen.bind(this),
            onclose: this._onclose.bind(this),
            ondestroy: this._ondestroy.bind(this)
          });
          this._pair = this._channel.addMessage({
            encoding: m.pair,
            onmessage: this._onpair.bind(this)
          });
          this._unpair = this._channel.addMessage({
            encoding: m.unpair
          });
          this._ending = false;
          this._destroyed = false;
          this._error = null;
          this._requests = /* @__PURE__ */ new Map();
          this._channel.open(handshake);
        }
        get closed() {
          return this._channel.closed;
        }
        get mux() {
          return this._mux;
        }
        get stream() {
          return this._mux.stream;
        }
        get requests() {
          return this._requests.values();
        }
        _onopen() {
          this.emit("open");
        }
        _onclose() {
          this._ending = Promise.resolve();
          const err = this._error || errors.CHANNEL_CLOSED();
          for (const request of this._requests.values()) {
            request.destroy(err);
          }
          this._requests.clear();
          this.constructor._clients.delete(this.stream);
          this.emit("close");
        }
        _ondestroy() {
          this._destroyed = true;
          this.emit("destroy");
        }
        _onpair({ isInitiator, token, id: remoteId }) {
          const request = this._requests.get(token.toString("hex"));
          if (request === void 0 || request.isInitiator !== isInitiator) return;
          request.push(remoteId);
          request.push(null);
          this.emit("pair", request.isInitiator, request.token, request.stream, remoteId);
        }
        pair(isInitiator, token, stream) {
          if (this._destroyed) throw errors.CHANNEL_DESTROYED();
          const keyString = token.toString("hex");
          if (this._requests.has(keyString)) throw errors.ALREADY_PAIRING();
          const request = new BlindRelayRequest(this, isInitiator, token, stream);
          this._requests.set(keyString, request);
          return request;
        }
        unpair(token) {
          if (this._destroyed) throw errors.CHANNEL_DESTROYED();
          const request = this._requests.get(token.toString("hex"));
          if (request) request.destroy(errors.PAIRING_CANCELLED());
          this._unpair.send({ token });
        }
        cork() {
          this._channel.cork();
        }
        uncork() {
          this._channel.uncork();
        }
        async end() {
          if (this._ending) return this._ending;
          this._ending = EventEmitter.once(this, "close");
          this._endMaybe();
          return this._ending;
        }
        _endMaybe() {
          if (this._ending && this._requests.size === 0) {
            this._channel.close();
          }
        }
        destroy(err) {
          if (this._destroyed) return;
          this._destroyed = true;
          this._error = err || errors.CHANNEL_DESTROYED();
          this._channel.close();
        }
      };
      var BlindRelayRequest = class extends Readable {
        constructor(client, isInitiator, token, stream) {
          super();
          this.client = client;
          this.isInitiator = isInitiator;
          this.token = token;
          this.stream = stream;
        }
        _open(cb) {
          if (this.client._destroyed) return cb(errors.CHANNEL_DESTROYED());
          this.client._pair.send({
            isInitiator: this.isInitiator,
            token: this.token,
            id: this.stream.id,
            seq: 0
          });
          cb(null);
        }
        _destroy(cb) {
          this.client._requests.delete(this.token.toString("hex"));
          cb(null);
          this.client._endMaybe();
        }
      };
      exports.token = function token(buf = b4a.allocUnsafe(32)) {
        sodium.randombytes_buf(buf);
        return buf;
      };
      function noop() {
      }
      var m = exports.messages = {};
      var flags = bitfield(7);
      m.pair = {
        preencode(state, m2) {
          flags.preencode(state);
          c.fixed32.preencode(state, m2.token);
          c.uint.preencode(state, m2.id);
          c.uint.preencode(state, m2.seq);
        },
        encode(state, m2) {
          flags.encode(state, bits.of(m2.isInitiator));
          c.fixed32.encode(state, m2.token);
          c.uint.encode(state, m2.id);
          c.uint.encode(state, m2.seq);
        },
        decode(state) {
          const [isInitiator] = bits.iterator(flags.decode(state));
          return {
            isInitiator,
            token: c.fixed32.decode(state),
            id: c.uint.decode(state),
            seq: c.uint.decode(state)
          };
        }
      };
      m.unpair = {
        preencode(state, m2) {
          flags.preencode(state);
          c.fixed32.preencode(state, m2.token);
        },
        encode(state, m2) {
          flags.encode(state, bits.of());
          c.fixed32.encode(state, m2.token);
        },
        decode(state) {
          flags.decode(state);
          return {
            token: c.fixed32.decode(state)
          };
        }
      };
    }
  });

  // ../../node_modules/hyperdht/lib/noise-wrap.js
  var require_noise_wrap = __commonJS({
    "../../node_modules/hyperdht/lib/noise-wrap.js"(exports, module) {
      var NoiseSecretStream = require_secret_stream();
      var NoiseHandshake = require_noise();
      var curve = require_noise_curve_ed();
      var c = require_compact_encoding();
      var b4a = require_b4a();
      var sodium = require_sodium_universal();
      var m = require_messages3();
      var { NS } = require_constants6();
      var { HANDSHAKE_UNFINISHED } = require_errors11();
      var NOISE_PROLOUGE = NS.PEER_HANDSHAKE;
      module.exports = class NoiseWrap {
        constructor(keyPair, remotePublicKey) {
          this.isInitiator = !!remotePublicKey;
          this.remotePublicKey = remotePublicKey;
          this.keyPair = keyPair;
          this.handshake = new NoiseHandshake("IK", this.isInitiator, keyPair, { curve });
          this.handshake.initialise(NOISE_PROLOUGE, remotePublicKey);
        }
        send(payload) {
          const buf = c.encode(m.noisePayload, payload);
          return this.handshake.send(buf);
        }
        recv(buf) {
          const payload = c.decode(m.noisePayload, this.handshake.recv(buf));
          this.remotePublicKey = b4a.toBuffer(this.handshake.rs);
          return payload;
        }
        final() {
          if (!this.handshake.complete) throw HANDSHAKE_UNFINISHED();
          const holepunchSecret = b4a.allocUnsafe(32);
          sodium.crypto_generichash(holepunchSecret, NS.PEER_HOLEPUNCH, this.handshake.hash);
          return {
            isInitiator: this.isInitiator,
            publicKey: this.keyPair.publicKey,
            streamId: this.streamId,
            remotePublicKey: this.remotePublicKey,
            remoteId: NoiseSecretStream.id(this.handshake.hash, !this.isInitiator),
            holepunchSecret,
            hash: b4a.toBuffer(this.handshake.hash),
            rx: b4a.toBuffer(this.handshake.rx),
            tx: b4a.toBuffer(this.handshake.tx)
          };
        }
      };
    }
  });

  // ../../node_modules/signal-promise/index.js
  var require_signal_promise = __commonJS({
    "../../node_modules/signal-promise/index.js"(exports, module) {
      module.exports = class Signal {
        constructor() {
          this._resolve = null;
          this._reject = null;
          this._promise = null;
          this._bind = bind.bind(this);
          this._onerror = clear.bind(this);
          this._onsuccess = clear.bind(this, null);
          this._timers = /* @__PURE__ */ new Set();
        }
        wait(max) {
          if (!this._promise) {
            this._promise = new Promise(this._bind);
            this._promise.then(this._onsuccess).catch(this._onerror);
          }
          if (max) return this._sleep(max);
          return this._promise;
        }
        _sleep(max) {
          const s = new Promise((resolve, reject) => {
            const done = () => {
              this._timers.delete(state);
              resolve(true);
            };
            const id = setTimeout(done, max);
            const state = { id, resolve, reject };
            this._timers.add(state);
          });
          return s;
        }
        notify(err) {
          if (!this._promise) return;
          const resolve = this._resolve;
          const reject = this._reject;
          this._promise = null;
          if (err) reject(err);
          else resolve(true);
        }
      };
      function clear(err) {
        for (const { id, resolve, reject } of this._timers) {
          clearTimeout(id);
          if (err) reject(err);
          else resolve(true);
        }
        this._timers.clear();
      }
      function bind(resolve, reject) {
        this._resolve = resolve;
        this._reject = reject;
      }
    }
  });

  // ../../node_modules/hyperdht/lib/sleeper.js
  var require_sleeper = __commonJS({
    "../../node_modules/hyperdht/lib/sleeper.js"(exports, module) {
      module.exports = class Sleeper {
        constructor() {
          this._timeout = null;
          this._resolve = null;
          this._start = (resolve) => {
            this._resolve = resolve;
          };
          this._trigger = () => {
            if (this._resolve === null) return;
            const resolve = this._resolve;
            this._timeout = null;
            this._resolve = null;
            resolve();
          };
        }
        pause(ms) {
          const p = new Promise(this._start);
          if (this._timeout !== null) {
            clearTimeout(this._timeout);
            this._trigger();
          }
          this._timeout = setTimeout(this._trigger, ms);
          return p;
        }
        resume() {
          if (this._timeout !== null) {
            clearTimeout(this._timeout);
            this._trigger();
          }
        }
      };
    }
  });

  // ../../node_modules/hyperdht/lib/announcer.js
  var require_announcer = __commonJS({
    "../../node_modules/hyperdht/lib/announcer.js"(exports, module) {
      var safetyCatch = require_safety_catch();
      var c = require_compact_encoding();
      var Signal = require_signal_promise();
      var { encodeUnslab } = require_encode2();
      var Sleeper = require_sleeper();
      var m = require_messages3();
      var Persistent = require_persistent();
      var { COMMANDS } = require_constants6();
      var MIN_ACTIVE = 3;
      module.exports = class Announcer {
        constructor(dht, keyPair, target, opts = {}) {
          this.dht = dht;
          this.keyPair = keyPair;
          this.target = target;
          this.relays = [];
          this.relayAddresses = [];
          this.stopped = false;
          this.suspended = false;
          this.record = encodeUnslab(m.peer, { publicKey: keyPair.publicKey, relayAddresses: [] });
          this.online = new Signal();
          this._refreshing = false;
          this._closestNodes = null;
          this._active = null;
          this._sleeper = new Sleeper();
          this._resumed = new Signal();
          this._signAnnounce = opts.signAnnounce || Persistent.signAnnounce;
          this._signUnannounce = opts.signUnannounce || Persistent.signUnannounce;
          this._updating = null;
          this._activeQuery = null;
          this._unannouncing = null;
          this._serverRelays = [/* @__PURE__ */ new Map(), /* @__PURE__ */ new Map(), /* @__PURE__ */ new Map()];
        }
        isRelay(addr) {
          const id = addr.host + ":" + addr.port;
          const [a, b, c2] = this._serverRelays;
          return a.has(id) || b.has(id) || c2.has(id);
        }
        async suspend({ log = noop } = {}) {
          if (this.suspended) return;
          this.suspended = true;
          log("Suspending announcer");
          this.online.notify();
          if (this._activeQuery) this._activeQuery.destroy();
          this._sleeper.resume();
          if (this._updating) await this._updating;
          log("Suspending announcer (post update)");
          if (this.suspended === false || this.stopped) return;
          log("Suspending announcer (pre unannounce)");
          await this._unannounceCurrent();
          log("Suspending announcer (post unannounce)");
        }
        resume() {
          if (!this.suspended) return;
          this.suspended = false;
          this.refresh();
          this._sleeper.resume();
          this._resumed.notify();
        }
        refresh() {
          if (this.stopped) return;
          this._refreshing = true;
        }
        async start() {
          if (this.stopped) return;
          this._active = this._runUpdate();
          await this._active;
          if (this.stopped) return;
          this._active = this._background();
        }
        async stop() {
          this.stopped = true;
          this.online.notify();
          this._sleeper.resume();
          this._resumed.notify();
          await this._active;
          await this._unannounceCurrent();
        }
        async _unannounceCurrent() {
          while (this._unannouncing !== null) await this._unannouncing;
          const un = this._unannouncing = this._unannounceAll(this._serverRelays[2].values());
          await this._unannouncing;
          if (un === this._unannouncing) this._unannouncing = null;
        }
        async _background() {
          while (!this.dht.destroyed && !this.stopped) {
            try {
              this._refreshing = false;
              for (let i = 0; i < 100 && !this.stopped && !this._refreshing && !this.suspended; i++) {
                const pings = [];
                for (const node of this._serverRelays[2].values()) {
                  pings.push(this.dht.ping(node));
                }
                const active = await resolved(pings);
                if (active < Math.min(pings.length, MIN_ACTIVE)) {
                  this.refresh();
                }
                if (this.stopped) return;
                if (!this.suspended && !this._refreshing) await this._sleeper.pause(3e3);
              }
              while (!this.stopped && this.suspended) await this._resumed.wait();
              if (!this.stopped) await this._runUpdate();
              while (!this.dht.online && !this.stopped && !this.suspended) {
                await this.online.wait();
              }
            } catch (err) {
              safetyCatch(err);
            }
          }
        }
        async _runUpdate() {
          this._updating = this._update();
          await this._updating;
          this._updating = null;
        }
        async _update() {
          while (this._unannouncing) await this._unannouncing;
          this._cycle();
          const q = this._activeQuery = this.dht.findPeer(this.target, {
            hash: false,
            nodes: this._closestNodes
          });
          try {
            await q.finished();
          } catch {
          }
          this._activeQuery = null;
          if (this.stopped || this.suspended) return;
          const ann = [];
          const replies = pickBest(q.closestReplies);
          const relays = [];
          const relayAddresses = [];
          if (!this.dht.firewalled) {
            const addr = this.dht.remoteAddress();
            if (addr) relayAddresses.push(addr);
          }
          for (const msg of replies) {
            ann.push(this._commit(msg, relays, relayAddresses));
          }
          await Promise.allSettled(ann);
          if (this.stopped || this.suspended) return;
          this._closestNodes = q.closestNodes;
          this.relays = relays;
          this.relayAddresses = relayAddresses;
          const removed = [];
          for (const [key, value] of this._serverRelays[1]) {
            if (!this._serverRelays[2].has(key)) removed.push(value);
          }
          await this._unannounceAll(removed);
        }
        _unannounceAll(relays) {
          const unann = [];
          for (const r of relays) unann.push(this._unannounce(r));
          return Promise.allSettled(unann);
        }
        async _unannounce(to) {
          const unann = {
            peer: {
              publicKey: this.keyPair.publicKey,
              relayAddresses: []
            },
            refresh: null,
            signature: null
          };
          const { from, token, value } = await this.dht.request(
            {
              token: null,
              command: COMMANDS.FIND_PEER,
              target: this.target,
              value: null
            },
            to
          );
          if (!token || !from.id || !value) return;
          unann.signature = await this._signUnannounce(this.target, token, from.id, unann, this.keyPair);
          await this.dht.request(
            {
              token,
              command: COMMANDS.UNANNOUNCE,
              target: this.target,
              value: c.encode(m.announce, unann)
            },
            to
          );
        }
        async _commit(msg, relays, relayAddresses) {
          const ann = {
            peer: {
              publicKey: this.keyPair.publicKey,
              relayAddresses: []
            },
            refresh: null,
            signature: null
          };
          ann.signature = await this._signAnnounce(this.target, msg.token, msg.from.id, ann, this.keyPair);
          const res = await this.dht.request(
            {
              token: msg.token,
              command: COMMANDS.ANNOUNCE,
              target: this.target,
              value: c.encode(m.announce, ann)
            },
            msg.from
          );
          if (res.error !== 0) return;
          if (relayAddresses.length < 3) relayAddresses.push({ host: msg.from.host, port: msg.from.port });
          relays.push({ relayAddress: msg.from, peerAddress: msg.to });
          this._serverRelays[2].set(msg.from.host + ":" + msg.from.port, msg.from);
        }
        _cycle() {
          const tmp = this._serverRelays[0];
          this._serverRelays[0] = this._serverRelays[1];
          this._serverRelays[1] = this._serverRelays[2];
          this._serverRelays[2] = tmp;
          tmp.clear();
        }
      };
      function resolved(ps) {
        let replied = 0;
        let ticks = ps.length + 1;
        return new Promise((resolve) => {
          for (const p of ps) p.then(push, tick);
          tick();
          function push(v) {
            replied++;
            tick();
          }
          function tick() {
            if (--ticks === 0) resolve(replied);
          }
        });
      }
      function pickBest(replies) {
        return replies.slice(0, 3);
      }
      function noop() {
      }
    }
  });

  // ../../node_modules/hyperdht/lib/crypto.js
  var require_crypto = __commonJS({
    "../../node_modules/hyperdht/lib/crypto.js"(exports, module) {
      var sodium = require_sodium_universal();
      var b4a = require_b4a();
      function hash(data) {
        const out = b4a.allocUnsafe(32);
        sodium.crypto_generichash(out, data);
        return out;
      }
      function unslabbedHash(data) {
        const out = b4a.allocUnsafeSlow(32);
        sodium.crypto_generichash(out, data);
        return out;
      }
      function createKeyPair(seed) {
        const publicKey = b4a.alloc(32);
        const secretKey = b4a.alloc(64);
        if (seed) sodium.crypto_sign_seed_keypair(publicKey, secretKey, seed);
        else sodium.crypto_sign_keypair(publicKey, secretKey);
        return { publicKey, secretKey };
      }
      module.exports = {
        hash,
        unslabbedHash,
        createKeyPair
      };
    }
  });

  // ../../node_modules/hyperdht/lib/secure-payload.js
  var require_secure_payload = __commonJS({
    "../../node_modules/hyperdht/lib/secure-payload.js"(exports, module) {
      var sodium = require_sodium_universal();
      var b4a = require_b4a();
      var { holepunchPayload } = require_messages3();
      module.exports = class HolepunchPayload {
        constructor(holepunchSecret) {
          this._sharedSecret = holepunchSecret;
          this._localSecret = b4a.allocUnsafe(32);
          sodium.randombytes_buf(this._localSecret);
        }
        decrypt(buffer) {
          const state = { start: 24, end: buffer.byteLength - 16, buffer };
          if (state.end <= state.start) return null;
          const nonce = buffer.subarray(0, 24);
          const msg = state.buffer.subarray(state.start, state.end);
          const cipher = state.buffer.subarray(state.start);
          if (!sodium.crypto_secretbox_open_easy(msg, cipher, nonce, this._sharedSecret)) return null;
          try {
            return holepunchPayload.decode(state);
          } catch {
            return null;
          }
        }
        encrypt(payload) {
          const state = { start: 24, end: 24, buffer: null };
          holepunchPayload.preencode(state, payload);
          state.buffer = b4a.allocUnsafe(state.end + 16);
          const nonce = state.buffer.subarray(0, 24);
          const msg = state.buffer.subarray(state.start, state.end);
          const cipher = state.buffer.subarray(state.start);
          holepunchPayload.encode(state, payload);
          sodium.randombytes_buf(nonce);
          sodium.crypto_secretbox_easy(cipher, msg, nonce, this._sharedSecret);
          return state.buffer;
        }
        token(addr) {
          const out = b4a.allocUnsafe(32);
          sodium.crypto_generichash(out, b4a.from(addr.host), this._localSecret);
          return out;
        }
      };
    }
  });

  // ../../node_modules/hyperdht/lib/nat.js
  var require_nat = __commonJS({
    "../../node_modules/hyperdht/lib/nat.js"(exports, module) {
      var { FIREWALL } = require_constants6();
      module.exports = class Nat {
        constructor(dht, session, socket) {
          this._samplesHost = [];
          this._samplesFull = [];
          this._visited = /* @__PURE__ */ new Map();
          this._resolve = null;
          this._minSamples = 4;
          this._autoSampling = false;
          this.dht = dht;
          this.session = session;
          this.socket = socket;
          this.sampled = 0;
          this.firewall = dht.firewalled ? FIREWALL.UNKNOWN : FIREWALL.OPEN;
          this.addresses = null;
          this.analyzing = new Promise((resolve) => {
            this._resolve = resolve;
          });
        }
        autoSample(retry = true) {
          if (this._autoSampling) return;
          this._autoSampling = true;
          const self2 = this;
          const socket = this.socket;
          const maxPings = this._minSamples;
          let skip = this.dht.nodes.length >= 8 ? 5 : 0;
          let pending = 0;
          for (let node = this.dht.nodes.latest; node && this.sampled + pending < maxPings; node = node.prev) {
            if (skip > 0) {
              skip--;
              continue;
            }
            const ref = node.host + ":" + node.port;
            if (this._visited.has(ref)) continue;
            this._visited.set(ref, 1);
            pending++;
            this.session.ping(node, { socket, retry: false }).then(onpong, onskip);
          }
          pending++;
          onskip();
          function onpong(res) {
            self2.add(res.to, res.from);
            onskip();
          }
          function onskip() {
            if (--pending === 0 && self2.sampled < self2._minSamples) {
              if (retry) {
                self2._autoSampling = false;
                self2.autoSample(false);
                return;
              }
              self2._resolve();
            }
          }
        }
        destroy() {
          this._autoSampling = true;
          this._minSamples = 0;
          this._resolve();
        }
        unfreeze() {
          this.frozen = false;
          this._updateFirewall();
          this._updateAddresses();
        }
        freeze() {
          this.frozen = true;
        }
        _updateFirewall() {
          if (!this.dht.firewalled) {
            this.firewall = FIREWALL.OPEN;
            return;
          }
          if (this.sampled < 3) return;
          const max = this._samplesFull[0].hits;
          if (max >= 3) {
            this.firewall = FIREWALL.CONSISTENT;
            return;
          }
          if (max === 1) {
            this.firewall = FIREWALL.RANDOM;
            return;
          }
          if (this._samplesHost.length === 1 && this.sampled > 3) {
            this.firewall = FIREWALL.RANDOM;
            return;
          }
          if (this._samplesHost.length > 1 && this._samplesFull[1].hits > 1) {
            this.firewall = FIREWALL.CONSISTENT;
            return;
          }
          if (this.sampled > 4) {
            this.firewall = FIREWALL.RANDOM;
          }
        }
        _updateAddresses() {
          if (this.firewall === FIREWALL.UNKNOWN) {
            this.addresses = null;
            return;
          }
          if (this.firewall === FIREWALL.RANDOM) {
            this.addresses = [this._samplesHost[0]];
            return;
          }
          if (this.firewall === FIREWALL.CONSISTENT) {
            this.addresses = [];
            for (const addr of this._samplesFull) {
              if (addr.hits >= 2 || this.addresses.length < 2) this.addresses.push(addr);
            }
          }
        }
        update() {
          if (this.dht.firewalled && this.firewall === FIREWALL.OPEN) {
            this.firewall = FIREWALL.UNKNOWN;
          }
          this._updateFirewall();
          this._updateAddresses();
        }
        add(addr, from) {
          const ref = from.host + ":" + from.port;
          if (this._visited.get(ref) === 2) return;
          this._visited.set(ref, 2);
          addSample(this._samplesHost, addr.host, 0);
          addSample(this._samplesFull, addr.host, addr.port);
          if ((++this.sampled >= 3 || !this.dht.firewalled) && !this.frozen) {
            this.update();
          }
          if (this.firewall === FIREWALL.CONSISTENT || this.firewall === FIREWALL.OPEN) {
            this._resolve();
          } else if (this.sampled >= this._minSamples) {
            this._resolve();
          }
        }
      };
      function addSample(samples, host, port) {
        for (let i = 0; i < samples.length; i++) {
          const s = samples[i];
          if (s.port !== port || s.host !== host) continue;
          s.hits++;
          for (; i > 0; i--) {
            const prev = samples[i - 1];
            if (prev.hits >= s.hits) return;
            samples[i - 1] = s;
            samples[i] = prev;
          }
          return;
        }
        samples.push({
          host,
          port,
          hits: 1
        });
      }
    }
  });

  // ../../node_modules/hyperdht/lib/holepuncher.js
  var require_holepuncher = __commonJS({
    "../../node_modules/hyperdht/lib/holepuncher.js"(exports, module) {
      var b4a = require_b4a();
      var Nat = require_nat();
      var Sleeper = require_sleeper();
      var { FIREWALL } = require_constants6();
      var BIRTHDAY_SOCKETS = 256;
      var HOLEPUNCH = b4a.from([0]);
      var HOLEPUNCH_TTL = 5;
      var DEFAULT_TTL = 64;
      var MAX_REOPENS = 3;
      module.exports = class Holepuncher {
        constructor(dht, session, isInitiator, remoteFirewall = FIREWALL.UNKNOWN) {
          const holder = dht._socketPool.acquire();
          this.dht = dht;
          this.session = session;
          this.nat = new Nat(dht, session, holder.socket);
          this.nat.autoSample();
          this.isInitiator = isInitiator;
          this.onconnect = noop;
          this.onabort = noop;
          this.punching = false;
          this.connected = false;
          this.destroyed = false;
          this.randomized = false;
          this.remoteFirewall = remoteFirewall;
          this.remoteAddresses = [];
          this.remoteHolepunching = false;
          this._sleeper = new Sleeper();
          this._reopening = null;
          this._timeout = null;
          this._punching = null;
          this._allHolders = [];
          this._holder = this._addRef(holder);
        }
        get socket() {
          return this._holder.socket;
        }
        updateRemote({ punching, firewall, addresses, verified }) {
          const remoteAddresses = [];
          if (addresses) {
            for (const addr of addresses) {
              remoteAddresses.push({
                host: addr.host,
                port: addr.port,
                verified: verified === addr.host || this._isVerified(addr.host)
              });
            }
          }
          this.remoteFirewall = firewall;
          this.remoteAddresses = remoteAddresses;
          this.remoteHolepunching = punching;
        }
        _isVerified(host) {
          for (const addr of this.remoteAddresses) {
            if (addr.verified && addr.host === host) {
              return true;
            }
          }
          return false;
        }
        ping(addr, socket = this._holder.socket) {
          return holepunch(socket, addr, false);
        }
        openSession(addr, socket = this._holder.socket) {
          return holepunch(socket, addr, true);
        }
        async analyze(allowReopen) {
          await this.nat.analyzing;
          if (this._unstable()) {
            if (!allowReopen) return false;
            if (!this._reopening) this._reopening = this._reopen();
            return this._reopening;
          }
          return true;
        }
        _unstable() {
          const firewall = this.nat.firewall;
          return this.remoteFirewall >= FIREWALL.RANDOM && firewall >= FIREWALL.RANDOM || firewall === FIREWALL.UNKNOWN;
        }
        _reset() {
          const prev = this._holder;
          this._allHolders.pop();
          this._holder = this._addRef(this.dht._socketPool.acquire());
          prev.release();
          this.nat.destroy();
          this.nat = new Nat(this.dht, this.session, this._holder.socket);
          this.nat.autoSample();
        }
        _addRef(ref) {
          this._allHolders.push(ref);
          ref.onholepunchmessage = (msg, rinfo) => this._onholepunchmessage(msg, rinfo, ref);
          return ref;
        }
        _onholepunchmessage(_, addr, ref) {
          if (!this.isInitiator) {
            holepunch(ref.socket, addr, false);
            return;
          }
          if (this.connected) return;
          this.connected = true;
          this.punching = false;
          for (const r of this._allHolders) {
            if (r === ref) continue;
            r.release();
          }
          this._allHolders[0] = ref;
          while (this._allHolders.length > 1) this._allHolders.pop();
          this._decrementRandomized();
          this.onconnect(ref.socket, addr.port, addr.host);
        }
        _done() {
          return this.destroyed || this.connected;
        }
        async _reopen() {
          for (let i = 0; this._unstable() && i < MAX_REOPENS && !this._done() && !this.punching; i++) {
            this._reset();
            await this.nat.analyzing;
          }
          return coerceFirewall(this.nat.firewall) === FIREWALL.CONSISTENT;
        }
        punch() {
          if (!this._punching) this._punching = this._punch();
          return this._punching;
        }
        async _punch() {
          if (this._done() || !this.remoteAddresses.length) return false;
          this.punching = true;
          const local = coerceFirewall(this.nat.firewall);
          const remote = coerceFirewall(this.remoteFirewall);
          let remoteVerifiedAddress = null;
          for (const addr of this.remoteAddresses) {
            if (addr.verified) {
              remoteVerifiedAddress = addr;
              break;
            }
          }
          if (local === FIREWALL.CONSISTENT && remote === FIREWALL.CONSISTENT) {
            this.dht.stats.punches.consistent++;
            this._consistentProbe();
            return true;
          }
          if (!remoteVerifiedAddress) return false;
          if (local === FIREWALL.CONSISTENT && remote >= FIREWALL.RANDOM) {
            this.dht.stats.punches.random++;
            this._incrementRandomized();
            this._randomProbes(remoteVerifiedAddress);
            return true;
          }
          if (local >= FIREWALL.RANDOM && remote === FIREWALL.CONSISTENT) {
            this.dht.stats.punches.random++;
            this._incrementRandomized();
            await this._openBirthdaySockets(remoteVerifiedAddress);
            if (this.punching) this._keepAliveRandomNat(remoteVerifiedAddress);
            return true;
          }
          return false;
        }
        // Note that this never throws so it is safe to run in the background
        async _consistentProbe() {
          if (!this.isInitiator) await this._sleeper.pause(1e3);
          let tries = 0;
          while (this.punching && tries++ < 10) {
            for (const addr of this.remoteAddresses) {
              if (!addr.verified && (tries & 3) !== 0) continue;
              await holepunch(this._holder.socket, addr, false);
            }
            if (this.punching) await this._sleeper.pause(1e3);
          }
          this._autoDestroy();
        }
        // Note that this never throws so it is safe to run in the background
        async _randomProbes(remoteAddr) {
          let tries = 1750;
          while (this.punching && tries-- > 0) {
            const addr = { host: remoteAddr.host, port: randomPort() };
            await holepunch(this._holder.socket, addr, false);
            if (this.punching) await this._sleeper.pause(20);
          }
          this._autoDestroy();
        }
        // Note that this never throws so it is safe to run in the background
        async _keepAliveRandomNat(remoteAddr) {
          let i = 0;
          let lowTTLRounds = 1;
          await this._sleeper.pause(100);
          let tries = 1750;
          while (this.punching && tries-- > 0) {
            if (i === this._allHolders.length) {
              i = 0;
              if (lowTTLRounds > 0) lowTTLRounds--;
            }
            await holepunch(this._allHolders[i++].socket, remoteAddr, lowTTLRounds > 0);
            if (this.punching) await this._sleeper.pause(20);
          }
          this._autoDestroy();
        }
        async _openBirthdaySockets(remoteAddr) {
          while (this.punching && this._allHolders.length < BIRTHDAY_SOCKETS) {
            const ref = this._addRef(this.dht._socketPool.acquire());
            await holepunch(ref.socket, remoteAddr, HOLEPUNCH_TTL);
          }
        }
        _autoDestroy() {
          if (!this.connected) this.destroy();
        }
        _incrementRandomized() {
          if (!this.randomized) {
            this.randomized = true;
            this.dht._randomPunches++;
          }
        }
        _decrementRandomized() {
          if (this.randomized) {
            this.dht._lastRandomPunch = Date.now();
            this.randomized = false;
            this.dht._randomPunches--;
          }
        }
        destroy() {
          if (this.destroyed) return;
          this.destroyed = true;
          this.punching = false;
          for (const ref of this._allHolders) ref.release();
          this._allHolders = [];
          this.nat.destroy();
          if (!this.connected) {
            this._decrementRandomized();
            this.onabort();
          }
        }
        static ping(socket, addr) {
          return holepunch(socket, addr, false);
        }
        static localAddresses(socket) {
          return localAddresses(socket);
        }
        static matchAddress(myAddresses, externalAddresses) {
          return matchAddress(myAddresses, externalAddresses);
        }
      };
      function holepunch(socket, addr, lowTTL) {
        return socket.send(HOLEPUNCH, addr.port, addr.host, lowTTL ? HOLEPUNCH_TTL : DEFAULT_TTL);
      }
      function randomPort() {
        return 1e3 + Math.random() * 64536 | 0;
      }
      function coerceFirewall(fw) {
        return fw === FIREWALL.OPEN ? FIREWALL.CONSISTENT : fw;
      }
      function localAddresses(socket) {
        const addrs = [];
        const { host, port } = socket.address();
        if (host === "127.0.0.1") return [{ host, port }];
        for (const n of socket.udx.networkInterfaces()) {
          if (n.family !== 4 || n.internal) continue;
          addrs.push({ host: n.host, port });
        }
        if (addrs.length === 0) {
          addrs.push({ host: "127.0.0.1", port });
        }
        return addrs;
      }
      function matchAddress(localAddresses2, remoteLocalAddresses) {
        if (remoteLocalAddresses.length === 0) return null;
        let best = { segment: 1, addr: null };
        for (const localAddress of localAddresses2) {
          const a = localAddress.host.split(".");
          for (const remoteAddress of remoteLocalAddresses) {
            const b = remoteAddress.host.split(".");
            if (a[0] === b[0]) {
              if (best.segment === 1) best = { segment: 2, addr: remoteAddress };
              if (a[1] === b[1]) {
                if (best.segment === 2) best = { segment: 3, addr: remoteAddress };
                if (a[2] === b[2]) return remoteAddress;
              }
            }
          }
        }
        return best.addr;
      }
      function noop() {
      }
    }
  });

  // ../../node_modules/bogon/index.js
  var require_bogon = __commonJS({
    "../../node_modules/bogon/index.js"(exports, module) {
      var b4a = require_b4a();
      var c = require_compact_encoding();
      var net = require_compact_encoding_net();
      module.exports = exports = function isBogon(ip) {
        return isBogonIP(ensureBuffer(ip));
      };
      exports.isBogon = exports;
      exports.isPrivate = function isPrivate(ip) {
        return isPrivateIP(ensureBuffer(ip));
      };
      exports.isReserved = function isReserved(ip) {
        return isReservedIP(ensureBuffer(ip));
      };
      function isBogonIP(ip) {
        return isPrivateIP(ip) || isReservedIP(ip);
      }
      function isPrivateIP(ip) {
        return ip.byteLength === 4 ? isPrivateIPv4(ip) : false;
      }
      function isPrivateIPv4(ip) {
        return (
          // 10.0.0.0/8  Private-use networks
          ip[0] === 10 || // 100.64.0.0/10 Carrier-grade NAT
          ip[0] === 100 && ip[1] >= 64 && ip[1] <= 127 || // 127.0.0.0/8 Loopback + Name collision occurrence (127.0.53.53)
          ip[0] === 127 || // 169.254.0.0/16  Link local
          ip[0] === 169 && ip[1] === 254 || // 172.16.0.0/12 Private-use networks
          ip[0] === 172 && ip[1] >= 16 && ip[1] <= 31 || // 192.168.0.0/16  Private-use networks
          ip[0] === 192 && ip[1] === 168
        );
      }
      function isReservedIP(ip) {
        return ip.byteLength === 4 ? isReservedIPv4(ip) : isReservedIPv6(ip);
      }
      function isReservedIPv4(ip) {
        return (
          // 0.0.0.0/8 "This" network
          ip[0] === 0 || // 192.0.0.0/24  IETF protocol assignments
          ip[0] === 192 && ip[1] === 0 && ip[2] === 0 || // 192.0.2.0/24  TEST-NET-1
          ip[0] === 192 && ip[1] === 0 && ip[2] === 2 || // 198.18.0.0/15 Network interconnect device benchmark testing
          ip[0] === 198 && ip[1] >= 18 && ip[1] <= 19 || // 198.51.100.0/24 TEST-NET-2
          ip[0] === 198 && ip[1] === 51 && ip[2] === 100 || // 203.0.113.0/24  TEST-NET-3
          ip[0] === 203 && ip[1] === 0 && ip[2] === 113 || // 224.0.0.0/4 Multicast
          ip[0] >= 224 && ip[0] <= 239 || // 240.0.0.0/4 Reserved for future use
          ip[0] >= 240 || // 255.255.255.255/32
          ip[0] === 255 && ip[1] === 255 && ip[2] === 255 && ip[3] === 255
        );
      }
      function isReservedIPv6(ip) {
        return (
          // ::/128 Node-scope unicast unspecified address
          // ::1/128 Node-scope unicast loopback address
          ip[0] === 0 && ip[1] === 0 && ip[2] === 0 && ip[3] === 0 && ip[4] === 0 && ip[5] === 0 && ip[6] === 0 && ip[7] === 0 && ip[8] === 0 && ip[9] === 0 && ip[10] === 0 && ip[11] === 0 && ip[12] === 0 && ip[13] === 0 && ip[14] === 0 && ip[15] <= 1 || // ::ffff:0:0/96 IPv4-mapped addresses
          // ::/96 IPv4-compatible addresses
          ip[0] === 0 && ip[1] === 0 && ip[2] === 0 && ip[3] === 0 && ip[4] === 0 && ip[5] === 0 && ip[6] === 0 && ip[7] === 0 && ip[8] === 0 && ip[9] === 0 && (ip[10] === 0 || ip[10] === 255) && (ip[11] === 0 || ip[11] === 255) || // 100::/64 Remotely triggered black hole addresses
          ip[0] === 1 && ip[1] === 0 && ip[2] === 0 && ip[3] === 0 && ip[4] === 0 && ip[5] === 0 && ip[6] === 0 && ip[7] === 0 || // 2001:10::/28 Overlay routable cryptographic hash identifiers (ORCHID)
          ip[0] === 32 && ip[1] === 1 && ip[2] === 0 && ip[3] >= 16 && ip[3] <= 31 || // 2001:20::/28 Overlay routable cryptographic hash identifiers version 2 (ORCHIDv2)
          ip[0] === 32 && ip[1] === 1 && ip[2] === 0 && ip[3] >= 32 && ip[3] <= 47 || // 2001:db8::/32 Documentation prefix
          ip[0] === 32 && ip[1] === 1 && ip[2] === 13 && ip[3] === 184 || // fc00::/7 Unique local addresses (ULA)
          ip[0] >= 252 && ip[0] <= 253 || // fe80::/10 Link-local unicast
          ip[0] === 254 && ip[1] >= 128 && ip[1] <= 191 || // ff00::/8 Multicast
          ip[0] === 255
        );
      }
      var state = c.state(0, 0, b4a.allocUnsafe(1 + 16));
      function ensureBuffer(ip) {
        if (b4a.isBuffer(ip)) return ip;
        net.ip.preencode(state, ip);
        net.ip.encode(state, ip);
        const buffer = state.buffer.subarray(1, state.end);
        state.start = 0;
        state.end = 0;
        return buffer;
      }
    }
  });

  // ../../node_modules/hyperdht/lib/server.js
  var require_server = __commonJS({
    "../../node_modules/hyperdht/lib/server.js"(exports, module) {
      var { EventEmitter } = require_bare_node_events();
      var safetyCatch = require_safety_catch();
      var NoiseSecretStream = require_secret_stream();
      var b4a = require_b4a();
      var relay = require_blind_relay();
      var NoiseWrap = require_noise_wrap();
      var Announcer = require_announcer();
      var { FIREWALL, ERROR } = require_constants6();
      var { unslabbedHash } = require_crypto();
      var SecurePayload = require_secure_payload();
      var Holepuncher = require_holepuncher();
      var { isPrivate } = require_bogon();
      var { ALREADY_LISTENING, NODE_DESTROYED, KEYPAIR_ALREADY_USED } = require_errors11();
      var HANDSHAKE_CLEAR_WAIT = 1e4;
      var HANDSHAKE_INITIAL_TIMEOUT = 1e4;
      module.exports = class Server extends EventEmitter {
        constructor(dht, opts = {}) {
          super();
          this.dht = dht;
          this.target = null;
          this.closed = false;
          this.firewall = opts.firewall || (() => false);
          this.holepunch = opts.holepunch || (() => true);
          this.relayThrough = opts.relayThrough || null;
          this.relayKeepAlive = opts.relayKeepAlive || 5e3;
          this.pool = opts.pool || null;
          this.createHandshake = opts.createHandshake || defaultCreateHandshake;
          this.createSecretStream = opts.createSecretStream || defaultCreateSecretStream;
          this.suspended = false;
          this.handshakeClearWait = opts.handshakeClearWait || HANDSHAKE_CLEAR_WAIT;
          this._shareLocalAddress = opts.shareLocalAddress !== false;
          this._reusableSocket = !!opts.reusableSocket;
          this._neverPunch = opts.holepunch === false;
          this._keyPair = null;
          this._announcer = null;
          this._connects = /* @__PURE__ */ new Map();
          this._holepunches = [];
          this._listening = null;
          this._closing = null;
        }
        get listening() {
          return this._listening !== null;
        }
        get publicKey() {
          return this._keyPair && this._keyPair.publicKey;
        }
        get relayAddresses() {
          return this._announcer ? this._announcer.relayAddresses : [];
        }
        onconnection(encryptedSocket) {
          this.emit("connection", encryptedSocket);
        }
        async suspend({ log = noop } = {}) {
          log("Suspending hyperdht server");
          if (this._listening !== null) await this._listening;
          log("Suspending hyperdht server (post listening)");
          this.suspended = true;
          this._clearAll();
          return this._announcer ? this._announcer.suspend({ log }) : Promise.resolve();
        }
        async resume() {
          if (this._listening !== null) await this._listening;
          this.suspended = false;
          return this._announcer ? this._announcer.resume() : Promise.resolve();
        }
        address() {
          if (!this._keyPair) return null;
          return {
            publicKey: this._keyPair.publicKey,
            host: this.dht.host,
            port: this.dht.port
          };
        }
        close() {
          if (this._closing) return this._closing;
          this._closing = this._close();
          return this._closing;
        }
        _gc() {
          this.dht.listening.delete(this);
          if (this.target) this.dht._router.delete(this.target);
        }
        async _stopListening() {
          try {
            if (this._announcer) await this._announcer.stop();
          } catch {
          }
          this._announcer = null;
          this._listening = null;
          this._keyPair = null;
        }
        async _close() {
          if (this._listening === null) {
            this.closed = true;
            this.emit("close");
            return;
          }
          try {
            await this._listening;
          } catch {
          }
          this._gc();
          this._clearAll();
          await this._stopListening();
          this.closed = true;
          this.emit("close");
        }
        _clearAll() {
          while (this._holepunches.length > 0) {
            const h = this._holepunches.pop();
            if (h && h.puncher) h.puncher.destroy();
            if (h && h.clearing) clearTimeout(h.clearing);
            if (h && h.prepunching) clearTimeout(h.prepunching);
            if (h && h.rawStream) h.rawStream.destroy();
          }
          this._connects.clear();
        }
        async listen(keyPair = this.dht.defaultKeyPair, opts = {}) {
          if (this._listening !== null) throw ALREADY_LISTENING();
          if (this.dht.destroyed) throw NODE_DESTROYED();
          this._listening = this._listen(keyPair, opts);
          await this._listening;
          return this;
        }
        async _listen(keyPair, opts) {
          this.dht.listening.add(this);
          try {
            await this.dht.bind();
            if (this._closing) return;
            for (const s of this.dht.listening) {
              if (s._keyPair && b4a.equals(s._keyPair.publicKey, keyPair.publicKey)) {
                throw KEYPAIR_ALREADY_USED();
              }
            }
            this.target = unslabbedHash(keyPair.publicKey);
            this._keyPair = keyPair;
            this._announcer = new Announcer(this.dht, keyPair, this.target, opts);
            this.dht._router.set(this.target, {
              relay: null,
              record: this._announcer.record,
              onpeerhandshake: this._onpeerhandshake.bind(this),
              onpeerholepunch: this._onpeerholepunch.bind(this)
            });
            this._localAddresses().catch(safetyCatch);
            await this._announcer.start();
          } catch (err) {
            await this._stopListening();
            this._gc();
            throw err;
          }
          if (this._closing) return;
          if (this.suspended) await this._announcer.suspend();
          if (this._closing) return;
          if (this.dht.destroyed) throw NODE_DESTROYED();
          if (this.pool) this.pool._attachServer(this);
          this.emit("listening");
        }
        refresh() {
          if (this._announcer && !this.suspended) this._announcer.refresh();
        }
        notifyOnline() {
          if (this._announcer) this._announcer.online.notify();
        }
        _localAddresses() {
          return this.dht.validateLocalAddresses(Holepuncher.localAddresses(this.dht.io.serverSocket));
        }
        async _addHandshake(k, noise, clientAddress, { from, to: serverAddress, socket }, direct) {
          let id = this._holepunches.indexOf(null);
          if (id === -1) id = this._holepunches.push(null) - 1;
          const hs = {
            round: 0,
            reply: null,
            puncher: null,
            payload: null,
            rawStream: null,
            encryptedSocket: null,
            prepunching: null,
            firewalled: true,
            clearing: null,
            onsocket: null,
            aborted: false,
            // Relay state
            relayTimeout: null,
            relayToken: null,
            relaySocket: null,
            relayClient: null,
            relayPaired: false
          };
          this._holepunches[id] = hs;
          const handshake = this.createHandshake(this._keyPair, null);
          let remotePayload;
          try {
            remotePayload = await handshake.recv(noise);
          } catch (err) {
            safetyCatch(err);
            this._clearLater(hs, id, k);
            return null;
          }
          if (this._closing || this.suspended) return null;
          try {
            hs.firewalled = await this.firewall(handshake.remotePublicKey, remotePayload, clientAddress);
          } catch (err) {
            safetyCatch(err);
          }
          if (this._closing || this.suspended) return null;
          if (hs.firewalled) {
            this._clearLater(hs, id, k);
            return null;
          }
          const error = remotePayload.version === 1 ? remotePayload.udx ? ERROR.NONE : ERROR.ABORTED : ERROR.VERSION_MISMATCH;
          const addresses = [];
          const ourRemoteAddr = this.dht.remoteAddress();
          const ourLocalAddrs = this._shareLocalAddress ? await this._localAddresses() : null;
          if (this._closing || this.suspended) return null;
          if (ourRemoteAddr) addresses.push(ourRemoteAddr);
          if (ourLocalAddrs) addresses.push(...ourLocalAddrs);
          if (error === ERROR.NONE) {
            let autoDestroy2 = function() {
              if (hs.puncher) hs.puncher.destroy();
            };
            var autoDestroy = autoDestroy2;
            hs.rawStream = this.dht.createRawStream({
              framed: true,
              firewall(socket2, port, host) {
                if (!(port > 0 && port < 65536)) return true;
                if (hs.relaySocket && isRelay(hs.relaySocket, socket2, port, host)) {
                  return false;
                }
                hs.onsocket(socket2, port, host);
                return false;
              }
            });
            hs.rawStream.on("error", autoDestroy2);
            const onrawstreamclose = () => {
              if (this._closing) return;
              this._clearLater(hs, id, k);
            };
            hs.rawStream.on("close", onrawstreamclose);
            hs.onsocket = (socket2, port, host) => {
              if (hs.rawStream === null) return;
              this._clearLater(hs, id, k);
              if (hs.prepunching) {
                clearTimeout(hs.prepunching);
                hs.prepunching = null;
              }
              if (this._reusableSocket && remotePayload.udx.reusableSocket) {
                this.dht._socketPool.routes.add(handshake.remotePublicKey, hs.rawStream);
              }
              hs.rawStream.removeListener("error", autoDestroy2);
              hs.rawStream.removeListener("close", onrawstreamclose);
              if (hs.rawStream.connected) {
                const remoteChanging = hs.rawStream.changeRemote(socket2, remotePayload.udx.id, port, host);
                if (remoteChanging) remoteChanging.catch(safetyCatch);
              } else {
                hs.rawStream.connect(socket2, remotePayload.udx.id, port, host);
                hs.encryptedSocket = this.createSecretStream(false, hs.rawStream, {
                  handshake: h,
                  keepAlive: this.dht.connectionKeepAlive
                });
                this.onconnection(hs.encryptedSocket);
              }
              if (hs.puncher) {
                hs.puncher.onabort = noop;
                hs.puncher.destroy();
              }
              hs.rawStream = null;
            };
          }
          const relayAddresses = this.relayAddresses;
          const relayThrough = selectRelay(this.relayThrough);
          if (relayThrough) hs.relayToken = relay.token();
          try {
            hs.reply = await handshake.send({
              error,
              firewall: ourRemoteAddr ? FIREWALL.OPEN : FIREWALL.UNKNOWN,
              holepunch: ourRemoteAddr ? null : { id, relays: this._announcer.relays },
              addresses4: addresses,
              addresses6: null,
              udx: {
                reusableSocket: this._reusableSocket,
                id: hs.rawStream ? hs.rawStream.id : 0,
                seq: 0
              },
              secretStream: {},
              relayThrough: relayThrough ? { publicKey: relayThrough, token: hs.relayToken } : null,
              relayAddresses: relayAddresses.length ? relayAddresses : null
            });
          } catch (err) {
            safetyCatch(err);
            if (hs.rawStream) hs.rawStream.destroy();
            this._clearLater(hs, id, k);
            return null;
          }
          if (this._closing || this.suspended) {
            if (hs.rawStream) hs.rawStream.destroy();
            return null;
          }
          const h = handshake.final();
          if (error !== ERROR.NONE) {
            if (hs.rawStream) hs.rawStream.destroy();
            this._clearLater(hs, id, k);
            return hs;
          }
          if (remotePayload.firewall === FIREWALL.OPEN || direct) {
            const sock = direct ? socket : this.dht.socket;
            this.dht.stats.punches.open++;
            hs.onsocket(sock, clientAddress.port, clientAddress.host);
            return hs;
          }
          if (relayThrough || remotePayload.relayThrough) {
            this._relayConnection(hs, relayThrough, remotePayload, h);
          }
          const onabort = () => {
            hs.aborted = true;
            if (hs.prepunching) clearTimeout(hs.prepunching);
            hs.prepunching = null;
            if (hs.rawStream.destroyed) {
              this._clearLater(hs, id, k);
              return;
            }
            hs.rawStream.on("close", () => this._clearLater(hs, id, k));
            if (hs.relayToken === null) hs.rawStream.destroy();
          };
          if (!direct && clientAddress.host === serverAddress.host) {
            const clientAddresses = remotePayload.addresses4.filter(onlyPrivateHosts);
            if (clientAddresses.length > 0 && this._shareLocalAddress) {
              const myAddresses = await this._localAddresses();
              const addr = Holepuncher.matchAddress(myAddresses, clientAddresses);
              if (addr) {
                hs.prepunching = setTimeout(onabort, HANDSHAKE_INITIAL_TIMEOUT);
                return hs;
              }
            }
          }
          if (this._closing || this.suspended) return null;
          if (ourRemoteAddr || this._neverPunch) {
            hs.prepunching = setTimeout(onabort, HANDSHAKE_INITIAL_TIMEOUT);
            return hs;
          }
          hs.payload = new SecurePayload(h.holepunchSecret);
          hs.puncher = new Holepuncher(this.dht, this.dht.session(), false, remotePayload.firewall);
          hs.puncher.onconnect = hs.onsocket;
          hs.puncher.onabort = onabort;
          hs.prepunching = setTimeout(hs.puncher.destroy.bind(hs.puncher), HANDSHAKE_INITIAL_TIMEOUT);
          return hs;
        }
        _clearLater(hs, id, k) {
          if (hs.clearing) return;
          hs.clearing = setTimeout(() => this._clear(hs, id, k), this.handshakeClearWait);
        }
        _clear(hs, id, k) {
          if (id >= this._holepunches.length || this._holepunches[id] !== hs) return;
          if (hs.clearing) clearTimeout(hs.clearing);
          this._holepunches[id] = null;
          while (this._holepunches.length > 0 && this._holepunches[this._holepunches.length - 1] === null) {
            this._holepunches.pop();
          }
          this._connects.delete(k);
        }
        async _onpeerhandshake({ noise, peerAddress }, req) {
          const k = b4a.toString(noise, "hex");
          let p = this._connects.get(k);
          if (!p) {
            p = this._addHandshake(k, noise, peerAddress || req.from, req, !peerAddress);
            this._connects.set(k, p);
          }
          const h = await p;
          if (!h) return null;
          if (this._closing !== null || this.suspended) return null;
          return { socket: h.puncher && h.puncher.socket, noise: h.reply };
        }
        async _onpeerholepunch({ id, peerAddress, payload }, req) {
          const h = id < this._holepunches.length ? this._holepunches[id] : null;
          if (!h) return null;
          if (!peerAddress || this._closing !== null || this.suspended) return null;
          const p = h.puncher;
          if (!p || !p.socket) return this._abort(h);
          const remotePayload = h.payload.decrypt(payload);
          if (!remotePayload) return null;
          const isServerRelay = this._announcer.isRelay(req.from);
          const { error, firewall, round, punching, addresses, remoteAddress, remoteToken } = remotePayload;
          if (error !== ERROR.NONE) {
            if (round >= h.round) h.round = round;
            return this._abort(h);
          }
          const token = h.payload.token(peerAddress);
          const echoed = isServerRelay && !!remoteToken && b4a.equals(token, remoteToken);
          if (req.socket === p.socket) {
            p.nat.add(req.to, req.from);
          }
          if (round >= h.round) {
            h.round = round;
            p.updateRemote({ punching, firewall, addresses, verified: echoed ? peerAddress.host : null });
          }
          let stable = await p.analyze(false);
          if (p.destroyed) return null;
          if (!p.remoteHolepunching && !stable) {
            stable = await p.analyze(true);
            if (p.destroyed) return null;
            if (!stable) return this._abort(h);
          }
          if (isConsistent(p.nat.firewall) && remoteAddress && hasSameAddr(p.nat.addresses, remoteAddress)) {
            await p.ping(peerAddress);
            if (p.destroyed) return null;
          }
          if (p.remoteHolepunching) {
            if (!this.holepunch(p.remoteFirewall, p.nat.firewall, p.remoteAddresses, p.nat.addresses)) {
              return p.destroyed ? null : this._abort(h);
            }
            if (h.prepunching) {
              clearTimeout(h.prepunching);
              h.prepunching = null;
            }
            if (p.remoteFirewall >= FIREWALL.RANDOM || p.nat.firewall >= FIREWALL.RANDOM) {
              if (this.dht._randomPunches >= this.dht._randomPunchLimit || Date.now() - this.dht._lastRandomPunch < this.dht._randomPunchInterval) {
                if (!h.relayToken) return this._abort(h, ERROR.TRY_LATER);
                return {
                  socket: p.socket,
                  payload: h.payload.encrypt({
                    error: ERROR.TRY_LATER,
                    firewall: p.nat.firewall,
                    round: h.round,
                    connected: p.connected,
                    punching: p.punching,
                    addresses: p.nat.addresses,
                    remoteAddress: null,
                    token: isServerRelay ? token : null,
                    remoteToken: remotePayload.token
                  })
                };
              }
            }
            const punching2 = await p.punch();
            if (p.destroyed) return null;
            if (!punching2) return this._abort(h);
          }
          if (p.nat.firewall !== FIREWALL.UNKNOWN) {
            p.nat.freeze();
          }
          return {
            socket: p.socket,
            payload: h.payload.encrypt({
              error: ERROR.NONE,
              firewall: p.nat.firewall,
              round: h.round,
              connected: p.connected,
              punching: p.punching,
              addresses: p.nat.addresses,
              remoteAddress: null,
              token: isServerRelay ? token : null,
              remoteToken: remotePayload.token
            })
          };
        }
        _abort(h, error = ERROR.ABORTED) {
          if (!h.payload) {
            if (h.puncher) h.puncher.destroy();
            return null;
          }
          const payload = h.payload.encrypt({
            error,
            firewall: FIREWALL.UNKNOWN,
            round: h.round,
            connected: false,
            punching: false,
            addresses: null,
            remoteAddress: null,
            token: null,
            remoteToken: null
          });
          h.puncher.destroy();
          return { socket: this.dht.socket, payload };
        }
        _relayConnection(hs, relayThrough, remotePayload, h) {
          this.dht.stats.relaying.attempts++;
          let isInitiator;
          let publicKey;
          let token;
          if (relayThrough) {
            isInitiator = true;
            publicKey = relayThrough;
            token = hs.relayToken;
          } else {
            isInitiator = false;
            publicKey = remotePayload.relayThrough.publicKey;
            token = remotePayload.relayThrough.token;
          }
          hs.relayToken = token;
          hs.relaySocket = this.dht.connect(publicKey);
          hs.relaySocket.setKeepAlive(this.relayKeepAlive);
          hs.relayClient = relay.Client.from(hs.relaySocket, { id: hs.relaySocket.publicKey });
          hs.relayTimeout = setTimeout(onabort, 15e3);
          hs.relayClient.pair(isInitiator, token, hs.rawStream).on("error", onabort).on("data", (remoteId) => {
            if (hs.relayTimeout) clearRelayTimeout(hs);
            if (hs.rawStream === null) {
              onabort(null);
              return;
            }
            hs.relayPaired = true;
            this.dht.stats.relaying.successes++;
            if (hs.prepunching) clearTimeout(hs.prepunching);
            hs.prepunching = null;
            const { remotePort, remoteHost, socket } = hs.relaySocket.rawStream;
            hs.rawStream.on("close", () => hs.relaySocket.destroy()).connect(socket, remoteId, remotePort, remoteHost);
            hs.encryptedSocket = this.createSecretStream(false, hs.rawStream, { handshake: h });
            this.onconnection(hs.encryptedSocket);
          });
          const dht = this.dht;
          function onabort() {
            if (!hs.relayPaired) dht.stats.relaying.aborts++;
            if (hs.relayTimeout) clearRelayTimeout(hs);
            const socket = hs.relaySocket;
            hs.relayToken = null;
            hs.relaySocket = null;
            if (socket) socket.destroy();
            if (hs.aborted && hs.rawStream) hs.rawStream.destroy();
          }
        }
      };
      function clearRelayTimeout(hs) {
        clearTimeout(hs.relayTimeout);
        hs.relayTimeout = null;
      }
      function isConsistent(fw) {
        return fw === FIREWALL.OPEN || fw === FIREWALL.CONSISTENT;
      }
      function hasSameAddr(addrs, other) {
        if (addrs === null) return false;
        for (const addr of addrs) {
          if (addr.port === other.port && addr.host === other.host) return true;
        }
        return false;
      }
      function defaultCreateHandshake(keyPair, remotePublicKey) {
        return new NoiseWrap(keyPair, remotePublicKey);
      }
      function defaultCreateSecretStream(isInitiator, rawStream, opts) {
        return new NoiseSecretStream(isInitiator, rawStream, opts);
      }
      function onlyPrivateHosts(addr) {
        return isPrivate(addr.host);
      }
      function isRelay(relaySocket, socket, port, host) {
        const stream = relaySocket.rawStream;
        if (!stream) return false;
        if (stream.socket !== socket) return false;
        return port === stream.remotePort && host === stream.remoteHost;
      }
      function selectRelay(relayThrough) {
        if (typeof relayThrough === "function") relayThrough = relayThrough();
        if (relayThrough === null) return null;
        if (Array.isArray(relayThrough)) {
          return relayThrough[Math.floor(Math.random() * relayThrough.length)];
        }
        return relayThrough;
      }
      function noop() {
      }
    }
  });

  // ../../node_modules/hyperdht/lib/semaphore.js
  var require_semaphore = __commonJS({
    "../../node_modules/hyperdht/lib/semaphore.js"(exports, module) {
      var DONE = Promise.resolve(true);
      var DESTROYED = Promise.resolve(false);
      module.exports = class Semaphore {
        constructor(limit = 1) {
          this.limit = limit;
          this.active = 0;
          this.waiting = [];
          this.flushedPromise = null;
          this.flushedResolve = null;
          this.destroyed = false;
          this._onwait = this._queueWaiting.bind(this);
          this._onflush = this._queueFlushed.bind(this);
        }
        _queueWaiting(resolve) {
          this.waiting.push(resolve);
        }
        _queueFlushed(resolve) {
          this.flushedResolve = resolve;
        }
        wait() {
          if (this.destroyed === true) return DESTROYED;
          if (this.active < this.limit && this.waiting.length === 0) {
            this.active++;
            return DONE;
          }
          return new Promise(this._onwait);
        }
        signal() {
          if (this.destroyed === true) return;
          this.active--;
          while (this.active < this.limit && this.waiting.length > 0 && this.destroyed === false) {
            this.active++;
            this.waiting.shift()(true);
          }
          if (this.active === 0 && this.flushedResolve) {
            const resolve = this.flushedResolve;
            this.flushedResolve = null;
            this.flushedPromise = null;
            resolve(true);
          }
        }
        async flush() {
          if (this.destroyed === true) return;
          if (this.active === 0) return;
          if (this.flushedPromise) return this.flushedPromise;
          this.flushedPromise = new Promise(this._onflush);
          return this.flushedPromise;
        }
        destroy() {
          this.destroyed = true;
          this.active = 0;
          while (this.waiting.length) this.waiting.pop()(false);
          if (this.flushedResolve) this.flushedResolve(false);
        }
      };
    }
  });

  // ../../node_modules/hyperdht/lib/connect.js
  var require_connect = __commonJS({
    "../../node_modules/hyperdht/lib/connect.js"(exports, module) {
      var NoiseSecretStream = require_secret_stream();
      var b4a = require_b4a();
      var relay = require_blind_relay();
      var { isReserved, isBogon } = require_bogon();
      var safetyCatch = require_safety_catch();
      var unslab = require_unslab();
      var Semaphore = require_semaphore();
      var NoiseWrap = require_noise_wrap();
      var SecurePayload = require_secure_payload();
      var Holepuncher = require_holepuncher();
      var Sleeper = require_sleeper();
      var { FIREWALL, ERROR } = require_constants6();
      var { unslabbedHash } = require_crypto();
      var {
        CANNOT_HOLEPUNCH,
        HANDSHAKE_INVALID,
        HOLEPUNCH_ABORTED,
        HOLEPUNCH_INVALID,
        HOLEPUNCH_PROBE_TIMEOUT,
        HOLEPUNCH_DOUBLE_RANDOMIZED_NATS,
        PEER_CONNECTION_FAILED,
        PEER_NOT_FOUND,
        REMOTE_ABORTED,
        REMOTE_NOT_HOLEPUNCHABLE,
        REMOTE_NOT_HOLEPUNCHING,
        SERVER_ERROR,
        SERVER_INCOMPATIBLE,
        RELAY_ABORTED,
        SUSPENDED
      } = require_errors11();
      module.exports = function connect(dht, publicKey, opts = {}) {
        const pool = opts.pool || null;
        if (pool && pool.has(publicKey)) return pool.get(publicKey);
        publicKey = unslab(publicKey);
        const keyPair = opts.keyPair || dht.defaultKeyPair;
        const relayThrough = selectRelay(opts.relayThrough || null);
        const encryptedSocket = (opts.createSecretStream || defaultCreateSecretStream)(true, null, {
          publicKey: keyPair.publicKey,
          remotePublicKey: publicKey,
          autoStart: false,
          keepAlive: dht.connectionKeepAlive
        });
        if (dht.suspended || !dht._connectable) {
          encryptedSocket.destroy(SUSPENDED());
          return encryptedSocket;
        }
        if (pool) pool._attachStream(encryptedSocket, false);
        const id = b4a.toString(publicKey, "hex");
        const c = {
          id,
          dht,
          session: dht.session(),
          relayAddresses: opts.relayAddresses || [],
          remoteRelayAddresses: [],
          pool,
          round: 0,
          target: unslabbedHash(publicKey),
          remotePublicKey: publicKey,
          reusableSocket: !!opts.reusableSocket,
          handshake: (opts.createHandshake || defaultCreateHandshake)(keyPair, publicKey),
          request: null,
          requesting: false,
          lan: opts.localConnection !== false,
          firewall: FIREWALL.UNKNOWN,
          rawStream: dht.createRawStream({ framed: true, firewall }),
          connect: null,
          query: null,
          puncher: null,
          payload: null,
          passiveConnectTimeout: null,
          serverSocket: null,
          serverAddress: null,
          onsocket: null,
          sleeper: new Sleeper(),
          encryptedSocket,
          // Relay state
          relayTimeout: null,
          relayThrough,
          relayToken: relayThrough ? relay.token() : null,
          relaySocket: null,
          relayClient: null,
          relayPaired: false,
          relayKeepAlive: opts.relayKeepAlive || 5e3
        };
        c.rawStream.on("error", autoDestroy);
        c.rawStream.once("connect", () => {
          c.rawStream.removeListener("error", autoDestroy);
        });
        encryptedSocket.on("close", function() {
          if (c.passiveConnectTimeout) clearPassiveConnectTimeout(c);
          if (c.query) c.query.destroy();
          if (c.puncher) c.puncher.destroy();
          if (c.rawStream) c.rawStream.destroy();
          c.session.destroy();
          c.sleeper.resume();
        });
        if (dht.suspended) encryptedSocket.destroy(SUSPENDED());
        else connectAndHolepunch(c, opts);
        return encryptedSocket;
        function autoDestroy(err) {
          maybeDestroyEncryptedSocket(c, err);
        }
        function firewall(socket, port, host) {
          if (c.relaySocket && isRelay(c.relaySocket, socket, port, host)) {
            return false;
          }
          if (c.onsocket) {
            c.onsocket(socket, port, host);
          } else {
            c.serverSocket = socket;
            c.serverAddress = { port, host };
          }
          return false;
        }
      };
      function isDone(c) {
        if (c.encryptedSocket.destroying || !!(c.puncher && c.puncher.connected)) {
          return true;
        }
        if (c.encryptedSocket.rawStream === null) {
          return false;
        }
        if (c.relaySocket && !!(c.puncher && !c.puncher.connected && !c.puncher.destroyed)) {
          return false;
        }
        return true;
      }
      async function retryRoute(c, route) {
        const ref = c.dht._socketPool.lookup(route.socket);
        if (!ref) {
          if (route.socket === c.dht.socket) {
            await connectThroughNode(c, route.address, c.dht.socket);
          }
          return;
        }
        ref.active();
        try {
          await connectThroughNode(c, route.address, route.socket);
        } catch {
        }
        ref.inactive();
      }
      async function connectAndHolepunch(c, opts) {
        const route = c.reusableSocket ? c.dht._socketPool.routes.get(c.remotePublicKey) : null;
        if (route) {
          await retryRoute(c, route);
          if (isDone(c)) return;
        }
        await findAndConnect(c, opts);
        if (isDone(c)) return;
        if (!c.connect) {
          maybeDestroyEncryptedSocket(c, HANDSHAKE_INVALID());
          return;
        }
        await holepunch(c, opts);
      }
      function getFirstRemoteAddress(addrs, serverAddress) {
        for (const addr of addrs) {
          if (isBogon(addr.host)) continue;
          return addr;
        }
        return serverAddress;
      }
      async function holepunch(c, opts) {
        let { relayAddress, serverAddress, clientAddress, payload } = c.connect;
        const remoteHolepunchable = !!(payload.holepunch && payload.holepunch.relays.length);
        const relayed = diffAddress(serverAddress, relayAddress);
        if (payload.firewall === FIREWALL.OPEN || relayed && !remoteHolepunchable) {
          const addr = getFirstRemoteAddress(payload.addresses4, serverAddress);
          if (addr) {
            const socket = c.dht.socket;
            c.dht.stats.punches.open++;
            c.onsocket(socket, addr.port, addr.host);
            return;
          }
        }
        const onabort = () => {
          c.session.destroy();
          maybeDestroyEncryptedSocket(c, HOLEPUNCH_ABORTED());
        };
        if (c.firewall === FIREWALL.OPEN) {
          c.passiveConnectTimeout = setTimeout(onabort, 1e4);
          return;
        }
        if (c.lan && relayed && clientAddress.host === serverAddress.host) {
          const serverAddresses = payload.addresses4.filter(onlyNonReserved);
          if (serverAddresses.length > 0) {
            const myAddresses = Holepuncher.localAddresses(c.dht.io.serverSocket);
            const addr = Holepuncher.matchAddress(myAddresses, serverAddresses) || serverAddresses[0];
            const socket = c.dht.io.serverSocket;
            try {
              await c.dht.ping(addr);
            } catch {
              maybeDestroyEncryptedSocket(c, HOLEPUNCH_ABORTED());
              return;
            }
            c.onsocket(socket, addr.port, addr.host);
            return;
          }
        }
        if (!remoteHolepunchable) {
          maybeDestroyEncryptedSocket(c, CANNOT_HOLEPUNCH());
          return;
        }
        c.puncher = new Holepuncher(c.dht, c.session, true, payload.firewall);
        c.puncher.onconnect = c.onsocket;
        c.puncher.onabort = onabort;
        const serverRelay = pickServerRelay(payload.holepunch.relays, relayAddress);
        let probe;
        try {
          probe = await probeRound(c, opts.fastOpen === false ? null : serverAddress, serverRelay, true);
        } catch (err) {
          destroyPuncher(c);
          maybeDestroyEncryptedSocket(c, err);
          return;
        }
        if (isDone(c) || !probe) return;
        const { token, peerAddress } = probe;
        if (!diffAddress(serverRelay.relayAddress, relayAddress) && diffAddress(serverAddress, peerAddress)) {
          serverAddress = peerAddress;
          await c.puncher.openSession(serverAddress);
          if (isDone(c)) return;
        }
        if (opts.holepunch && !opts.holepunch(
          c.puncher.remoteFirewall,
          c.puncher.nat.firewall,
          c.puncher.remoteAddresses,
          c.puncher.nat.addresses
        )) {
          await abort(c, serverRelay, HOLEPUNCH_ABORTED("Client aborted holepunch"));
          return;
        }
        try {
          await roundPunch(c, serverAddress, token, relayAddress, serverRelay, false);
        } catch (err) {
          destroyPuncher(c);
          maybeDestroyEncryptedSocket(c, err);
        }
      }
      async function findAndConnect(c, opts) {
        let attempts = 0;
        let closestNodes = opts.relayAddresses && opts.relayAddresses.length ? opts.relayAddresses : null;
        if (!closestNodes) {
          const cachedRelayAddresses = c.dht._relayAddressesCache.get(c.id);
          if (cachedRelayAddresses) closestNodes = cachedRelayAddresses;
        }
        if (c.dht._persistent) {
          const route = c.dht._router.get(c.target);
          if (route && route.relay !== null) {
            closestNodes = [{ host: route.relay.host, port: route.relay.port }];
          }
        }
        const sem = new Semaphore(2);
        const signal = sem.signal.bind(sem);
        const tries = closestNodes !== null ? 2 : 1;
        try {
          for (let i = 0; i < tries && !isDone(c) && !c.connect; i++) {
            c.query = c.dht.findPeer(c.target, {
              hash: false,
              session: c.session,
              closestNodes,
              onlyClosestNodes: closestNodes !== null,
              retries: closestNodes ? 1 : 3
            });
            for await (const data of c.query) {
              await sem.wait();
              if (isDone(c)) return;
              if (c.connect) {
                sem.signal();
                break;
              }
              c.remoteRelayAddresses.push(data.from);
              attempts++;
              connectThroughNode(c, data.from, null).then(signal, signal);
            }
            closestNodes = null;
            if (attempts > 0) await sem.flush();
          }
          c.query = null;
          if (isDone(c)) return;
          await sem.flush();
          if (isDone(c)) return;
        } catch (err) {
          c.query = null;
          maybeDestroyEncryptedSocket(c, err);
          return;
        }
        if (!c.connect) {
          maybeDestroyEncryptedSocket(c, attempts ? PEER_CONNECTION_FAILED() : PEER_NOT_FOUND());
        }
      }
      async function connectThroughNode(c, address, socket) {
        if (!c.requesting) {
          const addr = c.dht.remoteAddress();
          const localAddrs = c.lan ? Holepuncher.localAddresses(c.dht.io.serverSocket) : null;
          const addresses4 = [];
          if (addr) addresses4.push(addr);
          if (localAddrs) addresses4.push(...localAddrs);
          c.firewall = addr ? FIREWALL.OPEN : FIREWALL.UNKNOWN;
          c.requesting = true;
          c.request = await c.handshake.send({
            error: ERROR.NONE,
            firewall: c.firewall,
            holepunch: null,
            addresses4,
            addresses6: [],
            udx: {
              reusableSocket: c.reusableSocket,
              id: c.rawStream.id,
              seq: 0
            },
            secretStream: {},
            relayThrough: c.relayThrough ? { publicKey: c.relayThrough, token: c.relayToken } : null
          });
          if (isDone(c)) return;
        }
        const { serverAddress, clientAddress, relayed, noise } = await c.dht._router.peerHandshake(
          c.target,
          { noise: c.request, socket, session: c.session },
          address
        );
        if (isDone(c) || c.connect) return;
        const payload = await c.handshake.recv(noise);
        if (isDone(c) || !payload) return;
        if (payload.version !== 1) {
          maybeDestroyEncryptedSocket(c, SERVER_INCOMPATIBLE());
          return;
        }
        if (payload.error !== ERROR.NONE) {
          maybeDestroyEncryptedSocket(c, SERVER_ERROR());
          return;
        }
        if (!payload.udx) {
          maybeDestroyEncryptedSocket(c, SERVER_ERROR("Server did not send UDX data"));
          return;
        }
        const hs = c.handshake.final();
        c.handshake = null;
        c.request = null;
        c.requesting = false;
        c.connect = {
          relayed,
          relayAddress: address,
          clientAddress,
          serverAddress,
          payload
        };
        c.payload = new SecurePayload(hs.holepunchSecret);
        c.onsocket = function(socket2, port, host) {
          if (c.rawStream === null) return;
          if (c.rawStream.connected) {
            const remoteChanging = c.rawStream.changeRemote(socket2, c.connect.payload.udx.id, port, host);
            if (remoteChanging) remoteChanging.catch(safetyCatch);
          } else {
            if (payload.relayAddresses && payload.relayAddresses.length) {
              c.dht._relayAddressesCache.set(c.id, payload.relayAddresses);
            } else if (c.remoteRelayAddresses.length) {
              c.dht._relayAddressesCache.set(c.id, c.remoteRelayAddresses);
            }
            c.rawStream.connect(socket2, c.connect.payload.udx.id, port, host);
            c.encryptedSocket.start(c.rawStream, { handshake: hs });
          }
          if (c.reusableSocket && payload.udx.reusableSocket) {
            c.dht._socketPool.routes.add(c.remotePublicKey, c.rawStream);
          }
          if (c.puncher) {
            c.puncher.onabort = noop;
            c.puncher.destroy();
          }
          if (c.passiveConnectTimeout) {
            clearPassiveConnectTimeout(c);
          }
          c.rawStream = null;
        };
        if (payload.relayThrough || c.relayThrough) {
          relayConnection(c, c.relayThrough, payload, hs);
        }
        if (c.serverSocket) {
          c.onsocket(c.serverSocket, c.serverAddress.port, c.serverAddress.host);
          return;
        }
        if (!relayed) {
          c.onsocket(socket || c.dht.socket, address.port, address.host);
        }
        c.session.destroy();
      }
      async function updateHolepunch(c, peerAddress, relayAddr, payload) {
        const holepunch2 = await c.dht._router.peerHolepunch(
          c.target,
          {
            id: c.connect.payload.holepunch.id,
            payload: c.payload.encrypt(payload),
            peerAddress,
            socket: c.puncher.socket,
            session: c.session
          },
          relayAddr
        );
        if (isDone(c)) return null;
        const remotePayload = c.payload.decrypt(holepunch2.payload);
        if (!remotePayload) {
          throw HOLEPUNCH_INVALID();
        }
        const { error, firewall, punching, addresses, remoteToken } = remotePayload;
        if (error === ERROR.TRY_LATER && c.relayToken && payload.punching) {
          return {
            tryLater: true,
            ...holepunch2,
            payload: remotePayload
          };
        }
        if (error !== ERROR.NONE) {
          throw REMOTE_ABORTED("Remote aborted with error code " + error);
        }
        const echoed = !!(remoteToken && payload.token && b4a.equals(remoteToken, payload.token));
        c.puncher.updateRemote({
          punching,
          firewall,
          addresses,
          verified: echoed ? peerAddress.host : null
        });
        return {
          tryLater: false,
          ...holepunch2,
          payload: remotePayload
        };
      }
      async function probeRound(c, serverAddress, serverRelay, retry) {
        if (serverAddress) await c.puncher.openSession(serverAddress);
        if (isDone(c)) return null;
        const reply = await updateHolepunch(c, serverRelay.peerAddress, serverRelay.relayAddress, {
          error: ERROR.NONE,
          firewall: c.puncher.nat.firewall,
          round: c.round++,
          connected: false,
          punching: false,
          addresses: c.puncher.nat.addresses,
          remoteAddress: serverAddress,
          token: null,
          remoteToken: null
        });
        if (isDone(c) || !reply) return null;
        const { peerAddress } = reply;
        const { address, token } = reply.payload;
        c.puncher.nat.add(reply.to, reply.from);
        if (c.puncher.remoteFirewall < FIREWALL.RANDOM && address && address.host && address.port && diffAddress(address, serverAddress)) {
          await c.puncher.openSession(address);
          if (isDone(c)) return null;
        }
        if (c.puncher.remoteFirewall === FIREWALL.UNKNOWN) {
          await c.sleeper.pause(1e3);
          if (isDone(c)) return null;
        }
        let stable = await c.puncher.analyze(false);
        if (isDone(c)) return null;
        if (!stable) {
          stable = await c.puncher.analyze(true);
          if (isDone(c)) return null;
          if (stable) return probeRound(c, serverAddress, serverRelay, false);
        }
        if ((c.puncher.remoteFirewall === FIREWALL.UNKNOWN || !token) && retry) {
          return probeRound(c, serverAddress, serverRelay, false);
        }
        if (c.puncher.remoteFirewall === FIREWALL.UNKNOWN || c.puncher.nat.firewall === FIREWALL.UNKNOWN) {
          await abort(c, serverRelay, HOLEPUNCH_PROBE_TIMEOUT());
          return null;
        }
        if (c.puncher.remoteFirewall >= FIREWALL.RANDOM && c.puncher.nat.firewall >= FIREWALL.RANDOM) {
          await abort(c, serverRelay, HOLEPUNCH_DOUBLE_RANDOMIZED_NATS());
          return null;
        }
        return { token, peerAddress };
      }
      async function roundPunch(c, serverAddress, remoteToken, clientRelay, serverRelay, delayed) {
        c.puncher.nat.freeze();
        const isRandom = c.puncher.remoteFirewall >= FIREWALL.RANDOM || c.puncher.nat.firewall >= FIREWALL.RANDOM;
        if (isRandom) {
          while (c.dht._randomPunches >= c.dht._randomPunchLimit || Date.now() - c.dht._lastRandomPunch < c.dht._randomPunchInterval) {
            if (!c.relayToken) throw HOLEPUNCH_ABORTED();
            if (!delayed) {
              delayed = true;
              await updateHolepunch(c, serverAddress, clientRelay, {
                error: ERROR.NONE,
                firewall: c.puncher.nat.firewall,
                round: c.round++,
                connected: false,
                punching: false,
                addresses: c.puncher.nat.addresses,
                remoteAddress: null,
                token: c.payload.token(serverAddress),
                remoteToken
              });
              if (isDone(c)) return;
            }
            await tryLater(c);
            if (isDone(c)) return;
          }
        }
        if (isRandom) c.dht._randomPunches++;
        let reply;
        try {
          reply = await updateHolepunch(
            c,
            delayed ? serverRelay.peerAddress : serverAddress,
            delayed ? serverRelay.relayAddress : clientRelay,
            {
              error: ERROR.NONE,
              firewall: c.puncher.nat.firewall,
              round: c.round++,
              connected: false,
              punching: true,
              addresses: c.puncher.nat.addresses,
              remoteAddress: null,
              token: delayed ? null : c.payload.token(serverAddress),
              remoteToken
            }
          );
        } finally {
          if (isRandom) c.dht._randomPunches--;
        }
        if (isDone(c)) return;
        if (!reply) return;
        if (reply.tryLater) {
          await tryLater(c);
          if (isDone(c)) return;
          return roundPunch(c, serverAddress, remoteToken, clientRelay, serverRelay, true);
        }
        if (!c.puncher.remoteHolepunching) {
          throw REMOTE_NOT_HOLEPUNCHING();
        }
        if (!await c.puncher.punch()) {
          throw REMOTE_NOT_HOLEPUNCHABLE();
        }
      }
      async function tryLater(c) {
        if (!c.relayToken) throw HOLEPUNCH_ABORTED();
        await c.sleeper.pause(1e4 + Math.round(Math.random() * 1e4));
      }
      function maybeDestroyEncryptedSocket(c, err) {
        if (isDone(c)) return;
        if (c.encryptedSocket.rawStream) return;
        if (c.relaySocket) return;
        if (c.puncher && !c.puncher.destroyed) return;
        c.session.destroy();
        c.encryptedSocket.destroy(err);
      }
      async function abort(c, { peerAddress, relayAddress }, err) {
        try {
          await updateHolepunch(peerAddress, relayAddress, {
            error: ERROR.ABORTED,
            firewall: FIREWALL.UNKNOWN,
            round: c.round++,
            connected: false,
            punching: false,
            addresses: null,
            remoteAddress: null,
            token: null,
            remoteToken: null
          });
        } catch {
        }
        destroyPuncher(c);
        maybeDestroyEncryptedSocket(c, err);
      }
      function relayConnection(c, relayThrough, payload, hs) {
        let isInitiator;
        let publicKey;
        let token;
        if (payload.relayThrough) {
          isInitiator = false;
          publicKey = payload.relayThrough.publicKey;
          token = payload.relayThrough.token;
        } else {
          isInitiator = true;
          publicKey = relayThrough;
          token = c.relayToken;
        }
        c.relayToken = token;
        c.relaySocket = c.dht.connect(publicKey);
        c.relaySocket.setKeepAlive(c.relayKeepAlive);
        c.relayClient = relay.Client.from(c.relaySocket, { id: c.relaySocket.publicKey });
        c.relayTimeout = setTimeout(onabort, 15e3, null);
        c.relayClient.pair(isInitiator, token, c.rawStream).on("error", onabort).on("data", ondata);
        function ondata(remoteId) {
          if (c.relayTimeout) clearRelayTimeout(c);
          if (c.rawStream === null) {
            onabort(null);
            return;
          }
          c.relayPaired = true;
          const { remotePort, remoteHost, socket } = c.relaySocket.rawStream;
          c.rawStream.on("close", () => c.relaySocket.destroy()).connect(socket, remoteId, remotePort, remoteHost);
          c.encryptedSocket.start(c.rawStream, { handshake: hs });
        }
        function onabort(err) {
          if (c.relayTimeout) clearRelayTimeout(c);
          const socket = c.relaySocket;
          c.relayToken = null;
          c.relaySocket = null;
          if (socket) socket.destroy();
          maybeDestroyEncryptedSocket(c, err || RELAY_ABORTED());
        }
      }
      function clearPassiveConnectTimeout(c) {
        clearTimeout(c.passiveConnectTimeout);
        c.passiveConnectTimeout = null;
      }
      function clearRelayTimeout(c) {
        clearTimeout(c.relayTimeout);
        c.relayTimeout = null;
      }
      function destroyPuncher(c) {
        if (c.puncher) c.puncher.destroy();
        c.session.destroy();
      }
      function pickServerRelay(relays, clientRelay) {
        for (const r of relays) {
          if (!diffAddress(r.relayAddress, clientRelay)) return r;
        }
        return relays[0];
      }
      function diffAddress(a, b) {
        return a.host !== b.host || a.port !== b.port;
      }
      function defaultCreateHandshake(keyPair, remotePublicKey) {
        return new NoiseWrap(keyPair, remotePublicKey);
      }
      function defaultCreateSecretStream(isInitiator, rawStream, opts) {
        return new NoiseSecretStream(isInitiator, rawStream, opts);
      }
      function onlyNonReserved(addr) {
        return !isReserved(addr.host);
      }
      function isRelay(relaySocket, socket, port, host) {
        const stream = relaySocket.rawStream;
        if (!stream) return false;
        if (stream.socket !== socket) return false;
        return port === stream.remotePort && host === stream.remoteHost;
      }
      function selectRelay(relayThrough) {
        if (typeof relayThrough === "function") relayThrough = relayThrough();
        if (relayThrough === null) return null;
        if (Array.isArray(relayThrough))
          return relayThrough[Math.floor(Math.random() * relayThrough.length)];
        return relayThrough;
      }
      function noop() {
      }
    }
  });

  // ../../node_modules/hyperdht/lib/raw-stream-set.js
  var require_raw_stream_set = __commonJS({
    "../../node_modules/hyperdht/lib/raw-stream-set.js"(exports, module) {
      module.exports = class RawStreamSet {
        constructor(dht) {
          this._dht = dht;
          this._prefix = 16 - 1;
          this._streams = /* @__PURE__ */ new Map();
        }
        get size() {
          return this._streams.size;
        }
        [Symbol.iterator]() {
          return this._streams.values();
        }
        add(opts) {
          const self2 = this;
          let id = 0;
          while (true) {
            id = Math.random() * 4294967296 >>> 0;
            if (this._streams.has(id & this._prefix)) continue;
            break;
          }
          if (2 * this._streams.size >= this._prefix) {
            this._prefix = 2 * this._prefix + 1;
            const next = /* @__PURE__ */ new Map();
            for (const stream2 of this._streams.values()) {
              next.set(stream2.id & this._prefix, stream2);
            }
            this._streams = next;
          }
          const stream = this._dht.udx.createStream(id, opts);
          this._streams.set(id & this._prefix, stream);
          stream.on("close", onclose);
          return stream;
          function onclose() {
            self2._streams.delete(id & self2._prefix);
          }
        }
        async clear() {
          const destroying = [];
          for (const stream of this._streams.values()) {
            destroying.push(new Promise((resolve) => stream.once("close", resolve).destroy()));
          }
          await Promise.allSettled(destroying);
        }
      };
    }
  });

  // ../../node_modules/hyperdht/lib/connection-pool.js
  var require_connection_pool = __commonJS({
    "../../node_modules/hyperdht/lib/connection-pool.js"(exports, module) {
      var EventEmitter = require_bare_node_events();
      var b4a = require_b4a();
      var errors = require_errors11();
      module.exports = class ConnectionPool extends EventEmitter {
        constructor(dht) {
          super();
          this._dht = dht;
          this._servers = /* @__PURE__ */ new Map();
          this._connecting = /* @__PURE__ */ new Map();
          this._connections = /* @__PURE__ */ new Map();
        }
        _attachServer(server) {
          const keyString = b4a.toString(server.publicKey, "hex");
          this._servers.set(keyString, server);
          server.on("close", () => {
            this._servers.delete(keyString);
          }).on("connection", (socket) => {
            this._attachStream(socket, true);
          });
        }
        _attachStream(stream, opened) {
          const existing = this.get(stream.remotePublicKey);
          if (existing) {
            const keepNew = stream.isInitiator === existing.isInitiator || b4a.compare(stream.publicKey, stream.remotePublicKey) > 0;
            if (keepNew) {
              let closed = false;
              const onclose = () => {
                closed = true;
              };
              existing.on("error", noop).on("close", () => {
                if (closed) return;
                stream.off("error", noop).off("close", onclose);
                this._attachStream(stream, opened);
              }).destroy(errors.DUPLICATE_CONNECTION());
              stream.on("error", noop).on("close", onclose);
            } else {
              stream.on("error", noop).destroy(errors.DUPLICATE_CONNECTION());
            }
            return;
          }
          const session = new ConnectionRef(this, stream);
          const keyString = b4a.toString(stream.remotePublicKey, "hex");
          if (opened) {
            this._connections.set(keyString, session);
            stream.on("close", () => {
              this._connections.delete(keyString);
            });
            this.emit("connection", stream, session);
          } else {
            this._connecting.set(keyString, session);
            stream.on("error", noop).on("close", () => {
              if (opened) this._connections.delete(keyString);
              else this._connecting.delete(keyString);
            }).on("open", () => {
              opened = true;
              this._connecting.delete(keyString);
              this._connections.set(keyString, session);
              stream.off("error", noop);
              this.emit("connection", stream, session);
            });
          }
          return session;
        }
        get connecting() {
          return this._connecting.size;
        }
        get connections() {
          return this._connections.values();
        }
        has(publicKey) {
          const keyString = b4a.toString(publicKey, "hex");
          return this._connections.has(keyString) || this._connecting.has(keyString);
        }
        get(publicKey) {
          const keyString = b4a.toString(publicKey, "hex");
          const existing = this._connections.get(keyString) || this._connecting.get(keyString);
          return existing?._stream || null;
        }
      };
      var ConnectionRef = class {
        constructor(pool, stream) {
          this._pool = pool;
          this._stream = stream;
          this._refs = 0;
        }
        active() {
          this._refs++;
        }
        inactive() {
          this._refs--;
        }
        release() {
          this._stream.destroy();
        }
      };
      function noop() {
      }
    }
  });

  // ../../node_modules/hyperdht/index.js
  var require_hyperdht = __commonJS({
    "../../node_modules/hyperdht/index.js"(exports, module) {
      var DHT = require_dht_rpc();
      var sodium = require_sodium_universal();
      var c = require_compact_encoding();
      var b4a = require_b4a();
      var safetyCatch = require_safety_catch();
      var m = require_messages3();
      var SocketPool = require_socket_pool();
      var Persistent = require_persistent();
      var Router = require_router();
      var Cache = require_xache();
      var Server = require_server();
      var connect = require_connect();
      var { FIREWALL, BOOTSTRAP_NODES, KNOWN_NODES, COMMANDS } = require_constants6();
      var { hash, createKeyPair } = require_crypto();
      var { decode } = require_hypercore_id_encoding();
      var RawStreamSet = require_raw_stream_set();
      var ConnectionPool = require_connection_pool();
      var { STREAM_NOT_CONNECTED } = require_errors11();
      var DEFAULTS = {
        ...DHT.DEFAULTS,
        connectionKeepAlive: 5e3,
        randomPunchInterval: 2e4
      };
      var HyperDHT = class extends DHT {
        constructor(opts = {}) {
          const port = opts.port || 49737;
          const bootstrap = opts.bootstrap || BOOTSTRAP_NODES;
          const nodes = opts.nodes || KNOWN_NODES;
          super({ ...opts, port, bootstrap, nodes, filterNode });
          const { router, relayAddresses, persistent } = defaultCacheOpts(opts);
          this.defaultKeyPair = opts.keyPair || createKeyPair(opts.seed);
          this.listening = /* @__PURE__ */ new Set();
          this.connectionKeepAlive = opts.connectionKeepAlive === false ? 0 : opts.connectionKeepAlive || DEFAULTS.connectionKeepAlive;
          this.stats = {
            punches: { consistent: 0, random: 0, open: 0 },
            relaying: { attempts: 0, successes: 0, aborts: 0 },
            ...this.stats
          };
          this.rawStreams = new RawStreamSet(this);
          this._router = new Router(this, router);
          this._socketPool = new SocketPool(this, opts.host || "0.0.0.0");
          this._persistent = null;
          this._validatedLocalAddresses = /* @__PURE__ */ new Map();
          this._relayAddressesCache = new Cache(relayAddresses);
          this._deferRandomPunch = !!opts.deferRandomPunch;
          this._lastRandomPunch = this._deferRandomPunch ? Date.now() : 0;
          this._connectable = true;
          this._randomPunchInterval = opts.randomPunchInterval || DEFAULTS.randomPunchInterval;
          this._randomPunches = 0;
          this._randomPunchLimit = 1;
          this.once("persistent", () => {
            this._persistent = new Persistent(this, persistent);
          });
          this.on("network-change", () => {
            for (const server of this.listening) server.refresh();
          });
          this.on("network-update", () => {
            if (!this.online) return;
            for (const server of this.listening) server.notifyOnline();
          });
        }
        static DEFAULTS = DEFAULTS;
        connect(remotePublicKey, opts) {
          return connect(this, decode(remotePublicKey), opts);
        }
        createServer(opts, onconnection) {
          if (typeof opts === "function") return this.createServer({}, opts);
          if (opts && opts.onconnection) onconnection = opts.onconnection;
          const s = new Server(this, opts);
          if (onconnection) s.on("connection", onconnection);
          return s;
        }
        pool() {
          return new ConnectionPool(this);
        }
        async resume({ log = noop } = {}) {
          if (this._deferRandomPunch) this._lastRandomPunch = Date.now();
          await super.resume({ log });
          const resuming = [];
          for (const server of this.listening) resuming.push(server.resume());
          log("Resuming hyperdht servers");
          await Promise.allSettled(resuming);
          log("Done, hyperdht fully resumed");
        }
        async suspend({ log = noop } = {}) {
          this._connectable = false;
          const suspending = [];
          for (const server of this.listening) suspending.push(server.suspend());
          log("Suspending all hyperdht servers");
          await Promise.allSettled(suspending);
          log("Done, clearing all raw streams");
          await this.rawStreams.clear();
          log("Done, suspending dht-rpc");
          await super.suspend({ log });
          log("Done, clearing raw streams again");
          await this.rawStreams.clear();
          log("Done, hyperdht fully suspended");
          this._connectable = true;
        }
        async destroy({ force = false } = {}) {
          if (!force) {
            const closing = [];
            for (const server of this.listening) closing.push(server.close());
            await Promise.allSettled(closing);
          }
          this._router.destroy();
          if (this._persistent) this._persistent.destroy();
          await this.rawStreams.clear();
          await this._socketPool.destroy();
          await super.destroy();
        }
        async validateLocalAddresses(addresses) {
          const list = [];
          const socks = [];
          const waiting = [];
          for (const addr of addresses) {
            const { host } = addr;
            if (this._validatedLocalAddresses.has(host)) {
              if (await this._validatedLocalAddresses.get(host)) {
                list.push(addr);
              }
              continue;
            }
            const sock = this.udx.createSocket();
            try {
              sock.bind(0, host);
            } catch {
              this._validatedLocalAddresses.set(host, Promise.resolve(false));
              continue;
            }
            socks.push(sock);
            const promise = new Promise((resolve) => {
              sock.on("message", () => resolve(true));
              setTimeout(() => resolve(false), 500);
              sock.trySend(b4a.alloc(1), sock.address().port, addr.host);
            });
            this._validatedLocalAddresses.set(host, promise);
            waiting.push(addr);
          }
          for (const addr of waiting) {
            const { host } = addr;
            if (this._validatedLocalAddresses.has(host)) {
              if (await this._validatedLocalAddresses.get(host)) {
                list.push(addr);
              }
              continue;
            }
          }
          for (const sock of socks) await sock.close();
          return list;
        }
        findPeer(publicKey, opts = {}) {
          const target = opts.hash === false ? publicKey : hash(publicKey);
          opts = { ...opts, map: mapFindPeer };
          return this.query({ target, command: COMMANDS.FIND_PEER, value: null }, opts);
        }
        lookup(target, opts = {}) {
          opts = { ...opts, map: mapLookup };
          return this.query({ target, command: COMMANDS.LOOKUP, value: null }, opts);
        }
        lookupAndUnannounce(target, keyPair, opts = {}) {
          const unannounces = [];
          const dht = this;
          const userCommit = opts.commit || noop;
          const signUnannounce = opts.signUnannounce || Persistent.signUnannounce;
          if (this._persistent !== null) {
            this._persistent.unannounce(target, keyPair.publicKey);
          }
          opts = { ...opts, map, commit };
          return this.query({ target, command: COMMANDS.LOOKUP, value: null }, opts);
          async function commit(reply, dht2, query) {
            await Promise.all(unannounces);
            return userCommit(reply, dht2, query);
          }
          function map(reply) {
            const data = mapLookup(reply);
            if (!data || !data.token) return data;
            let found = data.peers.length >= 20;
            for (let i = 0; !found && i < data.peers.length; i++) {
              found = b4a.equals(data.peers[i].publicKey, keyPair.publicKey);
            }
            if (!found) return data;
            if (!data.from.id) return data;
            unannounces.push(
              dht._requestUnannounce(keyPair, dht, target, data.token, data.from, signUnannounce).catch(safetyCatch)
            );
            return data;
          }
        }
        unannounce(target, keyPair, opts = {}) {
          return this.lookupAndUnannounce(target, keyPair, opts).finished();
        }
        announce(target, keyPair, relayAddresses, opts = {}) {
          const signAnnounce = opts.signAnnounce || Persistent.signAnnounce;
          const bump = opts.bump || 0;
          opts = { ...opts, commit };
          return opts.clear ? this.lookupAndUnannounce(target, keyPair, opts) : this.lookup(target, opts);
          function commit(reply, dht) {
            return dht._requestAnnounce(
              keyPair,
              dht,
              target,
              reply.token,
              reply.from,
              relayAddresses,
              signAnnounce,
              bump
            );
          }
        }
        async immutableGet(target, opts = {}) {
          opts = { ...opts, map: mapImmutable };
          const query = this.query({ target, command: COMMANDS.IMMUTABLE_GET, value: null }, opts);
          const check = b4a.allocUnsafe(32);
          for await (const node of query) {
            const { value } = node;
            sodium.crypto_generichash(check, value);
            if (b4a.equals(check, target)) return node;
          }
          return null;
        }
        async immutablePut(value, opts = {}) {
          const target = b4a.allocUnsafe(32);
          sodium.crypto_generichash(target, value);
          opts = {
            ...opts,
            map: mapImmutable,
            commit(reply, dht) {
              return dht.request(
                { token: reply.token, target, command: COMMANDS.IMMUTABLE_PUT, value },
                reply.from
              );
            }
          };
          const query = this.query({ target, command: COMMANDS.IMMUTABLE_GET, value: null }, opts);
          await query.finished();
          return { hash: target, closestNodes: query.closestNodes };
        }
        async mutableGet(publicKey, opts = {}) {
          let refresh = opts.refresh || null;
          let signed = null;
          let result = null;
          opts = { ...opts, map: mapMutable, commit: refresh ? commit : null };
          const target = b4a.allocUnsafe(32);
          sodium.crypto_generichash(target, publicKey);
          const userSeq = opts.seq || 0;
          const query = this.query(
            { target, command: COMMANDS.MUTABLE_GET, value: c.encode(c.uint, userSeq) },
            opts
          );
          const latest = opts.latest !== false;
          for await (const node of query) {
            if (result && node.seq <= result.seq) continue;
            if (node.seq < userSeq || !Persistent.verifyMutable(node.signature, node.seq, node.value, publicKey))
              continue;
            if (!latest) return node;
            if (!result || node.seq > result.seq) result = node;
          }
          return result;
          function commit(reply, dht) {
            if (!signed && result && refresh) {
              if (refresh(result)) {
                signed = c.encode(m.mutablePutRequest, {
                  publicKey,
                  seq: result.seq,
                  value: result.value,
                  signature: result.signature
                });
              } else {
                refresh = null;
              }
            }
            return signed ? dht.request(
              { token: reply.token, target, command: COMMANDS.MUTABLE_PUT, value: signed },
              reply.from
            ) : Promise.resolve(null);
          }
        }
        async mutablePut(keyPair, value, opts = {}) {
          const signMutable = opts.signMutable || Persistent.signMutable;
          const target = b4a.allocUnsafe(32);
          sodium.crypto_generichash(target, keyPair.publicKey);
          const seq = opts.seq || 0;
          const signature = await signMutable(seq, value, keyPair);
          const signed = c.encode(m.mutablePutRequest, {
            publicKey: keyPair.publicKey,
            seq,
            value,
            signature
          });
          opts = {
            ...opts,
            map: mapMutable,
            commit(reply, dht) {
              return dht.request(
                { token: reply.token, target, command: COMMANDS.MUTABLE_PUT, value: signed },
                reply.from
              );
            }
          };
          const query = this.query(
            { target, command: COMMANDS.MUTABLE_GET, value: c.encode(c.uint, 0) },
            opts
          );
          await query.finished();
          return { publicKey: keyPair.publicKey, closestNodes: query.closestNodes, seq, signature };
        }
        onrequest(req) {
          switch (req.command) {
            case COMMANDS.PEER_HANDSHAKE: {
              this._router.onpeerhandshake(req);
              return true;
            }
            case COMMANDS.PEER_HOLEPUNCH: {
              this._router.onpeerholepunch(req);
              return true;
            }
          }
          if (this._persistent === null || this.id === null) return false;
          switch (req.command) {
            case COMMANDS.FIND_PEER: {
              this._persistent.onfindpeer(req);
              return true;
            }
            case COMMANDS.LOOKUP: {
              this._persistent.onlookup(req);
              return true;
            }
            case COMMANDS.ANNOUNCE: {
              this._persistent.onannounce(req);
              return true;
            }
            case COMMANDS.UNANNOUNCE: {
              this._persistent.onunannounce(req);
              return true;
            }
            case COMMANDS.MUTABLE_PUT: {
              this._persistent.onmutableput(req);
              return true;
            }
            case COMMANDS.MUTABLE_GET: {
              this._persistent.onmutableget(req);
              return true;
            }
            case COMMANDS.IMMUTABLE_PUT: {
              this._persistent.onimmutableput(req);
              return true;
            }
            case COMMANDS.IMMUTABLE_GET: {
              this._persistent.onimmutableget(req);
              return true;
            }
          }
          return false;
        }
        static keyPair(seed) {
          return createKeyPair(seed);
        }
        static hash(data) {
          return hash(data);
        }
        static connectRawStream(encryptedStream, rawStream, remoteId) {
          const stream = encryptedStream.rawStream;
          if (!stream.connected) throw STREAM_NOT_CONNECTED();
          rawStream.connect(stream.socket, remoteId, stream.remotePort, stream.remoteHost);
        }
        createRawStream(opts) {
          return this.rawStreams.add(opts);
        }
        async _requestAnnounce(keyPair, dht, target, token, from, relayAddresses, sign, bump) {
          const ann = {
            peer: {
              publicKey: keyPair.publicKey,
              relayAddresses: relayAddresses || []
            },
            refresh: null,
            signature: null,
            bump
          };
          ann.signature = await sign(target, token, from.id, ann, keyPair);
          const value = c.encode(m.announce, ann);
          return dht.request(
            {
              token,
              target,
              command: COMMANDS.ANNOUNCE,
              value
            },
            from
          );
        }
        async _requestUnannounce(keyPair, dht, target, token, from, sign) {
          const unann = {
            peer: {
              publicKey: keyPair.publicKey,
              relayAddresses: []
            },
            signature: null
          };
          unann.signature = await sign(target, token, from.id, unann, keyPair);
          const value = c.encode(m.announce, unann);
          return dht.request(
            {
              token,
              target,
              command: COMMANDS.UNANNOUNCE,
              value
            },
            from
          );
        }
      };
      HyperDHT.BOOTSTRAP = BOOTSTRAP_NODES;
      HyperDHT.FIREWALL = FIREWALL;
      module.exports = HyperDHT;
      function mapLookup(node) {
        if (!node.value) return null;
        try {
          const l = c.decode(m.lookupRawReply, node.value);
          return {
            token: node.token,
            from: node.from,
            to: node.to,
            peers: l.peers,
            bump: l.bump
          };
        } catch {
          return null;
        }
      }
      function mapFindPeer(node) {
        if (!node.value) return null;
        try {
          return {
            token: node.token,
            from: node.from,
            to: node.to,
            peer: c.decode(m.peer, node.value)
          };
        } catch {
          return null;
        }
      }
      function mapImmutable(node) {
        if (!node.value) return null;
        return {
          token: node.token,
          from: node.from,
          to: node.to,
          value: node.value
        };
      }
      function mapMutable(node) {
        if (!node.value) return null;
        try {
          const { seq, value, signature } = c.decode(m.mutableGetResponse, node.value);
          return {
            token: node.token,
            from: node.from,
            to: node.to,
            seq,
            value,
            signature
          };
        } catch {
          return null;
        }
      }
      function noop() {
      }
      function filterNode(node) {
        return !(node.port === 49738 && (node.host === "134.209.28.98" || node.host === "167.99.142.185")) && !(node.port === 9400 && node.host === "35.233.47.252") && !(node.host === "150.136.142.116");
      }
      var defaultMaxSize = 65536;
      var defaultMaxAge = 20 * 60 * 1e3;
      function defaultCacheOpts(opts) {
        const maxSize = opts.maxSize || defaultMaxSize;
        const maxAge = opts.maxAge || defaultMaxAge;
        return {
          router: {
            forwards: { maxSize, maxAge }
          },
          relayAddresses: { maxSize: Math.min(maxSize, 512), maxAge: 0 },
          persistent: {
            records: { maxSize, maxAge },
            refreshes: { maxSize, maxAge },
            mutables: {
              maxSize: maxSize / 2 | 0,
              maxAge: opts.maxAge || 48 * 60 * 60 * 1e3
              // 48 hours
            },
            immutables: {
              maxSize: maxSize / 2 | 0,
              maxAge: opts.maxAge || 48 * 60 * 60 * 1e3
              // 48 hours
            },
            bumps: { maxSize, maxAge }
          }
        };
      }
    }
  });

  // ../../node_modules/unordered-set/index.js
  var require_unordered_set = __commonJS({
    "../../node_modules/unordered-set/index.js"(exports) {
      exports.add = add;
      exports.has = has;
      exports.remove = remove;
      exports.swap = swap;
      function add(list, item) {
        if (has(list, item)) return item;
        item._index = list.length;
        list.push(item);
        return item;
      }
      function has(list, item) {
        return item._index < list.length && list[item._index] === item;
      }
      function remove(list, item) {
        if (!has(list, item)) return null;
        var last = list.pop();
        if (last !== item) {
          list[item._index] = last;
          last._index = item._index;
        }
        return item;
      }
      function swap(list, a, b) {
        if (!has(list, a) || !has(list, b)) return;
        var tmp = a._index;
        a._index = b._index;
        list[a._index] = a;
        b._index = tmp;
        list[b._index] = b;
      }
    }
  });

  // ../../node_modules/shuffled-priority-queue/index.js
  var require_shuffled_priority_queue = __commonJS({
    "../../node_modules/shuffled-priority-queue/index.js"(exports, module) {
      var set = require_unordered_set();
      module.exports = (opts) => new ShuffledPriorityQueue(opts);
      var ShuffledPriorityQueue = class {
        constructor(opts) {
          this.priorities = [];
          this.equals = opts && opts.equals || null;
        }
        get length() {
          return this.priorities.reduce(add, 0);
        }
        [Symbol.iterator]() {
          return new Iterator(this);
        }
        head() {
          for (let i = this.priorities.length - 1; i >= 0; i--) {
            const q = this.priorities[i];
            if (q.length) return shuffle(q, 0);
          }
          return null;
        }
        tail() {
          for (let i = 0; i < this.priorities.length; i++) {
            const q = this.priorities[i];
            if (q.length) return shuffle(q, 0);
          }
          return null;
        }
        prev(prev) {
          if (!prev) return this.tail();
          return next(this.priorities, prev, 1);
        }
        next(prev) {
          if (!prev) return this.head();
          return next(this.priorities, prev, -1);
        }
        shift() {
          return this.remove(this.head());
        }
        pop() {
          return this.remove(this.tail());
        }
        add(val) {
          const prio = val.priority || 0;
          while (prio >= this.priorities.length) this.priorities.push([]);
          set.add(this.priorities[prio], val);
          return val;
        }
        remove(val) {
          if (!val) return null;
          if (val._index === void 0) {
            val = this.find(val);
            if (!val) return null;
          }
          return set.remove(this.priorities[val.priority || 0], val);
        }
        has(val) {
          if (val._index === void 0) return this.find(val);
          const priority = val.priority || 0;
          if (priority >= this.priorities.length) return false;
          return set.has(this.priorities[priority], val);
        }
        find(val) {
          if (val._index !== void 0) return val;
          const prio = val.priority || 0;
          const qs = this.priorities;
          if (prio >= qs.length) return null;
          const q = qs[prio];
          for (let i = 0; i < q.length; i++) {
            if (this.equals(q[i], val)) return q[i];
          }
          return null;
        }
      };
      var Iterator = class {
        constructor(queue) {
          this.prev = null;
          this.queue = queue;
        }
        next() {
          const next2 = this.queue.next(this.prev);
          this.prev = next2;
          return { done: !next2, value: next2 };
        }
      };
      function shuffle(q, i) {
        const ran = i + Math.floor(Math.random() * (q.length - i));
        set.swap(q, q[ran], q[i]);
        return q[i];
      }
      function next(queues, prev, inc) {
        let i = prev.priority || 0;
        let j = (prev._index || 0) + 1;
        while (true) {
          if (i < 0 || i >= queues.length) return null;
          const q = queues[i];
          if (j >= q.length) {
            i += inc;
            j = 0;
            continue;
          }
          return shuffle(q, j);
        }
      }
      function add(len, b) {
        return len + b.length;
      }
    }
  });

  // ../../node_modules/hyperswarm/lib/peer-info.js
  var require_peer_info = __commonJS({
    "../../node_modules/hyperswarm/lib/peer-info.js"(exports, module) {
      var { EventEmitter } = require_bare_node_events();
      var b4a = require_b4a();
      var unslab = require_unslab();
      var MIN_CONNECTION_TIME = 15e3;
      var VERY_LOW_PRIORITY = 0;
      var LOW_PRIORITY = 1;
      var NORMAL_PRIORITY = 2;
      var HIGH_PRIORITY = 3;
      var VERY_HIGH_PRIORITY = 4;
      module.exports = class PeerInfo extends EventEmitter {
        constructor({ publicKey, relayAddresses }) {
          super();
          this.publicKey = unslab(publicKey);
          this.relayAddresses = relayAddresses;
          this.reconnecting = true;
          this.proven = false;
          this.connectedTime = -1;
          this.disconnectedTime = 0;
          this.banned = false;
          this.tried = false;
          this.explicit = false;
          this.waiting = false;
          this.forceRelaying = false;
          this.queued = false;
          this.client = false;
          this.topics = [];
          this.attempts = 0;
          this.priority = NORMAL_PRIORITY;
          this._index = 0;
          this._flushTick = 0;
          this._seenTopics = /* @__PURE__ */ new Set();
        }
        get server() {
          return !this.client;
        }
        get prioritized() {
          return this.priority >= NORMAL_PRIORITY;
        }
        _getPriority() {
          const peerIsStale = this.tried && !this.proven;
          if (peerIsStale || this.attempts > 3) return VERY_LOW_PRIORITY;
          if (this.attempts === 3) return LOW_PRIORITY;
          if (this.attempts === 2) return HIGH_PRIORITY;
          if (this.attempts === 1) return VERY_HIGH_PRIORITY;
          return NORMAL_PRIORITY;
        }
        _connected() {
          this.proven = true;
          this.connectedTime = Date.now();
        }
        _disconnected() {
          this.disconnectedTime = Date.now();
          if (this.connectedTime > -1) {
            if (this.disconnectedTime - this.connectedTime >= MIN_CONNECTION_TIME) this.attempts = 0;
            this.connectedTime = -1;
          }
          this.attempts++;
        }
        _deprioritize() {
          this.attempts = 3;
        }
        _reset() {
          this.client = false;
          this.proven = false;
          this.tried = false;
          this.attempts = 0;
        }
        _updatePriority() {
          if (this.explicit && this.attempts > 3) this._deprioritize();
          if (this.banned || this.queued || this.attempts > 3) return false;
          this.priority = this._getPriority();
          return true;
        }
        _topic(topic) {
          const topicString = b4a.toString(topic, "hex");
          if (this._seenTopics.has(topicString)) return;
          this._seenTopics.add(topicString);
          this.topics.push(topic);
          this.emit("topic", topic);
        }
        reconnect(val) {
          this.reconnecting = !!val;
        }
        ban(val) {
          this.banned = !!val;
        }
        shouldGC() {
          return !(this.banned || this.queued || this.explicit || this.waiting);
        }
      };
    }
  });

  // ../../node_modules/hyperswarm/lib/bulk-timer.js
  var require_bulk_timer = __commonJS({
    "../../node_modules/hyperswarm/lib/bulk-timer.js"(exports, module) {
      module.exports = class BulkTimer {
        constructor(time, fn) {
          this._time = time;
          this._fn = fn;
          this._interval = null;
          this._next = [];
          this._pending = [];
          this._destroyed = false;
        }
        destroy() {
          if (this._destroyed) return;
          this._destroyed = true;
          clearInterval(this._interval);
          this._interval = null;
        }
        _ontick() {
          if (!this._next.length && !this._pending.length) return;
          if (this._next.length) this._fn(this._next);
          this._next = this._pending;
          this._pending = [];
        }
        add(info) {
          if (this._destroyed) return;
          if (!this._interval) {
            this._interval = setInterval(this._ontick.bind(this), Math.floor(this._time * 0.66));
          }
          this._pending.push(info);
        }
      };
    }
  });

  // ../../node_modules/hyperswarm/lib/retry-timer.js
  var require_retry_timer = __commonJS({
    "../../node_modules/hyperswarm/lib/retry-timer.js"(exports, module) {
      var BulkTimer = require_bulk_timer();
      var BACKOFF_JITTER = 500;
      var BACKOFF_S = 1e3 + Math.round(BACKOFF_JITTER * Math.random());
      var BACKOFF_M = 5e3 + Math.round(2 * BACKOFF_JITTER * Math.random());
      var BACKOFF_L = 15e3 + Math.round(4 * BACKOFF_JITTER * Math.random());
      var BACKOFF_X = 1e3 * 60 * 10 + Math.round(240 * BACKOFF_JITTER * Math.random());
      module.exports = class RetryTimer {
        constructor(push, { backoffs = [BACKOFF_S, BACKOFF_M, BACKOFF_L, BACKOFF_X], jitter = BACKOFF_JITTER } = {}) {
          this.jitter = jitter;
          this.backoffs = backoffs;
          this._sTimer = new BulkTimer(backoffs[0] + Math.round(jitter * Math.random()), push);
          this._mTimer = new BulkTimer(backoffs[1] + Math.round(jitter * Math.random()), push);
          this._lTimer = new BulkTimer(backoffs[2] + Math.round(jitter * Math.random()), push);
          this._xTimer = new BulkTimer(backoffs[3] + Math.round(jitter * Math.random()), push);
        }
        _selectRetryTimer(peerInfo) {
          if (peerInfo.banned || !peerInfo.reconnecting) return null;
          if (peerInfo.attempts > 3) {
            return peerInfo.explicit ? this._xTimer : null;
          }
          if (peerInfo.attempts === 0) return this._sTimer;
          if (peerInfo.proven) {
            switch (peerInfo.attempts) {
              case 1:
                return this._sTimer;
              case 2:
                return this._mTimer;
              case 3:
                return this._lTimer;
            }
          } else {
            switch (peerInfo.attempts) {
              case 1:
                return this._mTimer;
              case 2:
                return this._lTimer;
              case 3:
                return this._lTimer;
            }
          }
          return null;
        }
        add(peerInfo) {
          const timer = this._selectRetryTimer(peerInfo);
          if (!timer) return false;
          timer.add(peerInfo);
          return true;
        }
        destroy() {
          this._sTimer.destroy();
          this._mTimer.destroy();
          this._lTimer.destroy();
          this._xTimer.destroy();
        }
      };
    }
  });

  // ../../node_modules/hyperswarm/lib/connection-set.js
  var require_connection_set = __commonJS({
    "../../node_modules/hyperswarm/lib/connection-set.js"(exports, module) {
      var b4a = require_b4a();
      module.exports = class ConnectionSet {
        constructor() {
          this._byPublicKey = /* @__PURE__ */ new Map();
        }
        [Symbol.iterator]() {
          return this._byPublicKey.values();
        }
        get size() {
          return this._byPublicKey.size;
        }
        has(publicKey) {
          return this._byPublicKey.has(toHex(publicKey));
        }
        get(publicKey) {
          return this._byPublicKey.get(toHex(publicKey));
        }
        add(connection) {
          this._byPublicKey.set(b4a.toString(connection.remotePublicKey, "hex"), connection);
        }
        delete(connection) {
          const keyString = b4a.toString(connection.remotePublicKey, "hex");
          const existing = this._byPublicKey.get(keyString);
          if (existing !== connection) return;
          this._byPublicKey.delete(keyString);
        }
      };
      function toHex(b) {
        return typeof b === "string" ? b : b4a.toString(b, "hex");
      }
    }
  });

  // ../../node_modules/hyperswarm/lib/peer-discovery.js
  var require_peer_discovery = __commonJS({
    "../../node_modules/hyperswarm/lib/peer-discovery.js"(exports, module) {
      var safetyCatch = require_safety_catch();
      var b4a = require_b4a();
      var REFRESH_INTERVAL = 1e3 * 60 * 10;
      var RANDOM_JITTER = 1e3 * 60 * 2;
      var DELAY_GRACE_PERIOD = 1e3 * 30;
      var MAX_DISCOVERY_CACHE = 64;
      module.exports = class PeerDiscovery {
        constructor(swarm, topic, { limit = Infinity, wait = null, suspended = false, onpeer = noop, onerror = safetyCatch }) {
          this.limit = limit;
          this.swarm = swarm;
          this.topic = topic;
          this.isClient = false;
          this.isServer = false;
          this.destroyed = false;
          this.destroying = null;
          this.suspended = suspended;
          this._sessions = [];
          this._clientSessions = 0;
          this._serverSessions = 0;
          this._onpeer = onpeer;
          this._onerror = onerror;
          this._discovered = /* @__PURE__ */ new Set();
          this._activeQuery = null;
          this._timer = null;
          this._currentRefresh = null;
          this._closestNodes = null;
          this._firstAnnounce = true;
          this._needsUnannounce = false;
          this._refreshes = 0;
          this._wait = wait;
        }
        session({ server = true, client = true, limit = Infinity, onerror = safetyCatch }) {
          if (this.destroyed) throw new Error("PeerDiscovery is destroyed");
          const session = new PeerDiscoverySession(this);
          session.refresh({ server, client, limit }).catch(onerror);
          this._sessions.push(session);
          return session;
        }
        _refreshLater(eager) {
          const jitter = Math.round(Math.random() * RANDOM_JITTER);
          const delay = !eager ? REFRESH_INTERVAL + jitter : jitter;
          if (this._timer) clearTimeout(this._timer);
          const startTime = Date.now();
          this._timer = setTimeout(() => {
            const overdue = Date.now() - startTime > delay + DELAY_GRACE_PERIOD;
            if (overdue) this._refreshLater(true);
            else this.refresh().catch(this._onerror);
          }, delay);
        }
        _isActive() {
          return !this.destroyed && !this.suspended;
        }
        // NOTE: Allow announce to be an argument to this
        // NOTE: Maybe announce should be a setter?
        async _refresh() {
          if (this.suspended) return;
          const clock = ++this._refreshes;
          if (this._wait) {
            await this._wait;
            this._wait = null;
            if (clock !== this._refreshes || !this._isActive()) return;
          }
          const clear = this.isServer && this._firstAnnounce;
          if (clear) this._firstAnnounce = false;
          const opts = {
            clear,
            closestNodes: this._closestNodes
          };
          if (this.isServer) {
            await this.swarm.listen();
            if (clock !== this._refreshes || !this._isActive()) return;
            this._needsUnannounce = true;
          }
          let limit = this.limit;
          if (limit < Infinity && limit > 0) {
            for (const id of this._discovered) {
              if (!this.swarm.connections.has(id)) continue;
              if (--limit === 0) break;
            }
          }
          this._discovered.clear();
          const announcing = this.isServer;
          const query = this._activeQuery = announcing ? this.swarm.dht.announce(
            this.topic,
            this.swarm.keyPair,
            this.swarm.server.relayAddresses,
            opts
          ) : this._needsUnannounce ? this.swarm.dht.lookupAndUnannounce(this.topic, this.swarm.keyPair, opts) : this.swarm.dht.lookup(this.topic, opts);
          try {
            for await (const data of this._activeQuery) {
              if (!this.isClient || !this._isActive()) continue;
              for (const peer of data.peers) {
                if (limit < Infinity) {
                  const id = b4a.toString(peer.publicKey, "hex");
                  if (this._discovered.size < MAX_DISCOVERY_CACHE) {
                    this._discovered.add(id);
                  }
                  if (limit === 0) continue;
                  if (!this.swarm.connections.has(id)) limit--;
                }
                this._onpeer(peer, data);
              }
            }
          } catch (err) {
            if (this._isActive()) throw err;
          } finally {
            if (this._activeQuery === query) {
              this._activeQuery = null;
              if (!this.destroyed && !this.suspended) this._refreshLater(false);
            }
          }
          this._closestNodes = query.closestNodes;
          if (clock !== this._refreshes) return;
          if (!announcing) this._needsUnannounce = false;
        }
        async refresh() {
          if (this.destroyed) throw new Error("PeerDiscovery is destroyed");
          const server = this._serverSessions > 0;
          const client = this._clientSessions > 0;
          if (this.suspended) return;
          if (server === this.isServer && client === this.isClient) {
            if (this._currentRefresh) return this._currentRefresh;
            this._currentRefresh = this._refresh();
          } else {
            if (this._activeQuery) this._activeQuery.destroy();
            this.isServer = server;
            this.isClient = client;
            this._currentRefresh = this._refresh();
          }
          const refresh = this._currentRefresh;
          try {
            await refresh;
          } catch {
            return false;
          } finally {
            if (refresh === this._currentRefresh) {
              this._currentRefresh = null;
            }
          }
          return true;
        }
        async flushed() {
          if (this.swarm.listening) await this.swarm.listening;
          try {
            await this._currentRefresh;
            return true;
          } catch {
            return false;
          }
        }
        async _destroyMaybe() {
          if (this.destroyed) return;
          try {
            if (this._sessions.length === 0) await this.swarm.leave(this.topic);
            else if (this._serverSessions === 0 && this._needsUnannounce) await this.refresh();
          } catch (err) {
            safetyCatch(err);
          }
        }
        destroy() {
          if (this.destroying) return this.destroying;
          this.destroying = this._destroy();
          return this.destroying;
        }
        async _abort(log) {
          const id = log === noop ? "" : b4a.toString(this.topic, "hex");
          log("Aborting discovery", id);
          if (this._wait) await this._wait;
          log("Aborting discovery (post wait)", id);
          if (this._activeQuery) {
            this._activeQuery.destroy();
            this._activeQuery = null;
          }
          if (this._timer) {
            clearTimeout(this._timer);
            this._timer = null;
          }
          let nodes = this._closestNodes;
          if (this._currentRefresh) {
            try {
              await this._currentRefresh;
            } catch {
            }
          }
          log("Aborting discovery (post refresh)", id);
          if (this._isActive()) return;
          if (!nodes) nodes = this._closestNodes;
          else if (this._closestNodes !== nodes) {
            const len = nodes.length;
            for (const newer of this._closestNodes) {
              if (newer.id && !hasNode(nodes, len, newer)) nodes.push(newer);
            }
          }
          if (this._needsUnannounce) {
            log("Unannouncing discovery", id);
            if (nodes && nodes.length) {
              await this.swarm.dht.unannounce(this.topic, this.swarm.keyPair, {
                closestNodes: nodes,
                onlyClosestNodes: true,
                force: true
              });
            }
            this._needsUnannounce = false;
            log("Unannouncing discovery (done)", id);
          }
        }
        _destroy() {
          if (this.destroyed) return;
          this.destroyed = true;
          return this._abort(noop);
        }
        async suspend({ log = noop } = {}) {
          if (this.suspended) return;
          this.suspended = true;
          try {
            await this._abort(log);
          } catch {
          }
        }
        resume() {
          if (!this.suspended) return;
          this.suspended = false;
          this.refresh().catch(noop);
        }
      };
      var PeerDiscoverySession = class {
        constructor(discovery) {
          this.discovery = discovery;
          this.isClient = false;
          this.isServer = false;
          this.destroyed = false;
        }
        get swarm() {
          return this.discovery.swarm;
        }
        get topic() {
          return this.discovery.topic;
        }
        async refresh({ client = this.isClient, server = this.isServer, limit = Infinity } = {}) {
          if (this.destroyed) throw new Error("PeerDiscovery is destroyed");
          if (!client && !server) throw new Error("Cannot refresh with neither client nor server option");
          if (client !== this.isClient) {
            this.isClient = client;
            this.discovery._clientSessions += client ? 1 : -1;
          }
          if (server !== this.isServer) {
            this.isServer = server;
            this.discovery._serverSessions += server ? 1 : -1;
          }
          this.discovery.limit = limit;
          return this.discovery.refresh();
        }
        async flushed() {
          return this.discovery.flushed();
        }
        async destroy() {
          if (this.destroyed) return;
          this.destroyed = true;
          if (this.isClient) this.discovery._clientSessions--;
          if (this.isServer) this.discovery._serverSessions--;
          const index = this.discovery._sessions.indexOf(this);
          const head = this.discovery._sessions.pop();
          if (head !== this) this.discovery._sessions[index] = head;
          return this.discovery._destroyMaybe();
        }
      };
      function hasNode(nodes, len, node) {
        for (let i = 0; i < len; i++) {
          const existing = nodes[i];
          if (existing.id && b4a.equals(existing.id, node.id)) return true;
        }
        return false;
      }
      function noop() {
      }
    }
  });

  // ../../node_modules/hyperswarm/index.js
  var require_hyperswarm = __commonJS({
    "../../node_modules/hyperswarm/index.js"(exports, module) {
      var { EventEmitter } = require_bare_node_events();
      var { getStreamError } = require_streamx();
      var DHT = require_hyperdht();
      var spq = require_shuffled_priority_queue();
      var b4a = require_b4a();
      var unslab = require_unslab();
      var PeerInfo = require_peer_info();
      var RetryTimer = require_retry_timer();
      var ConnectionSet = require_connection_set();
      var PeerDiscovery = require_peer_discovery();
      var MAX_PEERS = 64;
      var MAX_PARALLEL = 3;
      var MAX_CLIENT_CONNECTIONS = Infinity;
      var MAX_SERVER_CONNECTIONS = Infinity;
      var ERR_MISSING_TOPIC = "Topic is required and must be a 32-byte buffer";
      var ERR_DESTROYED = "Swarm has been destroyed";
      var ERR_DUPLICATE = "Duplicate connection";
      var ERR_FIREWALL = "Peer is firewalled";
      module.exports = class Hyperswarm extends EventEmitter {
        constructor(opts = {}) {
          super();
          const {
            seed,
            relayThrough,
            keyPair = DHT.keyPair(seed),
            maxPeers = MAX_PEERS,
            maxClientConnections = MAX_CLIENT_CONNECTIONS,
            maxServerConnections = MAX_SERVER_CONNECTIONS,
            maxParallel = MAX_PARALLEL,
            firewall = allowAll
          } = opts;
          this.keyPair = keyPair;
          this.dht = opts.dht || new DHT({
            bootstrap: opts.bootstrap,
            nodes: opts.nodes,
            port: opts.port,
            deferRandomPunch: opts.deferRandomPunch,
            randomPunchInterval: opts.randomPunchInterval
          });
          this.server = this.dht.createServer(
            {
              firewall: this._handleFirewall.bind(this),
              relayThrough: this._maybeRelayConnection.bind(this),
              handshakeClearWait: opts.handshakeClearWait
            },
            this._handleServerConnection.bind(this)
          );
          this.destroyed = false;
          this.suspended = false;
          this.maxPeers = maxPeers;
          this.maxClientConnections = maxClientConnections;
          this.maxServerConnections = maxServerConnections;
          this.maxParallel = maxParallel;
          this.relayThrough = relayThrough ? toRelayFunction(relayThrough) : null;
          this.connecting = 0;
          this.connections = /* @__PURE__ */ new Set();
          this.peers = /* @__PURE__ */ new Map();
          this.explicitPeers = /* @__PURE__ */ new Set();
          this.listening = null;
          this.stats = {
            updates: 0,
            connects: {
              client: {
                opened: 0,
                closed: 0,
                attempted: 0
              },
              server: {
                // Note: there is no notion of 'attempts' for server connections
                opened: 0,
                closed: 0
              }
            },
            bannedPeers: 0
          };
          this._discovery = /* @__PURE__ */ new Map();
          this._timer = new RetryTimer(this._requeue.bind(this), {
            backoffs: opts.backoffs,
            jitter: opts.jitter
          });
          this._queue = spq();
          this._allConnections = new ConnectionSet();
          this._pendingFlushes = [];
          this._flushTick = 0;
          this._drainingQueue = false;
          this._clientConnections = 0;
          this._serverConnections = 0;
          this._firewall = firewall;
          this.dht.on("network-change", this._handleNetworkChange.bind(this));
          this.dht.on("network-update", this._handleNetworkUpdate.bind(this));
          this.on("update", this._handleUpdate);
        }
        _maybeRelayConnection(force) {
          if (!this.relayThrough) return null;
          return this.relayThrough(force, this);
        }
        _enqueue(peerInfo) {
          if (peerInfo.queued) return;
          peerInfo.queued = true;
          peerInfo._flushTick = this._flushTick;
          this._queue.add(peerInfo);
          this._attemptClientConnections();
        }
        _requeue(batch) {
          if (this.suspended) return;
          for (const peerInfo of batch) {
            peerInfo.waiting = false;
            if (peerInfo._updatePriority() === false || this._allConnections.has(peerInfo.publicKey) || peerInfo.queued) {
              continue;
            }
            peerInfo.queued = true;
            peerInfo._flushTick = this._flushTick;
            this._queue.add(peerInfo);
          }
          this._attemptClientConnections();
        }
        _flushMaybe(peerInfo) {
          for (let i = 0; i < this._pendingFlushes.length; i++) {
            const flush = this._pendingFlushes[i];
            if (peerInfo._flushTick > flush.tick) continue;
            if (--flush.missing > 0) continue;
            flush.onflush(true);
            this._pendingFlushes.splice(i--, 1);
          }
        }
        _withinMaxPeers() {
          const e = this.explicitPeers.size;
          const factor = e === 0 ? 1 : e < 2 ? 2 : e < 4 ? 3 : 4;
          return factor * this._allConnections.size < this.maxPeers;
        }
        _flushAllMaybe() {
          if (this.connecting > 0 || this._withinMaxPeers() && this._clientConnections < this.maxClientConnections) {
            return false;
          }
          while (this._pendingFlushes.length) {
            const flush = this._pendingFlushes.pop();
            flush.onflush(true);
          }
          return true;
        }
        _shouldConnectExplicit() {
          return !this.destroyed && !this.suspended && this.connecting < this.maxParallel;
        }
        _shouldConnect() {
          return !this.destroyed && !this.suspended && this.connecting < this.maxParallel && this._withinMaxPeers() && this._clientConnections < this.maxClientConnections;
        }
        _shouldRequeue(peerInfo) {
          if (this.suspended) return false;
          if (peerInfo.explicit) return true;
          for (const topic of peerInfo.topics) {
            if (this._discovery.has(b4a.toString(topic, "hex")) && !this.destroyed) {
              return true;
            }
          }
          return false;
        }
        _connect(peerInfo, queued) {
          if (peerInfo.banned || this._allConnections.has(peerInfo.publicKey)) {
            if (queued) this._flushMaybe(peerInfo);
            return;
          }
          if (this._handleFirewall(peerInfo.publicKey, null)) {
            if (queued) this._flushMaybe(peerInfo);
            return;
          }
          const relayThrough = this._maybeRelayConnection(peerInfo.forceRelaying);
          const conn = this.dht.connect(peerInfo.publicKey, {
            relayAddresses: peerInfo.relayAddresses,
            keyPair: this.keyPair,
            relayThrough
          });
          this._allConnections.add(conn);
          this.stats.connects.client.attempted++;
          this.connecting++;
          this._clientConnections++;
          let opened = false;
          const onerror = (err) => {
            if (this.relayThrough && shouldForceRelaying(err.code)) {
              peerInfo.forceRelaying = true;
              peerInfo.attempts = 0;
            }
          };
          conn.on("error", onerror);
          conn.on("open", () => {
            opened = true;
            this.stats.connects.client.opened++;
            this._connectDone();
            this.connections.add(conn);
            conn.removeListener("error", onerror);
            peerInfo._connected();
            peerInfo.client = true;
            this.emit("connection", conn, peerInfo);
            if (queued) this._flushMaybe(peerInfo);
            this.emit("update");
          });
          conn.on("close", () => {
            if (!opened) this._connectDone();
            this.stats.connects.client.closed++;
            const err = getStreamError(conn);
            if (shouldBan(err)) {
              this._banPeer(peerInfo, true, err);
            }
            this.connections.delete(conn);
            this._allConnections.delete(conn);
            this._clientConnections--;
            peerInfo._disconnected();
            peerInfo.waiting = this._shouldRequeue(peerInfo) && this._timer.add(peerInfo);
            this._maybeDeletePeer(peerInfo);
            if (!opened && queued) this._flushMaybe(peerInfo);
            this._attemptClientConnections();
            this.emit("update");
          });
          this.emit("update");
        }
        _connectDone() {
          this.connecting--;
          if (this.connecting < this.maxParallel) this._attemptClientConnections();
          if (this.connecting === 0) this._flushAllMaybe();
        }
        // Called when the PeerQueue indicates a connection should be attempted.
        _attemptClientConnections() {
          if (this._drainingQueue || this.suspended) return;
          this._drainingQueue = true;
          for (const peerInfo of this.explicitPeers) {
            if (!this._shouldConnectExplicit()) break;
            if (peerInfo.attempts >= 5 || Date.now() - peerInfo.disconnectedTime < peerInfo.attempts * 1e3) {
              continue;
            }
            this._connect(peerInfo, false);
          }
          while (this._queue.length && this._shouldConnect()) {
            const peerInfo = this._queue.shift();
            peerInfo.queued = false;
            this._connect(peerInfo, true);
          }
          this._drainingQueue = false;
          if (this.connecting === 0) this._flushAllMaybe();
        }
        _handleFirewall(remotePublicKey, payload) {
          if (b4a.equals(remotePublicKey, this.keyPair.publicKey)) return true;
          let peerInfo = this.peers.get(b4a.toString(remotePublicKey, "hex"));
          if (peerInfo && peerInfo.banned) return true;
          const firewalled = this._firewall(remotePublicKey, payload);
          if (firewalled) {
            if (!peerInfo) peerInfo = this._upsertPeer(remotePublicKey);
            this._banPeer(peerInfo, true, new Error(ERR_FIREWALL));
          }
          return firewalled;
        }
        _handleServerConnectionSwap(existing, conn) {
          let closed = false;
          existing.on("close", () => {
            if (closed) return;
            conn.removeListener("error", noop);
            conn.removeListener("close", onclose);
            this._handleServerConnection(conn);
          });
          conn.on("error", noop);
          conn.on("close", onclose);
          function onclose() {
            closed = true;
          }
        }
        // Called when the DHT receives a new server connection.
        _handleServerConnection(conn) {
          if (this.destroyed || this.suspended) {
            conn.on("error", noop);
            return conn.destroy(ERR_DESTROYED);
          }
          const existing = this._allConnections.get(conn.remotePublicKey);
          if (existing) {
            const existingIsOutdated = existing.rawBytesRead > 0 && existing.rawBytesWritten > 0;
            const expectedInitiator = b4a.compare(conn.publicKey, conn.remotePublicKey) > 0;
            const keepNew = existingIsOutdated || expectedInitiator === conn.isInitiator;
            if (keepNew === false) {
              existing.sendKeepAlive();
              conn.on("error", noop);
              conn.destroy(new Error(ERR_DUPLICATE));
              return;
            }
            existing.on("error", noop);
            existing.destroy(new Error(ERR_DUPLICATE));
            this._handleServerConnectionSwap(existing, conn);
            return;
          }
          this.stats.connects.server.opened++;
          const peerInfo = this._upsertPeer(conn.remotePublicKey, null);
          this.connections.add(conn);
          this._allConnections.add(conn);
          this._serverConnections++;
          conn.on("close", () => {
            const err = getStreamError(conn);
            if (shouldBan(err)) {
              this._banPeer(peerInfo, true, err);
            }
            this.connections.delete(conn);
            this._allConnections.delete(conn);
            this._serverConnections--;
            this.stats.connects.server.closed++;
            this._maybeDeletePeer(peerInfo);
            this._attemptClientConnections();
            this.emit("update");
          });
          peerInfo.client = false;
          this.emit("connection", conn, peerInfo);
          this.emit("update");
        }
        _upsertPeer(publicKey, relayAddresses) {
          if (b4a.equals(publicKey, this.keyPair.publicKey)) return null;
          const keyString = b4a.toString(publicKey, "hex");
          let peerInfo = this.peers.get(keyString);
          if (peerInfo) {
            peerInfo.relayAddresses = relayAddresses;
            return peerInfo;
          }
          peerInfo = new PeerInfo({
            publicKey,
            relayAddresses
          });
          this.peers.set(keyString, peerInfo);
          return peerInfo;
        }
        _handleUpdate() {
          this.stats.updates++;
        }
        _maybeDeletePeer(peerInfo) {
          if (!peerInfo.shouldGC()) return;
          const hasActiveConn = this._allConnections.has(peerInfo.publicKey);
          if (hasActiveConn) return;
          const keyString = b4a.toString(peerInfo.publicKey, "hex");
          this.peers.delete(keyString);
        }
        /*
         * Called when a peer is actively discovered during a lookup.
         *
         * Three conditions:
         *  1. Not a known peer -- insert into queue
         *  2. A known peer with normal priority -- do nothing
         *  3. A known peer with low priority -- bump priority, because it's been rediscovered
         */
        _handlePeer(peer, topic) {
          const peerInfo = this._upsertPeer(peer.publicKey, peer.relayAddresses);
          if (peerInfo) peerInfo._topic(topic);
          if (!peerInfo || this._allConnections.has(peer.publicKey)) return;
          if (!peerInfo.prioritized || peerInfo.server) peerInfo._reset();
          if (peerInfo._updatePriority()) {
            this._enqueue(peerInfo);
          }
        }
        async _handleNetworkUpdate() {
          if (!this.online) return;
          this._handleNetworkChange();
        }
        async _handleNetworkChange() {
          if (this.suspended) return;
          for (const conn of this._allConnections) {
            conn.sendKeepAlive();
          }
          const refreshes = [];
          for (const discovery of this._discovery.values()) {
            refreshes.push(discovery.refresh());
          }
          await Promise.allSettled(refreshes);
        }
        _banPeer(peerInfo, banned, err) {
          peerInfo.ban(banned);
          this.stats.bannedPeers++;
          this.emit("ban", peerInfo, err);
        }
        status(key) {
          return this._discovery.get(b4a.toString(key, "hex")) || null;
        }
        listen() {
          if (!this.listening) {
            if (this.destroyed) throw new Error("Swarm destroyed");
            this.listening = this.server.listen(this.keyPair);
          }
          return this.listening;
        }
        // Object that exposes a cancellation method (destroy)
        // NOTE: When you rejoin, it should reannounce + bump lookup priority
        join(topic, opts = {}) {
          if (this.destroyed) throw new Error("Swarm destroyed");
          if (!topic) throw new Error(ERR_MISSING_TOPIC);
          topic = unslab(topic);
          const topicString = b4a.toString(topic, "hex");
          let discovery = this._discovery.get(topicString);
          if (discovery && !discovery.destroyed) {
            return discovery.session(opts);
          }
          discovery = new PeerDiscovery(this, topic, {
            limit: opts.limit,
            wait: discovery ? discovery.destroy() : null,
            suspended: this.suspended,
            onpeer: (peer) => this._handlePeer(peer, topic)
          });
          this._discovery.set(topicString, discovery);
          return discovery.session(opts);
        }
        // Returns a promise
        async leave(topic) {
          if (!topic) throw new Error(ERR_MISSING_TOPIC);
          const topicString = b4a.toString(topic, "hex");
          if (!this._discovery.has(topicString)) return Promise.resolve();
          const discovery = this._discovery.get(topicString);
          try {
            await discovery.destroy();
          } catch {
          }
          if (this._discovery.get(topicString) === discovery) {
            this._discovery.delete(topicString);
          }
        }
        joinPeer(publicKey) {
          const peerInfo = this._upsertPeer(publicKey, null);
          if (!peerInfo) return;
          if (!this.explicitPeers.has(peerInfo)) {
            peerInfo.explicit = true;
            this.explicitPeers.add(peerInfo);
          }
          if (this._allConnections.has(publicKey)) return;
          if (peerInfo._updatePriority()) {
            this._enqueue(peerInfo);
          }
        }
        leavePeer(publicKey) {
          const keyString = b4a.toString(publicKey, "hex");
          if (!this.peers.has(keyString)) return;
          const peerInfo = this.peers.get(keyString);
          peerInfo.explicit = false;
          this.explicitPeers.delete(peerInfo);
          this._maybeDeletePeer(peerInfo);
        }
        // Returns a promise
        async flush() {
          const allFlushed = [...this._discovery.values()].map((v) => v.flushed());
          await Promise.all(allFlushed);
          if (this._flushAllMaybe()) return true;
          const pendingSize = this._allConnections.size - this.connections.size;
          if (!this._queue.length && !pendingSize) return true;
          return new Promise((resolve) => {
            this._pendingFlushes.push({
              onflush: resolve,
              missing: this._queue.length + pendingSize,
              tick: this._flushTick++
            });
          });
        }
        async clear() {
          const cleared = Promise.allSettled([...this._discovery.values()].map((d) => d.destroy()));
          this._discovery.clear();
          return cleared;
        }
        async destroy({ force } = {}) {
          if (this.destroyed && !force) return;
          this.destroyed = true;
          this._timer.destroy();
          if (!force) await this.clear();
          await this.server.close();
          while (this._pendingFlushes.length) {
            const flush = this._pendingFlushes.pop();
            flush.onflush(false);
          }
          await this.dht.destroy({ force });
        }
        async suspend({ log = noop } = {}) {
          if (this.suspended) return;
          const promises = [];
          promises.push(this.server.suspend({ log }));
          for (const discovery of this._discovery.values()) {
            promises.push(discovery.suspend({ log }));
          }
          const pending = [];
          for (const connection of this._allConnections) {
            connection.destroy();
            pending.push(new Promise((resolve) => connection.on("close", resolve)));
          }
          this.suspended = true;
          log("Suspending server and discovery... (" + promises.length + ")");
          await Promise.allSettled(promises);
          log("Done, suspending the dht...");
          await this.dht.suspend({ log });
          log("Done, swarm fully suspended");
          await Promise.all(pending);
          this._timer.destroy();
          this._timer = new RetryTimer(this._requeue.bind(this), {
            backoffs: this._timer.backoffs,
            jitter: this._timer.jitter
          });
          this._queue = spq();
        }
        async resume({ log = noop } = {}) {
          if (!this.suspended) return;
          log("Resuming the dht");
          await this.dht.resume();
          log("Done, resuming the server");
          await this.server.resume();
          log("Done, all discovery");
          for (const discovery of this._discovery.values()) {
            discovery.resume();
          }
          this.suspended = false;
          this._attemptClientConnections();
        }
        topics() {
          return this._discovery.values();
        }
      };
      function noop() {
      }
      function allowAll() {
        return false;
      }
      function shouldForceRelaying(code) {
        return code === "HOLEPUNCH_ABORTED" || code === "HOLEPUNCH_DOUBLE_RANDOMIZED_NATS" || code === "REMOTE_NOT_HOLEPUNCHABLE";
      }
      function shouldBan() {
        return false;
      }
      function toRelayFunction(relayThrough) {
        return typeof relayThrough === "function" ? relayThrough : (force, swarm) => force || swarm.dht.randomized ? relayThrough : null;
      }
    }
  });

  // ../../node_modules/bare-dev/lib/drive/shared/swarm.js
  var require_swarm = __commonJS({
    "../../node_modules/bare-dev/lib/drive/shared/swarm.js"(exports, module) {
      var Hyperswarm = require_hyperswarm();
      module.exports = function swarm(store) {
        return new Hyperswarm().on("connection", (socket) => store.replicate(socket));
      };
    }
  });

  // ../../node_modules/bare-dev/lib/drive/list.js
  var require_list2 = __commonJS({
    "../../node_modules/bare-dev/lib/drive/list.js"(exports, module) {
      var process2 = __require("process");
      var path = __require("path");
      var open = require_open();
      module.exports = async function list(drive, opts = {}) {
        const {
          prefix = "/",
          mount = "/",
          checkout,
          separator = "\n",
          cwd = path.resolve("."),
          quiet = true
        } = opts;
        const store = require_corestore2()(opts);
        const swarm = require_swarm()(store);
        drive = await open(drive, { store, swarm, cwd });
        if (checkout) drive = drive.checkout(checkout);
        const result = [];
        let first = true;
        for await (const entry of drive.list(prefix)) {
          result.push(entry);
          if (quiet) continue;
          let out = path.join(path.resolve(cwd, mount), entry.key);
          if (/^\s+$/.test(separator)) {
            out += separator;
          } else {
            first ? first = false : out = separator + out;
          }
          process2.stdout.write(out);
        }
        await swarm.destroy();
        return result;
      };
    }
  });

  // ../../node_modules/bare-dev/lib/drive/mirror.js
  var require_mirror = __commonJS({
    "../../node_modules/bare-dev/lib/drive/mirror.js"(exports, module) {
      var process2 = __require("process");
      var path = __require("path");
      var open = require_open();
      var symbols = {
        add: "+",
        remove: "-",
        change: "~"
      };
      module.exports = async function mirror(source, destination, opts = {}) {
        const {
          prefix = "/",
          checkout,
          prune = false,
          separator = "\n",
          cwd = path.resolve("."),
          quiet = true
        } = opts;
        const store = require_corestore2()(opts);
        const swarm = require_swarm()(store);
        source = await open(source, { store, swarm, cwd });
        destination = await open(destination, { store, swarm, cwd });
        if (checkout) source = source.checkout(checkout);
        const result = [];
        let first = false;
        for await (const entry of source.mirror(destination, { prefix, prune })) {
          result.push(entry);
          if (quiet) continue;
          let out = `${symbols[entry.op]} ${entry.key}`;
          if (/^\s+$/.test(separator)) {
            out += separator;
          } else {
            first ? first = false : out = separator + out;
          }
          process2.stdout.write(out);
        }
        await swarm.destroy();
        return result;
      };
    }
  });

  // ../../node_modules/bare-dev/lib/drive/version.js
  var require_version2 = __commonJS({
    "../../node_modules/bare-dev/lib/drive/version.js"(exports, module) {
      var process2 = __require("process");
      var path = __require("path");
      var open = require_open();
      module.exports = async function version(drive, opts = {}) {
        const {
          separator = "\n",
          cwd = path.resolve("."),
          quiet = true
        } = opts;
        const store = require_corestore2()(opts);
        const swarm = require_swarm()(store);
        drive = await open(drive, { store, swarm, cwd });
        if (!quiet) {
          let out = drive.version;
          if (/^\s+$/.test(separator)) {
            out += separator;
          }
          process2.stdout.write(out);
        }
        await swarm.destroy();
        return drive.version;
      };
    }
  });

  // ../../node_modules/bare-dev/lib/drive.js
  var require_drive = __commonJS({
    "../../node_modules/bare-dev/lib/drive.js"(exports) {
      exports.list = require_list2();
      exports.mirror = require_mirror();
      exports.version = require_version2();
    }
  });

  // ../../node_modules/bare-dev/lib/init/addon.js
  var require_addon = __commonJS({
    "../../node_modules/bare-dev/lib/init/addon.js"(exports, module) {
      var fs = require_promises2();
      var path = __require("path");
      module.exports = async function addon(opts = {}) {
        const {
          force = false,
          cwd = path.resolve(".")
        } = opts;
        let {
          name = null
        } = opts;
        if (name === null) {
          const pkg = __require(path.join(cwd, "package.json"));
          name = pkg.name.replace(/[^a-z]/ig, "_").replace(/_+/, "_").replace(/^_|_$/, "");
        }
        const definition = path.join(cwd, "CMakeLists.txt");
        let exists = false;
        try {
          await fs.access(definition);
          exists = true;
        } catch {
        }
        if (exists && !force) throw new Error(`refusing to overwrite ${definition}`);
        await fs.writeFile(
          definition,
          `cmake_minimum_required(VERSION 3.25)

project(${name} C)

include(bare)

add_bare_module(${name})

target_sources(
  \${${name}}
  PRIVATE
    binding.c
)
`
        );
      };
    }
  });

  // ../../node_modules/bare-dev/lib/init/appling.js
  var require_appling = __commonJS({
    "../../node_modules/bare-dev/lib/init/appling.js"(exports, module) {
      var fs = require_promises2();
      var path = __require("path");
      module.exports = async function appling(opts = {}) {
        const {
          force = false,
          cwd = path.resolve(".")
        } = opts;
        let {
          name = null,
          key,
          version,
          author,
          description,
          macos,
          windows,
          linux
        } = opts;
        if (name === null) {
          const pkg = __require(path.join(cwd, "package.json"));
          name = pkg.name.replace(/[^a-z]/ig, "_").replace(/_+/, "_").replace(/^_|_$/, "");
        }
        const definition = path.join(cwd, "CMakeLists.txt");
        let exists = false;
        try {
          await fs.access(definition);
          exists = true;
        } catch {
        }
        if (exists && !force) throw new Error(`refusing to overwrite ${definition}`);
        await fs.writeFile(
          definition,
          `cmake_minimum_required(VERSION 3.25)

project(${name} C)

include(pear)

add_pear_appling(
  pear_appling
  NAME "${name}"
  KEY ${key}
  VERSION "${version}"
  AUTHOR "${author}"
  DESCRIPTION "${description}"

  MACOS_IDENTIFIER ${macos.identifier}
  MACOS_CATEGORY ${macos.category}
  MACOS_ENTITLEMENTS ${macos.entitlements.join(" ")}
  MACOS_SIGNING_IDENTITY "${macos.signing.identity}"

  WINDOWS_SIGNING_SUBJECT "${windows.signing.subject}"
  WINDOWS_SIGNING_THUMBPRINT ${windows.signing.thumbprint}

  LINUX_CATEGORY ${linux.category}
)
`
        );
      };
    }
  });

  // ../../node_modules/bare-dev/lib/init.js
  var require_init = __commonJS({
    "../../node_modules/bare-dev/lib/init.js"(exports) {
      exports.addon = require_addon();
      exports.appling = require_appling();
    }
  });

  // ../../node_modules/bare-dev/lib/vendor/sync.js
  var require_sync = __commonJS({
    "../../node_modules/bare-dev/lib/vendor/sync.js"(exports, module) {
      var path = __require("path");
      var which = require_bare_which();
      var spawn = require_spawn();
      var git = which.sync("git");
      module.exports = function sync(root = ".", opts = {}) {
        const {
          submodules = true,
          cwd = path.resolve("."),
          quiet = true,
          verbose = false
        } = opts;
        if (submodules) {
          spawn(git, ["submodule", "update", "--init", "--recursive", root], { quiet, verbose, cwd });
        }
      };
    }
  });

  // ../../node_modules/bare-dev/lib/install.js
  var require_install = __commonJS({
    "../../node_modules/bare-dev/lib/install.js"(exports, module) {
      var fs = require_bare_node_fs();
      var os = __require("os");
      var path = __require("path");
      var { globSync } = require_commonjs5();
      module.exports = function install(opts = {}) {
        const {
          build = "build",
          prebuilds = "prebuilds",
          platform = os.platform(),
          arch = os.arch(),
          simulator = false,
          bare = true,
          node = false,
          link = false,
          force = false,
          sync = false,
          cwd = path.resolve(".")
        } = opts;
        const info = __require(path.join(cwd, "package.json"));
        const name = info.name.replace(/\//g, "+");
        const extensions = [];
        if (bare) extensions.push(".bare");
        if (node) extensions.push(".node");
        const dir = path.resolve(cwd, prebuilds, `${platform}-${arch}${simulator ? "-simulator" : ""}`);
        const targets = extensions.map((ext) => path.join(dir, name + ext));
        if (force || !targets.every((target) => isFile(target))) {
          if (sync) require_sync()(opts);
          if (isFile(path.join(cwd, "CMakeLists.txt"))) {
            require_configure()(opts);
            require_build()(opts);
            fs.mkdirSync(dir, { recursive: true });
            for (const target of targets) {
              const [addon] = globSync(path.join(cwd, build, `**/${name}${path.extname(target)}`), {
                windowsPathsNoEscape: true
              });
              if (addon) {
                try {
                  fs.unlinkSync(target);
                } catch {
                }
                if (link) {
                  fs.symlinkSync(addon, target);
                } else {
                  fs.copyFileSync(addon, target);
                }
              }
            }
          }
        }
      };
      function isFile(file) {
        try {
          return fs.statSync(file).isFile();
        } catch {
          return false;
        }
      }
    }
  });

  // ../../node_modules/bare-dev/lib/ios/shared/xcrun.js
  var require_xcrun = __commonJS({
    "../../node_modules/bare-dev/lib/ios/shared/xcrun.js"(exports, module) {
      var which = require_bare_which();
      var exec = require_exec();
      var xcrun = module.exports = exports = function xcrun2() {
        return which.sync("xcrun");
      };
      exports.find = function find(tool, opts = {}) {
        return exec(xcrun(), ["--find", tool], opts).trim();
      };
    }
  });

  // ../../node_modules/bare-dev/lib/ios/shared/simctl.js
  var require_simctl = __commonJS({
    "../../node_modules/bare-dev/lib/ios/shared/simctl.js"(exports, module) {
      var path = __require("path");
      var which = require_bare_which();
      var exec = require_exec();
      var spawn = require_spawn();
      var xcrun = require_xcrun();
      var simctl = module.exports = exports = function simctl2() {
        return xcrun.find("simctl");
      };
      exports.list = function list(opts) {
        const json = JSON.parse(
          exec(simctl(), ["list", "--json", "--no-escape-slashes", "devices", "available"], opts)
        );
        return Object.values(json.devices).flatMap((devices) => devices.map((device) => {
          return {
            id: device.udid,
            name: device.name,
            state: device.state.toLowerCase()
          };
        }));
      };
      exports.launch = function launch(device, opts = {}) {
        const {
          open = false
        } = opts;
        spawn(simctl(), ["boot", device], opts);
        if (open) {
          spawn(which.sync("open"), ["-a", "Simulator.app"], opts);
        }
      };
      exports.install = function install(device, app, opts = {}) {
        const {
          cwd = path.resolve(".")
        } = opts;
        app = path.resolve(cwd, app);
        spawn(simctl(), ["install", device, app], opts);
      };
      exports.start = function start(device, app, opts = {}) {
        const {
          attach = false,
          waitForDebugger = false,
          cwd = path.resolve(".")
        } = opts;
        app = path.resolve(cwd, app);
        const id = exec(which.sync("defaults"), ["read", path.join(app, "Info"), "CFBundleIdentifier"], opts).trim();
        const args = ["launch", "--terminate-running-process"];
        if (attach) args.push("--console-pty");
        if (waitForDebugger) args.push("--wait-for-debugger");
        spawn(simctl(), [...args, device, id], opts);
      };
    }
  });

  // ../../node_modules/bare-dev/lib/ios/device/list.js
  var require_list3 = __commonJS({
    "../../node_modules/bare-dev/lib/ios/device/list.js"(exports, module) {
      var process2 = __require("process");
      var simctl = require_simctl();
      module.exports = function list(opts = {}) {
        const {
          separator = "\n",
          quiet = true
        } = opts;
        const devices = simctl.list(opts);
        if (!quiet) {
          let first = true;
          for (const device of devices) {
            let out = device.name;
            if (/^\s+$/.test(separator)) {
              out += separator;
            } else {
              first ? first = false : out = separator + out;
            }
            process2.stdout.write(out);
          }
        }
        return devices;
      };
    }
  });

  // ../../node_modules/bare-dev/lib/ios/device/launch.js
  var require_launch2 = __commonJS({
    "../../node_modules/bare-dev/lib/ios/device/launch.js"(exports, module) {
      var simctl = require_simctl();
      var list = require_list3();
      module.exports = function launch(name = null, opts) {
        if (typeof name === "object" && name !== null) {
          opts = name;
          name = null;
        }
        const [device = null] = list().filter((candidate) => name ? candidate.name === name : true);
        if (device === null) {
          throw new Error(`launch() could not find device "${device}"`);
        }
        if (device.state !== "booted") simctl.launch(device.id, opts);
        return device.id;
      };
    }
  });

  // ../../node_modules/bare-dev/lib/ios/device.js
  var require_device2 = __commonJS({
    "../../node_modules/bare-dev/lib/ios/device.js"(exports) {
      exports.launch = require_launch2();
      exports.list = require_list3();
    }
  });

  // ../../node_modules/bare-dev/lib/ios/run.js
  var require_run2 = __commonJS({
    "../../node_modules/bare-dev/lib/ios/run.js"(exports, module) {
      var path = __require("path");
      var { globSync } = require_commonjs5();
      var launch = require_launch2();
      var simctl = require_simctl();
      module.exports = function run(app = null, opts = {}) {
        const {
          device = null,
          cwd = path.resolve(".")
        } = opts;
        if (app === null) {
          [app = null] = globSync(path.join(cwd, "**/*.app"), {
            ignore: [
              "**/vendor/**"
            ]
          });
          if (app === null) {
            throw new Error("no .app found");
          }
        }
        const id = launch(device, opts);
        app = path.resolve(cwd, app);
        simctl.install(id, app, opts);
        simctl.start(id, app, opts);
      };
    }
  });

  // ../../node_modules/bare-dev/lib/ios.js
  var require_ios = __commonJS({
    "../../node_modules/bare-dev/lib/ios.js"(exports) {
      exports.device = require_device2();
      exports.run = require_run2();
    }
  });

  // ../../node_modules/bare-dev/lib/test.js
  var require_test = __commonJS({
    "../../node_modules/bare-dev/lib/test.js"(exports, module) {
      var path = __require("path");
      var spawn = require_spawn();
      var cmake = require_cmake();
      module.exports = function test(opts = {}) {
        exports.ctest(opts);
      };
      exports.ctest = function(opts = {}) {
        const {
          build = "build",
          timeout = 30,
          debug = false,
          cwd = path.resolve("."),
          verbose = false
        } = opts;
        const args = [
          "--test-dir",
          path.resolve(cwd, build),
          "--build-config",
          debug ? "Debug" : "Release",
          "--timeout",
          timeout,
          "--output-on-failure"
        ];
        if (verbose) args.push("--verbose");
        else args.push("--progress");
        spawn(cmake.ctest(), args, opts);
      };
    }
  });

  // ../../node_modules/bare-dev/lib/vendor/checkout.js
  var require_checkout = __commonJS({
    "../../node_modules/bare-dev/lib/vendor/checkout.js"(exports, module) {
      var path = __require("path");
      var which = require_bare_which();
      var spawn = require_spawn();
      var sync = require_sync();
      var git = which.sync("git");
      module.exports = function checkout(root, version, opts = {}) {
        const {
          submodules = true,
          cwd = path.resolve("."),
          quiet = true,
          verbose = false
        } = opts;
        if (submodules) {
          spawn(git, ["-C", root, "fetch"], { quiet, verbose, cwd });
          spawn(git, ["-C", root, "checkout", "--force", version], { quiet, verbose, cwd });
          spawn(git, ["stage", root], { quiet, verbose, cwd });
        }
        sync(root, opts);
      };
    }
  });

  // ../../node_modules/bare-dev/lib/vendor/clean.js
  var require_clean2 = __commonJS({
    "../../node_modules/bare-dev/lib/vendor/clean.js"(exports, module) {
      var path = __require("path");
      var which = require_bare_which();
      var spawn = require_spawn();
      var git = which.sync("git");
      module.exports = function clean(root = ".", opts = {}) {
        const {
          submodules = true,
          cwd = path.resolve("."),
          quiet = true,
          verbose = false
        } = opts;
        if (submodules) {
          spawn(git, ["submodule", "deinit", "--force", root], { quiet, verbose, cwd });
        }
      };
    }
  });

  // ../../node_modules/bare-dev/lib/vendor.js
  var require_vendor = __commonJS({
    "../../node_modules/bare-dev/lib/vendor.js"(exports) {
      exports.checkout = require_checkout();
      exports.clean = require_clean2();
      exports.sync = require_sync();
    }
  });

  // ../../node_modules/bare-dev/index.js
  var require_bare_dev = __commonJS({
    "../../node_modules/bare-dev/index.js"(exports) {
      exports.android = require_android();
      exports.build = require_build();
      exports.bundle = require_bundle();
      exports.clean = require_clean();
      exports.configure = require_configure();
      exports.dependencies = require_dependencies();
      exports.drive = require_drive();
      exports.init = require_init();
      exports.install = require_install();
      exports.ios = require_ios();
      exports.paths = require_paths();
      exports.test = require_test();
      exports.vendor = require_vendor();
    }
  });

  // ../../bare-lib-entry-bareDev.js
  var bare_lib_entry_bareDev_exports = {};
  __export(bare_lib_entry_bareDev_exports, {
    default: () => bare_lib_entry_bareDev_default
  });
  var import_bare_dev = __toESM(require_bare_dev());
  var bare_lib_entry_bareDev_default = import_bare_dev.default;
  return __toCommonJS(bare_lib_entry_bareDev_exports);
})();
/*! Bundled license information:

safe-buffer/index.js:
  (*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> *)

object-assign/index.js:
  (*
  object-assign
  (c) Sindre Sorhus
  @license MIT
  *)

is-natural-number/index.js:
  (*!
   * is-natural-number.js | MIT (c) Shinnosuke Watanabe
   * https://github.com/shinnn/is-natural-number.js
  *)

strip-dirs/index.js:
  (*!
   * strip-dirs | MIT (c) Shinnosuke Watanabe
   * https://github.com/shinnn/node-strip-dirs
  *)
*/
;(function(){var g=globalThis;var s="__bare_os_stdlib__";g[s]=g[s]||{};var e=typeof __bare_os_bundle_exports__!=="undefined"?__bare_os_bundle_exports__:void 0;var v=e!=null&&typeof e==="object"&&Object.prototype.hasOwnProperty.call(e,"default")?e.default:e;g[s]["bareDev"]=v;})();