@mnaoumov/typescript-lib 2.0.0 → 3.0.0

package/dist/lib/esm/async.mjs

@@ -29,10 +29,7 @@ import {
   noopAsync
 } from "./function.mjs";
 import { normalizeOptionalProperties } from "./object-utils.mjs";
-import {
-  assert,
-  assertNonNullable
-} from "./type-guards.mjs";
+import { assert } from "./type-guards.mjs";
 async function addErrorHandler(asyncFunction, stackTrace) {
   stackTrace ??= getStackTrace(1);
   const wasScheduledWithinIgnoreContext = isAsyncErrorIgnoreContextActive();
@@ -86,14 +83,13 @@ async function asyncMap(array, callback) {
   return await promiseAllSequentially(array.map(callback));
 }
 function convertAsyncToSync(asyncFunction, stackTrace) {
-  stackTrace ??= getStackTrace(1);
+  const outerStackTrace = stackTrace ?? getStackTrace(1);
   return (...$arguments) => {
-    assertNonNullable(stackTrace);
     const innerStackTrace = getStackTrace(1);
-    stackTrace += `
+    const callStackTrace = `${outerStackTrace}
     at --- convertAsyncToSync --- (0)
 ${innerStackTrace}`;
-    invokeAsyncSafely(() => asyncFunction(...$arguments), stackTrace);
+    invokeAsyncSafely(() => asyncFunction(...$arguments), callStackTrace);
   };
 }
 function convertSyncToAsync(syncFunction) {
@@ -447,4 +443,4 @@ export {
   timeout,
   toArray
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/async.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions for asynchronous operations.\n */\n\nimport type { Promisable } from 'type-fest';\n\nimport type {\n  GenericAsyncFunction,\n  GenericFunction,\n  GenericVoidFunction\n} from './function.ts';\n\nimport {\n  abortSignalAny,\n  abortSignalNever,\n  abortSignalTimeout,\n  waitForAbort\n} from './abort-controller.ts';\nimport { notifyAsyncOperationStarted } from './async-operation-hook.ts';\nimport { getTerminateOnTimeoutDebugSwitch } from './debug-switches.ts';\nimport {\n  getLibDebugger,\n  printWithStackTrace\n} from './debug.ts';\nimport {\n  ASYNC_WRAPPER_ERROR_MESSAGE,\n  CustomStackTraceError,\n  emitAsyncErrorEvent,\n  getStackTrace,\n  isAsyncErrorIgnoreContextActive,\n  printError,\n  SilentError\n} from './error.ts';\nimport {\n  noop,\n  noopAsync\n} from './function.ts';\nimport { normalizeOptionalProperties } from './object-utils.ts';\nimport {\n  assert,\n  assertNonNullable\n} from './type-guards.ts';\n\n/**\n * Parameters for {@link invokeAsyncSafelyAfterDelay}.\n */\nexport interface InvokeAsyncSafelyAfterDelayParams {\n  /**\n   * The abort signal to listen to.\n   */\n  readonly abortSignal?: AbortSignal;\n\n  /**\n   * The asynchronous function to invoke.\n   *\n   * @param abortSignal - The abort signal to listen to.\n   */\n  readonly asyncFunction: (abortSignal: AbortSignal) => Promisable<void>;\n\n  /**\n   * The delay in milliseconds.\n   *\n   * @default `0`\n   */\n  readonly delayInMilliseconds?: number;\n\n  /**\n   * The stack trace of the source function.\n   */\n  readonly stackTrace?: string;\n}\n\n/**\n * A type representing a function that resolves a {@link Promise}.\n *\n * @typeParam T - The type of the value.\n */\nexport type PromiseResolve<T> = undefined extends T ? (value?: PromiseLike<T> | T) => void\n  : (value: PromiseLike<T> | T) => void;\n\n/**\n * Options for {@link retryWithTimeout}.\n */\nexport interface RetryOptions {\n  /**\n   * A abort signal to cancel the retry operation.\n   */\n  readonly abortSignal?: AbortSignal;\n\n  /**\n   * A delay in milliseconds between retry attempts.\n   *\n   * @default `100`\n   */\n  readonly retryDelayInMilliseconds?: number;\n\n  /**\n   * Whether to retry the function on error.\n   *\n   * @default `false`\n   */\n  readonly shouldRetryOnError?: boolean;\n\n  /**\n   * A maximum time in milliseconds to wait before giving up on retrying.\n   *\n   * @default `5000`\n   */\n  readonly timeoutInMilliseconds?: number;\n}\n\n/**\n * Adds an error handler to a {@link Promise} that catches any errors and emits an async error event.\n *\n * @param asyncFunction - The asynchronous function to add an error handler to.\n * @param stackTrace - The stack trace of the source function.\n * @returns A {@link Promise} that resolves when the asynchronous function completes or emits async error event.\n */\nexport async function addErrorHandler(asyncFunction: () => Promise<unknown>, stackTrace?: string): Promise<void> {\n  stackTrace ??= getStackTrace(1);\n  // Capture the ignore context synchronously at schedule time, so a deferred rejection settling after the scope exits is still ignored.\n  const wasScheduledWithinIgnoreContext = isAsyncErrorIgnoreContextActive();\n  try {\n    await asyncFunction();\n  } catch (asyncError) {\n    const wrappedError = new CustomStackTraceError({\n      cause: asyncError,\n      message: ASYNC_WRAPPER_ERROR_MESSAGE,\n      stackTrace\n    });\n    if (handleSilentError(wrappedError)) {\n      return;\n    }\n    emitAsyncErrorEvent(wrappedError, wasScheduledWithinIgnoreContext);\n  }\n}\n\n/**\n * Filters an array asynchronously, keeping only the elements that satisfy the provided predicate function.\n *\n * @typeParam T - The type of elements in the input array.\n * @param array - The array to filter.\n * @param predicate - The predicate function to test each element.\n * @returns A {@link Promise} that resolves with an array of elements that satisfy the predicate function.\n */\nexport async function asyncFilter<T>(array: T[], predicate: (value: T, index: number, array: T[]) => Promisable<boolean>): Promise<T[]> {\n  const ans: T[] = [];\n\n  const length = array.length;\n  for (let index = 0; index < length; index++) {\n    if (!Object.hasOwn(array, index)) {\n      continue;\n    }\n\n    const item = array[index] as T;\n    if (await predicate(item, index, array)) {\n      ans.push(item);\n    }\n  }\n\n  return ans;\n}\n\n/**\n * Filters an array asynchronously in place, keeping only the elements that satisfy the provided predicate function.\n *\n * @typeParam T - The type of elements in the input array.\n * @param array - The array to filter.\n * @param predicate - The predicate function to test each element.\n * @returns A {@link Promise} that resolves when the array is filtered.\n */\nexport async function asyncFilterInPlace<T>(array: T[], predicate: (value: T, index: number, array: T[]) => Promisable<boolean>): Promise<void> {\n  const length = array.length;\n  let writeIndex = 0;\n  for (let readIndex = 0; readIndex < length; readIndex++) {\n    if (!Object.hasOwn(array, readIndex)) {\n      continue;\n    }\n\n    const current = array[readIndex] as T;\n    if (await predicate(current, readIndex, array)) {\n      // eslint-disable-next-line require-atomic-updates -- Yes, it is a potential race condition, but I don't an elegant way to fix it.\n      array[writeIndex++] = current;\n    }\n  }\n  array.length = writeIndex;\n}\n\n/**\n * Maps over an array asynchronously, applying the provided callback function to each element, and then flattens the results into a single array.\n *\n * @typeParam T - The type of elements in the input array.\n * @typeParam U - The type of elements in the output array.\n * @param array - The array to map over and flatten.\n * @param callback - The callback function to apply to each element.\n * @returns A {@link Promise} that resolves with a flattened array of the results of the callback function.\n */\nexport async function asyncFlatMap<T, U>(array: T[], callback: (value: T, index: number, array: T[]) => Promisable<U[]>): Promise<U[]> {\n  const nestedResults = await asyncMap(array, callback);\n  return nestedResults.flat();\n}\n\n/**\n * Maps over an array asynchronously, applying the provided callback function to each element.\n *\n * @typeParam T - The type of elements in the input array.\n * @typeParam U - The type of elements in the output array.\n * @param array - The array to map over.\n * @param callback - The callback function to apply to each element.\n * @returns A {@link Promise} that resolves with an array of the results of the callback function.\n */\nexport async function asyncMap<T, U>(array: T[], callback: (value: T, index: number, array: T[]) => Promisable<U>): Promise<U[]> {\n  // eslint-disable-next-line unicorn/no-array-callback-reference -- Passing `callback` straight through is the contract: it is declared as `(value, index, array)` so that it receives exactly what `Array#map` supplies. Wrapping it to take only the value would quietly stop forwarding the other two.\n  return await promiseAllSequentially(array.map(callback));\n}\n\n/**\n * Converts an asynchronous function to a synchronous one by automatically handling the Promise rejection.\n *\n * @typeParam Arguments - The types of the arguments the function accepts.\n * @param asyncFunction - The asynchronous function to convert.\n * @param stackTrace - The stack trace of the source function.\n * @returns A function that wraps the asynchronous function in a synchronous interface.\n */\nexport function convertAsyncToSync<Arguments extends unknown[]>(asyncFunction: GenericAsyncFunction<Arguments>, stackTrace?: string): GenericVoidFunction<Arguments> {\n  stackTrace ??= getStackTrace(1);\n  return (...$arguments: Arguments): void => {\n    assertNonNullable(stackTrace);\n    const innerStackTrace = getStackTrace(1);\n    stackTrace += `\\n    at --- convertAsyncToSync --- (0)\\n${innerStackTrace}`;\n    invokeAsyncSafely(() => asyncFunction(...$arguments), stackTrace);\n  };\n}\n\n/**\n * Converts a synchronous function to an asynchronous one by wrapping it in a {@link Promise}.\n *\n * @typeParam Arguments - The types of the arguments the function accepts.\n * @typeParam Result - The type of the function's return value.\n * @param syncFunction - The synchronous function to convert.\n * @returns A function that wraps the synchronous function in an asynchronous interface.\n */\nexport function convertSyncToAsync<Arguments extends unknown[], Result>(syncFunction: GenericFunction<Arguments, Result>): GenericAsyncFunction<Arguments, Result> {\n  return async (...$arguments: Arguments): Promise<Result> => {\n    await noopAsync();\n    return syncFunction(...$arguments);\n  };\n}\n\n/**\n * Handles a silent error.\n *\n * @param error - The error to handle.\n * @returns Whether the error is a silent error.\n */\n// eslint-disable-next-line unicorn/consistent-boolean-name -- The name states the action; the boolean only reports whether the error was handled.\nexport function handleSilentError(error: unknown): boolean {\n  let cause = error;\n  while (!(cause instanceof SilentError)) {\n    if (!(cause instanceof Error)) {\n      return false;\n    }\n\n    cause = cause.cause;\n  }\n\n  getLibDebugger('Async:handleSilentError')(error);\n  return true;\n}\n/**\n * Ignores an error that is thrown by an asynchronous function.\n *\n * @param promise - The promise to ignore the error of.\n * @param fallbackValue - Always `undefined`.\n * @returns A {@link Promise} that resolves when the asynchronous function completes or fails.\n */\nexport async function ignoreError(promise: Promise<unknown>, fallbackValue?: undefined): Promise<void>;\n/**\n * Invokes an asynchronous function and returns a fallback value if an error is thrown.\n *\n * @typeParam T - The type of the value returned by the asynchronous function.\n * @param promise - The promise to ignore the error of.\n * @param fallbackValue - The value to return if an error is thrown.\n * @returns A {@link Promise} that resolves with the value returned by the asynchronous function or the fallback value if an error is thrown.\n */\nexport async function ignoreError<T>(promise: Promise<T>, fallbackValue: T): Promise<T>;\n/**\n * Ignores an error that is thrown by an asynchronous function.\n *\n * @typeParam T - The type of the value returned by the asynchronous function.\n * @param promise - The promise to ignore the error of.\n * @param fallbackValue - The value to return if an error is thrown.\n * @returns A {@link Promise} that resolves with the value returned by the asynchronous function or the fallback value if an error is thrown.\n */\nexport async function ignoreError<T>(promise: Promise<T>, fallbackValue?: T): Promise<T | void> {\n  const ignoreErrorDebugger = getLibDebugger('Async:ignoreError');\n  const stackTrace = getStackTrace(1);\n  try {\n    return await promise;\n  } catch (error) {\n    ignoreErrorDebugger(\n      'Ignored error',\n      new CustomStackTraceError({\n        cause: error,\n        message: 'Ignored error',\n        stackTrace\n      })\n    );\n    return fallbackValue;\n  }\n}\n\n/**\n * Invokes a {@link Promise} and safely handles any errors by catching them and emitting an async error event.\n *\n * @param asyncFunction - The asynchronous function to invoke safely.\n * @param stackTrace - The stack trace of the source function.\n */\nexport function invokeAsyncSafely(asyncFunction: () => Promisable<unknown>, stackTrace?: string): void {\n  stackTrace ??= getStackTrace(1);\n\n  let result: unknown;\n  try {\n    result = asyncFunction();\n  } catch (error) {\n    // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors -- Re-rejecting the original caught error as-is.\n    notifyAsyncOperationStarted(addErrorHandler(() => Promise.reject(error), stackTrace));\n  }\n  if (result instanceof Promise) {\n    notifyAsyncOperationStarted(addErrorHandler(() => result, stackTrace));\n  }\n}\n\n/**\n * Invokes an asynchronous function after a delay.\n *\n * @param params - The parameters for the function.\n */\nexport function invokeAsyncSafelyAfterDelay(params: InvokeAsyncSafelyAfterDelayParams): void {\n  const {\n    asyncFunction,\n    delayInMilliseconds = 0\n  } = params;\n  const abortSignal = params.abortSignal ?? abortSignalNever();\n  abortSignal.throwIfAborted();\n  const stackTrace = params.stackTrace ?? getStackTrace(1);\n  invokeAsyncSafely(async () => {\n    await sleep({ abortSignal, milliseconds: delayInMilliseconds, shouldThrowOnAbort: true });\n    await asyncFunction(abortSignal);\n  }, stackTrace);\n}\n\n/**\n * Executes async functions sequentially.\n *\n * @typeParam T - The type of the value.\n * @param asyncFns - The async functions to execute sequentially.\n * @returns A {@link Promise} that resolves with an array of the results of the async functions.\n */\nexport async function promiseAllAsyncFnsSequentially<T>(asyncFns: (() => Promisable<T>)[]): Promise<T[]> {\n  const results: T[] = [];\n  for (const asyncFunction of asyncFns) {\n    results.push(await asyncFunction());\n  }\n  return results;\n}\n\n/**\n * Executes promises sequentially.\n *\n * @typeParam T - The type of the value.\n * @param promises - The promises to execute sequentially.\n * @returns A {@link Promise} that resolves with an array of the results of the promises.\n */\nexport async function promiseAllSequentially<T>(promises: Promisable<T>[]): Promise<T[]> {\n  return await promiseAllAsyncFnsSequentially(promises.map((promise) => () => promise));\n}\n\nconst terminateRetryErrors = new WeakSet<Error>();\n\n/**\n * Options for {@link retryWithTimeout}.\n */\nexport interface RetryWithTimeoutParams {\n  /**\n   * The function to handle the timeout.\n   *\n   * @param context - The timeout context.\n   */\n  readonly onTimeout?: (context: TimeoutContext) => void;\n\n  /**\n   * The function to execute.\n   *\n   * @param abortSignal - The abort signal to listen to.\n   * @returns The result of the function.\n   */\n  readonly operationFunction: (abortSignal: AbortSignal) => Promisable<boolean>;\n\n  /**\n   * The name of the operation.\n   *\n   * @default `''`\n   */\n  readonly operationName?: string;\n\n  /**\n   * The retry options.\n   */\n  readonly retryOptions?: RetryOptions;\n\n  /**\n   * The stack trace of the source function.\n   */\n  readonly stackTrace?: string;\n}\n\n/**\n * Options for {@link runWithTimeout}.\n *\n * @typeParam Result - The type of the result returned by the operation function.\n */\nexport interface RunWithTimeoutParams<Result> {\n  /**\n   * The context of the function.\n   */\n  readonly context?: unknown;\n\n  /**\n   * The function to handle the timeout.\n   *\n   * @param context - The timeout context.\n   */\n  readonly onTimeout?: (context: TimeoutContext) => void;\n\n  /**\n   * The operation function to execute.\n   *\n   * @param abortSignal - The abort signal to listen to.\n   * @returns The result of the function.\n   */\n  readonly operationFunction: (abortSignal: AbortSignal) => Promisable<Result>;\n\n  /**\n   * The name of the operation.\n   *\n   * @default `''`\n   */\n  readonly operationName?: string;\n\n  /**\n   * The stack trace of the source function.\n   */\n  readonly stackTrace?: string | undefined;\n\n  /**\n   * The maximum time to wait in milliseconds.\n   */\n  readonly timeoutInMilliseconds: number;\n}\n\n/**\n * Parameters for {@link sleep}.\n */\nexport interface SleepParams {\n  /**\n   * The abort signal to listen to.\n   */\n  readonly abortSignal?: AbortSignal;\n\n  /**\n   * The time to wait in milliseconds.\n   */\n  readonly milliseconds: number;\n\n  /**\n   * Whether to throw an error if the abort signal is aborted.\n   *\n   * @default `false`\n   */\n  readonly shouldThrowOnAbort?: boolean;\n}\n\n/**\n * Context provided to the timeout handler.\n */\nexport interface TimeoutContext {\n  /**\n   * The duration in milliseconds since the operation started.\n   */\n  readonly duration: number;\n  /**\n   * Registers a callback to be invoked when the operation completes.\n   *\n   * @param callback - The function to call when the operation completes.\n   */\n  onOperationCompleted: (callback: () => void) => void;\n  /**\n   * The name of the operation.\n   */\n  readonly operationName: string;\n  /**\n   * Terminates the operation that timed out.\n   */\n  terminateOperation: () => void;\n}\n\n/**\n * Parameters for {@link timeout}.\n */\nexport interface TimeoutParams {\n  /**\n   * The abort signal to listen to.\n   */\n  readonly abortSignal?: AbortSignal;\n\n  /**\n   * Whether to throw an error if the abort signal is aborted.\n   *\n   * @default `false`\n   */\n  readonly shouldThrowOnAbort?: boolean;\n\n  /**\n   * The timeout period in milliseconds.\n   */\n  readonly timeoutInMilliseconds: number;\n}\n\n/**\n * Chains a promise with another promise.\n *\n * @param chainPromise - Represents the chained promise.\n * @param promisableFunction - The function to chain.\n * @returns Chained promise or `null` if no async logic is chained.\n */\nexport function chain(chainPromise: null | Promise<void>, promisableFunction: () => null | Promisable<void>): null | Promise<void> {\n  let nextChainPromise = chainPromise;\n  if (chainPromise) {\n    nextChainPromise = chainPromise.then(() => promisableFunction() ?? undefined);\n  } else {\n    const promisable = promisableFunction();\n    if (promisable) {\n      nextChainPromise = promisable instanceof Promise ? promisable as Promise<void> : Promise.resolve(promisable);\n    }\n  }\n\n  nextChainPromise?.catch(noop);\n  return nextChainPromise;\n}\n\n/**\n * Gets whether a {@link runWithTimeout} call without its own `onTimeout` terminates the operation when it times out.\n *\n * @deprecated Use {@link getTerminateOnTimeoutDebugSwitch}`().isEnabled()`.\n *\n * @returns `true` (the default) if a timed-out operation is terminated, `false` if it is left running.\n */\nexport function isTerminationOnTimeoutEnabled(): boolean {\n  return getTerminateOnTimeoutDebugSwitch().isEnabled();\n}\n\n/**\n * Marks an error to terminate retry logic.\n *\n * @param error - The error to mark to terminate retry logic.\n */\nexport function marksAsTerminateRetry(error: Error): void {\n  terminateRetryErrors.add(error);\n}\n\n/**\n * An async function that never ends.\n *\n * @returns A {@link Promise} that never resolves.\n */\nexport async function neverEnds(): Promise<never> {\n  await new Promise(() => {\n    noop();\n  });\n  /* v8 ignore start -- Exhaustive switch guard; the await above never resolves. */\n  assert(false, 'Should never happen');\n  /* v8 ignore stop */\n}\n\n/**\n * Gets the next tick.\n *\n * @returns A promise that resolves when the next tick is available.\n */\nexport async function nextTickAsync(): Promise<void> {\n  return new Promise((resolve) => {\n    queueMicrotask(() => {\n      resolve();\n    });\n  });\n}\n\n/**\n * Converts to native promisable, converting {@link PromiseLike} (aka Thenable) to a native {@link Promise}.\n *\n * @typeParam T - The type of the value.\n * @param promisable - The promisable to normalize.\n * @returns The value itself or a native {@link Promise} if the value is a {@link PromiseLike}.\n */\nexport function normalizePromisable<T>(promisable: Promisable<T>): Promise<T> | T {\n  if (!promisable) {\n    return promisable;\n  }\n\n  if (promisable instanceof Promise) {\n    return promisable as Promise<T>;\n  }\n\n  return (promisable as Partial<PromiseLike<T>>).then ? Promise.resolve(promisable) : (promisable as T);\n}\n\n/**\n * Gets the next queue microtask.\n *\n * @returns A promise that resolves when the next queue microtask is available.\n */\nexport async function queueMicrotaskAsync(): Promise<void> {\n  return new Promise((resolve) => {\n    queueMicrotask(() => {\n      resolve();\n    });\n  });\n}\n\n/**\n * Gets the next request animation frame.\n *\n * @param fallbackTimeoutInMilliseconds - The fallback timeout in milliseconds to resolve the promise if `requestAnimationFrame` does not fire (e.g. the window is not active).\n *                                        Defaults to `100` milliseconds. Use `0` to disable the fallback.\n * @returns A promise that resolves when the next request animation frame is available (or when the fallback time is reached).\n */\nexport async function requestAnimationFrameAsync(fallbackTimeoutInMilliseconds?: number): Promise<void> {\n  const requestAnimationFrameAsyncPromise = new Promise<void>((resolve) => {\n    window.requestAnimationFrame(() => {\n      resolve();\n    });\n  });\n\n  const DEFAULT_FALLBACK_TIMEOUT_IN_MILLISECONDS = 100;\n  fallbackTimeoutInMilliseconds ??= DEFAULT_FALLBACK_TIMEOUT_IN_MILLISECONDS;\n\n  return Promise.race([requestAnimationFrameAsyncPromise, fallbackTimeoutInMilliseconds > 0 ? sleep({ milliseconds: fallbackTimeoutInMilliseconds }) : neverEnds()]);\n}\n\n/**\n * Retries the provided function until it returns `true` or the timeout is reached.\n *\n * @param params - The parameters for the function.\n * @returns A {@link Promise} that resolves when the function returns `true` or rejects when the timeout is reached.\n */\nexport async function retryWithTimeout(params: RetryWithTimeoutParams): Promise<void> {\n  const retryWithTimeoutDebugger = getLibDebugger('Async:retryWithTimeout');\n  const stackTrace = params.stackTrace ?? getStackTrace(1);\n  const DEFAULT_RETRY_OPTIONS = {\n    // eslint-disable-next-line no-magic-numbers -- Extracting magic number as a constant would be repetitive, as the value is used only once and its name would be the same as the property.\n    retryDelayInMilliseconds: 100,\n    shouldRetryOnError: false,\n    // eslint-disable-next-line no-magic-numbers -- Extracting magic number as a constant would be repetitive, as the value is used only once and its name would be the same as the property.\n    timeoutInMilliseconds: 5000\n  };\n  const fullOptions = { ...DEFAULT_RETRY_OPTIONS, ...params.retryOptions };\n  fullOptions.abortSignal?.throwIfAborted();\n\n  await runWithTimeout(normalizeOptionalProperties<RunWithTimeoutParams<void>>({\n    context: { operationName: params.operationName ?? '', retryFunction: params.operationFunction },\n    onTimeout: params.onTimeout,\n    async operationFunction(abortSignal: AbortSignal): Promise<void> {\n      const combinedAbortSignal = abortSignalAny(fullOptions.abortSignal, abortSignal);\n      combinedAbortSignal.throwIfAborted();\n      let attempt = 0;\n      while (!combinedAbortSignal.aborted) {\n        attempt++;\n        let isSuccess: boolean;\n        try {\n          isSuccess = await params.operationFunction(combinedAbortSignal);\n        } catch (error) {\n          // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- It might changed inside `fn()`. ESLint mistakenly does not recognize it.\n          if (combinedAbortSignal.aborted || !fullOptions.shouldRetryOnError || terminateRetryErrors.has(error as Error)) {\n            throw new CustomStackTraceError({\n              cause: error,\n              message: 'retryWithTimeout failed',\n              stackTrace\n            });\n          }\n          printError(error);\n          isSuccess = false;\n        }\n        if (isSuccess) {\n          printWithStackTrace({\n            $arguments: [{\n              operationFunction: params.operationFunction,\n              operationName: params.operationName ?? ''\n            }],\n            debuggerInstance: retryWithTimeoutDebugger,\n            message: `Retry completed successfully after ${String(attempt)} attempts`,\n            stackTrace\n          });\n          return;\n        }\n\n        printWithStackTrace({\n          $arguments: [{\n            operationFunction: params.operationFunction,\n            operationName: params.operationName ?? ''\n          }],\n          debuggerInstance: retryWithTimeoutDebugger,\n          message: `Retry attempt ${String(attempt)} completed unsuccessfully. Trying again in ${String(fullOptions.retryDelayInMilliseconds)} milliseconds`,\n          stackTrace\n        });\n\n        await sleep({ abortSignal, milliseconds: fullOptions.retryDelayInMilliseconds });\n      }\n    },\n    operationName: params.operationName ?? '',\n    stackTrace,\n    timeoutInMilliseconds: fullOptions.timeoutInMilliseconds\n  }));\n}\n\n/**\n * Executes a function with a timeout. If the function does not complete within the specified time, it is considered to have timed out.\n *\n * Without an `onTimeout`, a timed-out function is terminated, unless the {@link getTerminateOnTimeoutDebugSwitch} debug switch is off,\n * in which case it is allowed to run indefinitely.\n *\n * @typeParam Result - The type of the result from the asynchronous function.\n * @param params - The parameters for the function.\n * @returns A {@link Promise} that resolves with the result of the asynchronous function or rejects if it times out.\n */\nexport async function runWithTimeout<Result>(params: RunWithTimeoutParams<Result>): Promise<Result> {\n  const stackTrace = params.stackTrace ?? getStackTrace(1);\n  const startTime = performance.now();\n\n  const runAbortController = new AbortController();\n  const timeoutAbortController = new AbortController();\n\n  let result: null | Result = null;\n  let hasResult = false;\n  let isCompleted = false;\n  const runWithTimeoutDebugger = getLibDebugger('Async:runWithTimeout');\n  const onTimeout = params.onTimeout ?? defaultOnTimeout;\n\n  await Promise.race([run(), innerTimeout()]);\n  // The result is only valid if the run finished on its own. When the timeout terminated it, the\n  // operation might still resolve afterwards (e.g. a retry loop that exits on abort), but that value\n  // is past the deadline and must be treated as a failure, not a success.\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- Both might change inside `run()`/`innerTimeout()`. ESLint mistakenly does not recognize it.\n  if (hasResult && !runAbortController.signal.aborted) {\n    return result as Result;\n  }\n\n  throw new CustomStackTraceError({\n    cause: runAbortController.signal.reason,\n    message: 'Run with timeout failed',\n    stackTrace\n  });\n\n  async function run(): Promise<void> {\n    try {\n      result = await params.operationFunction(runAbortController.signal);\n      const duration = Math.trunc(performance.now() - startTime);\n      printWithStackTrace({\n        $arguments: [{\n          context: params.context,\n          operationFunction: params.operationFunction,\n          operationName: params.operationName ?? ''\n        }],\n        debuggerInstance: runWithTimeoutDebugger,\n        message: `Execution time: ${String(duration)} milliseconds`,\n        stackTrace\n      });\n      hasResult = true;\n    } catch (error) {\n      runAbortController.abort(error);\n    } finally {\n      isCompleted = true;\n      timeoutAbortController.abort(new Error('Completed'));\n    }\n  }\n\n  async function innerTimeout(): Promise<void> {\n    await sleep({ abortSignal: timeoutAbortController.signal, milliseconds: params.timeoutInMilliseconds });\n\n    if (isCompleted) {\n      return;\n    }\n    const duration = Math.trunc(performance.now() - startTime);\n    printWithStackTrace({\n      $arguments: [{\n        context: params.context,\n        operationFunction: params.operationFunction,\n        operationName: params.operationName ?? ''\n      }],\n      debuggerInstance: runWithTimeoutDebugger,\n      message: `Timed out after ${String(duration)} milliseconds`,\n      stackTrace\n    });\n\n    const timeoutContext: TimeoutContext = normalizeOptionalProperties<TimeoutContext>({\n      duration,\n      onOperationCompleted(callback) {\n        timeoutAbortController.signal.addEventListener('abort', callback);\n      },\n      operationName: params.operationName ?? '',\n      terminateOperation() {\n        const error = new Error(`Timed out after ${String(duration)} milliseconds`);\n        runAbortController.abort(error);\n        timeoutAbortController.abort(error);\n      }\n    });\n\n    onTimeout(timeoutContext);\n    await waitForAbort(timeoutAbortController.signal);\n  }\n}\n\n/**\n * Gets the next set immediate.\n *\n * @returns A promise that resolves when the next set immediate is available.\n */\nexport async function setImmediateAsync(): Promise<void> {\n  return new Promise((resolve) => {\n    setImmediate(() => {\n      resolve();\n    });\n  });\n}\n\n/**\n * Sets whether a {@link runWithTimeout} call without its own `onTimeout` terminates the operation when it times out.\n *\n * @deprecated Use {@link getTerminateOnTimeoutDebugSwitch}`().setEnabled(isEnabled)`.\n *\n * @param isEnabled - `true` to terminate a timed-out operation, `false` to leave it running.\n */\nexport function setTerminationOnTimeoutEnabled(isEnabled: boolean): void {\n  getTerminateOnTimeoutDebugSwitch().setEnabled(isEnabled);\n}\n\n/**\n * Delays execution for a specified number of milliseconds.\n *\n * @param delay - The time to wait in milliseconds.\n * @returns A {@link Promise} that resolves after the specified delay.\n */\nexport async function setTimeoutAsync(delay?: number): Promise<void> {\n  await new Promise((resolve) => {\n    window.setTimeout(resolve, delay);\n  });\n}\n\n/**\n * Delays execution for a specified number of milliseconds.\n *\n * @param params - The parameters for the function.\n * @returns A {@link Promise} that resolves after the specified delay.\n */\nexport async function sleep(params: SleepParams): Promise<void> {\n  const {\n    abortSignal,\n    milliseconds,\n    shouldThrowOnAbort\n  } = params;\n  await waitForAbort(abortSignalAny(abortSignal, abortSignalTimeout(milliseconds)));\n  if (shouldThrowOnAbort) {\n    abortSignal?.throwIfAborted();\n  }\n}\n\n/**\n * Returns a {@link Promise} that rejects after the specified timeout period.\n *\n * @param params - The parameters for the function.\n * @returns A {@link Promise} that always rejects with a timeout error.\n */\nexport async function timeout(params: TimeoutParams): Promise<never> {\n  const {\n    abortSignal,\n    shouldThrowOnAbort,\n    timeoutInMilliseconds\n  } = params;\n  await sleep(normalizeOptionalProperties<SleepParams>({\n    abortSignal,\n    milliseconds: timeoutInMilliseconds,\n    shouldThrowOnAbort\n  }));\n  throw new Error(`Timed out in ${String(timeoutInMilliseconds)} milliseconds`);\n}\n\n/**\n * Converts an AsyncIterableIterator to an array by consuming all its elements.\n *\n * @typeParam T - The type of elements produced by the AsyncIterableIterator.\n * @param iter - The AsyncIterableIterator to convert.\n * @returns A {@link Promise} that resolves with an array of all the elements in the AsyncIterableIterator.\n */\nexport async function toArray<T>(iter: AsyncIterableIterator<T>): Promise<T[]> {\n  const array: T[] = [];\n  for await (const item of iter) {\n    array.push(item);\n  }\n  return array;\n}\n\nfunction defaultOnTimeout(context: TimeoutContext): void {\n  if (getTerminateOnTimeoutDebugSwitch().isEnabled()) {\n    context.terminateOperation();\n    return;\n  }\n\n  getLibDebugger('Async:runWithTimeout')(\n    `Timeout termination is switched off, so the operation '${context.operationName}' keeps running after ${String(context.duration)} milliseconds`\n  );\n}\n"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/async.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions for asynchronous operations.\n */\n\nimport type { Promisable } from 'type-fest';\n\nimport type {\n  GenericAsyncFunction,\n  GenericFunction,\n  GenericVoidFunction\n} from './function.ts';\n\nimport {\n  abortSignalAny,\n  abortSignalNever,\n  abortSignalTimeout,\n  waitForAbort\n} from './abort-controller.ts';\nimport { notifyAsyncOperationStarted } from './async-operation-hook.ts';\nimport { getTerminateOnTimeoutDebugSwitch } from './debug-switches.ts';\nimport {\n  getLibDebugger,\n  printWithStackTrace\n} from './debug.ts';\nimport {\n  ASYNC_WRAPPER_ERROR_MESSAGE,\n  CustomStackTraceError,\n  emitAsyncErrorEvent,\n  getStackTrace,\n  isAsyncErrorIgnoreContextActive,\n  printError,\n  SilentError\n} from './error.ts';\nimport {\n  noop,\n  noopAsync\n} from './function.ts';\nimport { normalizeOptionalProperties } from './object-utils.ts';\nimport { assert } from './type-guards.ts';\n\n/**\n * Parameters for {@link invokeAsyncSafelyAfterDelay}.\n */\nexport interface InvokeAsyncSafelyAfterDelayParams {\n  /**\n   * The abort signal to listen to.\n   */\n  readonly abortSignal?: AbortSignal;\n\n  /**\n   * The asynchronous function to invoke.\n   *\n   * @param abortSignal - The abort signal to listen to.\n   */\n  readonly asyncFunction: (abortSignal: AbortSignal) => Promisable<void>;\n\n  /**\n   * The delay in milliseconds.\n   *\n   * @default `0`\n   */\n  readonly delayInMilliseconds?: number;\n\n  /**\n   * The stack trace of the source function.\n   */\n  readonly stackTrace?: string;\n}\n\n/**\n * A type representing a function that resolves a {@link Promise}.\n *\n * @typeParam T - The type of the value.\n */\nexport type PromiseResolve<T> = undefined extends T ? (value?: PromiseLike<T> | T) => void\n  : (value: PromiseLike<T> | T) => void;\n\n/**\n * Options for {@link retryWithTimeout}.\n */\nexport interface RetryOptions {\n  /**\n   * A abort signal to cancel the retry operation.\n   */\n  readonly abortSignal?: AbortSignal;\n\n  /**\n   * A delay in milliseconds between retry attempts.\n   *\n   * @default `100`\n   */\n  readonly retryDelayInMilliseconds?: number;\n\n  /**\n   * Whether to retry the function on error.\n   *\n   * @default `false`\n   */\n  readonly shouldRetryOnError?: boolean;\n\n  /**\n   * A maximum time in milliseconds to wait before giving up on retrying.\n   *\n   * @default `5000`\n   */\n  readonly timeoutInMilliseconds?: number;\n}\n\n/**\n * Adds an error handler to a {@link Promise} that catches any errors and emits an async error event.\n *\n * @param asyncFunction - The asynchronous function to add an error handler to.\n * @param stackTrace - The stack trace of the source function.\n * @returns A {@link Promise} that resolves when the asynchronous function completes or emits async error event.\n */\nexport async function addErrorHandler(asyncFunction: () => Promise<unknown>, stackTrace?: string): Promise<void> {\n  stackTrace ??= getStackTrace(1);\n  // Capture the ignore context synchronously at schedule time, so a deferred rejection settling after the scope exits is still ignored.\n  const wasScheduledWithinIgnoreContext = isAsyncErrorIgnoreContextActive();\n  try {\n    await asyncFunction();\n  } catch (asyncError) {\n    const wrappedError = new CustomStackTraceError({\n      cause: asyncError,\n      message: ASYNC_WRAPPER_ERROR_MESSAGE,\n      stackTrace\n    });\n    if (handleSilentError(wrappedError)) {\n      return;\n    }\n    emitAsyncErrorEvent(wrappedError, wasScheduledWithinIgnoreContext);\n  }\n}\n\n/**\n * Filters an array asynchronously, keeping only the elements that satisfy the provided predicate function.\n *\n * @typeParam T - The type of elements in the input array.\n * @param array - The array to filter.\n * @param predicate - The predicate function to test each element.\n * @returns A {@link Promise} that resolves with an array of elements that satisfy the predicate function.\n */\nexport async function asyncFilter<T>(array: T[], predicate: (value: T, index: number, array: T[]) => Promisable<boolean>): Promise<T[]> {\n  const ans: T[] = [];\n\n  const length = array.length;\n  for (let index = 0; index < length; index++) {\n    if (!Object.hasOwn(array, index)) {\n      continue;\n    }\n\n    const item = array[index] as T;\n    if (await predicate(item, index, array)) {\n      ans.push(item);\n    }\n  }\n\n  return ans;\n}\n\n/**\n * Filters an array asynchronously in place, keeping only the elements that satisfy the provided predicate function.\n *\n * @typeParam T - The type of elements in the input array.\n * @param array - The array to filter.\n * @param predicate - The predicate function to test each element.\n * @returns A {@link Promise} that resolves when the array is filtered.\n */\nexport async function asyncFilterInPlace<T>(array: T[], predicate: (value: T, index: number, array: T[]) => Promisable<boolean>): Promise<void> {\n  const length = array.length;\n  let writeIndex = 0;\n  for (let readIndex = 0; readIndex < length; readIndex++) {\n    if (!Object.hasOwn(array, readIndex)) {\n      continue;\n    }\n\n    const current = array[readIndex] as T;\n    if (await predicate(current, readIndex, array)) {\n      // eslint-disable-next-line require-atomic-updates -- Yes, it is a potential race condition, but I don't an elegant way to fix it.\n      array[writeIndex++] = current;\n    }\n  }\n  array.length = writeIndex;\n}\n\n/**\n * Maps over an array asynchronously, applying the provided callback function to each element, and then flattens the results into a single array.\n *\n * @typeParam T - The type of elements in the input array.\n * @typeParam U - The type of elements in the output array.\n * @param array - The array to map over and flatten.\n * @param callback - The callback function to apply to each element.\n * @returns A {@link Promise} that resolves with a flattened array of the results of the callback function.\n */\nexport async function asyncFlatMap<T, U>(array: T[], callback: (value: T, index: number, array: T[]) => Promisable<U[]>): Promise<U[]> {\n  const nestedResults = await asyncMap(array, callback);\n  return nestedResults.flat();\n}\n\n/**\n * Maps over an array asynchronously, applying the provided callback function to each element.\n *\n * @typeParam T - The type of elements in the input array.\n * @typeParam U - The type of elements in the output array.\n * @param array - The array to map over.\n * @param callback - The callback function to apply to each element.\n * @returns A {@link Promise} that resolves with an array of the results of the callback function.\n */\nexport async function asyncMap<T, U>(array: T[], callback: (value: T, index: number, array: T[]) => Promisable<U>): Promise<U[]> {\n  // eslint-disable-next-line unicorn/no-array-callback-reference -- Passing `callback` straight through is the contract: it is declared as `(value, index, array)` so that it receives exactly what `Array#map` supplies. Wrapping it to take only the value would quietly stop forwarding the other two.\n  return await promiseAllSequentially(array.map(callback));\n}\n\n/**\n * Converts an asynchronous function to a synchronous one by automatically handling the Promise rejection.\n *\n * @typeParam Arguments - The types of the arguments the function accepts.\n * @param asyncFunction - The asynchronous function to convert.\n * @param stackTrace - The stack trace of the source function.\n * @returns A function that wraps the asynchronous function in a synchronous interface.\n */\nexport function convertAsyncToSync<Arguments extends unknown[]>(asyncFunction: GenericAsyncFunction<Arguments>, stackTrace?: string): GenericVoidFunction<Arguments> {\n  const outerStackTrace = stackTrace ?? getStackTrace(1);\n  return (...$arguments: Arguments): void => {\n    const innerStackTrace = getStackTrace(1);\n    // Built per call: appending to the captured trace would grow it by one marker on every invocation.\n    const callStackTrace = `${outerStackTrace}\\n    at --- convertAsyncToSync --- (0)\\n${innerStackTrace}`;\n    invokeAsyncSafely(() => asyncFunction(...$arguments), callStackTrace);\n  };\n}\n\n/**\n * Converts a synchronous function to an asynchronous one by wrapping it in a {@link Promise}.\n *\n * @typeParam Arguments - The types of the arguments the function accepts.\n * @typeParam Result - The type of the function's return value.\n * @param syncFunction - The synchronous function to convert.\n * @returns A function that wraps the synchronous function in an asynchronous interface.\n */\nexport function convertSyncToAsync<Arguments extends unknown[], Result>(syncFunction: GenericFunction<Arguments, Result>): GenericAsyncFunction<Arguments, Result> {\n  return async (...$arguments: Arguments): Promise<Result> => {\n    await noopAsync();\n    return syncFunction(...$arguments);\n  };\n}\n\n/**\n * Handles a silent error.\n *\n * @param error - The error to handle.\n * @returns Whether the error is a silent error.\n */\n// eslint-disable-next-line unicorn/consistent-boolean-name -- The name states the action; the boolean only reports whether the error was handled.\nexport function handleSilentError(error: unknown): boolean {\n  let cause = error;\n  while (!(cause instanceof SilentError)) {\n    if (!(cause instanceof Error)) {\n      return false;\n    }\n\n    cause = cause.cause;\n  }\n\n  getLibDebugger('Async:handleSilentError')(error);\n  return true;\n}\n/**\n * Ignores an error that is thrown by an asynchronous function.\n *\n * @param promise - The promise to ignore the error of.\n * @param fallbackValue - Always `undefined`.\n * @returns A {@link Promise} that resolves when the asynchronous function completes or fails.\n */\nexport async function ignoreError(promise: Promise<unknown>, fallbackValue?: undefined): Promise<void>;\n/**\n * Invokes an asynchronous function and returns a fallback value if an error is thrown.\n *\n * @typeParam T - The type of the value returned by the asynchronous function.\n * @param promise - The promise to ignore the error of.\n * @param fallbackValue - The value to return if an error is thrown.\n * @returns A {@link Promise} that resolves with the value returned by the asynchronous function or the fallback value if an error is thrown.\n */\nexport async function ignoreError<T>(promise: Promise<T>, fallbackValue: T): Promise<T>;\n/**\n * Ignores an error that is thrown by an asynchronous function.\n *\n * @typeParam T - The type of the value returned by the asynchronous function.\n * @param promise - The promise to ignore the error of.\n * @param fallbackValue - The value to return if an error is thrown.\n * @returns A {@link Promise} that resolves with the value returned by the asynchronous function or the fallback value if an error is thrown.\n */\nexport async function ignoreError<T>(promise: Promise<T>, fallbackValue?: T): Promise<T | void> {\n  const ignoreErrorDebugger = getLibDebugger('Async:ignoreError');\n  const stackTrace = getStackTrace(1);\n  try {\n    return await promise;\n  } catch (error) {\n    ignoreErrorDebugger(\n      'Ignored error',\n      new CustomStackTraceError({\n        cause: error,\n        message: 'Ignored error',\n        stackTrace\n      })\n    );\n    return fallbackValue;\n  }\n}\n\n/**\n * Invokes a {@link Promise} and safely handles any errors by catching them and emitting an async error event.\n *\n * @param asyncFunction - The asynchronous function to invoke safely.\n * @param stackTrace - The stack trace of the source function.\n */\nexport function invokeAsyncSafely(asyncFunction: () => Promisable<unknown>, stackTrace?: string): void {\n  stackTrace ??= getStackTrace(1);\n\n  let result: unknown;\n  try {\n    result = asyncFunction();\n  } catch (error) {\n    // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors -- Re-rejecting the original caught error as-is.\n    notifyAsyncOperationStarted(addErrorHandler(() => Promise.reject(error), stackTrace));\n  }\n  if (result instanceof Promise) {\n    notifyAsyncOperationStarted(addErrorHandler(() => result, stackTrace));\n  }\n}\n\n/**\n * Invokes an asynchronous function after a delay.\n *\n * @param params - The parameters for the function.\n */\nexport function invokeAsyncSafelyAfterDelay(params: InvokeAsyncSafelyAfterDelayParams): void {\n  const {\n    asyncFunction,\n    delayInMilliseconds = 0\n  } = params;\n  const abortSignal = params.abortSignal ?? abortSignalNever();\n  abortSignal.throwIfAborted();\n  const stackTrace = params.stackTrace ?? getStackTrace(1);\n  invokeAsyncSafely(async () => {\n    await sleep({ abortSignal, milliseconds: delayInMilliseconds, shouldThrowOnAbort: true });\n    await asyncFunction(abortSignal);\n  }, stackTrace);\n}\n\n/**\n * Executes async functions sequentially.\n *\n * @typeParam T - The type of the value.\n * @param asyncFns - The async functions to execute sequentially.\n * @returns A {@link Promise} that resolves with an array of the results of the async functions.\n */\nexport async function promiseAllAsyncFnsSequentially<T>(asyncFns: (() => Promisable<T>)[]): Promise<T[]> {\n  const results: T[] = [];\n  for (const asyncFunction of asyncFns) {\n    results.push(await asyncFunction());\n  }\n  return results;\n}\n\n/**\n * Executes promises sequentially.\n *\n * @typeParam T - The type of the value.\n * @param promises - The promises to execute sequentially.\n * @returns A {@link Promise} that resolves with an array of the results of the promises.\n */\nexport async function promiseAllSequentially<T>(promises: Promisable<T>[]): Promise<T[]> {\n  return await promiseAllAsyncFnsSequentially(promises.map((promise) => () => promise));\n}\n\nconst terminateRetryErrors = new WeakSet<Error>();\n\n/**\n * Options for {@link retryWithTimeout}.\n */\nexport interface RetryWithTimeoutParams {\n  /**\n   * The function to handle the timeout.\n   *\n   * @param context - The timeout context.\n   */\n  readonly onTimeout?: (context: TimeoutContext) => void;\n\n  /**\n   * The function to execute.\n   *\n   * @param abortSignal - The abort signal to listen to.\n   * @returns The result of the function.\n   */\n  readonly operationFunction: (abortSignal: AbortSignal) => Promisable<boolean>;\n\n  /**\n   * The name of the operation.\n   *\n   * @default `''`\n   */\n  readonly operationName?: string;\n\n  /**\n   * The retry options.\n   */\n  readonly retryOptions?: RetryOptions;\n\n  /**\n   * The stack trace of the source function.\n   */\n  readonly stackTrace?: string;\n}\n\n/**\n * Options for {@link runWithTimeout}.\n *\n * @typeParam Result - The type of the result returned by the operation function.\n */\nexport interface RunWithTimeoutParams<Result> {\n  /**\n   * The context of the function.\n   */\n  readonly context?: unknown;\n\n  /**\n   * The function to handle the timeout.\n   *\n   * @param context - The timeout context.\n   */\n  readonly onTimeout?: (context: TimeoutContext) => void;\n\n  /**\n   * The operation function to execute.\n   *\n   * @param abortSignal - The abort signal to listen to.\n   * @returns The result of the function.\n   */\n  readonly operationFunction: (abortSignal: AbortSignal) => Promisable<Result>;\n\n  /**\n   * The name of the operation.\n   *\n   * @default `''`\n   */\n  readonly operationName?: string;\n\n  /**\n   * The stack trace of the source function.\n   */\n  readonly stackTrace?: string | undefined;\n\n  /**\n   * The maximum time to wait in milliseconds.\n   */\n  readonly timeoutInMilliseconds: number;\n}\n\n/**\n * Parameters for {@link sleep}.\n */\nexport interface SleepParams {\n  /**\n   * The abort signal to listen to.\n   */\n  readonly abortSignal?: AbortSignal;\n\n  /**\n   * The time to wait in milliseconds.\n   */\n  readonly milliseconds: number;\n\n  /**\n   * Whether to throw an error if the abort signal is aborted.\n   *\n   * @default `false`\n   */\n  readonly shouldThrowOnAbort?: boolean;\n}\n\n/**\n * Context provided to the timeout handler.\n */\nexport interface TimeoutContext {\n  /**\n   * The duration in milliseconds since the operation started.\n   */\n  readonly duration: number;\n  /**\n   * Registers a callback to be invoked when the operation completes.\n   *\n   * @param callback - The function to call when the operation completes.\n   */\n  readonly onOperationCompleted: (callback: () => void) => void;\n  /**\n   * The name of the operation.\n   */\n  readonly operationName: string;\n  /**\n   * Terminates the operation that timed out.\n   */\n  readonly terminateOperation: () => void;\n}\n\n/**\n * Parameters for {@link timeout}.\n */\nexport interface TimeoutParams {\n  /**\n   * The abort signal to listen to.\n   */\n  readonly abortSignal?: AbortSignal;\n\n  /**\n   * Whether to throw an error if the abort signal is aborted.\n   *\n   * @default `false`\n   */\n  readonly shouldThrowOnAbort?: boolean;\n\n  /**\n   * The timeout period in milliseconds.\n   */\n  readonly timeoutInMilliseconds: number;\n}\n\n/**\n * Chains a promise with another promise.\n *\n * @param chainPromise - Represents the chained promise.\n * @param promisableFunction - The function to chain.\n * @returns Chained promise or `null` if no async logic is chained.\n */\nexport function chain(chainPromise: null | Promise<void>, promisableFunction: () => null | Promisable<void>): null | Promise<void> {\n  let nextChainPromise = chainPromise;\n  if (chainPromise) {\n    nextChainPromise = chainPromise.then(() => promisableFunction() ?? undefined);\n  } else {\n    const promisable = promisableFunction();\n    if (promisable) {\n      nextChainPromise = promisable instanceof Promise ? promisable as Promise<void> : Promise.resolve(promisable);\n    }\n  }\n\n  nextChainPromise?.catch(noop);\n  return nextChainPromise;\n}\n\n/**\n * Gets whether a {@link runWithTimeout} call without its own `onTimeout` terminates the operation when it times out.\n *\n * @deprecated Use {@link getTerminateOnTimeoutDebugSwitch}`().isEnabled()`.\n *\n * @returns `true` (the default) if a timed-out operation is terminated, `false` if it is left running.\n */\nexport function isTerminationOnTimeoutEnabled(): boolean {\n  return getTerminateOnTimeoutDebugSwitch().isEnabled();\n}\n\n/**\n * Marks an error to terminate retry logic.\n *\n * @param error - The error to mark to terminate retry logic.\n */\nexport function marksAsTerminateRetry(error: Error): void {\n  terminateRetryErrors.add(error);\n}\n\n/**\n * An async function that never ends.\n *\n * @returns A {@link Promise} that never resolves.\n */\nexport async function neverEnds(): Promise<never> {\n  await new Promise(() => {\n    noop();\n  });\n  /* v8 ignore start -- Exhaustive switch guard; the await above never resolves. */\n  assert(false, 'Should never happen');\n  /* v8 ignore stop */\n}\n\n/**\n * Gets the next tick.\n *\n * @returns A promise that resolves when the next tick is available.\n */\nexport async function nextTickAsync(): Promise<void> {\n  return new Promise((resolve) => {\n    queueMicrotask(() => {\n      resolve();\n    });\n  });\n}\n\n/**\n * Converts to native promisable, converting {@link PromiseLike} (aka Thenable) to a native {@link Promise}.\n *\n * @typeParam T - The type of the value.\n * @param promisable - The promisable to normalize.\n * @returns The value itself or a native {@link Promise} if the value is a {@link PromiseLike}.\n */\nexport function normalizePromisable<T>(promisable: Promisable<T>): Promise<T> | T {\n  if (!promisable) {\n    return promisable;\n  }\n\n  if (promisable instanceof Promise) {\n    return promisable as Promise<T>;\n  }\n\n  return (promisable as Partial<PromiseLike<T>>).then ? Promise.resolve(promisable) : (promisable as T);\n}\n\n/**\n * Gets the next queue microtask.\n *\n * @returns A promise that resolves when the next queue microtask is available.\n */\nexport async function queueMicrotaskAsync(): Promise<void> {\n  return new Promise((resolve) => {\n    queueMicrotask(() => {\n      resolve();\n    });\n  });\n}\n\n/**\n * Gets the next request animation frame.\n *\n * @param fallbackTimeoutInMilliseconds - The fallback timeout in milliseconds to resolve the promise if `requestAnimationFrame` does not fire (e.g. the window is not active).\n *                                        Defaults to `100` milliseconds. Use `0` to disable the fallback.\n * @returns A promise that resolves when the next request animation frame is available (or when the fallback time is reached).\n */\nexport async function requestAnimationFrameAsync(fallbackTimeoutInMilliseconds?: number): Promise<void> {\n  const requestAnimationFrameAsyncPromise = new Promise<void>((resolve) => {\n    window.requestAnimationFrame(() => {\n      resolve();\n    });\n  });\n\n  const DEFAULT_FALLBACK_TIMEOUT_IN_MILLISECONDS = 100;\n  fallbackTimeoutInMilliseconds ??= DEFAULT_FALLBACK_TIMEOUT_IN_MILLISECONDS;\n\n  return Promise.race([requestAnimationFrameAsyncPromise, fallbackTimeoutInMilliseconds > 0 ? sleep({ milliseconds: fallbackTimeoutInMilliseconds }) : neverEnds()]);\n}\n\n/**\n * Retries the provided function until it returns `true` or the timeout is reached.\n *\n * @param params - The parameters for the function.\n * @returns A {@link Promise} that resolves when the function returns `true` or rejects when the timeout is reached.\n */\nexport async function retryWithTimeout(params: RetryWithTimeoutParams): Promise<void> {\n  const retryWithTimeoutDebugger = getLibDebugger('Async:retryWithTimeout');\n  const stackTrace = params.stackTrace ?? getStackTrace(1);\n  const DEFAULT_RETRY_OPTIONS = {\n    // eslint-disable-next-line no-magic-numbers -- Extracting magic number as a constant would be repetitive, as the value is used only once and its name would be the same as the property.\n    retryDelayInMilliseconds: 100,\n    shouldRetryOnError: false,\n    // eslint-disable-next-line no-magic-numbers -- Extracting magic number as a constant would be repetitive, as the value is used only once and its name would be the same as the property.\n    timeoutInMilliseconds: 5000\n  };\n  const fullOptions = { ...DEFAULT_RETRY_OPTIONS, ...params.retryOptions };\n  fullOptions.abortSignal?.throwIfAborted();\n\n  await runWithTimeout(normalizeOptionalProperties<RunWithTimeoutParams<void>>({\n    context: { operationName: params.operationName ?? '', retryFunction: params.operationFunction },\n    onTimeout: params.onTimeout,\n    async operationFunction(abortSignal: AbortSignal): Promise<void> {\n      const combinedAbortSignal = abortSignalAny(fullOptions.abortSignal, abortSignal);\n      combinedAbortSignal.throwIfAborted();\n      let attempt = 0;\n      while (!combinedAbortSignal.aborted) {\n        attempt++;\n        let isSuccess: boolean;\n        try {\n          isSuccess = await params.operationFunction(combinedAbortSignal);\n        } catch (error) {\n          // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- It might changed inside `fn()`. ESLint mistakenly does not recognize it.\n          if (combinedAbortSignal.aborted || !fullOptions.shouldRetryOnError || terminateRetryErrors.has(error as Error)) {\n            throw new CustomStackTraceError({\n              cause: error,\n              message: 'retryWithTimeout failed',\n              stackTrace\n            });\n          }\n          printError(error);\n          isSuccess = false;\n        }\n        if (isSuccess) {\n          printWithStackTrace({\n            $arguments: [{\n              operationFunction: params.operationFunction,\n              operationName: params.operationName ?? ''\n            }],\n            debuggerInstance: retryWithTimeoutDebugger,\n            message: `Retry completed successfully after ${String(attempt)} attempts`,\n            stackTrace\n          });\n          return;\n        }\n\n        printWithStackTrace({\n          $arguments: [{\n            operationFunction: params.operationFunction,\n            operationName: params.operationName ?? ''\n          }],\n          debuggerInstance: retryWithTimeoutDebugger,\n          message: `Retry attempt ${String(attempt)} completed unsuccessfully. Trying again in ${String(fullOptions.retryDelayInMilliseconds)} milliseconds`,\n          stackTrace\n        });\n\n        await sleep({ abortSignal, milliseconds: fullOptions.retryDelayInMilliseconds });\n      }\n    },\n    operationName: params.operationName ?? '',\n    stackTrace,\n    timeoutInMilliseconds: fullOptions.timeoutInMilliseconds\n  }));\n}\n\n/**\n * Executes a function with a timeout. If the function does not complete within the specified time, it is considered to have timed out.\n *\n * Without an `onTimeout`, a timed-out function is terminated, unless the {@link getTerminateOnTimeoutDebugSwitch} debug switch is off,\n * in which case it is allowed to run indefinitely.\n *\n * @typeParam Result - The type of the result from the asynchronous function.\n * @param params - The parameters for the function.\n * @returns A {@link Promise} that resolves with the result of the asynchronous function or rejects if it times out.\n */\nexport async function runWithTimeout<Result>(params: RunWithTimeoutParams<Result>): Promise<Result> {\n  const stackTrace = params.stackTrace ?? getStackTrace(1);\n  const startTime = performance.now();\n\n  const runAbortController = new AbortController();\n  const timeoutAbortController = new AbortController();\n\n  let result: null | Result = null;\n  let hasResult = false;\n  let isCompleted = false;\n  const runWithTimeoutDebugger = getLibDebugger('Async:runWithTimeout');\n  const onTimeout = params.onTimeout ?? defaultOnTimeout;\n\n  await Promise.race([run(), innerTimeout()]);\n  // The result is only valid if the run finished on its own. When the timeout terminated it, the\n  // operation might still resolve afterwards (e.g. a retry loop that exits on abort), but that value\n  // is past the deadline and must be treated as a failure, not a success.\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- Both might change inside `run()`/`innerTimeout()`. ESLint mistakenly does not recognize it.\n  if (hasResult && !runAbortController.signal.aborted) {\n    return result as Result;\n  }\n\n  throw new CustomStackTraceError({\n    cause: runAbortController.signal.reason,\n    message: 'Run with timeout failed',\n    stackTrace\n  });\n\n  async function run(): Promise<void> {\n    try {\n      result = await params.operationFunction(runAbortController.signal);\n      const duration = Math.trunc(performance.now() - startTime);\n      printWithStackTrace({\n        $arguments: [{\n          context: params.context,\n          operationFunction: params.operationFunction,\n          operationName: params.operationName ?? ''\n        }],\n        debuggerInstance: runWithTimeoutDebugger,\n        message: `Execution time: ${String(duration)} milliseconds`,\n        stackTrace\n      });\n      hasResult = true;\n    } catch (error) {\n      runAbortController.abort(error);\n    } finally {\n      isCompleted = true;\n      timeoutAbortController.abort(new Error('Completed'));\n    }\n  }\n\n  async function innerTimeout(): Promise<void> {\n    await sleep({ abortSignal: timeoutAbortController.signal, milliseconds: params.timeoutInMilliseconds });\n\n    if (isCompleted) {\n      return;\n    }\n    const duration = Math.trunc(performance.now() - startTime);\n    printWithStackTrace({\n      $arguments: [{\n        context: params.context,\n        operationFunction: params.operationFunction,\n        operationName: params.operationName ?? ''\n      }],\n      debuggerInstance: runWithTimeoutDebugger,\n      message: `Timed out after ${String(duration)} milliseconds`,\n      stackTrace\n    });\n\n    const timeoutContext: TimeoutContext = normalizeOptionalProperties<TimeoutContext>({\n      duration,\n      onOperationCompleted(callback) {\n        timeoutAbortController.signal.addEventListener('abort', callback);\n      },\n      operationName: params.operationName ?? '',\n      terminateOperation() {\n        const error = new Error(`Timed out after ${String(duration)} milliseconds`);\n        runAbortController.abort(error);\n        timeoutAbortController.abort(error);\n      }\n    });\n\n    onTimeout(timeoutContext);\n    await waitForAbort(timeoutAbortController.signal);\n  }\n}\n\n/**\n * Gets the next set immediate.\n *\n * @returns A promise that resolves when the next set immediate is available.\n */\nexport async function setImmediateAsync(): Promise<void> {\n  return new Promise((resolve) => {\n    setImmediate(() => {\n      resolve();\n    });\n  });\n}\n\n/**\n * Sets whether a {@link runWithTimeout} call without its own `onTimeout` terminates the operation when it times out.\n *\n * @deprecated Use {@link getTerminateOnTimeoutDebugSwitch}`().setEnabled(isEnabled)`.\n *\n * @param isEnabled - `true` to terminate a timed-out operation, `false` to leave it running.\n */\nexport function setTerminationOnTimeoutEnabled(isEnabled: boolean): void {\n  getTerminateOnTimeoutDebugSwitch().setEnabled(isEnabled);\n}\n\n/**\n * Delays execution for a specified number of milliseconds.\n *\n * @param delay - The time to wait in milliseconds.\n * @returns A {@link Promise} that resolves after the specified delay.\n */\nexport async function setTimeoutAsync(delay?: number): Promise<void> {\n  await new Promise((resolve) => {\n    window.setTimeout(resolve, delay);\n  });\n}\n\n/**\n * Delays execution for a specified number of milliseconds.\n *\n * @param params - The parameters for the function.\n * @returns A {@link Promise} that resolves after the specified delay.\n */\nexport async function sleep(params: SleepParams): Promise<void> {\n  const {\n    abortSignal,\n    milliseconds,\n    shouldThrowOnAbort\n  } = params;\n  await waitForAbort(abortSignalAny(abortSignal, abortSignalTimeout(milliseconds)));\n  if (shouldThrowOnAbort) {\n    abortSignal?.throwIfAborted();\n  }\n}\n\n/**\n * Returns a {@link Promise} that rejects after the specified timeout period.\n *\n * @param params - The parameters for the function.\n * @returns A {@link Promise} that always rejects with a timeout error.\n */\nexport async function timeout(params: TimeoutParams): Promise<never> {\n  const {\n    abortSignal,\n    shouldThrowOnAbort,\n    timeoutInMilliseconds\n  } = params;\n  await sleep(normalizeOptionalProperties<SleepParams>({\n    abortSignal,\n    milliseconds: timeoutInMilliseconds,\n    shouldThrowOnAbort\n  }));\n  throw new Error(`Timed out in ${String(timeoutInMilliseconds)} milliseconds`);\n}\n\n/**\n * Converts an AsyncIterableIterator to an array by consuming all its elements.\n *\n * @typeParam T - The type of elements produced by the AsyncIterableIterator.\n * @param iter - The AsyncIterableIterator to convert.\n * @returns A {@link Promise} that resolves with an array of all the elements in the AsyncIterableIterator.\n */\nexport async function toArray<T>(iter: AsyncIterableIterator<T>): Promise<T[]> {\n  const array: T[] = [];\n  for await (const item of iter) {\n    array.push(item);\n  }\n  return array;\n}\n\nfunction defaultOnTimeout(context: TimeoutContext): void {\n  if (getTerminateOnTimeoutDebugSwitch().isEnabled()) {\n    context.terminateOperation();\n    return;\n  }\n\n  getLibDebugger('Async:runWithTimeout')(\n    `Timeout termination is switched off, so the operation '${context.operationName}' keeps running after ${String(context.duration)} milliseconds`\n  );\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/esm/debug-controller.d.mts

@@ -40,7 +40,7 @@ export interface DebugController {
      *
      * @param namespaces - Single namespace string or array of namespace strings to disable
      */
-    disable: (namespaces: string | string[]) => void;
+    readonly disable: (namespaces: string | string[]) => void;
     /**
      * Enable specific debug namespaces. Note that explicitly disabled
      * namespaces (prefixed with '-') will remain disabled.
@@ -58,7 +58,7 @@ export interface DebugController {
      *
      * @param namespaces - Single namespace string or array of namespace strings to enable
      */
-    enable: (namespaces: string | string[]) => void;
+    readonly enable: (namespaces: string | string[]) => void;
     /**
      * Get currently configured debug namespaces.
      *
@@ -69,7 +69,7 @@ export interface DebugController {
      *
      * @returns Array of enabled and disabled (prefixed with `-`) debug namespaces
      */
-    get: () => string[];
+    readonly get: () => string[];
     /**
      * Set debug namespaces, replacing all previous configurations.
      *
@@ -83,5 +83,5 @@ export interface DebugController {
      *
      * @param namespaces - String or array of namespace patterns
      */
-    set: (namespaces: string | string[]) => void;
+    readonly set: (namespaces: string | string[]) => void;
 }

package/dist/lib/esm/debug-switches.d.mts

@@ -23,13 +23,13 @@ export interface DebugSwitch extends DebugSwitchDefinition {
      *
      * @returns `true` if the switch is on.
      */
-    isEnabled: () => boolean;
+    readonly isEnabled: () => boolean;
     /**
      * Sets the value, notifying the {@link onDebugSwitchChanged} listeners if it changed.
      *
      * @param isEnabled - The new value.
      */
-    setEnabled: (isEnabled: boolean) => void;
+    readonly setEnabled: (isEnabled: boolean) => void;
 }
 /**
  * A change of a debug switch's value, passed to an {@link onDebugSwitchChanged} listener.

package/dist/lib/esm/debug-switches.mjs

@@ -93,4 +93,4 @@ export {
   registerDebugSwitch,
   setDebugSwitch
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/debug-switches.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * A registry of debug switches: named, app-wide booleans that change behavior while debugging.\n *\n * A debug namespace (see `debug.ts`) controls logging only. Behavior that should differ while debugging, such as\n * not terminating an operation paused on a breakpoint, is a debug switch instead, so turning logging on never\n * changes what the code does.\n *\n * The definitions, the values and the change listeners all live in the shared state bag (`typescript-lib-state.ts`)\n * as plain data, so every copy of this library loaded in one realm, such as the copy each Obsidian plugin bundles,\n * sees one value per switch. A tool such as a debug-settings UI lists every registered switch with\n * {@link getDebugSwitches} and needs no change when a library or plugin adds one.\n */\n\nimport type { DisposableEx } from './disposable.ts';\nimport type { ValueWrapper } from './value-wrapper.ts';\n\nimport { CallbackDisposable } from './disposable.ts';\nimport { getTypescriptLibState } from './typescript-lib-state.ts';\n\n/**\n * A handle to a registered debug switch.\n */\nexport interface DebugSwitch extends DebugSwitchDefinition {\n  /**\n   * Gets the current value.\n   *\n   * @returns `true` if the switch is on.\n   */\n  isEnabled: () => boolean;\n\n  /**\n   * Sets the value, notifying the {@link onDebugSwitchChanged} listeners if it changed.\n   *\n   * @param isEnabled - The new value.\n   */\n  setEnabled: (isEnabled: boolean) => void;\n}\n\n/**\n * A change of a debug switch's value, passed to an {@link onDebugSwitchChanged} listener.\n */\nexport interface DebugSwitchChange {\n  /**\n   * The id of the switch that changed.\n   */\n  readonly id: string;\n\n  /**\n   * The new value.\n   */\n  readonly isEnabled: boolean;\n}\n\n/**\n * The listener of {@link onDebugSwitchChanged}.\n */\nexport type DebugSwitchChangeListener = (change: DebugSwitchChange) => void;\n\n/**\n * The definition of a debug switch.\n */\nexport interface DebugSwitchDefinition {\n  /**\n   * What the switch does, for a settings UI.\n   */\n  readonly description: string;\n\n  /**\n   * The unique id, namespaced by the library or plugin that owns the switch, e.g.\n   * `typescript-lib:terminate-on-timeout`.\n   */\n  readonly id: string;\n\n  /**\n   * The value the switch has until something sets it.\n   */\n  readonly isEnabledByDefault: boolean;\n\n  /**\n   * The human-readable name, for a settings UI.\n   */\n  readonly name: string;\n}\n\n// A switch whose value an earlier version of this library kept under its own shared-state key keeps that key, so a\n// copy of that version loaded beside this one still reads and writes the same value.\nconst LEGACY_STATE_KEYS: Readonly<Record<string, string>> = {\n  'typescript-lib:terminate-on-timeout': 'isTerminationOnTimeoutEnabled'\n};\n\nconst TERMINATE_ON_TIMEOUT_DEFINITION: DebugSwitchDefinition = {\n  description: 'Terminate an operation that times out. Switch it off so an operation paused on a breakpoint keeps running.',\n  id: 'typescript-lib:terminate-on-timeout',\n  isEnabledByDefault: true,\n  name: 'Terminate operations on timeout'\n};\n\n// This library's own switches, always registered, so a settings UI lists them before any code that reads them runs.\nconst BUILT_IN_DEFINITIONS: readonly DebugSwitchDefinition[] = [TERMINATE_ON_TIMEOUT_DEFINITION];\n\n/**\n * Gets a registered debug switch.\n *\n * @param id - The id of the switch.\n * @returns The switch, or `undefined` if no switch with that id is registered.\n */\nexport function getDebugSwitch(id: string): DebugSwitch | undefined {\n  const definition = getDefinitions().get(id);\n  return definition ? createHandle(definition) : undefined;\n}\n\n/**\n * Gets every registered debug switch, sorted by id.\n *\n * @returns The registered switches.\n */\nexport function getDebugSwitches(): DebugSwitch[] {\n  return [...getDefinitions().values()]\n    .sort((a, b) => a.id.localeCompare(b.id))\n    .map((definition) => createHandle(definition));\n}\n\n/**\n * Gets the debug switch that decides whether a `runWithTimeout` call without its own `onTimeout` terminates the\n * operation when it times out.\n *\n * Its id is `typescript-lib:terminate-on-timeout` and it is on by default. Switch it off while debugging, so an\n * operation paused on a breakpoint is not terminated under the debugger. The timeout is still logged through the\n * `Async:runWithTimeout` debugger.\n *\n * @returns The debug switch.\n */\nexport function getTerminateOnTimeoutDebugSwitch(): DebugSwitch {\n  return registerDebugSwitch(TERMINATE_ON_TIMEOUT_DEFINITION);\n}\n\n/**\n * Adds a listener called whenever a debug switch's value changes, in any loaded copy of this library.\n *\n * @param listener - The listener.\n * @returns A disposable that removes the listener.\n */\nexport function onDebugSwitchChanged(listener: DebugSwitchChangeListener): DisposableEx {\n  const listeners = getListeners();\n  listeners.add(listener);\n  return new CallbackDisposable({\n    callback(): void {\n      listeners.delete(listener);\n    }\n  });\n}\n\n/**\n * Registers a debug switch.\n *\n * Registering an id again is idempotent: the first definition is kept, and the returned handle reads the same\n * value. A value set with {@link setDebugSwitch} before the switch was registered is kept, not reset to the\n * default.\n *\n * @param definition - The definition of the switch.\n * @returns The handle to the switch.\n */\nexport function registerDebugSwitch(definition: DebugSwitchDefinition): DebugSwitch {\n  const definitions = getDefinitions();\n  let registeredDefinition = definitions.get(definition.id);\n  if (!registeredDefinition) {\n    registeredDefinition = {\n      description: definition.description,\n      id: definition.id,\n      isEnabledByDefault: definition.isEnabledByDefault,\n      name: definition.name\n    };\n    definitions.set(definition.id, registeredDefinition);\n  }\n  return createHandle(registeredDefinition);\n}\n\n/**\n * Sets the value of a debug switch, notifying the {@link onDebugSwitchChanged} listeners if it changed.\n *\n * The switch does not have to be registered yet: the value is kept, and the switch takes it when it registers. That\n * lets a settings store re-apply saved values before every library or plugin that owns a switch has loaded.\n *\n * @param id - The id of the switch.\n * @param isEnabled - The new value.\n */\nexport function setDebugSwitch(id: string, isEnabled: boolean): void {\n  const definition = getDefinitions().get(id);\n  // An unregistered switch with no value yet has no previous value, so its first set counts as a change.\n  const wrapper = getValueWrapper(id, definition?.isEnabledByDefault ?? !isEnabled);\n  if (wrapper.value === isEnabled) {\n    return;\n  }\n  wrapper.value = isEnabled;\n  for (const listener of getListeners()) {\n    listener({ id, isEnabled });\n  }\n}\n\nfunction createHandle(definition: DebugSwitchDefinition): DebugSwitch {\n  return {\n    ...definition,\n    isEnabled(): boolean {\n      return getValueWrapper(definition.id, definition.isEnabledByDefault).value;\n    },\n    setEnabled(isEnabled: boolean): void {\n      setDebugSwitch(definition.id, isEnabled);\n    }\n  };\n}\n\nfunction getDefinitions(): Map<string, DebugSwitchDefinition> {\n  const definitions = getTypescriptLibState('debugSwitchDefinitions', new Map<string, DebugSwitchDefinition>()).value;\n  // Checked on every read, because the map may have been created by a copy of this library that predates a switch.\n  for (const definition of BUILT_IN_DEFINITIONS) {\n    if (!definitions.has(definition.id)) {\n      definitions.set(definition.id, definition);\n    }\n  }\n  return definitions;\n}\n\nfunction getListeners(): Set<DebugSwitchChangeListener> {\n  return getTypescriptLibState('debugSwitchListeners', new Set<DebugSwitchChangeListener>()).value;\n}\n\nfunction getValueWrapper(id: string, isEnabledByDefault: boolean): ValueWrapper<boolean> {\n  return getTypescriptLibState(LEGACY_STATE_KEYS[id] ?? `debugSwitch:${id}`, isEnabledByDefault);\n}\n"],
  "mappings": ";;;;;AAkBA,SAAS,0BAA0B;AACnC,SAAS,6BAA6B;AAqEtC,MAAM,oBAAsD;AAAA,EAC1D,uCAAuC;AACzC;AAEA,MAAM,kCAAyD;AAAA,EAC7D,aAAa;AAAA,EACb,IAAI;AAAA,EACJ,oBAAoB;AAAA,EACpB,MAAM;AACR;AAGA,MAAM,uBAAyD,CAAC,+BAA+B;AAQxF,SAAS,eAAe,IAAqC;AAClE,QAAM,aAAa,eAAe,EAAE,IAAI,EAAE;AAC1C,SAAO,aAAa,aAAa,UAAU,IAAI;AACjD;AAOO,SAAS,mBAAkC;AAChD,SAAO,CAAC,GAAG,eAAe,EAAE,OAAO,CAAC,EACjC,KAAK,CAAC,GAAG,MAAM,EAAE,GAAG,cAAc,EAAE,EAAE,CAAC,EACvC,IAAI,CAAC,eAAe,aAAa,UAAU,CAAC;AACjD;AAYO,SAAS,mCAAgD;AAC9D,SAAO,oBAAoB,+BAA+B;AAC5D;AAQO,SAAS,qBAAqB,UAAmD;AACtF,QAAM,YAAY,aAAa;AAC/B,YAAU,IAAI,QAAQ;AACtB,SAAO,IAAI,mBAAmB;AAAA,IAC5B,WAAiB;AACf,gBAAU,OAAO,QAAQ;AAAA,IAC3B;AAAA,EACF,CAAC;AACH;AAYO,SAAS,oBAAoB,YAAgD;AAClF,QAAM,cAAc,eAAe;AACnC,MAAI,uBAAuB,YAAY,IAAI,WAAW,EAAE;AACxD,MAAI,CAAC,sBAAsB;AACzB,2BAAuB;AAAA,MACrB,aAAa,WAAW;AAAA,MACxB,IAAI,WAAW;AAAA,MACf,oBAAoB,WAAW;AAAA,MAC/B,MAAM,WAAW;AAAA,IACnB;AACA,gBAAY,IAAI,WAAW,IAAI,oBAAoB;AAAA,EACrD;AACA,SAAO,aAAa,oBAAoB;AAC1C;AAWO,SAAS,eAAe,IAAY,WAA0B;AACnE,QAAM,aAAa,eAAe,EAAE,IAAI,EAAE;AAE1C,QAAM,UAAU,gBAAgB,IAAI,YAAY,sBAAsB,CAAC,SAAS;AAChF,MAAI,QAAQ,UAAU,WAAW;AAC/B;AAAA,EACF;AACA,UAAQ,QAAQ;AAChB,aAAW,YAAY,aAAa,GAAG;AACrC,aAAS,EAAE,IAAI,UAAU,CAAC;AAAA,EAC5B;AACF;AAEA,SAAS,aAAa,YAAgD;AACpE,SAAO;AAAA,IACL,GAAG;AAAA,IACH,YAAqB;AACnB,aAAO,gBAAgB,WAAW,IAAI,WAAW,kBAAkB,EAAE;AAAA,IACvE;AAAA,IACA,WAAW,WAA0B;AACnC,qBAAe,WAAW,IAAI,SAAS;AAAA,IACzC;AAAA,EACF;AACF;AAEA,SAAS,iBAAqD;AAC5D,QAAM,cAAc,sBAAsB,0BAA0B,oBAAI,IAAmC,CAAC,EAAE;AAE9G,aAAW,cAAc,sBAAsB;AAC7C,QAAI,CAAC,YAAY,IAAI,WAAW,EAAE,GAAG;AACnC,kBAAY,IAAI,WAAW,IAAI,UAAU;AAAA,IAC3C;AAAA,EACF;AACA,SAAO;AACT;AAEA,SAAS,eAA+C;AACtD,SAAO,sBAAsB,wBAAwB,oBAAI,IAA+B,CAAC,EAAE;AAC7F;AAEA,SAAS,gBAAgB,IAAY,oBAAoD;AACvF,SAAO,sBAAsB,kBAAkB,EAAE,KAAK,eAAe,EAAE,IAAI,kBAAkB;AAC/F;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/debug-switches.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * A registry of debug switches: named, app-wide booleans that change behavior while debugging.\n *\n * A debug namespace (see `debug.ts`) controls logging only. Behavior that should differ while debugging, such as\n * not terminating an operation paused on a breakpoint, is a debug switch instead, so turning logging on never\n * changes what the code does.\n *\n * The definitions, the values and the change listeners all live in the shared state bag (`typescript-lib-state.ts`)\n * as plain data, so every copy of this library loaded in one realm, such as the copy each Obsidian plugin bundles,\n * sees one value per switch. A tool such as a debug-settings UI lists every registered switch with\n * {@link getDebugSwitches} and needs no change when a library or plugin adds one.\n */\n\nimport type { DisposableEx } from './disposable.ts';\nimport type { ValueWrapper } from './value-wrapper.ts';\n\nimport { CallbackDisposable } from './disposable.ts';\nimport { getTypescriptLibState } from './typescript-lib-state.ts';\n\n/**\n * A handle to a registered debug switch.\n */\nexport interface DebugSwitch extends DebugSwitchDefinition {\n  /**\n   * Gets the current value.\n   *\n   * @returns `true` if the switch is on.\n   */\n  readonly isEnabled: () => boolean;\n\n  /**\n   * Sets the value, notifying the {@link onDebugSwitchChanged} listeners if it changed.\n   *\n   * @param isEnabled - The new value.\n   */\n  readonly setEnabled: (isEnabled: boolean) => void;\n}\n\n/**\n * A change of a debug switch's value, passed to an {@link onDebugSwitchChanged} listener.\n */\nexport interface DebugSwitchChange {\n  /**\n   * The id of the switch that changed.\n   */\n  readonly id: string;\n\n  /**\n   * The new value.\n   */\n  readonly isEnabled: boolean;\n}\n\n/**\n * The listener of {@link onDebugSwitchChanged}.\n */\nexport type DebugSwitchChangeListener = (change: DebugSwitchChange) => void;\n\n/**\n * The definition of a debug switch.\n */\nexport interface DebugSwitchDefinition {\n  /**\n   * What the switch does, for a settings UI.\n   */\n  readonly description: string;\n\n  /**\n   * The unique id, namespaced by the library or plugin that owns the switch, e.g.\n   * `typescript-lib:terminate-on-timeout`.\n   */\n  readonly id: string;\n\n  /**\n   * The value the switch has until something sets it.\n   */\n  readonly isEnabledByDefault: boolean;\n\n  /**\n   * The human-readable name, for a settings UI.\n   */\n  readonly name: string;\n}\n\n// A switch whose value an earlier version of this library kept under its own shared-state key keeps that key, so a\n// copy of that version loaded beside this one still reads and writes the same value.\nconst LEGACY_STATE_KEYS: Readonly<Record<string, string>> = {\n  'typescript-lib:terminate-on-timeout': 'isTerminationOnTimeoutEnabled'\n};\n\nconst TERMINATE_ON_TIMEOUT_DEFINITION: DebugSwitchDefinition = {\n  description: 'Terminate an operation that times out. Switch it off so an operation paused on a breakpoint keeps running.',\n  id: 'typescript-lib:terminate-on-timeout',\n  isEnabledByDefault: true,\n  name: 'Terminate operations on timeout'\n};\n\n// This library's own switches, always registered, so a settings UI lists them before any code that reads them runs.\nconst BUILT_IN_DEFINITIONS: readonly DebugSwitchDefinition[] = [TERMINATE_ON_TIMEOUT_DEFINITION];\n\n/**\n * Gets a registered debug switch.\n *\n * @param id - The id of the switch.\n * @returns The switch, or `undefined` if no switch with that id is registered.\n */\nexport function getDebugSwitch(id: string): DebugSwitch | undefined {\n  const definition = getDefinitions().get(id);\n  return definition ? createHandle(definition) : undefined;\n}\n\n/**\n * Gets every registered debug switch, sorted by id.\n *\n * @returns The registered switches.\n */\nexport function getDebugSwitches(): DebugSwitch[] {\n  return [...getDefinitions().values()]\n    .sort((a, b) => a.id.localeCompare(b.id))\n    .map((definition) => createHandle(definition));\n}\n\n/**\n * Gets the debug switch that decides whether a `runWithTimeout` call without its own `onTimeout` terminates the\n * operation when it times out.\n *\n * Its id is `typescript-lib:terminate-on-timeout` and it is on by default. Switch it off while debugging, so an\n * operation paused on a breakpoint is not terminated under the debugger. The timeout is still logged through the\n * `Async:runWithTimeout` debugger.\n *\n * @returns The debug switch.\n */\nexport function getTerminateOnTimeoutDebugSwitch(): DebugSwitch {\n  return registerDebugSwitch(TERMINATE_ON_TIMEOUT_DEFINITION);\n}\n\n/**\n * Adds a listener called whenever a debug switch's value changes, in any loaded copy of this library.\n *\n * @param listener - The listener.\n * @returns A disposable that removes the listener.\n */\nexport function onDebugSwitchChanged(listener: DebugSwitchChangeListener): DisposableEx {\n  const listeners = getListeners();\n  listeners.add(listener);\n  return new CallbackDisposable({\n    callback(): void {\n      listeners.delete(listener);\n    }\n  });\n}\n\n/**\n * Registers a debug switch.\n *\n * Registering an id again is idempotent: the first definition is kept, and the returned handle reads the same\n * value. A value set with {@link setDebugSwitch} before the switch was registered is kept, not reset to the\n * default.\n *\n * @param definition - The definition of the switch.\n * @returns The handle to the switch.\n */\nexport function registerDebugSwitch(definition: DebugSwitchDefinition): DebugSwitch {\n  const definitions = getDefinitions();\n  let registeredDefinition = definitions.get(definition.id);\n  if (!registeredDefinition) {\n    registeredDefinition = {\n      description: definition.description,\n      id: definition.id,\n      isEnabledByDefault: definition.isEnabledByDefault,\n      name: definition.name\n    };\n    definitions.set(definition.id, registeredDefinition);\n  }\n  return createHandle(registeredDefinition);\n}\n\n/**\n * Sets the value of a debug switch, notifying the {@link onDebugSwitchChanged} listeners if it changed.\n *\n * The switch does not have to be registered yet: the value is kept, and the switch takes it when it registers. That\n * lets a settings store re-apply saved values before every library or plugin that owns a switch has loaded.\n *\n * @param id - The id of the switch.\n * @param isEnabled - The new value.\n */\nexport function setDebugSwitch(id: string, isEnabled: boolean): void {\n  const definition = getDefinitions().get(id);\n  // An unregistered switch with no value yet has no previous value, so its first set counts as a change.\n  const wrapper = getValueWrapper(id, definition?.isEnabledByDefault ?? !isEnabled);\n  if (wrapper.value === isEnabled) {\n    return;\n  }\n  wrapper.value = isEnabled;\n  for (const listener of getListeners()) {\n    listener({ id, isEnabled });\n  }\n}\n\nfunction createHandle(definition: DebugSwitchDefinition): DebugSwitch {\n  return {\n    ...definition,\n    isEnabled(): boolean {\n      return getValueWrapper(definition.id, definition.isEnabledByDefault).value;\n    },\n    setEnabled(isEnabled: boolean): void {\n      setDebugSwitch(definition.id, isEnabled);\n    }\n  };\n}\n\nfunction getDefinitions(): Map<string, DebugSwitchDefinition> {\n  const definitions = getTypescriptLibState('debugSwitchDefinitions', new Map<string, DebugSwitchDefinition>()).value;\n  // Checked on every read, because the map may have been created by a copy of this library that predates a switch.\n  for (const definition of BUILT_IN_DEFINITIONS) {\n    if (!definitions.has(definition.id)) {\n      definitions.set(definition.id, definition);\n    }\n  }\n  return definitions;\n}\n\nfunction getListeners(): Set<DebugSwitchChangeListener> {\n  return getTypescriptLibState('debugSwitchListeners', new Set<DebugSwitchChangeListener>()).value;\n}\n\nfunction getValueWrapper(id: string, isEnabledByDefault: boolean): ValueWrapper<boolean> {\n  return getTypescriptLibState(LEGACY_STATE_KEYS[id] ?? `debugSwitch:${id}`, isEnabledByDefault);\n}\n"],
  "mappings": ";;;;;AAkBA,SAAS,0BAA0B;AACnC,SAAS,6BAA6B;AAqEtC,MAAM,oBAAsD;AAAA,EAC1D,uCAAuC;AACzC;AAEA,MAAM,kCAAyD;AAAA,EAC7D,aAAa;AAAA,EACb,IAAI;AAAA,EACJ,oBAAoB;AAAA,EACpB,MAAM;AACR;AAGA,MAAM,uBAAyD,CAAC,+BAA+B;AAQxF,SAAS,eAAe,IAAqC;AAClE,QAAM,aAAa,eAAe,EAAE,IAAI,EAAE;AAC1C,SAAO,aAAa,aAAa,UAAU,IAAI;AACjD;AAOO,SAAS,mBAAkC;AAChD,SAAO,CAAC,GAAG,eAAe,EAAE,OAAO,CAAC,EACjC,KAAK,CAAC,GAAG,MAAM,EAAE,GAAG,cAAc,EAAE,EAAE,CAAC,EACvC,IAAI,CAAC,eAAe,aAAa,UAAU,CAAC;AACjD;AAYO,SAAS,mCAAgD;AAC9D,SAAO,oBAAoB,+BAA+B;AAC5D;AAQO,SAAS,qBAAqB,UAAmD;AACtF,QAAM,YAAY,aAAa;AAC/B,YAAU,IAAI,QAAQ;AACtB,SAAO,IAAI,mBAAmB;AAAA,IAC5B,WAAiB;AACf,gBAAU,OAAO,QAAQ;AAAA,IAC3B;AAAA,EACF,CAAC;AACH;AAYO,SAAS,oBAAoB,YAAgD;AAClF,QAAM,cAAc,eAAe;AACnC,MAAI,uBAAuB,YAAY,IAAI,WAAW,EAAE;AACxD,MAAI,CAAC,sBAAsB;AACzB,2BAAuB;AAAA,MACrB,aAAa,WAAW;AAAA,MACxB,IAAI,WAAW;AAAA,MACf,oBAAoB,WAAW;AAAA,MAC/B,MAAM,WAAW;AAAA,IACnB;AACA,gBAAY,IAAI,WAAW,IAAI,oBAAoB;AAAA,EACrD;AACA,SAAO,aAAa,oBAAoB;AAC1C;AAWO,SAAS,eAAe,IAAY,WAA0B;AACnE,QAAM,aAAa,eAAe,EAAE,IAAI,EAAE;AAE1C,QAAM,UAAU,gBAAgB,IAAI,YAAY,sBAAsB,CAAC,SAAS;AAChF,MAAI,QAAQ,UAAU,WAAW;AAC/B;AAAA,EACF;AACA,UAAQ,QAAQ;AAChB,aAAW,YAAY,aAAa,GAAG;AACrC,aAAS,EAAE,IAAI,UAAU,CAAC;AAAA,EAC5B;AACF;AAEA,SAAS,aAAa,YAAgD;AACpE,SAAO;AAAA,IACL,GAAG;AAAA,IACH,YAAqB;AACnB,aAAO,gBAAgB,WAAW,IAAI,WAAW,kBAAkB,EAAE;AAAA,IACvE;AAAA,IACA,WAAW,WAA0B;AACnC,qBAAe,WAAW,IAAI,SAAS;AAAA,IACzC;AAAA,EACF;AACF;AAEA,SAAS,iBAAqD;AAC5D,QAAM,cAAc,sBAAsB,0BAA0B,oBAAI,IAAmC,CAAC,EAAE;AAE9G,aAAW,cAAc,sBAAsB;AAC7C,QAAI,CAAC,YAAY,IAAI,WAAW,EAAE,GAAG;AACnC,kBAAY,IAAI,WAAW,IAAI,UAAU;AAAA,IAC3C;AAAA,EACF;AACA,SAAO;AACT;AAEA,SAAS,eAA+C;AACtD,SAAO,sBAAsB,wBAAwB,oBAAI,IAA+B,CAAC,EAAE;AAC7F;AAEA,SAAS,gBAAgB,IAAY,oBAAoD;AACvF,SAAO,sBAAsB,kBAAkB,EAAE,KAAK,eAAe,EAAE,IAAI,kBAAkB;AAC/F;",
  "names": []
}


package/dist/lib/esm/desktop-zip-extractor.d.mts

@@ -61,14 +61,14 @@ export interface ZipExtractionFileSystem {
      * @param options - The {@link ZipExtractionMkdirOptions}.
      * @returns The first directory created, if any.
      */
-    mkdirSync: (path: string, options: ZipExtractionMkdirOptions) => string | undefined;
+    readonly 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;
+    readonly writeFileSync: (path: string, data: Buffer) => void;
 }
 /**
  * The options {@link ZipExtractionFileSystem.mkdirSync} is always called with.

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

@@ -133,4 +133,4 @@ function readEntryData(archive, entry) {
 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": []
}

+//# 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  readonly 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  readonly 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

@@ -79,7 +79,7 @@ export interface AsyncDisposableEx extends AsyncDisposable {
      *
      * @returns A {@link Promise} that resolves once disposal completes.
      */
-    asyncDispose: () => Promise<void>;
+    readonly asyncDispose: () => Promise<void>;
 }
 /**
  * A callback invoked when an {@link AsyncCallbackDisposable} is disposed.
@@ -162,7 +162,7 @@ export interface DisposableEx extends Disposable {
     /**
      * Disposes the object. Delegates to `this[Symbol.dispose]()`.
      */
-    dispose: () => void;
+    readonly dispose: () => void;
 }
 /**
  * A callback invoked when a {@link CallbackDisposable} is disposed.