@mnaoumov/typescript-dev-toolkit 1.3.0 → 2.0.0

package/dist/lib/esm/docs-site/api-doc-link-rendering.d.mts

@@ -0,0 +1,185 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * Type-link rendering: turns type text and inline link tags into markdown links to generated pages
+ * or external references (TypeScript handbook, MDN Web API, JS globals).
+ */
+import type { TypeInfo } from './api-doc-types.mjs';
+/**
+ * Whether a member page will be generated for `routeSegment` on the given type.
+ *
+ * @param namespace - The type's namespace.
+ * @param typeName - The type's name.
+ * @param routeSegment - The member's route segment.
+ * @returns Whether the page is generated.
+ */
+export declare function doesMemberPageExist(namespace: string, typeName: string, routeSegment: string): boolean;
+/**
+ * Resolve a bare type name to a documented `TypeInfo`.
+ *
+ * The model map is keyed by a qualified `${namespace}#${name}` identity, because a package
+ * can export the same simple name from different modules. Resolution is best-effort:
+ *   1. Prefer a type in `currentNamespace` (the referencing page's module).
+ *   2. Otherwise, if exactly one type across all modules has that bare name, use it.
+ *   3. If the bare name is ambiguous (multiple modules), give up (caller renders plain code).
+ *
+ * @param allTypes - Every documented type, keyed by `${namespace}#${name}`.
+ * @param name - The type's name.
+ * @param currentNamespace - The namespace of the referencing page, preferred when the name is ambiguous.
+ * @returns The type, or `undefined` when no type or more than one has that name.
+ */
+export declare function findType(allTypes: Map<string, TypeInfo>, name: string, currentNamespace?: string): TypeInfo | undefined;
+/**
+ * Link a base type expression for the "Extends:" line.
+ * Simple type references (identifier + optional generics) use renderTypeWithLinks
+ * so each type argument gets its own link.
+ * Complex expressions (object types, intersections, etc.) fall back to typeLink
+ * to avoid MDX parsing issues with `{`, `}`, `|` etc.
+ *
+ * @param typeName - The type's name.
+ * @param allTypes - Every documented type, keyed by `${namespace}#${name}`.
+ * @param currentNamespace - The namespace of the referencing page, preferred when the name is ambiguous.
+ * @returns The linked type.
+ */
+export declare function linkBaseType(typeName: string, allTypes: Map<string, TypeInfo>, currentNamespace?: string): string;
+/**
+ * Loads the Web API links `typedoc-plugin-mdn-links` ships, if it is installed. Without it, Web API types render
+ * unlinked.
+ *
+ * @param rootDirectory - The folder whose `node_modules` holds the package.
+ */
+export declare function loadExternalTypeMaps(rootDirectory: string): void;
+/**
+ * Convert inline markdown to HTML for use in component props with set:html
+ *
+ * @param text - The text.
+ * @returns The HTML.
+ */
+export declare function markdownToHtml(text: string): string;
+/**
+ * Build the href for a member, pointing to the parent type's page if inherited
+ *
+ * @param memberSlugString - The member's route segment.
+ * @param inheritedFrom - The name of the type the member is inherited from, or an empty string for an own member.
+ * @param allTypes - Every documented type, keyed by `${namespace}#${name}`.
+ * @param currentNamespace - The namespace of the referencing page, preferred when the name is ambiguous.
+ * @returns The link, or an empty string when no page documents the member.
+ */
+export declare function memberHref(memberSlugString: string, inheritedFrom: string, allTypes: Map<string, TypeInfo>, currentNamespace?: string): string;
+/**
+ * Populate {@link doesMemberPageExist}. Mirrors `generateMemberPages`'s own filtering exactly (one page
+ * per non-inherited property, one per non-inherited method overload key). Must run once before any
+ * link is rendered.
+ *
+ * @param types - The documented types, keyed by qualified id.
+ */
+export declare function registerMemberPages(types: Map<string, TypeInfo>): void;
+/**
+ * For every documented type assign BOTH:
+ *  - a lowercased, numerically-disambiguated FILE segment (so `TypeAsserter` vs `typeAsserter`, which
+ *    both lowercase to `typeasserter`, become `typeasserter` / `typeasserter-2` on disk and never
+ *    collide on Windows' case-insensitive filesystem), and
+ *  - a case-PRESERVED ROUTE segment (`TypeAsserter` / `typeAsserter`) used for the explicit `slug:`
+ *    frontmatter and every internal link, so the URLs stay pretty and naturally distinct.
+ * The route decouples from the file path via the `slug:` frontmatter, so no `-2` suffix leaks into
+ * URLs. Also warns about member-slug collisions within a type. Must run once before any page/link.
+ *
+ * @param types - The documented types, keyed by qualified id.
+ */
+export declare function registerRouteSegments(types: Map<string, TypeInfo>): void;
+/**
+ * Render an `@example` block as MDX. If the example already contains a fenced code block, it is
+ * normalized through {@link renderMdxProse} (code preserved raw, surrounding prose escaped);
+ * otherwise the raw example text is wrapped in a `ts` code fence so it is emitted literally.
+ *
+ * @param example - The `@example` text.
+ * @param allTypes - Every documented type, keyed by `${namespace}#${name}`.
+ * @param selfNamespace - The namespace of the page being rendered, preferred when a name is ambiguous.
+ * @returns The MDX.
+ */
+export declare function renderExampleMdx(example: string, allTypes: Map<string, TypeInfo>, selfNamespace?: string): string;
+/**
+ * Render markdown block text (a description, remarks, or module overview) as MDX-safe markdown.
+ * Fenced code blocks are re-emitted verbatim (surrounded by blank lines, with a language); prose
+ * segments have their inline link tags resolved and their MDX-unsafe characters escaped.
+ *
+ * @param text - The text.
+ * @param allTypes - Every documented type, keyed by `${namespace}#${name}`.
+ * @param selfNamespace - The namespace of the page being rendered, preferred when a name is ambiguous.
+ * @returns The MDX.
+ */
+export declare function renderMdxProse(text: string, allTypes: Map<string, TypeInfo>, selfNamespace?: string): string;
+/**
+ * Render a type string with clickable links for known types
+ *
+ * @param typeText - The type text.
+ * @param allTypes - Every documented type, keyed by `${namespace}#${name}`.
+ * @param selfTypeName - The name of the type the page documents, which `this` links to.
+ * @param selfNamespace - The namespace of the page being rendered, preferred when a name is ambiguous.
+ * @returns The type text with markdown links.
+ */
+export declare function renderTypeWithLinks(typeText: string, allTypes: Map<string, TypeInfo>, selfTypeName?: string, selfNamespace?: string): string;
+/**
+ * Resolve a type no page of this site documents to the page that does: another documented package's site, or an
+ * entry of the site's own `externalTypeLinks` setting.
+ *
+ * @param name - The type's name.
+ * @returns The URL, or `undefined` when neither knows the type.
+ */
+export declare function resolveExternalTypeUrl(name: string): string | undefined;
+/**
+ * Resolve `@link` tags, with or without a `| display text` part, in description text
+ *
+ * @param text - The text.
+ * @param allTypes - Every documented type, keyed by `${namespace}#${name}`.
+ * @param selfNamespace - The namespace of the page being rendered, preferred when a name is ambiguous.
+ * @returns The text with markdown links.
+ */
+export declare function resolveLinks(text: string, allTypes: Map<string, TypeInfo>, selfNamespace?: string): string;
+/**
+ * Resolves a TypeScript utility type to its handbook entry.
+ *
+ * @param name - The type's name.
+ * @returns The handbook URL, or `undefined` when it is not a utility type.
+ */
+export declare function resolveTsUtilityUrl(name: string): string | undefined;
+/**
+ * Resolves a Web API type to its MDN page.
+ *
+ * @param name - The type's name.
+ * @returns The MDN URL, or `undefined` when it is not a known Web API type.
+ */
+export declare function resolveWebApiUrl(name: string): string | undefined;
+/**
+ * Resolve the lowercased ON-DISK segment for a type (file path + component-import relative path).
+ *
+ * @param namespace - The type's namespace.
+ * @param name - The type's name.
+ * @returns The segment.
+ */
+export declare function toTypeFileSegment(namespace: string, name: string): string;
+/**
+ * Resolve the case-preserved URL/ROUTE segment for a type (slug frontmatter + internal links).
+ *
+ * @param namespace - The type's namespace.
+ * @param name - The type's name.
+ * @returns The segment.
+ */
+export declare function toTypeRouteSegment(namespace: string, name: string): string;
+/**
+ * Absolute link to a type's overview page.
+ *
+ * @param info - The documented type.
+ * @returns The link.
+ */
+export declare function typeHref(info: TypeInfo): string;
+/**
+ * Create an absolute link to a type page
+ *
+ * @param typeName - The type's name.
+ * @param allTypes - Every documented type, keyed by `${namespace}#${name}`.
+ * @param currentNamespace - The namespace of the referencing page, preferred when the name is ambiguous.
+ * @returns A markdown link, or inline code when the type is not documented.
+ */
+export declare function typeLink(typeName: string, allTypes: Map<string, TypeInfo>, currentNamespace?: string): string;

package/dist/lib/esm/docs-site/api-doc-link-rendering.mjs

@@ -0,0 +1,356 @@
+/*
+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,
+  getOptionalNamedGroup
+} from "@mnaoumov/typescript-lib/reg-exp";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import {
+  GENERIC_TYPE_PARAMS,
+  TS_GLOBAL_TYPES,
+  TS_PRIMITIVE_TYPES,
+  TS_UTILITY_TYPES
+} from "./api-doc-constants.mjs";
+import { getPackageTypeUrl } from "./api-doc-package-sites.mjs";
+import {
+  toRouteSegment,
+  toRouteSegmentPreserveCase
+} from "./api-doc-route-segments.mjs";
+import { getApiDocSettings } from "./api-doc-settings.mjs";
+import {
+  escapeMdxAngleBrackets,
+  escapeMdxProse,
+  getNamespaceDirectory,
+  memberRouteSegment,
+  memberSlug,
+  overloadRouteSegment,
+  overloadSlug,
+  replaceRegExpMatches,
+  segmentMarkdown
+} from "./api-doc-text-utils.mjs";
+const moduleState = {
+  webApiTypes: {}
+};
+const typeFileSegments = /* @__PURE__ */ new Map();
+const typeRouteSegments = /* @__PURE__ */ new Map();
+const generatedMemberPages = /* @__PURE__ */ new Set();
+function doesMemberPageExist(namespace, typeName, routeSegment) {
+  return generatedMemberPages.has(`${namespace}#${typeName}#${routeSegment}`);
+}
+function findType(allTypes, name, currentNamespace) {
+  if (currentNamespace !== void 0) {
+    const qualified = allTypes.get(`${currentNamespace}#${name}`);
+    if (qualified) {
+      return qualified;
+    }
+  }
+  let found;
+  let matchCount = 0;
+  for (const info of allTypes.values()) {
+    if (info.name !== name) {
+      continue;
+    }
+    found = info;
+    matchCount++;
+    if (matchCount > 1) {
+      return void 0;
+    }
+  }
+  return matchCount === 1 ? found : void 0;
+}
+function linkBaseType(typeName, allTypes, currentNamespace) {
+  const isSimpleTypeRef = /^[a-zA-Z][a-zA-Z0-9]*(?:<.*>)?$/.test(typeName.trim());
+  return isSimpleTypeRef ? escapeMdxAngleBrackets(renderTypeWithLinks(typeName, allTypes, void 0, currentNamespace)) : typeLink(typeName, allTypes, currentNamespace);
+}
+function loadExternalTypeMaps(rootDirectory) {
+  try {
+    const dataPath = join(rootDirectory, "node_modules/typedoc-plugin-mdn-links/data/web-api.json");
+    moduleState.webApiTypes = JSON.parse(readFileSync(dataPath, "utf-8"));
+    console.warn(`Loaded ${String(Object.keys(moduleState.webApiTypes).length)} Web API type links`);
+  } catch {
+    moduleState.webApiTypes = {};
+    console.warn("typedoc-plugin-mdn-links data not found \u2014 Web API links will be unavailable.");
+  }
+}
+function markdownToHtml(text) {
+  const escaped = text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+  return replaceRegExpMatches(escaped, /\[(?<text>[^\]]+)\]\((?<url>[^)]+)\)/g, (match) => {
+    const linkText = getMandatoryNamedGroup(match, "text");
+    const url = getMandatoryNamedGroup(match, "url");
+    return /^(?:https?:\/\/|\/|#|mailto:)/.test(url) ? `<a href="${url}">${linkText}</a>` : `<code>[${linkText}](${url})</code>`;
+  }).replaceAll(/`(?<code>[^`]+)`/g, "<code>$<code></code>").replaceAll("\n", "<br/>");
+}
+function memberHref(memberSlugString, inheritedFrom, allTypes, currentNamespace) {
+  if (!inheritedFrom) {
+    return `./${memberSlugString}/`;
+  }
+  const parentInfo = findType(allTypes, inheritedFrom, currentNamespace);
+  if (!parentInfo || !doesMemberPageExist(parentInfo.namespace, parentInfo.name, memberSlugString)) {
+    return "";
+  }
+  const parentNsDirectory = getNamespaceDirectory(parentInfo.namespace);
+  return `${getBasePath()}/api/${parentNsDirectory}/${toTypeRouteSegment(parentInfo.namespace, parentInfo.name)}/${memberSlugString}/`;
+}
+function registerMemberPages(types) {
+  generatedMemberPages.clear();
+  for (const info of types.values()) {
+    for (const property of info.properties) {
+      if (!property.inheritedFrom) {
+        generatedMemberPages.add(`${info.namespace}#${info.name}#${memberRouteSegment(property.name)}`);
+      }
+    }
+    const overloadKeys = /* @__PURE__ */ new Set();
+    for (const method of info.methods) {
+      if (!method.inheritedFrom) {
+        overloadKeys.add(method.overloadKey);
+      }
+    }
+    for (const overloadKey of overloadKeys) {
+      generatedMemberPages.add(`${info.namespace}#${info.name}#${overloadRouteSegment(overloadKey)}`);
+    }
+  }
+}
+function registerRouteSegments(types) {
+  typeFileSegments.clear();
+  typeRouteSegments.clear();
+  const byNamespace = /* @__PURE__ */ new Map();
+  for (const info of types.values()) {
+    const list = byNamespace.get(info.namespace) ?? [];
+    list.push(info);
+    byNamespace.set(info.namespace, list);
+  }
+  for (const [namespace, infos] of byNamespace) {
+    const usedFileSegments = /* @__PURE__ */ new Set();
+    const usedRouteSegments = /* @__PURE__ */ new Set();
+    const sorted = [...infos].sort((alpha, bravo) => alpha.name.localeCompare(bravo.name));
+    for (const info of sorted) {
+      typeFileSegments.set(`${namespace}#${info.name}`, disambiguate(toRouteSegment(info.name), usedFileSegments, (segment) => segment));
+      const routeBase = toRouteSegmentPreserveCase(info.name);
+      const routeSegment = disambiguate(routeBase, usedRouteSegments, (segment) => segment.toLowerCase());
+      typeRouteSegments.set(`${namespace}#${info.name}`, routeSegment);
+      if (routeSegment !== routeBase) {
+        console.warn(`Disambiguated ROUTE for "${namespace}#${info.name}": "${routeBase}" -> "${routeSegment}" (slug collision).`);
+      }
+      warnMemberSlugCollisions(info, namespace);
+    }
+  }
+}
+function renderExampleMdx(example, allTypes, selfNamespace) {
+  return /(?:^|\n)\s*(?:```|~~~)/.test(example) ? renderMdxProse(example, allTypes, selfNamespace) : `\`\`\`ts
+${example}
+\`\`\``;
+}
+function renderMdxProse(text, allTypes, selfNamespace) {
+  const out = [];
+  for (const seg of segmentMarkdown(text)) {
+    if (seg.type === "code") {
+      out.push("", `\`\`\`${seg.lang || "ts"}`, seg.text, "```", "");
+    } else {
+      out.push(escapeMdxProse(resolveLinks(seg.text, allTypes, selfNamespace)));
+    }
+  }
+  return out.join("\n").replaceAll(/\n{3,}/g, "\n\n").trim();
+}
+function renderTypeWithLinks(typeText, allTypes, selfTypeName, selfNamespace) {
+  const MDN_OBJECT_BASE = "https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object";
+  const withObjectMethods = replaceRegExpMatches(typeText, /\bObject\.(?<method>[a-zA-Z][a-zA-Z0-9]*)\b/g, (match) => {
+    const method = getMandatoryNamedGroup(match, "method");
+    return `[Object](${MDN_OBJECT_BASE}).[${method}](${MDN_OBJECT_BASE}/${method})`;
+  });
+  return replaceRegExpMatches(
+    withObjectMethods,
+    /\[[^\]]+\]\([^)]+\)|\b(?<typeName>[a-zA-Z][a-zA-Z0-9]*)\b/g,
+    (match) => {
+      const typeName = getOptionalNamedGroup(match, "typeName");
+      if (typeName === null) {
+        return match[0];
+      }
+      if (typeName === "this" && selfTypeName) {
+        const selfInfo = findType(allTypes, selfTypeName, selfNamespace);
+        if (selfInfo) {
+          return `[${typeName}](${typeHref(selfInfo)})`;
+        }
+      }
+      if (GENERIC_TYPE_PARAMS.has(typeName)) {
+        return typeName;
+      }
+      const info = findType(allTypes, typeName, selfNamespace);
+      if (info) {
+        return `[${typeName}](${typeHref(info)})`;
+      }
+      const externalUrl = resolveExternalTypeUrl(typeName);
+      if (externalUrl) {
+        return `[${typeName}](${externalUrl})`;
+      }
+      const tsUrl = resolveTsUtilityUrl(typeName);
+      if (tsUrl) {
+        return `[${typeName}](${tsUrl})`;
+      }
+      const globalUrl = Object.hasOwn(TS_GLOBAL_TYPES, typeName) ? TS_GLOBAL_TYPES[typeName] : void 0;
+      if (globalUrl) {
+        return `[${typeName}](${globalUrl})`;
+      }
+      const mdnUrl = resolveWebApiUrl(typeName);
+      if (mdnUrl) {
+        return `[${typeName}](${mdnUrl})`;
+      }
+      const primitiveUrl = Object.hasOwn(TS_PRIMITIVE_TYPES, typeName) ? TS_PRIMITIVE_TYPES[typeName] : void 0;
+      return primitiveUrl ? `[${typeName}](${primitiveUrl})` : typeName;
+    }
+  );
+}
+function resolveExternalTypeUrl(name) {
+  return getPackageTypeUrl(name) ?? getApiDocSettings().externalTypeLinks.get(name);
+}
+function resolveLinks(text, allTypes, selfNamespace) {
+  return replaceRegExpMatches(text, /\{@link\s+(?<target>[^|}]+?)(?:\s*\|\s*(?<display>[^}]+?))?\}/g, (match) => {
+    const target = getMandatoryNamedGroup(match, "target").trim();
+    const display = (getOptionalNamedGroup(match, "display")?.trim() ?? target).replaceAll(/\\(?=[<>{}])/g, "");
+    const dotMatch = /^(?<typeName>[A-Za-z]\w*)\.(?<memberName>\w+)$/.exec(target);
+    if (dotMatch) {
+      const typeName = getMandatoryNamedGroup(dotMatch, "typeName");
+      const memberName = getMandatoryNamedGroup(dotMatch, "memberName");
+      const typeInfo = findType(allTypes, typeName, selfNamespace);
+      if (typeInfo && doesMemberPageExist(typeInfo.namespace, typeInfo.name, memberRouteSegment(memberName))) {
+        const targetNsDirectory = getNamespaceDirectory(typeInfo.namespace);
+        return `[${display}](${getBasePath()}/api/${targetNsDirectory}/${toTypeRouteSegment(typeInfo.namespace, typeInfo.name)}/${memberRouteSegment(memberName)}/)`;
+      }
+    }
+    const info = findType(allTypes, target, selfNamespace);
+    if (info) {
+      return display !== target && display.includes("<") ? renderTypeWithLinks(display, allTypes, void 0, selfNamespace) : `[${display}](${typeHref(info)})`;
+    }
+    const externalUrl = resolveExternalTypeUrl(target);
+    return externalUrl ? `[${display}](${externalUrl})` : `\`${display}\``;
+  });
+}
+function resolveTsUtilityUrl(name) {
+  const hash = TS_UTILITY_TYPES.get(name);
+  if (hash) {
+    if (["Iterable"].includes(name)) {
+      return `https://www.typescriptlang.org/docs/handbook/iterators-and-generators.html#${hash}`;
+    }
+    const handbookPage = ["Capitalize", "Lowercase", "Uncapitalize", "Uppercase"].includes(name) ? "2/template-literal-types" : "utility-types";
+    return `https://www.typescriptlang.org/docs/handbook/${handbookPage}.html#${hash}`;
+  }
+  return void 0;
+}
+function resolveWebApiUrl(name) {
+  if (!Object.hasOwn(moduleState.webApiTypes, name)) {
+    return void 0;
+  }
+  const entry = moduleState.webApiTypes[name];
+  if (typeof entry === "string") {
+    return entry;
+  }
+  if (typeof entry === "object" && entry !== null && "url" in entry) {
+    const typedEntry = entry;
+    return typedEntry.url;
+  }
+  return void 0;
+}
+function toTypeFileSegment(namespace, name) {
+  return typeFileSegments.get(`${namespace}#${name}`) ?? toRouteSegment(name);
+}
+function toTypeRouteSegment(namespace, name) {
+  return typeRouteSegments.get(`${namespace}#${name}`) ?? toRouteSegmentPreserveCase(name);
+}
+function typeHref(info) {
+  return `${getBasePath()}/api/${getNamespaceDirectory(info.namespace)}/${toTypeRouteSegment(info.namespace, info.name)}/`;
+}
+function typeLink(typeName, allTypes, currentNamespace) {
+  const cleanName = typeName.replace(/<.*>$/, "").trim();
+  const info = findType(allTypes, cleanName, currentNamespace);
+  return info ? `[${escapeMdxAngleBrackets(typeName)}](${typeHref(info)})` : `\`${typeName}\``;
+}
+function disambiguate(base, used, keyOf) {
+  let segment = base;
+  const FIRST_DISAMBIGUATION_SUFFIX = 2;
+  let suffix = FIRST_DISAMBIGUATION_SUFFIX;
+  while (used.has(keyOf(segment))) {
+    segment = `${base}-${String(suffix)}`;
+    suffix++;
+  }
+  used.add(keyOf(segment));
+  return segment;
+}
+function getBasePath() {
+  return getApiDocSettings().basePath;
+}
+function warnMemberSlugCollisions(info, namespace) {
+  const seen = /* @__PURE__ */ new Map();
+  function check(slug, original) {
+    const normalized = original.replace(/\?$/, "");
+    const existing = seen.get(slug);
+    if (existing !== void 0 && existing !== normalized) {
+      console.warn(`Member route collision in "${namespace}#${info.name}": "${existing}" and "${normalized}" both map to "/${slug}/".`);
+      return;
+    }
+    seen.set(slug, normalized);
+  }
+  for (const property of info.properties) {
+    check(memberSlug(property.name), property.name);
+  }
+  for (const method of info.methods) {
+    check(overloadSlug(method.overloadKey), method.overloadKey);
+  }
+}
+export {
+  doesMemberPageExist,
+  findType,
+  linkBaseType,
+  loadExternalTypeMaps,
+  markdownToHtml,
+  memberHref,
+  registerMemberPages,
+  registerRouteSegments,
+  renderExampleMdx,
+  renderMdxProse,
+  renderTypeWithLinks,
+  resolveExternalTypeUrl,
+  resolveLinks,
+  resolveTsUtilityUrl,
+  resolveWebApiUrl,
+  toTypeFileSegment,
+  toTypeRouteSegment,
+  typeHref,
+  typeLink
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/docs-site/api-doc-link-rendering.ts"],"sourcesContent":["/**\n * @file\n *\n * Type-link rendering: turns type text and inline link tags into markdown links to generated pages\n * or external references (TypeScript handbook, MDN Web API, JS globals).\n */\n\nimport {\n  getMandatoryNamedGroup,\n  getOptionalNamedGroup\n} from '@mnaoumov/typescript-lib/reg-exp';\nimport { readFileSync } from 'node:fs';\nimport { join } from 'node:path';\n\nimport type {\n  TypeInfo,\n  WebApiEntry\n} from './api-doc-types.ts';\n\nimport {\n  GENERIC_TYPE_PARAMS,\n  TS_GLOBAL_TYPES,\n  TS_PRIMITIVE_TYPES,\n  TS_UTILITY_TYPES\n} from './api-doc-constants.ts';\nimport { getPackageTypeUrl } from './api-doc-package-sites.ts';\nimport {\n  toRouteSegment,\n  toRouteSegmentPreserveCase\n} from './api-doc-route-segments.ts';\nimport { getApiDocSettings } from './api-doc-settings.ts';\nimport {\n  escapeMdxAngleBrackets,\n  escapeMdxProse,\n  getNamespaceDirectory,\n  memberRouteSegment,\n  memberSlug,\n  overloadRouteSegment,\n  overloadSlug,\n  replaceRegExpMatches,\n  segmentMarkdown\n} from './api-doc-text-utils.ts';\n\n/**\nLoaded from typedoc-plugin-mdn-links data at runtime\n */\n/**\nModule-level mutable state, held in one object so each mutation names it explicitly.\n */\ninterface ModuleState {\n  webApiTypes: Record<string, unknown>;\n}\n\nconst moduleState: ModuleState = {\n  webApiTypes: {}\n};\n/**\nLowercased, collision-disambiguated ON-DISK segment per qualified type key (`${namespace}#${name}`).\n */\nconst typeFileSegments = new Map<string, string>();\n/**\nCase-preserved URL/route segment per qualified type key (`${namespace}#${name}`).\n */\nconst typeRouteSegments = new Map<string, string>();\n\n/**\n * Route-segment keys of the member pages that `generateMemberPages` will actually emit, as\n * `${namespace}#${TypeName}#${routeSegment}`. Only NON-inherited properties and non-inherited method\n * overload keys get a page, so this lets link emitters avoid pointing at a member page that is never\n * generated (an inherited member, an enum member, an options-interface member) — which would 404.\n */\nconst generatedMemberPages = new Set<string>();\n\n/**\n * Whether a member page will be generated for `routeSegment` on the given type.\n *\n * @param namespace - The type's namespace.\n * @param typeName - The type's name.\n * @param routeSegment - The member's route segment.\n * @returns Whether the page is generated.\n */\nexport function doesMemberPageExist(namespace: string, typeName: string, routeSegment: string): boolean {\n  return generatedMemberPages.has(`${namespace}#${typeName}#${routeSegment}`);\n}\n\n/**\n * Resolve a bare type name to a documented `TypeInfo`.\n *\n * The model map is keyed by a qualified `${namespace}#${name}` identity, because a package\n * can export the same simple name from different modules. Resolution is best-effort:\n *   1. Prefer a type in `currentNamespace` (the referencing page's module).\n *   2. Otherwise, if exactly one type across all modules has that bare name, use it.\n *   3. If the bare name is ambiguous (multiple modules), give up (caller renders plain code).\n *\n * @param allTypes - Every documented type, keyed by `${namespace}#${name}`.\n * @param name - The type's name.\n * @param currentNamespace - The namespace of the referencing page, preferred when the name is ambiguous.\n * @returns The type, or `undefined` when no type or more than one has that name.\n */\nexport function findType(allTypes: Map<string, TypeInfo>, name: string, currentNamespace?: string): TypeInfo | undefined {\n  if (currentNamespace !== undefined) {\n    const qualified = allTypes.get(`${currentNamespace}#${name}`);\n    if (qualified) {\n      return qualified;\n    }\n  }\n  let found: TypeInfo | undefined;\n  let matchCount = 0;\n  for (const info of allTypes.values()) {\n    if (info.name !== name) {\n      continue;\n    }\n\n    found = info;\n    matchCount++;\n    if (matchCount > 1) {\n      return undefined;\n    }\n  }\n  return matchCount === 1 ? found : undefined;\n}\n\n/**\n * Link a base type expression for the \"Extends:\" line.\n * Simple type references (identifier + optional generics) use renderTypeWithLinks\n * so each type argument gets its own link.\n * Complex expressions (object types, intersections, etc.) fall back to typeLink\n * to avoid MDX parsing issues with `{`, `}`, `|` etc.\n *\n * @param typeName - The type's name.\n * @param allTypes - Every documented type, keyed by `${namespace}#${name}`.\n * @param currentNamespace - The namespace of the referencing page, preferred when the name is ambiguous.\n * @returns The linked type.\n */\nexport function linkBaseType(typeName: string, allTypes: Map<string, TypeInfo>, currentNamespace?: string): string {\n  const isSimpleTypeRef = /^[a-zA-Z][a-zA-Z0-9]*(?:<.*>)?$/.test(typeName.trim());\n  return isSimpleTypeRef ? escapeMdxAngleBrackets(renderTypeWithLinks(typeName, allTypes, undefined, currentNamespace)) : typeLink(typeName, allTypes, currentNamespace);\n}\n\n/**\n * Loads the Web API links `typedoc-plugin-mdn-links` ships, if it is installed. Without it, Web API types render\n * unlinked.\n *\n * @param rootDirectory - The folder whose `node_modules` holds the package.\n */\nexport function loadExternalTypeMaps(rootDirectory: string): void {\n  try {\n    const dataPath = join(rootDirectory, 'node_modules/typedoc-plugin-mdn-links/data/web-api.json');\n    moduleState.webApiTypes = JSON.parse(readFileSync(dataPath, 'utf-8')) as Record<string, unknown>;\n    console.warn(`Loaded ${String(Object.keys(moduleState.webApiTypes).length)} Web API type links`);\n  } catch {\n    moduleState.webApiTypes = {};\n    console.warn('typedoc-plugin-mdn-links data not found — Web API links will be unavailable.');\n  }\n}\n\n/**\n * Convert inline markdown to HTML for use in component props with set:html\n *\n * @param text - The text.\n * @returns The HTML.\n */\nexport function markdownToHtml(text: string): string {\n  const escaped = text\n    .replaceAll('&', '&amp;')\n    .replaceAll('<', '&lt;')\n    .replaceAll('>', '&gt;');\n  return replaceRegExpMatches(escaped, /\\[(?<text>[^\\]]+)\\]\\((?<url>[^)]+)\\)/g, (match) => {\n    const linkText = getMandatoryNamedGroup(match, 'text');\n    const url = getMandatoryNamedGroup(match, 'url');\n    // A relative URL here is an illustrative example path in TSDoc (e.g. `[foo](foo.png)`), not a\n    // real navigable link — render it as literal inline code so it neither 404s nor loses meaning.\n    return /^(?:https?:\\/\\/|\\/|#|mailto:)/.test(url) ? `<a href=\"${url}\">${linkText}</a>` : `<code>[${linkText}](${url})</code>`;\n  })\n    .replaceAll(/`(?<code>[^`]+)`/g, '<code>$<code></code>')\n    .replaceAll('\\n', '<br/>');\n}\n\n/**\n * Build the href for a member, pointing to the parent type's page if inherited\n *\n * @param memberSlugString - The member's route segment.\n * @param inheritedFrom - The name of the type the member is inherited from, or an empty string for an own member.\n * @param allTypes - Every documented type, keyed by `${namespace}#${name}`.\n * @param currentNamespace - The namespace of the referencing page, preferred when the name is ambiguous.\n * @returns The link, or an empty string when no page documents the member.\n */\nexport function memberHref(memberSlugString: string, inheritedFrom: string, allTypes: Map<string, TypeInfo>, currentNamespace?: string): string {\n  if (!inheritedFrom) {\n    // Own (non-inherited) member — `generateMemberPages` always emits its page on this same page.\n    return `./${memberSlugString}/`;\n  }\n  const parentInfo = findType(allTypes, inheritedFrom, currentNamespace);\n  if (!parentInfo || !doesMemberPageExist(parentInfo.namespace, parentInfo.name, memberSlugString)) {\n    // The declaring parent has no generated page for this member (it inherited the member too, or is\n    // undocumented). Return no href so the caller renders plain text instead of a broken link.\n    return '';\n  }\n  const parentNsDirectory = getNamespaceDirectory(parentInfo.namespace);\n  return `${getBasePath()}/api/${parentNsDirectory}/${toTypeRouteSegment(parentInfo.namespace, parentInfo.name)}/${memberSlugString}/`;\n}\n\n/**\n * Populate {@link doesMemberPageExist}. Mirrors `generateMemberPages`'s own filtering exactly (one page\n * per non-inherited property, one per non-inherited method overload key). Must run once before any\n * link is rendered.\n *\n * @param types - The documented types, keyed by qualified id.\n */\nexport function registerMemberPages(types: Map<string, TypeInfo>): void {\n  generatedMemberPages.clear();\n  for (const info of types.values()) {\n    for (const property of info.properties) {\n      if (!property.inheritedFrom) {\n        generatedMemberPages.add(`${info.namespace}#${info.name}#${memberRouteSegment(property.name)}`);\n      }\n    }\n    const overloadKeys = new Set<string>();\n    for (const method of info.methods) {\n      if (!method.inheritedFrom) {\n        overloadKeys.add(method.overloadKey);\n      }\n    }\n    for (const overloadKey of overloadKeys) {\n      generatedMemberPages.add(`${info.namespace}#${info.name}#${overloadRouteSegment(overloadKey)}`);\n    }\n  }\n}\n\n/**\n * For every documented type assign BOTH:\n *  - a lowercased, numerically-disambiguated FILE segment (so `TypeAsserter` vs `typeAsserter`, which\n *    both lowercase to `typeasserter`, become `typeasserter` / `typeasserter-2` on disk and never\n *    collide on Windows' case-insensitive filesystem), and\n *  - a case-PRESERVED ROUTE segment (`TypeAsserter` / `typeAsserter`) used for the explicit `slug:`\n *    frontmatter and every internal link, so the URLs stay pretty and naturally distinct.\n * The route decouples from the file path via the `slug:` frontmatter, so no `-2` suffix leaks into\n * URLs. Also warns about member-slug collisions within a type. Must run once before any page/link.\n *\n * @param types - The documented types, keyed by qualified id.\n */\nexport function registerRouteSegments(types: Map<string, TypeInfo>): void {\n  typeFileSegments.clear();\n  typeRouteSegments.clear();\n  const byNamespace = new Map<string, TypeInfo[]>();\n  // eslint-disable-next-line unicorn/prefer-group-by -- `Map.groupBy` is ES2024, and the shared `tsconfig.json` types only ES2022.\n  for (const info of types.values()) {\n    const list = byNamespace.get(info.namespace) ?? [];\n    list.push(info);\n    byNamespace.set(info.namespace, list);\n  }\n  for (const [namespace, infos] of byNamespace) {\n    const usedFileSegments = new Set<string>();\n    const usedRouteSegments = new Set<string>();\n    const sorted = [...infos].sort((alpha, bravo) => alpha.name.localeCompare(bravo.name));\n    for (const info of sorted) {\n      typeFileSegments.set(`${namespace}#${info.name}`, disambiguate(toRouteSegment(info.name), usedFileSegments, (segment) => segment));\n\n      const routeBase = toRouteSegmentPreserveCase(info.name);\n      // Disambiguate ROUTES case-INSENSITIVELY: the slug becomes Astro's on-disk output path, so\n      // `TypeAsserter` and `typeAsserter` (same name modulo case) would collide when the site is built\n      // on a case-insensitive filesystem (Windows/macOS), silently overwriting one page so every link\n      // to it 404s. Comparing lowercased keys forces the second occurrence to take a `-2` suffix.\n      const routeSegment = disambiguate(routeBase, usedRouteSegments, (segment) => segment.toLowerCase());\n      typeRouteSegments.set(`${namespace}#${info.name}`, routeSegment);\n      if (routeSegment !== routeBase) {\n        console.warn(`Disambiguated ROUTE for \"${namespace}#${info.name}\": \"${routeBase}\" -> \"${routeSegment}\" (slug collision).`);\n      }\n      warnMemberSlugCollisions(info, namespace);\n    }\n  }\n}\n\n/**\n * Render an `@example` block as MDX. If the example already contains a fenced code block, it is\n * normalized through {@link renderMdxProse} (code preserved raw, surrounding prose escaped);\n * otherwise the raw example text is wrapped in a `ts` code fence so it is emitted literally.\n *\n * @param example - The `@example` text.\n * @param allTypes - Every documented type, keyed by `${namespace}#${name}`.\n * @param selfNamespace - The namespace of the page being rendered, preferred when a name is ambiguous.\n * @returns The MDX.\n */\nexport function renderExampleMdx(example: string, allTypes: Map<string, TypeInfo>, selfNamespace?: string): string {\n  return /(?:^|\\n)\\s*(?:```|~~~)/.test(example) ? renderMdxProse(example, allTypes, selfNamespace) : `\\`\\`\\`ts\\n${example}\\n\\`\\`\\``;\n}\n\n/**\n * Render markdown block text (a description, remarks, or module overview) as MDX-safe markdown.\n * Fenced code blocks are re-emitted verbatim (surrounded by blank lines, with a language); prose\n * segments have their inline link tags resolved and their MDX-unsafe characters escaped.\n *\n * @param text - The text.\n * @param allTypes - Every documented type, keyed by `${namespace}#${name}`.\n * @param selfNamespace - The namespace of the page being rendered, preferred when a name is ambiguous.\n * @returns The MDX.\n */\nexport function renderMdxProse(text: string, allTypes: Map<string, TypeInfo>, selfNamespace?: string): string {\n  const out: string[] = [];\n  for (const seg of segmentMarkdown(text)) {\n    if (seg.type === 'code') {\n      out.push('', `\\`\\`\\`${seg.lang || 'ts'}`, seg.text, '```', '');\n    } else {\n      out.push(escapeMdxProse(resolveLinks(seg.text, allTypes, selfNamespace)));\n    }\n  }\n  return out.join('\\n').replaceAll(/\\n{3,}/g, '\\n\\n').trim();\n}\n\n/**\n * Render a type string with clickable links for known types\n *\n * @param typeText - The type text.\n * @param allTypes - Every documented type, keyed by `${namespace}#${name}`.\n * @param selfTypeName - The name of the type the page documents, which `this` links to.\n * @param selfNamespace - The namespace of the page being rendered, preferred when a name is ambiguous.\n * @returns The type text with markdown links.\n */\nexport function renderTypeWithLinks(typeText: string, allTypes: Map<string, TypeInfo>, selfTypeName?: string, selfNamespace?: string): string {\n  // Pre-pass: link Object.method patterns to MDN before word-by-word linking\n  const MDN_OBJECT_BASE = 'https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object';\n  const withObjectMethods = replaceRegExpMatches(typeText, /\\bObject\\.(?<method>[a-zA-Z][a-zA-Z0-9]*)\\b/g, (match) => {\n    const method = getMandatoryNamedGroup(match, 'method');\n    return `[Object](${MDN_OBJECT_BASE}).[${method}](${MDN_OBJECT_BASE}/${method})`;\n  });\n  // Main pass: link individual type names, skipping text already inside markdown links\n  return replaceRegExpMatches(\n    withObjectMethods,\n    /\\[[^\\]]+\\]\\([^)]+\\)|\\b(?<typeName>[a-zA-Z][a-zA-Z0-9]*)\\b/g,\n    (match) => {\n      const typeName = getOptionalNamedGroup(match, 'typeName');\n      if (typeName === null) {\n        return match[0];\n      }\n      // Link `this` return type to the current type's page\n      if (typeName === 'this' && selfTypeName) {\n        const selfInfo = findType(allTypes, selfTypeName, selfNamespace);\n        if (selfInfo) {\n          return `[${typeName}](${typeHref(selfInfo)})`;\n        }\n      }\n\n      // Skip generic type parameters\n      if (GENERIC_TYPE_PARAMS.has(typeName)) {\n        return typeName;\n      }\n\n      // Check our own types first\n      const info = findType(allTypes, typeName, selfNamespace);\n      if (info) {\n        return `[${typeName}](${typeHref(info)})`;\n      }\n\n      // A type another documented package declares, or one the site maps itself\n      const externalUrl = resolveExternalTypeUrl(typeName);\n      if (externalUrl) {\n        return `[${typeName}](${externalUrl})`;\n      }\n\n      // TypeScript utility types\n      const tsUrl = resolveTsUtilityUrl(typeName);\n      if (tsUrl) {\n        return `[${typeName}](${tsUrl})`;\n      }\n\n      // JS global types (Array, Promise, Map, etc.)\n      const globalUrl = Object.hasOwn(TS_GLOBAL_TYPES, typeName) ? TS_GLOBAL_TYPES[typeName] : undefined;\n      if (globalUrl) {\n        return `[${typeName}](${globalUrl})`;\n      }\n\n      // Web API / MDN types\n      const mdnUrl = resolveWebApiUrl(typeName);\n      if (mdnUrl) {\n        return `[${typeName}](${mdnUrl})`;\n      }\n\n      // TypeScript primitive types\n      const primitiveUrl = Object.hasOwn(TS_PRIMITIVE_TYPES, typeName) ? TS_PRIMITIVE_TYPES[typeName] : undefined;\n      return primitiveUrl ? `[${typeName}](${primitiveUrl})` : typeName;\n    }\n  );\n}\n\n/**\n * Resolve a type no page of this site documents to the page that does: another documented package's site, or an\n * entry of the site's own `externalTypeLinks` setting.\n *\n * @param name - The type's name.\n * @returns The URL, or `undefined` when neither knows the type.\n */\nexport function resolveExternalTypeUrl(name: string): string | undefined {\n  return getPackageTypeUrl(name) ?? getApiDocSettings().externalTypeLinks.get(name);\n}\n\n/**\n * Resolve `@link` tags, with or without a `| display text` part, in description text\n *\n * @param text - The text.\n * @param allTypes - Every documented type, keyed by `${namespace}#${name}`.\n * @param selfNamespace - The namespace of the page being rendered, preferred when a name is ambiguous.\n * @returns The text with markdown links.\n */\nexport function resolveLinks(text: string, allTypes: Map<string, TypeInfo>, selfNamespace?: string): string {\n  return replaceRegExpMatches(text, /\\{@link\\s+(?<target>[^|}]+?)(?:\\s*\\|\\s*(?<display>[^}]+?))?\\}/g, (match) => {\n    const target = getMandatoryNamedGroup(match, 'target').trim();\n    const display = (getOptionalNamedGroup(match, 'display')?.trim() ?? target).replaceAll(/\\\\(?=[<>{}])/g, '');\n\n    // Handle Type.member references (e.g., PluginNoticeComponent.showNotice)\n    const dotMatch = /^(?<typeName>[A-Za-z]\\w*)\\.(?<memberName>\\w+)$/.exec(target);\n    if (dotMatch) {\n      const typeName = getMandatoryNamedGroup(dotMatch, 'typeName');\n      const memberName = getMandatoryNamedGroup(dotMatch, 'memberName');\n      const typeInfo = findType(allTypes, typeName, selfNamespace);\n      if (typeInfo && doesMemberPageExist(typeInfo.namespace, typeInfo.name, memberRouteSegment(memberName))) {\n        const targetNsDirectory = getNamespaceDirectory(typeInfo.namespace);\n        return `[${display}](${getBasePath()}/api/${targetNsDirectory}/${toTypeRouteSegment(typeInfo.namespace, typeInfo.name)}/${memberRouteSegment(memberName)}/)`;\n      }\n    }\n\n    // Handle simple type references — if display contains generic args, link each type individually\n    const info = findType(allTypes, target, selfNamespace);\n    if (info) {\n      return display !== target && display.includes('<') ? renderTypeWithLinks(display, allTypes, undefined, selfNamespace) : `[${display}](${typeHref(info)})`;\n    }\n\n    const externalUrl = resolveExternalTypeUrl(target);\n    return externalUrl ? `[${display}](${externalUrl})` : `\\`${display}\\``;\n  });\n}\n\n/**\n * Resolves a TypeScript utility type to its handbook entry.\n *\n * @param name - The type's name.\n * @returns The handbook URL, or `undefined` when it is not a utility type.\n */\nexport function resolveTsUtilityUrl(name: string): string | undefined {\n  const hash = TS_UTILITY_TYPES.get(name);\n  if (hash) {\n    if (['Iterable'].includes(name)) {\n      return `https://www.typescriptlang.org/docs/handbook/iterators-and-generators.html#${hash}`;\n    }\n    const handbookPage = ['Capitalize', 'Lowercase', 'Uncapitalize', 'Uppercase'].includes(name) ? '2/template-literal-types' : 'utility-types'; // Cspell:disable-line\n    return `https://www.typescriptlang.org/docs/handbook/${handbookPage}.html#${hash}`;\n  }\n  return undefined;\n}\n\n/**\n * Resolves a Web API type to its MDN page.\n *\n * @param name - The type's name.\n * @returns The MDN URL, or `undefined` when it is not a known Web API type.\n */\nexport function resolveWebApiUrl(name: string): string | undefined {\n  if (!Object.hasOwn(moduleState.webApiTypes, name)) {\n    return undefined;\n  }\n  const entry = moduleState.webApiTypes[name];\n  if (typeof entry === 'string') {\n    return entry;\n  }\n  if (typeof entry === 'object' && entry !== null && 'url' in entry) {\n    const typedEntry = entry as WebApiEntry;\n    return typedEntry.url;\n  }\n  return undefined;\n}\n\n/**\n * Resolve the lowercased ON-DISK segment for a type (file path + component-import relative path).\n *\n * @param namespace - The type's namespace.\n * @param name - The type's name.\n * @returns The segment.\n */\nexport function toTypeFileSegment(namespace: string, name: string): string {\n  return typeFileSegments.get(`${namespace}#${name}`) ?? toRouteSegment(name);\n}\n\n/**\n * Resolve the case-preserved URL/ROUTE segment for a type (slug frontmatter + internal links).\n *\n * @param namespace - The type's namespace.\n * @param name - The type's name.\n * @returns The segment.\n */\nexport function toTypeRouteSegment(namespace: string, name: string): string {\n  return typeRouteSegments.get(`${namespace}#${name}`) ?? toRouteSegmentPreserveCase(name);\n}\n\n/**\n * Absolute link to a type's overview page.\n *\n * @param info - The documented type.\n * @returns The link.\n */\nexport function typeHref(info: TypeInfo): string {\n  return `${getBasePath()}/api/${getNamespaceDirectory(info.namespace)}/${toTypeRouteSegment(info.namespace, info.name)}/`;\n}\n\n/**\n * Create an absolute link to a type page\n *\n * @param typeName - The type's name.\n * @param allTypes - Every documented type, keyed by `${namespace}#${name}`.\n * @param currentNamespace - The namespace of the referencing page, preferred when the name is ambiguous.\n * @returns A markdown link, or inline code when the type is not documented.\n */\nexport function typeLink(typeName: string, allTypes: Map<string, TypeInfo>, currentNamespace?: string): string {\n  const cleanName = typeName.replace(/<.*>$/, '').trim();\n  const info = findType(allTypes, cleanName, currentNamespace);\n  return info ? `[${escapeMdxAngleBrackets(typeName)}](${typeHref(info)})` : `\\`${typeName}\\``;\n}\n\nfunction disambiguate(base: string, used: Set<string>, keyOf: (segment: string) => string): string {\n  let segment = base;\n  const FIRST_DISAMBIGUATION_SUFFIX = 2;\n  let suffix = FIRST_DISAMBIGUATION_SUFFIX;\n  while (used.has(keyOf(segment))) {\n    segment = `${base}-${String(suffix)}`;\n    suffix++;\n  }\n  used.add(keyOf(segment));\n  return segment;\n}\n\nfunction getBasePath(): string {\n  return getApiDocSettings().basePath;\n}\n\n/**\n * Warn when two distinct members of a type produce the same member slug (URL/file segment). The\n * optional-`?` suffix is stripped first, so a property appearing as both required and optional is not\n * a false positive.\n *\n * @param info - The type.\n * @param namespace - The type's namespace.\n */\nfunction warnMemberSlugCollisions(info: TypeInfo, namespace: string): void {\n  const seen = new Map<string, string>();\n  function check(slug: string, original: string): void {\n    const normalized = original.replace(/\\?$/, '');\n    const existing = seen.get(slug);\n    if (existing !== undefined && existing !== normalized) {\n      console.warn(`Member route collision in \"${namespace}#${info.name}\": \"${existing}\" and \"${normalized}\" both map to \"/${slug}/\".`);\n      return;\n    }\n    seen.set(slug, normalized);\n  }\n  for (const property of info.properties) {\n    check(memberSlug(property.name), property.name);\n  }\n  for (const method of info.methods) {\n    check(overloadSlug(method.overloadKey), method.overloadKey);\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/lib/esm/docs-site/api-doc-package-sites.d.mts

@@ -0,0 +1,36 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * Cross-site links: a type declared in another documented package links to its page on that package's site.
+ *
+ * A type is recognized by where its declaration lives, not by its name: a declaration under
+ * `node_modules/<package>/dist/lib/{esm,cjs}/<path>.d.{mts,cts}` of a package in
+ * {@link ApiDocSettings.packageSites} is the page `<site>api/<path>/<Type>/`, built with the generator's own slug
+ * rules, because that site was generated from the same tree.
+ */
+/**
+ * The documentation sites of the `@mnaoumov` packages, which each site links to unless told otherwise.
+ */
+export declare const DEFAULT_PACKAGE_SITES: ReadonlyMap<string, string>;
+/**
+ * Forgets every declaration {@link registerPackageDeclaration} recorded.
+ */
+export declare function clearPackageDeclarations(): void;
+/**
+ * Gets the page URL of a type declared in another documented package.
+ *
+ * @param name - The type's name, as type text prints it.
+ * @returns The URL, or `undefined` when no documented package declares exactly one type of that name.
+ */
+export declare function getPackageTypeUrl(name: string): string | undefined;
+/**
+ * Records where a type is declared, so its references link to its page on that package's site.
+ *
+ * A declaration outside every {@link ApiDocSettings.packageSites} package is ignored. A name two packages declare is
+ * remembered as ambiguous and never linked.
+ *
+ * @param name - The type's name.
+ * @param declarationFilePath - The declaration file's path, with or without its `.d.mts` / `.d.cts` extension.
+ */
+export declare function registerPackageDeclaration(name: string, declarationFilePath: string): void;