obsidian-dev-utils 85.0.0 → 86.0.0

package/dist/lib/cjs/disposable.cjs

@@ -127,12 +127,30 @@ var disposable_exports = {};
 __export(disposable_exports, {
   AsyncCallbackDisposable: () => AsyncCallbackDisposable,
   CallbackDisposable: () => CallbackDisposable,
+  CombineAsyncDisposable: () => CombineAsyncDisposable,
+  CombineDisposable: () => CombineDisposable,
+  DisposeErrorBehavior: () => DisposeErrorBehavior,
+  DisposeOrder: () => DisposeOrder,
   MultipleDisposeBehavior: () => MultipleDisposeBehavior,
   isAsyncDisposable: () => isAsyncDisposable,
-  isDisposable: () => isDisposable
+  isAsyncDisposableEx: () => isAsyncDisposableEx,
+  isDisposable: () => isDisposable,
+  isDisposableEx: () => isDisposableEx,
+  toAsyncDisposableEx: () => toAsyncDisposableEx,
+  toDisposableEx: () => toDisposableEx
 });
 module.exports = __toCommonJS(disposable_exports);
 var import_type_guards = require('./type-guards.cjs');
+var DisposeErrorBehavior = /* @__PURE__ */ ((DisposeErrorBehavior2) => {
+  DisposeErrorBehavior2[DisposeErrorBehavior2["Aggregate"] = 0] = "Aggregate";
+  DisposeErrorBehavior2[DisposeErrorBehavior2["FailFast"] = 1] = "FailFast";
+  return DisposeErrorBehavior2;
+})(DisposeErrorBehavior || {});
+var DisposeOrder = /* @__PURE__ */ ((DisposeOrder2) => {
+  DisposeOrder2[DisposeOrder2["Lifo"] = 0] = "Lifo";
+  DisposeOrder2[DisposeOrder2["Fifo"] = 1] = "Fifo";
+  return DisposeOrder2;
+})(DisposeOrder || {});
 var MultipleDisposeBehavior = /* @__PURE__ */ ((MultipleDisposeBehavior2) => {
   MultipleDisposeBehavior2[MultipleDisposeBehavior2["Invoke"] = 0] = "Invoke";
   MultipleDisposeBehavior2[MultipleDisposeBehavior2["Ignore"] = 1] = "Ignore";
@@ -152,6 +170,15 @@ class AsyncCallbackDisposable {
     this.callback = params.callback;
     this.multipleDisposeBehavior = params.multipleDisposeBehavior ?? 0 /* Invoke */;
   }
+  /**
+   * Disposes the object by executing the callback. Convenience alias that delegates to
+   * `this[Symbol.asyncDispose]()`.
+   *
+   * @returns A {@link Promise} that resolves once the callback completes.
+   */
+  asyncDispose() {
+    return this[Symbol.asyncDispose]();
+  }
   /**
    * Disposes the object by executing the callback.
    *
@@ -191,6 +218,13 @@ class CallbackDisposable {
     this.callback = params.callback;
     this.multipleDisposeBehavior = params.multipleDisposeBehavior ?? 0 /* Invoke */;
   }
+  /**
+   * Disposes the object by executing the callback. Convenience alias that delegates to
+   * `this[Symbol.dispose]()`.
+   */
+  dispose() {
+    this[Symbol.dispose]();
+  }
   /**
    * Disposes the object by executing the callback.
    *
@@ -215,20 +249,207 @@ class CallbackDisposable {
     this.callback();
   }
 }
+class CombineAsyncDisposable {
+  children;
+  disposeOrder;
+  errorBehavior;
+  isDisposed = false;
+  multipleDisposeBehavior;
+  /**
+   * Creates a new instance of {@link CombineAsyncDisposable}.
+   *
+   * @param params - The parameters.
+   */
+  constructor(params) {
+    this.children = [...params.asyncDisposables];
+    this.disposeOrder = params.disposeOrder ?? 0 /* Lifo */;
+    this.errorBehavior = params.errorBehavior ?? 0 /* Aggregate */;
+    this.multipleDisposeBehavior = params.multipleDisposeBehavior ?? 0 /* Invoke */;
+  }
+  /**
+   * Disposes all combined children. Convenience alias that delegates to
+   * `this[Symbol.asyncDispose]()`.
+   *
+   * @returns A {@link Promise} that resolves once all children have been disposed.
+   */
+  asyncDispose() {
+    return this[Symbol.asyncDispose]();
+  }
+  /**
+   * Disposes all combined children in the configured {@link DisposeOrder}, applying the configured
+   * {@link DisposeErrorBehavior} when a child throws.
+   *
+   * This method is called automatically when the object is used in an `await using` declaration. It can
+   * also be called manually. The behavior on a second and later dispose is controlled by
+   * {@link CombineAsyncDisposableConstructorParams.multipleDisposeBehavior}.
+   *
+   * @returns A {@link Promise} that resolves once all children have been disposed.
+   */
+  async [Symbol.asyncDispose]() {
+    if (this.isDisposed) {
+      switch (this.multipleDisposeBehavior) {
+        case 1 /* Ignore */:
+          return;
+        case 0 /* Invoke */:
+          break;
+        case 2 /* Throw */:
+          throw new Error("This CombineAsyncDisposable has already been disposed.");
+        default:
+          (0, import_type_guards.assertNever)(this.multipleDisposeBehavior);
+      }
+    }
+    this.isDisposed = true;
+    const errors = [];
+    for (const child of this.getOrderedChildren()) {
+      try {
+        await child[Symbol.asyncDispose]();
+      } catch (error) {
+        if (this.errorBehavior === 1 /* FailFast */) {
+          throw error;
+        }
+        errors.push(error);
+      }
+    }
+    if (errors.length > 0) {
+      throw new AggregateError(errors);
+    }
+  }
+  getOrderedChildren() {
+    switch (this.disposeOrder) {
+      case 1 /* Fifo */:
+        return this.children;
+      case 0 /* Lifo */:
+        return [...this.children].reverse();
+      default:
+        (0, import_type_guards.assertNever)(this.disposeOrder);
+    }
+  }
+}
+class CombineDisposable {
+  children;
+  disposeOrder;
+  errorBehavior;
+  isDisposed = false;
+  multipleDisposeBehavior;
+  /**
+   * Creates a new instance of {@link CombineDisposable}.
+   *
+   * @param params - The parameters.
+   */
+  constructor(params) {
+    this.children = [...params.disposables];
+    this.disposeOrder = params.disposeOrder ?? 0 /* Lifo */;
+    this.errorBehavior = params.errorBehavior ?? 0 /* Aggregate */;
+    this.multipleDisposeBehavior = params.multipleDisposeBehavior ?? 0 /* Invoke */;
+  }
+  /**
+   * Disposes all combined children. Convenience alias that delegates to `this[Symbol.dispose]()`.
+   */
+  dispose() {
+    this[Symbol.dispose]();
+  }
+  /**
+   * Disposes all combined children in the configured {@link DisposeOrder}, applying the configured
+   * {@link DisposeErrorBehavior} when a child throws.
+   *
+   * This method is called automatically when the object is used in a `using` declaration. It can also
+   * be called manually. The behavior on a second and later dispose is controlled by
+   * {@link CombineDisposableConstructorParams.multipleDisposeBehavior}.
+   */
+  [Symbol.dispose]() {
+    if (this.isDisposed) {
+      switch (this.multipleDisposeBehavior) {
+        case 1 /* Ignore */:
+          return;
+        case 0 /* Invoke */:
+          break;
+        case 2 /* Throw */:
+          throw new Error("This CombineDisposable has already been disposed.");
+        default:
+          (0, import_type_guards.assertNever)(this.multipleDisposeBehavior);
+      }
+    }
+    this.isDisposed = true;
+    const errors = [];
+    for (const child of this.getOrderedChildren()) {
+      try {
+        child[Symbol.dispose]();
+      } catch (error) {
+        if (this.errorBehavior === 1 /* FailFast */) {
+          throw error;
+        }
+        errors.push(error);
+      }
+    }
+    if (errors.length > 0) {
+      throw new AggregateError(errors);
+    }
+  }
+  getOrderedChildren() {
+    switch (this.disposeOrder) {
+      case 1 /* Fifo */:
+        return this.children;
+      case 0 /* Lifo */:
+        return [...this.children].reverse();
+      default:
+        (0, import_type_guards.assertNever)(this.disposeOrder);
+    }
+  }
+}
 function isAsyncDisposable(obj) {
   const asyncDisposable = obj;
   return !!asyncDisposable[Symbol.asyncDispose];
 }
+function isAsyncDisposableEx(obj) {
+  const asyncDisposableEx = obj;
+  return isAsyncDisposable(obj) && typeof asyncDisposableEx.asyncDispose === "function";
+}
 function isDisposable(obj) {
   const disposable = obj;
   return !!disposable[Symbol.dispose];
 }
+function isDisposableEx(obj) {
+  const disposableEx = obj;
+  return isDisposable(obj) && typeof disposableEx.dispose === "function";
+}
+function toAsyncDisposableEx(asyncDisposable) {
+  if (isAsyncDisposableEx(asyncDisposable)) {
+    return asyncDisposable;
+  }
+  return {
+    asyncDispose,
+    [Symbol.asyncDispose]: asyncDispose
+  };
+  function asyncDispose() {
+    return Promise.resolve(asyncDisposable[Symbol.asyncDispose]());
+  }
+}
+function toDisposableEx(disposable) {
+  if (isDisposableEx(disposable)) {
+    return disposable;
+  }
+  return {
+    dispose,
+    [Symbol.dispose]: dispose
+  };
+  function dispose() {
+    disposable[Symbol.dispose]();
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AsyncCallbackDisposable,
   CallbackDisposable,
+  CombineAsyncDisposable,
+  CombineDisposable,
+  DisposeErrorBehavior,
+  DisposeOrder,
   MultipleDisposeBehavior,
   isAsyncDisposable,
-  isDisposable
+  isAsyncDisposableEx,
+  isDisposable,
+  isDisposableEx,
+  toAsyncDisposableEx,
+  toDisposableEx
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/disposable.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Disposable utilities for `using` / `await using` declarations.\n */\n\nimport type { Promisable } from 'type-fest';\n\nimport { assertNever } from './type-guards.ts';\n\n/**\n * Determines how a {@link CallbackDisposable} or {@link AsyncCallbackDisposable} behaves when it is\n * disposed more than once.\n */\nexport enum MultipleDisposeBehavior {\n  /**\n   * Invoke the callback on every dispose.\n   */\n  Invoke,\n\n  /**\n   * Invoke the callback on the first dispose only; subsequent disposes are no-ops.\n   */\n  Ignore,\n\n  /**\n   * Invoke the callback on the first dispose only; subsequent disposes throw.\n   */\n  Throw\n}\n\n/**\n * The parameters for constructing an {@link AsyncCallbackDisposable}.\n */\nexport interface AsyncCallbackDisposableConstructorParams {\n  /**\n   * The callback to execute when disposed.\n   */\n  readonly callback: AsyncDisposeCallback;\n\n  /**\n   * How the disposable behaves when disposed more than once.\n   *\n   * @default {@link MultipleDisposeBehavior.Invoke}\n   */\n  readonly multipleDisposeBehavior?: MultipleDisposeBehavior;\n}\n\n/**\n * A callback invoked when an {@link AsyncCallbackDisposable} is disposed.\n */\nexport type AsyncDisposeCallback = (this: void) => Promisable<void>;\n\n/**\n * The parameters for constructing a {@link CallbackDisposable}.\n */\nexport interface CallbackDisposableConstructorParams {\n  /**\n   * The callback to execute when disposed.\n   */\n  readonly callback: DisposeCallback;\n\n  /**\n   * How the disposable behaves when disposed more than once.\n   *\n   * @default {@link MultipleDisposeBehavior.Invoke}\n   */\n  readonly multipleDisposeBehavior?: MultipleDisposeBehavior;\n}\n\n/**\n * A callback invoked when a {@link CallbackDisposable} is disposed.\n */\nexport type DisposeCallback = (this: void) => void;\n\n/**\n * An async disposable that executes a callback when disposed via `await using` (or a manual\n * `await disposable[Symbol.asyncDispose]()`).\n */\nexport class AsyncCallbackDisposable implements AsyncDisposable {\n  private readonly callback: AsyncDisposeCallback;\n  private isDisposed = false;\n  private readonly multipleDisposeBehavior: MultipleDisposeBehavior;\n\n  /**\n   * Creates a new instance of {@link AsyncCallbackDisposable}.\n   *\n   * @param params - The parameters.\n   */\n  public constructor(params: AsyncCallbackDisposableConstructorParams) {\n    this.callback = params.callback;\n    this.multipleDisposeBehavior = params.multipleDisposeBehavior ?? MultipleDisposeBehavior.Invoke;\n  }\n\n  /**\n   * Disposes the object by executing the callback.\n   *\n   * This method is called automatically when the object is used in an `await using` declaration. It\n   * can also be called manually. The behavior on a second and later dispose is controlled by\n   * {@link AsyncCallbackDisposableConstructorParams.multipleDisposeBehavior}.\n   *\n   * @returns A {@link Promise} that resolves once the callback completes.\n   */\n  public async [Symbol.asyncDispose](): Promise<void> {\n    if (this.isDisposed) {\n      switch (this.multipleDisposeBehavior) {\n        case MultipleDisposeBehavior.Ignore:\n          return;\n        case MultipleDisposeBehavior.Invoke:\n          break;\n        case MultipleDisposeBehavior.Throw:\n          throw new Error('This AsyncCallbackDisposable has already been disposed.');\n        default:\n          assertNever(this.multipleDisposeBehavior);\n      }\n    }\n\n    this.isDisposed = true;\n    await this.callback();\n  }\n}\n\n/**\n * A disposable that executes a callback when disposed.\n */\nexport class CallbackDisposable implements Disposable {\n  private readonly callback: DisposeCallback;\n  private isDisposed = false;\n  private readonly multipleDisposeBehavior: MultipleDisposeBehavior;\n\n  /**\n   * Creates a new instance of {@link CallbackDisposable}.\n   *\n   * @param params - The parameters.\n   */\n  public constructor(params: CallbackDisposableConstructorParams) {\n    this.callback = params.callback;\n    this.multipleDisposeBehavior = params.multipleDisposeBehavior ?? MultipleDisposeBehavior.Invoke;\n  }\n\n  /**\n   * Disposes the object by executing the callback.\n   *\n   * This method is called automatically when the object is used in a `using` declaration. It can also\n   * be called manually. The behavior on a second and later dispose is controlled by\n   * {@link CallbackDisposableConstructorParams.multipleDisposeBehavior}.\n   */\n  public [Symbol.dispose](): void {\n    if (this.isDisposed) {\n      switch (this.multipleDisposeBehavior) {\n        case MultipleDisposeBehavior.Ignore:\n          return;\n        case MultipleDisposeBehavior.Invoke:\n          break;\n        case MultipleDisposeBehavior.Throw:\n          throw new Error('This CallbackDisposable has already been disposed.');\n        default:\n          assertNever(this.multipleDisposeBehavior);\n      }\n    }\n\n    this.isDisposed = true;\n    this.callback();\n  }\n}\n\n/**\n * Type guard to check if an object implements the {@link AsyncDisposable} interface.\n *\n * @param obj - the object to check for the {@link AsyncDisposable} interface\n * @returns Whether the object implements the {@link AsyncDisposable} interface\n */\nexport function isAsyncDisposable(obj: unknown): obj is AsyncDisposable {\n  const asyncDisposable = obj as Partial<AsyncDisposable>;\n  return !!asyncDisposable[Symbol.asyncDispose];\n}\n\n/**\n * Type guard to check if an object implements the {@link Disposable} interface.\n *\n * @param obj - the object to check for the {@link Disposable} interface\n * @returns Whether the object implements the {@link Disposable} interface\n */\nexport function isDisposable(obj: unknown): obj is Disposable {\n  const disposable = obj as Partial<Disposable>;\n  return !!disposable[Symbol.dispose];\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,yBAA4B;AAMrB,IAAK,0BAAL,kBAAKA,6BAAL;AAIL,EAAAA,kDAAA;AAKA,EAAAA,kDAAA;AAKA,EAAAA,kDAAA;AAdU,SAAAA;AAAA,GAAA;AAiEL,MAAM,wBAAmD;AAAA,EAC7C;AAAA,EACT,aAAa;AAAA,EACJ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOV,YAAY,QAAkD;AACnE,SAAK,WAAW,OAAO;AACvB,SAAK,0BAA0B,OAAO,2BAA2B;AAAA,EACnE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWA,OAAc,OAAO,YAAY,IAAmB;AAClD,QAAI,KAAK,YAAY;AACnB,cAAQ,KAAK,yBAAyB;AAAA,QACpC,KAAK;AACH;AAAA,QACF,KAAK;AACH;AAAA,QACF,KAAK;AACH,gBAAM,IAAI,MAAM,yDAAyD;AAAA,QAC3E;AACE,8CAAY,KAAK,uBAAuB;AAAA,MAC5C;AAAA,IACF;AAEA,SAAK,aAAa;AAClB,UAAM,KAAK,SAAS;AAAA,EACtB;AACF;AAKO,MAAM,mBAAyC;AAAA,EACnC;AAAA,EACT,aAAa;AAAA,EACJ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOV,YAAY,QAA6C;AAC9D,SAAK,WAAW,OAAO;AACvB,SAAK,0BAA0B,OAAO,2BAA2B;AAAA,EACnE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,CAAQ,OAAO,OAAO,IAAU;AAC9B,QAAI,KAAK,YAAY;AACnB,cAAQ,KAAK,yBAAyB;AAAA,QACpC,KAAK;AACH;AAAA,QACF,KAAK;AACH;AAAA,QACF,KAAK;AACH,gBAAM,IAAI,MAAM,oDAAoD;AAAA,QACtE;AACE,8CAAY,KAAK,uBAAuB;AAAA,MAC5C;AAAA,IACF;AAEA,SAAK,aAAa;AAClB,SAAK,SAAS;AAAA,EAChB;AACF;AAQO,SAAS,kBAAkB,KAAsC;AACtE,QAAM,kBAAkB;AACxB,SAAO,CAAC,CAAC,gBAAgB,OAAO,YAAY;AAC9C;AAQO,SAAS,aAAa,KAAiC;AAC5D,QAAM,aAAa;AACnB,SAAO,CAAC,CAAC,WAAW,OAAO,OAAO;AACpC;",
  "names": ["MultipleDisposeBehavior"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/disposable.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Disposable utilities for `using` / `await using` declarations.\n */\n\nimport type { Promisable } from 'type-fest';\n\nimport { assertNever } from './type-guards.ts';\n\n/**\n * Determines the error semantics of a {@link CombineDisposable} or {@link CombineAsyncDisposable} when\n * one of its children throws while being disposed.\n */\nexport enum DisposeErrorBehavior {\n  /**\n   * Dispose every child even if some of them throw, collecting the thrown errors and re-throwing them\n   * as a single {@link AggregateError} once all children have been disposed.\n   */\n  Aggregate,\n\n  /**\n   * Re-throw the first error a child throws immediately, leaving the remaining children undisposed.\n   */\n  FailFast\n}\n\n/**\n * Determines the order in which a {@link CombineDisposable} or {@link CombineAsyncDisposable} disposes\n * its children.\n */\nexport enum DisposeOrder {\n  /**\n   * Dispose the last-registered child first (last-in, first-out), like nested `using` declarations\n   * unwinding in reverse.\n   */\n  Lifo,\n\n  /**\n   * Dispose the first-registered child first (first-in, first-out).\n   */\n  Fifo\n}\n\n/**\n * Determines how a {@link CallbackDisposable} or {@link AsyncCallbackDisposable} behaves when it is\n * disposed more than once.\n */\nexport enum MultipleDisposeBehavior {\n  /**\n   * Invoke the callback on every dispose.\n   */\n  Invoke,\n\n  /**\n   * Invoke the callback on the first dispose only; subsequent disposes are no-ops.\n   */\n  Ignore,\n\n  /**\n   * Invoke the callback on the first dispose only; subsequent disposes throw.\n   */\n  Throw\n}\n\n/**\n * The parameters for constructing an {@link AsyncCallbackDisposable}.\n */\nexport interface AsyncCallbackDisposableConstructorParams {\n  /**\n   * The callback to execute when disposed.\n   */\n  readonly callback: AsyncDisposeCallback;\n\n  /**\n   * How the disposable behaves when disposed more than once.\n   *\n   * @default {@link MultipleDisposeBehavior.Invoke}\n   */\n  readonly multipleDisposeBehavior?: MultipleDisposeBehavior;\n}\n\n/**\n * An {@link AsyncDisposable} that additionally exposes a convenience {@link AsyncDisposableEx.asyncDispose}\n * method, so a stored handle can be disposed as `handle.asyncDispose()` instead of the clunkier\n * `handle[Symbol.asyncDispose]()`.\n */\nexport interface AsyncDisposableEx extends AsyncDisposable {\n  /**\n   * Disposes the object. Delegates to `this[Symbol.asyncDispose]()`.\n   *\n   * @returns A {@link Promise} that resolves once disposal completes.\n   */\n  asyncDispose(): Promise<void>;\n}\n\n/**\n * A callback invoked when an {@link AsyncCallbackDisposable} is disposed.\n */\nexport type AsyncDisposeCallback = (this: void) => Promisable<void>;\n\n/**\n * The parameters for constructing a {@link CallbackDisposable}.\n */\nexport interface CallbackDisposableConstructorParams {\n  /**\n   * The callback to execute when disposed.\n   */\n  readonly callback: DisposeCallback;\n\n  /**\n   * How the disposable behaves when disposed more than once.\n   *\n   * @default {@link MultipleDisposeBehavior.Invoke}\n   */\n  readonly multipleDisposeBehavior?: MultipleDisposeBehavior;\n}\n\n/**\n * The parameters for constructing a {@link CombineAsyncDisposable}.\n */\nexport interface CombineAsyncDisposableConstructorParams {\n  /**\n   * The async disposables to dispose when the combiner is disposed.\n   */\n  readonly asyncDisposables: Iterable<AsyncDisposable>;\n\n  /**\n   * The order in which the children are disposed.\n   *\n   * @default {@link DisposeOrder.Lifo}\n   */\n  readonly disposeOrder?: DisposeOrder;\n\n  /**\n   * How the combiner behaves when one of its children throws while being disposed.\n   *\n   * @default {@link DisposeErrorBehavior.Aggregate}\n   */\n  readonly errorBehavior?: DisposeErrorBehavior;\n\n  /**\n   * How the combiner behaves when it is disposed more than once.\n   *\n   * @default {@link MultipleDisposeBehavior.Invoke}\n   */\n  readonly multipleDisposeBehavior?: MultipleDisposeBehavior;\n}\n\n/**\n * The parameters for constructing a {@link CombineDisposable}.\n */\nexport interface CombineDisposableConstructorParams {\n  /**\n   * The disposables to dispose when the combiner is disposed.\n   */\n  readonly disposables: Iterable<Disposable>;\n\n  /**\n   * The order in which the children are disposed.\n   *\n   * @default {@link DisposeOrder.Lifo}\n   */\n  readonly disposeOrder?: DisposeOrder;\n\n  /**\n   * How the combiner behaves when one of its children throws while being disposed.\n   *\n   * @default {@link DisposeErrorBehavior.Aggregate}\n   */\n  readonly errorBehavior?: DisposeErrorBehavior;\n\n  /**\n   * How the combiner behaves when it is disposed more than once.\n   *\n   * @default {@link MultipleDisposeBehavior.Invoke}\n   */\n  readonly multipleDisposeBehavior?: MultipleDisposeBehavior;\n}\n\n/**\n * A {@link Disposable} that additionally exposes a convenience {@link DisposableEx.dispose} method, so a\n * stored handle can be disposed as `handle.dispose()` instead of the clunkier `handle[Symbol.dispose]()`.\n */\nexport interface DisposableEx extends Disposable {\n  /**\n   * Disposes the object. Delegates to `this[Symbol.dispose]()`.\n   */\n  dispose(): void;\n}\n\n/**\n * A callback invoked when a {@link CallbackDisposable} is disposed.\n */\nexport type DisposeCallback = (this: void) => void;\n\n/**\n * An async disposable that executes a callback when disposed via `await using` (or a manual\n * `await disposable[Symbol.asyncDispose]()`).\n */\nexport class AsyncCallbackDisposable implements AsyncDisposableEx {\n  private readonly callback: AsyncDisposeCallback;\n  private isDisposed = false;\n  private readonly multipleDisposeBehavior: MultipleDisposeBehavior;\n\n  /**\n   * Creates a new instance of {@link AsyncCallbackDisposable}.\n   *\n   * @param params - The parameters.\n   */\n  public constructor(params: AsyncCallbackDisposableConstructorParams) {\n    this.callback = params.callback;\n    this.multipleDisposeBehavior = params.multipleDisposeBehavior ?? MultipleDisposeBehavior.Invoke;\n  }\n\n  /**\n   * Disposes the object by executing the callback. Convenience alias that delegates to\n   * `this[Symbol.asyncDispose]()`.\n   *\n   * @returns A {@link Promise} that resolves once the callback completes.\n   */\n  public asyncDispose(): Promise<void> {\n    return this[Symbol.asyncDispose]();\n  }\n\n  /**\n   * Disposes the object by executing the callback.\n   *\n   * This method is called automatically when the object is used in an `await using` declaration. It\n   * can also be called manually. The behavior on a second and later dispose is controlled by\n   * {@link AsyncCallbackDisposableConstructorParams.multipleDisposeBehavior}.\n   *\n   * @returns A {@link Promise} that resolves once the callback completes.\n   */\n  public async [Symbol.asyncDispose](): Promise<void> {\n    if (this.isDisposed) {\n      switch (this.multipleDisposeBehavior) {\n        case MultipleDisposeBehavior.Ignore:\n          return;\n        case MultipleDisposeBehavior.Invoke:\n          break;\n        case MultipleDisposeBehavior.Throw:\n          throw new Error('This AsyncCallbackDisposable has already been disposed.');\n        default:\n          assertNever(this.multipleDisposeBehavior);\n      }\n    }\n\n    this.isDisposed = true;\n    await this.callback();\n  }\n}\n\n/**\n * A disposable that executes a callback when disposed.\n */\nexport class CallbackDisposable implements DisposableEx {\n  private readonly callback: DisposeCallback;\n  private isDisposed = false;\n  private readonly multipleDisposeBehavior: MultipleDisposeBehavior;\n\n  /**\n   * Creates a new instance of {@link CallbackDisposable}.\n   *\n   * @param params - The parameters.\n   */\n  public constructor(params: CallbackDisposableConstructorParams) {\n    this.callback = params.callback;\n    this.multipleDisposeBehavior = params.multipleDisposeBehavior ?? MultipleDisposeBehavior.Invoke;\n  }\n\n  /**\n   * Disposes the object by executing the callback. Convenience alias that delegates to\n   * `this[Symbol.dispose]()`.\n   */\n  public dispose(): void {\n    this[Symbol.dispose]();\n  }\n\n  /**\n   * Disposes the object by executing the callback.\n   *\n   * This method is called automatically when the object is used in a `using` declaration. It can also\n   * be called manually. The behavior on a second and later dispose is controlled by\n   * {@link CallbackDisposableConstructorParams.multipleDisposeBehavior}.\n   */\n  public [Symbol.dispose](): void {\n    if (this.isDisposed) {\n      switch (this.multipleDisposeBehavior) {\n        case MultipleDisposeBehavior.Ignore:\n          return;\n        case MultipleDisposeBehavior.Invoke:\n          break;\n        case MultipleDisposeBehavior.Throw:\n          throw new Error('This CallbackDisposable has already been disposed.');\n        default:\n          assertNever(this.multipleDisposeBehavior);\n      }\n    }\n\n    this.isDisposed = true;\n    this.callback();\n  }\n}\n\n/**\n * An {@link AsyncDisposableEx} that combines multiple async disposables and disposes all of them when it\n * is disposed.\n */\nexport class CombineAsyncDisposable implements AsyncDisposableEx {\n  private readonly children: readonly AsyncDisposable[];\n  private readonly disposeOrder: DisposeOrder;\n  private readonly errorBehavior: DisposeErrorBehavior;\n  private isDisposed = false;\n  private readonly multipleDisposeBehavior: MultipleDisposeBehavior;\n\n  /**\n   * Creates a new instance of {@link CombineAsyncDisposable}.\n   *\n   * @param params - The parameters.\n   */\n  public constructor(params: CombineAsyncDisposableConstructorParams) {\n    this.children = [...params.asyncDisposables];\n    this.disposeOrder = params.disposeOrder ?? DisposeOrder.Lifo;\n    this.errorBehavior = params.errorBehavior ?? DisposeErrorBehavior.Aggregate;\n    this.multipleDisposeBehavior = params.multipleDisposeBehavior ?? MultipleDisposeBehavior.Invoke;\n  }\n\n  /**\n   * Disposes all combined children. Convenience alias that delegates to\n   * `this[Symbol.asyncDispose]()`.\n   *\n   * @returns A {@link Promise} that resolves once all children have been disposed.\n   */\n  public asyncDispose(): Promise<void> {\n    return this[Symbol.asyncDispose]();\n  }\n\n  /**\n   * Disposes all combined children in the configured {@link DisposeOrder}, applying the configured\n   * {@link DisposeErrorBehavior} when a child throws.\n   *\n   * This method is called automatically when the object is used in an `await using` declaration. It can\n   * also be called manually. The behavior on a second and later dispose is controlled by\n   * {@link CombineAsyncDisposableConstructorParams.multipleDisposeBehavior}.\n   *\n   * @returns A {@link Promise} that resolves once all children have been disposed.\n   */\n  public async [Symbol.asyncDispose](): Promise<void> {\n    if (this.isDisposed) {\n      switch (this.multipleDisposeBehavior) {\n        case MultipleDisposeBehavior.Ignore:\n          return;\n        case MultipleDisposeBehavior.Invoke:\n          break;\n        case MultipleDisposeBehavior.Throw:\n          throw new Error('This CombineAsyncDisposable has already been disposed.');\n        default:\n          assertNever(this.multipleDisposeBehavior);\n      }\n    }\n\n    this.isDisposed = true;\n\n    const errors: unknown[] = [];\n    for (const child of this.getOrderedChildren()) {\n      try {\n        await child[Symbol.asyncDispose]();\n      } catch (error) {\n        if (this.errorBehavior === DisposeErrorBehavior.FailFast) {\n          throw error;\n        }\n\n        errors.push(error);\n      }\n    }\n\n    if (errors.length > 0) {\n      throw new AggregateError(errors);\n    }\n  }\n\n  private getOrderedChildren(): readonly AsyncDisposable[] {\n    switch (this.disposeOrder) {\n      case DisposeOrder.Fifo:\n        return this.children;\n      case DisposeOrder.Lifo:\n        return [...this.children].reverse();\n      default:\n        assertNever(this.disposeOrder);\n    }\n  }\n}\n\n/**\n * A {@link DisposableEx} that combines multiple disposables and disposes all of them when it is\n * disposed.\n */\nexport class CombineDisposable implements DisposableEx {\n  private readonly children: readonly Disposable[];\n  private readonly disposeOrder: DisposeOrder;\n  private readonly errorBehavior: DisposeErrorBehavior;\n  private isDisposed = false;\n  private readonly multipleDisposeBehavior: MultipleDisposeBehavior;\n\n  /**\n   * Creates a new instance of {@link CombineDisposable}.\n   *\n   * @param params - The parameters.\n   */\n  public constructor(params: CombineDisposableConstructorParams) {\n    this.children = [...params.disposables];\n    this.disposeOrder = params.disposeOrder ?? DisposeOrder.Lifo;\n    this.errorBehavior = params.errorBehavior ?? DisposeErrorBehavior.Aggregate;\n    this.multipleDisposeBehavior = params.multipleDisposeBehavior ?? MultipleDisposeBehavior.Invoke;\n  }\n\n  /**\n   * Disposes all combined children. Convenience alias that delegates to `this[Symbol.dispose]()`.\n   */\n  public dispose(): void {\n    this[Symbol.dispose]();\n  }\n\n  /**\n   * Disposes all combined children in the configured {@link DisposeOrder}, applying the configured\n   * {@link DisposeErrorBehavior} when a child throws.\n   *\n   * This method is called automatically when the object is used in a `using` declaration. It can also\n   * be called manually. The behavior on a second and later dispose is controlled by\n   * {@link CombineDisposableConstructorParams.multipleDisposeBehavior}.\n   */\n  public [Symbol.dispose](): void {\n    if (this.isDisposed) {\n      switch (this.multipleDisposeBehavior) {\n        case MultipleDisposeBehavior.Ignore:\n          return;\n        case MultipleDisposeBehavior.Invoke:\n          break;\n        case MultipleDisposeBehavior.Throw:\n          throw new Error('This CombineDisposable has already been disposed.');\n        default:\n          assertNever(this.multipleDisposeBehavior);\n      }\n    }\n\n    this.isDisposed = true;\n\n    const errors: unknown[] = [];\n    for (const child of this.getOrderedChildren()) {\n      try {\n        child[Symbol.dispose]();\n      } catch (error) {\n        if (this.errorBehavior === DisposeErrorBehavior.FailFast) {\n          throw error;\n        }\n\n        errors.push(error);\n      }\n    }\n\n    if (errors.length > 0) {\n      throw new AggregateError(errors);\n    }\n  }\n\n  private getOrderedChildren(): readonly Disposable[] {\n    switch (this.disposeOrder) {\n      case DisposeOrder.Fifo:\n        return this.children;\n      case DisposeOrder.Lifo:\n        return [...this.children].reverse();\n      default:\n        assertNever(this.disposeOrder);\n    }\n  }\n}\n\n/**\n * Type guard to check if an object implements the {@link AsyncDisposable} interface.\n *\n * @param obj - the object to check for the {@link AsyncDisposable} interface\n * @returns Whether the object implements the {@link AsyncDisposable} interface\n */\nexport function isAsyncDisposable(obj: unknown): obj is AsyncDisposable {\n  const asyncDisposable = obj as Partial<AsyncDisposable>;\n  return !!asyncDisposable[Symbol.asyncDispose];\n}\n\n/**\n * Type guard to check if an object implements the {@link AsyncDisposableEx} interface.\n *\n * @param obj - the object to check for the {@link AsyncDisposableEx} interface\n * @returns Whether the object implements the {@link AsyncDisposableEx} interface\n */\nexport function isAsyncDisposableEx(obj: unknown): obj is AsyncDisposableEx {\n  const asyncDisposableEx = obj as Partial<AsyncDisposableEx>;\n  return isAsyncDisposable(obj) && typeof asyncDisposableEx.asyncDispose === 'function';\n}\n\n/**\n * Type guard to check if an object implements the {@link Disposable} interface.\n *\n * @param obj - the object to check for the {@link Disposable} interface\n * @returns Whether the object implements the {@link Disposable} interface\n */\nexport function isDisposable(obj: unknown): obj is Disposable {\n  const disposable = obj as Partial<Disposable>;\n  return !!disposable[Symbol.dispose];\n}\n\n/**\n * Type guard to check if an object implements the {@link DisposableEx} interface.\n *\n * @param obj - the object to check for the {@link DisposableEx} interface\n * @returns Whether the object implements the {@link DisposableEx} interface\n */\nexport function isDisposableEx(obj: unknown): obj is DisposableEx {\n  const disposableEx = obj as Partial<DisposableEx>;\n  return isDisposable(obj) && typeof disposableEx.dispose === 'function';\n}\n\n/**\n * Adapts a plain {@link AsyncDisposable} into an {@link AsyncDisposableEx} by adding a convenience\n * {@link AsyncDisposableEx.asyncDispose} method that delegates to `Symbol.asyncDispose`.\n *\n * If the object already implements {@link AsyncDisposableEx}, it is returned unchanged.\n *\n * @param asyncDisposable - the async disposable to adapt\n * @returns An {@link AsyncDisposableEx} wrapping the async disposable.\n */\nexport function toAsyncDisposableEx(asyncDisposable: AsyncDisposable): AsyncDisposableEx {\n  if (isAsyncDisposableEx(asyncDisposable)) {\n    return asyncDisposable;\n  }\n\n  return {\n    asyncDispose,\n    [Symbol.asyncDispose]: asyncDispose\n  };\n\n  function asyncDispose(): Promise<void> {\n    return Promise.resolve(asyncDisposable[Symbol.asyncDispose]());\n  }\n}\n\n/**\n * Adapts a plain {@link Disposable} into a {@link DisposableEx} by adding a convenience\n * {@link DisposableEx.dispose} method that delegates to `Symbol.dispose`.\n *\n * If the object already implements {@link DisposableEx}, it is returned unchanged.\n *\n * @param disposable - the disposable to adapt\n * @returns A {@link DisposableEx} wrapping the disposable.\n */\nexport function toDisposableEx(disposable: Disposable): DisposableEx {\n  if (isDisposableEx(disposable)) {\n    return disposable;\n  }\n\n  return {\n    dispose,\n    [Symbol.dispose]: dispose\n  };\n\n  function dispose(): void {\n    disposable[Symbol.dispose]();\n  }\n}\n"],
  "mappings": "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",
  "names": ["DisposeErrorBehavior", "DisposeOrder", "MultipleDisposeBehavior"]
}


package/dist/lib/cjs/disposable.d.cts

@@ -5,6 +5,36 @@
  * Disposable utilities for `using` / `await using` declarations.
  */
 import type { Promisable } from 'type-fest' with { 'resolution-mode': 'import' };
+/**
+ * Determines the error semantics of a {@link CombineDisposable} or {@link CombineAsyncDisposable} when
+ * one of its children throws while being disposed.
+ */
+export declare enum DisposeErrorBehavior {
+    /**
+     * Dispose every child even if some of them throw, collecting the thrown errors and re-throwing them
+     * as a single {@link AggregateError} once all children have been disposed.
+     */
+    Aggregate = 0,
+    /**
+     * Re-throw the first error a child throws immediately, leaving the remaining children undisposed.
+     */
+    FailFast = 1
+}
+/**
+ * Determines the order in which a {@link CombineDisposable} or {@link CombineAsyncDisposable} disposes
+ * its children.
+ */
+export declare enum DisposeOrder {
+    /**
+     * Dispose the last-registered child first (last-in, first-out), like nested `using` declarations
+     * unwinding in reverse.
+     */
+    Lifo = 0,
+    /**
+     * Dispose the first-registered child first (first-in, first-out).
+     */
+    Fifo = 1
+}
 /**
  * Determines how a {@link CallbackDisposable} or {@link AsyncCallbackDisposable} behaves when it is
  * disposed more than once.
@@ -38,6 +68,19 @@ export interface AsyncCallbackDisposableConstructorParams {
      */
     readonly multipleDisposeBehavior?: MultipleDisposeBehavior;
 }
+/**
+ * An {@link AsyncDisposable} that additionally exposes a convenience {@link AsyncDisposableEx.asyncDispose}
+ * method, so a stored handle can be disposed as `handle.asyncDispose()` instead of the clunkier
+ * `handle[Symbol.asyncDispose]()`.
+ */
+export interface AsyncDisposableEx extends AsyncDisposable {
+    /**
+     * Disposes the object. Delegates to `this[Symbol.asyncDispose]()`.
+     *
+     * @returns A {@link Promise} that resolves once disposal completes.
+     */
+    asyncDispose(): Promise<void>;
+}
 /**
  * A callback invoked when an {@link AsyncCallbackDisposable} is disposed.
  */
@@ -57,6 +100,70 @@ export interface CallbackDisposableConstructorParams {
      */
     readonly multipleDisposeBehavior?: MultipleDisposeBehavior;
 }
+/**
+ * The parameters for constructing a {@link CombineAsyncDisposable}.
+ */
+export interface CombineAsyncDisposableConstructorParams {
+    /**
+     * The async disposables to dispose when the combiner is disposed.
+     */
+    readonly asyncDisposables: Iterable<AsyncDisposable>;
+    /**
+     * The order in which the children are disposed.
+     *
+     * @default {@link DisposeOrder.Lifo}
+     */
+    readonly disposeOrder?: DisposeOrder;
+    /**
+     * How the combiner behaves when one of its children throws while being disposed.
+     *
+     * @default {@link DisposeErrorBehavior.Aggregate}
+     */
+    readonly errorBehavior?: DisposeErrorBehavior;
+    /**
+     * How the combiner behaves when it is disposed more than once.
+     *
+     * @default {@link MultipleDisposeBehavior.Invoke}
+     */
+    readonly multipleDisposeBehavior?: MultipleDisposeBehavior;
+}
+/**
+ * The parameters for constructing a {@link CombineDisposable}.
+ */
+export interface CombineDisposableConstructorParams {
+    /**
+     * The disposables to dispose when the combiner is disposed.
+     */
+    readonly disposables: Iterable<Disposable>;
+    /**
+     * The order in which the children are disposed.
+     *
+     * @default {@link DisposeOrder.Lifo}
+     */
+    readonly disposeOrder?: DisposeOrder;
+    /**
+     * How the combiner behaves when one of its children throws while being disposed.
+     *
+     * @default {@link DisposeErrorBehavior.Aggregate}
+     */
+    readonly errorBehavior?: DisposeErrorBehavior;
+    /**
+     * How the combiner behaves when it is disposed more than once.
+     *
+     * @default {@link MultipleDisposeBehavior.Invoke}
+     */
+    readonly multipleDisposeBehavior?: MultipleDisposeBehavior;
+}
+/**
+ * A {@link Disposable} that additionally exposes a convenience {@link DisposableEx.dispose} method, so a
+ * stored handle can be disposed as `handle.dispose()` instead of the clunkier `handle[Symbol.dispose]()`.
+ */
+export interface DisposableEx extends Disposable {
+    /**
+     * Disposes the object. Delegates to `this[Symbol.dispose]()`.
+     */
+    dispose(): void;
+}
 /**
  * A callback invoked when a {@link CallbackDisposable} is disposed.
  */
@@ -65,7 +172,7 @@ export type DisposeCallback = (this: void) => void;
  * An async disposable that executes a callback when disposed via `await using` (or a manual
  * `await disposable[Symbol.asyncDispose]()`).
  */
-export declare class AsyncCallbackDisposable implements AsyncDisposable {
+export declare class AsyncCallbackDisposable implements AsyncDisposableEx {
     private readonly callback;
     private isDisposed;
     private readonly multipleDisposeBehavior;
@@ -75,6 +182,13 @@ export declare class AsyncCallbackDisposable implements AsyncDisposable {
      * @param params - The parameters.
      */
     constructor(params: AsyncCallbackDisposableConstructorParams);
+    /**
+     * Disposes the object by executing the callback. Convenience alias that delegates to
+     * `this[Symbol.asyncDispose]()`.
+     *
+     * @returns A {@link Promise} that resolves once the callback completes.
+     */
+    asyncDispose(): Promise<void>;
     /**
      * Disposes the object by executing the callback.
      *
@@ -89,7 +203,7 @@ export declare class AsyncCallbackDisposable implements AsyncDisposable {
 /**
  * A disposable that executes a callback when disposed.
  */
-export declare class CallbackDisposable implements Disposable {
+export declare class CallbackDisposable implements DisposableEx {
     private readonly callback;
     private isDisposed;
     private readonly multipleDisposeBehavior;
@@ -99,6 +213,11 @@ export declare class CallbackDisposable implements Disposable {
      * @param params - The parameters.
      */
     constructor(params: CallbackDisposableConstructorParams);
+    /**
+     * Disposes the object by executing the callback. Convenience alias that delegates to
+     * `this[Symbol.dispose]()`.
+     */
+    dispose(): void;
     /**
      * Disposes the object by executing the callback.
      *
@@ -108,6 +227,73 @@ export declare class CallbackDisposable implements Disposable {
      */
     [Symbol.dispose](): void;
 }
+/**
+ * An {@link AsyncDisposableEx} that combines multiple async disposables and disposes all of them when it
+ * is disposed.
+ */
+export declare class CombineAsyncDisposable implements AsyncDisposableEx {
+    private readonly children;
+    private readonly disposeOrder;
+    private readonly errorBehavior;
+    private isDisposed;
+    private readonly multipleDisposeBehavior;
+    /**
+     * Creates a new instance of {@link CombineAsyncDisposable}.
+     *
+     * @param params - The parameters.
+     */
+    constructor(params: CombineAsyncDisposableConstructorParams);
+    /**
+     * Disposes all combined children. Convenience alias that delegates to
+     * `this[Symbol.asyncDispose]()`.
+     *
+     * @returns A {@link Promise} that resolves once all children have been disposed.
+     */
+    asyncDispose(): Promise<void>;
+    /**
+     * Disposes all combined children in the configured {@link DisposeOrder}, applying the configured
+     * {@link DisposeErrorBehavior} when a child throws.
+     *
+     * This method is called automatically when the object is used in an `await using` declaration. It can
+     * also be called manually. The behavior on a second and later dispose is controlled by
+     * {@link CombineAsyncDisposableConstructorParams.multipleDisposeBehavior}.
+     *
+     * @returns A {@link Promise} that resolves once all children have been disposed.
+     */
+    [Symbol.asyncDispose](): Promise<void>;
+    private getOrderedChildren;
+}
+/**
+ * A {@link DisposableEx} that combines multiple disposables and disposes all of them when it is
+ * disposed.
+ */
+export declare class CombineDisposable implements DisposableEx {
+    private readonly children;
+    private readonly disposeOrder;
+    private readonly errorBehavior;
+    private isDisposed;
+    private readonly multipleDisposeBehavior;
+    /**
+     * Creates a new instance of {@link CombineDisposable}.
+     *
+     * @param params - The parameters.
+     */
+    constructor(params: CombineDisposableConstructorParams);
+    /**
+     * Disposes all combined children. Convenience alias that delegates to `this[Symbol.dispose]()`.
+     */
+    dispose(): void;
+    /**
+     * Disposes all combined children in the configured {@link DisposeOrder}, applying the configured
+     * {@link DisposeErrorBehavior} when a child throws.
+     *
+     * This method is called automatically when the object is used in a `using` declaration. It can also
+     * be called manually. The behavior on a second and later dispose is controlled by
+     * {@link CombineDisposableConstructorParams.multipleDisposeBehavior}.
+     */
+    [Symbol.dispose](): void;
+    private getOrderedChildren;
+}
 /**
  * Type guard to check if an object implements the {@link AsyncDisposable} interface.
  *
@@ -115,6 +301,13 @@ export declare class CallbackDisposable implements Disposable {
  * @returns Whether the object implements the {@link AsyncDisposable} interface
  */
 export declare function isAsyncDisposable(obj: unknown): obj is AsyncDisposable;
+/**
+ * Type guard to check if an object implements the {@link AsyncDisposableEx} interface.
+ *
+ * @param obj - the object to check for the {@link AsyncDisposableEx} interface
+ * @returns Whether the object implements the {@link AsyncDisposableEx} interface
+ */
+export declare function isAsyncDisposableEx(obj: unknown): obj is AsyncDisposableEx;
 /**
  * Type guard to check if an object implements the {@link Disposable} interface.
  *
@@ -122,3 +315,30 @@ export declare function isAsyncDisposable(obj: unknown): obj is AsyncDisposable;
  * @returns Whether the object implements the {@link Disposable} interface
  */
 export declare function isDisposable(obj: unknown): obj is Disposable;
+/**
+ * Type guard to check if an object implements the {@link DisposableEx} interface.
+ *
+ * @param obj - the object to check for the {@link DisposableEx} interface
+ * @returns Whether the object implements the {@link DisposableEx} interface
+ */
+export declare function isDisposableEx(obj: unknown): obj is DisposableEx;
+/**
+ * Adapts a plain {@link AsyncDisposable} into an {@link AsyncDisposableEx} by adding a convenience
+ * {@link AsyncDisposableEx.asyncDispose} method that delegates to `Symbol.asyncDispose`.
+ *
+ * If the object already implements {@link AsyncDisposableEx}, it is returned unchanged.
+ *
+ * @param asyncDisposable - the async disposable to adapt
+ * @returns An {@link AsyncDisposableEx} wrapping the async disposable.
+ */
+export declare function toAsyncDisposableEx(asyncDisposable: AsyncDisposable): AsyncDisposableEx;
+/**
+ * Adapts a plain {@link Disposable} into a {@link DisposableEx} by adding a convenience
+ * {@link DisposableEx.dispose} method that delegates to `Symbol.dispose`.
+ *
+ * If the object already implements {@link DisposableEx}, it is returned unchanged.
+ *
+ * @param disposable - the disposable to adapt
+ * @returns A {@link DisposableEx} wrapping the disposable.
+ */
+export declare function toDisposableEx(disposable: Disposable): DisposableEx;