obsidian-dev-utils 13.9.0 → 13.10.1

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # CHANGELOG
 
+## 13.10.1
+
+- Update libs
+- Don't show `consoleDebug()` in call stack
+
+## 13.10.0
+
+- Refactor and document debugging
+
 ## 13.9.0
 
 - Update libs

package/README.md

@@ -151,6 +151,30 @@ import * as obsidianDevUtils from "obsidian-dev-utils";
 await obsidianDevUtils.obsidian.Modal.Prompt.prompt({ app, title: 'Enter your name' });
 ```
 
+## Debugging
+
+By default, console debug messages are not shown. To enable them you have to enable `Verbose` mode in the console settings.
+
+![Console settings](./images/console-settings.png)
+
+When you enable `Verbose` mode, you will see debug messages in the console sent via `console.debug()` calls.
+
+`obsidian-dev-utils` library uses [debug](https://github.com/debug-js/debug) library to enable conditional logging.
+
+By default, none of the debug messages are shown. You have to enable the debug namespace explicitly.
+
+To see debug messages for your plugin `foo`, you have to enable them:
+
+```javascript
+window.DEBUG.enable('foo'); // show all debug messages from the `foo` plugin
+window.DEBUG.enable('foo:obsidian-dev-utils:*'); // show all debug messages from the `obsidian-dev-utils` library within the `foo` plugin
+window.DEBUG.enable('foo:*'); // show all debug messages from the `foo` plugin and its submodules
+window.DEBUG.enable('*:obsidian-dev-utils:*'); // show all debug messages for the `obsidian-dev-utils` library within any plugin
+window.DEBUG.enable('*'); // show all debug messages
+```
+
+See full documentation of [`window.DEBUG`](https://github.com/mnaoumov/obsidian-dev-utils/blob/main/src/DebugController.ts).
+
 ## Support
 
 <a href="https://www.buymeacoffee.com/mnaoumov" target="_blank"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="Buy Me A Coffee" style="height: 60px !important;width: 217px !important;"></a>

package/dist/lib/Async.cjs

@@ -44,7 +44,6 @@ __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();
@@ -77,6 +76,7 @@ function marksAsTerminateRetry(error) {
   return Object.assign(error, { __terminateRetry: true });
 }
 async function retryWithTimeout(fn, retryOptions = {}, stackTrace) {
+  const retryWithTimeoutDebugger = (0, import_Debug.getLibDebugger)("Async:retryWithTimeout");
   stackTrace ??= (0, import_Error.getStackTrace)(1);
   const DEFAULT_RETRY_OPTIONS = {
     retryDelayInMilliseconds: 100,
@@ -127,7 +127,7 @@ async function runWithTimeout(timeoutInMilliseconds, fn) {
     result = await fn();
     isTimedOut = false;
     const duration = performance.now() - startTime;
-    (0, import_Debug.getDebugger)("obsidian-dev-utils:Async:runWithTimeout")(`Execution time: ${duration.toString()} milliseconds`, { fn });
+    (0, import_Debug.getLibDebugger)("Async:runWithTimeout")(`Execution time: ${duration.toString()} milliseconds`, { fn });
   }
   async function timeout2() {
     if (!isTimedOut) {
@@ -139,8 +139,9 @@ 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 debugger obsidian-dev-utils:Async:timeout is enabled. See window.DEBUG.enable('obsidian-dev-utils:Async:timeout') and https://github.com/debug-js/debug?tab=readme-ov-file for more information");
+    const _debugger = (0, import_Debug.getLibDebugger)("Async:runWithTimeout:timeout");
+    if (_debugger.enabled) {
+      _debugger.log(`The execution is not terminated because debugger ${_debugger.namespace} is enabled. See https://github.com/mnaoumov/obsidian-dev-utils/?tab=readme-ov-file#debugging for more information`);
       await timeout2();
     }
   }
@@ -175,4 +176,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\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] ?? false);\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 & TError;\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.DEBUG.enable(\\'obsidian-dev-utils:Async:timeout\\') and https://github.com/debug-js/debug?tab=readme-ov-file 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 { getLibDebugger } 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] ?? false);\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 & TError;\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  const retryWithTimeoutDebugger = getLibDebugger('Async:retryWithTimeout');\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    getLibDebugger('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    const _debugger = getLibDebugger('Async:runWithTimeout:timeout');\n    if (_debugger.enabled) {\n      _debugger.log(`The execution is not terminated because debugger ${_debugger.namespace} is enabled. See https://github.com/mnaoumov/obsidian-dev-utils/?tab=readme-ov-file#debugging 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/Debug.cjs

@@ -38,23 +38,30 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var Debug_exports = {};
 __export(Debug_exports, {
   getDebugger: () => getDebugger,
+  getLibDebugger: () => getLibDebugger,
   initDebugHelpers: () => initDebugHelpers
 });
 module.exports = __toCommonJS(Debug_exports);
 var import_debug = __toESM(__extractDefault(require('debug')), 1);
+let currentPluginId = "";
 const NAMESPACE_SEPARATOR = ",";
 const NEGATED_NAMESPACE_PREFIX = "-";
-function getDebugger(namespace) {
-  const debugInstance = import_debug.default.default(namespace);
+function getDebugger(namespace, framesToSkip = 0) {
+  const debugInstance = (0, import_debug.default)(namespace);
   debugInstance.log = (message, ...args) => {
-    logWithCaller(namespace, message, ...args);
+    logWithCaller(namespace, framesToSkip, message, ...args);
   };
   debugInstance.printStackTrace = (stackTrace, title) => {
     printStackTrace(namespace, stackTrace, title);
   };
   return debugInstance;
 }
-function initDebugHelpers() {
+function getLibDebugger(namespace) {
+  const prefix = currentPluginId ? `${currentPluginId}:` : "";
+  return getDebugger(`${prefix}obsidian-dev-utils:${namespace}`);
+}
+function initDebugHelpers(pluginId) {
+  currentPluginId = pluginId;
   window.DEBUG = {
     disable: disableNamespaces,
     enable: enableNamespaces,
@@ -92,13 +99,13 @@ function enableNamespaces(namespaces) {
 function getNamespaces() {
   return toArray(import_debug.default.load() ?? "");
 }
-function logWithCaller(namespace, message, ...args) {
+function logWithCaller(namespace, framesToSkip, 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] ?? "";
+  const callerLine = stackLines[CALLER_LINE_INDEX + framesToSkip] ?? "";
   console.debug(message, ...args);
   printStackTrace(namespace, callerLine, "Original debug message caller");
 }
@@ -124,6 +131,7 @@ function toArray(namespaces) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   getDebugger,
+  getLibDebugger,
   initDebugHelpers
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/Debug.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation Debug\n * Contains utility functions for debugging.\n */\n\nimport type { Debugger } from 'debug';\n\nimport debug from 'debug';\n\nimport type { DebugController } from './DebugController.ts';\n\ninterface DebuggerEx extends Debugger {\n  printStackTrace(stackTrace: string, title?: string): void;\n}\n\ninterface DebugWrapper {\n  DEBUG: DebugController;\n}\n\nlet currentPluginId = '';\nconst NAMESPACE_SEPARATOR = ',';\nconst NEGATED_NAMESPACE_PREFIX = '-';\n\n/**\n * Returns a debugger instance with a log function that includes the caller's file name and line number.\n *\n * @param namespace - The namespace for the debugger instance.\n * @param framesToSkip - The number of frames to skip in the stack trace.\n * @returns A debugger instance with a log function that includes the caller's file name and line number.\n */\nexport function getDebugger(namespace: string, framesToSkip = 0): DebuggerEx {\n  const debugInstance = debug(namespace) as DebuggerEx;\n  debugInstance.log = (message: string, ...args: unknown[]): void => {\n    logWithCaller(namespace, framesToSkip, message, ...args);\n  };\n  debugInstance.printStackTrace = (stackTrace, title): void => {\n    printStackTrace(namespace, stackTrace, title);\n  };\n  return debugInstance;\n}\n\n/**\n * Returns a debugger instance for the `obsidian-dev-utils` library.\n *\n * @param namespace - The namespace for the debugger instance.\n * @returns A debugger instance for the `obsidian-dev-utils` library.\n */\nexport function getLibDebugger(namespace: string): DebuggerEx {\n  const prefix = currentPluginId ? `${currentPluginId}:` : '';\n  return getDebugger(`${prefix}obsidian-dev-utils:${namespace}`);\n}\n\n/**\n * Adds the DEBUG variable to the window object.\n *\n * @param pluginId - The plugin ID.\n */\nexport function initDebugHelpers(pluginId: string): void {\n  currentPluginId = pluginId;\n  (window as Partial<DebugWrapper>).DEBUG = {\n    disable: disableNamespaces,\n    enable: enableNamespaces,\n    get: getNamespaces,\n    set: setNamespaces\n  };\n}\n\nfunction disableNamespaces(namespaces: string | string[]): void {\n  const set = new Set(getNamespaces());\n  for (const namespace of toArray(namespaces)) {\n    if (namespace.startsWith(NEGATED_NAMESPACE_PREFIX)) {\n      continue;\n    }\n    const negatedNamespace = NEGATED_NAMESPACE_PREFIX + namespace;\n    if (set.has(namespace)) {\n      set.delete(namespace);\n    }\n    set.add(negatedNamespace);\n  }\n  setNamespaces(Array.from(set));\n}\n\nfunction enableNamespaces(namespaces: string | string[]): void {\n  const set = new Set(getNamespaces());\n  for (const namespace of toArray(namespaces)) {\n    if (!namespace.startsWith(NEGATED_NAMESPACE_PREFIX)) {\n      const negatedNamespace = NEGATED_NAMESPACE_PREFIX + namespace;\n      if (set.has(negatedNamespace)) {\n        set.delete(negatedNamespace);\n      }\n    }\n    set.add(namespace);\n  }\n  setNamespaces(Array.from(set));\n}\n\nfunction getNamespaces(): string[] {\n  return toArray(debug.load() ?? '');\n}\n\nfunction logWithCaller(namespace: string, framesToSkip: number, message: string, ...args: unknown[]): void {\n  if (!debug.enabled(namespace)) {\n    return;\n  }\n\n  /**\n   * The caller line index is 4 because the call stack is as follows:\n   *\n   * 0: Error\n   * 1:     at logWithCaller (?:?:?)\n   * 2:     at debugInstance.log (?:?:?)\n   * 3:     at debug (?:?:?)\n   * 4:     at functionName (path/to/caller.js:?:?)\n   */\n  const CALLER_LINE_INDEX = 4;\n\n  const stackLines = new Error().stack?.split('\\n') ?? [];\n  const callerLine = stackLines[CALLER_LINE_INDEX + framesToSkip] ?? '';\n  console.debug(message, ...args);\n  printStackTrace(namespace, callerLine, 'Original debug message caller');\n}\n\nfunction printStackTrace(namespace: string, stackTrace: string, title?: string): void {\n  if (!debug.enabled(namespace)) {\n    return;\n  }\n\n  if (!stackTrace) {\n    stackTrace = '(unavailable)';\n  }\n  if (!title) {\n    title = 'Caller stack trace';\n  }\n  console.debug(`NotError:${namespace}:${title}\\n${stackTrace}`);\n}\n\nfunction setNamespaces(namespaces: string | string[]): void {\n  debug.enable(toArray(namespaces).join(NAMESPACE_SEPARATOR));\n}\n\nfunction toArray(namespaces: string | string[]): string[] {\n  return typeof namespaces === 'string' ? namespaces.split(NAMESPACE_SEPARATOR).filter(Boolean) : namespaces.flatMap(toArray);\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,mBAAkB;AAYlB,IAAI,kBAAkB;AACtB,MAAM,sBAAsB;AAC5B,MAAM,2BAA2B;AAS1B,SAAS,YAAY,WAAmB,eAAe,GAAe;AAC3E,QAAM,oBAAgB,aAAAA,SAAM,SAAS;AACrC,gBAAc,MAAM,CAAC,YAAoB,SAA0B;AACjE,kBAAc,WAAW,cAAc,SAAS,GAAG,IAAI;AAAA,EACzD;AACA,gBAAc,kBAAkB,CAAC,YAAY,UAAgB;AAC3D,oBAAgB,WAAW,YAAY,KAAK;AAAA,EAC9C;AACA,SAAO;AACT;AAQO,SAAS,eAAe,WAA+B;AAC5D,QAAM,SAAS,kBAAkB,GAAG,eAAe,MAAM;AACzD,SAAO,YAAY,GAAG,MAAM,sBAAsB,SAAS,EAAE;AAC/D;AAOO,SAAS,iBAAiB,UAAwB;AACvD,oBAAkB;AAClB,EAAC,OAAiC,QAAQ;AAAA,IACxC,SAAS;AAAA,IACT,QAAQ;AAAA,IACR,KAAK;AAAA,IACL,KAAK;AAAA,EACP;AACF;AAEA,SAAS,kBAAkB,YAAqC;AAC9D,QAAM,MAAM,IAAI,IAAI,cAAc,CAAC;AACnC,aAAW,aAAa,QAAQ,UAAU,GAAG;AAC3C,QAAI,UAAU,WAAW,wBAAwB,GAAG;AAClD;AAAA,IACF;AACA,UAAM,mBAAmB,2BAA2B;AACpD,QAAI,IAAI,IAAI,SAAS,GAAG;AACtB,UAAI,OAAO,SAAS;AAAA,IACtB;AACA,QAAI,IAAI,gBAAgB;AAAA,EAC1B;AACA,gBAAc,MAAM,KAAK,GAAG,CAAC;AAC/B;AAEA,SAAS,iBAAiB,YAAqC;AAC7D,QAAM,MAAM,IAAI,IAAI,cAAc,CAAC;AACnC,aAAW,aAAa,QAAQ,UAAU,GAAG;AAC3C,QAAI,CAAC,UAAU,WAAW,wBAAwB,GAAG;AACnD,YAAM,mBAAmB,2BAA2B;AACpD,UAAI,IAAI,IAAI,gBAAgB,GAAG;AAC7B,YAAI,OAAO,gBAAgB;AAAA,MAC7B;AAAA,IACF;AACA,QAAI,IAAI,SAAS;AAAA,EACnB;AACA,gBAAc,MAAM,KAAK,GAAG,CAAC;AAC/B;AAEA,SAAS,gBAA0B;AACjC,SAAO,QAAQ,aAAAA,QAAM,KAAK,KAAK,EAAE;AACnC;AAEA,SAAS,cAAc,WAAmB,cAAsB,YAAoB,MAAuB;AACzG,MAAI,CAAC,aAAAA,QAAM,QAAQ,SAAS,GAAG;AAC7B;AAAA,EACF;AAWA,QAAM,oBAAoB;AAE1B,QAAM,aAAa,IAAI,MAAM,EAAE,OAAO,MAAM,IAAI,KAAK,CAAC;AACtD,QAAM,aAAa,WAAW,oBAAoB,YAAY,KAAK;AACnE,UAAQ,MAAM,SAAS,GAAG,IAAI;AAC9B,kBAAgB,WAAW,YAAY,+BAA+B;AACxE;AAEA,SAAS,gBAAgB,WAAmB,YAAoB,OAAsB;AACpF,MAAI,CAAC,aAAAA,QAAM,QAAQ,SAAS,GAAG;AAC7B;AAAA,EACF;AAEA,MAAI,CAAC,YAAY;AACf,iBAAa;AAAA,EACf;AACA,MAAI,CAAC,OAAO;AACV,YAAQ;AAAA,EACV;AACA,UAAQ,MAAM,YAAY,SAAS,IAAI,KAAK;AAAA,EAAK,UAAU,EAAE;AAC/D;AAEA,SAAS,cAAc,YAAqC;AAC1D,eAAAA,QAAM,OAAO,QAAQ,UAAU,EAAE,KAAK,mBAAmB,CAAC;AAC5D;AAEA,SAAS,QAAQ,YAAyC;AACxD,SAAO,OAAO,eAAe,WAAW,WAAW,MAAM,mBAAmB,EAAE,OAAO,OAAO,IAAI,WAAW,QAAQ,OAAO;AAC5H;",
  "names": ["debug"]
}


package/dist/lib/Debug.d.ts

@@ -10,11 +10,21 @@ interface DebuggerEx extends Debugger {
  * Returns a debugger instance with a log function that includes the caller's file name and line number.
  *
  * @param namespace - The namespace for the debugger instance.
+ * @param framesToSkip - The number of frames to skip in the stack trace.
  * @returns A debugger instance with a log function that includes the caller's file name and line number.
  */
-export declare function getDebugger(namespace: string): DebuggerEx;
+export declare function getDebugger(namespace: string, framesToSkip?: number): DebuggerEx;
+/**
+ * Returns a debugger instance for the `obsidian-dev-utils` library.
+ *
+ * @param namespace - The namespace for the debugger instance.
+ * @returns A debugger instance for the `obsidian-dev-utils` library.
+ */
+export declare function getLibDebugger(namespace: string): DebuggerEx;
 /**
  * Adds the DEBUG variable to the window object.
+ *
+ * @param pluginId - The plugin ID.
  */
-export declare function initDebugHelpers(): void;
+export declare function initDebugHelpers(pluginId: string): void;
 export {};

package/dist/lib/DebugController.cjs

@@ -0,0 +1,26 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+function __extractDefault(module){return module&&module.__esModule&&module.default?module.default:module}
+
+(function patchRequireEsmDefault(){const __require=require;require=Object.assign(id=>{const module=__require(id)??{};return __extractDefault(module)},__require)})()
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var DebugController_exports = {};
+module.exports = __toCommonJS(DebugController_exports);
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/DebugController.d.ts

@@ -0,0 +1,85 @@
+/**
+ * @packageDocumentation
+ * Provides the interface for controlling debug output through namespace management.
+ *
+ * Debug namespaces follow the pattern 'foo', `foo:bar`, `foo:bar:baz`, etc, and can use wildcards (`*`).
+ *
+ * @example
+ * - `foo:*` matches all submodules of 'foo'
+ * - `*:bar` matches all plugins' `bar` submodules
+ * - `*` matches everything
+ *
+ * Special syntax:
+ * - Namespaces prefixed with '-' are explicitly disabled
+ * - Multiple namespaces can be combined with commas: `foo,-foo:bar,baz:*`
+ *
+ * @see {@link https://github.com/mnaoumov/obsidian-dev-utils/?tab=readme-ov-file#debugging}
+ */
+/**
+ * Controls debug output by managing debug namespaces.
+ * Exposed globally as `window.DEBUG`.
+ *
+ * @remarks
+ * Debug settings persist across plugin reloads in localStorage.
+ */
+export interface DebugController {
+    /**
+     * Disable specific debug namespaces. Disabled namespaces take precedence
+     * over enabled ones when there's a conflict.
+     *
+     * @example
+     * ```typescript
+     * window.DEBUG.disable('foo'); // hide all debug messages from the `foo` plugin
+     * window.DEBUG.disable('foo:*'); // hide all debug messages from the `foo` plugin submodules
+     * window.DEBUG.disable(['foo', 'bar']); // disable multiple namespaces
+     * window.DEBUG.disable('foo,bar'); // disable multiple namespaces using comma-separated string
+     * window.DEBUG.disable('*'); // disable all debug messages
+     * ```
+     *
+     * @param namespaces - Single namespace string or array of namespace strings to disable
+     */
+    disable(namespaces: string | string[]): void;
+    /**
+     * Enable specific debug namespaces. Note that explicitly disabled
+     * namespaces (prefixed with '-') will remain disabled.
+     *
+     * @example
+     * ```typescript
+     * window.DEBUG.enable('foo'); // show all debug messages from the `foo` plugin
+     * window.DEBUG.enable('foo:obsidian-dev-utils:*'); // show all debug messages from the `obsidian-dev-utils` library within the `foo` plugin
+     * window.DEBUG.enable('foo:*'); // show all debug messages from the `foo` plugin and its submodules
+     * window.DEBUG.enable('*:obsidian-dev-utils:*'); // show all debug messages for the `obsidian-dev-utils` library within any plugin
+     * window.DEBUG.enable(['foo', 'bar']); // enable multiple namespaces
+     * window.DEBUG.enable('foo,bar'); // enable multiple namespaces using comma-separated string
+     * window.DEBUG.enable('*'); // show all debug messages
+     * ```
+     *
+     * @param namespaces - Single namespace string or array of namespace strings to enable
+     */
+    enable(namespaces: string | string[]): void;
+    /**
+     * Get currently configured debug namespaces.
+     *
+     * @example
+     * ```typescript
+     * window.DEBUG.get(); // returns ['foo', 'bar:*', '-baz']
+     * ```
+     *
+     * @returns Array of enabled and disabled (prefixed with `-`) debug namespaces
+     */
+    get(): string[];
+    /**
+     * Set debug namespaces, replacing all previous configurations.
+     *
+     * @example
+     * ```typescript
+     * window.DEBUG.set(['foo', 'bar:*', '-baz']); // Enable 'foo' and 'bar:*', explicitly disable 'baz'
+     * window.DEBUG.set('foo,bar:*,-baz'); // Same thing using comma-separated string
+     * window.DEBUG.set('*'); // Enable all debug messages
+     * window.DEBUG.set(''); // Disable all debug messages
+     * ```
+     *
+     * @param namespaces - String or array of namespace patterns
+     */
+    set(namespaces: string | string[]): void;
+}

package/dist/lib/index.cjs

@@ -40,6 +40,7 @@ __export(index_exports, {
   Async: () => Async,
   Blob: () => Blob,
   Debug: () => Debug,
+  DebugController: () => DebugController,
   Error: () => Error2,
   Function: () => Function,
   HTMLElement: () => HTMLElement,
@@ -58,6 +59,7 @@ var _types = __toESM(__extractDefault(require('./@types.cjs')), 1);
 var Async = __toESM(__extractDefault(require('./Async.cjs')), 1);
 var Blob = __toESM(__extractDefault(require('./Blob.cjs')), 1);
 var Debug = __toESM(__extractDefault(require('./Debug.cjs')), 1);
+var DebugController = __toESM(__extractDefault(require('./DebugController.cjs')), 1);
 var Error2 = __toESM(__extractDefault(require('./Error.cjs')), 1);
 var Function = __toESM(__extractDefault(require('./Function.cjs')), 1);
 var HTMLElement = __toESM(__extractDefault(require('./HTMLElement.cjs')), 1);
@@ -74,6 +76,7 @@ var ValueProvider = __toESM(__extractDefault(require('./ValueProvider.cjs')), 1)
   Async,
   Blob,
   Debug,
+  DebugController,
   Error,
   Function,
   HTMLElement,
@@ -87,4 +90,4 @@ var ValueProvider = __toESM(__extractDefault(require('./ValueProvider.cjs')), 1)
   scripts,
   url
 });
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vc3JjL2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKiBUSElTIElTIEEgR0VORVJBVEVEL0JVTkRMRUQgRklMRSBCWSBCVUlMRCBTQ1JJUFQgKi9cblxuZXhwb3J0ICogYXMgX3R5cGVzIGZyb20gJy4vQHR5cGVzLnRzJztcbmV4cG9ydCAqIGFzIEFzeW5jIGZyb20gJy4vQXN5bmMudHMnO1xuZXhwb3J0ICogYXMgQmxvYiBmcm9tICcuL0Jsb2IudHMnO1xuZXhwb3J0ICogYXMgRGVidWcgZnJvbSAnLi9EZWJ1Zy50cyc7XG5leHBvcnQgKiBhcyBFcnJvciBmcm9tICcuL0Vycm9yLnRzJztcbmV4cG9ydCAqIGFzIEZ1bmN0aW9uIGZyb20gJy4vRnVuY3Rpb24udHMnO1xuZXhwb3J0ICogYXMgSFRNTEVsZW1lbnQgZnJvbSAnLi9IVE1MRWxlbWVudC50cyc7XG5leHBvcnQgKiBhcyBPYmplY3QgZnJvbSAnLi9PYmplY3QudHMnO1xuZXhwb3J0ICogYXMgb2JzaWRpYW4gZnJvbSAnLi9vYnNpZGlhbi9pbmRleC50cyc7XG5leHBvcnQgKiBhcyBQYXRoIGZyb20gJy4vUGF0aC50cyc7XG5leHBvcnQgKiBhcyBSZWdFeHAgZnJvbSAnLi9SZWdFeHAudHMnO1xuZXhwb3J0ICogYXMgc2NyaXB0cyBmcm9tICcuL3NjcmlwdHMvaW5kZXgudHMnO1xuZXhwb3J0ICogYXMgU3RyaW5nIGZyb20gJy4vU3RyaW5nLnRzJztcbmV4cG9ydCAqIGFzIHVybCBmcm9tICcuL3VybC50cyc7XG5leHBvcnQgKiBhcyBWYWx1ZVByb3ZpZGVyIGZyb20gJy4vVmFsdWVQcm92aWRlci50cyc7XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBLGVBQUFBO0FBQUEsRUFBQTtBQUFBO0FBQUEsZ0JBQUFDO0FBQUEsRUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUVBLGFBQXdCO0FBQ3hCLFlBQXVCO0FBQ3ZCLFdBQXNCO0FBQ3RCLFlBQXVCO0FBQ3ZCLElBQUFELFNBQXVCO0FBQ3ZCLGVBQTBCO0FBQzFCLGtCQUE2QjtBQUM3QixJQUFBQyxVQUF3QjtBQUN4QixlQUEwQjtBQUMxQixXQUFzQjtBQUN0QixhQUF3QjtBQUN4QixjQUF5QjtBQUN6QixhQUF3QjtBQUN4QixVQUFxQjtBQUNyQixvQkFBK0I7IiwKICAibmFtZXMiOiBbIkVycm9yIiwgIk9iamVjdCJdCn0K
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vc3JjL2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKiBUSElTIElTIEEgR0VORVJBVEVEL0JVTkRMRUQgRklMRSBCWSBCVUlMRCBTQ1JJUFQgKi9cblxuZXhwb3J0ICogYXMgX3R5cGVzIGZyb20gJy4vQHR5cGVzLnRzJztcbmV4cG9ydCAqIGFzIEFzeW5jIGZyb20gJy4vQXN5bmMudHMnO1xuZXhwb3J0ICogYXMgQmxvYiBmcm9tICcuL0Jsb2IudHMnO1xuZXhwb3J0ICogYXMgRGVidWcgZnJvbSAnLi9EZWJ1Zy50cyc7XG5leHBvcnQgKiBhcyBEZWJ1Z0NvbnRyb2xsZXIgZnJvbSAnLi9EZWJ1Z0NvbnRyb2xsZXIudHMnO1xuZXhwb3J0ICogYXMgRXJyb3IgZnJvbSAnLi9FcnJvci50cyc7XG5leHBvcnQgKiBhcyBGdW5jdGlvbiBmcm9tICcuL0Z1bmN0aW9uLnRzJztcbmV4cG9ydCAqIGFzIEhUTUxFbGVtZW50IGZyb20gJy4vSFRNTEVsZW1lbnQudHMnO1xuZXhwb3J0ICogYXMgT2JqZWN0IGZyb20gJy4vT2JqZWN0LnRzJztcbmV4cG9ydCAqIGFzIG9ic2lkaWFuIGZyb20gJy4vb2JzaWRpYW4vaW5kZXgudHMnO1xuZXhwb3J0ICogYXMgUGF0aCBmcm9tICcuL1BhdGgudHMnO1xuZXhwb3J0ICogYXMgUmVnRXhwIGZyb20gJy4vUmVnRXhwLnRzJztcbmV4cG9ydCAqIGFzIHNjcmlwdHMgZnJvbSAnLi9zY3JpcHRzL2luZGV4LnRzJztcbmV4cG9ydCAqIGFzIFN0cmluZyBmcm9tICcuL1N0cmluZy50cyc7XG5leHBvcnQgKiBhcyB1cmwgZnJvbSAnLi91cmwudHMnO1xuZXhwb3J0ICogYXMgVmFsdWVQcm92aWRlciBmcm9tICcuL1ZhbHVlUHJvdmlkZXIudHMnO1xuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBLGVBQUFBO0FBQUEsRUFBQTtBQUFBO0FBQUEsZ0JBQUFDO0FBQUEsRUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUVBLGFBQXdCO0FBQ3hCLFlBQXVCO0FBQ3ZCLFdBQXNCO0FBQ3RCLFlBQXVCO0FBQ3ZCLHNCQUFpQztBQUNqQyxJQUFBRCxTQUF1QjtBQUN2QixlQUEwQjtBQUMxQixrQkFBNkI7QUFDN0IsSUFBQUMsVUFBd0I7QUFDeEIsZUFBMEI7QUFDMUIsV0FBc0I7QUFDdEIsYUFBd0I7QUFDeEIsY0FBeUI7QUFDekIsYUFBd0I7QUFDeEIsVUFBcUI7QUFDckIsb0JBQStCOyIsCiAgIm5hbWVzIjogWyJFcnJvciIsICJPYmplY3QiXQp9Cg==

package/dist/lib/index.d.ts

@@ -2,6 +2,7 @@ export * as _types from './@types.ts';
 export * as Async from './Async.ts';
 export * as Blob from './Blob.ts';
 export * as Debug from './Debug.ts';
+export * as DebugController from './DebugController.ts';
 export * as Error from './Error.ts';
 export * as Function from './Function.ts';
 export * as HTMLElement from './HTMLElement.ts';

package/dist/lib/obsidian/Logger.cjs

@@ -32,35 +32,35 @@ __export(Logger_exports, {
 module.exports = __toCommonJS(Logger_exports);
 var import_Debug = require('../Debug.cjs');
 var import_Error = require('../Error.cjs');
-const invokeAsyncAndLogDebugger = (0, import_Debug.getDebugger)("obsidian-dev-utils:Logger:invokeAsyncAndLog");
 async function invokeAsyncAndLog(title, fn, stackTrace) {
+  const _debugger = (0, import_Debug.getLibDebugger)("Logger:invokeAsyncAndLog");
   const timestampStart = performance.now();
   stackTrace ??= (0, import_Error.getStackTrace)(1);
-  invokeAsyncAndLogDebugger(`${title}:start`, {
+  _debugger(`${title}:start`, {
     fn,
     timestampStart
   });
-  invokeAsyncAndLogDebugger.printStackTrace(stackTrace);
+  _debugger.printStackTrace(stackTrace);
   try {
     await fn();
     const timestampEnd = performance.now();
-    invokeAsyncAndLogDebugger(`${title}:end`, {
+    _debugger(`${title}:end`, {
       duration: timestampEnd - timestampStart,
       fn,
       timestampEnd,
       timestampStart
     });
-    invokeAsyncAndLogDebugger.printStackTrace(stackTrace);
+    _debugger.printStackTrace(stackTrace);
   } catch (error) {
     const timestampEnd = performance.now();
-    invokeAsyncAndLogDebugger(`${title}:error`, {
+    _debugger(`${title}:error`, {
       duration: timestampEnd - timestampStart,
       error,
       fn,
       timestampEnd,
       timestampStart
     });
-    invokeAsyncAndLogDebugger.printStackTrace(stackTrace);
+    _debugger.printStackTrace(stackTrace);
     throw error;
   }
 }
@@ -68,4 +68,4 @@ async function invokeAsyncAndLog(title, fn, stackTrace) {
 0 && (module.exports = {
   invokeAsyncAndLog
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/obsidian/Loop.cjs

@@ -51,7 +51,7 @@ async function loop(options) {
     const iterationStr = `# ${iterationCount.toString()} / ${items.length.toString()}`;
     const message = options.buildNoticeMessage(item, iterationStr);
     notice.setMessage(message);
-    (0, import_Debug.getDebugger)("obsidian-dev-utils:loop")(message);
+    (0, import_Debug.getLibDebugger)("Loop")(message);
     try {
       await options.processItem(item);
     } catch (error) {
@@ -69,4 +69,4 @@ async function loop(options) {
 0 && (module.exports = {
   loop
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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