ezal-theme-example 0.0.1

package/dist/index.js

@@ -0,0 +1,2066 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let node_path = require("node:path");
+node_path = __toESM(node_path);
+let ezal = require("ezal");
+let feed = require("feed");
+let node_path_posix = require("node:path/posix");
+node_path_posix = __toESM(node_path_posix);
+let node_fs = require("node:fs");
+let sharp = require("sharp");
+sharp = __toESM(sharp);
+let better_sqlite3 = require("better-sqlite3");
+better_sqlite3 = __toESM(better_sqlite3);
+let node_crypto = require("node:crypto");
+let node_fs_promises = require("node:fs/promises");
+let node_vibrant_node = require("node-vibrant/node");
+let indexnow = require("indexnow");
+indexnow = __toESM(indexnow);
+let ezal_layout = require("ezal-layout");
+let mime_types = require("mime-types");
+mime_types = __toESM(mime_types);
+let ezal_markdown = require("ezal-markdown");
+let __shikijs_colorized_brackets = require("@shikijs/colorized-brackets");
+let __shikijs_transformers = require("@shikijs/transformers");
+let __vscode_vscode_languagedetection = require("@vscode/vscode-languagedetection");
+let shiki = require("shiki");
+let clean_css = require("clean-css");
+clean_css = __toESM(clean_css);
+let stylus = require("stylus");
+stylus = __toESM(stylus);
+let katex = require("katex");
+katex = __toESM(katex);
+let sitemap = require("sitemap");
+let esbuild = require("esbuild");
+esbuild = __toESM(esbuild);
+
+//#region packages/ezal-theme-example/src/config.ts
+let config$1;
+function setThemeConfig(cfg) {
+	config$1 = cfg ?? {};
+}
+function getThemeConfig() {
+	return config$1;
+}
+
+//#endregion
+//#region packages/ezal-theme-example/src/utils.ts
+function compareByDate(a, b) {
+	return b.date.epochMilliseconds - a.date.epochMilliseconds;
+}
+
+//#endregion
+//#region packages/ezal-theme-example/src/feed.ts
+const FEED_TYPE_URL = {
+	rss: "/rss.xml",
+	atom: "/atom.xml",
+	feed: "/feed.json"
+};
+let author;
+let feed$1;
+let assets$1;
+var FeedAsset = class extends ezal.VirtualAssets {
+	#type;
+	constructor(type) {
+		super(FEED_TYPE_URL[type]);
+		this.#type = type;
+	}
+	build() {
+		switch (this.#type) {
+			case "rss": return feed$1.rss2();
+			case "atom": return feed$1.atom1();
+			case "feed": return feed$1.json1();
+			default: return "";
+		}
+	}
+	onDependenciesChanged() {}
+};
+function initFeed() {
+	const { site } = (0, ezal.getConfig)();
+	const theme$1 = getThemeConfig();
+	const since = theme$1.since?.year;
+	author = {
+		name: site.author,
+		link: site.domain
+	};
+	feed$1 = new feed.Feed({
+		title: site.title,
+		description: site.description,
+		id: site.domain,
+		language: site.language,
+		favicon: theme$1.favicon?.[0],
+		copyright: `© ${since ? `${since}-` : ""}${(/* @__PURE__ */ new Date()).getFullYear()} ${site.author}`,
+		author,
+		updated: /* @__PURE__ */ new Date(),
+		feedLinks: {
+			rss: `${site.domain}/rss.xml`,
+			atom: `${site.domain}/atom.xml`,
+			json: `${site.domain}/feed.json`
+		}
+	});
+	assets$1 = {
+		rss: new FeedAsset("rss"),
+		atom: new FeedAsset("atom"),
+		feed: new FeedAsset("feed")
+	};
+	for (const article of ezal.Article.getAll().sort(compareByDate)) updateFeedItem(article);
+	for (const category of ezal.Category.getAll()) updateFeedCategory(category);
+}
+function refreshAsset() {
+	if (!assets$1) return;
+	assets$1.rss.invalidated();
+	assets$1.atom.invalidated();
+	assets$1.feed.invalidated();
+}
+function updateFeedItem(article) {
+	if (!feed$1) return;
+	const i = feed$1.items.findIndex((item$1) => item$1.id === article.id);
+	if (article.destroyed) {
+		if (i === -1) return;
+		feed$1.items.splice(i, 1);
+		return refreshAsset();
+	}
+	const { site } = (0, ezal.getConfig)();
+	let image$1 = article.data?.cover ? ezal.URL.resolve(article.url, article.data.cover) : void 0;
+	if (image$1) image$1 = site.domain + image$1;
+	const item = {
+		title: article.title,
+		id: article.id,
+		link: site.domain + article.url,
+		description: article.description,
+		content: article.content,
+		author: [author],
+		date: new Date(article.date.toInstant().epochMilliseconds),
+		image: image$1,
+		category: article.categories.values().toArray().map((category) => ({ name: category.path.join("/") }))
+	};
+	if (i === -1) feed$1.addItem(item);
+	else feed$1.items[i] = item;
+	refreshAsset();
+}
+function updateFeedCategory(category) {
+	if (!feed$1) return;
+	const name = category.path.join("/");
+	const i = feed$1.categories.indexOf(name);
+	if (category.destroyed) {
+		if (i === -1) return;
+		feed$1.categories.splice(i, 1);
+		return refreshAsset();
+	}
+	if (i !== -1) return;
+	feed$1.addCategory(name);
+	refreshAsset();
+}
+
+//#endregion
+//#region packages/ezal-theme-example/src/image/utils.ts
+let dir;
+function getCacheDir() {
+	if (dir) return dir;
+	dir = getThemeConfig().imageCache?.optimized ?? "cache";
+	if (!node_path.default.isAbsolute(dir)) dir = node_path.default.resolve(dir);
+	return dir;
+}
+function getOptimizedPath(filepath, ext) {
+	const dir$1 = getCacheDir();
+	const cachePath = node_path.default.relative(process.cwd(), filepath);
+	return `${node_path.default.join(dir$1, cachePath)}.opt${ext}`;
+}
+
+//#endregion
+//#region packages/ezal-theme-example/src/image/asset.ts
+const OPTIMIZE = {
+	".avif": (sharp$1) => sharp$1.avif().toBuffer(),
+	".webp": (sharp$1) => sharp$1.webp().toBuffer(),
+	".jxl": (sharp$1) => sharp$1.jxl().toBuffer(),
+	".jpg": (sharp$1) => sharp$1.jpeg({
+		trellisQuantisation: true,
+		overshootDeringing: true,
+		progressive: true,
+		optimiseScans: true
+	}).toBuffer(),
+	".png": (sharp$1) => sharp$1.png({
+		progressive: true,
+		adaptiveFiltering: true
+	}).toBuffer(),
+	".gif": (sharp$1) => sharp$1.gif().toBuffer()
+};
+var OptimizedImage = class extends ezal.VirtualAssets {
+	#optimizedPath;
+	#filepath;
+	#ext;
+	/**
+	* @param asset 源资源
+	* @param target 目标优化格式
+	*/
+	constructor(asset$2, ext) {
+		super(ezal.URL.extname(asset$2.url, `.opt${ext}`));
+		this.#filepath = asset$2.filepath;
+		this.#ext = ext;
+		this.#optimizedPath = getOptimizedPath(this.#filepath, ext);
+	}
+	async build() {
+		if (await ezal.fs.isFile(this.#optimizedPath)) return (0, node_fs.createReadStream)(this.#optimizedPath);
+		const sharp$1 = (0, sharp.default)(this.#filepath);
+		const buffer = await OPTIMIZE[this.#ext](sharp$1);
+		ezal.fs.writeFile(this.#optimizedPath, buffer);
+		return buffer;
+	}
+	onDependenciesChanged() {}
+};
+
+//#endregion
+//#region packages/ezal-theme-example/src/image/db.ts
+let db;
+let statements;
+function getMetadata(url) {
+	return statements.get.get(url);
+}
+function updateMetadata(data) {
+	return statements.update.run(data.path, data.hash, data.width, data.height, data.color).changes !== 0;
+}
+function deleteMetadata(url) {
+	return statements.delete.run(url).changes !== 0;
+}
+function initImageMetadataDB() {
+	let filename = getThemeConfig().imageCache?.metadata ?? "image-metadata.sqlite";
+	if (!node_path.default.isAbsolute(filename)) filename = node_path.default.resolve(filename);
+	db = new better_sqlite3.default(filename);
+	db.exec(`CREATE TABLE IF NOT EXISTS image_metadata (
+		path TEXT PRIMARY KEY,
+		hash TEXT NOT NULL,
+		width INTEGER NOT NULL,
+		height INTEGER NOT NULL,
+		color TEXT(8)
+	)`);
+	statements = {
+		get: db.prepare("SELECT * FROM image_metadata WHERE path = ?"),
+		delete: db.prepare("DELETE FROM image_metadata WHERE path = ?"),
+		update: db.prepare(`INSERT OR REPLACE INTO image_metadata
+			(path, hash, width, height, color)
+			VALUES (?, ?, ?, ?, ?)
+		`)
+	};
+}
+const imageDB = {
+	init: initImageMetadataDB,
+	get: getMetadata,
+	update: updateMetadata,
+	delete: deleteMetadata
+};
+
+//#endregion
+//#region packages/ezal-theme-example/src/image/metadata.ts
+async function updateImageMetadata(asset$2) {
+	const buffer = await (0, node_fs_promises.readFile)(asset$2.filepath);
+	const hash = (0, node_crypto.createHash)("sha256").update(buffer).digest("hex");
+	if (imageDB.get(asset$2.url)?.hash === hash) return false;
+	const { width, height, format } = await (0, sharp.default)(buffer).metadata();
+	let color = null;
+	if (format !== "svg") try {
+		color = (await node_vibrant_node.Vibrant.from(buffer).getPalette()).Muted?.hex ?? null;
+	} catch {}
+	const metadata = {
+		path: asset$2.url,
+		hash,
+		width,
+		height,
+		color
+	};
+	imageDB.update(metadata);
+	return true;
+}
+
+//#endregion
+//#region packages/ezal-theme-example/src/image/index.ts
+const INFO = {
+	ADD: "Add image file:",
+	UPDATE: "Update image file:",
+	REMOVE: "Remove image file:",
+	OPTIMIZE: (path$8) => `The image "${path$8}" will be generated in this format:`
+};
+const ERR = { METADATA: (path$8) => `Unable to update metadata for "${path$8}"` };
+const SUPPORT_EXTS = new Set([
+	".jpeg",
+	".jpg",
+	".png",
+	".gif",
+	".webp",
+	".svg",
+	".tiff",
+	".tif",
+	".avif",
+	".heif",
+	".jxl"
+]);
+const OPTIMIZE_RULES = new Map([
+	[".jpeg", [
+		".avif",
+		".webp",
+		".jxl",
+		".jpg"
+	]],
+	[".jpg", [
+		".avif",
+		".webp",
+		".jpg"
+	]],
+	[".png", [
+		".avif",
+		".webp",
+		".png"
+	]],
+	[".webp", [
+		".avif",
+		".webp",
+		".png"
+	]],
+	[".avif", [
+		".avif",
+		".webp",
+		".png"
+	]]
+]);
+const logger$3 = new ezal.Logger("theme:image");
+const assetsMap = /* @__PURE__ */ new Map();
+function getImageInfo(url) {
+	const ext = node_path_posix.default.extname(url).toLowerCase();
+	if (!SUPPORT_EXTS.has(ext)) return null;
+	return {
+		metadata: imageDB.get(url),
+		rule: OPTIMIZE_RULES.get(ext)
+	};
+}
+async function cleanOptimized(asset$2) {
+	const ext = node_path_posix.default.extname(asset$2.filepath).toLowerCase();
+	const rule = OPTIMIZE_RULES.get(ext);
+	if (!rule) return;
+	await Promise.all(rule.map((ext$1) => getOptimizedPath(asset$2.filepath, ext$1)).map((filepath) => ezal.fs.remove(filepath)));
+}
+async function imageAddHook(asset$2) {
+	if (asset$2.level !== "user") return;
+	const ext = node_path_posix.default.extname(asset$2.filepath).toLowerCase();
+	if (!SUPPORT_EXTS.has(ext)) return;
+	logger$3.debug(INFO.ADD, asset$2.filepath);
+	let updated = false;
+	try {
+		updated = await updateImageMetadata(asset$2);
+	} catch (error) {
+		logger$3.error(ERR.METADATA(asset$2.filepath), error);
+	}
+	if (updated) await cleanOptimized(asset$2);
+	const rule = OPTIMIZE_RULES.get(ext);
+	if (!rule) return;
+	logger$3.debug(INFO.OPTIMIZE(asset$2.filepath), rule);
+	const assets$2 = rule.map((ext$1) => {
+		try {
+			return new OptimizedImage(asset$2, ext$1);
+		} catch (error) {
+			logger$3.warn(error);
+			return null;
+		}
+	}).filter((v) => v);
+	assetsMap.set(asset$2.url, assets$2);
+}
+async function imageUpdateHook(asset$2) {
+	if (asset$2.level !== "user") return;
+	const ext = node_path_posix.default.extname(asset$2.filepath).toLowerCase();
+	if (!SUPPORT_EXTS.has(ext)) return;
+	logger$3.debug(INFO.UPDATE, asset$2.filepath);
+	let updated = false;
+	try {
+		updated = await updateImageMetadata(asset$2);
+	} catch (error) {
+		logger$3.error(ERR.METADATA(asset$2.filepath), error);
+	}
+	if (updated) await cleanOptimized(asset$2);
+	const assets$2 = assetsMap.get(asset$2.url);
+	if (!assets$2) return;
+	for (const asset$3 of assets$2) asset$3.invalidated();
+}
+function imageRemoveHook(asset$2) {
+	if (asset$2.level !== "user") return;
+	const ext = node_path_posix.default.extname(asset$2.filepath).toLowerCase();
+	if (!SUPPORT_EXTS.has(ext)) return;
+	logger$3.debug(INFO.REMOVE, asset$2.filepath);
+	imageDB.delete(asset$2.filepath);
+	const assets$2 = assetsMap.get(asset$2.url);
+	if (!assets$2) return;
+	assetsMap.delete(asset$2.url);
+	for (const asset$3 of assets$2) asset$3.destroy();
+}
+
+//#endregion
+//#region packages/ezal-theme-example/src/index-now.ts
+const logger$2 = new ezal.Logger("theme:index-now");
+async function exeIndexNow() {
+	const { site } = (0, ezal.getConfig)();
+	const { indexNow } = getThemeConfig();
+	if (!indexNow) return;
+	logger$2.log("Collecting data...");
+	const urls = [];
+	for (const article of ezal.Article.getAll()) {
+		if (article.data?.robots === false) continue;
+		urls.push(site.domain + article.url);
+	}
+	for (const page of ezal.Page.getAll()) {
+		if (!page.data?.robots) continue;
+		urls.push(site.domain + page.url);
+	}
+	if (indexNow.bing) {
+		logger$2.log("Submitting urls to Bing...");
+		await new indexnow.default(indexnow.SEARCH_ENGINES.BING, indexNow.bing).submitUrls(site.domain, urls);
+	}
+	if (indexNow.yandex) {
+		logger$2.log("Submitting urls to Yandex...");
+		await new indexnow.default(indexnow.SEARCH_ENGINES.YANDEX, indexNow.yandex).submitUrls(site.domain, urls);
+	}
+	logger$2.log("Finished");
+}
+
+//#endregion
+//#region packages/ezal-theme-example/src/layout.ts
+const EXTERNAL_MODULES = Object.fromEntries([
+	"mime-types",
+	"ezal",
+	"@js-temporal/polyfill"
+].map((name) => [name, require(name)]));
+function createRenderer(template) {
+	return (page) => {
+		const { site } = (0, ezal.getConfig)();
+		const context = {
+			page,
+			site,
+			theme: getThemeConfig(),
+			getImageInfo,
+			mime: mime_types.default,
+			compareByDate
+		};
+		try {
+			return template(context);
+		} catch (error) {
+			return (0, ezal.normalizeError)(error);
+		}
+	};
+}
+async function compiler(src) {
+	try {
+		const { renderer: template, dependencies } = await (0, ezal_layout.compile)(src, EXTERNAL_MODULES);
+		return {
+			renderer: createRenderer(template),
+			dependencies
+		};
+	} catch (error) {
+		return (0, ezal.normalizeError)(error);
+	}
+}
+const layoutConfig = {
+	root: node_path.default.join(__dirname, "../layouts"),
+	compiler
+};
+
+//#endregion
+//#region packages/ezal-theme-example/src/markdown/codeblock/data.ts
+const LANGUAGE_MAP = new Map([
+	["markup", "Markup"],
+	["html", "HTML"],
+	["xml", "XML"],
+	["svg", "SVG"],
+	["mathml", "MathML"],
+	["ssml", "SSML"],
+	["atom", "Atom"],
+	["rss", "RSS"],
+	["css", "CSS"],
+	["clike", "C-like"],
+	["javascript", "JavaScript"],
+	["js", "JavaScript"],
+	["abap", "ABAP"],
+	["abnf", "ABNF"],
+	["actionscript", "ActionScript"],
+	["ada", "Ada"],
+	["agda", "Agda"],
+	["al", "AL"],
+	["antlr4", "ANTLR4"],
+	["g4", "ANTLR4"],
+	["apacheconf", "Apache Configuration"],
+	["apex", "Apex"],
+	["apl", "APL"],
+	["applescript", "AppleScript"],
+	["aql", "AQL"],
+	["arduino", "Arduino"],
+	["ino", "Arduino"],
+	["arff", "ARFF"],
+	["armasm", "ARM Assembly"],
+	["arm-asm", "ARM Assembly"],
+	["arturo", "Arturo"],
+	["art", "Arturo"],
+	["asciidoc", "AsciiDoc"],
+	["adoc", "AsciiDoc"],
+	["aspnet", "ASP.NET (C#)"],
+	["asm6502", "6502 Assembly"],
+	["asmatmel", "Atmel AVR Assembly"],
+	["autohotkey", "AutoHotkey"],
+	["autoit", "AutoIt"],
+	["avisynth", "AviSynth"],
+	["avs", "AviSynth"],
+	["avro-idl", "Avro IDL"],
+	["avdl", "Avro IDL"],
+	["awk", "AWK"],
+	["gawk", "AWK"],
+	["bash", "Bash"],
+	["sh", "Bash"],
+	["shell", "Bash"],
+	["basic", "BASIC"],
+	["batch", "Batch"],
+	["bbcode", "BBcode"],
+	["shortcode", "BBcode"],
+	["bbj", "BBj"],
+	["bicep", "Bicep"],
+	["birb", "Birb"],
+	["bison", "Bison"],
+	["bnf", "BNF"],
+	["rbnf", "BNF"],
+	["bqn", "BQN"],
+	["brainfuck", "Brainfuck"],
+	["brightscript", "BrightScript"],
+	["bro", "Bro"],
+	["bsl", "BSL (1C:Enterprise)"],
+	["oscript", "BSL (1C:Enterprise)"],
+	["c", "C"],
+	["csharp", "C#"],
+	["cs", "C#"],
+	["dotnet", "C#"],
+	["cpp", "C++"],
+	["cfscript", "CFScript"],
+	["cfc", "CFScript"],
+	["chaiscript", "ChaiScript"],
+	["cil", "CIL"],
+	["cilkc", "Cilk/C"],
+	["cilk-c", "Cilk/C"],
+	["cilkcpp", "Cilk/C++"],
+	["cilk-cpp", "Cilk/C++"],
+	["cilk", "Cilk/C++"],
+	["clojure", "Clojure"],
+	["cmake", "CMake"],
+	["cobol", "COBOL"],
+	["coffeescript", "CoffeeScript"],
+	["coffee", "CoffeeScript"],
+	["concurnas", "Concurnas"],
+	["conc", "Concurnas"],
+	["csp", "Content-Security-Policy"],
+	["cooklang", "Cooklang"],
+	["coq", "Coq"],
+	["crystal", "Crystal"],
+	["css-extras", "CSS Extras"],
+	["csv", "CSV"],
+	["cue", "CUE"],
+	["cypher", "Cypher"],
+	["d", "D"],
+	["dart", "Dart"],
+	["dataweave", "DataWeave"],
+	["dax", "DAX"],
+	["dhall", "Dhall"],
+	["diff", "Diff"],
+	["django", "Django/Jinja2"],
+	["jinja2", "Django/Jinja2"],
+	["dns-zone-file", "DNS zone file"],
+	["dns-zone", "DNS zone file"],
+	["docker", "Docker"],
+	["dockerfile", "Docker"],
+	["dot", "DOT (Graphviz)"],
+	["gv", "DOT (Graphviz)"],
+	["ebnf", "EBNF"],
+	["editorconfig", "EditorConfig"],
+	["eiffel", "Eiffel"],
+	["ejs", "EJS"],
+	["eta", "EJS"],
+	["elixir", "Elixir"],
+	["elm", "Elm"],
+	["etlua", "Embedded Lua templating"],
+	["erb", "ERB"],
+	["erlang", "Erlang"],
+	["excel-formula", "Excel Formula"],
+	["xlsx", "Excel Formula"],
+	["xls", "Excel Formula"],
+	["fsharp", "F#"],
+	["factor", "Factor"],
+	["false", "False"],
+	["firestore-security-rules", "Firestore security rules"],
+	["flow", "Flow"],
+	["fortran", "Fortran"],
+	["ftl", "FreeMarker Template Language"],
+	["gml", "GameMaker Language"],
+	["gamemakerlanguage", "GameMaker Language"],
+	["gap", "GAP (CAS)"],
+	["gcode", "G-code"],
+	["gdscript", "GDScript"],
+	["gedcom", "GEDCOM"],
+	["gettext", "gettext"],
+	["po", "gettext"],
+	["gherkin", "Gherkin"],
+	["git", "Git"],
+	["glsl", "GLSL"],
+	["gn", "GN"],
+	["gni", "GN"],
+	["linker-script", "GNU Linker Script"],
+	["ld", "GNU Linker Script"],
+	["go", "Go"],
+	["go-module", "Go module"],
+	["go-mod", "Go module"],
+	["gradle", "Gradle"],
+	["graphql", "GraphQL"],
+	["groovy", "Groovy"],
+	["haml", "Haml"],
+	["handlebars", "Handlebars"],
+	["hbs", "Handlebars"],
+	["mustache", "Handlebars"],
+	["haskell", "Haskell"],
+	["hs", "Haskell"],
+	["haxe", "Haxe"],
+	["hcl", "HCL"],
+	["hlsl", "HLSL"],
+	["hoon", "Hoon"],
+	["http", "HTTP"],
+	["hpkp", "HTTP Public-Key-Pins"],
+	["hsts", "HTTP Strict-Transport-Security"],
+	["ichigojam", "IchigoJam"],
+	["icon", "Icon"],
+	["icu-message-format", "ICU Message Format"],
+	["idris", "Idris"],
+	["idr", "Idris"],
+	["ignore", ".ignore"],
+	["gitignore", ".ignore"],
+	["hgignore", ".ignore"],
+	["npmignore", ".ignore"],
+	["inform7", "Inform 7"],
+	["ini", "Ini"],
+	["io", "Io"],
+	["j", "J"],
+	["java", "Java"],
+	["javadoc", "JavaDoc"],
+	["javadoclike", "JavaDoc-like"],
+	["javastacktrace", "Java stack trace"],
+	["jexl", "Jexl"],
+	["jolie", "Jolie"],
+	["jq", "JQ"],
+	["jsdoc", "JSDoc"],
+	["js-extras", "JS Extras"],
+	["json", "JSON"],
+	["webmanifest", "JSON"],
+	["json5", "JSON5"],
+	["jsonp", "JSONP"],
+	["jsstacktrace", "JS stack trace"],
+	["js-templates", "JS Templates"],
+	["julia", "Julia"],
+	["keepalived", "Keepalived Configure"],
+	["keyman", "Keyman"],
+	["kotlin", "Kotlin"],
+	["kt", "Kotlin"],
+	["kts", "Kotlin"],
+	["kumir", "KuMir (КуМир)"],
+	["kum", "KuMir (КуМир)"],
+	["kusto", "Kusto"],
+	["latex", "LaTeX"],
+	["tex", "LaTeX"],
+	["context", "LaTeX"],
+	["latte", "Latte"],
+	["less", "Less"],
+	["lilypond", "LilyPond"],
+	["ly", "LilyPond"],
+	["liquid", "Liquid"],
+	["lisp", "Lisp"],
+	["emacs", "Lisp"],
+	["elisp", "Lisp"],
+	["emacs-lisp", "Lisp"],
+	["livescript", "LiveScript"],
+	["llvm", "LLVM IR"],
+	["log", "Log file"],
+	["lolcode", "LOLCODE"],
+	["lua", "Lua"],
+	["magma", "Magma (CAS)"],
+	["makefile", "Makefile"],
+	["markdown", "Markdown"],
+	["md", "Markdown"],
+	["markup-templating", "Markup templating"],
+	["mata", "Mata"],
+	["matlab", "MATLAB"],
+	["maxscript", "MAXScript"],
+	["mel", "MEL"],
+	["mermaid", "Mermaid"],
+	["metafont", "METAFONT"],
+	["mizar", "Mizar"],
+	["mongodb", "MongoDB"],
+	["monkey", "Monkey"],
+	["moonscript", "MoonScript"],
+	["moon", "MoonScript"],
+	["n1ql", "N1QL"],
+	["n4js", "N4JS"],
+	["n4jsd", "N4JS"],
+	["nand2tetris-hdl", "Nand To Tetris HDL"],
+	["naniscript", "Naninovel Script"],
+	["nani", "Naninovel Script"],
+	["nasm", "NASM"],
+	["neon", "NEON"],
+	["nevod", "Nevod"],
+	["nginx", "nginx"],
+	["nim", "Nim"],
+	["nix", "Nix"],
+	["nsis", "NSIS"],
+	["objectivec", "Objective-C"],
+	["objc", "Objective-C"],
+	["ocaml", "OCaml"],
+	["odin", "Odin"],
+	["opencl", "OpenCL"],
+	["openqasm", "OpenQasm"],
+	["qasm", "OpenQasm"],
+	["oz", "Oz"],
+	["parigp", "PARI/GP"],
+	["parser", "Parser"],
+	["pascal", "Pascal"],
+	["objectpascal", "Pascal"],
+	["pascaligo", "Pascaligo"],
+	["psl", "PATROL Scripting Language"],
+	["pcaxis", "PC-Axis"],
+	["px", "PC-Axis"],
+	["peoplecode", "PeopleCode"],
+	["pcode", "PeopleCode"],
+	["perl", "Perl"],
+	["php", "PHP"],
+	["phpdoc", "PHPDoc"],
+	["php-extras", "PHP Extras"],
+	["plant-uml", "PlantUML"],
+	["plantuml", "PlantUML"],
+	["plsql", "PL/SQL"],
+	["powerquery", "PowerQuery"],
+	["pq", "PowerQuery"],
+	["mscript", "PowerQuery"],
+	["powershell", "PowerShell"],
+	["processing", "Processing"],
+	["prolog", "Prolog"],
+	["promql", "PromQL"],
+	["properties", ".properties"],
+	["protobuf", "Protocol Buffers"],
+	["pug", "Pug"],
+	["puppet", "Puppet"],
+	["pure", "Pure"],
+	["purebasic", "PureBasic"],
+	["pbfasm", "PureBasic"],
+	["purescript", "PureScript"],
+	["purs", "PureScript"],
+	["python", "Python"],
+	["py", "Python"],
+	["qsharp", "Q#"],
+	["qs", "Q#"],
+	["q", "Q (kdb+ database)"],
+	["qml", "QML"],
+	["qore", "Qore"],
+	["r", "R"],
+	["racket", "Racket"],
+	["rkt", "Racket"],
+	["cshtml", "Razor C#"],
+	["razor", "Razor C#"],
+	["jsx", "React JSX"],
+	["tsx", "React TSX"],
+	["reason", "Reason"],
+	["regex", "Regex"],
+	["rego", "Rego"],
+	["renpy", "Ren'py"],
+	["rpy", "Ren'py"],
+	["rescript", "ReScript"],
+	["res", "ReScript"],
+	["rest", "reST (reStructuredText)"],
+	["rip", "Rip"],
+	["roboconf", "Roboconf"],
+	["robotframework", "Robot Framework"],
+	["robot", "Robot Framework"],
+	["ruby", "Ruby"],
+	["rb", "Ruby"],
+	["rust", "Rust"],
+	["sas", "SAS"],
+	["sass", "Sass (Sass)"],
+	["scss", "Sass (SCSS)"],
+	["scala", "Scala"],
+	["scheme", "Scheme"],
+	["shell-session", "Shell session"],
+	["sh-session", "Shell session"],
+	["shellsession", "Shell session"],
+	["smali", "Smali"],
+	["smalltalk", "Smalltalk"],
+	["smarty", "Smarty"],
+	["sml", "SML"],
+	["smlnj", "SML"],
+	["solidity", "Solidity (Ethereum)"],
+	["sol", "Solidity (Ethereum)"],
+	["solution-file", "Solution file"],
+	["sln", "Solution file"],
+	["soy", "Soy (Closure Template)"],
+	["sparql", "SPARQL"],
+	["rq", "SPARQL"],
+	["splunk-spl", "Splunk SPL"],
+	["sqf", "SQF: Status Quo Function (Arma 3)"],
+	["sql", "SQL"],
+	["squirrel", "Squirrel"],
+	["stan", "Stan"],
+	["stata", "Stata Ado"],
+	["iecst", "Structured Text (IEC 61131-3)"],
+	["stylus", "Stylus"],
+	["supercollider", "SuperCollider"],
+	["sclang", "SuperCollider"],
+	["swift", "Swift"],
+	["systemd", "Systemd configuration file"],
+	["t4-templating", "T4 templating"],
+	["t4-cs", "T4 Text Templates (C#)"],
+	["t4", "T4 Text Templates (C#)"],
+	["t4-vb", "T4 Text Templates (VB)"],
+	["tap", "TAP"],
+	["tcl", "Tcl"],
+	["tt2", "Template Toolkit 2"],
+	["textile", "Textile"],
+	["toml", "TOML"],
+	["tremor", "Tremor"],
+	["trickle", "Tremor"],
+	["troy", "Tremor"],
+	["turtle", "Turtle"],
+	["trig", "Turtle"],
+	["twig", "Twig"],
+	["typescript", "TypeScript"],
+	["ts", "TypeScript"],
+	["typoscript", "TypoScript"],
+	["tsconfig", "TypoScript"],
+	["unrealscript", "UnrealScript"],
+	["uscript", "UnrealScript"],
+	["uc", "UnrealScript"],
+	["uorazor", "UO Razor Script"],
+	["uri", "URI"],
+	["url", "URI"],
+	["v", "V"],
+	["vala", "Vala"],
+	["vbnet", "VB.Net"],
+	["velocity", "Velocity"],
+	["verilog", "Verilog"],
+	["vhdl", "VHDL"],
+	["vim", "vim"],
+	["visual-basic", "Visual Basic"],
+	["vb", "Visual Basic"],
+	["vba", "Visual Basic"],
+	["warpscript", "WarpScript"],
+	["wasm", "WebAssembly"],
+	["web-idl", "Web IDL"],
+	["webidl", "Web IDL"],
+	["wgsl", "WGSL"],
+	["wiki", "Wiki markup"],
+	["wolfram", "Wolfram language"],
+	["mathematica", "Wolfram language"],
+	["nb", "Wolfram language"],
+	["wl", "Wolfram language"],
+	["wren", "Wren"],
+	["xeora", "Xeora"],
+	["xeoracube", "Xeora"],
+	["xml-doc", "XML doc (.net)"],
+	["xojo", "Xojo (REALbasic)"],
+	["xquery", "XQuery"],
+	["yaml", "YAML"],
+	["yml", "YAML"],
+	["yang", "YANG"],
+	["zig", "Zig"]
+]);
+
+//#endregion
+//#region packages/ezal-theme-example/src/markdown/codeblock/style.ts
+const base = node_path.default.join(__dirname, "../assets/styles/_code.styl");
+const cleaner$1 = new clean_css.default();
+var CodeblockStyle = class extends ezal.VirtualAssets {
+	#baseCache = new ezal.Cache();
+	extra = "";
+	constructor() {
+		super("/styles/code.css");
+		super.updateDependencies([base]);
+	}
+	async build() {
+		let cache = this.#baseCache.get();
+		if (!cache) {
+			const file = await (0, node_fs_promises.readFile)(base, "utf8");
+			cache = stylus.default.render(file);
+			this.#baseCache.set(cache);
+		}
+		const result = this.extra + cache;
+		if ((0, ezal.getMode)() !== "build") return result;
+		return cleaner$1.minify(result).styles;
+	}
+	onDependenciesChanged() {
+		super.invalidated();
+		this.#baseCache.clean();
+	}
+};
+let asset$1;
+function updateStyles(css) {
+	if (css === asset$1.extra) return;
+	asset$1.extra = css;
+	asset$1.invalidated();
+}
+function initCodeblockStyle() {
+	asset$1 = new CodeblockStyle();
+}
+
+//#endregion
+//#region packages/ezal-theme-example/src/markdown/codeblock/index.ts
+const PATTERN_CLASS = /class="([A-Za-z0-9 -]+)"/;
+const PATTERN_EMPTY_LINE = /\n<span class="line">(<span class="mtk-\d+"><\/span>)?<\/span><\/code><\/pre>$/;
+const modelOperations = new __vscode_vscode_languagedetection.ModelOperations();
+async function getLang(code, lang) {
+	if (lang) return lang;
+	return (await modelOperations.runModel(code)).toSorted((a, b) => b.confidence - a.confidence)[0].languageId;
+}
+let shiki$1;
+const shikiClassName = [];
+const toClass = (0, __shikijs_transformers.transformerStyleToClass)({ classReplacer(name) {
+	let i = shikiClassName.indexOf(name);
+	if (i === -1) {
+		i = shikiClassName.length;
+		shikiClassName.push(name);
+	}
+	return `mtk-${i}`;
+} });
+const transformers = [
+	(0, __shikijs_transformers.transformerNotationDiff)(),
+	(0, __shikijs_transformers.transformerNotationHighlight)(),
+	(0, __shikijs_transformers.transformerNotationWordHighlight)(),
+	(0, __shikijs_transformers.transformerNotationFocus)(),
+	(0, __shikijs_transformers.transformerNotationErrorLevel)(),
+	(0, __shikijs_colorized_brackets.transformerColorizedBrackets)(),
+	toClass
+];
+async function highlighter(code, lang) {
+	lang = await getLang(code, lang);
+	let loadedLanguage = lang;
+	try {
+		await shiki$1.loadLanguage(lang);
+	} catch {
+		loadedLanguage = "plain";
+	}
+	const theme$1 = getThemeConfig().markdown?.codeBlockTheme;
+	const html = await shiki$1.codeToHtml(code, {
+		lang: loadedLanguage,
+		themes: {
+			light: theme$1?.light.name ?? "light-plus",
+			dark: theme$1?.dark.name ?? "dark-plus"
+		},
+		transformers
+	});
+	if ((0, ezal.getMode)() === "serve") updateStyles(toClass.getCSS());
+	return [html, lang];
+}
+const { $: $$9 } = ezal_markdown.utils;
+function packager(html, lang, extra) {
+	const name = LANGUAGE_MAP.get(lang) ?? lang;
+	let mtk = "";
+	html = html.replace(PATTERN_CLASS, (_, className) => {
+		const classes = className.split(" ");
+		const result = ["shiki"];
+		for (const name$1 of classes) if (name$1.startsWith("has-")) result.push(name$1);
+		else if (name$1.startsWith("mtk-")) mtk = name$1;
+		return `class="${result.join(" ")}"`;
+	}).replace(PATTERN_EMPTY_LINE, "</code></pre>");
+	return $$9("figure", {
+		class: [
+			"code",
+			"rounded",
+			mtk
+		],
+		html: [$$9("figcaption", {
+			class: ["sticky", "rounded"],
+			html: [
+				$$9("code", name),
+				extra,
+				$$9("button", {
+					class: ["link", "icon-copy"],
+					attr: { title: "复制代码" }
+				})
+			]
+		}), html]
+	});
+}
+const origin$1 = ezal_markdown.plugins.codeblock();
+async function render$1({ code, lang, children }, { shared, counter }) {
+	counter.count(code);
+	shared.codeblock = true;
+	const result = await highlighter(code, lang);
+	return packager(result[0], result[1], children?.html ?? "");
+}
+const indented = {
+	...origin$1.indentedCodeblock,
+	render: render$1
+};
+const fenced = {
+	...origin$1.fencedCodeblock,
+	render: render$1
+};
+async function codeblock() {
+	const theme$1 = getThemeConfig().markdown?.codeBlockTheme;
+	shiki$1 = await (0, shiki.createHighlighter)({
+		themes: theme$1 ? [theme$1.light, theme$1.dark] : ["light-plus", "dark-plus"],
+		langs: []
+	});
+	return {
+		indented,
+		fenced
+	};
+}
+function setupCodeblockStyle() {
+	updateStyles(toClass.getCSS());
+}
+
+//#endregion
+//#region packages/ezal-theme-example/src/markdown/fold.ts
+const PATTERN_START$2 = /(?<=^|\n) {0,3}(\+{3,}) {0,3}(\S.*)\n/;
+const { $: $$8 } = ezal_markdown.utils;
+const fold = {
+	name: "fold",
+	type: "block",
+	order: 0,
+	priority: 0,
+	start: PATTERN_START$2,
+	parse(source$1, { md }) {
+		const matched = source$1.match(PATTERN_START$2);
+		if (!matched) return;
+		const size = matched[1].length;
+		const summary = matched[2];
+		const pattern = /* @__PURE__ */ new RegExp(`(?<=^|\\n) {0,3}\\+{${size}}\\s*(\\n|$)`);
+		const endMatched = source$1.match(pattern);
+		const end = endMatched?.index ?? Infinity;
+		const rawEnd = end + (endMatched?.[0].length ?? 0);
+		const raw = source$1.slice(0, rawEnd);
+		const details = raw.slice(matched[0].length, end);
+		return {
+			raw,
+			children: [md(summary, "inline"), md(details, "block")]
+		};
+	},
+	render({ children: [summary, details] }) {
+		return $$8("details", {
+			class: "rounded",
+			html: [$$8("summary", {
+				class: ["rounded", "sticky"],
+				html: summary.html
+			}), $$8("div", {
+				class: "sticky-content",
+				html: details.html
+			})]
+		});
+	}
+};
+
+//#endregion
+//#region packages/ezal-theme-example/src/markdown/footnote.ts
+const { eachLine, $: $$7 } = ezal_markdown.utils;
+const PATTERN_SOURCE_START = /(?<=^|\n)\[\^.*?\]:/;
+const PATTERN_SOURCE_BEGIN = /^\[(.*?)\]:/;
+const PATTERN_SOURCE_INDENT = /^(\t| {1,4})/;
+const render = {
+	name: "footnote",
+	type: "inline",
+	render({ id, label }, { counter }) {
+		counter.count(label);
+		return $$7("sup", $$7("a", {
+			class: "footnote",
+			attr: { href: id },
+			content: label
+		}));
+	}
+};
+const ast = {
+	name: "footnote-ast",
+	type: "inline",
+	phase: "post",
+	priority: -1,
+	parse(root) {
+		for (const child of root.entires().toArray()) {
+			if (!(child instanceof ezal_markdown.LinkNode)) continue;
+			if (child.label?.[0] !== "^") continue;
+			if (child.raw?.length !== child.label.length + 2) continue;
+			const id = child.destination;
+			const label = child.raw.slice(2, -1);
+			child.before(new ezal_markdown.ParsedNode("footnote", "inline", {
+				id,
+				label
+			}));
+			child.remove();
+		}
+	},
+	verifyNode: (_) => false,
+	render: () => ""
+};
+const source = {
+	name: "footnote-source",
+	type: "block",
+	order: 0,
+	priority: 0,
+	start: PATTERN_SOURCE_START,
+	parse(source$1, { anchors, refMap, md }) {
+		const contents = [];
+		const id = [];
+		let current = "";
+		let raw = "";
+		let indentState = null;
+		for (const [line] of eachLine(source$1)) {
+			const matched = line.match(PATTERN_SOURCE_BEGIN);
+			if (matched) {
+				if (matched[1][0] !== "^") break;
+				if (raw) contents.push(current);
+				const label = matched[1].slice(1);
+				const hash = anchors.register(label);
+				id.push([label, hash]);
+				refMap.set(matched[1], { destination: `#${hash}` });
+				current = line.slice(matched[0].length);
+				raw += line;
+				indentState = null;
+				continue;
+			}
+			const indent = PATTERN_SOURCE_INDENT.test(line);
+			const empty = line.trim().length === 0;
+			if (indentState === null) indentState = indent || empty;
+			if (!indentState && empty) break;
+			if (indentState && !indent) break;
+			if (!(empty || indent)) indentState = false;
+			current += line;
+			raw += line;
+		}
+		if (id.length !== contents.length) contents.push(current);
+		const children = contents.map((content) => md(content, {
+			skipParagraphWrapping: true,
+			maxLevel: "block"
+		}));
+		return {
+			raw,
+			id,
+			children
+		};
+	},
+	render({ id, children }, { counter }) {
+		for (const [label] of id) counter.count(label);
+		for (const child of children) counter.count(child.raw);
+		return $$7("dl", children.flatMap((child, i) => [$$7("dt", {
+			content: id[i][0],
+			id: id[i][1]
+		}), $$7("dd", child.html)]));
+	}
+};
+const footnote = {
+	source,
+	ast,
+	render
+};
+
+//#endregion
+//#region packages/ezal-theme-example/src/markdown/image.ts
+const { $: $$6 } = ezal_markdown.utils;
+function img(info, src, alt, title) {
+	return $$6("img", {
+		attr: {
+			src: ezal.URL.for(src),
+			alt,
+			width: info?.metadata?.width,
+			height: info?.metadata?.height,
+			loading: "lazy",
+			title
+		},
+		style: { $imgColor: info?.metadata?.color }
+	});
+}
+function renderImage(url, alt, title, page) {
+	const info = getImageInfo(ezal.URL.resolve(page.url, url));
+	if (!info?.rule) return img(info, url, alt, title);
+	const html = info.rule.slice(0, -1).map((ext) => $$6("source", { attr: {
+		srcset: ezal.URL.extname(url, `.opt${ext}`),
+		type: mime_types.default.lookup(ext)
+	} }));
+	html.push(img(info, ezal.URL.extname(url, info.rule.at(-1)), alt, title));
+	return $$6("picture", html);
+}
+const blockRender = {
+	name: "image",
+	type: "block",
+	render({ title, url, alt }, { shared, counter }) {
+		const page = shared.page;
+		const html = [renderImage(url, alt, title, page)];
+		html.push($$6("figcaption", { content: alt }));
+		counter.count(alt);
+		return $$6("figure", {
+			class: "image",
+			html
+		});
+	}
+};
+const block$1 = {
+	name: "image-post",
+	type: "inline",
+	phase: "post",
+	priority: -1,
+	parse(root) {
+		if (!(root instanceof ezal_markdown.Paragraph)) return;
+		if (root.size !== 1) return;
+		const child = root.child(0);
+		if (!(child instanceof ezal_markdown.ImageNode)) return;
+		const alt = child.entires().map((node) => node.raw ?? "").toArray().join("");
+		const image$1 = new ezal_markdown.ParsedNode("image", "block", {
+			raw: child.raw ?? "",
+			title: child.title,
+			alt: (0, ezal.escapeHTML)(alt),
+			url: child.destination
+		});
+		root.before(image$1);
+		root.remove();
+	},
+	verifyNode: (_node) => false,
+	render: () => ""
+};
+const inline$1 = {
+	name: "image",
+	type: "inline",
+	phase: "post",
+	priority: 1,
+	parse() {},
+	verifyNode(node) {
+		return node instanceof ezal_markdown.ImageNode;
+	},
+	render(node, { shared }) {
+		const page = shared.page;
+		const { destination, title } = node;
+		return renderImage(destination, (0, ezal.escapeHTML)(node.entires().map((node$1) => node$1.html).toArray().join("")), title, page);
+	}
+};
+const image = {
+	block: block$1,
+	blockRender,
+	inline: inline$1
+};
+
+//#endregion
+//#region packages/ezal-theme-example/src/markdown/kbd.ts
+const PATTERN = /{{\S+?}}/;
+const { $: $$5 } = ezal_markdown.utils;
+const kbd = {
+	name: "kbd",
+	type: "inline",
+	order: 0,
+	priority: 0,
+	start: PATTERN,
+	parse(source$1) {
+		const matched = source$1.match(PATTERN);
+		if (!matched) return;
+		return {
+			raw: matched[0],
+			key: matched[0].slice(2, -2)
+		};
+	},
+	render({ key }, { counter }) {
+		counter.count(key);
+		return $$5("kbd", { content: key });
+	}
+};
+
+//#endregion
+//#region packages/ezal-theme-example/src/markdown/link.ts
+const PATTERN_ABSOLUTE_LINK = /^[a-z][a-z0-9+.-]*:|^\/\//;
+const { $: $$4 } = ezal_markdown.utils;
+const link = {
+	name: "link",
+	type: "inline",
+	phase: "post",
+	priority: 1,
+	parse() {},
+	verifyNode(node) {
+		return node instanceof ezal_markdown.LinkNode;
+	},
+	render(node) {
+		const html = [...node.entires().map((node$1) => node$1.html)];
+		const target = PATTERN_ABSOLUTE_LINK.test(node.destination) ? "_blank" : void 0;
+		return $$4("a", {
+			attr: {
+				href: ezal.URL.for(node.destination),
+				target,
+				title: node.title
+			},
+			html
+		});
+	}
+};
+
+//#endregion
+//#region packages/ezal-theme-example/src/markdown/links.ts
+const PATTERN_ALL = /(?<=^|\n)@@\n.*?\n@@(\n|$)/s;
+const PATTERN_EACH = /(?<=^|\n)@ ?([^@\n].*\n){2,3}/g;
+const PATTERN_WHITESPACE = /\s+/;
+const { $: $$3 } = ezal_markdown.utils;
+const links = {
+	name: "links",
+	type: "block",
+	order: 0,
+	priority: 0,
+	start: PATTERN_ALL,
+	parse(source$1) {
+		const matched = source$1.match(PATTERN_ALL);
+		if (!matched) return;
+		const raw = matched[0];
+		return {
+			raw,
+			links: [...raw.matchAll(PATTERN_EACH).map((matched$1) => {
+				const lines = matched$1[0].split("\n");
+				const args = lines[0].slice(1).trim().split(PATTERN_WHITESPACE);
+				return {
+					href: args[0],
+					icon: args[1],
+					title: lines[1],
+					subtitle: lines[2]
+				};
+			})]
+		};
+	},
+	render({ links: links$1 }, { counter }) {
+		return $$3("div", {
+			class: "links",
+			html: links$1.map(({ href, icon, title, subtitle }) => {
+				const html = [$$3("i", { class: ["icon-link"] })];
+				if (icon) html.push($$3("img", {
+					class: "rounded",
+					attr: {
+						src: ezal.URL.for(icon),
+						alt: title
+					}
+				}));
+				html.push($$3("div", {
+					class: "link-title",
+					content: title
+				}));
+				counter.count(title);
+				if (subtitle) {
+					html.push($$3("div", { content: subtitle }));
+					counter.count(subtitle);
+				}
+				return $$3("a", {
+					class: "rounded",
+					html,
+					attr: { href: ezal.URL.for(href) }
+				});
+			})
+		});
+	}
+};
+
+//#endregion
+//#region packages/ezal-theme-example/src/markdown/note.ts
+const PATTERN_START$1 = /(?<=^|\n) {0,3}(!{3,}) ?(info|tip|warn|danger)(.*)\n/;
+const { $: $$2 } = ezal_markdown.utils;
+const NOTE_TITLE = {
+	info: "注意",
+	tip: "提示",
+	warn: "警告",
+	danger: "危险"
+};
+const note = {
+	name: "note",
+	type: "block",
+	order: 0,
+	priority: 0,
+	start: PATTERN_START$1,
+	parse(source$1, { md }) {
+		const matched = source$1.match(PATTERN_START$1);
+		if (!matched) return;
+		const size = matched[1].length;
+		const type = matched[2];
+		let title = matched[3]?.trim();
+		if (!title) title = NOTE_TITLE[type];
+		const pattern = /* @__PURE__ */ new RegExp(`(?<=^|\\n) {0,3}!{${size}}\\s*(\\n|$)`);
+		const endMatched = source$1.match(pattern);
+		const end = endMatched?.index ?? Infinity;
+		const rawEnd = end + (endMatched?.[0].length ?? 0);
+		const raw = source$1.slice(0, rawEnd);
+		const content = raw.slice(matched[0].length, end);
+		return {
+			raw,
+			type,
+			title,
+			children: md(content, "block")
+		};
+	},
+	render({ type, title, children }) {
+		return $$2("div", {
+			class: ["note", `note-${type}`],
+			html: [$$2("p", [$$2("i", { class: `icon-${type}` }), title]), children.html]
+		});
+	}
+};
+
+//#endregion
+//#region packages/ezal-theme-example/src/markdown/table.ts
+const { $: $$1 } = ezal_markdown.utils;
+const origin = ezal_markdown.plugins.table();
+const table = {
+	...origin,
+	render(source$1, context, options) {
+		return $$1("div", {
+			class: ["table", "rounded"],
+			attr: { tabindex: "0" },
+			html: origin.render(source$1, context, options)
+		});
+	}
+};
+
+//#endregion
+//#region packages/ezal-theme-example/src/markdown/tabs.ts
+const PATTERN_START = /(?<=^|\n) {0,3}(:{3,}) {0,3}\S/;
+const { $ } = ezal_markdown.utils;
+const tabs = {
+	name: "tabs",
+	type: "block",
+	order: 0,
+	priority: 0,
+	start: PATTERN_START,
+	parse(source$1, { anchors, md }) {
+		const size = source$1.match(PATTERN_START)?.[1].length ?? 0;
+		if (!size) return;
+		const pattern = /* @__PURE__ */ new RegExp(`(?<=^|\\n) {0,3}:{${size}}(.*)(\\n|$)`);
+		const children = [];
+		const id = [];
+		let matched = source$1.match(pattern);
+		let offset = 0;
+		while (matched) {
+			offset += matched[0].length;
+			if (matched[1].trim().length === 0) break;
+			const tab = md(matched[1], "inline");
+			matched = source$1.slice(offset).match(pattern);
+			const next = (matched?.index ?? Infinity) + offset;
+			const content = md(source$1.slice(offset, next), "block");
+			offset = next;
+			id.push(anchors.register("tab"));
+			children.push([tab, content]);
+		}
+		if (children.length === 0) return;
+		return {
+			raw: source$1.slice(0, offset),
+			children,
+			id
+		};
+	},
+	render({ children, id }, context) {
+		const name = `tabs-${context.self}`;
+		context.self++;
+		const nav = children.map(([tab], i) => $("label", {
+			attr: { for: id[i] },
+			html: [$("input", {
+				attr: {
+					type: "radio",
+					name,
+					checked: i === 0
+				},
+				id: id[i]
+			}), tab.html]
+		}));
+		const content = children.map(([_, content$1], i) => $("div", {
+			class: i === 0 ? "active" : void 0,
+			html: content$1.html
+		}));
+		return $("div", {
+			class: ["tabs", "rounded"],
+			html: [$("div", {
+				class: [
+					"tab-nav",
+					"rounded",
+					"sticky"
+				],
+				html: nav
+			}), $("div", {
+				class: ["tab-content", "sticky-content"],
+				html: content
+			})]
+		});
+	},
+	context: () => 0
+};
+
+//#endregion
+//#region packages/ezal-theme-example/src/markdown/tex.ts
+const PATTERN_INLINE = /(?<=\s|\W|^)(?<!\$)(\$\$?)(.+?)(\1)(?!\$)(?=\s|\W|$)/;
+const PATTERN_BLOCK = /(?<=^|\n) {0,3}\$\$.*?\$\$\s*(\n|$)/s;
+const katexErrorHandler = (logger$4) => (errorCode, errorMsg, token) => {
+	switch (errorCode) {
+		case "unknownSymbol":
+		case "unicodeTextInMathMode":
+		case "mathVsTextUnits":
+		case "newLineInDisplayMode":
+		case "htmlExtension":
+			logger$4.warn(`${errorCode}: ${errorMsg}`, token);
+			break;
+		case "commentAtEnd":
+			logger$4.error(`${errorCode}: ${errorMsg}`, token);
+			break;
+	}
+	return false;
+};
+const inline = {
+	name: "tex",
+	type: "inline",
+	order: 0,
+	priority: 0,
+	start: PATTERN_INLINE,
+	parse(source$1) {
+		const matched = source$1.match(PATTERN_INLINE);
+		if (!matched) return;
+		return {
+			raw: matched[0],
+			tex: matched[2]
+		};
+	},
+	render({ tex: tex$1 }, { logger: logger$4, shared, counter }) {
+		shared.tex = true;
+		counter.count(tex$1);
+		return katex.default.renderToString(tex$1, {
+			output: "html",
+			throwOnError: false,
+			strict: katexErrorHandler(logger$4)
+		});
+	}
+};
+const block = {
+	name: "tex",
+	type: "block",
+	order: 0,
+	priority: 0,
+	start: PATTERN_BLOCK,
+	parse(source$1) {
+		const matched = source$1.match(PATTERN_BLOCK);
+		if (!matched) return;
+		const raw = matched[0];
+		const start = raw.indexOf("$$");
+		const end = raw.lastIndexOf("$$");
+		return {
+			raw,
+			tex: raw.slice(start + 2, end).trim()
+		};
+	},
+	render({ tex: tex$1 }, { logger: logger$4, shared, counter }) {
+		shared.tex = true;
+		counter.count(tex$1);
+		return katex.default.renderToString(tex$1, {
+			displayMode: true,
+			output: "html",
+			throwOnError: false,
+			strict: katexErrorHandler(logger$4)
+		});
+	}
+};
+const tex = {
+	inline,
+	block
+};
+
+//#endregion
+//#region packages/ezal-theme-example/src/markdown/index.ts
+const logger$1 = new ezal.Logger("markdown");
+const renderer = new ezal_markdown.EzalMarkdown();
+renderer.logger = {
+	debug(data) {
+		logger$1.debug(`[${data.name}]`, data.message, data.errObj);
+	},
+	info(data) {
+		logger$1.log(`[${data.name}]`, data.message, data.errObj);
+	},
+	warn(data) {
+		if (data.name === "link-reference-define" && data.message.includes("label ^")) return;
+		logger$1.warn(`[${data.name}]`, data.message, data.errObj);
+	},
+	error(data) {
+		logger$1.error(`[${data.name}]`, data.message, data.errObj);
+	}
+};
+const setext = {
+	name: "setext-heading",
+	type: "block",
+	order: 0,
+	priority: 0,
+	start: () => null,
+	parse: () => null,
+	render: () => ""
+};
+async function markdownPageHandler() {
+	renderer.set(ezal_markdown.plugins.heading({ shiftLevels: true }), image, table, await codeblock(), footnote, tex, tabs, note, fold, kbd, links, setext, link);
+	return {
+		exts: ".md",
+		async parser(src) {
+			const file = await ezal.fs.readFile(src);
+			if (file instanceof Error) return file;
+			const frontmatter = await (0, ezal_markdown.extractFrontmatter)(file);
+			let data = frontmatter?.data;
+			if (typeof data !== "object") data = {};
+			return {
+				content: file.slice(frontmatter?.raw.length ?? 0),
+				data
+			};
+		},
+		async renderer(content, page) {
+			const config$2 = getThemeConfig();
+			const result = await renderer.renderHTML(content, {
+				lineBreak: config$2.markdown?.lineBreak,
+				shared: { page }
+			});
+			return {
+				html: result.html,
+				data: result.context
+			};
+		}
+	};
+}
+
+//#endregion
+//#region packages/ezal-theme-example/src/page/404.ts
+function init404Page() {
+	new ezal.VirtualPage({
+		id: "404",
+		src: "/404.html",
+		layout: "404"
+	});
+}
+
+//#endregion
+//#region packages/ezal-theme-example/src/page/archive.ts
+let indexPage;
+const years = /* @__PURE__ */ new Map();
+function getArticles$1(year) {
+	return ezal.Article.getAll().filter((article) => article.date.year === year).toSorted(compareByDate);
+}
+function createIndex() {
+	indexPage = new ezal.VirtualPage({
+		id: "archive",
+		src: "/archive/",
+		layout: "archive",
+		title: "归档",
+		data: {
+			years,
+			getArticles: getArticles$1
+		}
+	});
+}
+let scanned$3 = false;
+function updateArchivePage(_any) {
+	if (!scanned$3 && _any) return;
+	scanned$3 = true;
+	if (!indexPage) createIndex();
+	const newYears = /* @__PURE__ */ new Map();
+	for (const article of ezal.Article.getAll()) {
+		const year = article.date.year;
+		let count = newYears.get(year);
+		if (count === void 0) count = 0;
+		count++;
+		newYears.set(year, count);
+	}
+	years.clear();
+	for (const [year, count] of newYears) years.set(year, count);
+	indexPage.invalidated();
+}
+
+//#endregion
+//#region packages/ezal-theme-example/src/page/category.ts
+const categories = /* @__PURE__ */ new Map();
+function createPage$2(category) {
+	const id = `category/${category.path.join("/")}`;
+	const data = { category };
+	return new ezal.VirtualPage({
+		id,
+		src: `/${id}/`,
+		title: `分类：${category.name}`,
+		layout: "category",
+		data
+	});
+}
+let scanned$2 = false;
+function updateCategoryPage(_any) {
+	if (!scanned$2 && _any) return;
+	scanned$2 = true;
+	for (const [category, page] of categories.entries().toArray()) {
+		if (!category.destroyed) continue;
+		page.destroy();
+		categories.delete(category);
+	}
+	for (const category of ezal.Category.getAll()) {
+		if (categories.has(category)) continue;
+		categories.set(category, createPage$2(category));
+	}
+}
+
+//#endregion
+//#region packages/ezal-theme-example/src/page/home.ts
+const pages = [];
+function getArticles(index$1) {
+	const pre = getThemeConfig().home?.articlesPrePage ?? 10;
+	const offset = index$1 * pre;
+	return ezal.Article.getAll().toSorted(compareByDate).slice(offset, offset + pre);
+}
+function getPages() {
+	return pages;
+}
+function createPage$1(index$1) {
+	const i = String(index$1 + 1);
+	const data = {
+		index: index$1,
+		getPages,
+		getArticles
+	};
+	return new ezal.VirtualPage({
+		id: index$1 ? `${i}/` : "",
+		src: `/${index$1 ? `${i}/` : ""}`,
+		layout: "home",
+		data
+	});
+}
+let scanned$1 = false;
+function updateHomePage(article) {
+	if (!scanned$1 && article) return;
+	scanned$1 = true;
+	const pre = getThemeConfig().home?.articlesPrePage ?? 10;
+	const count = Math.ceil(Math.max(ezal.Article.getAll().length / pre, 1));
+	if (count > pages.length) for (let i = pages.length; i < count; i++) pages.push(createPage$1(i));
+	else if (count < pages.length) for (const page of pages.splice(count)) page.destroy();
+	for (const page of pages) page.invalidated();
+}
+
+//#endregion
+//#region packages/ezal-theme-example/src/page/tag.ts
+const tags = /* @__PURE__ */ new Map();
+function createPage(tag) {
+	const id = `tag/${tag.name}`;
+	const data = { tag };
+	return new ezal.VirtualPage({
+		id,
+		src: `/${id}/`,
+		title: `标签：${tag.name}`,
+		layout: "tag",
+		data
+	});
+}
+let scanned = false;
+function updateTagPage(_any) {
+	if (!scanned && _any) return;
+	scanned = true;
+	for (const [tag, page] of tags.entries().toArray()) {
+		if (!tag.destroyed) continue;
+		page.destroy();
+		tags.delete(tag);
+	}
+	for (const tag of ezal.Tag.getAll()) {
+		if (tags.has(tag)) continue;
+		tags.set(tag, createPage(tag));
+	}
+}
+
+//#endregion
+//#region packages/ezal-theme-example/src/pagefind.ts
+const logger = new ezal.Logger("theme:index");
+let index;
+const assets = /* @__PURE__ */ new Map();
+var PagefindIndex = class extends ezal.VirtualAssets {
+	buffer;
+	constructor(url, buffer) {
+		super(url);
+		this.buffer = buffer;
+	}
+	build() {
+		return this.buffer;
+	}
+	onDependenciesChanged() {}
+};
+/** 重建索引文件虚拟资源 */
+async function rebuildIndexFile() {
+	if (!index) return;
+	const { errors, files } = await index.getFiles();
+	if (errors.length > 0) {
+		if ((0, ezal.getMode)() === "build") logger.fatal(errors);
+		else logger.error(errors);
+		return;
+	}
+	const fileMap = new Map(files.map(({ path: path$8, content }) => [path$8, Buffer.from(content)]));
+	for (const [path$8, asset$2] of assets.entries().toArray()) {
+		if (fileMap.has(path$8)) continue;
+		asset$2.destroy();
+		assets.delete(path$8);
+	}
+	for (const [path$8, buffer] of fileMap) {
+		let asset$2 = assets.get(path$8);
+		if (asset$2) {
+			asset$2.buffer = buffer;
+			asset$2.invalidated();
+			continue;
+		}
+		asset$2 = new PagefindIndex(path$8, buffer);
+		assets.set(path$8, asset$2);
+	}
+}
+/**
+* 添加页面
+* @description 构建模式下需启用强制才能添加索引
+*/
+async function addPage(page, force) {
+	if (!index) return [];
+	if ((0, ezal.getMode)() === "build" && !force) return [];
+	const allowIndex = page.data?.index;
+	if (page instanceof ezal.Article) {
+		if (allowIndex === false) return [];
+	} else if (!allowIndex) return [];
+	const { errors } = await index.addCustomRecord({
+		url: page.url,
+		content: page.content ?? page.markdownContent ?? "",
+		language: (0, ezal.getConfig)().site.language,
+		meta: { title: page.title }
+	});
+	if (errors.length > 0) logger.error(errors);
+	if (!force) await rebuildIndexFile();
+	return errors;
+}
+/** 创建所有页面索引 */
+async function buildAllIndex() {
+	const errors = [];
+	for (const article of ezal.Article.getAll()) errors.push(...await addPage(article, true));
+	for (const page of ezal.Page.getAll()) errors.push(...await addPage(page, true));
+	return errors;
+}
+/**
+* 清除并重建索引
+* @description 构建模式下无效
+*/
+async function rebuildPagefind() {
+	if (!index) return;
+	if ((0, ezal.getMode)() === "build") return;
+	await index.deleteIndex();
+	const response = await (await import("pagefind")).createIndex();
+	if (!response.index) throw response.errors;
+	index = response.index;
+	await buildAllIndex();
+	await rebuildIndexFile();
+}
+/** 构建 Pagefind */
+async function buildPagefind() {
+	if (!index) throw new Error("Pagefind not initialized");
+	await buildAllIndex();
+	await rebuildIndexFile();
+}
+/**
+* 初始化 PageFind
+* @description 构建模式下不会构建索引
+*/
+async function initPagefind() {
+	if (index) return;
+	const response = await (await import("pagefind")).createIndex();
+	if (!response.index) throw response.errors;
+	index = response.index;
+	if ((0, ezal.getMode)() === "build") return;
+	await rebuildPagefind();
+}
+/** 停止 PageFind */
+async function stopPagefind() {
+	await (await import("pagefind")).close();
+}
+
+//#endregion
+//#region packages/ezal-theme-example/src/sitemap.ts
+function getInfo(page) {
+	let img$1 = page.data?.cover;
+	if (img$1) img$1 = ezal.URL.resolve(page.url, img$1);
+	return {
+		url: page.url,
+		changefreq: "weekly",
+		img: img$1
+	};
+}
+var Sitemap = class extends ezal.VirtualAssets {
+	constructor() {
+		super("/sitemap.xml");
+	}
+	build() {
+		const { site } = (0, ezal.getConfig)();
+		const stream = new sitemap.SitemapStream({ hostname: site.domain });
+		stream.write({ url: "/" });
+		const pre = getThemeConfig().home?.articlesPrePage ?? 10;
+		const count = Math.ceil(Math.max(ezal.Article.getAll().length / pre, 1));
+		for (let i = 2; i <= count; i++) stream.write({ url: `/${i}/` });
+		for (const article of ezal.Article.getAll()) {
+			if (article.data?.sitemap === false) continue;
+			stream.write(getInfo(article));
+		}
+		for (const page of ezal.Page.getAll()) {
+			if (!page.data?.sitemap) continue;
+			stream.write(getInfo(page));
+		}
+		stream.end();
+		return stream;
+	}
+	onDependenciesChanged() {}
+};
+let asset;
+function initSitemap() {
+	asset = new Sitemap();
+}
+function updateSitemap() {
+	asset?.invalidated();
+}
+
+//#endregion
+//#region packages/ezal-theme-example/src/transform/script.ts
+const scriptTransformRule = {
+	from: ".ts",
+	to: ".js",
+	async transformer(src) {
+		const buildMode = (0, ezal.getMode)() === "build";
+		const { outputFiles, metafile: { inputs } } = await esbuild.default.build({
+			entryPoints: [src],
+			loader: { ".ts": "ts" },
+			external: ["../pagefind.js"],
+			bundle: true,
+			platform: "browser",
+			format: "iife",
+			target: "es2024",
+			write: false,
+			metafile: true,
+			sourcemap: buildMode ? false : "inline",
+			treeShaking: buildMode,
+			minify: buildMode
+		});
+		const cwd = process.cwd();
+		return {
+			result: outputFiles[0].text,
+			dependencies: Object.keys(inputs).map((src$1) => node_path.default.join(cwd, src$1))
+		};
+	}
+};
+
+//#endregion
+//#region packages/ezal-theme-example/src/transform/stylus.ts
+const STYLE_CONFIGS = {
+	"color.light": () => getThemeConfig().color?.light,
+	"color.dark": () => getThemeConfig().color?.dark,
+	waline: () => !!getThemeConfig().waline
+};
+function config({ val }) {
+	if (val in STYLE_CONFIGS) return STYLE_CONFIGS[val]();
+}
+function linksStyle({ val }) {
+	const styles = getThemeConfig().linkPageStyles;
+	if (!styles) return true;
+	return styles.includes(val);
+}
+const cleaner = new clean_css.default();
+const styleTransformRule = {
+	from: ".styl",
+	to: ".css",
+	async transformer(src) {
+		const file = await ezal.fs.readFile(src);
+		if (file instanceof Error) return file;
+		try {
+			const renderer$1 = (0, stylus.default)(file, {
+				paths: [node_path.default.join(src, "..")],
+				filename: node_path.default.basename(src),
+				functions: {
+					config,
+					linksStyle
+				},
+				"include css": true
+			});
+			const dependencies = renderer$1.deps().map((dep) => {
+				if (!dep.startsWith("//?/")) return dep;
+				return node_path.default.normalize(dep.slice(4));
+			});
+			let result = renderer$1.render();
+			if ((0, ezal.getMode)() === "build") result = cleaner.minify(result).styles;
+			return {
+				result,
+				dependencies
+			};
+		} catch (error) {
+			return (0, ezal.normalizeError)(error);
+		}
+	}
+};
+
+//#endregion
+//#region packages/ezal-theme-example/src/index.ts
+async function theme(config$2) {
+	setThemeConfig(config$2);
+	imageDB.init();
+	return {
+		assetsRoot: node_path.default.join(__dirname, "../assets"),
+		transformRules: [styleTransformRule, scriptTransformRule],
+		layout: layoutConfig,
+		pageHandlers: [await markdownPageHandler()],
+		hooks: {
+			"config:after": [initCodeblockStyle],
+			"scan:after": [
+				updateHomePage,
+				updateArchivePage,
+				updateCategoryPage,
+				updateTagPage,
+				init404Page,
+				initPagefind,
+				initSitemap,
+				initFeed
+			],
+			"asset:add": [imageAddHook],
+			"asset:update": [imageUpdateHook],
+			"asset:remove": [imageRemoveHook],
+			"build:before:assets-virtual": [
+				setupCodeblockStyle,
+				buildPagefind,
+				updateSitemap
+			],
+			"build:after": [stopPagefind, exeIndexNow],
+			"article:add": [updateHomePage, updateArchivePage],
+			"article:update": [
+				updateHomePage,
+				updateArchivePage,
+				addPage,
+				updateSitemap,
+				updateFeedItem
+			],
+			"article:remove": [
+				updateHomePage,
+				updateArchivePage,
+				rebuildPagefind,
+				updateSitemap,
+				updateFeedItem
+			],
+			"article:build:after": [addPage, updateFeedItem],
+			"page:update": [addPage, updateSitemap],
+			"page:remove": [rebuildPagefind, updateSitemap],
+			"page:build:after": [addPage],
+			"category:add": [updateCategoryPage],
+			"category:update": [updateCategoryPage, updateFeedCategory],
+			"category:remove": [updateCategoryPage, updateFeedCategory],
+			"tag:add": [updateTagPage],
+			"tag:update": [updateTagPage],
+			"tag:remove": [updateTagPage],
+			"preview:stop": [stopPagefind]
+		}
+	};
+}
+
+//#endregion
+exports.theme = theme;
+//# sourceMappingURL=index.js.map