@eclipsa/content 0.0.0

package/.turbo/turbo-build.log

@@ -0,0 +1,34 @@
+$ vp pack && bun ../../scripts/release/write-dist-package-json.ts
+ℹ entry: mod.ts, vite.ts, internal.ts
+ℹ tsconfig: ../../tsconfig.json
+ℹ Build start
+ℹ Cleaning 15 files
+ℹ dist/vite.mjs                    7.59 kB │ gzip:  2.38 kB
+ℹ dist/mod.mjs                     1.16 kB │ gzip:  0.56 kB
+ℹ dist/internal.mjs                0.35 kB │ gzip:  0.18 kB
+ℹ dist/internal-h0upzIHm.mjs.map  42.66 kB │ gzip: 11.12 kB
+ℹ dist/internal-h0upzIHm.mjs      21.25 kB │ gzip:  6.36 kB
+ℹ dist/vite.mjs.map               13.07 kB │ gzip:  3.98 kB
+ℹ dist/mod.mjs.map                 4.44 kB │ gzip:  1.36 kB
+ℹ dist/types-rZ-wc23p.mjs.map      4.34 kB │ gzip:  1.19 kB
+ℹ dist/types-rZ-wc23p.mjs          0.19 kB │ gzip:  0.17 kB
+ℹ dist/internal.d.mts              1.67 kB │ gzip:  0.58 kB
+ℹ dist/mod.d.mts                   1.63 kB │ gzip:  0.51 kB
+ℹ dist/vite.d.mts                  0.18 kB │ gzip:  0.15 kB
+ℹ dist/mod-P8gKoDsz.d.mts          6.45 kB │ gzip:  1.63 kB
+ℹ 13 files, total: 104.99 kB
+mod.ts (27:16) [UNRESOLVED_IMPORT] Warning: Could not resolve 'virtual:eclipsa-content:runtime' in mod.ts
+    ╭─[ mod.ts:27:17 ]
+    │
+ 27 │   return import('virtual:eclipsa-content:runtime')
+    │                 ────────────────┬────────────────  
+    │                                 ╰────────────────── Module not found, treating it as an external dependency
+────╯
+
+[PLUGIN_TIMINGS] Warning: Your build spent significant time in plugins. Here is a breakdown:
+  - tsdown:external (51%)
+  - rolldown-plugin-dts:generate (47%)
+See https://rolldown.rs/options/checks#plugintimings for more details.
+
+✔ Build complete in 3322ms
+dist/package.json

package/.turbo/turbo-test.log

@@ -0,0 +1,13 @@
+$ vp test --run
+ RUN  /home/nakasyou/eclipsa/packages/content
+
+ ✓ search.test.ts (2 tests) 8ms
+ ✓ vite-config.test.ts (1 test) 5ms
+ ✓ vite.test.ts (6 tests) 95ms
+ ✓ internal.test.ts (5 tests) 197ms
+
+ Test Files  4 passed (4)
+      Tests  14 passed (14)
+   Start at  17:36:38
+   Duration  734ms (transform 424ms, setup 0ms, import 1.17s, tests 304ms, environment 1ms)
+

package/.turbo/turbo-typecheck.log

@@ -0,0 +1 @@
+$ bun x tsc -p ../../tsconfig.json --noEmit

package/dist/internal-h0upzIHm.mjs

@@ -0,0 +1,644 @@
+import "./types-rZ-wc23p.mjs";
+import { createRequire } from "node:module";
+import * as fs from "node:fs/promises";
+import path from "node:path";
+import fg from "fast-glob";
+import YAML from "yaml";
+import { createHighlighter } from "shiki";
+//#region highlight.ts
+const DEFAULT_THEME = "github-dark";
+const CODE_BLOCK_RE = /<pre\b[^>]*>\s*<code\b([^>]*)>([\s\S]*?)<\/code>\s*<\/pre>/giu;
+const CLASS_ATTR_RE = /\bclass=(['"])(.*?)\1/iu;
+const HTML_ENTITY_RE = /&(?:#(\d+)|#x([\da-fA-F]+)|amp|lt|gt|quot|#39);/g;
+const highlighterCache = /* @__PURE__ */ new Map();
+const loadedLanguagesByTheme = /* @__PURE__ */ new Map();
+const decodeHtmlEntities$1 = (value) => value.replace(HTML_ENTITY_RE, (entity, decimal, hex) => {
+	if (decimal) return String.fromCodePoint(Number(decimal));
+	if (hex) return String.fromCodePoint(Number.parseInt(hex, 16));
+	switch (entity) {
+		case "&amp;": return "&";
+		case "&lt;": return "<";
+		case "&gt;": return ">";
+		case "&quot;": return "\"";
+		case "&#39;": return "'";
+		default: return entity;
+	}
+});
+const getLanguageFromCodeAttributes = (attributes) => {
+	const classAttr = CLASS_ATTR_RE.exec(attributes)?.[2];
+	if (!classAttr) return null;
+	for (const token of classAttr.split(/\s+/)) if (token.startsWith("language-")) return token.slice(9);
+	return null;
+};
+const resolveTheme = (options) => {
+	if (!options) return null;
+	return options === true ? DEFAULT_THEME : options.theme ?? DEFAULT_THEME;
+};
+const getHighlighter = (theme) => {
+	const cached = highlighterCache.get(theme);
+	if (cached) return cached;
+	const next = createHighlighter({
+		langs: [],
+		themes: [theme]
+	});
+	highlighterCache.set(theme, next);
+	loadedLanguagesByTheme.set(theme, /* @__PURE__ */ new Set());
+	return next;
+};
+const ensureLanguageLoaded = async (theme, language) => {
+	const loadedLanguages = loadedLanguagesByTheme.get(theme) ?? /* @__PURE__ */ new Set();
+	loadedLanguagesByTheme.set(theme, loadedLanguages);
+	if (loadedLanguages.has(language)) return;
+	await (await getHighlighter(theme)).loadLanguage(language);
+	loadedLanguages.add(language);
+};
+const highlightHtml = async (html, options) => {
+	const theme = resolveTheme(options);
+	if (!theme) return html;
+	const highlighter = await getHighlighter(theme);
+	let highlightedHtml = "";
+	let lastIndex = 0;
+	for (const match of html.matchAll(CODE_BLOCK_RE)) {
+		const index = match.index ?? 0;
+		const fullMatch = match[0];
+		const codeAttributes = match[1] ?? "";
+		const encodedCode = match[2] ?? "";
+		const language = getLanguageFromCodeAttributes(codeAttributes);
+		highlightedHtml += html.slice(lastIndex, index);
+		lastIndex = index + fullMatch.length;
+		if (!language) {
+			highlightedHtml += fullMatch;
+			continue;
+		}
+		try {
+			await ensureLanguageLoaded(theme, language);
+			highlightedHtml += highlighter.codeToHtml(decodeHtmlEntities$1(encodedCode), {
+				lang: language,
+				theme
+			});
+		} catch {
+			highlightedHtml += fullMatch;
+		}
+	}
+	if (lastIndex === 0) return html;
+	highlightedHtml += html.slice(lastIndex);
+	return highlightedHtml;
+};
+//#endregion
+//#region search.ts
+const DEFAULT_SEARCH_OPTIONS = {
+	enabled: true,
+	hotkey: "/",
+	limit: 10,
+	placeholder: "Search docs...",
+	prefix: true
+};
+const SEARCH_STOPWORDS = new Set([
+	"a",
+	"an",
+	"and",
+	"are",
+	"as",
+	"at",
+	"be",
+	"by",
+	"for",
+	"from",
+	"has",
+	"have",
+	"how",
+	"in",
+	"is",
+	"it",
+	"of",
+	"on",
+	"or",
+	"that",
+	"the",
+	"this",
+	"to",
+	"was",
+	"were",
+	"with"
+]);
+const isCjkChar = (char) => /[\u3400-\u4dbf\u4e00-\u9fff\u3040-\u30ff\uac00-\ud7af]/u.test(char);
+const tokenizeValue = (text, query) => {
+	const tokens = [];
+	let current = "";
+	for (const char of text) {
+		if (isCjkChar(char)) {
+			if (current !== "") {
+				const token = current.toLowerCase();
+				if (query || token.length >= 2 && !SEARCH_STOPWORDS.has(token)) tokens.push(token);
+				current = "";
+			}
+			tokens.push(char);
+			continue;
+		}
+		if (/[\p{L}\p{N}_]/u.test(char)) {
+			current += char;
+			continue;
+		}
+		if (current !== "") {
+			const token = current.toLowerCase();
+			if (query || token.length >= 2 && !SEARCH_STOPWORDS.has(token)) tokens.push(token);
+			current = "";
+		}
+	}
+	if (current !== "") {
+		const token = current.toLowerCase();
+		if (query || token.length >= 2 && !SEARCH_STOPWORDS.has(token)) tokens.push(token);
+	}
+	return tokens;
+};
+const tokenizeIndex = (text) => tokenizeValue(text, false);
+const addDocumentFieldTerms = (map, field, text) => {
+	for (const token of tokenizeIndex(text)) {
+		const existing = map.get(token);
+		if (existing) {
+			existing.tf += 1;
+			continue;
+		}
+		map.set(token, {
+			field,
+			tf: 1
+		});
+	}
+};
+const resolveContentSearchOptions = (options) => {
+	if (options === false) return {
+		...DEFAULT_SEARCH_OPTIONS,
+		enabled: false
+	};
+	const normalized = typeof options === "object" ? options : {};
+	return {
+		enabled: normalized.enabled ?? true,
+		hotkey: normalized.hotkey ?? DEFAULT_SEARCH_OPTIONS.hotkey,
+		limit: normalized.limit ?? DEFAULT_SEARCH_OPTIONS.limit,
+		placeholder: normalized.placeholder ?? DEFAULT_SEARCH_OPTIONS.placeholder,
+		prefix: normalized.prefix ?? DEFAULT_SEARCH_OPTIONS.prefix
+	};
+};
+const buildContentSearchIndex = (documents, options) => {
+	const index = {};
+	const df = {};
+	let totalDocumentLength = 0;
+	documents.forEach((document, docIdx) => {
+		const docTerms = /* @__PURE__ */ new Map();
+		addDocumentFieldTerms(docTerms, "title", document.title);
+		for (const heading of document.headings) addDocumentFieldTerms(docTerms, "heading", heading);
+		addDocumentFieldTerms(docTerms, "body", document.body);
+		for (const code of document.code) addDocumentFieldTerms(docTerms, "code", code);
+		totalDocumentLength += tokenizeIndex(document.body).length;
+		for (const [term, posting] of docTerms) {
+			df[term] = (df[term] ?? 0) + 1;
+			const postings = index[term] ?? [];
+			postings.push({
+				docIdx,
+				field: posting.field,
+				tf: posting.tf
+			});
+			index[term] = postings;
+		}
+	});
+	return {
+		avgDl: documents.length === 0 ? 0 : totalDocumentLength / documents.length,
+		df,
+		docCount: documents.length,
+		documents,
+		index,
+		options
+	};
+};
+const generateContentSearchRuntimeModule = (assetPath, options) => `let searchIndexPromise = null
+const searchOptions = ${JSON.stringify(options)}
+
+const loadSearchIndex = async () => {
+  if (searchIndexPromise) {
+    return searchIndexPromise
+  }
+  searchIndexPromise = fetch(${JSON.stringify(assetPath)})
+    .then((response) => {
+      if (!response.ok) {
+        throw new Error('Failed to load search index.')
+      }
+      return response.json()
+    })
+    .catch(() => null)
+  return searchIndexPromise
+}
+
+const isCjkChar = (char) => /[\\u3400-\\u4dbf\\u4e00-\\u9fff\\u3040-\\u30ff\\uac00-\\ud7af]/u.test(char)
+
+const tokenizeQuery = (text) => {
+  const tokens = []
+  let current = ''
+  for (const char of text) {
+    if (isCjkChar(char)) {
+      if (current !== '') {
+        tokens.push(current.toLowerCase())
+        current = ''
+      }
+      tokens.push(char)
+      continue
+    }
+    if (/[\\p{L}\\p{N}_]/u.test(char)) {
+      current += char
+      continue
+    }
+    if (current !== '') {
+      tokens.push(current.toLowerCase())
+      current = ''
+    }
+  }
+  if (current !== '') {
+    tokens.push(current.toLowerCase())
+  }
+  return tokens
+}
+
+const getFieldBoost = (field) => {
+  switch (field) {
+    case 'title':
+      return 10
+    case 'heading':
+      return 5
+    case 'code':
+      return 0.5
+    case 'body':
+    default:
+      return 1
+  }
+}
+
+const getSnippet = (body, matches, maxLength = 150) => {
+  if (body === '') {
+    return ''
+  }
+  const lowerBody = body.toLowerCase()
+  let firstMatchIndex = -1
+  for (const match of matches) {
+    const index = lowerBody.indexOf(match.toLowerCase())
+    if (index !== -1 && (firstMatchIndex === -1 || index < firstMatchIndex)) {
+      firstMatchIndex = index
+    }
+  }
+  const start = Math.max(0, firstMatchIndex - 50)
+  const end = Math.min(body.length, start + maxLength)
+  let snippet = body.slice(start, end).trim()
+  if (start > 0) {
+    snippet = '...' + snippet
+  }
+  if (end < body.length) {
+    snippet = snippet + '...'
+  }
+  return snippet
+}
+
+export const search = async (
+  query,
+  options = {},
+) => {
+  const searchIndex = await loadSearchIndex()
+  if (!searchIndex || query.trim() === '') {
+    return []
+  }
+  const tokens = tokenizeQuery(query)
+  if (tokens.length === 0) {
+    return []
+  }
+  const limit = options.limit ?? searchOptions.limit
+  const prefix = options.prefix ?? searchOptions.prefix
+  const docScores = new Map()
+
+  tokens.forEach((token, tokenIndex) => {
+    const isLastToken = tokenIndex === tokens.length - 1
+    const matchingTerms =
+      prefix && isLastToken && token.length >= 2
+        ? Object.keys(searchIndex.index).filter((term) => term.startsWith(token))
+        : searchIndex.index[token]
+          ? [token]
+          : []
+
+    for (const term of matchingTerms) {
+      const postings = searchIndex.index[term] ?? []
+      const df = searchIndex.df[term] ?? 1
+      const idf = Math.log((searchIndex.docCount - df + 0.5) / (df + 0.5) + 1)
+
+      for (const posting of postings) {
+        const document = searchIndex.documents[posting.docIdx]
+        if (!document) {
+          continue
+        }
+        const docLength = Math.max(1, document.body.split(/\\s+/u).filter(Boolean).length)
+        const score =
+          idf *
+          ((posting.tf * (1.2 + 1)) /
+            (posting.tf + 1.2 * (1 - 0.75 + (0.75 * docLength) / Math.max(1, searchIndex.avgDl)))) *
+          getFieldBoost(posting.field)
+
+        const current = docScores.get(posting.docIdx) ?? {
+          matches: new Set(),
+          score: 0,
+        }
+        current.score += score
+        current.matches.add(term)
+        docScores.set(posting.docIdx, current)
+      }
+    }
+  })
+
+  return [...docScores.entries()]
+    .map(([docIdx, value]) => {
+      const document = searchIndex.documents[docIdx]
+      const matches = [...value.matches]
+      return {
+        collection: document.collection,
+        id: document.id,
+        matches,
+        score: value.score,
+        snippet: getSnippet(document.body, matches),
+        title: document.title,
+        url: document.url,
+      }
+    })
+    .sort((left, right) => right.score - left.score)
+    .slice(0, limit)
+}
+
+export { searchOptions }
+export default { search, searchOptions }
+`;
+//#endregion
+//#region internal.ts
+const MARKDOWN_EXTENSION_RE = /\.md$/i;
+const require = createRequire(import.meta.url);
+let markdownTransform = null;
+var ContentCollectionError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ContentCollectionError";
+	}
+};
+const normalizeSlashes = (value) => value.replaceAll("\\", "/");
+const formatIssuePath = (pathValue) => {
+	if (!pathValue || pathValue.length === 0) return "";
+	return pathValue.map((segment) => typeof segment === "object" && segment !== null && "key" in segment ? String(segment.key) : String(segment)).join(".");
+};
+const createSchemaError = (collection, filePath, issues) => {
+	return new ContentCollectionError(`Invalid frontmatter in collection "${collection}" for ${filePath}: ${issues.map((issue) => {
+		const issuePath = formatIssuePath(issue.path);
+		return issuePath === "" ? issue.message : `${issuePath}: ${issue.message}`;
+	}).join("; ")}`);
+};
+const parseFrontmatter = (source) => {
+	if (!source.startsWith("---")) return {
+		body: source,
+		data: {}
+	};
+	const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/u.exec(source);
+	if (!match) return {
+		body: source,
+		data: {}
+	};
+	const raw = YAML.parse(match[1] ?? "");
+	if (raw == null) return {
+		body: source.slice(match[0].length),
+		data: {}
+	};
+	if (typeof raw !== "object" || Array.isArray(raw)) throw new ContentCollectionError("Markdown frontmatter must resolve to an object.");
+	return {
+		body: source.slice(match[0].length),
+		data: { ...raw }
+	};
+};
+const normalizeIdSegment = (segment) => segment.trim().replaceAll(/\s+/g, "-").replaceAll(/[^a-zA-Z0-9/_-]+/g, "-").replaceAll(/-+/g, "-").replaceAll(/^[-/]+|[-/]+$/g, "");
+const normalizeEntryId = (value) => normalizeSlashes(value).split("/").map(normalizeIdSegment).filter(Boolean).join("/");
+const toEntryIdFromRelativePath = (relativePath) => {
+	const segments = normalizeSlashes(relativePath).replace(MARKDOWN_EXTENSION_RE, "").split("/").filter(Boolean);
+	if (segments[segments.length - 1] === "index" && segments.length > 1) segments.pop();
+	return normalizeEntryId(segments.join("/")) || "index";
+};
+const validateData = async (collection, schema, filePath, data) => {
+	if (!schema) return data;
+	const result = await schema["~standard"].validate(data);
+	if ("issues" in result && result.issues !== void 0) throw createSchemaError(collection, filePath, result.issues);
+	return result.value;
+};
+const resolveGlobLoaderEntries = async (collection, loader, context) => {
+	const baseDir = path.resolve(path.dirname(context.configPath), loader.base);
+	const matches = await fg(loader.pattern, {
+		absolute: true,
+		cwd: baseDir,
+		onlyFiles: true
+	});
+	return Promise.all(matches.map(async (filePath) => {
+		const source = await fs.readFile(filePath, "utf8");
+		const relativePath = normalizeSlashes(path.relative(baseDir, filePath));
+		const parsed = parseFrontmatter(source);
+		const slug = typeof parsed.data.slug === "string" ? parsed.data.slug : void 0;
+		delete parsed.data.slug;
+		return {
+			body: parsed.body,
+			data: parsed.data,
+			filePath,
+			id: slug ? normalizeEntryId(slug) : toEntryIdFromRelativePath(relativePath)
+		};
+	}));
+};
+const resolveLoaderEntries = async (collection, loader, context) => {
+	if (loader.kind === "glob") return resolveGlobLoaderEntries(collection, loader, context);
+	return [...await loader.load(context)];
+};
+const normalizeResolvedEntry = async (collection, schema, entry, index) => {
+	const parsed = entry.data === void 0 ? parseFrontmatter(entry.body) : {
+		body: entry.body,
+		data: { ...entry.data }
+	};
+	const filePath = entry.filePath ?? `${collection}:${entry.id ?? index}`;
+	const slug = typeof parsed.data.slug === "string" ? parsed.data.slug : void 0;
+	delete parsed.data.slug;
+	const id = normalizeEntryId(entry.id ?? slug ?? `${collection}-${index}`) || `${collection}-${index}`;
+	return {
+		body: parsed.body,
+		collection,
+		data: await validateData(collection, schema, filePath, parsed.data),
+		filePath,
+		id
+	};
+};
+const isDefinedCollection = (value) => typeof value === "object" && value !== null && "__eclipsa_content_collection__" in value && value["__eclipsa_content_collection__"] === true;
+const resolveCollections = async ({ collectionsModule, configPath, root }) => {
+	const byCollection = /* @__PURE__ */ new Map();
+	const entriesByCollection = /* @__PURE__ */ new Map();
+	const markdownByCollectionName = /* @__PURE__ */ new Map();
+	const searchByCollectionName = /* @__PURE__ */ new Map();
+	const definedCollections = Object.entries(collectionsModule).filter((entry) => isDefinedCollection(entry[1]));
+	for (const [collectionName, definition] of definedCollections) {
+		const context = {
+			collection: collectionName,
+			configPath,
+			root
+		};
+		const rawEntries = await resolveLoaderEntries(collectionName, definition.loader, context);
+		const resolvedEntries = await Promise.all(rawEntries.map((entry, index) => normalizeResolvedEntry(collectionName, definition.schema, entry, index)));
+		resolvedEntries.sort((left, right) => left.id.localeCompare(right.id));
+		const entriesById = /* @__PURE__ */ new Map();
+		for (const entry of resolvedEntries) {
+			if (entriesById.has(entry.id)) throw new ContentCollectionError(`Duplicate content id "${entry.id}" in collection "${collectionName}".`);
+			entriesById.set(entry.id, entry);
+		}
+		byCollection.set(definition, resolvedEntries);
+		entriesByCollection.set(definition, entriesById);
+		markdownByCollectionName.set(collectionName, definition.markdown);
+		searchByCollectionName.set(collectionName, resolveContentSearchOptions(definition.search));
+	}
+	return {
+		collections: byCollection,
+		markdownByCollectionName,
+		searchByCollectionName,
+		entriesByCollection
+	};
+};
+const createContentRenderer = (html) => (props = {}) => ({
+	isStatic: false,
+	props: {
+		...props,
+		dangerouslySetInnerHTML: html
+	},
+	type: props.as ?? "article"
+});
+const resolveOxContentNapiPath = () => {
+	const resolvePaths = [process.cwd(), path.join(process.cwd(), "node_modules", "@eclipsa", "content")];
+	try {
+		return require.resolve("@ox-content/napi", { paths: resolvePaths });
+	} catch {
+		return "@ox-content/napi";
+	}
+};
+const loadMarkdownTransform = async () => {
+	markdownTransform ??= require(resolveOxContentNapiPath()).transform;
+	return markdownTransform;
+};
+const decodeHtmlEntities = (value) => value.replaceAll("&amp;", "&").replaceAll("&lt;", "<").replaceAll("&gt;", ">").replaceAll("&quot;", "\"").replaceAll("&#39;", "'").replaceAll("&nbsp;", " ");
+const stripHtml = (html) => decodeHtmlEntities(html.replaceAll(/<style[\s\S]*?<\/style>/gu, " ").replaceAll(/<script[\s\S]*?<\/script>/gu, " ").replaceAll(/<[^>]+>/gu, " ").replaceAll(/\s+/gu, " ").trim());
+const extractMarkdownCode = (source) => {
+	const codeBlocks = /* @__PURE__ */ new Set();
+	for (const match of source.matchAll(/```[\t ]*[^\n\r]*\r?\n([\s\S]*?)```/gu)) {
+		const code = match[1]?.trim();
+		if (code) codeBlocks.add(code);
+	}
+	for (const match of source.matchAll(/`([^`\n\r]+)`/gu)) {
+		const code = match[1]?.trim();
+		if (code) codeBlocks.add(code);
+	}
+	return [...codeBlocks];
+};
+const resolveSearchUrl = (base, entry) => {
+	return `${base === "" ? "/" : base.endsWith("/") ? base : `${base}/`}${entry.collection}/${entry.id}`.replaceAll(/\/+/g, "/");
+};
+const transformMarkdownEntry = async (entry) => {
+	const result = (await loadMarkdownTransform())(entry.body, {
+		autolinks: true,
+		footnotes: true,
+		gfm: true,
+		sourcePath: entry.filePath,
+		strikethrough: true,
+		tables: true,
+		taskLists: true,
+		tocMaxDepth: 6
+	});
+	if (result.errors.length > 0) throw new ContentCollectionError(`Failed to render markdown for ${entry.filePath}: ${result.errors.join("; ")}`);
+	return result;
+};
+const createSearchDocument = async (entry, base) => {
+	const result = await transformMarkdownEntry(entry);
+	const headings = result.toc.map((heading) => heading.text);
+	const title = typeof entry.data.title === "string" ? entry.data.title : result.toc.find((heading) => heading.depth === 1)?.text ?? entry.id;
+	return {
+		body: stripHtml(result.html),
+		code: extractMarkdownCode(entry.body),
+		collection: entry.collection,
+		headings,
+		id: entry.id,
+		title,
+		url: resolveSearchUrl(base, entry)
+	};
+};
+const renderMarkdown = async (entry, markdownOptions) => {
+	const result = await transformMarkdownEntry(entry);
+	const headings = result.toc.map((heading) => ({
+		depth: heading.depth,
+		slug: heading.slug,
+		text: heading.text
+	}));
+	const html = await highlightHtml(result.html, markdownOptions?.highlight);
+	return {
+		Content: createContentRenderer(html),
+		headings,
+		html
+	};
+};
+const createContentSearch = async ({ collectionsModule, configPath, root, base }) => {
+	const manifest = await resolveCollections({
+		collectionsModule,
+		configPath,
+		root
+	});
+	const documents = [];
+	let resolvedOptions = resolveContentSearchOptions(false);
+	for (const entries of manifest.collections.values()) {
+		const collectionName = entries[0]?.collection;
+		if (!collectionName) continue;
+		const searchOptions = manifest.searchByCollectionName.get(collectionName);
+		if (!searchOptions?.enabled) continue;
+		if (!resolvedOptions.enabled) resolvedOptions = searchOptions;
+		for (const entry of entries) documents.push(await createSearchDocument(entry, base));
+	}
+	return {
+		index: buildContentSearchIndex(documents, resolvedOptions),
+		options: resolvedOptions
+	};
+};
+const createContentRuntime = ({ collectionsModule, configPath, root }) => {
+	let manifestPromise = null;
+	const renderCache = /* @__PURE__ */ new Map();
+	const getManifest = () => {
+		manifestPromise ??= resolveCollections({
+			collectionsModule,
+			configPath,
+			root
+		});
+		return manifestPromise;
+	};
+	return {
+		async getCollection(collection, filter) {
+			const entries = (await getManifest()).collections.get(collection) ?? [];
+			if (!filter) return [...entries];
+			const filtered = [];
+			for (const entry of entries) if (await filter(entry)) filtered.push(entry);
+			return filtered;
+		},
+		async getEntries(entries) {
+			const manifest = await getManifest();
+			return entries.map((entry) => {
+				return manifest.entriesByCollection.get(entry.collection)?.get(entry.id);
+			});
+		},
+		async getEntry(collection, id) {
+			return (await getManifest()).entriesByCollection.get(collection)?.get(id);
+		},
+		async render(entry) {
+			const key = `${entry.collection}:${entry.id}`;
+			const cached = renderCache.get(key);
+			if (cached) return cached;
+			const rendered = await renderMarkdown(entry, (await getManifest()).markdownByCollectionName.get(entry.collection));
+			renderCache.set(key, rendered);
+			return rendered;
+		}
+	};
+};
+//#endregion
+export { resolveCollections as a, resolveContentSearchOptions as c, parseFrontmatter as i, createContentRuntime as n, toEntryIdFromRelativePath as o, createContentSearch as r, generateContentSearchRuntimeModule as s, ContentCollectionError as t };
+
+//# sourceMappingURL=internal-h0upzIHm.mjs.map