obsidian-dev-utils 12.0.1-beta.9 → 12.1.1-beta.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # CHANGELOG
 
+## 12.1.0
+
+- Don't fail when no root dir
+- Set process.browser
+- Switch to debug lib
+
 ## 12.0.0
 
 - Refactor appendCodeBlock to DocumentFragment or HTMLElement

package/dist/lib/@types/debug.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @packageDocumentation debug
+ * Fixed typings for the `debug` package.
+ */
+
+export { };
+
+declare module 'debug' {
+  interface Debug {
+    /**
+     * Loads the debug configuration from the environment.
+     * @returns The loaded debug configuration.
+     */
+    load(): string;
+  }
+}

package/dist/lib/Async.cjs

@@ -44,6 +44,7 @@ __export(Async_exports, {
 module.exports = __toCommonJS(Async_exports);
 var import_Debug = require('./Debug.cjs');
 var import_Error = require('./Error.cjs');
+const retryWithTimeoutDebugger = (0, import_Debug.getDebugger)("obsidian-dev-utils:Async:retryWithTimeout");
 async function addErrorHandler(asyncFn) {
   try {
     await asyncFn();
@@ -75,8 +76,8 @@ function invokeAsyncSafely(asyncFn) {
 function marksAsTerminateRetry(error) {
   return Object.assign(error, { __terminateRetry: true });
 }
-async function retryWithTimeout(fn, retryOptions = {}) {
-  const stackTrace = (0, import_Error.getStackTrace)();
+async function retryWithTimeout(fn, retryOptions = {}, stackTrace) {
+  stackTrace ??= (0, import_Error.getStackTrace)(1);
   const DEFAULT_RETRY_OPTIONS = {
     retryDelayInMilliseconds: 100,
     shouldRetryOnError: false,
@@ -100,14 +101,15 @@ async function retryWithTimeout(fn, retryOptions = {}) {
       }
       if (isSuccess) {
         if (attempt > 1) {
-          (0, import_Debug.getDebugger)("obsidian-dev-utils:Async:runWithTimeout")(`Retry completed successfully after ${attempt.toString()} attempts`);
+          retryWithTimeoutDebugger(`Retry completed successfully after ${attempt.toString()} attempts`);
+          retryWithTimeoutDebugger.printStackTrace(stackTrace);
         }
         return;
       }
-      (0, import_Debug.getDebugger)("obsidian-dev-utils:Async:runWithTimeout")(`Retry attempt ${attempt.toString()} completed unsuccessfully. Trying again in ${fullOptions.retryDelayInMilliseconds.toString()} milliseconds`, {
-        fn,
-        stackTrace
+      retryWithTimeoutDebugger(`Retry attempt ${attempt.toString()} completed unsuccessfully. Trying again in ${fullOptions.retryDelayInMilliseconds.toString()} milliseconds`, {
+        fn
       });
+      retryWithTimeoutDebugger.printStackTrace(stackTrace);
       await sleep(fullOptions.retryDelayInMilliseconds);
     }
   });
@@ -138,7 +140,7 @@ async function runWithTimeout(timeoutInMilliseconds, fn) {
     const duration = performance.now() - startTime;
     console.warn(`Timed out in ${duration.toString()} milliseconds`, { fn });
     if ((0, import_Debug.getDebugger)("obsidian-dev-utils:Async:timeout").enabled) {
-      console.warn("The execution is not terminated because localStorage.debug='obsidian-dev-utils:Async:timeout' is enabled. See https://github.com/debug-js/debug?tab=readme-ov-file#browser-support for more information");
+      console.warn("The execution is not terminated because debugger obsidian-dev-utils:Async:timeout is enabled. See window.enableDebuggers and https://github.com/debug-js/debug?tab=readme-ov-file#browser-support for more information");
       await timeout2();
     }
   }
@@ -173,4 +175,4 @@ async function toArray(iter) {
   timeout,
   toArray
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/Async.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation Async\n * Contains utility functions for asynchronous operations.\n */\n\nimport { getDebugger } from './Debug.ts';\nimport {\n  emitAsyncErrorEvent,\n  getStackTrace,\n  printError\n} from './Error.ts';\n\n/**\n * A type representing a value that can either be a direct value or a Promise resolving to that value.\n * @typeParam T - The type of the value.\n */\nexport type MaybePromise<T> = Promise<T> | T;\n\n/**\n * Options for configuring the retry behavior.\n */\nexport interface RetryOptions {\n  /**\n   * The abort signal to cancel the retry operation.\n   */\n  abortSignal?: AbortSignal;\n\n  /**\n   * The delay in milliseconds between retry attempts.\n   */\n  retryDelayInMilliseconds?: number;\n\n  /**\n   * Whether to retry the function on error.\n   */\n  shouldRetryOnError?: boolean;\n\n  /**\n   * The maximum time in milliseconds to wait before giving up on retrying.\n   */\n  timeoutInMilliseconds?: number;\n}\n\n/**\n * A marker interface to indicate that an error should terminate retry logic.\n */\nexport interface TerminateRetry {\n  /**\n   * A marker property to indicate that an error should terminate retry logic.\n   */\n  __terminateRetry: true;\n}\n\n/**\n * Adds an error handler to a 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 * @returns A Promise that resolves when the asynchronous function completes or emits async error event.\n */\nexport async function addErrorHandler(asyncFn: () => Promise<unknown>): Promise<void> {\n  try {\n    await asyncFn();\n  } catch (asyncError) {\n    emitAsyncErrorEvent(asyncError);\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 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[]) => MaybePromise<boolean>): Promise<T[]> {\n  const predicateResults = await asyncMap(arr, predicate);\n  return arr.filter((_, index) => predicateResults[index]);\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 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[]) => MaybePromise<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 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[]) => MaybePromise<U>): Promise<U[]> {\n  return await Promise.all(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 * @returns A function that wraps the asynchronous function in a synchronous interface.\n */\nexport function convertAsyncToSync<Args extends unknown[]>(asyncFunc: (...args: Args) => Promise<unknown>): (...args: Args) => void {\n  return (...args: Args): void => {\n    invokeAsyncSafely(() => asyncFunc(...args));\n  };\n}\n\n/**\n * Converts a synchronous function to an asynchronous one by wrapping it in a 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: (...args: Args) => Result): (...args: Args) => Promise<Result> {\n  return (...args: Args): Promise<Result> => Promise.resolve().then(() => syncFn(...args));\n}\n\n/**\n * Invokes a 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 */\nexport function invokeAsyncSafely(asyncFn: () => Promise<unknown>): void {\n  void addErrorHandler(asyncFn);\n}\n\n/**\n * Marks an error to terminate retry logic.\n *\n * @param error - The error to mark to terminate retry logic.\n * @returns An error that should terminate retry logic.\n */\nexport function marksAsTerminateRetry<TError extends Error>(error: TError): TerminateRetry & TError {\n  return Object.assign(error, { __terminateRetry: true } as TerminateRetry);\n}\n\n/**\n * Retries the provided function until it returns true or the timeout is reached.\n *\n * @param fn - The function to retry.\n * @param retryOptions - Optional parameters to configure the retry behavior.\n * @returns A Promise that resolves when the function returns true or rejects when the timeout is reached.\n */\nexport async function retryWithTimeout(fn: () => MaybePromise<boolean>, retryOptions: RetryOptions = {}): Promise<void> {\n  const stackTrace = getStackTrace();\n  const DEFAULT_RETRY_OPTIONS = {\n    retryDelayInMilliseconds: 100,\n    shouldRetryOnError: false,\n    timeoutInMilliseconds: 5000\n  };\n  const fullOptions = { ...DEFAULT_RETRY_OPTIONS, ...retryOptions };\n  await runWithTimeout(fullOptions.timeoutInMilliseconds, async () => {\n    let attempt = 0;\n    for (; ;) {\n      fullOptions.abortSignal?.throwIfAborted();\n      attempt++;\n      let isSuccess: boolean;\n      try {\n        isSuccess = await fn();\n      } catch (error) {\n        if (!fullOptions.shouldRetryOnError || (error as Partial<TerminateRetry>).__terminateRetry) {\n          throw error;\n        }\n        printError(error);\n        isSuccess = false;\n      }\n      if (isSuccess) {\n        if (attempt > 1) {\n          getDebugger('obsidian-dev-utils:Async:runWithTimeout')(`Retry completed successfully after ${attempt.toString()} attempts`);\n        }\n        return;\n      }\n\n      getDebugger('obsidian-dev-utils:Async:runWithTimeout')(`Retry attempt ${attempt.toString()} completed unsuccessfully. Trying again in ${fullOptions.retryDelayInMilliseconds.toString()} milliseconds`, {\n        fn,\n        stackTrace\n      });\n      await sleep(fullOptions.retryDelayInMilliseconds);\n    }\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 R - The type of the result from the asynchronous function.\n * @param timeoutInMilliseconds - The maximum time to wait in milliseconds.\n * @param fn - The function to execute.\n * @returns A Promise that resolves with the result of the asynchronous function or rejects if it times out.\n */\nexport async function runWithTimeout<R>(timeoutInMilliseconds: number, fn: () => MaybePromise<R>): Promise<R> {\n  let isTimedOut = true;\n  let result: R = null as R;\n  const startTime = performance.now();\n  await Promise.race([run(), timeout()]);\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n  if (isTimedOut) {\n    throw new Error('Timed out');\n  }\n  return result;\n\n  async function run(): Promise<void> {\n    result = await fn();\n    isTimedOut = false;\n    const duration = performance.now() - startTime;\n    getDebugger('obsidian-dev-utils:Async:runWithTimeout')(`Execution time: ${duration.toString()} milliseconds`, { fn });\n  }\n\n  async function timeout(): Promise<void> {\n    if (!isTimedOut) {\n      return;\n    }\n    await sleep(timeoutInMilliseconds);\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n    if (!isTimedOut) {\n      return;\n    }\n    const duration = performance.now() - startTime;\n    console.warn(`Timed out in ${duration.toString()} milliseconds`, { fn });\n    if (getDebugger('obsidian-dev-utils:Async:timeout').enabled) {\n      console.warn('The execution is not terminated because localStorage.debug=\\'obsidian-dev-utils:Async:timeout\\' is enabled. See https://github.com/debug-js/debug?tab=readme-ov-file#browser-support for more information');\n      await timeout();\n    }\n  }\n}\n\n/**\n * Delays execution for a specified number of milliseconds.\n *\n * @param milliseconds - The time to wait in milliseconds.\n * @returns A Promise that resolves after the specified delay.\n */\nexport async function sleep(milliseconds: number): Promise<void> {\n  await new Promise((resolve) => setTimeout(resolve, milliseconds));\n}\n\n/**\n * Returns a Promise that rejects after the specified timeout period.\n *\n * @param timeoutInMilliseconds - The timeout period in milliseconds.\n * @returns A Promise that always rejects with a timeout error.\n */\nexport async function timeout(timeoutInMilliseconds: number): Promise<never> {\n  await sleep(timeoutInMilliseconds);\n  throw new Error(`Timed out in ${timeoutInMilliseconds.toString()} 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 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": ["timeout"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/Async.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation Async\n * Contains utility functions for asynchronous operations.\n */\n\nimport { getDebugger } from './Debug.ts';\nimport {\n  emitAsyncErrorEvent,\n  getStackTrace,\n  printError\n} from './Error.ts';\n\n/**\n * A type representing a value that can either be a direct value or a Promise resolving to that value.\n * @typeParam T - The type of the value.\n */\nexport type MaybePromise<T> = Promise<T> | T;\n\n/**\n * Options for configuring the retry behavior.\n */\nexport interface RetryOptions {\n  /**\n   * The abort signal to cancel the retry operation.\n   */\n  abortSignal?: AbortSignal;\n\n  /**\n   * The delay in milliseconds between retry attempts.\n   */\n  retryDelayInMilliseconds?: number;\n\n  /**\n   * Whether to retry the function on error.\n   */\n  shouldRetryOnError?: boolean;\n\n  /**\n   * The maximum time in milliseconds to wait before giving up on retrying.\n   */\n  timeoutInMilliseconds?: number;\n}\n\n/**\n * A marker interface to indicate that an error should terminate retry logic.\n */\nexport interface TerminateRetry {\n  /**\n   * A marker property to indicate that an error should terminate retry logic.\n   */\n  __terminateRetry: true;\n}\n\nconst retryWithTimeoutDebugger = getDebugger('obsidian-dev-utils:Async:retryWithTimeout');\n\n/**\n * Adds an error handler to a 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 * @returns A Promise that resolves when the asynchronous function completes or emits async error event.\n */\nexport async function addErrorHandler(asyncFn: () => Promise<unknown>): Promise<void> {\n  try {\n    await asyncFn();\n  } catch (asyncError) {\n    emitAsyncErrorEvent(asyncError);\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 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[]) => MaybePromise<boolean>): Promise<T[]> {\n  const predicateResults = await asyncMap(arr, predicate);\n  return arr.filter((_, index) => predicateResults[index]);\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 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[]) => MaybePromise<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 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[]) => MaybePromise<U>): Promise<U[]> {\n  return await Promise.all(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 * @returns A function that wraps the asynchronous function in a synchronous interface.\n */\nexport function convertAsyncToSync<Args extends unknown[]>(asyncFunc: (...args: Args) => Promise<unknown>): (...args: Args) => void {\n  return (...args: Args): void => {\n    invokeAsyncSafely(() => asyncFunc(...args));\n  };\n}\n\n/**\n * Converts a synchronous function to an asynchronous one by wrapping it in a 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: (...args: Args) => Result): (...args: Args) => Promise<Result> {\n  return (...args: Args): Promise<Result> => Promise.resolve().then(() => syncFn(...args));\n}\n\n/**\n * Invokes a 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 */\nexport function invokeAsyncSafely(asyncFn: () => Promise<unknown>): void {\n  void addErrorHandler(asyncFn);\n}\n\n/**\n * Marks an error to terminate retry logic.\n *\n * @param error - The error to mark to terminate retry logic.\n * @returns An error that should terminate retry logic.\n */\nexport function marksAsTerminateRetry<TError extends Error>(error: TError): TerminateRetry & TError {\n  return Object.assign(error, { __terminateRetry: true } as TerminateRetry);\n}\n\n/**\n * Retries the provided function until it returns true or the timeout is reached.\n *\n * @param fn - The function to retry.\n * @param retryOptions - Optional parameters to configure the retry behavior.\n * @param stackTrace - Optional stack trace.\n * @returns A Promise that resolves when the function returns true or rejects when the timeout is reached.\n */\nexport async function retryWithTimeout(fn: () => MaybePromise<boolean>, retryOptions: RetryOptions = {}, stackTrace?: string): Promise<void> {\n  stackTrace ??= getStackTrace(1);\n  const DEFAULT_RETRY_OPTIONS = {\n    retryDelayInMilliseconds: 100,\n    shouldRetryOnError: false,\n    timeoutInMilliseconds: 5000\n  };\n  const fullOptions = { ...DEFAULT_RETRY_OPTIONS, ...retryOptions };\n  await runWithTimeout(fullOptions.timeoutInMilliseconds, async () => {\n    let attempt = 0;\n    for (; ;) {\n      fullOptions.abortSignal?.throwIfAborted();\n      attempt++;\n      let isSuccess: boolean;\n      try {\n        isSuccess = await fn();\n      } catch (error) {\n        if (!fullOptions.shouldRetryOnError || (error as Partial<TerminateRetry>).__terminateRetry) {\n          throw error;\n        }\n        printError(error);\n        isSuccess = false;\n      }\n      if (isSuccess) {\n        if (attempt > 1) {\n          retryWithTimeoutDebugger(`Retry completed successfully after ${attempt.toString()} attempts`);\n          retryWithTimeoutDebugger.printStackTrace(stackTrace);\n        }\n        return;\n      }\n\n      retryWithTimeoutDebugger(`Retry attempt ${attempt.toString()} completed unsuccessfully. Trying again in ${fullOptions.retryDelayInMilliseconds.toString()} milliseconds`, {\n        fn\n      });\n      retryWithTimeoutDebugger.printStackTrace(stackTrace);\n      await sleep(fullOptions.retryDelayInMilliseconds);\n    }\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 R - The type of the result from the asynchronous function.\n * @param timeoutInMilliseconds - The maximum time to wait in milliseconds.\n * @param fn - The function to execute.\n * @returns A Promise that resolves with the result of the asynchronous function or rejects if it times out.\n */\nexport async function runWithTimeout<R>(timeoutInMilliseconds: number, fn: () => MaybePromise<R>): Promise<R> {\n  let isTimedOut = true;\n  let result: R = null as R;\n  const startTime = performance.now();\n  await Promise.race([run(), timeout()]);\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n  if (isTimedOut) {\n    throw new Error('Timed out');\n  }\n  return result;\n\n  async function run(): Promise<void> {\n    result = await fn();\n    isTimedOut = false;\n    const duration = performance.now() - startTime;\n    getDebugger('obsidian-dev-utils:Async:runWithTimeout')(`Execution time: ${duration.toString()} milliseconds`, { fn });\n  }\n\n  async function timeout(): Promise<void> {\n    if (!isTimedOut) {\n      return;\n    }\n    await sleep(timeoutInMilliseconds);\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n    if (!isTimedOut) {\n      return;\n    }\n    const duration = performance.now() - startTime;\n    console.warn(`Timed out in ${duration.toString()} milliseconds`, { fn });\n    if (getDebugger('obsidian-dev-utils:Async:timeout').enabled) {\n      console.warn('The execution is not terminated because debugger obsidian-dev-utils:Async:timeout is enabled. See window.enableDebuggers and https://github.com/debug-js/debug?tab=readme-ov-file#browser-support for more information');\n      await timeout();\n    }\n  }\n}\n\n/**\n * Delays execution for a specified number of milliseconds.\n *\n * @param milliseconds - The time to wait in milliseconds.\n * @returns A Promise that resolves after the specified delay.\n */\nexport async function sleep(milliseconds: number): Promise<void> {\n  await new Promise((resolve) => setTimeout(resolve, milliseconds));\n}\n\n/**\n * Returns a Promise that rejects after the specified timeout period.\n *\n * @param timeoutInMilliseconds - The timeout period in milliseconds.\n * @returns A Promise that always rejects with a timeout error.\n */\nexport async function timeout(timeoutInMilliseconds: number): Promise<never> {\n  await sleep(timeoutInMilliseconds);\n  throw new Error(`Timed out in ${timeoutInMilliseconds.toString()} 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 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": ["timeout"]
}


package/dist/lib/Async.d.ts

@@ -108,9 +108,10 @@ export declare function marksAsTerminateRetry<TError extends Error>(error: TErro
  *
  * @param fn - The function to retry.
  * @param retryOptions - Optional parameters to configure the retry behavior.
+ * @param stackTrace - Optional stack trace.
  * @returns A Promise that resolves when the function returns true or rejects when the timeout is reached.
  */
-export declare function retryWithTimeout(fn: () => MaybePromise<boolean>, retryOptions?: RetryOptions): Promise<void>;
+export declare function retryWithTimeout(fn: () => MaybePromise<boolean>, retryOptions?: RetryOptions, stackTrace?: string): Promise<void>;
 /**
  * Executes a function with a timeout. If the function does not complete within the specified time, it is considered to have timed out.
  *

package/dist/lib/Debug.cjs

@@ -37,25 +37,93 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var Debug_exports = {};
 __export(Debug_exports, {
-  getDebugger: () => getDebugger
+  getDebugger: () => getDebugger,
+  initDebugHelpers: () => initDebugHelpers
 });
 module.exports = __toCommonJS(Debug_exports);
 var import_debug = __toESM(__extractDefault(require('debug')), 1);
-function getDebugger(id) {
-  const debugInstance = import_debug.default.default(id);
-  debugInstance.log = logWithCaller;
+const NAMESPACE_SEPARATOR = ",";
+const NEGATED_NAMESPACE_PREFIX = "-";
+function getDebugger(namespace) {
+  const debugInstance = import_debug.default.default(namespace);
+  debugInstance.log = (message, ...args) => {
+    logWithCaller(namespace, message, ...args);
+  };
+  debugInstance.printStackTrace = (stackTrace, title) => {
+    printStackTrace(namespace, stackTrace, title);
+  };
   return debugInstance;
 }
-function logWithCaller(message, ...args) {
-  const originalCaptureStackTrace = Error.captureStackTrace;
-  Error.captureStackTrace = function(target, constructorOpt) {
-    originalCaptureStackTrace.call(Error, target, constructorOpt);
+function initDebugHelpers() {
+  window.DEBUG = {
+    disable: disableNamespaces,
+    enable: enableNamespaces,
+    get: getNamespaces,
+    set: setNamespaces
   };
+}
+function disableNamespaces(namespaces) {
+  const set = new Set(getNamespaces());
+  for (const namespace of toArray(namespaces)) {
+    if (namespace.startsWith(NEGATED_NAMESPACE_PREFIX)) {
+      continue;
+    }
+    const negatedNamespace = NEGATED_NAMESPACE_PREFIX + namespace;
+    if (set.has(namespace)) {
+      set.delete(namespace);
+    }
+    set.add(negatedNamespace);
+  }
+  setNamespaces(Array.from(set));
+}
+function enableNamespaces(namespaces) {
+  const set = new Set(getNamespaces());
+  for (const namespace of toArray(namespaces)) {
+    if (!namespace.startsWith(NEGATED_NAMESPACE_PREFIX)) {
+      const negatedNamespace = NEGATED_NAMESPACE_PREFIX + namespace;
+      if (set.has(negatedNamespace)) {
+        set.delete(negatedNamespace);
+      }
+    }
+    set.add(namespace);
+  }
+  setNamespaces(Array.from(set));
+}
+function getNamespaces() {
+  return toArray(import_debug.default.load());
+}
+function logWithCaller(namespace, message, ...args) {
+  if (!import_debug.default.enabled(namespace)) {
+    return;
+  }
+  const CALLER_LINE_INDEX = 4;
+  const stackLines = new Error().stack?.split("\n") ?? [];
+  const callerLine = stackLines[CALLER_LINE_INDEX] ?? "";
   console.debug(message, ...args);
-  Error.captureStackTrace = originalCaptureStackTrace;
+  printStackTrace(namespace, callerLine, "Original debug message caller");
+}
+function printStackTrace(namespace, stackTrace, title) {
+  if (!import_debug.default.enabled(namespace)) {
+    return;
+  }
+  if (!stackTrace) {
+    stackTrace = "(unavailable)";
+  }
+  if (!title) {
+    title = "Caller stack trace";
+  }
+  console.debug(`NotError:${namespace}:${title}
+${stackTrace}`);
+}
+function setNamespaces(namespaces) {
+  import_debug.default.enable(toArray(namespaces).join(NAMESPACE_SEPARATOR));
+}
+function toArray(namespaces) {
+  return typeof namespaces === "string" ? namespaces.split(NAMESPACE_SEPARATOR) : namespaces.flatMap(toArray);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  getDebugger
+  getDebugger,
+  initDebugHelpers
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/Debug.d.ts

@@ -2,11 +2,19 @@
  * @packageDocumentation Debug
  * Contains utility functions for debugging.
  */
-import debug from 'debug';
+import type { Debugger } from 'debug';
+interface DebuggerEx extends Debugger {
+    printStackTrace(stackTrace: string, title?: string): void;
+}
 /**
  * Returns a debugger instance with a log function that includes the caller's file name and line number.
  *
- * @param id - The namespace for the debugger instance.
+ * @param namespace - The namespace for the debugger instance.
  * @returns A debugger instance with a log function that includes the caller's file name and line number.
  */
-export declare function getDebugger(id: string): debug.Debugger;
+export declare function getDebugger(namespace: string): DebuggerEx;
+/**
+ * Adds the DEBUG variable to the window object.
+ */
+export declare function initDebugHelpers(): void;
+export {};

package/dist/lib/Error.cjs

@@ -45,10 +45,10 @@ function emitAsyncErrorEvent(asyncError) {
 function errorToString(error) {
   return parseErrorEntries(error).map((entry) => "  ".repeat(entry.level) + entry.message).join("\n");
 }
-function getStackTrace() {
+function getStackTrace(framesToSkip = 0) {
   const stack = new Error().stack ?? "";
   const lines = stack.split("\n");
-  return lines.slice(2).join("\n");
+  return lines.slice(framesToSkip + 2).join("\n");
 }
 function printError(error) {
   const entries = parseErrorEntries(error);
@@ -108,4 +108,4 @@ ${restStack}` });
   registerAsyncErrorEventHandler,
   throwExpression
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/Error.d.ts

@@ -18,9 +18,10 @@ export declare function errorToString(error: unknown): string;
 /**
  * Gets the current stack trace as a string, excluding the current function call.
  *
+ * @param framesToSkip - The number of frames to skip in the stack trace.
  * @returns A string representation of the current stack trace, excluding the current function call.
  */
-export declare function getStackTrace(): string;
+export declare function getStackTrace(framesToSkip?: number): string;
 /**
  * Prints an error to the console, including nested causes and optional ANSI sequence clearing.
  *

package/dist/lib/Object.cjs

@@ -42,6 +42,7 @@ __export(Object_exports, {
 module.exports = __toCommonJS(Object_exports);
 var import_Error = require('./Error.cjs');
 var __process = globalThis["process"] ?? {
+  "browser": true,
   "cwd": () => "/",
   "env": {},
   "platform": "android"
@@ -172,4 +173,4 @@ function _assignWithNonEnumerableProperties(target, ...sources) {
   setNestedPropertyValue,
   toJson
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/Object.ts"],
  "sourcesContent": ["var __process = globalThis['process'] ?? {\n  \"cwd\": ()=>\"/\",\n  \"env\": {},\n  \"platform\": \"android\"\n};\n/**\n * @packageDocumentation Object\n * Contains utility functions for Objects.\n */\n\nimport type { UndefinedOnPartialDeep } from 'type-fest';\n\nimport { throwExpression } from './Error.ts';\n\n/**\n * Options for converting an object to JSON.\n */\nexport interface ToJsonOptions {\n  /**\n   * If `true`, functions within the value will be handled and included in the JSON string. Defaults to `false`.\n   */\n  shouldHandleFunctions?: boolean;\n  /**\n   * Specifies the indentation of the JSON output. This can be a number of spaces or a string. Defaults to `2`.\n   */\n  space?: number | string;\n}\n\n/**\n * Assigns properties from one or more source objects to a target object, including non-enumerable properties.\n *\n * @param target - The target object to assign properties to.\n * @param source - The source object to assign properties from.\n * @returns The target object with the assigned properties.\n */\nexport function assignWithNonEnumerableProperties<T extends object, U>(target: T, source: U): T & U;\n\n/**\n * @param target - The target object to assign properties to.\n * @param source1 - The first source object to assign properties from.\n * @param source2 - The second source object to assign properties from.\n * @returns The target object with the assigned properties.\n */\nexport function assignWithNonEnumerableProperties<T extends object, U, V>(target: T, source1: U, source2: V): T & U & V;\n\n/**\n * Assigns properties from one or more source objects to a target object, including non-enumerable properties.\n *\n * @param target - The target object to assign properties to.\n * @param source1 - The first source object to assign properties from.\n * @param source2 - The second source object to assign properties from.\n * @param source3 - The third source object to assign properties from.\n * @returns The target object with the assigned properties.\n */\nexport function assignWithNonEnumerableProperties<T extends object, U, V, W>(target: T, source1: U, source2: V, source3: W): T & U & V & W;\n\n/**\n * Assigns properties from one or more source objects to a target object, including non-enumerable properties.\n *\n * @param target - The target object to assign properties to.\n * @param sources - The source objects to assign properties from.\n * @returns The target object with the assigned properties.\n */\nexport function assignWithNonEnumerableProperties(target: object, ...sources: object[]): object {\n  return _assignWithNonEnumerableProperties(target, ...sources);\n}\n\n/**\n * Clones an object, including non-enumerable properties.\n *\n * @param obj - The object to clone.\n * @returns A new object with the same properties as the original object, including non-enumerable properties.\n */\nexport function cloneWithNonEnumerableProperties<T extends object>(obj: T): T {\n  return Object.create(getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj)) as T;\n}\n\n/**\n * Compares two values to determine if they are deeply equal.\n *\n * @param a - The first value to compare.\n * @param b - The second value to compare.\n * @returns `true` if the values are deeply equal, otherwise `false`.\n */\nexport function deepEqual(a: unknown, b: unknown): boolean {\n  if (a === b) {\n    return true;\n  }\n\n  if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null) {\n    return false;\n  }\n\n  const keysA = Object.keys(a);\n  const keysB = Object.keys(b);\n\n  if (keysA.length !== keysB.length) {\n    return false;\n  }\n\n  const aRecord = a as Record<string, unknown>;\n  const bRecord = b as Record<string, unknown>;\n\n  for (const key of keysA) {\n    if (!keysB.includes(key) || !deepEqual(aRecord[key], bRecord[key])) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\n/**\n * Deletes multiple properties from an object.\n *\n * @param obj - The object to delete the properties from.\n * @param propertyNames - The names of the properties to delete.\n * @returns `true` if any of the properties were present, otherwise `false`.\n */\nexport function deleteProperties(obj: Record<string, unknown>, propertyNames: string[]): boolean {\n  let ans = false;\n\n  for (const propertyName of propertyNames) {\n    ans = deleteProperty(obj, propertyName) || ans;\n  }\n\n  return ans;\n}\n\n/**\n * Deletes a property from an object.\n *\n * @param obj - The object to delete the property from.\n * @param propertyName - The name of the property to delete.\n * @returns `true` if the property was present, otherwise `false`.\n */\nexport function deleteProperty(obj: Record<string, unknown>, propertyName: string): boolean {\n  if (!Object.prototype.hasOwnProperty.call(obj, propertyName)) {\n    return false;\n  }\n  // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n  delete obj[propertyName];\n  return true;\n}\n\n/**\n * Gets the value of a nested property from an object.\n *\n * @param obj - The object to get the nested property value from.\n * @param path - The path to the nested property.\n * @returns The value of the nested property.\n */\nexport function getNestedPropertyValue(obj: Record<string, unknown>, path: string): unknown {\n  let node: Record<string, unknown> | undefined = obj;\n  const keys = path.split('.');\n  for (const key of keys) {\n    if (node === undefined) {\n      return undefined;\n    }\n    node = node[key] as Record<string, unknown> | undefined;\n  }\n\n  return node;\n}\n\n/**\n * Gets the prototype of the specified object.\n *\n * @typeParam T - The type of the object.\n * @param instance - The object instance to retrieve the prototype of.\n * @returns The prototype of the object.\n */\nexport function getPrototypeOf<T>(instance: T): T {\n  if (instance === undefined || instance === null) {\n    return instance;\n  }\n  return Object.getPrototypeOf(instance) as T;\n}\n\n/**\n * Retrieves the name of a property of a given type `T`.\n *\n * @typeParam T - The type of the object containing the property.\n * @param name - The name of the property as a string.\n * @returns The name of the property.\n */\nexport function nameof<T>(name: Extract<keyof T, string>): string {\n  return name;\n}\n\n/**\n * Normalizes optional properties to allow `undefined` assignment in strict mode.\n *\n * This utility provides a workaround for the `exactOptionalPropertyTypes` TypeScript flag,\n * which prohibits directly assigning `undefined` to optional properties when the type\n * explicitly omits `undefined`.\n *\n * Example:\n * ```typescript\n * // With `exactOptionalPropertyTypes: true`\n * const x: { prop?: string } = { prop: undefined }; // Compiler error\n *\n * // Using this utility:\n * const y: { prop?: string } = normalizeOptionalProperties<{ prop?: string }>({ prop: undefined }); // Works\n * ```\n *\n * @typeParam T - The target type with optional properties to normalize.\n * @param obj - The object to normalize, allowing explicit `undefined` for optional properties.\n * @returns The normalized object, compatible with `exactOptionalPropertyTypes`.\n */\nexport function normalizeOptionalProperties<T>(obj: UndefinedOnPartialDeep<T>): T {\n  return obj as T;\n}\n\n/**\n * Sets the value of a nested property in an object.\n *\n * @param obj - The object to set the nested property value in.\n * @param path - The path to the nested property.\n * @param value - The value to set.\n */\nexport function setNestedPropertyValue(obj: Record<string, unknown>, path: string, value: unknown): void {\n  const error = new Error(`Property path ${path} not found`);\n  let node: Record<string, unknown> | undefined = obj;\n  const keys = path.split('.');\n  for (const key of keys.slice(0, -1)) {\n    if (node === undefined) {\n      throw error;\n    }\n    node = node[key] as Record<string, unknown> | undefined;\n  }\n\n  const lastKey = keys.at(-1);\n  if (node === undefined || lastKey === undefined) {\n    throw error;\n  }\n\n  node[lastKey] = value;\n}\n\n/**\n * Converts a given value to a JSON string.\n *\n * @param value - The value to be converted to JSON. This can be of any type.\n * @param options - Options for customizing the JSON conversion process.\n * @returns The JSON string representation of the input value.\n */\nexport function toJson(value: unknown, options: ToJsonOptions = {}): string {\n  const {\n    shouldHandleFunctions = false,\n    space = 2\n  } = options;\n  if (!shouldHandleFunctions) {\n    return JSON.stringify(value, null, space);\n  }\n\n  const functionTexts: string[] = [];\n\n  const replacer = (_: string, value: unknown): unknown => {\n    if (typeof value === 'function') {\n      const index = functionTexts.length;\n      functionTexts.push(value.toString());\n      return `__FUNCTION_${index.toString()}`;\n    }\n\n    return value;\n  };\n\n  let json = JSON.stringify(value, replacer, space);\n  json = json.replaceAll(/\"__FUNCTION_(\\d+)\"/g, (_, indexStr: string) => functionTexts[parseInt(indexStr)] ?? throwExpression(new Error(`Function with index ${indexStr} not found`)));\n  return json;\n}\n\nfunction _assignWithNonEnumerableProperties(target: object, ...sources: object[]): object {\n  for (const source of sources) {\n    Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));\n  }\n\n  const sourcePrototypes = (sources.map((source) => getPrototypeOf(source)) as (null | object)[]).filter<null | object>((proto) => !!proto) as object[];\n\n  if (sourcePrototypes.length > 0) {\n    const targetPrototype = _assignWithNonEnumerableProperties({}, getPrototypeOf(target), ...sourcePrototypes);\n    Object.setPrototypeOf(target, targetPrototype);\n  }\n\n  return target;\n}\n"],
  "mappings": "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",
  "names": ["value"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/Object.ts"],
  "sourcesContent": ["var __process = globalThis['process'] ?? {\n  \"browser\": true,\n  \"cwd\": ()=>\"/\",\n  \"env\": {},\n  \"platform\": \"android\"\n};\n/**\n * @packageDocumentation Object\n * Contains utility functions for Objects.\n */\n\nimport type { UndefinedOnPartialDeep } from 'type-fest';\n\nimport { throwExpression } from './Error.ts';\n\n/**\n * Options for converting an object to JSON.\n */\nexport interface ToJsonOptions {\n  /**\n   * If `true`, functions within the value will be handled and included in the JSON string. Defaults to `false`.\n   */\n  shouldHandleFunctions?: boolean;\n  /**\n   * Specifies the indentation of the JSON output. This can be a number of spaces or a string. Defaults to `2`.\n   */\n  space?: number | string;\n}\n\n/**\n * Assigns properties from one or more source objects to a target object, including non-enumerable properties.\n *\n * @param target - The target object to assign properties to.\n * @param source - The source object to assign properties from.\n * @returns The target object with the assigned properties.\n */\nexport function assignWithNonEnumerableProperties<T extends object, U>(target: T, source: U): T & U;\n\n/**\n * @param target - The target object to assign properties to.\n * @param source1 - The first source object to assign properties from.\n * @param source2 - The second source object to assign properties from.\n * @returns The target object with the assigned properties.\n */\nexport function assignWithNonEnumerableProperties<T extends object, U, V>(target: T, source1: U, source2: V): T & U & V;\n\n/**\n * Assigns properties from one or more source objects to a target object, including non-enumerable properties.\n *\n * @param target - The target object to assign properties to.\n * @param source1 - The first source object to assign properties from.\n * @param source2 - The second source object to assign properties from.\n * @param source3 - The third source object to assign properties from.\n * @returns The target object with the assigned properties.\n */\nexport function assignWithNonEnumerableProperties<T extends object, U, V, W>(target: T, source1: U, source2: V, source3: W): T & U & V & W;\n\n/**\n * Assigns properties from one or more source objects to a target object, including non-enumerable properties.\n *\n * @param target - The target object to assign properties to.\n * @param sources - The source objects to assign properties from.\n * @returns The target object with the assigned properties.\n */\nexport function assignWithNonEnumerableProperties(target: object, ...sources: object[]): object {\n  return _assignWithNonEnumerableProperties(target, ...sources);\n}\n\n/**\n * Clones an object, including non-enumerable properties.\n *\n * @param obj - The object to clone.\n * @returns A new object with the same properties as the original object, including non-enumerable properties.\n */\nexport function cloneWithNonEnumerableProperties<T extends object>(obj: T): T {\n  return Object.create(getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj)) as T;\n}\n\n/**\n * Compares two values to determine if they are deeply equal.\n *\n * @param a - The first value to compare.\n * @param b - The second value to compare.\n * @returns `true` if the values are deeply equal, otherwise `false`.\n */\nexport function deepEqual(a: unknown, b: unknown): boolean {\n  if (a === b) {\n    return true;\n  }\n\n  if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null) {\n    return false;\n  }\n\n  const keysA = Object.keys(a);\n  const keysB = Object.keys(b);\n\n  if (keysA.length !== keysB.length) {\n    return false;\n  }\n\n  const aRecord = a as Record<string, unknown>;\n  const bRecord = b as Record<string, unknown>;\n\n  for (const key of keysA) {\n    if (!keysB.includes(key) || !deepEqual(aRecord[key], bRecord[key])) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\n/**\n * Deletes multiple properties from an object.\n *\n * @param obj - The object to delete the properties from.\n * @param propertyNames - The names of the properties to delete.\n * @returns `true` if any of the properties were present, otherwise `false`.\n */\nexport function deleteProperties(obj: Record<string, unknown>, propertyNames: string[]): boolean {\n  let ans = false;\n\n  for (const propertyName of propertyNames) {\n    ans = deleteProperty(obj, propertyName) || ans;\n  }\n\n  return ans;\n}\n\n/**\n * Deletes a property from an object.\n *\n * @param obj - The object to delete the property from.\n * @param propertyName - The name of the property to delete.\n * @returns `true` if the property was present, otherwise `false`.\n */\nexport function deleteProperty(obj: Record<string, unknown>, propertyName: string): boolean {\n  if (!Object.prototype.hasOwnProperty.call(obj, propertyName)) {\n    return false;\n  }\n  // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n  delete obj[propertyName];\n  return true;\n}\n\n/**\n * Gets the value of a nested property from an object.\n *\n * @param obj - The object to get the nested property value from.\n * @param path - The path to the nested property.\n * @returns The value of the nested property.\n */\nexport function getNestedPropertyValue(obj: Record<string, unknown>, path: string): unknown {\n  let node: Record<string, unknown> | undefined = obj;\n  const keys = path.split('.');\n  for (const key of keys) {\n    if (node === undefined) {\n      return undefined;\n    }\n    node = node[key] as Record<string, unknown> | undefined;\n  }\n\n  return node;\n}\n\n/**\n * Gets the prototype of the specified object.\n *\n * @typeParam T - The type of the object.\n * @param instance - The object instance to retrieve the prototype of.\n * @returns The prototype of the object.\n */\nexport function getPrototypeOf<T>(instance: T): T {\n  if (instance === undefined || instance === null) {\n    return instance;\n  }\n  return Object.getPrototypeOf(instance) as T;\n}\n\n/**\n * Retrieves the name of a property of a given type `T`.\n *\n * @typeParam T - The type of the object containing the property.\n * @param name - The name of the property as a string.\n * @returns The name of the property.\n */\nexport function nameof<T>(name: Extract<keyof T, string>): string {\n  return name;\n}\n\n/**\n * Normalizes optional properties to allow `undefined` assignment in strict mode.\n *\n * This utility provides a workaround for the `exactOptionalPropertyTypes` TypeScript flag,\n * which prohibits directly assigning `undefined` to optional properties when the type\n * explicitly omits `undefined`.\n *\n * Example:\n * ```typescript\n * // With `exactOptionalPropertyTypes: true`\n * const x: { prop?: string } = { prop: undefined }; // Compiler error\n *\n * // Using this utility:\n * const y: { prop?: string } = normalizeOptionalProperties<{ prop?: string }>({ prop: undefined }); // Works\n * ```\n *\n * @typeParam T - The target type with optional properties to normalize.\n * @param obj - The object to normalize, allowing explicit `undefined` for optional properties.\n * @returns The normalized object, compatible with `exactOptionalPropertyTypes`.\n */\nexport function normalizeOptionalProperties<T>(obj: UndefinedOnPartialDeep<T>): T {\n  return obj as T;\n}\n\n/**\n * Sets the value of a nested property in an object.\n *\n * @param obj - The object to set the nested property value in.\n * @param path - The path to the nested property.\n * @param value - The value to set.\n */\nexport function setNestedPropertyValue(obj: Record<string, unknown>, path: string, value: unknown): void {\n  const error = new Error(`Property path ${path} not found`);\n  let node: Record<string, unknown> | undefined = obj;\n  const keys = path.split('.');\n  for (const key of keys.slice(0, -1)) {\n    if (node === undefined) {\n      throw error;\n    }\n    node = node[key] as Record<string, unknown> | undefined;\n  }\n\n  const lastKey = keys.at(-1);\n  if (node === undefined || lastKey === undefined) {\n    throw error;\n  }\n\n  node[lastKey] = value;\n}\n\n/**\n * Converts a given value to a JSON string.\n *\n * @param value - The value to be converted to JSON. This can be of any type.\n * @param options - Options for customizing the JSON conversion process.\n * @returns The JSON string representation of the input value.\n */\nexport function toJson(value: unknown, options: ToJsonOptions = {}): string {\n  const {\n    shouldHandleFunctions = false,\n    space = 2\n  } = options;\n  if (!shouldHandleFunctions) {\n    return JSON.stringify(value, null, space);\n  }\n\n  const functionTexts: string[] = [];\n\n  const replacer = (_: string, value: unknown): unknown => {\n    if (typeof value === 'function') {\n      const index = functionTexts.length;\n      functionTexts.push(value.toString());\n      return `__FUNCTION_${index.toString()}`;\n    }\n\n    return value;\n  };\n\n  let json = JSON.stringify(value, replacer, space);\n  json = json.replaceAll(/\"__FUNCTION_(\\d+)\"/g, (_, indexStr: string) => functionTexts[parseInt(indexStr)] ?? throwExpression(new Error(`Function with index ${indexStr} not found`)));\n  return json;\n}\n\nfunction _assignWithNonEnumerableProperties(target: object, ...sources: object[]): object {\n  for (const source of sources) {\n    Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));\n  }\n\n  const sourcePrototypes = (sources.map((source) => getPrototypeOf(source)) as (null | object)[]).filter<null | object>((proto) => !!proto) as object[];\n\n  if (sourcePrototypes.length > 0) {\n    const targetPrototype = _assignWithNonEnumerableProperties({}, getPrototypeOf(target), ...sourcePrototypes);\n    Object.setPrototypeOf(target, targetPrototype);\n  }\n\n  return target;\n}\n"],
  "mappings": "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",
  "names": ["value"]
}


package/dist/lib/obsidian/FileChange.cjs

@@ -38,6 +38,7 @@ var import_FileSystem = require('./FileSystem.cjs');
 var import_Frontmatter = require('./Frontmatter.cjs');
 var import_Vault = require('./Vault.cjs');
 var __process = globalThis["process"] ?? {
+  "browser": true,
   "cwd": () => "/",
   "env": {},
   "platform": "android"
@@ -143,4 +144,4 @@ function isFrontmatterChange(fileChange) {
   isContentChange,
   isFrontmatterChange
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/obsidian/FileChange.ts"],
  "sourcesContent": ["var __process = globalThis['process'] ?? {\n  \"cwd\": ()=>\"/\",\n  \"env\": {},\n  \"platform\": \"android\"\n};\n/**\n * @packageDocumentation FileChange\n * Contains utility types and functions for handling file changes in Obsidian.\n */\n\nimport type { App } from 'obsidian';\n\nimport type { ValueProvider } from '../ValueProvider.ts';\nimport type { PathOrFile } from './FileSystem.ts';\nimport type { ProcessOptions } from './Vault.ts';\n\nimport {\n  deepEqual,\n  getNestedPropertyValue,\n  setNestedPropertyValue\n} from '../Object.ts';\nimport { resolveValue } from '../ValueProvider.ts';\nimport {\n  getPath,\n  isCanvasFile\n} from './FileSystem.ts';\nimport {\n  parseFrontmatter,\n  setFrontmatter\n} from './Frontmatter.ts';\nimport { process } from './Vault.ts';\n\n/**\n * Represents a content body change in the Vault.\n */\nexport interface ContentChange extends FileChange {\n  /**\n     * The end index of the change in the file content.\n     */\n  endIndex: number;\n\n  /**\n     * The start index of the change in the file content.\n     */\n  startIndex: number;\n}\n\n/**\n * Represents a file change in the Vault.\n */\nexport interface FileChange {\n  /**\n   * The new content to replace the old content.\n   */\n  newContent: string;\n\n  /**\n   * The old content that will be replaced.\n   */\n  oldContent: string;\n}\n\n/**\n * Represents a frontmatter change in the Vault.\n */\nexport interface FrontmatterChange extends FileChange {\n  /**\n   * The key in the frontmatter to use for the link.\n   */\n  frontmatterKey: string;\n}\n\n/**\n * Applies a series of file changes to the specified file or path within the application.\n *\n * @param app - The application instance where the file changes will be applied.\n * @param pathOrFile - The path or file to which the changes should be applied.\n * @param changesProvider - A provider that returns an array of file changes to apply.\n * @param processOptions - Optional options for processing/retrying the operation.\n *\n * @returns A promise that resolves when the file changes have been successfully applied.\n */\nexport async function applyFileChanges(app: App, pathOrFile: PathOrFile, changesProvider: ValueProvider<FileChange[]>, processOptions: ProcessOptions = {}): Promise<void> {\n  await process(app, pathOrFile, async (content) => {\n    let changes = await resolveValue(changesProvider);\n    const frontmatter = isCanvasFile(app, pathOrFile) ? JSON.parse(content) as Record<string, unknown> : parseFrontmatter(content);\n\n    for (const change of changes) {\n      if (isContentChange(change)) {\n        const actualContent = content.slice(change.startIndex, change.endIndex);\n        if (actualContent !== change.oldContent) {\n          console.warn('Content mismatch', {\n            actualContent,\n            endIndex: change.endIndex,\n            expectedContent: change.oldContent,\n            path: getPath(app, pathOrFile),\n            startIndex: change.startIndex\n          });\n\n          return null;\n        }\n      } else if (isFrontmatterChange(change)) {\n        const actualContent = getNestedPropertyValue(frontmatter, change.frontmatterKey);\n        if (actualContent !== change.oldContent) {\n          console.warn('Content mismatch', {\n            actualContent,\n            expectedContent: change.oldContent,\n            frontmatterKey: change.frontmatterKey,\n            path: getPath(app, pathOrFile)\n          });\n\n          return null;\n        }\n      }\n    }\n\n    changes.sort((a, b) => {\n      if (isContentChange(a) && isContentChange(b)) {\n        return a.startIndex - b.startIndex;\n      }\n\n      if (isFrontmatterChange(a) && isFrontmatterChange(b)) {\n        return a.frontmatterKey.localeCompare(b.frontmatterKey);\n      }\n\n      return isContentChange(a) ? -1 : 1;\n    });\n\n    // BUG: https://forum.obsidian.md/t/bug-duplicated-links-in-metadatacache-inside-footnotes/85551\n    changes = changes.filter((change, index) => {\n      if (change.oldContent === change.newContent) {\n        return false;\n      }\n      if (index === 0) {\n        return true;\n      }\n      return !deepEqual(change, changes[index - 1]);\n    });\n\n    for (let i = 1; i < changes.length; i++) {\n      const change = changes[i];\n      if (!change) {\n        continue;\n      }\n      const previousChange = changes[i - 1];\n      if (!previousChange) {\n        continue;\n      }\n\n      if (isContentChange(previousChange) && isContentChange(change) && previousChange.endIndex && change.startIndex && previousChange.endIndex > change.startIndex) {\n        console.warn('Overlapping changes', {\n          change,\n          previousChange\n        });\n        return null;\n      }\n    }\n\n    let newContent = '';\n    let lastIndex = 0;\n    let frontmatterChanged = false;\n\n    for (const change of changes) {\n      if (isContentChange(change)) {\n        newContent += content.slice(lastIndex, change.startIndex);\n        newContent += change.newContent;\n        lastIndex = change.endIndex;\n      } else if (isFrontmatterChange(change)) {\n        setNestedPropertyValue(frontmatter, change.frontmatterKey, change.newContent);\n        frontmatterChanged = true;\n      }\n    }\n\n    if (isCanvasFile(app, pathOrFile)) {\n      newContent = JSON.stringify(frontmatter, null, '\\t');\n    } else {\n      newContent += content.slice(lastIndex);\n      if (frontmatterChanged) {\n        newContent = setFrontmatter(newContent, frontmatter);\n      }\n    }\n    return newContent;\n  }, processOptions);\n}\n\n/**\n * Checks if a file change is a content change.\n *\n * @param fileChange - The file change to check.\n * @returns A boolean indicating whether the file change is a content change.\n */\nexport function isContentChange(fileChange: FileChange): fileChange is ContentChange {\n  return (fileChange as Partial<ContentChange>).startIndex !== undefined;\n}\n\n/**\n * Checks if a file change is a frontmatter change.\n *\n * @param fileChange - The file change to check.\n * @returns A boolean indicating whether the file change is a frontmatter change.\n */\nexport function isFrontmatterChange(fileChange: FileChange): fileChange is FrontmatterChange {\n  return (fileChange as Partial<FrontmatterChange>).frontmatterKey !== undefined;\n}\n"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/obsidian/FileChange.ts"],
  "sourcesContent": ["var __process = globalThis['process'] ?? {\n  \"browser\": true,\n  \"cwd\": ()=>\"/\",\n  \"env\": {},\n  \"platform\": \"android\"\n};\n/**\n * @packageDocumentation FileChange\n * Contains utility types and functions for handling file changes in Obsidian.\n */\n\nimport type { App } from 'obsidian';\n\nimport type { ValueProvider } from '../ValueProvider.ts';\nimport type { PathOrFile } from './FileSystem.ts';\nimport type { ProcessOptions } from './Vault.ts';\n\nimport {\n  deepEqual,\n  getNestedPropertyValue,\n  setNestedPropertyValue\n} from '../Object.ts';\nimport { resolveValue } from '../ValueProvider.ts';\nimport {\n  getPath,\n  isCanvasFile\n} from './FileSystem.ts';\nimport {\n  parseFrontmatter,\n  setFrontmatter\n} from './Frontmatter.ts';\nimport { process } from './Vault.ts';\n\n/**\n * Represents a content body change in the Vault.\n */\nexport interface ContentChange extends FileChange {\n  /**\n     * The end index of the change in the file content.\n     */\n  endIndex: number;\n\n  /**\n     * The start index of the change in the file content.\n     */\n  startIndex: number;\n}\n\n/**\n * Represents a file change in the Vault.\n */\nexport interface FileChange {\n  /**\n   * The new content to replace the old content.\n   */\n  newContent: string;\n\n  /**\n   * The old content that will be replaced.\n   */\n  oldContent: string;\n}\n\n/**\n * Represents a frontmatter change in the Vault.\n */\nexport interface FrontmatterChange extends FileChange {\n  /**\n   * The key in the frontmatter to use for the link.\n   */\n  frontmatterKey: string;\n}\n\n/**\n * Applies a series of file changes to the specified file or path within the application.\n *\n * @param app - The application instance where the file changes will be applied.\n * @param pathOrFile - The path or file to which the changes should be applied.\n * @param changesProvider - A provider that returns an array of file changes to apply.\n * @param processOptions - Optional options for processing/retrying the operation.\n *\n * @returns A promise that resolves when the file changes have been successfully applied.\n */\nexport async function applyFileChanges(app: App, pathOrFile: PathOrFile, changesProvider: ValueProvider<FileChange[]>, processOptions: ProcessOptions = {}): Promise<void> {\n  await process(app, pathOrFile, async (content) => {\n    let changes = await resolveValue(changesProvider);\n    const frontmatter = isCanvasFile(app, pathOrFile) ? JSON.parse(content) as Record<string, unknown> : parseFrontmatter(content);\n\n    for (const change of changes) {\n      if (isContentChange(change)) {\n        const actualContent = content.slice(change.startIndex, change.endIndex);\n        if (actualContent !== change.oldContent) {\n          console.warn('Content mismatch', {\n            actualContent,\n            endIndex: change.endIndex,\n            expectedContent: change.oldContent,\n            path: getPath(app, pathOrFile),\n            startIndex: change.startIndex\n          });\n\n          return null;\n        }\n      } else if (isFrontmatterChange(change)) {\n        const actualContent = getNestedPropertyValue(frontmatter, change.frontmatterKey);\n        if (actualContent !== change.oldContent) {\n          console.warn('Content mismatch', {\n            actualContent,\n            expectedContent: change.oldContent,\n            frontmatterKey: change.frontmatterKey,\n            path: getPath(app, pathOrFile)\n          });\n\n          return null;\n        }\n      }\n    }\n\n    changes.sort((a, b) => {\n      if (isContentChange(a) && isContentChange(b)) {\n        return a.startIndex - b.startIndex;\n      }\n\n      if (isFrontmatterChange(a) && isFrontmatterChange(b)) {\n        return a.frontmatterKey.localeCompare(b.frontmatterKey);\n      }\n\n      return isContentChange(a) ? -1 : 1;\n    });\n\n    // BUG: https://forum.obsidian.md/t/bug-duplicated-links-in-metadatacache-inside-footnotes/85551\n    changes = changes.filter((change, index) => {\n      if (change.oldContent === change.newContent) {\n        return false;\n      }\n      if (index === 0) {\n        return true;\n      }\n      return !deepEqual(change, changes[index - 1]);\n    });\n\n    for (let i = 1; i < changes.length; i++) {\n      const change = changes[i];\n      if (!change) {\n        continue;\n      }\n      const previousChange = changes[i - 1];\n      if (!previousChange) {\n        continue;\n      }\n\n      if (isContentChange(previousChange) && isContentChange(change) && previousChange.endIndex && change.startIndex && previousChange.endIndex > change.startIndex) {\n        console.warn('Overlapping changes', {\n          change,\n          previousChange\n        });\n        return null;\n      }\n    }\n\n    let newContent = '';\n    let lastIndex = 0;\n    let frontmatterChanged = false;\n\n    for (const change of changes) {\n      if (isContentChange(change)) {\n        newContent += content.slice(lastIndex, change.startIndex);\n        newContent += change.newContent;\n        lastIndex = change.endIndex;\n      } else if (isFrontmatterChange(change)) {\n        setNestedPropertyValue(frontmatter, change.frontmatterKey, change.newContent);\n        frontmatterChanged = true;\n      }\n    }\n\n    if (isCanvasFile(app, pathOrFile)) {\n      newContent = JSON.stringify(frontmatter, null, '\\t');\n    } else {\n      newContent += content.slice(lastIndex);\n      if (frontmatterChanged) {\n        newContent = setFrontmatter(newContent, frontmatter);\n      }\n    }\n    return newContent;\n  }, processOptions);\n}\n\n/**\n * Checks if a file change is a content change.\n *\n * @param fileChange - The file change to check.\n * @returns A boolean indicating whether the file change is a content change.\n */\nexport function isContentChange(fileChange: FileChange): fileChange is ContentChange {\n  return (fileChange as Partial<ContentChange>).startIndex !== undefined;\n}\n\n/**\n * Checks if a file change is a frontmatter change.\n *\n * @param fileChange - The file change to check.\n * @returns A boolean indicating whether the file change is a frontmatter change.\n */\nexport function isFrontmatterChange(fileChange: FileChange): fileChange is FrontmatterChange {\n  return (fileChange as Partial<FrontmatterChange>).frontmatterKey !== undefined;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAiBA,oBAIO;AACP,2BAA6B;AAC7B,wBAGO;AACP,yBAGO;AACP,mBAAwB;AA/BxB,IAAI,YAAY,WAAW,SAAS,KAAK;AAAA,EACvC,WAAW;AAAA,EACX,OAAO,MAAI;AAAA,EACX,OAAO,CAAC;AAAA,EACR,YAAY;AACd;AA8EA,eAAsB,iBAAiB,KAAU,YAAwB,iBAA8C,iBAAiC,CAAC,GAAkB;AACzK,YAAM,sBAAQ,KAAK,YAAY,OAAO,YAAY;AAChD,QAAI,UAAU,UAAM,mCAAa,eAAe;AAChD,UAAM,kBAAc,gCAAa,KAAK,UAAU,IAAI,KAAK,MAAM,OAAO,QAA+B,qCAAiB,OAAO;AAE7H,eAAW,UAAU,SAAS;AAC5B,UAAI,gBAAgB,MAAM,GAAG;AAC3B,cAAM,gBAAgB,QAAQ,MAAM,OAAO,YAAY,OAAO,QAAQ;AACtE,YAAI,kBAAkB,OAAO,YAAY;AACvC,kBAAQ,KAAK,oBAAoB;AAAA,YAC/B;AAAA,YACA,UAAU,OAAO;AAAA,YACjB,iBAAiB,OAAO;AAAA,YACxB,UAAM,2BAAQ,KAAK,UAAU;AAAA,YAC7B,YAAY,OAAO;AAAA,UACrB,CAAC;AAED,iBAAO;AAAA,QACT;AAAA,MACF,WAAW,oBAAoB,MAAM,GAAG;AACtC,cAAM,oBAAgB,sCAAuB,aAAa,OAAO,cAAc;AAC/E,YAAI,kBAAkB,OAAO,YAAY;AACvC,kBAAQ,KAAK,oBAAoB;AAAA,YAC/B;AAAA,YACA,iBAAiB,OAAO;AAAA,YACxB,gBAAgB,OAAO;AAAA,YACvB,UAAM,2BAAQ,KAAK,UAAU;AAAA,UAC/B,CAAC;AAED,iBAAO;AAAA,QACT;AAAA,MACF;AAAA,IACF;AAEA,YAAQ,KAAK,CAAC,GAAG,MAAM;AACrB,UAAI,gBAAgB,CAAC,KAAK,gBAAgB,CAAC,GAAG;AAC5C,eAAO,EAAE,aAAa,EAAE;AAAA,MAC1B;AAEA,UAAI,oBAAoB,CAAC,KAAK,oBAAoB,CAAC,GAAG;AACpD,eAAO,EAAE,eAAe,cAAc,EAAE,cAAc;AAAA,MACxD;AAEA,aAAO,gBAAgB,CAAC,IAAI,KAAK;AAAA,IACnC,CAAC;AAGD,cAAU,QAAQ,OAAO,CAAC,QAAQ,UAAU;AAC1C,UAAI,OAAO,eAAe,OAAO,YAAY;AAC3C,eAAO;AAAA,MACT;AACA,UAAI,UAAU,GAAG;AACf,eAAO;AAAA,MACT;AACA,aAAO,KAAC,yBAAU,QAAQ,QAAQ,QAAQ,CAAC,CAAC;AAAA,IAC9C,CAAC;AAED,aAAS,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;AACvC,YAAM,SAAS,QAAQ,CAAC;AACxB,UAAI,CAAC,QAAQ;AACX;AAAA,MACF;AACA,YAAM,iBAAiB,QAAQ,IAAI,CAAC;AACpC,UAAI,CAAC,gBAAgB;AACnB;AAAA,MACF;AAEA,UAAI,gBAAgB,cAAc,KAAK,gBAAgB,MAAM,KAAK,eAAe,YAAY,OAAO,cAAc,eAAe,WAAW,OAAO,YAAY;AAC7J,gBAAQ,KAAK,uBAAuB;AAAA,UAClC;AAAA,UACA;AAAA,QACF,CAAC;AACD,eAAO;AAAA,MACT;AAAA,IACF;AAEA,QAAI,aAAa;AACjB,QAAI,YAAY;AAChB,QAAI,qBAAqB;AAEzB,eAAW,UAAU,SAAS;AAC5B,UAAI,gBAAgB,MAAM,GAAG;AAC3B,sBAAc,QAAQ,MAAM,WAAW,OAAO,UAAU;AACxD,sBAAc,OAAO;AACrB,oBAAY,OAAO;AAAA,MACrB,WAAW,oBAAoB,MAAM,GAAG;AACtC,kDAAuB,aAAa,OAAO,gBAAgB,OAAO,UAAU;AAC5E,6BAAqB;AAAA,MACvB;AAAA,IACF;AAEA,YAAI,gCAAa,KAAK,UAAU,GAAG;AACjC,mBAAa,KAAK,UAAU,aAAa,MAAM,GAAI;AAAA,IACrD,OAAO;AACL,oBAAc,QAAQ,MAAM,SAAS;AACrC,UAAI,oBAAoB;AACtB,yBAAa,mCAAe,YAAY,WAAW;AAAA,MACrD;AAAA,IACF;AACA,WAAO;AAAA,EACT,GAAG,cAAc;AACnB;AAQO,SAAS,gBAAgB,YAAqD;AACnF,SAAQ,WAAsC,eAAe;AAC/D;AAQO,SAAS,oBAAoB,YAAyD;AAC3F,SAAQ,WAA0C,mBAAmB;AACvE;",
  "names": []
}


package/dist/lib/obsidian/FileManager.cjs

@@ -37,6 +37,7 @@ var import_FileSystem = require('./FileSystem.cjs');
 var import_Frontmatter = require('./Frontmatter.cjs');
 var import_Vault = require('./Vault.cjs');
 var __process = globalThis["process"] ?? {
+  "browser": true,
   "cwd": () => "/",
   "env": {},
   "platform": "android"
@@ -93,4 +94,4 @@ async function processFrontmatter(app, pathOrFile, frontmatterFn, processOptions
   deleteAlias,
   processFrontmatter
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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