@mnaoumov/typescript-lib 0.0.0 → 1.0.0

package/dist/lib/cjs/desktop-zip-extractor.d.cts

@@ -0,0 +1,95 @@
+/// <reference path="./library.d.cts" />
+/**
+ * @file
+ *
+ * Extracts a ZIP archive to disk using only Node's `zlib` — with no third-party unzip dependency.
+ *
+ * It exists for one measured reason. The dependency it replaced on this path, `adm-zip`, bundled
+ * roughly 34 KB of minified JavaScript into EVERY Obsidian plugin built with this library: a plugin
+ * ships a single CJS `main.js`, esbuild has no code splitting to put a dependency behind, and a
+ * `await import()` only defers evaluation — the module body is inlined either way. `node:zlib` is
+ * already an esbuild external, so the same work now costs a plugin bundle nothing at all. Archives are
+ * WRITTEN with `fflate` at release time (`script-utils/demo-vault.ts`), which is Node-side tooling and
+ * never reaches a plugin bundle — a third-party writer there is also what keeps this reader checked
+ * against an implementation that is not its own.
+ *
+ * Deliberately narrow: it reads exactly what that writer produces — stored and deflated entries in an
+ * unencrypted archive below the 4 GB / 65535-entry ZIP64 threshold — and raises a named error for
+ * anything else rather than guessing at it. Sizes and offsets are taken from the central directory,
+ * which is authoritative even for archives written with data descriptors.
+ *
+ * The `node:` imports below are safe to merely EVALUATE on mobile — `require` hands back `undefined`
+ * there and nothing reads it at load time — so this module can sit in the generated barrels without
+ * breaking the library's load on Android. Only the calls are desktop-only.
+ */
+import type { Buffer } from 'node:buffer' with { 'resolution-mode': 'import' };
+/**
+ * Parameters for {@link extractZipArchive}.
+ */
+export interface ExtractZipArchiveParams {
+    /**
+     * The raw ZIP archive bytes.
+     */
+    readonly archive: Buffer;
+    /**
+     * The file-system implementation the extracted entries are written with.
+     *
+     * Injected rather than imported so the caller chooses which `fs` writes the files. The demo-vault
+     * opener hands over Electron's `original-fs` (see {@link ZipExtractionFileSystem}).
+     */
+    readonly fileSystem: ZipExtractionFileSystem;
+    /**
+     * The directory to extract into. Created if it does not exist.
+     */
+    readonly targetDirectory: string;
+}
+/**
+ * The slice of `node:fs` extraction needs.
+ *
+ * Only the two WRITING calls are required, and that is deliberate: Electron's asar layer intercepts
+ * `fs` READS (and `existsSync`) on any path containing `.asar`, which a demo vault may legitimately
+ * ship as a plain file. Never probing the target with a read keeps that interception out of the
+ * picture entirely, and a caller that hands over Electron's `original-fs` is safe even from the
+ * write side.
+ */
+export interface ZipExtractionFileSystem {
+    /**
+     * Creates a directory, including any missing parents.
+     *
+     * @param path - The directory to create.
+     * @param options - The {@link ZipExtractionMkdirOptions}.
+     * @returns The first directory created, if any.
+     */
+    mkdirSync: (path: string, options: ZipExtractionMkdirOptions) => string | undefined;
+    /**
+     * Writes a file, overwriting it if it exists.
+     *
+     * @param path - The file to write.
+     * @param data - The bytes to write.
+     */
+    writeFileSync: (path: string, data: Buffer) => void;
+}
+/**
+ * The options {@link ZipExtractionFileSystem.mkdirSync} is always called with.
+ *
+ * Extraction never probes for an existing directory, so every call has to create the missing parents
+ * itself and tolerate a directory that is already there.
+ */
+export interface ZipExtractionMkdirOptions {
+    /**
+     * Always `true`.
+     */
+    readonly recursive: true;
+}
+/**
+ * Extracts every entry of a ZIP archive into a directory.
+ *
+ * Directory entries become directories; a file entry's parents are created whether or not the archive
+ * declared them. An entry whose name would escape {@link ExtractZipArchiveParams.targetDirectory} is
+ * refused rather than written (the "zip slip" traversal), as is an encrypted, ZIP64, or
+ * unknown-compression archive.
+ *
+ * @param params - The {@link ExtractZipArchiveParams}.
+ * @throws An {@link Error} naming the reason when the archive cannot be read as written.
+ */
+export declare function extractZipArchive(params: ExtractZipArchiveParams): void;

package/dist/lib/cjs/disposable.cjs

@@ -0,0 +1,414 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for('Symbol.asyncDispose');
+  symbolConstructor.dispose ??= symbolConstructor.for('Symbol.dispose');
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+function keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord['__name'] ??= keepName;
+  globalThisRecord['__extractDefault'] ??= extractDefault;
+
+  ensureBrowserProcess();
+
+  // eslint-disable-next-line unicorn/consistent-function-scoping -- Serialized with initCjs into the banner; at module scope it would be left out of it.
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+})();
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var disposable_exports = {};
+__export(disposable_exports, {
+  AsyncCallbackDisposable: () => AsyncCallbackDisposable,
+  AsyncDisposableBase: () => AsyncDisposableBase,
+  CallbackDisposable: () => CallbackDisposable,
+  CombineAsyncDisposable: () => CombineAsyncDisposable,
+  CombineDisposable: () => CombineDisposable,
+  DisposableBase: () => DisposableBase,
+  DisposeErrorBehavior: () => DisposeErrorBehavior,
+  DisposeOrder: () => DisposeOrder,
+  MultipleDisposeBehavior: () => MultipleDisposeBehavior,
+  dispose: () => dispose,
+  disposeAsync: () => disposeAsync,
+  isAsyncDisposable: () => isAsyncDisposable,
+  isAsyncDisposableEx: () => isAsyncDisposableEx,
+  isDisposable: () => isDisposable,
+  isDisposableEx: () => isDisposableEx,
+  toAsyncDisposableEx: () => toAsyncDisposableEx,
+  toDisposableEx: () => toDisposableEx
+});
+module.exports = __toCommonJS(disposable_exports);
+var import_aggregate_error = require('./aggregate-error.cjs');
+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";
+  MultipleDisposeBehavior2[MultipleDisposeBehavior2["Throw"] = 2] = "Throw";
+  return MultipleDisposeBehavior2;
+})(MultipleDisposeBehavior || {});
+class AsyncDisposableBase {
+  /**
+   * How the disposable behaves when disposed more than once.
+   *
+   * @default {@link MultipleDisposeBehavior.Ignore}
+   */
+  multipleDisposeBehavior = 1 /* Ignore */;
+  /**
+   * Whether this disposable has been disposed (its teardown has run at least once).
+   *
+   * @returns `true` once disposal has started.
+   */
+  get isDisposed() {
+    return this._isDisposed;
+  }
+  _isDisposed = false;
+  /**
+   * Disposes the object. Convenience alias that delegates to `this[Symbol.asyncDispose]()`.
+   *
+   * @returns A {@link Promise} that resolves once teardown completes.
+   */
+  asyncDispose() {
+    return this[Symbol.asyncDispose]();
+  }
+  /**
+   * Disposes the object by running {@link AsyncDisposableBase.performDisposeAsync}, honoring the configured
+   * {@link MultipleDisposeBehavior} on a repeat dispose.
+   *
+   * @returns A {@link Promise} that resolves once teardown completes.
+   */
+  async [Symbol.asyncDispose]() {
+    if (!shouldPerformDispose(this._isDisposed, this.multipleDisposeBehavior)) {
+      return;
+    }
+    this._isDisposed = true;
+    await this.performDisposeAsync();
+  }
+}
+class AsyncCallbackDisposable extends AsyncDisposableBase {
+  callback;
+  /**
+   * Creates a new instance of {@link AsyncCallbackDisposable}.
+   *
+   * @param params - The parameters.
+   */
+  constructor(params) {
+    super();
+    this.callback = params.callback;
+    this.multipleDisposeBehavior = params.multipleDisposeBehavior ?? 1 /* Ignore */;
+  }
+  /**
+   * Runs the dispose callback.
+   *
+   * @returns A {@link Promise} that resolves once the callback completes.
+   */
+  async performDisposeAsync() {
+    await this.callback();
+  }
+}
+function dispose(disposable) {
+  disposable[Symbol.dispose]();
+}
+class DisposableBase {
+  /**
+   * How the disposable behaves when disposed more than once.
+   *
+   * @default {@link MultipleDisposeBehavior.Ignore}
+   */
+  multipleDisposeBehavior = 1 /* Ignore */;
+  /**
+   * Whether this disposable has been disposed (its teardown has run at least once).
+   *
+   * @returns `true` once disposal has started.
+   */
+  get isDisposed() {
+    return this._isDisposed;
+  }
+  _isDisposed = false;
+  /**
+   * Disposes the object. Convenience alias that delegates to `this[Symbol.dispose]()`.
+   */
+  dispose() {
+    this[Symbol.dispose]();
+  }
+  /**
+   * Disposes the object by running {@link DisposableBase.performDispose}, honoring the configured
+   * {@link MultipleDisposeBehavior} on a repeat dispose.
+   */
+  [Symbol.dispose]() {
+    if (!shouldPerformDispose(this._isDisposed, this.multipleDisposeBehavior)) {
+      return;
+    }
+    this._isDisposed = true;
+    this.performDispose();
+  }
+}
+class CallbackDisposable extends DisposableBase {
+  callback;
+  /**
+   * Creates a new instance of {@link CallbackDisposable}.
+   *
+   * @param params - The parameters.
+   */
+  constructor(params) {
+    super();
+    this.callback = params.callback;
+    this.multipleDisposeBehavior = params.multipleDisposeBehavior ?? 1 /* Ignore */;
+  }
+  /**
+   * Runs the dispose callback.
+   */
+  performDispose() {
+    this.callback();
+  }
+}
+class CombineAsyncDisposable extends AsyncDisposableBase {
+  children;
+  disposeOrder;
+  errorBehavior;
+  /**
+   * Creates a new instance of {@link CombineAsyncDisposable}.
+   *
+   * @param params - The parameters.
+   */
+  constructor(params) {
+    super();
+    this.children = [...params.asyncDisposables];
+    this.disposeOrder = params.disposeOrder ?? 0 /* Lifo */;
+    this.errorBehavior = params.errorBehavior ?? 0 /* Aggregate */;
+    this.multipleDisposeBehavior = params.multipleDisposeBehavior ?? 1 /* Ignore */;
+  }
+  /**
+   * Disposes all combined children in the configured {@link DisposeOrder}, applying the configured
+   * {@link DisposeErrorBehavior} when a child throws.
+   *
+   * @returns A {@link Promise} that resolves once all children have been disposed.
+   */
+  async performDisposeAsync() {
+    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 (0, import_aggregate_error.createAggregateError)(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 extends DisposableBase {
+  children;
+  disposeOrder;
+  errorBehavior;
+  /**
+   * Creates a new instance of {@link CombineDisposable}.
+   *
+   * @param params - The parameters.
+   */
+  constructor(params) {
+    super();
+    this.children = [...params.disposables];
+    this.disposeOrder = params.disposeOrder ?? 0 /* Lifo */;
+    this.errorBehavior = params.errorBehavior ?? 0 /* Aggregate */;
+    this.multipleDisposeBehavior = params.multipleDisposeBehavior ?? 1 /* Ignore */;
+  }
+  /**
+   * Disposes all combined children in the configured {@link DisposeOrder}, applying the configured
+   * {@link DisposeErrorBehavior} when a child throws.
+   */
+  performDispose() {
+    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 (0, import_aggregate_error.createAggregateError)(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);
+      }
+    }
+  }
+}
+async function disposeAsync(asyncDisposable) {
+  await asyncDisposable[Symbol.asyncDispose]();
+}
+function isAsyncDisposable($unknown) {
+  const asyncDisposable = $unknown;
+  return !!asyncDisposable[Symbol.asyncDispose];
+}
+function isAsyncDisposableEx($unknown) {
+  const asyncDisposableEx = $unknown;
+  return isAsyncDisposable($unknown) && typeof asyncDisposableEx.asyncDispose === "function";
+}
+function isDisposable($unknown) {
+  const disposable = $unknown;
+  return !!disposable[Symbol.dispose];
+}
+function isDisposableEx($unknown) {
+  const disposableEx = $unknown;
+  return isDisposable($unknown) && typeof disposableEx.dispose === "function";
+}
+function toAsyncDisposableEx(asyncDisposable) {
+  return isAsyncDisposableEx(asyncDisposable) ? asyncDisposable : {
+    asyncDispose: asyncDisposeAdapted,
+    [Symbol.asyncDispose]: asyncDisposeAdapted
+  };
+  function asyncDisposeAdapted() {
+    return disposeAsync(asyncDisposable);
+  }
+}
+function toDisposableEx(disposable) {
+  return isDisposableEx(disposable) ? disposable : {
+    dispose: disposeAdapted,
+    [Symbol.dispose]: disposeAdapted
+  };
+  function disposeAdapted() {
+    dispose(disposable);
+  }
+}
+function shouldPerformDispose(isDisposed, multipleDisposeBehavior) {
+  if (!isDisposed) {
+    return true;
+  }
+  switch (multipleDisposeBehavior) {
+    case 1 /* Ignore */: {
+      return false;
+    }
+    case 0 /* Invoke */: {
+      return true;
+    }
+    case 2 /* Throw */: {
+      throw new Error("This disposable has already been disposed.");
+    }
+    default: {
+      (0, import_type_guards.assertNever)(multipleDisposeBehavior);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AsyncCallbackDisposable,
+  AsyncDisposableBase,
+  CallbackDisposable,
+  CombineAsyncDisposable,
+  CombineDisposable,
+  DisposableBase,
+  DisposeErrorBehavior,
+  DisposeOrder,
+  MultipleDisposeBehavior,
+  dispose,
+  disposeAsync,
+  isAsyncDisposable,
+  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 { createAggregateError } from './aggregate-error.ts';\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.Ignore}\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 = () => 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.Ignore}\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.Ignore}\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.Ignore}\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 = () => void;\n\n/**\n * Abstract base for an {@link AsyncDisposableEx}: it carries the re-dispose guard (via\n * {@link MultipleDisposeBehavior}) and the {@link AsyncDisposableEx.asyncDispose} alias; a subclass only\n * implements {@link AsyncDisposableBase.performDisposeAsync}.\n */\nexport abstract class AsyncDisposableBase implements AsyncDisposableEx {\n  /**\n   * How the disposable behaves when disposed more than once.\n   *\n   * @default {@link MultipleDisposeBehavior.Ignore}\n   */\n  protected multipleDisposeBehavior: MultipleDisposeBehavior = MultipleDisposeBehavior.Ignore;\n\n  /**\n   * Whether this disposable has been disposed (its teardown has run at least once).\n   *\n   * @returns `true` once disposal has started.\n   */\n  protected get isDisposed(): boolean {\n    return this._isDisposed;\n  }\n\n  private _isDisposed = false;\n\n  /**\n   * Disposes the object. Convenience alias that delegates to `this[Symbol.asyncDispose]()`.\n   *\n   * @returns A {@link Promise} that resolves once teardown completes.\n   */\n  public asyncDispose(): Promise<void> {\n    return this[Symbol.asyncDispose]();\n  }\n\n  /**\n   * Disposes the object by running {@link AsyncDisposableBase.performDisposeAsync}, honoring the configured\n   * {@link MultipleDisposeBehavior} on a repeat dispose.\n   *\n   * @returns A {@link Promise} that resolves once teardown completes.\n   */\n  public async [Symbol.asyncDispose](): Promise<void> {\n    if (!shouldPerformDispose(this._isDisposed, this.multipleDisposeBehavior)) {\n      return;\n    }\n\n    this._isDisposed = true;\n    await this.performDisposeAsync();\n  }\n\n  /**\n   * Performs the actual teardown. Called at most once unless {@link MultipleDisposeBehavior.Invoke} is set.\n   *\n   * @returns A {@link Promisable} that resolves once teardown completes.\n   */\n  protected abstract performDisposeAsync(): Promisable<void>;\n}\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 extends AsyncDisposableBase {\n  private readonly callback: AsyncDisposeCallback;\n\n  /**\n   * Creates a new instance of {@link AsyncCallbackDisposable}.\n   *\n   * @param params - The parameters.\n   */\n  public constructor(params: AsyncCallbackDisposableConstructorParams) {\n    super();\n    this.callback = params.callback;\n    this.multipleDisposeBehavior = params.multipleDisposeBehavior ?? MultipleDisposeBehavior.Ignore;\n  }\n\n  /**\n   * Runs the dispose callback.\n   *\n   * @returns A {@link Promise} that resolves once the callback completes.\n   */\n  protected override async performDisposeAsync(): Promise<void> {\n    await this.callback();\n  }\n}\n\n/**\n * Disposes a {@link Disposable}.\n *\n * Prefer this over calling `disposable[Symbol.dispose]()` at the call site: it reads better and keeps the\n * well-known symbol referenced in a single place.\n *\n * @param disposable - the disposable to dispose\n */\nexport function dispose(disposable: Disposable): void {\n  disposable[Symbol.dispose]();\n}\n\n/**\n * Abstract base for a {@link DisposableEx}: it carries the re-dispose guard (via {@link MultipleDisposeBehavior})\n * and the {@link DisposableEx.dispose} alias; a subclass only implements {@link DisposableBase.performDispose}.\n */\nexport abstract class DisposableBase implements DisposableEx {\n  /**\n   * How the disposable behaves when disposed more than once.\n   *\n   * @default {@link MultipleDisposeBehavior.Ignore}\n   */\n  protected multipleDisposeBehavior: MultipleDisposeBehavior = MultipleDisposeBehavior.Ignore;\n\n  /**\n   * Whether this disposable has been disposed (its teardown has run at least once).\n   *\n   * @returns `true` once disposal has started.\n   */\n  protected get isDisposed(): boolean {\n    return this._isDisposed;\n  }\n\n  private _isDisposed = false;\n\n  /**\n   * Disposes the object. Convenience alias that delegates to `this[Symbol.dispose]()`.\n   */\n  public dispose(): void {\n    this[Symbol.dispose]();\n  }\n\n  /**\n   * Disposes the object by running {@link DisposableBase.performDispose}, honoring the configured\n   * {@link MultipleDisposeBehavior} on a repeat dispose.\n   */\n  public [Symbol.dispose](): void {\n    if (!shouldPerformDispose(this._isDisposed, this.multipleDisposeBehavior)) {\n      return;\n    }\n\n    this._isDisposed = true;\n    this.performDispose();\n  }\n\n  /**\n   * Performs the actual teardown. Called at most once unless {@link MultipleDisposeBehavior.Invoke} is set.\n   */\n  protected abstract performDispose(): void;\n}\n\n/**\n * A disposable that executes a callback when disposed.\n */\nexport class CallbackDisposable extends DisposableBase {\n  private readonly callback: DisposeCallback;\n\n  /**\n   * Creates a new instance of {@link CallbackDisposable}.\n   *\n   * @param params - The parameters.\n   */\n  public constructor(params: CallbackDisposableConstructorParams) {\n    super();\n    this.callback = params.callback;\n    this.multipleDisposeBehavior = params.multipleDisposeBehavior ?? MultipleDisposeBehavior.Ignore;\n  }\n\n  /**\n   * Runs the dispose callback.\n   */\n  protected override performDispose(): void {\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 extends AsyncDisposableBase {\n  private readonly children: readonly AsyncDisposable[];\n  private readonly disposeOrder: DisposeOrder;\n  private readonly errorBehavior: DisposeErrorBehavior;\n\n  /**\n   * Creates a new instance of {@link CombineAsyncDisposable}.\n   *\n   * @param params - The parameters.\n   */\n  public constructor(params: CombineAsyncDisposableConstructorParams) {\n    super();\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.Ignore;\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   * @returns A {@link Promise} that resolves once all children have been disposed.\n   */\n  protected override async performDisposeAsync(): Promise<void> {\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 createAggregateError(errors);\n    }\n  }\n\n  private getOrderedChildren(): readonly AsyncDisposable[] {\n    switch (this.disposeOrder) {\n      case DisposeOrder.Fifo: {\n        return this.children;\n      }\n      case DisposeOrder.Lifo: {\n        return [...this.children].reverse();\n      }\n      default: {\n        assertNever(this.disposeOrder);\n      }\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 extends DisposableBase {\n  private readonly children: readonly Disposable[];\n  private readonly disposeOrder: DisposeOrder;\n  private readonly errorBehavior: DisposeErrorBehavior;\n\n  /**\n   * Creates a new instance of {@link CombineDisposable}.\n   *\n   * @param params - The parameters.\n   */\n  public constructor(params: CombineDisposableConstructorParams) {\n    super();\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.Ignore;\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  protected override performDispose(): void {\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 createAggregateError(errors);\n    }\n  }\n\n  private getOrderedChildren(): readonly Disposable[] {\n    switch (this.disposeOrder) {\n      case DisposeOrder.Fifo: {\n        return this.children;\n      }\n      case DisposeOrder.Lifo: {\n        return [...this.children].reverse();\n      }\n      default: {\n        assertNever(this.disposeOrder);\n      }\n    }\n  }\n}\n\n/**\n * Disposes an {@link AsyncDisposable}.\n *\n * Prefer this over calling `asyncDisposable[Symbol.asyncDispose]()` at the call site: it reads better and\n * keeps the well-known symbol referenced in a single place.\n *\n * @param asyncDisposable - the async disposable to dispose\n * @returns A {@link Promise} that resolves once the disposal completes.\n */\nexport async function disposeAsync(asyncDisposable: AsyncDisposable): Promise<void> {\n  await asyncDisposable[Symbol.asyncDispose]();\n}\n\n/**\n * Type guard to check if an object implements the {@link AsyncDisposable} interface.\n *\n * @param $unknown - the object to check for the {@link AsyncDisposable} interface\n * @returns Whether the object implements the {@link AsyncDisposable} interface\n */\nexport function isAsyncDisposable($unknown: unknown): $unknown is AsyncDisposable {\n  const asyncDisposable = $unknown as Partial<AsyncDisposable>;\n  // eslint-disable-next-line unicorn/no-computed-property-existence-check -- `Object.hasOwn` is own-property-only, and `[Symbol.asyncDispose]` is a prototype method on every class-based disposable here.\n  return !!asyncDisposable[Symbol.asyncDispose];\n}\n\n/**\n * Type guard to check if an object implements the {@link AsyncDisposableEx} interface.\n *\n * @param $unknown - the object to check for the {@link AsyncDisposableEx} interface\n * @returns Whether the object implements the {@link AsyncDisposableEx} interface\n */\nexport function isAsyncDisposableEx($unknown: unknown): $unknown is AsyncDisposableEx {\n  const asyncDisposableEx = $unknown as Partial<AsyncDisposableEx>;\n  return isAsyncDisposable($unknown) && typeof asyncDisposableEx.asyncDispose === 'function';\n}\n\n/**\n * Type guard to check if an object implements the {@link Disposable} interface.\n *\n * @param $unknown - the object to check for the {@link Disposable} interface\n * @returns Whether the object implements the {@link Disposable} interface\n */\nexport function isDisposable($unknown: unknown): $unknown is Disposable {\n  const disposable = $unknown as Partial<Disposable>;\n  // eslint-disable-next-line unicorn/no-computed-property-existence-check -- `Object.hasOwn` is own-property-only, and `[Symbol.dispose]` is a prototype method on every class-based disposable here.\n  return !!disposable[Symbol.dispose];\n}\n\n/**\n * Type guard to check if an object implements the {@link DisposableEx} interface.\n *\n * @param $unknown - the object to check for the {@link DisposableEx} interface\n * @returns Whether the object implements the {@link DisposableEx} interface\n */\nexport function isDisposableEx($unknown: unknown): $unknown is DisposableEx {\n  const disposableEx = $unknown as Partial<DisposableEx>;\n  return isDisposable($unknown) && 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  return isAsyncDisposableEx(asyncDisposable)\n    ? asyncDisposable\n    : {\n      asyncDispose: asyncDisposeAdapted,\n      [Symbol.asyncDispose]: asyncDisposeAdapted\n    };\n\n  function asyncDisposeAdapted(): Promise<void> {\n    return disposeAsync(asyncDisposable);\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  return isDisposableEx(disposable)\n    ? disposable\n    : {\n      dispose: disposeAdapted,\n      [Symbol.dispose]: disposeAdapted\n    };\n\n  function disposeAdapted(): void {\n    dispose(disposable);\n  }\n}\n\n/**\n * Decides whether a disposable's teardown should run on the current dispose call, applying the\n * {@link MultipleDisposeBehavior} re-dispose policy. Single source of the guard shared by\n * {@link DisposableBase} and {@link AsyncDisposableBase}.\n *\n * @param isDisposed - Whether the disposable has already been disposed once.\n * @param multipleDisposeBehavior - The re-dispose behavior.\n * @returns `true` when the teardown should run, `false` when it should be skipped.\n */\nfunction shouldPerformDispose(isDisposed: boolean, multipleDisposeBehavior: MultipleDisposeBehavior): boolean {\n  if (!isDisposed) {\n    return true;\n  }\n\n  switch (multipleDisposeBehavior) {\n    case MultipleDisposeBehavior.Ignore: {\n      return false;\n    }\n    case MultipleDisposeBehavior.Invoke: {\n      return true;\n    }\n    case MultipleDisposeBehavior.Throw: {\n      throw new Error('This disposable has already been disposed.');\n    }\n    default: {\n      assertNever(multipleDisposeBehavior);\n    }\n  }\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,6BAAqC;AACrC,yBAA4B;AAMrB,IAAK,uBAAL,kBAAKA,0BAAL;AAKL,EAAAA,4CAAA;AAKA,EAAAA,4CAAA;AAVU,SAAAA;AAAA,GAAA;AAiBL,IAAK,eAAL,kBAAKC,kBAAL;AAKL,EAAAA,4BAAA;AAKA,EAAAA,4BAAA;AAVU,SAAAA;AAAA,GAAA;AAiBL,IAAK,0BAAL,kBAAKC,6BAAL;AAIL,EAAAA,kDAAA;AAKA,EAAAA,kDAAA;AAKA,EAAAA,kDAAA;AAdU,SAAAA;AAAA,GAAA;AAyJL,MAAe,oBAAiD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAM3D,0BAAmD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAO7D,IAAc,aAAsB;AAClC,WAAO,KAAK;AAAA,EACd;AAAA,EAEQ,cAAc;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOf,eAA8B;AACnC,WAAO,KAAK,OAAO,YAAY,EAAE;AAAA,EACnC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAc,OAAO,YAAY,IAAmB;AAClD,QAAI,CAAC,qBAAqB,KAAK,aAAa,KAAK,uBAAuB,GAAG;AACzE;AAAA,IACF;AAEA,SAAK,cAAc;AACnB,UAAM,KAAK,oBAAoB;AAAA,EACjC;AAQF;AAMO,MAAM,gCAAgC,oBAAoB;AAAA,EAC9C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOV,YAAY,QAAkD;AACnE,UAAM;AACN,SAAK,WAAW,OAAO;AACvB,SAAK,0BAA0B,OAAO,2BAA2B;AAAA,EACnE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,MAAyB,sBAAqC;AAC5D,UAAM,KAAK,SAAS;AAAA,EACtB;AACF;AAUO,SAAS,QAAQ,YAA8B;AACpD,aAAW,OAAO,OAAO,EAAE;AAC7B;AAMO,MAAe,eAAuC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMjD,0BAAmD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAO7D,IAAc,aAAsB;AAClC,WAAO,KAAK;AAAA,EACd;AAAA,EAEQ,cAAc;AAAA;AAAA;AAAA;AAAA,EAKf,UAAgB;AACrB,SAAK,OAAO,OAAO,EAAE;AAAA,EACvB;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,CAAQ,OAAO,OAAO,IAAU;AAC9B,QAAI,CAAC,qBAAqB,KAAK,aAAa,KAAK,uBAAuB,GAAG;AACzE;AAAA,IACF;AAEA,SAAK,cAAc;AACnB,SAAK,eAAe;AAAA,EACtB;AAMF;AAKO,MAAM,2BAA2B,eAAe;AAAA,EACpC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOV,YAAY,QAA6C;AAC9D,UAAM;AACN,SAAK,WAAW,OAAO;AACvB,SAAK,0BAA0B,OAAO,2BAA2B;AAAA,EACnE;AAAA;AAAA;AAAA;AAAA,EAKmB,iBAAuB;AACxC,SAAK,SAAS;AAAA,EAChB;AACF;AAMO,MAAM,+BAA+B,oBAAoB;AAAA,EAC7C;AAAA,EACA;AAAA,EACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOV,YAAY,QAAiD;AAClE,UAAM;AACN,SAAK,WAAW,CAAC,GAAG,OAAO,gBAAgB;AAC3C,SAAK,eAAe,OAAO,gBAAgB;AAC3C,SAAK,gBAAgB,OAAO,iBAAiB;AAC7C,SAAK,0BAA0B,OAAO,2BAA2B;AAAA,EACnE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,MAAyB,sBAAqC;AAC5D,UAAM,SAAoB,CAAC;AAC3B,eAAW,SAAS,KAAK,mBAAmB,GAAG;AAC7C,UAAI;AACF,cAAM,MAAM,OAAO,YAAY,EAAE;AAAA,MACnC,SAAS,OAAO;AACd,YAAI,KAAK,kBAAkB,kBAA+B;AACxD,gBAAM;AAAA,QACR;AAEA,eAAO,KAAK,KAAK;AAAA,MACnB;AAAA,IACF;AAEA,QAAI,OAAO,SAAS,GAAG;AACrB,gBAAM,6CAAqB,MAAM;AAAA,IACnC;AAAA,EACF;AAAA,EAEQ,qBAAiD;AACvD,YAAQ,KAAK,cAAc;AAAA,MACzB,KAAK,cAAmB;AACtB,eAAO,KAAK;AAAA,MACd;AAAA,MACA,KAAK,cAAmB;AACtB,eAAO,CAAC,GAAG,KAAK,QAAQ,EAAE,QAAQ;AAAA,MACpC;AAAA,MACA,SAAS;AACP,4CAAY,KAAK,YAAY;AAAA,MAC/B;AAAA,IACF;AAAA,EACF;AACF;AAMO,MAAM,0BAA0B,eAAe;AAAA,EACnC;AAAA,EACA;AAAA,EACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOV,YAAY,QAA4C;AAC7D,UAAM;AACN,SAAK,WAAW,CAAC,GAAG,OAAO,WAAW;AACtC,SAAK,eAAe,OAAO,gBAAgB;AAC3C,SAAK,gBAAgB,OAAO,iBAAiB;AAC7C,SAAK,0BAA0B,OAAO,2BAA2B;AAAA,EACnE;AAAA;AAAA;AAAA;AAAA;AAAA,EAMmB,iBAAuB;AACxC,UAAM,SAAoB,CAAC;AAC3B,eAAW,SAAS,KAAK,mBAAmB,GAAG;AAC7C,UAAI;AACF,cAAM,OAAO,OAAO,EAAE;AAAA,MACxB,SAAS,OAAO;AACd,YAAI,KAAK,kBAAkB,kBAA+B;AACxD,gBAAM;AAAA,QACR;AAEA,eAAO,KAAK,KAAK;AAAA,MACnB;AAAA,IACF;AAEA,QAAI,OAAO,SAAS,GAAG;AACrB,gBAAM,6CAAqB,MAAM;AAAA,IACnC;AAAA,EACF;AAAA,EAEQ,qBAA4C;AAClD,YAAQ,KAAK,cAAc;AAAA,MACzB,KAAK,cAAmB;AACtB,eAAO,KAAK;AAAA,MACd;AAAA,MACA,KAAK,cAAmB;AACtB,eAAO,CAAC,GAAG,KAAK,QAAQ,EAAE,QAAQ;AAAA,MACpC;AAAA,MACA,SAAS;AACP,4CAAY,KAAK,YAAY;AAAA,MAC/B;AAAA,IACF;AAAA,EACF;AACF;AAWA,eAAsB,aAAa,iBAAiD;AAClF,QAAM,gBAAgB,OAAO,YAAY,EAAE;AAC7C;AAQO,SAAS,kBAAkB,UAAgD;AAChF,QAAM,kBAAkB;AAExB,SAAO,CAAC,CAAC,gBAAgB,OAAO,YAAY;AAC9C;AAQO,SAAS,oBAAoB,UAAkD;AACpF,QAAM,oBAAoB;AAC1B,SAAO,kBAAkB,QAAQ,KAAK,OAAO,kBAAkB,iBAAiB;AAClF;AAQO,SAAS,aAAa,UAA2C;AACtE,QAAM,aAAa;AAEnB,SAAO,CAAC,CAAC,WAAW,OAAO,OAAO;AACpC;AAQO,SAAS,eAAe,UAA6C;AAC1E,QAAM,eAAe;AACrB,SAAO,aAAa,QAAQ,KAAK,OAAO,aAAa,YAAY;AACnE;AAWO,SAAS,oBAAoB,iBAAqD;AACvF,SAAO,oBAAoB,eAAe,IACtC,kBACA;AAAA,IACA,cAAc;AAAA,IACd,CAAC,OAAO,YAAY,GAAG;AAAA,EACzB;AAEF,WAAS,sBAAqC;AAC5C,WAAO,aAAa,eAAe;AAAA,EACrC;AACF;AAWO,SAAS,eAAe,YAAsC;AACnE,SAAO,eAAe,UAAU,IAC5B,aACA;AAAA,IACA,SAAS;AAAA,IACT,CAAC,OAAO,OAAO,GAAG;AAAA,EACpB;AAEF,WAAS,iBAAuB;AAC9B,YAAQ,UAAU;AAAA,EACpB;AACF;AAWA,SAAS,qBAAqB,YAAqB,yBAA2D;AAC5G,MAAI,CAAC,YAAY;AACf,WAAO;AAAA,EACT;AAEA,UAAQ,yBAAyB;AAAA,IAC/B,KAAK,gBAAgC;AACnC,aAAO;AAAA,IACT;AAAA,IACA,KAAK,gBAAgC;AACnC,aAAO;AAAA,IACT;AAAA,IACA,KAAK,eAA+B;AAClC,YAAM,IAAI,MAAM,4CAA4C;AAAA,IAC9D;AAAA,IACA,SAAS;AACP,0CAAY,uBAAuB;AAAA,IACrC;AAAA,EACF;AACF;",
  "names": ["DisposeErrorBehavior", "DisposeOrder", "MultipleDisposeBehavior"]
}
