@mintlify/scraping 4.0.906 → 4.0.908

package/__test__/sdk-typedoc.test.ts

@@ -0,0 +1,138 @@
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { describe, expect, it, beforeEach, afterEach } from 'vitest';
+
+import { convertTypedoc } from '../src/sdk/converters/typedoc.js';
+
+const project = {
+  id: 0,
+  name: '@auth0/example',
+  kind: 1,
+  children: [
+    {
+      id: 1,
+      name: 'Client',
+      kind: 128,
+      comment: {
+        summary: [
+          { kind: 'text', text: 'A client for the [API](https://example.com). Second sentence.' },
+        ],
+      },
+      children: [
+        {
+          id: 2,
+          name: 'constructor',
+          kind: 512,
+          signatures: [
+            {
+              id: 3,
+              name: 'new Client',
+              kind: 16384,
+              parameters: [
+                {
+                  id: 4,
+                  name: 'options',
+                  kind: 32768,
+                  type: { type: 'reference', name: 'ClientOptions' },
+                  comment: { summary: [{ kind: 'text', text: 'The options.' }] },
+                },
+              ],
+              type: { type: 'reference', name: 'Client', target: 1 },
+            },
+          ],
+        },
+        {
+          id: 5,
+          name: 'token',
+          kind: 1024,
+          flags: { isOptional: true },
+          type: {
+            type: 'union',
+            types: [
+              { type: 'intrinsic', name: 'string' },
+              { type: 'intrinsic', name: 'undefined' },
+            ],
+          },
+          comment: { summary: [{ kind: 'text', text: 'The current token.' }] },
+        },
+        {
+          id: 6,
+          name: 'login',
+          kind: 2048,
+          signatures: [
+            {
+              id: 7,
+              name: 'login',
+              kind: 4096,
+              comment: {
+                summary: [
+                  { kind: 'text', text: 'Logs in. See ' },
+                  { kind: 'inline-tag', text: 'ClientOptions', target: 8 },
+                ],
+              },
+              type: {
+                type: 'reference',
+                name: 'Promise',
+                typeArguments: [{ type: 'intrinsic', name: 'void' }],
+              },
+            },
+          ],
+        },
+      ],
+    },
+    {
+      id: 8,
+      name: 'ClientOptions',
+      kind: 256,
+      children: [
+        {
+          id: 9,
+          name: 'domain',
+          kind: 1024,
+          type: { type: 'intrinsic', name: 'string' },
+        },
+      ],
+    },
+    { id: 10, name: 'hidden', kind: 64, flags: { isPrivate: true }, signatures: [] },
+  ],
+};
+
+describe('convertTypedoc', () => {
+  let directory: string;
+
+  beforeEach(async () => {
+    directory = await mkdtemp(path.join(os.tmpdir(), 'typedoc-'));
+  });
+
+  afterEach(async () => {
+    await rm(directory, { recursive: true, force: true });
+  });
+
+  it('converts a typedoc project into pages and groups', async () => {
+    const artifact = path.join(directory, 'typedoc.json');
+    await writeFile(artifact, JSON.stringify(project));
+
+    const reference = await convertTypedoc(artifact);
+
+    expect(reference.groups).toEqual([
+      { group: 'Classes', pages: ['classes/Client'] },
+      { group: 'Interfaces', pages: ['interfaces/ClientOptions'] },
+    ]);
+
+    const client = reference.pages.find((page) => page.slug === 'classes/Client');
+    expect(client).toBeDefined();
+    expect(client?.title).toBe('Client');
+    expect(client?.tag).toBe('CLASS');
+    expect(client?.description).toBe('A client for the API.');
+    expect(client?.content).toContain('## Constructor');
+    expect(client?.content).toContain('new Client(options: ClientOptions): Client');
+    expect(client?.content).toContain(
+      '<ResponseField name={"options"} type={"ClientOptions"} required>'
+    );
+    expect(client?.content).toContain('<ResponseField name={"token"} type={"string | undefined"}>');
+    expect(client?.content).toContain('### login()');
+    expect(client?.content).toContain('[ClientOptions](/interfaces/ClientOptions)');
+    expect(client?.content).not.toContain('hidden');
+  });
+});

package/bin/index.d.ts

@@ -12,3 +12,6 @@ export { getErrorMessage } from './utils/errors.js';
 export { checkUrl } from './utils/url.js';
 export { FINAL_SUCCESS_MESSAGE } from './constants.js';
 export { parseGraphqlSdl } from './graphql/parseGraphqlSdl.js';
+export { generateSdkReference } from './sdk/generateSdkReference.js';
+export { htmlToMdx, hastToMdx, markdownToMdx } from './sdk/convert.js';
+export type { SdkFormat, SdkPage, SdkNavGroup, SdkReference, SdkConverter } from './sdk/types.js';

package/bin/index.js

@@ -12,4 +12,6 @@ export { getErrorMessage } from './utils/errors.js';
 export { checkUrl } from './utils/url.js';
 export { FINAL_SUCCESS_MESSAGE } from './constants.js';
 export { parseGraphqlSdl } from './graphql/parseGraphqlSdl.js';
+export { generateSdkReference } from './sdk/generateSdkReference.js';
+export { htmlToMdx, hastToMdx, markdownToMdx } from './sdk/convert.js';
 //# sourceMappingURL=index.js.map

package/bin/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAC;AACzE,OAAO,EAAE,iCAAiC,EAAE,MAAM,gDAAgD,CAAC;AACnG,cAAc,gBAAgB,CAAC;AAC/B,OAAO,EAAE,kCAAkC,EAAE,MAAM,kDAAkD,CAAC;AAEtG,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAChD,OAAO,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AACxE,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AACxC,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AACvD,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAC;AACzE,OAAO,EAAE,iCAAiC,EAAE,MAAM,gDAAgD,CAAC;AACnG,cAAc,gBAAgB,CAAC;AAC/B,OAAO,EAAE,kCAAkC,EAAE,MAAM,kDAAkD,CAAC;AAEtG,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAChD,OAAO,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AACxE,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AACxC,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AACvD,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAC/D,OAAO,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC"}

package/bin/sdk/convert.d.ts

@@ -0,0 +1,6 @@
+import type { Root as HastRoot } from 'hast';
+export type RewriteLink = (href: string) => string | undefined;
+export declare function hastToMdx(fragment: HastRoot, rewriteLink?: RewriteLink): string;
+export declare function htmlToMdx(html: string, rewriteLink?: RewriteLink): string;
+export declare function markdownToMdx(markdown: string): string;
+export declare function escapeMdxText(text: string): string;

package/bin/sdk/convert.js

@@ -0,0 +1,90 @@
+import remarkGfm from 'remark-gfm';
+import remarkMdx from 'remark-mdx';
+import remarkParse from 'remark-parse';
+import remarkStringify from 'remark-stringify';
+import { unified } from 'unified';
+import { visit } from 'unist-util-visit';
+import { convertHeaderLinksToText } from '../components/link.js';
+import { createCallout, createCodeGroup, createTabs } from '../customComponents/create.js';
+import { rehypeToRemarkCustomComponents } from '../customComponents/plugin.js';
+import { selectiveRehypeRemark } from '../customComponents/selective.js';
+import { htmlToHast } from '../pipeline/root.js';
+import { unifiedRemoveBreaks } from '../utils/breaks.js';
+import { unifiedRemoveClassNames } from '../utils/className.js';
+import { unifiedRemoveCopyButtons } from '../utils/copyButton.js';
+import { framework } from '../utils/detectFramework.js';
+import { remarkRemoveEmptyEmphases } from '../utils/emptyEmphasis.js';
+import { unifiedRemoveEmptyParagraphs } from '../utils/emptyParagraphs.js';
+import { remarkProperlyFormatEmphasis } from '../utils/formatEmphasis.js';
+import { removeHastComments } from '../utils/hastComments.js';
+import { remarkSpaceListsOut } from '../utils/lists.js';
+import { unifiedRemoveNestedRoots } from '../utils/nestedRoots.js';
+import { unifiedRemovePositions } from '../utils/position.js';
+const rehypeRewriteLinks = (rewriteLink) => () => (tree) => {
+    visit(tree, 'element', (node) => {
+        if (node.tagName !== 'a' || typeof node.properties?.href !== 'string')
+            return;
+        const rewritten = rewriteLink(node.properties.href);
+        if (rewritten === undefined) {
+            delete node.properties.href;
+        }
+        else {
+            node.properties.href = rewritten;
+        }
+    });
+};
+export function hastToMdx(fragment, rewriteLink) {
+    const originalVendor = framework.vendor;
+    framework.vendor ??= 'gitbook';
+    try {
+        return runHastToMdx(fragment, rewriteLink);
+    }
+    finally {
+        framework.vendor = originalVendor;
+    }
+}
+function runHastToMdx(fragment, rewriteLink) {
+    const processor = unified().use(unifiedRemoveBreaks).use(unifiedRemoveCopyButtons);
+    if (rewriteLink)
+        processor.use(rehypeRewriteLinks(rewriteLink));
+    const mdastTree = processor
+        .use(createCallout)
+        .use(createCodeGroup)
+        .use(createTabs)
+        .use(unifiedRemoveClassNames)
+        .use(unifiedRemoveEmptyParagraphs)
+        .use(unifiedRemovePositions)
+        .use(selectiveRehypeRemark)
+        .use(rehypeToRemarkCustomComponents)
+        .use(convertHeaderLinksToText)
+        .use(unifiedRemoveNestedRoots)
+        .use(remarkSpaceListsOut)
+        .use(remarkRemoveEmptyEmphases)
+        .use(remarkProperlyFormatEmphasis)
+        // @ts-expect-error hast root is transformed to mdast by the plugin chain
+        .runSync(fragment);
+    return stringifyMdast(mdastTree);
+}
+export function htmlToMdx(html, rewriteLink) {
+    const hast = htmlToHast(html);
+    removeHastComments(hast);
+    return hastToMdx(hast, rewriteLink);
+}
+export function markdownToMdx(markdown) {
+    const mdastTree = unified().use(remarkParse).use(remarkGfm).parse(markdown);
+    visit(mdastTree, 'html', (node) => {
+        node.type = 'text';
+        node.value = node.value.replace(/<[^>]*>/g, '');
+    });
+    return stringifyMdast(mdastTree);
+}
+function stringifyMdast(tree) {
+    const result = unified().use(remarkMdx).use(remarkGfm).use(remarkStringify).stringify(tree);
+    return String(result)
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+}
+export function escapeMdxText(text) {
+    return markdownToMdx(text.replace(/\r\n/g, '\n'));
+}
+//# sourceMappingURL=convert.js.map

package/bin/sdk/convert.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert.js","sourceRoot":"","sources":["../../src/sdk/convert.ts"],"names":[],"mappings":"AAEA,OAAO,SAAS,MAAM,YAAY,CAAC;AACnC,OAAO,SAAS,MAAM,YAAY,CAAC;AACnC,OAAO,WAAW,MAAM,cAAc,CAAC;AACvC,OAAO,eAAe,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,OAAO,EAAe,MAAM,SAAS,CAAC;AAC/C,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAEzC,OAAO,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AACjE,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAC3F,OAAO,EAAE,8BAA8B,EAAE,MAAM,+BAA+B,CAAC;AAC/E,OAAO,EAAE,qBAAqB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AAClE,OAAO,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AACxD,OAAO,EAAE,yBAAyB,EAAE,MAAM,2BAA2B,CAAC;AACtE,OAAO,EAAE,4BAA4B,EAAE,MAAM,6BAA6B,CAAC;AAC3E,OAAO,EAAE,4BAA4B,EAAE,MAAM,4BAA4B,CAAC;AAC1E,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAC9D,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAI9D,MAAM,kBAAkB,GACtB,CAAC,WAAwB,EAAwB,EAAE,CACnD,GAAG,EAAE,CACL,CAAC,IAAc,EAAE,EAAE;IACjB,KAAK,CAAC,IAAI,EAAE,SAAS,EAAE,CAAC,IAAa,EAAE,EAAE;QACvC,IAAI,IAAI,CAAC,OAAO,KAAK,GAAG,IAAI,OAAO,IAAI,CAAC,UAAU,EAAE,IAAI,KAAK,QAAQ;YAAE,OAAO;QAC9E,MAAM,SAAS,GAAG,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;QACpD,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;YAC5B,OAAO,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC;QAC9B,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,UAAU,CAAC,IAAI,GAAG,SAAS,CAAC;QACnC,CAAC;IACH,CAAC,CAAC,CAAC;AACL,CAAC,CAAC;AAEJ,MAAM,UAAU,SAAS,CAAC,QAAkB,EAAE,WAAyB;IACrE,MAAM,cAAc,GAAG,SAAS,CAAC,MAAM,CAAC;IACxC,SAAS,CAAC,MAAM,KAAK,SAAS,CAAC;IAC/B,IAAI,CAAC;QACH,OAAO,YAAY,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;IAC7C,CAAC;YAAS,CAAC;QACT,SAAS,CAAC,MAAM,GAAG,cAAc,CAAC;IACpC,CAAC;AACH,CAAC;AAED,SAAS,YAAY,CAAC,QAAkB,EAAE,WAAyB;IACjE,MAAM,SAAS,GAAG,OAAO,EAAE,CAAC,GAAG,CAAC,mBAAmB,CAAC,CAAC,GAAG,CAAC,wBAAwB,CAAC,CAAC;IACnF,IAAI,WAAW;QAAE,SAAS,CAAC,GAAG,CAAC,kBAAkB,CAAC,WAAW,CAAC,CAAC,CAAC;IAChE,MAAM,SAAS,GAAG,SAAS;SACxB,GAAG,CAAC,aAAa,CAAC;SAClB,GAAG,CAAC,eAAe,CAAC;SACpB,GAAG,CAAC,UAAU,CAAC;SACf,GAAG,CAAC,uBAAuB,CAAC;SAC5B,GAAG,CAAC,4BAA4B,CAAC;SACjC,GAAG,CAAC,sBAAsB,CAAC;SAC3B,GAAG,CAAC,qBAAqB,CAAC;SAC1B,GAAG,CAAC,8BAA8B,CAAC;SACnC,GAAG,CAAC,wBAAwB,CAAC;SAC7B,GAAG,CAAC,wBAAwB,CAAC;SAC7B,GAAG,CAAC,mBAAmB,CAAC;SACxB,GAAG,CAAC,yBAAyB,CAAC;SAC9B,GAAG,CAAC,4BAA4B,CAAC;QAClC,yEAAyE;SACxE,OAAO,CAAC,QAAQ,CAAc,CAAC;IAElC,OAAO,cAAc,CAAC,SAAS,CAAC,CAAC;AACnC,CAAC;AAED,MAAM,UAAU,SAAS,CAAC,IAAY,EAAE,WAAyB;IAC/D,MAAM,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC;IAC9B,kBAAkB,CAAC,IAAI,CAAC,CAAC;IACzB,OAAO,SAAS,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC;AACtC,CAAC;AAED,MAAM,UAAU,aAAa,CAAC,QAAgB;IAC5C,MAAM,SAAS,GAAG,OAAO,EAAE,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,KAAK,CAAC,QAAQ,CAAc,CAAC;IACzF,KAAK,CAAC,SAAS,EAAE,MAAM,EAAE,CAAC,IAAqC,EAAE,EAAE;QACjE,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC;QACnB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC;IAClD,CAAC,CAAC,CAAC;IACH,OAAO,cAAc,CAAC,SAAS,CAAC,CAAC;AACnC,CAAC;AAED,SAAS,cAAc,CAAC,IAAe;IACrC,MAAM,MAAM,GAAG,OAAO,EAAE,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;IAC5F,OAAO,MAAM,CAAC,MAAM,CAAC;SAClB,OAAO,CAAC,SAAS,EAAE,MAAM,CAAC;SAC1B,IAAI,EAAE,CAAC;AACZ,CAAC;AAED,MAAM,UAAU,aAAa,CAAC,IAAY;IACxC,OAAO,aAAa,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC;AACpD,CAAC"}

package/bin/sdk/converters/docfx.d.ts

@@ -0,0 +1,2 @@
+import type { SdkReference } from '../types.js';
+export declare function convertDocfx(sourcePath: string): Promise<SdkReference>;

package/bin/sdk/converters/docfx.js

@@ -0,0 +1,402 @@
+import fse from 'fs-extra';
+import yaml from 'js-yaml';
+import path from 'node:path';
+import { htmlToMdx } from '../convert.js';
+const PAGE_TAGS = {
+    Class: 'CLASS',
+    Interface: 'INTERFACE',
+    Enum: 'ENUM',
+    Struct: 'STRUCT',
+    Delegate: 'DELEGATE',
+};
+export async function convertDocfx(sourcePath) {
+    const files = await loadManagedReferenceFiles(sourcePath);
+    const itemsByUid = new Map();
+    const namesByUid = new Map();
+    for (const file of files) {
+        for (const item of file.items ?? []) {
+            if (!item.uid)
+                continue;
+            itemsByUid.set(item.uid, item);
+            if (item.name)
+                namesByUid.set(item.uid, item.name);
+        }
+        for (const reference of file.references ?? []) {
+            if (reference.uid && reference.name && !namesByUid.has(reference.uid)) {
+                namesByUid.set(reference.uid, reference.name);
+            }
+        }
+    }
+    const types = [...itemsByUid.values()]
+        .filter((item) => item.type !== undefined && item.type in PAGE_TAGS)
+        .sort((left, right) => (left.name ?? '').localeCompare(right.name ?? ''));
+    const namespaceSlug = namespaceSlugs([...new Set(types.map((type) => type.namespace ?? ''))].sort());
+    const slugByUid = new Map();
+    for (const type of types) {
+        slugByUid.set(type.uid, path.posix.join(namespaceSlug.get(type.namespace ?? '') ?? '', slugify(type.name ?? type.uid)));
+    }
+    const renderer = new DocfxRenderer(slugByUid, namesByUid, itemsByUid);
+    const { tocNamespaces, tocOrder } = await loadToc(sourcePath);
+    const typesByNamespace = new Map();
+    for (const type of types) {
+        const namespace = type.namespace ?? '';
+        typesByNamespace.set(namespace, [...(typesByNamespace.get(namespace) ?? []), type]);
+    }
+    const namespaceOrder = [
+        ...tocNamespaces.filter((namespace) => typesByNamespace.has(namespace)),
+        ...[...typesByNamespace.keys()]
+            .filter((namespace) => !tocNamespaces.includes(namespace))
+            .sort(),
+    ];
+    const pages = [];
+    const groups = [];
+    for (const namespace of namespaceOrder) {
+        const ordered = orderByToc(typesByNamespace.get(namespace) ?? [], tocOrder.get(namespace) ?? []);
+        const namespacePages = ordered.map((type) => renderer.renderPage(type));
+        pages.push(...namespacePages);
+        groups.push({
+            group: namespace || 'Reference',
+            pages: namespacePages.map((page) => page.slug),
+        });
+    }
+    return { pages, groups };
+}
+async function loadManagedReferenceFiles(sourcePath) {
+    const entries = await fse.readdir(sourcePath);
+    const files = [];
+    for (const entry of entries.filter((name) => /\.ya?ml$/.test(name)).sort()) {
+        const raw = await fse.readFile(path.join(sourcePath, entry), 'utf8');
+        if (!raw.startsWith('### YamlMime:ManagedReference'))
+            continue;
+        const parsed = yaml.load(raw);
+        if (parsed && typeof parsed === 'object')
+            files.push(parsed);
+    }
+    return files;
+}
+async function loadToc(sourcePath) {
+    const tocNamespaces = [];
+    const tocOrder = new Map();
+    const tocPath = path.join(sourcePath, 'toc.yml');
+    if (!(await fse.pathExists(tocPath)))
+        return { tocNamespaces, tocOrder };
+    const parsed = yaml.load(await fse.readFile(tocPath, 'utf8'));
+    const collect = (nodes) => {
+        for (const node of nodes) {
+            if (node.type === 'Namespace' && node.uid !== undefined) {
+                tocNamespaces.push(node.uid);
+                tocOrder.set(node.uid, (node.items ?? [])
+                    .map((child) => child.uid)
+                    .filter((uid) => typeof uid === 'string'));
+            }
+            if (node.items)
+                collect(node.items);
+        }
+    };
+    collect(parsed?.items ?? []);
+    return { tocNamespaces, tocOrder };
+}
+function orderByToc(types, order) {
+    const rank = new Map(order.map((uid, index) => [uid, index]));
+    return [...types].sort((left, right) => {
+        const leftRank = rank.get(left.uid);
+        const rightRank = rank.get(right.uid);
+        if (leftRank !== undefined && rightRank !== undefined)
+            return leftRank - rightRank;
+        if (leftRank !== undefined)
+            return -1;
+        if (rightRank !== undefined)
+            return 1;
+        return (left.name ?? '').localeCompare(right.name ?? '');
+    });
+}
+function namespaceSlugs(namespaces) {
+    const parts = namespaces.map((namespace) => namespace.split('.'));
+    let common = parts[0] ?? [];
+    for (const segments of parts.slice(1)) {
+        let index = 0;
+        while (index < common.length && common[index] === segments[index])
+            index += 1;
+        common = common.slice(0, index);
+    }
+    const slugs = new Map();
+    const used = new Set();
+    for (const [index, namespace] of namespaces.entries()) {
+        const segments = parts[index] ?? [];
+        const rest = segments.slice(common.length);
+        const base = slugify((rest.length ? rest : segments.slice(-1)).join('-'));
+        let slug = used.has(base) ? slugify(segments.join('-')) : base;
+        for (let suffix = 2; used.has(slug); suffix += 1) {
+            slug = `${slugify(segments.join('-'))}-${suffix}`;
+        }
+        used.add(slug);
+        slugs.set(namespace, slug);
+    }
+    return slugs;
+}
+function slugify(name) {
+    return (name
+        .toLowerCase()
+        .replace(/`+\d*/g, '')
+        .replace(/[^a-z0-9-_.]+/g, '-')
+        .replace(/^-+|-+$/g, '') || 'item');
+}
+class DocfxRenderer {
+    constructor(slugByUid, namesByUid, itemsByUid) {
+        this.slugByUid = slugByUid;
+        this.namesByUid = namesByUid;
+        this.itemsByUid = itemsByUid;
+    }
+    renderPage(item) {
+        const lines = [this.prose(item.summary)];
+        if (item.syntax?.content)
+            lines.push(this.codeBlock(item.syntax.content));
+        lines.push(this.prose(item.remarks));
+        lines.push(...(item.example ?? []).map((example) => this.renderExample(example)));
+        switch (item.type) {
+            case 'Enum':
+                lines.push(...this.renderEnum(item));
+                break;
+            case 'Delegate':
+                lines.push(...this.renderSignatureDetails(item.syntax, 2));
+                break;
+            default:
+                lines.push(...this.renderTypeMembers(item));
+        }
+        return {
+            slug: this.slugByUid.get(item.uid) ?? slugify(item.name ?? item.uid),
+            title: item.name ?? item.uid,
+            description: this.firstSentence(item.summary),
+            tag: PAGE_TAGS[item.type ?? ''],
+            content: lines.filter(Boolean).join('\n\n'),
+        };
+    }
+    members(item) {
+        return (item.children ?? [])
+            .map((uid) => this.itemsByUid.get(uid))
+            .filter((member) => member !== undefined);
+    }
+    renderTypeMembers(item) {
+        const members = this.members(item);
+        const lines = [];
+        const constructors = members.filter((member) => member.type === 'Constructor');
+        const fields = members.filter((member) => member.type === 'Field').sort(byName);
+        const properties = members
+            .filter((member) => member.type === 'Property' || member.type === 'Event')
+            .sort(byName);
+        const methods = members.filter((member) => member.type === 'Method' || member.type === 'Operator');
+        if (constructors.length) {
+            lines.push('## Constructors');
+            for (const ctor of constructors)
+                lines.push(...this.renderMember(ctor, 3));
+        }
+        if (fields.length) {
+            lines.push('## Fields');
+            for (const field of fields)
+                lines.push(this.memberField(field));
+        }
+        if (properties.length) {
+            lines.push('## Properties');
+            for (const property of properties)
+                lines.push(this.memberField(property));
+        }
+        if (methods.length) {
+            lines.push('## Methods');
+            const grouped = new Map();
+            for (const method of methods) {
+                const base = baseName(method.name ?? method.uid);
+                grouped.set(base, [...(grouped.get(base) ?? []), method]);
+            }
+            for (const [name, overloads] of [...grouped.entries()].sort(([left], [right]) => left.localeCompare(right))) {
+                lines.push(`### ${name}()`);
+                for (const overload of overloads)
+                    lines.push(...this.renderMember(overload, 4));
+            }
+        }
+        return lines;
+    }
+    renderEnum(item) {
+        const lines = ['## Members'];
+        for (const member of this.members(item).filter((child) => child.type === 'Field')) {
+            const value = member.syntax?.content?.split('=')[1]?.trim() ?? '';
+            lines.push(this.responseField(member.name ?? member.uid, value, false, this.prose(member.summary)));
+        }
+        return lines;
+    }
+    renderMember(member, depth) {
+        const lines = [];
+        if (member.syntax?.content)
+            lines.push(this.codeBlock(member.syntax.content));
+        lines.push(this.prose(member.summary), this.prose(member.remarks));
+        lines.push(...(member.example ?? []).map((example) => this.renderExample(example)));
+        lines.push(...this.renderSignatureDetails(member.syntax, depth));
+        return lines.filter(Boolean);
+    }
+    renderSignatureDetails(syntax, depth) {
+        if (!syntax)
+            return [];
+        const lines = [];
+        const heading = '#'.repeat(depth);
+        if (syntax.typeParameters?.length) {
+            lines.push(`${heading} Type Parameters`);
+            for (const param of syntax.typeParameters) {
+                lines.push(this.responseField(param.id ?? '', '', false, this.prose(param.description)));
+            }
+        }
+        if (syntax.parameters?.length) {
+            lines.push(`${heading} Parameters`);
+            for (const param of syntax.parameters) {
+                lines.push(this.responseField(param.id ?? '', this.typeName(param.type), isOptionalParameter(param.id, syntax.content), this.prose(param.description)));
+            }
+        }
+        const returnType = this.typeName(syntax.return?.type);
+        if (returnType && returnType.toLowerCase() !== 'void') {
+            lines.push(`${heading} Returns`);
+            const description = this.prose(syntax.return?.description);
+            lines.push(`\`${escapeInlineCode(returnType)}\`${description ? `\n\n${description}` : ''}`);
+        }
+        return lines;
+    }
+    memberField(member) {
+        const body = [
+            this.prose(member.summary),
+            this.prose(member.remarks),
+            ...(member.example ?? []).map((example) => this.renderExample(example)),
+        ]
+            .filter(Boolean)
+            .join('\n\n');
+        return this.responseField(member.name ?? member.uid, this.typeName(member.syntax?.return?.type), isNullable(member.syntax?.content), body);
+    }
+    responseField(name, type, optional, body) {
+        const typeAttr = type ? ` type=${this.jsxString(truncate(type, 80))}` : '';
+        const requiredAttr = optional ? '' : ' required';
+        return `<ResponseField name=${this.jsxString(name)}${typeAttr}${requiredAttr}>\n${indent(body || '')}\n</ResponseField>`;
+    }
+    jsxString(value) {
+        return `{${JSON.stringify(value)}}`;
+    }
+    codeBlock(code, lang = 'csharp') {
+        return `\`\`\`${lang}\n${code}\n\`\`\``;
+    }
+    renderExample(example) {
+        if (/<[a-z][^>]*>/i.test(example))
+            return this.prose(example);
+        return this.codeBlock(decodeEntities(example));
+    }
+    prose(html) {
+        if (!html)
+            return '';
+        const resolved = this.inlineCodeSpans(this.resolveXrefs(html));
+        return resolved
+            .split(/(<pre[^>]*>[\s\S]*?<\/pre>)/g)
+            .map((segment, index) => index % 2 === 1 ? this.preToCodeBlock(segment) : htmlToMdx(segment))
+            .filter(Boolean)
+            .join('\n\n');
+    }
+    preToCodeBlock(segment) {
+        const lang = /class="lang(?:uage)?-([\w-]+)"/.exec(segment)?.[1] ?? 'csharp';
+        const code = decodeEntities(segment.replace(/<[^>]+>/g, '')).replace(/^\n+|\n+$/g, '');
+        return this.codeBlock(code, lang);
+    }
+    resolveXrefs(html) {
+        return html.replace(/<xref\s[^>]*?(?:href|uid)="([^"]+)"[^>]*>([\s\S]*?)<\/xref>/g, (_, href, text) => {
+            const uid = decodeUid(href);
+            const label = text.trim() || escapeHtml(this.shortName(uid));
+            const slug = this.slugForUid(uid);
+            return slug ? `<a href="/${slug}">${label}</a>` : `<code>${label}</code>`;
+        });
+    }
+    inlineCodeSpans(html) {
+        return html
+            .split(/(<pre[\s\S]*?<\/pre>|<code[\s\S]*?<\/code>)/g)
+            .map((segment, index) => index % 2 === 1
+            ? segment
+            : segment.replace(/`([^`\n]+)`/g, (_, code) => `<code>${escapeHtml(code)}</code>`))
+            .join('');
+    }
+    slugForUid(uid) {
+        const direct = this.slugByUid.get(uid);
+        if (direct)
+            return direct;
+        const parent = this.itemsByUid.get(uid)?.parent ??
+            uid
+                .replace(/\(.*\)$/, '')
+                .replace(/\*$/, '')
+                .replace(/\.[^.]*$/, '');
+        return parent ? this.slugByUid.get(parent) : undefined;
+    }
+    shortName(uid) {
+        return this.namesByUid.get(uid) ?? shortNameFromUid(uid);
+    }
+    typeName(uid) {
+        return uid ? this.shortName(uid) : '';
+    }
+    firstSentence(summary) {
+        if (!summary)
+            return undefined;
+        const text = decodeEntities(summary.replace(/<[^>]*>/g, ' '))
+            .replace(/\s+/g, ' ')
+            .trim();
+        if (!text)
+            return undefined;
+        const sentence = text.split(/(?<=\.)\s/)[0] ?? text;
+        return truncate(sentence, 160);
+    }
+}
+function byName(left, right) {
+    return (left.name ?? '').localeCompare(right.name ?? '');
+}
+function baseName(name) {
+    return name.split(/[(<]/)[0]?.trim() || name;
+}
+function shortNameFromUid(uid) {
+    return uid
+        .replace(/`+\d+/g, '')
+        .replace(/\{/g, '<')
+        .replace(/\}/g, '>')
+        .replace(/[A-Za-z_][A-Za-z0-9_.]*/g, (dotted) => dotted.split('.').at(-1) ?? dotted);
+}
+function decodeUid(href) {
+    try {
+        return decodeEntities(decodeURIComponent(href));
+    }
+    catch {
+        return decodeEntities(href);
+    }
+}
+function decodeEntities(text) {
+    return text
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/&nbsp;/g, ' ')
+        .replace(/&amp;/g, '&');
+}
+function escapeHtml(text) {
+    return text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+function isNullable(content) {
+    return content !== undefined && /\?\s+\w+\s*[{;=]/.test(content);
+}
+function isOptionalParameter(id, content) {
+    if (!id || !content)
+        return false;
+    return new RegExp(`\\b${escapeRegExp(id)}\\s*=`).test(content);
+}
+function escapeRegExp(text) {
+    return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function indent(text) {
+    return text
+        .split('\n')
+        .map((line) => (line ? `  ${line}` : line))
+        .join('\n');
+}
+function truncate(text, max) {
+    return text.length > max ? `${text.slice(0, max - 1)}…` : text;
+}
+function escapeInlineCode(text) {
+    return text.replace(/`/g, '');
+}
+//# sourceMappingURL=docfx.js.map