obsidian-dev-utils 88.5.0 → 88.7.0

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

@@ -26,6 +26,7 @@ import { enableLibraryDebuggers } from "../debug.mjs";
 import { printError } from "../error.mjs";
 import { noop } from "../function.mjs";
 import { replaceAll } from "../string.mjs";
+import { getDisabledScriptEnvVariableName } from "./env-toggle.mjs";
 class CliTaskResult {
   /**
    * Chains multiple tasks together, executing them sequentially until one fails.
@@ -178,6 +179,13 @@ function cmdEscapeCommandLine(commandLine) {
   });
 }
 async function wrapCliTask(taskFn) {
+  const disabledScriptEnvVariableName = getDisabledScriptEnvVariableName();
+  if (disabledScriptEnvVariableName !== null) {
+    process.stdout.write(`Skipped (${disabledScriptEnvVariableName} is off).
+`);
+    CliTaskResult.Success().exit();
+    return;
+  }
   enableLibraryDebuggers();
   const result = await wrapResult(taskFn);
   result.exit();
@@ -197,4 +205,4 @@ export {
   toPosixCommandLine,
   wrapCliTask
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/script-utils/cli-utils.ts"],
  "sourcesContent": ["/**\n * @file\n *\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 process from 'node:process';\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';\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   * 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   * Throws an error if the task was not successful.\n   */\n  public throwOnFailure(): void {\n    if (!this.isSuccessful()) {\n      throw new Error('Task failed');\n    }\n  }\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 * 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 * 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 * 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 * using the `CommandLineToArgvW` convention (the standard used by the\n * Microsoft C runtime and most Windows programs).\n *\n * Implements the ArgvQuote algorithm from\n * {@link https://learn.microsoft.com/archive/blogs/twistylittlepassagesallalike/everyone-quotes-command-line-arguments-the-wrong-way | Everyone quotes command line arguments the wrong way}:\n * backslashes before quotes and at the end of a quoted argument are doubled.\n *\n * This produces a shell-agnostic command line. Callers that route through\n * a specific shell (cmd.exe, PowerShell, sh) must apply shell-specific\n * escaping on top \u2014 see {@link cmdEscapeCommandLine}.\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.map((arg) => argvQuote(arg)).join(' ');\n}\n\n/**\n * Converts an array of command-line arguments into a single command-line string\n * quoted for a POSIX shell (`sh`, `bash`, `zsh`, ...).\n *\n * Each argument is wrapped in single quotes unless it consists solely of\n * characters that are safe unquoted, mirroring Python's `shlex.quote`. A literal\n * single quote inside an argument is emitted as the `'\\''` idiom (close the\n * quoted span, add an escaped literal quote, reopen), so the shell reproduces the\n * argument verbatim \u2014 no variable expansion (`$`), command substitution\n * (`` ` ``), globbing (`*`, `?`, `[`), or word splitting.\n *\n * Use this on platforms where the command is executed through `sh -c`. On\n * Windows, use {@link toCommandLine} plus {@link cmdEscapeCommandLine} instead \u2014\n * the two conventions are not interchangeable.\n *\n * @param args - The array of command-line arguments to convert.\n * @returns A string representing the command-line invocation for a POSIX shell.\n */\nexport function toPosixCommandLine(args: string[]): string {\n  return args.map((arg) => posixQuote(arg)).join(' ');\n}\n\n/**\n * Matches an argument that is entirely composed of characters safe to pass to a\n * POSIX shell unquoted. Mirrors the safe set used by Python's `shlex.quote`.\n */\nconst POSIX_SAFE_ARG_RE = /^[\\w@%+=:,./-]+$/;\n\n/**\n * Matches a literal single quote, for replacing it with the `'\\''` idiom.\n */\nconst SINGLE_QUOTE_RE = /'/g;\n\n/**\n * The replacement for a literal single quote inside a single-quoted POSIX span:\n * close the span, add an escaped literal quote, reopen the span.\n */\nconst POSIX_ESCAPED_SINGLE_QUOTE = '\\'\\\\\\'\\'';\n\n/**\n * Quotes a single argument so that `CommandLineToArgvW` will decode it\n * unchanged. Implements the ArgvQuote algorithm from\n * {@link https://learn.microsoft.com/archive/blogs/twistylittlepassagesallalike/everyone-quotes-command-line-arguments-the-wrong-way | Everyone quotes command line arguments the wrong way}.\n *\n * @param arg - The raw argument string.\n * @returns The quoted argument string.\n */\nfunction argvQuote(arg: string): string {\n  if (arg.length > 0 && !/[\\s\\t\\n\\v\"]/.test(arg)) {\n    return arg;\n  }\n\n  const BACKSLASH_ESCAPE_FACTOR = 2;\n  let result = '\"';\n  for (let i = 0; i < arg.length; i++) {\n    let numBackslashes = 0;\n    while (i < arg.length && arg[i] === '\\\\') {\n      i++;\n      numBackslashes++;\n    }\n\n    if (i === arg.length) {\n      result += '\\\\'.repeat(numBackslashes * BACKSLASH_ESCAPE_FACTOR);\n      break;\n    }\n\n    const ch = arg.charAt(i);\n    if (ch === '\"') {\n      result += `${'\\\\'.repeat(numBackslashes * BACKSLASH_ESCAPE_FACTOR + 1)}\"`;\n    } else {\n      result += '\\\\'.repeat(numBackslashes) + ch;\n    }\n  }\n\n  result += '\"';\n  return result;\n}\n\n/**\n * Quotes a single argument for a POSIX shell so it is passed through verbatim.\n * An empty argument becomes `''`; an argument of only safe characters is\n * returned unchanged; anything else is single-quoted.\n *\n * @param arg - The raw argument string.\n * @returns The quoted argument string.\n */\nfunction posixQuote(arg: string): string {\n  if (POSIX_SAFE_ARG_RE.test(arg)) {\n    return arg;\n  }\n  return `'${replaceAll({ replacer: POSIX_ESCAPED_SINGLE_QUOTE, searchValue: SINGLE_QUOTE_RE, str: arg })}'`;\n}\n\n/**\n * Matches `cmd.exe` metacharacters that must be `^`-escaped.\n */\nconst CMD_META_RE = /[()%!^\"<>&|]/g;\n\n/**\n * Escapes `cmd.exe` metacharacters with `^` so that `cmd.exe` passes them\n * through literally. This is necessary because `cmd.exe`'s `\"` handling\n * differs from `CommandLineToArgvW` and cannot be relied upon.\n *\n * Apply this to a command line string that will be executed via `cmd.exe`\n * (e.g., `spawn(cmd, [], { shell: true })` on Windows).\n *\n * @param commandLine - The already-quoted command line string.\n * @returns The string with all cmd metacharacters `^`-escaped.\n */\nexport function cmdEscapeCommandLine(commandLine: string): string {\n  return replaceAll({\n    replacer: '^$&',\n    searchValue: CMD_META_RE,\n    str: commandLine\n  });\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 * An 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": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/script-utils/cli-utils.ts"],
  "sourcesContent": ["/**\n * @file\n *\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 process from 'node:process';\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 { getDisabledScriptEnvVariableName } from './env-toggle.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   * 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   * Throws an error if the task was not successful.\n   */\n  public throwOnFailure(): void {\n    if (!this.isSuccessful()) {\n      throw new Error('Task failed');\n    }\n  }\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 * 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 * 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 * 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 * using the `CommandLineToArgvW` convention (the standard used by the\n * Microsoft C runtime and most Windows programs).\n *\n * Implements the ArgvQuote algorithm from\n * {@link https://learn.microsoft.com/archive/blogs/twistylittlepassagesallalike/everyone-quotes-command-line-arguments-the-wrong-way | Everyone quotes command line arguments the wrong way}:\n * backslashes before quotes and at the end of a quoted argument are doubled.\n *\n * This produces a shell-agnostic command line. Callers that route through\n * a specific shell (cmd.exe, PowerShell, sh) must apply shell-specific\n * escaping on top \u2014 see {@link cmdEscapeCommandLine}.\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.map((arg) => argvQuote(arg)).join(' ');\n}\n\n/**\n * Converts an array of command-line arguments into a single command-line string\n * quoted for a POSIX shell (`sh`, `bash`, `zsh`, ...).\n *\n * Each argument is wrapped in single quotes unless it consists solely of\n * characters that are safe unquoted, mirroring Python's `shlex.quote`. A literal\n * single quote inside an argument is emitted as the `'\\''` idiom (close the\n * quoted span, add an escaped literal quote, reopen), so the shell reproduces the\n * argument verbatim \u2014 no variable expansion (`$`), command substitution\n * (`` ` ``), globbing (`*`, `?`, `[`), or word splitting.\n *\n * Use this on platforms where the command is executed through `sh -c`. On\n * Windows, use {@link toCommandLine} plus {@link cmdEscapeCommandLine} instead \u2014\n * the two conventions are not interchangeable.\n *\n * @param args - The array of command-line arguments to convert.\n * @returns A string representing the command-line invocation for a POSIX shell.\n */\nexport function toPosixCommandLine(args: string[]): string {\n  return args.map((arg) => posixQuote(arg)).join(' ');\n}\n\n/**\n * Matches an argument that is entirely composed of characters safe to pass to a\n * POSIX shell unquoted. Mirrors the safe set used by Python's `shlex.quote`.\n */\nconst POSIX_SAFE_ARG_RE = /^[\\w@%+=:,./-]+$/;\n\n/**\n * Matches a literal single quote, for replacing it with the `'\\''` idiom.\n */\nconst SINGLE_QUOTE_RE = /'/g;\n\n/**\n * The replacement for a literal single quote inside a single-quoted POSIX span:\n * close the span, add an escaped literal quote, reopen the span.\n */\nconst POSIX_ESCAPED_SINGLE_QUOTE = '\\'\\\\\\'\\'';\n\n/**\n * Quotes a single argument so that `CommandLineToArgvW` will decode it\n * unchanged. Implements the ArgvQuote algorithm from\n * {@link https://learn.microsoft.com/archive/blogs/twistylittlepassagesallalike/everyone-quotes-command-line-arguments-the-wrong-way | Everyone quotes command line arguments the wrong way}.\n *\n * @param arg - The raw argument string.\n * @returns The quoted argument string.\n */\nfunction argvQuote(arg: string): string {\n  if (arg.length > 0 && !/[\\s\\t\\n\\v\"]/.test(arg)) {\n    return arg;\n  }\n\n  const BACKSLASH_ESCAPE_FACTOR = 2;\n  let result = '\"';\n  for (let i = 0; i < arg.length; i++) {\n    let numBackslashes = 0;\n    while (i < arg.length && arg[i] === '\\\\') {\n      i++;\n      numBackslashes++;\n    }\n\n    if (i === arg.length) {\n      result += '\\\\'.repeat(numBackslashes * BACKSLASH_ESCAPE_FACTOR);\n      break;\n    }\n\n    const ch = arg.charAt(i);\n    if (ch === '\"') {\n      result += `${'\\\\'.repeat(numBackslashes * BACKSLASH_ESCAPE_FACTOR + 1)}\"`;\n    } else {\n      result += '\\\\'.repeat(numBackslashes) + ch;\n    }\n  }\n\n  result += '\"';\n  return result;\n}\n\n/**\n * Quotes a single argument for a POSIX shell so it is passed through verbatim.\n * An empty argument becomes `''`; an argument of only safe characters is\n * returned unchanged; anything else is single-quoted.\n *\n * @param arg - The raw argument string.\n * @returns The quoted argument string.\n */\nfunction posixQuote(arg: string): string {\n  if (POSIX_SAFE_ARG_RE.test(arg)) {\n    return arg;\n  }\n  return `'${replaceAll({ replacer: POSIX_ESCAPED_SINGLE_QUOTE, searchValue: SINGLE_QUOTE_RE, str: arg })}'`;\n}\n\n/**\n * Matches `cmd.exe` metacharacters that must be `^`-escaped.\n */\nconst CMD_META_RE = /[()%!^\"<>&|]/g;\n\n/**\n * Escapes `cmd.exe` metacharacters with `^` so that `cmd.exe` passes them\n * through literally. This is necessary because `cmd.exe`'s `\"` handling\n * differs from `CommandLineToArgvW` and cannot be relied upon.\n *\n * Apply this to a command line string that will be executed via `cmd.exe`\n * (e.g., `spawn(cmd, [], { shell: true })` on Windows).\n *\n * @param commandLine - The already-quoted command line string.\n * @returns The string with all cmd metacharacters `^`-escaped.\n */\nexport function cmdEscapeCommandLine(commandLine: string): string {\n  return replaceAll({\n    replacer: '^$&',\n    searchValue: CMD_META_RE,\n    str: commandLine\n  });\n}\n\n/**\n * Wraps a CLI task function to ensure it runs safely and handles its {@link CliTaskResult}.\n *\n * Honors the per-script off switch first: when the npm script currently running has been switched off \u2014\n * `LINT_MD=0 npm run lint:md`, see {@link getDisabledScriptEnvVariableName} \u2014 the task is not executed and\n * the process exits successfully. Because every `scripts/*.ts` entry point already funnels through here, no\n * script has to opt in, and each `npm run` sub-step of a composite script (e.g. `build`) carries its own\n * switch.\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  const disabledScriptEnvVariableName = getDisabledScriptEnvVariableName();\n  if (disabledScriptEnvVariableName !== null) {\n    process.stdout.write(`Skipped (${disabledScriptEnvVariableName} is off).\\n`);\n    CliTaskResult.Success().exit();\n    return;\n  }\n\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 * An 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": "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",
  "names": []
}


package/dist/lib/esm/script-utils/env-toggle.d.mts

@@ -0,0 +1,42 @@
+/// <reference path="../library.d.mts" />
+/**
+ * @file
+ *
+ * Shared environment-variable off switches for the CLI scripts.
+ *
+ * Every npm script can be skipped by setting an environment variable named after it — the script name
+ * uppercased, with every non-alphanumeric character replaced by `_`:
+ *
+ * | Script              | Switch              |
+ * |---------------------|---------------------|
+ * | `lint`              | `LINT=0`            |
+ * | `lint:md:fix`       | `LINT_MD_FIX=0`     |
+ * | `format:check`      | `FORMAT_CHECK=0`    |
+ * | `find-overexposed`  | `FIND_OVEREXPOSED=0`|
+ *
+ * This mirrors the pre-existing `NANO_STAGED=0` / `HUSKY=0` escape hatches, and reuses their notion of an
+ * "off" value, so there is a single answer to what counts as off across the whole tool set.
+ */
+/**
+ * Resolves the off switch for the npm script that is currently running, loading {@link ENV_FILE_PATH} first.
+ *
+ * The script name comes from npm itself, so no script has to declare its own switch. When the script was
+ * started directly rather than through npm, there is no name to derive from and nothing is ever skipped.
+ *
+ * @returns The name of the environment variable that switched the current script off, or `null` when the
+ * script should run.
+ */
+export declare function getDisabledScriptEnvVariableName(): null | string;
+/**
+ * Determines whether the environment variable is set to an off value (`0`, `false`, `no`, or `off`,
+ * case-insensitively and ignoring surrounding whitespace).
+ *
+ * @param envVariableName - The name of the environment variable to inspect.
+ * @returns `true` when the variable is set to an off value, otherwise `false`.
+ */
+export declare function isEnvVariableOff(envVariableName: string): boolean;
+/**
+ * Loads the optional {@link ENV_FILE_PATH} file into `process.env` when it exists, so a developer can park a
+ * switch such as `LINT_MD=0` there instead of prefixing every command.
+ */
+export declare function loadEnvFileIfExists(): void;

package/dist/lib/esm/script-utils/env-toggle.mjs

@@ -0,0 +1,60 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  globalThis.process = browserProcess;
+})();
+
+import { existsSync } from "node:fs";
+import process from "node:process";
+import { replaceAll } from "../string.mjs";
+const OFF_VALUES = /* @__PURE__ */ new Set(["0", "false", "no", "off"]);
+const ENV_FILE_PATH = ".env";
+const NON_ALPHANUMERIC_REG_EXP = /[^a-z0-9]+/gi;
+const NPM_SCRIPT_NAME_ENV_VARIABLE = "npm_lifecycle_event";
+function getDisabledScriptEnvVariableName() {
+  loadEnvFileIfExists();
+  const scriptName = process.env[NPM_SCRIPT_NAME_ENV_VARIABLE];
+  if (!scriptName) {
+    return null;
+  }
+  const envVariableName = toEnvVariableName(scriptName);
+  return isEnvVariableOff(envVariableName) ? envVariableName : null;
+}
+function isEnvVariableOff(envVariableName) {
+  return OFF_VALUES.has((process.env[envVariableName] ?? "").trim().toLowerCase());
+}
+function loadEnvFileIfExists() {
+  if (existsSync(ENV_FILE_PATH)) {
+    process.loadEnvFile(ENV_FILE_PATH);
+  }
+}
+function toEnvVariableName(scriptName) {
+  return replaceAll({
+    replacer: "_",
+    searchValue: NON_ALPHANUMERIC_REG_EXP,
+    str: scriptName
+  }).toUpperCase();
+}
+export {
+  getDisabledScriptEnvVariableName,
+  isEnvVariableOff,
+  loadEnvFileIfExists
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,37 @@
+/// <reference path="../library.d.mts" />
+/**
+ * @file
+ *
+ * Git-derived file listings for the repo-walking scripts.
+ *
+ * Tooling that walks the repository must skip whatever `.gitignore` skips — otherwise every script grows its
+ * own hand-maintained ignore list, the lists drift apart, and a path that is gitignored but not enumerated
+ * (a nested `node_modules` under a test fixture, say) is walked anyway. Most tools have a native switch for
+ * this; the ones that do not take a file list instead, and that is what this module produces.
+ *
+ * Asking git rather than parsing `.gitignore` is deliberate: it honors nested ignore files, `!` negations,
+ * `.git/info/exclude`, and the user's global excludes, at no cost to us.
+ */
+/**
+ * Options for {@link getNonIgnoredFiles}.
+ */
+export interface GetNonIgnoredFilesOptions {
+    /**
+     * Git pathspecs limiting the listing, e.g. `['*.md']`. When omitted, every non-ignored file is listed.
+     *
+     * @default `[]`
+     */
+    readonly patterns?: readonly string[] | undefined;
+}
+/**
+ * Lists the repository files that `.gitignore` does not exclude.
+ *
+ * Covers both tracked files and untracked-but-not-ignored ones, so a brand-new file is checked before it is
+ * ever committed.
+ *
+ * @param options - The {@link GetNonIgnoredFilesOptions}.
+ * @returns A {@link Promise} that resolves with the matching paths, relative to the root folder and
+ * separated by `/`; or with `null` when git cannot answer — it is not installed, or the project is not a
+ * git repository (a tarball checkout, for instance). Callers fall back to their own listing in that case.
+ */
+export declare function getNonIgnoredFiles(options?: GetNonIgnoredFilesOptions): Promise<null | string[]>;

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

@@ -0,0 +1,48 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  globalThis.process = browserProcess;
+})();
+
+import { execFromRoot } from "./root.mjs";
+const NUL_SEPARATOR = "\0";
+async function getNonIgnoredFiles(options) {
+  const { patterns = [] } = options ?? {};
+  const command = [
+    "git",
+    "ls-files",
+    "--cached",
+    "--others",
+    "--exclude-standard",
+    "-z",
+    ...patterns.length > 0 ? ["--", ...patterns] : []
+  ];
+  let stdout;
+  try {
+    stdout = await execFromRoot(command, { isQuiet: true });
+  } catch {
+    return null;
+  }
+  return [...new Set(stdout.split(NUL_SEPARATOR).filter((path) => path !== ""))];
+}
+export {
+  getNonIgnoredFiles
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -7,9 +7,11 @@ export * as 'code-generator' from './code-generator.mjs';
 export * as 'commitlint-config' from './commitlint-config.mjs';
 export * as 'demo-vault-coverage' from './demo-vault-coverage.mjs';
 export * as 'demo-vault' from './demo-vault.mjs';
+export * as 'env-toggle' from './env-toggle.mjs';
 export * as 'exec' from './exec.mjs';
 export * as 'formatters' from './formatters/index.mjs';
 export * as 'fs' from './fs.mjs';
+export * as 'git' from './git.mjs';
 export * as 'json' from './json.mjs';
 export * as 'linters' from './linters/index.mjs';
 export * as 'nano-staged-config' from './nano-staged-config.mjs';

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

@@ -29,9 +29,11 @@ import * as code_generator from "./code-generator.mjs";
 import * as commitlint_config from "./commitlint-config.mjs";
 import * as demo_vault_coverage from "./demo-vault-coverage.mjs";
 import * as demo_vault from "./demo-vault.mjs";
+import * as env_toggle from "./env-toggle.mjs";
 import * as exec from "./exec.mjs";
 import * as formatters from "./formatters/index.mjs";
 import * as fs from "./fs.mjs";
+import * as git from "./git.mjs";
 import * as json from "./json.mjs";
 import * as linters from "./linters/index.mjs";
 import * as nano_staged_config from "./nano-staged-config.mjs";
@@ -53,9 +55,11 @@ export {
   commitlint_config as "commitlint-config",
   demo_vault as "demo-vault",
   demo_vault_coverage as "demo-vault-coverage",
+  env_toggle as "env-toggle",
   exec,
   formatters,
   fs,
+  git,
   json,
   linters,
   nano_staged_config as "nano-staged-config",
@@ -69,4 +73,4 @@ export {
   version,
   warnings_as_errors as "warnings-as-errors"
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/script-utils/linters/cspell.d.mts

@@ -23,6 +23,13 @@ export interface SpellcheckOptions {
  * Uses `--no-must-find-files` so that cspell does not fail when all provided paths
  * are excluded by built-in ignore rules (e.g., `package-lock.json`).
  *
+ * Uses `--gitignore` so a path git ignores is a path cspell skips — generated output, build folders and
+ * every `node_modules` are covered without a hand-maintained `ignorePaths` list that drifts from
+ * `.gitignore`. It is passed on the command line rather than set in `cspell.json` so that every project
+ * consuming this function inherits it, rather than each having to edit its own config. `--gitignore-root`
+ * stops the search at the project root, so a `.gitignore` in some parent folder outside the project cannot
+ * silently remove files from the check.
+ *
  * @param options - The {@link SpellcheckOptions}.
  * @returns A {@link Promise} that resolves to a {@link CliTaskResult}, indicating the success or failure of the spellcheck.
  */

package/dist/lib/esm/script-utils/linters/cspell.mjs

@@ -21,13 +21,25 @@ if you want to view the source, please visit the github repository of this plugi
   globalThis.process = browserProcess;
 })();
 
-import { execFromRoot } from "../root.mjs";
+import {
+  execFromRoot,
+  getRootFolder
+} from "../root.mjs";
 async function spellcheck(options) {
   const { paths } = options ?? {};
   const targets = paths?.length ? paths : ["."];
-  await execFromRoot(["npx", "cspell", "--no-progress", "--no-must-find-files", { batchedArgs: targets }]);
+  const rootFolder = getRootFolder();
+  await execFromRoot([
+    "npx",
+    "cspell",
+    "--no-progress",
+    "--no-must-find-files",
+    "--gitignore",
+    ...rootFolder === null ? [] : ["--gitignore-root", rootFolder],
+    { batchedArgs: targets }
+  ]);
 }
 export {
   spellcheck
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/script-utils/linters/markdownlint-cli2-config.mjs

@@ -45,16 +45,19 @@ const obsidianDevUtilsConfig = {
   customRules: [
     relativeLinksRule
   ],
+  // Every `.gitignore` in the tree, and up to the repository root — git's own default behavior. A path git
+  // Ignores is a path we do not lint, so `node_modules` (including the nested ones under test fixtures),
+  // `dist`, and every generated folder are skipped without anyone maintaining a list that can drift.
+  gitignore: true,
   globs: [
     "**/*.md"
   ],
+  // Git never "ignores" `.git` itself — it is simply outside the working tree — so this one stays explicit.
   ignores: [
-    "**/node_modules/**",
-    ".git/**",
-    "dist/**"
+    ".git/**"
   ]
 };
 export {
   obsidianDevUtilsConfig
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/script-utils/linters/markdownlint.mjs

@@ -35,6 +35,7 @@ import {
   join
 } from "../../path.mjs";
 import { assertNonNullable } from "../../type-guards.mjs";
+import { getNonIgnoredFiles } from "../git.mjs";
 import { ObsidianDevUtilsRepoPaths } from "../obsidian-dev-utils-repo-paths.mjs";
 import {
   execFromRoot,
@@ -71,13 +72,7 @@ async function lint(options) {
   const targets = paths?.length ? paths : [ObsidianPluginRepoPaths.CurrentFolder];
   await execFromRoot(["npx", "markdownlint-cli2", ...shouldFix ? ["--fix"] : [], { batchedArgs: targets }]);
   const rootFolder = getRootFolder() ?? process.cwd();
-  const mdFiles = paths?.length ? paths.map((p) => relative(rootFolder, p).replace(/\\/g, "/") || p) : await toArray(glob(["**/*.md"], {
-    exclude: [
-      ".git/**",
-      "dist/**",
-      "**/node_modules/**"
-    ]
-  }));
+  const mdFiles = paths?.length ? paths.map((p) => relative(rootFolder, p).replace(/\\/g, "/") || p) : await getMarkdownFiles();
   await execFromRoot([
     "npx",
     "linkinator",
@@ -94,7 +89,21 @@ async function lint(options) {
     { batchedArgs: mdFiles }
   ]);
 }
+const MARKDOWN_PATHSPEC = "*.md";
+async function getMarkdownFiles() {
+  const nonIgnoredFiles = await getNonIgnoredFiles({ patterns: [MARKDOWN_PATHSPEC] });
+  if (nonIgnoredFiles) {
+    return nonIgnoredFiles;
+  }
+  return await toArray(glob(["**/*.md"], {
+    exclude: [
+      ".git/**",
+      "dist/**",
+      "**/node_modules/**"
+    ]
+  }));
+}
 export {
   lint
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/script-utils/linters/markdownlint.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Lint markdown documentation using `markdownlint-cli2` and `linkinator`.\n */\n\nimport { existsSync } from 'node:fs';\nimport {\n  cp,\n  glob\n} from 'node:fs/promises';\nimport { relative } from 'node:path';\n\nimport { toArray } from '../../async.ts';\nimport { getLibDebugger } from '../../debug.ts';\nimport { ObsidianPluginRepoPaths } from '../../obsidian/plugin/obsidian-plugin-repo-paths.ts';\nimport {\n  getFolderName,\n  join\n} from '../../path.ts';\nimport { assertNonNullable } from '../../type-guards.ts';\nimport { getNonIgnoredFiles } from '../git.ts';\nimport { ObsidianDevUtilsRepoPaths } from '../obsidian-dev-utils-repo-paths.ts';\nimport {\n  execFromRoot,\n  getRootFolder,\n  resolvePathFromRootSafe\n} from '../root.ts';\n\n/**\n * Parameters for the {@link lint} function.\n */\nexport interface LintOptions {\n  /**\n   * Optional file paths to lint. If omitted, lints the entire project.\n   */\n  readonly paths?: string[] | undefined;\n\n  /**\n   * Whether to fix linting issues automatically.\n   *\n   * @default `false`\n   */\n  readonly shouldFix?: boolean | undefined;\n}\n\n/**\n * Lint markdown documentation using `markdownlint-cli2` and `linkinator`.\n *\n * @param options - The {@link LintOptions}.\n */\nexport async function lint(options?: LintOptions): Promise<void> {\n  const { paths, shouldFix = false } = options ?? {};\n  const configFiles = [\n    ObsidianPluginRepoPaths.MarkdownlintCli2ConfigJsonc,\n    ObsidianPluginRepoPaths.MarkdownlintCli2ConfigYaml,\n    ObsidianPluginRepoPaths.MarkdownlintCli2ConfigCjs,\n    ObsidianPluginRepoPaths.MarkdownlintCli2ConfigMjs,\n    ObsidianPluginRepoPaths.MarkdownlintConfigJsonc,\n    ObsidianPluginRepoPaths.MarkdownlintConfigJson,\n    ObsidianPluginRepoPaths.MarkdownlintConfigYaml,\n    ObsidianPluginRepoPaths.MarkdownlintConfigYml,\n    ObsidianPluginRepoPaths.MarkdownlintConfigCjs,\n    ObsidianPluginRepoPaths.MarkdownlintConfigMjs\n  ];\n\n  const configFileExist = configFiles.some((configFile) => {\n    const configFilePath = resolvePathFromRootSafe({ path: configFile });\n    return existsSync(configFilePath);\n  });\n\n  if (!configFileExist) {\n    getLibDebugger('markdownlint:lint')('markdownlint configuration file not found. Creating default config...');\n    const packageFolder = getRootFolder(getFolderName(import.meta.url));\n    assertNonNullable(packageFolder, 'Package folder not found');\n    await cp(\n      join(packageFolder, ObsidianDevUtilsRepoPaths.DistTemplates, ObsidianDevUtilsRepoPaths.MarkdownlintCli2ConfigMjs),\n      resolvePathFromRootSafe({ path: ObsidianPluginRepoPaths.MarkdownlintCli2ConfigMjs })\n    );\n  }\n\n  /* v8 ignore start -- The paths-provided branches are only exercised by consumer projects passing file lists. */\n  const targets = paths?.length ? paths : [ObsidianPluginRepoPaths.CurrentFolder];\n  /* v8 ignore stop */\n  await execFromRoot(['npx', 'markdownlint-cli2', ...(shouldFix ? ['--fix'] : []), { batchedArgs: targets }]);\n\n  /* v8 ignore start -- The paths-provided branch is only exercised by consumer projects passing file lists. */\n  const rootFolder = getRootFolder() ?? process.cwd();\n  const mdFiles = paths?.length\n    ? paths.map((p) => relative(rootFolder, p).replace(/\\\\/g, '/') || p)\n    : await getMarkdownFiles();\n  /* v8 ignore stop */\n  await execFromRoot([\n    'npx',\n    'linkinator',\n    '--retry',\n    '--retry-errors',\n    '--retry-errors-count',\n    '3',\n    '--retry-errors-jitter',\n    '5',\n    '--url-rewrite-search',\n    'https://www\\\\.npmjs\\\\.com/package/',\n    '--url-rewrite-replace',\n    'https://registry.npmjs.org/',\n    { batchedArgs: mdFiles }\n  ]);\n}\n\n/**\n * The git pathspec matching every markdown file in the repository, at any depth.\n */\nconst MARKDOWN_PATHSPEC = '*.md';\n\n/**\n * Lists the markdown files to hand to `linkinator`.\n *\n * `linkinator` takes a file list rather than an ignore configuration, so the gitignored files have to be\n * dropped before it is invoked. Git itself answers that (nested ignore files, `!` negations and all); the\n * hand-maintained glob exclusions below are only the fallback for a checkout without git, and they are the\n * very lists this indirection exists to stop from drifting.\n *\n * @returns A {@link Promise} that resolves with the markdown file paths, relative to the root folder.\n */\nasync function getMarkdownFiles(): Promise<string[]> {\n  const nonIgnoredFiles = await getNonIgnoredFiles({ patterns: [MARKDOWN_PATHSPEC] });\n  if (nonIgnoredFiles) {\n    return nonIgnoredFiles;\n  }\n\n  return await toArray(glob(['**/*.md'], {\n    exclude: [\n      '.git/**',\n      'dist/**',\n      '**/node_modules/**'\n    ]\n  }));\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAMA,SAAS,kBAAkB;AAC3B;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,gBAAgB;AAEzB,SAAS,eAAe;AACxB,SAAS,sBAAsB;AAC/B,SAAS,+BAA+B;AACxC;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,yBAAyB;AAClC,SAAS,0BAA0B;AACnC,SAAS,iCAAiC;AAC1C;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAwBP,eAAsB,KAAK,SAAsC;AAC/D,QAAM,EAAE,OAAO,YAAY,MAAM,IAAI,WAAW,CAAC;AACjD,QAAM,cAAc;AAAA,IAClB,wBAAwB;AAAA,IACxB,wBAAwB;AAAA,IACxB,wBAAwB;AAAA,IACxB,wBAAwB;AAAA,IACxB,wBAAwB;AAAA,IACxB,wBAAwB;AAAA,IACxB,wBAAwB;AAAA,IACxB,wBAAwB;AAAA,IACxB,wBAAwB;AAAA,IACxB,wBAAwB;AAAA,EAC1B;AAEA,QAAM,kBAAkB,YAAY,KAAK,CAAC,eAAe;AACvD,UAAM,iBAAiB,wBAAwB,EAAE,MAAM,WAAW,CAAC;AACnE,WAAO,WAAW,cAAc;AAAA,EAClC,CAAC;AAED,MAAI,CAAC,iBAAiB;AACpB,mBAAe,mBAAmB,EAAE,uEAAuE;AAC3G,UAAM,gBAAgB,cAAc,cAAc,YAAY,GAAG,CAAC;AAClE,sBAAkB,eAAe,0BAA0B;AAC3D,UAAM;AAAA,MACJ,KAAK,eAAe,0BAA0B,eAAe,0BAA0B,yBAAyB;AAAA,MAChH,wBAAwB,EAAE,MAAM,wBAAwB,0BAA0B,CAAC;AAAA,IACrF;AAAA,EACF;AAGA,QAAM,UAAU,OAAO,SAAS,QAAQ,CAAC,wBAAwB,aAAa;AAE9E,QAAM,aAAa,CAAC,OAAO,qBAAqB,GAAI,YAAY,CAAC,OAAO,IAAI,CAAC,GAAI,EAAE,aAAa,QAAQ,CAAC,CAAC;AAG1G,QAAM,aAAa,cAAc,KAAK,QAAQ,IAAI;AAClD,QAAM,UAAU,OAAO,SACnB,MAAM,IAAI,CAAC,MAAM,SAAS,YAAY,CAAC,EAAE,QAAQ,OAAO,GAAG,KAAK,CAAC,IACjE,MAAM,iBAAiB;AAE3B,QAAM,aAAa;AAAA,IACjB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,EAAE,aAAa,QAAQ;AAAA,EACzB,CAAC;AACH;AAKA,MAAM,oBAAoB;AAY1B,eAAe,mBAAsC;AACnD,QAAM,kBAAkB,MAAM,mBAAmB,EAAE,UAAU,CAAC,iBAAiB,EAAE,CAAC;AAClF,MAAI,iBAAiB;AACnB,WAAO;AAAA,EACT;AAEA,SAAO,MAAM,QAAQ,KAAK,CAAC,SAAS,GAAG;AAAA,IACrC,SAAS;AAAA,MACP;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACF,CAAC,CAAC;AACJ;",
  "names": []
}


package/dist/lib/esm/script-utils/nano-staged-config.d.mts

@@ -16,11 +16,13 @@ export declare const obsidianDevUtilsConfig: Record<string, string[]>;
 /**
  * Resolves the nano-staged configuration to use, honoring a per-developer opt-out.
  *
- * Loads a gitignored `.env` if present (via Node's own `process.loadEnvFile`, so it behaves the same
- * on every platform and shell), then — when `NANO_STAGED` is set to an off value (`0`, `false`, `off`,
- * or `no`) — prints a notice and exits the process successfully so the pre-commit checks are skipped.
- * This mirrors husky's own `HUSKY=0` switch, but scoped to the nano-staged step (so the commit-msg
- * hook still runs). Otherwise it returns {@link obsidianDevUtilsConfig}.
+ * Loads a gitignored `.env` if present, then — when `NANO_STAGED` is set to an off value (`0`, `false`,
+ * `off`, or `no`) — prints a notice and exits the process successfully so the pre-commit checks are
+ * skipped. This mirrors husky's own `HUSKY=0` switch, but scoped to the nano-staged step (so the
+ * commit-msg hook still runs). Otherwise it returns {@link obsidianDevUtilsConfig}.
+ *
+ * `NANO_STAGED` is not an npm script, so it carries its own switch rather than the script-name-derived one
+ * every npm script gets — but both share the same notion of an off value, via {@link isEnvVariableOff}.
  *
  * This is a function rather than module-level code so importing the package barrel never triggers the
  * `.env` read or the process exit; call it from the thin `scripts/nano-staged-config.ts` entry.