@mnaoumov/typescript-dev-toolkit 5.1.0 → 5.3.0

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,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKiBUSElTIElTIEEgR0VORVJBVEVEL0JVTkRMRUQgRklMRSBCWSBCVUlMRCBTQ1JJUFQgKi9cblxuZXhwb3J0ICogYXMgJ2J1aWxkJyBmcm9tICcuL2J1aWxkLnRzJztcbmV4cG9ydCAqIGFzICdidWxrLWNvbmN1cnJlbmN5JyBmcm9tICcuL2J1bGstY29uY3VycmVuY3kudHMnO1xuZXhwb3J0ICogYXMgJ2J1bmRsZXJzJyBmcm9tICcuL2J1bmRsZXJzL2luZGV4LnRzJztcbmV4cG9ydCAqIGFzICdjaGVjay1wcm9qZWN0LXR5cGVzJyBmcm9tICcuL2NoZWNrLXByb2plY3QtdHlwZXMudHMnO1xuZXhwb3J0ICogYXMgJ2NsaS11dGlscycgZnJvbSAnLi9jbGktdXRpbHMudHMnO1xuZXhwb3J0ICogYXMgJ2NvZGUtZ2VuZXJhdG9yJyBmcm9tICcuL2NvZGUtZ2VuZXJhdG9yLnRzJztcbmV4cG9ydCAqIGFzICdjb21taXRsaW50LWNvbmZpZycgZnJvbSAnLi9jb21taXRsaW50LWNvbmZpZy50cyc7XG5leHBvcnQgKiBhcyAnY29tbWl0bGludC1mb3JiaWRkZW4tcGF0dGVybnMnIGZyb20gJy4vY29tbWl0bGludC1mb3JiaWRkZW4tcGF0dGVybnMudHMnO1xuZXhwb3J0ICogYXMgJ2NvbW1pdGxpbnQtbGludC1tZC1oZWFkZXInIGZyb20gJy4vY29tbWl0bGludC1saW50LW1kLWhlYWRlci50cyc7XG5leHBvcnQgKiBhcyAnY29tbWl0bGludC1zcGVsbGNoZWNrLWhlYWRlcicgZnJvbSAnLi9jb21taXRsaW50LXNwZWxsY2hlY2staGVhZGVyLnRzJztcbmV4cG9ydCAqIGFzICdkb2NzLXNpdGUnIGZyb20gJy4vZG9jcy1zaXRlL2luZGV4LnRzJztcbmV4cG9ydCAqIGFzICdlbnYtdG9nZ2xlJyBmcm9tICcuL2Vudi10b2dnbGUudHMnO1xuZXhwb3J0ICogYXMgJ2V4ZWMnIGZyb20gJy4vZXhlYy50cyc7XG5leHBvcnQgKiBhcyAnZm9yYmlkZGVuLXBhdHRlcm5zJyBmcm9tICcuL2ZvcmJpZGRlbi1wYXR0ZXJucy50cyc7XG5leHBvcnQgKiBhcyAnZm9ybWF0dGVycycgZnJvbSAnLi9mb3JtYXR0ZXJzL2luZGV4LnRzJztcbmV4cG9ydCAqIGFzICdmcycgZnJvbSAnLi9mcy50cyc7XG5leHBvcnQgKiBhcyAnZ2F0ZScgZnJvbSAnLi9nYXRlLnRzJztcbmV4cG9ydCAqIGFzICdnaXQnIGZyb20gJy4vZ2l0LnRzJztcbmV4cG9ydCAqIGFzICdqc29uJyBmcm9tICcuL2pzb24udHMnO1xuZXhwb3J0ICogYXMgJ2xpYnJhcnktYnVpbGQnIGZyb20gJy4vbGlicmFyeS1idWlsZC50cyc7XG5leHBvcnQgKiBhcyAnbGluay1jaGVjay1za2lwJyBmcm9tICcuL2xpbmstY2hlY2stc2tpcC50cyc7XG5leHBvcnQgKiBhcyAnbGludGVycycgZnJvbSAnLi9saW50ZXJzL2luZGV4LnRzJztcbmV4cG9ydCAqIGFzICduYW5vLXN0YWdlZC1jb25maWcnIGZyb20gJy4vbmFuby1zdGFnZWQtY29uZmlnLnRzJztcbmV4cG9ydCAqIGFzICducG0tcHVibGlzaCcgZnJvbSAnLi9ucG0tcHVibGlzaC50cyc7XG5leHBvcnQgKiBhcyAnbnBtLXJ1bicgZnJvbSAnLi9ucG0tcnVuLnRzJztcbmV4cG9ydCAqIGFzICducG0nIGZyb20gJy4vbnBtLnRzJztcbmV4cG9ydCAqIGFzICdwYWNrYWdlLWxvY2staW50ZWdyaXR5JyBmcm9tICcuL3BhY2thZ2UtbG9jay1pbnRlZ3JpdHkudHMnO1xuZXhwb3J0ICogYXMgJ3BhY2thZ2UtbWFuYWdlcicgZnJvbSAnLi9wYWNrYWdlLW1hbmFnZXIudHMnO1xuZXhwb3J0ICogYXMgJ3JlbGVhc2VkLWlzc3VlcycgZnJvbSAnLi9yZWxlYXNlZC1pc3N1ZXMudHMnO1xuZXhwb3J0ICogYXMgJ3JlcG8tcGF0aHMnIGZyb20gJy4vcmVwby1wYXRocy50cyc7XG5leHBvcnQgKiBhcyAncm9vdCcgZnJvbSAnLi9yb290LnRzJztcbmV4cG9ydCAqIGFzICdzaGFyZWQtY29uZmlnLWZpbGVzJyBmcm9tICcuL3NoYXJlZC1jb25maWctZmlsZXMudHMnO1xuZXhwb3J0ICogYXMgJ3Rlc3QtcnVubmVycycgZnJvbSAnLi90ZXN0LXJ1bm5lcnMvaW5kZXgudHMnO1xuZXhwb3J0ICogYXMgJ3Vwc3RyZWFtLXN5bmMtY2xpJyBmcm9tICcuL3Vwc3RyZWFtLXN5bmMtY2xpLnRzJztcbmV4cG9ydCAqIGFzICd1cHN0cmVhbS1zeW5jJyBmcm9tICcuL3Vwc3RyZWFtLXN5bmMudHMnO1xuZXhwb3J0ICogYXMgJ3ZhbGlkYXRlLWRlY2xhcmF0aW9ucycgZnJvbSAnLi92YWxpZGF0ZS1kZWNsYXJhdGlvbnMudHMnO1xuZXhwb3J0ICogYXMgJ3ZhbGlkYXRlLWRlcGVuZGVuY2llcycgZnJvbSAnLi92YWxpZGF0ZS1kZXBlbmRlbmNpZXMudHMnO1xuZXhwb3J0ICogYXMgJ3ZlcnNpb24nIGZyb20gJy4vdmVyc2lvbi50cyc7XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7OztBQUVBLFlBQVksV0FBYTtBQUN6QixZQUFZQSxzQkFBd0I7QUFDcEMsWUFBWSxjQUFnQjtBQUM1QixZQUFZQyx5QkFBMkI7QUFDdkMsWUFBWUMsZUFBaUI7QUFDN0IsWUFBWUMsb0JBQXNCO0FBQ2xDLFlBQVlDLHVCQUF5QjtBQUNyQyxZQUFZQyxtQ0FBcUM7QUFDakQsWUFBWUMsK0JBQWlDO0FBQzdDLFlBQVlDLGtDQUFvQztBQUNoRCxZQUFZQyxlQUFpQjtBQUM3QixZQUFZQyxnQkFBa0I7QUFDOUIsWUFBWSxVQUFZO0FBQ3hCLFlBQVlDLHdCQUEwQjtBQUN0QyxZQUFZLGdCQUFrQjtBQUM5QixZQUFZLFFBQVU7QUFDdEIsWUFBWSxVQUFZO0FBQ3hCLFlBQVksU0FBVztBQUN2QixZQUFZLFVBQVk7QUFDeEIsWUFBWUMsbUJBQXFCO0FBQ2pDLFlBQVlDLHFCQUF1QjtBQUNuQyxZQUFZLGFBQWU7QUFDM0IsWUFBWUMsd0JBQTBCO0FBQ3RDLFlBQVlDLGlCQUFtQjtBQUMvQixZQUFZQyxhQUFlO0FBQzNCLFlBQVksU0FBVztBQUN2QixZQUFZQyw0QkFBOEI7QUFDMUMsWUFBWUMscUJBQXVCO0FBQ25DLFlBQVlDLHFCQUF1QjtBQUNuQyxZQUFZQyxnQkFBa0I7QUFDOUIsWUFBWSxVQUFZO0FBQ3hCLFlBQVlDLHlCQUEyQjtBQUN2QyxZQUFZQyxrQkFBb0I7QUFDaEMsWUFBWUMsdUJBQXlCO0FBQ3JDLFlBQVlDLG1CQUFxQjtBQUNqQyxZQUFZQywyQkFBNkI7QUFDekMsWUFBWUMsMkJBQTZCO0FBQ3pDLFlBQVksYUFBZTsiLAogICJuYW1lcyI6IFsiYnVsay1jb25jdXJyZW5jeSIsICJjaGVjay1wcm9qZWN0LXR5cGVzIiwgImNsaS11dGlscyIsICJjb2RlLWdlbmVyYXRvciIsICJjb21taXRsaW50LWNvbmZpZyIsICJjb21taXRsaW50LWZvcmJpZGRlbi1wYXR0ZXJucyIsICJjb21taXRsaW50LWxpbnQtbWQtaGVhZGVyIiwgImNvbW1pdGxpbnQtc3BlbGxjaGVjay1oZWFkZXIiLCAiZG9jcy1zaXRlIiwgImVudi10b2dnbGUiLCAiZm9yYmlkZGVuLXBhdHRlcm5zIiwgImxpYnJhcnktYnVpbGQiLCAibGluay1jaGVjay1za2lwIiwgIm5hbm8tc3RhZ2VkLWNvbmZpZyIsICJucG0tcHVibGlzaCIsICJucG0tcnVuIiwgInBhY2thZ2UtbG9jay1pbnRlZ3JpdHkiLCAicGFja2FnZS1tYW5hZ2VyIiwgInJlbGVhc2VkLWlzc3VlcyIsICJyZXBvLXBhdGhzIiwgInNoYXJlZC1jb25maWctZmlsZXMiLCAidGVzdC1ydW5uZXJzIiwgInVwc3RyZWFtLXN5bmMtY2xpIiwgInVwc3RyZWFtLXN5bmMiLCAidmFsaWRhdGUtZGVjbGFyYXRpb25zIiwgInZhbGlkYXRlLWRlcGVuZGVuY2llcyJdCn0K

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":[]}