comarkserv 0.1.0

package/dist/server-Dkjk_D1Y.mjs

@@ -0,0 +1,2628 @@
+import { O as relative, S as getAssets, T as dirname$1, _ as injectClient, a as themeWatchPath, b as renderReadme, d as hasHiddenSegment, f as isMarkdown, g as serverLinks, h as readDirectory, i as isThemeSource, k as resolve$1, l as crumbsFor, o as createSearchIndex, p as isSkippedPath, r as createThemeStore, s as extractOutline, t as OMARCHY_CURRENT, v as renderListing, x as renderStatus, y as renderPage } from "./themes-mEufQ_3e.mjs";
+import { existsSync, readdirSync, stat, unwatchFile, watch, watchFile } from "node:fs";
+import { lstat, open, readFile, readdir, realpath, stat as stat$1 } from "node:fs/promises";
+import { createHash, randomUUID } from "node:crypto";
+import * as sp from "node:path";
+import { basename, join, resolve, sep } from "node:path";
+import { networkInterfaces, tmpdir, type } from "node:os";
+import { promisify, styleText } from "node:util";
+import { brotliCompress, constants as constants$1, gzip } from "node:zlib";
+import { staticMiddleware } from "srvx/static";
+import { EventEmitter } from "node:events";
+import { Readable } from "node:stream";
+import { createServer } from "node:net";
+import { serve } from "srvx";
+//#region src/share.ts
+/** The Cloudflare documents that a user must accept before untun installs cloudflared. */
+const CLOUDFLARE_LINKS = {
+	license: "https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/downloads/license/",
+	terms: "https://www.cloudflare.com/terms/",
+	privacy: "https://www.cloudflare.com/privacypolicy/"
+};
+/** The error when cloudflared must be installed and the user did not accept the Cloudflare license. */
+var ShareConsentError = class extends Error {
+	constructor() {
+		super("Accept the Cloudflare license before comarkserv installs cloudflared.");
+		this.name = "ShareConsentError";
+	}
+};
+/** Returns true when untun installed cloudflared already, so no consent is necessary. */
+function isCloudflaredInstalled() {
+	const directory = join(tmpdir(), "node-untun");
+	return existsSync(directory) && readdirSync(directory).some((name) => name.startsWith("cloudflared"));
+}
+const untunTunnel = async (options) => {
+	const { startTunnel } = await import("./dist-ZoN94PJ0.mjs");
+	return startTunnel(options);
+};
+function createShareService(options = {}) {
+	const startTunnel = options.startTunnel ?? untunTunnel;
+	const isInstalled = options.isInstalled ?? isCloudflaredInstalled;
+	const listeners = /* @__PURE__ */ new Set();
+	let tunnel;
+	let url;
+	let starting;
+	let error;
+	const status = () => ({
+		state: url ? "on" : starting ? "starting" : "off",
+		...url ? { url } : {},
+		needsConsent: !isInstalled(),
+		...error ? { error } : {}
+	});
+	const notify = () => {
+		const current = status();
+		for (const listener of listeners) listener(current);
+	};
+	const start = async (request) => {
+		if (url) return url;
+		if (starting) return starting;
+		const accept = request.accept === true;
+		if (!accept && !isInstalled()) throw new ShareConsentError();
+		error = void 0;
+		starting = (async () => {
+			const started = await startTunnel({
+				url: request.origin,
+				acceptCloudflareNotice: accept
+			});
+			if (!started) throw new Error("The tunnel did not start.");
+			const publicUrl = await started.getURL();
+			tunnel = started;
+			url = publicUrl;
+			return publicUrl;
+		})();
+		notify();
+		try {
+			return await starting;
+		} catch (cause) {
+			error = cause instanceof Error ? cause.message : String(cause);
+			throw cause;
+		} finally {
+			starting = void 0;
+			notify();
+		}
+	};
+	const stop = async () => {
+		const running = tunnel;
+		tunnel = void 0;
+		url = void 0;
+		if (running) {
+			await running.close();
+			notify();
+		}
+	};
+	return {
+		status,
+		start,
+		stop,
+		subscribe: (listener) => {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		}
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/readdirp@5.1.1/node_modules/readdirp/index.js
+const EntryTypes = {
+	FILE_TYPE: "files",
+	DIR_TYPE: "directories",
+	FILE_DIR_TYPE: "files_directories",
+	EVERYTHING_TYPE: "all"
+};
+const defaultOptions = {
+	root: ".",
+	fileFilter: (_entryInfo) => true,
+	directoryFilter: (_entryInfo) => true,
+	type: EntryTypes.FILE_TYPE,
+	lstat: false,
+	depth: 2147483648,
+	alwaysStat: false,
+	highWaterMark: 256
+};
+Object.freeze(defaultOptions);
+const RECURSIVE_ERROR_CODE = "READDIRP_RECURSIVE_ERROR";
+const NORMAL_FLOW_ERRORS = /* @__PURE__ */ new Set([
+	"ENOENT",
+	"EPERM",
+	"EACCES",
+	"ELOOP",
+	RECURSIVE_ERROR_CODE
+]);
+const ALL_TYPES = [
+	EntryTypes.DIR_TYPE,
+	EntryTypes.EVERYTHING_TYPE,
+	EntryTypes.FILE_DIR_TYPE,
+	EntryTypes.FILE_TYPE
+];
+const DIR_TYPES = /* @__PURE__ */ new Set([
+	EntryTypes.DIR_TYPE,
+	EntryTypes.EVERYTHING_TYPE,
+	EntryTypes.FILE_DIR_TYPE
+]);
+const FILE_TYPES = /* @__PURE__ */ new Set([
+	EntryTypes.EVERYTHING_TYPE,
+	EntryTypes.FILE_DIR_TYPE,
+	EntryTypes.FILE_TYPE
+]);
+const isNormalFlowError = (error) => NORMAL_FLOW_ERRORS.has(error.code);
+const wantBigintFsStats = process.platform === "win32";
+const emptyFn = (_entryInfo) => true;
+const normalizeFilter = (filter) => {
+	if (filter === void 0) return emptyFn;
+	if (typeof filter === "function") return filter;
+	if (typeof filter === "string") {
+		const fl = filter.trim();
+		return (entry) => entry.basename === fl;
+	}
+	if (Array.isArray(filter)) {
+		const trItems = filter.map((item) => item.trim());
+		return (entry) => trItems.some((f) => entry.basename === f);
+	}
+	return emptyFn;
+};
+var ReaddirpStream = class extends Readable {
+	/**
+	* Directories discovered but not yet emitted from. Listings are read
+	* lazily (on pop, plus one prefetch) instead of eagerly on discovery:
+	* keeping whole listings for every queued dir balloons RAM on wide trees.
+	*/
+	parents;
+	reading;
+	parent;
+	_stat;
+	_maxDepth;
+	_wantsDir;
+	_wantsFile;
+	_wantsEverything;
+	_root;
+	_isDirent;
+	_statsProp;
+	_rdOptions;
+	_fileFilter;
+	_directoryFilter;
+	_relStart;
+	constructor(options = {}) {
+		super({
+			objectMode: true,
+			autoDestroy: true,
+			highWaterMark: options.highWaterMark ?? defaultOptions.highWaterMark
+		});
+		const opts = {
+			...defaultOptions,
+			...options
+		};
+		const root = opts.root ?? defaultOptions.root;
+		const type = opts.type ?? defaultOptions.type;
+		this._fileFilter = normalizeFilter(opts.fileFilter);
+		this._directoryFilter = normalizeFilter(opts.directoryFilter);
+		const statMethod = opts.lstat ? lstat : stat$1;
+		if (wantBigintFsStats) this._stat = (path) => statMethod(path, { bigint: true });
+		else this._stat = statMethod;
+		this._maxDepth = opts.depth != null && Number.isSafeInteger(opts.depth) ? opts.depth : defaultOptions.depth;
+		this._wantsDir = DIR_TYPES.has(type);
+		this._wantsFile = FILE_TYPES.has(type);
+		this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE;
+		this._root = resolve(root);
+		this._relStart = this._root.endsWith(sep) ? this._root.length : this._root.length + 1;
+		this._isDirent = !opts.alwaysStat;
+		this._statsProp = this._isDirent ? "dirent" : "stats";
+		this._rdOptions = {
+			encoding: "utf8",
+			withFileTypes: this._isDirent
+		};
+		const rootDir = {
+			path: this._root,
+			depth: 1
+		};
+		rootDir.pending = this._exploreDir(this._root, 1);
+		this.parents = [rootDir];
+		this.reading = false;
+		this.parent = void 0;
+	}
+	async _read(batch) {
+		if (this.reading) return;
+		this.reading = true;
+		try {
+			while (!this.destroyed && batch > 0) {
+				const par = this.parent;
+				const fil = par && par.files;
+				if (fil && fil.length > 0) {
+					const { path, depth } = par;
+					const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path));
+					const awaited = this._isDirent ? slice : await Promise.all(slice);
+					for (const entry of awaited) {
+						if (!entry) continue;
+						if (this.destroyed) return;
+						let entryType = this._getEntryType(entry);
+						if (typeof entryType !== "string") entryType = await entryType;
+						if (entryType === "directory" && this._directoryFilter(entry)) {
+							if (depth <= this._maxDepth) this.parents.push({
+								path: entry.fullPath,
+								depth: depth + 1
+							});
+							if (this._wantsDir) {
+								this.push(entry);
+								batch--;
+							}
+						} else if ((entryType === "file" || this._includeAsFile(entry)) && this._fileFilter(entry)) {
+							if (this._wantsFile) {
+								this.push(entry);
+								batch--;
+							}
+						}
+					}
+				} else {
+					const parent = this.parents.pop();
+					if (!parent) {
+						this.push(null);
+						break;
+					}
+					const dir = parent.pending ?? this._exploreDir(parent.path, parent.depth);
+					const next = this.parents[this.parents.length - 1];
+					if (next && !next.pending) next.pending = this._exploreDir(next.path, next.depth);
+					this.parent = await dir;
+					if (this.destroyed) return;
+				}
+			}
+		} catch (error) {
+			this.destroy(error);
+		} finally {
+			this.reading = false;
+		}
+	}
+	async _exploreDir(path, depth) {
+		let files;
+		try {
+			files = await readdir(path, this._rdOptions);
+		} catch (error) {
+			this._onError(error);
+		}
+		return {
+			files,
+			depth,
+			path
+		};
+	}
+	_formatEntry(dirent, path) {
+		const basename = this._isDirent ? dirent.name : dirent;
+		const fullPath = join(path, basename);
+		const entry = {
+			path: fullPath.slice(this._relStart),
+			fullPath,
+			basename
+		};
+		if (this._isDirent) {
+			entry.dirent = dirent;
+			return entry;
+		}
+		return this._stat(fullPath).then((stats) => {
+			entry.stats = stats;
+			return entry;
+		}, (err) => {
+			this._onError(err);
+		});
+	}
+	_onError(err) {
+		if (isNormalFlowError(err) && !this.destroyed) this.emit("warn", err);
+		else this.destroy(err);
+	}
+	_getEntryType(entry) {
+		if (!entry || !(this._statsProp in entry)) return "";
+		const stats = entry[this._statsProp];
+		if (stats.isFile()) return "file";
+		if (stats.isDirectory()) return "directory";
+		if (stats.isSymbolicLink()) return this._getSymlinkEntryType(entry);
+		return "";
+	}
+	async _getSymlinkEntryType(entry) {
+		const full = entry.fullPath;
+		try {
+			const entryRealPath = await realpath(full);
+			const entryRealPathStats = await lstat(entryRealPath);
+			if (entryRealPathStats.isFile()) return "file";
+			if (entryRealPathStats.isDirectory()) {
+				const len = entryRealPath.length;
+				if (full.startsWith(entryRealPath) && full[len] === sep) {
+					const recursiveError = /* @__PURE__ */ new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
+					recursiveError.code = RECURSIVE_ERROR_CODE;
+					this._onError(recursiveError);
+					return "";
+				}
+				return "directory";
+			}
+		} catch (error) {
+			this._onError(error);
+		}
+		return "";
+	}
+	_includeAsFile(entry) {
+		const stats = entry && entry[this._statsProp];
+		return stats && this._wantsEverything && !stats.isDirectory();
+	}
+};
+/**
+* Streaming version: Reads all files and directories in given root recursively.
+* Consumes ~constant small amount of RAM.
+* @param root Root directory
+* @param options Options to specify root (start directory), filters and recursion depth
+*/
+function readdirp(root, options = {}) {
+	let type = options.entryType || options.type;
+	if (type === "both") type = EntryTypes.FILE_DIR_TYPE;
+	if (!root) throw new Error("readdirp: root argument is required. Usage: readdirp(root, options)");
+	else if (typeof root !== "string") throw new TypeError("readdirp: root argument must be a string. Usage: readdirp(root, options)");
+	else if (type && !ALL_TYPES.includes(type)) throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(", ")}`);
+	const opts = {
+		...options,
+		root
+	};
+	if (type) opts.type = type;
+	return new ReaddirpStream(opts);
+}
+//#endregion
+//#region node_modules/.pnpm/chokidar@5.0.0/node_modules/chokidar/handler.js
+const STR_DATA = "data";
+const STR_CLOSE = "close";
+const EMPTY_FN = () => {};
+const pl = process.platform;
+const isWindows = pl === "win32";
+const isMacos = pl === "darwin";
+const isLinux = pl === "linux";
+const isFreeBSD = pl === "freebsd";
+const isIBMi = type() === "OS400";
+const EVENTS = {
+	ALL: "all",
+	READY: "ready",
+	ADD: "add",
+	CHANGE: "change",
+	ADD_DIR: "addDir",
+	UNLINK: "unlink",
+	UNLINK_DIR: "unlinkDir",
+	RAW: "raw",
+	ERROR: "error"
+};
+const EV = EVENTS;
+const THROTTLE_MODE_WATCH = "watch";
+const statMethods = {
+	lstat,
+	stat: stat$1
+};
+const KEY_LISTENERS = "listeners";
+const KEY_ERR = "errHandlers";
+const KEY_RAW = "rawEmitters";
+const HANDLER_KEYS = [
+	KEY_LISTENERS,
+	KEY_ERR,
+	KEY_RAW
+];
+const binaryExtensions = /* @__PURE__ */ new Set([
+	"3dm",
+	"3ds",
+	"3g2",
+	"3gp",
+	"7z",
+	"a",
+	"aac",
+	"adp",
+	"afdesign",
+	"afphoto",
+	"afpub",
+	"ai",
+	"aif",
+	"aiff",
+	"alz",
+	"ape",
+	"apk",
+	"appimage",
+	"ar",
+	"arj",
+	"asf",
+	"au",
+	"avi",
+	"bak",
+	"baml",
+	"bh",
+	"bin",
+	"bk",
+	"bmp",
+	"btif",
+	"bz2",
+	"bzip2",
+	"cab",
+	"caf",
+	"cgm",
+	"class",
+	"cmx",
+	"cpio",
+	"cr2",
+	"cur",
+	"dat",
+	"dcm",
+	"deb",
+	"dex",
+	"djvu",
+	"dll",
+	"dmg",
+	"dng",
+	"doc",
+	"docm",
+	"docx",
+	"dot",
+	"dotm",
+	"dra",
+	"DS_Store",
+	"dsk",
+	"dts",
+	"dtshd",
+	"dvb",
+	"dwg",
+	"dxf",
+	"ecelp4800",
+	"ecelp7470",
+	"ecelp9600",
+	"egg",
+	"eol",
+	"eot",
+	"epub",
+	"exe",
+	"f4v",
+	"fbs",
+	"fh",
+	"fla",
+	"flac",
+	"flatpak",
+	"fli",
+	"flv",
+	"fpx",
+	"fst",
+	"fvt",
+	"g3",
+	"gh",
+	"gif",
+	"graffle",
+	"gz",
+	"gzip",
+	"h261",
+	"h263",
+	"h264",
+	"icns",
+	"ico",
+	"ief",
+	"img",
+	"ipa",
+	"iso",
+	"jar",
+	"jpeg",
+	"jpg",
+	"jpgv",
+	"jpm",
+	"jxr",
+	"key",
+	"ktx",
+	"lha",
+	"lib",
+	"lvp",
+	"lz",
+	"lzh",
+	"lzma",
+	"lzo",
+	"m3u",
+	"m4a",
+	"m4v",
+	"mar",
+	"mdi",
+	"mht",
+	"mid",
+	"midi",
+	"mj2",
+	"mka",
+	"mkv",
+	"mmr",
+	"mng",
+	"mobi",
+	"mov",
+	"movie",
+	"mp3",
+	"mp4",
+	"mp4a",
+	"mpeg",
+	"mpg",
+	"mpga",
+	"mxu",
+	"nef",
+	"npx",
+	"numbers",
+	"nupkg",
+	"o",
+	"odp",
+	"ods",
+	"odt",
+	"oga",
+	"ogg",
+	"ogv",
+	"otf",
+	"ott",
+	"pages",
+	"pbm",
+	"pcx",
+	"pdb",
+	"pdf",
+	"pea",
+	"pgm",
+	"pic",
+	"png",
+	"pnm",
+	"pot",
+	"potm",
+	"potx",
+	"ppa",
+	"ppam",
+	"ppm",
+	"pps",
+	"ppsm",
+	"ppsx",
+	"ppt",
+	"pptm",
+	"pptx",
+	"psd",
+	"pya",
+	"pyc",
+	"pyo",
+	"pyv",
+	"qt",
+	"rar",
+	"ras",
+	"raw",
+	"resources",
+	"rgb",
+	"rip",
+	"rlc",
+	"rmf",
+	"rmvb",
+	"rpm",
+	"rtf",
+	"rz",
+	"s3m",
+	"s7z",
+	"scpt",
+	"sgi",
+	"shar",
+	"snap",
+	"sil",
+	"sketch",
+	"slk",
+	"smv",
+	"snk",
+	"so",
+	"stl",
+	"suo",
+	"sub",
+	"swf",
+	"tar",
+	"tbz",
+	"tbz2",
+	"tga",
+	"tgz",
+	"thmx",
+	"tif",
+	"tiff",
+	"tlz",
+	"ttc",
+	"ttf",
+	"txz",
+	"udf",
+	"uvh",
+	"uvi",
+	"uvm",
+	"uvp",
+	"uvs",
+	"uvu",
+	"viv",
+	"vob",
+	"war",
+	"wav",
+	"wax",
+	"wbmp",
+	"wdp",
+	"weba",
+	"webm",
+	"webp",
+	"whl",
+	"wim",
+	"wm",
+	"wma",
+	"wmv",
+	"wmx",
+	"woff",
+	"woff2",
+	"wrm",
+	"wvx",
+	"xbm",
+	"xif",
+	"xla",
+	"xlam",
+	"xls",
+	"xlsb",
+	"xlsm",
+	"xlsx",
+	"xlt",
+	"xltm",
+	"xltx",
+	"xm",
+	"xmind",
+	"xpi",
+	"xpm",
+	"xwd",
+	"xz",
+	"z",
+	"zip",
+	"zipx"
+]);
+const isBinaryPath = (filePath) => binaryExtensions.has(sp.extname(filePath).slice(1).toLowerCase());
+const foreach = (val, fn) => {
+	if (val instanceof Set) val.forEach(fn);
+	else fn(val);
+};
+const addAndConvert = (main, prop, item) => {
+	let container = main[prop];
+	if (!(container instanceof Set)) main[prop] = container = /* @__PURE__ */ new Set([container]);
+	container.add(item);
+};
+const clearItem = (cont) => (key) => {
+	const set = cont[key];
+	if (set instanceof Set) set.clear();
+	else delete cont[key];
+};
+const delFromSet = (main, prop, item) => {
+	const container = main[prop];
+	if (container instanceof Set) container.delete(item);
+	else if (container === item) delete main[prop];
+};
+const isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
+const FsWatchInstances = /* @__PURE__ */ new Map();
+/**
+* Instantiates the fs_watch interface
+* @param path to be watched
+* @param options to be passed to fs_watch
+* @param listener main event handler
+* @param errHandler emits info about errors
+* @param emitRaw emits raw event data
+* @returns {NativeFsWatcher}
+*/
+function createFsWatchInstance(path, options, listener, errHandler, emitRaw) {
+	const handleEvent = (rawEvent, evPath) => {
+		listener(path);
+		emitRaw(rawEvent, evPath, { watchedPath: path });
+		if (evPath && path !== evPath) fsWatchBroadcast(sp.resolve(path, evPath), KEY_LISTENERS, sp.join(path, evPath));
+	};
+	try {
+		return watch(path, { persistent: options.persistent }, handleEvent);
+	} catch (error) {
+		errHandler(error);
+		return;
+	}
+}
+/**
+* Helper for passing fs_watch event data to a collection of listeners
+* @param fullPath absolute path bound to fs_watch instance
+*/
+const fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
+	const cont = FsWatchInstances.get(fullPath);
+	if (!cont) return;
+	foreach(cont[listenerType], (listener) => {
+		listener(val1, val2, val3);
+	});
+};
+/**
+* Instantiates the fs_watch interface or binds listeners
+* to an existing one covering the same file system entry
+* @param path
+* @param fullPath absolute path
+* @param options to be passed to fs_watch
+* @param handlers container for event listener functions
+*/
+const setFsWatchListener = (path, fullPath, options, handlers) => {
+	const { listener, errHandler, rawEmitter } = handlers;
+	let cont = FsWatchInstances.get(fullPath);
+	let watcher;
+	if (!options.persistent) {
+		watcher = createFsWatchInstance(path, options, listener, errHandler, rawEmitter);
+		if (!watcher) return;
+		return watcher.close.bind(watcher);
+	}
+	if (cont) {
+		addAndConvert(cont, KEY_LISTENERS, listener);
+		addAndConvert(cont, KEY_ERR, errHandler);
+		addAndConvert(cont, KEY_RAW, rawEmitter);
+	} else {
+		watcher = createFsWatchInstance(path, options, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, fsWatchBroadcast.bind(null, fullPath, KEY_RAW));
+		if (!watcher) return;
+		watcher.on(EV.ERROR, async (error) => {
+			const broadcastErr = fsWatchBroadcast.bind(null, fullPath, KEY_ERR);
+			if (cont) cont.watcherUnusable = true;
+			if (isWindows && error.code === "EPERM") try {
+				await (await open(path, "r")).close();
+				broadcastErr(error);
+			} catch (err) {}
+			else broadcastErr(error);
+		});
+		cont = {
+			listeners: listener,
+			errHandlers: errHandler,
+			rawEmitters: rawEmitter,
+			watcher
+		};
+		FsWatchInstances.set(fullPath, cont);
+	}
+	return () => {
+		delFromSet(cont, KEY_LISTENERS, listener);
+		delFromSet(cont, KEY_ERR, errHandler);
+		delFromSet(cont, KEY_RAW, rawEmitter);
+		if (isEmptySet(cont.listeners)) {
+			cont.watcher.close();
+			FsWatchInstances.delete(fullPath);
+			HANDLER_KEYS.forEach(clearItem(cont));
+			cont.watcher = void 0;
+			Object.freeze(cont);
+		}
+	};
+};
+const FsWatchFileInstances = /* @__PURE__ */ new Map();
+/**
+* Instantiates the fs_watchFile interface or binds listeners
+* to an existing one covering the same file system entry
+* @param path to be watched
+* @param fullPath absolute path
+* @param options options to be passed to fs_watchFile
+* @param handlers container for event listener functions
+* @returns closer
+*/
+const setFsWatchFileListener = (path, fullPath, options, handlers) => {
+	const { listener, rawEmitter } = handlers;
+	let cont = FsWatchFileInstances.get(fullPath);
+	const copts = cont && cont.options;
+	if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
+		unwatchFile(fullPath);
+		cont = void 0;
+	}
+	if (cont) {
+		addAndConvert(cont, KEY_LISTENERS, listener);
+		addAndConvert(cont, KEY_RAW, rawEmitter);
+	} else {
+		cont = {
+			listeners: listener,
+			rawEmitters: rawEmitter,
+			options,
+			watcher: watchFile(fullPath, options, (curr, prev) => {
+				foreach(cont.rawEmitters, (rawEmitter) => {
+					rawEmitter(EV.CHANGE, fullPath, {
+						curr,
+						prev
+					});
+				});
+				const currmtime = curr.mtimeMs;
+				if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) foreach(cont.listeners, (listener) => listener(path, curr));
+			})
+		};
+		FsWatchFileInstances.set(fullPath, cont);
+	}
+	return () => {
+		delFromSet(cont, KEY_LISTENERS, listener);
+		delFromSet(cont, KEY_RAW, rawEmitter);
+		if (isEmptySet(cont.listeners)) {
+			FsWatchFileInstances.delete(fullPath);
+			unwatchFile(fullPath);
+			cont.options = cont.watcher = void 0;
+			Object.freeze(cont);
+		}
+	};
+};
+/**
+* @mixin
+*/
+var NodeFsHandler = class {
+	fsw;
+	_boundHandleError;
+	constructor(fsW) {
+		this.fsw = fsW;
+		this._boundHandleError = (error) => fsW._handleError(error);
+	}
+	/**
+	* Watch file for changes with fs_watchFile or fs_watch.
+	* @param path to file or dir
+	* @param listener on fs change
+	* @returns closer for the watcher instance
+	*/
+	_watchWithNodeFs(path, listener) {
+		const opts = this.fsw.options;
+		const directory = sp.dirname(path);
+		const basename = sp.basename(path);
+		this.fsw._getWatchedDir(directory).add(basename);
+		const absolutePath = sp.resolve(path);
+		const options = { persistent: opts.persistent };
+		if (!listener) listener = EMPTY_FN;
+		let closer;
+		if (opts.usePolling) {
+			options.interval = opts.interval !== opts.binaryInterval && isBinaryPath(basename) ? opts.binaryInterval : opts.interval;
+			closer = setFsWatchFileListener(path, absolutePath, options, {
+				listener,
+				rawEmitter: this.fsw._emitRaw
+			});
+		} else closer = setFsWatchListener(path, absolutePath, options, {
+			listener,
+			errHandler: this._boundHandleError,
+			rawEmitter: this.fsw._emitRaw
+		});
+		return closer;
+	}
+	/**
+	* Watch a file and emit add event if warranted.
+	* @returns closer for the watcher instance
+	*/
+	_handleFile(file, stats, initialAdd) {
+		if (this.fsw.closed) return;
+		const dirname = sp.dirname(file);
+		const basename = sp.basename(file);
+		const parent = this.fsw._getWatchedDir(dirname);
+		let prevStats = stats;
+		if (parent.has(basename)) return;
+		const listener = async (path, newStats) => {
+			if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5)) return;
+			if (!newStats || newStats.mtimeMs === 0) try {
+				const newStats = await stat$1(file);
+				if (this.fsw.closed) return;
+				const at = newStats.atimeMs;
+				const mt = newStats.mtimeMs;
+				if (!at || at <= mt || mt !== prevStats.mtimeMs) this.fsw._emit(EV.CHANGE, file, newStats);
+				if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats.ino) {
+					this.fsw._closeFile(path);
+					prevStats = newStats;
+					const closer = this._watchWithNodeFs(file, listener);
+					if (closer) this.fsw._addPathCloser(path, closer);
+				} else prevStats = newStats;
+			} catch (error) {
+				this.fsw._remove(dirname, basename);
+			}
+			else if (parent.has(basename)) {
+				const at = newStats.atimeMs;
+				const mt = newStats.mtimeMs;
+				if (!at || at <= mt || mt !== prevStats.mtimeMs) this.fsw._emit(EV.CHANGE, file, newStats);
+				prevStats = newStats;
+			}
+		};
+		const closer = this._watchWithNodeFs(file, listener);
+		if (!(initialAdd && this.fsw.options.ignoreInitial) && this.fsw._isntIgnored(file)) {
+			if (!this.fsw._throttle(EV.ADD, file, 0)) return;
+			this.fsw._emit(EV.ADD, file, stats);
+		}
+		return closer;
+	}
+	/**
+	* Handle symlinks encountered while reading a dir.
+	* @param entry returned by readdirp
+	* @param directory path of dir being read
+	* @param path of this item
+	* @param item basename of this item
+	* @returns true if no more processing is needed for this entry.
+	*/
+	async _handleSymlink(entry, directory, path, item) {
+		if (this.fsw.closed) return;
+		const full = entry.fullPath;
+		const dir = this.fsw._getWatchedDir(directory);
+		if (!this.fsw.options.followSymlinks) {
+			this.fsw._incrReadyCount();
+			let linkPath;
+			try {
+				linkPath = await realpath(path);
+			} catch (e) {
+				this.fsw._emitReady();
+				return true;
+			}
+			if (this.fsw.closed) return;
+			if (dir.has(item)) {
+				if (this.fsw._symlinkPaths.get(full) !== linkPath) {
+					this.fsw._symlinkPaths.set(full, linkPath);
+					this.fsw._emit(EV.CHANGE, path, entry.stats);
+				}
+			} else {
+				dir.add(item);
+				this.fsw._symlinkPaths.set(full, linkPath);
+				this.fsw._emit(EV.ADD, path, entry.stats);
+			}
+			this.fsw._emitReady();
+			return true;
+		}
+		if (this.fsw._symlinkPaths.has(full)) return true;
+		this.fsw._symlinkPaths.set(full, true);
+	}
+	_handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
+		directory = sp.join(directory, "");
+		const throttleKey = target ? `${directory}:${target}` : directory;
+		throttler = this.fsw._throttle("readdir", throttleKey, 1e3);
+		if (!throttler) return;
+		const previous = this.fsw._getWatchedDir(wh.path);
+		const current = /* @__PURE__ */ new Set();
+		let stream = this.fsw._readdirp(directory, {
+			fileFilter: (entry) => wh.filterPath(entry),
+			directoryFilter: (entry) => wh.filterDir(entry)
+		});
+		if (!stream) return;
+		stream.on(STR_DATA, async (entry) => {
+			if (this.fsw.closed) {
+				stream = void 0;
+				return;
+			}
+			const item = entry.path;
+			let path = sp.join(directory, item);
+			current.add(item);
+			if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path, item)) return;
+			if (this.fsw.closed) {
+				stream = void 0;
+				return;
+			}
+			if (item === target || !target && !previous.has(item)) {
+				this.fsw._incrReadyCount();
+				path = sp.join(dir, sp.relative(dir, path));
+				this._addToNodeFs(path, initialAdd, wh, depth + 1);
+			}
+		}).on(EV.ERROR, this._boundHandleError);
+		return new Promise((resolve, reject) => {
+			if (!stream) return reject();
+			stream.once("end", () => {
+				if (this.fsw.closed) {
+					stream = void 0;
+					return;
+				}
+				const wasThrottled = throttler ? throttler.clear() : false;
+				resolve(void 0);
+				previous.getChildren().filter((item) => {
+					return item !== directory && !current.has(item);
+				}).forEach((item) => {
+					this.fsw._remove(directory, item);
+				});
+				stream = void 0;
+				if (wasThrottled) this._handleRead(directory, false, wh, target, dir, depth, throttler);
+			});
+		});
+	}
+	/**
+	* Read directory to add / remove files from `@watched` list and re-read it on change.
+	* @param dir fs path
+	* @param stats
+	* @param initialAdd
+	* @param depth relative to user-supplied path
+	* @param target child path targeted for watch
+	* @param wh Common watch helpers for this path
+	* @param realpath
+	* @returns closer for the watcher instance.
+	*/
+	async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath) {
+		const parentDir = this.fsw._getWatchedDir(sp.dirname(dir));
+		const tracked = parentDir.has(sp.basename(dir));
+		if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) this.fsw._emit(EV.ADD_DIR, dir, stats);
+		parentDir.add(sp.basename(dir));
+		this.fsw._getWatchedDir(dir);
+		let throttler;
+		let closer;
+		const oDepth = this.fsw.options.depth;
+		if ((oDepth == null || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath)) {
+			if (!target) {
+				await this._handleRead(dir, initialAdd, wh, target, dir, depth, throttler);
+				if (this.fsw.closed) return;
+			}
+			closer = this._watchWithNodeFs(dir, (dirPath, stats) => {
+				if (stats && stats.mtimeMs === 0) return;
+				this._handleRead(dirPath, false, wh, target, dir, depth, throttler);
+			});
+		}
+		return closer;
+	}
+	/**
+	* Handle added file, directory, or glob pattern.
+	* Delegates call to _handleFile / _handleDir after checks.
+	* @param path to file or ir
+	* @param initialAdd was the file added at watch instantiation?
+	* @param priorWh depth relative to user-supplied path
+	* @param depth Child path actually targeted for watch
+	* @param target Child path actually targeted for watch
+	*/
+	async _addToNodeFs(path, initialAdd, priorWh, depth, target) {
+		const ready = this.fsw._emitReady;
+		if (this.fsw._isIgnored(path) || this.fsw.closed) {
+			ready();
+			return false;
+		}
+		const wh = this.fsw._getWatchHelpers(path);
+		if (priorWh) {
+			wh.filterPath = (entry) => priorWh.filterPath(entry);
+			wh.filterDir = (entry) => priorWh.filterDir(entry);
+		}
+		try {
+			const stats = await statMethods[wh.statMethod](wh.watchPath);
+			if (this.fsw.closed) return;
+			if (this.fsw._isIgnored(wh.watchPath, stats)) {
+				ready();
+				return false;
+			}
+			const follow = this.fsw.options.followSymlinks;
+			let closer;
+			if (stats.isDirectory()) {
+				const absPath = sp.resolve(path);
+				const targetPath = follow ? await realpath(path) : path;
+				if (this.fsw.closed) return;
+				closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
+				if (this.fsw.closed) return;
+				if (absPath !== targetPath && targetPath !== void 0) this.fsw._symlinkPaths.set(absPath, targetPath);
+			} else if (stats.isSymbolicLink()) {
+				const targetPath = follow ? await realpath(path) : path;
+				if (this.fsw.closed) return;
+				const parent = sp.dirname(wh.watchPath);
+				this.fsw._getWatchedDir(parent).add(wh.watchPath);
+				this.fsw._emit(EV.ADD, wh.watchPath, stats);
+				closer = await this._handleDir(parent, stats, initialAdd, depth, path, wh, targetPath);
+				if (this.fsw.closed) return;
+				if (targetPath !== void 0) this.fsw._symlinkPaths.set(sp.resolve(path), targetPath);
+			} else closer = this._handleFile(wh.watchPath, stats, initialAdd);
+			ready();
+			if (closer) this.fsw._addPathCloser(path, closer);
+			return false;
+		} catch (error) {
+			if (this.fsw._handleError(error)) {
+				ready();
+				return path;
+			}
+		}
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/chokidar@5.0.0/node_modules/chokidar/index.js
+/*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) */
+const SLASH = "/";
+const SLASH_SLASH = "//";
+const ONE_DOT = ".";
+const TWO_DOTS = "..";
+const STRING_TYPE = "string";
+const BACK_SLASH_RE = /\\/g;
+const DOUBLE_SLASH_RE = /\/\//g;
+const DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
+const REPLACER_RE = /^\.[/\\]/;
+function arrify(item) {
+	return Array.isArray(item) ? item : [item];
+}
+const isMatcherObject = (matcher) => typeof matcher === "object" && matcher !== null && !(matcher instanceof RegExp);
+function createPattern(matcher) {
+	if (typeof matcher === "function") return matcher;
+	if (typeof matcher === "string") return (string) => matcher === string;
+	if (matcher instanceof RegExp) return (string) => matcher.test(string);
+	if (typeof matcher === "object" && matcher !== null) return (string) => {
+		if (matcher.path === string) return true;
+		if (matcher.recursive) {
+			const relative = sp.relative(matcher.path, string);
+			if (!relative) return false;
+			return !relative.startsWith("..") && !sp.isAbsolute(relative);
+		}
+		return false;
+	};
+	return () => false;
+}
+function normalizePath(path) {
+	if (typeof path !== "string") throw new Error("string expected");
+	path = sp.normalize(path);
+	path = path.replace(/\\/g, "/");
+	let prepend = false;
+	if (path.startsWith("//")) prepend = true;
+	path = path.replace(DOUBLE_SLASH_RE, "/");
+	if (prepend) path = "/" + path;
+	return path;
+}
+function matchPatterns(patterns, testString, stats) {
+	const path = normalizePath(testString);
+	for (let index = 0; index < patterns.length; index++) {
+		const pattern = patterns[index];
+		if (pattern(path, stats)) return true;
+	}
+	return false;
+}
+function anymatch(matchers, testString) {
+	if (matchers == null) throw new TypeError("anymatch: specify first argument");
+	const patterns = arrify(matchers).map((matcher) => createPattern(matcher));
+	if (testString == null) return (testString, stats) => {
+		return matchPatterns(patterns, testString, stats);
+	};
+	return matchPatterns(patterns, testString);
+}
+const unifyPaths = (paths_) => {
+	const paths = arrify(paths_).flat();
+	if (!paths.every((p) => typeof p === STRING_TYPE)) throw new TypeError(`Non-string provided as watch path: ${paths}`);
+	return paths.map(normalizePathToUnix);
+};
+const toUnix = (string) => {
+	let str = string.replace(BACK_SLASH_RE, SLASH);
+	let prepend = false;
+	if (str.startsWith(SLASH_SLASH)) prepend = true;
+	str = str.replace(DOUBLE_SLASH_RE, SLASH);
+	if (prepend) str = SLASH + str;
+	return str;
+};
+const normalizePathToUnix = (path) => toUnix(sp.normalize(toUnix(path)));
+const normalizeIgnored = (cwd = "") => (path) => {
+	if (typeof path === "string") return normalizePathToUnix(sp.isAbsolute(path) ? path : sp.join(cwd, path));
+	else return path;
+};
+const getAbsolutePath = (path, cwd) => {
+	if (sp.isAbsolute(path)) return path;
+	return sp.join(cwd, path);
+};
+const EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
+/**
+* Directory entry.
+*/
+var DirEntry = class {
+	path;
+	_removeWatcher;
+	items;
+	constructor(dir, removeWatcher) {
+		this.path = dir;
+		this._removeWatcher = removeWatcher;
+		this.items = /* @__PURE__ */ new Set();
+	}
+	add(item) {
+		const { items } = this;
+		if (!items) return;
+		if (item !== ONE_DOT && item !== TWO_DOTS) items.add(item);
+	}
+	async remove(item) {
+		const { items } = this;
+		if (!items) return;
+		items.delete(item);
+		if (items.size > 0) return;
+		const dir = this.path;
+		try {
+			await readdir(dir);
+		} catch (err) {
+			if (this._removeWatcher) this._removeWatcher(sp.dirname(dir), sp.basename(dir));
+		}
+	}
+	has(item) {
+		const { items } = this;
+		if (!items) return;
+		return items.has(item);
+	}
+	getChildren() {
+		const { items } = this;
+		if (!items) return [];
+		return [...items.values()];
+	}
+	dispose() {
+		this.items.clear();
+		this.path = "";
+		this._removeWatcher = EMPTY_FN;
+		this.items = EMPTY_SET;
+		Object.freeze(this);
+	}
+};
+const STAT_METHOD_F = "stat";
+const STAT_METHOD_L = "lstat";
+var WatchHelper = class {
+	fsw;
+	path;
+	watchPath;
+	fullWatchPath;
+	dirParts;
+	followSymlinks;
+	statMethod;
+	constructor(path, follow, fsw) {
+		this.fsw = fsw;
+		const watchPath = path;
+		this.path = path = path.replace(REPLACER_RE, "");
+		this.watchPath = watchPath;
+		this.fullWatchPath = sp.resolve(watchPath);
+		this.dirParts = [];
+		this.dirParts.forEach((parts) => {
+			if (parts.length > 1) parts.pop();
+		});
+		this.followSymlinks = follow;
+		this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
+	}
+	entryPath(entry) {
+		return sp.join(this.watchPath, sp.relative(this.watchPath, entry.fullPath));
+	}
+	filterPath(entry) {
+		const { stats } = entry;
+		if (stats && stats.isSymbolicLink()) return this.filterDir(entry);
+		const resolvedPath = this.entryPath(entry);
+		return this.fsw._isntIgnored(resolvedPath, stats) && this.fsw._hasReadPermissions(stats);
+	}
+	filterDir(entry) {
+		return this.fsw._isntIgnored(this.entryPath(entry), entry.stats);
+	}
+};
+/**
+* Watches files & directories for changes. Emitted events:
+* `add`, `addDir`, `change`, `unlink`, `unlinkDir`, `all`, `error`
+*
+*     new FSWatcher()
+*       .add(directories)
+*       .on('add', path => log('File', path, 'was added'))
+*/
+var FSWatcher = class extends EventEmitter {
+	closed;
+	options;
+	_closers;
+	_ignoredPaths;
+	_throttled;
+	_streams;
+	_symlinkPaths;
+	_watched;
+	_pendingWrites;
+	_pendingUnlinks;
+	_readyCount;
+	_emitReady;
+	_closePromise;
+	_userIgnored;
+	_readyEmitted;
+	_emitRaw;
+	_boundRemove;
+	_nodeFsHandler;
+	constructor(_opts = {}) {
+		super();
+		this.closed = false;
+		this._closers = /* @__PURE__ */ new Map();
+		this._ignoredPaths = /* @__PURE__ */ new Set();
+		this._throttled = /* @__PURE__ */ new Map();
+		this._streams = /* @__PURE__ */ new Set();
+		this._symlinkPaths = /* @__PURE__ */ new Map();
+		this._watched = /* @__PURE__ */ new Map();
+		this._pendingWrites = /* @__PURE__ */ new Map();
+		this._pendingUnlinks = /* @__PURE__ */ new Map();
+		this._readyCount = 0;
+		this._readyEmitted = false;
+		const awf = _opts.awaitWriteFinish;
+		const DEF_AWF = {
+			stabilityThreshold: 2e3,
+			pollInterval: 100
+		};
+		const opts = {
+			persistent: true,
+			ignoreInitial: false,
+			ignorePermissionErrors: false,
+			interval: 100,
+			binaryInterval: 300,
+			followSymlinks: true,
+			usePolling: false,
+			atomic: true,
+			..._opts,
+			ignored: _opts.ignored ? arrify(_opts.ignored) : arrify([]),
+			awaitWriteFinish: awf === true ? DEF_AWF : typeof awf === "object" ? {
+				...DEF_AWF,
+				...awf
+			} : false
+		};
+		if (isIBMi) opts.usePolling = true;
+		if (opts.atomic === void 0) opts.atomic = !opts.usePolling;
+		const envPoll = process.env.CHOKIDAR_USEPOLLING;
+		if (envPoll !== void 0) {
+			const envLower = envPoll.toLowerCase();
+			if (envLower === "false" || envLower === "0") opts.usePolling = false;
+			else if (envLower === "true" || envLower === "1") opts.usePolling = true;
+			else opts.usePolling = !!envLower;
+		}
+		const envInterval = process.env.CHOKIDAR_INTERVAL;
+		if (envInterval) opts.interval = Number.parseInt(envInterval, 10);
+		let readyCalls = 0;
+		this._emitReady = () => {
+			readyCalls++;
+			if (readyCalls >= this._readyCount) {
+				this._emitReady = EMPTY_FN;
+				this._readyEmitted = true;
+				process.nextTick(() => this.emit(EVENTS.READY));
+			}
+		};
+		this._emitRaw = (...args) => this.emit(EVENTS.RAW, ...args);
+		this._boundRemove = this._remove.bind(this);
+		this.options = opts;
+		this._nodeFsHandler = new NodeFsHandler(this);
+		Object.freeze(opts);
+	}
+	_addIgnoredPath(matcher) {
+		if (isMatcherObject(matcher)) {
+			for (const ignored of this._ignoredPaths) if (isMatcherObject(ignored) && ignored.path === matcher.path && ignored.recursive === matcher.recursive) return;
+		}
+		this._ignoredPaths.add(matcher);
+	}
+	_removeIgnoredPath(matcher) {
+		this._ignoredPaths.delete(matcher);
+		if (typeof matcher === "string") {
+			for (const ignored of this._ignoredPaths) if (isMatcherObject(ignored) && ignored.path === matcher) this._ignoredPaths.delete(ignored);
+		}
+	}
+	/**
+	* Adds paths to be watched on an existing FSWatcher instance.
+	* @param paths_ file or file list. Other arguments are unused
+	*/
+	add(paths_, _origAdd, _internal) {
+		const { cwd } = this.options;
+		this.closed = false;
+		this._closePromise = void 0;
+		let paths = unifyPaths(paths_);
+		if (cwd) paths = paths.map((path) => {
+			return getAbsolutePath(path, cwd);
+		});
+		paths.forEach((path) => {
+			this._removeIgnoredPath(path);
+		});
+		this._userIgnored = void 0;
+		if (!this._readyCount) this._readyCount = 0;
+		this._readyCount += paths.length;
+		Promise.all(paths.map(async (path) => {
+			const res = await this._nodeFsHandler._addToNodeFs(path, !_internal, void 0, 0, _origAdd);
+			if (res) this._emitReady();
+			return res;
+		})).then((results) => {
+			if (this.closed) return;
+			results.forEach((item) => {
+				if (item) this.add(sp.dirname(item), sp.basename(_origAdd || item));
+			});
+		});
+		return this;
+	}
+	/**
+	* Close watchers or start ignoring events from specified paths.
+	*/
+	unwatch(paths_) {
+		if (this.closed) return this;
+		const paths = unifyPaths(paths_);
+		const { cwd } = this.options;
+		paths.forEach((path) => {
+			if (!sp.isAbsolute(path) && !this._closers.has(path)) {
+				if (cwd) path = sp.join(cwd, path);
+				path = sp.resolve(path);
+			}
+			this._closePath(path);
+			this._addIgnoredPath(path);
+			if (this._watched.has(path)) this._addIgnoredPath({
+				path,
+				recursive: true
+			});
+			this._userIgnored = void 0;
+		});
+		return this;
+	}
+	/**
+	* Close watchers and remove all listeners from watched paths.
+	*/
+	close() {
+		if (this._closePromise) return this._closePromise;
+		this.closed = true;
+		this.removeAllListeners();
+		const closers = [];
+		this._closers.forEach((closerList) => closerList.forEach((closer) => {
+			const promise = closer();
+			if (promise instanceof Promise) closers.push(promise);
+		}));
+		this._streams.forEach((stream) => stream.destroy());
+		this._userIgnored = void 0;
+		this._readyCount = 0;
+		this._readyEmitted = false;
+		this._watched.forEach((dirent) => dirent.dispose());
+		this._closers.clear();
+		this._watched.clear();
+		this._streams.clear();
+		this._symlinkPaths.clear();
+		this._throttled.clear();
+		this._closePromise = closers.length ? Promise.all(closers).then(() => void 0) : Promise.resolve();
+		return this._closePromise;
+	}
+	/**
+	* Expose list of watched paths
+	* @returns for chaining
+	*/
+	getWatched() {
+		const watchList = {};
+		this._watched.forEach((entry, dir) => {
+			const index = (this.options.cwd ? sp.relative(this.options.cwd, dir) : dir) || ONE_DOT;
+			watchList[index] = entry.getChildren().sort();
+		});
+		return watchList;
+	}
+	emitWithAll(event, args) {
+		this.emit(event, ...args);
+		if (event !== EVENTS.ERROR) this.emit(EVENTS.ALL, event, ...args);
+	}
+	/**
+	* Normalize and emit events.
+	* Calling _emit DOES NOT MEAN emit() would be called!
+	* @param event Type of event
+	* @param path File or directory path
+	* @param stats arguments to be passed with event
+	* @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+	*/
+	async _emit(event, path, stats) {
+		if (this.closed) return;
+		const opts = this.options;
+		if (isWindows) path = sp.normalize(path);
+		if (opts.cwd) path = sp.relative(opts.cwd, path);
+		const args = [path];
+		if (stats != null) args.push(stats);
+		const awf = opts.awaitWriteFinish;
+		let pw;
+		if (awf && (pw = this._pendingWrites.get(path))) {
+			pw.lastChange = /* @__PURE__ */ new Date();
+			return this;
+		}
+		if (opts.atomic) {
+			if (event === EVENTS.UNLINK) {
+				this._pendingUnlinks.set(path, [event, ...args]);
+				setTimeout(() => {
+					this._pendingUnlinks.forEach((entry, path) => {
+						this.emit(...entry);
+						this.emit(EVENTS.ALL, ...entry);
+						this._pendingUnlinks.delete(path);
+					});
+				}, typeof opts.atomic === "number" ? opts.atomic : 100);
+				return this;
+			}
+			if (event === EVENTS.ADD && this._pendingUnlinks.has(path)) {
+				event = EVENTS.CHANGE;
+				this._pendingUnlinks.delete(path);
+			}
+		}
+		if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
+			const awfEmit = (err, stats) => {
+				if (err) {
+					event = EVENTS.ERROR;
+					args[0] = err;
+					this.emitWithAll(event, args);
+				} else if (stats) {
+					if (args.length > 1) args[1] = stats;
+					else args.push(stats);
+					this.emitWithAll(event, args);
+				}
+			};
+			this._awaitWriteFinish(path, awf.stabilityThreshold, event, awfEmit);
+			return this;
+		}
+		if (event === EVENTS.CHANGE) {
+			if (!this._throttle(EVENTS.CHANGE, path, 50)) return this;
+		}
+		if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
+			const fullPath = opts.cwd ? sp.join(opts.cwd, path) : path;
+			let stats;
+			try {
+				stats = await stat$1(fullPath);
+			} catch (err) {}
+			if (!stats || this.closed) return;
+			args.push(stats);
+		}
+		this.emitWithAll(event, args);
+		return this;
+	}
+	/**
+	* Common handler for errors
+	* @returns The error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+	*/
+	_handleError(error) {
+		const code = error && error.code;
+		if (error && code !== "ENOENT" && code !== "ENOTDIR" && (!this.options.ignorePermissionErrors || code !== "EPERM" && code !== "EACCES")) this.emit(EVENTS.ERROR, error);
+		return error || this.closed;
+	}
+	/**
+	* Helper utility for throttling
+	* @param actionType type being throttled
+	* @param path being acted upon
+	* @param timeout duration of time to suppress duplicate actions
+	* @returns tracking object or false if action should be suppressed
+	*/
+	_throttle(actionType, path, timeout) {
+		if (!this._throttled.has(actionType)) this._throttled.set(actionType, /* @__PURE__ */ new Map());
+		const action = this._throttled.get(actionType);
+		if (!action) throw new Error("invalid throttle");
+		const actionPath = action.get(path);
+		if (actionPath) {
+			actionPath.count++;
+			return false;
+		}
+		let timeoutObject;
+		const clear = () => {
+			const item = action.get(path);
+			const count = item ? item.count : 0;
+			action.delete(path);
+			clearTimeout(timeoutObject);
+			if (item) clearTimeout(item.timeoutObject);
+			return count;
+		};
+		timeoutObject = setTimeout(clear, timeout);
+		const thr = {
+			timeoutObject,
+			clear,
+			count: 0
+		};
+		action.set(path, thr);
+		return thr;
+	}
+	_incrReadyCount() {
+		return this._readyCount++;
+	}
+	/**
+	* Awaits write operation to finish.
+	* Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback.
+	* @param path being acted upon
+	* @param threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished
+	* @param event
+	* @param awfEmit Callback to be called when ready for event to be emitted.
+	*/
+	_awaitWriteFinish(path, threshold, event, awfEmit) {
+		const awf = this.options.awaitWriteFinish;
+		if (typeof awf !== "object") return;
+		const pollInterval = awf.pollInterval;
+		let timeoutHandler;
+		let fullPath = path;
+		if (this.options.cwd && !sp.isAbsolute(path)) fullPath = sp.join(this.options.cwd, path);
+		const now = /* @__PURE__ */ new Date();
+		const writes = this._pendingWrites;
+		function awaitWriteFinishFn(prevStat) {
+			stat(fullPath, (err, curStat) => {
+				if (err || !writes.has(path)) {
+					if (err && err.code !== "ENOENT") awfEmit(err);
+					return;
+				}
+				const now = Number(/* @__PURE__ */ new Date());
+				if (prevStat && curStat.size !== prevStat.size) writes.get(path).lastChange = now;
+				if (now - writes.get(path).lastChange >= threshold) {
+					writes.delete(path);
+					awfEmit(void 0, curStat);
+				} else timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
+			});
+		}
+		if (!writes.has(path)) {
+			writes.set(path, {
+				lastChange: now,
+				cancelWait: () => {
+					writes.delete(path);
+					clearTimeout(timeoutHandler);
+					return event;
+				}
+			});
+			timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval);
+		}
+	}
+	/**
+	* Determines whether user has asked to ignore this path.
+	*/
+	_isIgnored(path, stats) {
+		if (this.options.atomic && DOT_RE.test(path)) return true;
+		if (!this._userIgnored) {
+			const { cwd } = this.options;
+			const ignored = (this.options.ignored || []).map(normalizeIgnored(cwd));
+			const list = [...[...this._ignoredPaths].map(normalizeIgnored(cwd)), ...ignored];
+			this._userIgnored = anymatch(list, void 0);
+		}
+		return this._userIgnored(path, stats);
+	}
+	_isntIgnored(path, stat) {
+		return !this._isIgnored(path, stat);
+	}
+	/**
+	* Provides a set of common helpers and properties relating to symlink handling.
+	* @param path file or directory pattern being watched
+	*/
+	_getWatchHelpers(path) {
+		return new WatchHelper(path, this.options.followSymlinks, this);
+	}
+	/**
+	* Provides directory tracking objects
+	* @param directory path of the directory
+	*/
+	_getWatchedDir(directory) {
+		const dir = sp.resolve(directory);
+		if (!this._watched.has(dir)) this._watched.set(dir, new DirEntry(dir, this._boundRemove));
+		return this._watched.get(dir);
+	}
+	/**
+	* Check for read permissions: https://stackoverflow.com/a/11781404/1358405
+	*/
+	_hasReadPermissions(stats) {
+		if (this.options.ignorePermissionErrors) return true;
+		return Boolean(Number(stats.mode) & 256);
+	}
+	/**
+	* Handles emitting unlink events for
+	* files and directories, and via recursion, for
+	* files and directories within directories that are unlinked
+	* @param directory within which the following item is located
+	* @param item      base path of item/directory
+	*/
+	_remove(directory, item, isDirectory) {
+		const path = sp.join(directory, item);
+		const fullPath = sp.resolve(path);
+		isDirectory = isDirectory != null ? isDirectory : this._watched.has(path) || this._watched.has(fullPath);
+		if (!this._throttle("remove", path, 100)) return;
+		if (!isDirectory && this._watched.size === 1) this.add(directory, item, true);
+		this._getWatchedDir(path).getChildren().forEach((nested) => this._remove(path, nested));
+		const parent = this._getWatchedDir(directory);
+		const wasTracked = parent.has(item);
+		parent.remove(item);
+		if (this._symlinkPaths.has(fullPath)) this._symlinkPaths.delete(fullPath);
+		let relPath = path;
+		if (this.options.cwd) relPath = sp.relative(this.options.cwd, path);
+		if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
+			if (this._pendingWrites.get(relPath).cancelWait() === EVENTS.ADD) return;
+		}
+		this._watched.delete(path);
+		this._watched.delete(fullPath);
+		const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
+		if (wasTracked && !this._isIgnored(path)) this._emit(eventName, path);
+		this._closePath(path);
+	}
+	/**
+	* Closes all watchers for a path
+	*/
+	_closePath(path) {
+		this._closeFile(path);
+		const dir = sp.dirname(path);
+		this._getWatchedDir(dir).remove(sp.basename(path));
+	}
+	/**
+	* Closes only file-specific watchers
+	*/
+	_closeFile(path) {
+		const closers = this._closers.get(path);
+		if (!closers) return;
+		closers.forEach((closer) => closer());
+		this._closers.delete(path);
+	}
+	_addPathCloser(path, closer) {
+		if (!closer) return;
+		let list = this._closers.get(path);
+		if (!list) {
+			list = [];
+			this._closers.set(path, list);
+		}
+		list.push(closer);
+	}
+	_readdirp(root, opts) {
+		if (this.closed) return;
+		let stream = readdirp(root, {
+			type: EVENTS.ALL,
+			alwaysStat: true,
+			lstat: true,
+			...opts,
+			depth: 0
+		});
+		this._streams.add(stream);
+		stream.once(STR_CLOSE, () => {
+			stream = void 0;
+		});
+		stream.once("end", () => {
+			if (stream) {
+				this._streams.delete(stream);
+				stream = void 0;
+			}
+		});
+		return stream;
+	}
+};
+/**
+* Instantiates watcher with paths to be tracked.
+* @param paths file / directory paths
+* @param options opts, such as `atomic`, `awaitWriteFinish`, `ignored`, and others
+* @returns an instance of FSWatcher for chaining.
+* @example
+* const watcher = watch('.').on('all', (event, path) => { console.log(event, path); });
+* watch('.', { atomic: true, awaitWriteFinish: true, ignored: (f, stats) => stats?.isFile() && !f.endsWith('.js') })
+*/
+function watch$1(paths, options = {}) {
+	const watcher = new FSWatcher(options);
+	watcher.add(paths);
+	return watcher;
+}
+//#endregion
+//#region src/theme-server.ts
+const RAW_PATH = /^raw\/([^/]+)\/([^/]+)$/;
+const DEBOUNCE = 80;
+function notFound() {
+	return new Response("Not found", { status: 404 });
+}
+function text(body, cacheControl) {
+	return new Response(body, { headers: {
+		"content-type": "text/plain; charset=utf-8",
+		"cache-control": cacheControl
+	} });
+}
+function createThemeService(options) {
+	const { store, prefix } = options;
+	const omarchyPath = resolve$1(options.omarchyPath ?? OMARCHY_CURRENT);
+	const cwd = options.cwd ?? process.cwd();
+	const defaultPath = themeWatchPath(options.spec, cwd, omarchyPath);
+	const listeners = /* @__PURE__ */ new Set();
+	const timers = /* @__PURE__ */ new Map();
+	let version = 0;
+	const load = () => store.load(options.spec, cwd).catch((error) => {
+		const message = error instanceof Error ? error.message : String(error);
+		console.warn(`comarkserv: ${message} The pages use the GitHub theme.`);
+	});
+	let current = load();
+	const emit = (theme) => {
+		if (theme) for (const listener of listeners) listener(theme);
+	};
+	const onFile = async (path) => {
+		if (path === defaultPath) {
+			version++;
+			current = load();
+			emit(await current);
+		} else if (path === omarchyPath) emit(await store.load("omarchy", cwd).catch(() => void 0));
+	};
+	let watcher;
+	let ready = Promise.resolve();
+	const files = /* @__PURE__ */ new Set();
+	if (options.watch) {
+		if (defaultPath) files.add(resolve$1(defaultPath));
+		if (existsSync(omarchyPath)) files.add(omarchyPath);
+	}
+	if (files.size > 0) {
+		const active = watch$1([...files].map((file) => file === omarchyPath ? dirname$1(dirname$1(file)) : dirname$1(file)), {
+			ignoreInitial: true,
+			depth: 1,
+			ignored: (path, stats) => stats?.isFile() === true && !files.has(resolve$1(path))
+		});
+		active.on("all", (_event, path) => {
+			const file = resolve$1(path);
+			if (!files.has(file)) return;
+			clearTimeout(timers.get(file));
+			timers.set(file, setTimeout(() => void onFile(file), DEBOUNCE));
+		});
+		active.on("error", () => {});
+		ready = new Promise((done) => active.once("ready", () => done()));
+		watcher = active;
+	}
+	const catalog = async () => {
+		const entries = await store.catalog((source, id) => `${prefix}raw/${source}/${id}`).catch(() => []);
+		if (existsSync(omarchyPath)) entries.unshift({
+			id: "omarchy-live",
+			name: "Omarchy (live)",
+			source: "omarchy-live",
+			url: `${prefix}omarchy-live`
+		});
+		return Response.json(entries, { headers: { "cache-control": "no-cache" } });
+	};
+	const handle = async (_request, name) => {
+		if (name === "catalog.json") return catalog();
+		if (name === "omarchy-live") {
+			const body = await readFile(omarchyPath, "utf8").catch(() => void 0);
+			return body === void 0 ? notFound() : text(body, "no-cache");
+		}
+		const [, source = "", id = ""] = RAW_PATH.exec(name) ?? [];
+		if (!isThemeSource(source)) return notFound();
+		const body = await store.raw(source, id).catch(() => void 0);
+		return body === void 0 ? notFound() : text(body, "public, max-age=86400");
+	};
+	return {
+		ready,
+		current: () => current,
+		version: () => version,
+		handle,
+		subscribe: (listener) => {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		},
+		close: async () => {
+			for (const timer of timers.values()) clearTimeout(timer);
+			listeners.clear();
+			await watcher?.close();
+		}
+	};
+}
+//#endregion
+//#region src/watch.ts
+function watchTree(root, options) {
+	const listeners = /* @__PURE__ */ new Set();
+	let pending = /* @__PURE__ */ new Set();
+	let timer;
+	const watcher = watch$1(root, {
+		ignoreInitial: true,
+		ignored: (path) => {
+			const local = relative(root, path);
+			return local !== "" && options.ignore(local);
+		}
+	});
+	const flush = () => {
+		timer = void 0;
+		const paths = [...pending];
+		pending = /* @__PURE__ */ new Set();
+		for (const listener of listeners) listener(paths);
+	};
+	watcher.on("all", (_event, path) => {
+		pending.add(`/${relative(root, path)}`);
+		timer ??= setTimeout(flush, options.debounce ?? 30);
+	});
+	watcher.on("error", () => {});
+	return {
+		ready: new Promise((resolve) => watcher.once("ready", () => resolve())),
+		subscribe: (listener) => {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		},
+		close: async () => {
+			if (timer) clearTimeout(timer);
+			listeners.clear();
+			await watcher.close();
+		}
+	};
+}
+//#endregion
+//#region src/handler.ts
+/** The URL prefix of the files and endpoints of comarkserv itself. */
+const INTERNAL_PREFIX = "/__comarkserv/";
+const HTML = "text/html; charset=utf-8";
+const LOOPBACK_HOSTS = /* @__PURE__ */ new Set([
+	"localhost",
+	"127.0.0.1",
+	"[::1]"
+]);
+const PROXY_HEADERS = [
+	"cf-ray",
+	"cf-connecting-ip",
+	"x-forwarded-for",
+	"forwarded",
+	"x-real-ip"
+];
+/** Returns true for a request from a browser on this machine, not through a tunnel or a proxy. */
+function isLocalRequest(request) {
+	return LOOPBACK_HOSTS.has(new URL(request.url).hostname) && PROXY_HEADERS.every((header) => !request.headers.has(header));
+}
+/**
+* Returns true for an action from a comarkserv page on this machine: a local request,
+* from the same origin, with the custom header. A cross-origin request with that
+* header needs a preflight, and the server answers no preflight.
+*/
+function isLocalAction(request) {
+	const origin = request.headers.get("origin");
+	return isLocalRequest(request) && (origin === null || origin === new URL(request.url).origin) && request.headers.get("x-comarkserv-action") === "1";
+}
+async function qrCode(text) {
+	const { renderSVG } = await import("./dist-CfsjQ0o8.mjs");
+	return renderSVG(text, {
+		pixelSize: 4,
+		whiteColor: "#ffffff",
+		blackColor: "#1f2328"
+	});
+}
+const MIN_COMPRESS_SIZE = 1024;
+const IMMUTABLE = "public, max-age=31536000, immutable";
+const brotli = promisify(brotliCompress);
+const gzipAsync = promisify(gzip);
+var Lru = class {
+	map = /* @__PURE__ */ new Map();
+	max;
+	constructor(max) {
+		this.max = max;
+	}
+	get(key) {
+		const value = this.map.get(key);
+		if (value !== void 0) {
+			this.map.delete(key);
+			this.map.set(key, value);
+		}
+		return value;
+	}
+	set(key, value) {
+		this.map.delete(key);
+		this.map.set(key, value);
+		if (this.map.size > this.max) this.map.delete(this.map.keys().next().value ?? "");
+	}
+	delete(key) {
+		this.map.delete(key);
+	}
+};
+function makeBody(text, type, etag) {
+	return {
+		text,
+		type,
+		etag: `W/"${etag ?? createHash("sha1").update(text).digest("base64url").slice(0, 16)}"`,
+		encoded: /* @__PURE__ */ new Map()
+	};
+}
+function negotiate(header) {
+	if (!header) return void 0;
+	const accepted = /* @__PURE__ */ new Set();
+	for (const part of header.toLowerCase().split(",")) {
+		const [name = "", ...params] = part.trim().split(";");
+		const quality = params.find((param) => param.trim().startsWith("q="));
+		if (quality && Number(quality.trim().slice(2)) === 0) continue;
+		accepted.add(name.trim());
+	}
+	if (accepted.has("br")) return "br";
+	if (accepted.has("gzip")) return "gzip";
+}
+async function compress(text, encoding) {
+	const data = encoding === "br" ? await brotli(text, { params: {
+		[constants$1.BROTLI_PARAM_QUALITY]: 5,
+		[constants$1.BROTLI_PARAM_SIZE_HINT]: Buffer.byteLength(text)
+	} }) : await gzipAsync(text, { level: 6 });
+	return new Uint8Array(data);
+}
+function etagMatches(header, etag) {
+	if (!header) return false;
+	const weak = (tag) => tag.trim().replace(/^W\//, "");
+	return header.split(",").some((tag) => tag.trim() === "*" || weak(tag) === weak(etag));
+}
+async function respond(request, body, init = {}) {
+	const status = init.status ?? 200;
+	const headers = new Headers({
+		"content-type": body.type,
+		"cache-control": "no-cache",
+		etag: body.etag,
+		...init.headers
+	});
+	if (status === 200 && etagMatches(request.headers.get("if-none-match"), body.etag)) return new Response(null, {
+		status: 304,
+		headers
+	});
+	const compressible = body.text.length >= MIN_COMPRESS_SIZE;
+	if (compressible) headers.set("vary", "accept-encoding");
+	if (request.method === "HEAD") return new Response(null, {
+		status,
+		headers
+	});
+	const encoding = compressible ? negotiate(request.headers.get("accept-encoding")) : void 0;
+	if (!encoding) return new Response(body.text, {
+		status,
+		headers
+	});
+	let data = body.encoded.get(encoding);
+	if (!data) {
+		data = compress(body.text, encoding);
+		body.encoded.set(encoding, data);
+	}
+	headers.set("content-encoding", encoding);
+	return new Response(await data, {
+		status,
+		headers
+	});
+}
+function timing(ms, cached) {
+	return `render;dur=${ms.toFixed(2)}${cached ? ", cache;desc=\"hit\"" : ""}`;
+}
+function errorText(error) {
+	return error instanceof Error ? error.stack ?? error.message : String(error);
+}
+function createHandler(options = {}) {
+	const root = resolve(options.root ?? process.cwd());
+	const rootName = basename(root) || root;
+	const livereload = options.livereload ?? true;
+	const editor = options.editor ?? true;
+	const shareService = options.share === false ? void 0 : options.shareService ?? createShareService();
+	const openEditor = options.openEditor ?? (async (file, line) => (await import("./editor-CHDyOp-8.mjs")).openInEditor(file, line));
+	const dotfiles = options.dotfiles ?? false;
+	let renderer;
+	const getRenderer = () => renderer ??= import("./markdown-DWuqfzps.mjs").then((module) => module.createMarkdownRenderer(options));
+	const renders = new Lru(options.cacheSize ?? 500);
+	const pages = new Lru(options.cacheSize ?? 500);
+	const search = createSearchIndex({
+		root,
+		dotfiles
+	});
+	const serverId = randomUUID();
+	const streams = /* @__PURE__ */ new Set();
+	const themes = createThemeService({
+		spec: options.theme ?? "github",
+		store: options.themeStore ?? createThemeStore({ omarchyPath: options.omarchyPath }),
+		prefix: `${INTERNAL_PREFIX}themes/`,
+		watch: livereload,
+		omarchyPath: options.omarchyPath
+	});
+	const assets = getAssets();
+	const assetBodies = {
+		"app.css": makeBody(assets["app.css"].body, assets["app.css"].type, assets["app.css"].version),
+		"app.js": makeBody(assets["app.js"].body, assets["app.js"].type, assets["app.js"].version)
+	};
+	const pageAssets = {
+		css: `${INTERNAL_PREFIX}app.css?v=${assets["app.css"].version}`,
+		js: `${INTERNAL_PREFIX}app.js?v=${assets["app.js"].version}`,
+		katex: `${INTERNAL_PREFIX}katex/katex.min.css?v=${assets.katexVersion}`
+	};
+	const config = (source, kind, lines) => ({
+		root: "/",
+		search: `${INTERNAL_PREFIX}search.json`,
+		events: livereload ? `${INTERNAL_PREFIX}events` : "",
+		themes: `${INTERNAL_PREFIX}themes/catalog.json`,
+		edit: editor ? `${INTERNAL_PREFIX}edit` : "",
+		share: shareService ? `${INTERNAL_PREFIX}share` : "",
+		local: `${INTERNAL_PREFIX}local`,
+		source,
+		kind,
+		...lines ? { lines } : {}
+	});
+	const page = async (input) => renderPage({
+		...input,
+		assets: pageAssets,
+		theme: await themes.current()
+	});
+	const watcher = livereload ? watchTree(root, { ignore: (path) => isSkippedPath(path, dotfiles) }) : void 0;
+	watcher?.subscribe((paths) => {
+		search.invalidate(paths);
+		for (const path of paths) {
+			renders.delete(join(root, path));
+			pages.delete(path);
+			pages.delete(path.slice(0, path.lastIndexOf("/") + 1));
+		}
+	});
+	const serveStatic = staticMiddleware({
+		dir: root,
+		dotfiles: dotfiles ? true : [".well-known"],
+		renderHTML: livereload ? ({ request, html }) => {
+			const source = decodeURIComponent(new URL(request.url).pathname);
+			const injected = injectClient(html, config(source, "html"), pageAssets);
+			return new Response(injected, { headers: { "content-type": HTML } });
+		} : void 0
+	});
+	const serveKatex = staticMiddleware({
+		dir: assets.katexDir,
+		maxAge: 31536e3,
+		immutable: true,
+		dotfiles: false
+	});
+	const renderFile = (path, info) => {
+		const stamp = `${info.mtimeMs}:${info.size}`;
+		const cached = renders.get(path);
+		if (cached?.stamp === stamp) return cached.result;
+		const result = (async () => {
+			const started = performance.now();
+			const [render, source] = await Promise.all([getRenderer(), readFile(path, "utf8")]);
+			const rendered = await render(source);
+			const lines = Object.fromEntries(extractOutline(source).headings.map((heading) => [heading.id, heading.line]));
+			return {
+				rendered,
+				ms: performance.now() - started,
+				lines
+			};
+		})();
+		renders.set(path, {
+			stamp,
+			result
+		});
+		result.catch(() => renders.delete(path));
+		return result;
+	};
+	const notFound = async (request, pathname) => respond(request, makeBody(await page({
+		title: "Not found",
+		content: renderStatus(404, "Not found", `There is no file at ${pathname}.`),
+		crumbs: crumbsFor(pathname, rootName),
+		config: config(pathname, "status")
+	}), HTML), { status: 404 });
+	const failure = async (request, pathname, error, source = pathname) => respond(request, makeBody(await page({
+		title: "Render error",
+		content: renderStatus(500, "Render error", `comarkserv could not render ${pathname}.`, errorText(error)),
+		crumbs: crumbsFor(pathname, rootName),
+		config: config(source, "markdown")
+	}), HTML), { status: 500 });
+	const markdownPage = async (request, pathname, path, info, source) => {
+		const stamp = `${info.mtimeMs}:${info.size}:${themes.version()}`;
+		const cached = pages.get(pathname);
+		if (cached?.stamp === stamp) return respond(request, cached.body, { headers: { "server-timing": timing(cached.ms, true) } });
+		let timed;
+		try {
+			timed = await renderFile(path, info);
+		} catch (error) {
+			return failure(request, pathname, error, source);
+		}
+		const { rendered, ms } = timed;
+		const body = makeBody(await page({
+			title: rendered.title ?? basename(path),
+			description: rendered.description,
+			content: rendered.html,
+			toc: rendered.toc,
+			crumbs: crumbsFor(pathname, rootName),
+			features: rendered.features,
+			rawHref: `${encodeURI(source)}?raw`,
+			footer: `rendered in ${ms.toFixed(1)} ms`,
+			config: config(source, "markdown", timed.lines)
+		}), HTML);
+		pages.set(pathname, {
+			stamp,
+			body,
+			ms
+		});
+		return respond(request, body, { headers: { "server-timing": timing(ms, false) } });
+	};
+	const directoryPage = async (request, pathname, path) => {
+		const started = performance.now();
+		const directory = await readDirectory(path, {
+			dotfiles,
+			links: serverLinks
+		});
+		const names = new Set(directory.entries.map((entry) => entry.name));
+		if (names.has("index.html")) return serveStatic(request, () => notFound(request, pathname));
+		if (names.has("index.md")) {
+			const index = join(path, "index.md");
+			return markdownPage(request, pathname, index, await stat$1(index), `${pathname}index.md`);
+		}
+		let content = renderListing(directory.entries, pathname === "/" ? void 0 : "../");
+		let readme;
+		if (directory.readme) {
+			const readmePath = join(path, directory.readme);
+			try {
+				readme = (await renderFile(readmePath, await stat$1(readmePath))).rendered;
+				content += renderReadme(directory.readme, readme.html);
+			} catch (error) {
+				content += renderStatus(500, "Render error", `comarkserv could not render ${directory.readme}.`, errorText(error));
+			}
+		}
+		const ms = performance.now() - started;
+		const count = directory.entries.length;
+		return respond(request, makeBody(await page({
+			title: pathname === "/" ? rootName : pathname.slice(1),
+			content,
+			contentClass: "cms-directory",
+			toc: readme?.toc,
+			crumbs: crumbsFor(pathname, rootName),
+			features: readme?.features,
+			footer: `${count} ${count === 1 ? "item" : "items"} · rendered in ${ms.toFixed(1)} ms`,
+			config: config(pathname, "directory")
+		}), HTML), { headers: { "server-timing": timing(ms, false) } });
+	};
+	const events = (request) => {
+		if (!watcher) return new Response("Live reload is off", { status: 404 });
+		const encoder = new TextEncoder();
+		let close = () => {};
+		const stream = new ReadableStream({
+			start(controller) {
+				const send = (text) => {
+					try {
+						controller.enqueue(encoder.encode(text));
+					} catch {
+						close();
+					}
+				};
+				const unsubscribe = watcher.subscribe((paths) => {
+					send(`event: change\ndata: ${JSON.stringify({ paths })}\n\n`);
+				});
+				const unsubscribeTheme = themes.subscribe((theme) => {
+					send(`event: theme\ndata: ${JSON.stringify({ theme })}\n\n`);
+				});
+				const unsubscribeShare = shareService?.subscribe((status) => {
+					send(`event: share\ndata: ${JSON.stringify(status)}\n\n`);
+				});
+				const ping = setInterval(() => send(": ping\n\n"), 25e3);
+				close = () => {
+					clearInterval(ping);
+					unsubscribe();
+					unsubscribeTheme();
+					unsubscribeShare?.();
+					streams.delete(close);
+					try {
+						controller.close();
+					} catch {}
+				};
+				streams.add(close);
+				request.signal.addEventListener("abort", () => close(), { once: true });
+				send(`retry: 1000\nevent: hello\ndata: ${JSON.stringify({ id: serverId })}\n\n`);
+			},
+			cancel() {
+				close();
+			}
+		});
+		return new Response(stream, { headers: {
+			"content-type": "text/event-stream",
+			"cache-control": "no-cache",
+			"x-accel-buffering": "no"
+		} });
+	};
+	const edit = async (request) => {
+		if (!editor) return new Response("Not found", { status: 404 });
+		if (request.method !== "POST") return new Response("Method not allowed", {
+			status: 405,
+			headers: { allow: "POST" }
+		});
+		if (!isLocalAction(request)) return new Response("Forbidden", { status: 403 });
+		const body = await request.json().catch(() => ({}));
+		const pathname = typeof body.path === "string" ? body.path : "";
+		const visible = pathname.startsWith("/") && !pathname.includes("\0") && (dotfiles || !hasHiddenSegment(pathname));
+		const path = resolve(root, `.${pathname}`);
+		const inside = path === root || path.startsWith(root + sep);
+		if (!(visible && inside ? await stat$1(path).catch(() => void 0) : void 0)?.isFile()) return new Response("Not found", { status: 404 });
+		const line = typeof body.line === "number" && Number.isInteger(body.line) && body.line > 0 ? body.line : void 0;
+		try {
+			await openEditor(path, line);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			return Response.json({ error: message }, { status: 500 });
+		}
+		return new Response(null, { status: 204 });
+	};
+	const localCheck = (request) => {
+		if (!isLocalRequest(request)) return new Response("Forbidden", { status: 403 });
+		return Response.json({
+			edit: editor,
+			share: shareService ? shareService.status() : null
+		}, { headers: { "cache-control": "no-store" } });
+	};
+	const shareState = async (path, status = 200) => {
+		const current = shareService?.status();
+		let extra = {};
+		if (current?.url) {
+			const page = typeof path === "string" && path.startsWith("/") && !path.startsWith("//") ? new URL(path, current.url).href : current.url;
+			extra = {
+				page,
+				qr: await qrCode(page)
+			};
+		}
+		return Response.json({
+			...current,
+			links: CLOUDFLARE_LINKS,
+			...extra
+		}, { status });
+	};
+	const shareAction = async (request) => {
+		if (!shareService) return new Response("Not found", { status: 404 });
+		if (request.method !== "POST") return new Response("Method not allowed", {
+			status: 405,
+			headers: { allow: "POST" }
+		});
+		if (!isLocalAction(request)) return new Response("Forbidden", { status: 403 });
+		const body = await request.json().catch(() => ({}));
+		if (body.action === "stop") await shareService.stop();
+		else if (body.action === "start") try {
+			await shareService.start({
+				origin: new URL(request.url).origin,
+				accept: body.accept === true
+			});
+		} catch (error) {
+			return shareState(body.path, error instanceof ShareConsentError ? 409 : 500);
+		}
+		return shareState(body.path);
+	};
+	const internal = async (request, name) => {
+		if (name === "local") return localCheck(request);
+		if (name === "app.css" || name === "app.js") return respond(request, assetBodies[name], { headers: { "cache-control": IMMUTABLE } });
+		if (name === "search.json") return Response.json(await search.get(), { headers: { "cache-control": "no-cache" } });
+		if (name === "events") return events(request);
+		if (name.startsWith("themes/")) return themes.handle(request, name.slice(7));
+		if (name.startsWith("katex/")) {
+			const url = new URL(request.url);
+			url.pathname = `/${name.slice(6)}`;
+			return serveKatex(new Request(url, request), () => new Response("Not found", { status: 404 }));
+		}
+		return new Response("Not found", { status: 404 });
+	};
+	const handle = async (request) => {
+		const requested = new URL(request.url).pathname;
+		if (requested === `/__comarkserv/edit`) return edit(request);
+		if (requested === `/__comarkserv/share`) return shareAction(request);
+		if (request.method !== "GET" && request.method !== "HEAD") return new Response("Method not allowed", {
+			status: 405,
+			headers: { allow: "GET, HEAD" }
+		});
+		const url = new URL(request.url);
+		let pathname;
+		try {
+			pathname = decodeURIComponent(url.pathname);
+		} catch {
+			return new Response("Bad request", { status: 400 });
+		}
+		if (pathname.startsWith("/__comarkserv/")) return internal(request, pathname.slice(14));
+		if (pathname.includes("\0") || !dotfiles && hasHiddenSegment(pathname)) return notFound(request, pathname);
+		const path = resolve(root, `.${pathname}`);
+		if (path !== root && !path.startsWith(root + sep)) return notFound(request, pathname);
+		const info = await stat$1(path).catch(() => void 0);
+		if (!info) return notFound(request, pathname);
+		if (info.isDirectory()) {
+			if (!pathname.endsWith("/")) return new Response(null, {
+				status: 301,
+				headers: { location: `${url.pathname}/${url.search}` }
+			});
+			return directoryPage(request, pathname, path);
+		}
+		if (!info.isFile()) return notFound(request, pathname);
+		if (isMarkdown(path)) {
+			if (url.searchParams.has("raw")) return respond(request, makeBody(await readFile(path, "utf8"), "text/plain; charset=utf-8"));
+			return markdownPage(request, pathname, path, info, pathname);
+		}
+		return serveStatic(request, () => notFound(request, pathname));
+	};
+	return {
+		root,
+		share: shareService,
+		warmup: async () => {
+			await Promise.all([getRenderer(), themes.current()]);
+		},
+		fetch: async (request) => {
+			try {
+				return await handle(request);
+			} catch (error) {
+				const pathname = new URL(request.url).pathname;
+				return failure(request, pathname, error);
+			}
+		},
+		close: async () => {
+			await Promise.all([
+				watcher?.close(),
+				themes.close(),
+				shareService?.stop()
+			]);
+			for (const close of streams) close();
+		}
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/get-port-please@3.2.0/node_modules/get-port-please/dist/index.mjs
+const unsafePorts = /* @__PURE__ */ new Set([
+	1,
+	7,
+	9,
+	11,
+	13,
+	15,
+	17,
+	19,
+	20,
+	21,
+	22,
+	23,
+	25,
+	37,
+	42,
+	43,
+	53,
+	69,
+	77,
+	79,
+	87,
+	95,
+	101,
+	102,
+	103,
+	104,
+	109,
+	110,
+	111,
+	113,
+	115,
+	117,
+	119,
+	123,
+	135,
+	137,
+	139,
+	143,
+	161,
+	179,
+	389,
+	427,
+	465,
+	512,
+	513,
+	514,
+	515,
+	526,
+	530,
+	531,
+	532,
+	540,
+	548,
+	554,
+	556,
+	563,
+	587,
+	601,
+	636,
+	989,
+	990,
+	993,
+	995,
+	1719,
+	1720,
+	1723,
+	2049,
+	3659,
+	4045,
+	5060,
+	5061,
+	6e3,
+	6566,
+	6665,
+	6666,
+	6667,
+	6668,
+	6669,
+	6697,
+	10080
+]);
+function isUnsafePort(port) {
+	return unsafePorts.has(port);
+}
+function isSafePort(port) {
+	return !isUnsafePort(port);
+}
+var GetPortError = class extends Error {
+	constructor(message, opts) {
+		super(message, opts);
+		this.message = message;
+	}
+	name = "GetPortError";
+};
+function _log(verbose, message) {
+	if (verbose) console.log(`[get-port] ${message}`);
+}
+function _generateRange(from, to) {
+	if (to < from) return [];
+	const r = [];
+	for (let index = from; index <= to; index++) r.push(index);
+	return r;
+}
+function _tryPort(port, host) {
+	return new Promise((resolve) => {
+		const server = createServer();
+		server.unref();
+		server.on("error", () => {
+			resolve(false);
+		});
+		server.listen({
+			port,
+			host
+		}, () => {
+			const { port: port2 } = server.address();
+			server.close(() => {
+				resolve(isSafePort(port2) && port2);
+			});
+		});
+	});
+}
+function _getLocalHosts(additional) {
+	const hosts = new Set(additional);
+	for (const _interface of Object.values(networkInterfaces())) for (const config of _interface || []) if (config.address && !config.internal && !config.address.startsWith("fe80::") && !config.address.startsWith("169.254")) hosts.add(config.address);
+	return [...hosts];
+}
+async function _findPort(ports, host) {
+	for (const port of ports) {
+		const r = await _tryPort(port, host);
+		if (r) return r;
+	}
+}
+function _fmtOnHost(hostname) {
+	return hostname ? `on host ${JSON.stringify(hostname)}` : "on any host";
+}
+const HOSTNAME_RE = /^(?!-)[\d.:A-Za-z-]{1,63}(?<!-)$/;
+function _validateHostname(hostname, _public, verbose) {
+	if (hostname && !HOSTNAME_RE.test(hostname)) {
+		const fallbackHost = _public ? "0.0.0.0" : "127.0.0.1";
+		_log(verbose, `Invalid hostname: ${JSON.stringify(hostname)}. Using ${JSON.stringify(fallbackHost)} as fallback.`);
+		return fallbackHost;
+	}
+	return hostname;
+}
+async function getPort(_userOptions = {}) {
+	if (typeof _userOptions === "number" || typeof _userOptions === "string") _userOptions = { port: Number.parseInt(_userOptions + "") || 0 };
+	const _port = Number(_userOptions.port ?? process.env.PORT);
+	const _userSpecifiedAnyPort = Boolean(_userOptions.port || _userOptions.ports?.length || _userOptions.portRange?.length);
+	const options = {
+		random: _port === 0,
+		ports: [],
+		portRange: [],
+		alternativePortRange: _userSpecifiedAnyPort ? [] : [3e3, 3100],
+		verbose: false,
+		..._userOptions,
+		port: _port,
+		host: _validateHostname(_userOptions.host ?? process.env.HOST, _userOptions.public, _userOptions.verbose)
+	};
+	if (options.random && !_userSpecifiedAnyPort) return getRandomPort(options.host);
+	const portsToCheck = [
+		options.port,
+		...options.ports,
+		..._generateRange(...options.portRange)
+	].filter((port) => {
+		if (!port) return false;
+		if (!isSafePort(port)) {
+			_log(options.verbose, `Ignoring unsafe port: ${port}`);
+			return false;
+		}
+		return true;
+	});
+	if (portsToCheck.length === 0) portsToCheck.push(3e3);
+	let availablePort = await _findPort(portsToCheck, options.host);
+	if (!availablePort && options.alternativePortRange.length > 0) {
+		availablePort = await _findPort(_generateRange(...options.alternativePortRange), options.host);
+		if (portsToCheck.length > 0) {
+			let message = `Unable to find an available port (tried ${portsToCheck.join("-")} ${_fmtOnHost(options.host)}).`;
+			if (availablePort) message += ` Using alternative port ${availablePort}.`;
+			_log(options.verbose, message);
+		}
+	}
+	if (!availablePort && _userOptions.random !== false) {
+		availablePort = await getRandomPort(options.host);
+		if (availablePort) _log(options.verbose, `Using random port ${availablePort}`);
+	}
+	if (!availablePort) {
+		const triedRanges = [
+			options.port,
+			options.portRange.join("-"),
+			options.alternativePortRange.join("-")
+		].filter(Boolean).join(", ");
+		throw new GetPortError(`Unable to find an available port ${_fmtOnHost(options.host)} (tried ${triedRanges})`);
+	}
+	return availablePort;
+}
+async function getRandomPort(host) {
+	const port = await checkPort(0, host);
+	if (port === false) throw new GetPortError(`Unable to find a random port ${_fmtOnHost(host)}`);
+	return port;
+}
+async function checkPort(port, host = process.env.HOST, verbose) {
+	if (!host) host = _getLocalHosts([void 0, "0.0.0.0"]);
+	if (!Array.isArray(host)) return _tryPort(port, host);
+	for (const _host of host) {
+		const _port = await _tryPort(port, _host);
+		if (_port === false) {
+			if (port < 1024 && verbose) _log(verbose, `Unable to listen to the privileged port ${port} ${_fmtOnHost(_host)}`);
+			return false;
+		}
+		if (port === 0 && _port !== 0) port = _port;
+	}
+	return port;
+}
+//#endregion
+//#region src/server.ts
+const DEFAULT_PORT = 8642;
+/** Returns the first free port from `start`. With `strict`, it rejects when `start` is in use. */
+async function findPort(start, host, strict) {
+	if (start === 0) return 0;
+	if (!strict) return getPort({
+		port: start,
+		portRange: [start, start + 20],
+		alternativePortRange: [start + 21, start + 100],
+		host
+	});
+	if (await checkPort(start, host)) return start;
+	throw new Error(`Port ${start} is in use. Choose another port, or remove --strict-port.`);
+}
+function statusColor(status) {
+	if (status >= 500) return "red";
+	if (status >= 400) return "yellow";
+	if (status >= 300) return "cyan";
+	return "green";
+}
+const logger = async (request, next) => {
+	const started = performance.now();
+	const response = await next();
+	const { pathname, search } = new URL(request.url);
+	if (!pathname.startsWith("/__comarkserv/")) {
+		const time = (/* @__PURE__ */ new Date()).toLocaleTimeString("en-GB");
+		const ms = (performance.now() - started).toFixed(1);
+		console.log(`${styleText("dim", time)} ${styleText(statusColor(response.status), String(response.status))} ${request.method} ${decodeURIComponent(pathname)}${search} ${styleText("dim", `${ms} ms`)}`);
+	}
+	return response;
+};
+/** Starts a comarkserv server with srvx. */
+async function startServer(options = {}) {
+	const host = options.host ?? "localhost";
+	const port = await findPort(options.port ?? 8642, host, options.strictPort ?? false);
+	const handler = createHandler(options);
+	const server = serve({
+		fetch: handler.fetch,
+		port,
+		hostname: host,
+		silent: true,
+		gracefulShutdown: false,
+		middleware: options.log ? [logger] : []
+	});
+	try {
+		await server.ready();
+	} catch (error) {
+		await handler.close();
+		throw error;
+	}
+	setImmediate(() => void handler.warmup());
+	const url = new URL(server.url ?? `http://${host}:${port}/`);
+	if (host === "localhost" || url.hostname === "0.0.0.0" || url.hostname === "[::]") url.hostname = "localhost";
+	return {
+		url: url.href,
+		port: Number(url.port) || port,
+		host,
+		handler,
+		close: async () => {
+			await handler.close();
+			await server.close(true);
+		}
+	};
+}
+//#endregion
+export { createHandler as a, INTERNAL_PREFIX as i, findPort as n, CLOUDFLARE_LINKS as o, startServer as r, isCloudflaredInstalled as s, DEFAULT_PORT as t };