@ciderpress/ui 1.0.0-rc.10 → 1.0.0-rc.12

package/dist/node.mjs

@@ -6,12 +6,14 @@ import node_path from "node:path";
 import { fileURLToPath } from "node:url";
 import { resolveOptionalIcon, serializeIcon } from "@ciderpress/config";
 import { BRAND_COLORS, BUILT_IN_THEMES, DEFAULT_THEME_NAME, defineTheme, isBuiltInTheme, resolveDefaultVariant, resolveThemeAlias, resolveThemeVariants, themeToCss } from "@ciderpress/theme";
+import { pluginSitemap } from "@rspress/plugin-sitemap";
 import { P, match as match_match } from "massaman/match";
 import { visit as external_unist_util_visit_visit } from "unist-util-visit";
 import path_0 from "path";
 import { Project, SyntaxKind as external_ts_morph_SyntaxKind } from "ts-morph";
 import node_process from "node:process";
 import katex from "katex";
+import { unfold } from "massaman/array";
 import react from "react";
 import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
 import { dirname as __rspack_dirname } from "node:path";
@@ -17358,7 +17360,7 @@ function buildLabelCss(label) {
   margin-top: -14px;
   text-align: left;
   color: var(--cp-c-text-2, #888);
-  font-family: 'Geist Pixel Square', ui-sans-serif, system-ui, sans-serif;
+  font-family: var(--cp-ff-display, 'Geist Pixel Square', ui-sans-serif, system-ui, sans-serif);
   font-size: 28px;
   font-weight: 400;
   line-height: 1;
@@ -17375,10 +17377,658 @@ function ciderpressPlugin() {
         name: 'ciderpress',
         globalUIComponents: [
             node_path.resolve(componentsDir, 'theme-provider.tsx'),
-            node_path.resolve(componentsDir, 'edit-source-button.tsx')
+            node_path.resolve(componentsDir, 'edit-source-button.tsx'),
+            node_path.resolve(componentsDir, 'seo-head.tsx')
         ]
     };
 }
+const VERCEL_RESERVED_ROUTES = new Set([
+    'account',
+    'ai',
+    'blog',
+    'changelog',
+    'contact',
+    'customers',
+    'dashboard',
+    'design',
+    'docs',
+    'enterprise',
+    'guides',
+    'integrations',
+    'login',
+    'marketplace',
+    'new',
+    'oss',
+    'partners',
+    'pricing',
+    'resources',
+    'security',
+    'signup',
+    'solutions',
+    'templates'
+]);
+function parseIssueLink(value) {
+    if (!URL.canParse(value)) return null;
+    const url = new URL(value);
+    if ('https:' !== url.protocol) return null;
+    const segments = url.pathname.split('/').filter(Boolean);
+    const known = match_match(url.hostname).with('github.com', ()=>parseGitHubLink(segments)).with('www.github.com', ()=>parseGitHubLink(segments)).with('gitlab.com', ()=>parseGitLabLink(segments)).with('www.gitlab.com', ()=>parseGitLabLink(segments)).with('bitbucket.org', ()=>parseBitbucketLink(segments)).with('www.npmjs.com', ()=>parseNpmLink(segments)).with('npmjs.com', ()=>parseNpmLink(segments)).with('linear.app', ()=>parseLinearLink(segments)).with('app.clickup.com', ()=>parseClickUpLink(segments)).with('app.dash0.com', ()=>parseDash0Link({
+            segments,
+            url
+        })).with('app.launchdarkly.com', ()=>parseLaunchDarklyLink(segments)).with('app.posthog.com', ()=>parsePostHogLink(segments)).with('eu.posthog.com', ()=>parsePostHogLink(segments)).with('app.pulumi.com', ()=>parsePulumiLink(segments)).with('vercel.com', ()=>parseVercelLink(segments)).with('www.figma.com', ()=>parseFigmaLink(segments)).with('figma.com', ()=>parseFigmaLink(segments)).with('docs.google.com', ()=>parseGoogleDocsLink(segments)).with('drive.google.com', ()=>parseGoogleDriveLink(segments)).with('trello.com', ()=>parseTrelloLink(segments)).with('www.trello.com', ()=>parseTrelloLink(segments)).with('app.asana.com', ()=>parseAsanaLink(segments)).with('www.loom.com', ()=>parseLoomLink(segments)).with('loom.com', ()=>parseLoomLink(segments)).with('www.postman.com', ()=>parsePostmanLink(segments)).with('postman.com', ()=>parsePostmanLink(segments)).when((hostname)=>hostname.endsWith('.atlassian.net'), ()=>parseAtlassianLink(segments)).when(isNotionHostname, ()=>parseNotionLink(segments)).when(isDatadogHostname, ()=>parseDatadogLink(segments)).when(isPagerDutyHostname, ()=>parsePagerDutyLink(segments)).when(isSlackHostname, ()=>parseSlackLink(segments)).when(isSentryHostname, ()=>parseSentryLink(segments)).otherwise(()=>null);
+    return known;
+}
+function parseClickUpLink(segments) {
+    const [resource, identifier] = segments;
+    if ('t' !== resource || void 0 === identifier) return null;
+    return {
+        provider: 'clickup',
+        kind: 'task',
+        label: `Task ${identifier}`,
+        reference: identifier,
+        title: `Task ${identifier} on ClickUp`
+    };
+}
+function parseDash0Link({ segments, url }) {
+    const [marker, resource, view] = segments;
+    if ('goto' !== marker || void 0 === resource) return null;
+    return match_match({
+        resource,
+        view
+    }).with({
+        resource: 'dashboards'
+    }, ()=>opaqueLink({
+            provider: 'dash0',
+            kind: 'dashboard',
+            label: 'Dash0 dashboard'
+        })).with({
+        resource: 'logs'
+    }, ()=>opaqueLink({
+            provider: 'dash0',
+            kind: 'logs',
+            label: 'Dash0 logs'
+        })).with({
+        resource: 'services'
+    }, ()=>opaqueLink({
+            provider: 'dash0',
+            kind: 'service',
+            label: 'Dash0 service'
+        })).when(({ resource: area })=>'traces' === area && url.searchParams.has('traceid'), ()=>opaqueLink({
+            provider: 'dash0',
+            kind: 'trace',
+            label: 'Dash0 trace'
+        })).otherwise(()=>null);
+}
+function parseDatadogLink(segments) {
+    const [resource, identifier] = segments;
+    if (void 0 === identifier) return null;
+    return match_match(resource).with('dashboard', ()=>opaqueLink({
+            provider: 'datadog',
+            kind: 'dashboard',
+            label: 'Datadog dashboard'
+        })).with('monitors', ()=>opaqueLink({
+            provider: 'datadog',
+            kind: 'monitor',
+            label: 'Datadog monitor'
+        })).otherwise(()=>null);
+}
+function parseLaunchDarklyLink(segments) {
+    const [projects, project, flags, identifier] = segments;
+    if ('projects' !== projects || void 0 === project || 'flags' !== flags || void 0 === identifier) return null;
+    return {
+        provider: 'launchdarkly',
+        kind: 'flag',
+        label: `Flag ${identifier}`,
+        reference: identifier,
+        title: `Flag ${identifier} in ${project} on LaunchDarkly`
+    };
+}
+function parsePostHogLink(segments) {
+    const [projectMarker, project, resource, identifier] = segments;
+    if ('project' !== projectMarker || void 0 === project || void 0 === resource) return null;
+    return match_match(resource).when((value)=>'insights' === value && void 0 !== identifier, ()=>opaqueLink({
+            provider: 'posthog',
+            kind: 'insight',
+            label: 'PostHog insight'
+        })).when((value)=>'replay' === value && void 0 !== identifier, ()=>opaqueLink({
+            provider: 'posthog',
+            kind: 'recording',
+            label: 'PostHog recording'
+        })).when((value)=>'feature_flags' === value && void 0 !== identifier, ()=>opaqueLink({
+            provider: 'posthog',
+            kind: 'feature-flag',
+            label: 'PostHog flag'
+        })).otherwise(()=>null);
+}
+function parsePulumiLink(segments) {
+    const [organization, project, stack] = segments;
+    if (void 0 === organization || void 0 === project || void 0 === stack) return null;
+    return {
+        provider: 'pulumi',
+        kind: 'stack',
+        label: `Stack ${stack}`,
+        reference: stack,
+        title: `Stack ${organization}/${project}/${stack} on Pulumi`
+    };
+}
+function parsePagerDutyLink(segments) {
+    const [resource, identifier] = segments;
+    if ('incidents' !== resource || void 0 === identifier) return null;
+    return {
+        provider: 'pagerduty',
+        kind: 'incident',
+        label: `Incident ${identifier}`,
+        reference: identifier,
+        title: `Incident ${identifier} on PagerDuty`
+    };
+}
+function parseVercelLink(segments) {
+    const [team, project] = segments;
+    if (void 0 === team || void 0 === project || VERCEL_RESERVED_ROUTES.has(team)) return null;
+    return opaqueLink({
+        provider: 'vercel',
+        kind: 'project',
+        label: 'Vercel project'
+    });
+}
+function remarkIssueLinks() {
+    return (tree)=>{
+        external_unist_util_visit_visit(tree, 'link', (node)=>{
+            const issue = parseIssueLink(node.url);
+            if (null === issue) return;
+            const label = resolveLabel({
+                issue,
+                node
+            });
+            const data = node.data ?? {};
+            const properties = readHProperties(data);
+            node.children = buildBadgeChildren({
+                provider: issue.provider,
+                label
+            });
+            node.data = {
+                ...data,
+                hProperties: {
+                    ...properties,
+                    className: [
+                        ...readClassNames(properties.className),
+                        'cp-issue-link',
+                        `cp-issue-link--${issue.provider}`
+                    ],
+                    title: issue.title
+                }
+            };
+        });
+    };
+}
+function buildBadgeChildren({ provider, label }) {
+    return [
+        {
+            type: 'mdxJsxTextElement',
+            name: 'IssueLinkIcon',
+            attributes: [
+                {
+                    type: 'mdxJsxAttribute',
+                    name: 'provider',
+                    value: provider
+                }
+            ],
+            children: []
+        },
+        {
+            type: 'text',
+            value: label.text
+        },
+        ...buildReferenceChildren(label.reference)
+    ];
+}
+function parseGitHubLink(segments) {
+    const [owner, repo, resource, identifier] = segments;
+    if (void 0 === owner || void 0 === repo || void 0 === identifier) return null;
+    return match_match(resource).when((value)=>'issues' === value && isNumericIdentifier(identifier), ()=>numberedGitHubLink({
+            owner,
+            repo,
+            identifier,
+            kind: 'issue'
+        })).when((value)=>'pull' === value && isNumericIdentifier(identifier), ()=>numberedGitHubLink({
+            owner,
+            repo,
+            identifier,
+            kind: 'pull'
+        })).when((value)=>'discussions' === value && isNumericIdentifier(identifier), ()=>numberedGitHubLink({
+            owner,
+            repo,
+            identifier,
+            kind: 'discussion'
+        })).when((value)=>'commit' === value && /^[a-f\d]{7,64}$/i.test(identifier), ()=>commitLink({
+            provider: 'github',
+            owner,
+            repo,
+            identifier
+        })).with('releases', ()=>parseGitHubRelease({
+            owner,
+            repo,
+            segments
+        })).with('actions', ()=>parseGitHubAction({
+            owner,
+            repo,
+            segments
+        })).otherwise(()=>null);
+}
+function parseGitLabLink(segments) {
+    const divider = segments.indexOf('-');
+    if (divider < 1) return null;
+    const resource = segments.at(divider + 1);
+    const identifier = segments.at(divider + 2);
+    if (void 0 === resource || void 0 === identifier) return null;
+    return match_match(resource).when((value)=>'issues' === value && isNumericIdentifier(identifier), ()=>numberedLink({
+            provider: 'gitlab',
+            kind: 'issue',
+            identifier
+        })).when((value)=>'merge_requests' === value && isNumericIdentifier(identifier), ()=>numberedLink({
+            provider: 'gitlab',
+            kind: 'merge',
+            identifier
+        })).with('commit', ()=>commitLink({
+            provider: 'gitlab',
+            owner: '',
+            repo: '',
+            identifier
+        })).with('releases', ()=>({
+            provider: 'gitlab',
+            kind: 'release',
+            label: `Release ${identifier}`,
+            reference: identifier,
+            title: `Release ${identifier} on GitLab`
+        })).otherwise(()=>null);
+}
+function parseBitbucketLink(segments) {
+    const [owner, repo, resource, identifier] = segments;
+    if (void 0 === owner || void 0 === repo || void 0 === identifier) return null;
+    return match_match(resource).when((value)=>'issues' === value && isNumericIdentifier(identifier), ()=>numberedLink({
+            provider: 'bitbucket',
+            kind: 'issue',
+            identifier
+        })).when((value)=>'pull-requests' === value && isNumericIdentifier(identifier), ()=>numberedLink({
+            provider: 'bitbucket',
+            kind: 'pull',
+            identifier
+        })).with('commits', ()=>commitLink({
+            provider: 'bitbucket',
+            owner,
+            repo,
+            identifier
+        })).otherwise(()=>null);
+}
+function resolveLabel({ issue, node }) {
+    const authored = node.children.map(readInlineText).join('').trim();
+    if (0 === authored.length || authored === node.url) return {
+        text: issue.label,
+        reference: null
+    };
+    return {
+        text: authored,
+        reference: issue.reference
+    };
+}
+function readHProperties(data) {
+    const properties = data.hProperties;
+    if ('object' != typeof properties || null === properties || Array.isArray(properties)) return {};
+    return properties;
+}
+function readClassNames(value) {
+    if ('string' == typeof value) return value.split(/\s+/).filter(Boolean);
+    if (!Array.isArray(value)) return [];
+    return value.filter((entry)=>'string' == typeof entry);
+}
+function isNumericIdentifier(identifier) {
+    return /^\d+$/.test(identifier);
+}
+function buildReferenceChildren(reference) {
+    if (null === reference) return [];
+    return [
+        {
+            type: 'mdxJsxTextElement',
+            name: 'span',
+            attributes: [
+                {
+                    type: 'mdxJsxAttribute',
+                    name: 'className',
+                    value: 'cp-issue-link__reference'
+                }
+            ],
+            children: [
+                {
+                    type: 'text',
+                    value: reference
+                }
+            ]
+        }
+    ];
+}
+function readInlineText(node) {
+    if (void 0 !== node.value) return node.value;
+    if (void 0 === node.children) return '';
+    return node.children.map(readInlineText).join('');
+}
+function parseLinearLink(segments) {
+    const [workspace, resource, identifier] = segments;
+    if (void 0 === workspace || 'issue' !== resource || void 0 === identifier) return null;
+    if (!/^[A-Z][A-Z0-9]+-\d+$/i.test(identifier)) return null;
+    const label = identifier.toUpperCase();
+    return {
+        provider: 'linear',
+        kind: 'issue',
+        label,
+        reference: label,
+        title: `${label} in ${workspace} on Linear`
+    };
+}
+function parseJiraLink(segments) {
+    const [resource, identifier] = segments;
+    if (2 !== segments.length || 'browse' !== resource || void 0 === identifier) return null;
+    if (!/^[A-Z][A-Z0-9]+-\d+$/i.test(identifier)) return null;
+    const label = identifier.toUpperCase();
+    return {
+        provider: 'jira',
+        kind: 'issue',
+        label,
+        reference: label,
+        title: `${label} on Jira`
+    };
+}
+function parseNpmLink(segments) {
+    const [resource, ...nameParts] = segments;
+    const packageName = nameParts.join('/');
+    if ('package' !== resource || 0 === packageName.length || nameParts.length > 2) return null;
+    return {
+        provider: 'npm',
+        kind: 'package',
+        label: packageName,
+        reference: 'npm',
+        title: `${packageName} on npm`
+    };
+}
+function parseFigmaLink(segments) {
+    const [resource, key] = segments;
+    if (void 0 === key) return null;
+    return match_match(resource).with('design', ()=>opaqueLink({
+            provider: 'figma',
+            kind: 'design',
+            label: 'Figma design'
+        })).with('file', ()=>opaqueLink({
+            provider: 'figma',
+            kind: 'file',
+            label: 'Figma file'
+        })).with('proto', ()=>opaqueLink({
+            provider: 'figma',
+            kind: 'prototype',
+            label: 'Figma prototype'
+        })).with('board', ()=>opaqueLink({
+            provider: 'figma',
+            kind: 'whiteboard',
+            label: 'FigJam board'
+        })).otherwise(()=>null);
+}
+function parseGoogleDocsLink(segments) {
+    const [resource, marker, identifier] = segments;
+    if ('d' !== marker || void 0 === identifier) return null;
+    return match_match(resource).with('document', ()=>opaqueLink({
+            provider: 'google-docs',
+            kind: 'document',
+            label: 'Google Doc'
+        })).with('spreadsheets', ()=>opaqueLink({
+            provider: 'google-sheets',
+            kind: 'spreadsheet',
+            label: 'Google Sheet'
+        })).otherwise(()=>null);
+}
+function parseGoogleDriveLink(segments) {
+    const [resource, marker, identifier] = segments;
+    if ('file' !== resource || 'd' !== marker || void 0 === identifier) return null;
+    return opaqueLink({
+        provider: 'google-drive',
+        kind: 'file',
+        label: 'Drive file'
+    });
+}
+function parseTrelloLink(segments) {
+    const [resource, identifier] = segments;
+    if ('c' !== resource || void 0 === identifier) return null;
+    return opaqueLink({
+        provider: 'trello',
+        kind: 'card',
+        label: 'Trello card'
+    });
+}
+function parseAsanaLink(segments) {
+    const [workspace, project, identifier] = segments;
+    if ('0' !== workspace || void 0 === project || void 0 === identifier) return null;
+    return {
+        provider: 'asana',
+        kind: 'task',
+        label: `Task ${identifier}`,
+        reference: identifier,
+        title: `Task ${identifier} on Asana`
+    };
+}
+function parseLoomLink(segments) {
+    const [resource, identifier] = segments;
+    if ('share' !== resource || void 0 === identifier) return null;
+    return opaqueLink({
+        provider: 'loom',
+        kind: 'video',
+        label: 'Loom video'
+    });
+}
+function parsePostmanLink(segments) {
+    return match_match(segments).when((path)=>path.includes('workspace'), ()=>opaqueLink({
+            provider: 'postman',
+            kind: 'workspace',
+            label: 'Postman workspace'
+        })).when((path)=>path.includes('collection') || path.includes('collections'), ()=>opaqueLink({
+            provider: 'postman',
+            kind: 'collection',
+            label: 'Postman collection'
+        })).otherwise(()=>null);
+}
+function parseAtlassianLink(segments) {
+    const jira = parseJiraLink(segments);
+    return match_match({
+        jira,
+        segments
+    }).when(({ jira: parsed })=>null !== parsed, ({ jira: parsed })=>parsed).when(({ segments: path })=>'wiki' === path.at(0), ({ segments: path })=>parseConfluenceLink(path)).otherwise(()=>null);
+}
+function parseConfluenceLink(segments) {
+    const pagesIndex = segments.indexOf('pages');
+    if (-1 === pagesIndex) return opaqueLink({
+        provider: 'confluence',
+        kind: 'page',
+        label: 'Confluence page'
+    });
+    const identifier = segments.at(pagesIndex + 1);
+    return match_match(identifier).when((value)=>void 0 !== value, (value)=>({
+            provider: 'confluence',
+            kind: 'page',
+            label: `Page ${value}`,
+            reference: value,
+            title: `Page ${value} on Confluence`
+        })).otherwise(()=>opaqueLink({
+            provider: 'confluence',
+            kind: 'page',
+            label: 'Confluence page'
+        }));
+}
+function parseSlackLink(segments) {
+    const [resource, channel, timestamp] = segments;
+    if ('archives' !== resource || void 0 === channel || void 0 === timestamp) return null;
+    return opaqueLink({
+        provider: 'slack',
+        kind: 'message',
+        label: 'Slack message'
+    });
+}
+function parseSentryLink(segments) {
+    const issueIndex = segments.indexOf('issues');
+    const identifier = segments.at(issueIndex + 1);
+    if (-1 === issueIndex || void 0 === identifier) return null;
+    return {
+        provider: 'sentry',
+        kind: 'issue',
+        label: `Issue #${identifier}`,
+        reference: `#${identifier}`,
+        title: `Issue #${identifier} on Sentry`
+    };
+}
+function numberedGitHubLink({ owner, repo, identifier, kind }) {
+    return match_match(kind).with('issue', ()=>({
+            provider: 'github',
+            kind,
+            label: `Issue #${identifier}`,
+            reference: `#${identifier}`,
+            title: `Issue #${identifier} in ${owner}/${repo} on GitHub`
+        })).with('pull', ()=>({
+            provider: 'github',
+            kind,
+            label: `Pull #${identifier}`,
+            reference: `#${identifier}`,
+            title: `Pull #${identifier} in ${owner}/${repo} on GitHub`
+        })).with('discussion', ()=>({
+            provider: 'github',
+            kind,
+            label: `Discussion #${identifier}`,
+            reference: `#${identifier}`,
+            title: `Discussion #${identifier} in ${owner}/${repo} on GitHub`
+        })).exhaustive();
+}
+function numberedLink({ provider, kind, identifier }) {
+    return match_match({
+        provider,
+        kind
+    }).with({
+        provider: 'gitlab',
+        kind: 'issue'
+    }, ()=>({
+            provider: 'gitlab',
+            kind: 'issue',
+            label: `Issue #${identifier}`,
+            reference: `#${identifier}`,
+            title: `Issue #${identifier} on GitLab`
+        })).with({
+        provider: 'gitlab',
+        kind: 'merge'
+    }, ()=>({
+            provider: 'gitlab',
+            kind: 'merge',
+            label: `Merge #${identifier}`,
+            reference: `#${identifier}`,
+            title: `Merge request #${identifier} on GitLab`
+        })).with({
+        provider: 'bitbucket',
+        kind: 'issue'
+    }, ()=>({
+            provider: 'bitbucket',
+            kind: 'issue',
+            label: `Issue #${identifier}`,
+            reference: `#${identifier}`,
+            title: `Issue #${identifier} on Bitbucket`
+        })).with({
+        provider: 'bitbucket',
+        kind: 'pull'
+    }, ()=>({
+            provider: 'bitbucket',
+            kind: 'pull',
+            label: `Pull #${identifier}`,
+            reference: `#${identifier}`,
+            title: `Pull request #${identifier} on Bitbucket`
+        })).otherwise(()=>null);
+}
+function commitLink({ provider, owner, repo, identifier }) {
+    const shortHash = identifier.slice(0, 7);
+    const repository = repositoryLabel({
+        owner,
+        repo
+    });
+    return match_match(provider).with('github', ()=>({
+            provider,
+            kind: 'commit',
+            label: `Commit ${shortHash}`,
+            reference: shortHash,
+            title: `Commit ${shortHash}${repository} on GitHub`
+        })).with('gitlab', ()=>({
+            provider,
+            kind: 'commit',
+            label: `Commit ${shortHash}`,
+            reference: shortHash,
+            title: `Commit ${shortHash} on GitLab`
+        })).with('bitbucket', ()=>({
+            provider,
+            kind: 'commit',
+            label: `Commit ${shortHash}`,
+            reference: shortHash,
+            title: `Commit ${shortHash}${repository} on Bitbucket`
+        })).exhaustive();
+}
+function repositoryLabel({ owner, repo }) {
+    if (0 === owner.length || 0 === repo.length) return '';
+    return ` in ${owner}/${repo}`;
+}
+function parseGitHubRelease({ owner, repo, segments }) {
+    const [tagMarker, identifier] = segments.slice(3);
+    if ('tag' !== tagMarker || void 0 === identifier) return null;
+    return {
+        provider: 'github',
+        kind: 'release',
+        label: `Release ${identifier}`,
+        reference: identifier,
+        title: `Release ${identifier} in ${owner}/${repo} on GitHub`
+    };
+}
+function parseGitHubAction({ owner, repo, segments }) {
+    const [runMarker, identifier] = segments.slice(3);
+    if ('runs' !== runMarker || void 0 === identifier) return null;
+    return {
+        provider: 'github',
+        kind: 'action',
+        label: `Run #${identifier}`,
+        reference: `#${identifier}`,
+        title: `Actions run #${identifier} in ${owner}/${repo} on GitHub`
+    };
+}
+function parseNotionLink(segments) {
+    if (0 === segments.length) return null;
+    return opaqueLink({
+        provider: 'notion',
+        kind: 'page',
+        label: 'Notion page'
+    });
+}
+function opaqueLink(params) {
+    const provider = providerName(params.provider);
+    return {
+        ...params,
+        reference: null,
+        title: `${params.label} on ${provider}`
+    };
+}
+function providerName(provider) {
+    return match_match(provider).with('confluence', ()=>'Confluence').with('dash0', ()=>'Dash0').with('datadog', ()=>'Datadog').with('figma', ()=>'Figma').with('google-docs', ()=>'Google Docs').with('google-drive', ()=>'Google Drive').with('google-sheets', ()=>'Google Sheets').with('loom', ()=>'Loom').with('notion', ()=>'Notion').with('postman', ()=>'Postman').with('posthog', ()=>'PostHog').with('slack', ()=>'Slack').with('trello', ()=>'Trello').with('vercel', ()=>'Vercel').exhaustive();
+}
+function isNotionHostname(hostname) {
+    return 'notion.so' === hostname || 'www.notion.so' === hostname || 'app.notion.com' === hostname || 'notion.site' === hostname || hostname.endsWith('.notion.site');
+}
+function isSlackHostname(hostname) {
+    return hostname.endsWith('.slack.com');
+}
+function isSentryHostname(hostname) {
+    return 'sentry.io' === hostname || hostname.endsWith('.sentry.io');
+}
+function isDatadogHostname(hostname) {
+    return /^(?:app|ap\d+|us\d+)\.datadoghq\.(?:com|eu)$/.test(hostname);
+}
+function isPagerDutyHostname(hostname) {
+    return 'app.pagerduty.com' === hostname || hostname.endsWith('.pagerduty.com');
+}
 function remarkMathToDiv() {
     return (tree)=>{
         external_unist_util_visit_visit(tree, 'math', (node)=>{
@@ -17451,6 +18101,412 @@ function mermaidPlugin(options = {}) {
         builderConfig: remarkMermaid.builderConfig
     };
 }
+const SAFE_PROTOCOLS = new Set([
+    'http:',
+    'https:',
+    'mailto:',
+    'tel:'
+]);
+const PROTOCOL_PATTERN = /^[a-z][a-z0-9+.-]*:/i;
+const FORBIDDEN_CHARS_PATTERN = /[\u0000-\u0020\u007F]/u;
+function safeUrl(href) {
+    const trimmed = href.trim();
+    if (FORBIDDEN_CHARS_PATTERN.test(trimmed)) return null;
+    return match_match(trimmed).with('', ()=>null).with(P.string.startsWith('#'), ()=>trimmed).with(P.string.startsWith('/'), ()=>trimmed).with(P.string.startsWith('./'), ()=>trimmed).with(P.string.startsWith('../'), ()=>trimmed).otherwise(()=>{
+        const match_ = trimmed.match(PROTOCOL_PATTERN);
+        if (!match_) return trimmed;
+        const scheme = match_[0].toLowerCase();
+        if (SAFE_PROTOCOLS.has(scheme)) return trimmed;
+        return null;
+    });
+}
+const ALLOWED_TAGS = new Set([
+    'b',
+    'strong',
+    'i',
+    'em',
+    'code',
+    'kbd',
+    'mark',
+    'sup',
+    'sub',
+    'span',
+    'small',
+    'u',
+    's',
+    'del',
+    'ins'
+]);
+const STRIPPED_TAGS = new Set([
+    "script",
+    'style',
+    'iframe',
+    'object',
+    'embed',
+    'template',
+    "noscript"
+]);
+const ACCENT_CLASS = 'cp-accent';
+const MARK_CLASS = 'cp-mark';
+const TOKEN_PATTERN = /(?:\\([*=`[\]<\\]))|(?:`([^`]+)`)|(?:\*\*([\s\S]+?)\*\*)|(?:==([\s\S]+?)==)|(?:(?<!\*)\*(?=[^\s*])([^*\n]+?)(?<=[^\s*])\*(?!\*))|(?:\[([^\]]*)\]\(((?:[^()\s]|\([^()\s]*\))+)\))|(?:<(\/?)\s*([a-zA-Z][a-zA-Z0-9-]*)(?=[\s/>])((?:"[^"]*"|'[^']*'|[^>"'])*)>)/;
+const ATTR_PATTERN = /([a-zA-Z-]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
+const CLOSE_TAG_BOUNDARY = /[\s>]/;
+function parseRichText(text) {
+    if ('string' != typeof text || 0 === text.length) return [];
+    return parseInline({
+        input: text,
+        inLink: false
+    });
+}
+function toPlainText(text) {
+    return flattenNodes(parseRichText(text));
+}
+function parseInline({ input, inLink }) {
+    return unfold((remaining)=>{
+        if (0 === remaining.length) return false;
+        const found = TOKEN_PATTERN.exec(remaining);
+        if (null === found) return [
+            [
+                {
+                    kind: 'text',
+                    value: remaining
+                }
+            ],
+            ''
+        ];
+        const lead = remaining.slice(0, found.index);
+        const after = remaining.slice(found.index + found[0].length);
+        const step = consumeToken({
+            found,
+            after,
+            inLink
+        });
+        return [
+            [
+                ...textNodes(lead),
+                ...step.nodes
+            ],
+            step.rest
+        ];
+    }, input).flat();
+}
+function textNodes(lead) {
+    if (0 === lead.length) return [];
+    return [
+        {
+            kind: 'text',
+            value: lead
+        }
+    ];
+}
+function consumeToken({ found, after, inLink }) {
+    const [, escaped, code, bold, highlight, italic, linkText, linkHref, closing, tagName, rawAttrs] = found;
+    if (void 0 !== escaped) return {
+        nodes: [
+            {
+                kind: 'text',
+                value: escaped
+            }
+        ],
+        rest: after
+    };
+    if (void 0 !== code) return {
+        nodes: [
+            codeNode(code)
+        ],
+        rest: after
+    };
+    if (void 0 !== bold) return {
+        nodes: [
+            accentNode(parseInline({
+                input: bold,
+                inLink
+            }))
+        ],
+        rest: after
+    };
+    if (void 0 !== highlight) return {
+        nodes: [
+            markNode(parseInline({
+                input: highlight,
+                inLink
+            }))
+        ],
+        rest: after
+    };
+    if (void 0 !== italic) return {
+        nodes: [
+            rich_text_parse_element({
+                tag: 'em',
+                children: parseInline({
+                    input: italic,
+                    inLink
+                })
+            })
+        ],
+        rest: after
+    };
+    if (void 0 !== linkHref) return {
+        nodes: linkNodes({
+            text: linkText ?? '',
+            href: linkHref,
+            inLink
+        }),
+        rest: after
+    };
+    if (void 0 !== tagName) {
+        const tail = (rawAttrs ?? '').trimEnd();
+        const isSelfClosing = tail.endsWith('/');
+        return consumeTag({
+            tagName: tagName.toLowerCase(),
+            attrs: match_match(isSelfClosing).with(true, ()=>tail.slice(0, -1)).otherwise(()=>tail),
+            isClosing: '/' === closing,
+            isSelfClosing,
+            after,
+            inLink
+        });
+    }
+    return {
+        nodes: [
+            {
+                kind: 'text',
+                value: found[0]
+            }
+        ],
+        rest: after
+    };
+}
+function consumeTag(params) {
+    const { tagName, attrs, isClosing, isSelfClosing, after, inLink } = params;
+    if (isClosing) return {
+        nodes: [],
+        rest: after
+    };
+    if ('br' === tagName) return {
+        nodes: [
+            {
+                kind: 'break'
+            }
+        ],
+        rest: after
+    };
+    if (isSelfClosing) return {
+        nodes: selfClosingNodes({
+            tagName,
+            attrs
+        }),
+        rest: after
+    };
+    const close = findClosingTag({
+        text: after,
+        tagName
+    });
+    if (null === close) {
+        if (STRIPPED_TAGS.has(tagName)) return {
+            nodes: [],
+            rest: ''
+        };
+        return {
+            nodes: [],
+            rest: after
+        };
+    }
+    const inner = after.slice(0, close.start);
+    const rest = after.slice(close.end);
+    if (STRIPPED_TAGS.has(tagName)) return {
+        nodes: [],
+        rest
+    };
+    if ('a' === tagName) return {
+        nodes: anchorNodes({
+            attrs,
+            inner,
+            inLink
+        }),
+        rest
+    };
+    if (ALLOWED_TAGS.has(tagName)) return {
+        nodes: [
+            taggedElement({
+                tag: tagName,
+                attrs,
+                children: parseInline({
+                    input: inner,
+                    inLink
+                })
+            })
+        ],
+        rest
+    };
+    return {
+        nodes: parseInline({
+            input: inner,
+            inLink
+        }),
+        rest
+    };
+}
+function selfClosingNodes({ tagName, attrs }) {
+    if (!ALLOWED_TAGS.has(tagName)) return [];
+    return [
+        taggedElement({
+            tag: tagName,
+            attrs,
+            children: []
+        })
+    ];
+}
+function findClosingTag({ text, tagName }) {
+    return scanForClose({
+        lower: text.toLowerCase(),
+        tagName,
+        from: 0
+    });
+}
+function scanForClose({ lower, tagName, from }) {
+    const needle = `</${tagName}`;
+    const candidates = unfold((offset)=>{
+        const at = lower.indexOf(needle, offset);
+        if (-1 === at) return false;
+        return [
+            at,
+            at + needle.length
+        ];
+    }, from);
+    const start = candidates.find((at)=>CLOSE_TAG_BOUNDARY.test(lower.charAt(at + needle.length)));
+    if (void 0 === start) return null;
+    const gt = lower.indexOf('>', start);
+    if (-1 === gt) return null;
+    return {
+        start,
+        end: gt + 1
+    };
+}
+function parseAttrs(attrs) {
+    const entries = [
+        ...attrs.matchAll(ATTR_PATTERN)
+    ];
+    return entries.reduce((acc, entry)=>{
+        const name = entry[1].toLowerCase();
+        const value = entry[2] ?? entry[3] ?? '';
+        return match_match(name).with('class', ()=>({
+                ...acc,
+                className: value
+            })).with('classname', ()=>({
+                ...acc,
+                className: value
+            })).with('title', ()=>({
+                ...acc,
+                title: value
+            })).with('href', ()=>({
+                ...acc,
+                href: value
+            })).otherwise(()=>acc);
+    }, {});
+}
+function taggedElement({ tag, attrs, children }) {
+    const parsed = parseAttrs(attrs);
+    return {
+        kind: 'element',
+        tag,
+        className: parsed.className,
+        title: parsed.title,
+        children
+    };
+}
+function anchorNodes({ attrs, inner, inLink }) {
+    const { href } = parseAttrs(attrs);
+    if (void 0 === href || inLink) return parseInline({
+        input: inner,
+        inLink
+    });
+    const safe = safeUrl(href);
+    if (null === safe) return parseInline({
+        input: inner,
+        inLink
+    });
+    const children = parseInline({
+        input: inner,
+        inLink: true
+    });
+    return linkOrChildren({
+        href: safe,
+        children
+    });
+}
+function linkNodes({ text, href, inLink }) {
+    const safe = safeUrl(href);
+    if (null === safe || inLink) return parseInline({
+        input: text,
+        inLink
+    });
+    return linkOrChildren({
+        href: safe,
+        children: parseInline({
+            input: text,
+            inLink: true
+        })
+    });
+}
+function linkOrChildren({ href, children }) {
+    if (0 === children.length) return [];
+    return [
+        {
+            kind: 'link',
+            href,
+            children
+        }
+    ];
+}
+function codeNode(value) {
+    return {
+        kind: 'code',
+        value
+    };
+}
+function accentNode(children) {
+    return {
+        kind: 'element',
+        tag: 'strong',
+        className: ACCENT_CLASS,
+        children
+    };
+}
+function markNode(children) {
+    return {
+        kind: 'element',
+        tag: 'mark',
+        className: MARK_CLASS,
+        children
+    };
+}
+function rich_text_parse_element({ tag, children }) {
+    return {
+        kind: 'element',
+        tag,
+        children
+    };
+}
+function flattenNodes(nodes) {
+    return nodes.map(flattenNode).join('');
+}
+function flattenNode(node) {
+    return match_match(node).with({
+        kind: 'text'
+    }, (n)=>n.value).with({
+        kind: 'code'
+    }, (n)=>n.value).with({
+        kind: 'break'
+    }, ()=>' ').with({
+        kind: 'link'
+    }, (n)=>flattenNodes(n.children)).with({
+        kind: 'element'
+    }, (n)=>flattenNodes(n.children)).exhaustive();
+}
+function resolveSeoSiteUrl(params) {
+    return new URL(params.base, params.origin).href;
+}
+const issueLinkIconPath = node_path.join(import.meta.dirname, 'theme', 'components', 'shared', 'IssueLinkIcon.tsx');
 const DEFAULT_LOADER_MIN_MS = 150;
 const DEFAULT_LOADER_MAX_MS = 5000;
 const VSCODE_SET_JS = "document.documentElement.dataset.ciderpressEnv='vscode'";
@@ -17538,22 +18594,33 @@ function createRspressConfig(options) {
         sidebar,
         footer
     });
+    const seoThemeConfig = match_match(config.seo).with(void 0, ()=>({})).otherwise((seo)=>({
+            seo,
+            seoBase: resolvedBase
+        }));
     return {
         root: paths.contentDir,
         outDir: paths.distDir,
         base: resolvedBase,
+        ...match_match(config.seo).with(void 0, ()=>({})).otherwise((seo)=>({
+                siteOrigin: seo.origin
+            })),
         route: {
             cleanUrls: true
         },
         llms: true,
-        title: config.title ?? 'ciderpress',
-        description: config.description ?? 'Documentation',
+        title: toPlainText(config.title ?? 'ciderpress'),
+        description: toPlainText(config.description ?? 'Documentation'),
         icon: resolveFaviconPath(favicon),
         logo: match_match(logoRaw).with(P.string, (l)=>l).otherwise(()=>''),
         logoText: '',
         themeDir: node_path.resolve(import.meta.dirname, 'theme'),
         plugins: [
             ciderpressPlugin(),
+            ...resolveSitemapPlugins({
+                config,
+                base: resolvedBase
+            }),
             mermaidPlugin(),
             dist({
                 initialExpandDepth: 1
@@ -17563,7 +18630,11 @@ function createRspressConfig(options) {
         ],
         markdown: {
             remarkPlugins: [
-                remarkMathToDiv
+                remarkMathToDiv,
+                remarkIssueLinks
+            ],
+            globalComponents: [
+                issueLinkIconPath
             ],
             link: {
                 checkDeadLinks: {
@@ -17572,12 +18643,9 @@ function createRspressConfig(options) {
             }
         },
         builderConfig: {
-            ...(()=>{
-                if (logLevel) return {
-                    logLevel
-                };
-                return {};
-            })(),
+            ...match_match(logLevel).with(void 0, ()=>({})).otherwise((resolvedLogLevel)=>({
+                    logLevel: resolvedLogLevel
+                })),
             html: {
                 tags: [
                     ...resolveFaviconLinkTags(favicon),
@@ -17645,6 +18713,7 @@ function createRspressConfig(options) {
                 standaloneScopePaths,
                 pageBadges
             },
+            ...seoThemeConfig,
             ...{
                 socialLinks: serializeSocials(config.socials),
                 sidebarAbove: resolveSidebarLinks({
@@ -17662,6 +18731,32 @@ function createRspressConfig(options) {
         }
     };
 }
+function resolveSitemapPlugins(params) {
+    const { config } = params;
+    const { seo } = config;
+    if (void 0 === seo || false === seo.sitemap) return [];
+    const sitemap = seo.sitemap;
+    const siteUrl = resolveSeoSiteUrl({
+        origin: seo.origin,
+        base: params.base
+    });
+    if (void 0 === sitemap || true === sitemap) return [
+        pluginSitemap({
+            siteUrl
+        })
+    ];
+    return [
+        pluginSitemap({
+            siteUrl,
+            ...match_match(sitemap.changeFrequency).with(void 0, ()=>({})).otherwise((defaultChangeFreq)=>({
+                    defaultChangeFreq
+                })),
+            ...match_match(sitemap.priority).with(void 0, ()=>({})).otherwise((defaultPriority)=>({
+                    defaultPriority
+                }))
+        })
+    ];
+}
 function loadGenerated(params) {
     const p = node_path.resolve(params.contentDir, '.generated', params.name);
     if (!existsSync(p)) {
@@ -17860,20 +18955,10 @@ function buildSiteBlock(params) {
     };
 }
 function resolveHomeConfig(home) {
-    const fallbackShowcase = {
-        columns: 2
-    };
     if (void 0 === home) return {
-        hero: {},
-        showcase: fallbackShowcase
-    };
-    return {
-        ...home,
-        showcase: {
-            columns: 2,
-            ...home.showcase
-        }
+        hero: {}
     };
+    return home;
 }
 function buildHeadScriptBody(options) {
     const minimalRegistry = options.registry.map((entry)=>({
@@ -17916,13 +19001,10 @@ function buildHeadScriptBody(options) {
     }
     try { localStorage.setItem('rspress-theme-appearance', variant); } catch (_) {}
   })()`;
-    const vscodeJs = (()=>{
-        if (options.vscode) return [
+    const vscodeJs = match_match(options.vscode).with(true, ()=>[
             VSCODE_SET_JS,
             VSCODE_NAV_JS
-        ].join(';');
-        return '';
-    })();
+        ].join(';')).otherwise(()=>'');
     const fallbackJs = match_match(options.loaderEnabled).with(true, ()=>`setTimeout(function(){var d=document.documentElement;if(d.dataset.cpReady!=='true'){d.classList.add('cp-loader-fade');setTimeout(function(){d.dataset.cpReady='true'},220)}},${options.loaderMaxMs})`).otherwise(()=>'');
     const loaderJs = match_match(options.useDotsLoader).with(true, ()=>LOADER_DOTS_JS).otherwise(()=>'');
     return [