indisposed 0.0.6 → 0.0.8

package/dist/explicit-resource-management-BSyjFgS-.js

@@ -0,0 +1,837 @@
+import { r as requireFails, a as requireHasOwnProperty, b as requireSharedKey, c as requireToObject, d as requireIsCallable, e as requireObjectKeysInternal, f as requireEnumBugKeys, g as requireDescriptors, h as requireV8PrototypeDefineBug, i as requireObjectDefineProperty, j as requireAnObject, k as requireToIndexedObject, l as requireHtml, m as requireDocumentCreateElement, n as requireHiddenKeys, o as requireFunctionUncurryThis, p as requireCreatePropertyDescriptor, q as requireCreateNonEnumerableProperty, s as requireClassof, t as require_export, u as requireGlobalThis, v as requireObjectIsPrototypeOf, w as requireObjectSetPrototypeOf, x as requireCopyConstructorProperties, y as requireWellKnownSymbol, z as requireIsPure, A as requireDefineBuiltIn, B as requireGetBuiltIn, C as requireFunctionCall, D as requireFunctionBindContext, E as requireIsNullOrUndefined, F as requireACallable, G as requireGetMethod, H as requireAnInstance, I as requireDefineBuiltInAccessor, J as requireInternalState, K as requireEnvironmentV8Version, L as requireSharedStore, M as requireIsObject, N as requirePath, O as requireObjectGetOwnPropertyDescriptor } from "./path-DtH12Oyl.js";
+var explicitResourceManagement$1 = {};
+var esnext_suppressedError_constructor = {};
+var es_suppressedError_constructor = {};
+var correctPrototypeGetter;
+var hasRequiredCorrectPrototypeGetter;
+function requireCorrectPrototypeGetter() {
+  if (hasRequiredCorrectPrototypeGetter) return correctPrototypeGetter;
+  hasRequiredCorrectPrototypeGetter = 1;
+  var fails = requireFails();
+  correctPrototypeGetter = !fails(function() {
+    function F() {
+    }
+    F.prototype.constructor = null;
+    return Object.getPrototypeOf(new F()) !== F.prototype;
+  });
+  return correctPrototypeGetter;
+}
+var objectGetPrototypeOf;
+var hasRequiredObjectGetPrototypeOf;
+function requireObjectGetPrototypeOf() {
+  if (hasRequiredObjectGetPrototypeOf) return objectGetPrototypeOf;
+  hasRequiredObjectGetPrototypeOf = 1;
+  var hasOwn = requireHasOwnProperty();
+  var isCallable = requireIsCallable();
+  var toObject = requireToObject();
+  var sharedKey = requireSharedKey();
+  var CORRECT_PROTOTYPE_GETTER = requireCorrectPrototypeGetter();
+  var IE_PROTO = sharedKey("IE_PROTO");
+  var $Object = Object;
+  var ObjectPrototype = $Object.prototype;
+  objectGetPrototypeOf = CORRECT_PROTOTYPE_GETTER ? $Object.getPrototypeOf : function(O) {
+    var object = toObject(O);
+    if (hasOwn(object, IE_PROTO)) return object[IE_PROTO];
+    var constructor = object.constructor;
+    if (isCallable(constructor) && object instanceof constructor) {
+      return constructor.prototype;
+    }
+    return object instanceof $Object ? ObjectPrototype : null;
+  };
+  return objectGetPrototypeOf;
+}
+var objectDefineProperties = {};
+var objectKeys;
+var hasRequiredObjectKeys;
+function requireObjectKeys() {
+  if (hasRequiredObjectKeys) return objectKeys;
+  hasRequiredObjectKeys = 1;
+  var internalObjectKeys = requireObjectKeysInternal();
+  var enumBugKeys = requireEnumBugKeys();
+  objectKeys = Object.keys || function keys(O) {
+    return internalObjectKeys(O, enumBugKeys);
+  };
+  return objectKeys;
+}
+var hasRequiredObjectDefineProperties;
+function requireObjectDefineProperties() {
+  if (hasRequiredObjectDefineProperties) return objectDefineProperties;
+  hasRequiredObjectDefineProperties = 1;
+  var DESCRIPTORS = requireDescriptors();
+  var V8_PROTOTYPE_DEFINE_BUG = requireV8PrototypeDefineBug();
+  var definePropertyModule = requireObjectDefineProperty();
+  var anObject = requireAnObject();
+  var toIndexedObject = requireToIndexedObject();
+  var objectKeys2 = requireObjectKeys();
+  objectDefineProperties.f = DESCRIPTORS && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {
+    anObject(O);
+    var props = toIndexedObject(Properties);
+    var keys = objectKeys2(Properties);
+    var length = keys.length;
+    var index = 0;
+    var key;
+    while (length > index) definePropertyModule.f(O, key = keys[index++], props[key]);
+    return O;
+  };
+  return objectDefineProperties;
+}
+var objectCreate;
+var hasRequiredObjectCreate;
+function requireObjectCreate() {
+  if (hasRequiredObjectCreate) return objectCreate;
+  hasRequiredObjectCreate = 1;
+  var anObject = requireAnObject();
+  var definePropertiesModule = requireObjectDefineProperties();
+  var enumBugKeys = requireEnumBugKeys();
+  var hiddenKeys = requireHiddenKeys();
+  var html = requireHtml();
+  var documentCreateElement = requireDocumentCreateElement();
+  var sharedKey = requireSharedKey();
+  var GT = ">";
+  var LT = "<";
+  var PROTOTYPE = "prototype";
+  var SCRIPT = "script";
+  var IE_PROTO = sharedKey("IE_PROTO");
+  var EmptyConstructor = function() {
+  };
+  var scriptTag = function(content) {
+    return LT + SCRIPT + GT + content + LT + "/" + SCRIPT + GT;
+  };
+  var NullProtoObjectViaActiveX = function(activeXDocument2) {
+    activeXDocument2.write(scriptTag(""));
+    activeXDocument2.close();
+    var temp = activeXDocument2.parentWindow.Object;
+    activeXDocument2 = null;
+    return temp;
+  };
+  var NullProtoObjectViaIFrame = function() {
+    var iframe = documentCreateElement("iframe");
+    var JS = "java" + SCRIPT + ":";
+    var iframeDocument;
+    iframe.style.display = "none";
+    html.appendChild(iframe);
+    iframe.src = String(JS);
+    iframeDocument = iframe.contentWindow.document;
+    iframeDocument.open();
+    iframeDocument.write(scriptTag("document.F=Object"));
+    iframeDocument.close();
+    return iframeDocument.F;
+  };
+  var activeXDocument;
+  var NullProtoObject = function() {
+    try {
+      activeXDocument = new ActiveXObject("htmlfile");
+    } catch (error) {
+    }
+    NullProtoObject = typeof document != "undefined" ? document.domain && activeXDocument ? NullProtoObjectViaActiveX(activeXDocument) : NullProtoObjectViaIFrame() : NullProtoObjectViaActiveX(activeXDocument);
+    var length = enumBugKeys.length;
+    while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];
+    return NullProtoObject();
+  };
+  hiddenKeys[IE_PROTO] = true;
+  objectCreate = Object.create || function create(O, Properties) {
+    var result;
+    if (O !== null) {
+      EmptyConstructor[PROTOTYPE] = anObject(O);
+      result = new EmptyConstructor();
+      EmptyConstructor[PROTOTYPE] = null;
+      result[IE_PROTO] = O;
+    } else result = NullProtoObject();
+    return Properties === void 0 ? result : definePropertiesModule.f(result, Properties);
+  };
+  return objectCreate;
+}
+var errorStackClear;
+var hasRequiredErrorStackClear;
+function requireErrorStackClear() {
+  if (hasRequiredErrorStackClear) return errorStackClear;
+  hasRequiredErrorStackClear = 1;
+  var uncurryThis = requireFunctionUncurryThis();
+  var $Error = Error;
+  var replace = uncurryThis("".replace);
+  var TEST = (function(arg) {
+    return String(new $Error(arg).stack);
+  })("zxcasd");
+  var V8_OR_CHAKRA_STACK_ENTRY = /\n\s*at [^:]*:[^\n]*/;
+  var IS_V8_OR_CHAKRA_STACK = V8_OR_CHAKRA_STACK_ENTRY.test(TEST);
+  errorStackClear = function(stack, dropEntries) {
+    if (IS_V8_OR_CHAKRA_STACK && typeof stack == "string" && !$Error.prepareStackTrace) {
+      while (dropEntries--) stack = replace(stack, V8_OR_CHAKRA_STACK_ENTRY, "");
+    }
+    return stack;
+  };
+  return errorStackClear;
+}
+var errorStackInstallable;
+var hasRequiredErrorStackInstallable;
+function requireErrorStackInstallable() {
+  if (hasRequiredErrorStackInstallable) return errorStackInstallable;
+  hasRequiredErrorStackInstallable = 1;
+  var fails = requireFails();
+  var createPropertyDescriptor = requireCreatePropertyDescriptor();
+  errorStackInstallable = !fails(function() {
+    var error = new Error("a");
+    if (!("stack" in error)) return true;
+    Object.defineProperty(error, "stack", createPropertyDescriptor(1, 7));
+    return error.stack !== 7;
+  });
+  return errorStackInstallable;
+}
+var errorStackInstall;
+var hasRequiredErrorStackInstall;
+function requireErrorStackInstall() {
+  if (hasRequiredErrorStackInstall) return errorStackInstall;
+  hasRequiredErrorStackInstall = 1;
+  var createNonEnumerableProperty = requireCreateNonEnumerableProperty();
+  var clearErrorStack = requireErrorStackClear();
+  var ERROR_STACK_INSTALLABLE = requireErrorStackInstallable();
+  var captureStackTrace = Error.captureStackTrace;
+  errorStackInstall = function(error, C, stack, dropEntries) {
+    if (ERROR_STACK_INSTALLABLE) {
+      if (captureStackTrace) captureStackTrace(error, C);
+      else createNonEnumerableProperty(error, "stack", clearErrorStack(stack, dropEntries));
+    }
+  };
+  return errorStackInstall;
+}
+var toString;
+var hasRequiredToString;
+function requireToString() {
+  if (hasRequiredToString) return toString;
+  hasRequiredToString = 1;
+  var classof = requireClassof();
+  var $String = String;
+  toString = function(argument) {
+    if (classof(argument) === "Symbol") throw new TypeError("Cannot convert a Symbol value to a string");
+    return $String(argument);
+  };
+  return toString;
+}
+var normalizeStringArgument;
+var hasRequiredNormalizeStringArgument;
+function requireNormalizeStringArgument() {
+  if (hasRequiredNormalizeStringArgument) return normalizeStringArgument;
+  hasRequiredNormalizeStringArgument = 1;
+  var toString2 = requireToString();
+  normalizeStringArgument = function(argument, $default) {
+    return argument === void 0 ? arguments.length < 2 ? "" : $default : toString2(argument);
+  };
+  return normalizeStringArgument;
+}
+var hasRequiredEs_suppressedError_constructor;
+function requireEs_suppressedError_constructor() {
+  if (hasRequiredEs_suppressedError_constructor) return es_suppressedError_constructor;
+  hasRequiredEs_suppressedError_constructor = 1;
+  var $ = require_export();
+  var globalThis = requireGlobalThis();
+  var isPrototypeOf = requireObjectIsPrototypeOf();
+  var getPrototypeOf = requireObjectGetPrototypeOf();
+  var setPrototypeOf = requireObjectSetPrototypeOf();
+  var copyConstructorProperties = requireCopyConstructorProperties();
+  var create = requireObjectCreate();
+  var createNonEnumerableProperty = requireCreateNonEnumerableProperty();
+  var createPropertyDescriptor = requireCreatePropertyDescriptor();
+  var installErrorStack = requireErrorStackInstall();
+  var normalizeStringArgument2 = requireNormalizeStringArgument();
+  var wellKnownSymbol = requireWellKnownSymbol();
+  var fails = requireFails();
+  var IS_PURE = requireIsPure();
+  var NativeSuppressedError = globalThis.SuppressedError;
+  var TO_STRING_TAG = wellKnownSymbol("toStringTag");
+  var $Error = Error;
+  var WRONG_ARITY = !!NativeSuppressedError && NativeSuppressedError.length !== 3;
+  var EXTRA_ARGS_SUPPORT = !!NativeSuppressedError && fails(function() {
+    return new NativeSuppressedError(1, 2, 3, { cause: 4 }).cause === 4;
+  });
+  var PATCH = WRONG_ARITY || EXTRA_ARGS_SUPPORT;
+  var $SuppressedError = function SuppressedError(error, suppressed, message) {
+    var isInstance = isPrototypeOf(SuppressedErrorPrototype, this);
+    var that;
+    if (setPrototypeOf) {
+      that = PATCH && (!isInstance || getPrototypeOf(this) === SuppressedErrorPrototype) ? new NativeSuppressedError() : setPrototypeOf(new $Error(), isInstance ? getPrototypeOf(this) : SuppressedErrorPrototype);
+    } else {
+      that = isInstance ? this : create(SuppressedErrorPrototype);
+      createNonEnumerableProperty(that, TO_STRING_TAG, "Error");
+    }
+    if (message !== void 0) createNonEnumerableProperty(that, "message", normalizeStringArgument2(message));
+    installErrorStack(that, $SuppressedError, that.stack, 1);
+    createNonEnumerableProperty(that, "error", error);
+    createNonEnumerableProperty(that, "suppressed", suppressed);
+    return that;
+  };
+  if (setPrototypeOf) setPrototypeOf($SuppressedError, $Error);
+  else copyConstructorProperties($SuppressedError, $Error, { name: true });
+  var SuppressedErrorPrototype = $SuppressedError.prototype = PATCH ? NativeSuppressedError.prototype : create($Error.prototype, {
+    constructor: createPropertyDescriptor(1, $SuppressedError),
+    message: createPropertyDescriptor(1, ""),
+    name: createPropertyDescriptor(1, "SuppressedError")
+  });
+  if (PATCH && !IS_PURE) SuppressedErrorPrototype.constructor = $SuppressedError;
+  $({ global: true, constructor: true, arity: 3, forced: PATCH }, {
+    SuppressedError: $SuppressedError
+  });
+  return es_suppressedError_constructor;
+}
+var hasRequiredEsnext_suppressedError_constructor;
+function requireEsnext_suppressedError_constructor() {
+  if (hasRequiredEsnext_suppressedError_constructor) return esnext_suppressedError_constructor;
+  hasRequiredEsnext_suppressedError_constructor = 1;
+  requireEs_suppressedError_constructor();
+  return esnext_suppressedError_constructor;
+}
+var esnext_asyncDisposableStack_constructor = {};
+var es_asyncDisposableStack_constructor = {};
+var defineBuiltIns;
+var hasRequiredDefineBuiltIns;
+function requireDefineBuiltIns() {
+  if (hasRequiredDefineBuiltIns) return defineBuiltIns;
+  hasRequiredDefineBuiltIns = 1;
+  var defineBuiltIn = requireDefineBuiltIn();
+  defineBuiltIns = function(target, src, options) {
+    for (var key in src) defineBuiltIn(target, key, src[key], options);
+    return target;
+  };
+  return defineBuiltIns;
+}
+var addDisposableResource;
+var hasRequiredAddDisposableResource;
+function requireAddDisposableResource() {
+  if (hasRequiredAddDisposableResource) return addDisposableResource;
+  hasRequiredAddDisposableResource = 1;
+  var getBuiltIn = requireGetBuiltIn();
+  var call = requireFunctionCall();
+  var uncurryThis = requireFunctionUncurryThis();
+  var bind = requireFunctionBindContext();
+  var anObject = requireAnObject();
+  var aCallable = requireACallable();
+  var isNullOrUndefined = requireIsNullOrUndefined();
+  var getMethod = requireGetMethod();
+  var wellKnownSymbol = requireWellKnownSymbol();
+  var ASYNC_DISPOSE = wellKnownSymbol("asyncDispose");
+  var DISPOSE = wellKnownSymbol("dispose");
+  var push = uncurryThis([].push);
+  var getDisposeMethod = function(V, hint) {
+    if (hint === "async-dispose") {
+      var method = getMethod(V, ASYNC_DISPOSE);
+      if (method !== void 0) return method;
+      method = getMethod(V, DISPOSE);
+      if (method === void 0) return method;
+      return function() {
+        var O = this;
+        var Promise2 = getBuiltIn("Promise");
+        return new Promise2(function(resolve) {
+          call(method, O);
+          resolve(void 0);
+        });
+      };
+    }
+    return getMethod(V, DISPOSE);
+  };
+  var createDisposableResource = function(V, hint, method) {
+    if (arguments.length < 3 && !isNullOrUndefined(V)) {
+      method = aCallable(getDisposeMethod(anObject(V), hint));
+    }
+    return method === void 0 ? function() {
+      return void 0;
+    } : bind(method, V);
+  };
+  addDisposableResource = function(disposable, V, hint, method) {
+    var resource;
+    if (arguments.length < 4) {
+      if (isNullOrUndefined(V) && hint === "sync-dispose") return;
+      resource = createDisposableResource(V, hint);
+    } else {
+      resource = createDisposableResource(void 0, hint, method);
+    }
+    push(disposable.stack, resource);
+  };
+  return addDisposableResource;
+}
+var hasRequiredEs_asyncDisposableStack_constructor;
+function requireEs_asyncDisposableStack_constructor() {
+  if (hasRequiredEs_asyncDisposableStack_constructor) return es_asyncDisposableStack_constructor;
+  hasRequiredEs_asyncDisposableStack_constructor = 1;
+  var $ = require_export();
+  var DESCRIPTORS = requireDescriptors();
+  var getBuiltIn = requireGetBuiltIn();
+  var aCallable = requireACallable();
+  var anInstance = requireAnInstance();
+  var defineBuiltIn = requireDefineBuiltIn();
+  var defineBuiltIns2 = requireDefineBuiltIns();
+  var defineBuiltInAccessor = requireDefineBuiltInAccessor();
+  var wellKnownSymbol = requireWellKnownSymbol();
+  var InternalStateModule = requireInternalState();
+  var addDisposableResource2 = requireAddDisposableResource();
+  var V8_VERSION = requireEnvironmentV8Version();
+  var Promise2 = getBuiltIn("Promise");
+  var SuppressedError = getBuiltIn("SuppressedError");
+  var $ReferenceError = ReferenceError;
+  var ASYNC_DISPOSE = wellKnownSymbol("asyncDispose");
+  var TO_STRING_TAG = wellKnownSymbol("toStringTag");
+  var ASYNC_DISPOSABLE_STACK = "AsyncDisposableStack";
+  var setInternalState = InternalStateModule.set;
+  var getAsyncDisposableStackInternalState = InternalStateModule.getterFor(ASYNC_DISPOSABLE_STACK);
+  var HINT = "async-dispose";
+  var DISPOSED = "disposed";
+  var PENDING = "pending";
+  var getPendingAsyncDisposableStackInternalState = function(stack) {
+    var internalState = getAsyncDisposableStackInternalState(stack);
+    if (internalState.state === DISPOSED) throw new $ReferenceError(ASYNC_DISPOSABLE_STACK + " already disposed");
+    return internalState;
+  };
+  var $AsyncDisposableStack = function AsyncDisposableStack() {
+    setInternalState(anInstance(this, AsyncDisposableStackPrototype), {
+      type: ASYNC_DISPOSABLE_STACK,
+      state: PENDING,
+      stack: []
+    });
+    if (!DESCRIPTORS) this.disposed = false;
+  };
+  var AsyncDisposableStackPrototype = $AsyncDisposableStack.prototype;
+  defineBuiltIns2(AsyncDisposableStackPrototype, {
+    disposeAsync: function disposeAsync() {
+      var asyncDisposableStack = this;
+      return new Promise2(function(resolve, reject) {
+        var internalState = getAsyncDisposableStackInternalState(asyncDisposableStack);
+        if (internalState.state === DISPOSED) return resolve(void 0);
+        internalState.state = DISPOSED;
+        if (!DESCRIPTORS) asyncDisposableStack.disposed = true;
+        var stack = internalState.stack;
+        var i = stack.length;
+        var thrown = false;
+        var suppressed;
+        var handleError = function(result) {
+          if (thrown) {
+            suppressed = new SuppressedError(result, suppressed);
+          } else {
+            thrown = true;
+            suppressed = result;
+          }
+          loop();
+        };
+        var loop = function() {
+          if (i) {
+            var disposeMethod = stack[--i];
+            stack[i] = null;
+            try {
+              Promise2.resolve(disposeMethod()).then(loop, handleError);
+            } catch (error) {
+              handleError(error);
+            }
+          } else {
+            internalState.stack = null;
+            thrown ? reject(suppressed) : resolve(void 0);
+          }
+        };
+        loop();
+      });
+    },
+    use: function use(value) {
+      addDisposableResource2(getPendingAsyncDisposableStackInternalState(this), value, HINT);
+      return value;
+    },
+    adopt: function adopt(value, onDispose) {
+      var internalState = getPendingAsyncDisposableStackInternalState(this);
+      aCallable(onDispose);
+      addDisposableResource2(internalState, void 0, HINT, function() {
+        return onDispose(value);
+      });
+      return value;
+    },
+    defer: function defer(onDispose) {
+      var internalState = getPendingAsyncDisposableStackInternalState(this);
+      aCallable(onDispose);
+      addDisposableResource2(internalState, void 0, HINT, onDispose);
+    },
+    move: function move() {
+      var internalState = getPendingAsyncDisposableStackInternalState(this);
+      var newAsyncDisposableStack = new $AsyncDisposableStack();
+      getAsyncDisposableStackInternalState(newAsyncDisposableStack).stack = internalState.stack;
+      internalState.stack = [];
+      internalState.state = DISPOSED;
+      if (!DESCRIPTORS) this.disposed = true;
+      return newAsyncDisposableStack;
+    }
+  });
+  if (DESCRIPTORS) defineBuiltInAccessor(AsyncDisposableStackPrototype, "disposed", {
+    configurable: true,
+    get: function disposed() {
+      return getAsyncDisposableStackInternalState(this).state === DISPOSED;
+    }
+  });
+  defineBuiltIn(AsyncDisposableStackPrototype, ASYNC_DISPOSE, AsyncDisposableStackPrototype.disposeAsync, { name: "disposeAsync" });
+  defineBuiltIn(AsyncDisposableStackPrototype, TO_STRING_TAG, ASYNC_DISPOSABLE_STACK, { nonWritable: true });
+  var SYNC_DISPOSE_RETURNING_PROMISE_RESOLUTION_BUG = V8_VERSION && V8_VERSION < 136;
+  $({ global: true, constructor: true, forced: SYNC_DISPOSE_RETURNING_PROMISE_RESOLUTION_BUG }, {
+    AsyncDisposableStack: $AsyncDisposableStack
+  });
+  return es_asyncDisposableStack_constructor;
+}
+var hasRequiredEsnext_asyncDisposableStack_constructor;
+function requireEsnext_asyncDisposableStack_constructor() {
+  if (hasRequiredEsnext_asyncDisposableStack_constructor) return esnext_asyncDisposableStack_constructor;
+  hasRequiredEsnext_asyncDisposableStack_constructor = 1;
+  requireEs_asyncDisposableStack_constructor();
+  return esnext_asyncDisposableStack_constructor;
+}
+var esnext_asyncIterator_asyncDispose = {};
+var es_asyncIterator_asyncDispose = {};
+var asyncIteratorPrototype;
+var hasRequiredAsyncIteratorPrototype;
+function requireAsyncIteratorPrototype() {
+  if (hasRequiredAsyncIteratorPrototype) return asyncIteratorPrototype;
+  hasRequiredAsyncIteratorPrototype = 1;
+  var globalThis = requireGlobalThis();
+  var shared = requireSharedStore();
+  var isCallable = requireIsCallable();
+  var create = requireObjectCreate();
+  var getPrototypeOf = requireObjectGetPrototypeOf();
+  var defineBuiltIn = requireDefineBuiltIn();
+  var wellKnownSymbol = requireWellKnownSymbol();
+  var IS_PURE = requireIsPure();
+  var USE_FUNCTION_CONSTRUCTOR = "USE_FUNCTION_CONSTRUCTOR";
+  var ASYNC_ITERATOR = wellKnownSymbol("asyncIterator");
+  var AsyncIterator = globalThis.AsyncIterator;
+  var PassedAsyncIteratorPrototype = shared.AsyncIteratorPrototype;
+  var AsyncIteratorPrototype, prototype;
+  if (PassedAsyncIteratorPrototype) {
+    AsyncIteratorPrototype = PassedAsyncIteratorPrototype;
+  } else if (isCallable(AsyncIterator)) {
+    AsyncIteratorPrototype = AsyncIterator.prototype;
+  } else if (shared[USE_FUNCTION_CONSTRUCTOR] || globalThis[USE_FUNCTION_CONSTRUCTOR]) {
+    try {
+      prototype = getPrototypeOf(getPrototypeOf(getPrototypeOf(Function("return async function*(){}()")())));
+      if (getPrototypeOf(prototype) === Object.prototype) AsyncIteratorPrototype = prototype;
+    } catch (error) {
+    }
+  }
+  if (!AsyncIteratorPrototype) AsyncIteratorPrototype = {};
+  else if (IS_PURE) AsyncIteratorPrototype = create(AsyncIteratorPrototype);
+  if (!isCallable(AsyncIteratorPrototype[ASYNC_ITERATOR])) {
+    defineBuiltIn(AsyncIteratorPrototype, ASYNC_ITERATOR, function() {
+      return this;
+    });
+  }
+  asyncIteratorPrototype = AsyncIteratorPrototype;
+  return asyncIteratorPrototype;
+}
+var hasRequiredEs_asyncIterator_asyncDispose;
+function requireEs_asyncIterator_asyncDispose() {
+  if (hasRequiredEs_asyncIterator_asyncDispose) return es_asyncIterator_asyncDispose;
+  hasRequiredEs_asyncIterator_asyncDispose = 1;
+  var call = requireFunctionCall();
+  var defineBuiltIn = requireDefineBuiltIn();
+  var getBuiltIn = requireGetBuiltIn();
+  var getMethod = requireGetMethod();
+  var hasOwn = requireHasOwnProperty();
+  var wellKnownSymbol = requireWellKnownSymbol();
+  var AsyncIteratorPrototype = requireAsyncIteratorPrototype();
+  var ASYNC_DISPOSE = wellKnownSymbol("asyncDispose");
+  var Promise2 = getBuiltIn("Promise");
+  if (!hasOwn(AsyncIteratorPrototype, ASYNC_DISPOSE)) {
+    defineBuiltIn(AsyncIteratorPrototype, ASYNC_DISPOSE, function() {
+      var O = this;
+      return new Promise2(function(resolve, reject) {
+        var $return = getMethod(O, "return");
+        if ($return) {
+          Promise2.resolve(call($return, O)).then(function() {
+            resolve(void 0);
+          }, reject);
+        } else resolve(void 0);
+      });
+    });
+  }
+  return es_asyncIterator_asyncDispose;
+}
+var hasRequiredEsnext_asyncIterator_asyncDispose;
+function requireEsnext_asyncIterator_asyncDispose() {
+  if (hasRequiredEsnext_asyncIterator_asyncDispose) return esnext_asyncIterator_asyncDispose;
+  hasRequiredEsnext_asyncIterator_asyncDispose = 1;
+  requireEs_asyncIterator_asyncDispose();
+  return esnext_asyncIterator_asyncDispose;
+}
+var esnext_disposableStack_constructor = {};
+var es_disposableStack_constructor = {};
+var hasRequiredEs_disposableStack_constructor;
+function requireEs_disposableStack_constructor() {
+  if (hasRequiredEs_disposableStack_constructor) return es_disposableStack_constructor;
+  hasRequiredEs_disposableStack_constructor = 1;
+  var $ = require_export();
+  var DESCRIPTORS = requireDescriptors();
+  var getBuiltIn = requireGetBuiltIn();
+  var aCallable = requireACallable();
+  var anInstance = requireAnInstance();
+  var defineBuiltIn = requireDefineBuiltIn();
+  var defineBuiltIns2 = requireDefineBuiltIns();
+  var defineBuiltInAccessor = requireDefineBuiltInAccessor();
+  var wellKnownSymbol = requireWellKnownSymbol();
+  var InternalStateModule = requireInternalState();
+  var addDisposableResource2 = requireAddDisposableResource();
+  var SuppressedError = getBuiltIn("SuppressedError");
+  var $ReferenceError = ReferenceError;
+  var DISPOSE = wellKnownSymbol("dispose");
+  var TO_STRING_TAG = wellKnownSymbol("toStringTag");
+  var DISPOSABLE_STACK = "DisposableStack";
+  var setInternalState = InternalStateModule.set;
+  var getDisposableStackInternalState = InternalStateModule.getterFor(DISPOSABLE_STACK);
+  var HINT = "sync-dispose";
+  var DISPOSED = "disposed";
+  var PENDING = "pending";
+  var getPendingDisposableStackInternalState = function(stack) {
+    var internalState = getDisposableStackInternalState(stack);
+    if (internalState.state === DISPOSED) throw new $ReferenceError(DISPOSABLE_STACK + " already disposed");
+    return internalState;
+  };
+  var $DisposableStack = function DisposableStack() {
+    setInternalState(anInstance(this, DisposableStackPrototype), {
+      type: DISPOSABLE_STACK,
+      state: PENDING,
+      stack: []
+    });
+    if (!DESCRIPTORS) this.disposed = false;
+  };
+  var DisposableStackPrototype = $DisposableStack.prototype;
+  defineBuiltIns2(DisposableStackPrototype, {
+    dispose: function dispose() {
+      var internalState = getDisposableStackInternalState(this);
+      if (internalState.state === DISPOSED) return;
+      internalState.state = DISPOSED;
+      if (!DESCRIPTORS) this.disposed = true;
+      var stack = internalState.stack;
+      var i = stack.length;
+      var thrown = false;
+      var suppressed;
+      while (i) {
+        var disposeMethod = stack[--i];
+        stack[i] = null;
+        try {
+          disposeMethod();
+        } catch (errorResult) {
+          if (thrown) {
+            suppressed = new SuppressedError(errorResult, suppressed);
+          } else {
+            thrown = true;
+            suppressed = errorResult;
+          }
+        }
+      }
+      internalState.stack = null;
+      if (thrown) throw suppressed;
+    },
+    use: function use(value) {
+      addDisposableResource2(getPendingDisposableStackInternalState(this), value, HINT);
+      return value;
+    },
+    adopt: function adopt(value, onDispose) {
+      var internalState = getPendingDisposableStackInternalState(this);
+      aCallable(onDispose);
+      addDisposableResource2(internalState, void 0, HINT, function() {
+        onDispose(value);
+      });
+      return value;
+    },
+    defer: function defer(onDispose) {
+      var internalState = getPendingDisposableStackInternalState(this);
+      aCallable(onDispose);
+      addDisposableResource2(internalState, void 0, HINT, onDispose);
+    },
+    move: function move() {
+      var internalState = getPendingDisposableStackInternalState(this);
+      var newDisposableStack = new $DisposableStack();
+      getDisposableStackInternalState(newDisposableStack).stack = internalState.stack;
+      internalState.stack = [];
+      internalState.state = DISPOSED;
+      if (!DESCRIPTORS) this.disposed = true;
+      return newDisposableStack;
+    }
+  });
+  if (DESCRIPTORS) defineBuiltInAccessor(DisposableStackPrototype, "disposed", {
+    configurable: true,
+    get: function disposed() {
+      return getDisposableStackInternalState(this).state === DISPOSED;
+    }
+  });
+  defineBuiltIn(DisposableStackPrototype, DISPOSE, DisposableStackPrototype.dispose, { name: "dispose" });
+  defineBuiltIn(DisposableStackPrototype, TO_STRING_TAG, DISPOSABLE_STACK, { nonWritable: true });
+  $({ global: true, constructor: true }, {
+    DisposableStack: $DisposableStack
+  });
+  return es_disposableStack_constructor;
+}
+var hasRequiredEsnext_disposableStack_constructor;
+function requireEsnext_disposableStack_constructor() {
+  if (hasRequiredEsnext_disposableStack_constructor) return esnext_disposableStack_constructor;
+  hasRequiredEsnext_disposableStack_constructor = 1;
+  requireEs_disposableStack_constructor();
+  return esnext_disposableStack_constructor;
+}
+var esnext_iterator_dispose = {};
+var es_iterator_dispose = {};
+var iteratorsCore;
+var hasRequiredIteratorsCore;
+function requireIteratorsCore() {
+  if (hasRequiredIteratorsCore) return iteratorsCore;
+  hasRequiredIteratorsCore = 1;
+  var fails = requireFails();
+  var isCallable = requireIsCallable();
+  var isObject = requireIsObject();
+  var create = requireObjectCreate();
+  var getPrototypeOf = requireObjectGetPrototypeOf();
+  var defineBuiltIn = requireDefineBuiltIn();
+  var wellKnownSymbol = requireWellKnownSymbol();
+  var IS_PURE = requireIsPure();
+  var ITERATOR = wellKnownSymbol("iterator");
+  var BUGGY_SAFARI_ITERATORS = false;
+  var IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator;
+  if ([].keys) {
+    arrayIterator = [].keys();
+    if (!("next" in arrayIterator)) BUGGY_SAFARI_ITERATORS = true;
+    else {
+      PrototypeOfArrayIteratorPrototype = getPrototypeOf(getPrototypeOf(arrayIterator));
+      if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype = PrototypeOfArrayIteratorPrototype;
+    }
+  }
+  var NEW_ITERATOR_PROTOTYPE = !isObject(IteratorPrototype) || fails(function() {
+    var test = {};
+    return IteratorPrototype[ITERATOR].call(test) !== test;
+  });
+  if (NEW_ITERATOR_PROTOTYPE) IteratorPrototype = {};
+  else if (IS_PURE) IteratorPrototype = create(IteratorPrototype);
+  if (!isCallable(IteratorPrototype[ITERATOR])) {
+    defineBuiltIn(IteratorPrototype, ITERATOR, function() {
+      return this;
+    });
+  }
+  iteratorsCore = {
+    IteratorPrototype,
+    BUGGY_SAFARI_ITERATORS
+  };
+  return iteratorsCore;
+}
+var hasRequiredEs_iterator_dispose;
+function requireEs_iterator_dispose() {
+  if (hasRequiredEs_iterator_dispose) return es_iterator_dispose;
+  hasRequiredEs_iterator_dispose = 1;
+  var call = requireFunctionCall();
+  var defineBuiltIn = requireDefineBuiltIn();
+  var getMethod = requireGetMethod();
+  var hasOwn = requireHasOwnProperty();
+  var wellKnownSymbol = requireWellKnownSymbol();
+  var IteratorPrototype = requireIteratorsCore().IteratorPrototype;
+  var DISPOSE = wellKnownSymbol("dispose");
+  if (!hasOwn(IteratorPrototype, DISPOSE)) {
+    defineBuiltIn(IteratorPrototype, DISPOSE, function() {
+      var $return = getMethod(this, "return");
+      if ($return) call($return, this);
+    });
+  }
+  return es_iterator_dispose;
+}
+var hasRequiredEsnext_iterator_dispose;
+function requireEsnext_iterator_dispose() {
+  if (hasRequiredEsnext_iterator_dispose) return esnext_iterator_dispose;
+  hasRequiredEsnext_iterator_dispose = 1;
+  requireEs_iterator_dispose();
+  return esnext_iterator_dispose;
+}
+var esnext_symbol_asyncDispose = {};
+var es_symbol_asyncDispose = {};
+var wellKnownSymbolWrapped = {};
+var hasRequiredWellKnownSymbolWrapped;
+function requireWellKnownSymbolWrapped() {
+  if (hasRequiredWellKnownSymbolWrapped) return wellKnownSymbolWrapped;
+  hasRequiredWellKnownSymbolWrapped = 1;
+  var wellKnownSymbol = requireWellKnownSymbol();
+  wellKnownSymbolWrapped.f = wellKnownSymbol;
+  return wellKnownSymbolWrapped;
+}
+var wellKnownSymbolDefine;
+var hasRequiredWellKnownSymbolDefine;
+function requireWellKnownSymbolDefine() {
+  if (hasRequiredWellKnownSymbolDefine) return wellKnownSymbolDefine;
+  hasRequiredWellKnownSymbolDefine = 1;
+  var path = requirePath();
+  var hasOwn = requireHasOwnProperty();
+  var wrappedWellKnownSymbolModule = requireWellKnownSymbolWrapped();
+  var defineProperty = requireObjectDefineProperty().f;
+  wellKnownSymbolDefine = function(NAME) {
+    var Symbol2 = path.Symbol || (path.Symbol = {});
+    if (!hasOwn(Symbol2, NAME)) defineProperty(Symbol2, NAME, {
+      value: wrappedWellKnownSymbolModule.f(NAME)
+    });
+  };
+  return wellKnownSymbolDefine;
+}
+var hasRequiredEs_symbol_asyncDispose;
+function requireEs_symbol_asyncDispose() {
+  if (hasRequiredEs_symbol_asyncDispose) return es_symbol_asyncDispose;
+  hasRequiredEs_symbol_asyncDispose = 1;
+  var globalThis = requireGlobalThis();
+  var defineWellKnownSymbol = requireWellKnownSymbolDefine();
+  var defineProperty = requireObjectDefineProperty().f;
+  var getOwnPropertyDescriptor = requireObjectGetOwnPropertyDescriptor().f;
+  var Symbol2 = globalThis.Symbol;
+  defineWellKnownSymbol("asyncDispose");
+  if (Symbol2) {
+    var descriptor = getOwnPropertyDescriptor(Symbol2, "asyncDispose");
+    if (descriptor.enumerable && descriptor.configurable && descriptor.writable) {
+      defineProperty(Symbol2, "asyncDispose", { value: descriptor.value, enumerable: false, configurable: false, writable: false });
+    }
+  }
+  return es_symbol_asyncDispose;
+}
+var hasRequiredEsnext_symbol_asyncDispose;
+function requireEsnext_symbol_asyncDispose() {
+  if (hasRequiredEsnext_symbol_asyncDispose) return esnext_symbol_asyncDispose;
+  hasRequiredEsnext_symbol_asyncDispose = 1;
+  requireEs_symbol_asyncDispose();
+  return esnext_symbol_asyncDispose;
+}
+var esnext_symbol_dispose = {};
+var es_symbol_dispose = {};
+var hasRequiredEs_symbol_dispose;
+function requireEs_symbol_dispose() {
+  if (hasRequiredEs_symbol_dispose) return es_symbol_dispose;
+  hasRequiredEs_symbol_dispose = 1;
+  var globalThis = requireGlobalThis();
+  var defineWellKnownSymbol = requireWellKnownSymbolDefine();
+  var defineProperty = requireObjectDefineProperty().f;
+  var getOwnPropertyDescriptor = requireObjectGetOwnPropertyDescriptor().f;
+  var Symbol2 = globalThis.Symbol;
+  defineWellKnownSymbol("dispose");
+  if (Symbol2) {
+    var descriptor = getOwnPropertyDescriptor(Symbol2, "dispose");
+    if (descriptor.enumerable && descriptor.configurable && descriptor.writable) {
+      defineProperty(Symbol2, "dispose", { value: descriptor.value, enumerable: false, configurable: false, writable: false });
+    }
+  }
+  return es_symbol_dispose;
+}
+var hasRequiredEsnext_symbol_dispose;
+function requireEsnext_symbol_dispose() {
+  if (hasRequiredEsnext_symbol_dispose) return esnext_symbol_dispose;
+  hasRequiredEsnext_symbol_dispose = 1;
+  requireEs_symbol_dispose();
+  return esnext_symbol_dispose;
+}
+var hasRequiredExplicitResourceManagement;
+function requireExplicitResourceManagement() {
+  if (hasRequiredExplicitResourceManagement) return explicitResourceManagement$1;
+  hasRequiredExplicitResourceManagement = 1;
+  requireEsnext_suppressedError_constructor();
+  requireEsnext_asyncDisposableStack_constructor();
+  requireEsnext_asyncIterator_asyncDispose();
+  requireEsnext_disposableStack_constructor();
+  requireEsnext_iterator_dispose();
+  requireEsnext_symbol_asyncDispose();
+  requireEsnext_symbol_dispose();
+  return explicitResourceManagement$1;
+}
+requireExplicitResourceManagement();
+const explicitResourceManagement = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  explicitResourceManagement as e
+};
+//# sourceMappingURL=explicit-resource-management-BSyjFgS-.js.map