@mnaoumov/typescript-dev-toolkit 1.3.0 → 2.0.0

package/dist/lib/esm/docs-site/link-check.d.mts

@@ -0,0 +1,163 @@
+/// <reference path="../library-references.d.mts" />
+/// <reference lib="dom" />
+/**
+ * @file
+ *
+ * Validation of the links emitted by the built documentation HTML.
+ *
+ * Internal (same-site) links are validated offline: every `href`/`src` must resolve to a real
+ * file in the build output, and every `#fragment` must resolve to a real element id on the
+ * target page.
+ *
+ * External links can only be validated over the network, so those requests are heavily
+ * deduplicated — each unique external URL is fetched at most once regardless of how many of the
+ * thousands of generated pages reference it — and run through a bounded concurrency pool.
+ */
+/**
+ * The {@link BrokenLink.httpStatus} sentinel for a network-level failure (timeout, DNS,
+ * connection refused) where no HTTP response was received.
+ */
+export declare const NETWORK_FAILURE_STATUS = 0;
+/**
+ * A single link that does not resolve.
+ */
+export interface BrokenLink {
+    /**
+     * The HTTP status returned by an external link, when {@link BrokenLink.reason} is
+     * `external-error`. `0` denotes a network-level failure (timeout, DNS, connection refused).
+     */
+    httpStatus?: number;
+    /**
+     * The absolute URL of the page that contains the broken link.
+     */
+    pageUrl: string;
+    /**
+     * Why the link is considered broken.
+     */
+    reason: 'external-error' | 'missing-fragment' | 'missing-page';
+    /**
+     * The resolved absolute URL the link points at.
+     */
+    targetUrl: string;
+}
+/**
+ * A single built documentation page to validate.
+ */
+export interface DocumentationPage {
+    /**
+     * The page's rendered HTML.
+     */
+    html: string;
+    /**
+     * The page's path relative to the build-output root, e.g. `api/foo/index.html`.
+     */
+    relativePath: string;
+}
+/**
+ * Filesystem access the link checker needs, injected so the pure decision logic can be tested
+ * against an in-memory stub instead of a real build output.
+ */
+export interface LinkCheckFileSystem {
+    /**
+     * Reads the element ids present on an already-resolved page.
+     *
+     * @param pageKey - The key returned by {@link LinkCheckFileSystem.resolveExistingPage}.
+     * @returns The set of element ids on that page.
+     */
+    readIds: (pageKey: string) => Set<string>;
+    /**
+     * Resolves an output-relative path to an existing page.
+     *
+     * @param outputRelativePath - The decoded path relative to the build-output root.
+     * @returns A stable key (e.g. the resolved absolute file path) for the existing page, or
+     *   `null` when nothing exists at that path or the path escapes the build-output root.
+     */
+    resolveExistingPage: (outputRelativePath: string) => null | string;
+}
+/**
+ * Validates the deduplicated external URLs over the network through a bounded concurrency pool.
+ *
+ * @param targets - The unique external URL → referencing page map from {@link collectExternalTargets}.
+ * @param fetchUrlStatus - Injected probe returning the HTTP status for a URL (`0` for a network failure).
+ * @param concurrency - The maximum number of in-flight probes.
+ * @returns Every external URL that did not return HTTP `200`, in the map's iteration order.
+ */
+export declare function collectBrokenExternalLinks(targets: Map<string, string>, fetchUrlStatus: (url: string) => Promise<number>, concurrency: number): Promise<BrokenLink[]>;
+/**
+ * Finds every internal link across the built documentation pages that does not resolve.
+ *
+ * External and non-HTTP links are ignored. Each internal link must resolve to an existing page,
+ * and each `#fragment` must resolve to an existing element id on the target page.
+ *
+ * @param pages - The built documentation pages to validate.
+ * @param fileSystem - Injected access to the build output.
+ * @param siteBaseUrl - The absolute base URL the site is served from (with a trailing slash).
+ * @returns Every broken internal link, in page-then-document order.
+ */
+export declare function collectBrokenLinks(pages: DocumentationPage[], fileSystem: LinkCheckFileSystem, siteBaseUrl: string): BrokenLink[];
+/**
+ * Collects every unique external URL referenced across the built pages, deduplicated.
+ *
+ * Only HTTP(S) links that are not {@link isInternalDocUrl} are returned. Each unique URL maps to
+ * the first page that referenced it, so a later failure can be reported with a concrete example
+ * page even though the URL is fetched only once.
+ *
+ * @param pages - The built documentation pages to scan.
+ * @param siteBaseUrl - The absolute base URL the site is served from (with a trailing slash).
+ * @returns A map from each unique external URL to one referencing page URL.
+ */
+export declare function collectExternalTargets(pages: DocumentationPage[], siteBaseUrl: string): Map<string, string>;
+/**
+ * Extracts the values of every `id` attribute in a chunk of HTML.
+ *
+ * @param html - The HTML to scan.
+ * @returns The set of element ids.
+ */
+export declare function extractIds(html: string): Set<string>;
+/**
+ * Extracts the values of every `href`/`src` attribute in a chunk of HTML.
+ *
+ * @param html - The HTML to scan.
+ * @returns The raw link values, in document order (duplicates preserved).
+ */
+export declare function extractLinks(html: string): string[];
+/**
+ * Formats broken links into a human-readable multi-line report.
+ *
+ * @param brokenLinks - The broken links to describe.
+ * @returns One line per broken link.
+ */
+export declare function formatBrokenLinks(brokenLinks: BrokenLink[]): string;
+/**
+ * Computes the build-output-relative path for an internal documentation URL.
+ *
+ * @param targetUrl - The resolved absolute link URL (must be {@link isInternalDocUrl}).
+ * @param siteBaseUrl - The absolute base URL the site is served from (with a trailing slash).
+ * @returns The decoded path relative to the build-output root.
+ */
+export declare function getOutputRelativePath(targetUrl: URL, siteBaseUrl: string): string;
+/**
+ * Computes the absolute URL a built page is served at.
+ *
+ * @param relativePath - The page's path relative to the build-output root.
+ * @param siteBaseUrl - The absolute base URL the site is served from (with a trailing slash).
+ * @returns The page's absolute URL.
+ */
+export declare function getPageUrl(relativePath: string, siteBaseUrl: string): string;
+/**
+ * Determines whether a resolved link points at a page hosted by this documentation site.
+ *
+ * @param targetUrl - The resolved absolute link URL.
+ * @param siteBaseUrl - The absolute base URL the site is served from (with a trailing slash).
+ * @returns `true` when the link is same-origin and under the site base path.
+ */
+export declare function isInternalDocUrl(targetUrl: URL, siteBaseUrl: string): boolean;
+/**
+ * Resolves an output-relative path to an absolute path inside the build-output root, rejecting
+ * paths that escape it via `..` segments.
+ *
+ * @param outputRootPath - The absolute build-output root path.
+ * @param outputRelativePath - The decoded output-relative path.
+ * @returns The joined path when it stays within the root, otherwise `null`.
+ */
+export declare function resolveWithinRoot(outputRootPath: string, outputRelativePath: string): null | string;

package/dist/lib/esm/docs-site/link-check.mjs

@@ -0,0 +1,166 @@
+/*
+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 { getMandatoryNamedGroup } from "@mnaoumov/typescript-lib/reg-exp";
+import {
+  assertNever,
+  ensureNonNullable
+} from "@mnaoumov/typescript-lib/type-guards";
+import { normalize } from "node:path/posix";
+const LINK_ATTRIBUTE_REGEX = /\b(?:href|src)=(?<quote>['"])(?<value>.*?)\k<quote>/giu;
+const ID_ATTRIBUTE_REGEX = /\bid=(?<quote>['"])(?<value>.*?)\k<quote>/giu;
+const HTTP_OK_STATUS = 200;
+const NETWORK_FAILURE_STATUS = 0;
+async function collectBrokenExternalLinks(targets, fetchUrlStatus, concurrency) {
+  const entries = [...targets];
+  const results = Array.from({ length: entries.length }, () => null);
+  let nextIndex = 0;
+  async function runWorker() {
+    for (let index = nextIndex++; index < entries.length; index = nextIndex++) {
+      const [externalUrl, pageUrl] = ensureNonNullable(entries[index]);
+      const httpStatus = await fetchUrlStatus(externalUrl);
+      if (httpStatus !== HTTP_OK_STATUS) {
+        results[index] = { httpStatus, pageUrl, reason: "external-error", targetUrl: externalUrl };
+      }
+    }
+  }
+  const workerCount = Math.max(1, Math.min(concurrency, entries.length));
+  await Promise.all(Array.from({ length: workerCount }, () => runWorker()));
+  return results.filter((brokenLink) => brokenLink !== null);
+}
+function collectBrokenLinks(pages, fileSystem, siteBaseUrl) {
+  const brokenLinks = [];
+  for (const page of pages) {
+    const pageUrl = getPageUrl(page.relativePath, siteBaseUrl);
+    for (const rawLink of extractLinks(page.html)) {
+      const targetUrl = new URL(rawLink, pageUrl);
+      if (!isInternalDocUrl(targetUrl, siteBaseUrl)) {
+        continue;
+      }
+      const pageKey = fileSystem.resolveExistingPage(getOutputRelativePath(targetUrl, siteBaseUrl));
+      if (pageKey === null) {
+        brokenLinks.push({ pageUrl, reason: "missing-page", targetUrl: targetUrl.href });
+        continue;
+      }
+      const fragment = targetUrl.hash.slice(1);
+      if (fragment.length > 0 && !fileSystem.readIds(pageKey).has(fragment)) {
+        brokenLinks.push({ pageUrl, reason: "missing-fragment", targetUrl: targetUrl.href });
+      }
+    }
+  }
+  return brokenLinks;
+}
+function collectExternalTargets(pages, siteBaseUrl) {
+  const targets = /* @__PURE__ */ new Map();
+  for (const page of pages) {
+    const pageUrl = getPageUrl(page.relativePath, siteBaseUrl);
+    for (const rawLink of extractLinks(page.html)) {
+      const targetUrl = new URL(rawLink, pageUrl);
+      if (targetUrl.protocol !== "http:" && targetUrl.protocol !== "https:" || isInternalDocUrl(targetUrl, siteBaseUrl)) {
+        continue;
+      }
+      const externalUrl = `${targetUrl.origin}${targetUrl.pathname}${targetUrl.search}`;
+      if (!targets.has(externalUrl)) {
+        targets.set(externalUrl, pageUrl);
+      }
+    }
+  }
+  return targets;
+}
+function extractIds(html) {
+  return new Set([...html.matchAll(ID_ATTRIBUTE_REGEX)].map((match) => getMandatoryNamedGroup(match, "value")));
+}
+function extractLinks(html) {
+  return [...html.matchAll(LINK_ATTRIBUTE_REGEX)].map((match) => getMandatoryNamedGroup(match, "value"));
+}
+function formatBrokenLinks(brokenLinks) {
+  return brokenLinks.map((brokenLink) => {
+    switch (brokenLink.reason) {
+      case "external-error": {
+        return `${brokenLink.pageUrl} links to external URL ${brokenLink.targetUrl} that returned ${describeHttpStatus(brokenLink.httpStatus)}.`;
+      }
+      case "missing-fragment": {
+        return `${brokenLink.pageUrl} links to missing fragment ${brokenLink.targetUrl}.`;
+      }
+      case "missing-page": {
+        return `${brokenLink.pageUrl} links to missing page ${brokenLink.targetUrl}.`;
+      }
+      default: {
+        return assertNever(brokenLink.reason);
+      }
+    }
+  }).join("\n");
+}
+function getOutputRelativePath(targetUrl, siteBaseUrl) {
+  const base = new URL(siteBaseUrl);
+  return decodeURIComponent(targetUrl.pathname.slice(base.pathname.length));
+}
+function getPageUrl(relativePath, siteBaseUrl) {
+  const normalized = relativePath.replaceAll("\\", "/");
+  const urlPath = normalized === "index.html" ? "" : normalized.replace(/index\.html$/u, "");
+  return new URL(urlPath, siteBaseUrl).href;
+}
+function isInternalDocUrl(targetUrl, siteBaseUrl) {
+  const base = new URL(siteBaseUrl);
+  return targetUrl.origin === base.origin && targetUrl.pathname.startsWith(base.pathname);
+}
+function resolveWithinRoot(outputRootPath, outputRelativePath) {
+  const root = normalize(outputRootPath.replaceAll("\\", "/")).replace(/\/$/u, "");
+  let joined = normalize(`${root}/${outputRelativePath.replaceAll("\\", "/")}`);
+  if (joined.length > 1) {
+    joined = joined.replace(/\/$/u, "");
+  }
+  return joined !== root && !joined.startsWith(`${root}/`) ? null : joined;
+}
+function describeHttpStatus(httpStatus) {
+  return httpStatus === void 0 || httpStatus === NETWORK_FAILURE_STATUS ? "a network failure" : `HTTP ${String(httpStatus)}`;
+}
+export {
+  NETWORK_FAILURE_STATUS,
+  collectBrokenExternalLinks,
+  collectBrokenLinks,
+  collectExternalTargets,
+  extractIds,
+  extractLinks,
+  formatBrokenLinks,
+  getOutputRelativePath,
+  getPageUrl,
+  isInternalDocUrl,
+  resolveWithinRoot
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/docs-site/link-check.ts"],"sourcesContent":["/**\n * @file\n *\n * Validation of the links emitted by the built documentation HTML.\n *\n * Internal (same-site) links are validated offline: every `href`/`src` must resolve to a real\n * file in the build output, and every `#fragment` must resolve to a real element id on the\n * target page.\n *\n * External links can only be validated over the network, so those requests are heavily\n * deduplicated — each unique external URL is fetched at most once regardless of how many of the\n * thousands of generated pages reference it — and run through a bounded concurrency pool.\n */\n\nimport { getMandatoryNamedGroup } from '@mnaoumov/typescript-lib/reg-exp';\nimport {\n  assertNever,\n  ensureNonNullable\n} from '@mnaoumov/typescript-lib/type-guards';\nimport { normalize } from 'node:path/posix';\n\nconst LINK_ATTRIBUTE_REGEX = /\\b(?:href|src)=(?<quote>['\"])(?<value>.*?)\\k<quote>/giu;\nconst ID_ATTRIBUTE_REGEX = /\\bid=(?<quote>['\"])(?<value>.*?)\\k<quote>/giu;\nconst HTTP_OK_STATUS = 200;\n\n/**\n * The {@link BrokenLink.httpStatus} sentinel for a network-level failure (timeout, DNS,\n * connection refused) where no HTTP response was received.\n */\nexport const NETWORK_FAILURE_STATUS = 0;\n\n/**\n * A single link that does not resolve.\n */\nexport interface BrokenLink {\n  /**\n   * The HTTP status returned by an external link, when {@link BrokenLink.reason} is\n   * `external-error`. `0` denotes a network-level failure (timeout, DNS, connection refused).\n   */\n  httpStatus?: number;\n\n  /**\n   * The absolute URL of the page that contains the broken link.\n   */\n  pageUrl: string;\n\n  /**\n   * Why the link is considered broken.\n   */\n  reason: 'external-error' | 'missing-fragment' | 'missing-page';\n\n  /**\n   * The resolved absolute URL the link points at.\n   */\n  targetUrl: string;\n}\n\n/**\n * A single built documentation page to validate.\n */\nexport interface DocumentationPage {\n  /**\n   * The page's rendered HTML.\n   */\n  html: string;\n\n  /**\n   * The page's path relative to the build-output root, e.g. `api/foo/index.html`.\n   */\n  relativePath: string;\n}\n\n/**\n * Filesystem access the link checker needs, injected so the pure decision logic can be tested\n * against an in-memory stub instead of a real build output.\n */\nexport interface LinkCheckFileSystem {\n  /**\n   * Reads the element ids present on an already-resolved page.\n   *\n   * @param pageKey - The key returned by {@link LinkCheckFileSystem.resolveExistingPage}.\n   * @returns The set of element ids on that page.\n   */\n  readIds: (pageKey: string) => Set<string>;\n\n  /**\n   * Resolves an output-relative path to an existing page.\n   *\n   * @param outputRelativePath - The decoded path relative to the build-output root.\n   * @returns A stable key (e.g. the resolved absolute file path) for the existing page, or\n   *   `null` when nothing exists at that path or the path escapes the build-output root.\n   */\n  resolveExistingPage: (outputRelativePath: string) => null | string;\n}\n\n/**\n * Validates the deduplicated external URLs over the network through a bounded concurrency pool.\n *\n * @param targets - The unique external URL → referencing page map from {@link collectExternalTargets}.\n * @param fetchUrlStatus - Injected probe returning the HTTP status for a URL (`0` for a network failure).\n * @param concurrency - The maximum number of in-flight probes.\n * @returns Every external URL that did not return HTTP `200`, in the map's iteration order.\n */\nexport async function collectBrokenExternalLinks(\n  targets: Map<string, string>,\n  fetchUrlStatus: (url: string) => Promise<number>,\n  concurrency: number\n): Promise<BrokenLink[]> {\n  const entries = [...targets];\n  const results: (BrokenLink | null)[] = Array.from({ length: entries.length }, () => null);\n  let nextIndex = 0;\n\n  async function runWorker(): Promise<void> {\n    for (let index = nextIndex++; index < entries.length; index = nextIndex++) {\n      const [externalUrl, pageUrl] = ensureNonNullable(entries[index]);\n      const httpStatus = await fetchUrlStatus(externalUrl);\n      if (httpStatus !== HTTP_OK_STATUS) {\n        results[index] = { httpStatus, pageUrl, reason: 'external-error', targetUrl: externalUrl };\n      }\n    }\n  }\n\n  const workerCount = Math.max(1, Math.min(concurrency, entries.length));\n  await Promise.all(Array.from({ length: workerCount }, () => runWorker()));\n\n  // Indexed assignment above keeps failures in the map's iteration order; drop the successful gaps.\n  return results.filter((brokenLink): brokenLink is BrokenLink => brokenLink !== null);\n}\n\n/**\n * Finds every internal link across the built documentation pages that does not resolve.\n *\n * External and non-HTTP links are ignored. Each internal link must resolve to an existing page,\n * and each `#fragment` must resolve to an existing element id on the target page.\n *\n * @param pages - The built documentation pages to validate.\n * @param fileSystem - Injected access to the build output.\n * @param siteBaseUrl - The absolute base URL the site is served from (with a trailing slash).\n * @returns Every broken internal link, in page-then-document order.\n */\nexport function collectBrokenLinks(pages: DocumentationPage[], fileSystem: LinkCheckFileSystem, siteBaseUrl: string): BrokenLink[] {\n  const brokenLinks: BrokenLink[] = [];\n\n  for (const page of pages) {\n    const pageUrl = getPageUrl(page.relativePath, siteBaseUrl);\n    for (const rawLink of extractLinks(page.html)) {\n      const targetUrl = new URL(rawLink, pageUrl);\n      if (!isInternalDocUrl(targetUrl, siteBaseUrl)) {\n        continue;\n      }\n\n      const pageKey = fileSystem.resolveExistingPage(getOutputRelativePath(targetUrl, siteBaseUrl));\n      if (pageKey === null) {\n        brokenLinks.push({ pageUrl, reason: 'missing-page', targetUrl: targetUrl.href });\n        continue;\n      }\n\n      const fragment = targetUrl.hash.slice(1);\n      if (fragment.length > 0 && !fileSystem.readIds(pageKey).has(fragment)) {\n        brokenLinks.push({ pageUrl, reason: 'missing-fragment', targetUrl: targetUrl.href });\n      }\n    }\n  }\n\n  return brokenLinks;\n}\n\n/**\n * Collects every unique external URL referenced across the built pages, deduplicated.\n *\n * Only HTTP(S) links that are not {@link isInternalDocUrl} are returned. Each unique URL maps to\n * the first page that referenced it, so a later failure can be reported with a concrete example\n * page even though the URL is fetched only once.\n *\n * @param pages - The built documentation pages to scan.\n * @param siteBaseUrl - The absolute base URL the site is served from (with a trailing slash).\n * @returns A map from each unique external URL to one referencing page URL.\n */\nexport function collectExternalTargets(pages: DocumentationPage[], siteBaseUrl: string): Map<string, string> {\n  const targets = new Map<string, string>();\n\n  for (const page of pages) {\n    const pageUrl = getPageUrl(page.relativePath, siteBaseUrl);\n    for (const rawLink of extractLinks(page.html)) {\n      const targetUrl = new URL(rawLink, pageUrl);\n      if ((targetUrl.protocol !== 'http:' && targetUrl.protocol !== 'https:') || isInternalDocUrl(targetUrl, siteBaseUrl)) {\n        continue;\n      }\n\n      const externalUrl = `${targetUrl.origin}${targetUrl.pathname}${targetUrl.search}`;\n      if (!targets.has(externalUrl)) {\n        targets.set(externalUrl, pageUrl);\n      }\n    }\n  }\n\n  return targets;\n}\n\n/**\n * Extracts the values of every `id` attribute in a chunk of HTML.\n *\n * @param html - The HTML to scan.\n * @returns The set of element ids.\n */\nexport function extractIds(html: string): Set<string> {\n  return new Set([...html.matchAll(ID_ATTRIBUTE_REGEX)].map((match) => getMandatoryNamedGroup(match, 'value')));\n}\n\n/**\n * Extracts the values of every `href`/`src` attribute in a chunk of HTML.\n *\n * @param html - The HTML to scan.\n * @returns The raw link values, in document order (duplicates preserved).\n */\nexport function extractLinks(html: string): string[] {\n  return [...html.matchAll(LINK_ATTRIBUTE_REGEX)].map((match) => getMandatoryNamedGroup(match, 'value'));\n}\n\n/**\n * Formats broken links into a human-readable multi-line report.\n *\n * @param brokenLinks - The broken links to describe.\n * @returns One line per broken link.\n */\nexport function formatBrokenLinks(brokenLinks: BrokenLink[]): string {\n  return brokenLinks\n    .map((brokenLink) => {\n      switch (brokenLink.reason) {\n        case 'external-error': {\n          return `${brokenLink.pageUrl} links to external URL ${brokenLink.targetUrl} that returned ${describeHttpStatus(brokenLink.httpStatus)}.`;\n        }\n        case 'missing-fragment': {\n          return `${brokenLink.pageUrl} links to missing fragment ${brokenLink.targetUrl}.`;\n        }\n        case 'missing-page': {\n          return `${brokenLink.pageUrl} links to missing page ${brokenLink.targetUrl}.`;\n        }\n        default: {\n          return assertNever(brokenLink.reason);\n        }\n      }\n    })\n    .join('\\n');\n}\n\n/**\n * Computes the build-output-relative path for an internal documentation URL.\n *\n * @param targetUrl - The resolved absolute link URL (must be {@link isInternalDocUrl}).\n * @param siteBaseUrl - The absolute base URL the site is served from (with a trailing slash).\n * @returns The decoded path relative to the build-output root.\n */\nexport function getOutputRelativePath(targetUrl: URL, siteBaseUrl: string): string {\n  const base = new URL(siteBaseUrl);\n  return decodeURIComponent(targetUrl.pathname.slice(base.pathname.length));\n}\n\n/**\n * Computes the absolute URL a built page is served at.\n *\n * @param relativePath - The page's path relative to the build-output root.\n * @param siteBaseUrl - The absolute base URL the site is served from (with a trailing slash).\n * @returns The page's absolute URL.\n */\nexport function getPageUrl(relativePath: string, siteBaseUrl: string): string {\n  const normalized = relativePath.replaceAll('\\\\', '/');\n  const urlPath = normalized === 'index.html' ? '' : normalized.replace(/index\\.html$/u, '');\n  return new URL(urlPath, siteBaseUrl).href;\n}\n\n/**\n * Determines whether a resolved link points at a page hosted by this documentation site.\n *\n * @param targetUrl - The resolved absolute link URL.\n * @param siteBaseUrl - The absolute base URL the site is served from (with a trailing slash).\n * @returns `true` when the link is same-origin and under the site base path.\n */\nexport function isInternalDocUrl(targetUrl: URL, siteBaseUrl: string): boolean {\n  const base = new URL(siteBaseUrl);\n  return targetUrl.origin === base.origin && targetUrl.pathname.startsWith(base.pathname);\n}\n\n/**\n * Resolves an output-relative path to an absolute path inside the build-output root, rejecting\n * paths that escape it via `..` segments.\n *\n * @param outputRootPath - The absolute build-output root path.\n * @param outputRelativePath - The decoded output-relative path.\n * @returns The joined path when it stays within the root, otherwise `null`.\n */\nexport function resolveWithinRoot(outputRootPath: string, outputRelativePath: string): null | string {\n  const root = normalize(outputRootPath.replaceAll('\\\\', '/')).replace(/\\/$/u, '');\n  let joined = normalize(`${root}/${outputRelativePath.replaceAll('\\\\', '/')}`);\n  if (joined.length > 1) {\n    joined = joined.replace(/\\/$/u, '');\n  }\n\n  return joined !== root && !joined.startsWith(`${root}/`) ? null : joined;\n}\n\nfunction describeHttpStatus(httpStatus: number | undefined): string {\n  return httpStatus === undefined || httpStatus === NETWORK_FAILURE_STATUS ? 'a network failure' : `HTTP ${String(httpStatus)}`;\n}\n"],"mappings":"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","names":[]}

package/dist/lib/esm/docs-site/og-image-page.d.mts

@@ -0,0 +1,15 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * Resolves generated Open Graph image paths from documentation page metadata.
+ */
+/**
+ * Resolves the public Open Graph image slug for a documentation page.
+ *
+ * @param frontmatter - The page's parsed frontmatter.
+ * @param filePath - The page's source-file path.
+ * @param contentDocsDirectory - The documentation content root.
+ * @returns The case-preserved explicit slug, or a slug derived from the file path.
+ */
+export declare function getOgImagePageSlug(frontmatter: Record<string, unknown>, filePath: string, contentDocsDirectory: string): string;

package/dist/lib/esm/docs-site/og-image-page.mjs

@@ -0,0 +1,21 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+import { relative } from "node:path/posix";
+function getOgImagePageSlug(frontmatter, filePath, contentDocsDirectory) {
+  const slug = frontmatter["slug"];
+  if (typeof slug === "string") {
+    return slug;
+  }
+  let filePathSlug = relative(contentDocsDirectory, filePath);
+  filePathSlug = filePathSlug.replaceAll("\\", "/");
+  filePathSlug = filePathSlug.replace(/\.\w+$/, "");
+  filePathSlug = filePathSlug.replace(/(?:^|\/)index$/, "");
+  return filePathSlug || "index";
+}
+export {
+  getOgImagePageSlug
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL2RvY3Mtc2l0ZS9vZy1pbWFnZS1wYWdlLnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEBmaWxlXG4gKlxuICogUmVzb2x2ZXMgZ2VuZXJhdGVkIE9wZW4gR3JhcGggaW1hZ2UgcGF0aHMgZnJvbSBkb2N1bWVudGF0aW9uIHBhZ2UgbWV0YWRhdGEuXG4gKi9cblxuaW1wb3J0IHsgcmVsYXRpdmUgfSBmcm9tICdub2RlOnBhdGgvcG9zaXgnO1xuXG4vKipcbiAqIFJlc29sdmVzIHRoZSBwdWJsaWMgT3BlbiBHcmFwaCBpbWFnZSBzbHVnIGZvciBhIGRvY3VtZW50YXRpb24gcGFnZS5cbiAqXG4gKiBAcGFyYW0gZnJvbnRtYXR0ZXIgLSBUaGUgcGFnZSdzIHBhcnNlZCBmcm9udG1hdHRlci5cbiAqIEBwYXJhbSBmaWxlUGF0aCAtIFRoZSBwYWdlJ3Mgc291cmNlLWZpbGUgcGF0aC5cbiAqIEBwYXJhbSBjb250ZW50RG9jc0RpcmVjdG9yeSAtIFRoZSBkb2N1bWVudGF0aW9uIGNvbnRlbnQgcm9vdC5cbiAqIEByZXR1cm5zIFRoZSBjYXNlLXByZXNlcnZlZCBleHBsaWNpdCBzbHVnLCBvciBhIHNsdWcgZGVyaXZlZCBmcm9tIHRoZSBmaWxlIHBhdGguXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBnZXRPZ0ltYWdlUGFnZVNsdWcoZnJvbnRtYXR0ZXI6IFJlY29yZDxzdHJpbmcsIHVua25vd24+LCBmaWxlUGF0aDogc3RyaW5nLCBjb250ZW50RG9jc0RpcmVjdG9yeTogc3RyaW5nKTogc3RyaW5nIHtcbiAgY29uc3Qgc2x1ZyA9IGZyb250bWF0dGVyWydzbHVnJ107XG4gIGlmICh0eXBlb2Ygc2x1ZyA9PT0gJ3N0cmluZycpIHtcbiAgICByZXR1cm4gc2x1ZztcbiAgfVxuXG4gIGxldCBmaWxlUGF0aFNsdWcgPSByZWxhdGl2ZShjb250ZW50RG9jc0RpcmVjdG9yeSwgZmlsZVBhdGgpO1xuICBmaWxlUGF0aFNsdWcgPSBmaWxlUGF0aFNsdWcucmVwbGFjZUFsbCgnXFxcXCcsICcvJyk7XG4gIGZpbGVQYXRoU2x1ZyA9IGZpbGVQYXRoU2x1Zy5yZXBsYWNlKC9cXC5cXHcrJC8sICcnKTtcbiAgZmlsZVBhdGhTbHVnID0gZmlsZVBhdGhTbHVnLnJlcGxhY2UoLyg/Ol58XFwvKWluZGV4JC8sICcnKTtcbiAgcmV0dXJuIGZpbGVQYXRoU2x1ZyB8fCAnaW5kZXgnO1xufVxuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7QUFNQSxTQUFTLGdCQUFnQjtBQVVsQixTQUFTLG1CQUFtQixhQUFzQyxVQUFrQixzQkFBc0M7QUFDL0gsUUFBTSxPQUFPLFlBQVksTUFBTTtBQUMvQixNQUFJLE9BQU8sU0FBUyxVQUFVO0FBQzVCLFdBQU87QUFBQSxFQUNUO0FBRUEsTUFBSSxlQUFlLFNBQVMsc0JBQXNCLFFBQVE7QUFDMUQsaUJBQWUsYUFBYSxXQUFXLE1BQU0sR0FBRztBQUNoRCxpQkFBZSxhQUFhLFFBQVEsVUFBVSxFQUFFO0FBQ2hELGlCQUFlLGFBQWEsUUFBUSxrQkFBa0IsRUFBRTtBQUN4RCxTQUFPLGdCQUFnQjtBQUN6QjsiLAogICJuYW1lcyI6IFtdCn0K

package/dist/lib/esm/docs-site/og-image.d.mts

@@ -0,0 +1,70 @@
+/// <reference path="../library-references.d.mts" />
+/// <reference types="node" />
+/**
+ * @file
+ *
+ * Renders a page's Open Graph card: satori lays it out as SVG, resvg rasterizes it to PNG.
+ */
+import type { Font } from 'satori';
+/**
+ * What one Open Graph card shows: a title, and optionally a description, a code signature and a badge.
+ */
+export interface OgCardContent {
+    readonly badge?: string | undefined;
+    readonly description?: string | undefined;
+    readonly signature?: string | undefined;
+    readonly title: string;
+}
+/**
+ * The per-site part of every card: the fonts, the logo and the brand text in the footer.
+ */
+export interface RenderOgImageOptions {
+    /**
+     * The text the footer carries, normally the package's name.
+     */
+    readonly brandText: string;
+    /**
+     * The fonts satori renders the text with.
+     */
+    readonly fonts: Font[];
+    /**
+     * The site logo as a PNG data URI, or `null` to render the card without one.
+     */
+    readonly logoDataUri: null | string;
+}
+/**
+ * Hashes a card's content, so an unchanged card is not rendered again.
+ *
+ * @param params - The card's content.
+ * @returns A 16-character hex digest.
+ */
+export declare function computeOgHash(params: OgCardContent): string;
+/**
+ * Loads the fonts satori needs to render text.
+ *
+ * This package ships `inter-latin-400-normal.ttf` / `inter-latin-700-normal.ttf` under
+ * `assets/docs-site/fonts`; this falls back to any other `.ttf`/`.otf` in `fontsDirectory` and
+ * returns `null` when the directory holds none, so the caller can skip OG generation instead of
+ * crashing the build.
+ *
+ * @param fontsDirectory - The folder holding the fonts.
+ * @returns The fonts, or `null` when the folder holds none.
+ */
+export declare function loadFonts(fontsDirectory: string): Promise<Font[] | null>;
+/**
+ * Rasterize an SVG favicon to a PNG data URI via resvg for embedding in the satori layout (satori's
+ * `<img>` needs a raster/data-URI source). Returns `null` when the file is missing so the caller can
+ * render the card without a logo. Call this ONCE and reuse the result across all cards.
+ *
+ * @param faviconPath - The SVG favicon's path.
+ * @returns The PNG data URI, or `null` when the favicon is missing.
+ */
+export declare function loadLogoDataUri(faviconPath: string): Promise<null | string>;
+/**
+ * Renders a page's card to a PNG.
+ *
+ * @param params - The card's content.
+ * @param options - The fonts, logo and brand text every card shares.
+ * @returns The PNG.
+ */
+export declare function renderOgImage(params: OgCardContent, options: RenderOgImageOptions): Promise<Buffer>;