indisposed 0.0.6 → 0.0.8

package/dist/with-resolvers-0tPpPN4C.js

@@ -0,0 +1,1243 @@
+import { u as requireGlobalThis, P as requireEnvironmentUserAgent, Q as requireClassofRaw, i as requireObjectDefineProperty, a as requireHasOwnProperty, y as requireWellKnownSymbol, B as requireGetBuiltIn, I as requireDefineBuiltInAccessor, g as requireDescriptors, o as requireFunctionUncurryThis, r as requireFails, d as requireIsCallable, s as requireClassof, R as requireInspectSource, S as requireTryToString, j as requireAnObject, E as requireIsNullOrUndefined, T as requireFunctionBindNative, D as requireFunctionBindContext, l as requireHtml, m as requireDocumentCreateElement, U as requireIsForced, z as requireIsPure, K as requireEnvironmentV8Version, F as requireACallable, t as require_export, N as requirePath, C as requireFunctionCall, A as requireDefineBuiltIn, w as requireObjectSetPrototypeOf, M as requireIsObject, H as requireAnInstance, J as requireInternalState, G as requireGetMethod, V as requireLengthOfArrayLike, v as requireObjectIsPrototypeOf } from "./path-DtH12Oyl.js";
+var es_promise = {};
+var es_promise_constructor = {};
+var environment;
+var hasRequiredEnvironment;
+function requireEnvironment() {
+  if (hasRequiredEnvironment) return environment;
+  hasRequiredEnvironment = 1;
+  var globalThis = requireGlobalThis();
+  var userAgent = requireEnvironmentUserAgent();
+  var classof = requireClassofRaw();
+  var userAgentStartsWith = function(string) {
+    return userAgent.slice(0, string.length) === string;
+  };
+  environment = (function() {
+    if (userAgentStartsWith("Bun/")) return "BUN";
+    if (userAgentStartsWith("Cloudflare-Workers")) return "CLOUDFLARE";
+    if (userAgentStartsWith("Deno/")) return "DENO";
+    if (userAgentStartsWith("Node.js/")) return "NODE";
+    if (globalThis.Bun && typeof Bun.version == "string") return "BUN";
+    if (globalThis.Deno && typeof Deno.version == "object") return "DENO";
+    if (classof(globalThis.process) === "process") return "NODE";
+    if (globalThis.window && globalThis.document) return "BROWSER";
+    return "REST";
+  })();
+  return environment;
+}
+var environmentIsNode;
+var hasRequiredEnvironmentIsNode;
+function requireEnvironmentIsNode() {
+  if (hasRequiredEnvironmentIsNode) return environmentIsNode;
+  hasRequiredEnvironmentIsNode = 1;
+  var ENVIRONMENT = requireEnvironment();
+  environmentIsNode = ENVIRONMENT === "NODE";
+  return environmentIsNode;
+}
+var setToStringTag;
+var hasRequiredSetToStringTag;
+function requireSetToStringTag() {
+  if (hasRequiredSetToStringTag) return setToStringTag;
+  hasRequiredSetToStringTag = 1;
+  var defineProperty = requireObjectDefineProperty().f;
+  var hasOwn = requireHasOwnProperty();
+  var wellKnownSymbol = requireWellKnownSymbol();
+  var TO_STRING_TAG = wellKnownSymbol("toStringTag");
+  setToStringTag = function(target, TAG, STATIC) {
+    if (target && !STATIC) target = target.prototype;
+    if (target && !hasOwn(target, TO_STRING_TAG)) {
+      defineProperty(target, TO_STRING_TAG, { configurable: true, value: TAG });
+    }
+  };
+  return setToStringTag;
+}
+var setSpecies;
+var hasRequiredSetSpecies;
+function requireSetSpecies() {
+  if (hasRequiredSetSpecies) return setSpecies;
+  hasRequiredSetSpecies = 1;
+  var getBuiltIn = requireGetBuiltIn();
+  var defineBuiltInAccessor = requireDefineBuiltInAccessor();
+  var wellKnownSymbol = requireWellKnownSymbol();
+  var DESCRIPTORS = requireDescriptors();
+  var SPECIES = wellKnownSymbol("species");
+  setSpecies = function(CONSTRUCTOR_NAME) {
+    var Constructor = getBuiltIn(CONSTRUCTOR_NAME);
+    if (DESCRIPTORS && Constructor && !Constructor[SPECIES]) {
+      defineBuiltInAccessor(Constructor, SPECIES, {
+        configurable: true,
+        get: function() {
+          return this;
+        }
+      });
+    }
+  };
+  return setSpecies;
+}
+var isConstructor;
+var hasRequiredIsConstructor;
+function requireIsConstructor() {
+  if (hasRequiredIsConstructor) return isConstructor;
+  hasRequiredIsConstructor = 1;
+  var uncurryThis = requireFunctionUncurryThis();
+  var fails = requireFails();
+  var isCallable = requireIsCallable();
+  var classof = requireClassof();
+  var getBuiltIn = requireGetBuiltIn();
+  var inspectSource = requireInspectSource();
+  var noop = function() {
+  };
+  var construct = getBuiltIn("Reflect", "construct");
+  var constructorRegExp = /^\s*(?:class|function)\b/;
+  var exec = uncurryThis(constructorRegExp.exec);
+  var INCORRECT_TO_STRING = !constructorRegExp.test(noop);
+  var isConstructorModern = function isConstructor2(argument) {
+    if (!isCallable(argument)) return false;
+    try {
+      construct(noop, [], argument);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  };
+  var isConstructorLegacy = function isConstructor2(argument) {
+    if (!isCallable(argument)) return false;
+    switch (classof(argument)) {
+      case "AsyncFunction":
+      case "GeneratorFunction":
+      case "AsyncGeneratorFunction":
+        return false;
+    }
+    try {
+      return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource(argument));
+    } catch (error) {
+      return true;
+    }
+  };
+  isConstructorLegacy.sham = true;
+  isConstructor = !construct || fails(function() {
+    var called;
+    return isConstructorModern(isConstructorModern.call) || !isConstructorModern(Object) || !isConstructorModern(function() {
+      called = true;
+    }) || called;
+  }) ? isConstructorLegacy : isConstructorModern;
+  return isConstructor;
+}
+var aConstructor;
+var hasRequiredAConstructor;
+function requireAConstructor() {
+  if (hasRequiredAConstructor) return aConstructor;
+  hasRequiredAConstructor = 1;
+  var isConstructor2 = requireIsConstructor();
+  var tryToString = requireTryToString();
+  var $TypeError = TypeError;
+  aConstructor = function(argument) {
+    if (isConstructor2(argument)) return argument;
+    throw new $TypeError(tryToString(argument) + " is not a constructor");
+  };
+  return aConstructor;
+}
+var speciesConstructor;
+var hasRequiredSpeciesConstructor;
+function requireSpeciesConstructor() {
+  if (hasRequiredSpeciesConstructor) return speciesConstructor;
+  hasRequiredSpeciesConstructor = 1;
+  var anObject = requireAnObject();
+  var aConstructor2 = requireAConstructor();
+  var isNullOrUndefined = requireIsNullOrUndefined();
+  var wellKnownSymbol = requireWellKnownSymbol();
+  var SPECIES = wellKnownSymbol("species");
+  speciesConstructor = function(O, defaultConstructor) {
+    var C = anObject(O).constructor;
+    var S;
+    return C === void 0 || isNullOrUndefined(S = anObject(C)[SPECIES]) ? defaultConstructor : aConstructor2(S);
+  };
+  return speciesConstructor;
+}
+var functionApply;
+var hasRequiredFunctionApply;
+function requireFunctionApply() {
+  if (hasRequiredFunctionApply) return functionApply;
+  hasRequiredFunctionApply = 1;
+  var NATIVE_BIND = requireFunctionBindNative();
+  var FunctionPrototype = Function.prototype;
+  var apply = FunctionPrototype.apply;
+  var call = FunctionPrototype.call;
+  functionApply = typeof Reflect == "object" && Reflect.apply || (NATIVE_BIND ? call.bind(apply) : function() {
+    return call.apply(apply, arguments);
+  });
+  return functionApply;
+}
+var arraySlice;
+var hasRequiredArraySlice;
+function requireArraySlice() {
+  if (hasRequiredArraySlice) return arraySlice;
+  hasRequiredArraySlice = 1;
+  var uncurryThis = requireFunctionUncurryThis();
+  arraySlice = uncurryThis([].slice);
+  return arraySlice;
+}
+var validateArgumentsLength;
+var hasRequiredValidateArgumentsLength;
+function requireValidateArgumentsLength() {
+  if (hasRequiredValidateArgumentsLength) return validateArgumentsLength;
+  hasRequiredValidateArgumentsLength = 1;
+  var $TypeError = TypeError;
+  validateArgumentsLength = function(passed, required) {
+    if (passed < required) throw new $TypeError("Not enough arguments");
+    return passed;
+  };
+  return validateArgumentsLength;
+}
+var environmentIsIos;
+var hasRequiredEnvironmentIsIos;
+function requireEnvironmentIsIos() {
+  if (hasRequiredEnvironmentIsIos) return environmentIsIos;
+  hasRequiredEnvironmentIsIos = 1;
+  var userAgent = requireEnvironmentUserAgent();
+  environmentIsIos = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent);
+  return environmentIsIos;
+}
+var task;
+var hasRequiredTask;
+function requireTask() {
+  if (hasRequiredTask) return task;
+  hasRequiredTask = 1;
+  var globalThis = requireGlobalThis();
+  var apply = requireFunctionApply();
+  var bind = requireFunctionBindContext();
+  var isCallable = requireIsCallable();
+  var hasOwn = requireHasOwnProperty();
+  var fails = requireFails();
+  var html = requireHtml();
+  var arraySlice2 = requireArraySlice();
+  var createElement = requireDocumentCreateElement();
+  var validateArgumentsLength2 = requireValidateArgumentsLength();
+  var IS_IOS = requireEnvironmentIsIos();
+  var IS_NODE = requireEnvironmentIsNode();
+  var set = globalThis.setImmediate;
+  var clear = globalThis.clearImmediate;
+  var process = globalThis.process;
+  var Dispatch = globalThis.Dispatch;
+  var Function2 = globalThis.Function;
+  var MessageChannel = globalThis.MessageChannel;
+  var String2 = globalThis.String;
+  var counter = 0;
+  var queue2 = {};
+  var ONREADYSTATECHANGE = "onreadystatechange";
+  var $location, defer, channel, port;
+  fails(function() {
+    $location = globalThis.location;
+  });
+  var run = function(id) {
+    if (hasOwn(queue2, id)) {
+      var fn = queue2[id];
+      delete queue2[id];
+      fn();
+    }
+  };
+  var runner = function(id) {
+    return function() {
+      run(id);
+    };
+  };
+  var eventListener = function(event) {
+    run(event.data);
+  };
+  var globalPostMessageDefer = function(id) {
+    globalThis.postMessage(String2(id), $location.protocol + "//" + $location.host);
+  };
+  if (!set || !clear) {
+    set = function setImmediate(handler) {
+      validateArgumentsLength2(arguments.length, 1);
+      var fn = isCallable(handler) ? handler : Function2(handler);
+      var args = arraySlice2(arguments, 1);
+      queue2[++counter] = function() {
+        apply(fn, void 0, args);
+      };
+      defer(counter);
+      return counter;
+    };
+    clear = function clearImmediate(id) {
+      delete queue2[id];
+    };
+    if (IS_NODE) {
+      defer = function(id) {
+        process.nextTick(runner(id));
+      };
+    } else if (Dispatch && Dispatch.now) {
+      defer = function(id) {
+        Dispatch.now(runner(id));
+      };
+    } else if (MessageChannel && !IS_IOS) {
+      channel = new MessageChannel();
+      port = channel.port2;
+      channel.port1.onmessage = eventListener;
+      defer = bind(port.postMessage, port);
+    } else if (globalThis.addEventListener && isCallable(globalThis.postMessage) && !globalThis.importScripts && $location && $location.protocol !== "file:" && !fails(globalPostMessageDefer)) {
+      defer = globalPostMessageDefer;
+      globalThis.addEventListener("message", eventListener, false);
+    } else if (ONREADYSTATECHANGE in createElement("script")) {
+      defer = function(id) {
+        html.appendChild(createElement("script"))[ONREADYSTATECHANGE] = function() {
+          html.removeChild(this);
+          run(id);
+        };
+      };
+    } else {
+      defer = function(id) {
+        setTimeout(runner(id), 0);
+      };
+    }
+  }
+  task = {
+    set,
+    clear
+  };
+  return task;
+}
+var safeGetBuiltIn;
+var hasRequiredSafeGetBuiltIn;
+function requireSafeGetBuiltIn() {
+  if (hasRequiredSafeGetBuiltIn) return safeGetBuiltIn;
+  hasRequiredSafeGetBuiltIn = 1;
+  var globalThis = requireGlobalThis();
+  var DESCRIPTORS = requireDescriptors();
+  var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+  safeGetBuiltIn = function(name) {
+    if (!DESCRIPTORS) return globalThis[name];
+    var descriptor = getOwnPropertyDescriptor(globalThis, name);
+    return descriptor && descriptor.value;
+  };
+  return safeGetBuiltIn;
+}
+var queue;
+var hasRequiredQueue;
+function requireQueue() {
+  if (hasRequiredQueue) return queue;
+  hasRequiredQueue = 1;
+  var Queue = function() {
+    this.head = null;
+    this.tail = null;
+  };
+  Queue.prototype = {
+    add: function(item) {
+      var entry = { item, next: null };
+      var tail = this.tail;
+      if (tail) tail.next = entry;
+      else this.head = entry;
+      this.tail = entry;
+    },
+    get: function() {
+      var entry = this.head;
+      if (entry) {
+        var next = this.head = entry.next;
+        if (next === null) this.tail = null;
+        return entry.item;
+      }
+    }
+  };
+  queue = Queue;
+  return queue;
+}
+var environmentIsIosPebble;
+var hasRequiredEnvironmentIsIosPebble;
+function requireEnvironmentIsIosPebble() {
+  if (hasRequiredEnvironmentIsIosPebble) return environmentIsIosPebble;
+  hasRequiredEnvironmentIsIosPebble = 1;
+  var userAgent = requireEnvironmentUserAgent();
+  environmentIsIosPebble = /ipad|iphone|ipod/i.test(userAgent) && typeof Pebble != "undefined";
+  return environmentIsIosPebble;
+}
+var environmentIsWebosWebkit;
+var hasRequiredEnvironmentIsWebosWebkit;
+function requireEnvironmentIsWebosWebkit() {
+  if (hasRequiredEnvironmentIsWebosWebkit) return environmentIsWebosWebkit;
+  hasRequiredEnvironmentIsWebosWebkit = 1;
+  var userAgent = requireEnvironmentUserAgent();
+  environmentIsWebosWebkit = /web0s(?!.*chrome)/i.test(userAgent);
+  return environmentIsWebosWebkit;
+}
+var microtask_1;
+var hasRequiredMicrotask;
+function requireMicrotask() {
+  if (hasRequiredMicrotask) return microtask_1;
+  hasRequiredMicrotask = 1;
+  var globalThis = requireGlobalThis();
+  var safeGetBuiltIn2 = requireSafeGetBuiltIn();
+  var bind = requireFunctionBindContext();
+  var macrotask = requireTask().set;
+  var Queue = requireQueue();
+  var IS_IOS = requireEnvironmentIsIos();
+  var IS_IOS_PEBBLE = requireEnvironmentIsIosPebble();
+  var IS_WEBOS_WEBKIT = requireEnvironmentIsWebosWebkit();
+  var IS_NODE = requireEnvironmentIsNode();
+  var MutationObserver = globalThis.MutationObserver || globalThis.WebKitMutationObserver;
+  var document = globalThis.document;
+  var process = globalThis.process;
+  var Promise2 = globalThis.Promise;
+  var microtask = safeGetBuiltIn2("queueMicrotask");
+  var notify, toggle, node, promise, then;
+  if (!microtask) {
+    var queue2 = new Queue();
+    var flush = function() {
+      var parent, fn;
+      if (IS_NODE && (parent = process.domain)) parent.exit();
+      while (fn = queue2.get()) try {
+        fn();
+      } catch (error) {
+        if (queue2.head) notify();
+        throw error;
+      }
+      if (parent) parent.enter();
+    };
+    if (!IS_IOS && !IS_NODE && !IS_WEBOS_WEBKIT && MutationObserver && document) {
+      toggle = true;
+      node = document.createTextNode("");
+      new MutationObserver(flush).observe(node, { characterData: true });
+      notify = function() {
+        node.data = toggle = !toggle;
+      };
+    } else if (!IS_IOS_PEBBLE && Promise2 && Promise2.resolve) {
+      promise = Promise2.resolve(void 0);
+      promise.constructor = Promise2;
+      then = bind(promise.then, promise);
+      notify = function() {
+        then(flush);
+      };
+    } else if (IS_NODE) {
+      notify = function() {
+        process.nextTick(flush);
+      };
+    } else {
+      macrotask = bind(macrotask, globalThis);
+      notify = function() {
+        macrotask(flush);
+      };
+    }
+    microtask = function(fn) {
+      if (!queue2.head) notify();
+      queue2.add(fn);
+    };
+  }
+  microtask_1 = microtask;
+  return microtask_1;
+}
+var hostReportErrors;
+var hasRequiredHostReportErrors;
+function requireHostReportErrors() {
+  if (hasRequiredHostReportErrors) return hostReportErrors;
+  hasRequiredHostReportErrors = 1;
+  hostReportErrors = function(a, b) {
+    try {
+      arguments.length === 1 ? console.error(a) : console.error(a, b);
+    } catch (error) {
+    }
+  };
+  return hostReportErrors;
+}
+var perform;
+var hasRequiredPerform;
+function requirePerform() {
+  if (hasRequiredPerform) return perform;
+  hasRequiredPerform = 1;
+  perform = function(exec) {
+    try {
+      return { error: false, value: exec() };
+    } catch (error) {
+      return { error: true, value: error };
+    }
+  };
+  return perform;
+}
+var promiseNativeConstructor;
+var hasRequiredPromiseNativeConstructor;
+function requirePromiseNativeConstructor() {
+  if (hasRequiredPromiseNativeConstructor) return promiseNativeConstructor;
+  hasRequiredPromiseNativeConstructor = 1;
+  var globalThis = requireGlobalThis();
+  promiseNativeConstructor = globalThis.Promise;
+  return promiseNativeConstructor;
+}
+var promiseConstructorDetection;
+var hasRequiredPromiseConstructorDetection;
+function requirePromiseConstructorDetection() {
+  if (hasRequiredPromiseConstructorDetection) return promiseConstructorDetection;
+  hasRequiredPromiseConstructorDetection = 1;
+  var globalThis = requireGlobalThis();
+  var NativePromiseConstructor = requirePromiseNativeConstructor();
+  var isCallable = requireIsCallable();
+  var isForced = requireIsForced();
+  var inspectSource = requireInspectSource();
+  var wellKnownSymbol = requireWellKnownSymbol();
+  var ENVIRONMENT = requireEnvironment();
+  var IS_PURE = requireIsPure();
+  var V8_VERSION = requireEnvironmentV8Version();
+  var NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;
+  var SPECIES = wellKnownSymbol("species");
+  var SUBCLASSING = false;
+  var NATIVE_PROMISE_REJECTION_EVENT = isCallable(globalThis.PromiseRejectionEvent);
+  var FORCED_PROMISE_CONSTRUCTOR = isForced("Promise", function() {
+    var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(NativePromiseConstructor);
+    var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(NativePromiseConstructor);
+    if (!GLOBAL_CORE_JS_PROMISE && V8_VERSION === 66) return true;
+    if (IS_PURE && !(NativePromisePrototype["catch"] && NativePromisePrototype["finally"])) return true;
+    if (!V8_VERSION || V8_VERSION < 51 || !/native code/.test(PROMISE_CONSTRUCTOR_SOURCE)) {
+      var promise = new NativePromiseConstructor(function(resolve) {
+        resolve(1);
+      });
+      var FakePromise = function(exec) {
+        exec(function() {
+        }, function() {
+        });
+      };
+      var constructor = promise.constructor = {};
+      constructor[SPECIES] = FakePromise;
+      SUBCLASSING = promise.then(function() {
+      }) instanceof FakePromise;
+      if (!SUBCLASSING) return true;
+    }
+    return !GLOBAL_CORE_JS_PROMISE && (ENVIRONMENT === "BROWSER" || ENVIRONMENT === "DENO") && !NATIVE_PROMISE_REJECTION_EVENT;
+  });
+  promiseConstructorDetection = {
+    CONSTRUCTOR: FORCED_PROMISE_CONSTRUCTOR,
+    REJECTION_EVENT: NATIVE_PROMISE_REJECTION_EVENT,
+    SUBCLASSING
+  };
+  return promiseConstructorDetection;
+}
+var newPromiseCapability = {};
+var hasRequiredNewPromiseCapability;
+function requireNewPromiseCapability() {
+  if (hasRequiredNewPromiseCapability) return newPromiseCapability;
+  hasRequiredNewPromiseCapability = 1;
+  var aCallable = requireACallable();
+  var $TypeError = TypeError;
+  var PromiseCapability = function(C) {
+    var resolve, reject;
+    this.promise = new C(function($$resolve, $$reject) {
+      if (resolve !== void 0 || reject !== void 0) throw new $TypeError("Bad Promise constructor");
+      resolve = $$resolve;
+      reject = $$reject;
+    });
+    this.resolve = aCallable(resolve);
+    this.reject = aCallable(reject);
+  };
+  newPromiseCapability.f = function(C) {
+    return new PromiseCapability(C);
+  };
+  return newPromiseCapability;
+}
+var hasRequiredEs_promise_constructor;
+function requireEs_promise_constructor() {
+  if (hasRequiredEs_promise_constructor) return es_promise_constructor;
+  hasRequiredEs_promise_constructor = 1;
+  var $ = require_export();
+  var IS_PURE = requireIsPure();
+  var IS_NODE = requireEnvironmentIsNode();
+  var globalThis = requireGlobalThis();
+  var path = requirePath();
+  var call = requireFunctionCall();
+  var defineBuiltIn = requireDefineBuiltIn();
+  var setPrototypeOf = requireObjectSetPrototypeOf();
+  var setToStringTag2 = requireSetToStringTag();
+  var setSpecies2 = requireSetSpecies();
+  var aCallable = requireACallable();
+  var isCallable = requireIsCallable();
+  var isObject = requireIsObject();
+  var anInstance = requireAnInstance();
+  var speciesConstructor2 = requireSpeciesConstructor();
+  var task2 = requireTask().set;
+  var microtask = requireMicrotask();
+  var hostReportErrors2 = requireHostReportErrors();
+  var perform2 = requirePerform();
+  var Queue = requireQueue();
+  var InternalStateModule = requireInternalState();
+  var NativePromiseConstructor = requirePromiseNativeConstructor();
+  var PromiseConstructorDetection = requirePromiseConstructorDetection();
+  var newPromiseCapabilityModule = requireNewPromiseCapability();
+  var PROMISE = "Promise";
+  var FORCED_PROMISE_CONSTRUCTOR = PromiseConstructorDetection.CONSTRUCTOR;
+  var NATIVE_PROMISE_REJECTION_EVENT = PromiseConstructorDetection.REJECTION_EVENT;
+  var NATIVE_PROMISE_SUBCLASSING = PromiseConstructorDetection.SUBCLASSING;
+  var getInternalPromiseState = InternalStateModule.getterFor(PROMISE);
+  var setInternalState = InternalStateModule.set;
+  var NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;
+  var PromiseConstructor = NativePromiseConstructor;
+  var PromisePrototype = NativePromisePrototype;
+  var TypeError2 = globalThis.TypeError;
+  var document = globalThis.document;
+  var process = globalThis.process;
+  var newPromiseCapability2 = newPromiseCapabilityModule.f;
+  var newGenericPromiseCapability = newPromiseCapability2;
+  var DISPATCH_EVENT = !!(document && document.createEvent && globalThis.dispatchEvent);
+  var UNHANDLED_REJECTION = "unhandledrejection";
+  var REJECTION_HANDLED = "rejectionhandled";
+  var PENDING = 0;
+  var FULFILLED = 1;
+  var REJECTED = 2;
+  var HANDLED = 1;
+  var UNHANDLED = 2;
+  var Internal, OwnPromiseCapability, PromiseWrapper, nativeThen;
+  var isThenable = function(it) {
+    var then;
+    return isObject(it) && isCallable(then = it.then) ? then : false;
+  };
+  var callReaction = function(reaction, state) {
+    var value = state.value;
+    var ok = state.state === FULFILLED;
+    var handler = ok ? reaction.ok : reaction.fail;
+    var resolve = reaction.resolve;
+    var reject = reaction.reject;
+    var domain = reaction.domain;
+    var result, then, exited;
+    try {
+      if (handler) {
+        if (!ok) {
+          if (state.rejection === UNHANDLED) onHandleUnhandled(state);
+          state.rejection = HANDLED;
+        }
+        if (handler === true) result = value;
+        else {
+          if (domain) domain.enter();
+          result = handler(value);
+          if (domain) {
+            domain.exit();
+            exited = true;
+          }
+        }
+        if (result === reaction.promise) {
+          reject(new TypeError2("Promise-chain cycle"));
+        } else if (then = isThenable(result)) {
+          call(then, result, resolve, reject);
+        } else resolve(result);
+      } else reject(value);
+    } catch (error) {
+      if (domain && !exited) domain.exit();
+      reject(error);
+    }
+  };
+  var notify = function(state, isReject) {
+    if (state.notified) return;
+    state.notified = true;
+    microtask(function() {
+      var reactions = state.reactions;
+      var reaction;
+      while (reaction = reactions.get()) {
+        callReaction(reaction, state);
+      }
+      state.notified = false;
+      if (isReject && !state.rejection) onUnhandled(state);
+    });
+  };
+  var dispatchEvent = function(name, promise, reason) {
+    var event, handler;
+    if (DISPATCH_EVENT) {
+      event = document.createEvent("Event");
+      event.promise = promise;
+      event.reason = reason;
+      event.initEvent(name, false, true);
+      globalThis.dispatchEvent(event);
+    } else event = { promise, reason };
+    if (!NATIVE_PROMISE_REJECTION_EVENT && (handler = globalThis["on" + name])) handler(event);
+    else if (name === UNHANDLED_REJECTION) hostReportErrors2("Unhandled promise rejection", reason);
+  };
+  var onUnhandled = function(state) {
+    call(task2, globalThis, function() {
+      var promise = state.facade;
+      var value = state.value;
+      var IS_UNHANDLED = isUnhandled(state);
+      var result;
+      if (IS_UNHANDLED) {
+        result = perform2(function() {
+          if (IS_NODE) {
+            process.emit("unhandledRejection", value, promise);
+          } else dispatchEvent(UNHANDLED_REJECTION, promise, value);
+        });
+        state.rejection = IS_NODE || isUnhandled(state) ? UNHANDLED : HANDLED;
+        if (result.error) throw result.value;
+      }
+    });
+  };
+  var isUnhandled = function(state) {
+    return state.rejection !== HANDLED && !state.parent;
+  };
+  var onHandleUnhandled = function(state) {
+    call(task2, globalThis, function() {
+      var promise = state.facade;
+      if (IS_NODE) {
+        process.emit("rejectionHandled", promise);
+      } else dispatchEvent(REJECTION_HANDLED, promise, state.value);
+    });
+  };
+  var bind = function(fn, state, unwrap) {
+    return function(value) {
+      fn(state, value, unwrap);
+    };
+  };
+  var internalReject = function(state, value, unwrap) {
+    if (state.done) return;
+    state.done = true;
+    if (unwrap) state = unwrap;
+    state.value = value;
+    state.state = REJECTED;
+    notify(state, true);
+  };
+  var internalResolve = function(state, value, unwrap) {
+    if (state.done) return;
+    state.done = true;
+    if (unwrap) state = unwrap;
+    try {
+      if (state.facade === value) throw new TypeError2("Promise can't be resolved itself");
+      var then = isThenable(value);
+      if (then) {
+        microtask(function() {
+          var wrapper = { done: false };
+          try {
+            call(
+              then,
+              value,
+              bind(internalResolve, wrapper, state),
+              bind(internalReject, wrapper, state)
+            );
+          } catch (error) {
+            internalReject(wrapper, error, state);
+          }
+        });
+      } else {
+        state.value = value;
+        state.state = FULFILLED;
+        notify(state, false);
+      }
+    } catch (error) {
+      internalReject({ done: false }, error, state);
+    }
+  };
+  if (FORCED_PROMISE_CONSTRUCTOR) {
+    PromiseConstructor = function Promise2(executor) {
+      anInstance(this, PromisePrototype);
+      aCallable(executor);
+      call(Internal, this);
+      var state = getInternalPromiseState(this);
+      try {
+        executor(bind(internalResolve, state), bind(internalReject, state));
+      } catch (error) {
+        internalReject(state, error);
+      }
+    };
+    PromisePrototype = PromiseConstructor.prototype;
+    Internal = function Promise2(executor) {
+      setInternalState(this, {
+        type: PROMISE,
+        done: false,
+        notified: false,
+        parent: false,
+        reactions: new Queue(),
+        rejection: false,
+        state: PENDING,
+        value: null
+      });
+    };
+    Internal.prototype = defineBuiltIn(PromisePrototype, "then", function then(onFulfilled, onRejected) {
+      var state = getInternalPromiseState(this);
+      var reaction = newPromiseCapability2(speciesConstructor2(this, PromiseConstructor));
+      state.parent = true;
+      reaction.ok = isCallable(onFulfilled) ? onFulfilled : true;
+      reaction.fail = isCallable(onRejected) && onRejected;
+      reaction.domain = IS_NODE ? process.domain : void 0;
+      if (state.state === PENDING) state.reactions.add(reaction);
+      else microtask(function() {
+        callReaction(reaction, state);
+      });
+      return reaction.promise;
+    });
+    OwnPromiseCapability = function() {
+      var promise = new Internal();
+      var state = getInternalPromiseState(promise);
+      this.promise = promise;
+      this.resolve = bind(internalResolve, state);
+      this.reject = bind(internalReject, state);
+    };
+    newPromiseCapabilityModule.f = newPromiseCapability2 = function(C) {
+      return C === PromiseConstructor || C === PromiseWrapper ? new OwnPromiseCapability(C) : newGenericPromiseCapability(C);
+    };
+    if (!IS_PURE && isCallable(NativePromiseConstructor) && NativePromisePrototype !== Object.prototype) {
+      nativeThen = NativePromisePrototype.then;
+      if (!NATIVE_PROMISE_SUBCLASSING) {
+        defineBuiltIn(NativePromisePrototype, "then", function then(onFulfilled, onRejected) {
+          var that = this;
+          return new PromiseConstructor(function(resolve, reject) {
+            call(nativeThen, that, resolve, reject);
+          }).then(onFulfilled, onRejected);
+        }, { unsafe: true });
+      }
+      try {
+        delete NativePromisePrototype.constructor;
+      } catch (error) {
+      }
+      if (setPrototypeOf) {
+        setPrototypeOf(NativePromisePrototype, PromisePrototype);
+      }
+    }
+  }
+  $({ global: true, constructor: true, wrap: true, forced: FORCED_PROMISE_CONSTRUCTOR }, {
+    Promise: PromiseConstructor
+  });
+  PromiseWrapper = path.Promise;
+  setToStringTag2(PromiseConstructor, PROMISE, false, true);
+  setSpecies2(PROMISE);
+  return es_promise_constructor;
+}
+var es_promise_all = {};
+var iterators;
+var hasRequiredIterators;
+function requireIterators() {
+  if (hasRequiredIterators) return iterators;
+  hasRequiredIterators = 1;
+  iterators = {};
+  return iterators;
+}
+var isArrayIteratorMethod;
+var hasRequiredIsArrayIteratorMethod;
+function requireIsArrayIteratorMethod() {
+  if (hasRequiredIsArrayIteratorMethod) return isArrayIteratorMethod;
+  hasRequiredIsArrayIteratorMethod = 1;
+  var wellKnownSymbol = requireWellKnownSymbol();
+  var Iterators = requireIterators();
+  var ITERATOR = wellKnownSymbol("iterator");
+  var ArrayPrototype = Array.prototype;
+  isArrayIteratorMethod = function(it) {
+    return it !== void 0 && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it);
+  };
+  return isArrayIteratorMethod;
+}
+var getIteratorMethod;
+var hasRequiredGetIteratorMethod;
+function requireGetIteratorMethod() {
+  if (hasRequiredGetIteratorMethod) return getIteratorMethod;
+  hasRequiredGetIteratorMethod = 1;
+  var classof = requireClassof();
+  var getMethod = requireGetMethod();
+  var isNullOrUndefined = requireIsNullOrUndefined();
+  var Iterators = requireIterators();
+  var wellKnownSymbol = requireWellKnownSymbol();
+  var ITERATOR = wellKnownSymbol("iterator");
+  getIteratorMethod = function(it) {
+    if (!isNullOrUndefined(it)) return getMethod(it, ITERATOR) || getMethod(it, "@@iterator") || Iterators[classof(it)];
+  };
+  return getIteratorMethod;
+}
+var getIterator;
+var hasRequiredGetIterator;
+function requireGetIterator() {
+  if (hasRequiredGetIterator) return getIterator;
+  hasRequiredGetIterator = 1;
+  var call = requireFunctionCall();
+  var aCallable = requireACallable();
+  var anObject = requireAnObject();
+  var tryToString = requireTryToString();
+  var getIteratorMethod2 = requireGetIteratorMethod();
+  var $TypeError = TypeError;
+  getIterator = function(argument, usingIterator) {
+    var iteratorMethod = arguments.length < 2 ? getIteratorMethod2(argument) : usingIterator;
+    if (aCallable(iteratorMethod)) return anObject(call(iteratorMethod, argument));
+    throw new $TypeError(tryToString(argument) + " is not iterable");
+  };
+  return getIterator;
+}
+var iteratorClose;
+var hasRequiredIteratorClose;
+function requireIteratorClose() {
+  if (hasRequiredIteratorClose) return iteratorClose;
+  hasRequiredIteratorClose = 1;
+  var call = requireFunctionCall();
+  var anObject = requireAnObject();
+  var getMethod = requireGetMethod();
+  iteratorClose = function(iterator, kind, value) {
+    var innerResult, innerError;
+    anObject(iterator);
+    try {
+      innerResult = getMethod(iterator, "return");
+      if (!innerResult) {
+        if (kind === "throw") throw value;
+        return value;
+      }
+      innerResult = call(innerResult, iterator);
+    } catch (error) {
+      innerError = true;
+      innerResult = error;
+    }
+    if (kind === "throw") throw value;
+    if (innerError) throw innerResult;
+    anObject(innerResult);
+    return value;
+  };
+  return iteratorClose;
+}
+var iterate;
+var hasRequiredIterate;
+function requireIterate() {
+  if (hasRequiredIterate) return iterate;
+  hasRequiredIterate = 1;
+  var bind = requireFunctionBindContext();
+  var call = requireFunctionCall();
+  var anObject = requireAnObject();
+  var tryToString = requireTryToString();
+  var isArrayIteratorMethod2 = requireIsArrayIteratorMethod();
+  var lengthOfArrayLike = requireLengthOfArrayLike();
+  var isPrototypeOf = requireObjectIsPrototypeOf();
+  var getIterator2 = requireGetIterator();
+  var getIteratorMethod2 = requireGetIteratorMethod();
+  var iteratorClose2 = requireIteratorClose();
+  var $TypeError = TypeError;
+  var Result = function(stopped, result) {
+    this.stopped = stopped;
+    this.result = result;
+  };
+  var ResultPrototype = Result.prototype;
+  iterate = function(iterable, unboundFunction, options) {
+    var that = options && options.that;
+    var AS_ENTRIES = !!(options && options.AS_ENTRIES);
+    var IS_RECORD = !!(options && options.IS_RECORD);
+    var IS_ITERATOR = !!(options && options.IS_ITERATOR);
+    var INTERRUPTED = !!(options && options.INTERRUPTED);
+    var fn = bind(unboundFunction, that);
+    var iterator, iterFn, index, length, result, next, step;
+    var stop = function(condition) {
+      if (iterator) iteratorClose2(iterator, "normal");
+      return new Result(true, condition);
+    };
+    var callFn = function(value) {
+      if (AS_ENTRIES) {
+        anObject(value);
+        return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);
+      }
+      return INTERRUPTED ? fn(value, stop) : fn(value);
+    };
+    if (IS_RECORD) {
+      iterator = iterable.iterator;
+    } else if (IS_ITERATOR) {
+      iterator = iterable;
+    } else {
+      iterFn = getIteratorMethod2(iterable);
+      if (!iterFn) throw new $TypeError(tryToString(iterable) + " is not iterable");
+      if (isArrayIteratorMethod2(iterFn)) {
+        for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) {
+          result = callFn(iterable[index]);
+          if (result && isPrototypeOf(ResultPrototype, result)) return result;
+        }
+        return new Result(false);
+      }
+      iterator = getIterator2(iterable, iterFn);
+    }
+    next = IS_RECORD ? iterable.next : iterator.next;
+    while (!(step = call(next, iterator)).done) {
+      try {
+        result = callFn(step.value);
+      } catch (error) {
+        iteratorClose2(iterator, "throw", error);
+      }
+      if (typeof result == "object" && result && isPrototypeOf(ResultPrototype, result)) return result;
+    }
+    return new Result(false);
+  };
+  return iterate;
+}
+var checkCorrectnessOfIteration;
+var hasRequiredCheckCorrectnessOfIteration;
+function requireCheckCorrectnessOfIteration() {
+  if (hasRequiredCheckCorrectnessOfIteration) return checkCorrectnessOfIteration;
+  hasRequiredCheckCorrectnessOfIteration = 1;
+  var wellKnownSymbol = requireWellKnownSymbol();
+  var ITERATOR = wellKnownSymbol("iterator");
+  var SAFE_CLOSING = false;
+  try {
+    var called = 0;
+    var iteratorWithReturn = {
+      next: function() {
+        return { done: !!called++ };
+      },
+      "return": function() {
+        SAFE_CLOSING = true;
+      }
+    };
+    iteratorWithReturn[ITERATOR] = function() {
+      return this;
+    };
+    Array.from(iteratorWithReturn, function() {
+      throw 2;
+    });
+  } catch (error) {
+  }
+  checkCorrectnessOfIteration = function(exec, SKIP_CLOSING) {
+    try {
+      if (!SKIP_CLOSING && !SAFE_CLOSING) return false;
+    } catch (error) {
+      return false;
+    }
+    var ITERATION_SUPPORT = false;
+    try {
+      var object = {};
+      object[ITERATOR] = function() {
+        return {
+          next: function() {
+            return { done: ITERATION_SUPPORT = true };
+          }
+        };
+      };
+      exec(object);
+    } catch (error) {
+    }
+    return ITERATION_SUPPORT;
+  };
+  return checkCorrectnessOfIteration;
+}
+var promiseStaticsIncorrectIteration;
+var hasRequiredPromiseStaticsIncorrectIteration;
+function requirePromiseStaticsIncorrectIteration() {
+  if (hasRequiredPromiseStaticsIncorrectIteration) return promiseStaticsIncorrectIteration;
+  hasRequiredPromiseStaticsIncorrectIteration = 1;
+  var NativePromiseConstructor = requirePromiseNativeConstructor();
+  var checkCorrectnessOfIteration2 = requireCheckCorrectnessOfIteration();
+  var FORCED_PROMISE_CONSTRUCTOR = requirePromiseConstructorDetection().CONSTRUCTOR;
+  promiseStaticsIncorrectIteration = FORCED_PROMISE_CONSTRUCTOR || !checkCorrectnessOfIteration2(function(iterable) {
+    NativePromiseConstructor.all(iterable).then(void 0, function() {
+    });
+  });
+  return promiseStaticsIncorrectIteration;
+}
+var hasRequiredEs_promise_all;
+function requireEs_promise_all() {
+  if (hasRequiredEs_promise_all) return es_promise_all;
+  hasRequiredEs_promise_all = 1;
+  var $ = require_export();
+  var call = requireFunctionCall();
+  var aCallable = requireACallable();
+  var newPromiseCapabilityModule = requireNewPromiseCapability();
+  var perform2 = requirePerform();
+  var iterate2 = requireIterate();
+  var PROMISE_STATICS_INCORRECT_ITERATION = requirePromiseStaticsIncorrectIteration();
+  $({ target: "Promise", stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, {
+    all: function all(iterable) {
+      var C = this;
+      var capability = newPromiseCapabilityModule.f(C);
+      var resolve = capability.resolve;
+      var reject = capability.reject;
+      var result = perform2(function() {
+        var $promiseResolve = aCallable(C.resolve);
+        var values = [];
+        var counter = 0;
+        var remaining = 1;
+        iterate2(iterable, function(promise) {
+          var index = counter++;
+          var alreadyCalled = false;
+          remaining++;
+          call($promiseResolve, C, promise).then(function(value) {
+            if (alreadyCalled) return;
+            alreadyCalled = true;
+            values[index] = value;
+            --remaining || resolve(values);
+          }, reject);
+        });
+        --remaining || resolve(values);
+      });
+      if (result.error) reject(result.value);
+      return capability.promise;
+    }
+  });
+  return es_promise_all;
+}
+var es_promise_catch = {};
+var hasRequiredEs_promise_catch;
+function requireEs_promise_catch() {
+  if (hasRequiredEs_promise_catch) return es_promise_catch;
+  hasRequiredEs_promise_catch = 1;
+  var $ = require_export();
+  var IS_PURE = requireIsPure();
+  var FORCED_PROMISE_CONSTRUCTOR = requirePromiseConstructorDetection().CONSTRUCTOR;
+  var NativePromiseConstructor = requirePromiseNativeConstructor();
+  var getBuiltIn = requireGetBuiltIn();
+  var isCallable = requireIsCallable();
+  var defineBuiltIn = requireDefineBuiltIn();
+  var NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;
+  $({ target: "Promise", proto: true, forced: FORCED_PROMISE_CONSTRUCTOR, real: true }, {
+    "catch": function(onRejected) {
+      return this.then(void 0, onRejected);
+    }
+  });
+  if (!IS_PURE && isCallable(NativePromiseConstructor)) {
+    var method = getBuiltIn("Promise").prototype["catch"];
+    if (NativePromisePrototype["catch"] !== method) {
+      defineBuiltIn(NativePromisePrototype, "catch", method, { unsafe: true });
+    }
+  }
+  return es_promise_catch;
+}
+var es_promise_race = {};
+var hasRequiredEs_promise_race;
+function requireEs_promise_race() {
+  if (hasRequiredEs_promise_race) return es_promise_race;
+  hasRequiredEs_promise_race = 1;
+  var $ = require_export();
+  var call = requireFunctionCall();
+  var aCallable = requireACallable();
+  var newPromiseCapabilityModule = requireNewPromiseCapability();
+  var perform2 = requirePerform();
+  var iterate2 = requireIterate();
+  var PROMISE_STATICS_INCORRECT_ITERATION = requirePromiseStaticsIncorrectIteration();
+  $({ target: "Promise", stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, {
+    race: function race(iterable) {
+      var C = this;
+      var capability = newPromiseCapabilityModule.f(C);
+      var reject = capability.reject;
+      var result = perform2(function() {
+        var $promiseResolve = aCallable(C.resolve);
+        iterate2(iterable, function(promise) {
+          call($promiseResolve, C, promise).then(capability.resolve, reject);
+        });
+      });
+      if (result.error) reject(result.value);
+      return capability.promise;
+    }
+  });
+  return es_promise_race;
+}
+var es_promise_reject = {};
+var hasRequiredEs_promise_reject;
+function requireEs_promise_reject() {
+  if (hasRequiredEs_promise_reject) return es_promise_reject;
+  hasRequiredEs_promise_reject = 1;
+  var $ = require_export();
+  var newPromiseCapabilityModule = requireNewPromiseCapability();
+  var FORCED_PROMISE_CONSTRUCTOR = requirePromiseConstructorDetection().CONSTRUCTOR;
+  $({ target: "Promise", stat: true, forced: FORCED_PROMISE_CONSTRUCTOR }, {
+    reject: function reject(r) {
+      var capability = newPromiseCapabilityModule.f(this);
+      var capabilityReject = capability.reject;
+      capabilityReject(r);
+      return capability.promise;
+    }
+  });
+  return es_promise_reject;
+}
+var es_promise_resolve = {};
+var promiseResolve;
+var hasRequiredPromiseResolve;
+function requirePromiseResolve() {
+  if (hasRequiredPromiseResolve) return promiseResolve;
+  hasRequiredPromiseResolve = 1;
+  var anObject = requireAnObject();
+  var isObject = requireIsObject();
+  var newPromiseCapability2 = requireNewPromiseCapability();
+  promiseResolve = function(C, x) {
+    anObject(C);
+    if (isObject(x) && x.constructor === C) return x;
+    var promiseCapability = newPromiseCapability2.f(C);
+    var resolve = promiseCapability.resolve;
+    resolve(x);
+    return promiseCapability.promise;
+  };
+  return promiseResolve;
+}
+var hasRequiredEs_promise_resolve;
+function requireEs_promise_resolve() {
+  if (hasRequiredEs_promise_resolve) return es_promise_resolve;
+  hasRequiredEs_promise_resolve = 1;
+  var $ = require_export();
+  var getBuiltIn = requireGetBuiltIn();
+  var IS_PURE = requireIsPure();
+  var NativePromiseConstructor = requirePromiseNativeConstructor();
+  var FORCED_PROMISE_CONSTRUCTOR = requirePromiseConstructorDetection().CONSTRUCTOR;
+  var promiseResolve2 = requirePromiseResolve();
+  var PromiseConstructorWrapper = getBuiltIn("Promise");
+  var CHECK_WRAPPER = IS_PURE && !FORCED_PROMISE_CONSTRUCTOR;
+  $({ target: "Promise", stat: true, forced: IS_PURE || FORCED_PROMISE_CONSTRUCTOR }, {
+    resolve: function resolve(x) {
+      return promiseResolve2(CHECK_WRAPPER && this === PromiseConstructorWrapper ? NativePromiseConstructor : this, x);
+    }
+  });
+  return es_promise_resolve;
+}
+var hasRequiredEs_promise;
+function requireEs_promise() {
+  if (hasRequiredEs_promise) return es_promise;
+  hasRequiredEs_promise = 1;
+  requireEs_promise_constructor();
+  requireEs_promise_all();
+  requireEs_promise_catch();
+  requireEs_promise_race();
+  requireEs_promise_reject();
+  requireEs_promise_resolve();
+  return es_promise;
+}
+var es_promise_withResolvers = {};
+var hasRequiredEs_promise_withResolvers;
+function requireEs_promise_withResolvers() {
+  if (hasRequiredEs_promise_withResolvers) return es_promise_withResolvers;
+  hasRequiredEs_promise_withResolvers = 1;
+  var $ = require_export();
+  var newPromiseCapabilityModule = requireNewPromiseCapability();
+  $({ target: "Promise", stat: true }, {
+    withResolvers: function withResolvers2() {
+      var promiseCapability = newPromiseCapabilityModule.f(this);
+      return {
+        promise: promiseCapability.promise,
+        resolve: promiseCapability.resolve,
+        reject: promiseCapability.reject
+      };
+    }
+  });
+  return es_promise_withResolvers;
+}
+var withResolvers$3;
+var hasRequiredWithResolvers$2;
+function requireWithResolvers$2() {
+  if (hasRequiredWithResolvers$2) return withResolvers$3;
+  hasRequiredWithResolvers$2 = 1;
+  requireEs_promise();
+  requireEs_promise_withResolvers();
+  var call = requireFunctionCall();
+  var isCallable = requireIsCallable();
+  var path = requirePath();
+  var Promise2 = path.Promise;
+  var promiseWithResolvers = Promise2.withResolvers;
+  withResolvers$3 = function withResolvers2() {
+    return call(promiseWithResolvers, isCallable(this) ? this : Promise2);
+  };
+  return withResolvers$3;
+}
+var withResolvers$2;
+var hasRequiredWithResolvers$1;
+function requireWithResolvers$1() {
+  if (hasRequiredWithResolvers$1) return withResolvers$2;
+  hasRequiredWithResolvers$1 = 1;
+  var parent = requireWithResolvers$2();
+  withResolvers$2 = parent;
+  return withResolvers$2;
+}
+var esnext_promise_withResolvers = {};
+var hasRequiredEsnext_promise_withResolvers;
+function requireEsnext_promise_withResolvers() {
+  if (hasRequiredEsnext_promise_withResolvers) return esnext_promise_withResolvers;
+  hasRequiredEsnext_promise_withResolvers = 1;
+  requireEs_promise_withResolvers();
+  return esnext_promise_withResolvers;
+}
+var withResolvers$1;
+var hasRequiredWithResolvers;
+function requireWithResolvers() {
+  if (hasRequiredWithResolvers) return withResolvers$1;
+  hasRequiredWithResolvers = 1;
+  var parent = requireWithResolvers$1();
+  requireEsnext_promise_withResolvers();
+  withResolvers$1 = parent;
+  return withResolvers$1;
+}
+requireWithResolvers();
+const withResolvers = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  withResolvers as w
+};
+//# sourceMappingURL=with-resolvers-0tPpPN4C.js.map