@mnaoumov/typescript-dev-toolkit 5.2.0 → 5.4.0

package/dist/lib/cjs/linters/markdownlint.cjs

@@ -64,9 +64,11 @@ var import_debug = require('@mnaoumov/typescript-lib/debug');
 var import_path = require('@mnaoumov/typescript-lib/path');
 var import_node_fs = require('node:fs');
 var import_promises = require('node:fs/promises');
+var import_node_os = require('node:os');
 var import_node_path = require('node:path');
 var import_bulk_concurrency = require('../bulk-concurrency.cjs');
 var import_git = require('../git.cjs');
+var import_link_check_skip = require('../link-check-skip.cjs');
 var import_package_manager = require('../package-manager.cjs');
 var import_repo_paths = require('../repo-paths.cjs');
 var import_root = require('../root.cjs');
@@ -101,6 +103,31 @@ async function lint(options) {
   if (linkCheckFiles.length === 0) {
     return;
   }
+  const skipEntries = (0, import_link_check_skip.readLinkCheckSkipEntries)();
+  const skipConfigFolder = skipEntries.length > 0 ? await writeSkipConfig(skipEntries, linkCheckFiles, rootFolder) : null;
+  try {
+    await runLinkinator(linkCheckFiles, skipConfigFolder);
+  } finally {
+    if (skipConfigFolder !== null) {
+      await (0, import_promises.rm)(skipConfigFolder, { force: true, recursive: true });
+    }
+  }
+}
+const MARKDOWN_PATHSPEC = "*.md";
+const LINK_CHECK_CONCURRENCY = 100;
+const LINK_CHECK_TIMEOUT_IN_MILLISECONDS = 3e4;
+const LINKINATOR_CONFIG_FILE_NAME = "linkinator.config.json";
+async function getMarkdownFiles() {
+  const nonIgnoredFiles = await (0, import_git.getNonIgnoredFiles)({ patterns: [MARKDOWN_PATHSPEC] });
+  return nonIgnoredFiles ? nonIgnoredFiles.filter((path) => !(0, import_markdownlint_ignores.checkIsInNodeModules)(path)) : await (0, import_async.toArray)((0, import_promises.glob)(["**/*.md"], {
+    exclude: [
+      ".git/**",
+      "dist/**",
+      import_markdownlint_ignores.NODE_MODULES_IGNORE_GLOB
+    ]
+  }));
+}
+async function runLinkinator(linkCheckFiles, skipConfigFolder) {
   await (0, import_root.execFromRoot)([
     ...(0, import_package_manager.resolveToolCommand)({ tool: "linkinator" }),
     "--concurrency",
@@ -118,24 +145,26 @@ async function lint(options) {
     String.raw`https://www\.npmjs\.com/package/`,
     "--url-rewrite-replace",
     "https://registry.npmjs.org/",
+    ...skipConfigFolder === null ? [] : ["--config", (0, import_node_path.join)(skipConfigFolder, LINKINATOR_CONFIG_FILE_NAME)],
     { batchedArguments: linkCheckFiles }
   ]);
 }
-const MARKDOWN_PATHSPEC = "*.md";
-const LINK_CHECK_CONCURRENCY = 100;
-const LINK_CHECK_TIMEOUT_IN_MILLISECONDS = 3e4;
-async function getMarkdownFiles() {
-  const nonIgnoredFiles = await (0, import_git.getNonIgnoredFiles)({ patterns: [MARKDOWN_PATHSPEC] });
-  return nonIgnoredFiles ? nonIgnoredFiles.filter((path) => !(0, import_markdownlint_ignores.checkIsInNodeModules)(path)) : await (0, import_async.toArray)((0, import_promises.glob)(["**/*.md"], {
-    exclude: [
-      ".git/**",
-      "dist/**",
-      import_markdownlint_ignores.NODE_MODULES_IGNORE_GLOB
-    ]
-  }));
+async function writeSkipConfig(skipEntries, linkCheckFiles, rootFolder) {
+  const sourceFiles = await Promise.all(linkCheckFiles.map(async (path) => ({
+    content: await (0, import_promises.readFile)((0, import_node_path.resolve)(rootFolder, path), "utf-8"),
+    path
+  })));
+  for (const warning of (0, import_link_check_skip.getLinkCheckSkipWarnings)(skipEntries, sourceFiles)) {
+    console.warn(warning);
+  }
+  const projectConfigPath = (0, import_node_path.resolve)(rootFolder, LINKINATOR_CONFIG_FILE_NAME);
+  const projectConfig = (0, import_node_fs.existsSync)(projectConfigPath) ? JSON.parse(await (0, import_promises.readFile)(projectConfigPath, "utf-8")) : void 0;
+  const skipConfigFolder = await (0, import_promises.mkdtemp)((0, import_node_path.join)((0, import_node_os.tmpdir)(), "link-check-skip-"));
+  await (0, import_promises.writeFile)((0, import_node_path.join)(skipConfigFolder, LINKINATOR_CONFIG_FILE_NAME), JSON.stringify((0, import_link_check_skip.mergeLinkinatorSkipConfig)(projectConfig, skipEntries)));
+  return skipConfigFolder;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   lint
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/linters/markdownlint.ts"],"sourcesContent":["/**\n * @file\n *\n * Lint markdown documentation using `markdownlint-cli2` and `linkinator`.\n */\n\nimport { toArray } from '@mnaoumov/typescript-lib/async';\nimport { getLibDebugger } from '@mnaoumov/typescript-lib/debug';\nimport { basename } from '@mnaoumov/typescript-lib/path';\nimport { existsSync } from 'node:fs';\nimport {\n  cp,\n  glob\n} from 'node:fs/promises';\nimport {\n  matchesGlob,\n  relative\n} from 'node:path';\n\nimport { getBulkConcurrency } from '../bulk-concurrency.ts';\nimport { getNonIgnoredFiles } from '../git.ts';\nimport { resolveToolCommand } from '../package-manager.ts';\nimport { RepoPaths } from '../repo-paths.ts';\nimport {\n  execFromRoot,\n  getRootFolder,\n  resolvePathFromRootSafe\n} from '../root.ts';\nimport {\n  checkIsInNodeModules,\n  NODE_MODULES_IGNORE_GLOB\n} from './markdownlint-ignores.ts';\n\n/**\n * Parameters for the {@link lint} function.\n */\nexport interface LintOptions {\n  /**\n   * The configuration file copied to the project root when the project has none. Without it,\n   * `markdownlint-cli2` runs with its own defaults.\n   */\n  readonly defaultConfigFilePath?: string | undefined;\n\n  /**\n   * Globs, relative to the root folder, of markdown files to leave out of the `linkinator` pass only;\n   * `markdownlint-cli2` still lints them.\n   *\n   * For a documentation site whose pages link to each other base-absolutely (`/<site-base>/guides/...`): those\n   * links resolve only against the BUILT site, so `linkinator` reports each one as a 404, and the site's own\n   * build is what checks them.\n   *\n   * @example `['docs/**']`\n   */\n  readonly linkCheckExcludeGlobs?: readonly string[] | undefined;\n\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 { defaultConfigFilePath, linkCheckExcludeGlobs = [], paths, shouldFix = false } = options ?? {};\n  const configFiles = [\n    RepoPaths.MarkdownlintCli2ConfigJsonc,\n    RepoPaths.MarkdownlintCli2ConfigYaml,\n    RepoPaths.MarkdownlintCli2ConfigCjs,\n    RepoPaths.MarkdownlintCli2ConfigMjs,\n    RepoPaths.MarkdownlintConfigJsonc,\n    RepoPaths.MarkdownlintConfigJson,\n    RepoPaths.MarkdownlintConfigYaml,\n    RepoPaths.MarkdownlintConfigYml,\n    RepoPaths.MarkdownlintConfigCjs,\n    RepoPaths.MarkdownlintConfigMjs\n  ];\n\n  const doesConfigFileExist = configFiles.some((configFile) => {\n    const configFilePath = resolvePathFromRootSafe({ path: configFile });\n    return existsSync(configFilePath);\n  });\n\n  if (!doesConfigFileExist && defaultConfigFilePath) {\n    getLibDebugger('markdownlint:lint')('markdownlint configuration file not found. Creating default config...');\n    await cp(defaultConfigFilePath, resolvePathFromRootSafe({ path: basename(defaultConfigFilePath) }));\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 : [RepoPaths.CurrentFolder];\n  /* v8 ignore stop */\n  await execFromRoot([...resolveToolCommand({ tool: 'markdownlint-cli2' }), ...(shouldFix ? ['--fix'] : []), { batchedArguments: 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).replaceAll('\\\\', '/') || p)\n    : await getMarkdownFiles();\n  /* v8 ignore stop */\n  const linkCheckFiles = mdFiles.filter((mdFile) => linkCheckExcludeGlobs.every((excludeGlob) => !matchesGlob(mdFile, excludeGlob)));\n  // `linkinator` with no LOCATION prints its usage and exits non-zero, so a list emptied by the exclusions has nothing to check.\n  if (linkCheckFiles.length === 0) {\n    return;\n  }\n  // Error retries use millisecond jitter. Omit --retry: its separate Retry-After mode can sleep for thousands\n  // of seconds on a 429 we already accept as a warning. Request timeouts remain errors and keep their retries.\n  await execFromRoot([\n    ...resolveToolCommand({ tool: 'linkinator' }),\n    '--concurrency',\n    String(getBulkConcurrency(LINK_CHECK_CONCURRENCY)),\n    '--timeout',\n    String(LINK_CHECK_TIMEOUT_IN_MILLISECONDS),\n    '--retry-errors',\n    '--retry-errors-count',\n    '3',\n    '--retry-errors-jitter',\n    '5000',\n    '--status-code',\n    '429:warn',\n    '--url-rewrite-search',\n    String.raw`https://www\\.npmjs\\.com/package/`,\n    '--url-rewrite-replace',\n    'https://registry.npmjs.org/',\n    { batchedArguments: linkCheckFiles }\n  ]);\n}\n\n/**\n * The git pathspec matching every markdown file in the repository, at any depth.\n */\nconst MARKDOWN_PATHSPEC = '*.md';\nconst LINK_CHECK_CONCURRENCY = 100;\nconst LINK_CHECK_TIMEOUT_IN_MILLISECONDS = 30_000;\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 * The `node_modules` filter is applied to the git-derived list too, and deliberately so: git only skips\n * what the repository asked it to skip, and a repository can deliberately TRACK a vendored `node_modules`\n * tree. That is the one exclusion `.gitignore` cannot answer — see `markdownlint-ignores.ts`. Applying it\n * here keeps `linkinator` in step with the markdownlint half, which ignores the same paths by glob.\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  return nonIgnoredFiles\n    ? nonIgnoredFiles.filter((path) => !checkIsInNodeModules(path))\n    : (await toArray(glob(['**/*.md'], {\n      exclude: [\n        '.git/**',\n        'dist/**',\n        NODE_MODULES_IGNORE_GLOB\n      ]\n    })));\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,mBAAwB;AACxB,mBAA+B;AAC/B,kBAAyB;AACzB,qBAA2B;AAC3B,sBAGO;AACP,uBAGO;AAEP,8BAAmC;AACnC,iBAAmC;AACnC,6BAAmC;AACnC,wBAA0B;AAC1B,kBAIO;AACP,kCAGO;AA0CP,eAAsB,KAAK,SAAsC;AAC/D,QAAM,EAAE,uBAAuB,wBAAwB,CAAC,GAAG,OAAO,YAAY,MAAM,IAAI,WAAW,CAAC;AACpG,QAAM,cAAc;AAAA,IAClB,4BAAU;AAAA,IACV,4BAAU;AAAA,IACV,4BAAU;AAAA,IACV,4BAAU;AAAA,IACV,4BAAU;AAAA,IACV,4BAAU;AAAA,IACV,4BAAU;AAAA,IACV,4BAAU;AAAA,IACV,4BAAU;AAAA,IACV,4BAAU;AAAA,EACZ;AAEA,QAAM,sBAAsB,YAAY,KAAK,CAAC,eAAe;AAC3D,UAAM,qBAAiB,qCAAwB,EAAE,MAAM,WAAW,CAAC;AACnE,eAAO,2BAAW,cAAc;AAAA,EAClC,CAAC;AAED,MAAI,CAAC,uBAAuB,uBAAuB;AACjD,qCAAe,mBAAmB,EAAE,uEAAuE;AAC3G,cAAM,oBAAG,2BAAuB,qCAAwB,EAAE,UAAM,sBAAS,qBAAqB,EAAE,CAAC,CAAC;AAAA,EACpG;AAGA,QAAM,UAAU,OAAO,SAAS,QAAQ,CAAC,4BAAU,aAAa;AAEhE,YAAM,0BAAa,CAAC,OAAG,2CAAmB,EAAE,MAAM,oBAAoB,CAAC,GAAG,GAAI,YAAY,CAAC,OAAO,IAAI,CAAC,GAAI,EAAE,kBAAkB,QAAQ,CAAC,CAAC;AAGzI,QAAM,iBAAa,2BAAc,KAAK,QAAQ,IAAI;AAClD,QAAM,UAAU,OAAO,SACnB,MAAM,IAAI,CAAC,UAAM,2BAAS,YAAY,CAAC,EAAE,WAAW,MAAM,GAAG,KAAK,CAAC,IACnE,MAAM,iBAAiB;AAE3B,QAAM,iBAAiB,QAAQ,OAAO,CAAC,WAAW,sBAAsB,MAAM,CAAC,gBAAgB,KAAC,8BAAY,QAAQ,WAAW,CAAC,CAAC;AAEjI,MAAI,eAAe,WAAW,GAAG;AAC/B;AAAA,EACF;AAGA,YAAM,0BAAa;AAAA,IACjB,OAAG,2CAAmB,EAAE,MAAM,aAAa,CAAC;AAAA,IAC5C;AAAA,IACA,WAAO,4CAAmB,sBAAsB,CAAC;AAAA,IACjD;AAAA,IACA,OAAO,kCAAkC;AAAA,IACzC;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,OAAO;AAAA,IACP;AAAA,IACA;AAAA,IACA,EAAE,kBAAkB,eAAe;AAAA,EACrC,CAAC;AACH;AAKA,MAAM,oBAAoB;AAC1B,MAAM,yBAAyB;AAC/B,MAAM,qCAAqC;AAiB3C,eAAe,mBAAsC;AACnD,QAAM,kBAAkB,UAAM,+BAAmB,EAAE,UAAU,CAAC,iBAAiB,EAAE,CAAC;AAClF,SAAO,kBACH,gBAAgB,OAAO,CAAC,SAAS,KAAC,kDAAqB,IAAI,CAAC,IAC3D,UAAM,0BAAQ,sBAAK,CAAC,SAAS,GAAG;AAAA,IACjC,SAAS;AAAA,MACP;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACF,CAAC,CAAC;AACN;","names":[]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/linters/markdownlint.ts"],"sourcesContent":["/**\n * @file\n *\n * Lint markdown documentation using `markdownlint-cli2` and `linkinator`.\n */\n\nimport { toArray } from '@mnaoumov/typescript-lib/async';\nimport { getLibDebugger } from '@mnaoumov/typescript-lib/debug';\nimport { basename } from '@mnaoumov/typescript-lib/path';\nimport { existsSync } from 'node:fs';\nimport {\n  cp,\n  glob,\n  mkdtemp,\n  readFile,\n  rm,\n  writeFile\n} from 'node:fs/promises';\nimport { tmpdir } from 'node:os';\nimport {\n  join,\n  matchesGlob,\n  relative,\n  resolve\n} from 'node:path';\n\nimport type { LinkCheckSkipEntry } from '../link-check-skip.ts';\n\nimport { getBulkConcurrency } from '../bulk-concurrency.ts';\nimport { getNonIgnoredFiles } from '../git.ts';\nimport {\n  getLinkCheckSkipWarnings,\n  mergeLinkinatorSkipConfig,\n  readLinkCheckSkipEntries\n} from '../link-check-skip.ts';\nimport { resolveToolCommand } from '../package-manager.ts';\nimport { RepoPaths } from '../repo-paths.ts';\nimport {\n  execFromRoot,\n  getRootFolder,\n  resolvePathFromRootSafe\n} from '../root.ts';\nimport {\n  checkIsInNodeModules,\n  NODE_MODULES_IGNORE_GLOB\n} from './markdownlint-ignores.ts';\n\n/**\n * Parameters for the {@link lint} function.\n */\nexport interface LintOptions {\n  /**\n   * The configuration file copied to the project root when the project has none. Without it,\n   * `markdownlint-cli2` runs with its own defaults.\n   */\n  readonly defaultConfigFilePath?: string | undefined;\n\n  /**\n   * Globs, relative to the root folder, of markdown files to leave out of the `linkinator` pass only;\n   * `markdownlint-cli2` still lints them.\n   *\n   * For a documentation site whose pages link to each other base-absolutely (`/<site-base>/guides/...`): those\n   * links resolve only against the BUILT site, so `linkinator` reports each one as a 404, and the site's own\n   * build is what checks them.\n   *\n   * @example `['docs/**']`\n   */\n  readonly linkCheckExcludeGlobs?: readonly string[] | undefined;\n\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 { defaultConfigFilePath, linkCheckExcludeGlobs = [], paths, shouldFix = false } = options ?? {};\n  const configFiles = [\n    RepoPaths.MarkdownlintCli2ConfigJsonc,\n    RepoPaths.MarkdownlintCli2ConfigYaml,\n    RepoPaths.MarkdownlintCli2ConfigCjs,\n    RepoPaths.MarkdownlintCli2ConfigMjs,\n    RepoPaths.MarkdownlintConfigJsonc,\n    RepoPaths.MarkdownlintConfigJson,\n    RepoPaths.MarkdownlintConfigYaml,\n    RepoPaths.MarkdownlintConfigYml,\n    RepoPaths.MarkdownlintConfigCjs,\n    RepoPaths.MarkdownlintConfigMjs\n  ];\n\n  const doesConfigFileExist = configFiles.some((configFile) => {\n    const configFilePath = resolvePathFromRootSafe({ path: configFile });\n    return existsSync(configFilePath);\n  });\n\n  if (!doesConfigFileExist && defaultConfigFilePath) {\n    getLibDebugger('markdownlint:lint')('markdownlint configuration file not found. Creating default config...');\n    await cp(defaultConfigFilePath, resolvePathFromRootSafe({ path: basename(defaultConfigFilePath) }));\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 : [RepoPaths.CurrentFolder];\n  /* v8 ignore stop */\n  await execFromRoot([...resolveToolCommand({ tool: 'markdownlint-cli2' }), ...(shouldFix ? ['--fix'] : []), { batchedArguments: 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).replaceAll('\\\\', '/') || p)\n    : await getMarkdownFiles();\n  /* v8 ignore stop */\n  const linkCheckFiles = mdFiles.filter((mdFile) => linkCheckExcludeGlobs.every((excludeGlob) => !matchesGlob(mdFile, excludeGlob)));\n  // `linkinator` with no LOCATION prints its usage and exits non-zero, so a list emptied by the exclusions has nothing to check.\n  if (linkCheckFiles.length === 0) {\n    return;\n  }\n  const skipEntries = readLinkCheckSkipEntries();\n  const skipConfigFolder = skipEntries.length > 0 ? await writeSkipConfig(skipEntries, linkCheckFiles, rootFolder) : null;\n  try {\n    await runLinkinator(linkCheckFiles, skipConfigFolder);\n  } finally {\n    if (skipConfigFolder !== null) {\n      await rm(skipConfigFolder, { force: true, recursive: true });\n    }\n  }\n}\n\n/**\n * The git pathspec matching every markdown file in the repository, at any depth.\n */\nconst MARKDOWN_PATHSPEC = '*.md';\nconst LINK_CHECK_CONCURRENCY = 100;\nconst LINK_CHECK_TIMEOUT_IN_MILLISECONDS = 30_000;\nconst LINKINATOR_CONFIG_FILE_NAME = 'linkinator.config.json';\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 * The `node_modules` filter is applied to the git-derived list too, and deliberately so: git only skips\n * what the repository asked it to skip, and a repository can deliberately TRACK a vendored `node_modules`\n * tree. That is the one exclusion `.gitignore` cannot answer — see `markdownlint-ignores.ts`. Applying it\n * here keeps `linkinator` in step with the markdownlint half, which ignores the same paths by glob.\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  return nonIgnoredFiles\n    ? nonIgnoredFiles.filter((path) => !checkIsInNodeModules(path))\n    : (await toArray(glob(['**/*.md'], {\n      exclude: [\n        '.git/**',\n        'dist/**',\n        NODE_MODULES_IGNORE_GLOB\n      ]\n    })));\n}\n\nasync function runLinkinator(linkCheckFiles: string[], skipConfigFolder: null | string): Promise<void> {\n  // Error retries use millisecond jitter. Omit --retry: its separate Retry-After mode can sleep for thousands\n  // of seconds on a 429 we already accept as a warning. Request timeouts remain errors and keep their retries.\n  await execFromRoot([\n    ...resolveToolCommand({ tool: 'linkinator' }),\n    '--concurrency',\n    String(getBulkConcurrency(LINK_CHECK_CONCURRENCY)),\n    '--timeout',\n    String(LINK_CHECK_TIMEOUT_IN_MILLISECONDS),\n    '--retry-errors',\n    '--retry-errors-count',\n    '3',\n    '--retry-errors-jitter',\n    '5000',\n    '--status-code',\n    '429:warn',\n    '--url-rewrite-search',\n    String.raw`https://www\\.npmjs\\.com/package/`,\n    '--url-rewrite-replace',\n    'https://registry.npmjs.org/',\n    ...(skipConfigFolder === null ? [] : ['--config', join(skipConfigFolder, LINKINATOR_CONFIG_FILE_NAME)]),\n    { batchedArguments: linkCheckFiles }\n  ]);\n}\n\n/**\n * Warns about every link the skip entries take out of the check, and writes the `linkinator` config that skips them.\n *\n * @param skipEntries - The skip entries.\n * @param linkCheckFiles - The markdown files handed to `linkinator`, relative to the root folder.\n * @param rootFolder - The root folder.\n * @returns A {@link Promise} that resolves with the temporary folder holding the config; the caller removes it.\n */\nasync function writeSkipConfig(skipEntries: readonly LinkCheckSkipEntry[], linkCheckFiles: readonly string[], rootFolder: string): Promise<string> {\n  const sourceFiles = await Promise.all(linkCheckFiles.map(async (path) => ({\n    content: await readFile(resolve(rootFolder, path), 'utf-8'),\n    path\n  })));\n  for (const warning of getLinkCheckSkipWarnings(skipEntries, sourceFiles)) {\n    console.warn(warning);\n  }\n\n  const projectConfigPath = resolve(rootFolder, LINKINATOR_CONFIG_FILE_NAME);\n  const projectConfig: unknown = existsSync(projectConfigPath) ? JSON.parse(await readFile(projectConfigPath, 'utf-8')) : undefined;\n  const skipConfigFolder = await mkdtemp(join(tmpdir(), 'link-check-skip-'));\n  await writeFile(join(skipConfigFolder, LINKINATOR_CONFIG_FILE_NAME), JSON.stringify(mergeLinkinatorSkipConfig(projectConfig, skipEntries)));\n  return skipConfigFolder;\n}\n"],"mappings":"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","names":[]}

package/dist/lib/esm/index.d.mts

@@ -23,6 +23,7 @@ export * as 'gate' from './gate.mjs';
 export * as 'git' from './git.mjs';
 export * as 'json' from './json.mjs';
 export * as 'library-build' from './library-build.mjs';
+export * as 'link-check-skip' from './link-check-skip.mjs';
 export * as 'linters' from './linters/index.mjs';
 export * as 'nano-staged-config' from './nano-staged-config.mjs';
 export * as 'npm-publish' from './npm-publish.mjs';

package/dist/lib/esm/index.mjs

@@ -23,6 +23,7 @@ import * as gate from "./gate.mjs";
 import * as git from "./git.mjs";
 import * as json from "./json.mjs";
 import * as library_build from "./library-build.mjs";
+import * as link_check_skip from "./link-check-skip.mjs";
 import * as linters from "./linters/index.mjs";
 import * as nano_staged_config from "./nano-staged-config.mjs";
 import * as npm_publish from "./npm-publish.mjs";
@@ -61,6 +62,7 @@ export {
   git,
   json,
   library_build as "library-build",
+  link_check_skip as "link-check-skip",
   linters,
   nano_staged_config as "nano-staged-config",
   npm,
@@ -79,4 +81,4 @@ export {
   validate_dependencies as "validate-dependencies",
   version
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/link-check-skip.d.mts

@@ -0,0 +1,109 @@
+/// <reference path="./library-references.d.mts" />
+/**
+ * @file
+ *
+ * Links the markdown link check leaves unchecked for one run, named by the {@link LINK_CHECK_SKIP_ENV_VARIABLE}
+ * environment variable.
+ *
+ * Two cases need it: a host the current network cannot reach although it is up (a provider blocking it), and a
+ * release whose documentation links to something only that same release pushes. Both are temporary, so the
+ * variable belongs on the one command that needs it, never in `.env`: a skip left in place lets a link go stale
+ * with nothing to say so. It is read like every other variable here, `.env` included, and every skipped link,
+ * like every entry that skipped nothing, prints a warning, so a skip is never silent.
+ *
+ * Entries are comma-separated. An entry holding `://` is a URL prefix and matches every link starting with it; any
+ * other entry is a host and matches the links to exactly that host (`mail.tm` does not match `docs.mail.tm`).
+ */
+/**
+ * The environment variable naming the links to skip.
+ */
+export declare const LINK_CHECK_SKIP_ENV_VARIABLE = "LINK_CHECK_SKIP";
+/**
+ * One entry of {@link LINK_CHECK_SKIP_ENV_VARIABLE}.
+ */
+export interface LinkCheckSkipEntry {
+    /**
+     * `host` matches links to exactly that host; `prefix` matches links starting with {@link value}.
+     */
+    readonly kind: 'host' | 'prefix';
+    /**
+     * The entry as written, a host lowercased.
+     */
+    readonly value: string;
+}
+/**
+ * The text of one markdown file the link check reads.
+ */
+export interface LinkCheckSourceFile {
+    /**
+     * The file's content.
+     */
+    readonly content: string;
+    /**
+     * The file's path, as the warnings name it.
+     */
+    readonly path: string;
+}
+/**
+ * Tells whether an entry matches a URL.
+ *
+ * @param url - The URL.
+ * @param entry - The entry.
+ * @returns `true` when a `prefix` entry starts the URL, or a `host` entry is exactly the URL's host.
+ */
+export declare function doesLinkCheckSkipEntryMatch(url: string, entry: LinkCheckSkipEntry): boolean;
+/**
+ * Finds the absolute `http`/`https` URLs written in a text.
+ *
+ * It is a textual scan, so it also finds a URL inside a code span, which `linkinator` does not check.
+ *
+ * @param text - The text to scan.
+ * @returns The URLs, in order of appearance, trailing punctuation dropped.
+ */
+export declare function extractUrls(text: string): string[];
+/**
+ * Builds the warnings for a run with skip entries: one per distinct link each file loses to an entry, and one per
+ * entry that matched no link at all.
+ *
+ * @param entries - The entries, as {@link parseLinkCheckSkipEntries} returned them.
+ * @param files - The markdown files the link check is handed.
+ * @returns The warning lines, without a trailing newline.
+ */
+export declare function getLinkCheckSkipWarnings(entries: readonly LinkCheckSkipEntry[], files: readonly LinkCheckSourceFile[]): string[];
+/**
+ * Adds the entries to a `linkinator` config, keeping whatever the project's own config already skips.
+ *
+ * The skip list goes to `linkinator` as a config file because `--config` replaces the project's
+ * `linkinator.config.json` rather than adding to it, so the project's settings have to be carried over.
+ *
+ * @param projectConfig - The parsed project `linkinator.config.json`, or `undefined` when there is none.
+ * @param entries - The entries.
+ * @returns The config to write.
+ * @throws If the project config is not a JSON object.
+ */
+export declare function mergeLinkinatorSkipConfig(projectConfig: unknown, entries: readonly LinkCheckSkipEntry[]): Record<string, unknown>;
+/**
+ * Parses the value of {@link LINK_CHECK_SKIP_ENV_VARIABLE}.
+ *
+ * @param value - The comma-separated value; blank entries are ignored.
+ * @returns The entries.
+ * @throws If an entry is neither a URL prefix nor a host name.
+ */
+export declare function parseLinkCheckSkipEntries(value: string): LinkCheckSkipEntry[];
+/**
+ * Reads the entries of {@link LINK_CHECK_SKIP_ENV_VARIABLE}, loading the optional `.env` first.
+ *
+ * @returns The entries; none when the variable is unset or blank.
+ */
+export declare function readLinkCheckSkipEntries(): LinkCheckSkipEntry[];
+/**
+ * Converts an entry into a regular expression for the `skip` list of a `linkinator` config file.
+ *
+ * Never pass it as a `--skip` argument: on Windows the command line passes through the `npx` and `.bin` shims,
+ * which re-expand it unquoted, so the `|` in it pipes into a command named by what follows.
+ *
+ * @param entry - The entry.
+ * @returns The regular expression source: an anchored prefix, or the scheme, optional credentials, the host and an
+ * optional port followed by the end of the authority.
+ */
+export declare function toLinkinatorSkipPattern(entry: LinkCheckSkipEntry): string;

package/dist/lib/esm/link-check-skip.mjs

@@ -0,0 +1,125 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+(function () {
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+ensureBrowserProcess();
+})();
+
+import { escapeRegExp } from "@mnaoumov/typescript-lib/reg-exp";
+import process from "node:process";
+import { loadEnvFileIfExists } from "./env-toggle.mjs";
+const LINK_CHECK_SKIP_ENV_VARIABLE = "LINK_CHECK_SKIP";
+const HOST_REG_EXP = /^[a-z\d-]+(?:\.[a-z\d-]+)*$/i;
+const URL_REG_EXP = /\bhttps?:\/\/[^\s<>()[\]{}"'`]+/gi;
+const URL_TRAILING_PUNCTUATION_REG_EXP = /[.,;:!?*_~]+$/;
+function doesLinkCheckSkipEntryMatch(url, entry) {
+  return entry.kind === "prefix" ? url.startsWith(entry.value) : URL.parse(url)?.hostname === entry.value;
+}
+function extractUrls(text) {
+  return Array.from(text.matchAll(URL_REG_EXP), (match) => match[0].replace(URL_TRAILING_PUNCTUATION_REG_EXP, ""));
+}
+function getLinkCheckSkipWarnings(entries, files) {
+  const warnings = [];
+  const usedEntries = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    for (const url of new Set(extractUrls(file.content))) {
+      const entry = entries.find((candidate) => doesLinkCheckSkipEntryMatch(url, candidate));
+      if (!entry) {
+        continue;
+      }
+      usedEntries.add(entry);
+      warnings.push(`WARNING: ${LINK_CHECK_SKIP_ENV_VARIABLE} skips ${url} in ${file.path} (entry ${entry.value}).`);
+    }
+  }
+  for (const entry of entries) {
+    if (!usedEntries.has(entry)) {
+      warnings.push(`WARNING: ${LINK_CHECK_SKIP_ENV_VARIABLE} entry ${entry.value} matched no link; remove it.`);
+    }
+  }
+  if (entries.length > 0) {
+    warnings.push(
+      `WARNING: ${LINK_CHECK_SKIP_ENV_VARIABLE} is set. Set it for one command only, never in .env: a lasting skip lets links go stale unnoticed.`
+    );
+  }
+  return warnings;
+}
+function mergeLinkinatorSkipConfig(projectConfig, entries) {
+  const config = projectConfig ?? {};
+  if (typeof config !== "object" || Array.isArray(config)) {
+    throw new TypeError("The project linkinator.config.json is not a JSON object.");
+  }
+  const record = config;
+  const projectSkip = record["skip"];
+  const existingSkip = projectSkip === void 0 ? [] : [projectSkip].flat();
+  return { ...record, skip: [...existingSkip, ...entries.map((entry) => toLinkinatorSkipPattern(entry))] };
+}
+function parseLinkCheckSkipEntries(value) {
+  const entries = [];
+  for (const rawEntry of value.split(",")) {
+    const entry = rawEntry.trim();
+    if (entry === "") {
+      continue;
+    }
+    if (entry.includes("://")) {
+      entries.push({ kind: "prefix", value: entry });
+      continue;
+    }
+    if (!HOST_REG_EXP.test(entry)) {
+      throw new Error(`${LINK_CHECK_SKIP_ENV_VARIABLE} entry ${entry} is neither a host name nor a URL prefix (one holding ://).`);
+    }
+    entries.push({ kind: "host", value: entry.toLowerCase() });
+  }
+  return entries;
+}
+function readLinkCheckSkipEntries() {
+  loadEnvFileIfExists();
+  return parseLinkCheckSkipEntries(process.env[LINK_CHECK_SKIP_ENV_VARIABLE] ?? "");
+}
+function toLinkinatorSkipPattern(entry) {
+  if (entry.kind === "prefix") {
+    return `^${escapeRegExp(entry.value)}`;
+  }
+  return String.raw`^https?://(?:[^/?#@]*@)?${escapeRegExp(entry.value)}(?::\d+)?(?:[/?#]|$)`;
+}
+export {
+  LINK_CHECK_SKIP_ENV_VARIABLE,
+  doesLinkCheckSkipEntryMatch,
+  extractUrls,
+  getLinkCheckSkipWarnings,
+  mergeLinkinatorSkipConfig,
+  parseLinkCheckSkipEntries,
+  readLinkCheckSkipEntries,
+  toLinkinatorSkipPattern
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/link-check-skip.ts"],"sourcesContent":["/**\n * @file\n *\n * Links the markdown link check leaves unchecked for one run, named by the {@link LINK_CHECK_SKIP_ENV_VARIABLE}\n * environment variable.\n *\n * Two cases need it: a host the current network cannot reach although it is up (a provider blocking it), and a\n * release whose documentation links to something only that same release pushes. Both are temporary, so the\n * variable belongs on the one command that needs it, never in `.env`: a skip left in place lets a link go stale\n * with nothing to say so. It is read like every other variable here, `.env` included, and every skipped link,\n * like every entry that skipped nothing, prints a warning, so a skip is never silent.\n *\n * Entries are comma-separated. An entry holding `://` is a URL prefix and matches every link starting with it; any\n * other entry is a host and matches the links to exactly that host (`mail.tm` does not match `docs.mail.tm`).\n */\n\nimport { escapeRegExp } from '@mnaoumov/typescript-lib/reg-exp';\nimport process from 'node:process';\n\nimport { loadEnvFileIfExists } from './env-toggle.ts';\n\n/**\n * The environment variable naming the links to skip.\n */\nexport const LINK_CHECK_SKIP_ENV_VARIABLE = 'LINK_CHECK_SKIP';\n\n/**\n * One entry of {@link LINK_CHECK_SKIP_ENV_VARIABLE}.\n */\nexport interface LinkCheckSkipEntry {\n  /**\n   * `host` matches links to exactly that host; `prefix` matches links starting with {@link value}.\n   */\n  readonly kind: 'host' | 'prefix';\n\n  /**\n   * The entry as written, a host lowercased.\n   */\n  readonly value: string;\n}\n\n/**\n * The text of one markdown file the link check reads.\n */\nexport interface LinkCheckSourceFile {\n  /**\n   * The file's content.\n   */\n  readonly content: string;\n\n  /**\n   * The file's path, as the warnings name it.\n   */\n  readonly path: string;\n}\n\nconst HOST_REG_EXP = /^[a-z\\d-]+(?:\\.[a-z\\d-]+)*$/i;\nconst URL_REG_EXP = /\\bhttps?:\\/\\/[^\\s<>()[\\]{}\"'`]+/gi;\nconst URL_TRAILING_PUNCTUATION_REG_EXP = /[.,;:!?*_~]+$/;\n\n/**\n * Tells whether an entry matches a URL.\n *\n * @param url - The URL.\n * @param entry - The entry.\n * @returns `true` when a `prefix` entry starts the URL, or a `host` entry is exactly the URL's host.\n */\nexport function doesLinkCheckSkipEntryMatch(url: string, entry: LinkCheckSkipEntry): boolean {\n  return entry.kind === 'prefix' ? url.startsWith(entry.value) : URL.parse(url)?.hostname === entry.value;\n}\n\n/**\n * Finds the absolute `http`/`https` URLs written in a text.\n *\n * It is a textual scan, so it also finds a URL inside a code span, which `linkinator` does not check.\n *\n * @param text - The text to scan.\n * @returns The URLs, in order of appearance, trailing punctuation dropped.\n */\nexport function extractUrls(text: string): string[] {\n  return Array.from(text.matchAll(URL_REG_EXP), (match) => match[0].replace(URL_TRAILING_PUNCTUATION_REG_EXP, ''));\n}\n\n/**\n * Builds the warnings for a run with skip entries: one per distinct link each file loses to an entry, and one per\n * entry that matched no link at all.\n *\n * @param entries - The entries, as {@link parseLinkCheckSkipEntries} returned them.\n * @param files - The markdown files the link check is handed.\n * @returns The warning lines, without a trailing newline.\n */\nexport function getLinkCheckSkipWarnings(entries: readonly LinkCheckSkipEntry[], files: readonly LinkCheckSourceFile[]): string[] {\n  const warnings: string[] = [];\n  const usedEntries = new Set<LinkCheckSkipEntry>();\n\n  for (const file of files) {\n    for (const url of new Set(extractUrls(file.content))) {\n      const entry = entries.find((candidate) => doesLinkCheckSkipEntryMatch(url, candidate));\n      if (!entry) {\n        continue;\n      }\n\n      usedEntries.add(entry);\n      warnings.push(`WARNING: ${LINK_CHECK_SKIP_ENV_VARIABLE} skips ${url} in ${file.path} (entry ${entry.value}).`);\n    }\n  }\n\n  for (const entry of entries) {\n    if (!usedEntries.has(entry)) {\n      warnings.push(`WARNING: ${LINK_CHECK_SKIP_ENV_VARIABLE} entry ${entry.value} matched no link; remove it.`);\n    }\n  }\n\n  if (entries.length > 0) {\n    warnings.push(\n      `WARNING: ${LINK_CHECK_SKIP_ENV_VARIABLE} is set. Set it for one command only, never in .env: a lasting skip lets links go stale unnoticed.`\n    );\n  }\n\n  return warnings;\n}\n\n/**\n * Adds the entries to a `linkinator` config, keeping whatever the project's own config already skips.\n *\n * The skip list goes to `linkinator` as a config file because `--config` replaces the project's\n * `linkinator.config.json` rather than adding to it, so the project's settings have to be carried over.\n *\n * @param projectConfig - The parsed project `linkinator.config.json`, or `undefined` when there is none.\n * @param entries - The entries.\n * @returns The config to write.\n * @throws If the project config is not a JSON object.\n */\nexport function mergeLinkinatorSkipConfig(projectConfig: unknown, entries: readonly LinkCheckSkipEntry[]): Record<string, unknown> {\n  const config = projectConfig ?? {};\n  if (typeof config !== 'object' || Array.isArray(config)) {\n    throw new TypeError('The project linkinator.config.json is not a JSON object.');\n  }\n\n  const record = config as Record<string, unknown>;\n  const projectSkip = record['skip'];\n  const existingSkip = projectSkip === undefined ? [] : [projectSkip].flat();\n  return { ...record, skip: [...existingSkip, ...entries.map((entry) => toLinkinatorSkipPattern(entry))] };\n}\n\n/**\n * Parses the value of {@link LINK_CHECK_SKIP_ENV_VARIABLE}.\n *\n * @param value - The comma-separated value; blank entries are ignored.\n * @returns The entries.\n * @throws If an entry is neither a URL prefix nor a host name.\n */\nexport function parseLinkCheckSkipEntries(value: string): LinkCheckSkipEntry[] {\n  const entries: LinkCheckSkipEntry[] = [];\n\n  for (const rawEntry of value.split(',')) {\n    const entry = rawEntry.trim();\n    if (entry === '') {\n      continue;\n    }\n\n    if (entry.includes('://')) {\n      entries.push({ kind: 'prefix', value: entry });\n      continue;\n    }\n\n    if (!HOST_REG_EXP.test(entry)) {\n      throw new Error(`${LINK_CHECK_SKIP_ENV_VARIABLE} entry ${entry} is neither a host name nor a URL prefix (one holding ://).`);\n    }\n\n    entries.push({ kind: 'host', value: entry.toLowerCase() });\n  }\n\n  return entries;\n}\n\n/**\n * Reads the entries of {@link LINK_CHECK_SKIP_ENV_VARIABLE}, loading the optional `.env` first.\n *\n * @returns The entries; none when the variable is unset or blank.\n */\nexport function readLinkCheckSkipEntries(): LinkCheckSkipEntry[] {\n  loadEnvFileIfExists();\n  return parseLinkCheckSkipEntries(process.env[LINK_CHECK_SKIP_ENV_VARIABLE] ?? '');\n}\n\n/**\n * Converts an entry into a regular expression for the `skip` list of a `linkinator` config file.\n *\n * Never pass it as a `--skip` argument: on Windows the command line passes through the `npx` and `.bin` shims,\n * which re-expand it unquoted, so the `|` in it pipes into a command named by what follows.\n *\n * @param entry - The entry.\n * @returns The regular expression source: an anchored prefix, or the scheme, optional credentials, the host and an\n * optional port followed by the end of the authority.\n */\nexport function toLinkinatorSkipPattern(entry: LinkCheckSkipEntry): string {\n  if (entry.kind === 'prefix') {\n    return `^${escapeRegExp(entry.value)}`;\n  }\n\n  // `linkinator` matches the URL it has normalized, whose scheme and host are lowercase already.\n  return String.raw`^https?://(?:[^/?#@]*@)?${escapeRegExp(entry.value)}(?::\\d+)?(?:[/?#]|$)`;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgBA,SAAS,oBAAoB;AAC7B,OAAO,aAAa;AAEpB,SAAS,2BAA2B;AAK7B,MAAM,+BAA+B;AAgC5C,MAAM,eAAe;AACrB,MAAM,cAAc;AACpB,MAAM,mCAAmC;AASlC,SAAS,4BAA4B,KAAa,OAAoC;AAC3F,SAAO,MAAM,SAAS,WAAW,IAAI,WAAW,MAAM,KAAK,IAAI,IAAI,MAAM,GAAG,GAAG,aAAa,MAAM;AACpG;AAUO,SAAS,YAAY,MAAwB;AAClD,SAAO,MAAM,KAAK,KAAK,SAAS,WAAW,GAAG,CAAC,UAAU,MAAM,CAAC,EAAE,QAAQ,kCAAkC,EAAE,CAAC;AACjH;AAUO,SAAS,yBAAyB,SAAwC,OAAiD;AAChI,QAAM,WAAqB,CAAC;AAC5B,QAAM,cAAc,oBAAI,IAAwB;AAEhD,aAAW,QAAQ,OAAO;AACxB,eAAW,OAAO,IAAI,IAAI,YAAY,KAAK,OAAO,CAAC,GAAG;AACpD,YAAM,QAAQ,QAAQ,KAAK,CAAC,cAAc,4BAA4B,KAAK,SAAS,CAAC;AACrF,UAAI,CAAC,OAAO;AACV;AAAA,MACF;AAEA,kBAAY,IAAI,KAAK;AACrB,eAAS,KAAK,YAAY,4BAA4B,UAAU,GAAG,OAAO,KAAK,IAAI,WAAW,MAAM,KAAK,IAAI;AAAA,IAC/G;AAAA,EACF;AAEA,aAAW,SAAS,SAAS;AAC3B,QAAI,CAAC,YAAY,IAAI,KAAK,GAAG;AAC3B,eAAS,KAAK,YAAY,4BAA4B,UAAU,MAAM,KAAK,8BAA8B;AAAA,IAC3G;AAAA,EACF;AAEA,MAAI,QAAQ,SAAS,GAAG;AACtB,aAAS;AAAA,MACP,YAAY,4BAA4B;AAAA,IAC1C;AAAA,EACF;AAEA,SAAO;AACT;AAaO,SAAS,0BAA0B,eAAwB,SAAiE;AACjI,QAAM,SAAS,iBAAiB,CAAC;AACjC,MAAI,OAAO,WAAW,YAAY,MAAM,QAAQ,MAAM,GAAG;AACvD,UAAM,IAAI,UAAU,0DAA0D;AAAA,EAChF;AAEA,QAAM,SAAS;AACf,QAAM,cAAc,OAAO,MAAM;AACjC,QAAM,eAAe,gBAAgB,SAAY,CAAC,IAAI,CAAC,WAAW,EAAE,KAAK;AACzE,SAAO,EAAE,GAAG,QAAQ,MAAM,CAAC,GAAG,cAAc,GAAG,QAAQ,IAAI,CAAC,UAAU,wBAAwB,KAAK,CAAC,CAAC,EAAE;AACzG;AASO,SAAS,0BAA0B,OAAqC;AAC7E,QAAM,UAAgC,CAAC;AAEvC,aAAW,YAAY,MAAM,MAAM,GAAG,GAAG;AACvC,UAAM,QAAQ,SAAS,KAAK;AAC5B,QAAI,UAAU,IAAI;AAChB;AAAA,IACF;AAEA,QAAI,MAAM,SAAS,KAAK,GAAG;AACzB,cAAQ,KAAK,EAAE,MAAM,UAAU,OAAO,MAAM,CAAC;AAC7C;AAAA,IACF;AAEA,QAAI,CAAC,aAAa,KAAK,KAAK,GAAG;AAC7B,YAAM,IAAI,MAAM,GAAG,4BAA4B,UAAU,KAAK,6DAA6D;AAAA,IAC7H;AAEA,YAAQ,KAAK,EAAE,MAAM,QAAQ,OAAO,MAAM,YAAY,EAAE,CAAC;AAAA,EAC3D;AAEA,SAAO;AACT;AAOO,SAAS,2BAAiD;AAC/D,sBAAoB;AACpB,SAAO,0BAA0B,QAAQ,IAAI,4BAA4B,KAAK,EAAE;AAClF;AAYO,SAAS,wBAAwB,OAAmC;AACzE,MAAI,MAAM,SAAS,UAAU;AAC3B,WAAO,IAAI,aAAa,MAAM,KAAK,CAAC;AAAA,EACtC;AAGA,SAAO,OAAO,8BAA8B,aAAa,MAAM,KAAK,CAAC;AACvE;","names":[]}

package/dist/lib/esm/linters/eslint-rules/prefer-dedent.d.mts

@@ -8,3 +8,14 @@ export declare const MESSAGE_ID = "preferDedent";
  * ESLint rule preferring a `dedent` template over an array of string literals joined with a newline.
  */
 export declare const preferDedent: Rule.RuleModule;
+/**
+ * Options of the `prefer-dedent` rule.
+ */
+export interface PreferDedentOptions {
+    /**
+     * Names of functions whose callback arguments run where the module's imports are not in scope. A join inside a
+     * function nested in the arguments of a call to one of them is not reported. A name matches a bare callee
+     * (`evalInObsidian(...)`) and the property of a member callee (`helpers.evalInObsidian(...)`).
+     */
+    readonly ignoreInsideCallsTo?: readonly string[];
+}

package/dist/lib/esm/linters/eslint-rules/prefer-dedent.mjs

@@ -45,17 +45,24 @@ import {
 } from "./import-fix.mjs";
 import { toTSESTreeNode } from "./ts-estree-node.mjs";
 const DEDENT_MODULE = "dedent";
+const FUNCTION_NODE_TYPES = /* @__PURE__ */ new Set([
+  AST_NODE_TYPES.ArrowFunctionExpression,
+  AST_NODE_TYPES.FunctionDeclaration,
+  AST_NODE_TYPES.FunctionExpression
+]);
 const INDENT = "  ";
 const LINE_BREAK_SEPARATORS = /* @__PURE__ */ new Set(["\n", "\r\n"]);
 const MINIMUM_ELEMENTS_WITH_A_LINE_BREAK = 2;
 const MESSAGE_ID = "preferDedent";
 const preferDedent = {
   create(context) {
+    const options = context.options[0] ?? {};
+    const ignoredCalleeNames = new Set(options.ignoreInsideCallsTo);
     return {
       "CallExpression"(node) {
         const callNode = toTSESTreeNode(node);
         const joined = getJoinedStringElements(callNode);
-        if (!joined) {
+        if (!joined || isInsideIgnoredCallback(callNode, ignoredCalleeNames)) {
           return;
         }
         context.report({
@@ -100,7 +107,19 @@ ${lineIndent}\``));
     messages: {
       [MESSAGE_ID]: "Write this multiline string as a `dedent` template instead of joining an array of string literals with a newline."
     },
-    schema: [],
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          ignoreInsideCallsTo: {
+            items: { type: "string" },
+            type: "array",
+            uniqueItems: true
+          }
+        },
+        type: "object"
+      }
+    ],
     type: "suggestion"
   }
 };
@@ -110,6 +129,12 @@ function escapeLineBreaks(text) {
 function escapeTemplateText(text) {
   return text.replaceAll("`", "\\`").replaceAll("${", "\\${").replaceAll("\r", String.raw`\r`);
 }
+function getCalleeName(callee) {
+  if (callee.type === AST_NODE_TYPES.Identifier) {
+    return callee.name;
+  }
+  return callee.type === AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES.Identifier ? callee.property.name : null;
+}
 function getJoinedStringElements(node) {
   const callee = node.callee;
   if (node.optional || node.arguments.length !== 1 || callee.type !== AST_NODE_TYPES.MemberExpression || callee.optional || callee.computed || callee.property.type !== AST_NODE_TYPES.Identifier || callee.property.name !== "join" || callee.object.type !== AST_NODE_TYPES.ArrayExpression) {
@@ -145,6 +170,24 @@ function getStaticString(node) {
   }
   return node.type === AST_NODE_TYPES.TemplateLiteral && node.expressions.length === 0 ? ensureNonNullable(node.quasis[0]).value.cooked : null;
 }
+function isInsideIgnoredCallback(node, ignoredCalleeNames) {
+  if (ignoredCalleeNames.size === 0) {
+    return false;
+  }
+  let isInsideFunction = false;
+  let child = node;
+  for (let parent = node.parent; parent; child = parent, parent = parent.parent) {
+    if (FUNCTION_NODE_TYPES.has(parent.type)) {
+      isInsideFunction = true;
+    } else if (isInsideFunction && parent.type === AST_NODE_TYPES.CallExpression && parent.callee !== child) {
+      const name = getCalleeName(parent.callee);
+      if (name !== null && ignoredCalleeNames.has(name)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
 function isStringElement(element) {
   return element?.type === AST_NODE_TYPES.TemplateLiteral || element?.type === AST_NODE_TYPES.Literal && typeof element.value === "string";
 }
@@ -165,4 +208,4 @@ export {
   MESSAGE_ID,
   preferDedent
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../src/linters/eslint-rules/prefer-dedent.ts"],"sourcesContent":["/**\n * @file\n *\n * ESLint rule: prefer-dedent\n *\n * Reports an array of string literals joined with a newline (`['a', 'b'].join('\\n')`) and fixes it to a `dedent`\n * template. An array holding anything but string and template literals is left alone: it builds a string at runtime.\n *\n * The fix rewrites the joined text so that `dedent` (1.x, used as a tag) returns exactly the same string. It runs the\n * same steps `dedent` does in reverse: a leading or trailing run of line breaks and every carriage return become\n * `\\n` / `\\r` escapes, which `dedent` decodes only after it trims, and backticks and `${` are escaped. Text it cannot\n * represent that way keeps the diagnostic without a fix: a backslash, which `dedent` passes on raw; leading or trailing\n * whitespace that `dedent` would trim; a template literal with expressions, whose values are unknown; and comments\n * inside the call. The fix reuses a visible default import of `dedent`, or adds one under a free name.\n */\nimport type { TSESTree } from '@typescript-eslint/utils';\nimport type { Rule } from 'eslint';\n\nimport { ensureNonNullable } from '@mnaoumov/typescript-lib/type-guards';\nimport { AST_NODE_TYPES } from '@typescript-eslint/utils';\n\nimport {\n  findVisibleImportName,\n  getUnusedName,\n  insertImport\n} from './import-fix.ts';\nimport { toTSESTreeNode } from './ts-estree-node.ts';\n\nconst DEDENT_MODULE = 'dedent';\nconst INDENT = '  ';\nconst LINE_BREAK_SEPARATORS = new Set(['\\n', '\\r\\n']);\nconst MINIMUM_ELEMENTS_WITH_A_LINE_BREAK = 2;\n\n/**\n * Message ID reported when an array of string literals is joined with a newline instead of written as a `dedent` template.\n */\nexport const MESSAGE_ID = 'preferDedent';\n\ntype StringElement = TSESTree.StringLiteral | TSESTree.TemplateLiteral;\n\n/**\n * ESLint rule preferring a `dedent` template over an array of string literals joined with a newline.\n */\nexport const preferDedent: Rule.RuleModule = {\n  create(context) {\n    return {\n      'CallExpression'(node: Rule.Node): void {\n        const callNode = toTSESTreeNode(node) as TSESTree.CallExpression;\n        const joined = getJoinedStringElements(callNode);\n        if (!joined) {\n          return;\n        }\n\n        context.report({\n          fix(fixer) {\n            const sourceCode = context.sourceCode;\n            if (sourceCode.getCommentsInside(node).length > 0) {\n              return null;\n            }\n            const text = getJoinedText(joined.elements, joined.separator);\n            const lines = text === null ? null : toDedentLines(text);\n            if (lines === null) {\n              return null;\n            }\n\n            const fixes: Rule.Fix[] = [];\n            let name = findVisibleImportName({ importedName: 'default', moduleName: DEDENT_MODULE, node, sourceCode });\n            if (name === null) {\n              // A script cannot accept an ESM import. Leave its diagnostic for a manual edit.\n              if (sourceCode.ast.sourceType !== 'module') {\n                return null;\n              }\n              name = getUnusedName(sourceCode, 'dedent');\n              fixes.push(insertImport(fixer, sourceCode, `import ${name} from '${DEDENT_MODULE}';`));\n            }\n\n            const linePrefix = sourceCode.text.slice(sourceCode.getIndexFromLoc({ column: 0, line: callNode.loc.start.line }), callNode.range[0]);\n            const lineIndent = linePrefix.slice(0, linePrefix.length - linePrefix.trimStart().length);\n            const body = lines.map((line) => line === '' ? '' : `${lineIndent}${INDENT}${line}`).join('\\n');\n            fixes.push(fixer.replaceText(node, `${name}\\`\\n${body}\\n${lineIndent}\\``));\n            return fixes;\n          },\n          messageId: MESSAGE_ID,\n          node\n        });\n      }\n    };\n  },\n  meta: {\n    docs: {\n      description: 'Prefer a `dedent` template over an array of string literals joined with a newline'\n    },\n    fixable: 'code',\n    messages: {\n      [MESSAGE_ID]: 'Write this multiline string as a `dedent` template instead of joining an array of string literals with a newline.'\n    },\n    schema: [],\n    type: 'suggestion'\n  }\n};\n\ninterface JoinedStringElements {\n  readonly elements: readonly StringElement[];\n  readonly separator: string;\n}\n\nfunction escapeLineBreaks(text: string): string {\n  return text.replaceAll('\\r', String.raw`\\r`).replaceAll('\\n', String.raw`\\n`);\n}\n\nfunction escapeTemplateText(text: string): string {\n  return text.replaceAll('`', '\\\\`').replaceAll('${', '\\\\${').replaceAll('\\r', String.raw`\\r`);\n}\n\nfunction getJoinedStringElements(node: TSESTree.CallExpression): JoinedStringElements | null {\n  const callee = node.callee;\n  if (\n    node.optional || node.arguments.length !== 1\n    || callee.type !== AST_NODE_TYPES.MemberExpression || callee.optional || callee.computed\n    || callee.property.type !== AST_NODE_TYPES.Identifier || callee.property.name !== 'join'\n    || callee.object.type !== AST_NODE_TYPES.ArrayExpression\n  ) {\n    return null;\n  }\n\n  const separator = getStaticString(ensureNonNullable(node.arguments[0]));\n  if (separator === null || !LINE_BREAK_SEPARATORS.has(separator)) {\n    return null;\n  }\n\n  const elements: StringElement[] = [];\n  for (const element of callee.object.elements) {\n    if (!isStringElement(element)) {\n      return null;\n    }\n    elements.push(element);\n  }\n  // A single element joins to itself; there is no line break to rewrite.\n  return elements.length < MINIMUM_ELEMENTS_WITH_A_LINE_BREAK ? null : { elements, separator };\n}\n\nfunction getJoinedText(elements: readonly StringElement[], separator: string): null | string {\n  const values: string[] = [];\n  for (const element of elements) {\n    const value = getStaticString(element);\n    if (value === null) {\n      return null;\n    }\n    values.push(value);\n  }\n  return values.join(separator);\n}\n\nfunction getStaticString(node: TSESTree.Node): null | string {\n  if (node.type === AST_NODE_TYPES.Literal) {\n    return typeof node.value === 'string' ? node.value : null;\n  }\n  // An untagged template with an invalid escape is a syntax error, so its cooked text always exists.\n  return node.type === AST_NODE_TYPES.TemplateLiteral && node.expressions.length === 0 ? ensureNonNullable(node.quasis[0]).value.cooked : null;\n}\n\nfunction isStringElement(element: null | TSESTree.Node): element is StringElement {\n  return element?.type === AST_NODE_TYPES.TemplateLiteral\n    || (element?.type === AST_NODE_TYPES.Literal && typeof element.value === 'string');\n}\n\n/**\n * Encodes text as the lines of a `dedent` template body, before indentation.\n *\n * `dedent` trims the whole result and only then decodes `\\n` and `\\r` escapes, so an edge run of line breaks survives\n * when written as escapes, and any other edge whitespace does not survive at all. It strips the smallest indentation\n * of the lines, and the first line here always starts with a non-blank character, so every line keeps its own.\n *\n * @param text - The text the template must produce.\n * @returns The body lines, or `null` when `dedent` cannot produce the text from a plain template.\n */\nfunction toDedentLines(text: string): null | string[] {\n  if (text.includes('\\\\')) {\n    return null;\n  }\n  const rest = text.replace(/^[\\r\\n]+/, '');\n  const leading = text.slice(0, text.length - rest.length);\n  const core = rest.replace(/[\\r\\n]+$/, '');\n  const trailing = rest.slice(core.length);\n  if (core === '' || (leading === '' && /^\\s/.test(core)) || (trailing === '' && /\\s$/.test(core))) {\n    return null;\n  }\n\n  // The escapes hold no line break, so splitting after escaping splits only the line breaks of the core.\n  return `${escapeLineBreaks(leading)}${escapeTemplateText(core)}${escapeLineBreaks(trailing)}`.split('\\n');\n}\n"],"mappings":"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","names":[]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../src/linters/eslint-rules/prefer-dedent.ts"],"sourcesContent":["/**\n * @file\n *\n * ESLint rule: prefer-dedent\n *\n * Reports an array of string literals joined with a newline (`['a', 'b'].join('\\n')`) and fixes it to a `dedent`\n * template. An array holding anything but string and template literals is left alone: it builds a string at runtime.\n *\n * The fix rewrites the joined text so that `dedent` (1.x, used as a tag) returns exactly the same string. It runs the\n * same steps `dedent` does in reverse: a leading or trailing run of line breaks and every carriage return become\n * `\\n` / `\\r` escapes, which `dedent` decodes only after it trims, and backticks and `${` are escaped. Text it cannot\n * represent that way keeps the diagnostic without a fix: a backslash, which `dedent` passes on raw; leading or trailing\n * whitespace that `dedent` would trim; a template literal with expressions, whose values are unknown; and comments\n * inside the call. The fix reuses a visible default import of `dedent`, or adds one under a free name.\n *\n * The `ignoreInsideCallsTo` option names functions whose callback arguments are serialized and run elsewhere (an\n * Obsidian test's `evalInObsidian`), where the module's imports are not in scope. A join inside a function nested in\n * the arguments of such a call is not reported, because `dedent` cannot be used there.\n */\nimport type { TSESTree } from '@typescript-eslint/utils';\nimport type { Rule } from 'eslint';\n\nimport { ensureNonNullable } from '@mnaoumov/typescript-lib/type-guards';\nimport { AST_NODE_TYPES } from '@typescript-eslint/utils';\n\nimport {\n  findVisibleImportName,\n  getUnusedName,\n  insertImport\n} from './import-fix.ts';\nimport { toTSESTreeNode } from './ts-estree-node.ts';\n\nconst DEDENT_MODULE = 'dedent';\nconst FUNCTION_NODE_TYPES: ReadonlySet<AST_NODE_TYPES> = new Set([\n  AST_NODE_TYPES.ArrowFunctionExpression,\n  AST_NODE_TYPES.FunctionDeclaration,\n  AST_NODE_TYPES.FunctionExpression\n]);\nconst INDENT = '  ';\nconst LINE_BREAK_SEPARATORS = new Set(['\\n', '\\r\\n']);\nconst MINIMUM_ELEMENTS_WITH_A_LINE_BREAK = 2;\n\n/**\n * Message ID reported when an array of string literals is joined with a newline instead of written as a `dedent` template.\n */\nexport const MESSAGE_ID = 'preferDedent';\n\ntype StringElement = TSESTree.StringLiteral | TSESTree.TemplateLiteral;\n\n/**\n * ESLint rule preferring a `dedent` template over an array of string literals joined with a newline.\n */\nexport const preferDedent: Rule.RuleModule = {\n  create(context) {\n    const options = (context.options[0] ?? {}) as PreferDedentOptions;\n    const ignoredCalleeNames = new Set(options.ignoreInsideCallsTo);\n    return {\n      'CallExpression'(node: Rule.Node): void {\n        const callNode = toTSESTreeNode(node) as TSESTree.CallExpression;\n        const joined = getJoinedStringElements(callNode);\n        if (!joined || isInsideIgnoredCallback(callNode, ignoredCalleeNames)) {\n          return;\n        }\n\n        context.report({\n          fix(fixer) {\n            const sourceCode = context.sourceCode;\n            if (sourceCode.getCommentsInside(node).length > 0) {\n              return null;\n            }\n            const text = getJoinedText(joined.elements, joined.separator);\n            const lines = text === null ? null : toDedentLines(text);\n            if (lines === null) {\n              return null;\n            }\n\n            const fixes: Rule.Fix[] = [];\n            let name = findVisibleImportName({ importedName: 'default', moduleName: DEDENT_MODULE, node, sourceCode });\n            if (name === null) {\n              // A script cannot accept an ESM import. Leave its diagnostic for a manual edit.\n              if (sourceCode.ast.sourceType !== 'module') {\n                return null;\n              }\n              name = getUnusedName(sourceCode, 'dedent');\n              fixes.push(insertImport(fixer, sourceCode, `import ${name} from '${DEDENT_MODULE}';`));\n            }\n\n            const linePrefix = sourceCode.text.slice(sourceCode.getIndexFromLoc({ column: 0, line: callNode.loc.start.line }), callNode.range[0]);\n            const lineIndent = linePrefix.slice(0, linePrefix.length - linePrefix.trimStart().length);\n            const body = lines.map((line) => line === '' ? '' : `${lineIndent}${INDENT}${line}`).join('\\n');\n            fixes.push(fixer.replaceText(node, `${name}\\`\\n${body}\\n${lineIndent}\\``));\n            return fixes;\n          },\n          messageId: MESSAGE_ID,\n          node\n        });\n      }\n    };\n  },\n  meta: {\n    docs: {\n      description: 'Prefer a `dedent` template over an array of string literals joined with a newline'\n    },\n    fixable: 'code',\n    messages: {\n      [MESSAGE_ID]: 'Write this multiline string as a `dedent` template instead of joining an array of string literals with a newline.'\n    },\n    schema: [\n      {\n        additionalProperties: false,\n        properties: {\n          ignoreInsideCallsTo: {\n            items: { type: 'string' },\n            type: 'array',\n            uniqueItems: true\n          }\n        },\n        type: 'object'\n      }\n    ],\n    type: 'suggestion'\n  }\n};\n\n/**\n * Options of the `prefer-dedent` rule.\n */\nexport interface PreferDedentOptions {\n  /**\n   * Names of functions whose callback arguments run where the module's imports are not in scope. A join inside a\n   * function nested in the arguments of a call to one of them is not reported. A name matches a bare callee\n   * (`evalInObsidian(...)`) and the property of a member callee (`helpers.evalInObsidian(...)`).\n   */\n  readonly ignoreInsideCallsTo?: readonly string[];\n}\n\ninterface JoinedStringElements {\n  readonly elements: readonly StringElement[];\n  readonly separator: string;\n}\n\nfunction escapeLineBreaks(text: string): string {\n  return text.replaceAll('\\r', String.raw`\\r`).replaceAll('\\n', String.raw`\\n`);\n}\n\nfunction escapeTemplateText(text: string): string {\n  return text.replaceAll('`', '\\\\`').replaceAll('${', '\\\\${').replaceAll('\\r', String.raw`\\r`);\n}\n\nfunction getCalleeName(callee: TSESTree.Expression): null | string {\n  if (callee.type === AST_NODE_TYPES.Identifier) {\n    return callee.name;\n  }\n  return callee.type === AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES.Identifier\n    ? callee.property.name\n    : null;\n}\n\nfunction getJoinedStringElements(node: TSESTree.CallExpression): JoinedStringElements | null {\n  const callee = node.callee;\n  if (\n    node.optional || node.arguments.length !== 1\n    || callee.type !== AST_NODE_TYPES.MemberExpression || callee.optional || callee.computed\n    || callee.property.type !== AST_NODE_TYPES.Identifier || callee.property.name !== 'join'\n    || callee.object.type !== AST_NODE_TYPES.ArrayExpression\n  ) {\n    return null;\n  }\n\n  const separator = getStaticString(ensureNonNullable(node.arguments[0]));\n  if (separator === null || !LINE_BREAK_SEPARATORS.has(separator)) {\n    return null;\n  }\n\n  const elements: StringElement[] = [];\n  for (const element of callee.object.elements) {\n    if (!isStringElement(element)) {\n      return null;\n    }\n    elements.push(element);\n  }\n  // A single element joins to itself; there is no line break to rewrite.\n  return elements.length < MINIMUM_ELEMENTS_WITH_A_LINE_BREAK ? null : { elements, separator };\n}\n\nfunction getJoinedText(elements: readonly StringElement[], separator: string): null | string {\n  const values: string[] = [];\n  for (const element of elements) {\n    const value = getStaticString(element);\n    if (value === null) {\n      return null;\n    }\n    values.push(value);\n  }\n  return values.join(separator);\n}\n\nfunction getStaticString(node: TSESTree.Node): null | string {\n  if (node.type === AST_NODE_TYPES.Literal) {\n    return typeof node.value === 'string' ? node.value : null;\n  }\n  // An untagged template with an invalid escape is a syntax error, so its cooked text always exists.\n  return node.type === AST_NODE_TYPES.TemplateLiteral && node.expressions.length === 0 ? ensureNonNullable(node.quasis[0]).value.cooked : null;\n}\n\nfunction isInsideIgnoredCallback(node: TSESTree.Node, ignoredCalleeNames: ReadonlySet<string>): boolean {\n  if (ignoredCalleeNames.size === 0) {\n    return false;\n  }\n  let isInsideFunction = false;\n  let child = node;\n  for (let parent = node.parent; parent; child = parent, parent = parent.parent) {\n    if (FUNCTION_NODE_TYPES.has(parent.type)) {\n      isInsideFunction = true;\n    } else if (isInsideFunction && parent.type === AST_NODE_TYPES.CallExpression && parent.callee !== child) {\n      const name = getCalleeName(parent.callee);\n      if (name !== null && ignoredCalleeNames.has(name)) {\n        return true;\n      }\n    }\n  }\n  return false;\n}\n\nfunction isStringElement(element: null | TSESTree.Node): element is StringElement {\n  return element?.type === AST_NODE_TYPES.TemplateLiteral\n    || (element?.type === AST_NODE_TYPES.Literal && typeof element.value === 'string');\n}\n\n/**\n * Encodes text as the lines of a `dedent` template body, before indentation.\n *\n * `dedent` trims the whole result and only then decodes `\\n` and `\\r` escapes, so an edge run of line breaks survives\n * when written as escapes, and any other edge whitespace does not survive at all. It strips the smallest indentation\n * of the lines, and the first line here always starts with a non-blank character, so every line keeps its own.\n *\n * @param text - The text the template must produce.\n * @returns The body lines, or `null` when `dedent` cannot produce the text from a plain template.\n */\nfunction toDedentLines(text: string): null | string[] {\n  if (text.includes('\\\\')) {\n    return null;\n  }\n  const rest = text.replace(/^[\\r\\n]+/, '');\n  const leading = text.slice(0, text.length - rest.length);\n  const core = rest.replace(/[\\r\\n]+$/, '');\n  const trailing = rest.slice(core.length);\n  if (core === '' || (leading === '' && /^\\s/.test(core)) || (trailing === '' && /\\s$/.test(core))) {\n    return null;\n  }\n\n  // The escapes hold no line break, so splitting after escaping splits only the line breaks of the core.\n  return `${escapeLineBreaks(leading)}${escapeTemplateText(core)}${escapeLineBreaks(trailing)}`.split('\\n');\n}\n"],"mappings":"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","names":[]}