for-humanity 0.12.0 → 0.13.1

package/dist/load-site-B-u5-jv0.js

@@ -0,0 +1,2343 @@
+import { S as copy_nav_toc_label, T as copy_warn_unknown_status, a as copy_error_doc_id_clash, b as copy_nav_open, c as copy_error_doc_parent_missing, g as copy_error_unknown_directive, h as copy_error_snippet, i as copy_error_doc_id, l as copy_error_frontmatter, o as copy_error_doc_parent_cycle, r as copy_error_directive_syntax, s as copy_error_doc_parent_group, t as copy_error_asset, u as copy_error_home_clash, v as copy_nav_aria_label, w as copy_warn_broken_link, x as copy_nav_title, y as copy_nav_close } from "./copy-C1uzvEnr.js";
+import { t as logger } from "./logger-Dv1i9xSV.js";
+import { t as groupPathSchema } from "./group-path-XAThmzvC.js";
+import { t as toChangeQueue } from "./to-change-queue-DbEnZGNK.js";
+import { readFile, readdir } from "node:fs/promises";
+import { z } from "zod";
+import { existsSync, readFileSync, readdirSync, realpathSync, statSync } from "node:fs";
+import { basename, dirname, extname, isAbsolute, join, posix, relative, resolve, sep } from "node:path";
+import rehypeShiki from "@shikijs/rehype";
+import rehypeRaw from "rehype-raw";
+import rehypeStringify from "rehype-stringify";
+import remarkDirective from "remark-directive";
+import remarkFrontmatter from "remark-frontmatter";
+import remarkGfm from "remark-gfm";
+import remarkParse from "remark-parse";
+import remarkRehype from "remark-rehype";
+import remarkSmartypants from "remark-smartypants";
+import { createCssVariablesTheme } from "shiki";
+import { unified } from "unified";
+import { SKIP, visit } from "unist-util-visit";
+import { createHash } from "node:crypto";
+import Slugger from "github-slugger";
+import { toString } from "hast-util-to-string";
+import { dropRightWhile, dropWhile, minBy, takeWhile, uniqBy } from "es-toolkit/array";
+import { transformerMetaHighlight, transformerNotationDiff, transformerNotationErrorLevel, transformerNotationHighlight, transformerNotationWordHighlight } from "@shikijs/transformers";
+import { toString as toString$1 } from "mdast-util-to-string";
+import { escape, escapeRegExp } from "es-toolkit/string";
+import { findAndReplace } from "mdast-util-find-and-replace";
+import { isEqual } from "es-toolkit/predicate";
+import { VFile } from "vfile";
+import { parse } from "yaml";
+import { Hono } from "hono";
+import { html, raw } from "hono/html";
+import { ssgParams } from "hono/ssg";
+import clsx from "clsx";
+import { jsx, jsxs } from "hono/jsx/jsx-runtime";
+import { createHead, escapeHtml } from "unhead/server";
+import { Fragment, useEffect, useLayoutEffect, useRef, useState } from "hono/jsx";
+import { flushSync } from "hono/jsx/dom";
+//#region src/app/_constant/crawling.ts
+/**
+* 크롤러 안내 파일의 사이트 루트 경로
+*/
+var crawling_robots_path = "/robots.txt";
+/**
+* 공개 페이지 목록의 사이트 루트 경로
+*/
+var crawling_sitemap_path = "/sitemap.xml";
+/**
+* 공개 크롤러 파일과 정적 출력이 충돌하는 문서의 첫 경로 조각
+*/
+var crawling_reserved_roots = [crawling_robots_path.slice(1), crawling_sitemap_path.slice(1)];
+/**
+* 내용 지문을 붙일 번들 CSS의 기본 URL
+*/
+var asset_style_path = `/_fh/style.css`;
+/**
+* 자체 호스팅 글꼴 폴더
+*/
+var asset_font_dir = `/_fh/fonts`;
+/**
+* 자체 호스팅 Mermaid ESM과 지연 청크 폴더
+*/
+var asset_mermaid_dir = `/_fh/mermaid`;
+/**
+* 탭 아이콘 URL
+*/
+var asset_favicon_path = "/favicon.svg";
+/**
+* dev 자원 응답의 확장자별 content-type
+*/
+var asset_content_types = {
+	".css": "text/css; charset=utf-8",
+	".js": "text/javascript; charset=utf-8",
+	".woff2": "font/woff2",
+	".svg": "image/svg+xml",
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".gif": "image/gif",
+	".webp": "image/webp",
+	".avif": "image/avif",
+	".pdf": "application/pdf",
+	".csv": "text/csv; charset=utf-8",
+	".txt": "text/plain; charset=utf-8",
+	".zip": "application/zip"
+};
+/**
+* 문서에서 참조한 그림, 첨부 자원의 예약 경로
+*/
+var asset_media_dir = `/_fh/media`;
+/**
+* 명시적 로컬 참조로 배포할 수 있는 파일 형식. 실행 파일, 소스, 설정 제외
+*/
+var asset_media_extensions = /* @__PURE__ */ new Set([
+	".svg",
+	".png",
+	".jpg",
+	".jpeg",
+	".gif",
+	".webp",
+	".avif",
+	".pdf",
+	".csv",
+	".txt",
+	".zip"
+]);
+//#endregion
+//#region src/util/file/to-asset-path.ts
+/**
+* 파일명에 내용 지문 추가. 같은 내용은 같은 URL, 변경한 내용은 새 캐시 키 사용
+*/
+var toAssetPath = (options) => {
+	const extension = posix.extname(options.path);
+	return `${posix.dirname(options.path)}/${posix.basename(options.path, extension)}.${createHash("sha256").update(readFileSync(options.file)).digest("hex")}${extension}`;
+};
+//#endregion
+//#region src/app/_function/create-processor/_rehype-assets.ts
+/**
+* 문서 상대 경로의 이미지와 첨부 수집
+*
+*   - 원시 HTML에도 같은 내용 지문 URL 적용
+*   - 없는 파일, 폴더 밖 경로와 symlink, 지원하지 않는 이미지 형식은 빌드 실패
+*   - 절대 URL, 외부 URL은 작성자가 제공하며 수집하지 않음
+*/
+var rehypeAssets = (options) => (tree, file) => {
+	visit(tree, "element", (node) => {
+		const property = node.tagName === "img" ? "src" : "href";
+		const url = node.properties[property];
+		if (node.tagName !== "img" && node.tagName !== "a" || typeof url !== "string" || /^(?:[a-z][a-z\d+.-]*:|\/|#)/i.test(url)) return;
+		const match = /^([^?#]+)([?#].*)?$/.exec(url);
+		if (match === null) return;
+		const path = decodeURIComponent(match[1]);
+		const extension = extname(path).toLowerCase();
+		if (!asset_media_extensions.has(extension)) {
+			if (node.tagName === "img") file.fail(`${copy_error_asset}: 지원하지 않는 이미지 형식 · ${url}`, node);
+			return;
+		}
+		const target = resolve(dirname(file.path), path);
+		const location = relative(options.root, target);
+		if (location === ".." || location.startsWith(`..${sep}`) || isAbsolute(location)) file.fail(`${copy_error_asset}: 문서 폴더 밖 · ${url}`, node);
+		if (!existsSync(target)) file.fail(`${copy_error_asset}: 파일이 없다 · ${url}`, node);
+		const actual = realpathSync(target);
+		const actualLocation = relative(realpathSync(options.root), actual);
+		if (actualLocation === ".." || actualLocation.startsWith(`..${sep}`) || isAbsolute(actualLocation) || !statSync(actual).isFile()) file.fail(`${copy_error_asset}: 문서 폴더 밖이거나 일반 파일이 아니다 · ${url}`, node);
+		const assetUrl = toAssetPath({
+			path: `${asset_media_dir}/asset${extension}`,
+			file: actual
+		});
+		options.files.set(assetUrl, actual);
+		node.properties[property] = match[2] === void 0 ? assetUrl : `${assetUrl}${match[2]}`;
+	});
+};
+//#endregion
+//#region src/app/_function/create-processor/_rehype-heading-ids.ts
+/**
+* 제목 id와 목차 수집. 같은 제목은 -1, -2 접미사
+*
+*   - 작성한 제목 텍스트를 그대로 사용
+*/
+var rehypeHeadingIds = () => (tree, file) => {
+	const slugger = new Slugger();
+	const headings = [];
+	visit(tree, "element", (node) => {
+		const depth = /^h([1-6])$/.exec(node.tagName)?.[1];
+		if (depth === void 0) return;
+		const text = toString(node);
+		node.properties.id = typeof node.properties.id === "string" ? node.properties.id : slugger.slug(text);
+		headings.push({
+			depth: Number(depth),
+			slug: node.properties.id,
+			text
+		});
+		node.children = [{
+			type: "element",
+			tagName: "span",
+			properties: { className: ["wg_prose__headingText"] },
+			children: node.children
+		}];
+	});
+	if (file.data.fh) file.data.fh.headings = headings;
+};
+//#endregion
+//#region src/app/_function/create-processor/_remark-report.ts
+/**
+* 파일 경고의 터미널 출력. 파일:줄 경고. 빌드 계속
+*
+*   - 경고 수집 뒤 실행하는 마지막 remark 플러그인
+*/
+var remarkReport = (options) => (_tree, file) => {
+	const path = relative(options.root, file.path);
+	for (const message of file.messages) logger.warn(`${message.line === void 0 ? path : `${path}:${message.line}`} ${message.reason}`);
+};
+//#endregion
+//#region src/app/_constant/snippet.ts
+/**
+* 스니펫 구문, `<<< ./path.ext` 뒤 선택 region과 코드 펜스 메타 허용
+*/
+var snippet_pattern = /^<<<\s+(\S+?)(?:#([\w-]+))?(?:\s+(.+?))?\s*$/;
+/**
+* region 경계 구문, 주석 형식과 무관하게 이름으로 대응
+*/
+var snippet_region_pattern = /^\s*\S*\s*#(end)?region\s+([\w-]+)/;
+/**
+* 펜스 언어로 치환할 확장자, 미등록 확장자는 원문 사용
+*/
+var snippet_language_by_extension = {
+	".cjs": "js",
+	".md": "markdown",
+	".mjs": "js",
+	".mts": "ts",
+	".txt": "text",
+	".yml": "yaml"
+};
+//#endregion
+//#region src/app/_function/create-processor/_to-snippet-body.ts
+/**
+* region 지정 시 해당 범위만 추출, 미지정 시 전체 사용
+*
+*   - region 경계 줄과 공통 들여쓰기 제거
+*   - 빈 region은 빈 문자열, 없는 region은 undefined 반환
+*/
+var toSnippetBody = (source, region) => {
+	const lines = source.replace(/\r\n/g, "\n").split("\n");
+	let inside = region === void 0;
+	let found = region === void 0;
+	const kept = [];
+	for (const line of lines) {
+		const marker = snippet_region_pattern.exec(line);
+		if (marker !== null) {
+			if (region !== void 0 && marker[2] === region) {
+				inside = marker[1] === void 0;
+				found = true;
+			}
+			continue;
+		}
+		if (inside) kept.push(line);
+	}
+	if (!found) return;
+	const content = dropRightWhile(dropWhile(kept, (line) => line.trim() === ""), (line) => line.trim() === "");
+	const leastIndentedLine = minBy(content.filter((line) => line.trim() !== ""), (line) => line.length - line.trimStart().length);
+	if (leastIndentedLine === void 0) return "";
+	const indent = leastIndentedLine.length - leastIndentedLine.trimStart().length;
+	return content.map((line) => line.slice(Math.min(indent, line.length - line.trimStart().length))).join("\n");
+};
+//#endregion
+//#region src/app/_function/create-processor/_remark-snippets.ts
+/**
+* 문서 상대 경로의 코드 스니펫 삽입
+*
+*   - 선택 region과 메타를 코드 펜스에 반영
+*   - 문서 폴더 밖 경로와 없는 파일은 빌드 실패
+*/
+var remarkSnippets = (options) => (tree, file) => {
+	visit(tree, "paragraph", (node, index, parent) => {
+		const [child] = node.children;
+		if (node.children.length !== 1 || child === void 0 || child.type !== "text" || parent === void 0 || index === void 0) return;
+		const match = snippet_pattern.exec(child.value.trim());
+		if (match === null) return;
+		const [, path = "", region, meta] = match;
+		const target = resolve(dirname(file.path), path);
+		const location = relative(options.root, target);
+		if (location === ".." || location.startsWith(`..${sep}`) || isAbsolute(location)) file.fail(`${copy_error_snippet}: 문서 폴더 밖 · ${path}`, node);
+		if (!existsSync(target)) file.fail(`${copy_error_snippet}: 파일이 없다 · ${path}`, node);
+		const actual = realpathSync(target);
+		const actualLocation = relative(realpathSync(options.root), actual);
+		if (actualLocation === ".." || actualLocation.startsWith(`..${sep}`) || isAbsolute(actualLocation) || !statSync(actual).isFile()) file.fail(`${copy_error_snippet}: 문서 폴더 밖이거나 일반 파일이 아니다 · ${path}`, node);
+		const body = toSnippetBody(readFileSync(actual, "utf8"), region);
+		if (body === void 0) {
+			file.fail(`${copy_error_snippet}: region 이 없다 · ${path}#${region}`, node);
+			return;
+		}
+		const extension = extname(actual).toLowerCase();
+		const lang = snippet_language_by_extension[extension] === void 0 ? extension.slice(1) : snippet_language_by_extension[extension];
+		parent.children.splice(index, 1, {
+			type: "code",
+			lang,
+			meta: meta === void 0 ? null : meta,
+			value: body
+		});
+	});
+};
+/**
+* 코드 메타와 줄 지시문의 Shiki 변환기 순서
+*/
+var shikiTransformers = [
+	transformerNotationHighlight({ matchAlgorithm: "v3" }),
+	transformerNotationErrorLevel({ matchAlgorithm: "v3" }),
+	transformerNotationDiff({ matchAlgorithm: "v3" }),
+	transformerNotationWordHighlight({ matchAlgorithm: "v3" }),
+	transformerMetaHighlight(),
+	{
+		name: "for-humanity:code-metadata",
+		root(root) {
+			this.pre.properties.style = void 0;
+			this.addClassToHast(this.pre, "wg_prose__code");
+			if (this.options.meta?.__raw === void 0) return;
+			if (/\bline-numbers\b/.test(this.options.meta.__raw)) this.addClassToHast(this.pre, "wg_prose__lineNumbers");
+			const isBad = /\bbad\b/.test(this.options.meta.__raw);
+			const isGood = /\bgood\b/.test(this.options.meta.__raw);
+			if (isBad) this.addClassToHast(this.pre, "wg_prose__code--bad");
+			if (isGood) this.addClassToHast(this.pre, "wg_prose__code--good");
+			const title = /\[([^\]]+)\]/.exec(this.options.meta.__raw)?.[1];
+			if (title === void 0) return;
+			root.children = [{
+				type: "element",
+				tagName: "figure",
+				properties: { className: ["wg_prose__codeFile"] },
+				children: [{
+					type: "element",
+					tagName: "figcaption",
+					properties: { className: [
+						"wg_prose__codeFileTitle",
+						...isBad ? ["wg_prose__codeFileTitle--bad"] : [],
+						...isGood ? ["wg_prose__codeFileTitle--good"] : []
+					] },
+					children: [{
+						type: "text",
+						value: title
+					}, {
+						type: "element",
+						tagName: "span",
+						properties: { className: ["wg_prose__codeFileLang"] },
+						children: [{
+							type: "text",
+							value: this.options.lang
+						}]
+					}]
+				}, ...root.children.filter((child) => child.type !== "doctype")]
+			}];
+		}
+	}
+];
+//#endregion
+//#region src/component/widget/mermaid/_function/remark-mermaid.ts
+/**
+* Mermaid 원문과 브라우저 렌더 영역. JavaScript 비활성 환경에서도 원문 유지
+*/
+var remarkMermaid = (options) => (tree) => {
+	visit(tree, "code", (node, index, parent) => {
+		if (node.lang !== "mermaid" || parent === void 0 || index === void 0) return;
+		if (options.assets !== void 0) for (const [url, path] of options.assets.files) options.files.set(url, path);
+		parent.children[index] = {
+			type: "html",
+			value: `<figure class="wg_mermaid__root" data-mermaid${options.assets === void 0 ? "" : ` data-mermaid-module="${options.assets.entry}"`}><div class="wg_mermaid__result" hidden></div><pre class="wg_mermaid__source"><code data-mermaid-source>${node.value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;")}</code></pre><p class="wg_mermaid__error" role="status" hidden></p></figure>`
+		};
+	});
+};
+//#endregion
+//#region src/component/widget/prose/_constant/section.ts
+/**
+* 목차 대상 제목 깊이. h2 절, h3 소제목
+*/
+var section_heading_depth = {
+	section: 2,
+	sub: 3
+};
+//#endregion
+//#region src/component/widget/prose/_function/rehype-head.ts
+/**
+* name 제목과 첫 절 앞 본문의 공통 머리. README는 원문의 h1 사용
+*/
+var rehypeHead = () => (tree, file) => {
+	const firstSection = tree.children.findIndex((node) => node.type === "element" && node.tagName === `h${section_heading_depth.section}`);
+	const leadEnd = firstSection === -1 ? tree.children.length : firstSection;
+	const head = {
+		type: "element",
+		tagName: "header",
+		properties: { className: ["wg_prose__head"] },
+		children: tree.children.slice(0, leadEnd).filter((node) => node.type !== "doctype")
+	};
+	if (file.data.fh?.frontmatter !== void 0) head.children.unshift({
+		type: "element",
+		tagName: "h1",
+		properties: { className: ["wg_prose__title"] },
+		children: [{
+			type: "text",
+			value: file.data.fh.frontmatter.name
+		}]
+	});
+	else if (leadEnd === 0) return;
+	tree.children = [head, ...tree.children.slice(leadEnd)];
+};
+//#endregion
+//#region src/component/widget/prose/_function/rehype-sections/_to-section-headings.ts
+/**
+* 목차 대상 h2, h3. 중첩 블록까지 문서 순서 수집
+*
+*   - rehype-heading-ids의 순회 순서와 일치
+*/
+var toSectionHeadings = (node) => {
+	return node.children.flatMap((child) => {
+		if (child.type !== "element") return [];
+		if (child.tagName === `h${section_heading_depth.section}` || child.tagName === `h${section_heading_depth.sub}`) return [child];
+		return toSectionHeadings(child);
+	});
+};
+//#endregion
+//#region src/component/widget/prose/_function/rehype-sections/rehype-sections.ts
+/**
+* h2, h3의 가름 메타데이터 수집. 작성한 제목은 그대로 유지
+*
+*   - id, 목차 텍스트는 앞 단계의 rehype-heading-ids 소유
+*   - file.data.fh.sections는 headings의 h2, h3 순서와 일치
+*/
+var rehypeSections = () => (tree, file) => {
+	if (file.data.fh === void 0) return;
+	file.data.fh.sections = toSectionHeadings(tree).map((heading) => {
+		return { part: typeof heading.properties.dataPart === "string" ? heading.properties.dataPart : void 0 };
+	});
+};
+//#endregion
+//#region src/component/widget/prose/_function/rehype-tables.ts
+/**
+* 넓은 표의 내부 가로 스크롤 래퍼
+*/
+var rehypeTables = () => (tree) => {
+	visit(tree, "element", (node, index, parent) => {
+		if (node.tagName !== "table" || parent === void 0 || index === void 0) return;
+		parent.children[index] = {
+			type: "element",
+			tagName: "div",
+			properties: { className: ["wg_prose__table"] },
+			children: [node]
+		};
+		return [SKIP, index + 1];
+	});
+};
+//#endregion
+//#region src/component/widget/prose/_function/has-block-content.ts
+/**
+* 부품 본문의 내용 판정. 참조 정의, 주석, 빈 텍스트와 빈 구조 제외
+*
+*   - 이미지, 표, 구분선, 주석 외 원시 HTML은 본문 요소
+*/
+var hasBlockContent = (node) => {
+	if (node.type === "definition") return false;
+	if (node.type === "html") return node.value.replace(/<!--(?:>|->|[\s\S]*?(?:--!?>|$))/g, "").trim() !== "";
+	if ("value" in node) return node.value.trim() !== "";
+	if (node.type === "table" || node.type === "textDirective") return true;
+	if ("children" in node) return node.children.some(hasBlockContent);
+	return true;
+};
+//#endregion
+//#region src/component/widget/prose/_function/remark-blocks.ts
+/**
+* Note, Details의 제목, 본문, 속성, 닫힘 계약
+*
+*   - label은 첫 자식. summary는 Details의 첫 요소. 원문 위치는 오류 기준
+*/
+var remarkBlocks = () => (tree, file) => {
+	const source = String(file.value);
+	visit(tree, (node, _index, parent) => {
+		if (node.type === "leafDirective" && node.name === "part" && parent?.type !== "root") file.fail(`${copy_error_directive_syntax}: part · 문서 최상위에 작성`, node);
+		if (node.type !== "containerDirective" && node.type !== "leafDirective" && node.type !== "textDirective") return;
+		if (node.name !== "note" && node.name !== "details") return;
+		if (node.type !== "containerDirective") file.fail(`${copy_error_directive_syntax}: ${node.name} · ::: 블록으로 작성`, node);
+		const label = node.children.at(0);
+		if (label?.type !== "paragraph" || label.data?.directiveLabel !== true || label.children.some((child) => child.type !== "text")) file.fail(`${copy_error_directive_syntax}: ${node.name} · 일반 텍스트 제목 필수`, node);
+		const title = toString$1(label).trim();
+		if (title === "") file.fail(`${copy_error_directive_syntax}: ${node.name} · 비어 있지 않은 제목 필수`, node);
+		if (!node.children.slice(1).some(hasBlockContent)) file.fail(`${copy_error_directive_syntax}: ${node.name} · 본문 필수`, node);
+		const unsupported = node.attributes ? Object.keys(node.attributes).find((key) => node.name !== "details" || key !== "open") : void 0;
+		if (unsupported !== void 0) file.fail(`${copy_error_directive_syntax}: ${node.name} · 미지원 속성 ${unsupported}`, node);
+		const open = node.attributes?.open;
+		const attributeSource = source.slice(label.position?.end.offset, node.position?.end.offset).split(/\r?\n/, 1)[0].trim();
+		if (attributeSource !== "" && (node.name !== "details" || !/^\{[ \t]*open[ \t]*\}$/.test(attributeSource))) file.fail(`${copy_error_directive_syntax}: ${node.name} · 허용 속성은 Details의 {open}, 나머지는 생략`, node);
+		const original = source.slice(node.position?.start.offset, node.position?.end.offset);
+		const opening = /^(:{3,})/.exec(original);
+		const closing = /(?:^|\n)[ \t>]*(:{3,})[ \t]*\r?$/.exec(original);
+		if (opening === null || closing === null || closing.index + closing[0].length !== original.length || closing[1].length < opening[1].length || node.position?.end.offset === node.children.at(-1)?.position?.end.offset) file.fail(`${copy_error_directive_syntax}: ${node.name} · 블록을 닫는 fence 필수`, node);
+		visit(node, "heading", (heading) => {
+			if (heading.depth <= section_heading_depth.section) file.fail(`${copy_error_directive_syntax}: ${node.name} · #·## 제목은 부품 밖에 작성`, heading);
+		});
+		visit(node, "code", (code) => {
+			const originalCode = source.slice(code.position?.start.offset, code.position?.end.offset);
+			const codeOpening = /^ {0,3}(`{3,}|~{3,})/.exec(originalCode);
+			const codeClosing = /(?:^|\n)[ \t>]*(`{3,}|~{3,})[ \t]*\r?$/.exec(originalCode);
+			if (codeOpening !== null && (codeClosing === null || codeClosing.index + codeClosing[0].length !== originalCode.length || codeClosing[1][0] !== codeOpening[1][0] || codeClosing[1].length < codeOpening[1].length)) file.fail(`${copy_error_directive_syntax}: ${node.name} · 코드 fence를 닫고, 코드 안의 :보다 긴 바깥 fence 사용`, code);
+		});
+		label.children = [{
+			type: "text",
+			value: title
+		}];
+		label.data = {
+			...label.data,
+			hName: node.name === "note" ? "strong" : "summary",
+			hProperties: { className: [node.name === "note" ? "wg_prose__noteTitle" : "wg_prose__detailsSummary"] }
+		};
+		node.data = {
+			...node.data,
+			hName: node.name === "note" ? "aside" : "details",
+			hProperties: node.name === "note" ? {
+				className: ["wg_prose__note"],
+				ariaLabel: title
+			} : {
+				className: ["wg_prose__details"],
+				open: open === ""
+			}
+		};
+	});
+};
+//#endregion
+//#region src/component/widget/prose/_function/remark-links.ts
+/**
+* 상대 Markdown 링크의 사이트 URL 변환, query와 hash 원문 유지
+*
+*   - 외부, 절대 URL과 같은 페이지 hash 유지. 없는 파일은 터미널 경고
+*/
+var remarkLinks = (options) => (tree, file) => {
+	const here = posix.dirname(relative(options.root, file.path).split(sep).join("/"));
+	visit(tree, (node) => {
+		if (node.type !== "link" && node.type !== "definition") return;
+		const match = /^(?![a-z]+:|\/|#)([^#?]+)(\.mdx?)([?#].*|)$/i.exec(node.url);
+		if (match) {
+			if (!existsSync(resolve(dirname(file.path), `${match[1]}${match[2]}`))) file.message(`${copy_warn_broken_link}: ${node.url}`, node);
+			const target = posix.join(here, `${match[1]}${match[2]}`).toLowerCase();
+			node.url = target === "readme.md" ? `/${match[3]}` : `/${target.slice(0, -match[2].length)}/${match[3]}`;
+		}
+	});
+};
+//#endregion
+//#region src/component/widget/prose/_function/remark-parts.ts
+/**
+* ::part[이름]의 본문 가름과 다음 h2의 data-part
+*
+*   - rehype-sections에서 같은 지점의 목차 묶음 생성
+*/
+var remarkParts = () => (tree) => {
+	for (const [index, node] of tree.children.entries()) {
+		if (node.type !== "leafDirective" || node.name !== "part") continue;
+		const section = tree.children.slice(index + 1).find((next) => next.type === "heading" && next.depth === section_heading_depth.section);
+		node.data = {
+			hName: "div",
+			hProperties: { className: ["wg_prose__part"] }
+		};
+		if (section) section.data = {
+			...section.data,
+			hProperties: {
+				...section.data?.hProperties,
+				dataPart: toString$1(node).trim()
+			}
+		};
+	}
+};
+//#endregion
+//#region src/component/widget/prose/_constant/status.ts
+/**
+* 상태 문구 뒤 날짜 패턴. YYYY-MM-DD
+*/
+var status_date_pattern = String.raw`\d{4}-\d{2}-\d{2}`;
+/**
+* 미등록 날짜 상태 후보. 등록 문구 치환 뒤 남은 괄호 문구
+*/
+var status_candidate_pattern = new RegExp(String.raw`\([^()\n]*${status_date_pattern}\)`, "g");
+//#endregion
+//#region src/component/widget/prose/_function/remark-status.ts
+/**
+* 설정 문구의 상태 표지 변환. 괄호 제거. 제목, 링크 제외
+*
+*   - 미등록 날짜 문구는 파일 경고. remark-report에서 출력
+*/
+var remarkStatus = (options) => {
+	const statuses = options.status.toSorted((a, b) => b.phrase.length - a.phrase.length);
+	const phrases = statuses.map((item) => [escapeRegExp(item.phrase), ...item.date ? [`(?: ${status_date_pattern})?`] : []].join("")).join("|");
+	const pattern = new RegExp(String.raw`\((${phrases})\)|(${phrases})`, "g");
+	const ignore = [
+		"link",
+		"linkReference",
+		"heading"
+	];
+	return (tree, file) => {
+		findAndReplace(tree, [pattern, (_match, inParens, bare) => {
+			const text = inParens ?? bare;
+			const item = statuses.find((status) => text?.startsWith(status.phrase));
+			if (text === void 0 || item === void 0) return false;
+			return {
+				type: "html",
+				value: `<span class="wg_prose__pill wg_prose__pill--${item.kind}">${escape(text)}</span>`
+			};
+		}], { ignore });
+		findAndReplace(tree, [status_candidate_pattern, (match, info) => {
+			file.message(`${copy_warn_unknown_status}: ${match}`, info.stack.findLast((node) => node.position !== void 0));
+			return false;
+		}], { ignore });
+	};
+};
+//#endregion
+//#region src/component/widget/prose/_function/remark-swatch.ts
+/**
+* 인라인 hex 색 값의 칩 표시
+*
+*   - 문서별 색은 --wg-prose-chip-color로 전달. 고정 스타일시트 값 불가
+*/
+var remarkSwatch = () => (tree) => {
+	visit(tree, "inlineCode", (node) => {
+		if (/^#[0-9a-f]{3,8}$/i.test(node.value.trim())) node.data = { hProperties: {
+			className: ["wg_prose__color"],
+			style: `--wg-prose-chip-color: ${node.value.trim()}`
+		} };
+	});
+};
+//#endregion
+//#region src/component/widget/prose/_function/remark-unknown-directives.ts
+/**
+* hName 없는 블록 지시문은 작성 오류
+*
+*   - textDirective는 원문 복원. 예:이것 같은 일반 문장의 오인 방지
+*/
+var remarkUnknownDirectives = () => (tree, file) => {
+	visit(tree, (node, index, parent) => {
+		if (node.type === "textDirective" && parent !== void 0 && index !== void 0) {
+			parent.children[index] = {
+				type: "text",
+				value: String(file.value).slice(node.position?.start.offset, node.position?.end.offset)
+			};
+			return SKIP;
+		}
+		if ((node.type === "leafDirective" || node.type === "containerDirective") && node.data?.hName === void 0) file.fail(`${copy_error_unknown_directive}: ${node.name}`, node);
+	});
+};
+//#endregion
+//#region src/app/_function/create-processor/create-processor.ts
+/**
+* Markdown 변환과 문서 메타데이터 수집
+*
+*   - 코드와 문서 머리 생성 후 제목 ID와 가름 수집
+*   - 플러그인 HTML 조각은 마지막 rehype-raw에서 해석
+*   - 코드 상자의 색상은 prose CSS 소유, Shiki 토큰 색상은 --app-code-* 참조
+*/
+var createProcessor = (options) => {
+	const files = options.files ?? /* @__PURE__ */ new Map();
+	return unified().use(remarkParse).use(remarkFrontmatter, ["yaml"]).use(remarkGfm).use(remarkSnippets, { root: options.root }).use(remarkSmartypants).use(remarkDirective).use(remarkBlocks).use(remarkParts).use(remarkMermaid, {
+		assets: options.mermaid,
+		files
+	}).use(remarkStatus, { status: options.site.status }).use(remarkSwatch).use(remarkLinks, { root: options.root }).use(remarkUnknownDirectives).use(remarkReport, { root: options.root }).use(remarkRehype, { allowDangerousHtml: true }).use(rehypeShiki, {
+		theme: createCssVariablesTheme({
+			name: "for-humanity",
+			variablePrefix: "--app-code-"
+		}),
+		transformers: shikiTransformers
+	}).use(rehypeHead).use(rehypeHeadingIds).use(rehypeSections).use(rehypeTables).use(rehypeRaw).use(rehypeAssets, {
+		root: options.root,
+		files
+	}).use(rehypeStringify, { allowDangerousHtml: true });
+};
+//#endregion
+//#region src/app/_function/load-mermaid-assets.ts
+/**
+* 패키지에 포함한 Mermaid 진입 모듈과 지연 청크 등록 목록
+*/
+var loadMermaidAssets = (kitRoot) => {
+	const directory = join(kitRoot, "dist/mermaid");
+	const names = readdirSync(directory);
+	const entry = names.find((name) => name.startsWith("mermaid-") && name.endsWith(".js"));
+	if (entry === void 0) throw new Error("Missing Mermaid browser entry. Run pnpm build:kit before using the CLI.");
+	return {
+		entry: `${asset_mermaid_dir}/${entry}`,
+		files: new Map(names.map((name) => [`${asset_mermaid_dir}/${name}`, join(directory, name)]))
+	};
+};
+//#endregion
+//#region src/constant/doc.ts
+/**
+* 기존 frontmatter type의 호환 값. 모두 같은 Markdown 렌더링
+*
+*   - 새 문서는 type 생략 권장
+*/
+var doc_type = {
+	document: "document",
+	blueprint: "blueprint"
+};
+/**
+* 순서 미지정 문서는 번호가 있는 문서 뒤에서 이름순 배치
+*/
+var doc_order_default = Number.MAX_SAFE_INTEGER;
+//#endregion
+//#region src/type/doc-data.ts
+/**
+* 문서 frontmatter 스키마. 검증 실패 시 빌드 중단
+*/
+var docDataSchema = z.object({
+	/**
+	* 문서 이름. 제목, 목록. 같은 첫 글자 허용
+	*/
+	name: z.string().trim().min(1),
+	/**
+	* 짧은 문서 설명. 사이드바 툴팁
+	*/
+	label: z.string(),
+	/**
+	* 기존 type 값 호환. 생략 권장, 렌더링 차이 없음
+	*/
+	type: z.enum(doc_type).default(doc_type.document),
+	/**
+	* 사이드바의 문서 묶음 경로. 문자열도 배열로 정규화
+	*/
+	group: groupPathSchema,
+	/**
+	* 같은 묶음 안의 부모 문서 id. 확장자 제외, ./, ../ 상대 경로도 허용
+	*/
+	parent: z.string().trim().min(1).optional(),
+	/**
+	* 묶음 안의 읽는 순서. 미지정 문서는 뒤에서 이름순
+	*/
+	order: z.number().int().nonnegative().default(doc_order_default)
+});
+//#endregion
+//#region src/app/_function/read-docs.ts
+/**
+* Markdown 수집과 렌더링. 루트 README는 홈, AGENTS, CLAUDE는 작성 지침으로 분리
+*
+*   - 문서 목록에서 루트 안내 파일, node_modules, dist 제외
+*   - 머리말, 문서 식별자 중복, 플러그인 오류 시 실패
+*/
+var readDocs = async (options) => {
+	const paths = (await readdir(options.root, { recursive: true })).filter((path) => /\.mdx?$/i.test(path) && !/^(readme|agents|claude)\.md$/i.test(path) && !path.split(sep).includes("node_modules") && !path.startsWith(`dist${sep}`));
+	const docs = await Promise.all(paths.map(async (path) => {
+		const id = path.replace(/\.mdx?$/i, "").split(sep).join("/").toLowerCase();
+		const segments = id.split("/");
+		if (segments.some((segment) => segment === "" || segment === "." || segment === ".." || segment === "index.html") || /[#?%*:\\]/.test(id) || /[\p{Cc}]/u.test(id) || options.reserved?.includes(segments[0]) === true || segments[0] === "_fh" || segments[0] === "/favicon.svg".slice(1)) throw new Error(`${copy_error_doc_id}: ${path}`);
+		const source = await readFile(join(options.root, path), "utf8");
+		const file = new VFile({
+			value: source.replace(/^\uFEFF/, ""),
+			path: join(options.root, path)
+		});
+		const tree = options.processor.parse(file);
+		const frontmatter = tree.children[0];
+		const parsed = docDataSchema.safeParse(frontmatter?.type === "yaml" ? parse(frontmatter.value) : {});
+		if (!parsed.success) throw new Error(`${copy_error_frontmatter}: ${path}: ${parsed.error.issues.map((issue) => `${issue.path.join(".")} ${issue.message}`).join(", ")}`);
+		const data = {
+			...parsed.data,
+			parent: parsed.data.parent !== void 0 && /^\.\.?\//.test(parsed.data.parent) ? posix.join(posix.dirname(id), parsed.data.parent) : parsed.data.parent
+		};
+		const fh = {
+			frontmatter: data,
+			headings: [],
+			sections: []
+		};
+		file.data.fh = fh;
+		tree.children = tree.children.filter((node) => node.type !== "yaml");
+		const rendered = await options.processor.run(tree, file);
+		return {
+			id,
+			data,
+			ancestors: [],
+			html: options.processor.stringify(rendered, file),
+			outline: {
+				headings: fh.headings,
+				sections: fh.sections
+			}
+		};
+	}));
+	const duplicateIds = [...Map.groupBy(docs, (doc) => doc.id)].filter((entry) => entry[1].length > 1);
+	if (duplicateIds.length > 0) throw new Error(`${copy_error_doc_id_clash}: ${duplicateIds.map((entry) => entry[0]).join(", ")}`);
+	const docsById = new Map(docs.map((doc) => [doc.id, doc]));
+	return docs.map((doc) => {
+		const ancestors = /* @__PURE__ */ new Set([doc.id]);
+		for (let parentId = doc.data.parent; parentId !== void 0;) {
+			const parent = docsById.get(parentId);
+			if (parent === void 0) throw new Error(`${copy_error_doc_parent_missing}: ${doc.id} → ${parentId}`);
+			if (ancestors.has(parent.id)) throw new Error(`${copy_error_doc_parent_cycle}: ${[...ancestors, parent.id].join(" → ")}`);
+			if (!isEqual(parent.data.group, doc.data.group)) throw new Error(`${copy_error_doc_parent_group}: ${doc.id} → ${parent.id}`);
+			ancestors.add(parent.id);
+			parentId = parent.data.parent;
+		}
+		return {
+			...doc,
+			ancestors: [...ancestors].slice(1).toReversed()
+		};
+	});
+};
+//#endregion
+//#region src/app/_function/read-home.ts
+/**
+* 문서 루트의 README 홈 변환
+*
+*   - 대소문자 무시, frontmatter 불필요
+*   - 파일 부재 시 생성 안내 표시, 이름만 다른 README 중복은 오류
+*/
+var readHome = async (options) => {
+	const paths = (await readdir(options.root)).filter((path) => path.toLowerCase() === "readme.md");
+	if (paths.length > 1) throw new Error(`${copy_error_home_clash}: ${paths.join(", ")}`);
+	if (paths.length === 0) return;
+	const path = join(options.root, paths[0]);
+	const fh = {
+		headings: [],
+		sections: []
+	};
+	const file = new VFile({
+		value: (await readFile(path, "utf8")).replace(/^\uFEFF/, ""),
+		path,
+		data: { fh }
+	});
+	await options.processor.process(file);
+	return {
+		html: String(file),
+		outline: {
+			headings: fh.headings,
+			sections: fh.sections
+		}
+	};
+};
+//#endregion
+//#region src/app/_function/to-crawling-app.ts
+/**
+* dev와 정적 빌드에서 같은 크롤러 파일 생성. 정책, 수정 시각은 추정하지 않음
+*/
+var toCrawlingApp = (params) => {
+	const app = new Hono();
+	app.get(crawling_robots_path, (c) => c.text(`User-agent: *\nAllow: /\n\nSitemap: ${params.url}${crawling_sitemap_path}\n`));
+	app.get(crawling_sitemap_path, (_c) => {
+		return new Response(html`<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+<url><loc>${params.url}/</loc></url>
+${params.store.docs.map((doc) => html`<url><loc>${params.url}/${doc.id.split("/").map(encodeURIComponent).join("/")}/</loc></url>`)}
+</urlset>`.toString(), { headers: { "Content-Type": "application/xml; charset=utf-8" } });
+	});
+	return app;
+};
+//#endregion
+//#region src/constant/font.ts
+/**
+* 본문 영문, 코드, 흐름도 글꼴 CSS. 패키지 기준 경로. Regular, SemiBold 두 파일
+*/
+var font_mono_css = "src/asset/font/monoplex-kr/monoplex-kr.css";
+/**
+* 본문 한글 글꼴 CSS. IBM Plex Sans KR Regular, SemiBold. 한글 unicode-range
+*/
+var font_body_css = "src/asset/font/ibm-plex-sans-kr/ibm-plex-sans-kr.css";
+/**
+* 사이트 이름 글꼴 CSS. Architects Daughter Regular. 라틴 subset
+*/
+var font_brand_css = "src/asset/font/architects-daughter/architects-daughter.css";
+/**
+* 늦게 받은 글꼴로 이미 보이는 대체 글꼴을 교체하지 않는 표시 정책
+*/
+var font_display_strategy = "optional";
+/**
+* 내용 지문이 붙은 글꼴만 장기 재사용. CSS와 브라우저 스크립트는 대상 제외
+*/
+var font_cache_control = "public, max-age=31536000, immutable";
+//#endregion
+//#region src/app/_function/to-http-app.ts
+/**
+* 등록 자원과 크롤러 응답, 나머지 요청은 페이지 앱에 위임
+*
+*   - 정적 생성은 페이지 앱만 사용, 파일 응답과 정규식 페이지 라우트 분리
+*/
+var toHttpApp = (options) => {
+	const app = new Hono();
+	/**
+	* 등록된 URL의 자원 응답. 미등록 시 404
+	*/
+	const handleAsset = async (c) => {
+		const file = options.files.get(c.req.path);
+		if (file === void 0) return c.notFound();
+		c.header("content-type", asset_content_types[extname(file).toLowerCase()] ?? "application/octet-stream");
+		if (extname(file) === ".woff2") c.header("Cache-Control", font_cache_control);
+		return c.body(await readFile(file));
+	};
+	app.get(`/_fh/*`, handleAsset);
+	app.get(asset_favicon_path, handleAsset);
+	if (options.crawling !== void 0) app.on("GET", [crawling_robots_path, crawling_sitemap_path], (c) => options.crawling?.fetch(c.req.raw, c.env) ?? c.notFound());
+	app.all("/*", (c) => options.pages.fetch(c.req.raw, c.env));
+	return app;
+};
+//#endregion
+//#region src/app/_function/to-page-app/_to-html.ts
+/**
+* Hono JSX 페이지의 HTML 문서 선언, 서버와 정적 출력의 공통 직렬화
+*/
+var toHtml = (page) => {
+	return html`<!DOCTYPE html>${page}`;
+};
+//#endregion
+//#region src/component/widget/prose/wg-prose.tsx
+var WgProse = (props) => {
+	if (props.html !== void 0) return /* @__PURE__ */ jsx("article", {
+		className: clsx("wg_prose__root"),
+		dangerouslySetInnerHTML: { __html: props.html }
+	});
+	return /* @__PURE__ */ jsx("article", {
+		className: clsx("wg_prose__root"),
+		children: props.head !== void 0 && /* @__PURE__ */ jsxs("header", {
+			className: clsx("wg_prose__head"),
+			children: [/* @__PURE__ */ jsx("h1", {
+				className: clsx("wg_prose__title"),
+				children: props.head.title
+			}), props.head.lead !== void 0 && /* @__PURE__ */ jsx("p", {
+				className: clsx("wg_prose__lead"),
+				children: props.head.lead
+			})]
+		})
+	});
+};
+//#endregion
+//#region src/component/widget/navigation/_function/to-doc-groups/_to-doc-branches.ts
+/**
+* 검증된 부모 관계로 문서 가지를 재귀 구성. 형제 순서와 URL 유지
+*/
+var toDocBranches = (options) => {
+	return options.docs.toSorted((a, b) => a.data.order - b.data.order || a.data.name.localeCompare(b.data.name, "en") || a.id.localeCompare(b.id, "en")).map((doc) => {
+		const children = options.children.get(doc.id);
+		return {
+			...doc,
+			children: children === void 0 ? void 0 : toDocBranches({
+				docs: children,
+				children: options.children
+			})
+		};
+	});
+};
+//#endregion
+//#region src/component/widget/navigation/_function/to-doc-groups/_to-doc-group-branches.ts
+/**
+* 각 단계의 직접 문서와 하위 묶음을 분리. 고정된 깊이 제한 없이 구성
+*/
+var toDocGroupBranches = (options) => {
+	return [...Map.groupBy(options.docs.filter((doc) => doc.data.group.length > options.path.length), (doc) => doc.data.group[options.path.length])].map(([name, docs]) => {
+		const path = [...options.path, name];
+		return {
+			name,
+			path,
+			docs,
+			position: options.positions.get(JSON.stringify(path)) ?? options.unlistedPosition
+		};
+	}).toSorted((a, b) => a.position - b.position || a.name.localeCompare(b.name, "ko")).map((group) => {
+		return {
+			name: group.name,
+			path: group.path,
+			docs: toDocBranches({
+				docs: group.docs.filter((doc) => doc.data.group.length === group.path.length && doc.data.parent === void 0),
+				children: options.children
+			}),
+			groups: toDocGroupBranches({
+				docs: group.docs,
+				children: options.children,
+				path: group.path,
+				positions: options.positions,
+				unlistedPosition: options.unlistedPosition
+			})
+		};
+	});
+};
+//#endregion
+//#region src/component/widget/navigation/_function/to-doc-groups/to-doc-groups.ts
+/**
+* 메타데이터 경로로 읽는 순서를 가진 문서 계층 구성
+*
+*   - 같은 조상의 중복 지정은 최초 순서 유지
+*   - 미지정 형제 묶음은 이름순
+*/
+var toDocGroups = (options) => {
+	const positions = new Map(uniqBy(options.navigation.flatMap((path, index) => {
+		return path.map((_name, depth) => [JSON.stringify(path.slice(0, depth + 1)), index]);
+	}), (entry) => entry[0]));
+	const children = Map.groupBy(options.docs, (doc) => doc.data.parent);
+	return toDocGroupBranches({
+		docs: options.docs,
+		children,
+		path: [],
+		positions,
+		unlistedPosition: options.navigation.length
+	});
+};
+//#endregion
+//#region src/component/widget/navigation/_function/to-navigation-data/_to-navigation-document.ts
+/**
+* 본문 없는 문서 가지. 재귀에서도 현재 페이지 한 항목만 표시
+*/
+var toNavigationDocument = (options) => {
+	return {
+		id: options.doc.id,
+		name: options.doc.data.name,
+		label: options.doc.data.label,
+		active: options.doc.id === options.current,
+		children: options.doc.children === void 0 ? [] : options.doc.children.map((doc) => toNavigationDocument({
+			...options,
+			doc
+		}))
+	};
+};
+//#endregion
+//#region src/component/widget/navigation/_function/to-navigation-data/_to-navigation-group.ts
+/**
+* 전체 묶음 경로와 본문 없는 하위 가지
+*/
+var toNavigationGroup = (options) => {
+	return {
+		name: options.group.name,
+		path: options.group.path,
+		docs: options.group.docs.map((doc) => toNavigationDocument({
+			doc,
+			current: options.current
+		})),
+		groups: options.group.groups.map((group) => toNavigationGroup({
+			...options,
+			group
+		}))
+	};
+};
+//#endregion
+//#region src/component/widget/navigation/_function/to-toc-groups.ts
+/**
+* h2별 h3 수집. 가름 시작 절에서 목차 묶음 분리
+*
+*   - 첫 h2 앞의 h3은 목차 제외
+*/
+var toTocGroups = (outline) => {
+	const entries = outline.headings.filter((heading) => heading.depth === section_heading_depth.section || heading.depth === section_heading_depth.sub).map((heading, index) => ({
+		heading,
+		section: outline.sections[index]
+	}));
+	const sections = entries.flatMap((entry, index) => {
+		if (entry.heading.depth !== section_heading_depth.section) return [];
+		return [{
+			heading: entry.heading,
+			part: entry.section.part,
+			subs: takeWhile(entries.slice(index + 1), (sub) => sub.heading.depth !== section_heading_depth.section).map((sub) => {
+				return { heading: sub.heading };
+			})
+		}];
+	});
+	return sections.flatMap((section, index) => {
+		if (index > 0 && section.part === void 0) return [];
+		return [{
+			part: section.part,
+			sections: [section, ...takeWhile(sections.slice(index + 1), (next) => next.part === void 0)]
+		}];
+	});
+};
+//#endregion
+//#region src/component/widget/navigation/_function/to-navigation-data/to-navigation-data.ts
+/**
+* 현재 문서의 이름, 계층, 목차만 전송. 다른 문서 본문은 브라우저 탐색 입력에서 제외
+*/
+var toNavigationData = (options) => {
+	return {
+		title: options.site.title,
+		groups: toDocGroups({
+			docs: options.docs,
+			navigation: options.site.navigation
+		}).map((group) => toNavigationGroup({
+			group,
+			current: options.current
+		})),
+		outline: options.outline === void 0 ? [] : toTocGroups(options.outline),
+		home: options.current === void 0,
+		cursorFace: options.site.cursorFace
+	};
+};
+//#endregion
+//#region src/component/widget/navigation/_function/to-navigation-json.ts
+/**
+* 작성한 이름이 script 종료 태그나 JavaScript 줄 구분자로 해석되지 않는 JSON
+*/
+var toNavigationJson = (data) => {
+	return JSON.stringify(data).replaceAll("<", "\\u003c").replaceAll("\u2028", "\\u2028").replaceAll("\u2029", "\\u2029");
+};
+//#endregion
+//#region src/component/widget/cursor-face/_constant/cursor-face.ts
+/**
+* 같은 탭의 문서 이동에서 커서 위치를 한 번 이어받는 저장소 키
+*/
+var cursor_face_storage_key = "fh-cursor-face";
+//#endregion
+//#region src/component/widget/cursor-face/wg-cursor-face.tsx
+var WgCursorFace = (props) => {
+	const faceRef = useRef(null);
+	const mediaRef = useRef(null);
+	const positionRef = useRef({
+		x: 0,
+		y: 0,
+		frame: 0,
+		hasPointer: false
+	});
+	/**
+	* 화면 이탈, 터치 전환에서 예약된 이동까지 취소
+	*/
+	const handleCursorHide = () => {
+		cancelAnimationFrame(positionRef.current.frame);
+		positionRef.current.frame = 0;
+		faceRef.current?.classList.remove("wg_cursorFace__root--visible");
+	};
+	/**
+	* 비활성 전환에서만 숨겨 새 마우스 이동을 취소하지 않음
+	*/
+	const handleCursorMediaChange = () => {
+		if (!mediaRef.current?.matches) {
+			positionRef.current.hasPointer = false;
+			handleCursorHide();
+		}
+	};
+	/**
+	* 화면 갱신마다 한 번만 반영. transform으로 본문 재배치 방지
+	*/
+	const renderCursorFace = () => {
+		if (positionRef.current.frame !== 0) return;
+		positionRef.current.frame = requestAnimationFrame(() => {
+			positionRef.current.frame = 0;
+			const face = faceRef.current;
+			if (face === null) return;
+			face.style.transform = `translate3d(
+                ${Math.max(0, Math.min(positionRef.current.x + 16, document.documentElement.clientWidth - face.width - 16))}px,
+                ${Math.max(0, Math.min(positionRef.current.y + 16, document.documentElement.clientHeight - face.height - 16))}px,
+                0
+            )`;
+			face.classList.add("wg_cursorFace__root--visible");
+		});
+	};
+	/**
+	* 클릭, 텍스트 선택 중에도 장식 유지. 실제 마우스 입력만 좌표 반영
+	*/
+	const handleDocumentPointer = (event) => {
+		if (!mediaRef.current?.matches || event.pointerType !== "mouse") {
+			positionRef.current.hasPointer = false;
+			handleCursorHide();
+			return;
+		}
+		positionRef.current.x = event.clientX;
+		positionRef.current.y = event.clientY;
+		positionRef.current.hasPointer = true;
+		renderCursorFace();
+	};
+	/**
+	* 새 마우스 이동 없이 화면 가장자리의 좌표 재계산
+	*/
+	const handleCursorResize = () => {
+		if (faceRef.current?.classList.contains("wg_cursorFace__root--visible")) renderCursorFace();
+	};
+	/**
+	* 같은 탭의 마지막 마우스 좌표 전달, 포커스 이탈의 일시 숨김과 무관
+	*/
+	const handlePageHide = () => {
+		if (!positionRef.current.hasPointer) return;
+		try {
+			sessionStorage.setItem(cursor_face_storage_key, JSON.stringify({
+				x: positionRef.current.x,
+				y: positionRef.current.y
+			}));
+		} catch {}
+	};
+	/**
+	* 첫 진입, BFCache 복귀의 좌표를 한 번 소비. 외부 저장 값은 검증 후 사용
+	*/
+	const handlePageShow = () => {
+		try {
+			const stored = sessionStorage.getItem(cursor_face_storage_key);
+			sessionStorage.removeItem(cursor_face_storage_key);
+			if (stored === null || !mediaRef.current?.matches) return;
+			const point = JSON.parse(stored);
+			if (typeof point === "object" && point !== null && "x" in point && "y" in point && typeof point.x === "number" && typeof point.y === "number" && Number.isFinite(point.x) && Number.isFinite(point.y)) {
+				positionRef.current.x = point.x;
+				positionRef.current.y = point.y;
+				positionRef.current.hasPointer = true;
+				renderCursorFace();
+			}
+		} catch {}
+	};
+	/**
+	* 첫 paint 전 좌표 복원. 해제 시 전역 이벤트와 예약 frame을 함께 정리
+	*/
+	useLayoutEffect(() => {
+		if (!props.ready) return;
+		const lifetime = new AbortController();
+		const media = matchMedia("(hover: hover) and (pointer: fine) and (prefers-reduced-motion: no-preference)");
+		mediaRef.current = media;
+		handlePageShow();
+		document.addEventListener("pointermove", handleDocumentPointer, {
+			passive: true,
+			signal: lifetime.signal
+		});
+		document.addEventListener("pointerdown", handleDocumentPointer, {
+			passive: true,
+			signal: lifetime.signal
+		});
+		document.documentElement.addEventListener("pointerleave", handleCursorHide, { signal: lifetime.signal });
+		addEventListener("blur", handleCursorHide, { signal: lifetime.signal });
+		addEventListener("resize", handleCursorResize, { signal: lifetime.signal });
+		addEventListener("pagehide", handlePageHide, { signal: lifetime.signal });
+		addEventListener("pageshow", handlePageShow, { signal: lifetime.signal });
+		media.addEventListener("change", handleCursorMediaChange, { signal: lifetime.signal });
+		return () => {
+			lifetime.abort();
+			mediaRef.current = null;
+			handleCursorHide();
+		};
+	}, [props.ready]);
+	return /* @__PURE__ */ jsx("img", {
+		ref: props.ready ? faceRef : void 0,
+		className: clsx("wg_cursorFace__root"),
+		src: asset_favicon_path,
+		width: 24,
+		height: 24,
+		alt: "",
+		"aria-hidden": "true",
+		draggable: false,
+		"data-cursor-face": ""
+	});
+};
+//#endregion
+//#region src/component/widget/mermaid/_constant/copy.ts
+/**
+* 모듈 수신 실패의 원문 유지 안내
+*/
+var copy_error_load = "다이어그램을 불러오지 못했습니다. 원문을 확인해 주세요.";
+/**
+* 문법이나 렌더 실패의 원문 유지 안내
+*/
+var copy_error_render = "다이어그램을 그리지 못했습니다. 원문을 확인해 주세요.";
+//#endregion
+//#region src/component/widget/mermaid/_constant/render.ts
+/**
+* 원문 크기 제한. Mermaid의 제한 안내 SVG 대신 오류와 원문 표시
+*/
+var render_source_max_chars = 5e4;
+/**
+* 공식 유형별 기본 표현, 자동 실행과 오류 SVG 삽입 제외
+*/
+var render_config = {
+	startOnLoad: false,
+	securityLevel: "strict",
+	suppressErrorRendering: true,
+	maxTextSize: render_source_max_chars
+};
+/**
+* 공식 어두운 테마, Tree View 기본 검정 글자와 선의 대비 보정
+*
+*   - 제약: Mermaid 12.2의 Tree View 스타일은 공통 테마 글색 미사용
+*/
+var render_dark_config = {
+	...render_config,
+	theme: "redux-dark-color",
+	themeVariables: { treeView: {
+		labelColor: "currentColor",
+		lineColor: "currentColor"
+	} }
+};
+//#endregion
+//#region src/component/widget/mermaid/wg-mermaid.tsx
+/**
+* 서버 본문의 Mermaid 영역 렌더 수명. 셸과 본문 DOM 교체 미포함
+*/
+var WgMermaid = (props) => {
+	/**
+	* 본문 파싱 후 모듈 수신, 테마 변경과 Details 공개의 직렬 렌더
+	*/
+	useEffect(() => {
+		const lifetime = new AbortController();
+		const theme = matchMedia("(prefers-color-scheme: dark)");
+		const measurements = /* @__PURE__ */ new Set();
+		const owned = /* @__PURE__ */ new Set();
+		const tooltips = /* @__PURE__ */ new Set();
+		/**
+		* 공유 툴팁 재사용, 테마나 접힘 변경에서 숨긴 안내의 다음 호버 복원
+		*/
+		const handleTooltipShow = (event) => {
+			if (event.target instanceof Element && event.target.closest("[title]") !== null) for (const tooltip of tooltips) {
+				tooltip.hidden = false;
+				const bounds = tooltip.getBoundingClientRect();
+				tooltip.style.left = `${scrollX + Math.max(0, Math.min(bounds.left, document.documentElement.clientWidth - bounds.width))}px`;
+			}
+		};
+		/**
+		* SVG 이탈이나 배치 변경에서 툴팁의 이전 절대 좌표와 스크롤 넘침 제외
+		*/
+		const handleTooltipHide = () => {
+			for (const tooltip of tooltips) tooltip.hidden = true;
+		};
+		const render = toChangeQueue({
+			run: async () => {
+				const elements = [...document.querySelectorAll(".wg_mermaid__root[data-mermaid]")];
+				const path = elements[0]?.dataset.mermaidModule;
+				if (path === void 0 || lifetime.signal.aborted) return;
+				const mode = theme.matches ? "dark" : "light";
+				const pending = elements.filter((element) => element.checkVisibility({ visibilityProperty: true }) && element.dataset.mermaidTheme !== mode);
+				if (pending.length === 0) return;
+				const library = await import(
+					/* @vite-ignore */
+					path
+);
+				await document.fonts.ready;
+				if (lifetime.signal.aborted) return;
+				for (const element of pending) {
+					if (lifetime.signal.aborted || !element.isConnected || theme.matches !== (mode === "dark")) return;
+					const source = element.querySelector(".wg_mermaid__source");
+					const result = element.querySelector(".wg_mermaid__result");
+					const error = element.querySelector(".wg_mermaid__error");
+					if (source === null || result === null || error === null) continue;
+					const measurement = document.createElement("div");
+					measurement.className = "wg_mermaid__measurement";
+					measurements.add(measurement);
+					document.body.append(measurement);
+					try {
+						if (source.textContent.length > 5e4) throw new Error(`Mermaid source exceeds ${render_source_max_chars} characters`);
+						library.default.initialize(mode === "dark" ? render_dark_config : render_config);
+						const rendered = await library.default.render(`fh-mermaid-${crypto.getRandomValues(/* @__PURE__ */ new Uint32Array(4)).join("-")}`, source.textContent, measurement);
+						if (lifetime.signal.aborted || !element.isConnected || theme.matches !== (mode === "dark")) return;
+						const shadow = result.shadowRoot ?? result.attachShadow({ mode: "open" });
+						const canvas = document.createElement("div");
+						canvas.innerHTML = rendered.svg;
+						shadow.replaceChildren(canvas);
+						rendered.bindFunctions?.(canvas);
+						canvas.addEventListener("mouseover", handleTooltipShow, { signal: lifetime.signal });
+						canvas.addEventListener("mouseout", handleTooltipHide, { signal: lifetime.signal });
+						const tooltip = document.querySelector(".mermaidTooltip");
+						if (tooltip !== null) {
+							tooltip.classList.add("wg_mermaid__tooltip");
+							tooltips.add(tooltip);
+						}
+						result.hidden = false;
+						source.hidden = true;
+						error.hidden = true;
+						element.dataset.mermaidStatus = "rendered";
+					} catch (cause) {
+						if (lifetime.signal.aborted) return;
+						result.hidden = true;
+						source.hidden = false;
+						error.textContent = copy_error_render;
+						error.hidden = false;
+						element.dataset.mermaidStatus = "error";
+						console.error("for-humanity Mermaid rendering failed", cause);
+					} finally {
+						measurement.remove();
+						measurements.delete(measurement);
+					}
+					element.dataset.mermaidTheme = mode;
+					owned.add(element);
+				}
+				props.onRendered?.();
+			},
+			onError: (cause) => {
+				if (lifetime.signal.aborted) return;
+				for (const element of document.querySelectorAll(".wg_mermaid__root[data-mermaid]")) {
+					const error = element.querySelector(".wg_mermaid__error");
+					if (error !== null) {
+						owned.add(element);
+						error.textContent = copy_error_load;
+						error.hidden = false;
+					}
+				}
+				console.error("for-humanity Mermaid loading failed", cause);
+			}
+		});
+		/**
+		* 연속 이벤트 집약, 직전 렌더 완료 후 최신 테마 반영
+		*/
+		const handleRender = () => {
+			handleTooltipHide();
+			render();
+		};
+		theme.addEventListener("change", handleRender, { signal: lifetime.signal });
+		addEventListener("resize", handleTooltipHide, { signal: lifetime.signal });
+		document.addEventListener("toggle", handleRender, {
+			capture: true,
+			signal: lifetime.signal
+		});
+		if (document.readyState === "loading") document.addEventListener("DOMContentLoaded", handleRender, {
+			once: true,
+			signal: lifetime.signal
+		});
+		else handleRender();
+		return () => {
+			lifetime.abort();
+			for (const measurement of measurements) measurement.remove();
+			measurements.clear();
+			for (const tooltip of tooltips) tooltip.remove();
+			tooltips.clear();
+			for (const element of owned) {
+				const source = element.querySelector(".wg_mermaid__source");
+				const result = element.querySelector(".wg_mermaid__result");
+				const error = element.querySelector(".wg_mermaid__error");
+				result?.shadowRoot?.replaceChildren();
+				if (result !== null) result.hidden = true;
+				if (source !== null) source.hidden = false;
+				if (error !== null) error.hidden = true;
+				delete element.dataset.mermaidTheme;
+				delete element.dataset.mermaidStatus;
+			}
+			owned.clear();
+		};
+	}, [props.onRendered]);
+	return null;
+};
+//#endregion
+//#region src/component/widget/navigation/_constant/navigation.ts
+/**
+* 모바일 탐색 전환. wg-shell.css의 폭 조건과 일치
+*/
+var navigation_mobile_query = "(width < 1024px)";
+/**
+* 양쪽 200px 탐색, 간격 120px, 최소 800px 본문과 스크롤바가 들어가는 3열 기준
+*/
+var navigation_wide_query = "(width >= 1360px)";
+//#endregion
+//#region src/component/widget/navigation/_wg-navigation-nav-list.tsx
+var WgNavigationNavList = (props) => {
+	const entries = [...props.group.docs.map((doc) => ({
+		kind: "document",
+		key: `doc:${doc.id}`,
+		doc
+	})), ...props.group.groups.map((group) => ({
+		kind: "group",
+		key: `group:${JSON.stringify(group.path)}`,
+		group
+	}))];
+	return /* @__PURE__ */ jsx("ul", {
+		className: clsx("wg_navigationNavList__root"),
+		"aria-label": props.group.name,
+		children: entries.map((entry) => {
+			return /* @__PURE__ */ jsxs("li", {
+				className: clsx("wg_navigationNavList__item"),
+				children: [entry.kind === "document" && /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("a", {
+					className: clsx("wg_navigationNavList__link", { "wg_navigationNavList__link--active": entry.doc.active }),
+					href: `/${entry.doc.id}/`,
+					title: entry.doc.label,
+					"aria-current": entry.doc.active ? "page" : void 0,
+					children: entry.doc.name
+				}), entry.doc.children.length > 0 && /* @__PURE__ */ jsx(WgNavigationNavList, { group: {
+					name: entry.doc.name,
+					path: props.group.path,
+					docs: entry.doc.children,
+					groups: []
+				} })] }), entry.kind === "group" && /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("span", {
+					className: clsx("wg_navigationNavList__branch"),
+					children: entry.group.name
+				}), /* @__PURE__ */ jsx(WgNavigationNavList, { group: entry.group })] })]
+			}, entry.key);
+		})
+	});
+};
+//#endregion
+//#region src/component/widget/navigation/_wg-navigation-nav.tsx
+var WgNavigationNav = (props) => {
+	return /* @__PURE__ */ jsx("nav", {
+		className: clsx("wg_navigationNav__root"),
+		"aria-label": copy_nav_aria_label,
+		children: /* @__PURE__ */ jsx("div", {
+			className: clsx("wg_navigationNav__docs"),
+			children: props.groups.map((group) => {
+				return /* @__PURE__ */ jsxs("section", {
+					className: clsx("wg_navigationNav__docGroup"),
+					"aria-label": group.name,
+					children: [/* @__PURE__ */ jsx("div", {
+						className: clsx("wg_navigationNav__group"),
+						children: group.name
+					}), /* @__PURE__ */ jsx(WgNavigationNavList, { group })]
+				}, JSON.stringify(group.path));
+			})
+		})
+	});
+};
+//#endregion
+//#region src/component/widget/navigation/_wg-navigation-scroll.tsx
+var WgNavigationScroll = (props) => {
+	const [overflow, setOverflow] = useState({
+		above: false,
+		below: false
+	});
+	const frameRef = useRef(0);
+	/**
+	* 소수 픽셀 반올림을 제외한 실제 남은 내용만 위, 아래 흐림으로 알림
+	*/
+	const updateOverflow = () => {
+		frameRef.current = 0;
+		if (props.portRef.current === null) return;
+		const above = props.portRef.current.scrollTop > 1;
+		const below = props.portRef.current.scrollHeight - props.portRef.current.clientHeight - props.portRef.current.scrollTop > 1;
+		setOverflow((state) => state.above === above && state.below === below ? state : {
+			above,
+			below
+		});
+	};
+	/**
+	* 연속 스크롤과 관찰자 알림은 프레임당 한 번 측정
+	*/
+	const scheduleOverflow = () => {
+		if (frameRef.current === 0) frameRef.current = requestAnimationFrame(updateOverflow);
+	};
+	/**
+	* 네이티브 좌표는 바로 저장하고 시각적 넘침만 프레임에 맞춰 갱신
+	*/
+	const handlePortScroll = (_event) => {
+		props.onScroll?.();
+		scheduleOverflow();
+	};
+	/**
+	* 영역과 내용의 크기를 함께 추적. Hono 최초 mount의 분리된 fragment 측정은 연결 직후 실행
+	*/
+	useLayoutEffect(() => {
+		if (!props.ready || props.portRef.current === null) return;
+		const observer = new ResizeObserver(scheduleOverflow);
+		observer.observe(props.portRef.current);
+		if (props.portRef.current.firstElementChild !== null) observer.observe(props.portRef.current.firstElementChild);
+		let active = true;
+		addEventListener("pageshow", scheduleOverflow);
+		if (props.portRef.current.isConnected) updateOverflow();
+		else queueMicrotask(() => {
+			if (active) updateOverflow();
+		});
+		return () => {
+			active = false;
+			observer.disconnect();
+			removeEventListener("pageshow", scheduleOverflow);
+			cancelAnimationFrame(frameRef.current);
+			frameRef.current = 0;
+		};
+	}, [props.portRef, props.ready]);
+	/**
+	* 접힘 선택의 렌더가 바뀐 직후 측정. 좌표 복원은 부모의 연결 후 처리보다 앞서 저장하지 않음
+	*/
+	useLayoutEffect(() => {
+		if (props.ready && props.portRef.current?.isConnected) updateOverflow();
+	}, [props.children, props.ready]);
+	return /* @__PURE__ */ jsx("div", {
+		ref: props.ready ? props.portRef : void 0,
+		className: clsx("wg_navigation__scroll", props.kind === "documents" && "wg_navigation__documents", props.kind === "outline" && "wg_navigation__headings", props.ready && "wg_navigation__scroll--ready", props.ready && overflow.above && "wg_navigation__scroll--above", props.ready && overflow.below && "wg_navigation__scroll--below"),
+		"data-navigation-scroll": props.kind,
+		onClick: props.onClick,
+		onScroll: handlePortScroll,
+		children: props.children
+	});
+};
+//#endregion
+//#region src/util/dom/find-hash-target.ts
+/**
+* URL hash 대상. 한국어 제목의 percent encoding 해석
+*/
+var findHashTarget = (hash) => {
+	if (!hash) return null;
+	try {
+		return document.getElementById(decodeURIComponent(hash.slice(1)));
+	} catch (error) {
+		if (error instanceof URIError) return null;
+		throw error;
+	}
+};
+//#endregion
+//#region src/component/widget/navigation/_wg-navigation-toc.tsx
+var WgNavigationToc = (props) => {
+	const [currentSlug, setCurrentSlug] = useState();
+	/**
+	* 연결마다 구독 설치, 초기 위치 갱신은 본문 파싱 이후 실행
+	*/
+	useLayoutEffect(() => {
+		const headings = props.groups.flatMap((group) => group.sections).flatMap((section) => [section.heading, ...section.subs.map((sub) => sub.heading)]);
+		const frame = { id: 0 };
+		/**
+		* 접힌 본문 제목은 제외하고 읽는 선을 통과한 마지막 제목 선택
+		*/
+		const updateCurrentHeading = () => {
+			frame.id = 0;
+			const visible = headings.flatMap((heading) => {
+				const target = findHashTarget(`#${heading.slug}`);
+				return target?.checkVisibility() ? [{
+					slug: heading.slug,
+					top: target.getBoundingClientRect().top - Number.parseFloat(getComputedStyle(target).scrollMarginTop)
+				}] : [];
+			});
+			setCurrentSlug(visible.findLast((heading) => heading.top <= 1)?.slug ?? visible[0]?.slug);
+		};
+		/**
+		* 연속 스크롤의 프레임당 1회 위치 조회
+		*/
+		const handleReadingPositionChange = () => {
+			if (frame.id === 0) frame.id = requestAnimationFrame(updateCurrentHeading);
+		};
+		addEventListener("scroll", handleReadingPositionChange, { passive: true });
+		addEventListener("resize", handleReadingPositionChange);
+		addEventListener("toggle", handleReadingPositionChange, true);
+		addEventListener("pageshow", handleReadingPositionChange);
+		document.addEventListener("DOMContentLoaded", handleReadingPositionChange);
+		if (document.readyState !== "loading") updateCurrentHeading();
+		return () => {
+			cancelAnimationFrame(frame.id);
+			removeEventListener("scroll", handleReadingPositionChange);
+			removeEventListener("resize", handleReadingPositionChange);
+			removeEventListener("toggle", handleReadingPositionChange, true);
+			removeEventListener("pageshow", handleReadingPositionChange);
+			document.removeEventListener("DOMContentLoaded", handleReadingPositionChange);
+		};
+	}, [props.groups]);
+	return /* @__PURE__ */ jsxs("nav", {
+		className: clsx("wg_navigationToc__root"),
+		"aria-label": copy_nav_toc_label,
+		children: [/* @__PURE__ */ jsx("div", {
+			className: clsx("wg_navigationToc__label"),
+			children: copy_nav_toc_label
+		}), props.groups.map((group) => {
+			return /* @__PURE__ */ jsxs("div", {
+				className: clsx("wg_navigationToc__groupSection", { "wg_navigationToc__groupSection--named": group.part !== void 0 }),
+				children: [group.part !== void 0 && /* @__PURE__ */ jsx("div", {
+					className: clsx("wg_navigationToc__group"),
+					children: group.part
+				}), /* @__PURE__ */ jsx("ul", {
+					className: clsx("wg_navigationToc__list"),
+					children: group.sections.map((section) => {
+						return /* @__PURE__ */ jsxs("li", {
+							className: clsx("wg_navigationToc__item"),
+							children: [/* @__PURE__ */ jsx("a", {
+								className: clsx("wg_navigationToc__link", { "wg_navigationToc__link--active": section.heading.slug === currentSlug }),
+								href: `#${section.heading.slug}`,
+								"data-toc-link": "",
+								"aria-current": section.heading.slug === currentSlug ? "location" : void 0,
+								children: section.heading.text
+							}), section.subs.length > 0 && /* @__PURE__ */ jsx("ul", {
+								className: clsx("wg_navigationToc__sub"),
+								children: section.subs.map((sub) => {
+									return /* @__PURE__ */ jsx("li", {
+										className: clsx("wg_navigationToc__subItem"),
+										children: /* @__PURE__ */ jsx("a", {
+											className: clsx("wg_navigationToc__subLink", { "wg_navigationToc__subLink--active": sub.heading.slug === currentSlug }),
+											href: `#${sub.heading.slug}`,
+											"data-toc-sub-link": "",
+											"aria-current": sub.heading.slug === currentSlug ? "location" : void 0,
+											children: sub.heading.text
+										})
+									}, sub.heading.slug);
+								})
+							})]
+						}, section.heading.slug);
+					})
+				})]
+			}, group.sections[0].heading.slug);
+		})]
+	});
+};
+//#endregion
+//#region src/util/dom/reveal-hash-target.ts
+/**
+* 접힌 내용의 hash 대상과 상위 Details 공개
+*
+*   - 초기 접속, 문서 안 링크, hash 변경에 동일 적용
+*/
+var revealHashTarget = (hash) => {
+	const target = findHashTarget(hash);
+	for (let fold = target?.closest("details"); fold; fold = fold.parentElement?.closest("details")) fold.open = true;
+	return target;
+};
+//#endregion
+//#region src/component/widget/navigation/wg-navigation.tsx
+var WgNavigation = (props) => {
+	const [layout, setLayout] = useState(() => {
+		if (props.stores === void 0) return "desktop";
+		if (matchMedia("(width < 1024px)").matches) return "drawer";
+		return matchMedia("(width >= 1360px)").matches ? "wide" : "desktop";
+	});
+	const [drawerOpen, setDrawerOpen] = useState(false);
+	const navigationRef = useRef(null);
+	const documentsRef = useRef(null);
+	const drawerNavigationRef = useRef(null);
+	const drawerDocumentsRef = useRef(null);
+	const outlineRef = useRef(null);
+	const dialogRef = useRef(null);
+	const openButtonRef = useRef(null);
+	const brandRef = useRef(null);
+	const mobileRef = useRef(null);
+	const wideRef = useRef(null);
+	const layoutRef = useRef(layout);
+	const focusRef = useRef(null);
+	const restorePendingRef = useRef(true);
+	const navigationSignature = JSON.stringify(props.data.groups, (key, value) => key === "active" ? void 0 : value);
+	/**
+	* 저장된 배치와 현재 CSS 조건을 구분. 조건 변경 직후 잘린 좌표를 이전 배치에 저장하지 않음
+	*/
+	const getNavigationLayout = () => {
+		if (mobileRef.current === null || wideRef.current === null) return layoutRef.current;
+		if (mobileRef.current.matches) return "drawer";
+		return wideRef.current.matches ? "wide" : "desktop";
+	};
+	/**
+	* 배치별 DOM 참조 분리, 이전 노드 정리 시 새 배치 참조 유지
+	*/
+	const getNavigationPort = () => {
+		return layoutRef.current === "drawer" ? drawerNavigationRef.current : navigationRef.current;
+	};
+	/**
+	* 배치별 DOM은 분리하되 좌표 저장과 복원은 현재 표시되는 한 영역을 소비
+	*/
+	const getDocumentsPort = () => {
+		return layoutRef.current === "drawer" ? drawerDocumentsRef.current : documentsRef.current;
+	};
+	/**
+	* 닫기, 이동보다 먼저 실제 좌표 보존. 숨긴 모달과 아직 복원하지 않은 배치는 저장하지 않음
+	*/
+	const saveScroll = () => {
+		const documents = getDocumentsPort();
+		const outline = outlineRef.current;
+		if (props.stores === void 0 || documents === null || outline === null || restorePendingRef.current || layoutRef.current !== getNavigationLayout() || layoutRef.current === "drawer" && dialogRef.current?.open !== true) return;
+		props.stores.scroll.setState((state) => {
+			return { positions: {
+				...state.positions,
+				[layoutRef.current]: {
+					navigation: navigationSignature,
+					pathname: location.pathname,
+					documents: documents.scrollTop,
+					outline: outline.scrollTop
+				}
+			} };
+		});
+	};
+	/**
+	* 연결된 영역에서 첫 paint 전 복원. 문서는 페이지 간 공유하고 목차는 같은 경로에서만 재사용
+	*/
+	const restoreScroll = () => {
+		layoutRef.current = getNavigationLayout();
+		const documents = getDocumentsPort();
+		if (props.stores === void 0 || documents === null || outlineRef.current === null) return;
+		if (layoutRef.current === "drawer" && dialogRef.current?.open !== true) return;
+		const position = props.stores.scroll.getState().positions[layoutRef.current];
+		if (position?.navigation === navigationSignature) {
+			documents.scrollTop = position.documents;
+			outlineRef.current.scrollTop = position.pathname === location.pathname ? position.outline : 0;
+		} else {
+			documents.scrollTop = 0;
+			outlineRef.current.scrollTop = 0;
+		}
+		restorePendingRef.current = false;
+		saveScroll();
+		documents.dispatchEvent(new Event("scroll"));
+		outlineRef.current.dispatchEvent(new Event("scroll"));
+	};
+	/**
+	* 네이티브 close가 이전 열기 이벤트보다 늦게 도착해도 새 모달을 잠금 해제하지 않음
+	*/
+	const handleDrawerClose = (_event) => {
+		if (dialogRef.current?.open === true) return;
+		document.body.classList.remove("wg_shell__root--drawerOpen");
+		setDrawerOpen(false);
+	};
+	/**
+	* 네이티브 포커스 복원을 유지하면서 링크의 기본 이동보다 먼저 배경 잠금 해제
+	*/
+	const closeNavigation = () => {
+		saveScroll();
+		dialogRef.current?.close();
+		document.body.classList.remove("wg_shell__root--drawerOpen");
+		setDrawerOpen(false);
+	};
+	/**
+	* 모바일에서만 네이티브 모달을 열고 독립된 드로어 좌표를 즉시 복원
+	*/
+	const handleOpenButtonClick = (_event) => {
+		if (getNavigationLayout() !== "drawer" || dialogRef.current === null || dialogRef.current.open) return;
+		dialogRef.current.showModal();
+		document.body.classList.add("wg_shell__root--drawerOpen");
+		setDrawerOpen(true);
+		restoreScroll();
+	};
+	const handleCloseButtonClick = (_event) => {
+		closeNavigation();
+	};
+	/**
+	* Escape의 네이티브 포커스 복원을 쓰되 좌표는 닫힌 모달이 되기 전에 보존
+	*/
+	const handleDrawerCancel = (event) => {
+		event.preventDefault();
+		closeNavigation();
+	};
+	/**
+	* 대화상자 내부 빈 공간은 유지하고 경계 밖 배경만 닫기
+	*/
+	const handleDrawerClick = (event) => {
+		if (dialogRef.current === null || event.target !== dialogRef.current) return;
+		const bounds = dialogRef.current.getBoundingClientRect();
+		if (event.clientX < bounds.left || event.clientX > bounds.right || event.clientY < bounds.top || event.clientY > bounds.bottom) closeNavigation();
+	};
+	/**
+	* 보조키, 새 탭 링크는 모달 유지. 기본 문서 이동만 닫고 같은 문서 제목에 키보드 위치 전달
+	*/
+	const handleNavigationClick = (event) => {
+		saveScroll();
+		if (dialogRef.current?.open !== true || event.defaultPrevented || event.button !== 0 || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey || !(event.target instanceof Element)) return;
+		const link = event.target.closest("a[href]");
+		if (!(link instanceof HTMLAnchorElement) || link.target !== "" && link.target !== "_self" || link.hasAttribute("download")) return;
+		closeNavigation();
+		if (link.origin === location.origin && link.pathname === location.pathname && link.search === location.search && link.hash) {
+			const target = revealHashTarget(link.hash);
+			if (target !== null) {
+				target.tabIndex = -1;
+				target.focus({ preventScroll: true });
+			}
+		}
+	};
+	/**
+	* 같은 목록을 한 배치에만 렌더. 전환 전 포커스를 기억하고 새 배치가 연결된 뒤 좌표 복원
+	*/
+	const handleLayoutChange = () => {
+		const nextLayout = getNavigationLayout();
+		if (nextLayout === layoutRef.current) return;
+		if (document.activeElement instanceof HTMLElement) focusRef.current = {
+			navigation: document.activeElement.closest("[data-navigation]") !== null,
+			drawer: document.activeElement === openButtonRef.current || document.activeElement.closest("[data-navigation-drawer]") !== null,
+			href: document.activeElement.getAttribute("href")
+		};
+		if (nextLayout !== "drawer") closeNavigation();
+		restorePendingRef.current = true;
+		layoutRef.current = nextLayout;
+		flushSync(() => setLayout(nextLayout));
+	};
+	/**
+	* BFCache 복귀 시 persist의 최신 저장 좌표를 다시 읽어 복원
+	*/
+	const handlePageShow = (event) => {
+		if (!event.persisted || props.stores === void 0) return;
+		restorePendingRef.current = true;
+		props.stores.scroll.persist.rehydrate();
+		handleLayoutChange();
+		restoreScroll();
+	};
+	/**
+	* Hono 탐색이 전역 구독의 설치, 정리를 소유. 서버 렌더에서는 실행하지 않음
+	*/
+	useLayoutEffect(() => {
+		if (props.stores === void 0) return;
+		mobileRef.current = matchMedia(navigation_mobile_query);
+		wideRef.current = matchMedia(navigation_wide_query);
+		mobileRef.current.addEventListener("change", handleLayoutChange);
+		wideRef.current.addEventListener("change", handleLayoutChange);
+		addEventListener("pagehide", saveScroll);
+		addEventListener("pageshow", handlePageShow);
+		return () => {
+			mobileRef.current?.removeEventListener("change", handleLayoutChange);
+			wideRef.current?.removeEventListener("change", handleLayoutChange);
+			mobileRef.current = null;
+			wideRef.current = null;
+			removeEventListener("pagehide", saveScroll);
+			removeEventListener("pageshow", handlePageShow);
+			document.body.classList.remove("wg_shell__root--drawerOpen");
+		};
+	}, [props.stores]);
+	/**
+	* 최초 mount와 반응형 재연결의 paint 전 좌표, 포커스 복원. Hono의 fragment 연결 시점 보정
+	*/
+	useLayoutEffect(() => {
+		if (props.stores === void 0) return;
+		let active = true;
+		const restoreNavigation = () => {
+			if (!active) return;
+			restoreScroll();
+			if (focusRef.current === null) return;
+			const navigation = getNavigationPort();
+			if (layout === "drawer") {
+				if (focusRef.current.navigation) openButtonRef.current?.focus({ preventScroll: true });
+			} else if (focusRef.current.navigation && navigation !== null) {
+				const href = focusRef.current.href;
+				[...navigation.querySelectorAll("a[href]")].find((element) => element.getAttribute("href") === href)?.focus({ preventScroll: true });
+			} else if (focusRef.current.drawer) brandRef.current?.focus({ preventScroll: true });
+			focusRef.current = null;
+		};
+		if (getDocumentsPort()?.isConnected) restoreNavigation();
+		else queueMicrotask(restoreNavigation);
+		return () => {
+			active = false;
+		};
+	}, [layout, props.stores]);
+	return /* @__PURE__ */ jsxs(Fragment, { children: [
+		/* @__PURE__ */ jsxs("div", {
+			className: clsx("wg_navigation__sidebar", props.stores !== void 0 && "wg_navigation__sidebar--navigationReady"),
+			children: [/* @__PURE__ */ jsxs("div", {
+				className: clsx("wg_navigation__brandRow"),
+				children: [/* @__PURE__ */ jsx("a", {
+					ref: props.stores === void 0 ? void 0 : brandRef,
+					className: clsx("wg_navigation__brand"),
+					href: "/",
+					"aria-current": props.data.home ? "page" : void 0,
+					children: props.data.title
+				}), /* @__PURE__ */ jsx("button", {
+					ref: props.stores === void 0 ? void 0 : openButtonRef,
+					className: clsx("wg_navigation__menuToggle", props.stores !== void 0 && layout === "drawer" && "wg_navigation__menuToggle--visible"),
+					type: "button",
+					"aria-label": copy_nav_open,
+					"aria-controls": "fh-navigation-drawer",
+					"aria-expanded": String(drawerOpen),
+					"data-navigation-open": "",
+					onClick: handleOpenButtonClick,
+					children: /* @__PURE__ */ jsx("svg", {
+						className: clsx("wg_navigation__menuIcon"),
+						viewBox: "0 0 24 24",
+						"aria-hidden": "true",
+						focusable: "false",
+						children: /* @__PURE__ */ jsx("path", { d: "M4 6h16M4 12h16M4 18h16" })
+					})
+				})]
+			}), layout !== "drawer" && /* @__PURE__ */ jsx("div", {
+				ref: props.stores === void 0 ? void 0 : navigationRef,
+				className: clsx("wg_navigation__navigation"),
+				"data-navigation": "",
+				"data-navigation-layout": layout,
+				children: /* @__PURE__ */ jsx(WgNavigationScroll, {
+					portRef: documentsRef,
+					kind: "documents",
+					ready: props.stores !== void 0,
+					onScroll: saveScroll,
+					onClick: handleNavigationClick,
+					children: /* @__PURE__ */ jsx(WgNavigationNav, { groups: props.data.groups })
+				})
+			})]
+		}),
+		/* @__PURE__ */ jsx("aside", {
+			className: clsx("wg_navigation__tocRail"),
+			"data-navigation-rail": "",
+			children: /* @__PURE__ */ jsx("div", {
+				className: clsx("wg_navigation__outline"),
+				"data-navigation-outline": "",
+				children: /* @__PURE__ */ jsx(WgNavigationScroll, {
+					portRef: outlineRef,
+					kind: "outline",
+					ready: props.stores !== void 0,
+					onScroll: saveScroll,
+					onClick: handleNavigationClick,
+					children: props.data.outline.length > 0 && /* @__PURE__ */ jsx(WgNavigationToc, { groups: props.data.outline })
+				})
+			})
+		}),
+		/* @__PURE__ */ jsxs("dialog", {
+			ref: props.stores === void 0 ? void 0 : dialogRef,
+			className: clsx("wg_navigation__drawer"),
+			id: "fh-navigation-drawer",
+			"aria-labelledby": "fh-navigation-title",
+			"data-navigation-drawer": "",
+			onClose: handleDrawerClose,
+			onCancel: handleDrawerCancel,
+			onClick: handleDrawerClick,
+			children: [/* @__PURE__ */ jsxs("div", {
+				className: clsx("wg_navigation__drawerHeader"),
+				children: [/* @__PURE__ */ jsx("h2", {
+					className: clsx("wg_navigation__drawerTitle"),
+					id: "fh-navigation-title",
+					children: copy_nav_title
+				}), /* @__PURE__ */ jsx("button", {
+					className: clsx("wg_navigation__drawerClose"),
+					type: "button",
+					"aria-label": copy_nav_close,
+					"data-navigation-close": "",
+					onClick: handleCloseButtonClick,
+					children: /* @__PURE__ */ jsx("svg", {
+						className: clsx("wg_navigation__menuIcon"),
+						viewBox: "0 0 24 24",
+						"aria-hidden": "true",
+						focusable: "false",
+						children: /* @__PURE__ */ jsx("path", { d: "m6 6 12 12M18 6 6 18" })
+					})
+				})]
+			}), /* @__PURE__ */ jsx("div", {
+				className: clsx("wg_navigation__drawerContent"),
+				"data-navigation-content": "",
+				children: layout === "drawer" && /* @__PURE__ */ jsx("div", {
+					ref: props.stores === void 0 ? void 0 : drawerNavigationRef,
+					className: clsx("wg_navigation__navigation"),
+					"data-navigation": "",
+					"data-navigation-layout": layout,
+					children: /* @__PURE__ */ jsx(WgNavigationScroll, {
+						portRef: drawerDocumentsRef,
+						kind: "documents",
+						ready: props.stores !== void 0,
+						onScroll: saveScroll,
+						onClick: handleNavigationClick,
+						children: /* @__PURE__ */ jsx(WgNavigationNav, { groups: props.data.groups })
+					})
+				})
+			})]
+		})
+	] });
+};
+//#endregion
+//#region src/component/widget/prose/_constant/heading-highlight.ts
+/**
+* 앵커 이동 후 제목 강조 유지 시간. 이후 CSS로 서서히 해제
+*/
+var heading_highlight_hold_ms = 3e3;
+//#endregion
+//#region src/component/widget/shell-controls/wg-shell-controls.tsx
+var WgShellControls = (props) => {
+	const headingRef = useRef(null);
+	const timerRef = useRef(0);
+	const arrivalRef = useRef(null);
+	const lifetimeRef = useRef(null);
+	const userScrollRef = useRef(null);
+	/**
+	* 다음 앵커 이동과 해제에서 이전 강조, 도착 감시, 타이머를 함께 정리
+	*/
+	const clearHeadingHighlight = () => {
+		clearTimeout(timerRef.current);
+		timerRef.current = 0;
+		arrivalRef.current?.abort();
+		arrivalRef.current = null;
+		headingRef.current?.classList.remove("wg_prose__headingText--highlighted");
+		headingRef.current = null;
+	};
+	/**
+	* 본문 스크롤 도착 후 3초 확보. 사이드바 자체의 scrollend는 제외
+	*/
+	const handleHighlightArrival = (event) => {
+		if (event.target !== document) return;
+		clearTimeout(timerRef.current);
+		arrivalRef.current?.abort();
+		arrivalRef.current = null;
+		timerRef.current = window.setTimeout(clearHeadingHighlight, heading_highlight_hold_ms);
+	};
+	/**
+	* 도착 제목만 강조. 같은 hash 재클릭도 유지 시간 재시작
+	*/
+	const highlightHeading = (target) => {
+		clearHeadingHighlight();
+		headingRef.current = target === null ? null : target.querySelector(".wg_prose__headingText");
+		if (headingRef.current === null) return;
+		headingRef.current.classList.add("wg_prose__headingText--highlighted");
+		timerRef.current = window.setTimeout(clearHeadingHighlight, heading_highlight_hold_ms);
+		arrivalRef.current = new AbortController();
+		document.addEventListener("scrollend", handleHighlightArrival, { signal: arrivalRef.current.signal });
+	};
+	/**
+	* 탐색 DOM이 다시 만들어져도 같은 hash의 접힌 Details 공개를 유지
+	*/
+	const handleHashClick = (event) => {
+		if (event.defaultPrevented || event.button !== 0 || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) return;
+		const link = event.target instanceof Element ? event.target.closest("a[href]") : null;
+		if (link instanceof HTMLAnchorElement && (link.target === "" || link.target === "_self") && !link.hasAttribute("download") && link.origin === location.origin && link.pathname === location.pathname && link.search === location.search && link.hash) {
+			const target = revealHashTarget(link.hash);
+			if (link.hash === location.hash) highlightHeading(target);
+		}
+	};
+	/**
+	* hash 변경 시 접힌 대상을 공개하고 네이티브 스크롤, 강조 적용
+	*/
+	const handleHashChange = () => {
+		const target = revealHashTarget(location.hash);
+		target?.scrollIntoView();
+		highlightHeading(target);
+	};
+	const handleUserScroll = () => {
+		userScrollRef.current?.abort();
+	};
+	/**
+	* 초기 폰트 로드 후 앵커 보정. 해제된 인스턴스와 사용자 이동에 개입하지 않음
+	*/
+	const handlePageLoad = async () => {
+		const lifetime = lifetimeRef.current;
+		const hash = location.hash;
+		const target = revealHashTarget(hash);
+		await document.fonts.ready;
+		if (lifetime === null || lifetime.signal.aborted) return;
+		if (target !== null && !userScrollRef.current?.signal.aborted && hash === location.hash) {
+			target.scrollIntoView({ behavior: "instant" });
+			highlightHeading(target);
+		}
+		document.documentElement.style.removeProperty("scroll-behavior");
+	};
+	/**
+	* 셸은 본문 앞에서 마운트. 본문 파싱 이후에만 초기 접힘 대상 조회
+	*/
+	const handleBodyReady = () => {
+		revealHashTarget(location.hash);
+		if (document.readyState === "complete") handlePageLoad();
+	};
+	/**
+	* 본문 이벤트의 설치, 정리는 셸이 소유. SSR에서는 DOM에 접근하지 않음
+	*/
+	useLayoutEffect(() => {
+		const lifetime = new AbortController();
+		lifetimeRef.current = lifetime;
+		userScrollRef.current = new AbortController();
+		document.documentElement.style.scrollBehavior = "auto";
+		document.addEventListener("click", handleHashClick, { signal: lifetime.signal });
+		addEventListener("hashchange", handleHashChange, { signal: lifetime.signal });
+		addEventListener("load", handlePageLoad, {
+			once: true,
+			signal: lifetime.signal
+		});
+		for (const type of [
+			"wheel",
+			"touchmove",
+			"keydown",
+			"mousedown"
+		]) addEventListener(type, handleUserScroll, {
+			once: true,
+			passive: true,
+			signal: lifetime.signal
+		});
+		if (document.readyState === "loading") document.addEventListener("DOMContentLoaded", handleBodyReady, {
+			once: true,
+			signal: lifetime.signal
+		});
+		else handleBodyReady();
+		return () => {
+			lifetime.abort();
+			lifetimeRef.current = null;
+			userScrollRef.current?.abort();
+			userScrollRef.current = null;
+			clearHeadingHighlight();
+			document.documentElement.style.removeProperty("scroll-behavior");
+		};
+	}, []);
+	return /* @__PURE__ */ jsxs(Fragment, { children: [
+		/* @__PURE__ */ jsx("div", {
+			className: clsx("wg_shellControls__navigation"),
+			children: /* @__PURE__ */ jsx(WgNavigation, {
+				data: props.data,
+				stores: props.stores
+			})
+		}),
+		props.data.cursorFace && /* @__PURE__ */ jsx(WgCursorFace, { ready: props.stores !== void 0 }),
+		/* @__PURE__ */ jsx(WgMermaid, { onRendered: handlePageLoad })
+	] });
+};
+//#endregion
+//#region src/component/widget/shell/wg-shell.tsx
+var WgShell = (props) => {
+	const navigationData = toNavigationData({
+		site: props.site,
+		docs: props.docs,
+		current: props.current,
+		outline: props.outline
+	});
+	const head = createHead({ disableDefaults: true });
+	head.push({
+		title: props.title === void 0 ? props.site.title : `${props.title} · ${props.site.title}`,
+		meta: [
+			{ charset: "utf-8" },
+			{
+				name: "viewport",
+				content: "width=device-width, initial-scale=1"
+			},
+			{
+				name: "description",
+				content: props.site.description === void 0 ? void 0 : escapeHtml(props.site.description)
+			}
+		],
+		style: [{ textContent: props.assets.fontCss }],
+		link: [
+			{
+				rel: "icon",
+				href: asset_favicon_path,
+				type: "image/svg+xml"
+			},
+			...props.assets.preload.map((href) => ({
+				rel: "preload",
+				href,
+				as: "font",
+				type: "font/woff2",
+				crossorigin: ""
+			})),
+			...props.assets.stylePaths.map((href) => ({
+				rel: "stylesheet",
+				href
+			}))
+		]
+	});
+	return /* @__PURE__ */ jsxs("html", {
+		lang: "ko",
+		children: [/* @__PURE__ */ jsx("head", { children: raw(head.render().headTags) }), /* @__PURE__ */ jsxs("body", {
+			className: clsx("wg_shell__root"),
+			children: [
+				/* @__PURE__ */ jsx("div", {
+					className: clsx("wg_shell__browserRoot"),
+					"data-shell-browser-root": "",
+					children: /* @__PURE__ */ jsx(WgShellControls, { data: navigationData })
+				}),
+				/* @__PURE__ */ jsx("script", {
+					type: "application/json",
+					id: "fh-navigation-data",
+					dangerouslySetInnerHTML: { __html: toNavigationJson(navigationData) }
+				}),
+				props.assets.browser.kind === "inline" && /* @__PURE__ */ jsx("script", { dangerouslySetInnerHTML: { __html: props.assets.browser.code } }),
+				props.assets.browser.kind === "module" && /* @__PURE__ */ jsx("script", {
+					type: "module",
+					src: props.assets.browser.path
+				}),
+				/* @__PURE__ */ jsx("main", {
+					className: clsx("wg_shell__main"),
+					children: props.children
+				})
+			]
+		})]
+	});
+};
+//#endregion
+//#region src/page/doc/pg-doc.tsx
+var PgDoc = (props) => {
+	return /* @__PURE__ */ jsx(WgShell, {
+		site: props.site,
+		docs: props.docs,
+		assets: props.assets,
+		title: props.doc.data.name,
+		current: props.doc.id,
+		outline: props.doc.outline,
+		children: /* @__PURE__ */ jsx(WgProse, { html: props.doc.html })
+	});
+};
+//#endregion
+//#region src/page/home/pg-home.tsx
+var PgHome = (props) => {
+	return /* @__PURE__ */ jsxs(WgShell, {
+		site: props.site,
+		docs: props.docs,
+		assets: props.assets,
+		outline: props.home?.outline,
+		children: [props.home !== void 0 && /* @__PURE__ */ jsx(WgProse, { html: props.home.html }), props.home === void 0 && /* @__PURE__ */ jsx(WgProse, { head: {
+			title: props.site.title,
+			lead: "문서 폴더에 README.md를 추가하면 이곳에 홈 화면으로 표시됩니다."
+		} })]
+	});
+};
+//#endregion
+//#region src/app/_function/to-page-app/to-page-app.tsx
+/**
+* 첫 화면 /. 문서 /:slug{.+}/. 하위 폴더 id 지원
+*
+*   - 자원 wildcard와 정규식 매개변수 혼합 시 TrieRouter fallback으로 중첩 경로 불일치
+*   - 자원 응답은 toHttpApp의 별도 앱 소유
+*/
+var toPageApp = (options) => {
+	const app = new Hono();
+	app.get("/", (c) => c.html(toHtml(/* @__PURE__ */ jsx(PgHome, {
+		site: options.site,
+		docs: options.store.docs,
+		assets: options.assets,
+		home: options.store.home
+	}))));
+	app.get("/:slug{.+}/", ssgParams(() => options.store.docs.map((doc) => ({ slug: doc.id }))), (c) => {
+		const doc = options.store.docs.find((entry) => entry.id === c.req.param("slug"));
+		return doc === void 0 ? c.notFound() : c.html(toHtml(/* @__PURE__ */ jsx(PgDoc, {
+			site: options.site,
+			docs: options.store.docs,
+			assets: options.assets,
+			doc
+		})));
+	});
+	return app;
+};
+//#endregion
+//#region src/util/font/to-font-css.ts
+/**
+* 내장 @font-face의 표시 정책과 내용 지문 URL 적용. 원본 파일 수집
+*
+*   - 늦은 글꼴 교체와 문서 이동마다 같은 글꼴을 다시 받는 현상 방지
+*/
+var toFontCss = (options) => {
+	const files = /* @__PURE__ */ new Map();
+	return {
+		css: [...readFileSync(options.css, "utf8").matchAll(/@font-face\s*\{[^}]*\}/g)].map((match) => {
+			return match[0].replace(/font-display:\s*[^;]+;/g, `font-display: ${font_display_strategy};`).replace(/url\(([^)]+)\)/g, (_match, relativeUrl) => {
+				const file = join(dirname(options.css), relativeUrl);
+				const extension = extname(file);
+				const hash = createHash("sha256").update(readFileSync(file)).digest("hex").slice(0, 12);
+				const url = `${options.fontDir}/${basename(file, extension)}.${hash}${extension}`;
+				files.set(url, file);
+				return `url(${url})`;
+			});
+		}).join("\n"),
+		files
+	};
+};
+//#endregion
+//#region src/app/load-site.ts
+/**
+* 문서, 등록 자원과 Hono 앱의 일관된 스냅샷
+*
+*   - 실패한 준비 결과는 반환하지 않으며 이전 스냅샷 변경 없음
+*   - 파일 조회와 Markdown 변환은 준비 시에만 실행, 페이지 요청에서는 재사용
+*/
+var loadSite = async (params) => {
+	const mono = toFontCss({
+		css: join(params.kitRoot, font_mono_css),
+		fontDir: asset_font_dir
+	});
+	const body = toFontCss({
+		css: join(params.kitRoot, font_body_css),
+		fontDir: asset_font_dir
+	});
+	const brand = toFontCss({
+		css: join(params.kitRoot, font_brand_css),
+		fontDir: asset_font_dir
+	});
+	const stylePaths = params.stylePaths ?? [toAssetPath({
+		path: asset_style_path,
+		file: join(params.kitRoot, "dist/cli.css")
+	})];
+	const files = new Map([
+		[asset_favicon_path, join(params.kitRoot, "src/asset/favicon.svg")],
+		...mono.files,
+		...body.files,
+		...brand.files
+	]);
+	if (params.stylePaths === void 0) files.set(stylePaths[0], join(params.kitRoot, "dist/cli.css"));
+	const processor = createProcessor({
+		site: params.site,
+		root: params.root,
+		files,
+		mermaid: loadMermaidAssets(params.kitRoot)
+	});
+	const [docs, home] = await Promise.all([readDocs({
+		root: params.root,
+		processor,
+		reserved: params.site.url === void 0 ? void 0 : crawling_reserved_roots
+	}), readHome({
+		root: params.root,
+		processor
+	})]);
+	const store = {
+		docs,
+		home
+	};
+	const pages = toPageApp({
+		site: params.site,
+		store,
+		assets: {
+			stylePaths,
+			browser: params.browser === void 0 ? {
+				kind: "inline",
+				code: readFileSync(join(params.kitRoot, "dist/browser.js"), "utf8")
+			} : params.browser,
+			fontCss: [
+				mono.css,
+				body.css,
+				brand.css
+			].join("\n"),
+			preload: [
+				...brand.files.keys(),
+				...mono.files.keys(),
+				...body.files.keys()
+			]
+		}
+	});
+	const crawling = params.site.url === void 0 ? void 0 : toCrawlingApp({
+		url: params.site.url,
+		store
+	});
+	return {
+		pages,
+		crawling,
+		files,
+		app: toHttpApp({
+			pages,
+			crawling,
+			files
+		})
+	};
+};
+//#endregion
+export { font_cache_control as n, asset_font_dir as r, loadSite as t };