indisposed 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Andrew Ross
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,225 @@
+# indisposed
+
+[![CI](https://github.com/andrew-w-ross/indisposed/actions/workflows/ci.yml/badge.svg)](https://github.com/andrew-w-ross/indisposed/actions/workflows/ci.yml)
+[![npm version](https://badge.fury.io/js/indisposed.svg)](https://www.npmjs.com/package/indisposed)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+The missing utilities for JavaScript's [Explicit Resource Management](https://github.com/tc39/proposal-explicit-resource-management) (`using` and `await using` declarations).
+
+## Features
+
+- 🧹 **Resource Management** - Convert any resource into a disposable with `toDisposable` and `toAsyncDisposable`
+- 🎧 **Event Handlers** - Transform event emitters into disposable iterators with `on` and promises with `once`
+- 🔒 **Scoped Execution** - Execute code with automatic cleanup using `invoke`
+- 📦 **Zero Dependencies** - Lightweight and focused
+- 🔧 **TypeScript First** - Full type safety and inference
+- 🌳 **Tree Shakeable** - Import only what you need
+
+## Installation
+
+```bash
+npm install indisposed
+# or
+yarn add indisposed
+# or
+pnpm add indisposed
+```
+
+## Quick Start
+
+```typescript
+import { toAsyncDisposable, once, invoke } from "indisposed";
+import { WebSocketServer } from "ws";
+
+// Automatic cleanup with await using
+{
+	await using wss = await invoke(async () => {
+		const wss = toAsyncDisposable(
+			new WebSocketServer({ host: "127.0.0.1", port: 0 }),
+			(wss) =>
+				new Promise((resolve, reject) => {
+					wss.close((err) => {
+						if (err) return reject(err);
+						resolve(undefined);
+					});
+				}),
+		);
+
+		using listening = once(wss, "listening");
+		using error = once(wss, "error", true);
+
+		await Promise.race([listening, error]);
+
+		return wss;
+	});
+
+	console.log("Server ready at", wss.address());
+	// ... handle connections ...
+}
+// wss is automatically closed once the scope ends
+```
+
+## API Reference
+
+### `toDisposable<T>(value, disposeFn)`
+
+Make any object disposable by adding a `Symbol.dispose` method.
+
+```typescript
+import { toDisposable } from "indisposed";
+
+const resource = toDisposable({ handle: 123 }, (r) =>
+	console.log(`Closing handle ${r.handle}`),
+);
+
+{
+	using r = resource;
+	// use resource
+} // automatically disposed here
+```
+
+### `toAsyncDisposable<T>(value, disposeFn)`
+
+Make any object async disposable by adding a `Symbol.asyncDispose` method.
+
+```typescript
+import { toAsyncDisposable } from "indisposed";
+
+const resource = toAsyncDisposable(
+	{ connection: db },
+	async (r) => await r.connection.close(),
+);
+
+{
+	await using r = resource;
+	// use resource
+} // automatically disposed here
+```
+
+### `once(emitter, event, rejects?)`
+
+Create a disposable promise that resolves/rejects when an event fires once.
+
+The promise result is automatically unpacked based on the handler signature:
+
+- 0 parameters → `undefined`
+- 1 parameter → the single value
+- 2+ parameters → array of values
+
+```typescript
+import { once } from "indisposed";
+
+{
+	using promise = once(server, "listening");
+	await promise; // waits for 'listening' event
+} // removes listener if not yet fired
+
+// Single parameter events return the value directly
+{
+	using data = once(socket, "message");
+	const message = await data; // string (not [string])
+}
+
+// Multiple parameters return as array
+{
+	using result = once(emitter, "result");
+	const [status, data] = await result; // [number, object]
+}
+
+// Handle errors
+{
+	using error = once(server, "error", true);
+	await error; // rejects if 'error' event fires
+}
+```
+
+### `on(emitter, event, maxBuffer?)`
+
+Create a disposable async iterator for multiple events.
+
+Yielded values are automatically unpacked based on the handler signature:
+
+- 0 parameters → `undefined`
+- 1 parameter → the single value
+- 2+ parameters → array of values
+
+```typescript
+import { on } from "indisposed";
+
+// Single parameter events yield values directly
+{
+	using events = on(emitter, "data");
+
+	for await (const data of events) {
+		console.log(data); // string (not [string])
+		if (shouldStop) break;
+	}
+} // automatically removes listener
+
+// Multiple parameters yield as array
+{
+	using positions = on(emitter, "move");
+
+	for await (const [x, y] of positions) {
+		console.log(`Position: ${x}, ${y}`);
+	}
+}
+```
+
+### `invoke<T>(fn)`
+
+Immediately invoke a function - useful for scoping resources.
+
+```typescript
+import { invoke } from "indisposed";
+
+const result = invoke(() => {
+	using resource1 = getResource1();
+	using resource2 = getResource2();
+
+	return processResources(resource1, resource2);
+}); // resources disposed in reverse order
+```
+
+## Polyfills
+
+By default, `indisposed` automatically polyfills `Symbol.dispose` and `Symbol.asyncDispose` when:
+
+1. The environment doesn't natively support these symbols
+2. `core-js` is installed as a peer dependency
+
+The polyfill is smart and only applies when needed. If your environment already supports explicit resource management or you don't have `core-js` installed, no polyfill is loaded.
+
+For environments that already support these symbols, you can skip the polyfill check entirely using the no-polyfill entry point:
+
+```typescript
+import { toDisposable } from "indisposed/no-polyfill";
+```
+
+Or configure your bundler to alias the main export:
+
+```json
+{
+	"alias": {
+		"indisposed": "indisposed/no-polyfill"
+	}
+}
+```
+
+## Requirements
+
+- Node.js >= 22.20.0
+- TypeScript >= 5.2.0 (for `using` declarations support)
+
+## License
+
+MIT © [andrew-w-ross](https://github.com/andrew-w-ross)
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## Resources
+
+- [TC39 Explicit Resource Management Proposal](https://github.com/tc39/proposal-explicit-resource-management)
+- [TypeScript 5.2 Release Notes](https://devblogs.microsoft.com/typescript/announcing-typescript-5-2/#using-declarations-and-explicit-resource-management)

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

@@ -0,0 +1,448 @@
+import { r as N, a as x, b as le, c as Pe, d as ir, e as qe, f as ve, g as ur, h as Re, i as B, j as cr, k as me, l as ge, m as Te, n as De, o as fe, p as pe, q as de, s as we, t as lr, u as G, v as Ae, w as ke, x as Ce, y as D, z as vr, A, B as U, C as fr, D as je, E as Ke, F as pr, G as dr, H as ye, I as Se, J as be, K as Ne, L as xe, M as Be, N as Ge, O as _e } from "./path-CtSS7upm.js";
+var _r = {}, Er = {}, Ir = {}, Y, Or;
+function Ue() {
+  if (Or) return Y;
+  Or = 1;
+  var t = N();
+  return Y = !t(function() {
+    function r() {
+    }
+    return r.prototype.constructor = null, Object.getPrototypeOf(new r()) !== r.prototype;
+  }), Y;
+}
+var H, hr;
+function yr() {
+  if (hr) return H;
+  hr = 1;
+  var t = x(), r = ir(), a = Pe(), s = le(), e = Ue(), n = s("IE_PROTO"), i = Object, u = i.prototype;
+  return H = e ? i.getPrototypeOf : function(l) {
+    var v = a(l);
+    if (t(v, n)) return v[n];
+    var o = v.constructor;
+    return r(o) && v instanceof o ? o.prototype : v instanceof i ? u : null;
+  }, H;
+}
+var L = {}, z, Pr;
+function Fe() {
+  if (Pr) return z;
+  Pr = 1;
+  var t = qe(), r = ve();
+  return z = Object.keys || function(s) {
+    return t(s, r);
+  }, z;
+}
+var qr;
+function We() {
+  if (qr) return L;
+  qr = 1;
+  var t = ur(), r = Re(), a = B(), s = cr(), e = me(), n = Fe();
+  return L.f = t && !r ? Object.defineProperties : function(u, l) {
+    s(u);
+    for (var v = e(l), o = n(l), _ = o.length, c = 0, h; _ > c; ) a.f(u, h = o[c++], v[h]);
+    return u;
+  }, L;
+}
+var V, Rr;
+function Sr() {
+  if (Rr) return V;
+  Rr = 1;
+  var t = cr(), r = We(), a = ve(), s = De(), e = ge(), n = Te(), i = le(), u = ">", l = "<", v = "prototype", o = "script", _ = i("IE_PROTO"), c = function() {
+  }, h = function(p) {
+    return l + o + u + p + l + "/" + o + u;
+  }, y = function(p) {
+    p.write(h("")), p.close();
+    var S = p.parentWindow.Object;
+    return p = null, S;
+  }, q = function() {
+    var p = n("iframe"), S = "java" + o + ":", E;
+    return p.style.display = "none", e.appendChild(p), p.src = String(S), E = p.contentWindow.document, E.open(), E.write(h("document.F=Object")), E.close(), E.F;
+  }, d, P = function() {
+    try {
+      d = new ActiveXObject("htmlfile");
+    } catch {
+    }
+    P = typeof document < "u" ? document.domain && d ? y(d) : q() : y(d);
+    for (var p = a.length; p--; ) delete P[v][a[p]];
+    return P();
+  };
+  return s[_] = !0, V = Object.create || function(S, E) {
+    var I;
+    return S !== null ? (c[v] = t(S), I = new c(), c[v] = null, I[_] = S) : I = P(), E === void 0 ? I : r.f(I, E);
+  }, V;
+}
+var J, mr;
+function Me() {
+  if (mr) return J;
+  mr = 1;
+  var t = fe(), r = Error, a = t("".replace), s = (function(i) {
+    return String(new r(i).stack);
+  })("zxcasd"), e = /\n\s*at [^:]*:[^\n]*/, n = e.test(s);
+  return J = function(i, u) {
+    if (n && typeof i == "string" && !r.prepareStackTrace)
+      for (; u--; ) i = a(i, e, "");
+    return i;
+  }, J;
+}
+var X, gr;
+function $e() {
+  if (gr) return X;
+  gr = 1;
+  var t = N(), r = pe();
+  return X = !t(function() {
+    var a = new Error("a");
+    return "stack" in a ? (Object.defineProperty(a, "stack", r(1, 7)), a.stack !== 7) : !0;
+  }), X;
+}
+var Q, Tr;
+function Ye() {
+  if (Tr) return Q;
+  Tr = 1;
+  var t = de(), r = Me(), a = $e(), s = Error.captureStackTrace;
+  return Q = function(e, n, i, u) {
+    a && (s ? s(e, n) : t(e, "stack", r(i, u)));
+  }, Q;
+}
+var Z, Dr;
+function He() {
+  if (Dr) return Z;
+  Dr = 1;
+  var t = we(), r = String;
+  return Z = function(a) {
+    if (t(a) === "Symbol") throw new TypeError("Cannot convert a Symbol value to a string");
+    return r(a);
+  }, Z;
+}
+var rr, wr;
+function Le() {
+  if (wr) return rr;
+  wr = 1;
+  var t = He();
+  return rr = function(r, a) {
+    return r === void 0 ? arguments.length < 2 ? "" : a : t(r);
+  }, rr;
+}
+var Ar;
+function ze() {
+  if (Ar) return Ir;
+  Ar = 1;
+  var t = lr(), r = G(), a = Ae(), s = yr(), e = ke(), n = Ce(), i = Sr(), u = de(), l = pe(), v = Ye(), o = Le(), _ = D(), c = N(), h = vr(), y = r.SuppressedError, q = _("toStringTag"), d = Error, P = !!y && y.length !== 3, p = !!y && c(function() {
+    return new y(1, 2, 3, { cause: 4 }).cause === 4;
+  }), S = P || p, E = function(T, g, f) {
+    var R = a(I, this), b;
+    return e ? b = S && (!R || s(this) === I) ? new y() : e(new d(), R ? s(this) : I) : (b = R ? this : i(I), u(b, q, "Error")), f !== void 0 && u(b, "message", o(f)), v(b, E, b.stack, 1), u(b, "error", T), u(b, "suppressed", g), b;
+  };
+  e ? e(E, d) : n(E, d, { name: !0 });
+  var I = E.prototype = S ? y.prototype : i(d.prototype, {
+    constructor: l(1, E),
+    message: l(1, ""),
+    name: l(1, "SuppressedError")
+  });
+  return S && !h && (I.constructor = E), t({ global: !0, constructor: !0, arity: 3, forced: S }, {
+    SuppressedError: E
+  }), Ir;
+}
+var kr;
+function Ve() {
+  return kr || (kr = 1, ze()), Er;
+}
+var Cr = {}, jr = {}, er, Kr;
+function Ee() {
+  if (Kr) return er;
+  Kr = 1;
+  var t = A();
+  return er = function(r, a, s) {
+    for (var e in a) t(r, e, a[e], s);
+    return r;
+  }, er;
+}
+var tr, Nr;
+function Ie() {
+  if (Nr) return tr;
+  Nr = 1;
+  var t = U(), r = fr(), a = fe(), s = je(), e = cr(), n = pr(), i = Ke(), u = dr(), l = D(), v = l("asyncDispose"), o = l("dispose"), _ = a([].push), c = function(y, q) {
+    if (q === "async-dispose") {
+      var d = u(y, v);
+      return d !== void 0 || (d = u(y, o), d === void 0) ? d : function() {
+        var P = this, p = t("Promise");
+        return new p(function(S) {
+          r(d, P), S(void 0);
+        });
+      };
+    }
+    return u(y, o);
+  }, h = function(y, q, d) {
+    return arguments.length < 3 && !i(y) && (d = n(c(e(y), q))), d === void 0 ? function() {
+    } : s(d, y);
+  };
+  return tr = function(y, q, d, P) {
+    var p;
+    if (arguments.length < 4) {
+      if (i(q) && d === "sync-dispose") return;
+      p = h(q, d);
+    } else
+      p = h(void 0, d, P);
+    _(y.stack, p);
+  }, tr;
+}
+var xr;
+function Je() {
+  if (xr) return jr;
+  xr = 1;
+  var t = lr(), r = ur(), a = U(), s = pr(), e = ye(), n = A(), i = Ee(), u = Se(), l = D(), v = be(), o = Ie(), _ = Ne(), c = a("Promise"), h = a("SuppressedError"), y = ReferenceError, q = l("asyncDispose"), d = l("toStringTag"), P = "AsyncDisposableStack", p = v.set, S = v.getterFor(P), E = "async-dispose", I = "disposed", k = "pending", T = function(b) {
+    var O = S(b);
+    if (O.state === I) throw new y(P + " already disposed");
+    return O;
+  }, g = function() {
+    p(e(this, f), {
+      type: P,
+      state: k,
+      stack: []
+    }), r || (this.disposed = !1);
+  }, f = g.prototype;
+  i(f, {
+    disposeAsync: function() {
+      var O = this;
+      return new c(function(m, C) {
+        var w = S(O);
+        if (w.state === I) return m(void 0);
+        w.state = I, r || (O.disposed = !0);
+        var F = w.stack, W = F.length, M = !1, j, br = function(K) {
+          M ? j = new h(K, j) : (M = !0, j = K), $();
+        }, $ = function() {
+          if (W) {
+            var K = F[--W];
+            F[W] = null;
+            try {
+              c.resolve(K()).then($, br);
+            } catch (he) {
+              br(he);
+            }
+          } else
+            w.stack = null, M ? C(j) : m(void 0);
+        };
+        $();
+      });
+    },
+    use: function(O) {
+      return o(T(this), O, E), O;
+    },
+    adopt: function(O, m) {
+      var C = T(this);
+      return s(m), o(C, void 0, E, function() {
+        return m(O);
+      }), O;
+    },
+    defer: function(O) {
+      var m = T(this);
+      s(O), o(m, void 0, E, O);
+    },
+    move: function() {
+      var O = T(this), m = new g();
+      return S(m).stack = O.stack, O.stack = [], O.state = I, r || (this.disposed = !0), m;
+    }
+  }), r && u(f, "disposed", {
+    configurable: !0,
+    get: function() {
+      return S(this).state === I;
+    }
+  }), n(f, q, f.disposeAsync, { name: "disposeAsync" }), n(f, d, P, { nonWritable: !0 });
+  var R = _ && _ < 136;
+  return t({ global: !0, constructor: !0, forced: R }, {
+    AsyncDisposableStack: g
+  }), jr;
+}
+var Br;
+function Xe() {
+  return Br || (Br = 1, Je()), Cr;
+}
+var Gr = {}, Ur = {}, ar, Fr;
+function Qe() {
+  if (Fr) return ar;
+  Fr = 1;
+  var t = G(), r = xe(), a = ir(), s = Sr(), e = yr(), n = A(), i = D(), u = vr(), l = "USE_FUNCTION_CONSTRUCTOR", v = i("asyncIterator"), o = t.AsyncIterator, _ = r.AsyncIteratorPrototype, c, h;
+  if (_)
+    c = _;
+  else if (a(o))
+    c = o.prototype;
+  else if (r[l] || t[l])
+    try {
+      h = e(e(e(Function("return async function*(){}()")()))), e(h) === Object.prototype && (c = h);
+    } catch {
+    }
+  return c ? u && (c = s(c)) : c = {}, a(c[v]) || n(c, v, function() {
+    return this;
+  }), ar = c, ar;
+}
+var Wr;
+function Ze() {
+  if (Wr) return Ur;
+  Wr = 1;
+  var t = fr(), r = A(), a = U(), s = dr(), e = x(), n = D(), i = Qe(), u = n("asyncDispose"), l = a("Promise");
+  return e(i, u) || r(i, u, function() {
+    var v = this;
+    return new l(function(o, _) {
+      var c = s(v, "return");
+      c ? l.resolve(t(c, v)).then(function() {
+        o(void 0);
+      }, _) : o(void 0);
+    });
+  }), Ur;
+}
+var Mr;
+function rt() {
+  return Mr || (Mr = 1, Ze()), Gr;
+}
+var $r = {}, Yr = {}, Hr;
+function et() {
+  if (Hr) return Yr;
+  Hr = 1;
+  var t = lr(), r = ur(), a = U(), s = pr(), e = ye(), n = A(), i = Ee(), u = Se(), l = D(), v = be(), o = Ie(), _ = a("SuppressedError"), c = ReferenceError, h = l("dispose"), y = l("toStringTag"), q = "DisposableStack", d = v.set, P = v.getterFor(q), p = "sync-dispose", S = "disposed", E = "pending", I = function(g) {
+    var f = P(g);
+    if (f.state === S) throw new c(q + " already disposed");
+    return f;
+  }, k = function() {
+    d(e(this, T), {
+      type: q,
+      state: E,
+      stack: []
+    }), r || (this.disposed = !1);
+  }, T = k.prototype;
+  return i(T, {
+    dispose: function() {
+      var f = P(this);
+      if (f.state !== S) {
+        f.state = S, r || (this.disposed = !0);
+        for (var R = f.stack, b = R.length, O = !1, m; b; ) {
+          var C = R[--b];
+          R[b] = null;
+          try {
+            C();
+          } catch (w) {
+            O ? m = new _(w, m) : (O = !0, m = w);
+          }
+        }
+        if (f.stack = null, O) throw m;
+      }
+    },
+    use: function(f) {
+      return o(I(this), f, p), f;
+    },
+    adopt: function(f, R) {
+      var b = I(this);
+      return s(R), o(b, void 0, p, function() {
+        R(f);
+      }), f;
+    },
+    defer: function(f) {
+      var R = I(this);
+      s(f), o(R, void 0, p, f);
+    },
+    move: function() {
+      var f = I(this), R = new k();
+      return P(R).stack = f.stack, f.stack = [], f.state = S, r || (this.disposed = !0), R;
+    }
+  }), r && u(T, "disposed", {
+    configurable: !0,
+    get: function() {
+      return P(this).state === S;
+    }
+  }), n(T, h, T.dispose, { name: "dispose" }), n(T, y, q, { nonWritable: !0 }), t({ global: !0, constructor: !0 }, {
+    DisposableStack: k
+  }), Yr;
+}
+var Lr;
+function tt() {
+  return Lr || (Lr = 1, et()), $r;
+}
+var zr = {}, Vr = {}, nr, Jr;
+function at() {
+  if (Jr) return nr;
+  Jr = 1;
+  var t = N(), r = ir(), a = Be(), s = Sr(), e = yr(), n = A(), i = D(), u = vr(), l = i("iterator"), v = !1, o, _, c;
+  [].keys && (c = [].keys(), "next" in c ? (_ = e(e(c)), _ !== Object.prototype && (o = _)) : v = !0);
+  var h = !a(o) || t(function() {
+    var y = {};
+    return o[l].call(y) !== y;
+  });
+  return h ? o = {} : u && (o = s(o)), r(o[l]) || n(o, l, function() {
+    return this;
+  }), nr = {
+    IteratorPrototype: o,
+    BUGGY_SAFARI_ITERATORS: v
+  }, nr;
+}
+var Xr;
+function nt() {
+  if (Xr) return Vr;
+  Xr = 1;
+  var t = fr(), r = A(), a = dr(), s = x(), e = D(), n = at().IteratorPrototype, i = e("dispose");
+  return s(n, i) || r(n, i, function() {
+    var u = a(this, "return");
+    u && t(u, this);
+  }), Vr;
+}
+var Qr;
+function st() {
+  return Qr || (Qr = 1, nt()), zr;
+}
+var Zr = {}, re = {}, sr = {}, ee;
+function ot() {
+  if (ee) return sr;
+  ee = 1;
+  var t = D();
+  return sr.f = t, sr;
+}
+var or, te;
+function Oe() {
+  if (te) return or;
+  te = 1;
+  var t = Ge(), r = x(), a = ot(), s = B().f;
+  return or = function(e) {
+    var n = t.Symbol || (t.Symbol = {});
+    r(n, e) || s(n, e, {
+      value: a.f(e)
+    });
+  }, or;
+}
+var ae;
+function it() {
+  if (ae) return re;
+  ae = 1;
+  var t = G(), r = Oe(), a = B().f, s = _e().f, e = t.Symbol;
+  if (r("asyncDispose"), e) {
+    var n = s(e, "asyncDispose");
+    n.enumerable && n.configurable && n.writable && a(e, "asyncDispose", { value: n.value, enumerable: !1, configurable: !1, writable: !1 });
+  }
+  return re;
+}
+var ne;
+function ut() {
+  return ne || (ne = 1, it()), Zr;
+}
+var se = {}, oe = {}, ie;
+function ct() {
+  if (ie) return oe;
+  ie = 1;
+  var t = G(), r = Oe(), a = B().f, s = _e().f, e = t.Symbol;
+  if (r("dispose"), e) {
+    var n = s(e, "dispose");
+    n.enumerable && n.configurable && n.writable && a(e, "dispose", { value: n.value, enumerable: !1, configurable: !1, writable: !1 });
+  }
+  return oe;
+}
+var ue;
+function lt() {
+  return ue || (ue = 1, ct()), se;
+}
+var ce;
+function vt() {
+  return ce || (ce = 1, Ve(), Xe(), rt(), tt(), st(), ut(), lt()), _r;
+}
+vt();
+const pt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  pt as e
+};
+//# sourceMappingURL=explicit-resource-management-C54qWHAr.js.map