methanol 0.0.14 → 0.0.16

package/index.js

@@ -19,6 +19,7 @@
  */
 
 import { HTMLRenderer } from './src/renderer.js'
+export { extractExcerpt } from './src/text-utils.js'
 
 export { env } from './src/reframe.js'
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "methanol",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "description": "Static site generator powered by rEFui and MDX",
   "main": "./index.js",
   "type": "module",

package/src/build-system.js

@@ -147,6 +147,7 @@ export const buildHtmlEntries = async () => {
 			}
 		}
 		pagesContext.refreshPagesTree?.()
+		state.PAGES_CONTEXT = pagesContext
 
 		const titleSnapshot = pages.map((page) => page.title)
 		await runWorkerStage({

package/src/client/virtual-module/assets.js

@@ -21,14 +21,15 @@
 import { readFileSync } from 'fs'
 import { fileURLToPath } from 'url'
 import { dirname, resolve } from 'path'
-import { cached } from '../../utils.js'
+import { cached, cachedStr } from '../../utils.js'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = dirname(__filename)
 
-const readStatic = (filePath) => cached(() => readFileSync(resolve(__dirname, filePath), 'utf-8'))
+export const virtualModuleDir = __dirname
+export const createStaticResource = (filePath) => cached(() => readFileSync(resolve(__dirname, filePath), 'utf-8'))
 
-export const INJECT_SCRIPT = readStatic('./inject.js')
-export const LOADER_SCRIPT = readStatic('./loader.js')
-export const PAGEFIND_LOADER_SCRIPT = readStatic('./pagefind-loader.js')
-export const PWA_INJECT_SCRIPT = readStatic('./pwa-inject.js')
+export const INJECT_SCRIPT = createStaticResource('./inject.js')
+export const LOADER_SCRIPT = createStaticResource('./loader.js')
+export const PAGEFIND_LOADER_SCRIPT = createStaticResource('./pagefind-loader.js')
+export const PWA_INJECT_SCRIPT = createStaticResource('./pwa-inject.js')

package/src/config.js

@@ -20,9 +20,10 @@
 
 import { readFile } from 'fs/promises'
 import { existsSync } from 'fs'
-import { resolve, isAbsolute, extname, basename } from 'path'
-import { pathToFileURL } from 'url'
+import { resolve, isAbsolute, extname, basename, dirname } from 'path'
+import { pathToFileURL, fileURLToPath } from 'url'
 import { mergeConfig } from 'vite'
+import { projectRequire } from './node-loader.js'
 import { cli, state } from './state.js'
 import { logger } from './logger.js'
 import { HTMLRenderer } from './renderer.js'
@@ -239,6 +240,34 @@ const buildConfigContext = (mode) => ({
 	HTMLRenderer
 })
 
+const resolveTheme = async (themeValue, root) => {
+	if (typeof themeValue !== 'string') return themeValue
+
+	const load = async (p) => {
+		const mod = await import(pathToFileURL(p).href)
+		const fn = mod.default ?? mod
+		return typeof fn === 'function' ? fn() : fn
+	}
+
+	// 1. Check Methanol themes dir
+	const __dirname = dirname(fileURLToPath(import.meta.url))
+	const builtInPath = resolve(__dirname, '../themes', themeValue, 'index.js')
+	if (existsSync(builtInPath)) {
+		return load(builtInPath)
+	}
+
+	// 2. Resolve methanol-theme-<name> from user dir
+	try {
+		const pkgName = `methanol-theme-${themeValue}`
+		const pkgPath = projectRequire.resolve(pkgName)
+		return load(pkgPath)
+	} catch (e) {
+		// Ignore
+	}
+
+	throw new Error(`Theme not found: ${themeValue}`)
+}
+
 export const loadUserConfig = async (mode, configPath = null) => {
 	if (configPath) {
 		const filePath = resolveConfigPath(configPath)
@@ -323,7 +352,8 @@ export const applyConfig = async (config, mode) => {
 
 	state.VIRTUAL_HTML_OUTPUT_ROOT = state.PAGES_DIR
 
-	state.USER_THEME = config.theme || await defaultTheme()
+	const themeValue = cli.CLI_THEME || config.theme
+	state.USER_THEME = themeValue ? await resolveTheme(themeValue, root) : await defaultTheme()
 	if (!state.USER_THEME?.root && !config.theme?.root) {
 		throw new Error('Theme root is required.')
 	}

package/src/dev-server.js

@@ -38,13 +38,16 @@ import {
 } from './components.js'
 import { buildPagesContext, buildPageEntry, routePathFromFile } from './pages.js'
 import { compilePageMdx, renderHtml } from './mdx.js'
+import { DevErrorPage } from './error-page.jsx'
+import { HTMLRenderer } from './renderer.js'
 import { methanolResolverPlugin } from './vite-plugins.js'
 import { preparePublicAssets, updateAsset } from './public-assets.js'
 import { createBuildWorkers, runWorkerStage, terminateWorkers } from './workers/build-pool.js'
+import { virtualModuleDir } from './client/virtual-module/assets.js'
 import { style } from './logger.js'
 
 export const runViteDev = async () => {
-	const baseFsAllow = [state.ROOT_DIR, state.USER_THEME.root].filter(Boolean)
+	const baseFsAllow = [virtualModuleDir, state.ROOT_DIR, state.USER_THEME.root].filter(Boolean)
 	if (state.MERGED_ASSETS_DIR) {
 		baseFsAllow.push(state.MERGED_ASSETS_DIR)
 	}
@@ -143,6 +146,7 @@ export const runViteDev = async () => {
 	let pagesContextToken = 0
 	const setPagesContext = (next) => {
 		pagesContext = next
+		state.PAGES_CONTEXT = next
 		pagesContextToken += 1
 	}
 	setPagesContext(await buildPagesContext({ compileAll: false }))
@@ -159,10 +163,54 @@ export const runViteDev = async () => {
 		console.error(style.red(`\n[methanol] ${phase} error in ${target}`))
 		console.error(error?.stack || error)
 	}
+	const formatDevError = (error) => {
+		if (!error) return 'Unknown error'
+		if (typeof error === 'string') return error
+		if (error?.stack) return error.stack
+		if (error?.message) return error.message
+		return String(error)
+	}
+	const sendDevError = async (res, error, url = '/') => {
+		const message = formatDevError(error)
+		const basePrefix = devBasePrefix || ''
+		const rawHtml = HTMLRenderer.serialize(
+			DevErrorPage({ message, basePrefix })(HTMLRenderer)
+		)
+		let html = rawHtml
+		try {
+			html = await server.transformIndexHtml(url, rawHtml)
+		} catch (err) {
+			console.error(err)
+		}
+		res.statusCode = 500
+		res.setHeader('Content-Type', 'text/html')
+		res.end(html)
+	}
+
+	const _invalidate = (id) => {
+		const _module = server.moduleGraph.getModuleById(id)
+		if (_module) {
+			server.moduleGraph.invalidateModule(_module)
+		}
+	}
+	const invalidateReframeInject = () => {
+		_invalidate('\0methanol:registry')
+		_invalidate('\0methanol:inject')
+		_invalidate(resolve(virtualModuleDir, 'inject.js'))
+	}
+	const invalidatePagesIndex = () => {
+		_invalidate('\0methanol:pages')
+	}
 
 	const refreshPagesContext = async () => {
 		setPagesContext(await buildPagesContext({ compileAll: false }))
 	}
+	const resolveStaticCandidate = (baseDir, pathname) => {
+		if (!baseDir) return null
+		const target = resolve(baseDir, pathname.replace(/^\//, ''))
+		if (!target.startsWith(baseDir)) return null
+		return target
+	}
 
 	const prebuildHtmlCache = async (token) => {
 		if (!pagesContext || token !== pagesContextToken) return
@@ -214,6 +262,7 @@ export const runViteDev = async () => {
 				}
 			}
 			pagesContext.refreshPagesTree?.()
+			invalidatePagesIndex()
 			invalidateHtmlCache()
 			const renderEpoch = htmlCacheEpoch
 
@@ -383,7 +432,14 @@ export const runViteDev = async () => {
 		const requestedPath = routePath
 		if (pathname.includes('.') && !pathname.endsWith('.html')) {
 			if (!pagesContext?.pagesByRoute?.has(requestedPath)) {
-				return next()
+				const pageCandidate = resolveStaticCandidate(state.PAGES_DIR, pathname)
+				if (pageCandidate && existsSync(pageCandidate)) {
+					return next()
+				}
+				const staticCandidate = resolveStaticCandidate(state.STATIC_DIR, pathname)
+				if (staticCandidate && existsSync(staticCandidate)) {
+					return next()
+				}
 			}
 		}
 		const isExcludedPath = () => {
@@ -429,8 +485,7 @@ export const runViteDev = async () => {
 					return
 				} catch (err) {
 					console.error(err)
-					res.statusCode = 500
-					res.end('Internal Server Error')
+					await sendDevError(res, err, req.url)
 					return
 				}
 			}
@@ -487,8 +542,7 @@ export const runViteDev = async () => {
 				})
 			} catch (err) {
 				logMdxError('MDX render', err, pageMeta || { path, routePath: renderRoutePath })
-				res.statusCode = 500
-				res.end('Internal Server Error')
+				await sendDevError(res, err, req.url)
 				return
 			}
 			if (renderEpoch === htmlCacheEpoch) {
@@ -504,8 +558,7 @@ export const runViteDev = async () => {
 			res.end(html)
 		} catch (err) {
 			logMdxError('MDX render', err, pageMeta || { path, routePath: renderRoutePath })
-			res.statusCode = 500
-			res.end('Internal Server Error')
+			await sendDevError(res, err, req.url)
 		}
 	}
 
@@ -518,19 +571,6 @@ export const runViteDev = async () => {
 	await server.listen()
 	server.printUrls()
 
-	const _invalidate = (id) => {
-		const _module = server.moduleGraph.getModuleById(id)
-		if (_module) {
-			server.moduleGraph.invalidateModule(_module)
-		}
-	}
-	const invalidateRewindInject = () => {
-		_invalidate('\0/.methanol_virtual_module/registry.js')
-		_invalidate('\0methanol:registry')
-		_invalidate('\0/.methanol_virtual_module/inject.js')
-		_invalidate('\0methanol:inject')
-	}
-
 	let queue = Promise.resolve()
 	const enqueue = (task) => {
 		queue = queue.then(task).catch((err) => {
@@ -547,6 +587,7 @@ export const runViteDev = async () => {
 
 	const refreshPages = async () => {
 		await refreshPagesContext()
+		invalidatePagesIndex()
 		invalidateHtmlCache()
 		reload()
 	}
@@ -700,6 +741,7 @@ export const runViteDev = async () => {
 		}
 		const updated = await updatePageEntry(path, resolved)
 		if (updated) {
+			invalidatePagesIndex()
 			invalidateHtmlCache()
 			reload()
 			return
@@ -740,7 +782,7 @@ export const runViteDev = async () => {
 			enqueue(async () => {
 				const { hasClient } = await updateComponentEntry(path)
 				if (hasClient) {
-					invalidateRewindInject()
+					invalidateReframeInject()
 				}
 				invalidateHtmlCache()
 				reload()
@@ -751,7 +793,7 @@ export const runViteDev = async () => {
 			const { hasClient } = await updateComponentEntry(path)
 			invalidateHtmlCache()
 			if (hasClient) {
-				invalidateRewindInject()
+				invalidateReframeInject()
 			}
 			reload()
 		})
@@ -772,7 +814,7 @@ export const runViteDev = async () => {
 			const { hasClient } = await updateComponentEntry(path)
 			invalidateHtmlCache()
 			if (hasClient) {
-				invalidateRewindInject()
+				invalidateReframeInject()
 			}
 			reload()
 		})
@@ -783,7 +825,7 @@ export const runViteDev = async () => {
 		if (isClientComponent(path)) {
 			enqueue(async () => {
 				await updateComponentEntry(path, { fallback: true })
-				invalidateRewindInject()
+				invalidateReframeInject()
 				invalidateHtmlCache()
 				reload()
 			})
@@ -800,7 +842,7 @@ export const runViteDev = async () => {
 			})
 			invalidateHtmlCache()
 			if (hasClient) {
-				invalidateRewindInject()
+				invalidateReframeInject()
 			}
 			reload()
 		})

package/src/error-page.jsx

@@ -0,0 +1,49 @@
+/* Copyright Yukino Song, SudoMaker Ltd.
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ * 	http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import { HTMLRenderer as R } from './renderer.js'
+
+export const DevErrorPage = ({ message = '', basePrefix = ''} = {}) => (
+	<>
+		{R.rawHTML`<!doctype html>`}
+		<html lang="en">
+			<head>
+				<meta charset="UTF-8" />
+				<meta name="viewport" content="width=device-width, initial-scale=1" />
+				<title>Methanol dev error</title>
+				<style>{`
+					body { margin: 0; font-family: ui-sans-serif, system-ui, sans-serif; background: #0f1115; color: #e9edf1; }
+					.main { padding: 24px; max-width: 960px; }
+					h1 { margin: 0 0 12px; font-size: 20px; }
+					pre { white-space: pre-wrap; background: #151922; padding: 16px; border-radius: 8px; border: 1px solid #2a2f3a; }
+					.note { color: #9aa3ad; font-size: 12px; margin-top: 12px; }
+				`}</style>
+			</head>
+			<body>
+				<div class="main">
+					<h1>Dev server error</h1>
+					<pre>{message}</pre>
+					<div class="note">Fix the error and save to reload.</div>
+				</div>
+			</body>
+		</html>
+	</>
+)
+

package/src/mdx.js

@@ -25,6 +25,7 @@ import rehypeSlug from 'rehype-slug'
 import extractToc from '@stefanprobst/rehype-extract-toc'
 import withTocExport from '@stefanprobst/rehype-extract-toc/mdx'
 import rehypeStarryNight from 'rehype-starry-night'
+import { createStarryNight } from '@wooorm/starry-night'
 import remarkGfm from 'remark-gfm'
 import { HTMLRenderer } from './renderer.js'
 import { signal, computed, read, Suspense, nextTick } from 'refui'
@@ -36,10 +37,12 @@ import { state } from './state.js'
 import { resolveUserMdxConfig, withBase } from './config.js'
 import { methanolCtx } from './rehype-plugins/methanol-ctx.js'
 import { linkResolve } from './rehype-plugins/link-resolve.js'
+import { cached } from './utils.js'
 
 // Workaround for Vite: it doesn't support resolving module/virtual modules in script src in dev mode
-const resolveRewindInject = () =>
+const resolveRewindInject = cached(() =>
 	HTMLRenderer.rawHTML(`<script type="module" src="${withBase('/.methanol_virtual_module/inject.js')}"></script>`)
+)
 const RWND_FALLBACK = HTMLRenderer.rawHTML(
 	'<script>if(!window.$$rfrm){var l=[];var r=function(k,i,p){l.push([k,i,p,document.currentScript])};r.$$loaded=l;window.$$rfrm=r}</script>'
 )
@@ -219,16 +222,228 @@ const normalizeStarryNightConfig = (value) => {
 const resolveStarryNightForPage = (frontmatter) => {
 	const base = {
 		enabled: state.STARRY_NIGHT_ENABLED === true,
-		options: state.STARRY_NIGHT_OPTIONS || null
+		options: state.STARRY_NIGHT_OPTIONS || null,
+		explicit: false
 	}
 	if (!frontmatter || !Object.prototype.hasOwnProperty.call(frontmatter, 'starryNight')) {
 		return base
 	}
-	const override = normalizeStarryNightConfig(frontmatter.starryNight)
+	const overrideValue = frontmatter.starryNight
+	if (typeof overrideValue === 'boolean') {
+		if (overrideValue === false) {
+			return { enabled: false, options: null, explicit: true }
+		}
+		return { enabled: true, options: base.options, explicit: false }
+	}
+	if (!overrideValue || typeof overrideValue !== 'object') {
+		return base
+	}
+	const override = normalizeStarryNightConfig(overrideValue)
 	if (!override) return base
-	if (override.enabled === false) return { enabled: false, options: null }
+	if (override.enabled === false) return { enabled: false, options: null, explicit: true }
 	const options = override.options != null ? override.options : base.options
-	return { enabled: true, options }
+	return { enabled: true, options, explicit: true }
+}
+
+const CODE_FENCE_LANG_PATTERN = /(^|\n)\s*(```|~~~)\s*([^\s{]+)/g
+const extractCodeFenceLanguages = (value) => {
+	const text = String(value || '')
+	const languages = new Set()
+	CODE_FENCE_LANG_PATTERN.lastIndex = 0
+	let match
+	while ((match = CODE_FENCE_LANG_PATTERN.exec(text))) {
+		let lang = match[3] ? String(match[3]).trim() : ''
+		if (!lang) continue
+		const braceIndex = lang.indexOf('{')
+		if (braceIndex >= 0) {
+			lang = lang.slice(0, braceIndex).trim()
+		}
+		if (!lang || !/[A-Za-z]/.test(lang)) continue
+		languages.add(lang.toLowerCase())
+	}
+	return languages
+}
+const cleanStarryOptions = (options) => {
+	if (!options || typeof options !== 'object') return undefined
+	const next = { ...options }
+	delete next.grammars
+	return next
+}
+let starryNightFuture = null
+const resolvedGrammarCache = new Map()
+const resolvedCustomGrammarCache = new Map()
+const failedLanguageCache = new Set()
+const failedCustomLanguageCache = new Map()
+const loadStarryNight = async (options) => {
+	if (!starryNightFuture) {
+		starryNightFuture = import('@wooorm/starry-night').then(async (mod) => {
+			const grammars = Array.isArray(mod?.all) ? mod.all : []
+			const starryNight = await createStarryNight(grammars, cleanStarryOptions(options))
+			return {
+				starryNight,
+				grammars,
+				scopeMap: buildScopeGrammarMap(grammars)
+			}
+		})
+	}
+	return starryNightFuture
+}
+const buildScopeGrammarMap = (grammars) => {
+	const scopeMap = new Map()
+	for (const grammar of grammars || []) {
+		const scopeName = grammar?.scopeName
+		if (typeof scopeName === 'string' && scopeName) {
+			scopeMap.set(scopeName, grammar)
+		}
+	}
+	return scopeMap
+}
+const collectExternalScopes = (grammar) => {
+	const scopes = new Set()
+	const addScope = (value) => {
+		if (typeof value !== 'string') return
+		if (!value || value.startsWith('#')) return
+		scopes.add(value)
+	}
+	const visit = (node) => {
+		if (!node) return
+		if (Array.isArray(node)) {
+			for (const item of node) {
+				visit(item)
+			}
+			return
+		}
+		if (typeof node !== 'object') return
+		if (typeof node.include === 'string') {
+			addScope(node.include)
+		}
+		for (const value of Object.values(node)) {
+			visit(value)
+		}
+	}
+	if (Array.isArray(grammar?.dependencies)) {
+		for (const dep of grammar.dependencies) {
+			addScope(dep)
+		}
+	}
+	visit(grammar?.patterns)
+	visit(grammar?.repository)
+	return scopes
+}
+const resolveStarryNightGrammars = async (languages, options) => {
+	const hasCustomGrammars = Array.isArray(options?.grammars)
+	const baseGrammars = hasCustomGrammars ? options.grammars : null
+	if (hasCustomGrammars && (!baseGrammars || !baseGrammars.length)) return null
+	const getCustomKey = (grammars) =>
+		(grammars || [])
+			.map((grammar) => grammar?.scopeName)
+			.filter(Boolean)
+			.sort()
+			.join('|')
+	const failedSet = hasCustomGrammars
+		? (() => {
+				const customKey = getCustomKey(baseGrammars)
+				let set = failedCustomLanguageCache.get(customKey)
+				if (!set) {
+					set = new Set()
+					failedCustomLanguageCache.set(customKey, set)
+				}
+				return set
+			})()
+		: failedLanguageCache
+	const filteredLanguages = Array.from(languages || [])
+		.map((lang) => String(lang).toLowerCase())
+		.filter((lang) => lang && !failedSet.has(lang))
+	const languageKey = filteredLanguages.slice().sort().join('|')
+	if (!languageKey) return []
+	if (hasCustomGrammars) {
+		const customKey = getCustomKey(baseGrammars)
+		const customCache = resolvedCustomGrammarCache.get(customKey)
+		if (customCache?.has(languageKey)) {
+			return customCache.get(languageKey)
+		}
+	} else if (resolvedGrammarCache.has(languageKey)) {
+		return resolvedGrammarCache.get(languageKey)
+	}
+	const selected = new Set()
+	const selectedScopes = new Set()
+	let scopeMap = baseGrammars ? buildScopeGrammarMap(baseGrammars) : null
+	let loadedStarryNight = null
+	const ensureAll = async () => {
+		if (!loadedStarryNight && !hasCustomGrammars) {
+			loadedStarryNight = await loadStarryNight(options)
+			if (!scopeMap) {
+				scopeMap = loadedStarryNight?.scopeMap || null
+			}
+		}
+	}
+	let flagToScope = null
+	if (hasCustomGrammars) {
+		const customStarryNight = await createStarryNight(baseGrammars, cleanStarryOptions(options))
+		flagToScope = (lang) => customStarryNight.flagToScope(String(lang))
+	} else {
+		try {
+			await ensureAll()
+		} catch {
+			for (const lang of filteredLanguages) {
+				failedSet.add(lang)
+			}
+			return []
+		}
+		flagToScope = (lang) => loadedStarryNight?.starryNight.flagToScope(String(lang))
+	}
+	if (!scopeMap) return null
+	const addGrammar = (grammar) => {
+		if (!grammar) return false
+		const scopeName = grammar.scopeName
+		if (!scopeName || selectedScopes.has(scopeName)) return false
+		selectedScopes.add(scopeName)
+		selected.add(grammar)
+		return true
+	}
+	for (const lang of filteredLanguages) {
+		let scope
+		try {
+			scope = flagToScope ? flagToScope(String(lang)) : undefined
+		} catch {
+			scope = undefined
+		}
+		const grammar = scope && scopeMap ? scopeMap.get(scope) : null
+		if (!grammar) {
+			failedSet.add(lang)
+		}
+		addGrammar(grammar)
+	}
+	if (!selected.size) return []
+	const queue = Array.from(selected)
+	while (queue.length) {
+		const grammar = queue.pop()
+		const scopes = collectExternalScopes(grammar)
+		for (const scope of scopes) {
+			if (selectedScopes.has(scope)) continue
+			let depGrammar = scopeMap ? scopeMap.get(scope) : null
+			if (!depGrammar && !hasCustomGrammars) {
+				await ensureAll()
+				depGrammar = scopeMap ? scopeMap.get(scope) : null
+			}
+			if (addGrammar(depGrammar)) {
+				queue.push(depGrammar)
+			}
+		}
+	}
+	const result = selected.size ? Array.from(selected) : []
+	if (hasCustomGrammars) {
+		const customKey = getCustomKey(baseGrammars)
+		let customCache = resolvedCustomGrammarCache.get(customKey)
+		if (!customCache) {
+			customCache = new Map()
+			resolvedCustomGrammarCache.set(customKey, customCache)
+		}
+		customCache.set(languageKey, result)
+	} else {
+		resolvedGrammarCache.set(languageKey, result)
+	}
+	return result
 }
 
 const resolveBaseMdxConfig = async () => {
@@ -262,7 +477,7 @@ const resolveBaseMdxConfig = async () => {
 	return (cachedMdxConfig = mdxConfig)
 }
 
-const resolveMdxConfigForPage = async (frontmatter) => {
+const resolveMdxConfigForPage = async (frontmatter, content = '') => {
 	const baseConfig = await resolveBaseMdxConfig()
 	const mdxConfig = {
 		...baseConfig,
@@ -270,7 +485,19 @@ const resolveMdxConfigForPage = async (frontmatter) => {
 	}
 	const starryNightConfig = resolveStarryNightForPage(frontmatter)
 	if (!starryNightConfig.enabled) return mdxConfig
-	const plugin = starryNightConfig.options ? [rehypeStarryNight, starryNightConfig.options] : [rehypeStarryNight]
+	let options = starryNightConfig.options
+	if (!starryNightConfig.explicit) {
+		const languages = extractCodeFenceLanguages(content)
+		if (!languages.size) {
+			return mdxConfig
+		}
+		const grammars = await resolveStarryNightGrammars(languages, options)
+		if (!grammars || !grammars.length) {
+			return mdxConfig
+		}
+		options = { ...(options || {}), grammars }
+	}
+	const plugin = options ? [rehypeStarryNight, options] : [rehypeStarryNight]
 	const insertIndex = mdxConfig.rehypePlugins.indexOf(linkResolve)
 	if (insertIndex >= 0) {
 		mdxConfig.rehypePlugins.splice(insertIndex, 0, plugin)
@@ -281,7 +508,7 @@ const resolveMdxConfigForPage = async (frontmatter) => {
 }
 
 export const compileMdxSource = async ({ content, path, frontmatter }) => {
-	const mdxConfig = await resolveMdxConfigForPage(frontmatter)
+	const mdxConfig = await resolveMdxConfigForPage(frontmatter, content)
 	const compiled = await compile({ value: content, path: path }, mdxConfig)
 	const code = String(compiled.value ?? compiled)
 	return { code, development: Boolean(mdxConfig.development) }