sourcey 3.4.11 → 3.5.1

package/dist/site-assembly.js

@@ -0,0 +1,467 @@
+import { readFile } from "node:fs/promises";
+import { extname, posix, resolve } from "node:path";
+import { loadSpec } from "./core/loader.js";
+import { convertToOpenApi3 } from "./core/converter.js";
+import { parseSpec } from "./core/parser.js";
+import { normalizeSpec } from "./core/normalizer.js";
+import { normalizeMcpSpec } from "./core/mcp-normalizer.js";
+import { loadDocsPage, slugFromPath } from "./core/markdown-loader.js";
+import { loadDoxygenTab } from "./core/doxygen-loader.js";
+import { buildNavFromSpec, buildNavFromPages } from "./core/navigation.js";
+import { generateChangelogFeeds } from "./renderer/changelog-feed.js";
+import { pageOutputPath, tabPath } from "./config.js";
+import { toPublicUrl } from "./site-url.js";
+export async function assembleSite(config) {
+    const specsBySlug = await loadSpecs(config.tabs);
+    const primarySpec = specsBySlug.values().next().value ?? createMinimalSpec();
+    const pageMap = new Map();
+    const siteTabs = [];
+    const changelogDiagnostics = [];
+    for (const tab of config.tabs) {
+        if (tab.openapi || tab.mcp) {
+            const spec = specsBySlug.get(tab.slug);
+            const navTab = buildNavFromSpec(spec, tab.slug, config.prettyUrls);
+            navTab.label = tab.label;
+            siteTabs.push(navTab);
+            pageMap.set(tabPath(tab.slug, "index.html"), {
+                outputPath: tabPath(tab.slug, "index.html"),
+                currentPage: { kind: "spec", spec },
+                spec,
+                tabSlug: tab.slug,
+                pageSlug: "introduction",
+            });
+            continue;
+        }
+        if (tab.doxygen) {
+            const { pages, navTab } = await loadDoxygenTab(tab.doxygen, tab.slug, tab.label);
+            for (const [slug, page] of pages) {
+                const outputPath = pageOutputPath(tab.slug, slug, config.prettyUrls);
+                pageMap.set(outputPath, {
+                    outputPath,
+                    currentPage: { kind: "markdown", markdown: page },
+                    spec: primarySpec,
+                    tabSlug: tab.slug,
+                    pageSlug: slug,
+                });
+            }
+            siteTabs.push(navTab);
+            continue;
+        }
+        if (!tab.groups)
+            continue;
+        const pagesByPath = new Map();
+        for (const group of tab.groups) {
+            for (const rp of group.pages) {
+                const slug = slugFromPath(rp.slug);
+                const page = await loadDocsPage(rp.file, slug, {
+                    changelog: config.changelog.enabled,
+                    repoUrl: config.repo,
+                });
+                pagesByPath.set(rp.slug, page);
+                const outputPath = pageOutputPath(tab.slug, slug, config.prettyUrls);
+                if (page.kind === "changelog") {
+                    changelogDiagnostics.push(...page.changelog.diagnostics);
+                    pageMap.set(outputPath, {
+                        outputPath,
+                        currentPage: { kind: "changelog", changelog: page },
+                        spec: primarySpec,
+                        tabSlug: tab.slug,
+                        pageSlug: slug,
+                    });
+                    continue;
+                }
+                pageMap.set(outputPath, {
+                    outputPath,
+                    currentPage: { kind: "markdown", markdown: page },
+                    spec: primarySpec,
+                    tabSlug: tab.slug,
+                    pageSlug: slug,
+                });
+            }
+        }
+        siteTabs.push(buildNavFromPages(tab, pagesByPath, config.prettyUrls));
+    }
+    if (config.changelog.permalinks) {
+        addPermalinkPages(pageMap);
+    }
+    const sitePages = Array.from(pageMap.values());
+    resolveInternalLinks(sitePages, config);
+    const extraFiles = attachChangelogFeeds(sitePages, config);
+    return {
+        siteTabs,
+        primarySpec,
+        specsBySlug,
+        pageMap,
+        changelogDiagnostics,
+        extraFiles,
+    };
+}
+export function collectDocsPagesByTab(pageMap, tabs) {
+    const docsPagesByTab = new Map();
+    for (const tab of tabs) {
+        if (!tab.groups && !tab.doxygen)
+            continue;
+        const tabPages = [];
+        for (const [, page] of pageMap) {
+            if (page.tabSlug !== tab.slug || !isSearchableDocsSitePage(page))
+                continue;
+            tabPages.push(page.currentPage.kind === "markdown" ? page.currentPage.markdown : page.currentPage.changelog);
+        }
+        docsPagesByTab.set(tab.slug, tabPages);
+    }
+    return docsPagesByTab;
+}
+export function rebuildMarkdownTabNavigation(pageMap, siteTabs, tabs, tabSlug, prettyUrls) {
+    const tab = tabs.find((candidate) => candidate.slug === tabSlug);
+    if (!tab?.groups)
+        return;
+    const pagesByPath = new Map();
+    for (const group of tab.groups) {
+        for (const rp of group.pages) {
+            const slug = slugFromPath(rp.slug);
+            const entry = pageMap.get(pageOutputPath(tab.slug, slug, prettyUrls));
+            if (!entry)
+                continue;
+            if (entry.currentPage.kind === "markdown") {
+                pagesByPath.set(rp.slug, entry.currentPage.markdown);
+            }
+            else if (entry.currentPage.kind === "changelog") {
+                pagesByPath.set(rp.slug, entry.currentPage.changelog);
+            }
+        }
+    }
+    const navTab = buildNavFromPages(tab, pagesByPath, prettyUrls);
+    const idx = siteTabs.findIndex((candidate) => candidate.slug === tabSlug);
+    if (idx !== -1)
+        siteTabs[idx] = navTab;
+}
+export function enforceChangelogDiagnostics(diagnostics, strictChangelog = false) {
+    const error = diagnostics.find((diagnostic) => diagnostic.severity === "error");
+    if (error) {
+        throw new Error(formatChangelogFailure(error));
+    }
+    if (!strictChangelog)
+        return;
+    const warning = diagnostics.find((diagnostic) => diagnostic.severity === "warning");
+    if (warning) {
+        throw new Error(formatChangelogFailure(warning));
+    }
+}
+export function formatChangelogDiagnostic(diagnostic) {
+    const location = diagnostic.version ? ` (${diagnostic.version})` : "";
+    const line = diagnostic.line ? ` line ${diagnostic.line}` : "";
+    return `${diagnostic.severity.toUpperCase()} ${diagnostic.code}${location}${line}: ${diagnostic.message}`;
+}
+export function formatChangelogFailure(diagnostic) {
+    const location = diagnostic.version ? ` (${diagnostic.version})` : "";
+    const line = diagnostic.line ? ` line ${diagnostic.line}` : "";
+    return `[${diagnostic.code}]${location}${line}: ${diagnostic.message}`;
+}
+export function formatChangelogDiagnostics(diagnostics) {
+    return diagnostics.map(formatChangelogDiagnostic);
+}
+export async function buildSiteConfig(config) {
+    const logo = config.logo
+        ? {
+            light: await resolveAssetUrl(config.logo.light ?? ""),
+            dark: config.logo.dark ? await resolveAssetUrl(config.logo.dark) : undefined,
+            href: config.logo.href,
+        }
+        : undefined;
+    const customCSS = await loadCustomCSS(config.theme.css);
+    return {
+        name: config.name,
+        siteUrl: config.siteUrl,
+        baseUrl: config.baseUrl,
+        prettyUrls: config.prettyUrls,
+        theme: config.theme,
+        logo: logo?.light ? logo : undefined,
+        favicon: config.favicon ? await resolveAssetUrl(config.favicon) : undefined,
+        repo: config.repo,
+        editBranch: config.editBranch,
+        editBasePath: config.editBasePath,
+        codeSamples: config.codeSamples,
+        navbar: config.navbar,
+        footer: config.footer,
+        customCSS: customCSS || undefined,
+        changelog: config.changelog,
+    };
+}
+export function createMinimalSpec() {
+    return {
+        info: { title: "", version: "", description: "" },
+        servers: [],
+        tags: [],
+        operations: [],
+        schemas: {},
+        securitySchemes: {},
+        webhooks: [],
+    };
+}
+export function resolveInternalLinks(pages, config) {
+    const pathMap = new Map();
+    for (const page of pages) {
+        const out = page.outputPath;
+        const clean = out.replace(/\/index\.html$/, "").replace(/\.html$/, "");
+        pathMap.set(clean, out);
+        const docsSourcePath = getCanonicalSourcePath(page);
+        if (!docsSourcePath)
+            continue;
+        const sourceClean = docsSourcePath
+            .replace(/\\/g, "/")
+            .replace(/^\/+/, "")
+            .replace(/\.(md|mdx)$/, "");
+        pathMap.set(sourceClean, out);
+    }
+    const repoBase = config.repo?.replace(/\/$/, "");
+    const branch = config.editBranch;
+    const sourceBase = repoBase && branch ? `${repoBase}/tree/${branch}` : undefined;
+    const prettyUrls = config.prettyUrls;
+    for (const page of pages) {
+        const docsSourcePath = getDocsSourcePath(page);
+        if (!docsSourcePath)
+            continue;
+        if (page.currentPage.kind === "markdown") {
+            page.currentPage.markdown.html = rewriteHtmlLinks(page.currentPage.markdown.html, page.outputPath, docsSourcePath, pathMap, sourceBase, prettyUrls);
+            continue;
+        }
+        if (page.currentPage.kind !== "changelog")
+            continue;
+        const changelog = page.currentPage.changelog;
+        for (const version of changelog.changelog.versions) {
+            if (version.summary) {
+                version.summary = rewriteMarkdownLinks(version.summary, page.outputPath, docsSourcePath, pathMap, sourceBase, prettyUrls);
+            }
+            for (const section of version.sections) {
+                for (const entry of section.entries) {
+                    entry.html = rewriteHtmlLinks(entry.html, page.outputPath, docsSourcePath, pathMap, sourceBase, prettyUrls);
+                    entry.links = entry.links.map((link) => ({
+                        ...link,
+                        href: resolveInternalHref(link.href, page.outputPath, docsSourcePath, pathMap, sourceBase, prettyUrls) ?? link.href,
+                    }));
+                }
+            }
+        }
+    }
+}
+function attachChangelogFeeds(pages, config) {
+    const extraFiles = new Map();
+    if (!config.changelog.feed)
+        return extraFiles;
+    const changelogPages = pages.filter(isMainChangelogSitePage);
+    const globalFeedLinks = changelogPages.length === 1
+        ? createFeedLinks("feed.xml", "feed.rss", changelogPages[0].currentPage.changelog.title)
+        : null;
+    for (const page of changelogPages) {
+        const changelog = page.currentPage.changelog;
+        const versionHref = (version) => {
+            if (config.changelog.permalinks) {
+                return toPublicUrl(tabPath(page.tabSlug, `${changelog.slug}/${version.id}/index.html`), config.siteUrl, config.baseUrl, config.prettyUrls);
+            }
+            return `${toPublicUrl(page.outputPath, config.siteUrl, config.baseUrl, config.prettyUrls)}#${version.id}`;
+        };
+        const atomPath = globalFeedLinks && changelogPages.length === 1
+            ? "feed.xml"
+            : tabPath(page.tabSlug, `${changelog.slug}/feed.xml`);
+        const rssPath = globalFeedLinks && changelogPages.length === 1
+            ? "feed.rss"
+            : tabPath(page.tabSlug, `${changelog.slug}/feed.rss`);
+        const feedConfig = config.changelog.feed || undefined;
+        const feeds = generateChangelogFeeds(changelog, {
+            atomPath: toPublicUrl(atomPath, config.siteUrl, config.baseUrl, config.prettyUrls),
+            rssPath: toPublicUrl(rssPath, config.siteUrl, config.baseUrl, config.prettyUrls),
+            pagePath: toPublicUrl(page.outputPath, config.siteUrl, config.baseUrl, config.prettyUrls),
+            siteName: config.name,
+            title: feedConfig?.title,
+            description: feedConfig?.description,
+            versionHref,
+        });
+        extraFiles.set(atomPath, feeds.atom);
+        extraFiles.set(rssPath, feeds.rss);
+        const feedLinks = createFeedLinks(atomPath, rssPath, changelog.title);
+        page.alternateLinks = feedLinks;
+        for (const candidate of pages) {
+            if (candidate.currentPage.kind !== "changelog")
+                continue;
+            if (candidate.currentPage.changelog.sourcePath !== changelog.sourcePath)
+                continue;
+            candidate.alternateLinks = feedLinks;
+        }
+    }
+    if (globalFeedLinks) {
+        for (const page of pages) {
+            if (!page.alternateLinks?.length) {
+                page.alternateLinks = globalFeedLinks;
+            }
+        }
+    }
+    return extraFiles;
+}
+function addPermalinkPages(pageMap) {
+    const changelogPages = Array.from(pageMap.values()).filter(isMainChangelogSitePage);
+    for (const page of changelogPages) {
+        const changelog = page.currentPage.changelog;
+        for (const version of changelog.changelog.versions) {
+            const permalinkPage = {
+                ...changelog,
+                description: version.summary ?? changelog.description,
+                slug: `${changelog.slug}/${version.id}`,
+                headings: [],
+                permalinkVersionId: version.id,
+            };
+            const outputPath = tabPath(page.tabSlug, `${changelog.slug}/${version.id}/index.html`);
+            pageMap.set(outputPath, {
+                outputPath,
+                currentPage: { kind: "changelog", changelog: permalinkPage },
+                spec: page.spec,
+                tabSlug: page.tabSlug,
+                pageSlug: `${page.pageSlug}--${version.id}`,
+            });
+        }
+    }
+}
+async function loadSpecs(tabs) {
+    const specsBySlug = new Map();
+    for (const tab of tabs) {
+        if (tab.openapi) {
+            const loaded = await loadSpec(tab.openapi);
+            const parsed = await parseSpec(loaded);
+            const openapi3 = await convertToOpenApi3(parsed);
+            specsBySlug.set(tab.slug, normalizeSpec(openapi3));
+        }
+        else if (tab.mcp) {
+            const { parse } = await import("mcp-parser");
+            const mcpSpec = await parse(tab.mcp);
+            specsBySlug.set(tab.slug, normalizeMcpSpec(mcpSpec));
+        }
+    }
+    return specsBySlug;
+}
+async function loadCustomCSS(paths) {
+    const parts = [];
+    for (const path of paths) {
+        parts.push(await readFile(path, "utf-8"));
+    }
+    return parts.join("\n");
+}
+const MIME_TYPES = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".svg": "image/svg+xml",
+    ".webp": "image/webp",
+    ".ico": "image/x-icon",
+};
+async function resolveAssetUrl(pathOrUrl) {
+    if (!pathOrUrl || pathOrUrl.startsWith("data:") || pathOrUrl.startsWith("http://") || pathOrUrl.startsWith("https://")) {
+        return pathOrUrl;
+    }
+    const abs = resolve(pathOrUrl);
+    const mime = MIME_TYPES[extname(abs).toLowerCase()] ?? "application/octet-stream";
+    const data = await readFile(abs);
+    return `data:${mime};base64,${data.toString("base64")}`;
+}
+function isMainChangelogSitePage(page) {
+    return page.currentPage.kind === "changelog" && !page.currentPage.changelog.permalinkVersionId;
+}
+function isSearchableDocsSitePage(page) {
+    return page.currentPage.kind === "markdown" || isMainChangelogSitePage(page);
+}
+function createFeedLinks(atomPath, rssPath, title) {
+    return [
+        { href: atomPath, type: "application/atom+xml", title: `${title} Atom Feed` },
+        { href: rssPath, type: "application/rss+xml", title: `${title} RSS Feed` },
+    ];
+}
+function getCanonicalSourcePath(page) {
+    if (page.currentPage.kind === "markdown")
+        return page.currentPage.markdown.sourcePath;
+    if (isMainChangelogSitePage(page))
+        return page.currentPage.changelog.sourcePath;
+    return undefined;
+}
+function getDocsSourcePath(page) {
+    if (page.currentPage.kind === "markdown")
+        return page.currentPage.markdown.sourcePath;
+    if (page.currentPage.kind === "changelog")
+        return page.currentPage.changelog.sourcePath;
+    return undefined;
+}
+function rewriteHtmlLinks(html, outputPath, docsSourcePath, pathMap, sourceBase, prettyUrls) {
+    return html.replace(/href="([^"]+)"/g, (match, href) => {
+        const resolved = resolveInternalHref(href, outputPath, docsSourcePath, pathMap, sourceBase, prettyUrls);
+        return resolved ? `href="${resolved}"` : match;
+    });
+}
+function rewriteMarkdownLinks(markdown, outputPath, docsSourcePath, pathMap, sourceBase, prettyUrls) {
+    return markdown.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (match, label, href) => {
+        const resolved = resolveInternalHref(href, outputPath, docsSourcePath, pathMap, sourceBase, prettyUrls);
+        return resolved ? `[${label}](${resolved})` : match;
+    });
+}
+function resolveInternalHref(href, outputPath, docsSourcePath, pathMap, sourceBase, prettyUrls) {
+    if (href.startsWith("http://") || href.startsWith("https://") || href.startsWith("#") || href.startsWith("mailto:")) {
+        return null;
+    }
+    const [path, hash] = href.split("#", 2);
+    const hashSuffix = hash ? `#${hash}` : "";
+    const sourcePath = path.replace(/\\/g, "/");
+    const clean = sourcePath.replace(/^\/+/, "").replace(/\/+$/, "").replace(/\.(md|mdx)$/, "");
+    if (clean.endsWith(".html"))
+        return null;
+    const pageDir = outputPath.includes("/")
+        ? outputPath.substring(0, outputPath.lastIndexOf("/"))
+        : "";
+    const depth = pageDir ? pageDir.split("/").length : 0;
+    const toRoot = depth > 0 ? "../".repeat(depth) : "";
+    const candidates = new Set();
+    if (!sourcePath.startsWith("/") && docsSourcePath) {
+        const sourceDir = posix.dirname(docsSourcePath.replace(/\\/g, "/"));
+        candidates.add(posix.normalize(posix.join(sourceDir, clean)));
+    }
+    candidates.add(clean);
+    let target;
+    for (const initialCandidate of candidates) {
+        let candidate = initialCandidate;
+        while (!target && candidate && candidate !== ".") {
+            target = pathMap.get(candidate);
+            if (target)
+                break;
+            const slash = candidate.indexOf("/");
+            if (slash === -1)
+                break;
+            candidate = candidate.substring(slash + 1);
+        }
+        if (target)
+            break;
+    }
+    if (target) {
+        return `${toRoot}${toPrettyLink(target, prettyUrls)}${hashSuffix}`;
+    }
+    if (sourceBase && href.includes("../") && docsSourcePath) {
+        const sourceDir = posix.dirname(docsSourcePath);
+        const resolved = posix.normalize(posix.join(sourceDir, path));
+        if (!resolved.startsWith("..")) {
+            return `${sourceBase}/${resolved}${hashSuffix}`;
+        }
+    }
+    return null;
+}
+/**
+ * Rewrite an on-disk output path into the relative href that a user visits.
+ * - `"slash"`: trims trailing `index.html`, leaves a directory-style `foo/`.
+ * - `"strip"`: trims both `index.html` and the trailing slash, so the browser sees `foo`.
+ * - `false`: returns the path unchanged.
+ */
+function toPrettyLink(target, prettyUrls) {
+    if (!prettyUrls)
+        return target;
+    if (target === "index.html")
+        return "";
+    if (target.endsWith("/index.html")) {
+        const withSlash = target.slice(0, -"index.html".length);
+        return prettyUrls === "strip" ? withSlash.slice(0, -1) : withSlash;
+    }
+    return target;
+}

package/dist/site-url.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Pretty-URL emission style. See `ResolvedConfig.prettyUrls`.
+ */
+export type PrettyUrls = false | "slash" | "strip";
+export declare function isAbsoluteHttpUrl(value: string): boolean;
+export declare function normalizeBaseUrl(baseUrl?: string): string;
+export declare function normalizeSiteUrl(siteUrl?: string): string | undefined;
+export declare function toPublicPath(outputPath: string, baseUrl?: string, prettyUrls?: PrettyUrls): string;
+export declare function toAbsoluteUrl(publicPath: string, siteUrl?: string): string;
+export declare function toPublicUrl(outputPath: string, siteUrl?: string, baseUrl?: string, prettyUrls?: PrettyUrls): string;
+export declare function stripBaseUrl(pathname: string, baseUrl?: string): string;
+//# sourceMappingURL=site-url.d.ts.map

package/dist/site-url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"site-url.d.ts","sourceRoot":"","sources":["../src/site-url.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG,OAAO,GAAG,OAAO,CAAC;AAEnD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAExD;AAED,wBAAgB,gBAAgB,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAMzD;AAED,wBAAgB,gBAAgB,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAoBrE;AAED,wBAAgB,YAAY,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,SAAK,EAAE,UAAU,GAAE,UAAkB,GAAG,MAAM,CAkBrG;AAED,wBAAgB,aAAa,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAK1E;AAED,wBAAgB,WAAW,CACzB,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,MAAM,EAChB,OAAO,SAAK,EACZ,UAAU,GAAE,UAAkB,GAC7B,MAAM,CAER;AAED,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,SAAK,GAAG,MAAM,CAcnE"}

package/dist/site-url.js

@@ -0,0 +1,67 @@
+export function isAbsoluteHttpUrl(value) {
+    return value.startsWith("http://") || value.startsWith("https://");
+}
+export function normalizeBaseUrl(baseUrl) {
+    const raw = baseUrl?.trim();
+    if (!raw || raw === "/")
+        return "";
+    const cleaned = raw.replace(/^\/+|\/+$/g, "");
+    return cleaned ? `/${cleaned}/` : "";
+}
+export function normalizeSiteUrl(siteUrl) {
+    const raw = siteUrl?.trim();
+    if (!raw)
+        return undefined;
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        throw new Error(`Invalid siteUrl "${siteUrl}". Expected an absolute http(s) URL.`);
+    }
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+        throw new Error(`Invalid siteUrl "${siteUrl}". Expected an absolute http(s) URL.`);
+    }
+    if (url.pathname !== "/" || url.search || url.hash) {
+        throw new Error(`Invalid siteUrl "${siteUrl}". Use siteUrl for the origin and baseUrl for any path prefix.`);
+    }
+    return url.origin;
+}
+export function toPublicPath(outputPath, baseUrl = "", prettyUrls = false) {
+    const normalizedBase = normalizeBaseUrl(baseUrl);
+    const prefix = normalizedBase || "/";
+    const cleanOutputPath = outputPath.replace(/^\/+/, "");
+    if (!cleanOutputPath || cleanOutputPath === "index.html") {
+        return prefix;
+    }
+    if (cleanOutputPath.endsWith("/index.html")) {
+        const withSlash = cleanOutputPath.slice(0, -("index.html".length));
+        if (prettyUrls === "strip") {
+            return `${prefix}${withSlash.slice(0, -1)}`;
+        }
+        return `${prefix}${withSlash}`;
+    }
+    return `${prefix}${cleanOutputPath}`;
+}
+export function toAbsoluteUrl(publicPath, siteUrl) {
+    if (!siteUrl)
+        return publicPath;
+    const base = siteUrl.endsWith("/") ? siteUrl : `${siteUrl}/`;
+    return new URL(publicPath.replace(/^\/+/, ""), base).toString();
+}
+export function toPublicUrl(outputPath, siteUrl, baseUrl = "", prettyUrls = false) {
+    return toAbsoluteUrl(toPublicPath(outputPath, baseUrl, prettyUrls), siteUrl);
+}
+export function stripBaseUrl(pathname, baseUrl = "") {
+    const normalizedBase = normalizeBaseUrl(baseUrl);
+    if (!normalizedBase)
+        return pathname;
+    const bareBase = normalizedBase.slice(0, -1);
+    if (pathname === bareBase || pathname === normalizedBase) {
+        return "/";
+    }
+    if (pathname.startsWith(normalizedBase)) {
+        return `/${pathname.slice(normalizedBase.length)}`;
+    }
+    return pathname;
+}