obsidian-dev-utils 22.1.1-beta.20 → 22.1.1-beta.22

package/dist/lib/cjs/AsyncEvents.d.cts

@@ -0,0 +1,139 @@
+import type { Promisable } from 'type-fest';
+/**
+ * Async event reference.
+ */
+export interface AsyncEventRef {
+    /**
+     * The event emitter.
+     */
+    asyncEvents: AsyncEvents;
+    /**
+     * The callback to call when the event is triggered.
+     */
+    callback: (...args: unknown[]) => Promisable<unknown>;
+    /**
+     * The name of the event.
+     */
+    name: string;
+    /**
+     * The context passed as `this` to the `callback`.
+     */
+    thisArg: unknown;
+}
+/**
+ * Async event emitter implementation
+ */
+export declare class AsyncEvents {
+    private eventRefsMap;
+    /**
+     * Remove an event listener.
+     *
+     * @param name - The name of the event.
+     * @param callback - The callback to remove.
+     *
+     * @example
+     * ```ts
+     * events.off('my-event', myListener);
+     * ```
+     *
+     * @public
+     */
+    off(name: string, callback: (...args: unknown[]) => Promisable<unknown>): void;
+    /**
+     * Remove an event listener by reference.
+     *
+     * @param eventRef - The reference to the event listener.
+     *
+     * @example
+     * ```ts
+     * events.offref(myRef);
+     * ```
+     *
+     * @public
+     */
+    offref(eventRef: AsyncEventRef): void;
+    /**
+     * Add an event listener.
+     *
+     * @param name - The name of the event.
+     * @param callback - The callback to call when the event is triggered.
+     * @param thisArg - The context passed as `this` to the `callback`.
+     * @returns A reference to the event listener.
+     *
+     * @example
+     * ```ts
+     * events.on('my-event', async (arg1, arg2) => {
+     *     await sleep(100);
+     *     console.log(arg1, arg2);
+     * });
+     * ```
+     *
+     * @public
+     */
+    on(name: string, callback: (...args: unknown[]) => Promisable<unknown>, thisArg?: unknown): AsyncEventRef;
+    /**
+     * Add an event listener that will be triggered only once.
+     *
+     * @param name - The name of the event.
+     * @param callback - The callback to call when the event is triggered.
+     * @param thisArg - The context passed as `this` to the `callback`.
+     * @returns A reference to the event listener.
+     *
+     * @example
+     * ```ts
+     * events.once('my-event', async (arg1, arg2) => {
+     *     await sleep(100);
+     *     console.log(arg1, arg2);
+     * });
+     * ```
+     *
+     * @public
+     */
+    once(name: string, callback: (...args: unknown[]) => Promisable<unknown>, thisArg?: unknown): AsyncEventRef;
+    /**
+     * Trigger an event, executing all the listeners in order even if some of them throw an error.
+     *
+     * @param name - The name of the event.
+     * @param args - The data to pass to the event listeners.
+     *
+     * @example
+     * ```ts
+     * events.trigger('my-event', 'arg1', 'arg2');
+     * ```
+     *
+     * @public
+     */
+    trigger(name: string, ...args: unknown[]): void;
+    /**
+     * Trigger an event asynchronously, executing all the listeners in order even if some of them throw an error.
+     *
+     * @param name - The name of the event.
+     * @param args - The data to pass to the event listeners.
+     *
+     * @public
+     */
+    triggerAsync(name: string, ...args: unknown[]): Promise<void>;
+    /**
+     * Try to trigger an event, executing all the listeners in order even if some of them throw an error.
+     *
+     * @param eventRef - The event reference.
+     * @param args - The data to pass to the event listeners.
+     *
+     * @example
+     * ```ts
+     * events.tryTrigger(myRef, ['arg1', 'arg2']);
+     * ```
+     *
+     * @public
+     */
+    tryTrigger(eventRef: AsyncEventRef, args: unknown[]): void;
+    /**
+     * Try to trigger an event asynchronously, executing all the listeners in order even if some of them throw an error.
+     *
+     * @param eventRef - The event reference.
+     * @param args - The data to pass to the event listeners.
+     *
+     * @public
+     */
+    tryTriggerAsync(eventRef: AsyncEventRef, args: unknown[]): Promise<void>;
+}

package/dist/lib/cjs/Blob.cjs

@@ -106,4 +106,4 @@ function isImageFile(file) {
   dataUrlToArrayBuffer,
   isImageFile
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/Blob.d.cts

@@ -3,29 +3,29 @@
  * Contains utility functions for Blob objects.
  */
 /**
- * Converts a Blob object to an ArrayBuffer.
+ * Converts a {@link Blob} object to an {@link ArrayBuffer}.
  *
  * @param blob - The Blob object to convert.
- * @returns A promise that resolves to an ArrayBuffer.
+ * @returns A {@link Promise} that resolves to an {@link ArrayBuffer}.
  */
 export declare function blobToArrayBuffer(blob: Blob): Promise<ArrayBuffer>;
 /**
- * Converts a Blob object to a data URL.
+ * Converts a {@link Blob} object to a data URL.
  *
  * @param blob - The Blob object to convert.
- * @returns A promise that resolves to a data URL.
+ * @returns A {@link Promise} that resolves to a data URL.
  */
 export declare function blobToDataUrl(blob: Blob): Promise<string>;
 /**
- * Converts a Blob object to a JPEG ArrayBuffer with the specified quality.
+ * Converts a {@link Blob} object to a JPEG ArrayBuffer with the specified quality.
  *
  * @param blob - The Blob object to convert.
  * @param jpegQuality - The quality of the JPEG image (0 to 1).
- * @returns A promise that resolves to an ArrayBuffer.
+ * @returns A {@link Promise} that resolves to an {@link ArrayBuffer}.
  */
 export declare function blobToJpegArrayBuffer(blob: Blob, jpegQuality: number): Promise<ArrayBuffer>;
 /**
- * Converts a base64 encoded string to an ArrayBuffer.
+ * Converts a base64 encoded string to an {@link ArrayBuffer}.
  *
  * @param dataUrl - The data URL to convert.
  * @returns The decoded ArrayBuffer.

package/dist/lib/cjs/Error.cjs

@@ -34,13 +34,13 @@ __export(Error_exports, {
   throwExpression: () => throwExpression
 });
 module.exports = __toCommonJS(Error_exports);
-var import_eventemitter3 = require('eventemitter3');
+var import_AsyncEvents = require('./AsyncEvents.cjs');
 const ASYNC_ERROR_EVENT = "asyncError";
 const ASYNC_ERROR_WRAPPER_MESSAGE = "An unhandled error occurred executing async operation";
-const asyncErrorEventEmitter = new import_eventemitter3.EventEmitter();
+const asyncErrorEventEmitter = new import_AsyncEvents.AsyncEvents();
 asyncErrorEventEmitter.on(ASYNC_ERROR_EVENT, handleAsyncError);
 function emitAsyncErrorEvent(asyncError) {
-  asyncErrorEventEmitter.emit(ASYNC_ERROR_EVENT, asyncError);
+  asyncErrorEventEmitter.trigger(ASYNC_ERROR_EVENT, asyncError);
 }
 function errorToString(error) {
   return parseErrorEntries(error).map((entry) => "  ".repeat(entry.level) + entry.message).join("\n");
@@ -63,8 +63,10 @@ function printError(error, console) {
   }
 }
 function registerAsyncErrorEventHandler(handler) {
-  asyncErrorEventEmitter.on(ASYNC_ERROR_EVENT, handler);
-  return () => asyncErrorEventEmitter.off(ASYNC_ERROR_EVENT, handler);
+  const eventRef = asyncErrorEventEmitter.on(ASYNC_ERROR_EVENT, handler);
+  return () => {
+    asyncErrorEventEmitter.offref(eventRef);
+  };
 }
 function throwExpression(error) {
   throw error;
@@ -111,4 +113,4 @@ ${restStack}` });
   registerAsyncErrorEventHandler,
   throwExpression
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/Error.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation Error\n * Contains utility functions for error handling.\n */\n\nimport { EventEmitter } from 'eventemitter3';\n\nconst ASYNC_ERROR_EVENT = 'asyncError';\n\n/**\n * The message of the error wrapper that is used to wrap an actual error that occurred during an async operation.\n */\nexport const ASYNC_ERROR_WRAPPER_MESSAGE = 'An unhandled error occurred executing async operation';\n\nconst asyncErrorEventEmitter = new EventEmitter();\nasyncErrorEventEmitter.on(ASYNC_ERROR_EVENT, handleAsyncError);\n\ninterface ErrorEntry {\n  level: number;\n  message: string;\n  shouldClearAnsiSequence?: boolean;\n}\n\n/**\n * Emits an asynchronous error event.\n *\n * @param asyncError - The error to emit as an asynchronous error event.\n */\nexport function emitAsyncErrorEvent(asyncError: unknown): void {\n  asyncErrorEventEmitter.emit(ASYNC_ERROR_EVENT, asyncError);\n}\n\n/**\n * Converts an error to a string representation, including nested causes with indentation.\n *\n * @param error - The error to convert to a string.\n * @returns The string representation of the error.\n */\nexport function errorToString(error: unknown): string {\n  return parseErrorEntries(error).map((entry) => '  '.repeat(entry.level) + entry.message).join('\\n');\n}\n\n/**\n * Gets the current stack trace as a string, excluding the current function call.\n *\n * @param framesToSkip - The number of frames to skip in the stack trace.\n * @returns A string representation of the current stack trace, excluding the current function call.\n */\nexport function getStackTrace(framesToSkip = 0): string {\n  // Skipping Error prefix and `getStackTrace` function call\n  const ADDITIONAL_FRAMES_TO_SKIP = 2;\n  const stack = new Error().stack ?? '';\n  const lines = stack.split('\\n');\n  return lines.slice(framesToSkip + ADDITIONAL_FRAMES_TO_SKIP).join('\\n');\n}\n\n/**\n * Prints an error to the console, including nested causes and optional ANSI sequence clearing.\n *\n * @param error - The error to print.\n * @param console - The console to print to (default: `globalThis.console`).\n */\nexport function printError(error: unknown, console?: Console): void {\n  console ??= globalThis.console;\n  const entries = parseErrorEntries(error);\n\n  for (const entry of entries) {\n    if (entry.shouldClearAnsiSequence) {\n      console.error(`\\x1b[0m${entry.message}\\x1b[0m`);\n    } else {\n      console.error(entry.message);\n    }\n  }\n}\n\n/**\n * Registers an event handler for asynchronous errors.\n *\n * @param handler - The handler function to be called when an asynchronous error event occurs.\n * @returns A function to unregister the handler.\n */\nexport function registerAsyncErrorEventHandler(handler: (asyncError: unknown) => void): () => void {\n  asyncErrorEventEmitter.on(ASYNC_ERROR_EVENT, handler);\n  return () => asyncErrorEventEmitter.off(ASYNC_ERROR_EVENT, handler);\n}\n\n/**\n * Throws an error with the specified message.\n *\n * @param error - The error to throw.\n * @returns A never-returning function.\n */\nexport function throwExpression(error: unknown): never {\n  throw error;\n}\n\n/**\n * Handles asynchronous errors by printing them.\n *\n * @param asyncError - The asynchronous error to handle.\n */\nfunction handleAsyncError(asyncError: unknown): void {\n  printError(asyncError);\n}\n\n/**\n * Parses an error into an array of ErrorEntry objects, including nested causes.\n *\n * @param error - The error to parse.\n * @param level - The current indentation level for nested causes.\n * @param entries - The array of ErrorEntry objects to populate.\n * @returns An array of ErrorEntry objects representing the error and its causes.\n */\nfunction parseErrorEntries(error: unknown, level = 0, entries: ErrorEntry[] = []): ErrorEntry[] {\n  if (error === undefined) {\n    return entries;\n  }\n\n  if (!(error instanceof Error)) {\n    let str: string;\n\n    if (error === null) {\n      str = '(null)';\n    } else if (typeof error === 'string') {\n      str = error;\n    } else {\n      str = JSON.stringify(error) ?? 'undefined';\n    }\n\n    entries.push({ level, message: str });\n    return entries;\n  }\n\n  const title = `${error.name}: ${error.message}`;\n  entries.push({ level, message: title, shouldClearAnsiSequence: true });\n\n  if (error.stack) {\n    const restStack = error.stack.startsWith(title) ? error.stack.slice(title.length + 1) : error.stack;\n    entries.push({ level, message: `Error stack:\\n${restStack}` });\n  }\n\n  if (error.cause !== undefined) {\n    entries.push({ level, message: 'Caused by:' });\n    parseErrorEntries(error.cause, level + 1, entries);\n  }\n\n  return entries;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,2BAA6B;AAE7B,MAAM,oBAAoB;AAKnB,MAAM,8BAA8B;AAE3C,MAAM,yBAAyB,IAAI,kCAAa;AAChD,uBAAuB,GAAG,mBAAmB,gBAAgB;AAatD,SAAS,oBAAoB,YAA2B;AAC7D,yBAAuB,KAAK,mBAAmB,UAAU;AAC3D;AAQO,SAAS,cAAc,OAAwB;AACpD,SAAO,kBAAkB,KAAK,EAAE,IAAI,CAAC,UAAU,KAAK,OAAO,MAAM,KAAK,IAAI,MAAM,OAAO,EAAE,KAAK,IAAI;AACpG;AAQO,SAAS,cAAc,eAAe,GAAW;AAEtD,QAAM,4BAA4B;AAClC,QAAM,QAAQ,IAAI,MAAM,EAAE,SAAS;AACnC,QAAM,QAAQ,MAAM,MAAM,IAAI;AAC9B,SAAO,MAAM,MAAM,eAAe,yBAAyB,EAAE,KAAK,IAAI;AACxE;AAQO,SAAS,WAAW,OAAgB,SAAyB;AAClE,cAAY,WAAW;AACvB,QAAM,UAAU,kBAAkB,KAAK;AAEvC,aAAW,SAAS,SAAS;AAC3B,QAAI,MAAM,yBAAyB;AACjC,cAAQ,MAAM,UAAU,MAAM,OAAO,SAAS;AAAA,IAChD,OAAO;AACL,cAAQ,MAAM,MAAM,OAAO;AAAA,IAC7B;AAAA,EACF;AACF;AAQO,SAAS,+BAA+B,SAAoD;AACjG,yBAAuB,GAAG,mBAAmB,OAAO;AACpD,SAAO,MAAM,uBAAuB,IAAI,mBAAmB,OAAO;AACpE;AAQO,SAAS,gBAAgB,OAAuB;AACrD,QAAM;AACR;AAOA,SAAS,iBAAiB,YAA2B;AACnD,aAAW,UAAU;AACvB;AAUA,SAAS,kBAAkB,OAAgB,QAAQ,GAAG,UAAwB,CAAC,GAAiB;AAC9F,MAAI,UAAU,QAAW;AACvB,WAAO;AAAA,EACT;AAEA,MAAI,EAAE,iBAAiB,QAAQ;AAC7B,QAAI;AAEJ,QAAI,UAAU,MAAM;AAClB,YAAM;AAAA,IACR,WAAW,OAAO,UAAU,UAAU;AACpC,YAAM;AAAA,IACR,OAAO;AACL,YAAM,KAAK,UAAU,KAAK,KAAK;AAAA,IACjC;AAEA,YAAQ,KAAK,EAAE,OAAO,SAAS,IAAI,CAAC;AACpC,WAAO;AAAA,EACT;AAEA,QAAM,QAAQ,GAAG,MAAM,IAAI,KAAK,MAAM,OAAO;AAC7C,UAAQ,KAAK,EAAE,OAAO,SAAS,OAAO,yBAAyB,KAAK,CAAC;AAErE,MAAI,MAAM,OAAO;AACf,UAAM,YAAY,MAAM,MAAM,WAAW,KAAK,IAAI,MAAM,MAAM,MAAM,MAAM,SAAS,CAAC,IAAI,MAAM;AAC9F,YAAQ,KAAK,EAAE,OAAO,SAAS;AAAA,EAAiB,SAAS,GAAG,CAAC;AAAA,EAC/D;AAEA,MAAI,MAAM,UAAU,QAAW;AAC7B,YAAQ,KAAK,EAAE,OAAO,SAAS,aAAa,CAAC;AAC7C,sBAAkB,MAAM,OAAO,QAAQ,GAAG,OAAO;AAAA,EACnD;AAEA,SAAO;AACT;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/Error.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation Error\n * Contains utility functions for error handling.\n */\n\nimport { AsyncEvents } from './AsyncEvents.ts';\n\nconst ASYNC_ERROR_EVENT = 'asyncError';\n\n/**\n * The message of the error wrapper that is used to wrap an actual error that occurred during an async operation.\n */\nexport const ASYNC_ERROR_WRAPPER_MESSAGE = 'An unhandled error occurred executing async operation';\n\nconst asyncErrorEventEmitter = new AsyncEvents();\nasyncErrorEventEmitter.on(ASYNC_ERROR_EVENT, handleAsyncError);\n\ninterface ErrorEntry {\n  level: number;\n  message: string;\n  shouldClearAnsiSequence?: boolean;\n}\n\n/**\n * Emits an asynchronous error event.\n *\n * @param asyncError - The error to emit as an asynchronous error event.\n */\nexport function emitAsyncErrorEvent(asyncError: unknown): void {\n  asyncErrorEventEmitter.trigger(ASYNC_ERROR_EVENT, asyncError);\n}\n\n/**\n * Converts an error to a string representation, including nested causes with indentation.\n *\n * @param error - The error to convert to a string.\n * @returns The string representation of the error.\n */\nexport function errorToString(error: unknown): string {\n  return parseErrorEntries(error).map((entry) => '  '.repeat(entry.level) + entry.message).join('\\n');\n}\n\n/**\n * Gets the current stack trace as a string, excluding the current function call.\n *\n * @param framesToSkip - The number of frames to skip in the stack trace.\n * @returns A string representation of the current stack trace, excluding the current function call.\n */\nexport function getStackTrace(framesToSkip = 0): string {\n  // Skipping Error prefix and `getStackTrace` function call\n  const ADDITIONAL_FRAMES_TO_SKIP = 2;\n  const stack = new Error().stack ?? '';\n  const lines = stack.split('\\n');\n  return lines.slice(framesToSkip + ADDITIONAL_FRAMES_TO_SKIP).join('\\n');\n}\n\n/**\n * Prints an error to the console, including nested causes and optional ANSI sequence clearing.\n *\n * @param error - The error to print.\n * @param console - The console to print to (default: `globalThis.console`).\n */\nexport function printError(error: unknown, console?: Console): void {\n  console ??= globalThis.console;\n  const entries = parseErrorEntries(error);\n\n  for (const entry of entries) {\n    if (entry.shouldClearAnsiSequence) {\n      console.error(`\\x1b[0m${entry.message}\\x1b[0m`);\n    } else {\n      console.error(entry.message);\n    }\n  }\n}\n\n/**\n * Registers an event handler for asynchronous errors.\n *\n * @param handler - The handler function to be called when an asynchronous error event occurs.\n * @returns A function to unregister the handler.\n */\nexport function registerAsyncErrorEventHandler(handler: (asyncError: unknown) => void): () => void {\n  const eventRef = asyncErrorEventEmitter.on(ASYNC_ERROR_EVENT, handler);\n  return () => {\n    asyncErrorEventEmitter.offref(eventRef);\n  };\n}\n\n/**\n * Throws an error with the specified message.\n *\n * @param error - The error to throw.\n * @returns A never-returning function.\n */\nexport function throwExpression(error: unknown): never {\n  throw error;\n}\n\n/**\n * Handles asynchronous errors by printing them.\n *\n * @param asyncError - The asynchronous error to handle.\n */\nfunction handleAsyncError(asyncError: unknown): void {\n  printError(asyncError);\n}\n\n/**\n * Parses an error into an array of ErrorEntry objects, including nested causes.\n *\n * @param error - The error to parse.\n * @param level - The current indentation level for nested causes.\n * @param entries - The array of ErrorEntry objects to populate.\n * @returns An array of ErrorEntry objects representing the error and its causes.\n */\nfunction parseErrorEntries(error: unknown, level = 0, entries: ErrorEntry[] = []): ErrorEntry[] {\n  if (error === undefined) {\n    return entries;\n  }\n\n  if (!(error instanceof Error)) {\n    let str: string;\n\n    if (error === null) {\n      str = '(null)';\n    } else if (typeof error === 'string') {\n      str = error;\n    } else {\n      str = JSON.stringify(error) ?? 'undefined';\n    }\n\n    entries.push({ level, message: str });\n    return entries;\n  }\n\n  const title = `${error.name}: ${error.message}`;\n  entries.push({ level, message: title, shouldClearAnsiSequence: true });\n\n  if (error.stack) {\n    const restStack = error.stack.startsWith(title) ? error.stack.slice(title.length + 1) : error.stack;\n    entries.push({ level, message: `Error stack:\\n${restStack}` });\n  }\n\n  if (error.cause !== undefined) {\n    entries.push({ level, message: 'Caused by:' });\n    parseErrorEntries(error.cause, level + 1, entries);\n  }\n\n  return entries;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,yBAA4B;AAE5B,MAAM,oBAAoB;AAKnB,MAAM,8BAA8B;AAE3C,MAAM,yBAAyB,IAAI,+BAAY;AAC/C,uBAAuB,GAAG,mBAAmB,gBAAgB;AAatD,SAAS,oBAAoB,YAA2B;AAC7D,yBAAuB,QAAQ,mBAAmB,UAAU;AAC9D;AAQO,SAAS,cAAc,OAAwB;AACpD,SAAO,kBAAkB,KAAK,EAAE,IAAI,CAAC,UAAU,KAAK,OAAO,MAAM,KAAK,IAAI,MAAM,OAAO,EAAE,KAAK,IAAI;AACpG;AAQO,SAAS,cAAc,eAAe,GAAW;AAEtD,QAAM,4BAA4B;AAClC,QAAM,QAAQ,IAAI,MAAM,EAAE,SAAS;AACnC,QAAM,QAAQ,MAAM,MAAM,IAAI;AAC9B,SAAO,MAAM,MAAM,eAAe,yBAAyB,EAAE,KAAK,IAAI;AACxE;AAQO,SAAS,WAAW,OAAgB,SAAyB;AAClE,cAAY,WAAW;AACvB,QAAM,UAAU,kBAAkB,KAAK;AAEvC,aAAW,SAAS,SAAS;AAC3B,QAAI,MAAM,yBAAyB;AACjC,cAAQ,MAAM,UAAU,MAAM,OAAO,SAAS;AAAA,IAChD,OAAO;AACL,cAAQ,MAAM,MAAM,OAAO;AAAA,IAC7B;AAAA,EACF;AACF;AAQO,SAAS,+BAA+B,SAAoD;AACjG,QAAM,WAAW,uBAAuB,GAAG,mBAAmB,OAAO;AACrE,SAAO,MAAM;AACX,2BAAuB,OAAO,QAAQ;AAAA,EACxC;AACF;AAQO,SAAS,gBAAgB,OAAuB;AACrD,QAAM;AACR;AAOA,SAAS,iBAAiB,YAA2B;AACnD,aAAW,UAAU;AACvB;AAUA,SAAS,kBAAkB,OAAgB,QAAQ,GAAG,UAAwB,CAAC,GAAiB;AAC9F,MAAI,UAAU,QAAW;AACvB,WAAO;AAAA,EACT;AAEA,MAAI,EAAE,iBAAiB,QAAQ;AAC7B,QAAI;AAEJ,QAAI,UAAU,MAAM;AAClB,YAAM;AAAA,IACR,WAAW,OAAO,UAAU,UAAU;AACpC,YAAM;AAAA,IACR,OAAO;AACL,YAAM,KAAK,UAAU,KAAK,KAAK;AAAA,IACjC;AAEA,YAAQ,KAAK,EAAE,OAAO,SAAS,IAAI,CAAC;AACpC,WAAO;AAAA,EACT;AAEA,QAAM,QAAQ,GAAG,MAAM,IAAI,KAAK,MAAM,OAAO;AAC7C,UAAQ,KAAK,EAAE,OAAO,SAAS,OAAO,yBAAyB,KAAK,CAAC;AAErE,MAAI,MAAM,OAAO;AACf,UAAM,YAAY,MAAM,MAAM,WAAW,KAAK,IAAI,MAAM,MAAM,MAAM,MAAM,SAAS,CAAC,IAAI,MAAM;AAC9F,YAAQ,KAAK,EAAE,OAAO,SAAS;AAAA,EAAiB,SAAS,GAAG,CAAC;AAAA,EAC/D;AAEA,MAAI,MAAM,UAAU,QAAW;AAC7B,YAAQ,KAAK,EAAE,OAAO,SAAS,aAAa,CAAC;AAC7C,sBAAkB,MAAM,OAAO,QAAQ,GAAG,OAAO;AAAA,EACnD;AAEA,SAAO;AACT;",
  "names": []
}


package/dist/lib/cjs/HTMLElement.cjs

@@ -88,4 +88,4 @@ function getLoadableElements(el) {
   ensureLoaded,
   isLoaded
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/HTMLElement.d.cts

@@ -37,7 +37,7 @@ export declare function appendCodeBlock(el: DocumentFragment | HTMLElement, code
  * Ensures that the given element is loaded.
  *
  * @param el - The element to ensure is loaded.
- * @returns A promise that resolves when the element is loaded.
+ * @returns A {@link Promise} that resolves when the element is loaded.
  */
 export declare function ensureLoaded(el: Element): Promise<void>;
 /**

package/dist/lib/cjs/Library.cjs

@@ -30,7 +30,7 @@ __export(Library_exports, {
   LIBRARY_VERSION: () => LIBRARY_VERSION
 });
 module.exports = __toCommonJS(Library_exports);
-const LIBRARY_VERSION = "22.1.1-beta.20";
+const LIBRARY_VERSION = "22.1.1-beta.22";
 const LIBRARY_NAME = "obsidian-dev-utils";
 const LIBRARY_STYLES = ".obsidian-dev-utils input[type=url] {\n  height: var(--input-height);\n}\n.obsidian-dev-utils input[type=month],\n.obsidian-dev-utils input[type=time],\n.obsidian-dev-utils input[type=url],\n.obsidian-dev-utils input[type=week] {\n  -webkit-app-region: no-drag;\n  background: var(--background-modifier-form-field);\n  border: var(--input-border-width) solid var(--background-modifier-border);\n  color: var(--text-normal);\n  font-family: inherit;\n  padding: var(--size-4-1) var(--size-4-2);\n  font-size: var(--font-ui-small);\n  border-radius: var(--input-radius);\n  outline: none;\n}\n@media (hover: hover) {\n  .obsidian-dev-utils input[type=month]:hover,\n  .obsidian-dev-utils input[type=time]:hover,\n  .obsidian-dev-utils input[type=url]:hover,\n  .obsidian-dev-utils input[type=week]:hover {\n    border-color: var(--background-modifier-border-hover);\n    transition: box-shadow 0.15s ease-in-out, border 0.15s ease-in-out;\n  }\n}\n.obsidian-dev-utils input[type=month]:active, .obsidian-dev-utils input[type=month]:focus,\n.obsidian-dev-utils input[type=time]:active,\n.obsidian-dev-utils input[type=time]:focus,\n.obsidian-dev-utils input[type=url]:active,\n.obsidian-dev-utils input[type=url]:focus,\n.obsidian-dev-utils input[type=week]:active,\n.obsidian-dev-utils input[type=week]:focus {\n  border-color: var(--background-modifier-border-focus);\n  transition: box-shadow 0.15s ease-in-out, border 0.15s ease-in-out;\n}\n.obsidian-dev-utils input[type=month]:active, .obsidian-dev-utils input[type=month]:focus, .obsidian-dev-utils input[type=month]:focus-visible,\n.obsidian-dev-utils input[type=time]:active,\n.obsidian-dev-utils input[type=time]:focus,\n.obsidian-dev-utils input[type=time]:focus-visible,\n.obsidian-dev-utils input[type=url]:active,\n.obsidian-dev-utils input[type=url]:focus,\n.obsidian-dev-utils input[type=url]:focus-visible,\n.obsidian-dev-utils input[type=week]:active,\n.obsidian-dev-utils input[type=week]:focus,\n.obsidian-dev-utils input[type=week]:focus-visible {\n  box-shadow: 0 0 0 2px var(--background-modifier-border-focus);\n}\n.obsidian-dev-utils input[type=month]::placeholder,\n.obsidian-dev-utils input[type=time]::placeholder,\n.obsidian-dev-utils input[type=url]::placeholder,\n.obsidian-dev-utils input[type=week]::placeholder {\n  color: var(--text-faint);\n}\n.mod-rtl input[type=month],\n.mod-rtl input[type=time],\n.mod-rtl input[type=week],\n.is-rtl input[type=month],\n.is-rtl input[type=time],\n.is-rtl input[type=week],\n.rtl input[type=month],\n.rtl input[type=time],\n.rtl input[type=week] {\n  direction: rtl;\n}\n.mod-rtl input[type=month]::-webkit-calendar-picker-indicator,\n.mod-rtl input[type=time]::-webkit-calendar-picker-indicator,\n.mod-rtl input[type=week]::-webkit-calendar-picker-indicator,\n.is-rtl input[type=month]::-webkit-calendar-picker-indicator,\n.is-rtl input[type=time]::-webkit-calendar-picker-indicator,\n.is-rtl input[type=week]::-webkit-calendar-picker-indicator,\n.rtl input[type=month]::-webkit-calendar-picker-indicator,\n.rtl input[type=time]::-webkit-calendar-picker-indicator,\n.rtl input[type=week]::-webkit-calendar-picker-indicator {\n  right: var(--size-4-1);\n  left: auto;\n}\n\n.obsidian-dev-utils input[type=month],\n.obsidian-dev-utils input[type=time],\n.obsidian-dev-utils input[type=week] {\n  font-variant-numeric: tabular-nums;\n  position: relative;\n}\n.obsidian-dev-utils input[type=month]::-webkit-datetime-edit-text,\n.obsidian-dev-utils input[type=time]::-webkit-datetime-edit-text,\n.obsidian-dev-utils input[type=week]::-webkit-datetime-edit-text {\n  color: var(--text-faint);\n  padding-inline-end: 0;\n}\n.obsidian-dev-utils input[type=month]::-webkit-calendar-picker-indicator,\n.obsidian-dev-utils input[type=time]::-webkit-calendar-picker-indicator,\n.obsidian-dev-utils input[type=week]::-webkit-calendar-picker-indicator {\n  position: absolute;\n  left: var(--size-4-1);\n  right: auto;\n  opacity: 0.5;\n}\n.obsidian-dev-utils input[type=month]::-webkit-datetime-edit-month-field:active, .obsidian-dev-utils input[type=month]::-webkit-datetime-edit-month-field:focus, .obsidian-dev-utils input[type=month]::-webkit-datetime-edit-day-field:active, .obsidian-dev-utils input[type=month]::-webkit-datetime-edit-day-field:focus, .obsidian-dev-utils input[type=month]::-webkit-datetime-edit-year-field:active, .obsidian-dev-utils input[type=month]::-webkit-datetime-edit-year-field:focus,\n.obsidian-dev-utils input[type=time]::-webkit-datetime-edit-month-field:active,\n.obsidian-dev-utils input[type=time]::-webkit-datetime-edit-month-field:focus,\n.obsidian-dev-utils input[type=time]::-webkit-datetime-edit-day-field:active,\n.obsidian-dev-utils input[type=time]::-webkit-datetime-edit-day-field:focus,\n.obsidian-dev-utils input[type=time]::-webkit-datetime-edit-year-field:active,\n.obsidian-dev-utils input[type=time]::-webkit-datetime-edit-year-field:focus,\n.obsidian-dev-utils input[type=week]::-webkit-datetime-edit-month-field:active,\n.obsidian-dev-utils input[type=week]::-webkit-datetime-edit-month-field:focus,\n.obsidian-dev-utils input[type=week]::-webkit-datetime-edit-day-field:active,\n.obsidian-dev-utils input[type=week]::-webkit-datetime-edit-day-field:focus,\n.obsidian-dev-utils input[type=week]::-webkit-datetime-edit-year-field:active,\n.obsidian-dev-utils input[type=week]::-webkit-datetime-edit-year-field:focus {\n  background-color: var(--text-selection);\n  color: var(--text-normal);\n  cursor: text;\n}\n.mod-rtl .obsidian-dev-utils input[type=month], .is-rtl .obsidian-dev-utils input[type=month], .rtl .obsidian-dev-utils input[type=month],\n.mod-rtl .obsidian-dev-utils input[type=time],\n.is-rtl .obsidian-dev-utils input[type=time],\n.rtl .obsidian-dev-utils input[type=time],\n.mod-rtl .obsidian-dev-utils input[type=week],\n.is-rtl .obsidian-dev-utils input[type=week],\n.rtl .obsidian-dev-utils input[type=week] {\n  direction: rtl;\n}\n.mod-rtl .obsidian-dev-utils input[type=month]::-webkit-calendar-picker-indicator, .is-rtl .obsidian-dev-utils input[type=month]::-webkit-calendar-picker-indicator, .rtl .obsidian-dev-utils input[type=month]::-webkit-calendar-picker-indicator,\n.mod-rtl .obsidian-dev-utils input[type=time]::-webkit-calendar-picker-indicator,\n.is-rtl .obsidian-dev-utils input[type=time]::-webkit-calendar-picker-indicator,\n.rtl .obsidian-dev-utils input[type=time]::-webkit-calendar-picker-indicator,\n.mod-rtl .obsidian-dev-utils input[type=week]::-webkit-calendar-picker-indicator,\n.is-rtl .obsidian-dev-utils input[type=week]::-webkit-calendar-picker-indicator,\n.rtl .obsidian-dev-utils input[type=week]::-webkit-calendar-picker-indicator {\n  left: auto;\n  right: var(--size-4-1);\n}\n\nbody:not(.is-ios):not(.is-android) .obsidian-dev-utils input[type=month],\nbody:not(.is-ios):not(.is-android) .obsidian-dev-utils input[type=time],\nbody:not(.is-ios):not(.is-android) .obsidian-dev-utils input[type=week] {\n  padding-inline-start: var(--size-4-6);\n}\n\n.obsidian-dev-utils input[type=time]::-webkit-calendar-picker-indicator {\n  margin-inline-start: 0;\n}\n\n.obsidian-dev-utils.modal-container .ok-button {\n  margin-right: 10px;\n  margin-top: 20px;\n}\n\n.obsidian-dev-utils .multiple-dropdown-component select,\n.obsidian-dev-utils .multiple-dropdown-component select:focus,\n.obsidian-dev-utils .multiple-dropdown-component .dropdown {\n  height: auto;\n}\n.obsidian-dev-utils .multiple-dropdown-component select option:checked,\n.obsidian-dev-utils .multiple-dropdown-component select:focus option:checked,\n.obsidian-dev-utils .multiple-dropdown-component .dropdown option:checked {\n  background-color: #1967d2;\n  color: #fff;\n}\n\n.obsidian-dev-utils.prompt-modal .text-box {\n  width: 100%;\n}\n\n.obsidian-dev-utils :invalid {\n  box-shadow: 0 0 0 2px var(--text-error);\n}\n\n/*# sourceMappingURL=data:application/json;charset=utf-8,%7B%22version%22:3,%22sourceRoot%22:%22%22,%22sources%22:%5B%22../src/styles/input.scss%22,%22../src/styles/input-time.scss%22,%22../src/styles/modal-container.scss%22,%22../src/styles/multiple-dropdown-component.scss%22,%22../src/styles/prompt-modal.scss%22,%22../src/styles/validation.scss%22%5D,%22names%22:%5B%5D,%22mappings%22:%22AACE;EACE;;AAGF;AAAA;AAAA;AAAA;EAIE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;AAGE;EACE;AAAA;AAAA;AAAA;IACE;IACA,YACE;;;AAMR;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;EAEE;EACA,YACE;;AAIJ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;EAGE;;AAGF;AAAA;AAAA;AAAA;EACE;;AASE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;EAGE;;AAEA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;EACE;EACA;;;AC5DV;AAAA;AAAA;EAGE;EACA;;AAEA;AAAA;AAAA;EACE;EACA;;AAGF;AAAA;AAAA;EACE;EACA;EACA;EACA;;AAMA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;EAEE;EACA;EACA;;AAIK;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;EAGP;;AAEA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;EACE;EACA;;;AAKF;AAAA;AAAA;EACE;;;AAMJ;EACE;;;AChDF;EACE;EACA;;;ACFF;AAAA;AAAA;EAGE;;AAEA;AAAA;AAAA;EACE;EACA;;;ACPJ;EACE;;;ACFJ;EACE%22,%22file%22:%22styles.css%22,%22sourcesContent%22:%5B%22.obsidian-dev-utils%20%7B%5Cn%20%20input%5Btype='url'%5D%20%7B%5Cn%20%20%20%20height:%20var(--input-height)%5Cn%20%20%7D%5Cn%5Cn%20%20input%5Btype='month'%5D,%5Cn%20%20input%5Btype='time'%5D,%5Cn%20%20input%5Btype='url'%5D,%5Cn%20%20input%5Btype='week'%5D%20%7B%5Cn%20%20%20%20-webkit-app-region:%20no-drag;%5Cn%20%20%20%20background:%20var(--background-modifier-form-field);%5Cn%20%20%20%20border:%20var(--input-border-width)%20solid%20var(--background-modifier-border);%5Cn%20%20%20%20color:%20var(--text-normal);%5Cn%20%20%20%20font-family:%20inherit;%5Cn%20%20%20%20padding:%20var(--size-4-1)%20var(--size-4-2);%5Cn%20%20%20%20font-size:%20var(--font-ui-small);%5Cn%20%20%20%20border-radius:%20var(--input-radius);%5Cn%20%20%20%20outline:%20none;%5Cn%5Cn%20%20%20%20@at-root%20%7B%5Cn%20%20%20%20%20%20@media%20(hover:%20hover)%20%7B%5Cn%20%20%20%20%20%20%20%20&:hover%20%7B%5Cn%20%20%20%20%20%20%20%20%20%20border-color:%20var(--background-modifier-border-hover);%5Cn%20%20%20%20%20%20%20%20%20%20transition:%5Cn%20%20%20%20%20%20%20%20%20%20%20%20box-shadow%200.15s%20ease-in-out,%5Cn%20%20%20%20%20%20%20%20%20%20%20%20border%200.15s%20ease-in-out;%5Cn%20%20%20%20%20%20%20%20%7D%5Cn%20%20%20%20%20%20%7D%5Cn%20%20%20%20%7D%5Cn%5Cn%20%20%20%20&:active,%5Cn%20%20%20%20&:focus%20%7B%5Cn%20%20%20%20%20%20border-color:%20var(--background-modifier-border-focus);%5Cn%20%20%20%20%20%20transition:%5Cn%20%20%20%20%20%20%20%20box-shadow%200.15s%20ease-in-out,%5Cn%20%20%20%20%20%20%20%20border%200.15s%20ease-in-out;%5Cn%20%20%20%20%7D%5Cn%5Cn%20%20%20%20&:active,%5Cn%20%20%20%20&:focus,%5Cn%20%20%20%20&:focus-visible%20%7B%5Cn%20%20%20%20%20%20box-shadow:%200%200%200%202px%20var(--background-modifier-border-focus);%5Cn%20%20%20%20%7D%5Cn%5Cn%20%20%20%20&::placeholder%20%7B%5Cn%20%20%20%20%20%20color:%20var(--text-faint);%5Cn%20%20%20%20%7D%5Cn%20%20%7D%5Cn%5Cn%20%20@at-root%20%7B%5Cn%20%20%20%20.mod-rtl,%5Cn%20%20%20%20.is-rtl,%5Cn%20%20%20%20.rtl%20%7B%5Cn%20%20%20%20%20%20&%20%7B%5Cn%20%20%20%20%20%20%20%20input%5Btype='month'%5D,%5Cn%20%20%20%20%20%20%20%20input%5Btype='time'%5D,%5Cn%20%20%20%20%20%20%20%20input%5Btype='week'%5D%20%7B%5Cn%20%20%20%20%20%20%20%20%20%20direction:%20rtl;%5Cn%5Cn%20%20%20%20%20%20%20%20%20%20&::-webkit-calendar-picker-indicator%20%7B%5Cn%20%20%20%20%20%20%20%20%20%20%20%20right:%20var(--size-4-1);%5Cn%20%20%20%20%20%20%20%20%20%20%20%20left:%20auto;%5Cn%20%20%20%20%20%20%20%20%20%20%7D%5Cn%20%20%20%20%20%20%20%20%7D%5Cn%20%20%20%20%20%20%7D%5Cn%20%20%20%20%7D%5Cn%20%20%7D%5Cn%7D%5Cn%22,%22.obsidian-dev-utils%20%7B%5Cn%20%20input%5Btype='month'%5D,%5Cn%20%20input%5Btype='time'%5D,%5Cn%20%20input%5Btype='week'%5D%20%7B%5Cn%20%20%20%20font-variant-numeric:%20tabular-nums;%5Cn%20%20%20%20position:%20relative;%5Cn%5Cn%20%20%20%20&::-webkit-datetime-edit-text%20%7B%5Cn%20%20%20%20%20%20color:%20var(--text-faint);%5Cn%20%20%20%20%20%20padding-inline-end:%200;%5Cn%20%20%20%20%7D%5Cn%5Cn%20%20%20%20&::-webkit-calendar-picker-indicator%20%7B%5Cn%20%20%20%20%20%20position:%20absolute;%5Cn%20%20%20%20%20%20left:%20var(--size-4-1);%5Cn%20%20%20%20%20%20right:%20auto;%5Cn%20%20%20%20%20%20opacity:%200.5;%5Cn%20%20%20%20%7D%5Cn%5Cn%20%20%20%20&::-webkit-datetime-edit-month-field,%5Cn%20%20%20%20&::-webkit-datetime-edit-day-field,%5Cn%20%20%20%20&::-webkit-datetime-edit-year-field%20%7B%5Cn%20%20%20%20%20%20&:active,%5Cn%20%20%20%20%20%20&:focus%20%7B%5Cn%20%20%20%20%20%20%20%20background-color:%20var(--text-selection);%5Cn%20%20%20%20%20%20%20%20color:%20var(--text-normal);%5Cn%20%20%20%20%20%20%20%20cursor:%20text;%5Cn%20%20%20%20%20%20%7D%5Cn%20%20%20%20%7D%5Cn%5Cn%20%20%20%20@at-root%20.mod-rtl%20&,%5Cn%20%20%20%20%20%20.is-rtl%20&,%5Cn%20%20%20%20%20%20.rtl%20&%20%7B%5Cn%20%20%20%20%20%20direction:%20rtl;%5Cn%5Cn%20%20%20%20%20%20&::-webkit-calendar-picker-indicator%20%7B%5Cn%20%20%20%20%20%20%20%20left:%20auto;%5Cn%20%20%20%20%20%20%20%20right:%20var(--size-4-1);%5Cn%20%20%20%20%20%20%7D%5Cn%20%20%20%20%7D%5Cn%5Cn%20%20%20%20@at-root%20%7B%5Cn%20%20%20%20%20%20body:not(.is-ios):not(.is-android)%20&%20%7B%5Cn%20%20%20%20%20%20%20%20padding-inline-start:%20var(--size-4-6);%5Cn%20%20%20%20%20%20%7D%5Cn%20%20%20%20%7D%5Cn%20%20%7D%5Cn%5Cn%20%20input%5Btype='time'%5D%20%7B%5Cn%20%20%20%20&::-webkit-calendar-picker-indicator%20%7B%5Cn%20%20%20%20%20%20margin-inline-start:%200;%5Cn%20%20%20%20%7D%5Cn%20%20%7D%5Cn%7D%5Cn%22,%22.obsidian-dev-utils%20%7B%5Cn%20%20&.modal-container%20%7B%5Cn%20%20%20%20.ok-button%20%7B%5Cn%20%20%20%20%20%20margin-right:%2010px;%5Cn%20%20%20%20%20%20margin-top:%2020px;%5Cn%20%20%20%20%7D%5Cn%20%20%7D%5Cn%7D%5Cn%22,%22.obsidian-dev-utils%20%7B%5Cn%20%20.multiple-dropdown-component%20%7B%5Cn%20%20%20%20select,%5Cn%20%20%20%20select:focus,%5Cn%20%20%20%20.dropdown%20%7B%5Cn%20%20%20%20%20%20height:%20auto;%5Cn%5Cn%20%20%20%20%20%20option:checked%20%7B%5Cn%20%20%20%20%20%20%20%20background-color:%20%231967d2;%5Cn%20%20%20%20%20%20%20%20color:%20%23fff;%5Cn%20%20%20%20%20%20%7D%5Cn%20%20%20%20%7D%5Cn%20%20%7D%5Cn%7D%5Cn%22,%22.obsidian-dev-utils%20%7B%5Cn%20%20&.prompt-modal%20%7B%5Cn%20%20%20%20.text-box%20%7B%5Cn%20%20%20%20%20%20width:%20100%25;%5Cn%20%20%20%20%7D%5Cn%20%20%7D%5Cn%7D%5Cn%22,%22.obsidian-dev-utils%20%7B%5Cn%20%20:invalid%20%7B%5Cn%20%20%20%20box-shadow:%200%200%200%202px%20var(--text-error);%5Cn%20%20%7D%5Cn%7D%5Cn%22%5D%7D */\n";
 // Annotate the CommonJS export names for ESM import in node:

package/dist/lib/cjs/ScriptUtils/CliUtils.cjs

@@ -39,8 +39,8 @@ class CliTaskResult {
   /**
    * Chains multiple tasks together, executing them sequentially until one fails.
    *
-   * @param tasks - An array of task functions that return a `TaskResult` or `void`.
-   * @returns A promise that resolves with the first failed `TaskResult` or a success result.
+   * @param tasks - An array of task functions that return a {@link CliTaskResult} or `void`.
+   * @returns A {@link Promise} that resolves with the first failed {@link CliTaskResult} or a success result.
    */
   static async chain(tasks) {
     for (const task of tasks) {
@@ -52,9 +52,9 @@ class CliTaskResult {
     return CliTaskResult.Success();
   }
   /**
-   * Creates a `TaskResult` that does not exit the process.
+   * Creates a {@link CliTaskResult} that does not exit the process.
    *
-   * @returns A `TaskResult` that does not exit the process.
+   * @returns A {@link CliTaskResult} that does not exit the process.
    */
   static DoNotExit() {
     return new DoNotExitTaskResult();
@@ -68,10 +68,10 @@ class CliTaskResult {
     return this.Success(false);
   }
   /**
-   * Creates a `TaskResult` based on an exit code.
+   * Creates a {@link CliTaskResult} based on an exit code.
    *
    * @param exitCode - The exit code to represent.
-   * @returns A `TaskResult` representing the exit code.
+   * @returns A {@link CliTaskResult} representing the exit code.
    */
   static FromExitCode(exitCode) {
     return new ExitCodeTaskResult(exitCode);
@@ -157,4 +157,4 @@ async function wrapResult(taskFn) {
   toCommandLine,
   wrapCliTask
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/ScriptUtils/CliUtils.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation cli\n * Contains utility classes and functions for managing task results, including\n * success, exit codes, and chaining multiple tasks.\n */\n\nimport type { Promisable } from 'type-fest';\n\nimport type { MaybeReturn } from '../Type.ts';\n\nimport { enableLibraryDebuggers } from '../Debug.ts';\nimport { printError } from '../Error.ts';\nimport { noop } from '../Function.ts';\nimport { replaceAll } from '../String.ts';\nimport { process } from './NodeModules.ts';\n\n/**\n * Abstract class representing the result of a task. Includes methods for handling success,\n * exit codes, and chaining tasks.\n */\nexport abstract class CliTaskResult {\n  /**\n   * Chains multiple tasks together, executing them sequentially until one fails.\n   *\n   * @param tasks - An array of task functions that return a `TaskResult` or `void`.\n   * @returns A promise that resolves with the first failed `TaskResult` or a success result.\n   */\n  public static async chain(tasks: (() => Promisable<MaybeReturn<CliTaskResult>>)[]): Promise<CliTaskResult> {\n    for (const task of tasks) {\n      const result = await wrapResult(task);\n      if (!result.isSuccessful()) {\n        return result;\n      }\n    }\n\n    return CliTaskResult.Success();\n  }\n\n  /**\n   * Creates a `TaskResult` that does not exit the process.\n   *\n   * @returns A `TaskResult` that does not exit the process.\n   */\n  public static DoNotExit(): CliTaskResult {\n    return new DoNotExitTaskResult();\n  }\n\n  /**\n   * Represents a failure result of a CLI task.\n   *\n   * @returns The failure result.\n   */\n  public static Failure(): CliTaskResult {\n    return this.Success(false);\n  }\n\n  /**\n   * Creates a `TaskResult` based on an exit code.\n   *\n   * @param exitCode - The exit code to represent.\n   * @returns A `TaskResult` representing the exit code.\n   */\n  public static FromExitCode(exitCode: number): CliTaskResult {\n    return new ExitCodeTaskResult(exitCode);\n  }\n\n  /**\n   * Creates a CliTaskResult representing a successful task result.\n   *\n   * @param isSuccess - A boolean indicating whether the task was successful. Default is true.\n   * @returns A CliTaskResult object representing a successful task result.\n   */\n  public static Success(isSuccess = true): CliTaskResult {\n    return new SuccessTaskResult(isSuccess);\n  }\n\n  /**\n   * Exits the process based on the task result.\n   */\n  public abstract exit(): void;\n\n  /**\n   * Determines if the task was successful.\n   *\n   * @returns `true` if the task was successful, otherwise `false`.\n   */\n  protected abstract isSuccessful(): boolean;\n}\n\n/**\n * Represents a task result that does not exit the process.\n */\nclass DoNotExitTaskResult extends CliTaskResult {\n  /**\n   * Does not exit the process.\n   */\n  public override exit(): void {\n    noop();\n  }\n\n  protected override isSuccessful(): boolean {\n    return true;\n  }\n}\n\n/**\n * Represents a task result based on an exit code.\n */\nclass ExitCodeTaskResult extends CliTaskResult {\n  public constructor(private readonly exitCode: number) {\n    super();\n  }\n\n  /**\n   * Exits the process with the specified exit code.\n   */\n  public override exit(): void {\n    process.exit(this.exitCode);\n  }\n\n  protected override isSuccessful(): boolean {\n    return this.exitCode === 0;\n  }\n}\n\n/**\n * Represents a task result based on success or failure.\n */\nclass SuccessTaskResult extends CliTaskResult {\n  public constructor(private readonly _isSuccessful: boolean) {\n    super();\n  }\n\n  /**\n   * Exits the process based on the success of the task.\n   */\n  public override exit(): void {\n    process.exit(this._isSuccessful ? 0 : 1);\n  }\n\n  protected override isSuccessful(): boolean {\n    return this._isSuccessful;\n  }\n}\n\n/**\n * Converts an array of command-line arguments into a single command-line string.\n * Handles escaping of special characters such as spaces, quotes, and newlines.\n *\n * @param args - The array of command-line arguments to convert.\n * @returns A string representing the command-line invocation.\n */\nexport function toCommandLine(args: string[]): string {\n  return args\n    .map((arg) => {\n      if (/[\\s\"\\n]/.test(arg)) {\n        let escapedArg = arg;\n        escapedArg = replaceAll(escapedArg, /\"/g, '\\\\\"');\n        escapedArg = replaceAll(escapedArg, /\\n/g, '\\\\n');\n        return `\"${escapedArg}\"`;\n      }\n      return arg;\n    })\n    .join(' ');\n}\n\n/**\n * Wraps a CLI task function to ensure it runs safely and handles its `TaskResult`.\n *\n * @param taskFn - The task function to execute, which may return a `TaskResult` or void.\n * @returns A promise that resolves when the task is completed and exits with the appropriate status.\n */\nexport async function wrapCliTask(taskFn: () => Promisable<MaybeReturn<CliTaskResult>>): Promise<void> {\n  enableLibraryDebuggers();\n  const result = await wrapResult(taskFn);\n  result.exit();\n}\n\n/**\n * Safely executes a task function and returns a `TaskResult`. If the task function throws an error,\n * the error is caught, and a failure `TaskResult` is returned.\n *\n * @param taskFn - The task function to execute.\n * @returns A promise that resolves with a `TaskResult` representing the outcome of the task.\n */\nasync function wrapResult(taskFn: () => Promisable<MaybeReturn<CliTaskResult>>): Promise<CliTaskResult> {\n  try {\n    return (await taskFn()) as CliTaskResult | undefined ?? CliTaskResult.Success();\n  } catch (error) {\n    printError(new Error('An error occurred during task execution', { cause: error }));\n    return CliTaskResult.Failure();\n  }\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAUA,mBAAuC;AACvC,mBAA2B;AAC3B,sBAAqB;AACrB,oBAA2B;AAC3B,yBAAwB;AAMjB,MAAe,cAAc;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOlC,aAAoB,MAAM,OAAiF;AACzG,eAAW,QAAQ,OAAO;AACxB,YAAM,SAAS,MAAM,WAAW,IAAI;AACpC,UAAI,CAAC,OAAO,aAAa,GAAG;AAC1B,eAAO;AAAA,MACT;AAAA,IACF;AAEA,WAAO,cAAc,QAAQ;AAAA,EAC/B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,OAAc,YAA2B;AACvC,WAAO,IAAI,oBAAoB;AAAA,EACjC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,OAAc,UAAyB;AACrC,WAAO,KAAK,QAAQ,KAAK;AAAA,EAC3B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAc,aAAa,UAAiC;AAC1D,WAAO,IAAI,mBAAmB,QAAQ;AAAA,EACxC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAc,QAAQ,YAAY,MAAqB;AACrD,WAAO,IAAI,kBAAkB,SAAS;AAAA,EACxC;AAaF;AAKA,MAAM,4BAA4B,cAAc;AAAA;AAAA;AAAA;AAAA,EAI9B,OAAa;AAC3B,8BAAK;AAAA,EACP;AAAA,EAEmB,eAAwB;AACzC,WAAO;AAAA,EACT;AACF;AAKA,MAAM,2BAA2B,cAAc;AAAA,EACtC,YAA6B,UAAkB;AACpD,UAAM;AAD4B;AAAA,EAEpC;AAAA;AAAA;AAAA;AAAA,EAKgB,OAAa;AAC3B,+BAAQ,KAAK,KAAK,QAAQ;AAAA,EAC5B;AAAA,EAEmB,eAAwB;AACzC,WAAO,KAAK,aAAa;AAAA,EAC3B;AACF;AAKA,MAAM,0BAA0B,cAAc;AAAA,EACrC,YAA6B,eAAwB;AAC1D,UAAM;AAD4B;AAAA,EAEpC;AAAA;AAAA;AAAA;AAAA,EAKgB,OAAa;AAC3B,+BAAQ,KAAK,KAAK,gBAAgB,IAAI,CAAC;AAAA,EACzC;AAAA,EAEmB,eAAwB;AACzC,WAAO,KAAK;AAAA,EACd;AACF;AASO,SAAS,cAAc,MAAwB;AACpD,SAAO,KACJ,IAAI,CAAC,QAAQ;AACZ,QAAI,UAAU,KAAK,GAAG,GAAG;AACvB,UAAI,aAAa;AACjB,uBAAa,0BAAW,YAAY,MAAM,KAAK;AAC/C,uBAAa,0BAAW,YAAY,OAAO,KAAK;AAChD,aAAO,IAAI,UAAU;AAAA,IACvB;AACA,WAAO;AAAA,EACT,CAAC,EACA,KAAK,GAAG;AACb;AAQA,eAAsB,YAAY,QAAqE;AACrG,2CAAuB;AACvB,QAAM,SAAS,MAAM,WAAW,MAAM;AACtC,SAAO,KAAK;AACd;AASA,eAAe,WAAW,QAA8E;AACtG,MAAI;AACF,WAAQ,MAAM,OAAO,KAAmC,cAAc,QAAQ;AAAA,EAChF,SAAS,OAAO;AACd,iCAAW,IAAI,MAAM,2CAA2C,EAAE,OAAO,MAAM,CAAC,CAAC;AACjF,WAAO,cAAc,QAAQ;AAAA,EAC/B;AACF;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/ScriptUtils/CliUtils.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation cli\n * Contains utility classes and functions for managing task results, including\n * success, exit codes, and chaining multiple tasks.\n */\n\nimport type { Promisable } from 'type-fest';\n\nimport type { MaybeReturn } from '../Type.ts';\n\nimport { enableLibraryDebuggers } from '../Debug.ts';\nimport { printError } from '../Error.ts';\nimport { noop } from '../Function.ts';\nimport { replaceAll } from '../String.ts';\nimport { process } from './NodeModules.ts';\n\n/**\n * Abstract class representing the result of a task. Includes methods for handling success,\n * exit codes, and chaining tasks.\n */\nexport abstract class CliTaskResult {\n  /**\n   * Chains multiple tasks together, executing them sequentially until one fails.\n   *\n   * @param tasks - An array of task functions that return a {@link CliTaskResult} or `void`.\n   * @returns A {@link Promise} that resolves with the first failed {@link CliTaskResult} or a success result.\n   */\n  public static async chain(tasks: (() => Promisable<MaybeReturn<CliTaskResult>>)[]): Promise<CliTaskResult> {\n    for (const task of tasks) {\n      const result = await wrapResult(task);\n      if (!result.isSuccessful()) {\n        return result;\n      }\n    }\n\n    return CliTaskResult.Success();\n  }\n\n  /**\n   * Creates a {@link CliTaskResult} that does not exit the process.\n   *\n   * @returns A {@link CliTaskResult} that does not exit the process.\n   */\n  public static DoNotExit(): CliTaskResult {\n    return new DoNotExitTaskResult();\n  }\n\n  /**\n   * Represents a failure result of a CLI task.\n   *\n   * @returns The failure result.\n   */\n  public static Failure(): CliTaskResult {\n    return this.Success(false);\n  }\n\n  /**\n   * Creates a {@link CliTaskResult} based on an exit code.\n   *\n   * @param exitCode - The exit code to represent.\n   * @returns A {@link CliTaskResult} representing the exit code.\n   */\n  public static FromExitCode(exitCode: number): CliTaskResult {\n    return new ExitCodeTaskResult(exitCode);\n  }\n\n  /**\n   * Creates a CliTaskResult representing a successful task result.\n   *\n   * @param isSuccess - A boolean indicating whether the task was successful. Default is true.\n   * @returns A CliTaskResult object representing a successful task result.\n   */\n  public static Success(isSuccess = true): CliTaskResult {\n    return new SuccessTaskResult(isSuccess);\n  }\n\n  /**\n   * Exits the process based on the task result.\n   */\n  public abstract exit(): void;\n\n  /**\n   * Determines if the task was successful.\n   *\n   * @returns `true` if the task was successful, otherwise `false`.\n   */\n  protected abstract isSuccessful(): boolean;\n}\n\n/**\n * Represents a task result that does not exit the process.\n */\nclass DoNotExitTaskResult extends CliTaskResult {\n  /**\n   * Does not exit the process.\n   */\n  public override exit(): void {\n    noop();\n  }\n\n  protected override isSuccessful(): boolean {\n    return true;\n  }\n}\n\n/**\n * Represents a task result based on an exit code.\n */\nclass ExitCodeTaskResult extends CliTaskResult {\n  public constructor(private readonly exitCode: number) {\n    super();\n  }\n\n  /**\n   * Exits the process with the specified exit code.\n   */\n  public override exit(): void {\n    process.exit(this.exitCode);\n  }\n\n  protected override isSuccessful(): boolean {\n    return this.exitCode === 0;\n  }\n}\n\n/**\n * Represents a task result based on success or failure.\n */\nclass SuccessTaskResult extends CliTaskResult {\n  public constructor(private readonly _isSuccessful: boolean) {\n    super();\n  }\n\n  /**\n   * Exits the process based on the success of the task.\n   */\n  public override exit(): void {\n    process.exit(this._isSuccessful ? 0 : 1);\n  }\n\n  protected override isSuccessful(): boolean {\n    return this._isSuccessful;\n  }\n}\n\n/**\n * Converts an array of command-line arguments into a single command-line string.\n * Handles escaping of special characters such as spaces, quotes, and newlines.\n *\n * @param args - The array of command-line arguments to convert.\n * @returns A string representing the command-line invocation.\n */\nexport function toCommandLine(args: string[]): string {\n  return args\n    .map((arg) => {\n      if (/[\\s\"\\n]/.test(arg)) {\n        let escapedArg = arg;\n        escapedArg = replaceAll(escapedArg, /\"/g, '\\\\\"');\n        escapedArg = replaceAll(escapedArg, /\\n/g, '\\\\n');\n        return `\"${escapedArg}\"`;\n      }\n      return arg;\n    })\n    .join(' ');\n}\n\n/**\n * Wraps a CLI task function to ensure it runs safely and handles its {@link CliTaskResult}.\n *\n * @param taskFn - The task function to execute, which may return a {@link CliTaskResult} or `void`.\n * @returns A {@link Promise} that resolves when the task is completed and exits with the appropriate status.\n */\nexport async function wrapCliTask(taskFn: () => Promisable<MaybeReturn<CliTaskResult>>): Promise<void> {\n  enableLibraryDebuggers();\n  const result = await wrapResult(taskFn);\n  result.exit();\n}\n\n/**\n * Safely executes a task function and returns a {@link CliTaskResult}. If the task function throws an error,\n * the error is caught, and a failure {@link CliTaskResult} is returned.\n *\n * @param taskFn - The task function to execute.\n * @returns A {@link Promise} that resolves with a {@link CliTaskResult} representing the outcome of the task.\n */\nasync function wrapResult(taskFn: () => Promisable<MaybeReturn<CliTaskResult>>): Promise<CliTaskResult> {\n  try {\n    return (await taskFn()) as CliTaskResult | undefined ?? CliTaskResult.Success();\n  } catch (error) {\n    printError(new Error('An error occurred during task execution', { cause: error }));\n    return CliTaskResult.Failure();\n  }\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAUA,mBAAuC;AACvC,mBAA2B;AAC3B,sBAAqB;AACrB,oBAA2B;AAC3B,yBAAwB;AAMjB,MAAe,cAAc;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOlC,aAAoB,MAAM,OAAiF;AACzG,eAAW,QAAQ,OAAO;AACxB,YAAM,SAAS,MAAM,WAAW,IAAI;AACpC,UAAI,CAAC,OAAO,aAAa,GAAG;AAC1B,eAAO;AAAA,MACT;AAAA,IACF;AAEA,WAAO,cAAc,QAAQ;AAAA,EAC/B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,OAAc,YAA2B;AACvC,WAAO,IAAI,oBAAoB;AAAA,EACjC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,OAAc,UAAyB;AACrC,WAAO,KAAK,QAAQ,KAAK;AAAA,EAC3B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAc,aAAa,UAAiC;AAC1D,WAAO,IAAI,mBAAmB,QAAQ;AAAA,EACxC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAc,QAAQ,YAAY,MAAqB;AACrD,WAAO,IAAI,kBAAkB,SAAS;AAAA,EACxC;AAaF;AAKA,MAAM,4BAA4B,cAAc;AAAA;AAAA;AAAA;AAAA,EAI9B,OAAa;AAC3B,8BAAK;AAAA,EACP;AAAA,EAEmB,eAAwB;AACzC,WAAO;AAAA,EACT;AACF;AAKA,MAAM,2BAA2B,cAAc;AAAA,EACtC,YAA6B,UAAkB;AACpD,UAAM;AAD4B;AAAA,EAEpC;AAAA;AAAA;AAAA;AAAA,EAKgB,OAAa;AAC3B,+BAAQ,KAAK,KAAK,QAAQ;AAAA,EAC5B;AAAA,EAEmB,eAAwB;AACzC,WAAO,KAAK,aAAa;AAAA,EAC3B;AACF;AAKA,MAAM,0BAA0B,cAAc;AAAA,EACrC,YAA6B,eAAwB;AAC1D,UAAM;AAD4B;AAAA,EAEpC;AAAA;AAAA;AAAA;AAAA,EAKgB,OAAa;AAC3B,+BAAQ,KAAK,KAAK,gBAAgB,IAAI,CAAC;AAAA,EACzC;AAAA,EAEmB,eAAwB;AACzC,WAAO,KAAK;AAAA,EACd;AACF;AASO,SAAS,cAAc,MAAwB;AACpD,SAAO,KACJ,IAAI,CAAC,QAAQ;AACZ,QAAI,UAAU,KAAK,GAAG,GAAG;AACvB,UAAI,aAAa;AACjB,uBAAa,0BAAW,YAAY,MAAM,KAAK;AAC/C,uBAAa,0BAAW,YAAY,OAAO,KAAK;AAChD,aAAO,IAAI,UAAU;AAAA,IACvB;AACA,WAAO;AAAA,EACT,CAAC,EACA,KAAK,GAAG;AACb;AAQA,eAAsB,YAAY,QAAqE;AACrG,2CAAuB;AACvB,QAAM,SAAS,MAAM,WAAW,MAAM;AACtC,SAAO,KAAK;AACd;AASA,eAAe,WAAW,QAA8E;AACtG,MAAI;AACF,WAAQ,MAAM,OAAO,KAAmC,cAAc,QAAQ;AAAA,EAChF,SAAS,OAAO;AACd,iCAAW,IAAI,MAAM,2CAA2C,EAAE,OAAO,MAAM,CAAC,CAAC;AACjF,WAAO,cAAc,QAAQ;AAAA,EAC/B;AACF;",
  "names": []
}


package/dist/lib/cjs/ScriptUtils/CliUtils.d.cts

@@ -13,14 +13,14 @@ export declare abstract class CliTaskResult {
     /**
      * Chains multiple tasks together, executing them sequentially until one fails.
      *
-     * @param tasks - An array of task functions that return a `TaskResult` or `void`.
-     * @returns A promise that resolves with the first failed `TaskResult` or a success result.
+     * @param tasks - An array of task functions that return a {@link CliTaskResult} or `void`.
+     * @returns A {@link Promise} that resolves with the first failed {@link CliTaskResult} or a success result.
      */
     static chain(tasks: (() => Promisable<MaybeReturn<CliTaskResult>>)[]): Promise<CliTaskResult>;
     /**
-     * Creates a `TaskResult` that does not exit the process.
+     * Creates a {@link CliTaskResult} that does not exit the process.
      *
-     * @returns A `TaskResult` that does not exit the process.
+     * @returns A {@link CliTaskResult} that does not exit the process.
      */
     static DoNotExit(): CliTaskResult;
     /**
@@ -30,10 +30,10 @@ export declare abstract class CliTaskResult {
      */
     static Failure(): CliTaskResult;
     /**
-     * Creates a `TaskResult` based on an exit code.
+     * Creates a {@link CliTaskResult} based on an exit code.
      *
      * @param exitCode - The exit code to represent.
-     * @returns A `TaskResult` representing the exit code.
+     * @returns A {@link CliTaskResult} representing the exit code.
      */
     static FromExitCode(exitCode: number): CliTaskResult;
     /**
@@ -63,9 +63,9 @@ export declare abstract class CliTaskResult {
  */
 export declare function toCommandLine(args: string[]): string;
 /**
- * Wraps a CLI task function to ensure it runs safely and handles its `TaskResult`.
+ * Wraps a CLI task function to ensure it runs safely and handles its {@link CliTaskResult}.
  *
- * @param taskFn - The task function to execute, which may return a `TaskResult` or void.
- * @returns A promise that resolves when the task is completed and exits with the appropriate status.
+ * @param taskFn - The task function to execute, which may return a {@link CliTaskResult} or `void`.
+ * @returns A {@link Promise} that resolves when the task is completed and exits with the appropriate status.
  */
 export declare function wrapCliTask(taskFn: () => Promisable<MaybeReturn<CliTaskResult>>): Promise<void>;

package/dist/lib/cjs/ScriptUtils/CodeGenerator.cjs

@@ -40,4 +40,4 @@ async function generate(path, lines) {
 0 && (module.exports = {
   generate
 });
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL1NjcmlwdFV0aWxzL0NvZGVHZW5lcmF0b3IudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qKlxuICogQHBhY2thZ2VEb2N1bWVudGF0aW9uIENvZGVHZW5lcmF0b3JcbiAqIENvbnRhaW5zIHV0aWxpdHkgZnVuY3Rpb25zIGZvciBjb2RlIGdlbmVyYXRpb24uXG4gKi9cblxuaW1wb3J0IHsgd3JpdGVGaWxlIH0gZnJvbSAnLi9Ob2RlTW9kdWxlcy50cyc7XG5cbi8qKlxuICogR2VuZXJhdGVzIGEgZmlsZSBhdCB0aGUgc3BlY2lmaWVkIHBhdGggd2l0aCB0aGUgcHJvdmlkZWQgbGluZXMgb2YgY29kZS5cbiAqXG4gKiBAcGFyYW0gcGF0aCAtIFRoZSBwYXRoIHdoZXJlIHRoZSBmaWxlIHdpbGwgYmUgZ2VuZXJhdGVkLlxuICogQHBhcmFtIGxpbmVzIC0gQW4gYXJyYXkgb2Ygc3RyaW5ncyByZXByZXNlbnRpbmcgdGhlIGxpbmVzIG9mIGNvZGUgdG8gYmUgd3JpdHRlbiBpbiB0aGUgZmlsZS5cbiAqIEByZXR1cm5zIEEgcHJvbWlzZSB0aGF0IHJlc29sdmVzIHdoZW4gdGhlIGZpbGUgZ2VuZXJhdGlvbiBpcyBjb21wbGV0ZS5cbiAqL1xuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIGdlbmVyYXRlKHBhdGg6IHN0cmluZywgbGluZXM6IHN0cmluZ1tdKTogUHJvbWlzZTx2b2lkPiB7XG4gIGlmIChsaW5lcy5hdCgtMSkpIHtcbiAgICBsaW5lcy5wdXNoKCcnKTtcbiAgfVxuICBsaW5lcy51bnNoaWZ0KCcvKiBUSElTIElTIEEgR0VORVJBVEVEL0JVTkRMRUQgRklMRSBCWSBCVUlMRCBTQ1JJUFQgKi8nLCAnJyk7XG4gIGF3YWl0IHdyaXRlRmlsZShwYXRoLCBsaW5lcy5qb2luKCdcXG4nKSwgJ3V0Zi04Jyk7XG59XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUtBLHlCQUEwQjtBQVMxQixlQUFzQixTQUFTLE1BQWMsT0FBZ0M7QUFDM0UsTUFBSSxNQUFNLEdBQUcsRUFBRSxHQUFHO0FBQ2hCLFVBQU0sS0FBSyxFQUFFO0FBQUEsRUFDZjtBQUNBLFFBQU0sUUFBUSwwREFBMEQsRUFBRTtBQUMxRSxZQUFNLDhCQUFVLE1BQU0sTUFBTSxLQUFLLElBQUksR0FBRyxPQUFPO0FBQ2pEOyIsCiAgIm5hbWVzIjogW10KfQo=
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL1NjcmlwdFV0aWxzL0NvZGVHZW5lcmF0b3IudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qKlxuICogQHBhY2thZ2VEb2N1bWVudGF0aW9uIENvZGVHZW5lcmF0b3JcbiAqIENvbnRhaW5zIHV0aWxpdHkgZnVuY3Rpb25zIGZvciBjb2RlIGdlbmVyYXRpb24uXG4gKi9cblxuaW1wb3J0IHsgd3JpdGVGaWxlIH0gZnJvbSAnLi9Ob2RlTW9kdWxlcy50cyc7XG5cbi8qKlxuICogR2VuZXJhdGVzIGEgZmlsZSBhdCB0aGUgc3BlY2lmaWVkIHBhdGggd2l0aCB0aGUgcHJvdmlkZWQgbGluZXMgb2YgY29kZS5cbiAqXG4gKiBAcGFyYW0gcGF0aCAtIFRoZSBwYXRoIHdoZXJlIHRoZSBmaWxlIHdpbGwgYmUgZ2VuZXJhdGVkLlxuICogQHBhcmFtIGxpbmVzIC0gQW4gYXJyYXkgb2Ygc3RyaW5ncyByZXByZXNlbnRpbmcgdGhlIGxpbmVzIG9mIGNvZGUgdG8gYmUgd3JpdHRlbiBpbiB0aGUgZmlsZS5cbiAqIEByZXR1cm5zIEEge0BsaW5rIFByb21pc2V9IHRoYXQgcmVzb2x2ZXMgd2hlbiB0aGUgZmlsZSBnZW5lcmF0aW9uIGlzIGNvbXBsZXRlLlxuICovXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gZ2VuZXJhdGUocGF0aDogc3RyaW5nLCBsaW5lczogc3RyaW5nW10pOiBQcm9taXNlPHZvaWQ+IHtcbiAgaWYgKGxpbmVzLmF0KC0xKSkge1xuICAgIGxpbmVzLnB1c2goJycpO1xuICB9XG4gIGxpbmVzLnVuc2hpZnQoJy8qIFRISVMgSVMgQSBHRU5FUkFURUQvQlVORExFRCBGSUxFIEJZIEJVSUxEIFNDUklQVCAqLycsICcnKTtcbiAgYXdhaXQgd3JpdGVGaWxlKHBhdGgsIGxpbmVzLmpvaW4oJ1xcbicpLCAndXRmLTgnKTtcbn1cbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBS0EseUJBQTBCO0FBUzFCLGVBQXNCLFNBQVMsTUFBYyxPQUFnQztBQUMzRSxNQUFJLE1BQU0sR0FBRyxFQUFFLEdBQUc7QUFDaEIsVUFBTSxLQUFLLEVBQUU7QUFBQSxFQUNmO0FBQ0EsUUFBTSxRQUFRLDBEQUEwRCxFQUFFO0FBQzFFLFlBQU0sOEJBQVUsTUFBTSxNQUFNLEtBQUssSUFBSSxHQUFHLE9BQU87QUFDakQ7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist/lib/cjs/ScriptUtils/CodeGenerator.d.cts

@@ -7,6 +7,6 @@
  *
  * @param path - The path where the file will be generated.
  * @param lines - An array of strings representing the lines of code to be written in the file.
- * @returns A promise that resolves when the file generation is complete.
+ * @returns A {@link Promise} that resolves when the file generation is complete.
  */
 export declare function generate(path: string, lines: string[]): Promise<void>;

package/dist/lib/cjs/ScriptUtils/Exec.cjs

@@ -116,4 +116,4 @@ ${stderr}`));
 0 && (module.exports = {
   exec
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/ScriptUtils/Exec.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation Exec\n * Contains utility functions for executing commands.\n */\n\nimport { getLibDebugger } from '../Debug.ts';\nimport { trimEnd } from '../String.ts';\nimport { toCommandLine } from './CliUtils.ts';\nimport {\n  process,\n  spawn\n} from './NodeModules.ts';\n\n/**\n * Options for executing a command.\n */\nexport interface ExecOption {\n  /**\n   * The current working directory for the command execution.\n   */\n  cwd?: string;\n\n  /**\n   * If true, suppresses the output of the command.\n   */\n  isQuiet?: boolean;\n\n  /**\n   * If true, throws an error if the command fails.\n   */\n  shouldFailIfCalledFromOutsideRoot?: boolean;\n\n  /**\n   * If true, ignores the exit code of the command.\n   */\n  shouldIgnoreExitCode?: boolean;\n\n  /**\n   * If false, only returns the output of the command.\n   */\n  shouldIncludeDetails?: boolean;\n\n  /**\n   * The input to be passed to the command.\n   */\n  stdin?: string;\n}\n\n/**\n * Represents the result of executing a command.\n */\nexport interface ExecResult {\n  /**\n   * The exit code of the command. A value of `null` indicates that the process did not exit normally.\n   */\n  exitCode: null | number;\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 * Executes a command.\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 exec(command: string | string[], options?: { withDetails?: false } & ExecOption): Promise<string>;\n\n/**\n * Executes a command.\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 exec(command: string | string[], options: { withDetails: true } & ExecOption): Promise<ExecResult>;\n\n/**\n * Executes a command.\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 exec(command: string | string[], options: ExecOption = {}): Promise<ExecResult | string> {\n  const {\n    cwd = process.cwd(),\n    isQuiet: quiet = false,\n    shouldIgnoreExitCode: ignoreExitCode = false,\n    shouldIncludeDetails: withDetails = false,\n    stdin = ''\n  } = options;\n  if (Array.isArray(command)) {\n    command = toCommandLine(command);\n  }\n\n  return new Promise((resolve, reject) => {\n    getLibDebugger('Exec')(`Executing command: ${command}`);\n    const [cmd = '', ...args] = command.split(' ');\n\n    const child = spawn(cmd, args, {\n      cwd,\n      env: {\n        DEBUG_COLORS: '1',\n        ...process.env\n      },\n      shell: true,\n      stdio: 'pipe'\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        return;\n      }\n\n      if (!withDetails) {\n        resolve(stdout);\n        return;\n      }\n      resolve({\n        exitCode,\n        exitSignal,\n        stderr,\n        stdout\n      });\n    });\n\n    child.on('error', (err) => {\n      if (!ignoreExitCode) {\n        reject(err);\n        return;\n      }\n\n      if (!withDetails) {\n        resolve(stdout);\n        return;\n      }\n\n      resolve({\n        exitCode: null,\n        exitSignal: null,\n        stderr,\n        stdout\n      });\n    });\n  });\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,mBAA+B;AAC/B,oBAAwB;AACxB,sBAA8B;AAC9B,yBAGO;AAqGA,SAAS,KAAK,SAA4B,UAAsB,CAAC,GAAiC;AACvG,QAAM;AAAA,IACJ,MAAM,2BAAQ,IAAI;AAAA,IAClB,SAAS,QAAQ;AAAA,IACjB,sBAAsB,iBAAiB;AAAA,IACvC,sBAAsB,cAAc;AAAA,IACpC,QAAQ;AAAA,EACV,IAAI;AACJ,MAAI,MAAM,QAAQ,OAAO,GAAG;AAC1B,kBAAU,+BAAc,OAAO;AAAA,EACjC;AAEA,SAAO,IAAI,QAAQ,CAAC,SAAS,WAAW;AACtC,qCAAe,MAAM,EAAE,sBAAsB,OAAO,EAAE;AACtD,UAAM,CAAC,MAAM,IAAI,GAAG,IAAI,IAAI,QAAQ,MAAM,GAAG;AAE7C,UAAM,YAAQ,0BAAM,KAAK,MAAM;AAAA,MAC7B;AAAA,MACA,KAAK;AAAA,QACH,cAAc;AAAA,QACd,GAAG,2BAAQ;AAAA,MACb;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;AAChG;AAAA,MACF;AAEA,UAAI,CAAC,aAAa;AAChB,gBAAQ,MAAM;AACd;AAAA,MACF;AACA,cAAQ;AAAA,QACN;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MACF,CAAC;AAAA,IACH,CAAC;AAED,UAAM,GAAG,SAAS,CAAC,QAAQ;AACzB,UAAI,CAAC,gBAAgB;AACnB,eAAO,GAAG;AACV;AAAA,MACF;AAEA,UAAI,CAAC,aAAa;AAChB,gBAAQ,MAAM;AACd;AAAA,MACF;AAEA,cAAQ;AAAA,QACN,UAAU;AAAA,QACV,YAAY;AAAA,QACZ;AAAA,QACA;AAAA,MACF,CAAC;AAAA,IACH,CAAC;AAAA,EACH,CAAC;AACH;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/ScriptUtils/Exec.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation Exec\n * Contains utility functions for executing commands.\n */\n\nimport { getLibDebugger } from '../Debug.ts';\nimport { trimEnd } from '../String.ts';\nimport { toCommandLine } from './CliUtils.ts';\nimport {\n  process,\n  spawn\n} from './NodeModules.ts';\n\n/**\n * Options for executing a command.\n */\nexport interface ExecOption {\n  /**\n   * The current working directory for the command execution.\n   */\n  cwd?: string;\n\n  /**\n   * If true, suppresses the output of the command.\n   */\n  isQuiet?: boolean;\n\n  /**\n   * If true, throws an error if the command fails.\n   */\n  shouldFailIfCalledFromOutsideRoot?: boolean;\n\n  /**\n   * If true, ignores the exit code of the command.\n   */\n  shouldIgnoreExitCode?: boolean;\n\n  /**\n   * If false, only returns the output of the command.\n   */\n  shouldIncludeDetails?: boolean;\n\n  /**\n   * The input to be passed to the command.\n   */\n  stdin?: string;\n}\n\n/**\n * Represents the result of executing a command.\n */\nexport interface ExecResult {\n  /**\n   * The exit code of the command. A value of `null` indicates that the process did not exit normally.\n   */\n  exitCode: null | number;\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 * Executes a command.\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 {@link 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 exec(command: string | string[], options?: { withDetails?: false } & ExecOption): Promise<string>;\n\n/**\n * Executes a command.\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 {@link 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 exec(command: string | string[], options: { withDetails: true } & ExecOption): Promise<ExecResult>;\n\n/**\n * Executes a command.\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 {@link 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 exec(command: string | string[], options: ExecOption = {}): Promise<ExecResult | string> {\n  const {\n    cwd = process.cwd(),\n    isQuiet: quiet = false,\n    shouldIgnoreExitCode: ignoreExitCode = false,\n    shouldIncludeDetails: withDetails = false,\n    stdin = ''\n  } = options;\n  if (Array.isArray(command)) {\n    command = toCommandLine(command);\n  }\n\n  return new Promise((resolve, reject) => {\n    getLibDebugger('Exec')(`Executing command: ${command}`);\n    const [cmd = '', ...args] = command.split(' ');\n\n    const child = spawn(cmd, args, {\n      cwd,\n      env: {\n        DEBUG_COLORS: '1',\n        ...process.env\n      },\n      shell: true,\n      stdio: 'pipe'\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        return;\n      }\n\n      if (!withDetails) {\n        resolve(stdout);\n        return;\n      }\n      resolve({\n        exitCode,\n        exitSignal,\n        stderr,\n        stdout\n      });\n    });\n\n    child.on('error', (err) => {\n      if (!ignoreExitCode) {\n        reject(err);\n        return;\n      }\n\n      if (!withDetails) {\n        resolve(stdout);\n        return;\n      }\n\n      resolve({\n        exitCode: null,\n        exitSignal: null,\n        stderr,\n        stdout\n      });\n    });\n  });\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,mBAA+B;AAC/B,oBAAwB;AACxB,sBAA8B;AAC9B,yBAGO;AAqGA,SAAS,KAAK,SAA4B,UAAsB,CAAC,GAAiC;AACvG,QAAM;AAAA,IACJ,MAAM,2BAAQ,IAAI;AAAA,IAClB,SAAS,QAAQ;AAAA,IACjB,sBAAsB,iBAAiB;AAAA,IACvC,sBAAsB,cAAc;AAAA,IACpC,QAAQ;AAAA,EACV,IAAI;AACJ,MAAI,MAAM,QAAQ,OAAO,GAAG;AAC1B,kBAAU,+BAAc,OAAO;AAAA,EACjC;AAEA,SAAO,IAAI,QAAQ,CAAC,SAAS,WAAW;AACtC,qCAAe,MAAM,EAAE,sBAAsB,OAAO,EAAE;AACtD,UAAM,CAAC,MAAM,IAAI,GAAG,IAAI,IAAI,QAAQ,MAAM,GAAG;AAE7C,UAAM,YAAQ,0BAAM,KAAK,MAAM;AAAA,MAC7B;AAAA,MACA,KAAK;AAAA,QACH,cAAc;AAAA,QACd,GAAG,2BAAQ;AAAA,MACb;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;AAChG;AAAA,MACF;AAEA,UAAI,CAAC,aAAa;AAChB,gBAAQ,MAAM;AACd;AAAA,MACF;AACA,cAAQ;AAAA,QACN;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MACF,CAAC;AAAA,IACH,CAAC;AAED,UAAM,GAAG,SAAS,CAAC,QAAQ;AACzB,UAAI,CAAC,gBAAgB;AACnB,eAAO,GAAG;AACV;AAAA,MACF;AAEA,UAAI,CAAC,aAAa;AAChB,gBAAQ,MAAM;AACd;AAAA,MACF;AAEA,cAAQ;AAAA,QACN,UAAU;AAAA,QACV,YAAY;AAAA,QACZ;AAAA,QACA;AAAA,MACF,CAAC;AAAA,IACH,CAAC;AAAA,EACH,CAAC;AACH;",
  "names": []
}


package/dist/lib/cjs/ScriptUtils/Exec.d.cts

@@ -57,7 +57,7 @@ export interface ExecResult {
  *
  * @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.
+ * @returns A {@link 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,
@@ -71,7 +71,7 @@ export declare function exec(command: string | string[], options?: {
  *
  * @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.
+ * @returns A {@link 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.