@mnaoumov/typescript-dev-toolkit 3.6.4 → 3.7.0

package/dist/lib/esm/docs-site/docs-snippets.mjs

@@ -0,0 +1,298 @@
+/*
+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 {
+  readdir,
+  readFile
+} from "node:fs/promises";
+import {
+  join,
+  relative,
+  resolve
+} from "node:path";
+import {
+  createCompilerHost,
+  createProgram,
+  createSourceFile,
+  flattenDiagnosticMessageText,
+  getParsedCommandLineOfConfigFile,
+  ScriptKind,
+  sys
+} from "typescript";
+const CHECKED_LANGUAGES = /* @__PURE__ */ new Map([
+  ["javascript", true],
+  ["js", true],
+  ["ts", false],
+  ["typescript", false]
+]);
+const LINE_AFTER_FENCE_OFFSET = 2;
+const MARKER_REG_EXP = /^<!--\s*snippet-check:\s*(?<kind>[a-z]+)\b(?<text>.*?)-->$/su;
+const DIAGNOSTIC_DECLARED_BUT_VALUE_NEVER_READ = 6133;
+const DIAGNOSTIC_ALL_IMPORTS_UNUSED = 6192;
+const DIAGNOSTIC_DECLARED_BUT_NEVER_USED = 6196;
+const DIAGNOSTIC_ALL_DESTRUCTURED_ELEMENTS_UNUSED = 6198;
+const IGNORED_DIAGNOSTIC_CODES = /* @__PURE__ */ new Set([
+  DIAGNOSTIC_ALL_DESTRUCTURED_ELEMENTS_UNUSED,
+  DIAGNOSTIC_ALL_IMPORTS_UNUSED,
+  DIAGNOSTIC_DECLARED_BUT_NEVER_USED,
+  DIAGNOSTIC_DECLARED_BUT_VALUE_NEVER_READ
+]);
+const DIAGNOSTIC_VARIABLE_IMPLICITLY_ANY = 7005;
+const DIAGNOSTIC_PARAMETER_IMPLICITLY_ANY = 7006;
+const DIAGNOSTIC_MEMBER_IMPLICITLY_ANY = 7008;
+const DIAGNOSTIC_BINDING_ELEMENT_IMPLICITLY_ANY = 7031;
+const DIAGNOSTIC_VARIABLE_IMPLICITLY_ANY_IN_SOME_LOCATIONS = 7034;
+const DIAGNOSTIC_ARROW_FUNCTION_CAPTURES_GLOBAL_THIS = 7041;
+const DIAGNOSTIC_ELEMENT_IMPLICITLY_ANY = 7053;
+const JAVASCRIPT_IGNORED_DIAGNOSTIC_CODES = /* @__PURE__ */ new Set([
+  DIAGNOSTIC_ARROW_FUNCTION_CAPTURES_GLOBAL_THIS,
+  DIAGNOSTIC_BINDING_ELEMENT_IMPLICITLY_ANY,
+  DIAGNOSTIC_ELEMENT_IMPLICITLY_ANY,
+  DIAGNOSTIC_MEMBER_IMPLICITLY_ANY,
+  DIAGNOSTIC_PARAMETER_IMPLICITLY_ANY,
+  DIAGNOSTIC_VARIABLE_IMPLICITLY_ANY,
+  DIAGNOSTIC_VARIABLE_IMPLICITLY_ANY_IN_SOME_LOCATIONS
+]);
+async function assertDocsSnippetsCompile(params) {
+  const problems = await findDocsSnippetProblems(params);
+  if (problems.length > 0) {
+    throw new Error(`${String(problems.length)} problem(s) in the documentation snippets:
+${formatDocsSnippetProblems(problems)}`);
+  }
+}
+function extractDocsSnippets(markdown) {
+  const lines = markdown.split(/\r?\n/u);
+  const snippets = [];
+  let openFence = null;
+  let codeLines = [];
+  let pendingSkipReason = null;
+  let pendingContext = [];
+  for (const [index, line] of lines.entries()) {
+    if (openFence) {
+      const content = stripPrefix(line, openFence.prefix);
+      if (content.trimEnd() === openFence.fence) {
+        const isJavaScript = CHECKED_LANGUAGES.get(openFence.language);
+        if (isJavaScript !== void 0) {
+          snippets.push({
+            code: codeLines.join("\n"),
+            codeStartLine: openFence.startLine,
+            context: openFence.context.join("\n"),
+            isJavaScript,
+            language: openFence.language,
+            skipReason: openFence.skipReason
+          });
+        }
+        openFence = null;
+        codeLines = [];
+      } else {
+        codeLines.push(content);
+      }
+      continue;
+    }
+    const fenceMatch = /^(?<prefix>(?:\s*>)*\s*)(?<fence>`{3,}|~{3,})(?<language>[\w-]*)/u.exec(line);
+    if (fenceMatch?.groups) {
+      openFence = {
+        context: pendingContext,
+        fence: fenceMatch.groups["fence"] ?? "",
+        language: (fenceMatch.groups["language"] ?? "").toLowerCase(),
+        prefix: fenceMatch.groups["prefix"] ?? "",
+        skipReason: pendingSkipReason,
+        startLine: index + LINE_AFTER_FENCE_OFFSET
+      };
+      pendingSkipReason = null;
+      pendingContext = [];
+      continue;
+    }
+    const text = line.replace(/^(?:\s*>)*\s*/u, "").trim();
+    const markerMatch = MARKER_REG_EXP.exec(text);
+    const kind = markerMatch?.groups?.["kind"];
+    const markerText = (markerMatch?.groups?.["text"] ?? "").trim();
+    if (kind === "skip") {
+      pendingSkipReason = markerText.replace(/^[-—:]\s*/u, "");
+    } else if (kind === "context") {
+      pendingContext.push(markerText);
+    } else if (text !== "") {
+      pendingSkipReason = null;
+      pendingContext = [];
+    }
+  }
+  return snippets;
+}
+async function findDocsSnippetProblems(params) {
+  const rootDirectory = resolve(params.rootDirectory);
+  const docsDirectory = join(rootDirectory, params.docsDirectory ?? "docs/src/content/docs");
+  const problems = [];
+  const virtualFiles = /* @__PURE__ */ new Map();
+  const rootNames = [];
+  const snippetsDirectory = join(rootDirectory, "docs", "__snippets__");
+  function addVirtualFile(path, file) {
+    virtualFiles.set(normalizePath(path), file);
+    rootNames.push(path);
+  }
+  const prelude = params.prelude ?? "";
+  if (prelude !== "") {
+    addVirtualFile(join(snippetsDirectory, "prelude.ts"), { code: prelude, codeStartLine: 1, contextLineCount: 0, filePath: "<prelude>" });
+  }
+  for (const guidePath of await listGuides(docsDirectory)) {
+    const filePath = toPosix(relative(rootDirectory, guidePath));
+    const markdown = await readFile(guidePath, "utf-8");
+    for (const snippet of extractDocsSnippets(markdown)) {
+      if (snippet.skipReason === "") {
+        problems.push({
+          filePath,
+          line: snippet.codeStartLine - 1,
+          message: "A `snippet-check: skip` marker must give its reason."
+        });
+        continue;
+      }
+      if (snippet.skipReason !== null) {
+        continue;
+      }
+      const extension = snippet.isJavaScript ? "js" : "ts";
+      const baseName = `${toPosix(relative(docsDirectory, guidePath)).replaceAll("/", "__")}.L${String(snippet.codeStartLine)}.${extension}`;
+      const context = snippet.context === "" ? "" : `${snippet.context}
+`;
+      addVirtualFile(join(snippetsDirectory, baseName), {
+        code: `${context}${snippet.code}
+export {};
+`,
+        codeStartLine: snippet.codeStartLine,
+        contextLineCount: context === "" ? 0 : context.split("\n").length - 1,
+        filePath
+      });
+    }
+  }
+  problems.push(...compileSnippets({ compilerOptions: params.compilerOptions ?? {}, rootDirectory, rootNames, virtualFiles }));
+  return problems;
+}
+function formatDocsSnippetProblems(problems) {
+  return problems.map((problem) => `${problem.filePath}:${String(problem.line)} - ${problem.message}`).join("\n");
+}
+function compileSnippets(params) {
+  const { rootDirectory, rootNames, virtualFiles } = params;
+  const configPath = join(rootDirectory, "tsconfig.json");
+  const parsed = getParsedCommandLineOfConfigFile(configPath, {}, {
+    ...sys,
+    onUnRecoverableConfigFileDiagnostic(diagnostic) {
+      throw new Error(flattenDiagnosticMessageText(diagnostic.messageText, "\n"));
+    }
+  });
+  if (!parsed) {
+    throw new Error(`Cannot read ${configPath}`);
+  }
+  const compilerOptions = {
+    ...parsed.options,
+    ...params.compilerOptions,
+    allowJs: true,
+    checkJs: true,
+    composite: false,
+    incremental: false,
+    noEmit: true,
+    noUnusedLocals: false,
+    noUnusedParameters: false
+  };
+  delete compilerOptions.tsBuildInfoFile;
+  const host = createCompilerHost(compilerOptions, true);
+  const originalGetSourceFile = host.getSourceFile.bind(host);
+  const originalFileExists = host.fileExists.bind(host);
+  const originalReadFile = host.readFile.bind(host);
+  host.fileExists = (fileName) => virtualFiles.has(normalizePath(fileName)) || originalFileExists(fileName);
+  host.readFile = (fileName) => virtualFiles.get(normalizePath(fileName))?.code ?? originalReadFile(fileName);
+  host.getSourceFile = (fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile) => {
+    const virtualFile = virtualFiles.get(normalizePath(fileName));
+    if (virtualFile) {
+      const scriptKind = fileName.endsWith(".js") ? ScriptKind.JS : ScriptKind.TS;
+      return createSourceFile(fileName, virtualFile.code, languageVersionOrOptions, true, scriptKind);
+    }
+    return originalGetSourceFile(fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile);
+  };
+  const program = createProgram({ host, options: compilerOptions, rootNames });
+  const problems = [];
+  for (const rootName of rootNames) {
+    const sourceFile = program.getSourceFile(rootName);
+    const virtualFile = virtualFiles.get(normalizePath(rootName));
+    if (!sourceFile || !virtualFile) {
+      continue;
+    }
+    const isJavaScript = rootName.endsWith(".js");
+    const diagnostics = [...program.getSyntacticDiagnostics(sourceFile), ...program.getSemanticDiagnostics(sourceFile)];
+    for (const diagnostic of diagnostics) {
+      if (IGNORED_DIAGNOSTIC_CODES.has(diagnostic.code) || isJavaScript && JAVASCRIPT_IGNORED_DIAGNOSTIC_CODES.has(diagnostic.code)) {
+        continue;
+      }
+      const fileLine = diagnostic.start === void 0 ? 0 : sourceFile.getLineAndCharacterOfPosition(diagnostic.start).line;
+      const snippetLine = Math.max(0, fileLine - virtualFile.contextLineCount);
+      problems.push({
+        filePath: virtualFile.filePath,
+        line: virtualFile.codeStartLine + snippetLine,
+        message: `TS${String(diagnostic.code)}: ${flattenDiagnosticMessageText(diagnostic.messageText, " ")}`
+      });
+    }
+  }
+  return problems;
+}
+async function listGuides(directory) {
+  const guides = [];
+  for (const entry of await readdir(directory, { withFileTypes: true })) {
+    const entryPath = join(directory, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name !== "api") {
+        guides.push(...await listGuides(entryPath));
+      }
+    } else if (/\.mdx?$/u.test(entry.name)) {
+      guides.push(entryPath);
+    }
+  }
+  return guides.sort();
+}
+function normalizePath(path) {
+  return toPosix(resolve(path)).toLowerCase();
+}
+function stripPrefix(line, prefix) {
+  return line.startsWith(prefix) ? line.slice(prefix.length) : line.replace(/^(?:\s*>)*\s?/u, "");
+}
+function toPosix(path) {
+  return path.replaceAll("\\", "/");
+}
+export {
+  assertDocsSnippetsCompile,
+  extractDocsSnippets,
+  findDocsSnippetProblems,
+  formatDocsSnippetProblems
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/docs-site/docs-snippets.ts"],"sourcesContent":["/**\n * @file\n *\n * Extracts the code snippets of a package's documentation guides and type-checks them against its sources.\n *\n * A guide's snippet is code a reader copies, so a renamed member or a stale import path in it is a bug that ships\n * to the site with every check green. Every fenced `ts`, `typescript`, `js` or `javascript` block in\n * `docs/src/content/docs` is compiled as its own module, with the project's `tsconfig.json`, so an import of the\n * package's own name resolves wherever that configuration sends it (its `paths`, or the `compilerOptions` passed\n * here) and a wrong name fails. A `ts` / `typescript` block is compiled as TypeScript; a `js` / `javascript` block,\n * often a devtools-console recipe, is compiled as JavaScript with `checkJs`, so a wrong member of a typed object\n * still fails while an untyped lookup does not. The generated API reference (`docs/src/content/docs/api`) is\n * skipped: it is rendered from the TSDoc.\n *\n * Three things shape what a snippet is compiled with, each but the first written in the guide as an HTML comment,\n * invisible on the site, on the lines right above the fence:\n *\n * - The names every guide may use without declaring them are the package's `prelude`, compiled as a module of its\n *   own (a `declare global` block, with the imports it needs).\n * - `<!-- snippet-check: context <TypeScript> -->` prepends declarations to that one snippet, for the names its\n *   prose has already introduced (`declare const linkEl: HTMLAnchorElement;`). Several such lines add up.\n * - `<!-- snippet-check: skip <reason> -->` exempts a snippet that is deliberately not compilable, such as\n *   pseudo-code. The reason is required, so a skip is a decision somebody wrote down, never a silent hole.\n */\n\nimport type {\n  CompilerOptions,\n  SourceFile\n} from 'typescript';\n\nimport {\n  readdir,\n  readFile\n} from 'node:fs/promises';\nimport {\n  join,\n  relative,\n  resolve\n} from 'node:path';\nimport {\n  createCompilerHost,\n  createProgram,\n  createSourceFile,\n  flattenDiagnosticMessageText,\n  getParsedCommandLineOfConfigFile,\n  ScriptKind,\n  sys\n} from 'typescript';\n\n/**\n * The languages of the fenced blocks that are type-checked, and whether each is JavaScript.\n */\nconst CHECKED_LANGUAGES: ReadonlyMap<string, boolean> = new Map([\n  ['javascript', true],\n  ['js', true],\n  ['ts', false],\n  ['typescript', false]\n]);\n\n/**\n * The offset from a fence line's 0-based index to the 1-based line of the code after it.\n */\nconst LINE_AFTER_FENCE_OFFSET = 2;\n\nconst MARKER_REG_EXP = /^<!--\\s*snippet-check:\\s*(?<kind>[a-z]+)\\b(?<text>.*?)-->$/su;\n\n/**\n * Diagnostics a snippet is not held to: an illustration declares names it never reads.\n */\nconst DIAGNOSTIC_DECLARED_BUT_VALUE_NEVER_READ = 6133;\nconst DIAGNOSTIC_ALL_IMPORTS_UNUSED = 6192;\nconst DIAGNOSTIC_DECLARED_BUT_NEVER_USED = 6196;\nconst DIAGNOSTIC_ALL_DESTRUCTURED_ELEMENTS_UNUSED = 6198;\nconst IGNORED_DIAGNOSTIC_CODES = new Set([\n  DIAGNOSTIC_ALL_DESTRUCTURED_ELEMENTS_UNUSED,\n  DIAGNOSTIC_ALL_IMPORTS_UNUSED,\n  DIAGNOSTIC_DECLARED_BUT_NEVER_USED,\n  DIAGNOSTIC_DECLARED_BUT_VALUE_NEVER_READ\n]);\n\n/**\n * The implicit-`any` diagnostics, which a JavaScript snippet is not held to: a console recipe has no annotations to\n * give, and an untyped lookup such as a `Symbol.for` slot on `globalThis` is what plain JavaScript does.\n */\nconst DIAGNOSTIC_VARIABLE_IMPLICITLY_ANY = 7005;\nconst DIAGNOSTIC_PARAMETER_IMPLICITLY_ANY = 7006;\nconst DIAGNOSTIC_MEMBER_IMPLICITLY_ANY = 7008;\nconst DIAGNOSTIC_BINDING_ELEMENT_IMPLICITLY_ANY = 7031;\nconst DIAGNOSTIC_VARIABLE_IMPLICITLY_ANY_IN_SOME_LOCATIONS = 7034;\nconst DIAGNOSTIC_ARROW_FUNCTION_CAPTURES_GLOBAL_THIS = 7041;\nconst DIAGNOSTIC_ELEMENT_IMPLICITLY_ANY = 7053;\nconst JAVASCRIPT_IGNORED_DIAGNOSTIC_CODES = new Set([\n  DIAGNOSTIC_ARROW_FUNCTION_CAPTURES_GLOBAL_THIS,\n  DIAGNOSTIC_BINDING_ELEMENT_IMPLICITLY_ANY,\n  DIAGNOSTIC_ELEMENT_IMPLICITLY_ANY,\n  DIAGNOSTIC_MEMBER_IMPLICITLY_ANY,\n  DIAGNOSTIC_PARAMETER_IMPLICITLY_ANY,\n  DIAGNOSTIC_VARIABLE_IMPLICITLY_ANY,\n  DIAGNOSTIC_VARIABLE_IMPLICITLY_ANY_IN_SOME_LOCATIONS\n]);\n\n/**\n * Parameters for {@link assertDocsSnippetsCompile}: the same as {@link findDocsSnippetProblems} takes.\n */\nexport type AssertDocsSnippetsCompileParams = FindDocsSnippetProblemsParams;\n\n/**\n * One fenced code block of a guide.\n */\nexport interface DocsSnippet {\n  /**\n   * The code, with any blockquote or indentation prefix of the fence stripped.\n   */\n  readonly code: string;\n\n  /**\n   * The 1-based line of the guide on which the code starts (the line after the opening fence).\n   */\n  readonly codeStartLine: number;\n\n  /**\n   * The declarations of the `snippet-check: context` markers above the fence, joined by newlines.\n   */\n  readonly context: string;\n\n  /**\n   * Whether the snippet is JavaScript rather than TypeScript.\n   */\n  readonly isJavaScript: boolean;\n\n  /**\n   * The language of the fence.\n   */\n  readonly language: string;\n\n  /**\n   * The reason given by a `snippet-check: skip` marker, or `null` when the snippet is checked.\n   */\n  readonly skipReason: null | string;\n}\n\n/**\n * A problem found in a guide's snippet.\n */\nexport interface DocsSnippetProblem {\n  /**\n   * The guide's path, relative to the package root.\n   */\n  readonly filePath: string;\n\n  /**\n   * The 1-based line of the guide.\n   */\n  readonly line: number;\n\n  /**\n   * What is wrong.\n   */\n  readonly message: string;\n}\n\n/**\n * Parameters for {@link findDocsSnippetProblems}.\n */\nexport interface FindDocsSnippetProblemsParams {\n  /**\n   * Compiler options laid over the ones `tsconfig.json` gives, for instance `paths` that resolve the package's own\n   * name onto its sources when its `tsconfig.json` has none. A relative path in them is not resolved, so pass\n   * absolute ones.\n   */\n  readonly compilerOptions?: CompilerOptions;\n\n  /**\n   * The guides directory, relative to {@link FindDocsSnippetProblemsParams.rootDirectory}.\n   *\n   * @default `'docs/src/content/docs'`\n   */\n  readonly docsDirectory?: string;\n\n  /**\n   * The ambient context every snippet is compiled with: the names a guide may use without declaring them, written as\n   * a module (`declare global { ... }`, with the imports it needs).\n   *\n   * @default `''`, no prelude.\n   */\n  readonly prelude?: string;\n\n  /**\n   * The package root, holding `tsconfig.json`.\n   */\n  readonly rootDirectory: string;\n}\n\ninterface CompileSnippetsParams {\n  readonly compilerOptions: CompilerOptions;\n  readonly rootDirectory: string;\n  readonly rootNames: readonly string[];\n  readonly virtualFiles: ReadonlyMap<string, VirtualSnippetFile>;\n}\n\ninterface OpenFence {\n  readonly context: string[];\n  readonly fence: string;\n  readonly language: string;\n  readonly prefix: string;\n  readonly skipReason: null | string;\n  readonly startLine: number;\n}\n\ninterface VirtualSnippetFile {\n  readonly code: string;\n  readonly codeStartLine: number;\n  readonly contextLineCount: number;\n  readonly filePath: string;\n}\n\n/**\n * Type-checks every snippet of the guides and throws when one fails, for a `docs:check-snippets` script.\n *\n * @param params - The {@link AssertDocsSnippetsCompileParams}.\n * @returns A promise that resolves when every snippet compiles.\n * @throws {Error} Listing every problem, one per line.\n */\nexport async function assertDocsSnippetsCompile(params: AssertDocsSnippetsCompileParams): Promise<void> {\n  const problems = await findDocsSnippetProblems(params);\n  if (problems.length > 0) {\n    throw new Error(`${String(problems.length)} problem(s) in the documentation snippets:\\n${formatDocsSnippetProblems(problems)}`);\n  }\n}\n\n/**\n * Extracts the fenced code blocks of the checked languages from a markdown document.\n *\n * A fence inside a blockquote or a list item is recognized too: its prefix (`> `, indentation) is stripped from\n * every line of its code.\n *\n * @param markdown - The markdown document.\n * @returns The snippets, in document order.\n */\nexport function extractDocsSnippets(markdown: string): DocsSnippet[] {\n  const lines = markdown.split(/\\r?\\n/u);\n  const snippets: DocsSnippet[] = [];\n  let openFence: null | OpenFence = null;\n  let codeLines: string[] = [];\n  let pendingSkipReason: null | string = null;\n  let pendingContext: string[] = [];\n\n  for (const [index, line] of lines.entries()) {\n    if (openFence) {\n      const content = stripPrefix(line, openFence.prefix);\n      if (content.trimEnd() === openFence.fence) {\n        const isJavaScript = CHECKED_LANGUAGES.get(openFence.language);\n        if (isJavaScript !== undefined) {\n          snippets.push({\n            code: codeLines.join('\\n'),\n            codeStartLine: openFence.startLine,\n            context: openFence.context.join('\\n'),\n            isJavaScript,\n            language: openFence.language,\n            skipReason: openFence.skipReason\n          });\n        }\n        openFence = null;\n        codeLines = [];\n      } else {\n        codeLines.push(content);\n      }\n      continue;\n    }\n\n    const fenceMatch = /^(?<prefix>(?:\\s*>)*\\s*)(?<fence>`{3,}|~{3,})(?<language>[\\w-]*)/u.exec(line);\n    if (fenceMatch?.groups) {\n      /* v8 ignore start -- Every group of the fence pattern takes part in a match, so the fallbacks never apply. */\n      openFence = {\n        context: pendingContext,\n        fence: fenceMatch.groups['fence'] ?? '',\n        language: (fenceMatch.groups['language'] ?? '').toLowerCase(),\n        prefix: fenceMatch.groups['prefix'] ?? '',\n        skipReason: pendingSkipReason,\n        startLine: index + LINE_AFTER_FENCE_OFFSET\n      };\n      /* v8 ignore stop */\n      pendingSkipReason = null;\n      pendingContext = [];\n      continue;\n    }\n\n    const text = line.replace(/^(?:\\s*>)*\\s*/u, '').trim();\n    const markerMatch = MARKER_REG_EXP.exec(text);\n    const kind = markerMatch?.groups?.['kind'];\n    const markerText = (markerMatch?.groups?.['text'] ?? '').trim();\n    if (kind === 'skip') {\n      pendingSkipReason = markerText.replace(/^[-—:]\\s*/u, '');\n    } else if (kind === 'context') {\n      pendingContext.push(markerText);\n    } else if (text !== '') {\n      pendingSkipReason = null;\n      pendingContext = [];\n    }\n  }\n\n  return snippets;\n}\n\n/**\n * Type-checks every snippet of the guides.\n *\n * @param params - The {@link FindDocsSnippetProblemsParams}.\n * @returns The problems found, empty when every snippet compiles.\n */\nexport async function findDocsSnippetProblems(params: FindDocsSnippetProblemsParams): Promise<DocsSnippetProblem[]> {\n  const rootDirectory = resolve(params.rootDirectory);\n  const docsDirectory = join(rootDirectory, params.docsDirectory ?? 'docs/src/content/docs');\n  const problems: DocsSnippetProblem[] = [];\n  const virtualFiles = new Map<string, VirtualSnippetFile>();\n  const rootNames: string[] = [];\n  const snippetsDirectory = join(rootDirectory, 'docs', '__snippets__');\n\n  function addVirtualFile(path: string, file: VirtualSnippetFile): void {\n    virtualFiles.set(normalizePath(path), file);\n    rootNames.push(path);\n  }\n\n  const prelude = params.prelude ?? '';\n  if (prelude !== '') {\n    addVirtualFile(join(snippetsDirectory, 'prelude.ts'), { code: prelude, codeStartLine: 1, contextLineCount: 0, filePath: '<prelude>' });\n  }\n\n  for (const guidePath of await listGuides(docsDirectory)) {\n    const filePath = toPosix(relative(rootDirectory, guidePath));\n    const markdown = await readFile(guidePath, 'utf-8');\n    for (const snippet of extractDocsSnippets(markdown)) {\n      if (snippet.skipReason === '') {\n        problems.push({\n          filePath,\n          line: snippet.codeStartLine - 1,\n          message: 'A `snippet-check: skip` marker must give its reason.'\n        });\n        continue;\n      }\n      if (snippet.skipReason !== null) {\n        continue;\n      }\n      const extension = snippet.isJavaScript ? 'js' : 'ts';\n      const baseName = `${toPosix(relative(docsDirectory, guidePath)).replaceAll('/', '__')}.L${String(snippet.codeStartLine)}.${extension}`;\n      const context = snippet.context === '' ? '' : `${snippet.context}\\n`;\n      addVirtualFile(join(snippetsDirectory, baseName), {\n        code: `${context}${snippet.code}\\nexport {};\\n`,\n        codeStartLine: snippet.codeStartLine,\n        contextLineCount: context === '' ? 0 : context.split('\\n').length - 1,\n        filePath\n      });\n    }\n  }\n\n  problems.push(...compileSnippets({ compilerOptions: params.compilerOptions ?? {}, rootDirectory, rootNames, virtualFiles }));\n  return problems;\n}\n\n/**\n * Formats problems one per line, as `path:line - message`.\n *\n * @param problems - The problems.\n * @returns The formatted text.\n */\nexport function formatDocsSnippetProblems(problems: readonly DocsSnippetProblem[]): string {\n  return problems.map((problem) => `${problem.filePath}:${String(problem.line)} - ${problem.message}`).join('\\n');\n}\n\nfunction compileSnippets(params: CompileSnippetsParams): DocsSnippetProblem[] {\n  const { rootDirectory, rootNames, virtualFiles } = params;\n  const configPath = join(rootDirectory, 'tsconfig.json');\n  const parsed = getParsedCommandLineOfConfigFile(configPath, {}, {\n    ...sys,\n    onUnRecoverableConfigFileDiagnostic(diagnostic) {\n      throw new Error(flattenDiagnosticMessageText(diagnostic.messageText, '\\n'));\n    }\n  });\n  /* v8 ignore start -- An unreadable configuration throws in the handler above before this can be reached. */\n  if (!parsed) {\n    throw new Error(`Cannot read ${configPath}`);\n  }\n  /* v8 ignore stop */\n\n  const compilerOptions: CompilerOptions = {\n    ...parsed.options,\n    ...params.compilerOptions,\n    allowJs: true,\n    checkJs: true,\n    composite: false,\n    incremental: false,\n    noEmit: true,\n    noUnusedLocals: false,\n    noUnusedParameters: false\n  };\n  delete compilerOptions.tsBuildInfoFile;\n\n  const host = createCompilerHost(compilerOptions, true);\n  const originalGetSourceFile = host.getSourceFile.bind(host);\n  const originalFileExists = host.fileExists.bind(host);\n  const originalReadFile = host.readFile.bind(host);\n  host.fileExists = (fileName): boolean => virtualFiles.has(normalizePath(fileName)) || originalFileExists(fileName);\n  host.readFile = (fileName): string | undefined => virtualFiles.get(normalizePath(fileName))?.code ?? originalReadFile(fileName);\n  host.getSourceFile = (fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile): SourceFile | undefined => {\n    const virtualFile = virtualFiles.get(normalizePath(fileName));\n    if (virtualFile) {\n      const scriptKind = fileName.endsWith('.js') ? ScriptKind.JS : ScriptKind.TS;\n      return createSourceFile(fileName, virtualFile.code, languageVersionOrOptions, true, scriptKind);\n    }\n    return originalGetSourceFile(fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile);\n  };\n\n  const program = createProgram({ host, options: compilerOptions, rootNames });\n  const problems: DocsSnippetProblem[] = [];\n  for (const rootName of rootNames) {\n    const sourceFile = program.getSourceFile(rootName);\n    const virtualFile = virtualFiles.get(normalizePath(rootName));\n    /* v8 ignore start -- Every root name is a virtual file the program was built from. */\n    if (!sourceFile || !virtualFile) {\n      continue;\n    }\n    /* v8 ignore stop */\n    const isJavaScript = rootName.endsWith('.js');\n    const diagnostics = [...program.getSyntacticDiagnostics(sourceFile), ...program.getSemanticDiagnostics(sourceFile)];\n    for (const diagnostic of diagnostics) {\n      if (IGNORED_DIAGNOSTIC_CODES.has(diagnostic.code) || (isJavaScript && JAVASCRIPT_IGNORED_DIAGNOSTIC_CODES.has(diagnostic.code))) {\n        continue;\n      }\n      /* v8 ignore next -- A diagnostic of one source file always carries its position. */\n      const fileLine = diagnostic.start === undefined ? 0 : sourceFile.getLineAndCharacterOfPosition(diagnostic.start).line;\n      const snippetLine = Math.max(0, fileLine - virtualFile.contextLineCount);\n      problems.push({\n        filePath: virtualFile.filePath,\n        line: virtualFile.codeStartLine + snippetLine,\n        message: `TS${String(diagnostic.code)}: ${flattenDiagnosticMessageText(diagnostic.messageText, ' ')}`\n      });\n    }\n  }\n  return problems;\n}\n\nasync function listGuides(directory: string): Promise<string[]> {\n  const guides: string[] = [];\n  for (const entry of await readdir(directory, { withFileTypes: true })) {\n    const entryPath = join(directory, entry.name);\n    if (entry.isDirectory()) {\n      if (entry.name !== 'api') {\n        guides.push(...await listGuides(entryPath));\n      }\n    } else if (/\\.mdx?$/u.test(entry.name)) {\n      guides.push(entryPath);\n    }\n  }\n  return guides.sort();\n}\n\nfunction normalizePath(path: string): string {\n  return toPosix(resolve(path)).toLowerCase();\n}\n\nfunction stripPrefix(line: string, prefix: string): string {\n  return line.startsWith(prefix) ? line.slice(prefix.length) : line.replace(/^(?:\\s*>)*\\s?/u, '');\n}\n\nfunction toPosix(path: string): string {\n  return path.replaceAll('\\\\', '/');\n}\n"],"mappings":"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","names":[]}

package/dist/lib/esm/docs-site/index.d.mts

@@ -17,10 +17,12 @@ export * as 'docs-links' from './docs-links.mjs';
 export * as 'docs-site-assets' from './docs-site-assets.mjs';
 export * as 'docs-site-commands' from './docs-site-commands.mjs';
 export * as 'docs-site-config' from './docs-site-config.mjs';
+export * as 'docs-snippets' from './docs-snippets.mjs';
 export * as 'link-check' from './link-check.mjs';
 export * as 'og-image-page' from './og-image-page.mjs';
 export * as 'og-image' from './og-image.mjs';
 export * as 'og-images' from './og-images.mjs';
+export * as 'outdated-references' from './outdated-references.mjs';
 export * as 'repo-homepage' from './repo-homepage.mjs';
 export * as 'route-data' from './route-data.mjs';
 export * as 'satteri-github-alerts' from './satteri-github-alerts.mjs';

package/dist/lib/esm/docs-site/index.mjs

@@ -21,10 +21,12 @@ import * as docs_links from "./docs-links.mjs";
 import * as docs_site_assets from "./docs-site-assets.mjs";
 import * as docs_site_commands from "./docs-site-commands.mjs";
 import * as docs_site_config from "./docs-site-config.mjs";
+import * as docs_snippets from "./docs-snippets.mjs";
 import * as link_check from "./link-check.mjs";
 import * as og_image_page from "./og-image-page.mjs";
 import * as og_image from "./og-image.mjs";
 import * as og_images from "./og-images.mjs";
+import * as outdated_references from "./outdated-references.mjs";
 import * as repo_homepage from "./repo-homepage.mjs";
 import * as route_data from "./route-data.mjs";
 import * as satteri_github_alerts from "./satteri-github-alerts.mjs";
@@ -49,14 +51,16 @@ export {
   docs_site_assets as "docs-site-assets",
   docs_site_commands as "docs-site-commands",
   docs_site_config as "docs-site-config",
+  docs_snippets as "docs-snippets",
   link_check as "link-check",
   og_image as "og-image",
   og_image_page as "og-image-page",
   og_images as "og-images",
+  outdated_references as "outdated-references",
   repo_homepage as "repo-homepage",
   route_data as "route-data",
   satteri_github_alerts as "satteri-github-alerts",
   satteri_relative_links as "satteri-relative-links",
   unrendered_alerts as "unrendered-alerts"
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/docs-site/outdated-references.d.mts

@@ -0,0 +1,72 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * Finds references to the retired `obsidian-dev-utils` package that point a reader at something that no longer
+ * exists: one of its module paths, a link into its repository, or the legacy console recipe for the shared abort
+ * controller.
+ *
+ * The bare name `obsidian-dev-utils` is NOT flagged: `@mnaoumov/obsidian-lib` keeps it on purpose as a wire name (its
+ * debug namespace, CSS class and event prefix), and a migration note may name the package. What is flagged is the
+ * name used as an ADDRESS.
+ *
+ * Scanned, where present: `README.md`, the guides under `docs/src/content/docs` (not the generated API reference,
+ * which is rendered from the TSDoc this also scans), and every non-test `.ts` file under `src/` and `scripts/`.
+ * `CHANGELOG.md` is history and is not scanned. A line that names an old address on purpose, such as a migration
+ * note, carries `outdated-reference-ok` on that line.
+ */
+/**
+ * The marker that allows an outdated reference on its line.
+ */
+export declare const OUTDATED_REFERENCE_ALLOW_MARKER = "outdated-reference-ok";
+/**
+ * An outdated reference found in a file.
+ */
+export interface OutdatedReference {
+    /**
+     * The file's path, relative to the package root.
+     */
+    readonly filePath: string;
+    /**
+     * What to write instead.
+     */
+    readonly hint: string;
+    /**
+     * The 1-based line.
+     */
+    readonly line: number;
+    /**
+     * The line's text, trimmed.
+     */
+    readonly text: string;
+}
+/**
+ * Finds the outdated references in the package and throws when there is one, for a gate test or script.
+ *
+ * @param rootDirectory - The package root.
+ * @returns A promise that resolves when there is none.
+ * @throws {Error} Listing every reference, one per line.
+ */
+export declare function assertNoOutdatedReferences(rootDirectory: string): Promise<void>;
+/**
+ * Finds the outdated references in the package.
+ *
+ * @param rootDirectory - The package root.
+ * @returns The outdated references.
+ */
+export declare function findOutdatedReferences(rootDirectory: string): Promise<OutdatedReference[]>;
+/**
+ * Finds the outdated references in one file's text.
+ *
+ * @param filePath - The file's path, used in the result.
+ * @param text - The file's text.
+ * @returns The outdated references, in line order.
+ */
+export declare function findOutdatedReferencesInText(filePath: string, text: string): OutdatedReference[];
+/**
+ * Formats references one per line, as `path:line - text (hint)`.
+ *
+ * @param references - The references.
+ * @returns The formatted text.
+ */
+export declare function formatOutdatedReferences(references: readonly OutdatedReference[]): string;

package/dist/lib/esm/docs-site/outdated-references.mjs

@@ -0,0 +1,96 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+import { existsSync } from "node:fs";
+import {
+  readdir,
+  readFile
+} from "node:fs/promises";
+import {
+  join,
+  relative
+} from "node:path";
+const OUTDATED_REFERENCE_ALLOW_MARKER = "outdated-reference-ok";
+const OUTDATED_REFERENCE_PATTERNS = [
+  {
+    hint: "a module path or repository link of the retired `obsidian-dev-utils` package; name the `@mnaoumov/*` package that has it now",
+    regExp: /obsidian-dev-utils\//u
+  },
+  {
+    hint: "an import of the retired `obsidian-dev-utils` package; import the `@mnaoumov/*` package that has it now",
+    regExp: /from\s+['"]obsidian-dev-utils['"]/u
+  },
+  {
+    hint: "the legacy `__obsidianDevUtils` console recipe; use `getSharedAbortController()` or the `Symbol.for('@mnaoumov/typescript-lib/state')` slot",
+    regExp: /__obsidianDevUtils\.sharedAbortController/u
+  }
+];
+async function assertNoOutdatedReferences(rootDirectory) {
+  const references = await findOutdatedReferences(rootDirectory);
+  if (references.length > 0) {
+    throw new Error(`${String(references.length)} outdated reference(s):
+${formatOutdatedReferences(references)}`);
+  }
+}
+async function findOutdatedReferences(rootDirectory) {
+  const readmePath = join(rootDirectory, "README.md");
+  const files = [
+    ...existsSync(readmePath) ? [readmePath] : [],
+    ...await listFiles(join(rootDirectory, "docs", "src", "content", "docs"), (name) => /\.mdx?$/u.test(name), ["api"]),
+    ...await listFiles(join(rootDirectory, "src"), isScannedSource, []),
+    ...await listFiles(join(rootDirectory, "scripts"), isScannedSource, [])
+  ];
+  const references = [];
+  for (const file of files) {
+    references.push(...findOutdatedReferencesInText(relative(rootDirectory, file).replaceAll("\\", "/"), await readFile(file, "utf-8")));
+  }
+  return references;
+}
+function findOutdatedReferencesInText(filePath, text) {
+  const references = [];
+  for (const [index, line] of text.split(/\r?\n/u).entries()) {
+    if (line.includes(OUTDATED_REFERENCE_ALLOW_MARKER)) {
+      continue;
+    }
+    for (const pattern of OUTDATED_REFERENCE_PATTERNS) {
+      if (pattern.regExp.test(line)) {
+        references.push({ filePath, hint: pattern.hint, line: index + 1, text: line.trim() });
+        break;
+      }
+    }
+  }
+  return references;
+}
+function formatOutdatedReferences(references) {
+  return references.map((reference) => `${reference.filePath}:${String(reference.line)} - ${reference.text} (${reference.hint})`).join("\n");
+}
+function isScannedSource(name) {
+  return name.endsWith(".ts") && !name.endsWith(".d.ts") && !name.endsWith(".test.ts") && name !== "__merged.ts";
+}
+async function listFiles(directory, isIncluded, excludedDirectories) {
+  const files = [];
+  if (!existsSync(directory)) {
+    return files;
+  }
+  for (const entry of await readdir(directory, { withFileTypes: true })) {
+    const entryPath = join(directory, entry.name);
+    if (entry.isDirectory()) {
+      if (!excludedDirectories.includes(entry.name)) {
+        files.push(...await listFiles(entryPath, isIncluded, excludedDirectories));
+      }
+    } else if (isIncluded(entry.name)) {
+      files.push(entryPath);
+    }
+  }
+  return files.sort();
+}
+export {
+  OUTDATED_REFERENCE_ALLOW_MARKER,
+  assertNoOutdatedReferences,
+  findOutdatedReferences,
+  findOutdatedReferencesInText,
+  formatOutdatedReferences
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/docs-site/outdated-references.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Finds references to the retired `obsidian-dev-utils` package that point a reader at something that no longer\n * exists: one of its module paths, a link into its repository, or the legacy console recipe for the shared abort\n * controller.\n *\n * The bare name `obsidian-dev-utils` is NOT flagged: `@mnaoumov/obsidian-lib` keeps it on purpose as a wire name (its\n * debug namespace, CSS class and event prefix), and a migration note may name the package. What is flagged is the\n * name used as an ADDRESS.\n *\n * Scanned, where present: `README.md`, the guides under `docs/src/content/docs` (not the generated API reference,\n * which is rendered from the TSDoc this also scans), and every non-test `.ts` file under `src/` and `scripts/`.\n * `CHANGELOG.md` is history and is not scanned. A line that names an old address on purpose, such as a migration\n * note, carries `outdated-reference-ok` on that line.\n */\n\nimport { existsSync } from 'node:fs';\nimport {\n  readdir,\n  readFile\n} from 'node:fs/promises';\nimport {\n  join,\n  relative\n} from 'node:path';\n\n/**\n * The marker that allows an outdated reference on its line.\n */\nexport const OUTDATED_REFERENCE_ALLOW_MARKER = 'outdated-reference-ok';\n\ninterface OutdatedReferencePattern {\n  readonly hint: string;\n  readonly regExp: RegExp;\n}\n\nconst OUTDATED_REFERENCE_PATTERNS: readonly OutdatedReferencePattern[] = [\n  {\n    hint: 'a module path or repository link of the retired `obsidian-dev-utils` package; name the `@mnaoumov/*` package that has it now',\n    regExp: /obsidian-dev-utils\\//u\n  },\n  {\n    hint: 'an import of the retired `obsidian-dev-utils` package; import the `@mnaoumov/*` package that has it now',\n    regExp: /from\\s+['\"]obsidian-dev-utils['\"]/u\n  },\n  {\n    hint: 'the legacy `__obsidianDevUtils` console recipe; use `getSharedAbortController()` or the `Symbol.for(\\'@mnaoumov/typescript-lib/state\\')` slot',\n    regExp: /__obsidianDevUtils\\.sharedAbortController/u\n  }\n];\n\n/**\n * An outdated reference found in a file.\n */\nexport interface OutdatedReference {\n  /**\n   * The file's path, relative to the package root.\n   */\n  readonly filePath: string;\n\n  /**\n   * What to write instead.\n   */\n  readonly hint: string;\n\n  /**\n   * The 1-based line.\n   */\n  readonly line: number;\n\n  /**\n   * The line's text, trimmed.\n   */\n  readonly text: string;\n}\n\n/**\n * Finds the outdated references in the package and throws when there is one, for a gate test or script.\n *\n * @param rootDirectory - The package root.\n * @returns A promise that resolves when there is none.\n * @throws {Error} Listing every reference, one per line.\n */\nexport async function assertNoOutdatedReferences(rootDirectory: string): Promise<void> {\n  const references = await findOutdatedReferences(rootDirectory);\n  if (references.length > 0) {\n    throw new Error(`${String(references.length)} outdated reference(s):\\n${formatOutdatedReferences(references)}`);\n  }\n}\n\n/**\n * Finds the outdated references in the package.\n *\n * @param rootDirectory - The package root.\n * @returns The outdated references.\n */\nexport async function findOutdatedReferences(rootDirectory: string): Promise<OutdatedReference[]> {\n  const readmePath = join(rootDirectory, 'README.md');\n  const files = [\n    ...existsSync(readmePath) ? [readmePath] : [],\n    ...await listFiles(join(rootDirectory, 'docs', 'src', 'content', 'docs'), (name) => /\\.mdx?$/u.test(name), ['api']),\n    ...await listFiles(join(rootDirectory, 'src'), isScannedSource, []),\n    ...await listFiles(join(rootDirectory, 'scripts'), isScannedSource, [])\n  ];\n  const references: OutdatedReference[] = [];\n  for (const file of files) {\n    references.push(...findOutdatedReferencesInText(relative(rootDirectory, file).replaceAll('\\\\', '/'), await readFile(file, 'utf-8')));\n  }\n  return references;\n}\n\n/**\n * Finds the outdated references in one file's text.\n *\n * @param filePath - The file's path, used in the result.\n * @param text - The file's text.\n * @returns The outdated references, in line order.\n */\nexport function findOutdatedReferencesInText(filePath: string, text: string): OutdatedReference[] {\n  const references: OutdatedReference[] = [];\n  for (const [index, line] of text.split(/\\r?\\n/u).entries()) {\n    if (line.includes(OUTDATED_REFERENCE_ALLOW_MARKER)) {\n      continue;\n    }\n    for (const pattern of OUTDATED_REFERENCE_PATTERNS) {\n      if (pattern.regExp.test(line)) {\n        references.push({ filePath, hint: pattern.hint, line: index + 1, text: line.trim() });\n        break;\n      }\n    }\n  }\n  return references;\n}\n\n/**\n * Formats references one per line, as `path:line - text (hint)`.\n *\n * @param references - The references.\n * @returns The formatted text.\n */\nexport function formatOutdatedReferences(references: readonly OutdatedReference[]): string {\n  return references.map((reference) => `${reference.filePath}:${String(reference.line)} - ${reference.text} (${reference.hint})`).join('\\n');\n}\n\nfunction isScannedSource(name: string): boolean {\n  return name.endsWith('.ts') && !name.endsWith('.d.ts') && !name.endsWith('.test.ts') && name !== '__merged.ts';\n}\n\nasync function listFiles(directory: string, isIncluded: (name: string) => boolean, excludedDirectories: readonly string[]): Promise<string[]> {\n  const files: string[] = [];\n  if (!existsSync(directory)) {\n    return files;\n  }\n  for (const entry of await readdir(directory, { withFileTypes: true })) {\n    const entryPath = join(directory, entry.name);\n    if (entry.isDirectory()) {\n      if (!excludedDirectories.includes(entry.name)) {\n        files.push(...await listFiles(entryPath, isIncluded, excludedDirectories));\n      }\n    } else if (isIncluded(entry.name)) {\n      files.push(entryPath);\n    }\n  }\n  return files.sort();\n}\n"],
  "mappings": ";;;;;AAiBA,SAAS,kBAAkB;AAC3B;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAKA,MAAM,kCAAkC;AAO/C,MAAM,8BAAmE;AAAA,EACvE;AAAA,IACE,MAAM;AAAA,IACN,QAAQ;AAAA,EACV;AAAA,EACA;AAAA,IACE,MAAM;AAAA,IACN,QAAQ;AAAA,EACV;AAAA,EACA;AAAA,IACE,MAAM;AAAA,IACN,QAAQ;AAAA,EACV;AACF;AAkCA,eAAsB,2BAA2B,eAAsC;AACrF,QAAM,aAAa,MAAM,uBAAuB,aAAa;AAC7D,MAAI,WAAW,SAAS,GAAG;AACzB,UAAM,IAAI,MAAM,GAAG,OAAO,WAAW,MAAM,CAAC;AAAA,EAA4B,yBAAyB,UAAU,CAAC,EAAE;AAAA,EAChH;AACF;AAQA,eAAsB,uBAAuB,eAAqD;AAChG,QAAM,aAAa,KAAK,eAAe,WAAW;AAClD,QAAM,QAAQ;AAAA,IACZ,GAAG,WAAW,UAAU,IAAI,CAAC,UAAU,IAAI,CAAC;AAAA,IAC5C,GAAG,MAAM,UAAU,KAAK,eAAe,QAAQ,OAAO,WAAW,MAAM,GAAG,CAAC,SAAS,WAAW,KAAK,IAAI,GAAG,CAAC,KAAK,CAAC;AAAA,IAClH,GAAG,MAAM,UAAU,KAAK,eAAe,KAAK,GAAG,iBAAiB,CAAC,CAAC;AAAA,IAClE,GAAG,MAAM,UAAU,KAAK,eAAe,SAAS,GAAG,iBAAiB,CAAC,CAAC;AAAA,EACxE;AACA,QAAM,aAAkC,CAAC;AACzC,aAAW,QAAQ,OAAO;AACxB,eAAW,KAAK,GAAG,6BAA6B,SAAS,eAAe,IAAI,EAAE,WAAW,MAAM,GAAG,GAAG,MAAM,SAAS,MAAM,OAAO,CAAC,CAAC;AAAA,EACrI;AACA,SAAO;AACT;AASO,SAAS,6BAA6B,UAAkB,MAAmC;AAChG,QAAM,aAAkC,CAAC;AACzC,aAAW,CAAC,OAAO,IAAI,KAAK,KAAK,MAAM,QAAQ,EAAE,QAAQ,GAAG;AAC1D,QAAI,KAAK,SAAS,+BAA+B,GAAG;AAClD;AAAA,IACF;AACA,eAAW,WAAW,6BAA6B;AACjD,UAAI,QAAQ,OAAO,KAAK,IAAI,GAAG;AAC7B,mBAAW,KAAK,EAAE,UAAU,MAAM,QAAQ,MAAM,MAAM,QAAQ,GAAG,MAAM,KAAK,KAAK,EAAE,CAAC;AACpF;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACA,SAAO;AACT;AAQO,SAAS,yBAAyB,YAAkD;AACzF,SAAO,WAAW,IAAI,CAAC,cAAc,GAAG,UAAU,QAAQ,IAAI,OAAO,UAAU,IAAI,CAAC,MAAM,UAAU,IAAI,KAAK,UAAU,IAAI,GAAG,EAAE,KAAK,IAAI;AAC3I;AAEA,SAAS,gBAAgB,MAAuB;AAC9C,SAAO,KAAK,SAAS,KAAK,KAAK,CAAC,KAAK,SAAS,OAAO,KAAK,CAAC,KAAK,SAAS,UAAU,KAAK,SAAS;AACnG;AAEA,eAAe,UAAU,WAAmB,YAAuC,qBAA2D;AAC5I,QAAM,QAAkB,CAAC;AACzB,MAAI,CAAC,WAAW,SAAS,GAAG;AAC1B,WAAO;AAAA,EACT;AACA,aAAW,SAAS,MAAM,QAAQ,WAAW,EAAE,eAAe,KAAK,CAAC,GAAG;AACrE,UAAM,YAAY,KAAK,WAAW,MAAM,IAAI;AAC5C,QAAI,MAAM,YAAY,GAAG;AACvB,UAAI,CAAC,oBAAoB,SAAS,MAAM,IAAI,GAAG;AAC7C,cAAM,KAAK,GAAG,MAAM,UAAU,WAAW,YAAY,mBAAmB,CAAC;AAAA,MAC3E;AAAA,IACF,WAAW,WAAW,MAAM,IAAI,GAAG;AACjC,YAAM,KAAK,SAAS;AAAA,IACtB;AAAA,EACF;AACA,SAAO,MAAM,KAAK;AACpB;",
  "names": []
}


package/docs-site/docs-snippets/package.json

@@ -0,0 +1,6 @@
+{
+  "main": "../../dist/lib/cjs/docs-site/docs-snippets.cjs",
+  "module": "../../dist/lib/esm/docs-site/docs-snippets.mjs",
+  "type": "module",
+  "types": "../../dist/lib/cjs/docs-site/docs-snippets.d.cts"
+}

package/docs-site/outdated-references/package.json

@@ -0,0 +1,6 @@
+{
+  "main": "../../dist/lib/cjs/docs-site/outdated-references.cjs",
+  "module": "../../dist/lib/esm/docs-site/outdated-references.mjs",
+  "type": "module",
+  "types": "../../dist/lib/cjs/docs-site/outdated-references.d.cts"
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mnaoumov/typescript-dev-toolkit",
-  "version": "3.6.4",
+  "version": "3.7.0",
   "description": "Generic TypeScript project tooling: build, lint, format, spellcheck, test, gate and release scripts.",
   "keywords": [
     "typescript",
@@ -262,6 +262,7 @@
     "build:validate-dependencies": "jiti scripts/build-validate-dependencies.ts",
     "commit": "jiti scripts/commit.ts",
     "docs:build": "jiti scripts/docs-build.ts",
+    "docs:check-snippets": "jiti scripts/docs-check-snippets.ts",
     "docs:dev": "jiti scripts/docs-dev.ts",
     "docs:preview": "jiti scripts/docs-preview.ts",
     "find-overexposed": "jiti scripts/find-overexposed.ts",