@tonyclaw/agent-inspector 3.0.16 → 3.0.17

package/.output/server/_libs/p-retry.mjs

@@ -0,0 +1,87 @@
+import { g as getDefaultExportFromCjs } from "./react.mjs";
+import { r as requireRetry } from "./retry.mjs";
+var pRetry$1 = { exports: {} };
+var hasRequiredPRetry;
+function requirePRetry() {
+  if (hasRequiredPRetry) return pRetry$1.exports;
+  hasRequiredPRetry = 1;
+  const retry = requireRetry();
+  const networkErrorMsgs = [
+    "Failed to fetch",
+    // Chrome
+    "NetworkError when attempting to fetch resource.",
+    // Firefox
+    "The Internet connection appears to be offline.",
+    // Safari
+    "Network request failed"
+    // `cross-fetch`
+  ];
+  class AbortError extends Error {
+    constructor(message) {
+      super();
+      if (message instanceof Error) {
+        this.originalError = message;
+        ({ message } = message);
+      } else {
+        this.originalError = new Error(message);
+        this.originalError.stack = this.stack;
+      }
+      this.name = "AbortError";
+      this.message = message;
+    }
+  }
+  const decorateErrorWithCounts = (error, attemptNumber, options) => {
+    const retriesLeft = options.retries - (attemptNumber - 1);
+    error.attemptNumber = attemptNumber;
+    error.retriesLeft = retriesLeft;
+    return error;
+  };
+  const isNetworkError = (errorMessage) => networkErrorMsgs.includes(errorMessage);
+  const pRetry2 = (input, options) => new Promise((resolve, reject) => {
+    options = {
+      onFailedAttempt: () => {
+      },
+      retries: 10,
+      ...options
+    };
+    const operation = retry.operation(options);
+    operation.attempt(async (attemptNumber) => {
+      try {
+        resolve(await input(attemptNumber));
+      } catch (error) {
+        if (!(error instanceof Error)) {
+          reject(new TypeError(`Non-error was thrown: "${error}". You should only throw errors.`));
+          return;
+        }
+        if (error instanceof AbortError) {
+          operation.stop();
+          reject(error.originalError);
+        } else if (error instanceof TypeError && !isNetworkError(error.message)) {
+          operation.stop();
+          reject(error);
+        } else {
+          decorateErrorWithCounts(error, attemptNumber, options);
+          try {
+            await options.onFailedAttempt(error);
+          } catch (error2) {
+            reject(error2);
+            return;
+          }
+          if (!operation.retry(error)) {
+            reject(operation.mainError());
+          }
+        }
+      }
+    });
+  });
+  pRetry$1.exports = pRetry2;
+  pRetry$1.exports.default = pRetry2;
+  pRetry$1.exports.AbortError = AbortError;
+  return pRetry$1.exports;
+}
+var pRetryExports = requirePRetry();
+const pRetry = /* @__PURE__ */ getDefaultExportFromCjs(pRetryExports);
+export {
+  pRetryExports as a,
+  pRetry as p
+};

package/.output/server/_libs/partial-json.mjs

@@ -0,0 +1,244 @@
+var dist = {};
+var options = {};
+var hasRequiredOptions;
+function requireOptions() {
+  if (hasRequiredOptions) return options;
+  hasRequiredOptions = 1;
+  (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.Allow = exports$1.ALL = exports$1.COLLECTION = exports$1.ATOM = exports$1.SPECIAL = exports$1.INF = exports$1._INFINITY = exports$1.INFINITY = exports$1.NAN = exports$1.BOOL = exports$1.NULL = exports$1.OBJ = exports$1.ARR = exports$1.NUM = exports$1.STR = void 0;
+    exports$1.STR = 1;
+    exports$1.NUM = 2;
+    exports$1.ARR = 4;
+    exports$1.OBJ = 8;
+    exports$1.NULL = 16;
+    exports$1.BOOL = 32;
+    exports$1.NAN = 64;
+    exports$1.INFINITY = 128;
+    exports$1._INFINITY = 256;
+    exports$1.INF = exports$1.INFINITY | exports$1._INFINITY;
+    exports$1.SPECIAL = exports$1.NULL | exports$1.BOOL | exports$1.INF | exports$1.NAN;
+    exports$1.ATOM = exports$1.STR | exports$1.NUM | exports$1.SPECIAL;
+    exports$1.COLLECTION = exports$1.ARR | exports$1.OBJ;
+    exports$1.ALL = exports$1.ATOM | exports$1.COLLECTION;
+    exports$1.Allow = { STR: exports$1.STR, NUM: exports$1.NUM, ARR: exports$1.ARR, OBJ: exports$1.OBJ, NULL: exports$1.NULL, BOOL: exports$1.BOOL, NAN: exports$1.NAN, INFINITY: exports$1.INFINITY, _INFINITY: exports$1._INFINITY, INF: exports$1.INF, SPECIAL: exports$1.SPECIAL, ATOM: exports$1.ATOM, COLLECTION: exports$1.COLLECTION, ALL: exports$1.ALL };
+    exports$1.default = exports$1.Allow;
+  })(options);
+  return options;
+}
+var hasRequiredDist;
+function requireDist() {
+  if (hasRequiredDist) return dist;
+  hasRequiredDist = 1;
+  (function(exports$1) {
+    var __createBinding = dist && dist.__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 __exportStar = dist && dist.__exportStar || function(m, exports$12) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports$12, p)) __createBinding(exports$12, m, p);
+    };
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.Allow = exports$1.MalformedJSON = exports$1.PartialJSON = exports$1.parseJSON = exports$1.parse = void 0;
+    const options_1 = requireOptions();
+    Object.defineProperty(exports$1, "Allow", { enumerable: true, get: function() {
+      return options_1.Allow;
+    } });
+    __exportStar(requireOptions(), exports$1);
+    class PartialJSON extends Error {
+    }
+    exports$1.PartialJSON = PartialJSON;
+    class MalformedJSON extends Error {
+    }
+    exports$1.MalformedJSON = MalformedJSON;
+    function parseJSON(jsonString, allowPartial = options_1.Allow.ALL) {
+      if (typeof jsonString !== "string") {
+        throw new TypeError(`expecting str, got ${typeof jsonString}`);
+      }
+      if (!jsonString.trim()) {
+        throw new Error(`${jsonString} is empty`);
+      }
+      return _parseJSON(jsonString.trim(), allowPartial);
+    }
+    exports$1.parseJSON = parseJSON;
+    const _parseJSON = (jsonString, allow) => {
+      const length = jsonString.length;
+      let index = 0;
+      const markPartialJSON = (msg) => {
+        throw new PartialJSON(`${msg} at position ${index}`);
+      };
+      const throwMalformedError = (msg) => {
+        throw new MalformedJSON(`${msg} at position ${index}`);
+      };
+      const parseAny = () => {
+        skipBlank();
+        if (index >= length)
+          markPartialJSON("Unexpected end of input");
+        if (jsonString[index] === '"')
+          return parseStr();
+        if (jsonString[index] === "{")
+          return parseObj();
+        if (jsonString[index] === "[")
+          return parseArr();
+        if (jsonString.substring(index, index + 4) === "null" || options_1.Allow.NULL & allow && length - index < 4 && "null".startsWith(jsonString.substring(index))) {
+          index += 4;
+          return null;
+        }
+        if (jsonString.substring(index, index + 4) === "true" || options_1.Allow.BOOL & allow && length - index < 4 && "true".startsWith(jsonString.substring(index))) {
+          index += 4;
+          return true;
+        }
+        if (jsonString.substring(index, index + 5) === "false" || options_1.Allow.BOOL & allow && length - index < 5 && "false".startsWith(jsonString.substring(index))) {
+          index += 5;
+          return false;
+        }
+        if (jsonString.substring(index, index + 8) === "Infinity" || options_1.Allow.INFINITY & allow && length - index < 8 && "Infinity".startsWith(jsonString.substring(index))) {
+          index += 8;
+          return Infinity;
+        }
+        if (jsonString.substring(index, index + 9) === "-Infinity" || options_1.Allow._INFINITY & allow && 1 < length - index && length - index < 9 && "-Infinity".startsWith(jsonString.substring(index))) {
+          index += 9;
+          return -Infinity;
+        }
+        if (jsonString.substring(index, index + 3) === "NaN" || options_1.Allow.NAN & allow && length - index < 3 && "NaN".startsWith(jsonString.substring(index))) {
+          index += 3;
+          return NaN;
+        }
+        return parseNum();
+      };
+      const parseStr = () => {
+        const start = index;
+        let escape = false;
+        index++;
+        while (index < length && (jsonString[index] !== '"' || escape && jsonString[index - 1] === "\\")) {
+          escape = jsonString[index] === "\\" ? !escape : false;
+          index++;
+        }
+        if (jsonString.charAt(index) == '"') {
+          try {
+            return JSON.parse(jsonString.substring(start, ++index - Number(escape)));
+          } catch (e) {
+            throwMalformedError(String(e));
+          }
+        } else if (options_1.Allow.STR & allow) {
+          try {
+            return JSON.parse(jsonString.substring(start, index - Number(escape)) + '"');
+          } catch (e) {
+            return JSON.parse(jsonString.substring(start, jsonString.lastIndexOf("\\")) + '"');
+          }
+        }
+        markPartialJSON("Unterminated string literal");
+      };
+      const parseObj = () => {
+        index++;
+        skipBlank();
+        const obj = {};
+        try {
+          while (jsonString[index] !== "}") {
+            skipBlank();
+            if (index >= length && options_1.Allow.OBJ & allow)
+              return obj;
+            const key = parseStr();
+            skipBlank();
+            index++;
+            try {
+              const value = parseAny();
+              obj[key] = value;
+            } catch (e) {
+              if (options_1.Allow.OBJ & allow)
+                return obj;
+              else
+                throw e;
+            }
+            skipBlank();
+            if (jsonString[index] === ",")
+              index++;
+          }
+        } catch (e) {
+          if (options_1.Allow.OBJ & allow)
+            return obj;
+          else
+            markPartialJSON("Expected '}' at end of object");
+        }
+        index++;
+        return obj;
+      };
+      const parseArr = () => {
+        index++;
+        const arr = [];
+        try {
+          while (jsonString[index] !== "]") {
+            arr.push(parseAny());
+            skipBlank();
+            if (jsonString[index] === ",") {
+              index++;
+            }
+          }
+        } catch (e) {
+          if (options_1.Allow.ARR & allow) {
+            return arr;
+          }
+          markPartialJSON("Expected ']' at end of array");
+        }
+        index++;
+        return arr;
+      };
+      const parseNum = () => {
+        if (index === 0) {
+          if (jsonString === "-")
+            throwMalformedError("Not sure what '-' is");
+          try {
+            return JSON.parse(jsonString);
+          } catch (e) {
+            if (options_1.Allow.NUM & allow)
+              try {
+                return JSON.parse(jsonString.substring(0, jsonString.lastIndexOf("e")));
+              } catch (e2) {
+              }
+            throwMalformedError(String(e));
+          }
+        }
+        const start = index;
+        if (jsonString[index] === "-")
+          index++;
+        while (jsonString[index] && ",]}".indexOf(jsonString[index]) === -1)
+          index++;
+        if (index == length && !(options_1.Allow.NUM & allow))
+          markPartialJSON("Unterminated number literal");
+        try {
+          return JSON.parse(jsonString.substring(start, index));
+        } catch (e) {
+          if (jsonString.substring(start, index) === "-")
+            markPartialJSON("Not sure what '-' is");
+          try {
+            return JSON.parse(jsonString.substring(start, jsonString.lastIndexOf("e")));
+          } catch (e2) {
+            throwMalformedError(String(e2));
+          }
+        }
+      };
+      const skipBlank = () => {
+        while (index < length && " \n\r	".includes(jsonString[index])) {
+          index++;
+        }
+      };
+      return parseAny();
+    };
+    const parse = parseJSON;
+    exports$1.parse = parse;
+  })(dist);
+  return dist;
+}
+var distExports = requireDist();
+export {
+  distExports as d
+};

package/.output/server/_libs/react-dom.mjs

@@ -1,8 +1,8 @@
-import require$$0 from "util";
-import require$$2 from "async_hooks";
-import require$$0$1 from "stream";
-import { b as requireReact, g as getDefaultExportFromCjs } from "./react.mjs";
+import require$$2 from "util";
 import require$$1 from "crypto";
+import require$$2$1 from "async_hooks";
+import require$$0 from "stream";
+import { b as requireReact, g as getDefaultExportFromCjs } from "./react.mjs";
 var server_node = {};
 var reactDomServerLegacy_node_production = {};
 var reactDom = { exports: {} };
@@ -5058,7 +5058,7 @@ var hasRequiredReactDomServer_node_production;
 function requireReactDomServer_node_production() {
   if (hasRequiredReactDomServer_node_production) return reactDomServer_node_production;
   hasRequiredReactDomServer_node_production = 1;
-  var util = require$$0, crypto = require$$1, async_hooks = require$$2, React = requireReact(), ReactDOM2 = requireReactDom(), stream = require$$0$1, REACT_ELEMENT_TYPE = /* @__PURE__ */ Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = /* @__PURE__ */ Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = /* @__PURE__ */ Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = /* @__PURE__ */ Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = /* @__PURE__ */ Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = /* @__PURE__ */ Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = /* @__PURE__ */ Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = /* @__PURE__ */ Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = /* @__PURE__ */ Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = /* @__PURE__ */ Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = /* @__PURE__ */ Symbol.for("react.memo"), REACT_LAZY_TYPE = /* @__PURE__ */ Symbol.for("react.lazy"), REACT_SCOPE_TYPE = /* @__PURE__ */ Symbol.for("react.scope"), REACT_ACTIVITY_TYPE = /* @__PURE__ */ Symbol.for("react.activity"), REACT_LEGACY_HIDDEN_TYPE = /* @__PURE__ */ Symbol.for("react.legacy_hidden"), REACT_MEMO_CACHE_SENTINEL = /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel"), REACT_VIEW_TRANSITION_TYPE = /* @__PURE__ */ Symbol.for("react.view_transition"), MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+  var util = require$$2, crypto = require$$1, async_hooks = require$$2$1, React = requireReact(), ReactDOM2 = requireReactDom(), stream = require$$0, REACT_ELEMENT_TYPE = /* @__PURE__ */ Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = /* @__PURE__ */ Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = /* @__PURE__ */ Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = /* @__PURE__ */ Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = /* @__PURE__ */ Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = /* @__PURE__ */ Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = /* @__PURE__ */ Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = /* @__PURE__ */ Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = /* @__PURE__ */ Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = /* @__PURE__ */ Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = /* @__PURE__ */ Symbol.for("react.memo"), REACT_LAZY_TYPE = /* @__PURE__ */ Symbol.for("react.lazy"), REACT_SCOPE_TYPE = /* @__PURE__ */ Symbol.for("react.scope"), REACT_ACTIVITY_TYPE = /* @__PURE__ */ Symbol.for("react.activity"), REACT_LEGACY_HIDDEN_TYPE = /* @__PURE__ */ Symbol.for("react.legacy_hidden"), REACT_MEMO_CACHE_SENTINEL = /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel"), REACT_VIEW_TRANSITION_TYPE = /* @__PURE__ */ Symbol.for("react.view_transition"), MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
   function getIteratorFn(maybeIterable) {
     if (null === maybeIterable || "object" !== typeof maybeIterable) return null;
     maybeIterable = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable["@@iterator"];

package/.output/server/_libs/react-markdown.mjs

@@ -38,10 +38,10 @@ import "./ungap__structured-clone.mjs";
 import "./micromark-util-sanitize-uri.mjs";
 import "./unist-util-position.mjs";
 import "./trim-lines.mjs";
-import "./vfile-message.mjs";
-import "node:process";
 import "node:path";
 import "node:url";
+import "./vfile-message.mjs";
+import "node:process";
 import "./unist-util-visit-parents.mjs";
 import "./unist-util-is.mjs";
 import "./comma-separated-tokens.mjs";

package/.output/server/_libs/react.mjs

@@ -23,6 +23,35 @@ var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof win
 function getDefaultExportFromCjs(x) {
   return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
 }
+function getAugmentedNamespace(n) {
+  if (Object.prototype.hasOwnProperty.call(n, "__esModule")) return n;
+  var f = n.default;
+  if (typeof f == "function") {
+    var a = function a2() {
+      var isInstance = false;
+      try {
+        isInstance = this instanceof a2;
+      } catch {
+      }
+      if (isInstance) {
+        return Reflect.construct(f, arguments, this.constructor);
+      }
+      return f.apply(this, arguments);
+    };
+    a.prototype = f.prototype;
+  } else a = {};
+  Object.defineProperty(a, "__esModule", { value: true });
+  Object.keys(n).forEach(function(k) {
+    var d = Object.getOwnPropertyDescriptor(n, k);
+    Object.defineProperty(a, k, d.get ? d : {
+      enumerable: true,
+      get: function() {
+        return n[k];
+      }
+    });
+  });
+  return a;
+}
 var jsxRuntime = { exports: {} };
 var reactJsxRuntime_production = {};
 var hasRequiredReactJsxRuntime_production;
@@ -509,6 +538,7 @@ export {
   React as a,
   requireReact as b,
   commonjsGlobal as c,
+  getAugmentedNamespace as d,
   getDefaultExportFromCjs as g,
   jsxRuntimeExports as j,
   reactExports as r

package/.output/server/_libs/readable-stream.mjs

@@ -1,4 +1,4 @@
-import require$$2 from "events";
+import require$$0$1 from "events";
 import require$$11 from "node:string_decoder";
 import require$$0 from "stream";
 import { c as commonjsGlobal } from "./react.mjs";
@@ -7,7 +7,7 @@ import { r as requireIsarray } from "./isarray.mjs";
 import { r as requireSafeBuffer } from "./safe-buffer.mjs";
 import { r as requireUtil } from "./core-util-is.mjs";
 import { r as requireInherits } from "./inherits.mjs";
-import require$$0$1 from "util";
+import require$$2 from "util";
 import { r as requireNode } from "./util-deprecate.mjs";
 var readable = { exports: {} };
 var stream;
@@ -30,7 +30,7 @@ function requireBufferList() {
       }
     }
     var Buffer = requireSafeBuffer().Buffer;
-    var util = require$$0$1;
+    var util = require$$2;
     function copyBuffer(src, target, offset) {
       src.copy(target, offset);
     }
@@ -691,7 +691,7 @@ function require_stream_readable() {
   var isArray = requireIsarray();
   var Duplex;
   Readable.ReadableState = ReadableState;
-  require$$2.EventEmitter;
+  require$$0$1.EventEmitter;
   var EElistenerCount = function(emitter, type) {
     return emitter.listeners(type).length;
   };
@@ -707,7 +707,7 @@ function require_stream_readable() {
   }
   var util = Object.create(requireUtil());
   util.inherits = requireInherits();
-  var debugUtil = require$$0$1;
+  var debugUtil = require$$2;
   var debug = void 0;
   if (debugUtil && debugUtil.debuglog) {
     debug = debugUtil.debuglog("stream");

package/.output/server/_libs/retry.mjs

@@ -0,0 +1,236 @@
+var retry$1 = {};
+var retry_operation;
+var hasRequiredRetry_operation;
+function requireRetry_operation() {
+  if (hasRequiredRetry_operation) return retry_operation;
+  hasRequiredRetry_operation = 1;
+  function RetryOperation(timeouts, options) {
+    if (typeof options === "boolean") {
+      options = { forever: options };
+    }
+    this._originalTimeouts = JSON.parse(JSON.stringify(timeouts));
+    this._timeouts = timeouts;
+    this._options = options || {};
+    this._maxRetryTime = options && options.maxRetryTime || Infinity;
+    this._fn = null;
+    this._errors = [];
+    this._attempts = 1;
+    this._operationTimeout = null;
+    this._operationTimeoutCb = null;
+    this._timeout = null;
+    this._operationStart = null;
+    this._timer = null;
+    if (this._options.forever) {
+      this._cachedTimeouts = this._timeouts.slice(0);
+    }
+  }
+  retry_operation = RetryOperation;
+  RetryOperation.prototype.reset = function() {
+    this._attempts = 1;
+    this._timeouts = this._originalTimeouts.slice(0);
+  };
+  RetryOperation.prototype.stop = function() {
+    if (this._timeout) {
+      clearTimeout(this._timeout);
+    }
+    if (this._timer) {
+      clearTimeout(this._timer);
+    }
+    this._timeouts = [];
+    this._cachedTimeouts = null;
+  };
+  RetryOperation.prototype.retry = function(err) {
+    if (this._timeout) {
+      clearTimeout(this._timeout);
+    }
+    if (!err) {
+      return false;
+    }
+    var currentTime = (/* @__PURE__ */ new Date()).getTime();
+    if (err && currentTime - this._operationStart >= this._maxRetryTime) {
+      this._errors.push(err);
+      this._errors.unshift(new Error("RetryOperation timeout occurred"));
+      return false;
+    }
+    this._errors.push(err);
+    var timeout = this._timeouts.shift();
+    if (timeout === void 0) {
+      if (this._cachedTimeouts) {
+        this._errors.splice(0, this._errors.length - 1);
+        timeout = this._cachedTimeouts.slice(-1);
+      } else {
+        return false;
+      }
+    }
+    var self = this;
+    this._timer = setTimeout(function() {
+      self._attempts++;
+      if (self._operationTimeoutCb) {
+        self._timeout = setTimeout(function() {
+          self._operationTimeoutCb(self._attempts);
+        }, self._operationTimeout);
+        if (self._options.unref) {
+          self._timeout.unref();
+        }
+      }
+      self._fn(self._attempts);
+    }, timeout);
+    if (this._options.unref) {
+      this._timer.unref();
+    }
+    return true;
+  };
+  RetryOperation.prototype.attempt = function(fn, timeoutOps) {
+    this._fn = fn;
+    if (timeoutOps) {
+      if (timeoutOps.timeout) {
+        this._operationTimeout = timeoutOps.timeout;
+      }
+      if (timeoutOps.cb) {
+        this._operationTimeoutCb = timeoutOps.cb;
+      }
+    }
+    var self = this;
+    if (this._operationTimeoutCb) {
+      this._timeout = setTimeout(function() {
+        self._operationTimeoutCb();
+      }, self._operationTimeout);
+    }
+    this._operationStart = (/* @__PURE__ */ new Date()).getTime();
+    this._fn(this._attempts);
+  };
+  RetryOperation.prototype.try = function(fn) {
+    console.log("Using RetryOperation.try() is deprecated");
+    this.attempt(fn);
+  };
+  RetryOperation.prototype.start = function(fn) {
+    console.log("Using RetryOperation.start() is deprecated");
+    this.attempt(fn);
+  };
+  RetryOperation.prototype.start = RetryOperation.prototype.try;
+  RetryOperation.prototype.errors = function() {
+    return this._errors;
+  };
+  RetryOperation.prototype.attempts = function() {
+    return this._attempts;
+  };
+  RetryOperation.prototype.mainError = function() {
+    if (this._errors.length === 0) {
+      return null;
+    }
+    var counts = {};
+    var mainError = null;
+    var mainErrorCount = 0;
+    for (var i = 0; i < this._errors.length; i++) {
+      var error = this._errors[i];
+      var message = error.message;
+      var count = (counts[message] || 0) + 1;
+      counts[message] = count;
+      if (count >= mainErrorCount) {
+        mainError = error;
+        mainErrorCount = count;
+      }
+    }
+    return mainError;
+  };
+  return retry_operation;
+}
+var hasRequiredRetry$1;
+function requireRetry$1() {
+  if (hasRequiredRetry$1) return retry$1;
+  hasRequiredRetry$1 = 1;
+  (function(exports$1) {
+    var RetryOperation = requireRetry_operation();
+    exports$1.operation = function(options) {
+      var timeouts = exports$1.timeouts(options);
+      return new RetryOperation(timeouts, {
+        forever: options && (options.forever || options.retries === Infinity),
+        unref: options && options.unref,
+        maxRetryTime: options && options.maxRetryTime
+      });
+    };
+    exports$1.timeouts = function(options) {
+      if (options instanceof Array) {
+        return [].concat(options);
+      }
+      var opts = {
+        retries: 10,
+        factor: 2,
+        minTimeout: 1 * 1e3,
+        maxTimeout: Infinity,
+        randomize: false
+      };
+      for (var key in options) {
+        opts[key] = options[key];
+      }
+      if (opts.minTimeout > opts.maxTimeout) {
+        throw new Error("minTimeout is greater than maxTimeout");
+      }
+      var timeouts = [];
+      for (var i = 0; i < opts.retries; i++) {
+        timeouts.push(this.createTimeout(i, opts));
+      }
+      if (options && options.forever && !timeouts.length) {
+        timeouts.push(this.createTimeout(i, opts));
+      }
+      timeouts.sort(function(a, b) {
+        return a - b;
+      });
+      return timeouts;
+    };
+    exports$1.createTimeout = function(attempt, opts) {
+      var random = opts.randomize ? Math.random() + 1 : 1;
+      var timeout = Math.round(random * Math.max(opts.minTimeout, 1) * Math.pow(opts.factor, attempt));
+      timeout = Math.min(timeout, opts.maxTimeout);
+      return timeout;
+    };
+    exports$1.wrap = function(obj, options, methods) {
+      if (options instanceof Array) {
+        methods = options;
+        options = null;
+      }
+      if (!methods) {
+        methods = [];
+        for (var key in obj) {
+          if (typeof obj[key] === "function") {
+            methods.push(key);
+          }
+        }
+      }
+      for (var i = 0; i < methods.length; i++) {
+        var method = methods[i];
+        var original = obj[method];
+        obj[method] = (function retryWrapper(original2) {
+          var op = exports$1.operation(options);
+          var args = Array.prototype.slice.call(arguments, 1);
+          var callback = args.pop();
+          args.push(function(err) {
+            if (op.retry(err)) {
+              return;
+            }
+            if (err) {
+              arguments[0] = op.mainError();
+            }
+            callback.apply(this, arguments);
+          });
+          op.attempt(function() {
+            original2.apply(obj, args);
+          });
+        }).bind(obj, original);
+        obj[method].options = options;
+      }
+    };
+  })(retry$1);
+  return retry$1;
+}
+var retry;
+var hasRequiredRetry;
+function requireRetry() {
+  if (hasRequiredRetry) return retry;
+  hasRequiredRetry = 1;
+  retry = requireRetry$1();
+  return retry;
+}
+export {
+  requireRetry as r
+};