obsidian-dev-utils 74.0.0 → 74.2.0

package/dist/lib/esm/async.mjs

@@ -132,16 +132,25 @@ async function ignoreError(promise, fallbackValue) {
     return fallbackValue;
   }
 }
+const pendingAsyncOperations = /* @__PURE__ */ new Set();
+let isAsyncOperationTrackingEnabled = false;
+function disableAsyncOperationTracking() {
+  isAsyncOperationTrackingEnabled = false;
+  pendingAsyncOperations.clear();
+}
+function enableAsyncOperationTracking() {
+  isAsyncOperationTrackingEnabled = true;
+}
 function invokeAsyncSafely(asyncFn, stackTrace) {
   stackTrace ??= getStackTrace(1);
   let result;
   try {
     result = asyncFn();
   } catch (error) {
-    void addErrorHandler(() => Promise.reject(error), stackTrace);
+    trackAsyncOperation(addErrorHandler(() => Promise.reject(error), stackTrace));
   }
   if (result instanceof Promise) {
-    void addErrorHandler(() => result, stackTrace);
+    trackAsyncOperation(addErrorHandler(() => result, stackTrace));
   }
 }
 function invokeAsyncSafelyAfterDelay(asyncFn, delayInMilliseconds = 0, stackTrace, abortSignal) {
@@ -163,6 +172,23 @@ async function promiseAllAsyncFnsSequentially(asyncFns) {
 async function promiseAllSequentially(promises) {
   return await promiseAllAsyncFnsSequentially(promises.map((promise) => () => promise));
 }
+async function waitForAllAsyncOperations() {
+  if (!isAsyncOperationTrackingEnabled) {
+    throw new Error("Async operation tracking is not enabled. Call enableAsyncOperationTracking() before waitForAllAsyncOperations().");
+  }
+  while (pendingAsyncOperations.size > 0) {
+    await Promise.allSettled([...pendingAsyncOperations]);
+  }
+}
+function trackAsyncOperation(operation) {
+  if (!isAsyncOperationTrackingEnabled) {
+    return;
+  }
+  pendingAsyncOperations.add(operation);
+  void operation.finally(() => {
+    pendingAsyncOperations.delete(operation);
+  });
+}
 const terminateRetryErrors = /* @__PURE__ */ new WeakSet();
 function chain(chainPromise, promisableFn) {
   let nextChainPromise = chainPromise;
@@ -362,6 +388,8 @@ export {
   chain,
   convertAsyncToSync,
   convertSyncToAsync,
+  disableAsyncOperationTracking,
+  enableAsyncOperationTracking,
   handleSilentError,
   ignoreError,
   invokeAsyncSafely,
@@ -379,6 +407,7 @@ export {
   setTimeoutAsync,
   sleep,
   timeout,
-  toArray
+  toArray,
+  waitForAllAsyncOperations
 };
-//# 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 {\n  getLibDebugger,\n  printWithStackTrace\n} from './debug.ts';\nimport {\n  ASYNC_WRAPPER_ERROR_MESSAGE,\n  CustomStackTraceError,\n  emitAsyncErrorEvent,\n  getStackTrace,\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 * 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  readonly retryDelayInMilliseconds?: number;\n\n  /**\n   * Whether to retry the function on error.\n   */\n  readonly shouldRetryOnError?: boolean;\n\n  /**\n   * A maximum time in milliseconds to wait before giving up on retrying.\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 asyncFn - 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(asyncFn: () => Promise<unknown>, stackTrace?: string): Promise<void> {\n  stackTrace ??= getStackTrace(1);\n  try {\n    await asyncFn();\n  } catch (asyncError) {\n    const wrappedError = new CustomStackTraceError(ASYNC_WRAPPER_ERROR_MESSAGE, stackTrace, asyncError);\n    if (handleSilentError(wrappedError)) {\n      return;\n    }\n    emitAsyncErrorEvent(wrappedError);\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 arr - 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>(arr: T[], predicate: (value: T, index: number, array: T[]) => Promisable<boolean>): Promise<T[]> {\n  const ans: T[] = [];\n\n  const length = arr.length;\n  for (let i = 0; i < length; i++) {\n    if (!Object.hasOwn(arr, i)) {\n      continue;\n    }\n\n    const item = arr[i] as T;\n    if (await predicate(item, i, arr)) {\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 arr - 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>(arr: T[], predicate: (value: T, index: number, array: T[]) => Promisable<boolean>): Promise<void> {\n  const length = arr.length;\n  let writeIndex = 0;\n  for (let readIndex = 0; readIndex < length; readIndex++) {\n    if (!Object.hasOwn(arr, readIndex)) {\n      continue;\n    }\n\n    const current = arr[readIndex] as T;\n    if (await predicate(current, readIndex, arr)) {\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      arr[writeIndex++] = current;\n    }\n  }\n  arr.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 arr - 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>(arr: T[], callback: (value: T, index: number, array: T[]) => Promisable<U[]>): Promise<U[]> {\n  return (await asyncMap(arr, callback)).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 arr - 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>(arr: T[], callback: (value: T, index: number, array: T[]) => Promisable<U>): Promise<U[]> {\n  return await promiseAllSequentially(arr.map(callback));\n}\n\n/**\n * Converts an asynchronous function to a synchronous one by automatically handling the Promise rejection.\n *\n * @typeParam Args - The types of the arguments the function accepts.\n * @param asyncFunc - 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<Args extends unknown[]>(asyncFunc: GenericAsyncFunction<Args>, stackTrace?: string): GenericVoidFunction<Args> {\n  stackTrace ??= getStackTrace(1);\n  return (...args: Args): void => {\n    assertNonNullable(stackTrace);\n    const innerStackTrace = getStackTrace(1);\n    stackTrace = `${stackTrace}\\n    at --- convertAsyncToSync --- (0)\\n${innerStackTrace}`;\n    invokeAsyncSafely(() => asyncFunc(...args), stackTrace);\n  };\n}\n\n/**\n * Converts a synchronous function to an asynchronous one by wrapping it in a {@link Promise}.\n *\n * @typeParam Args - The types of the arguments the function accepts.\n * @typeParam Result - The type of the function's return value.\n * @param syncFn - The synchronous function to convert.\n * @returns A function that wraps the synchronous function in an asynchronous interface.\n */\nexport function convertSyncToAsync<Args extends unknown[], Result>(syncFn: GenericFunction<Args, Result>): GenericAsyncFunction<Args, Result> {\n  return async (...args: Args): Promise<Result> => {\n    await noopAsync();\n    return syncFn(...args);\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 */\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/**\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 (e) {\n    ignoreErrorDebugger('Ignored error', new CustomStackTraceError('Ignored error', stackTrace, e));\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 asyncFn - The asynchronous function to invoke safely.\n * @param stackTrace - The stack trace of the source function.\n */\nexport function invokeAsyncSafely(asyncFn: () => Promisable<unknown>, stackTrace?: string): void {\n  stackTrace ??= getStackTrace(1);\n\n  let result: unknown;\n  try {\n    result = asyncFn();\n  } catch (error) {\n    // eslint-disable-next-line no-void, @typescript-eslint/prefer-promise-reject-errors -- We need to fire-and-forget. Re-rejecting the original caught error as-is.\n    void addErrorHandler(() => Promise.reject(error), stackTrace);\n  }\n  if (result instanceof Promise) {\n    // eslint-disable-next-line no-void -- We need to fire-and-forget.\n    void addErrorHandler(() => result, stackTrace);\n  }\n}\n\n/**\n * Invokes an asynchronous function after a delay.\n *\n * @param asyncFn - The asynchronous function to invoke.\n * @param delayInMilliseconds - The delay in milliseconds.\n * @param stackTrace - The stack trace of the source function.\n * @param abortSignal - The abort signal to listen to.\n */\nexport function invokeAsyncSafelyAfterDelay(\n  asyncFn: (abortSignal: AbortSignal) => Promisable<void>,\n  delayInMilliseconds = 0,\n  stackTrace?: string,\n  abortSignal?: AbortSignal\n): void {\n  abortSignal ??= abortSignalNever();\n  abortSignal.throwIfAborted();\n  stackTrace ??= getStackTrace(1);\n  invokeAsyncSafely(async () => {\n    await sleep(delayInMilliseconds, abortSignal, true);\n    await asyncFn(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 asyncFn of asyncFns) {\n    results.push(await asyncFn());\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  onTimeout?(this: void, 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  operationFn(this: void, abortSignal: AbortSignal): Promisable<boolean>;\n\n  /**\n   * The name of the operation.\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  onTimeout?(this: void, 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  operationFn(this: void, abortSignal: AbortSignal): Promisable<Result>;\n\n  /**\n   * The name of the operation.\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 * 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 * Chains a promise with another promise.\n *\n * @param chainPromise - Represents the chained promise.\n * @param promisableFn - The function to chain.\n * @returns Chained promise or `null` if no async logic is chained.\n */\nexport function chain(chainPromise: null | Promise<void>, promisableFn: () => null | Promisable<void>): null | Promise<void> {\n  let nextChainPromise = chainPromise;\n  if (chainPromise) {\n    nextChainPromise = chainPromise.then(() => promisableFn() ?? undefined);\n  } else {\n    const promisable = promisableFn();\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 * 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    process.nextTick(() => {\n      resolve();\n    });\n  });\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 * @returns A promise that resolves when the next request animation frame is available.\n */\nexport async function requestAnimationFrameAsync(): Promise<void> {\n  return new Promise((resolve) => {\n    window.requestAnimationFrame(() => {\n      resolve();\n    });\n  });\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 ?? '', retryFn: params.operationFn },\n    onTimeout: params.onTimeout,\n    async operationFn(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.operationFn(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('retryWithTimeout failed', stackTrace, error);\n          }\n          printError(error);\n          isSuccess = false;\n        }\n        if (isSuccess) {\n          printWithStackTrace(retryWithTimeoutDebugger, stackTrace, `Retry completed successfully after ${String(attempt)} attempts`, {\n            operationFn: params.operationFn,\n            operationName: params.operationName ?? ''\n          });\n          return;\n        }\n\n        printWithStackTrace(\n          retryWithTimeoutDebugger,\n          stackTrace,\n          `Retry attempt ${String(attempt)} completed unsuccessfully. Trying again in ${String(fullOptions.retryDelayInMilliseconds)} milliseconds`,\n          {\n            operationFn: params.operationFn,\n            operationName: params.operationName ?? ''\n          }\n        );\n\n        await sleep(fullOptions.retryDelayInMilliseconds, abortSignal);\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 * If `DEBUG=obsidian-dev-utils:Async:runWithTimeout` is set, the execution is not terminated after the timeout and the function 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  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- It might changed inside `run()`. ESLint mistakenly does not recognize it.\n  if (hasResult) {\n    return result as Result;\n  }\n\n  throw new CustomStackTraceError('Run with timeout failed', stackTrace, runAbortController.signal.reason);\n\n  async function run(): Promise<void> {\n    try {\n      result = await params.operationFn(runAbortController.signal);\n      const duration = Math.trunc(performance.now() - startTime);\n      printWithStackTrace(runWithTimeoutDebugger, stackTrace, `Execution time: ${String(duration)} milliseconds`, {\n        context: params.context,\n        operationFn: params.operationFn,\n        operationName: params.operationName ?? ''\n      });\n      hasResult = true;\n    } catch (e) {\n      runAbortController.abort(e);\n    } finally {\n      isCompleted = true;\n      timeoutAbortController.abort(new Error('Completed'));\n    }\n  }\n\n  async function innerTimeout(): Promise<void> {\n    await sleep(params.timeoutInMilliseconds, timeoutAbortController.signal);\n\n    if (isCompleted) {\n      return;\n    }\n    const duration = Math.trunc(performance.now() - startTime);\n    printWithStackTrace(runWithTimeoutDebugger, stackTrace, `Timed out after ${String(duration)} milliseconds`, {\n      context: params.context,\n      operationFn: params.operationFn,\n      operationName: params.operationName ?? ''\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  function defaultOnTimeout(ctx: TimeoutContext): void {\n    ctx.terminateOperation();\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 * 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 milliseconds - The time to wait in milliseconds.\n * @param abortSignal - The abort signal to listen to.\n * @param shouldThrowOnAbort - Whether to throw an error if the abort signal is aborted.\n * @returns A {@link Promise} that resolves after the specified delay.\n */\nexport async function sleep(milliseconds: number, abortSignal?: AbortSignal, shouldThrowOnAbort?: boolean): Promise<void> {\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 timeoutInMilliseconds - The timeout period in milliseconds.\n * @param abortSignal - The abort signal to listen to.\n * @param shouldThrowOnAbort - Whether to throw an error if the abort signal is aborted.\n * @returns A {@link Promise} that always rejects with a timeout error.\n */\nexport async function timeout(timeoutInMilliseconds: number, abortSignal?: AbortSignal, shouldThrowOnAbort?: boolean): Promise<never> {\n  await sleep(timeoutInMilliseconds, abortSignal, shouldThrowOnAbort);\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 arr: T[] = [];\n  for await (const item of iter) {\n    arr.push(item);\n  }\n  return arr;\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 {\n  getLibDebugger,\n  printWithStackTrace\n} from './debug.ts';\nimport {\n  ASYNC_WRAPPER_ERROR_MESSAGE,\n  CustomStackTraceError,\n  emitAsyncErrorEvent,\n  getStackTrace,\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 * 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  readonly retryDelayInMilliseconds?: number;\n\n  /**\n   * Whether to retry the function on error.\n   */\n  readonly shouldRetryOnError?: boolean;\n\n  /**\n   * A maximum time in milliseconds to wait before giving up on retrying.\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 asyncFn - 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(asyncFn: () => Promise<unknown>, stackTrace?: string): Promise<void> {\n  stackTrace ??= getStackTrace(1);\n  try {\n    await asyncFn();\n  } catch (asyncError) {\n    const wrappedError = new CustomStackTraceError(ASYNC_WRAPPER_ERROR_MESSAGE, stackTrace, asyncError);\n    if (handleSilentError(wrappedError)) {\n      return;\n    }\n    emitAsyncErrorEvent(wrappedError);\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 arr - 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>(arr: T[], predicate: (value: T, index: number, array: T[]) => Promisable<boolean>): Promise<T[]> {\n  const ans: T[] = [];\n\n  const length = arr.length;\n  for (let i = 0; i < length; i++) {\n    if (!Object.hasOwn(arr, i)) {\n      continue;\n    }\n\n    const item = arr[i] as T;\n    if (await predicate(item, i, arr)) {\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 arr - 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>(arr: T[], predicate: (value: T, index: number, array: T[]) => Promisable<boolean>): Promise<void> {\n  const length = arr.length;\n  let writeIndex = 0;\n  for (let readIndex = 0; readIndex < length; readIndex++) {\n    if (!Object.hasOwn(arr, readIndex)) {\n      continue;\n    }\n\n    const current = arr[readIndex] as T;\n    if (await predicate(current, readIndex, arr)) {\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      arr[writeIndex++] = current;\n    }\n  }\n  arr.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 arr - 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>(arr: T[], callback: (value: T, index: number, array: T[]) => Promisable<U[]>): Promise<U[]> {\n  return (await asyncMap(arr, callback)).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 arr - 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>(arr: T[], callback: (value: T, index: number, array: T[]) => Promisable<U>): Promise<U[]> {\n  return await promiseAllSequentially(arr.map(callback));\n}\n\n/**\n * Converts an asynchronous function to a synchronous one by automatically handling the Promise rejection.\n *\n * @typeParam Args - The types of the arguments the function accepts.\n * @param asyncFunc - 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<Args extends unknown[]>(asyncFunc: GenericAsyncFunction<Args>, stackTrace?: string): GenericVoidFunction<Args> {\n  stackTrace ??= getStackTrace(1);\n  return (...args: Args): void => {\n    assertNonNullable(stackTrace);\n    const innerStackTrace = getStackTrace(1);\n    stackTrace = `${stackTrace}\\n    at --- convertAsyncToSync --- (0)\\n${innerStackTrace}`;\n    invokeAsyncSafely(() => asyncFunc(...args), stackTrace);\n  };\n}\n\n/**\n * Converts a synchronous function to an asynchronous one by wrapping it in a {@link Promise}.\n *\n * @typeParam Args - The types of the arguments the function accepts.\n * @typeParam Result - The type of the function's return value.\n * @param syncFn - The synchronous function to convert.\n * @returns A function that wraps the synchronous function in an asynchronous interface.\n */\nexport function convertSyncToAsync<Args extends unknown[], Result>(syncFn: GenericFunction<Args, Result>): GenericAsyncFunction<Args, Result> {\n  return async (...args: Args): Promise<Result> => {\n    await noopAsync();\n    return syncFn(...args);\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 */\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/**\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 (e) {\n    ignoreErrorDebugger('Ignored error', new CustomStackTraceError('Ignored error', stackTrace, e));\n    return fallbackValue;\n  }\n}\n\nconst pendingAsyncOperations = new Set<Promise<void>>();\nlet isAsyncOperationTrackingEnabled = false;\n\n/**\n * Disables tracking previously enabled via {@link enableAsyncOperationTracking} and forgets any currently-tracked operations.\n */\nexport function disableAsyncOperationTracking(): void {\n  isAsyncOperationTrackingEnabled = false;\n  pendingAsyncOperations.clear();\n}\n\n/**\n * Enables tracking of fire-and-forget operations scheduled via {@link invokeAsyncSafely} (and therefore {@link convertAsyncToSync}).\n *\n * While enabled, each scheduled operation is recorded until it settles so that tests can await them all via {@link waitForAllAsyncOperations}, removing the need to override {@link invokeAsyncSafely} / {@link convertAsyncToSync} in tests.\n *\n * Tracking is disabled by default, so production code carries no bookkeeping overhead. Intended to be enabled in test environments only.\n */\nexport function enableAsyncOperationTracking(): void {\n  isAsyncOperationTrackingEnabled = true;\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 asyncFn - The asynchronous function to invoke safely.\n * @param stackTrace - The stack trace of the source function.\n */\nexport function invokeAsyncSafely(asyncFn: () => Promisable<unknown>, stackTrace?: string): void {\n  stackTrace ??= getStackTrace(1);\n\n  let result: unknown;\n  try {\n    result = asyncFn();\n  } catch (error) {\n    // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors -- Re-rejecting the original caught error as-is.\n    trackAsyncOperation(addErrorHandler(() => Promise.reject(error), stackTrace));\n  }\n  if (result instanceof Promise) {\n    trackAsyncOperation(addErrorHandler(() => result, stackTrace));\n  }\n}\n\n/**\n * Invokes an asynchronous function after a delay.\n *\n * @param asyncFn - The asynchronous function to invoke.\n * @param delayInMilliseconds - The delay in milliseconds.\n * @param stackTrace - The stack trace of the source function.\n * @param abortSignal - The abort signal to listen to.\n */\nexport function invokeAsyncSafelyAfterDelay(\n  asyncFn: (abortSignal: AbortSignal) => Promisable<void>,\n  delayInMilliseconds = 0,\n  stackTrace?: string,\n  abortSignal?: AbortSignal\n): void {\n  abortSignal ??= abortSignalNever();\n  abortSignal.throwIfAborted();\n  stackTrace ??= getStackTrace(1);\n  invokeAsyncSafely(async () => {\n    await sleep(delayInMilliseconds, abortSignal, true);\n    await asyncFn(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 asyncFn of asyncFns) {\n    results.push(await asyncFn());\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\n/**\n * Waits for all fire-and-forget operations tracked since {@link enableAsyncOperationTracking} was called to settle.\n *\n * Operations scheduled while awaiting are also awaited, so cascading fire-and-forget chains are fully drained.\n *\n * @returns A {@link Promise} that resolves once no tracked operations remain pending.\n * @throws If tracking is not enabled. Otherwise this would silently resolve as if all operations were finished, masking a missing {@link enableAsyncOperationTracking} call.\n */\nexport async function waitForAllAsyncOperations(): Promise<void> {\n  if (!isAsyncOperationTrackingEnabled) {\n    throw new Error('Async operation tracking is not enabled. Call enableAsyncOperationTracking() before waitForAllAsyncOperations().');\n  }\n\n  while (pendingAsyncOperations.size > 0) {\n    await Promise.allSettled([...pendingAsyncOperations]);\n  }\n}\n\nfunction trackAsyncOperation(operation: Promise<void>): void {\n  if (!isAsyncOperationTrackingEnabled) {\n    return;\n  }\n\n  pendingAsyncOperations.add(operation);\n  // eslint-disable-next-line no-void -- Fire-and-forget cleanup of the settled operation.\n  void operation.finally(() => {\n    pendingAsyncOperations.delete(operation);\n  });\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  onTimeout?(this: void, 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  operationFn(this: void, abortSignal: AbortSignal): Promisable<boolean>;\n\n  /**\n   * The name of the operation.\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  onTimeout?(this: void, 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  operationFn(this: void, abortSignal: AbortSignal): Promisable<Result>;\n\n  /**\n   * The name of the operation.\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 * 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 * Chains a promise with another promise.\n *\n * @param chainPromise - Represents the chained promise.\n * @param promisableFn - The function to chain.\n * @returns Chained promise or `null` if no async logic is chained.\n */\nexport function chain(chainPromise: null | Promise<void>, promisableFn: () => null | Promisable<void>): null | Promise<void> {\n  let nextChainPromise = chainPromise;\n  if (chainPromise) {\n    nextChainPromise = chainPromise.then(() => promisableFn() ?? undefined);\n  } else {\n    const promisable = promisableFn();\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 * 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    process.nextTick(() => {\n      resolve();\n    });\n  });\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 * @returns A promise that resolves when the next request animation frame is available.\n */\nexport async function requestAnimationFrameAsync(): Promise<void> {\n  return new Promise((resolve) => {\n    window.requestAnimationFrame(() => {\n      resolve();\n    });\n  });\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 ?? '', retryFn: params.operationFn },\n    onTimeout: params.onTimeout,\n    async operationFn(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.operationFn(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('retryWithTimeout failed', stackTrace, error);\n          }\n          printError(error);\n          isSuccess = false;\n        }\n        if (isSuccess) {\n          printWithStackTrace(retryWithTimeoutDebugger, stackTrace, `Retry completed successfully after ${String(attempt)} attempts`, {\n            operationFn: params.operationFn,\n            operationName: params.operationName ?? ''\n          });\n          return;\n        }\n\n        printWithStackTrace(\n          retryWithTimeoutDebugger,\n          stackTrace,\n          `Retry attempt ${String(attempt)} completed unsuccessfully. Trying again in ${String(fullOptions.retryDelayInMilliseconds)} milliseconds`,\n          {\n            operationFn: params.operationFn,\n            operationName: params.operationName ?? ''\n          }\n        );\n\n        await sleep(fullOptions.retryDelayInMilliseconds, abortSignal);\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 * If `DEBUG=obsidian-dev-utils:Async:runWithTimeout` is set, the execution is not terminated after the timeout and the function 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  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- It might changed inside `run()`. ESLint mistakenly does not recognize it.\n  if (hasResult) {\n    return result as Result;\n  }\n\n  throw new CustomStackTraceError('Run with timeout failed', stackTrace, runAbortController.signal.reason);\n\n  async function run(): Promise<void> {\n    try {\n      result = await params.operationFn(runAbortController.signal);\n      const duration = Math.trunc(performance.now() - startTime);\n      printWithStackTrace(runWithTimeoutDebugger, stackTrace, `Execution time: ${String(duration)} milliseconds`, {\n        context: params.context,\n        operationFn: params.operationFn,\n        operationName: params.operationName ?? ''\n      });\n      hasResult = true;\n    } catch (e) {\n      runAbortController.abort(e);\n    } finally {\n      isCompleted = true;\n      timeoutAbortController.abort(new Error('Completed'));\n    }\n  }\n\n  async function innerTimeout(): Promise<void> {\n    await sleep(params.timeoutInMilliseconds, timeoutAbortController.signal);\n\n    if (isCompleted) {\n      return;\n    }\n    const duration = Math.trunc(performance.now() - startTime);\n    printWithStackTrace(runWithTimeoutDebugger, stackTrace, `Timed out after ${String(duration)} milliseconds`, {\n      context: params.context,\n      operationFn: params.operationFn,\n      operationName: params.operationName ?? ''\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  function defaultOnTimeout(ctx: TimeoutContext): void {\n    ctx.terminateOperation();\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 * 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 milliseconds - The time to wait in milliseconds.\n * @param abortSignal - The abort signal to listen to.\n * @param shouldThrowOnAbort - Whether to throw an error if the abort signal is aborted.\n * @returns A {@link Promise} that resolves after the specified delay.\n */\nexport async function sleep(milliseconds: number, abortSignal?: AbortSignal, shouldThrowOnAbort?: boolean): Promise<void> {\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 timeoutInMilliseconds - The timeout period in milliseconds.\n * @param abortSignal - The abort signal to listen to.\n * @param shouldThrowOnAbort - Whether to throw an error if the abort signal is aborted.\n * @returns A {@link Promise} that always rejects with a timeout error.\n */\nexport async function timeout(timeoutInMilliseconds: number, abortSignal?: AbortSignal, shouldThrowOnAbort?: boolean): Promise<never> {\n  await sleep(timeoutInMilliseconds, abortSignal, shouldThrowOnAbort);\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 arr: T[] = [];\n  for await (const item of iter) {\n    arr.push(item);\n  }\n  return arr;\n}\n"],
  "mappings": "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",
  "names": []
}


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

@@ -87,6 +87,16 @@ interface CreateFunctionParams<TFunction extends GenericFunction> extends Create
 type MapToArgNames<TArgs extends readonly unknown[]> = {
     readonly [K in keyof TArgs]: string;
 };
+/**
+ * Clone a function by creating a new function that calls the original function.
+ *
+ * This is useful for creating a new instance of a function that has the same behavior but is not strictly equal to the original function.
+ *
+ * @typeParam TFunction - The type of the function to clone.
+ * @param fn - The function to clone.
+ * @returns A new function that has the same behavior as the original function.
+ */
+export declare function cloneFunction<TFunction extends GenericFunction>(fn: TFunction): TFunction;
 /**
  * Creates a function from the provided parameters.
  *

package/dist/lib/esm/function.mjs

@@ -45,6 +45,12 @@ function omitAsyncReturnType(fn) {
 }
 const FUNCTION_EXPRESSION_RE = /^(?:function\b|async\b\s*(?:function\b|\()|\()/;
 const ASYNC_KEYWORD_RE = /^async\b\s*/;
+function cloneFunction(fn) {
+  return clonedFn;
+  function clonedFn(...args) {
+    return fn.apply(this, args);
+  }
+}
 function createFunction(params) {
   const argNames = params.argNames ?? [];
   return new Function(...argNames, params.functionBody);
@@ -55,6 +61,7 @@ function omitReturnType(fn) {
   };
 }
 export {
+  cloneFunction,
   createFunction,
   getFunctionExpressionString,
   noop,
@@ -63,4 +70,4 @@ export {
   omitAsyncReturnType,
   omitReturnType
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/function.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions and types for working with functions.\n */\n\nimport type { Promisable } from 'type-fest';\n\n/**\n * Represents a generic async function.\n *\n * @typeParam Args - The arguments of the function.\n * @typeParam Return - The awaited return type of the function.\n */\nexport type GenericAsyncFunction<Args extends unknown[] = never[], Return = unknown> = GenericFunction<Args, Promise<Return>>;\n\n/**\n * Represents a generic async void function.\n *\n * @typeParam Args - The arguments of the function.\n */\nexport type GenericAsyncVoidFunction<Args extends unknown[] = never[]> = GenericAsyncFunction<Args, void>;\n\n/**\n * Represents a generic function.\n *\n * @typeParam Args - The arguments of the function.\n * @typeParam Return - The return type of the function.\n */\nexport type GenericFunction<Args extends unknown[] = never[], Return = unknown> = (...args: Args) => Return;\n\n/**\n * Represents a generic promisable function.\n *\n * @typeParam Args - The arguments of the function.\n * @typeParam Return - The awaited return type of the function.\n */\nexport type GenericPromisableFunction<Args extends unknown[] = never[], Return = unknown> = GenericFunction<Args, Promisable<Return>>;\n\n/**\n * Represents a generic promisable void function.\n *\n * @typeParam Args - The arguments of the function.\n */\nexport type GenericPromisableVoidFunction<Args extends unknown[] = never[]> = GenericPromisableFunction<Args, void>;\n\n/**\n * Represents a generic void function.\n *\n * @typeParam Args - The arguments of the function.\n */\nexport type GenericVoidFunction<Args extends unknown[] = never[]> = GenericFunction<Args, void>;\n\n/**\n * Converts a function into a string that is a valid function expression.\n *\n * `Function.prototype.toString()` on a shorthand method like `{ fn() {} }`\n * returns `\"fn() {}\"`, which is not a valid expression.\n * This helper detects that form and prefixes it with `function `.\n *\n * @param fn - The function to convert.\n * @returns A string that is a valid function expression.\n */\n// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type -- We need to use `Function` type.\nexport function getFunctionExpressionString(fn: Function): string {\n  const fnString = fn.toString();\n\n  if (FUNCTION_EXPRESSION_RE.test(fnString)) {\n    return fnString;\n  }\n\n  const asyncMatch = ASYNC_KEYWORD_RE.exec(fnString);\n  if (asyncMatch) {\n    return `async function ${fnString.slice(asyncMatch[0].length)}`;\n  }\n\n  return `function ${fnString}`;\n}\n\n/**\n * A function that does nothing.\n */\nexport function noop(): void {\n  // Does nothing.\n}\n\n/**\n * A singleton no-op promise.\n */\n// eslint-disable-next-line obsidian-dev-utils/prefer-noop-async -- Avoid circular reference.\nexport const noopAsyncSingletonPromise = Promise.resolve();\n\n/**\n * A function that does nothing.\n *\n * @returns A promise that resolves when the function is complete.\n */\nexport function noopAsync(): Promise<void> {\n  return noopAsyncSingletonPromise;\n}\n\n/**\n * Makes an async function that calls the original async function with the provided arguments and omits the return value.\n *\n * @typeParam Args - Arguments to be passed to the function.\n * @param fn - Function to be called.\n * @returns An async function that calls the original function with the provided arguments and omits the return value.\n */\nexport function omitAsyncReturnType<Args extends unknown[]>(fn: GenericAsyncFunction<Args>): GenericAsyncVoidFunction<Args> {\n  return async (...args: Args) => {\n    await fn(...args);\n  };\n}\n\n/**\n * Matches strings that are already valid function expressions:\n * - `function ...` (keyword, not identifier like `function1`)\n * - `(` (arrow function)\n * - `async\\b` followed by `function\\b` or `(` (async function/arrow)\n */\nconst FUNCTION_EXPRESSION_RE = /^(?:function\\b|async\\b\\s*(?:function\\b|\\()|\\()/;\n\n/**\n * Matches the `async` keyword (word boundary, not `async1`) followed by optional whitespace.\n * Used to strip the `async` prefix from async shorthand methods before re-adding `async function`.\n */\nconst ASYNC_KEYWORD_RE = /^async\\b\\s*/;\n\ntype ArgNamesOf<T extends GenericFunction> = MapToArgNames<Parameters<T>>;\n\ninterface CreateFunctionArgumentlessParams {\n  readonly functionBody: string;\n}\n\ninterface CreateFunctionParams<TFunction extends GenericFunction> extends CreateFunctionArgumentlessParams {\n  readonly argNames: ArgNamesOf<TFunction>;\n}\n\ntype MapToArgNames<TArgs extends readonly unknown[]> = {\n  readonly [K in keyof TArgs]: string;\n};\n\n/**\n * Creates a function from the provided parameters.\n *\n * Function is argumentless, so `argNames` is not needed.\n *\n * @typeParam TFunction - The type of the function to create.\n * @param params - The parameters to create the function with.\n * @returns A function created from the provided parameters.\n */\n// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need return type.\nexport function createFunction<TFunction extends () => unknown>(params: CreateFunctionArgumentlessParams): TFunction;\n/**\n * Creates a function from the provided parameters.\n *\n * Function has arguments, so `argNames` is required.\n *\n * @typeParam TFunction - The type of the function to create.\n * @param params - The parameters to create the function with.\n * @returns A function created from the provided parameters.\n */\nexport function createFunction<TFunction extends GenericFunction>(params: CreateFunctionParams<TFunction>): TFunction;\n/**\n * Creates a function from the provided parameters.\n *\n * @typeParam TFunction - The type of the function to create.\n *\n * @param params - The parameters to create the function with.\n * @returns A function created from the provided parameters.\n */\nexport function createFunction<TFunction extends GenericFunction>(\n  params: CreateFunctionArgumentlessParams & Partial<CreateFunctionParams<TFunction>>\n): TFunction {\n  const argNames = params.argNames ?? [];\n  // eslint-disable-next-line no-new-func, @typescript-eslint/no-implied-eval -- Need function constructor\n  return new Function(...argNames, params.functionBody) as TFunction;\n}\n\n/**\n * Makes a function that calls the original function with the provided arguments and omits the return value.\n *\n * @typeParam Args - Arguments to be passed to the function.\n * @param fn - Function to be called.\n * @returns A function that calls the original function with the provided arguments and omits the return value.\n */\nexport function omitReturnType<Args extends unknown[]>(fn: GenericFunction<Args>): GenericVoidFunction<Args> {\n  return (...args: Args) => {\n    fn(...args);\n  };\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAgEO,SAAS,4BAA4B,IAAsB;AAChE,QAAM,WAAW,GAAG,SAAS;AAE7B,MAAI,uBAAuB,KAAK,QAAQ,GAAG;AACzC,WAAO;AAAA,EACT;AAEA,QAAM,aAAa,iBAAiB,KAAK,QAAQ;AACjD,MAAI,YAAY;AACd,WAAO,kBAAkB,SAAS,MAAM,WAAW,CAAC,EAAE,MAAM,CAAC;AAAA,EAC/D;AAEA,SAAO,YAAY,QAAQ;AAC7B;AAKO,SAAS,OAAa;AAE7B;AAMO,MAAM,4BAA4B,QAAQ,QAAQ;AAOlD,SAAS,YAA2B;AACzC,SAAO;AACT;AASO,SAAS,oBAA4C,IAAgE;AAC1H,SAAO,UAAU,SAAe;AAC9B,UAAM,GAAG,GAAG,IAAI;AAAA,EAClB;AACF;AAQA,MAAM,yBAAyB;AAM/B,MAAM,mBAAmB;AA6ClB,SAAS,eACd,QACW;AACX,QAAM,WAAW,OAAO,YAAY,CAAC;AAErC,SAAO,IAAI,SAAS,GAAG,UAAU,OAAO,YAAY;AACtD;AASO,SAAS,eAAuC,IAAsD;AAC3G,SAAO,IAAI,SAAe;AACxB,OAAG,GAAG,IAAI;AAAA,EACZ;AACF;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/function.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions and types for working with functions.\n */\n\nimport type { Promisable } from 'type-fest';\n\n/**\n * Represents a generic async function.\n *\n * @typeParam Args - The arguments of the function.\n * @typeParam Return - The awaited return type of the function.\n */\nexport type GenericAsyncFunction<Args extends unknown[] = never[], Return = unknown> = GenericFunction<Args, Promise<Return>>;\n\n/**\n * Represents a generic async void function.\n *\n * @typeParam Args - The arguments of the function.\n */\nexport type GenericAsyncVoidFunction<Args extends unknown[] = never[]> = GenericAsyncFunction<Args, void>;\n\n/**\n * Represents a generic function.\n *\n * @typeParam Args - The arguments of the function.\n * @typeParam Return - The return type of the function.\n */\nexport type GenericFunction<Args extends unknown[] = never[], Return = unknown> = (...args: Args) => Return;\n\n/**\n * Represents a generic promisable function.\n *\n * @typeParam Args - The arguments of the function.\n * @typeParam Return - The awaited return type of the function.\n */\nexport type GenericPromisableFunction<Args extends unknown[] = never[], Return = unknown> = GenericFunction<Args, Promisable<Return>>;\n\n/**\n * Represents a generic promisable void function.\n *\n * @typeParam Args - The arguments of the function.\n */\nexport type GenericPromisableVoidFunction<Args extends unknown[] = never[]> = GenericPromisableFunction<Args, void>;\n\n/**\n * Represents a generic void function.\n *\n * @typeParam Args - The arguments of the function.\n */\nexport type GenericVoidFunction<Args extends unknown[] = never[]> = GenericFunction<Args, void>;\n\n/**\n * Converts a function into a string that is a valid function expression.\n *\n * `Function.prototype.toString()` on a shorthand method like `{ fn() {} }`\n * returns `\"fn() {}\"`, which is not a valid expression.\n * This helper detects that form and prefixes it with `function `.\n *\n * @param fn - The function to convert.\n * @returns A string that is a valid function expression.\n */\n// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type -- We need to use `Function` type.\nexport function getFunctionExpressionString(fn: Function): string {\n  const fnString = fn.toString();\n\n  if (FUNCTION_EXPRESSION_RE.test(fnString)) {\n    return fnString;\n  }\n\n  const asyncMatch = ASYNC_KEYWORD_RE.exec(fnString);\n  if (asyncMatch) {\n    return `async function ${fnString.slice(asyncMatch[0].length)}`;\n  }\n\n  return `function ${fnString}`;\n}\n\n/**\n * A function that does nothing.\n */\nexport function noop(): void {\n  // Does nothing.\n}\n\n/**\n * A singleton no-op promise.\n */\n// eslint-disable-next-line obsidian-dev-utils/prefer-noop-async -- Avoid circular reference.\nexport const noopAsyncSingletonPromise = Promise.resolve();\n\n/**\n * A function that does nothing.\n *\n * @returns A promise that resolves when the function is complete.\n */\nexport function noopAsync(): Promise<void> {\n  return noopAsyncSingletonPromise;\n}\n\n/**\n * Makes an async function that calls the original async function with the provided arguments and omits the return value.\n *\n * @typeParam Args - Arguments to be passed to the function.\n * @param fn - Function to be called.\n * @returns An async function that calls the original function with the provided arguments and omits the return value.\n */\nexport function omitAsyncReturnType<Args extends unknown[]>(fn: GenericAsyncFunction<Args>): GenericAsyncVoidFunction<Args> {\n  return async (...args: Args) => {\n    await fn(...args);\n  };\n}\n\n/**\n * Matches strings that are already valid function expressions:\n * - `function ...` (keyword, not identifier like `function1`)\n * - `(` (arrow function)\n * - `async\\b` followed by `function\\b` or `(` (async function/arrow)\n */\nconst FUNCTION_EXPRESSION_RE = /^(?:function\\b|async\\b\\s*(?:function\\b|\\()|\\()/;\n\n/**\n * Matches the `async` keyword (word boundary, not `async1`) followed by optional whitespace.\n * Used to strip the `async` prefix from async shorthand methods before re-adding `async function`.\n */\nconst ASYNC_KEYWORD_RE = /^async\\b\\s*/;\n\ntype ArgNamesOf<T extends GenericFunction> = MapToArgNames<Parameters<T>>;\n\ninterface CreateFunctionArgumentlessParams {\n  readonly functionBody: string;\n}\n\ninterface CreateFunctionParams<TFunction extends GenericFunction> extends CreateFunctionArgumentlessParams {\n  readonly argNames: ArgNamesOf<TFunction>;\n}\n\ntype MapToArgNames<TArgs extends readonly unknown[]> = {\n  readonly [K in keyof TArgs]: string;\n};\n\n/**\n * Clone a function by creating a new function that calls the original function.\n *\n * This is useful for creating a new instance of a function that has the same behavior but is not strictly equal to the original function.\n *\n * @typeParam TFunction - The type of the function to clone.\n * @param fn - The function to clone.\n * @returns A new function that has the same behavior as the original function.\n */\nexport function cloneFunction<TFunction extends GenericFunction>(fn: TFunction): TFunction {\n  return clonedFn as TFunction;\n\n  function clonedFn(this: ThisParameterType<TFunction>, ...args: Parameters<TFunction>): ReturnType<TFunction> {\n    return fn.apply(this, args) as ReturnType<TFunction>;\n  }\n}\n/**\n * Creates a function from the provided parameters.\n *\n * Function is argumentless, so `argNames` is not needed.\n *\n * @typeParam TFunction - The type of the function to create.\n * @param params - The parameters to create the function with.\n * @returns A function created from the provided parameters.\n */\n// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need return type.\nexport function createFunction<TFunction extends () => unknown>(params: CreateFunctionArgumentlessParams): TFunction;\n/**\n * Creates a function from the provided parameters.\n *\n * Function has arguments, so `argNames` is required.\n *\n * @typeParam TFunction - The type of the function to create.\n * @param params - The parameters to create the function with.\n * @returns A function created from the provided parameters.\n */\nexport function createFunction<TFunction extends GenericFunction>(params: CreateFunctionParams<TFunction>): TFunction;\n/**\n * Creates a function from the provided parameters.\n *\n * @typeParam TFunction - The type of the function to create.\n *\n * @param params - The parameters to create the function with.\n * @returns A function created from the provided parameters.\n */\nexport function createFunction<TFunction extends GenericFunction>(\n  params: CreateFunctionArgumentlessParams & Partial<CreateFunctionParams<TFunction>>\n): TFunction {\n  const argNames = params.argNames ?? [];\n  // eslint-disable-next-line no-new-func, @typescript-eslint/no-implied-eval -- Need function constructor\n  return new Function(...argNames, params.functionBody) as TFunction;\n}\n\n/**\n * Makes a function that calls the original function with the provided arguments and omits the return value.\n *\n * @typeParam Args - Arguments to be passed to the function.\n * @param fn - Function to be called.\n * @returns A function that calls the original function with the provided arguments and omits the return value.\n */\nexport function omitReturnType<Args extends unknown[]>(fn: GenericFunction<Args>): GenericVoidFunction<Args> {\n  return (...args: Args) => {\n    fn(...args);\n  };\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAgEO,SAAS,4BAA4B,IAAsB;AAChE,QAAM,WAAW,GAAG,SAAS;AAE7B,MAAI,uBAAuB,KAAK,QAAQ,GAAG;AACzC,WAAO;AAAA,EACT;AAEA,QAAM,aAAa,iBAAiB,KAAK,QAAQ;AACjD,MAAI,YAAY;AACd,WAAO,kBAAkB,SAAS,MAAM,WAAW,CAAC,EAAE,MAAM,CAAC;AAAA,EAC/D;AAEA,SAAO,YAAY,QAAQ;AAC7B;AAKO,SAAS,OAAa;AAE7B;AAMO,MAAM,4BAA4B,QAAQ,QAAQ;AAOlD,SAAS,YAA2B;AACzC,SAAO;AACT;AASO,SAAS,oBAA4C,IAAgE;AAC1H,SAAO,UAAU,SAAe;AAC9B,UAAM,GAAG,GAAG,IAAI;AAAA,EAClB;AACF;AAQA,MAAM,yBAAyB;AAM/B,MAAM,mBAAmB;AAyBlB,SAAS,cAAiD,IAA0B;AACzF,SAAO;AAEP,WAAS,YAAgD,MAAoD;AAC3G,WAAO,GAAG,MAAM,MAAM,IAAI;AAAA,EAC5B;AACF;AA8BO,SAAS,eACd,QACW;AACX,QAAM,WAAW,OAAO,YAAY,CAAC;AAErC,SAAO,IAAI,SAAS,GAAG,UAAU,OAAO,YAAY;AACtD;AASO,SAAS,eAAuC,IAAsD;AAC3G,SAAO,IAAI,SAAe;AACxB,OAAG,GAAG,IAAI;AAAA,EACZ;AACF;",
  "names": []
}


package/dist/lib/esm/library.mjs

@@ -21,7 +21,7 @@ if you want to view the source, please visit the github repository of this plugi
   globalThis.process = browserProcess;
 })();
 
-const LIBRARY_VERSION = "74.0.0";
+const LIBRARY_VERSION = "74.2.0";
 const LIBRARY_NAME = "obsidian-dev-utils";
 const LIBRARY_STYLES = ".obsidian-dev-utils.code-highlighter-component textarea, .obsidian-dev-utils.code-highlighter-component pre, .obsidian-dev-utils.code-highlighter-component code {\n  font-family: var(--font-monospace);\n  line-height: var(--line-height-normal);\n  margin: 0;\n}\n.obsidian-dev-utils.code-highlighter-component textarea, .obsidian-dev-utils.code-highlighter-component code {\n  font-size: var(--code-size);\n}\n.obsidian-dev-utils.code-highlighter-component textarea {\n  background: transparent;\n  color: transparent;\n  z-index: 2;\n  width: 20em;\n  height: 10em;\n}\n.obsidian-dev-utils.code-highlighter-component pre {\n  position: absolute;\n  pointer-events: none;\n  border: var(--input-border-width) solid transparent;\n  overflow: auto;\n  inset: 0;\n  padding: var(--size-4-1) var(--size-4-2);\n  z-index: 1;\n}\n.obsidian-dev-utils.code-highlighter-component pre::after {\n  content: \"\";\n  display: block;\n  height: var(--bottom-gap, 0);\n}\n.obsidian-dev-utils.code-highlighter-component pre.is-placeholder {\n  opacity: 0.6;\n}\n.obsidian-dev-utils.code-highlighter-component code {\n  display: block;\n  padding: 0;\n}\n\n.obsidian-dev-utils input[type=url] {\n  height: var(--input-height);\n}\n.obsidian-dev-utils input[type=month],\n.obsidian-dev-utils input[type=tel],\n.obsidian-dev-utils input[type=time],\n.obsidian-dev-utils input[type=url],\n.obsidian-dev-utils input[type=week] {\n  -webkit-app-region: no-drag;\n  background: var(--background-modifier-form-field);\n  border: var(--input-border-width) solid var(--background-modifier-border);\n  color: var(--text-normal);\n  font-family: inherit;\n  padding: var(--size-4-1) var(--size-4-2);\n  font-size: var(--font-ui-small);\n  border-radius: var(--input-radius);\n  outline: none;\n}\n@media (hover: hover) {\n  .obsidian-dev-utils input[type=month]:hover,\n  .obsidian-dev-utils input[type=tel]:hover,\n  .obsidian-dev-utils input[type=time]:hover,\n  .obsidian-dev-utils input[type=url]:hover,\n  .obsidian-dev-utils input[type=week]:hover {\n    border-color: var(--background-modifier-border-hover);\n    transition: box-shadow 0.15s ease-in-out, border 0.15s ease-in-out;\n  }\n}\n.obsidian-dev-utils input[type=month]:active, .obsidian-dev-utils input[type=month]:focus,\n.obsidian-dev-utils input[type=tel]:active,\n.obsidian-dev-utils input[type=tel]:focus,\n.obsidian-dev-utils input[type=time]:active,\n.obsidian-dev-utils input[type=time]:focus,\n.obsidian-dev-utils input[type=url]:active,\n.obsidian-dev-utils input[type=url]:focus,\n.obsidian-dev-utils input[type=week]:active,\n.obsidian-dev-utils input[type=week]:focus {\n  border-color: var(--background-modifier-border-focus);\n  transition: box-shadow 0.15s ease-in-out, border 0.15s ease-in-out;\n}\n.obsidian-dev-utils input[type=month]:active, .obsidian-dev-utils input[type=month]:focus, .obsidian-dev-utils input[type=month]:focus-visible,\n.obsidian-dev-utils input[type=tel]:active,\n.obsidian-dev-utils input[type=tel]:focus,\n.obsidian-dev-utils input[type=tel]:focus-visible,\n.obsidian-dev-utils input[type=time]:active,\n.obsidian-dev-utils input[type=time]:focus,\n.obsidian-dev-utils input[type=time]:focus-visible,\n.obsidian-dev-utils input[type=url]:active,\n.obsidian-dev-utils input[type=url]:focus,\n.obsidian-dev-utils input[type=url]:focus-visible,\n.obsidian-dev-utils input[type=week]:active,\n.obsidian-dev-utils input[type=week]:focus,\n.obsidian-dev-utils input[type=week]:focus-visible {\n  box-shadow: 0 0 0 2px var(--background-modifier-border-focus);\n}\n.obsidian-dev-utils input[type=month]::placeholder,\n.obsidian-dev-utils input[type=tel]::placeholder,\n.obsidian-dev-utils input[type=time]::placeholder,\n.obsidian-dev-utils input[type=url]::placeholder,\n.obsidian-dev-utils input[type=week]::placeholder {\n  color: var(--text-faint);\n}\n.mod-rtl input[type=month],\n.mod-rtl input[type=time],\n.mod-rtl input[type=week],\n.is-rtl input[type=month],\n.is-rtl input[type=time],\n.is-rtl input[type=week],\n.rtl input[type=month],\n.rtl input[type=time],\n.rtl input[type=week] {\n  direction: rtl;\n}\n.mod-rtl input[type=month]::-webkit-calendar-picker-indicator,\n.mod-rtl input[type=time]::-webkit-calendar-picker-indicator,\n.mod-rtl input[type=week]::-webkit-calendar-picker-indicator,\n.is-rtl input[type=month]::-webkit-calendar-picker-indicator,\n.is-rtl input[type=time]::-webkit-calendar-picker-indicator,\n.is-rtl input[type=week]::-webkit-calendar-picker-indicator,\n.rtl input[type=month]::-webkit-calendar-picker-indicator,\n.rtl input[type=time]::-webkit-calendar-picker-indicator,\n.rtl input[type=week]::-webkit-calendar-picker-indicator {\n  right: var(--size-4-1);\n  left: auto;\n}\n\n.obsidian-dev-utils input[type=month],\n.obsidian-dev-utils input[type=time],\n.obsidian-dev-utils input[type=week] {\n  font-variant-numeric: tabular-nums;\n  position: relative;\n}\n.obsidian-dev-utils input[type=month]::-webkit-datetime-edit-text,\n.obsidian-dev-utils input[type=time]::-webkit-datetime-edit-text,\n.obsidian-dev-utils input[type=week]::-webkit-datetime-edit-text {\n  color: var(--text-faint);\n  padding-inline-end: 0;\n}\n.obsidian-dev-utils input[type=month]::-webkit-calendar-picker-indicator,\n.obsidian-dev-utils input[type=time]::-webkit-calendar-picker-indicator,\n.obsidian-dev-utils input[type=week]::-webkit-calendar-picker-indicator {\n  position: absolute;\n  left: var(--size-4-1);\n  right: auto;\n  opacity: 0.5;\n}\n.obsidian-dev-utils input[type=month]::-webkit-datetime-edit-month-field:active, .obsidian-dev-utils input[type=month]::-webkit-datetime-edit-month-field:focus, .obsidian-dev-utils input[type=month]::-webkit-datetime-edit-day-field:active, .obsidian-dev-utils input[type=month]::-webkit-datetime-edit-day-field:focus, .obsidian-dev-utils input[type=month]::-webkit-datetime-edit-year-field:active, .obsidian-dev-utils input[type=month]::-webkit-datetime-edit-year-field:focus,\n.obsidian-dev-utils input[type=time]::-webkit-datetime-edit-month-field:active,\n.obsidian-dev-utils input[type=time]::-webkit-datetime-edit-month-field:focus,\n.obsidian-dev-utils input[type=time]::-webkit-datetime-edit-day-field:active,\n.obsidian-dev-utils input[type=time]::-webkit-datetime-edit-day-field:focus,\n.obsidian-dev-utils input[type=time]::-webkit-datetime-edit-year-field:active,\n.obsidian-dev-utils input[type=time]::-webkit-datetime-edit-year-field:focus,\n.obsidian-dev-utils input[type=week]::-webkit-datetime-edit-month-field:active,\n.obsidian-dev-utils input[type=week]::-webkit-datetime-edit-month-field:focus,\n.obsidian-dev-utils input[type=week]::-webkit-datetime-edit-day-field:active,\n.obsidian-dev-utils input[type=week]::-webkit-datetime-edit-day-field:focus,\n.obsidian-dev-utils input[type=week]::-webkit-datetime-edit-year-field:active,\n.obsidian-dev-utils input[type=week]::-webkit-datetime-edit-year-field:focus {\n  background-color: var(--text-selection);\n  color: var(--text-normal);\n  cursor: text;\n}\n.mod-rtl .obsidian-dev-utils input[type=month], .is-rtl .obsidian-dev-utils input[type=month], .rtl .obsidian-dev-utils input[type=month],\n.mod-rtl .obsidian-dev-utils input[type=time],\n.is-rtl .obsidian-dev-utils input[type=time],\n.rtl .obsidian-dev-utils input[type=time],\n.mod-rtl .obsidian-dev-utils input[type=week],\n.is-rtl .obsidian-dev-utils input[type=week],\n.rtl .obsidian-dev-utils input[type=week] {\n  direction: rtl;\n}\n.mod-rtl .obsidian-dev-utils input[type=month]::-webkit-calendar-picker-indicator, .is-rtl .obsidian-dev-utils input[type=month]::-webkit-calendar-picker-indicator, .rtl .obsidian-dev-utils input[type=month]::-webkit-calendar-picker-indicator,\n.mod-rtl .obsidian-dev-utils input[type=time]::-webkit-calendar-picker-indicator,\n.is-rtl .obsidian-dev-utils input[type=time]::-webkit-calendar-picker-indicator,\n.rtl .obsidian-dev-utils input[type=time]::-webkit-calendar-picker-indicator,\n.mod-rtl .obsidian-dev-utils input[type=week]::-webkit-calendar-picker-indicator,\n.is-rtl .obsidian-dev-utils input[type=week]::-webkit-calendar-picker-indicator,\n.rtl .obsidian-dev-utils input[type=week]::-webkit-calendar-picker-indicator {\n  left: auto;\n  right: var(--size-4-1);\n}\n\nbody:not(.is-ios):not(.is-android) .obsidian-dev-utils input[type=month],\nbody:not(.is-ios):not(.is-android) .obsidian-dev-utils input[type=time],\nbody:not(.is-ios):not(.is-android) .obsidian-dev-utils input[type=week] {\n  padding-inline-start: var(--size-4-6);\n}\n\n.obsidian-dev-utils input[type=time]::-webkit-calendar-picker-indicator {\n  margin-inline-start: 0;\n}\n\n.obsidian-dev-utilsprogress.loop {\n  min-width: 200px;\n}\n\n.obsidian-dev-utils.modal-container .ok-button {\n  margin-right: 10px;\n  margin-top: 20px;\n}\n\n.obsidian-dev-utils .multiple-dropdown-component select,\n.obsidian-dev-utils .multiple-dropdown-component select:focus,\n.obsidian-dev-utils .multiple-dropdown-component .dropdown {\n  height: auto;\n  padding-top: 3px;\n}\n.obsidian-dev-utils .multiple-dropdown-component select option:checked,\n.obsidian-dev-utils .multiple-dropdown-component select:focus option:checked,\n.obsidian-dev-utils .multiple-dropdown-component .dropdown option:checked {\n  background-color: #1967d2;\n  color: #fff;\n}\n\n.obsidian-dev-utils.plugin-settings-tab a:focus {\n  outline: 2px solid var(--link-color);\n}\n\n.obsidian-dev-utils.prompt-modal .text-box {\n  width: 100%;\n}\n\n.obsidian-dev-utils.tri-state-checkbox-component input[type=checkbox]:indeterminate {\n  appearance: checkbox;\n}\n\n.obsidian-dev-utils :invalid {\n  box-shadow: 0 0 0 2px var(--text-error);\n}\n.obsidian-dev-utils input.metadata-input-text:active:invalid, .obsidian-dev-utils input.metadata-input-text:focus-visible:invalid, .obsidian-dev-utils input.metadata-input-text:focus:invalid,\n.obsidian-dev-utils input[type=date]:active:invalid,\n.obsidian-dev-utils input[type=date]:focus-visible:invalid,\n.obsidian-dev-utils input[type=date]:focus:invalid,\n.obsidian-dev-utils input[type=datetime-local]:active:invalid,\n.obsidian-dev-utils input[type=datetime-local]:focus-visible:invalid,\n.obsidian-dev-utils input[type=datetime-local]:focus:invalid,\n.obsidian-dev-utils input[type=email]:active:invalid,\n.obsidian-dev-utils input[type=email]:focus-visible:invalid,\n.obsidian-dev-utils input[type=email]:focus:invalid,\n.obsidian-dev-utils input[type=number]:active:invalid,\n.obsidian-dev-utils input[type=number]:focus-visible:invalid,\n.obsidian-dev-utils input[type=number]:focus:invalid,\n.obsidian-dev-utils input[type=password]:active:invalid,\n.obsidian-dev-utils input[type=password]:focus-visible:invalid,\n.obsidian-dev-utils input[type=password]:focus:invalid,\n.obsidian-dev-utils input[type=search]:active:invalid,\n.obsidian-dev-utils input[type=search]:focus-visible:invalid,\n.obsidian-dev-utils input[type=search]:focus:invalid,\n.obsidian-dev-utils input[type=text]:active:invalid,\n.obsidian-dev-utils input[type=text]:focus-visible:invalid,\n.obsidian-dev-utils input[type=text]:focus:invalid,\n.obsidian-dev-utils textarea:active:invalid,\n.obsidian-dev-utils textarea:focus-visible:invalid,\n.obsidian-dev-utils textarea:focus:invalid {\n  box-shadow: 0 0 0 2px var(--text-error);\n}\n.obsidian-dev-utils.setting-component-wrapper {\n  position: relative;\n  display: inline-flex;\n}\n.obsidian-dev-utils.overlay-validator {\n  caret-color: transparent;\n  cursor: default;\n  position: absolute;\n  background-color: transparent;\n  border: none;\n  outline: none;\n  pointer-events: none;\n  z-index: 9999;\n  left: 0;\n  top: 0;\n  width: 100%;\n  height: 100%;\n}\n.obsidian-dev-utils.tooltip.tooltip-validator {\n  position: absolute;\n  top: calc(100% + 8px);\n  width: max-content;\n}\n\n/*# sourceMappingURL=data:application/json;charset=utf-8,%7B%22version%22:3,%22sourceRoot%22:%22%22,%22sources%22:%5B%22../src/styles/code-highlighter-component.scss%22,%22../src/styles/input.scss%22,%22../src/styles/input-time.scss%22,%22../src/styles/loop.scss%22,%22../src/styles/modal-container.scss%22,%22../src/styles/multiple-dropdown-component.scss%22,%22../src/styles/plugin-settings-tab.scss%22,%22../src/styles/prompt-modal.scss%22,%22../src/styles/tri-state-checkbox-component.scss%22,%22../src/styles/validation.scss%22%5D,%22names%22:%5B%5D,%22mappings%22:%22AAEI;EACE;EACA;EACA;;AAGF;EACE;;AAGF;EACE;EACA;EACA;EACA;EACA;;AAGF;EACE;EACA;EACA;EACA;EACA;EACA;EACA;;AAGF;EACE;EACA;EACA;;AAGF;EACE;;AAGF;EACE;EACA;;;ACzCJ;EACE;;AAGF;AAAA;AAAA;AAAA;AAAA;EAKE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;AAGE;EACE;AAAA;AAAA;AAAA;AAAA;IACE;IACA,YACE;;;AAMR;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;EAEE;EACA,YACE;;AAIJ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;EAGE;;AAGF;AAAA;AAAA;AAAA;AAAA;EACE;;AASE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;EAGE;;AAEA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;EACE;EACA;;;AC7DV;AAAA;AAAA;EAGE;EACA;;AAEA;AAAA;AAAA;EACE;EACA;;AAGF;AAAA;AAAA;EACE;EACA;EACA;EACA;;AAMA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;EAEE;EACA;EACA;;AAIK;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;EAGP;;AAEA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;EACE;EACA;;;AAKF;AAAA;AAAA;EACE;;;AAMJ;EACE;;;ACjDJ;EACE;;;ACAA;EACE;EACA;;;ACFF;AAAA;AAAA;EAGE;EACA;;AAEA;AAAA;AAAA;EACE;EACA;;;ACRJ;EACE;;;ACDF;EACE;;;ACDF;EACE;;;ACEJ;EAJA;;AAoBI;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;EApBJ;;AA0BA;EACE;EACA;;AAGF;EACE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;AAGF;EACE;EACA;EACA%22,%22file%22:%22styles.css%22,%22sourcesContent%22:%5B%22.obsidian-dev-utils%20%7B%5Cn%20%20&.code-highlighter-component%20%7B%5Cn%20%20%20%20textarea,%20pre,%20code%20%7B%5Cn%20%20%20%20%20%20font-family:%20var(--font-monospace);%5Cn%20%20%20%20%20%20line-height:%20var(--line-height-normal);%5Cn%20%20%20%20%20%20margin:%200;%5Cn%20%20%20%20%7D%5Cn%5Cn%20%20%20%20textarea,%20code%20%7B%5Cn%20%20%20%20%20%20font-size:%20var(--code-size);%5Cn%20%20%20%20%7D%5Cn%5Cn%20%20%20%20textarea%20%7B%5Cn%20%20%20%20%20%20background:%20transparent;%5Cn%20%20%20%20%20%20color:%20transparent;%5Cn%20%20%20%20%20%20z-index:%202;%5Cn%20%20%20%20%20%20width:%2020em;%5Cn%20%20%20%20%20%20height:%2010em;%5Cn%20%20%20%20%7D%5Cn%5Cn%20%20%20%20pre%20%7B%5Cn%20%20%20%20%20%20position:%20absolute;%5Cn%20%20%20%20%20%20pointer-events:%20none;%5Cn%20%20%20%20%20%20border:%20var(--input-border-width)%20solid%20transparent;%5Cn%20%20%20%20%20%20overflow:%20auto;%5Cn%20%20%20%20%20%20inset:%200;%5Cn%20%20%20%20%20%20padding:%20var(--size-4-1)%20var(--size-4-2);%5Cn%20%20%20%20%20%20z-index:%201;%5Cn%20%20%20%20%7D%5Cn%5Cn%20%20%20%20pre::after%20%7B%5Cn%20%20%20%20%20%20content:%20%5C%22%5C%22;%5Cn%20%20%20%20%20%20display:%20block;%5Cn%20%20%20%20%20%20height:%20var(--bottom-gap,%200);%5Cn%20%20%20%20%7D%5Cn%5Cn%20%20%20%20pre.is-placeholder%20%7B%5Cn%20%20%20%20%20%20opacity:%200.6;%5Cn%20%20%20%20%7D%5Cn%5Cn%20%20%20%20code%20%7B%5Cn%20%20%20%20%20%20display:%20block;%5Cn%20%20%20%20%20%20padding:%200;%5Cn%20%20%20%20%7D%5Cn%20%20%7D%5Cn%7D%5Cn%22,%22.obsidian-dev-utils%20%7B%5Cn%20%20input%5Btype='url'%5D%20%7B%5Cn%20%20%20%20height:%20var(--input-height)%5Cn%20%20%7D%5Cn%5Cn%20%20input%5Btype='month'%5D,%5Cn%20%20input%5Btype='tel'%5D,%5Cn%20%20input%5Btype='time'%5D,%5Cn%20%20input%5Btype='url'%5D,%5Cn%20%20input%5Btype='week'%5D%20%7B%5Cn%20%20%20%20-webkit-app-region:%20no-drag;%5Cn%20%20%20%20background:%20var(--background-modifier-form-field);%5Cn%20%20%20%20border:%20var(--input-border-width)%20solid%20var(--background-modifier-border);%5Cn%20%20%20%20color:%20var(--text-normal);%5Cn%20%20%20%20font-family:%20inherit;%5Cn%20%20%20%20padding:%20var(--size-4-1)%20var(--size-4-2);%5Cn%20%20%20%20font-size:%20var(--font-ui-small);%5Cn%20%20%20%20border-radius:%20var(--input-radius);%5Cn%20%20%20%20outline:%20none;%5Cn%5Cn%20%20%20%20@at-root%20%7B%5Cn%20%20%20%20%20%20@media%20(hover:%20hover)%20%7B%5Cn%20%20%20%20%20%20%20%20&:hover%20%7B%5Cn%20%20%20%20%20%20%20%20%20%20border-color:%20var(--background-modifier-border-hover);%5Cn%20%20%20%20%20%20%20%20%20%20transition:%5Cn%20%20%20%20%20%20%20%20%20%20%20%20box-shadow%200.15s%20ease-in-out,%5Cn%20%20%20%20%20%20%20%20%20%20%20%20border%200.15s%20ease-in-out;%5Cn%20%20%20%20%20%20%20%20%7D%5Cn%20%20%20%20%20%20%7D%5Cn%20%20%20%20%7D%5Cn%5Cn%20%20%20%20&:active,%5Cn%20%20%20%20&:focus%20%7B%5Cn%20%20%20%20%20%20border-color:%20var(--background-modifier-border-focus);%5Cn%20%20%20%20%20%20transition:%5Cn%20%20%20%20%20%20%20%20box-shadow%200.15s%20ease-in-out,%5Cn%20%20%20%20%20%20%20%20border%200.15s%20ease-in-out;%5Cn%20%20%20%20%7D%5Cn%5Cn%20%20%20%20&:active,%5Cn%20%20%20%20&:focus,%5Cn%20%20%20%20&:focus-visible%20%7B%5Cn%20%20%20%20%20%20box-shadow:%200%200%200%202px%20var(--background-modifier-border-focus);%5Cn%20%20%20%20%7D%5Cn%5Cn%20%20%20%20&::placeholder%20%7B%5Cn%20%20%20%20%20%20color:%20var(--text-faint);%5Cn%20%20%20%20%7D%5Cn%20%20%7D%5Cn%5Cn%20%20@at-root%20%7B%5Cn%20%20%20%20.mod-rtl,%5Cn%20%20%20%20.is-rtl,%5Cn%20%20%20%20.rtl%20%7B%5Cn%20%20%20%20%20%20&%20%7B%5Cn%20%20%20%20%20%20%20%20input%5Btype='month'%5D,%5Cn%20%20%20%20%20%20%20%20input%5Btype='time'%5D,%5Cn%20%20%20%20%20%20%20%20input%5Btype='week'%5D%20%7B%5Cn%20%20%20%20%20%20%20%20%20%20direction:%20rtl;%5Cn%5Cn%20%20%20%20%20%20%20%20%20%20&::-webkit-calendar-picker-indicator%20%7B%5Cn%20%20%20%20%20%20%20%20%20%20%20%20right:%20var(--size-4-1);%5Cn%20%20%20%20%20%20%20%20%20%20%20%20left:%20auto;%5Cn%20%20%20%20%20%20%20%20%20%20%7D%5Cn%20%20%20%20%20%20%20%20%7D%5Cn%20%20%20%20%20%20%7D%5Cn%20%20%20%20%7D%5Cn%20%20%7D%5Cn%7D%5Cn%22,%22.obsidian-dev-utils%20%7B%5Cn%20%20input%5Btype='month'%5D,%5Cn%20%20input%5Btype='time'%5D,%5Cn%20%20input%5Btype='week'%5D%20%7B%5Cn%20%20%20%20font-variant-numeric:%20tabular-nums;%5Cn%20%20%20%20position:%20relative;%5Cn%5Cn%20%20%20%20&::-webkit-datetime-edit-text%20%7B%5Cn%20%20%20%20%20%20color:%20var(--text-faint);%5Cn%20%20%20%20%20%20padding-inline-end:%200;%5Cn%20%20%20%20%7D%5Cn%5Cn%20%20%20%20&::-webkit-calendar-picker-indicator%20%7B%5Cn%20%20%20%20%20%20position:%20absolute;%5Cn%20%20%20%20%20%20left:%20var(--size-4-1);%5Cn%20%20%20%20%20%20right:%20auto;%5Cn%20%20%20%20%20%20opacity:%200.5;%5Cn%20%20%20%20%7D%5Cn%5Cn%20%20%20%20&::-webkit-datetime-edit-month-field,%5Cn%20%20%20%20&::-webkit-datetime-edit-day-field,%5Cn%20%20%20%20&::-webkit-datetime-edit-year-field%20%7B%5Cn%20%20%20%20%20%20&:active,%5Cn%20%20%20%20%20%20&:focus%20%7B%5Cn%20%20%20%20%20%20%20%20background-color:%20var(--text-selection);%5Cn%20%20%20%20%20%20%20%20color:%20var(--text-normal);%5Cn%20%20%20%20%20%20%20%20cursor:%20text;%5Cn%20%20%20%20%20%20%7D%5Cn%20%20%20%20%7D%5Cn%5Cn%20%20%20%20@at-root%20.mod-rtl%20&,%5Cn%20%20%20%20%20%20.is-rtl%20&,%5Cn%20%20%20%20%20%20.rtl%20&%20%7B%5Cn%20%20%20%20%20%20direction:%20rtl;%5Cn%5Cn%20%20%20%20%20%20&::-webkit-calendar-picker-indicator%20%7B%5Cn%20%20%20%20%20%20%20%20left:%20auto;%5Cn%20%20%20%20%20%20%20%20right:%20var(--size-4-1);%5Cn%20%20%20%20%20%20%7D%5Cn%20%20%20%20%7D%5Cn%5Cn%20%20%20%20@at-root%20%7B%5Cn%20%20%20%20%20%20body:not(.is-ios):not(.is-android)%20&%20%7B%5Cn%20%20%20%20%20%20%20%20padding-inline-start:%20var(--size-4-6);%5Cn%20%20%20%20%20%20%7D%5Cn%20%20%20%20%7D%5Cn%20%20%7D%5Cn%5Cn%20%20input%5Btype='time'%5D%20%7B%5Cn%20%20%20%20&::-webkit-calendar-picker-indicator%20%7B%5Cn%20%20%20%20%20%20margin-inline-start:%200;%5Cn%20%20%20%20%7D%5Cn%20%20%7D%5Cn%7D%5Cn%22,%22.obsidian-dev-utils%20%7B%5Cn%20%20&progress.loop%20%7B%5Cn%20%20%20%20min-width:%20200px;%5Cn%20%20%7D%5Cn%7D%5Cn%22,%22.obsidian-dev-utils%20%7B%5Cn%20%20&.modal-container%20%7B%5Cn%20%20%20%20.ok-button%20%7B%5Cn%20%20%20%20%20%20margin-right:%2010px;%5Cn%20%20%20%20%20%20margin-top:%2020px;%5Cn%20%20%20%20%7D%5Cn%20%20%7D%5Cn%7D%5Cn%22,%22.obsidian-dev-utils%20%7B%5Cn%20%20.multiple-dropdown-component%20%7B%5Cn%20%20%20%20select,%5Cn%20%20%20%20select:focus,%5Cn%20%20%20%20.dropdown%20%7B%5Cn%20%20%20%20%20%20height:%20auto;%5Cn%20%20%20%20%20%20padding-top:%203px;%5Cn%5Cn%20%20%20%20%20%20option:checked%20%7B%5Cn%20%20%20%20%20%20%20%20background-color:%20%231967d2;%5Cn%20%20%20%20%20%20%20%20color:%20%23fff;%5Cn%20%20%20%20%20%20%7D%5Cn%20%20%20%20%7D%5Cn%20%20%7D%5Cn%7D%5Cn%22,%22.obsidian-dev-utils%20%7B%5Cn%20%20&.plugin-settings-tab%20%7B%5Cn%20%20%20%20a:focus%20%7B%5Cn%20%20%20%20%20%20outline:%202px%20solid%20var(--link-color);%5Cn%20%20%20%20%7D%5Cn%20%20%7D%5Cn%7D%5Cn%22,%22.obsidian-dev-utils%20%7B%5Cn%20%20&.prompt-modal%20%7B%5Cn%20%20%20%20.text-box%20%7B%5Cn%20%20%20%20%20%20width:%20100%25;%5Cn%20%20%20%20%7D%5Cn%20%20%7D%5Cn%7D%5Cn%22,%22.obsidian-dev-utils%20%7B%5Cr%5Cn%20%20&.tri-state-checkbox-component%20%7B%5Cr%5Cn%20%20%20%20input%5Btype='checkbox'%5D:indeterminate%20%7B%5Cr%5Cn%20%20%20%20%20%20appearance:%20checkbox;%5Cr%5Cn%20%20%20%20%7D%5Cr%5Cn%20%20%7D%5Cr%5Cn%7D%5Cr%5Cn%22,%22@mixin%20invalid%20%7B%5Cn%20%20box-shadow:%200%200%200%202px%20var(--text-error);%5Cn%7D%5Cn%5Cn.obsidian-dev-utils%20%7B%5Cn%20%20:invalid%20%7B%5Cn%20%20%20%20@include%20invalid;%5Cn%20%20%7D%5Cn%5Cn%20%20input.metadata-input-text,%5Cn%20%20input%5Btype='date'%5D,%5Cn%20%20input%5Btype='datetime-local'%5D,%5Cn%20%20input%5Btype='email'%5D,%5Cn%20%20input%5Btype='number'%5D,%5Cn%20%20input%5Btype='password'%5D,%5Cn%20%20input%5Btype='search'%5D,%5Cn%20%20input%5Btype='text'%5D,%5Cn%20%20textarea%20%7B%5Cn%20%20%20%20&:active,%5Cn%20%20%20%20&:focus-visible,%5Cn%20%20%20%20&:focus%20%7B%5Cn%20%20%20%20%20%20&:invalid%20%7B%5Cn%20%20%20%20%20%20%20%20@include%20invalid;%5Cn%20%20%20%20%20%20%7D%5Cn%20%20%20%20%7D%5Cn%20%20%7D%5Cn%5Cn%20%20&.setting-component-wrapper%20%7B%5Cn%20%20%20%20position:%20relative;%5Cn%20%20%20%20display:%20inline-flex;%5Cn%20%20%7D%5Cn%5Cn%20%20&.overlay-validator%20%7B%5Cn%20%20%20%20caret-color:%20transparent;%5Cn%20%20%20%20cursor:%20default;%5Cn%20%20%20%20position:%20absolute;%5Cn%20%20%20%20background-color:%20transparent;%5Cn%20%20%20%20border:%20none;%5Cn%20%20%20%20outline:%20none;%5Cn%20%20%20%20pointer-events:%20none;%5Cn%20%20%20%20z-index:%209999;%5Cn%20%20%20%20left:%200;%5Cn%20%20%20%20top:%200;%5Cn%20%20%20%20width:%20100%25;%5Cn%20%20%20%20height:%20100%25;%5Cn%20%20%7D%5Cn%5Cn%20%20&.tooltip.tooltip-validator%20%7B%5Cn%20%20%20%20position:%20absolute;%5Cn%20%20%20%20top:%20calc(100%25%20+%208px);%5Cn%20%20%20%20width:%20max-content;%5Cn%20%20%7D%5Cn%7D%5Cn%22%5D%7D */\n";
 export {

package/dist/lib/esm/object-utils.d.mts

@@ -80,9 +80,10 @@ interface TokenSubstitutions {
     maxDepthLimitReached: string;
     toJSONFailed: string;
 }
-type KeysWithUndefined<T> = {
+type KeysWithUndefined<T> = KeysWithUndefinedMap<T>[keyof T];
+type KeysWithUndefinedMap<T> = {
     [K in keyof T]-?: undefined extends T[K] ? K : never;
-}[keyof T];
+};
 type MandatoryKeysWithUndefined<T extends object> = Extract<RequiredKeysOf<T> & StringKeys<T>, KeysWithUndefined<T>>;
 type RemoveUndefinedOverload<T extends object> = MandatoryKeysWithUndefined<T> extends never ? [obj: T] : never;
 type RemoveUndefinedWithKeysOverload<T extends object, K extends readonly string[]> = [obj: T, keysToKeep: ExactMembers<MandatoryKeysWithUndefined<T>, K>];