svedocs 0.1.0-beta.10

package/dist/core/messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../src/core/messages.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+IR,CAAC;AAE5B,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,aAAa,GAAG,eAAe,CAYzE;AAED,wBAAgB,aAAa,CAC3B,IAAI,EAAE,eAAe,EACrB,QAAQ,EAAE,OAAO,CAAC,eAAe,CAAC,GAAG,SAAS,GAC7C,eAAe,CAKjB"}

package/dist/core/messages.js

@@ -0,0 +1,163 @@
+export const defaultSvedocsMessages = {
+    'nav.primary': 'Primary',
+    'nav.docs': 'Docs',
+    'nav.configuration': 'Configuration',
+    'nav.api': 'API',
+    'nav.documentation': 'Documentation',
+    'nav.footer': 'Footer',
+    'nav.social': 'Social links',
+    'nav.mobile.open': 'Open menu',
+    'nav.mobile.close': 'Close menu',
+    'nav.skipToContent': 'Skip to content',
+    'scope.group': 'Documentation scope',
+    'scope.locale': 'Locale',
+    'scope.localeOptions': 'Locale options',
+    'scope.langShort': 'Lang',
+    'search.trigger': 'Search',
+    'search.dialog': 'Search documentation',
+    'search.query': 'Search query',
+    'search.placeholder': 'Search docs',
+    'search.results': 'Search results',
+    'search.loading': 'Searching...',
+    'search.loadingIndex': 'Loading search index...',
+    'search.indexError': 'Search index could not be loaded.',
+    'search.remoteFallback': '{error} Showing local results.',
+    'search.empty': 'No matching docs yet.',
+    'search.fetchUnavailable': 'Fetch is not available.',
+    'search.requestError': 'Search returned {status}.',
+    'search.failed': 'Search failed.',
+    'ask.label': 'Ask AI',
+    'ask.placeholder': 'Ask about the docs',
+    'ask.welcome': '',
+    'ask.empty': 'Ask anything about these docs.',
+    'ask.newChat': 'New chat',
+    'ask.close': 'Close',
+    'ask.thinking': 'Thinking',
+    'ask.send': 'Send',
+    'ask.suggestion.1': '',
+    'ask.suggestion.2': '',
+    'ask.suggestion.3': '',
+    'ask.fetchUnavailable': 'Fetch is not available.',
+    'ask.requestError': 'Ask AI returned {status}.',
+    'ask.failed': 'Ask AI failed.',
+    'ask.streamUnreadable': 'Ask AI returned an unreadable stream event.',
+    'ask.localSource': 'I found 1 relevant source in this documentation.',
+    'ask.localSources': 'I found {count} relevant sources in this documentation.',
+    'ask.localEmpty': 'I could not find a matching local source for that question.',
+    'ask.fallbackSource': 'I found 1 relevant source. Connect the {provider} provider to replace this local draft with a hosted Ask AI response.',
+    'ask.fallbackSources': 'I found {count} relevant sources. Connect the {provider} provider to replace this local draft with a hosted Ask AI response.',
+    'ask.fallbackReady': 'Ask AI is ready. Connect {provider} and index your docs to answer this question with citations.',
+    'ask.sourceTitle': 'Source {index}',
+    'toc.label': 'On this page',
+    'heading.anchor': 'Link to this section',
+    'article.kind.doc': 'Documentation',
+    'article.kind.page': 'Page',
+    'article.breadcrumb': 'Breadcrumb',
+    'article.updated': 'Updated {date}',
+    'article.edit': 'Edit this page',
+    'article.previous': 'Previous',
+    'article.next': 'Next',
+    'code.copy': 'Copy code',
+    'code.copied': 'Copied',
+    'code.copyDiff': 'Copy diff',
+    'diff.label': 'Diff',
+    'diff.aria': '{title} diff',
+    'diff.before': 'Before',
+    'diff.after': 'After',
+    'tools.label': 'Page tools',
+    'tools.backToTop': 'Back to top',
+    'theme.switch': 'Switch to {mode} theme',
+    'theme.light': 'light',
+    'theme.dark': 'dark',
+    'home.kicker': 'SvelteKit-native docs',
+    'home.primaryAction': 'Read docs',
+    'home.features': 'Documentation entry points',
+    'home.card.start.label': 'Start',
+    'home.card.start.title': 'Quick Start',
+    'home.card.start.description': 'Get a site running, open the docs route, and move straight into the installed docs tree.',
+    'home.card.install.label': 'Install',
+    'home.card.install.title': 'Manual Installation',
+    'home.card.install.description': 'Add svedocs to an existing SvelteKit app and wire the Vite plugin plus theme styles.',
+    'home.card.write.label': 'Write',
+    'home.card.write.title': 'Writing',
+    'home.card.write.description': 'Use Markdown, frontmatter, and Svelte components in one content tree.',
+    'home.card.integrate.label': 'Integrate',
+    'home.card.integrate.title': 'Integrations',
+    'home.card.integrate.description': 'Add search, Ask AI, Cloudflare deployment, SEO, and OG assets when the content is ready.',
+    'footer.text': 'MIT licensed. Built with {site}.',
+    'error.notFound.title': 'Page not found',
+    'error.notFound.description': 'The page you are looking for is not in this documentation set.',
+    'error.generic.title': 'Something went wrong',
+    'error.generic.description': 'The docs shell is still available while this page recovers.',
+    'error.status': 'Error {status}',
+    'error.home': 'Home',
+    'error.docs': 'Docs',
+    'render.label': 'Rendering issue',
+    'render.title': 'This section could not render',
+    'render.message': 'Something in this part of the documentation failed while rendering. The rest of the page is still available.',
+    'render.details': 'Technical details',
+    'render.tryAgain': 'Try again',
+    'render.reload': 'Reload page',
+    'render.docsHome': 'Docs home',
+    'render.layout.label': 'Layout issue',
+    'render.layout.title': 'The page layout could not render',
+    'render.layout.message': 'A layout component failed while rendering. The default site shell is still available.',
+    'render.header.label': 'Header issue',
+    'render.header.title': 'Header could not render',
+    'render.header.message': 'The page is still available below. You can retry the header or use links inside the content.',
+    'render.ask.label': 'Ask AI issue',
+    'render.ask.title': 'Ask AI could not render',
+    'render.ask.message': 'The article is still available. Retry Ask AI when you need it.',
+    'render.tools.label': 'Page tools issue',
+    'render.tools.title': 'Page tools could not render',
+    'render.tools.message': 'The page tools failed to render. The document content is unaffected.',
+    'render.footer.label': 'Footer issue',
+    'render.footer.title': 'Footer could not render',
+    'render.footer.message': 'Footer links failed to render. The page content above is still available.',
+    'render.page.label': 'Page rendering issue',
+    'render.page.title': 'This page could not render',
+    'render.page.message': 'The page content failed while rendering. You can retry this section or reload the page.',
+    'render.article.label': 'Article rendering issue',
+    'render.article.title': 'This article could not render',
+    'render.article.message': 'The article content failed while rendering. Navigation and page tools are still available.',
+    'render.docs.label': 'Documentation layout issue',
+    'render.docs.title': 'This documentation layout could not render',
+    'render.docs.message': 'A layout component failed while rendering. Retry the section, or use the top navigation to continue.',
+    'render.home.label': 'Home content issue',
+    'render.home.title': 'Home content could not render',
+    'render.home.message': 'The home page content failed while rendering. The rest of the site is still available.',
+    'render.error.label': 'Error page issue',
+    'render.error.title': 'The error page could not render',
+    'render.error.message': 'A custom error page component failed while rendering. The default site shell is still available.',
+    'render.custom.label': 'Custom layout issue',
+    'render.custom.title': 'The custom layout could not render',
+    'render.custom.message': 'A custom page layout failed while rendering. The route is still loaded; retry after fixing the component.',
+    'render.navigation.label': 'Navigation issue',
+    'render.navigation.title': 'Navigation could not render',
+    'render.navigation.message': 'The page content is still available. You can retry the navigation area or use the top navigation.',
+    'render.outline.label': 'Outline issue',
+    'render.outline.title': 'Outline could not render',
+    'render.outline.message': 'The table of contents failed to render, but the article is still available.',
+    'render.errorUi.label': 'Error boundary issue',
+    'render.errorUi.title': 'Error UI could not render',
+    'render.errorUi.message': 'A custom error component failed while rendering. The default recovery UI is shown instead.'
+};
+export function createBaseMessages(config) {
+    const ai = config.ai === false ? undefined : config.ai;
+    const footerText = config.theme?.footer === false ? undefined : config.theme?.footer?.text;
+    return mergeMessages(defaultSvedocsMessages, {
+        ...(footerText ? { 'footer.text': footerText } : {}),
+        ...(ai?.label ? { 'ask.label': ai.label } : {}),
+        ...(ai?.placeholder ? { 'ask.placeholder': ai.placeholder } : {}),
+        ...(ai?.welcomeMessage ? { 'ask.welcome': ai.welcomeMessage } : {}),
+        ...(ai?.suggestions?.[0] ? { 'ask.suggestion.1': ai.suggestions[0] } : {}),
+        ...(ai?.suggestions?.[1] ? { 'ask.suggestion.2': ai.suggestions[1] } : {}),
+        ...(ai?.suggestions?.[2] ? { 'ask.suggestion.3': ai.suggestions[2] } : {})
+    });
+}
+export function mergeMessages(base, override) {
+    return {
+        ...base,
+        ...(override ?? {})
+    };
+}

package/dist/core/navigation.d.ts

@@ -0,0 +1,5 @@
+import type { SvedocsPage, SvedocsTreeItem } from './types.js';
+export declare function createPageTree(pages?: readonly SvedocsPage[]): SvedocsTreeItem[];
+export declare function flattenPageTree(tree?: readonly SvedocsTreeItem[]): SvedocsTreeItem[];
+export declare function wirePrevNext(pages: SvedocsPage[], tree: SvedocsTreeItem[]): void;
+//# sourceMappingURL=navigation.d.ts.map

package/dist/core/navigation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"navigation.d.ts","sourceRoot":"","sources":["../../src/core/navigation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAe/D,wBAAgB,cAAc,CAAC,KAAK,GAAE,SAAS,WAAW,EAAO,GAAG,eAAe,EAAE,CA8BpF;AAED,wBAAgB,eAAe,CAAC,IAAI,GAAE,SAAS,eAAe,EAAO,GAAG,eAAe,EAAE,CAExF;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,WAAW,EAAE,EAAE,IAAI,EAAE,eAAe,EAAE,QAkBzE"}

package/dist/core/navigation.js

@@ -0,0 +1,144 @@
+import { createGroupId, titleFromSegment } from './utils.js';
+export function createPageTree(pages = []) {
+    const docs = [...pages].filter((page) => page.kind === 'doc' && !page.hidden);
+    const pageByPath = new Map(docs.map((page) => [page.routePath, page]));
+    const nodeByPath = new Map();
+    const root = [];
+    for (const page of docs.sort(comparePagesForNavigation)) {
+        const segments = getDocRouteSegments(page);
+        let children = root;
+        const accumulated = [];
+        for (const [index, segment] of segments.entries()) {
+            const isDocsIndex = segments.length === 1 && segment === 'index';
+            const isLeaf = index === segments.length - 1;
+            if (!isDocsIndex)
+                accumulated.push(segment);
+            const nodePath = isDocsIndex ? '/docs' : `/docs/${accumulated.join('/')}`;
+            const sourcePage = pageByPath.get(nodePath);
+            const node = upsertTreeNode({
+                children,
+                nodeByPath,
+                nodePath,
+                segment,
+                page: sourcePage,
+                leafPage: isLeaf ? page : undefined
+            });
+            children = node.children;
+        }
+    }
+    return finalizeTree(root);
+}
+export function flattenPageTree(tree = []) {
+    return tree.flatMap((item) => [item, ...flattenPageTree(item.children ?? [])]);
+}
+export function wirePrevNext(pages, tree) {
+    const pageByPath = new Map(pages.map((page) => [page.routePath, page]));
+    const docs = flattenPageTree(tree)
+        .map((item) => item.path ? pageByPath.get(item.path) : undefined)
+        .filter((page) => Boolean(page && page.kind === 'doc' && !page.hidden));
+    for (const page of pages) {
+        delete page.prev;
+        delete page.next;
+    }
+    const docsByScope = groupDocsByScope(docs);
+    for (const scopedDocs of docsByScope.values()) {
+        for (const [index, page] of scopedDocs.entries()) {
+            const prev = scopedDocs[index - 1];
+            const next = scopedDocs[index + 1];
+            if (prev)
+                page.prev = { title: prev.navTitle ?? prev.title, path: prev.routePath };
+            if (next)
+                page.next = { title: next.navTitle ?? next.title, path: next.routePath };
+        }
+    }
+}
+function getDocRouteSegments(page) {
+    if (page.routePath === '/docs')
+        return ['index'];
+    return page.routePath.replace(/^\/docs\/?/, '').split('/').filter(Boolean);
+}
+function upsertTreeNode(input) {
+    const page = input.page ?? input.leafPage;
+    const existing = input.nodeByPath.get(input.nodePath);
+    if (existing) {
+        if (page)
+            applyPageToTreeItem(existing, page);
+        return existing;
+    }
+    const item = {
+        id: page?.id ?? createGroupId(input.nodePath),
+        title: page?.navTitle ?? page?.title ?? titleFromSegment(input.segment),
+        children: [],
+        _weight: page?.order ?? Number.POSITIVE_INFINITY,
+        ...(page ? { path: page.routePath } : {}),
+        ...(typeof page?.order === 'number' ? { order: page.order } : {}),
+        ...(typeof page?.collapsed === 'boolean' ? { collapsed: page.collapsed } : {}),
+        ...(page?.section === true ? { section: true } : {}),
+        ...(page?.icon ? { icon: page.icon } : {})
+    };
+    input.nodeByPath.set(input.nodePath, item);
+    input.children.push(item);
+    return item;
+}
+function applyPageToTreeItem(item, page) {
+    item.id = page.id;
+    item.title = page.navTitle ?? page.title;
+    item.path = page.routePath;
+    item._weight = page.order ?? item._weight;
+    if (typeof page.order === 'number')
+        item.order = page.order;
+    if (typeof page.collapsed === 'boolean')
+        item.collapsed = page.collapsed;
+    if (page.section === true)
+        item.section = true;
+    if (page.icon)
+        item.icon = page.icon;
+}
+function finalizeTree(items) {
+    for (const item of items) {
+        item._weight = Math.min(item._weight, ...item.children.map((child) => computeTreeWeight(child)));
+    }
+    return items
+        .sort(compareTreeItems)
+        .map((item) => {
+        const children = finalizeTree(item.children);
+        return {
+            id: item.id,
+            title: item.title,
+            ...(item.path ? { path: item.path } : {}),
+            ...(children.length > 0 ? { children } : {}),
+            ...(typeof item.collapsed === 'boolean' ? { collapsed: item.collapsed } : {}),
+            ...(typeof item.order === 'number' ? { order: item.order } : {}),
+            ...(item.section === true ? { section: true } : {}),
+            ...(item.icon ? { icon: item.icon } : {})
+        };
+    });
+}
+function computeTreeWeight(item) {
+    item._weight = Math.min(item._weight, ...item.children.map((child) => computeTreeWeight(child)));
+    return item._weight;
+}
+function compareTreeItems(a, b) {
+    const byWeight = a._weight - b._weight;
+    if (Number.isFinite(byWeight) && byWeight !== 0)
+        return byWeight;
+    if (a.path && b.path)
+        return a.path.localeCompare(b.path);
+    return a.title.localeCompare(b.title);
+}
+function comparePagesForNavigation(a, b) {
+    const orderA = a.order ?? Number.POSITIVE_INFINITY;
+    const orderB = b.order ?? Number.POSITIVE_INFINITY;
+    const byOrder = orderA - orderB;
+    return byOrder === 0 ? a.routePath.localeCompare(b.routePath) : byOrder;
+}
+function groupDocsByScope(docs) {
+    const groups = new Map();
+    for (const page of docs) {
+        const key = page.locale ?? '';
+        const group = groups.get(key) ?? [];
+        group.push(page);
+        groups.set(key, group);
+    }
+    return groups;
+}

package/dist/core/routes.d.ts

@@ -0,0 +1,36 @@
+import type { SvedocsResolvedConfig } from './types.js';
+export interface SvedocsRouteTarget {
+    routePath: string;
+    scopePath: string;
+    sourcePath?: string;
+    locale?: string;
+    kind: 'doc' | 'page';
+}
+export type SvedocsPageRouteResolution<T extends SvedocsRouteTarget = SvedocsRouteTarget> = {
+    status: 'found';
+    page: T;
+} | {
+    status: 'redirect';
+    page: T;
+    location: string;
+    requestedLocale: string;
+    resolvedLocale: string;
+} | {
+    status: 'missing';
+    requestedLocale?: string;
+};
+export interface SvedocsHrefResolution<T extends SvedocsRouteTarget = SvedocsRouteTarget> {
+    href: string;
+    page?: T;
+    fallback: boolean;
+}
+export declare function resolveSvedocsPageRoute<T extends SvedocsRouteTarget>(routePath: string, pages: readonly T[], config: SvedocsResolvedConfig): SvedocsPageRouteResolution<T>;
+export declare function createSvedocsRouteEntries<T extends SvedocsRouteTarget>(pages: readonly T[], config: SvedocsResolvedConfig): string[];
+export declare function resolveSvedocsHref<T extends SvedocsRouteTarget>(input: {
+    href: string;
+    pages: readonly T[];
+    config: SvedocsResolvedConfig;
+    page?: SvedocsRouteTarget;
+    localeCode?: string;
+}): SvedocsHrefResolution<T>;
+//# sourceMappingURL=routes.d.ts.map

package/dist/core/routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../../src/core/routes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAGxD,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,KAAK,GAAG,MAAM,CAAC;CACtB;AAED,MAAM,MAAM,0BAA0B,CAAC,CAAC,SAAS,kBAAkB,GAAG,kBAAkB,IACpF;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,CAAC,CAAA;CAAE,GAC5B;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,IAAI,EAAE,CAAC,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,eAAe,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE,GAClG;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,eAAe,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpD,MAAM,WAAW,qBAAqB,CAAC,CAAC,SAAS,kBAAkB,GAAG,kBAAkB;IACtF,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,CAAC,CAAC;IACT,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,kBAAkB,EAClE,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,MAAM,EAAE,qBAAqB,GAC5B,0BAA0B,CAAC,CAAC,CAAC,CAyB/B;AAED,wBAAgB,yBAAyB,CAAC,CAAC,SAAS,kBAAkB,EACpE,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,MAAM,EAAE,qBAAqB,GAC5B,MAAM,EAAE,CAsBV;AAED,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,kBAAkB,EAAE,KAAK,EAAE;IACtE,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,SAAS,CAAC,EAAE,CAAC;IACpB,MAAM,EAAE,qBAAqB,CAAC;IAC9B,IAAI,CAAC,EAAE,kBAAkB,CAAC;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,GAAG,qBAAqB,CAAC,CAAC,CAAC,CAoC3B"}

package/dist/core/routes.js

@@ -0,0 +1,152 @@
+import { normalizePath, stripContentExtension } from './utils.js';
+export function resolveSvedocsPageRoute(routePath, pages, config) {
+    const normalized = normalizeRoutePath(routePath);
+    const exact = pages.find((page) => normalizeRoutePath(page.routePath) === normalized);
+    if (exact)
+        return { status: 'found', page: exact };
+    const requested = resolveLocalizedScope(normalized, config);
+    if (!requested)
+        return { status: 'missing' };
+    const defaultLocale = config.i18n.defaultLocale;
+    if (!defaultLocale || requested.locale === defaultLocale) {
+        return { status: 'missing', requestedLocale: requested.locale };
+    }
+    const fallback = pages.find((page) => (page.kind === requested.kind
+        && page.scopePath === requested.scopePath
+        && page.locale === defaultLocale));
+    if (!fallback)
+        return { status: 'missing', requestedLocale: requested.locale };
+    return {
+        status: 'redirect',
+        page: fallback,
+        location: fallback.routePath,
+        requestedLocale: requested.locale,
+        resolvedLocale: defaultLocale
+    };
+}
+export function createSvedocsRouteEntries(pages, config) {
+    const entries = new Set(pages
+        .map((page) => normalizeRoutePath(page.routePath))
+        .filter((routePath) => routePath !== '/'));
+    const defaultLocale = config.i18n.defaultLocale;
+    if (!defaultLocale)
+        return [...entries];
+    const defaultPages = pages.filter((page) => page.locale === defaultLocale);
+    for (const page of defaultPages) {
+        for (const locale of config.i18n.locales) {
+            if (locale.code === defaultLocale)
+                continue;
+            const translationExists = pages.some((candidate) => (candidate.kind === page.kind
+                && candidate.scopePath === page.scopePath
+                && candidate.locale === locale.code));
+            if (!translationExists)
+                entries.add(createLocalizedRoutePath(page, locale.path));
+        }
+    }
+    return [...entries];
+}
+export function resolveSvedocsHref(input) {
+    const { pathname, suffix } = splitHref(input.href);
+    if (!pathname || isNonPageHref(input.href))
+        return { href: input.href, fallback: false };
+    const exactPath = pathname.startsWith('/') ? normalizeRoutePath(pathname) : undefined;
+    const exact = exactPath
+        ? input.pages.find((page) => normalizeRoutePath(page.routePath) === exactPath)
+        : undefined;
+    if (exact && exact.scopePath !== exactPath) {
+        return { href: `${exact.routePath}${suffix}`, page: exact, fallback: false };
+    }
+    const scopePath = pathname.startsWith('/')
+        ? normalizeContentPath(pathname)
+        : input.page
+            ? resolveRelativeScopePath(input.page, pathname)
+            : undefined;
+    if (!scopePath)
+        return { href: input.href, fallback: false };
+    const localeCode = input.localeCode ?? input.page?.locale ?? input.config.i18n.defaultLocale;
+    const kind = exact?.kind ?? inferTargetKind(scopePath, input.page?.kind);
+    const localized = input.pages.find((page) => (page.scopePath === scopePath
+        && page.kind === kind
+        && page.locale === localeCode));
+    if (localized)
+        return { href: `${localized.routePath}${suffix}`, page: localized, fallback: false };
+    const defaultLocale = input.config.i18n.defaultLocale;
+    const fallback = input.pages.find((page) => (page.scopePath === scopePath
+        && page.kind === kind
+        && page.locale === defaultLocale));
+    if (fallback)
+        return { href: `${fallback.routePath}${suffix}`, page: fallback, fallback: true };
+    return { href: input.href, fallback: false };
+}
+function resolveLocalizedScope(routePath, config) {
+    const segments = routePath.split('/').filter(Boolean);
+    const kind = segments[0] === 'docs' ? 'doc' : 'page';
+    const localeIndex = kind === 'doc' ? 1 : 0;
+    const locale = config.i18n.locales.find((candidate) => candidate.path === segments[localeIndex]);
+    if (!locale)
+        return undefined;
+    const scopeSegments = segments.filter((_, index) => index !== localeIndex);
+    return {
+        locale: locale.code,
+        scopePath: normalizeRoutePath(`/${scopeSegments.join('/')}`),
+        kind
+    };
+}
+function resolveRelativeScopePath(page, pathname) {
+    const sourceWithoutExtension = page.sourcePath ? stripContentExtension(normalizePath(page.sourcePath)) : '';
+    const sourceIsIndex = sourceWithoutExtension.endsWith('/index');
+    const base = sourceIsIndex || page.scopePath === '/' ? page.scopePath : dirnameRoutePath(page.scopePath);
+    return normalizeContentPath(`${base}/${pathname}`);
+}
+function createLocalizedRoutePath(page, localePath) {
+    const scopeSegments = normalizeRoutePath(page.scopePath).split('/').filter(Boolean);
+    if (page.kind === 'doc') {
+        const docSegments = scopeSegments[0] === 'docs' ? scopeSegments.slice(1) : scopeSegments;
+        return normalizeRoutePath(`/docs/${localePath}/${docSegments.join('/')}`);
+    }
+    return normalizeRoutePath(`/${localePath}/${scopeSegments.join('/')}`);
+}
+function normalizeContentPath(value) {
+    const normalized = normalizeRoutePath(stripContentExtension(normalizePath(value)));
+    return normalized.endsWith('/index')
+        ? normalized.slice(0, -'/index'.length) || '/'
+        : normalized;
+}
+function inferTargetKind(scopePath, currentKind) {
+    if (scopePath === '/docs' || scopePath.startsWith('/docs/'))
+        return 'doc';
+    return currentKind === 'doc' ? 'doc' : 'page';
+}
+function normalizeRoutePath(value) {
+    const [pathname = ''] = normalizePath(value).split(/[?#]/, 1);
+    const segments = [];
+    for (const segment of pathname.split('/')) {
+        if (!segment || segment === '.')
+            continue;
+        if (segment === '..') {
+            segments.pop();
+            continue;
+        }
+        segments.push(segment);
+    }
+    return segments.length > 0 ? `/${segments.join('/')}` : '/';
+}
+function dirnameRoutePath(value) {
+    const segments = normalizeRoutePath(value).split('/').filter(Boolean);
+    segments.pop();
+    return segments.length > 0 ? `/${segments.join('/')}` : '/';
+}
+function splitHref(href) {
+    const suffixIndex = href.search(/[?#]/);
+    return suffixIndex < 0
+        ? { pathname: href, suffix: '' }
+        : { pathname: href.slice(0, suffixIndex), suffix: href.slice(suffixIndex) };
+}
+function isNonPageHref(href) {
+    return href.startsWith('#')
+        || href.startsWith('mailto:')
+        || href.startsWith('tel:')
+        || /^(https?:)?\/\//.test(href)
+        || /^[a-z][a-z0-9+.-]*:/i.test(href)
+        || /\.(avif|gif|jpe?g|png|svg|webp|pdf|zip)([#?].*)?$/i.test(href);
+}

package/dist/core/search.d.ts

@@ -0,0 +1,5 @@
+import type { SvedocsPage, SvedocsSearchRecord } from './types.js';
+export declare function createSearchRecords(pages?: readonly SvedocsPage[]): SvedocsSearchRecord[];
+export declare function createPageSearchRecords(page: SvedocsPage, markdown?: string): SvedocsSearchRecord[];
+export declare function createPageSearchRecord(page: SvedocsPage): SvedocsSearchRecord;
+//# sourceMappingURL=search.d.ts.map

package/dist/core/search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../src/core/search.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEnE,wBAAgB,mBAAmB,CAAC,KAAK,GAAE,SAAS,WAAW,EAAO,GAAG,mBAAmB,EAAE,CAE7F;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,WAAW,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,mBAAmB,EAAE,CAInG;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,WAAW,GAAG,mBAAmB,CAa7E"}

package/dist/core/search.js

@@ -0,0 +1,41 @@
+import { extractMarkdownSections } from '../mdx/ast.js';
+export function createSearchRecords(pages = []) {
+    return pages.flatMap((page) => page.search.length > 0 ? page.search : [createPageSearchRecord(page)]);
+}
+export function createPageSearchRecords(page, markdown) {
+    const pageRecord = createPageSearchRecord(page);
+    if (!markdown)
+        return [pageRecord];
+    return [pageRecord, ...createSectionSearchRecords(page, markdown)];
+}
+export function createPageSearchRecord(page) {
+    return {
+        id: `${page.id}:page`,
+        pageId: page.id,
+        url: page.routePath,
+        title: page.title,
+        content: page.plainText,
+        metadata: {
+            kind: page.kind,
+            sourcePath: page.sourcePath,
+            ...(page.locale ? { locale: page.locale } : {})
+        }
+    };
+}
+function createSectionSearchRecords(page, markdown) {
+    return extractMarkdownSections(markdown).map((section) => ({
+        id: `${page.id}:${section.id}`,
+        pageId: page.id,
+        url: `${page.routePath}#${section.id}`,
+        title: page.title,
+        section: section.title,
+        content: section.content,
+        metadata: {
+            kind: page.kind,
+            sourcePath: page.sourcePath,
+            ...(page.locale ? { locale: page.locale } : {}),
+            headingId: section.id,
+            headingDepth: section.depth
+        }
+    }));
+}