obsidian-dev-utils 86.0.0 → 86.1.0

package/dist/lib/esm/script-utils/exec.d.mts

@@ -36,6 +36,20 @@ export interface ExecOptions {
      * A current working folder for the command execution.
      */
     readonly cwd?: string;
+    /**
+     * Additional environment variables for the child process, merged over the inherited environment.
+     *
+     * @default `{}`
+     */
+    readonly env?: NodeJS.ProcessEnv;
+    /**
+     * If `true`, attaches the child process's stdio directly to the terminal (`stdio: 'inherit'`) instead
+     * of capturing it. Use for long-running or interactive commands such as dev servers and watch mode.
+     * Because the output is not captured, the resolved stdout is an empty string.
+     *
+     * @default `false`
+     */
+    readonly isInteractive?: boolean;
     /**
      * If `true`, suppresses the output of the command.
      *

package/dist/lib/esm/script-utils/exec.mjs

@@ -94,6 +94,8 @@ function execString(params) {
   } = params;
   const {
     cwd = process.cwd(),
+    env,
+    isInteractive = false,
     isQuiet: quiet = false,
     shouldIgnoreExitCode: ignoreExitCode = false,
     shouldIncludeDetails = false,
@@ -104,36 +106,48 @@ function execString(params) {
     const child = spawnViaShell(normalizeOptionalProperties({
       command,
       cwd,
+      env,
+      isInteractive,
       rawArgs
     }));
     let stdout = "";
     let stderr = "";
-    child.stdin.write(stdin);
-    child.stdin.end();
-    child.stdout.on("data", (data) => {
-      if (!quiet) {
-        process.stdout.write(data);
-      }
-      stdout += data.toString("utf-8");
-    });
-    child.stdout.on("end", () => {
-      stdout = trimEnd({
-        str: stdout,
-        suffix: "\n"
+    if (!isInteractive) {
+      const {
+        stderr: childStderr,
+        stdin: childStdin,
+        stdout: childStdout
+      } = child;
+      assertNonNullable(childStdin, "Child process stdin is not available");
+      assertNonNullable(childStdout, "Child process stdout is not available");
+      assertNonNullable(childStderr, "Child process stderr is not available");
+      childStdin.write(stdin);
+      childStdin.end();
+      childStdout.on("data", (data) => {
+        if (!quiet) {
+          process.stdout.write(data);
+        }
+        stdout += data.toString("utf-8");
       });
-    });
-    child.stderr.on("data", (data) => {
-      if (!quiet) {
-        process.stderr.write(data);
-      }
-      stderr += data.toString("utf-8");
-    });
-    child.stderr.on("end", () => {
-      stderr = trimEnd({
-        str: stderr,
-        suffix: "\n"
+      childStdout.on("end", () => {
+        stdout = trimEnd({
+          str: stdout,
+          suffix: "\n"
+        });
       });
-    });
+      childStderr.on("data", (data) => {
+        if (!quiet) {
+          process.stderr.write(data);
+        }
+        stderr += data.toString("utf-8");
+      });
+      childStderr.on("end", () => {
+        stderr = trimEnd({
+          str: stderr,
+          suffix: "\n"
+        });
+      });
+    }
     child.on("close", (exitCode, exitSignal) => {
       if (exitCode !== 0 && !ignoreExitCode) {
         reject(new Error(`Command failed with exit code ${exitCode ? String(exitCode) : "(null)"}
@@ -245,7 +259,12 @@ function isExecArg(part) {
   return typeof part === "object" && "batchedArgs" in part;
 }
 function spawnViaShell(params) {
-  const { command, cwd, rawArgs } = params;
+  const { command, cwd, env: extraEnv, isInteractive = false, rawArgs } = params;
+  const env = {
+    ...CHILD_ENV,
+    ...extraEnv
+  };
+  const stdio = isInteractive ? "inherit" : "pipe";
   if (process.platform === "win32" && command.includes("\n")) {
     if (!rawArgs) {
       throw new Error("Commands containing newlines cannot be executed through cmd.exe on Windows. Pass an argument array instead of a string.");
@@ -254,16 +273,16 @@ function spawnViaShell(params) {
     assertNonNullable(program, "Command array must not be empty");
     return spawn(program, args, {
       cwd,
-      env: CHILD_ENV,
-      stdio: "pipe"
+      env,
+      stdio
     });
   }
   const shellCommand = process.platform === "win32" ? cmdEscapeCommandLine(command) : command;
   return spawn(shellCommand, [], {
     cwd,
-    env: CHILD_ENV,
+    env,
     shell: true,
-    stdio: "pipe"
+    stdio
   });
 }
 export {
@@ -271,4 +290,4 @@ export {
   buildChildEnv,
   exec
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/script-utils/exec.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions for executing commands.\n */\n\nimport type { ChildProcessWithoutNullStreams } from 'node:child_process';\n\nimport { spawn } from 'node:child_process';\nimport process from 'node:process';\n\nimport { getLibDebugger } from '../debug.ts';\nimport { normalizeOptionalProperties } from '../object-utils.ts';\nimport { trimEnd } from '../string.ts';\nimport { assertNonNullable } from '../type-guards.ts';\nimport {\n  cmdEscapeCommandLine,\n  toCommandLine\n} from './cli-utils.ts';\n\n/**\n * A command part: either a plain string or an {@link ExecArg} with batched arguments.\n */\nexport type CommandPart = ExecArg | string;\n\n/**\n * A command argument that contains a list of args to be batched.\n * If the expanded command exceeds the platform's max command length,\n * the batched args are split into sequential executions.\n */\nexport interface ExecArg {\n  /**\n   * The arguments to batch.\n   */\n  readonly batchedArgs: readonly string[];\n}\n\n/**\n * Options for {@link exec} that return detailed results.\n */\nexport interface ExecDetailedOptions extends ExecOptions {\n  /**\n   * Must be `true` to receive detailed results.\n   */\n  readonly shouldIncludeDetails: true;\n}\n\n/**\n * Options for executing a command.\n */\nexport interface ExecOptions {\n  /**\n   * A current working folder for the command execution.\n   */\n  readonly cwd?: string;\n\n  /**\n   * If `true`, suppresses the output of the command.\n   *\n   * @default `false`\n   */\n  readonly isQuiet?: boolean;\n\n  /**\n   * If `true`, throws an error if the command fails.\n   *\n   * @default `true`\n   */\n  readonly shouldFailIfCalledFromOutsideRoot?: boolean;\n\n  /**\n   * If `true`, ignores the exit code of the command.\n   *\n   * @default `false`\n   */\n  readonly shouldIgnoreExitCode?: boolean;\n\n  /**\n   * If `false`, only returns the output of the command.\n   *\n   * @default `false`\n   */\n  readonly shouldIncludeDetails?: boolean;\n\n  /**\n   * An input to be passed to the command.\n   *\n   * @default `''`\n   */\n  readonly stdin?: string;\n}\n\n/**\n * A result of {@link exec}.\n */\nexport interface ExecResult {\n  /**\n   * An exit code of the command. A value of `null` indicates that the process did not exit normally.\n   */\n  readonly exitCode: null | number;\n\n  /**\n   * A signal that caused the process to be terminated. A value of `null` indicates that no signal was received.\n   */\n  readonly exitSignal: NodeJS.Signals | null;\n\n  /**\n   * A standard error output from the command.\n   */\n  readonly stderr: string;\n\n  /**\n   * A standard output from the command.\n   */\n  readonly stdout: string;\n}\n\n/**\n * Options for {@link exec} that return only stdout.\n */\nexport interface ExecSimpleOptions extends ExecOptions {\n  /**\n   * Must be `false` or omitted to receive only stdout.\n   *\n   * @default `false`\n   */\n  readonly shouldIncludeDetails?: false;\n}\n\n/**\n * Parameters for {@link execString}.\n */\ninterface ExecStringParams {\n  /**\n   * The command string.\n   */\n  readonly command: string;\n\n  /**\n   * The exec options.\n   */\n  readonly options?: ExecOptions;\n\n  /**\n   * The original argument array (if available), used by the PowerShell\n   * fallback path to quote arguments with PowerShell-native single quotes.\n   */\n  readonly rawArgs?: string[];\n}\n/**\n * Appends a single `node` CLI option to a `NODE_OPTIONS` string, preserving any options already present.\n *\n * @param existingNodeOptions - The current `NODE_OPTIONS` value (e.g. `process.env.NODE_OPTIONS`), if any.\n * @param option - The `node` CLI option to append (e.g. `--localstorage-file=:memory:`).\n * @returns The combined `NODE_OPTIONS` string. If `option` is already present, the value is returned unchanged.\n */\nexport function appendNodeOption(existingNodeOptions: string | undefined, option: string): string {\n  const trimmed = (existingNodeOptions ?? '').trim();\n  if (trimmed === '') {\n    return option;\n  }\n  if (trimmed.split(/\\s+/).includes(option)) {\n    return trimmed;\n  }\n  return `${trimmed} ${option}`;\n}\n\n/**\n * Builds the environment for child processes: the parent environment plus `DEBUG_COLORS`, and \u2014 when\n * the running `node` supports it \u2014 {@link LOCAL_STORAGE_NODE_OPTION} appended to `NODE_OPTIONS`.\n *\n * The support check guards against older `node` (< 22): passing an option `node` does not recognize via\n * `NODE_OPTIONS` makes it exit before running, which would break every spawned tool.\n *\n * @param baseEnv - The parent environment to extend (typically `process.env`).\n * @param allowedNodeEnvironmentFlags - The `node` options accepted via `NODE_OPTIONS` (typically `process.allowedNodeEnvironmentFlags`).\n * @returns The environment to pass to spawned child processes.\n */\nexport function buildChildEnv(baseEnv: NodeJS.ProcessEnv, allowedNodeEnvironmentFlags: ReadonlySet<string>): NodeJS.ProcessEnv {\n  const env: NodeJS.ProcessEnv = {\n    DEBUG_COLORS: '1',\n    ...baseEnv\n  };\n  if (allowedNodeEnvironmentFlags.has('--localstorage-file')) {\n    env['NODE_OPTIONS'] = appendNodeOption(baseEnv['NODE_OPTIONS'], LOCAL_STORAGE_NODE_OPTION);\n  }\n  return env;\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: CommandPart[] | string, options?: ExecSimpleOptions): Promise<string>;\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: CommandPart[] | string, options: ExecDetailedOptions): Promise<ExecResult>;\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: CommandPart[] | string, options: ExecOptions = {}): Promise<ExecResult | string> {\n  if (Array.isArray(command)) {\n    const batchResult = handleBatchedCommand(command, options);\n    if (batchResult) {\n      return batchResult;\n    }\n    const args = command.filter((part): part is string => typeof part === 'string');\n    const commandLine = toCommandLine(args);\n\n    const maxCommandLength = getMaxCommandLength();\n    if (commandLine.length > maxCommandLength) {\n      return Promise.reject(\n        new Error(\n          `Command line is too long (${String(commandLine.length)} chars, max ${String(maxCommandLength)} on ${process.platform}). Consider splitting into smaller batches or use ExecArg.`\n        )\n      );\n    }\n\n    return execString({\n      command: commandLine,\n      options,\n      rawArgs: args\n    });\n  }\n\n  const maxCommandLength = getMaxCommandLength();\n  if (command.length > maxCommandLength) {\n    return Promise.reject(\n      new Error(\n        `Command line is too long (${String(command.length)} chars, max ${String(maxCommandLength)} on ${process.platform}). Consider splitting into smaller batches or use ExecArg.`\n      )\n    );\n  }\n\n  return execString({\n    command,\n    options\n  });\n}\n\n/**\n * Executes a single string command.\n *\n * @param params - The parameters for the execution.\n * @returns A Promise resolving to the result.\n */\nfunction execString(params: ExecStringParams): Promise<ExecResult | string> {\n  const {\n    command,\n    options = {},\n    rawArgs\n  } = params;\n  const {\n    cwd = process.cwd(),\n    isQuiet: quiet = false,\n    shouldIgnoreExitCode: ignoreExitCode = false,\n    shouldIncludeDetails = false,\n    stdin = ''\n  } = options;\n\n  return new Promise((resolve, reject) => {\n    getLibDebugger('Exec')(`Executing command: ${command}`);\n\n    const child = spawnViaShell(normalizeOptionalProperties<SpawnViaShellParams>({\n      command,\n      cwd,\n      rawArgs\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({\n        str: stdout,\n        suffix: '\\n'\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({\n        str: stderr,\n        suffix: '\\n'\n      });\n    });\n\n    child.on('close', (exitCode, exitSignal) => {\n      if (exitCode !== 0 && !ignoreExitCode) {\n        reject(new Error(`Command failed with exit code ${exitCode ? String(exitCode) : '(null)'}\\n${stderr}`));\n        return;\n      }\n\n      if (!shouldIncludeDetails) {\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 (!shouldIncludeDetails) {\n        resolve(stdout);\n        return;\n      }\n\n      resolve({\n        exitCode: null,\n        exitSignal: null,\n        stderr,\n        stdout\n      });\n    });\n  });\n}\n\n/**\n * A `node` CLI option (passed via `NODE_OPTIONS`) that provides an in-memory `localStorage` to every\n * spawned `node` process. Node 22+ exposes an experimental Web Storage `localStorage`, but accessing it\n * without `--localstorage-file` emits an `ExperimentalWarning` and leaves `localStorage` unavailable.\n * Pointing it at the special `:memory:` database gives each process a working, non-persistent\n * `localStorage` (no file on disk, no state shared between processes) \u2014 matching the real Obsidian\n * (Electron) runtime and silencing the warning by addressing its root cause rather than suppressing it.\n *\n * It is applied only when the running `node` actually supports it (see {@link buildChildEnv}): passing\n * an option `node` does not recognize via `NODE_OPTIONS` makes it refuse to start, so an older `node`\n * (< 22) must be left untouched.\n */\nconst LOCAL_STORAGE_NODE_OPTION = '--localstorage-file=:memory:';\n\n/**\n * Default environment variables passed to child processes.\n */\nconst CHILD_ENV = buildChildEnv(process.env, process.allowedNodeEnvironmentFlags);\n\n/**\n * Parameters for {@link executeBatches}.\n */\ninterface ExecuteBatchesParams {\n  /**\n   * The base command without batched args.\n   */\n  readonly baseCommand: string;\n\n  /**\n   * The batches of args.\n   */\n  readonly batches: string[][];\n\n  /**\n   * The exec options.\n   */\n  readonly options: ExecOptions;\n}\n\n/**\n * Parameters for {@link spawnViaShell}.\n */\ninterface SpawnViaShellParams {\n  /**\n   * The command string to execute.\n   */\n  readonly command: string;\n\n  /**\n   * The working directory.\n   */\n  readonly cwd: string;\n\n  /**\n   * The original argument array (if available).\n   */\n  readonly rawArgs?: string[];\n}\n\n/**\n * Executes batched commands sequentially and concatenates stdout.\n *\n * @param params - The parameters for the batched execution.\n * @returns A Promise resolving to the concatenated result.\n */\nasync function executeBatches(params: ExecuteBatchesParams): Promise<ExecResult | string> {\n  const { baseCommand, batches, options } = params;\n  const results: string[] = [];\n\n  for (const batch of batches) {\n    const batchCommand = `${baseCommand} ${batch.join(' ')}`;\n    const result = await execString({\n      command: batchCommand,\n      options\n    });\n    if (typeof result === 'string') {\n      results.push(result);\n    }\n  }\n\n  if (options.shouldIncludeDetails) {\n    return { exitCode: 0, exitSignal: null, stderr: '', stdout: results.join('\\n') };\n  }\n\n  return results.join('\\n');\n}\n\n/**\n * Returns the platform-specific max command line length.\n *\n * @returns The max command length in characters.\n */\nfunction getMaxCommandLength(): number {\n  const WINDOWS_MAX_COMMAND_LENGTH = 8191;\n  const UNIX_MAX_COMMAND_LENGTH = 131072;\n  return process.platform === 'win32' ? WINDOWS_MAX_COMMAND_LENGTH : UNIX_MAX_COMMAND_LENGTH;\n}\n\n/**\n * Handles a command array that may contain an {@link ExecArg}.\n * Returns a Promise if batching is needed, or `undefined` if the command\n * has no ExecArg and should be processed normally.\n *\n * @param parts - The command parts.\n * @param options - The exec options.\n * @returns A Promise if batching is handled, or `undefined`.\n */\nfunction handleBatchedCommand(parts: CommandPart[], options: ExecOptions): Promise<ExecResult | string> | undefined {\n  const execArgs = parts.filter(isExecArg);\n  if (execArgs.length === 0) {\n    return undefined;\n  }\n  if (execArgs.length > 1) {\n    return Promise.reject(new Error('Only one ExecArg with batchedArgs is allowed per command'));\n  }\n\n  const execArg = execArgs[0];\n  assertNonNullable(execArg);\n  const staticParts = parts.filter((part): part is string => typeof part === 'string');\n  const baseCommand = toCommandLine(staticParts);\n  const maxCommandLength = getMaxCommandLength();\n\n  // Try expanding all args inline\n  const fullCommand = `${baseCommand} ${execArg.batchedArgs.join(' ')}`;\n  if (fullCommand.length <= maxCommandLength) {\n    return execString({\n      command: fullCommand,\n      options\n    });\n  }\n\n  // Split into batches\n  const batches: string[][] = [];\n  let currentBatch: string[] = [];\n\n  for (const arg of execArg.batchedArgs) {\n    const tentative = `${baseCommand} ${[...currentBatch, arg].join(' ')}`;\n    if (tentative.length > maxCommandLength) {\n      if (currentBatch.length === 0) {\n        return Promise.reject(\n          new Error(\n            `Cannot split command into batches: a single argument (${String(arg.length)} chars) plus the base command (${String(baseCommand.length)} chars) exceeds the max command length (${String(maxCommandLength)}).`\n          )\n        );\n      }\n      batches.push(currentBatch);\n      currentBatch = [arg];\n    } else {\n      currentBatch.push(arg);\n    }\n  }\n  /* v8 ignore start -- Always true after the loop; batchedArgs is non-empty at this point. */\n  if (currentBatch.length > 0) {\n    /* v8 ignore stop */\n    batches.push(currentBatch);\n  }\n\n  return executeBatches({\n    baseCommand,\n    batches,\n    options\n  });\n}\n\n/**\n * Checks if a command part is an {@link ExecArg}.\n *\n * @param part - The command part to check.\n * @returns Whether the part is an ExecArg.\n */\nfunction isExecArg(part: CommandPart): part is ExecArg {\n  return typeof part === 'object' && 'batchedArgs' in part;\n}\n\n/**\n * Spawns a child process via the appropriate shell.\n *\n * On Windows, if the command contains newlines (which `cmd.exe` cannot handle)\n * and the raw args array is available, spawns the process directly without\n * any shell \u2014 passing args via `CreateProcess`, which avoids all quoting issues.\n *\n * On Windows (cmd.exe path), applies `^`-escaping for cmd metacharacters.\n *\n * @param params - The parameters for spawning the child process.\n * @returns The spawned child process.\n */\nfunction spawnViaShell(params: SpawnViaShellParams): ChildProcessWithoutNullStreams {\n  const { command, cwd, rawArgs } = params;\n  if (process.platform === 'win32' && command.includes('\\n')) {\n    if (!rawArgs) {\n      throw new Error('Commands containing newlines cannot be executed through cmd.exe on Windows. Pass an argument array instead of a string.');\n    }\n    const [program, ...args] = rawArgs;\n    assertNonNullable(program, 'Command array must not be empty');\n    return spawn(program, args, {\n      cwd,\n      env: CHILD_ENV,\n      stdio: 'pipe'\n    });\n  }\n\n  const shellCommand = process.platform === 'win32' ? cmdEscapeCommandLine(command) : command;\n  return spawn(shellCommand, [], {\n    cwd,\n    env: CHILD_ENV,\n    shell: true,\n    stdio: 'pipe'\n  });\n}\n"],
  "mappings": "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",
  "names": ["maxCommandLength"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/script-utils/exec.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions for executing commands.\n */\n\nimport type { ChildProcess } from 'node:child_process';\n\nimport { spawn } from 'node:child_process';\nimport process from 'node:process';\n\nimport { getLibDebugger } from '../debug.ts';\nimport { normalizeOptionalProperties } from '../object-utils.ts';\nimport { trimEnd } from '../string.ts';\nimport { assertNonNullable } from '../type-guards.ts';\nimport {\n  cmdEscapeCommandLine,\n  toCommandLine\n} from './cli-utils.ts';\n\n/**\n * A command part: either a plain string or an {@link ExecArg} with batched arguments.\n */\nexport type CommandPart = ExecArg | string;\n\n/**\n * A command argument that contains a list of args to be batched.\n * If the expanded command exceeds the platform's max command length,\n * the batched args are split into sequential executions.\n */\nexport interface ExecArg {\n  /**\n   * The arguments to batch.\n   */\n  readonly batchedArgs: readonly string[];\n}\n\n/**\n * Options for {@link exec} that return detailed results.\n */\nexport interface ExecDetailedOptions extends ExecOptions {\n  /**\n   * Must be `true` to receive detailed results.\n   */\n  readonly shouldIncludeDetails: true;\n}\n\n/**\n * Options for executing a command.\n */\nexport interface ExecOptions {\n  /**\n   * A current working folder for the command execution.\n   */\n  readonly cwd?: string;\n\n  /**\n   * Additional environment variables for the child process, merged over the inherited environment.\n   *\n   * @default `{}`\n   */\n  readonly env?: NodeJS.ProcessEnv;\n\n  /**\n   * If `true`, attaches the child process's stdio directly to the terminal (`stdio: 'inherit'`) instead\n   * of capturing it. Use for long-running or interactive commands such as dev servers and watch mode.\n   * Because the output is not captured, the resolved stdout is an empty string.\n   *\n   * @default `false`\n   */\n  readonly isInteractive?: boolean;\n\n  /**\n   * If `true`, suppresses the output of the command.\n   *\n   * @default `false`\n   */\n  readonly isQuiet?: boolean;\n\n  /**\n   * If `true`, throws an error if the command fails.\n   *\n   * @default `true`\n   */\n  readonly shouldFailIfCalledFromOutsideRoot?: boolean;\n\n  /**\n   * If `true`, ignores the exit code of the command.\n   *\n   * @default `false`\n   */\n  readonly shouldIgnoreExitCode?: boolean;\n\n  /**\n   * If `false`, only returns the output of the command.\n   *\n   * @default `false`\n   */\n  readonly shouldIncludeDetails?: boolean;\n\n  /**\n   * An input to be passed to the command.\n   *\n   * @default `''`\n   */\n  readonly stdin?: string;\n}\n\n/**\n * A result of {@link exec}.\n */\nexport interface ExecResult {\n  /**\n   * An exit code of the command. A value of `null` indicates that the process did not exit normally.\n   */\n  readonly exitCode: null | number;\n\n  /**\n   * A signal that caused the process to be terminated. A value of `null` indicates that no signal was received.\n   */\n  readonly exitSignal: NodeJS.Signals | null;\n\n  /**\n   * A standard error output from the command.\n   */\n  readonly stderr: string;\n\n  /**\n   * A standard output from the command.\n   */\n  readonly stdout: string;\n}\n\n/**\n * Options for {@link exec} that return only stdout.\n */\nexport interface ExecSimpleOptions extends ExecOptions {\n  /**\n   * Must be `false` or omitted to receive only stdout.\n   *\n   * @default `false`\n   */\n  readonly shouldIncludeDetails?: false;\n}\n\n/**\n * Parameters for {@link execString}.\n */\ninterface ExecStringParams {\n  /**\n   * The command string.\n   */\n  readonly command: string;\n\n  /**\n   * The exec options.\n   */\n  readonly options?: ExecOptions;\n\n  /**\n   * The original argument array (if available), used by the PowerShell\n   * fallback path to quote arguments with PowerShell-native single quotes.\n   */\n  readonly rawArgs?: string[];\n}\n/**\n * Appends a single `node` CLI option to a `NODE_OPTIONS` string, preserving any options already present.\n *\n * @param existingNodeOptions - The current `NODE_OPTIONS` value (e.g. `process.env.NODE_OPTIONS`), if any.\n * @param option - The `node` CLI option to append (e.g. `--localstorage-file=:memory:`).\n * @returns The combined `NODE_OPTIONS` string. If `option` is already present, the value is returned unchanged.\n */\nexport function appendNodeOption(existingNodeOptions: string | undefined, option: string): string {\n  const trimmed = (existingNodeOptions ?? '').trim();\n  if (trimmed === '') {\n    return option;\n  }\n  if (trimmed.split(/\\s+/).includes(option)) {\n    return trimmed;\n  }\n  return `${trimmed} ${option}`;\n}\n\n/**\n * Builds the environment for child processes: the parent environment plus `DEBUG_COLORS`, and \u2014 when\n * the running `node` supports it \u2014 {@link LOCAL_STORAGE_NODE_OPTION} appended to `NODE_OPTIONS`.\n *\n * The support check guards against older `node` (< 22): passing an option `node` does not recognize via\n * `NODE_OPTIONS` makes it exit before running, which would break every spawned tool.\n *\n * @param baseEnv - The parent environment to extend (typically `process.env`).\n * @param allowedNodeEnvironmentFlags - The `node` options accepted via `NODE_OPTIONS` (typically `process.allowedNodeEnvironmentFlags`).\n * @returns The environment to pass to spawned child processes.\n */\nexport function buildChildEnv(baseEnv: NodeJS.ProcessEnv, allowedNodeEnvironmentFlags: ReadonlySet<string>): NodeJS.ProcessEnv {\n  const env: NodeJS.ProcessEnv = {\n    DEBUG_COLORS: '1',\n    ...baseEnv\n  };\n  if (allowedNodeEnvironmentFlags.has('--localstorage-file')) {\n    env['NODE_OPTIONS'] = appendNodeOption(baseEnv['NODE_OPTIONS'], LOCAL_STORAGE_NODE_OPTION);\n  }\n  return env;\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: CommandPart[] | string, options?: ExecSimpleOptions): Promise<string>;\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: CommandPart[] | string, options: ExecDetailedOptions): Promise<ExecResult>;\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: CommandPart[] | string, options: ExecOptions = {}): Promise<ExecResult | string> {\n  if (Array.isArray(command)) {\n    const batchResult = handleBatchedCommand(command, options);\n    if (batchResult) {\n      return batchResult;\n    }\n    const args = command.filter((part): part is string => typeof part === 'string');\n    const commandLine = toCommandLine(args);\n\n    const maxCommandLength = getMaxCommandLength();\n    if (commandLine.length > maxCommandLength) {\n      return Promise.reject(\n        new Error(\n          `Command line is too long (${String(commandLine.length)} chars, max ${String(maxCommandLength)} on ${process.platform}). Consider splitting into smaller batches or use ExecArg.`\n        )\n      );\n    }\n\n    return execString({\n      command: commandLine,\n      options,\n      rawArgs: args\n    });\n  }\n\n  const maxCommandLength = getMaxCommandLength();\n  if (command.length > maxCommandLength) {\n    return Promise.reject(\n      new Error(\n        `Command line is too long (${String(command.length)} chars, max ${String(maxCommandLength)} on ${process.platform}). Consider splitting into smaller batches or use ExecArg.`\n      )\n    );\n  }\n\n  return execString({\n    command,\n    options\n  });\n}\n\n/**\n * Executes a single string command.\n *\n * @param params - The parameters for the execution.\n * @returns A Promise resolving to the result.\n */\nfunction execString(params: ExecStringParams): Promise<ExecResult | string> {\n  const {\n    command,\n    options = {},\n    rawArgs\n  } = params;\n  const {\n    cwd = process.cwd(),\n    env,\n    isInteractive = false,\n    isQuiet: quiet = false,\n    shouldIgnoreExitCode: ignoreExitCode = false,\n    shouldIncludeDetails = false,\n    stdin = ''\n  } = options;\n\n  return new Promise((resolve, reject) => {\n    getLibDebugger('Exec')(`Executing command: ${command}`);\n\n    const child = spawnViaShell(normalizeOptionalProperties<SpawnViaShellParams>({\n      command,\n      cwd,\n      env,\n      isInteractive,\n      rawArgs\n    }));\n\n    let stdout = '';\n    let stderr = '';\n\n    // In interactive mode the child's stdio is inherited by the terminal, so there are no streams to read and nothing is captured.\n    if (!isInteractive) {\n      const {\n        stderr: childStderr,\n        stdin: childStdin,\n        stdout: childStdout\n      } = child;\n      assertNonNullable(childStdin, 'Child process stdin is not available');\n      assertNonNullable(childStdout, 'Child process stdout is not available');\n      assertNonNullable(childStderr, 'Child process stderr is not available');\n\n      childStdin.write(stdin);\n      childStdin.end();\n\n      childStdout.on('data', (data: Buffer) => {\n        if (!quiet) {\n          process.stdout.write(data);\n        }\n        stdout += data.toString('utf-8');\n      });\n\n      childStdout.on('end', () => {\n        stdout = trimEnd({\n          str: stdout,\n          suffix: '\\n'\n        });\n      });\n\n      childStderr.on('data', (data: Buffer) => {\n        if (!quiet) {\n          process.stderr.write(data);\n        }\n        stderr += data.toString('utf-8');\n      });\n\n      childStderr.on('end', () => {\n        stderr = trimEnd({\n          str: stderr,\n          suffix: '\\n'\n        });\n      });\n    }\n\n    child.on('close', (exitCode, exitSignal) => {\n      if (exitCode !== 0 && !ignoreExitCode) {\n        reject(new Error(`Command failed with exit code ${exitCode ? String(exitCode) : '(null)'}\\n${stderr}`));\n        return;\n      }\n\n      if (!shouldIncludeDetails) {\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 (!shouldIncludeDetails) {\n        resolve(stdout);\n        return;\n      }\n\n      resolve({\n        exitCode: null,\n        exitSignal: null,\n        stderr,\n        stdout\n      });\n    });\n  });\n}\n\n/**\n * A `node` CLI option (passed via `NODE_OPTIONS`) that provides an in-memory `localStorage` to every\n * spawned `node` process. Node 22+ exposes an experimental Web Storage `localStorage`, but accessing it\n * without `--localstorage-file` emits an `ExperimentalWarning` and leaves `localStorage` unavailable.\n * Pointing it at the special `:memory:` database gives each process a working, non-persistent\n * `localStorage` (no file on disk, no state shared between processes) \u2014 matching the real Obsidian\n * (Electron) runtime and silencing the warning by addressing its root cause rather than suppressing it.\n *\n * It is applied only when the running `node` actually supports it (see {@link buildChildEnv}): passing\n * an option `node` does not recognize via `NODE_OPTIONS` makes it refuse to start, so an older `node`\n * (< 22) must be left untouched.\n */\nconst LOCAL_STORAGE_NODE_OPTION = '--localstorage-file=:memory:';\n\n/**\n * Default environment variables passed to child processes.\n */\nconst CHILD_ENV = buildChildEnv(process.env, process.allowedNodeEnvironmentFlags);\n\n/**\n * Parameters for {@link executeBatches}.\n */\ninterface ExecuteBatchesParams {\n  /**\n   * The base command without batched args.\n   */\n  readonly baseCommand: string;\n\n  /**\n   * The batches of args.\n   */\n  readonly batches: string[][];\n\n  /**\n   * The exec options.\n   */\n  readonly options: ExecOptions;\n}\n\n/**\n * Parameters for {@link spawnViaShell}.\n */\ninterface SpawnViaShellParams {\n  /**\n   * The command string to execute.\n   */\n  readonly command: string;\n\n  /**\n   * The working directory.\n   */\n  readonly cwd: string;\n\n  /**\n   * Additional environment variables merged over the inherited child environment.\n   */\n  readonly env?: NodeJS.ProcessEnv;\n\n  /**\n   * If `true`, attaches the child's stdio to the terminal instead of piping it.\n   */\n  readonly isInteractive?: boolean;\n\n  /**\n   * The original argument array (if available).\n   */\n  readonly rawArgs?: string[];\n}\n\n/**\n * Executes batched commands sequentially and concatenates stdout.\n *\n * @param params - The parameters for the batched execution.\n * @returns A Promise resolving to the concatenated result.\n */\nasync function executeBatches(params: ExecuteBatchesParams): Promise<ExecResult | string> {\n  const { baseCommand, batches, options } = params;\n  const results: string[] = [];\n\n  for (const batch of batches) {\n    const batchCommand = `${baseCommand} ${batch.join(' ')}`;\n    const result = await execString({\n      command: batchCommand,\n      options\n    });\n    if (typeof result === 'string') {\n      results.push(result);\n    }\n  }\n\n  if (options.shouldIncludeDetails) {\n    return { exitCode: 0, exitSignal: null, stderr: '', stdout: results.join('\\n') };\n  }\n\n  return results.join('\\n');\n}\n\n/**\n * Returns the platform-specific max command line length.\n *\n * @returns The max command length in characters.\n */\nfunction getMaxCommandLength(): number {\n  const WINDOWS_MAX_COMMAND_LENGTH = 8191;\n  const UNIX_MAX_COMMAND_LENGTH = 131072;\n  return process.platform === 'win32' ? WINDOWS_MAX_COMMAND_LENGTH : UNIX_MAX_COMMAND_LENGTH;\n}\n\n/**\n * Handles a command array that may contain an {@link ExecArg}.\n * Returns a Promise if batching is needed, or `undefined` if the command\n * has no ExecArg and should be processed normally.\n *\n * @param parts - The command parts.\n * @param options - The exec options.\n * @returns A Promise if batching is handled, or `undefined`.\n */\nfunction handleBatchedCommand(parts: CommandPart[], options: ExecOptions): Promise<ExecResult | string> | undefined {\n  const execArgs = parts.filter(isExecArg);\n  if (execArgs.length === 0) {\n    return undefined;\n  }\n  if (execArgs.length > 1) {\n    return Promise.reject(new Error('Only one ExecArg with batchedArgs is allowed per command'));\n  }\n\n  const execArg = execArgs[0];\n  assertNonNullable(execArg);\n  const staticParts = parts.filter((part): part is string => typeof part === 'string');\n  const baseCommand = toCommandLine(staticParts);\n  const maxCommandLength = getMaxCommandLength();\n\n  // Try expanding all args inline\n  const fullCommand = `${baseCommand} ${execArg.batchedArgs.join(' ')}`;\n  if (fullCommand.length <= maxCommandLength) {\n    return execString({\n      command: fullCommand,\n      options\n    });\n  }\n\n  // Split into batches\n  const batches: string[][] = [];\n  let currentBatch: string[] = [];\n\n  for (const arg of execArg.batchedArgs) {\n    const tentative = `${baseCommand} ${[...currentBatch, arg].join(' ')}`;\n    if (tentative.length > maxCommandLength) {\n      if (currentBatch.length === 0) {\n        return Promise.reject(\n          new Error(\n            `Cannot split command into batches: a single argument (${String(arg.length)} chars) plus the base command (${String(baseCommand.length)} chars) exceeds the max command length (${String(maxCommandLength)}).`\n          )\n        );\n      }\n      batches.push(currentBatch);\n      currentBatch = [arg];\n    } else {\n      currentBatch.push(arg);\n    }\n  }\n  /* v8 ignore start -- Always true after the loop; batchedArgs is non-empty at this point. */\n  if (currentBatch.length > 0) {\n    /* v8 ignore stop */\n    batches.push(currentBatch);\n  }\n\n  return executeBatches({\n    baseCommand,\n    batches,\n    options\n  });\n}\n\n/**\n * Checks if a command part is an {@link ExecArg}.\n *\n * @param part - The command part to check.\n * @returns Whether the part is an ExecArg.\n */\nfunction isExecArg(part: CommandPart): part is ExecArg {\n  return typeof part === 'object' && 'batchedArgs' in part;\n}\n\n/**\n * Spawns a child process via the appropriate shell.\n *\n * On Windows, if the command contains newlines (which `cmd.exe` cannot handle)\n * and the raw args array is available, spawns the process directly without\n * any shell \u2014 passing args via `CreateProcess`, which avoids all quoting issues.\n *\n * On Windows (cmd.exe path), applies `^`-escaping for cmd metacharacters.\n *\n * @param params - The parameters for spawning the child process.\n * @returns The spawned child process.\n */\nfunction spawnViaShell(params: SpawnViaShellParams): ChildProcess {\n  const { command, cwd, env: extraEnv, isInteractive = false, rawArgs } = params;\n  const env: NodeJS.ProcessEnv = {\n    ...CHILD_ENV,\n    ...extraEnv\n  };\n  const stdio: 'inherit' | 'pipe' = isInteractive ? 'inherit' : 'pipe';\n  if (process.platform === 'win32' && command.includes('\\n')) {\n    if (!rawArgs) {\n      throw new Error('Commands containing newlines cannot be executed through cmd.exe on Windows. Pass an argument array instead of a string.');\n    }\n    const [program, ...args] = rawArgs;\n    assertNonNullable(program, 'Command array must not be empty');\n    return spawn(program, args, {\n      cwd,\n      env,\n      stdio\n    });\n  }\n\n  const shellCommand = process.platform === 'win32' ? cmdEscapeCommandLine(command) : command;\n  return spawn(shellCommand, [], {\n    cwd,\n    env,\n    shell: true,\n    stdio\n  });\n}\n"],
  "mappings": "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",
  "names": ["maxCommandLength"]
}


package/dist/lib/esm/script-utils/obsidian-dev-utils-repo-paths.d.mts

@@ -26,6 +26,8 @@ export declare enum ObsidianDevUtilsRepoPaths {
     AnyPath = "**",
     /** Any TypeScript file. */
     AnyTs = "*.ts",
+    /** Astro configuration file (documentation site) at the repo root. */
+    AstroConfigTs = "astro.config.ts",
     /** CommonJS folder. */
     Cjs = "cjs",
     /** CommonJS file extension. */
@@ -46,6 +48,10 @@ export declare enum ObsidianDevUtilsRepoPaths {
     DjsExtension = ".d.js",
     /** ESM TypeScript declaration file extension. */
     DmtsExtension = ".d.mts",
+    /** Documentation site folder (Astro + Starlight API-docs sub-project). */
+    Docs = "docs",
+    /** Build output folder of the documentation site. */
+    DocsDist = "docs/dist",
     /** Dprint configuration file. */
     DprintJson = "dprint.json",
     /** TypeScript declaration file extension. */

package/dist/lib/esm/script-utils/obsidian-dev-utils-repo-paths.mjs

@@ -30,6 +30,7 @@ var ObsidianDevUtilsRepoPaths = /* @__PURE__ */ ((ObsidianDevUtilsRepoPaths2) =>
   ObsidianDevUtilsRepoPaths2["AnyMjs"] = "*.mjs";
   ObsidianDevUtilsRepoPaths2["AnyPath"] = "**";
   ObsidianDevUtilsRepoPaths2["AnyTs"] = "*.ts";
+  ObsidianDevUtilsRepoPaths2["AstroConfigTs"] = "astro.config.ts";
   ObsidianDevUtilsRepoPaths2["Cjs"] = "cjs";
   ObsidianDevUtilsRepoPaths2["CjsExtension"] = ".cjs";
   ObsidianDevUtilsRepoPaths2["CurrentFolder"] = ".";
@@ -40,6 +41,8 @@ var ObsidianDevUtilsRepoPaths = /* @__PURE__ */ ((ObsidianDevUtilsRepoPaths2) =>
   ObsidianDevUtilsRepoPaths2["DistTemplates"] = "dist/templates";
   ObsidianDevUtilsRepoPaths2["DjsExtension"] = ".d.js";
   ObsidianDevUtilsRepoPaths2["DmtsExtension"] = ".d.mts";
+  ObsidianDevUtilsRepoPaths2["Docs"] = "docs";
+  ObsidianDevUtilsRepoPaths2["DocsDist"] = "docs/dist";
   ObsidianDevUtilsRepoPaths2["DprintJson"] = "dprint.json";
   ObsidianDevUtilsRepoPaths2["DtsExtension"] = ".d.ts";
   ObsidianDevUtilsRepoPaths2["EslintConfigMts"] = "eslint.config.mts";
@@ -76,4 +79,4 @@ var ObsidianDevUtilsRepoPaths = /* @__PURE__ */ ((ObsidianDevUtilsRepoPaths2) =>
 export {
   ObsidianDevUtilsRepoPaths
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/script-utils/obsidian-dev-utils-repo-paths.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * This module defines an enumeration of common file paths and patterns used in the Obsidian development utilities repository.\n * These paths are used throughout the build process and other utilities, ensuring consistency and reducing the likelihood\n * of errors due to hardcoded strings.\n */\n\n/**\n * Enumeration of common file paths and patterns used in the Obsidian development utilities repository.\n */\nexport enum ObsidianDevUtilsRepoPaths {\n  /** Any file or folder. */\n  Any = '*',\n\n  /** CommonJS file. */\n  AnyCjs = '*.cjs',\n\n  /** CommonJS TypeScript declaration file. */\n  AnyDcts = '*.d.cts',\n\n  /** ESM TypeScript declaration file. */\n  AnyDmts = '*.d.mts',\n\n  /** TypeScript declaration file. */\n  AnyDts = '*.d.ts',\n\n  /** ESM JavaScript file. */\n  AnyMjs = '*.mjs',\n\n  /** Any path recursively. */\n  AnyPath = '**',\n\n  /** Any TypeScript file. */\n  AnyTs = '*.ts',\n\n  /** Astro configuration file (documentation site) at the repo root. */\n  AstroConfigTs = 'astro.config.ts',\n\n  /** CommonJS folder. */\n  Cjs = 'cjs',\n\n  /** CommonJS file extension. */\n  CjsExtension = '.cjs',\n\n  /** Current folder. */\n  CurrentFolder = '.',\n\n  /** Dataview types. */\n  DataviewTypes = 'src/obsidian/@types/dataview/**',\n\n  /** CommonJS TypeScript declaration file extension. */\n  DctsExtension = '.d.cts',\n\n  /** Distribution folder. */\n  Dist = 'dist',\n\n  /** A path to the `lib` folder within the {@link Dist} folder. */\n  DistLib = 'dist/lib',\n\n  /** A path to the `templates` folder within the {@link Dist} folder, holding the consumer-facing templates. */\n  DistTemplates = 'dist/templates',\n\n  /** Transpiled TypeScript declaration file extension. */\n  DjsExtension = '.d.js',\n\n  /** ESM TypeScript declaration file extension. */\n  DmtsExtension = '.d.mts',\n\n  /** Documentation site folder (Astro + Starlight API-docs sub-project). */\n  Docs = 'docs',\n\n  /** Build output folder of the documentation site. */\n  DocsDist = 'docs/dist',\n\n  /** Dprint configuration file. */\n  DprintJson = 'dprint.json',\n\n  /** TypeScript declaration file extension. */\n  DtsExtension = '.d.ts',\n\n  /** ESM TypeScript ESLint configuration file. */\n  EslintConfigMts = 'eslint.config.mts',\n\n  /** ESM JavaScript folder. */\n  Esm = 'esm',\n\n  /** Generated-during-build CommonJS file. */\n  GeneratedDuringBuildCjs = 'generated-during-build.cjs',\n\n  /** Generated-during-build ESM JavaScript file. */\n  GeneratedDuringBuildMjs = 'generated-during-build.mjs',\n\n  /** CommonJS JavaScript index file. */\n  IndexCjs = 'index.cjs',\n\n  /** CommonJS TypeScript declaration file index file. */\n  IndexDcts = 'index.d.cts',\n\n  /** ESM TypeScript declaration file index file. */\n  IndexDmts = 'index.d.mts',\n\n  /** ESM JavaScript index file. */\n  IndexMjs = 'index.mjs',\n\n  /** TypeScript index file. */\n  IndexTs = 'index.ts',\n\n  /** JavaScript file extension. */\n  JsExtension = '.js',\n\n  /** ESM Markdownlint CLI2 configuration file. */\n  MarkdownlintCli2ConfigMjs = '.markdownlint-cli2.mjs',\n\n  /** Markdownlint CLI2 configuration schema TypeScript declaration file. */\n  MarkdownlintTypesMarkdownlintCli2ConfigSchemaDts = 'src/script-utils/linters/markdownlint-types/@types/markdownlint-cli2-config-schema.d.ts',\n\n  /** Generated flat re-export barrel file. */\n  MergedTs = '__merged.ts',\n\n  /** ESM JavaScript file extension. */\n  MjsExtension = '.mjs',\n\n  /** Node modules folder. */\n  NodeModules = 'node_modules',\n\n  /** Package JSON file. */\n  PackageJson = 'package.json',\n\n  /** Root folder. */\n  RootFolder = '/',\n\n  /** Scripts folder. */\n  Scripts = 'scripts',\n\n  /** ScriptUtils folder. */\n  ScriptUtils = 'script-utils',\n\n  /** Source folder. */\n  Src = 'src',\n\n  /** Styles folder. */\n  Styles = 'styles',\n\n  /** Styles CSS file. */\n  StylesCss = 'styles.css',\n\n  /** Templates folder. */\n  Templates = 'templates',\n\n  /** Test helpers folder. */\n  TestHelpers = 'test-helpers',\n\n  /** TypeScript configuration file. */\n  TsConfigJson = 'tsconfig.json',\n\n  /** TypeScript configuration file that validates the generated CommonJS declarations. */\n  TsConfigValidateDeclarationsCjsJson = 'tsconfig.validate-declarations-cjs.json',\n\n  /** TypeScript configuration file that validates the generated ESM declarations. */\n  TsConfigValidateDeclarationsJson = 'tsconfig.validate-declarations.json',\n\n  /** TypeScript file extension. */\n  TsExtension = '.ts',\n\n  /** Types folder. */\n  Types = '@types'\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAWO,IAAK,4BAAL,kBAAKA,+BAAL;AAEL,EAAAA,2BAAA,SAAM;AAGN,EAAAA,2BAAA,YAAS;AAGT,EAAAA,2BAAA,aAAU;AAGV,EAAAA,2BAAA,aAAU;AAGV,EAAAA,2BAAA,YAAS;AAGT,EAAAA,2BAAA,YAAS;AAGT,EAAAA,2BAAA,aAAU;AAGV,EAAAA,2BAAA,WAAQ;AAGR,EAAAA,2BAAA,mBAAgB;AAGhB,EAAAA,2BAAA,SAAM;AAGN,EAAAA,2BAAA,kBAAe;AAGf,EAAAA,2BAAA,mBAAgB;AAGhB,EAAAA,2BAAA,mBAAgB;AAGhB,EAAAA,2BAAA,mBAAgB;AAGhB,EAAAA,2BAAA,UAAO;AAGP,EAAAA,2BAAA,aAAU;AAGV,EAAAA,2BAAA,mBAAgB;AAGhB,EAAAA,2BAAA,kBAAe;AAGf,EAAAA,2BAAA,mBAAgB;AAGhB,EAAAA,2BAAA,UAAO;AAGP,EAAAA,2BAAA,cAAW;AAGX,EAAAA,2BAAA,gBAAa;AAGb,EAAAA,2BAAA,kBAAe;AAGf,EAAAA,2BAAA,qBAAkB;AAGlB,EAAAA,2BAAA,SAAM;AAGN,EAAAA,2BAAA,6BAA0B;AAG1B,EAAAA,2BAAA,6BAA0B;AAG1B,EAAAA,2BAAA,cAAW;AAGX,EAAAA,2BAAA,eAAY;AAGZ,EAAAA,2BAAA,eAAY;AAGZ,EAAAA,2BAAA,cAAW;AAGX,EAAAA,2BAAA,aAAU;AAGV,EAAAA,2BAAA,iBAAc;AAGd,EAAAA,2BAAA,+BAA4B;AAG5B,EAAAA,2BAAA,sDAAmD;AAGnD,EAAAA,2BAAA,cAAW;AAGX,EAAAA,2BAAA,kBAAe;AAGf,EAAAA,2BAAA,iBAAc;AAGd,EAAAA,2BAAA,iBAAc;AAGd,EAAAA,2BAAA,gBAAa;AAGb,EAAAA,2BAAA,aAAU;AAGV,EAAAA,2BAAA,iBAAc;AAGd,EAAAA,2BAAA,SAAM;AAGN,EAAAA,2BAAA,YAAS;AAGT,EAAAA,2BAAA,eAAY;AAGZ,EAAAA,2BAAA,eAAY;AAGZ,EAAAA,2BAAA,iBAAc;AAGd,EAAAA,2BAAA,kBAAe;AAGf,EAAAA,2BAAA,yCAAsC;AAGtC,EAAAA,2BAAA,sCAAmC;AAGnC,EAAAA,2BAAA,iBAAc;AAGd,EAAAA,2BAAA,WAAQ;AA3JE,SAAAA;AAAA,GAAA;",
  "names": ["ObsidianDevUtilsRepoPaths"]
}


package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obsidian-dev-utils",
-  "version": "86.0.0",
+  "version": "86.1.0",
   "description": "This is the collection of useful functions that you can use for your Obsidian plugin development.",
   "keywords": [
     "obsidian"
@@ -623,6 +623,9 @@
     "build:types": "jiti scripts/build-types.ts",
     "build:validate-declarations": "jiti scripts/build-validate-declarations.ts",
     "commit": "jiti scripts/commit.ts",
+    "docs:build": "jiti scripts/docs-build.ts",
+    "docs:dev": "jiti scripts/docs-dev.ts",
+    "docs:preview": "jiti scripts/docs-preview.ts",
     "find-overexposed": "jiti scripts/find-overexposed.ts",
     "find-overexposed:fix": "jiti scripts/find-overexposed-fix.ts",
     "format": "jiti scripts/format.ts",
@@ -717,30 +720,41 @@
     "svelte-preprocess": "^6.0.5",
     "type-fest": "^5.8.0",
     "typescript": "6.0.3",
-    "typescript-eslint": "^8.63.0",
-    "unist-util-visit": "^5.1.0"
+    "typescript-eslint": "^8.63.0"
   },
   "devDependencies": {
+    "@astrojs/check": "^0.9.9",
+    "@astrojs/starlight": "^0.41.3",
     "@commitlint/cli": "^21.2.1",
     "@commitlint/config-conventional": "^21.2.0",
     "@commitlint/types": "^21.2.0",
     "@jest/globals": "^30.4.1",
+    "@resvg/resvg-js": "^2.6.2",
     "@total-typescript/ts-reset": "^0.6.1",
     "@types/adm-zip": "^0.5.8",
     "@typescript-eslint/rule-tester": "^8.63.0",
     "@vitest/coverage-v8": "^4.1.10",
     "@vitest/runner": "^4.1.10",
+    "astro": "^7.0.8",
     "better-typescript-lib": "^2.12.0",
     "czg": "^1.13.1",
     "dedent": "^1.7.2",
     "eslint-plugin-n": "^18.2.2",
+    "gray-matter": "^4.0.3",
+    "hast-util-from-html": "^2.0.3",
+    "hastscript": "^9.0.1",
     "husky": "^9.1.7",
     "jsdom": "^29.1.1",
     "moment": "^2.30.1",
     "nano-staged": "^1.0.2",
     "obsidian-integration-testing": "^8.1.0",
     "obsidian-test-mocks": "^3.6.0",
+    "satori": "^0.26.0",
+    "starlight-package-managers": "^0.12.0",
     "ts-declaration-location": "^1.0.7",
+    "ts-morph": "^28.0.0",
+    "typedoc-plugin-mdn-links": "^5.1.1",
+    "unist-util-visit": "^5.1.0",
     "vitest": "^4.1.10",
     "yaml": "^2.9.0"
   },