obsidian-dev-utils 3.42.3 → 3.43.0

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # CHANGELOG
 
+## 3.43.0
+
+- Extract Exec
+- Don't fail on error in retryWithTimeout
+
+## 3.42.4
+
+- Remove code after source maps
+
 ## 3.42.3
 
 - Avoid line break

package/dist/lib/Async.cjs

@@ -51,7 +51,14 @@ async function retryWithTimeout(fn, retryOptions = {}) {
     let attempt = 0;
     for (; ; ) {
       attempt++;
-      if (await fn()) {
+      let isSuccess;
+      try {
+        isSuccess = await fn();
+      } catch (error) {
+        (0, import_Error.printError)(error);
+        isSuccess = false;
+      }
+      if (isSuccess) {
         if (attempt > 1) {
           console.debug(`Retry completed successfully after ${attempt.toString()} attempts`);
         }
@@ -125,4 +132,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 {\n  emitAsyncErrorEvent,\n  getStackTrace\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> = T | Promise<T>;\n\n/**\n * Options for configuring the retry behavior.\n */\nexport interface RetryOptions {\n  /**\n   * The maximum time in milliseconds to wait before giving up on retrying.\n   */\n  timeoutInMilliseconds: number;\n\n  /**\n   * The delay in milliseconds between retry attempts.\n   */\n  retryDelayInMilliseconds: number;\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: Partial<RetryOptions> = {}): Promise<void> {\n  const stackTrace = getStackTrace();\n  const DEFAULT_RETRY_OPTIONS: RetryOptions = {\n    timeoutInMilliseconds: 5000,\n    retryDelayInMilliseconds: 100\n  };\n  const overriddenOptions: RetryOptions = { ...DEFAULT_RETRY_OPTIONS, ...retryOptions };\n  await runWithTimeout(overriddenOptions.timeoutInMilliseconds, async () => {\n    let attempt = 0;\n    for (; ;) {\n      attempt++;\n      if (await fn()) {\n        if (attempt > 1) {\n          console.debug(`Retry completed successfully after ${attempt.toString()} attempts`);\n        }\n        return;\n      }\n\n      console.debug(`Retry attempt ${attempt.toString()} completed unsuccessfully. Trying again in ${overriddenOptions.retryDelayInMilliseconds.toString()} milliseconds`, {\n        fn,\n        stackTrace\n      });\n      await sleep(overriddenOptions.retryDelayInMilliseconds);\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 * 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 * @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  return await Promise.race([fn(), timeout(timeoutInMilliseconds)]);\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 * 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 * 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 * 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 * 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 * 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 * 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": ";;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,mBAGO;AA8BP,eAAsB,iBAAiB,IAAiC,eAAsC,CAAC,GAAkB;AAC/H,QAAM,iBAAa,4BAAc;AACjC,QAAM,wBAAsC;AAAA,IAC1C,uBAAuB;AAAA,IACvB,0BAA0B;AAAA,EAC5B;AACA,QAAM,oBAAkC,EAAE,GAAG,uBAAuB,GAAG,aAAa;AACpF,QAAM,eAAe,kBAAkB,uBAAuB,YAAY;AACxE,QAAI,UAAU;AACd,eAAU;AACR;AACA,UAAI,MAAM,GAAG,GAAG;AACd,YAAI,UAAU,GAAG;AACf,kBAAQ,MAAM,sCAAsC,QAAQ,SAAS,CAAC,WAAW;AAAA,QACnF;AACA;AAAA,MACF;AAEA,cAAQ,MAAM,iBAAiB,QAAQ,SAAS,CAAC,8CAA8C,kBAAkB,yBAAyB,SAAS,CAAC,iBAAiB;AAAA,QACnK;AAAA,QACA;AAAA,MACF,CAAC;AACD,YAAM,MAAM,kBAAkB,wBAAwB;AAAA,IACxD;AAAA,EACF,CAAC;AACH;AAQA,eAAsB,MAAM,cAAqC;AAC/D,QAAM,IAAI,QAAQ,CAAC,YAAY,WAAW,SAAS,YAAY,CAAC;AAClE;AAUA,eAAsB,eAAkB,uBAA+B,IAAuC;AAC5G,SAAO,MAAM,QAAQ,KAAK,CAAC,GAAG,GAAG,QAAQ,qBAAqB,CAAC,CAAC;AAClE;AAQA,eAAsB,QAAQ,uBAA+C;AAC3E,QAAM,MAAM,qBAAqB;AACjC,QAAM,IAAI,MAAM,gBAAgB,sBAAsB,SAAS,CAAC,eAAe;AACjF;AAOO,SAAS,kBAAkB,SAAuC;AACvE,OAAK,gBAAgB,OAAO;AAC9B;AAQA,eAAsB,gBAAgB,SAAgD;AACpF,MAAI;AACF,UAAM,QAAQ;AAAA,EAChB,SAAS,YAAY;AACnB,0CAAoB,UAAU;AAAA,EAChC;AACF;AASO,SAAS,mBAA2C,WAAyE;AAClI,SAAO,IAAI,SAAqB;AAC9B,sBAAkB,MAAM,UAAU,GAAG,IAAI,CAAC;AAAA,EAC5C;AACF;AAUO,SAAS,mBAAmD,QAAuE;AACxI,SAAO,IAAI,SAAgC,QAAQ,QAAQ,EAAE,KAAK,MAAM,OAAO,GAAG,IAAI,CAAC;AACzF;AAWA,eAAsB,SAAe,KAAU,UAAkF;AAC/H,SAAO,MAAM,QAAQ,IAAI,IAAI,IAAI,QAAQ,CAAC;AAC5C;AAUA,eAAsB,YAAe,KAAU,WAAyF;AACtI,QAAM,mBAAmB,MAAM,SAAS,KAAK,SAAS;AACtD,SAAO,IAAI,OAAO,CAAC,GAAG,UAAU,iBAAiB,KAAK,CAAC;AACzD;AAWA,eAAsB,aAAmB,KAAU,UAAoF;AACrI,UAAQ,MAAM,SAAS,KAAK,QAAQ,GAAG,KAAK;AAC9C;AASA,eAAsB,QAAW,MAA8C;AAC7E,QAAM,MAAW,CAAC;AAClB,mBAAiB,QAAQ,MAAM;AAC7B,QAAI,KAAK,IAAI;AAAA,EACf;AACA,SAAO;AACT;",
  "names": []
}

+//# 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 {\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> = T | Promise<T>;\n\n/**\n * Options for configuring the retry behavior.\n */\nexport interface RetryOptions {\n  /**\n   * The maximum time in milliseconds to wait before giving up on retrying.\n   */\n  timeoutInMilliseconds: number;\n\n  /**\n   * The delay in milliseconds between retry attempts.\n   */\n  retryDelayInMilliseconds: number;\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: Partial<RetryOptions> = {}): Promise<void> {\n  const stackTrace = getStackTrace();\n  const DEFAULT_RETRY_OPTIONS: RetryOptions = {\n    timeoutInMilliseconds: 5000,\n    retryDelayInMilliseconds: 100\n  };\n  const overriddenOptions: RetryOptions = { ...DEFAULT_RETRY_OPTIONS, ...retryOptions };\n  await runWithTimeout(overriddenOptions.timeoutInMilliseconds, async () => {\n    let attempt = 0;\n    for (; ;) {\n      attempt++;\n      let isSuccess: boolean;\n      try {\n        isSuccess = await fn();\n      } catch (error) {\n        printError(error);\n        isSuccess = false;\n      }\n      if (isSuccess) {\n        if (attempt > 1) {\n          console.debug(`Retry completed successfully after ${attempt.toString()} attempts`);\n        }\n        return;\n      }\n\n      console.debug(`Retry attempt ${attempt.toString()} completed unsuccessfully. Trying again in ${overriddenOptions.retryDelayInMilliseconds.toString()} milliseconds`, {\n        fn,\n        stackTrace\n      });\n      await sleep(overriddenOptions.retryDelayInMilliseconds);\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 * 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 * @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  return await Promise.race([fn(), timeout(timeoutInMilliseconds)]);\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 * 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 * 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 * 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 * 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 * 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 * 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": ";;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,mBAIO;AA8BP,eAAsB,iBAAiB,IAAiC,eAAsC,CAAC,GAAkB;AAC/H,QAAM,iBAAa,4BAAc;AACjC,QAAM,wBAAsC;AAAA,IAC1C,uBAAuB;AAAA,IACvB,0BAA0B;AAAA,EAC5B;AACA,QAAM,oBAAkC,EAAE,GAAG,uBAAuB,GAAG,aAAa;AACpF,QAAM,eAAe,kBAAkB,uBAAuB,YAAY;AACxE,QAAI,UAAU;AACd,eAAU;AACR;AACA,UAAI;AACJ,UAAI;AACF,oBAAY,MAAM,GAAG;AAAA,MACvB,SAAS,OAAO;AACd,qCAAW,KAAK;AAChB,oBAAY;AAAA,MACd;AACA,UAAI,WAAW;AACb,YAAI,UAAU,GAAG;AACf,kBAAQ,MAAM,sCAAsC,QAAQ,SAAS,CAAC,WAAW;AAAA,QACnF;AACA;AAAA,MACF;AAEA,cAAQ,MAAM,iBAAiB,QAAQ,SAAS,CAAC,8CAA8C,kBAAkB,yBAAyB,SAAS,CAAC,iBAAiB;AAAA,QACnK;AAAA,QACA;AAAA,MACF,CAAC;AACD,YAAM,MAAM,kBAAkB,wBAAwB;AAAA,IACxD;AAAA,EACF,CAAC;AACH;AAQA,eAAsB,MAAM,cAAqC;AAC/D,QAAM,IAAI,QAAQ,CAAC,YAAY,WAAW,SAAS,YAAY,CAAC;AAClE;AAUA,eAAsB,eAAkB,uBAA+B,IAAuC;AAC5G,SAAO,MAAM,QAAQ,KAAK,CAAC,GAAG,GAAG,QAAQ,qBAAqB,CAAC,CAAC;AAClE;AAQA,eAAsB,QAAQ,uBAA+C;AAC3E,QAAM,MAAM,qBAAqB;AACjC,QAAM,IAAI,MAAM,gBAAgB,sBAAsB,SAAS,CAAC,eAAe;AACjF;AAOO,SAAS,kBAAkB,SAAuC;AACvE,OAAK,gBAAgB,OAAO;AAC9B;AAQA,eAAsB,gBAAgB,SAAgD;AACpF,MAAI;AACF,UAAM,QAAQ;AAAA,EAChB,SAAS,YAAY;AACnB,0CAAoB,UAAU;AAAA,EAChC;AACF;AASO,SAAS,mBAA2C,WAAyE;AAClI,SAAO,IAAI,SAAqB;AAC9B,sBAAkB,MAAM,UAAU,GAAG,IAAI,CAAC;AAAA,EAC5C;AACF;AAUO,SAAS,mBAAmD,QAAuE;AACxI,SAAO,IAAI,SAAgC,QAAQ,QAAQ,EAAE,KAAK,MAAM,OAAO,GAAG,IAAI,CAAC;AACzF;AAWA,eAAsB,SAAe,KAAU,UAAkF;AAC/H,SAAO,MAAM,QAAQ,IAAI,IAAI,IAAI,QAAQ,CAAC;AAC5C;AAUA,eAAsB,YAAe,KAAU,WAAyF;AACtI,QAAM,mBAAmB,MAAM,SAAS,KAAK,SAAS;AACtD,SAAO,IAAI,OAAO,CAAC,GAAG,UAAU,iBAAiB,KAAK,CAAC;AACzD;AAWA,eAAsB,aAAmB,KAAU,UAAoF;AACrI,UAAQ,MAAM,SAAS,KAAK,QAAQ,GAAG,KAAK;AAC9C;AASA,eAAsB,QAAW,MAA8C;AAC7E,QAAM,MAAW,CAAC;AAClB,mBAAiB,QAAQ,MAAM;AAC7B,QAAI,KAAK,IAAI;AAAA,EACf;AACA,SAAO;AACT;",
  "names": []
}


package/dist/lib/scripts/Exec.cjs

@@ -0,0 +1,123 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function patchRequireEsmDefault(){const __require=require;require=Object.assign(id=>{const module=__require(id);return module.__esModule&&module.default?module.default:module},__require)})()
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 Exec_exports = {};
+__export(Exec_exports, {
+  exec: () => exec
+});
+module.exports = __toCommonJS(Exec_exports);
+var import_String = require('../String.cjs');
+var import_CliUtils = require('./CliUtils.cjs');
+var import_NodeModules = require('./NodeModules.cjs');
+var __process = globalThis["process"] ?? {
+  "cwd": () => "/",
+  "env": {},
+  "platform": "android"
+};
+function exec(command, options = {}) {
+  const {
+    quiet = false,
+    ignoreExitCode = false,
+    stdin = "",
+    cwd = import_NodeModules.process.cwd(),
+    withDetails = false
+  } = options;
+  if (Array.isArray(command)) {
+    command = (0, import_CliUtils.toCommandLine)(command);
+  }
+  return new Promise((resolve, reject) => {
+    console.log(`Executing command: ${command}`);
+    const [cmd = "", ...args] = command.split(" ");
+    const child = (0, import_NodeModules.spawn)(cmd, args, {
+      cwd,
+      stdio: "pipe",
+      shell: true
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdin.write(stdin);
+    child.stdin.end();
+    child.stdout.on("data", (data) => {
+      if (!quiet) {
+        import_NodeModules.process.stdout.write(data);
+      }
+      stdout += data.toString("utf-8");
+    });
+    child.stdout.on("end", () => {
+      stdout = (0, import_String.trimEnd)(stdout, "\n");
+    });
+    child.stderr.on("data", (data) => {
+      if (!quiet) {
+        import_NodeModules.process.stderr.write(data);
+      }
+      stderr += data.toString("utf-8");
+    });
+    child.stderr.on("end", () => {
+      stderr = (0, import_String.trimEnd)(stderr, "\n");
+    });
+    child.on("close", (exitCode, exitSignal) => {
+      if (exitCode !== 0 && !ignoreExitCode) {
+        reject(new Error(`Command failed with exit code ${exitCode?.toString() ?? "(null)"}
+${stderr}`));
+      } else {
+        let result;
+        if (!withDetails) {
+          result = stdout;
+        } else {
+          result = {
+            exitCode,
+            exitSignal,
+            stderr,
+            stdout
+          };
+        }
+        resolve(result);
+      }
+    });
+    child.on("error", (err) => {
+      if (!ignoreExitCode) {
+        reject(err);
+      } else {
+        let result;
+        if (!withDetails) {
+          result = stdout;
+        } else {
+          result = {
+            exitCode: null,
+            exitSignal: null,
+            stderr,
+            stdout
+          };
+        }
+        resolve(result);
+      }
+    });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  exec
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/scripts/Exec.ts"],
  "sourcesContent": ["var __process = globalThis['process'] ?? {\n  \"cwd\": ()=>\"/\",\n  \"env\": {},\n  \"platform\": \"android\"\n};\nimport { trimEnd } from '../String.ts';\r\nimport { toCommandLine } from './CliUtils.ts';\r\nimport {\r\n  process,\r\n  spawn\r\n} from './NodeModules.ts';\r\n\r\n/**\r\n * Represents the result of executing a command.\r\n */\r\nexport interface ExecResult {\r\n  /**\r\n   * The exit code of the command. A value of `null` indicates that the process did not exit normally.\r\n   */\r\n  exitCode: number | null;\r\n\r\n  /**\r\n   * The signal that caused the process to be terminated. A value of `null` indicates that no signal was received.\r\n   */\r\n  exitSignal: NodeJS.Signals | null;\r\n\r\n  /**\r\n   * The standard error output from the command.\r\n   */\r\n  stderr: string;\r\n\r\n  /**\r\n   * The standard output from the command.\r\n   */\r\n  stdout: string;\r\n}\r\n\r\n/**\r\n * Options for executing a command.\r\n */\r\nexport interface ExecOption {\r\n  /**\r\n   * If true, suppresses the output of the command.\r\n   */\r\n  quiet?: boolean;\r\n\r\n  /**\r\n   * If true, ignores the exit code of the command.\r\n   */\r\n  ignoreExitCode?: boolean;\r\n\r\n  /**\r\n   * The input to be passed to the command.\r\n   */\r\n  stdin?: string;\r\n\r\n  /**\r\n   * The current working directory for the command execution.\r\n   */\r\n  cwd?: string | undefined;\r\n\r\n  /**\r\n   * If false, only returns the output of the command.\r\n   */\r\n  withDetails?: boolean;\r\n}\r\n\r\n/**\r\n * Executes a command.\r\n *\r\n * @param command - The command to execute. It can be a string or an array of strings.\r\n * @param options - The options for the execution.\r\n * @returns A Promise that resolves with the output of the command.\r\n * @throws If the command fails with a non-zero exit code and ignoreExitCode is false.\r\n *         The error message includes the exit code and stderr.\r\n *         If an error occurs during the execution and ignoreExitCode is true,\r\n *         the error is resolved with the stdout and stderr.\r\n */\r\nexport async function exec(command: string | string[], options?: ExecOption & { withDetails?: false }): Promise<string>;\r\n\r\n/**\r\n * Executes a command.\r\n *\r\n * @param command - The command to execute. It can be a string or an array of strings.\r\n * @param options - The options for the execution.\r\n * @returns A Promise that resolves with ExecResult object.\r\n *          The ExecResult object contains the exit code, exit signal, stderr, and stdout.\r\n * @throws If the command fails with a non-zero exit code and ignoreExitCode is false.\r\n *         The error message includes the exit code and stderr.\r\n *         If an error occurs during the execution and ignoreExitCode is true,\r\n *         the error is resolved with the stdout and stderr.\r\n */\r\nexport function exec(command: string | string[], options: ExecOption & { withDetails: true }): Promise<ExecResult>;\r\n\r\n/**\r\n * Executes a command.\r\n *\r\n * @param command - The command to execute. It can be a string or an array of strings.\r\n * @param options - The options for the execution.\r\n * @returns A Promise that resolves with the output of the command or an ExecResult object.\r\n *          The ExecResult object contains the exit code, exit signal, stderr, and stdout.\r\n * @throws If the command fails with a non-zero exit code and ignoreExitCode is false.\r\n *         The error message includes the exit code and stderr.\r\n *         If an error occurs during the execution and ignoreExitCode is true,\r\n *         the error is resolved with the stdout and stderr.\r\n */\r\nexport function exec(command: string | string[], options: ExecOption = {}): Promise<string | ExecResult> {\r\n  const {\r\n    quiet = false,\r\n    ignoreExitCode = false,\r\n    stdin = '',\r\n    cwd = process.cwd(),\r\n    withDetails = false\r\n  } = options;\r\n  if (Array.isArray(command)) {\r\n    command = toCommandLine(command);\r\n  }\r\n\r\n  return new Promise((resolve, reject) => {\r\n    console.log(`Executing command: ${command}`);\r\n    const [cmd = '', ...args] = command.split(' ');\r\n\r\n    const child = spawn(cmd, args, {\r\n      cwd,\r\n      stdio: 'pipe',\r\n      shell: true\r\n    });\r\n\r\n    let stdout = '';\r\n    let stderr = '';\r\n\r\n    child.stdin.write(stdin);\r\n    child.stdin.end();\r\n\r\n    child.stdout.on('data', (data: Buffer) => {\r\n      if (!quiet) {\r\n        process.stdout.write(data);\r\n      }\r\n      stdout += data.toString('utf-8');\r\n    });\r\n\r\n    child.stdout.on('end', () => {\r\n      stdout = trimEnd(stdout, '\\n');\r\n    });\r\n\r\n    child.stderr.on('data', (data: Buffer) => {\r\n      if (!quiet) {\r\n        process.stderr.write(data);\r\n      }\r\n      stderr += data.toString('utf-8');\r\n    });\r\n\r\n    child.stderr.on('end', () => {\r\n      stderr = trimEnd(stderr, '\\n');\r\n    });\r\n\r\n    child.on('close', (exitCode, exitSignal) => {\r\n      if (exitCode !== 0 && !ignoreExitCode) {\r\n        reject(new Error(`Command failed with exit code ${exitCode?.toString() ?? '(null)'}\\n${stderr}`));\r\n      } else {\r\n        let result: string | ExecResult;\r\n        if (!withDetails) {\r\n          result = stdout;\r\n        } else {\r\n          result = {\r\n            exitCode,\r\n            exitSignal,\r\n            stderr,\r\n            stdout\r\n          };\r\n        }\r\n        resolve(result);\r\n      }\r\n    });\r\n\r\n    child.on('error', (err) => {\r\n      if (!ignoreExitCode) {\r\n        reject(err);\r\n      } else {\r\n        let result: string | ExecResult;\r\n        if (!withDetails) {\r\n          result = stdout;\r\n        } else {\r\n          result = {\r\n            exitCode: null,\r\n            exitSignal: null,\r\n            stderr,\r\n            stdout\r\n          };\r\n        }\r\n        resolve(result);\r\n      }\r\n    });\r\n  });\r\n}\r\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,oBAAwB;AACxB,sBAA8B;AAC9B,yBAGO;AAVP,IAAI,YAAY,WAAW,SAAS,KAAK;AAAA,EACvC,OAAO,MAAI;AAAA,EACX,OAAO,CAAC;AAAA,EACR,YAAY;AACd;AAsGO,SAAS,KAAK,SAA4B,UAAsB,CAAC,GAAiC;AACvG,QAAM;AAAA,IACJ,QAAQ;AAAA,IACR,iBAAiB;AAAA,IACjB,QAAQ;AAAA,IACR,MAAM,2BAAQ,IAAI;AAAA,IAClB,cAAc;AAAA,EAChB,IAAI;AACJ,MAAI,MAAM,QAAQ,OAAO,GAAG;AAC1B,kBAAU,+BAAc,OAAO;AAAA,EACjC;AAEA,SAAO,IAAI,QAAQ,CAAC,SAAS,WAAW;AACtC,YAAQ,IAAI,sBAAsB,OAAO,EAAE;AAC3C,UAAM,CAAC,MAAM,IAAI,GAAG,IAAI,IAAI,QAAQ,MAAM,GAAG;AAE7C,UAAM,YAAQ,0BAAM,KAAK,MAAM;AAAA,MAC7B;AAAA,MACA,OAAO;AAAA,MACP,OAAO;AAAA,IACT,CAAC;AAED,QAAI,SAAS;AACb,QAAI,SAAS;AAEb,UAAM,MAAM,MAAM,KAAK;AACvB,UAAM,MAAM,IAAI;AAEhB,UAAM,OAAO,GAAG,QAAQ,CAAC,SAAiB;AACxC,UAAI,CAAC,OAAO;AACV,mCAAQ,OAAO,MAAM,IAAI;AAAA,MAC3B;AACA,gBAAU,KAAK,SAAS,OAAO;AAAA,IACjC,CAAC;AAED,UAAM,OAAO,GAAG,OAAO,MAAM;AAC3B,mBAAS,uBAAQ,QAAQ,IAAI;AAAA,IAC/B,CAAC;AAED,UAAM,OAAO,GAAG,QAAQ,CAAC,SAAiB;AACxC,UAAI,CAAC,OAAO;AACV,mCAAQ,OAAO,MAAM,IAAI;AAAA,MAC3B;AACA,gBAAU,KAAK,SAAS,OAAO;AAAA,IACjC,CAAC;AAED,UAAM,OAAO,GAAG,OAAO,MAAM;AAC3B,mBAAS,uBAAQ,QAAQ,IAAI;AAAA,IAC/B,CAAC;AAED,UAAM,GAAG,SAAS,CAAC,UAAU,eAAe;AAC1C,UAAI,aAAa,KAAK,CAAC,gBAAgB;AACrC,eAAO,IAAI,MAAM,iCAAiC,UAAU,SAAS,KAAK,QAAQ;AAAA,EAAK,MAAM,EAAE,CAAC;AAAA,MAClG,OAAO;AACL,YAAI;AACJ,YAAI,CAAC,aAAa;AAChB,mBAAS;AAAA,QACX,OAAO;AACL,mBAAS;AAAA,YACP;AAAA,YACA;AAAA,YACA;AAAA,YACA;AAAA,UACF;AAAA,QACF;AACA,gBAAQ,MAAM;AAAA,MAChB;AAAA,IACF,CAAC;AAED,UAAM,GAAG,SAAS,CAAC,QAAQ;AACzB,UAAI,CAAC,gBAAgB;AACnB,eAAO,GAAG;AAAA,MACZ,OAAO;AACL,YAAI;AACJ,YAAI,CAAC,aAAa;AAChB,mBAAS;AAAA,QACX,OAAO;AACL,mBAAS;AAAA,YACP,UAAU;AAAA,YACV,YAAY;AAAA,YACZ;AAAA,YACA;AAAA,UACF;AAAA,QACF;AACA,gBAAQ,MAAM;AAAA,MAChB;AAAA,IACF,CAAC;AAAA,EACH,CAAC;AACH;",
  "names": []
}


package/dist/lib/scripts/Exec.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Represents the result of executing a command.
+ */
+export interface ExecResult {
+    /**
+     * The exit code of the command. A value of `null` indicates that the process did not exit normally.
+     */
+    exitCode: number | null;
+    /**
+     * The signal that caused the process to be terminated. A value of `null` indicates that no signal was received.
+     */
+    exitSignal: NodeJS.Signals | null;
+    /**
+     * The standard error output from the command.
+     */
+    stderr: string;
+    /**
+     * The standard output from the command.
+     */
+    stdout: string;
+}
+/**
+ * Options for executing a command.
+ */
+export interface ExecOption {
+    /**
+     * If true, suppresses the output of the command.
+     */
+    quiet?: boolean;
+    /**
+     * If true, ignores the exit code of the command.
+     */
+    ignoreExitCode?: boolean;
+    /**
+     * The input to be passed to the command.
+     */
+    stdin?: string;
+    /**
+     * The current working directory for the command execution.
+     */
+    cwd?: string | undefined;
+    /**
+     * If false, only returns the output of the command.
+     */
+    withDetails?: boolean;
+}
+/**
+ * Executes a command.
+ *
+ * @param command - The command to execute. It can be a string or an array of strings.
+ * @param options - The options for the execution.
+ * @returns A Promise that resolves with the output of the command.
+ * @throws If the command fails with a non-zero exit code and ignoreExitCode is false.
+ *         The error message includes the exit code and stderr.
+ *         If an error occurs during the execution and ignoreExitCode is true,
+ *         the error is resolved with the stdout and stderr.
+ */
+export declare function exec(command: string | string[], options?: ExecOption & {
+    withDetails?: false;
+}): Promise<string>;
+/**
+ * Executes a command.
+ *
+ * @param command - The command to execute. It can be a string or an array of strings.
+ * @param options - The options for the execution.
+ * @returns A Promise that resolves with ExecResult object.
+ *          The ExecResult object contains the exit code, exit signal, stderr, and stdout.
+ * @throws If the command fails with a non-zero exit code and ignoreExitCode is false.
+ *         The error message includes the exit code and stderr.
+ *         If an error occurs during the execution and ignoreExitCode is true,
+ *         the error is resolved with the stdout and stderr.
+ */
+export declare function exec(command: string | string[], options: ExecOption & {
+    withDetails: true;
+}): Promise<ExecResult>;

package/dist/lib/scripts/Root.cjs

@@ -32,8 +32,7 @@ __export(Root_exports, {
 });
 module.exports = __toCommonJS(Root_exports);
 var import_Path = require('../Path.cjs');
-var import_String = require('../String.cjs');
-var import_CliUtils = require('./CliUtils.cjs');
+var import_Exec = require('./Exec.cjs');
 var import_NodeModules = require('./NodeModules.cjs');
 var import_ObsidianDevUtilsRepoPaths = require('./ObsidianDevUtilsRepoPaths.cjs');
 var __process = globalThis["process"] ?? {
@@ -42,90 +41,17 @@ var __process = globalThis["process"] ?? {
   "platform": "android"
 };
 function execFromRoot(command, options = {}) {
-  const {
-    quiet = false,
-    ignoreExitCode = false,
-    stdin = "",
-    cwd = void 0,
-    withDetails = false
-  } = options;
-  if (Array.isArray(command)) {
-    command = (0, import_CliUtils.toCommandLine)(command);
+  const root = getRootDir(options.cwd);
+  if (options.withDetails) {
+    return (0, import_Exec.exec)(command, { ...options, cwd: root, withDetails: true });
   }
-  return new Promise((resolve2, reject) => {
-    console.log(`Executing command: ${command}`);
-    const [cmd = "", ...args] = command.split(" ");
-    const child = (0, import_NodeModules.spawn)(cmd, args, {
-      cwd: getRootDir(cwd),
-      stdio: "pipe",
-      shell: true
-    });
-    let stdout = "";
-    let stderr = "";
-    child.stdin.write(stdin);
-    child.stdin.end();
-    child.stdout.on("data", (data) => {
-      if (!quiet) {
-        import_NodeModules.process.stdout.write(data);
-      }
-      stdout += data.toString("utf-8");
-    });
-    child.stdout.on("end", () => {
-      stdout = (0, import_String.trimEnd)(stdout, "\n");
-    });
-    child.stderr.on("data", (data) => {
-      if (!quiet) {
-        import_NodeModules.process.stderr.write(data);
-      }
-      stderr += data.toString("utf-8");
-    });
-    child.stderr.on("end", () => {
-      stderr = (0, import_String.trimEnd)(stderr, "\n");
-    });
-    child.on("close", (exitCode, exitSignal) => {
-      if (exitCode !== 0 && !ignoreExitCode) {
-        reject(new Error(`Command failed with exit code ${exitCode?.toString() ?? "(null)"}
-${stderr}`));
-      } else {
-        let result;
-        if (!withDetails) {
-          result = stdout;
-        } else {
-          result = {
-            exitCode,
-            exitSignal,
-            stderr,
-            stdout
-          };
-        }
-        resolve2(result);
-      }
-    });
-    child.on("error", (err) => {
-      if (!ignoreExitCode) {
-        reject(err);
-      } else {
-        let result;
-        if (!withDetails) {
-          result = stdout;
-        } else {
-          result = {
-            exitCode: null,
-            exitSignal: null,
-            stderr,
-            stdout
-          };
-        }
-        resolve2(result);
-      }
-    });
-  });
+  return (0, import_Exec.exec)(command, { ...options, cwd: root, withDetails: false });
 }
 function resolvePathFromRoot(path, cwd) {
   return (0, import_Path.resolve)(getRootDir(cwd), path);
 }
 function getRootDir(cwd) {
-  let currentDir = (0, import_Path.toPosixPath)(cwd ?? import_NodeModules.process.cwd());
+  let currentDir = (0, import_Path.toPosixPath)(cwd ?? __process.cwd());
   while (currentDir !== "." && currentDir !== "/") {
     if ((0, import_NodeModules.existsSync)((0, import_Path.join)(currentDir, import_ObsidianDevUtilsRepoPaths.ObsidianDevUtilsRepoPaths.PackageJson))) {
       return (0, import_Path.toPosixPath)(currentDir);
@@ -146,4 +72,4 @@ function toRelativeFromRoot(path, cwd) {
   resolvePathFromRoot,
   toRelativeFromRoot
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/scripts/Root.ts"],
  "sourcesContent": ["var __process = globalThis['process'] ?? {\n  \"cwd\": ()=>\"/\",\n  \"env\": {},\n  \"platform\": \"android\"\n};\n/**\n * @packageDocumentation Root\n * Contains utility functions for executing commands from the root directory of a project,\n * resolving paths relative to the root.\n */\n\nimport {\n  dirname,\n  join,\n  relative,\n  resolve,\n  toPosixPath\n} from '../Path.ts';\nimport { trimEnd } from '../String.ts';\nimport { toCommandLine } from './CliUtils.ts';\nimport {\n  existsSync,\n  process,\n  spawn\n} from './NodeModules.ts';\nimport { ObsidianDevUtilsRepoPaths } from './ObsidianDevUtilsRepoPaths.ts';\n\n/**\n * Represents the result of executing a command from the root directory.\n */\nexport interface ExecFromRootResult {\n  /**\n   * The exit code of the command. A value of `null` indicates that the process did not exit normally.\n   */\n  exitCode: number | null;\n\n  /**\n   * The signal that caused the process to be terminated. A value of `null` indicates that no signal was received.\n   */\n  exitSignal: NodeJS.Signals | null;\n\n  /**\n   * The standard error output from the command.\n   */\n  stderr: string;\n\n  /**\n   * The standard output from the command.\n   */\n  stdout: string;\n}\n\n/**\n * Options for executing a command from the root directory.\n */\nexport interface ExecFromRootOption {\n  /**\n   * If true, suppresses the output of the command.\n   */\n  quiet?: boolean;\n\n  /**\n   * If true, ignores the exit code of the command.\n   */\n  ignoreExitCode?: boolean;\n\n  /**\n   * The input to be passed to the command.\n   */\n  stdin?: string;\n\n  /**\n   * The current working directory for the command execution.\n   */\n  cwd?: string | undefined;\n\n  /**\n   * If false, only returns the output of the command.\n   */\n  withDetails?: boolean;\n}\n\n/**\n * Executes a command from the root directory of the project.\n *\n * @param command - The command to execute. It can be a string or an array of strings.\n * @param options - The options for the execution.\n * @returns A Promise that resolves with the output of the command.\n * @throws If the command fails with a non-zero exit code and ignoreExitCode is false.\n *         The error message includes the exit code and stderr.\n *         If an error occurs during the execution and ignoreExitCode is true,\n *         the error is resolved with the stdout and stderr.\n */\nexport async function execFromRoot(command: string | string[], options?: ExecFromRootOption & { withDetails?: false }): Promise<string>;\n\n/**\n * Executes a command from the root directory of the project.\n *\n * @param command - The command to execute. It can be a string or an array of strings.\n * @param options - The options for the execution.\n * @returns A Promise that resolves with ExecResult object.\n *          The ExecResult object contains the exit code, exit signal, stderr, and stdout.\n * @throws If the command fails with a non-zero exit code and ignoreExitCode is false.\n *         The error message includes the exit code and stderr.\n *         If an error occurs during the execution and ignoreExitCode is true,\n *         the error is resolved with the stdout and stderr.\n */\nexport function execFromRoot(command: string | string[], options: ExecFromRootOption & { withDetails: true }): Promise<ExecFromRootResult>;\n\n/**\n * Executes a command from the root directory of the project.\n *\n * @param command - The command to execute. It can be a string or an array of strings.\n * @param options - The options for the execution.\n * @returns A Promise that resolves with the output of the command or an ExecResult object.\n *          The ExecResult object contains the exit code, exit signal, stderr, and stdout.\n * @throws If the command fails with a non-zero exit code and ignoreExitCode is false.\n *         The error message includes the exit code and stderr.\n *         If an error occurs during the execution and ignoreExitCode is true,\n *         the error is resolved with the stdout and stderr.\n */\nexport function execFromRoot(command: string | string[], options: ExecFromRootOption = {}): Promise<string | ExecFromRootResult> {\n  const {\n    quiet = false,\n    ignoreExitCode = false,\n    stdin = '',\n    cwd = undefined,\n    withDetails = false\n  } = options;\n  if (Array.isArray(command)) {\n    command = toCommandLine(command);\n  }\n\n  return new Promise((resolve, reject) => {\n    console.log(`Executing command: ${command}`);\n    const [cmd = '', ...args] = command.split(' ');\n\n    const child = spawn(cmd, args, {\n      cwd: getRootDir(cwd),\n      stdio: 'pipe',\n      shell: true\n    });\n\n    let stdout = '';\n    let stderr = '';\n\n    child.stdin.write(stdin);\n    child.stdin.end();\n\n    child.stdout.on('data', (data: Buffer) => {\n      if (!quiet) {\n        process.stdout.write(data);\n      }\n      stdout += data.toString('utf-8');\n    });\n\n    child.stdout.on('end', () => {\n      stdout = trimEnd(stdout, '\\n');\n    });\n\n    child.stderr.on('data', (data: Buffer) => {\n      if (!quiet) {\n        process.stderr.write(data);\n      }\n      stderr += data.toString('utf-8');\n    });\n\n    child.stderr.on('end', () => {\n      stderr = trimEnd(stderr, '\\n');\n    });\n\n    child.on('close', (exitCode, exitSignal) => {\n      if (exitCode !== 0 && !ignoreExitCode) {\n        reject(new Error(`Command failed with exit code ${exitCode?.toString() ?? '(null)'}\\n${stderr}`));\n      } else {\n        let result: string | ExecFromRootResult;\n        if (!withDetails) {\n          result = stdout;\n        } else {\n          result = {\n            exitCode,\n            exitSignal,\n            stderr,\n            stdout\n          };\n        }\n        resolve(result);\n      }\n    });\n\n    child.on('error', (err) => {\n      if (!ignoreExitCode) {\n        reject(err);\n      } else {\n        let result: string | ExecFromRootResult;\n        if (!withDetails) {\n          result = stdout;\n        } else {\n          result = {\n            exitCode: null,\n            exitSignal: null,\n            stderr,\n            stdout\n          };\n        }\n        resolve(result);\n      }\n    });\n  });\n}\n\n/**\n * Resolves a path relative to the root directory of the project.\n *\n * @param path - The path to resolve.\n * @param cwd - The current working directory to resolve from.\n * @returns The resolved absolute path.\n */\nexport function resolvePathFromRoot(path: string, cwd?: string): string {\n  return resolve(getRootDir(cwd), path);\n}\n\n/**\n * Retrieves the root directory of the project.\n *\n * @param cwd - The current working directory to resolve from.\n * @returns The path to the root directory.\n * @throws If the root directory cannot be found.\n */\nexport function getRootDir(cwd?: string): string {\n  let currentDir = toPosixPath(cwd ?? process.cwd());\n  while (currentDir !== '.' && currentDir !== '/') {\n    if (existsSync(join(currentDir, ObsidianDevUtilsRepoPaths.PackageJson))) {\n      return toPosixPath(currentDir);\n    }\n    currentDir = dirname(currentDir);\n  }\n\n  throw new Error('Could not find root directory');\n}\n\n/**\n * Converts an absolute path to a relative path from the root directory of the project.\n *\n * @param path - The absolute path to convert.\n * @param cwd - The current working directory to resolve from.\n * @returns The relative path from the root directory.\n */\nexport function toRelativeFromRoot(path: string, cwd?: string): string {\n  const rootDir = getRootDir(cwd);\n  path = toPosixPath(path);\n  return relative(rootDir, path);\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAWA,kBAMO;AACP,oBAAwB;AACxB,sBAA8B;AAC9B,yBAIO;AACP,uCAA0C;AAzB1C,IAAI,YAAY,WAAW,SAAS,KAAK;AAAA,EACvC,OAAO,MAAI;AAAA,EACX,OAAO,CAAC;AAAA,EACR,YAAY;AACd;AAqHO,SAAS,aAAa,SAA4B,UAA8B,CAAC,GAAyC;AAC/H,QAAM;AAAA,IACJ,QAAQ;AAAA,IACR,iBAAiB;AAAA,IACjB,QAAQ;AAAA,IACR,MAAM;AAAA,IACN,cAAc;AAAA,EAChB,IAAI;AACJ,MAAI,MAAM,QAAQ,OAAO,GAAG;AAC1B,kBAAU,+BAAc,OAAO;AAAA,EACjC;AAEA,SAAO,IAAI,QAAQ,CAACA,UAAS,WAAW;AACtC,YAAQ,IAAI,sBAAsB,OAAO,EAAE;AAC3C,UAAM,CAAC,MAAM,IAAI,GAAG,IAAI,IAAI,QAAQ,MAAM,GAAG;AAE7C,UAAM,YAAQ,0BAAM,KAAK,MAAM;AAAA,MAC7B,KAAK,WAAW,GAAG;AAAA,MACnB,OAAO;AAAA,MACP,OAAO;AAAA,IACT,CAAC;AAED,QAAI,SAAS;AACb,QAAI,SAAS;AAEb,UAAM,MAAM,MAAM,KAAK;AACvB,UAAM,MAAM,IAAI;AAEhB,UAAM,OAAO,GAAG,QAAQ,CAAC,SAAiB;AACxC,UAAI,CAAC,OAAO;AACV,mCAAQ,OAAO,MAAM,IAAI;AAAA,MAC3B;AACA,gBAAU,KAAK,SAAS,OAAO;AAAA,IACjC,CAAC;AAED,UAAM,OAAO,GAAG,OAAO,MAAM;AAC3B,mBAAS,uBAAQ,QAAQ,IAAI;AAAA,IAC/B,CAAC;AAED,UAAM,OAAO,GAAG,QAAQ,CAAC,SAAiB;AACxC,UAAI,CAAC,OAAO;AACV,mCAAQ,OAAO,MAAM,IAAI;AAAA,MAC3B;AACA,gBAAU,KAAK,SAAS,OAAO;AAAA,IACjC,CAAC;AAED,UAAM,OAAO,GAAG,OAAO,MAAM;AAC3B,mBAAS,uBAAQ,QAAQ,IAAI;AAAA,IAC/B,CAAC;AAED,UAAM,GAAG,SAAS,CAAC,UAAU,eAAe;AAC1C,UAAI,aAAa,KAAK,CAAC,gBAAgB;AACrC,eAAO,IAAI,MAAM,iCAAiC,UAAU,SAAS,KAAK,QAAQ;AAAA,EAAK,MAAM,EAAE,CAAC;AAAA,MAClG,OAAO;AACL,YAAI;AACJ,YAAI,CAAC,aAAa;AAChB,mBAAS;AAAA,QACX,OAAO;AACL,mBAAS;AAAA,YACP;AAAA,YACA;AAAA,YACA;AAAA,YACA;AAAA,UACF;AAAA,QACF;AACA,QAAAA,SAAQ,MAAM;AAAA,MAChB;AAAA,IACF,CAAC;AAED,UAAM,GAAG,SAAS,CAAC,QAAQ;AACzB,UAAI,CAAC,gBAAgB;AACnB,eAAO,GAAG;AAAA,MACZ,OAAO;AACL,YAAI;AACJ,YAAI,CAAC,aAAa;AAChB,mBAAS;AAAA,QACX,OAAO;AACL,mBAAS;AAAA,YACP,UAAU;AAAA,YACV,YAAY;AAAA,YACZ;AAAA,YACA;AAAA,UACF;AAAA,QACF;AACA,QAAAA,SAAQ,MAAM;AAAA,MAChB;AAAA,IACF,CAAC;AAAA,EACH,CAAC;AACH;AASO,SAAS,oBAAoB,MAAc,KAAsB;AACtE,aAAO,qBAAQ,WAAW,GAAG,GAAG,IAAI;AACtC;AASO,SAAS,WAAW,KAAsB;AAC/C,MAAI,iBAAa,yBAAY,OAAO,2BAAQ,IAAI,CAAC;AACjD,SAAO,eAAe,OAAO,eAAe,KAAK;AAC/C,YAAI,mCAAW,kBAAK,YAAY,2DAA0B,WAAW,CAAC,GAAG;AACvE,iBAAO,yBAAY,UAAU;AAAA,IAC/B;AACA,qBAAa,qBAAQ,UAAU;AAAA,EACjC;AAEA,QAAM,IAAI,MAAM,+BAA+B;AACjD;AASO,SAAS,mBAAmB,MAAc,KAAsB;AACrE,QAAM,UAAU,WAAW,GAAG;AAC9B,aAAO,yBAAY,IAAI;AACvB,aAAO,sBAAS,SAAS,IAAI;AAC/B;",
  "names": ["resolve"]
}

+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/scripts/Root.d.ts

@@ -3,52 +3,7 @@
  * Contains utility functions for executing commands from the root directory of a project,
  * resolving paths relative to the root.
  */
-/**
- * Represents the result of executing a command from the root directory.
- */
-export interface ExecFromRootResult {
-    /**
-     * The exit code of the command. A value of `null` indicates that the process did not exit normally.
-     */
-    exitCode: number | null;
-    /**
-     * The signal that caused the process to be terminated. A value of `null` indicates that no signal was received.
-     */
-    exitSignal: NodeJS.Signals | null;
-    /**
-     * The standard error output from the command.
-     */
-    stderr: string;
-    /**
-     * The standard output from the command.
-     */
-    stdout: string;
-}
-/**
- * Options for executing a command from the root directory.
- */
-export interface ExecFromRootOption {
-    /**
-     * If true, suppresses the output of the command.
-     */
-    quiet?: boolean;
-    /**
-     * If true, ignores the exit code of the command.
-     */
-    ignoreExitCode?: boolean;
-    /**
-     * The input to be passed to the command.
-     */
-    stdin?: string;
-    /**
-     * The current working directory for the command execution.
-     */
-    cwd?: string | undefined;
-    /**
-     * If false, only returns the output of the command.
-     */
-    withDetails?: boolean;
-}
+import type { ExecOption, ExecResult } from './Exec.ts';
 /**
  * Executes a command from the root directory of the project.
  *
@@ -60,7 +15,7 @@ export interface ExecFromRootOption {
  *         If an error occurs during the execution and ignoreExitCode is true,
  *         the error is resolved with the stdout and stderr.
  */
-export declare function execFromRoot(command: string | string[], options?: ExecFromRootOption & {
+export declare function execFromRoot(command: string | string[], options?: ExecOption & {
     withDetails?: false;
 }): Promise<string>;
 /**
@@ -75,9 +30,9 @@ export declare function execFromRoot(command: string | string[], options?: ExecF
  *         If an error occurs during the execution and ignoreExitCode is true,
  *         the error is resolved with the stdout and stderr.
  */
-export declare function execFromRoot(command: string | string[], options: ExecFromRootOption & {
+export declare function execFromRoot(command: string | string[], options: ExecOption & {
     withDetails: true;
-}): Promise<ExecFromRootResult>;
+}): Promise<ExecResult>;
 /**
  * Resolves a path relative to the root directory of the project.
  *

package/dist/lib/scripts/esbuild/fixSourceMapsPlugin.cjs

@@ -40,7 +40,7 @@ function fixSourceMapsPlugin(isProductionBuild, distPath, pluginName) {
         }
         const content = await (0, import_NodeModules.readFile)(distPath, "utf-8");
         const newContent = content.replaceAll(
-          /(\n\/\/# sourceMappingURL=data:application\/json;base64,)(.+)\n/g,
+          /(\n\/\/# sourceMappingURL=data:application\/json;base64,)(.+)\n(.|\n)*/g,
           (_, prefix, sourceMapBase64) => prefix + fixSourceMap(sourceMapBase64, pluginName) + "\n/* nosourcemap */"
         );
         if (content !== newContent) {
@@ -64,4 +64,4 @@ function convertPathToObsidianUrl(path, pluginName) {
 0 && (module.exports = {
   fixSourceMapsPlugin
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/scripts/index.cjs

@@ -38,6 +38,7 @@ __export(scripts_exports, {
   CliUtils: () => CliUtils,
   CodeGenerator: () => CodeGenerator,
   ESLint: () => ESLint,
+  Exec: () => Exec,
   Fs: () => Fs,
   JSON: () => JSON,
   NodeModules: () => NodeModules,
@@ -57,6 +58,7 @@ var CliUtils = __toESM(require('./CliUtils.cjs'), 1);
 var CodeGenerator = __toESM(require('./CodeGenerator.cjs'), 1);
 var esbuild = __toESM(require('./esbuild/index.cjs'), 1);
 var ESLint = __toESM(require('./ESLint/index.cjs'), 1);
+var Exec = __toESM(require('./Exec.cjs'), 1);
 var Fs = __toESM(require('./Fs.cjs'), 1);
 var JSON = __toESM(require('./JSON.cjs'), 1);
 var NodeModules = __toESM(require('./NodeModules.cjs'), 1);
@@ -70,6 +72,7 @@ var version = __toESM(require('./version.cjs'), 1);
   CliUtils,
   CodeGenerator,
   ESLint,
+  Exec,
   Fs,
   JSON,
   NodeModules,
@@ -82,4 +85,4 @@ var version = __toESM(require('./version.cjs'), 1);
   spellcheck,
   version
 });
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL3NjcmlwdHMvaW5kZXgudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qIFRISVMgSVMgQSBHRU5FUkFURUQvQlVORExFRCBGSUxFIEJZIEJVSUxEIFNDUklQVCAqL1xuXG5leHBvcnQgKiBhcyBidWlsZCBmcm9tICcuL2J1aWxkLnRzJztcbmV4cG9ydCAqIGFzIGNsaSBmcm9tICcuL2NsaS50cyc7XG5leHBvcnQgKiBhcyBDbGlVdGlscyBmcm9tICcuL0NsaVV0aWxzLnRzJztcbmV4cG9ydCAqIGFzIENvZGVHZW5lcmF0b3IgZnJvbSAnLi9Db2RlR2VuZXJhdG9yLnRzJztcbmV4cG9ydCAqIGFzIGVzYnVpbGQgZnJvbSAnLi9lc2J1aWxkL2luZGV4LnRzJztcbmV4cG9ydCAqIGFzIEVTTGludCBmcm9tICcuL0VTTGludC9pbmRleC50cyc7XG5leHBvcnQgKiBhcyBGcyBmcm9tICcuL0ZzLnRzJztcbmV4cG9ydCAqIGFzIEpTT04gZnJvbSAnLi9KU09OLnRzJztcbmV4cG9ydCAqIGFzIE5vZGVNb2R1bGVzIGZyb20gJy4vTm9kZU1vZHVsZXMudHMnO1xuZXhwb3J0ICogYXMgTnBtIGZyb20gJy4vTnBtLnRzJztcbmV4cG9ydCAqIGFzIE9ic2lkaWFuRGV2VXRpbHNSZXBvUGF0aHMgZnJvbSAnLi9PYnNpZGlhbkRldlV0aWxzUmVwb1BhdGhzLnRzJztcbmV4cG9ydCAqIGFzIFJvb3QgZnJvbSAnLi9Sb290LnRzJztcbmV4cG9ydCAqIGFzIHNwZWxsY2hlY2sgZnJvbSAnLi9zcGVsbGNoZWNrLnRzJztcbmV4cG9ydCAqIGFzIHZlcnNpb24gZnJvbSAnLi92ZXJzaW9uLnRzJztcbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBRUEsWUFBdUI7QUFDdkIsVUFBcUI7QUFDckIsZUFBMEI7QUFDMUIsb0JBQStCO0FBQy9CLGNBQXlCO0FBQ3pCLGFBQXdCO0FBQ3hCLFNBQW9CO0FBQ3BCLFdBQXNCO0FBQ3RCLGtCQUE2QjtBQUM3QixVQUFxQjtBQUNyQixnQ0FBMkM7QUFDM0MsV0FBc0I7QUFDdEIsaUJBQTRCO0FBQzVCLGNBQXlCOyIsCiAgIm5hbWVzIjogW10KfQo=
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL3NjcmlwdHMvaW5kZXgudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qIFRISVMgSVMgQSBHRU5FUkFURUQvQlVORExFRCBGSUxFIEJZIEJVSUxEIFNDUklQVCAqL1xuXG5leHBvcnQgKiBhcyBidWlsZCBmcm9tICcuL2J1aWxkLnRzJztcbmV4cG9ydCAqIGFzIGNsaSBmcm9tICcuL2NsaS50cyc7XG5leHBvcnQgKiBhcyBDbGlVdGlscyBmcm9tICcuL0NsaVV0aWxzLnRzJztcbmV4cG9ydCAqIGFzIENvZGVHZW5lcmF0b3IgZnJvbSAnLi9Db2RlR2VuZXJhdG9yLnRzJztcbmV4cG9ydCAqIGFzIGVzYnVpbGQgZnJvbSAnLi9lc2J1aWxkL2luZGV4LnRzJztcbmV4cG9ydCAqIGFzIEVTTGludCBmcm9tICcuL0VTTGludC9pbmRleC50cyc7XG5leHBvcnQgKiBhcyBFeGVjIGZyb20gJy4vRXhlYy50cyc7XG5leHBvcnQgKiBhcyBGcyBmcm9tICcuL0ZzLnRzJztcbmV4cG9ydCAqIGFzIEpTT04gZnJvbSAnLi9KU09OLnRzJztcbmV4cG9ydCAqIGFzIE5vZGVNb2R1bGVzIGZyb20gJy4vTm9kZU1vZHVsZXMudHMnO1xuZXhwb3J0ICogYXMgTnBtIGZyb20gJy4vTnBtLnRzJztcbmV4cG9ydCAqIGFzIE9ic2lkaWFuRGV2VXRpbHNSZXBvUGF0aHMgZnJvbSAnLi9PYnNpZGlhbkRldlV0aWxzUmVwb1BhdGhzLnRzJztcbmV4cG9ydCAqIGFzIFJvb3QgZnJvbSAnLi9Sb290LnRzJztcbmV4cG9ydCAqIGFzIHNwZWxsY2hlY2sgZnJvbSAnLi9zcGVsbGNoZWNrLnRzJztcbmV4cG9ydCAqIGFzIHZlcnNpb24gZnJvbSAnLi92ZXJzaW9uLnRzJztcbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFFQSxZQUF1QjtBQUN2QixVQUFxQjtBQUNyQixlQUEwQjtBQUMxQixvQkFBK0I7QUFDL0IsY0FBeUI7QUFDekIsYUFBd0I7QUFDeEIsV0FBc0I7QUFDdEIsU0FBb0I7QUFDcEIsV0FBc0I7QUFDdEIsa0JBQTZCO0FBQzdCLFVBQXFCO0FBQ3JCLGdDQUEyQztBQUMzQyxXQUFzQjtBQUN0QixpQkFBNEI7QUFDNUIsY0FBeUI7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist/lib/scripts/index.d.ts

@@ -4,6 +4,7 @@ export * as CliUtils from './CliUtils.ts';
 export * as CodeGenerator from './CodeGenerator.ts';
 export * as esbuild from './esbuild/index.ts';
 export * as ESLint from './ESLint/index.ts';
+export * as Exec from './Exec.ts';
 export * as Fs from './Fs.ts';
 export * as JSON from './JSON.ts';
 export * as NodeModules from './NodeModules.ts';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obsidian-dev-utils",
-  "version": "3.42.3",
+  "version": "3.43.0",
   "description": "This is the collection of useful functions that you can use for your Obsidian plugin development",
   "main": "./dist/lib/index.cjs",
   "types": "./dist/lib/index.d.ts",