@mnaoumov/typescript-lib 0.0.0 → 1.0.1

package/dist/lib/esm/desktop-zip-extractor.mjs

@@ -0,0 +1,136 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+import { inflateRawSync } from "node:zlib";
+import {
+  dirname,
+  join
+} from "./path.mjs";
+const END_OF_CENTRAL_DIRECTORY_SIGNATURE = 101010256;
+const CENTRAL_DIRECTORY_HEADER_SIGNATURE = 33639248;
+const LOCAL_FILE_HEADER_SIGNATURE = 67324752;
+const END_OF_CENTRAL_DIRECTORY_SIZE = 22;
+const MAX_ARCHIVE_COMMENT_LENGTH = 65535;
+const SATURATED_UINT_16 = 65535;
+const SATURATED_UINT_32 = 4294967295;
+const ARCHIVE_ENTRY_COUNT_OFFSET = 10;
+const CENTRAL_DIRECTORY_START_OFFSET = 16;
+const CENTRAL_DIRECTORY_FLAGS_OFFSET = 8;
+const CENTRAL_DIRECTORY_COMPRESSION_METHOD_OFFSET = 10;
+const CENTRAL_DIRECTORY_COMPRESSED_SIZE_OFFSET = 20;
+const CENTRAL_DIRECTORY_NAME_LENGTH_OFFSET = 28;
+const CENTRAL_DIRECTORY_EXTRA_LENGTH_OFFSET = 30;
+const CENTRAL_DIRECTORY_COMMENT_LENGTH_OFFSET = 32;
+const CENTRAL_DIRECTORY_LOCAL_HEADER_OFFSET_OFFSET = 42;
+const CENTRAL_DIRECTORY_HEADER_SIZE = 46;
+const LOCAL_HEADER_NAME_LENGTH_OFFSET = 26;
+const LOCAL_HEADER_EXTRA_LENGTH_OFFSET = 28;
+const LOCAL_HEADER_SIZE = 30;
+const COMPRESSION_METHOD_STORED = 0;
+const COMPRESSION_METHOD_DEFLATED = 8;
+const ENCRYPTED_FLAG_DIVISOR = 2;
+const ENTRY_NAME_SEPARATOR = "/";
+const WINDOWS_DRIVE_PREFIX_REG_EXP = /^[A-Za-z]:/;
+function extractZipArchive(params) {
+  const {
+    archive,
+    fileSystem,
+    targetDirectory
+  } = params;
+  fileSystem.mkdirSync(targetDirectory, { recursive: true });
+  for (const entry of readCentralDirectory(archive)) {
+    assertSafeEntryName(entry.name);
+    if (entry.name.endsWith(ENTRY_NAME_SEPARATOR)) {
+      fileSystem.mkdirSync(join(targetDirectory, entry.name.slice(0, -1)), { recursive: true });
+      continue;
+    }
+    const entryPath = join(targetDirectory, entry.name);
+    fileSystem.mkdirSync(dirname(entryPath), { recursive: true });
+    fileSystem.writeFileSync(entryPath, readEntryData(archive, entry));
+  }
+}
+function assertSafeEntryName(entryName) {
+  if (entryName.startsWith(ENTRY_NAME_SEPARATOR)) {
+    throw new Error(`Refusing to extract the absolute archive entry '${entryName}'.`);
+  }
+  if (WINDOWS_DRIVE_PREFIX_REG_EXP.test(entryName)) {
+    throw new Error(`Refusing to extract the drive-qualified archive entry '${entryName}'.`);
+  }
+  if (entryName.includes("\\")) {
+    throw new Error(`Refusing to extract the archive entry '${entryName}', which uses a backslash separator.`);
+  }
+  if (entryName.split(ENTRY_NAME_SEPARATOR).includes("..")) {
+    throw new Error(`Refusing to extract the archive entry '${entryName}', which points outside the target directory.`);
+  }
+}
+function findEndOfCentralDirectoryOffset(archive) {
+  const lastPossibleOffset = archive.length - END_OF_CENTRAL_DIRECTORY_SIZE;
+  const firstPossibleOffset = Math.max(0, lastPossibleOffset - MAX_ARCHIVE_COMMENT_LENGTH);
+  for (let offset = lastPossibleOffset; offset >= firstPossibleOffset; offset--) {
+    if (archive.readUInt32LE(offset) === END_OF_CENTRAL_DIRECTORY_SIGNATURE) {
+      return offset;
+    }
+  }
+  throw new Error("The archive is not a ZIP file: its end-of-central-directory record is missing.");
+}
+function readCentralDirectory(archive) {
+  const endOfCentralDirectoryOffset = findEndOfCentralDirectoryOffset(archive);
+  const entryCount = archive.readUInt16LE(endOfCentralDirectoryOffset + ARCHIVE_ENTRY_COUNT_OFFSET);
+  let entryOffset = archive.readUInt32LE(endOfCentralDirectoryOffset + CENTRAL_DIRECTORY_START_OFFSET);
+  if (entryCount === SATURATED_UINT_16 || entryOffset === SATURATED_UINT_32) {
+    throw new Error("ZIP64 archives are not supported.");
+  }
+  const entries = [];
+  for (let entryIndex = 0; entryIndex < entryCount; entryIndex++) {
+    if (archive.readUInt32LE(entryOffset) !== CENTRAL_DIRECTORY_HEADER_SIGNATURE) {
+      throw new Error(`The archive's central directory is corrupt at entry ${String(entryIndex)}.`);
+    }
+    const flags = archive.readUInt16LE(entryOffset + CENTRAL_DIRECTORY_FLAGS_OFFSET);
+    if (flags % ENCRYPTED_FLAG_DIVISOR === 1) {
+      throw new Error("Encrypted ZIP archives are not supported.");
+    }
+    const compressedSize = archive.readUInt32LE(entryOffset + CENTRAL_DIRECTORY_COMPRESSED_SIZE_OFFSET);
+    const localHeaderOffset = archive.readUInt32LE(entryOffset + CENTRAL_DIRECTORY_LOCAL_HEADER_OFFSET_OFFSET);
+    if (compressedSize === SATURATED_UINT_32 || localHeaderOffset === SATURATED_UINT_32) {
+      throw new Error("ZIP64 archives are not supported.");
+    }
+    const nameLength = archive.readUInt16LE(entryOffset + CENTRAL_DIRECTORY_NAME_LENGTH_OFFSET);
+    const nameOffset = entryOffset + CENTRAL_DIRECTORY_HEADER_SIZE;
+    entries.push({
+      compressedSize,
+      compressionMethod: archive.readUInt16LE(entryOffset + CENTRAL_DIRECTORY_COMPRESSION_METHOD_OFFSET),
+      localHeaderOffset,
+      name: archive.toString("utf-8", nameOffset, nameOffset + nameLength)
+    });
+    entryOffset = nameOffset + nameLength + archive.readUInt16LE(entryOffset + CENTRAL_DIRECTORY_EXTRA_LENGTH_OFFSET) + archive.readUInt16LE(entryOffset + CENTRAL_DIRECTORY_COMMENT_LENGTH_OFFSET);
+  }
+  return entries;
+}
+function readEntryData(archive, entry) {
+  if (archive.readUInt32LE(entry.localHeaderOffset) !== LOCAL_FILE_HEADER_SIGNATURE) {
+    throw new Error(`The archive entry '${entry.name}' has a corrupt local header.`);
+  }
+  const dataOffset = entry.localHeaderOffset + LOCAL_HEADER_SIZE + archive.readUInt16LE(entry.localHeaderOffset + LOCAL_HEADER_NAME_LENGTH_OFFSET) + archive.readUInt16LE(entry.localHeaderOffset + LOCAL_HEADER_EXTRA_LENGTH_OFFSET);
+  const dataEnd = dataOffset + entry.compressedSize;
+  if (dataEnd > archive.length) {
+    throw new Error(`The archive is truncated: entry '${entry.name}' runs past its end.`);
+  }
+  const compressedData = archive.subarray(dataOffset, dataEnd);
+  switch (entry.compressionMethod) {
+    case COMPRESSION_METHOD_DEFLATED: {
+      return inflateRawSync(compressedData);
+    }
+    case COMPRESSION_METHOD_STORED: {
+      return compressedData;
+    }
+    default: {
+      throw new Error(`The archive entry '${entry.name}' uses unsupported compression method ${String(entry.compressionMethod)}.`);
+    }
+  }
+}
+export {
+  extractZipArchive
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/desktop-zip-extractor.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Extracts a ZIP archive to disk using only Node's `zlib` \u2014 with no third-party unzip dependency.\n *\n * It exists for one measured reason. The dependency it replaced on this path, `adm-zip`, bundled\n * roughly 34 KB of minified JavaScript into EVERY Obsidian plugin built with this library: a plugin\n * ships a single CJS `main.js`, esbuild has no code splitting to put a dependency behind, and a\n * `await import()` only defers evaluation \u2014 the module body is inlined either way. `node:zlib` is\n * already an esbuild external, so the same work now costs a plugin bundle nothing at all. Archives are\n * WRITTEN with `fflate` at release time (`script-utils/demo-vault.ts`), which is Node-side tooling and\n * never reaches a plugin bundle \u2014 a third-party writer there is also what keeps this reader checked\n * against an implementation that is not its own.\n *\n * Deliberately narrow: it reads exactly what that writer produces \u2014 stored and deflated entries in an\n * unencrypted archive below the 4 GB / 65535-entry ZIP64 threshold \u2014 and raises a named error for\n * anything else rather than guessing at it. Sizes and offsets are taken from the central directory,\n * which is authoritative even for archives written with data descriptors.\n *\n * The `node:` imports below are safe to merely EVALUATE on mobile \u2014 `require` hands back `undefined`\n * there and nothing reads it at load time \u2014 so this module can sit in the generated barrels without\n * breaking the library's load on Android. Only the calls are desktop-only.\n */\n\nimport type { Buffer } from 'node:buffer';\n\nimport { inflateRawSync } from 'node:zlib';\n\nimport {\n  dirname,\n  join\n} from './path.ts';\n\n/**\n * Parameters for {@link extractZipArchive}.\n */\nexport interface ExtractZipArchiveParams {\n  /**\n   * The raw ZIP archive bytes.\n   */\n  readonly archive: Buffer;\n\n  /**\n   * The file-system implementation the extracted entries are written with.\n   *\n   * Injected rather than imported so the caller chooses which `fs` writes the files. The demo-vault\n   * opener hands over Electron's `original-fs` (see {@link ZipExtractionFileSystem}).\n   */\n  readonly fileSystem: ZipExtractionFileSystem;\n\n  /**\n   * The directory to extract into. Created if it does not exist.\n   */\n  readonly targetDirectory: string;\n}\n\n/**\n * The slice of `node:fs` extraction needs.\n *\n * Only the two WRITING calls are required, and that is deliberate: Electron's asar layer intercepts\n * `fs` READS (and `existsSync`) on any path containing `.asar`, which a demo vault may legitimately\n * ship as a plain file. Never probing the target with a read keeps that interception out of the\n * picture entirely, and a caller that hands over Electron's `original-fs` is safe even from the\n * write side.\n */\nexport interface ZipExtractionFileSystem {\n  /**\n   * Creates a directory, including any missing parents.\n   *\n   * @param path - The directory to create.\n   * @param options - The {@link ZipExtractionMkdirOptions}.\n   * @returns The first directory created, if any.\n   */\n  mkdirSync: (path: string, options: ZipExtractionMkdirOptions) => string | undefined;\n\n  /**\n   * Writes a file, overwriting it if it exists.\n   *\n   * @param path - The file to write.\n   * @param data - The bytes to write.\n   */\n  writeFileSync: (path: string, data: Buffer) => void;\n}\n\n/**\n * The options {@link ZipExtractionFileSystem.mkdirSync} is always called with.\n *\n * Extraction never probes for an existing directory, so every call has to create the missing parents\n * itself and tolerate a directory that is already there.\n */\nexport interface ZipExtractionMkdirOptions {\n  /**\n   * Always `true`.\n   */\n  readonly recursive: true;\n}\n\ninterface ZipEntry {\n  readonly compressedSize: number;\n  readonly compressionMethod: number;\n  readonly localHeaderOffset: number;\n  readonly name: string;\n}\n\nconst END_OF_CENTRAL_DIRECTORY_SIGNATURE = 0x06_05_4B_50;\nconst CENTRAL_DIRECTORY_HEADER_SIGNATURE = 0x02_01_4B_50;\nconst LOCAL_FILE_HEADER_SIGNATURE = 0x04_03_4B_50;\n\nconst END_OF_CENTRAL_DIRECTORY_SIZE = 22;\nconst MAX_ARCHIVE_COMMENT_LENGTH = 65_535;\n\n// A count or offset saturated to all-ones means the real value lives in a ZIP64 record this reader\n// does not implement, so the field must never be read at face value.\nconst SATURATED_UINT_16 = 65_535;\nconst SATURATED_UINT_32 = 4_294_967_295;\n\n// Field offsets within the end-of-central-directory record.\nconst ARCHIVE_ENTRY_COUNT_OFFSET = 10;\nconst CENTRAL_DIRECTORY_START_OFFSET = 16;\n\n// Field offsets within a central-directory header.\nconst CENTRAL_DIRECTORY_FLAGS_OFFSET = 8;\nconst CENTRAL_DIRECTORY_COMPRESSION_METHOD_OFFSET = 10;\nconst CENTRAL_DIRECTORY_COMPRESSED_SIZE_OFFSET = 20;\nconst CENTRAL_DIRECTORY_NAME_LENGTH_OFFSET = 28;\nconst CENTRAL_DIRECTORY_EXTRA_LENGTH_OFFSET = 30;\nconst CENTRAL_DIRECTORY_COMMENT_LENGTH_OFFSET = 32;\nconst CENTRAL_DIRECTORY_LOCAL_HEADER_OFFSET_OFFSET = 42;\nconst CENTRAL_DIRECTORY_HEADER_SIZE = 46;\n\n// Field offsets within a local file header.\nconst LOCAL_HEADER_NAME_LENGTH_OFFSET = 26;\nconst LOCAL_HEADER_EXTRA_LENGTH_OFFSET = 28;\nconst LOCAL_HEADER_SIZE = 30;\n\nconst COMPRESSION_METHOD_STORED = 0;\nconst COMPRESSION_METHOD_DEFLATED = 8;\n\n// Bit 0 of the general-purpose flags marks an encrypted entry, and it is the lowest bit \u2014 so the\n// remainder tests it without reaching for a bitwise operator.\nconst ENCRYPTED_FLAG_DIVISOR = 2;\n\nconst ENTRY_NAME_SEPARATOR = '/';\nconst WINDOWS_DRIVE_PREFIX_REG_EXP = /^[A-Za-z]:/;\n\n/**\n * Extracts every entry of a ZIP archive into a directory.\n *\n * Directory entries become directories; a file entry's parents are created whether or not the archive\n * declared them. An entry whose name would escape {@link ExtractZipArchiveParams.targetDirectory} is\n * refused rather than written (the \"zip slip\" traversal), as is an encrypted, ZIP64, or\n * unknown-compression archive.\n *\n * @param params - The {@link ExtractZipArchiveParams}.\n * @throws An {@link Error} naming the reason when the archive cannot be read as written.\n */\nexport function extractZipArchive(params: ExtractZipArchiveParams): void {\n  const {\n    archive,\n    fileSystem,\n    targetDirectory\n  } = params;\n\n  fileSystem.mkdirSync(targetDirectory, { recursive: true });\n\n  for (const entry of readCentralDirectory(archive)) {\n    assertSafeEntryName(entry.name);\n\n    if (entry.name.endsWith(ENTRY_NAME_SEPARATOR)) {\n      // Named without its trailing separator, so the created path reads the same as every other one.\n      fileSystem.mkdirSync(join(targetDirectory, entry.name.slice(0, -1)), { recursive: true });\n      continue;\n    }\n\n    const entryPath = join(targetDirectory, entry.name);\n    fileSystem.mkdirSync(dirname(entryPath), { recursive: true });\n    fileSystem.writeFileSync(entryPath, readEntryData(archive, entry));\n  }\n}\n\n/**\n * Refuses an entry name that would place the extracted file outside the target directory.\n *\n * An archive is untrusted input even when we published it ourselves, and every one of these shapes\n * escapes the target: an absolute POSIX path, a Windows drive-qualified path, a backslash (which the\n * ZIP specification forbids as a separator, so its only use here is to smuggle one past a\n * forward-slash check), and a `..` segment.\n *\n * @param entryName - The entry name as recorded in the archive.\n */\nfunction assertSafeEntryName(entryName: string): void {\n  if (entryName.startsWith(ENTRY_NAME_SEPARATOR)) {\n    throw new Error(`Refusing to extract the absolute archive entry '${entryName}'.`);\n  }\n\n  if (WINDOWS_DRIVE_PREFIX_REG_EXP.test(entryName)) {\n    throw new Error(`Refusing to extract the drive-qualified archive entry '${entryName}'.`);\n  }\n\n  if (entryName.includes('\\\\')) {\n    throw new Error(`Refusing to extract the archive entry '${entryName}', which uses a backslash separator.`);\n  }\n\n  if (entryName.split(ENTRY_NAME_SEPARATOR).includes('..')) {\n    throw new Error(`Refusing to extract the archive entry '${entryName}', which points outside the target directory.`);\n  }\n}\n\n/**\n * Locates the end-of-central-directory record and returns its offset.\n *\n * The record sits at the very end of the archive unless a trailing comment follows it, so it is found\n * by scanning backwards over the comment's maximum length rather than assumed to be at a fixed place.\n *\n * @param archive - The raw ZIP archive bytes.\n * @returns The record's offset.\n */\nfunction findEndOfCentralDirectoryOffset(archive: Buffer): number {\n  const lastPossibleOffset = archive.length - END_OF_CENTRAL_DIRECTORY_SIZE;\n  const firstPossibleOffset = Math.max(0, lastPossibleOffset - MAX_ARCHIVE_COMMENT_LENGTH);\n\n  for (let offset = lastPossibleOffset; offset >= firstPossibleOffset; offset--) {\n    if (archive.readUInt32LE(offset) === END_OF_CENTRAL_DIRECTORY_SIGNATURE) {\n      return offset;\n    }\n  }\n\n  throw new Error('The archive is not a ZIP file: its end-of-central-directory record is missing.');\n}\n\n/**\n * Reads the central directory, which is the archive's authoritative index of its entries.\n *\n * @param archive - The raw ZIP archive bytes.\n * @returns One {@link ZipEntry} per entry, in the order the archive lists them.\n */\nfunction readCentralDirectory(archive: Buffer): ZipEntry[] {\n  const endOfCentralDirectoryOffset = findEndOfCentralDirectoryOffset(archive);\n  const entryCount = archive.readUInt16LE(endOfCentralDirectoryOffset + ARCHIVE_ENTRY_COUNT_OFFSET);\n  let entryOffset = archive.readUInt32LE(endOfCentralDirectoryOffset + CENTRAL_DIRECTORY_START_OFFSET);\n\n  if (entryCount === SATURATED_UINT_16 || entryOffset === SATURATED_UINT_32) {\n    throw new Error('ZIP64 archives are not supported.');\n  }\n\n  const entries: ZipEntry[] = [];\n  for (let entryIndex = 0; entryIndex < entryCount; entryIndex++) {\n    if (archive.readUInt32LE(entryOffset) !== CENTRAL_DIRECTORY_HEADER_SIGNATURE) {\n      throw new Error(`The archive's central directory is corrupt at entry ${String(entryIndex)}.`);\n    }\n\n    const flags = archive.readUInt16LE(entryOffset + CENTRAL_DIRECTORY_FLAGS_OFFSET);\n    if (flags % ENCRYPTED_FLAG_DIVISOR === 1) {\n      throw new Error('Encrypted ZIP archives are not supported.');\n    }\n\n    const compressedSize = archive.readUInt32LE(entryOffset + CENTRAL_DIRECTORY_COMPRESSED_SIZE_OFFSET);\n    const localHeaderOffset = archive.readUInt32LE(entryOffset + CENTRAL_DIRECTORY_LOCAL_HEADER_OFFSET_OFFSET);\n    if (compressedSize === SATURATED_UINT_32 || localHeaderOffset === SATURATED_UINT_32) {\n      throw new Error('ZIP64 archives are not supported.');\n    }\n\n    const nameLength = archive.readUInt16LE(entryOffset + CENTRAL_DIRECTORY_NAME_LENGTH_OFFSET);\n    const nameOffset = entryOffset + CENTRAL_DIRECTORY_HEADER_SIZE;\n    entries.push({\n      compressedSize,\n      compressionMethod: archive.readUInt16LE(entryOffset + CENTRAL_DIRECTORY_COMPRESSION_METHOD_OFFSET),\n      localHeaderOffset,\n      name: archive.toString('utf-8', nameOffset, nameOffset + nameLength)\n    });\n\n    entryOffset = nameOffset\n      + nameLength\n      + archive.readUInt16LE(entryOffset + CENTRAL_DIRECTORY_EXTRA_LENGTH_OFFSET)\n      + archive.readUInt16LE(entryOffset + CENTRAL_DIRECTORY_COMMENT_LENGTH_OFFSET);\n  }\n\n  return entries;\n}\n\n/**\n * Reads and decompresses one entry's bytes.\n *\n * The data's start is computed from the LOCAL header rather than the central one: the two carry\n * independent name and extra-field lengths, and only the local pair describes where the bytes\n * actually begin.\n *\n * @param archive - The raw ZIP archive bytes.\n * @param entry - The entry, as read from the central directory.\n * @returns The entry's uncompressed content.\n */\nfunction readEntryData(archive: Buffer, entry: ZipEntry): Buffer {\n  if (archive.readUInt32LE(entry.localHeaderOffset) !== LOCAL_FILE_HEADER_SIGNATURE) {\n    throw new Error(`The archive entry '${entry.name}' has a corrupt local header.`);\n  }\n\n  const dataOffset = entry.localHeaderOffset\n    + LOCAL_HEADER_SIZE\n    + archive.readUInt16LE(entry.localHeaderOffset + LOCAL_HEADER_NAME_LENGTH_OFFSET)\n    + archive.readUInt16LE(entry.localHeaderOffset + LOCAL_HEADER_EXTRA_LENGTH_OFFSET);\n  const dataEnd = dataOffset + entry.compressedSize;\n  if (dataEnd > archive.length) {\n    throw new Error(`The archive is truncated: entry '${entry.name}' runs past its end.`);\n  }\n\n  const compressedData = archive.subarray(dataOffset, dataEnd);\n  switch (entry.compressionMethod) {\n    case COMPRESSION_METHOD_DEFLATED: {\n      return inflateRawSync(compressedData);\n    }\n    case COMPRESSION_METHOD_STORED: {\n      return compressedData;\n    }\n    default: {\n      throw new Error(`The archive entry '${entry.name}' uses unsupported compression method ${String(entry.compressionMethod)}.`);\n    }\n  }\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/esm/disposable.d.mts

@@ -0,0 +1,387 @@
+/// <reference path="./library-references.d.mts" />
+/**
+ * @file
+ *
+ * Disposable utilities for `using` / `await using` declarations.
+ */
+import type { Promisable } from 'type-fest';
+/**
+ * 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.
+ */
+export declare enum MultipleDisposeBehavior {
+    /**
+     * Invoke the callback on every dispose.
+     */
+    Invoke = 0,
+    /**
+     * Invoke the callback on the first dispose only; subsequent disposes are no-ops.
+     */
+    Ignore = 1,
+    /**
+     * Invoke the callback on the first dispose only; subsequent disposes throw.
+     */
+    Throw = 2
+}
+/**
+ * The parameters for constructing an {@link AsyncCallbackDisposable}.
+ */
+export interface AsyncCallbackDisposableConstructorParams {
+    /**
+     * The callback to execute when disposed.
+     */
+    readonly callback: AsyncDisposeCallback;
+    /**
+     * How the disposable behaves when disposed more than once.
+     *
+     * @default {@link MultipleDisposeBehavior.Ignore}
+     */
+    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.
+ */
+export type AsyncDisposeCallback = () => Promisable<void>;
+/**
+ * The parameters for constructing a {@link CallbackDisposable}.
+ */
+export interface CallbackDisposableConstructorParams {
+    /**
+     * The callback to execute when disposed.
+     */
+    readonly callback: DisposeCallback;
+    /**
+     * How the disposable behaves when disposed more than once.
+     *
+     * @default {@link MultipleDisposeBehavior.Ignore}
+     */
+    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.Ignore}
+     */
+    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.Ignore}
+     */
+    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.
+ */
+export type DisposeCallback = () => void;
+/**
+ * Abstract base for an {@link AsyncDisposableEx}: it carries the re-dispose guard (via
+ * {@link MultipleDisposeBehavior}) and the {@link AsyncDisposableEx.asyncDispose} alias; a subclass only
+ * implements {@link AsyncDisposableBase.performDisposeAsync}.
+ */
+export declare abstract class AsyncDisposableBase implements AsyncDisposableEx {
+    /**
+     * How the disposable behaves when disposed more than once.
+     *
+     * @default {@link MultipleDisposeBehavior.Ignore}
+     */
+    protected multipleDisposeBehavior: MultipleDisposeBehavior;
+    /**
+     * Whether this disposable has been disposed (its teardown has run at least once).
+     *
+     * @returns `true` once disposal has started.
+     */
+    protected get isDisposed(): boolean;
+    private _isDisposed;
+    /**
+     * Disposes the object. Convenience alias that delegates to `this[Symbol.asyncDispose]()`.
+     *
+     * @returns A {@link Promise} that resolves once teardown completes.
+     */
+    asyncDispose(): Promise<void>;
+    /**
+     * 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.
+     */
+    [Symbol.asyncDispose](): Promise<void>;
+    /**
+     * Performs the actual teardown. Called at most once unless {@link MultipleDisposeBehavior.Invoke} is set.
+     *
+     * @returns A {@link Promisable} that resolves once teardown completes.
+     */
+    protected abstract performDisposeAsync(): Promisable<void>;
+}
+/**
+ * An async disposable that executes a callback when disposed via `await using` (or a manual
+ * `await disposable[Symbol.asyncDispose]()`).
+ */
+export declare class AsyncCallbackDisposable extends AsyncDisposableBase {
+    private readonly callback;
+    /**
+     * Creates a new instance of {@link AsyncCallbackDisposable}.
+     *
+     * @param params - The parameters.
+     */
+    constructor(params: AsyncCallbackDisposableConstructorParams);
+    /**
+     * Runs the dispose callback.
+     *
+     * @returns A {@link Promise} that resolves once the callback completes.
+     */
+    protected performDisposeAsync(): Promise<void>;
+}
+/**
+ * Disposes a {@link Disposable}.
+ *
+ * Prefer this over calling `disposable[Symbol.dispose]()` at the call site: it reads better and keeps the
+ * well-known symbol referenced in a single place.
+ *
+ * @param disposable - the disposable to dispose
+ */
+export declare function dispose(disposable: Disposable): void;
+/**
+ * Abstract base for a {@link DisposableEx}: it carries the re-dispose guard (via {@link MultipleDisposeBehavior})
+ * and the {@link DisposableEx.dispose} alias; a subclass only implements {@link DisposableBase.performDispose}.
+ */
+export declare abstract class DisposableBase implements DisposableEx {
+    /**
+     * How the disposable behaves when disposed more than once.
+     *
+     * @default {@link MultipleDisposeBehavior.Ignore}
+     */
+    protected multipleDisposeBehavior: MultipleDisposeBehavior;
+    /**
+     * Whether this disposable has been disposed (its teardown has run at least once).
+     *
+     * @returns `true` once disposal has started.
+     */
+    protected get isDisposed(): boolean;
+    private _isDisposed;
+    /**
+     * Disposes the object. Convenience alias that delegates to `this[Symbol.dispose]()`.
+     */
+    dispose(): void;
+    /**
+     * Disposes the object by running {@link DisposableBase.performDispose}, honoring the configured
+     * {@link MultipleDisposeBehavior} on a repeat dispose.
+     */
+    [Symbol.dispose](): void;
+    /**
+     * Performs the actual teardown. Called at most once unless {@link MultipleDisposeBehavior.Invoke} is set.
+     */
+    protected abstract performDispose(): void;
+}
+/**
+ * A disposable that executes a callback when disposed.
+ */
+export declare class CallbackDisposable extends DisposableBase {
+    private readonly callback;
+    /**
+     * Creates a new instance of {@link CallbackDisposable}.
+     *
+     * @param params - The parameters.
+     */
+    constructor(params: CallbackDisposableConstructorParams);
+    /**
+     * Runs the dispose callback.
+     */
+    protected performDispose(): void;
+}
+/**
+ * An {@link AsyncDisposableEx} that combines multiple async disposables and disposes all of them when it
+ * is disposed.
+ */
+export declare class CombineAsyncDisposable extends AsyncDisposableBase {
+    private readonly children;
+    private readonly disposeOrder;
+    private readonly errorBehavior;
+    /**
+     * Creates a new instance of {@link CombineAsyncDisposable}.
+     *
+     * @param params - The parameters.
+     */
+    constructor(params: CombineAsyncDisposableConstructorParams);
+    /**
+     * 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.
+     */
+    protected performDisposeAsync(): Promise<void>;
+    private getOrderedChildren;
+}
+/**
+ * A {@link DisposableEx} that combines multiple disposables and disposes all of them when it is
+ * disposed.
+ */
+export declare class CombineDisposable extends DisposableBase {
+    private readonly children;
+    private readonly disposeOrder;
+    private readonly errorBehavior;
+    /**
+     * Creates a new instance of {@link CombineDisposable}.
+     *
+     * @param params - The parameters.
+     */
+    constructor(params: CombineDisposableConstructorParams);
+    /**
+     * Disposes all combined children in the configured {@link DisposeOrder}, applying the configured
+     * {@link DisposeErrorBehavior} when a child throws.
+     */
+    protected performDispose(): void;
+    private getOrderedChildren;
+}
+/**
+ * Disposes an {@link AsyncDisposable}.
+ *
+ * Prefer this over calling `asyncDisposable[Symbol.asyncDispose]()` at the call site: it reads better and
+ * keeps the well-known symbol referenced in a single place.
+ *
+ * @param asyncDisposable - the async disposable to dispose
+ * @returns A {@link Promise} that resolves once the disposal completes.
+ */
+export declare function disposeAsync(asyncDisposable: AsyncDisposable): Promise<void>;
+/**
+ * Type guard to check if an object implements the {@link AsyncDisposable} interface.
+ *
+ * @param $unknown - the object to check for the {@link AsyncDisposable} interface
+ * @returns Whether the object implements the {@link AsyncDisposable} interface
+ */
+export declare function isAsyncDisposable($unknown: unknown): $unknown is AsyncDisposable;
+/**
+ * Type guard to check if an object implements the {@link AsyncDisposableEx} interface.
+ *
+ * @param $unknown - the object to check for the {@link AsyncDisposableEx} interface
+ * @returns Whether the object implements the {@link AsyncDisposableEx} interface
+ */
+export declare function isAsyncDisposableEx($unknown: unknown): $unknown is AsyncDisposableEx;
+/**
+ * Type guard to check if an object implements the {@link Disposable} interface.
+ *
+ * @param $unknown - the object to check for the {@link Disposable} interface
+ * @returns Whether the object implements the {@link Disposable} interface
+ */
+export declare function isDisposable($unknown: unknown): $unknown is Disposable;
+/**
+ * Type guard to check if an object implements the {@link DisposableEx} interface.
+ *
+ * @param $unknown - the object to check for the {@link DisposableEx} interface
+ * @returns Whether the object implements the {@link DisposableEx} interface
+ */
+export declare function isDisposableEx($unknown: unknown): $unknown 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;