svedocs 0.1.0-beta.10

package/dist/core/content.js

@@ -0,0 +1,340 @@
+import { readFile, stat } from 'node:fs/promises';
+import path from 'node:path';
+import fg from 'fast-glob';
+import matter from 'gray-matter';
+import { compileMarkdown } from '../mdx/compile.js';
+import { checkSvedocsContent } from './checks.js';
+import { defaultSvedocsMessages, isResolvedConfig, resolveSvedocsConfig } from './config.js';
+import { extractMarkdownLinks } from './links.js';
+import { createPageTree, wirePrevNext } from './navigation.js';
+import { resolveSvedocsHref } from './routes.js';
+import { createPageSearchRecords, createSearchRecords } from './search.js';
+import { booleanFrontmatter, formatRoutePathForBuildMode, normalizePath, numberFrontmatter, stringArrayFrontmatter, stringFrontmatter, stripInlineMarkdown, titleFromSegment } from './utils.js';
+export async function loadSvedocsContent(options = {}) {
+    const projectRoot = options.projectRoot ?? process.cwd();
+    const rawConfig = isResolvedConfig(options.config) ? undefined : options.config;
+    const config = isResolvedConfig(options.config)
+        ? options.config
+        : resolveSvedocsConfig(options.config ?? {});
+    const markdownOptions = createMarkdownCompileOptions(rawConfig, config);
+    const files = await fg(config.content.include, {
+        cwd: projectRoot,
+        absolute: false,
+        ignore: config.content.exclude,
+        onlyFiles: true
+    });
+    const entries = files
+        .filter((file) => isContentFile(file))
+        .sort()
+        .map((file) => {
+        const kind = inferKind(file, config);
+        return { file, kind, route: createRouteInfo(file, kind, config) };
+    });
+    const routeTargets = entries.map(({ file, kind, route }) => ({
+        kind,
+        sourcePath: file,
+        routePath: route.routePath,
+        scopePath: route.scopePath,
+        ...(route.locale ? { locale: route.locale } : {})
+    }));
+    const pages = await Promise.all(entries.map((entry) => (loadContentFile(projectRoot, entry, routeTargets, config, markdownOptions))));
+    const sorted = pages.sort((a, b) => a.routePath.localeCompare(b.routePath));
+    const tree = createPageTree(sorted);
+    wirePrevNext(sorted, tree);
+    const manifest = {
+        config,
+        pages: sorted,
+        tree,
+        search: createSearchRecords(sorted),
+        issues: []
+    };
+    manifest.issues = await checkSvedocsContent(manifest, projectRoot);
+    return manifest;
+}
+function isContentFile(file) {
+    return /\.(md|mdx|svx)$/.test(file);
+}
+async function loadContentFile(projectRoot, entry, routeTargets, config, markdownOptions) {
+    const { file, kind, route } = entry;
+    const sourcePath = path.join(projectRoot, file);
+    const raw = await readFile(sourcePath, 'utf8');
+    const fileStats = await stat(sourcePath);
+    const parsed = matter(raw);
+    const markdown = parsed.content.trim();
+    const frontmatter = parsed.data;
+    const discoveredTitle = extractFirstMarkdownTitle(markdown);
+    const titleFromFrontmatter = stringFrontmatter(frontmatter.title);
+    const renderMarkdown = stripLeadingTitleHeading(markdown, titleFromFrontmatter ?? discoveredTitle);
+    const routePath = route.routePath;
+    const currentRoute = {
+        kind,
+        sourcePath: file,
+        routePath,
+        scopePath: route.scopePath,
+        ...(route.locale ? { locale: route.locale } : {})
+    };
+    const compiled = await compileMarkdown(renderMarkdown, {
+        ...markdownOptions,
+        messages: createMarkdownMessages(config, route.locale),
+        resolveHref: (href) => resolveSvedocsHref({
+            href,
+            pages: routeTargets,
+            config,
+            page: currentRoute
+        }).href
+    });
+    const title = titleFromFrontmatter ?? discoveredTitle ?? compiled.title ?? titleFromRoute(routePath);
+    const navTitle = stringFrontmatter(frontmatter.navTitle) ?? stringFrontmatter(frontmatter.nav_title);
+    const description = stringFrontmatter(frontmatter.description);
+    const order = numberFrontmatter(frontmatter.order);
+    const hidden = booleanFrontmatter(frontmatter.hidden);
+    const collapsed = booleanFrontmatter(frontmatter.collapsed);
+    const section = booleanFrontmatter(frontmatter.section);
+    const icon = stringFrontmatter(frontmatter.icon);
+    const keywords = stringArrayFrontmatter(frontmatter.keywords);
+    const type = stringFrontmatter(frontmatter.type) ?? stringFrontmatter(frontmatter.ogType) ?? stringFrontmatter(frontmatter.og_type);
+    const author = stringFrontmatter(frontmatter.author) ?? config.seo.defaultAuthor;
+    const robots = stringFrontmatter(frontmatter.robots);
+    const head = normalizeSeoHead(frontmatter.head);
+    const publishedTime = dateFrontmatter(frontmatter.publishedTime)
+        ?? dateFrontmatter(frontmatter.published_time)
+        ?? dateFrontmatter(frontmatter.published)
+        ?? dateFrontmatter(frontmatter.date);
+    const updatedTime = dateFrontmatter(frontmatter.updatedTime)
+        ?? dateFrontmatter(frontmatter.updated_time)
+        ?? dateFrontmatter(frontmatter.updated);
+    const canonical = stringFrontmatter(frontmatter.canonical) ?? createPageCanonicalUrl(config, routePath);
+    const image = stringFrontmatter(frontmatter.image);
+    const page = {
+        id: createPageId(file),
+        sourcePath: file,
+        routePath,
+        scopePath: route.scopePath,
+        slug: route.slug,
+        ...(route.locale ? { locale: route.locale } : {}),
+        kind,
+        title,
+        ...(navTitle ? { navTitle } : {}),
+        ...(description ? { description } : {}),
+        ...(typeof order === 'number' ? { order } : {}),
+        ...(hidden === true ? { hidden } : {}),
+        ...(typeof collapsed === 'boolean' ? { collapsed } : {}),
+        ...(section === true ? { section } : {}),
+        ...(icon ? { icon } : {}),
+        html: compiled.html,
+        plainText: compiled.plainText,
+        headings: compiled.headings,
+        links: extractMarkdownLinks(markdown),
+        codeBlocks: compiled.codeBlocks,
+        frontmatter,
+        seo: {
+            title,
+            ...(description ? { description } : {}),
+            ...(canonical ? { canonical } : {}),
+            ...(image ? { image } : {}),
+            ...(keywords.length > 0 ? { keywords } : {}),
+            ...(type ? { type } : {}),
+            ...(author ? { author } : {}),
+            ...(publishedTime ? { publishedTime } : {}),
+            ...(updatedTime ? { updatedTime } : {}),
+            ...(robots ? { robots } : {}),
+            ...(head ? { head } : {})
+        },
+        search: [],
+        lastUpdated: fileStats.mtime.toISOString(),
+        ...(config.source.editBaseUrl ? { editUrl: createEditUrl(config.source.editBaseUrl, file) } : {})
+    };
+    page.search = createPageSearchRecords(page, renderMarkdown);
+    return page;
+}
+function normalizeSeoHead(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const input = value;
+    const meta = Array.isArray(input.meta) ? input.meta.map(normalizeSeoMetaTag).filter((tag) => Boolean(tag)) : [];
+    const links = Array.isArray(input.links) ? input.links.map(normalizeSeoLinkTag).filter((tag) => Boolean(tag)) : [];
+    const jsonLdInput = input.jsonLd ?? input.jsonld ?? input['json-ld'];
+    const jsonLd = Array.isArray(jsonLdInput) ? jsonLdInput.map(normalizeSeoJsonLd).filter((tag) => Boolean(tag)) : [];
+    if (meta.length === 0 && links.length === 0 && jsonLd.length === 0)
+        return undefined;
+    return {
+        ...(meta.length > 0 ? { meta } : {}),
+        ...(links.length > 0 ? { links } : {}),
+        ...(jsonLd.length > 0 ? { jsonLd } : {})
+    };
+}
+function normalizeSeoMetaTag(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const input = value;
+    const content = stringFrontmatter(input.content);
+    if (!content)
+        return undefined;
+    const tag = { content };
+    const name = stringFrontmatter(input.name);
+    const property = stringFrontmatter(input.property);
+    const httpEquiv = stringFrontmatter(input.httpEquiv) ?? stringFrontmatter(input['http-equiv']);
+    const itemprop = stringFrontmatter(input.itemprop);
+    if (name)
+        tag.name = name;
+    if (property)
+        tag.property = property;
+    if (httpEquiv)
+        tag.httpEquiv = httpEquiv;
+    if (itemprop)
+        tag.itemprop = itemprop;
+    return tag.name || tag.property || tag.httpEquiv || tag.itemprop ? tag : undefined;
+}
+function normalizeSeoLinkTag(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const input = value;
+    const rel = stringFrontmatter(input.rel);
+    const href = stringFrontmatter(input.href);
+    if (!rel || !href)
+        return undefined;
+    const tag = { rel, href };
+    const hreflang = stringFrontmatter(input.hreflang);
+    const type = stringFrontmatter(input.type);
+    const media = stringFrontmatter(input.media);
+    const title = stringFrontmatter(input.title);
+    const sizes = stringFrontmatter(input.sizes);
+    const as = stringFrontmatter(input.as);
+    const crossorigin = stringFrontmatter(input.crossorigin);
+    if (hreflang)
+        tag.hreflang = hreflang;
+    if (type)
+        tag.type = type;
+    if (media)
+        tag.media = media;
+    if (title)
+        tag.title = title;
+    if (sizes)
+        tag.sizes = sizes;
+    if (as)
+        tag.as = as;
+    if (crossorigin)
+        tag.crossorigin = crossorigin;
+    return tag;
+}
+function normalizeSeoJsonLd(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+}
+function createMarkdownCompileOptions(rawConfig, resolvedConfig) {
+    return {
+        ...(rawConfig?.markdown?.remarkPlugins ? { remarkPlugins: rawConfig.markdown.remarkPlugins } : {}),
+        ...(rawConfig?.markdown?.rehypePlugins ? { rehypePlugins: rawConfig.markdown.rehypePlugins } : {}),
+        ...(rawConfig?.markdown?.shiki?.transformers ? { shikiTransformers: rawConfig.markdown.shiki.transformers } : {}),
+        ...(resolvedConfig.theme.defaultMode === 'system'
+            ? {
+                codeThemes: {
+                    light: resolvedConfig.theme.codeTheme.light,
+                    dark: resolvedConfig.theme.codeTheme.dark
+                }
+            }
+            : { codeTheme: resolvedConfig.theme.codeTheme[resolvedConfig.theme.defaultMode] }),
+        codeLineNumbers: resolvedConfig.theme.code.lineNumbers,
+        codeWrap: resolvedConfig.theme.code.wrap,
+        codeCopyButton: resolvedConfig.theme.code.copyButton
+    };
+}
+function createMarkdownMessages(config, locale) {
+    const messages = config.i18n.messages[locale ?? config.i18n.defaultLocale ?? 'en']
+        ?? config.i18n.messages[config.i18n.defaultLocale ?? 'en']
+        ?? config.i18n.messages.en
+        ?? defaultSvedocsMessages;
+    return {
+        'code.copy': messages['code.copy'],
+        'code.copyDiff': messages['code.copyDiff'],
+        'diff.label': messages['diff.label'],
+        'diff.aria': messages['diff.aria'],
+        'diff.before': messages['diff.before'],
+        'diff.after': messages['diff.after'],
+        'heading.anchor': messages['heading.anchor']
+    };
+}
+function createEditUrl(baseUrl, sourcePath) {
+    return `${baseUrl.replace(/\/$/, '')}/${normalizePath(sourcePath)}`;
+}
+function createPageCanonicalUrl(config, routePath) {
+    if (!config.site.url)
+        return undefined;
+    return new URL(formatRoutePathForBuildMode(routePath, config.build.mode), config.site.url).href;
+}
+function dateFrontmatter(value) {
+    const text = stringFrontmatter(value);
+    if (text)
+        return text;
+    if (value instanceof Date && !Number.isNaN(value.valueOf()))
+        return value.toISOString();
+    return undefined;
+}
+function inferKind(file, config) {
+    return normalizePath(file).startsWith(`${normalizePath(config.content.docs)}/`) ? 'doc' : 'page';
+}
+function createRouteInfo(file, kind, config) {
+    const normalized = normalizePath(file);
+    const base = normalizePath(kind === 'doc' ? config.content.docs : config.content.pages);
+    const relative = normalized.startsWith(`${base}/`) ? normalized.slice(base.length + 1) : normalized;
+    const withoutExt = relative.replace(/\.(md|mdx|svx)$/, '');
+    const rawParts = withoutExt.split('/').filter(Boolean);
+    const parts = rawParts.at(-1) === 'index' ? rawParts.slice(0, -1) : [...rawParts];
+    const routeParts = kind === 'doc' ? ['docs'] : [];
+    const locale = consumeLocale(parts, config);
+    const scopeParts = [...parts];
+    if (locale && shouldPrefixLocale(locale, config)) {
+        routeParts.push(findLocalePath(locale, config) ?? locale);
+    }
+    routeParts.push(...parts);
+    const routePath = `/${routeParts.join('/')}`.replace(/\/$/, '') || '/';
+    const scopePath = `/${[...(kind === 'doc' ? ['docs'] : []), ...scopeParts].join('/')}`.replace(/\/$/, '') || '/';
+    return {
+        routePath,
+        scopePath,
+        slug: routePath.split('/').filter(Boolean),
+        ...(locale ? { locale } : {})
+    };
+}
+function consumeLocale(parts, config) {
+    if (config.i18n.locales.length === 0)
+        return undefined;
+    const match = config.i18n.locales.find((locale) => locale.path === parts[0]);
+    if (match) {
+        parts.shift();
+        return match.code;
+    }
+    return config.i18n.defaultLocale;
+}
+function shouldPrefixLocale(locale, config) {
+    return config.i18n.prefixDefaultLocale || locale !== config.i18n.defaultLocale;
+}
+function findLocalePath(locale, config) {
+    return config.i18n.locales.find((item) => item.code === locale)?.path;
+}
+function createPageId(file) {
+    return normalizePath(file).replace(/\.(md|mdx|svx)$/, '').replace(/[^a-zA-Z0-9]+/g, '-');
+}
+function titleFromRoute(routePath) {
+    const last = routePath.split('/').filter(Boolean).at(-1) ?? 'home';
+    return titleFromSegment(last);
+}
+function extractFirstMarkdownTitle(markdown) {
+    const match = /^#\s+(.+?)\s*#*$/m.exec(markdown);
+    return match?.[1] ? stripInlineMarkdown(match[1]) : undefined;
+}
+function stripLeadingTitleHeading(markdown, title) {
+    if (!title)
+        return markdown;
+    const lines = markdown.split(/\r?\n/);
+    const firstContentIndex = lines.findIndex((line) => line.trim().length > 0);
+    if (firstContentIndex < 0)
+        return markdown;
+    const match = /^#\s+(.+?)\s*#*$/.exec(lines[firstContentIndex] ?? '');
+    if (!match?.[1])
+        return markdown;
+    const heading = stripInlineMarkdown(match[1]);
+    if (heading !== title)
+        return markdown;
+    lines.splice(firstContentIndex, 1);
+    return lines.join('\n').trim();
+}

package/dist/core/i18n.d.ts

@@ -0,0 +1,5 @@
+import type { SvedocsConfig } from '../config.js';
+import type { SvedocsResolvedConfig } from './types.js';
+export { defaultSvedocsMessages } from './messages.js';
+export declare function resolveSvedocsI18nConfig(config: SvedocsConfig): SvedocsResolvedConfig['i18n'];
+//# sourceMappingURL=i18n.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"i18n.d.ts","sourceRoot":"","sources":["../../src/core/i18n.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,KAAK,EAAkC,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAGxF,OAAO,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAEvD,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,aAAa,GAAG,qBAAqB,CAAC,MAAM,CAAC,CAqB7F"}

package/dist/core/i18n.js

@@ -0,0 +1,117 @@
+import { createBaseMessages, mergeMessages } from './messages.js';
+export { defaultSvedocsMessages } from './messages.js';
+export function resolveSvedocsI18nConfig(config) {
+    const baseMessages = createBaseMessages(config);
+    if (config.i18n === false) {
+        return {
+            locales: [],
+            prefixDefaultLocale: false,
+            messages: {
+                en: baseMessages
+            }
+        };
+    }
+    const locales = (config.i18n?.locales ?? []).map(normalizeLocale);
+    const defaultLocale = config.i18n?.defaultLocale ?? locales[0]?.code;
+    const prefixDefaultLocale = config.i18n?.prefixDefaultLocale ?? false;
+    validateI18nConfig(locales, defaultLocale, prefixDefaultLocale, config.i18n?.messages);
+    return {
+        ...(defaultLocale ? { defaultLocale } : {}),
+        locales,
+        prefixDefaultLocale,
+        messages: resolveI18nMessages(locales, defaultLocale, baseMessages, config.i18n?.messages)
+    };
+}
+function normalizeLocale(locale) {
+    if (typeof locale === 'string') {
+        return {
+            code: locale,
+            label: locale,
+            path: locale
+        };
+    }
+    return {
+        code: locale.code,
+        label: locale.label ?? locale.code,
+        path: locale.path ?? locale.code,
+        ...(locale.hreflang ? { hreflang: locale.hreflang } : {}),
+        ...(locale.dir ? { dir: locale.dir } : {})
+    };
+}
+function validateI18nConfig(locales, defaultLocale, prefixDefaultLocale, messages) {
+    const codes = new Map();
+    const paths = new Map();
+    const languageTags = new Map();
+    for (const locale of locales) {
+        assertLocaleCode(locale.code);
+        assertLocalePath(locale.path, locale.code);
+        if (!locale.label.trim()) {
+            throw new Error(`i18n locale label for "${locale.code}" must not be empty.`);
+        }
+        assertLanguageTag(locale.hreflang ?? locale.code, locale.code);
+        assertUniqueLocaleValue(codes, locale.code, locale.code, 'code');
+        assertUniqueLocaleValue(paths, locale.path, locale.code, 'path');
+        assertUniqueLocaleValue(languageTags, locale.hreflang ?? locale.code, locale.code, 'language tag');
+    }
+    if (defaultLocale && locales.length === 0) {
+        throw new Error('i18n.defaultLocale requires at least one configured locale.');
+    }
+    if (defaultLocale && !locales.some((locale) => locale.code === defaultLocale)) {
+        throw new Error(`i18n.defaultLocale "${defaultLocale}" must match a configured locale code.`);
+    }
+    if (prefixDefaultLocale && locales.length === 0) {
+        throw new Error('i18n.prefixDefaultLocale requires at least one configured locale.');
+    }
+    const messageLocales = new Set(['en', ...(defaultLocale ? [defaultLocale] : []), ...locales.map((locale) => locale.code)]);
+    for (const code of Object.keys(messages ?? {})) {
+        if (!messageLocales.has(code)) {
+            throw new Error(`i18n.messages contains unknown locale "${code}". Add it to i18n.locales first.`);
+        }
+    }
+}
+function assertLocaleCode(code) {
+    if (!/^[A-Za-z0-9]+(?:-[A-Za-z0-9]+)*$/.test(code)) {
+        throw new Error(`i18n locale code "${code}" must be a non-empty language-style identifier such as "en" or "pt-BR".`);
+    }
+}
+function assertLocalePath(localePath, code) {
+    if (!/^[A-Za-z0-9][A-Za-z0-9._~-]*$/.test(localePath) || localePath === '.' || localePath === '..') {
+        throw new Error(`i18n locale path "${localePath}" for "${code}" must be one non-empty URL-safe segment.`);
+    }
+    if (localePath.toLowerCase() === 'docs') {
+        throw new Error(`i18n locale path "${localePath}" for "${code}" conflicts with the reserved /docs route.`);
+    }
+}
+function assertLanguageTag(languageTag, code) {
+    try {
+        new Intl.Locale(languageTag);
+    }
+    catch {
+        throw new Error(`i18n hreflang "${languageTag}" for "${code}" must be a valid BCP 47 language tag.`);
+    }
+}
+function assertUniqueLocaleValue(values, value, code, field) {
+    const normalized = value.toLowerCase();
+    const existing = values.get(normalized);
+    if (existing) {
+        throw new Error(`i18n locale ${field} "${value}" is shared by "${existing}" and "${code}".`);
+    }
+    values.set(normalized, code);
+}
+function resolveI18nMessages(locales, defaultLocale, baseMessages, messages) {
+    const base = mergeMessages(baseMessages, messages?.en);
+    const codes = new Set(['en']);
+    if (defaultLocale)
+        codes.add(defaultLocale);
+    for (const locale of locales)
+        codes.add(locale.code);
+    for (const code of Object.keys(messages ?? {}))
+        codes.add(code);
+    const resolved = {};
+    for (const code of codes) {
+        resolved[code] = code === 'en'
+            ? base
+            : mergeMessages(base, messages?.[code]);
+    }
+    return resolved;
+}

package/dist/core/links.d.ts

@@ -0,0 +1,5 @@
+import type { SvedocsContentIssue, SvedocsContentManifest, SvedocsLinkReference, SvedocsPage } from './types.js';
+export declare function extractMarkdownLinks(markdown: string): SvedocsLinkReference[];
+export declare function createLinkCheckContext(manifest: SvedocsContentManifest): SvedocsContentManifest;
+export declare function checkLink(page: SvedocsPage, link: SvedocsLinkReference, context: ReturnType<typeof createLinkCheckContext>): SvedocsContentIssue | undefined;
+//# sourceMappingURL=links.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"links.d.ts","sourceRoot":"","sources":["../../src/core/links.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,oBAAoB,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAIjH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,oBAAoB,EAAE,CAE7E;AAED,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,sBAAsB,0BAEtE;AAED,wBAAgB,SAAS,CACvB,IAAI,EAAE,WAAW,EACjB,IAAI,EAAE,oBAAoB,EAC1B,OAAO,EAAE,UAAU,CAAC,OAAO,sBAAsB,CAAC,GACjD,mBAAmB,GAAG,SAAS,CAwBjC"}

package/dist/core/links.js

@@ -0,0 +1,60 @@
+import GithubSlugger from 'github-slugger';
+import { extractMarkdownLinksFromAst } from '../mdx/ast.js';
+import { resolveSvedocsHref } from './routes.js';
+export function extractMarkdownLinks(markdown) {
+    return extractMarkdownLinksFromAst(markdown);
+}
+export function createLinkCheckContext(manifest) {
+    return manifest;
+}
+export function checkLink(page, link, context) {
+    if (['asset', 'external', 'mailto', 'tel'].includes(link.kind))
+        return undefined;
+    const target = resolveLinkTarget(page, link, context);
+    if (!target.page) {
+        return {
+            code: 'broken-link',
+            severity: 'error',
+            message: `${page.sourcePath}:${link.line} links to missing page ${link.href}.`,
+            pageId: page.id,
+            sourcePath: page.sourcePath,
+            href: link.href
+        };
+    }
+    if (target.hash && !knownAnchors(target.page).has(target.hash)) {
+        return {
+            code: 'broken-anchor',
+            severity: 'error',
+            message: `${page.sourcePath}:${link.line} links to missing anchor #${target.hash} on ${target.page.routePath}.`,
+            pageId: page.id,
+            sourcePath: page.sourcePath,
+            href: link.href
+        };
+    }
+    return undefined;
+}
+function resolveLinkTarget(page, link, context) {
+    const parts = splitHref(link.href);
+    if (!parts.pathname && parts.hash)
+        return { page, hash: parts.hash };
+    const resolved = resolveSvedocsHref({
+        href: link.href,
+        page,
+        pages: context.pages,
+        config: context.config
+    });
+    return { page: resolved.page, ...(parts.hash ? { hash: parts.hash } : {}) };
+}
+function splitHref(href) {
+    const [withoutHash = '', hashWithQuery] = href.trim().split('#');
+    const [pathname = ''] = withoutHash.split('?');
+    const [hash] = (hashWithQuery ?? '').split('?');
+    return {
+        pathname,
+        ...(hash ? { hash: decodeURIComponent(hash) } : {})
+    };
+}
+function knownAnchors(page) {
+    const slugger = new GithubSlugger();
+    return new Set([slugger.slug(page.title), ...page.headings.map((heading) => heading.id)]);
+}

package/dist/core/messages.d.ts

@@ -0,0 +1,149 @@
+import type { SvedocsConfig } from '../config.js';
+import type { SvedocsMessages } from './types.js';
+export declare const defaultSvedocsMessages: {
+    'nav.primary': string;
+    'nav.docs': string;
+    'nav.configuration': string;
+    'nav.api': string;
+    'nav.documentation': string;
+    'nav.footer': string;
+    'nav.social': string;
+    'nav.mobile.open': string;
+    'nav.mobile.close': string;
+    'nav.skipToContent': string;
+    'scope.group': string;
+    'scope.locale': string;
+    'scope.localeOptions': string;
+    'scope.langShort': string;
+    'search.trigger': string;
+    'search.dialog': string;
+    'search.query': string;
+    'search.placeholder': string;
+    'search.results': string;
+    'search.loading': string;
+    'search.loadingIndex': string;
+    'search.indexError': string;
+    'search.remoteFallback': string;
+    'search.empty': string;
+    'search.fetchUnavailable': string;
+    'search.requestError': string;
+    'search.failed': string;
+    'ask.label': string;
+    'ask.placeholder': string;
+    'ask.welcome': string;
+    'ask.empty': string;
+    'ask.newChat': string;
+    'ask.close': string;
+    'ask.thinking': string;
+    'ask.send': string;
+    'ask.suggestion.1': string;
+    'ask.suggestion.2': string;
+    'ask.suggestion.3': string;
+    'ask.fetchUnavailable': string;
+    'ask.requestError': string;
+    'ask.failed': string;
+    'ask.streamUnreadable': string;
+    'ask.localSource': string;
+    'ask.localSources': string;
+    'ask.localEmpty': string;
+    'ask.fallbackSource': string;
+    'ask.fallbackSources': string;
+    'ask.fallbackReady': string;
+    'ask.sourceTitle': string;
+    'toc.label': string;
+    'heading.anchor': string;
+    'article.kind.doc': string;
+    'article.kind.page': string;
+    'article.breadcrumb': string;
+    'article.updated': string;
+    'article.edit': string;
+    'article.previous': string;
+    'article.next': string;
+    'code.copy': string;
+    'code.copied': string;
+    'code.copyDiff': string;
+    'diff.label': string;
+    'diff.aria': string;
+    'diff.before': string;
+    'diff.after': string;
+    'tools.label': string;
+    'tools.backToTop': string;
+    'theme.switch': string;
+    'theme.light': string;
+    'theme.dark': string;
+    'home.kicker': string;
+    'home.primaryAction': string;
+    'home.features': string;
+    'home.card.start.label': string;
+    'home.card.start.title': string;
+    'home.card.start.description': string;
+    'home.card.install.label': string;
+    'home.card.install.title': string;
+    'home.card.install.description': string;
+    'home.card.write.label': string;
+    'home.card.write.title': string;
+    'home.card.write.description': string;
+    'home.card.integrate.label': string;
+    'home.card.integrate.title': string;
+    'home.card.integrate.description': string;
+    'footer.text': string;
+    'error.notFound.title': string;
+    'error.notFound.description': string;
+    'error.generic.title': string;
+    'error.generic.description': string;
+    'error.status': string;
+    'error.home': string;
+    'error.docs': string;
+    'render.label': string;
+    'render.title': string;
+    'render.message': string;
+    'render.details': string;
+    'render.tryAgain': string;
+    'render.reload': string;
+    'render.docsHome': string;
+    'render.layout.label': string;
+    'render.layout.title': string;
+    'render.layout.message': string;
+    'render.header.label': string;
+    'render.header.title': string;
+    'render.header.message': string;
+    'render.ask.label': string;
+    'render.ask.title': string;
+    'render.ask.message': string;
+    'render.tools.label': string;
+    'render.tools.title': string;
+    'render.tools.message': string;
+    'render.footer.label': string;
+    'render.footer.title': string;
+    'render.footer.message': string;
+    'render.page.label': string;
+    'render.page.title': string;
+    'render.page.message': string;
+    'render.article.label': string;
+    'render.article.title': string;
+    'render.article.message': string;
+    'render.docs.label': string;
+    'render.docs.title': string;
+    'render.docs.message': string;
+    'render.home.label': string;
+    'render.home.title': string;
+    'render.home.message': string;
+    'render.error.label': string;
+    'render.error.title': string;
+    'render.error.message': string;
+    'render.custom.label': string;
+    'render.custom.title': string;
+    'render.custom.message': string;
+    'render.navigation.label': string;
+    'render.navigation.title': string;
+    'render.navigation.message': string;
+    'render.outline.label': string;
+    'render.outline.title': string;
+    'render.outline.message': string;
+    'render.errorUi.label': string;
+    'render.errorUi.title': string;
+    'render.errorUi.message': string;
+};
+export declare function createBaseMessages(config: SvedocsConfig): SvedocsMessages;
+export declare function mergeMessages(base: SvedocsMessages, override: Partial<SvedocsMessages> | undefined): SvedocsMessages;
+//# sourceMappingURL=messages.d.ts.map