mdorigin 0.1.0

package/dist/core/content-store.d.ts

@@ -0,0 +1,27 @@
+export type ContentEntryKind = 'text' | 'binary';
+export interface ContentEntry {
+    path: string;
+    kind: ContentEntryKind;
+    mediaType: string;
+    text?: string;
+    bytes?: Uint8Array;
+}
+export interface ContentDirectoryEntry {
+    name: string;
+    path: string;
+    kind: 'file' | 'directory';
+}
+export interface ContentStore {
+    get(contentPath: string): Promise<ContentEntry | null>;
+    listDirectory(contentPath: string): Promise<ContentDirectoryEntry[] | null>;
+}
+export declare class MemoryContentStore implements ContentStore {
+    private readonly entries;
+    constructor(entries: Iterable<ContentEntry>);
+    get(contentPath: string): Promise<ContentEntry | null>;
+    listDirectory(contentPath: string): Promise<ContentDirectoryEntry[] | null>;
+}
+export declare function getMediaTypeForPath(contentPath: string): string;
+export declare function isLikelyTextPath(contentPath: string): boolean;
+export declare function normalizeContentPath(inputPath: string): string | null;
+export declare function normalizeDirectoryPath(inputPath: string): string | null;

package/dist/core/content-store.js

@@ -0,0 +1,95 @@
+import path from 'node:path';
+export class MemoryContentStore {
+    entries;
+    constructor(entries) {
+        this.entries = new Map(Array.from(entries, (entry) => [entry.path, { ...entry }]));
+    }
+    async get(contentPath) {
+        return this.entries.get(contentPath) ?? null;
+    }
+    async listDirectory(contentPath) {
+        const directoryPath = normalizeDirectoryPath(contentPath);
+        if (directoryPath === null) {
+            return null;
+        }
+        const prefix = directoryPath === '' ? '' : `${directoryPath}/`;
+        const children = new Map();
+        for (const entryPath of this.entries.keys()) {
+            if (!entryPath.startsWith(prefix)) {
+                continue;
+            }
+            const remainder = entryPath.slice(prefix.length);
+            if (remainder === '') {
+                continue;
+            }
+            const [firstSegment, ...rest] = remainder.split('/');
+            if (firstSegment.startsWith('.')) {
+                continue;
+            }
+            if (rest.length === 0) {
+                children.set(firstSegment, {
+                    name: firstSegment,
+                    path: prefix + firstSegment,
+                    kind: 'file',
+                });
+                continue;
+            }
+            children.set(firstSegment, {
+                name: firstSegment,
+                path: prefix + firstSegment,
+                kind: 'directory',
+            });
+        }
+        const entries = Array.from(children.values()).sort(compareDirectoryEntries);
+        return entries.length > 0 || directoryPath === '' ? entries : null;
+    }
+}
+const MEDIA_TYPES = new Map([
+    ['.css', 'text/css; charset=utf-8'],
+    ['.gif', 'image/gif'],
+    ['.html', 'text/html; charset=utf-8'],
+    ['.jpg', 'image/jpeg'],
+    ['.jpeg', 'image/jpeg'],
+    ['.js', 'text/javascript; charset=utf-8'],
+    ['.json', 'application/json; charset=utf-8'],
+    ['.md', 'text/markdown; charset=utf-8'],
+    ['.pdf', 'application/pdf'],
+    ['.png', 'image/png'],
+    ['.svg', 'image/svg+xml'],
+    ['.txt', 'text/plain; charset=utf-8'],
+    ['.webp', 'image/webp'],
+]);
+export function getMediaTypeForPath(contentPath) {
+    const extension = path.posix.extname(contentPath).toLowerCase();
+    return MEDIA_TYPES.get(extension) ?? 'application/octet-stream';
+}
+export function isLikelyTextPath(contentPath) {
+    const mediaType = getMediaTypeForPath(contentPath);
+    return (mediaType.startsWith('text/') ||
+        mediaType === 'application/json; charset=utf-8' ||
+        mediaType === 'image/svg+xml');
+}
+export function normalizeContentPath(inputPath) {
+    const normalized = inputPath.replace(/\\/g, '/');
+    const withoutLeadingSlash = normalized.replace(/^\/+/, '');
+    const resolved = path.posix.normalize(withoutLeadingSlash);
+    if (resolved === '' ||
+        resolved === '.' ||
+        resolved.startsWith('../') ||
+        resolved.includes('/../')) {
+        return null;
+    }
+    return resolved;
+}
+export function normalizeDirectoryPath(inputPath) {
+    if (inputPath === '') {
+        return '';
+    }
+    return normalizeContentPath(inputPath);
+}
+function compareDirectoryEntries(left, right) {
+    if (left.kind !== right.kind) {
+        return left.kind === 'directory' ? -1 : 1;
+    }
+    return left.name.localeCompare(right.name);
+}

package/dist/core/content-type.d.ts

@@ -0,0 +1,9 @@
+import type { ParsedDocumentMeta } from './markdown.js';
+export type ContentType = 'page' | 'post';
+export interface DirectoryShape {
+    hasChildDirectories: boolean;
+    hasExtraMarkdownFiles: boolean;
+    hasAssetFiles: boolean;
+}
+export declare function resolveContentType(meta: ParsedDocumentMeta): ContentType | undefined;
+export declare function inferDirectoryContentType(meta: ParsedDocumentMeta, shape: DirectoryShape): ContentType;

package/dist/core/content-type.js

@@ -0,0 +1,19 @@
+export function resolveContentType(meta) {
+    return meta.type === 'page' || meta.type === 'post' ? meta.type : undefined;
+}
+export function inferDirectoryContentType(meta, shape) {
+    const explicitType = resolveContentType(meta);
+    if (explicitType) {
+        return explicitType;
+    }
+    if (typeof meta.date === 'string' && meta.date !== '') {
+        return 'post';
+    }
+    if (shape.hasChildDirectories || shape.hasExtraMarkdownFiles) {
+        return 'page';
+    }
+    if (shape.hasAssetFiles) {
+        return 'post';
+    }
+    return 'page';
+}

package/dist/core/directory-index.d.ts

@@ -0,0 +1,2 @@
+export declare const DIRECTORY_INDEX_FILENAMES: readonly ["index.md", "README.md"];
+export declare function getDirectoryIndexCandidates(directoryPath: string): string[];

package/dist/core/directory-index.js

@@ -0,0 +1,5 @@
+import path from 'node:path';
+export const DIRECTORY_INDEX_FILENAMES = ['index.md', 'README.md'];
+export function getDirectoryIndexCandidates(directoryPath) {
+    return DIRECTORY_INDEX_FILENAMES.map((filename) => directoryPath === '' ? filename : path.posix.join(directoryPath, filename));
+}

package/dist/core/markdown.d.ts

@@ -0,0 +1,20 @@
+export interface ParsedDocumentMeta {
+    title?: string;
+    date?: string;
+    summary?: string;
+    draft?: boolean;
+    type?: string;
+    order?: number;
+    [key: string]: unknown;
+}
+export interface ParsedDocument {
+    sourcePath: string;
+    body: string;
+    html: string;
+    meta: ParsedDocumentMeta;
+}
+export declare function parseMarkdownDocument(sourcePath: string, markdown: string): Promise<ParsedDocument>;
+export declare function renderMarkdown(markdown: string): Promise<string>;
+export declare function rewriteMarkdownLinksInHtml(html: string): string;
+export declare function stripManagedIndexBlock(markdown: string): string;
+export declare function stripManagedIndexLinks(markdown: string, hrefs: ReadonlySet<string>): string;

package/dist/core/markdown.js

@@ -0,0 +1,135 @@
+import matter from 'gray-matter';
+import { remark } from 'remark';
+import remarkGfm from 'remark-gfm';
+import remarkHtml from 'remark-html';
+export async function parseMarkdownDocument(sourcePath, markdown) {
+    const parsed = matter(markdown);
+    const html = rewriteMarkdownLinksInHtml(await renderMarkdown(parsed.content));
+    return {
+        sourcePath,
+        body: parsed.content,
+        html,
+        meta: normalizeMeta(parsed.data),
+    };
+}
+export async function renderMarkdown(markdown) {
+    const output = await remark()
+        .use(remarkGfm)
+        .use(remarkHtml)
+        .process(markdown);
+    return String(output);
+}
+export function rewriteMarkdownLinksInHtml(html) {
+    return html.replaceAll(/(<a\b[^>]*?\shref=")([^"]+)(")/g, (_match, prefix, href, suffix) => `${prefix}${rewriteMarkdownHref(href)}${suffix}`);
+}
+export function stripManagedIndexBlock(markdown) {
+    return markdown.replace(/\n?<!-- INDEX:START -->[\s\S]*?<!-- INDEX:END -->\n?/g, '\n').trimEnd();
+}
+export function stripManagedIndexLinks(markdown, hrefs) {
+    if (hrefs.size === 0) {
+        return markdown;
+    }
+    return markdown.replace(/(\n<!-- INDEX:START -->\n)([\s\S]*?)(\n<!-- INDEX:END -->)/, (_match, start, content, end) => {
+        const blocks = content
+            .trim()
+            .split(/\n\s*\n/g)
+            .map((block) => block.trim())
+            .filter((block) => block !== '');
+        const keptBlocks = blocks.filter((block) => {
+            const firstLine = block.split('\n', 1)[0] ?? '';
+            const hrefMatch = firstLine.match(/\[[^\]]+\]\(([^)]+)\)/);
+            if (!hrefMatch) {
+                return true;
+            }
+            return !hrefs.has(normalizeManagedIndexHref(hrefMatch[1]));
+        });
+        if (keptBlocks.length === 0) {
+            return `${start.trimEnd()}\n\n${end.trimStart()}`;
+        }
+        return `${start}${keptBlocks.join('\n\n')}\n${end}`;
+    });
+}
+function normalizeMeta(data) {
+    const meta = { ...data };
+    if (typeof data.title === 'string') {
+        meta.title = data.title;
+    }
+    if (typeof data.date === 'string') {
+        meta.date = data.date;
+    }
+    if (data.date instanceof Date && !Number.isNaN(data.date.getTime())) {
+        meta.date = data.date.toISOString().slice(0, 10);
+    }
+    if (typeof data.summary === 'string') {
+        meta.summary = data.summary;
+    }
+    if (typeof data.draft === 'boolean') {
+        meta.draft = data.draft;
+    }
+    if (typeof data.type === 'string') {
+        meta.type = data.type;
+    }
+    if (typeof data.order === 'number' && Number.isFinite(data.order)) {
+        meta.order = data.order;
+    }
+    if (typeof data.order === 'string') {
+        const order = Number.parseInt(data.order, 10);
+        if (Number.isFinite(order)) {
+            meta.order = order;
+        }
+    }
+    return meta;
+}
+function rewriteMarkdownHref(href) {
+    if (shouldPreserveHref(href)) {
+        return href;
+    }
+    const [pathPart, hashPart] = splitOnce(href, '#');
+    const [pathname, queryPart] = splitOnce(pathPart, '?');
+    if (!pathname.toLowerCase().endsWith('.md')) {
+        return href;
+    }
+    const normalizedPath = pathname.replace(/\\/g, '/');
+    const rewrittenPath = rewriteMarkdownPath(normalizedPath);
+    const querySuffix = queryPart !== undefined ? `?${queryPart}` : '';
+    const hashSuffix = hashPart !== undefined ? `#${hashPart}` : '';
+    return `${rewrittenPath}${querySuffix}${hashSuffix}`;
+}
+function rewriteMarkdownPath(pathname) {
+    if (pathname.toLowerCase().endsWith('/index.md')) {
+        return pathname.slice(0, -'index.md'.length);
+    }
+    if (pathname.toLowerCase() === 'index.md') {
+        return './';
+    }
+    if (pathname.toLowerCase().endsWith('/readme.md')) {
+        return pathname.slice(0, -'README.md'.length);
+    }
+    if (pathname.toLowerCase() === 'readme.md') {
+        return './';
+    }
+    return pathname.slice(0, -'.md'.length);
+}
+function shouldPreserveHref(href) {
+    return (href.startsWith('#') ||
+        href.startsWith('mailto:') ||
+        href.startsWith('tel:') ||
+        href.startsWith('//') ||
+        /^[a-zA-Z][a-zA-Z\d+.-]*:/.test(href));
+}
+function splitOnce(value, separator) {
+    const index = value.indexOf(separator);
+    if (index === -1) {
+        return [value, undefined];
+    }
+    return [value.slice(0, index), value.slice(index + separator.length)];
+}
+function normalizeManagedIndexHref(href) {
+    if (href === './') {
+        return '/';
+    }
+    if (href.startsWith('./')) {
+        return `/${href.slice(2)}`;
+    }
+    return href;
+}

package/dist/core/request-handler.d.ts

@@ -0,0 +1,12 @@
+import type { ContentStore } from './content-store.js';
+import type { ResolvedSiteConfig } from './site-config.js';
+export interface HandleSiteRequestOptions {
+    draftMode: 'include' | 'exclude';
+    siteConfig: ResolvedSiteConfig;
+}
+export interface SiteResponse {
+    status: number;
+    headers: Record<string, string>;
+    body?: string | Uint8Array;
+}
+export declare function handleSiteRequest(store: ContentStore, pathname: string, options: HandleSiteRequestOptions): Promise<SiteResponse>;

package/dist/core/request-handler.js

@@ -0,0 +1,322 @@
+import path from 'node:path';
+import { inferDirectoryContentType } from './content-type.js';
+import { getDirectoryIndexCandidates } from './directory-index.js';
+import { parseMarkdownDocument, stripManagedIndexBlock, stripManagedIndexLinks, } from './markdown.js';
+import { resolveRequest } from './router.js';
+import { escapeHtml, renderDocument } from '../html/template.js';
+export async function handleSiteRequest(store, pathname, options) {
+    const resolved = resolveRequest(pathname);
+    if (resolved.kind === 'not-found' || !resolved.sourcePath) {
+        return notFound();
+    }
+    const entry = await store.get(resolved.sourcePath);
+    if (entry === null) {
+        if (resolved.kind === 'html' && resolved.requestPath.endsWith('/')) {
+            const directoryIndexResponse = await tryRenderAlternateDirectoryIndex(store, resolved.requestPath, options);
+            if (directoryIndexResponse !== null) {
+                return directoryIndexResponse;
+            }
+            return renderDirectoryListing(store, resolved.requestPath, options.siteConfig);
+        }
+        return notFound();
+    }
+    if (resolved.kind === 'asset') {
+        return serveAsset(entry);
+    }
+    if (entry.kind !== 'text' || entry.text === undefined) {
+        return notFound();
+    }
+    if (resolved.kind === 'markdown') {
+        const parsed = await parseMarkdownDocument(resolved.sourcePath, entry.text);
+        if (parsed.meta.draft === true && options.draftMode === 'exclude') {
+            return notFound();
+        }
+        return {
+            status: 200,
+            headers: {
+                'content-type': entry.mediaType,
+            },
+            body: entry.text,
+        };
+    }
+    const parsed = await parseMarkdownDocument(resolved.sourcePath, entry.text);
+    if (parsed.meta.draft === true && options.draftMode === 'exclude') {
+        return notFound();
+    }
+    const navigation = await resolveTopNav(store, options.siteConfig);
+    const renderedBody = isRootHomeRequest(resolved.requestPath) && !options.siteConfig.showHomeIndex
+        ? stripManagedIndexBlock(entry.text)
+        : isRootHomeRequest(resolved.requestPath) && navigation.items.length > 0
+            ? stripManagedIndexLinks(entry.text, new Set(navigation.items.map((item) => item.href)))
+            : entry.text;
+    const renderedParsed = renderedBody === entry.text
+        ? parsed
+        : await parseMarkdownDocument(resolved.sourcePath, renderedBody);
+    return {
+        status: 200,
+        headers: {
+            'content-type': 'text/html; charset=utf-8',
+        },
+        body: renderDocument({
+            siteTitle: options.siteConfig.siteTitle,
+            siteDescription: options.siteConfig.siteDescription,
+            title: getDocumentTitle(parsed),
+            body: renderedParsed.html,
+            summary: options.siteConfig.showSummary === false ? undefined : parsed.meta.summary,
+            date: options.siteConfig.showDate === false ? undefined : parsed.meta.date,
+            showSummary: options.siteConfig.showSummary,
+            showDate: options.siteConfig.showDate,
+            theme: options.siteConfig.theme,
+            template: options.siteConfig.template,
+            topNav: navigation.items,
+            stylesheetContent: options.siteConfig.stylesheetContent,
+        }),
+    };
+}
+function serveAsset(entry) {
+    if (entry.kind === 'text' && entry.text !== undefined) {
+        return {
+            status: 200,
+            headers: {
+                'content-type': entry.mediaType,
+            },
+            body: entry.text,
+        };
+    }
+    if (entry.kind === 'binary' && entry.bytes !== undefined) {
+        return {
+            status: 200,
+            headers: {
+                'content-type': entry.mediaType,
+            },
+            body: entry.bytes,
+        };
+    }
+    return notFound();
+}
+function notFound() {
+    return {
+        status: 404,
+        headers: {
+            'content-type': 'text/plain; charset=utf-8',
+        },
+        body: 'Not Found',
+    };
+}
+function getDocumentTitle(parsed) {
+    if (parsed.meta.title) {
+        return parsed.meta.title;
+    }
+    const basename = path.posix.basename(parsed.sourcePath, '.md');
+    return basename === 'index'
+        ? path.posix.basename(path.posix.dirname(parsed.sourcePath)) || 'mdorigin'
+        : basename;
+}
+async function renderDirectoryListing(store, requestPath, siteConfig) {
+    const directoryPath = requestPath === '/' ? '' : requestPath.slice(1).replace(/\/$/, '');
+    const entries = await store.listDirectory(directoryPath);
+    if (entries === null) {
+        return notFound();
+    }
+    const visibleEntries = entries.filter(isVisibleDirectoryEntry);
+    const navigation = await resolveTopNav(store, siteConfig);
+    const listItems = visibleEntries
+        .map((entry) => `<li><a href="${getDirectoryEntryHref(requestPath, entry)}">${escapeHtml(getDirectoryEntryLabel(entry))}</a></li>`)
+        .join('');
+    const body = [
+        `<h1>${escapeHtml(getDirectoryTitle(requestPath))}</h1>`,
+        visibleEntries.length > 0 ? `<ul>${listItems}</ul>` : '<p>This directory is empty.</p>',
+    ].join('');
+    return {
+        status: 200,
+        headers: {
+            'content-type': 'text/html; charset=utf-8',
+        },
+        body: renderDocument({
+            siteTitle: siteConfig.siteTitle,
+            siteDescription: siteConfig.siteDescription,
+            title: getDirectoryTitle(requestPath),
+            body,
+            showSummary: false,
+            showDate: false,
+            theme: siteConfig.theme,
+            template: siteConfig.template,
+            topNav: navigation.items,
+            stylesheetContent: siteConfig.stylesheetContent,
+        }),
+    };
+}
+function isVisibleDirectoryEntry(entry) {
+    if (entry.kind === 'directory') {
+        return true;
+    }
+    return path.posix.extname(entry.name).toLowerCase() === '.md';
+}
+function getDirectoryEntryHref(requestPath, entry) {
+    const basePath = requestPath.endsWith('/') ? requestPath : `${requestPath}/`;
+    if (entry.kind === 'directory') {
+        return `${basePath}${entry.name}/`;
+    }
+    return `${basePath}${entry.name.slice(0, -'.md'.length)}`;
+}
+function getDirectoryEntryLabel(entry) {
+    return entry.kind === 'directory'
+        ? `${entry.name}/`
+        : entry.name.slice(0, -'.md'.length);
+}
+function getDirectoryTitle(requestPath) {
+    return requestPath === '/' ? 'Index' : requestPath;
+}
+async function tryRenderAlternateDirectoryIndex(store, requestPath, options) {
+    const directoryPath = requestPath === '/' ? '' : requestPath.slice(1).replace(/\/$/, '');
+    for (const candidatePath of getDirectoryIndexCandidates(directoryPath)) {
+        if (candidatePath === (directoryPath === '' ? 'index.md' : `${directoryPath}/index.md`)) {
+            continue;
+        }
+        const entry = await store.get(candidatePath);
+        if (entry === null || entry.kind !== 'text' || entry.text === undefined) {
+            continue;
+        }
+        const parsed = await parseMarkdownDocument(candidatePath, entry.text);
+        if (parsed.meta.draft === true && options.draftMode === 'exclude') {
+            return notFound();
+        }
+        const navigation = await resolveTopNav(store, options.siteConfig);
+        const renderedBody = isRootHomeRequest(requestPath) && !options.siteConfig.showHomeIndex
+            ? stripManagedIndexBlock(entry.text)
+            : isRootHomeRequest(requestPath) && navigation.items.length > 0
+                ? stripManagedIndexLinks(entry.text, new Set(navigation.items.map((item) => item.href)))
+                : entry.text;
+        const renderedParsed = renderedBody === entry.text
+            ? parsed
+            : await parseMarkdownDocument(candidatePath, renderedBody);
+        return {
+            status: 200,
+            headers: {
+                'content-type': 'text/html; charset=utf-8',
+            },
+            body: renderDocument({
+                siteTitle: options.siteConfig.siteTitle,
+                siteDescription: options.siteConfig.siteDescription,
+                title: getDocumentTitle(parsed),
+                body: renderedParsed.html,
+                summary: options.siteConfig.showSummary === false ? undefined : parsed.meta.summary,
+                date: options.siteConfig.showDate === false ? undefined : parsed.meta.date,
+                showSummary: options.siteConfig.showSummary,
+                showDate: options.siteConfig.showDate,
+                theme: options.siteConfig.theme,
+                template: options.siteConfig.template,
+                topNav: navigation.items,
+                stylesheetContent: options.siteConfig.stylesheetContent,
+            }),
+        };
+    }
+    return null;
+}
+function isRootHomeRequest(requestPath) {
+    return requestPath === '/';
+}
+async function resolveTopNav(store, siteConfig) {
+    if (siteConfig.topNav.length > 0) {
+        return {
+            items: siteConfig.topNav,
+            autoGenerated: false,
+        };
+    }
+    const rootEntries = await store.listDirectory('');
+    if (rootEntries === null) {
+        return {
+            items: [],
+            autoGenerated: false,
+        };
+    }
+    const directories = rootEntries.filter((entry) => entry.kind === 'directory');
+    const navItems = [];
+    const orderedNavItems = [];
+    for (const entry of directories) {
+        const resolved = await resolveDirectoryNav(store, entry);
+        if (resolved.type !== 'page') {
+            continue;
+        }
+        orderedNavItems.push({
+            label: resolved.title,
+            href: `/${entry.name}/`,
+            order: resolved.order,
+        });
+    }
+    orderedNavItems.sort((left, right) => {
+        if (left.order !== undefined && right.order !== undefined) {
+            if (left.order !== right.order) {
+                return left.order - right.order;
+            }
+        }
+        else if (left.order !== undefined) {
+            return -1;
+        }
+        else if (right.order !== undefined) {
+            return 1;
+        }
+        return left.label.localeCompare(right.label);
+    });
+    navItems.push(...orderedNavItems.map(({ label, href }) => ({ label, href })));
+    return {
+        items: navItems,
+        autoGenerated: navItems.length > 0,
+    };
+}
+async function resolveDirectoryNav(store, entry) {
+    for (const candidatePath of getDirectoryIndexCandidates(entry.path)) {
+        const contentEntry = await store.get(candidatePath);
+        if (contentEntry === null || contentEntry.kind !== 'text' || contentEntry.text === undefined) {
+            continue;
+        }
+        const parsed = await parseMarkdownDocument(candidatePath, contentEntry.text);
+        const shape = await inspectDirectoryShape(store, entry.path);
+        return {
+            title: typeof parsed.meta.title === 'string' && parsed.meta.title !== ''
+                ? parsed.meta.title
+                : entry.name,
+            type: inferDirectoryContentType(parsed.meta, shape),
+            order: parsed.meta.order,
+        };
+    }
+    return {
+        title: entry.name,
+        type: 'page',
+    };
+}
+async function inspectDirectoryShape(store, directoryPath) {
+    const entries = await store.listDirectory(directoryPath);
+    if (entries === null) {
+        return {
+            hasChildDirectories: false,
+            hasExtraMarkdownFiles: false,
+            hasAssetFiles: false,
+        };
+    }
+    let hasChildDirectories = false;
+    let hasExtraMarkdownFiles = false;
+    let hasAssetFiles = false;
+    for (const entry of entries) {
+        if (entry.name.startsWith('.')) {
+            continue;
+        }
+        if (entry.kind === 'directory') {
+            hasChildDirectories = true;
+            continue;
+        }
+        const extension = path.posix.extname(entry.name).toLowerCase();
+        if (extension === '.md') {
+            if (entry.name !== 'index.md' && entry.name !== 'README.md') {
+                hasExtraMarkdownFiles = true;
+            }
+            continue;
+        }
+        hasAssetFiles = true;
+    }
+    return {
+        hasChildDirectories,
+        hasExtraMarkdownFiles,
+        hasAssetFiles,
+    };
+}

package/dist/core/router.d.ts

@@ -0,0 +1,7 @@
+export type ResolvedRequestKind = 'markdown' | 'html' | 'asset' | 'not-found';
+export interface ResolvedRequest {
+    kind: ResolvedRequestKind;
+    requestPath: string;
+    sourcePath?: string;
+}
+export declare function resolveRequest(pathname: string): ResolvedRequest;