mdsquare 0.0.0-stage → 0.1.0

package/dist/tikz.js

@@ -0,0 +1,343 @@
+import { syntaxTree } from "@codemirror/language";
+import { Decoration, EditorView, WidgetType } from "@codemirror/view";
+import { readFencedCode, renderedCodeLanguages } from "./codeBlock.js";
+import { createRevealField } from "./utils/reveal.js";
+const PRELOADED = new Set(["tikz", "xcolor", "pgf"]);
+const USE_PACKAGE = /\\usepackage\s*(?:\[([^\]]*)\])?\s*\{([^}]*)\}/g;
+const USE_LIBRARY = /\\usetikzlibrary\s*\{([^}]*)\}/g;
+/** TeX 주석(`%`부터 줄 끝, `\%`는 제외)을 지웁니다. */
+const stripComments = (text) => text.replace(/(^|[^\\])%.*$/gm, "$1");
+/** TikZ 코드 블록 원문을 렌더러가 쓸 수 있게 나눕니다. */
+export function parseTikz(source) {
+    const begin = source.search(/\\begin\s*\{document\}/);
+    let head;
+    let body;
+    if (begin >= 0) {
+        head = source.slice(0, begin);
+        const rest = source.slice(source.indexOf("}", begin) + 1);
+        const end = rest.search(/\\end\s*\{document\}/);
+        body = end >= 0 ? rest.slice(0, end) : rest;
+    }
+    else {
+        head = "";
+        body = source;
+    }
+    const packages = {};
+    const libraries = [];
+    const collect = (text) => stripComments(text)
+        .replace(USE_PACKAGE, (_, options, names) => {
+        for (const name of names.split(",").map((n) => n.trim())) {
+            if (name && !PRELOADED.has(name))
+                packages[name] = (options ?? "").trim();
+        }
+        return "";
+    })
+        .replace(USE_LIBRARY, (_, names) => {
+        for (const name of names.split(",").map((n) => n.trim()))
+            if (name && !libraries.includes(name))
+                libraries.push(name);
+        return "";
+    });
+    const preamble = begin >= 0 ? collect(head).trim() : "";
+    // 문서 시작이 없으면 선언을 본문에서 뺍니다. (본문에 남으면 TeX 오류)
+    if (begin < 0)
+        body = collect(body);
+    return { source, body: body.trim(), packages, libraries, preamble };
+}
+let tikzjaxLoading = null;
+function loadTikzJax(src, fonts) {
+    if (tikzjaxLoading)
+        return tikzjaxLoading;
+    tikzjaxLoading = new Promise((resolve, reject) => {
+        if (fonts) {
+            const link = document.head.appendChild(document.createElement("link"));
+            link.rel = "stylesheet";
+            link.href = fonts;
+        }
+        const script = document.createElement("script");
+        script.src = src;
+        script.async = true;
+        script.onload = () => resolve();
+        script.onerror = () => {
+            tikzjaxLoading = null; // 다음에 다시 시도
+            script.remove();
+            reject(new Error(`TikZJax를 불러오지 못했습니다: ${src}`));
+        };
+        document.head.appendChild(script);
+    });
+    return tikzjaxLoading;
+}
+let hiddenHost = null;
+/** TikZJax가 `<script type="text/tikz">`를 찾아 바꾸는 곳 (에디터 밖, 화면 밖) */
+function tikzjaxHost() {
+    if (!hiddenHost || !hiddenHost.isConnected) {
+        hiddenHost = document.body.appendChild(document.createElement("div"));
+        hiddenHost.className = "cm-tikz-host";
+        hiddenHost.setAttribute("aria-hidden", "true");
+        hiddenHost.style.cssText = "position:fixed;left:-100000px;top:0;width:1px;height:1px;overflow:hidden;visibility:hidden";
+    }
+    return hiddenHost;
+}
+/**
+ * TikZJax(@drgrice1/tikzjax, 브라우저 안의 WebAssembly TeX)로 그리는 렌더러.
+ * TikZJax는 GPL-3.0이므로 이 라이브러리에 포함하지 않고, 앱이 제공하는 주소에서 실행할 때 불러옵니다.
+ * 처음 한 번 TeX 엔진(약 7MB)을 내려받고, 결과는 TikZJax가 IndexedDB에 캐시합니다.
+ */
+export function tikzjaxRenderer(options = {}) {
+    const src = options.src ?? "/tikzjax/tikzjax.js";
+    const fonts = options.fonts ?? src.replace(/[^/]*$/, "fonts.css");
+    const timeout = options.timeout ?? 60000;
+    return async (doc) => {
+        await loadTikzJax(src, fonts);
+        return new Promise((resolve, reject) => {
+            const wrapper = document.createElement("div");
+            const script = wrapper.appendChild(document.createElement("script"));
+            script.type = "text/tikz";
+            if (Object.keys(doc.packages).length)
+                script.dataset["texPackages"] = JSON.stringify(doc.packages);
+            if (doc.libraries.length)
+                script.dataset["tikzLibraries"] = doc.libraries.join(",");
+            if (doc.preamble)
+                script.dataset["addToPreamble"] = doc.preamble;
+            script.textContent = doc.body;
+            const finish = (error, svg) => {
+                observer.disconnect();
+                clearTimeout(timer);
+                wrapper.remove();
+                if (error)
+                    reject(error);
+                else
+                    resolve(svg);
+            };
+            // 성공: 만든 SVG에서 tikzjax-load-finished 이벤트. 실패: TikZJax가 SVG 대신 깨진 이미지를 넣습니다.
+            wrapper.addEventListener("tikzjax-load-finished", (event) => {
+                finish(null, event.target.outerHTML);
+            });
+            const observer = new MutationObserver(() => {
+                if (wrapper.querySelector("img"))
+                    finish(new Error("TikZ 코드를 컴파일하지 못했습니다."));
+            });
+            observer.observe(wrapper, { childList: true, subtree: true });
+            const timer = setTimeout(() => finish(new Error("TikZ 렌더링 시간이 초과되었습니다.")), timeout);
+            tikzjaxHost().appendChild(wrapper);
+        });
+    };
+}
+const CACHE_LIMIT = 50;
+class TikzCache {
+    entries = new Map();
+    render;
+    constructor(render) {
+        this.render = render;
+    }
+    get(source) {
+        let entry = this.entries.get(source);
+        if (entry) {
+            this.entries.delete(source); // 최근 사용으로 갱신
+        }
+        else {
+            const created = {
+                status: "pending",
+                svg: "",
+                error: "",
+                promise: Promise.resolve()
+                    .then(() => this.render(parseTikz(source)))
+                    .then((svg) => {
+                    created.status = "done";
+                    created.svg = sanitizeSvg(svg);
+                }, (error) => {
+                    created.status = "error";
+                    created.error = error instanceof Error ? error.message : String(error);
+                }),
+            };
+            entry = created;
+        }
+        this.entries.set(source, entry);
+        if (this.entries.size > CACHE_LIMIT)
+            this.entries.delete(this.entries.keys().next().value);
+        return entry;
+    }
+}
+/**
+ * 렌더러가 돌려준 SVG에서 스크립트와 이벤트 속성, javascript: 링크를 지웁니다.
+ * (TeX의 \special로 SVG 조각을 넣을 수 있으므로, 신뢰할 수 없는 문서도 안전하게 보여주기 위함)
+ */
+export function sanitizeSvg(markup) {
+    const doc = new DOMParser().parseFromString(markup, "image/svg+xml");
+    const root = doc.documentElement;
+    if (root.nodeName.toLowerCase() !== "svg" || doc.getElementsByTagName("parsererror").length)
+        return "";
+    for (const el of [...root.querySelectorAll("script, foreignObject")])
+        el.remove();
+    for (const el of [root, ...root.querySelectorAll("*")]) {
+        for (const attr of [...el.attributes]) {
+            const name = attr.name.toLowerCase();
+            if (name.startsWith("on"))
+                el.removeAttribute(attr.name);
+            else if ((name === "href" || name === "xlink:href") && /^\s*javascript:/i.test(attr.value)) {
+                el.removeAttribute(attr.name);
+            }
+        }
+    }
+    return new XMLSerializer().serializeToString(root);
+}
+class TikzWidget extends WidgetType {
+    source;
+    kind;
+    entry;
+    constructor(source, kind, entry) {
+        super();
+        this.source = source;
+        this.kind = kind;
+        this.entry = entry;
+    }
+    eq(other) {
+        return other.source === this.source && other.kind === this.kind && other.entry === this.entry;
+    }
+    toDOM(view) {
+        const el = document.createElement(this.kind === "block" ? "div" : "span");
+        el.className = `cm-tikz cm-tikz-${this.kind}`;
+        this.fill(el);
+        if (this.entry.status === "pending") {
+            void this.entry.promise.then(() => {
+                this.fill(el);
+                view.requestMeasure(); // 그림이 들어와 높이가 바뀜
+            });
+        }
+        return el;
+    }
+    fill(el) {
+        const { status, svg, error } = this.entry;
+        el.classList.toggle("cm-tikz-pending", status === "pending");
+        el.classList.toggle("cm-tikz-error", status === "error");
+        if (status === "done") {
+            el.innerHTML = svg;
+        }
+        else if (status === "error") {
+            el.textContent = `TikZ 오류: ${error}`;
+        }
+        else {
+            el.innerHTML = '<span class="cm-tikz-spinner" aria-hidden="true"></span>';
+            el.appendChild(document.createTextNode("TikZ 그리는 중…"));
+        }
+        el.setAttribute("aria-busy", String(status === "pending"));
+    }
+    get estimatedHeight() {
+        return this.kind === "block" ? 160 : -1;
+    }
+    // 클릭하면 에디터가 처리해 커서가 블록으로 이동하고 원문이 펼쳐집니다.
+    ignoreEvent() {
+        return false;
+    }
+}
+const CONTAINERS = new Set(["Document", "Blockquote", "BulletList", "OrderedList", "ListItem"]);
+function scanTikz(state, languages) {
+    const { doc } = state;
+    const found = [];
+    syntaxTree(state).iterate({
+        enter(node) {
+            if (node.name === "FencedCode") {
+                const block = readFencedCode(state, node.node);
+                if (block && languages.has(block.lang) && block.code.trim()) {
+                    const first = doc.lineAt(node.from);
+                    const last = doc.lineAt(node.to);
+                    found.push({
+                        from: node.from,
+                        to: node.to,
+                        source: block.code,
+                        wholeLines: node.node.parent?.name === "Document" &&
+                            !first.text.slice(0, node.from - first.from).trim() &&
+                            !last.text.slice(node.to - last.from).trim(),
+                        lineFrom: first.from,
+                        lineTo: last.to,
+                    });
+                }
+                return false;
+            }
+            if (!CONTAINERS.has(node.name))
+                return false;
+        },
+    });
+    return found;
+}
+const tikzTheme = EditorView.baseTheme({
+    ".cm-tikz-block, .cm-tikz-inline, .cm-tikz-preview": {
+        display: "block",
+        textAlign: "center",
+        overflowX: "auto",
+        overflowY: "hidden",
+    },
+    // 위젯 안의 세로 margin은 높이 계산을 깨뜨리므로 padding으로 여백을 줍니다.
+    ".cm-tikz-block": { padding: "0.5em 6px" },
+    ".cm-tikz-inline": { padding: "0.25em 0" },
+    ".cm-tikz-preview": { padding: "0.5em 6px", borderRadius: "4px", cursor: "default" },
+    "&light .cm-tikz-preview": { backgroundColor: "rgba(135, 131, 120, 0.08)" },
+    "&dark .cm-tikz-preview": { backgroundColor: "rgba(255, 255, 255, 0.05)" },
+    ".cm-tikz svg": { display: "inline-block", maxWidth: "100%", height: "auto", verticalAlign: "middle" },
+    // 어두운 테마: 검은 선/글자를 밝게 (색상은 유지)
+    "&dark .cm-tikz svg": { filter: "invert(1) hue-rotate(180deg)" },
+    ".cm-tikz-pending, .cm-tikz-error": {
+        fontFamily: "system-ui, -apple-system, sans-serif",
+        fontSize: "0.875em",
+    },
+    "&light .cm-tikz-pending": { color: "#6b7280" },
+    "&dark .cm-tikz-pending": { color: "#9ca3af" },
+    ".cm-tikz-error": { color: "#cc0000" },
+    ".cm-tikz-spinner": {
+        display: "inline-block",
+        width: "0.9em",
+        height: "0.9em",
+        marginRight: "0.5em",
+        verticalAlign: "-0.1em",
+        border: "2px solid currentColor",
+        borderRightColor: "transparent",
+        borderRadius: "50%",
+        animation: "cm-tikz-spin 0.8s linear infinite",
+    },
+    "@keyframes cm-tikz-spin": { to: { transform: "rotate(360deg)" } },
+    "@media (prefers-reduced-motion: reduce)": { ".cm-tikz-spinner": { animation: "none" } },
+});
+/**
+ * ```` ```tikz ```` 코드 블록을 그림으로 보여주는 확장입니다.
+ * - 원문: Obsidian TikZJax 형식(`\usepackage`, `\usetikzlibrary`, `\begin{document}`…) 또는 tikzpicture만
+ * - 커서가 블록 밖이면 그림, 안이면 코드 블록 원문과 그 아래 미리보기
+ * - 렌더러는 바꿀 수 있습니다. 기본은 TikZJax(브라우저 WebAssembly TeX)이며, 그 파일은 앱이 제공해야 합니다.
+ *   ```ts
+ *   tikz({ render: tikzjaxRenderer({ src: "/tikzjax/tikzjax.js" }) })
+ *   ```
+ * - 같은 원문은 한 번만 렌더링합니다. 그리는 동안에는 진행 표시, 실패하면 오류를 보여줍니다.
+ */
+export function tikz(options = {}) {
+    const cache = new TikzCache(options.render ?? tikzjaxRenderer());
+    const languages = new Set((options.languages ?? ["tikz"]).map((l) => l.toLowerCase()));
+    const field = createRevealField({
+        scan: (state) => scanTikz(state, languages),
+        build(blocks, revealed) {
+            const out = [];
+            blocks.forEach((block, i) => {
+                const entry = cache.get(block.source);
+                if (!revealed[i]) {
+                    if (block.wholeLines) {
+                        const widget = new TikzWidget(block.source, "block", entry);
+                        out.push(Decoration.replace({ widget, block: true }).range(block.lineFrom, block.lineTo));
+                    }
+                    else {
+                        // 인용/목록 안: 줄 중간의 블록 위젯은 줄을 쪼개므로 접두어 뒤를 인라인 위젯으로 대체합니다.
+                        const widget = new TikzWidget(block.source, "inline", entry);
+                        out.push(Decoration.replace({ widget }).range(block.from, block.to));
+                    }
+                }
+                else {
+                    // 원문은 codeBlock()이 코드 블록으로 보여주고, 그 아래에 미리보기를 둡니다.
+                    const widget = new TikzWidget(block.source, "preview", entry);
+                    out.push(block.wholeLines
+                        ? Decoration.widget({ widget, block: true, side: 1 }).range(block.lineTo)
+                        : Decoration.widget({ widget, side: 1 }).range(block.to));
+                }
+            });
+            return Decoration.set(out, true);
+        },
+        block: (block) => block.wholeLines,
+    });
+    return [field, renderedCodeLanguages.of([...languages]), tikzTheme];
+}

package/dist/underline.d.ts

@@ -0,0 +1,5 @@
+import { Tag } from "@lezer/highlight";
+/** `--text--` 밑줄 문법에 사용할 하이라이트 태그 */
+export declare const underlineTag: Tag;
+/** `--text--` 인라인 밑줄 문법 (노드: Underline, UnderlineMark) */
+export declare const Underline: import("@lezer/markdown").MarkdownConfig;

package/dist/underline.js

@@ -0,0 +1,6 @@
+import { Tag, tags } from "@lezer/highlight";
+import { doubleDelimiterSyntax } from "./delimiter.js";
+/** `--text--` 밑줄 문법에 사용할 하이라이트 태그 */
+export const underlineTag = Tag.define(tags.content);
+/** `--text--` 인라인 밑줄 문법 (노드: Underline, UnderlineMark) */
+export const Underline = doubleDelimiterSyntax({ name: "Underline", char: "-", tag: underlineTag });

package/dist/utils/blockMargin.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 콜아웃/코드 블록 같은 상자형 블록의 좌우 바깥 여백. (폭은 제한하지 않고 양옆만 살짝 띄웁니다)
+ * 에디터(또는 그 조상)에서 CSS 변수 `--cm-block-margin-x`로 바꿀 수 있습니다. 여백 없이: `0`.
+ * 줄에 세로 margin을 주면 CodeMirror의 줄 높이 계산이 틀어지지만, 가로 margin은 괜찮습니다.
+ */
+export declare const BLOCK_MARGIN_X = "var(--cm-block-margin-x, 8px)";

package/dist/utils/blockMargin.js

@@ -0,0 +1,6 @@
+/**
+ * 콜아웃/코드 블록 같은 상자형 블록의 좌우 바깥 여백. (폭은 제한하지 않고 양옆만 살짝 띄웁니다)
+ * 에디터(또는 그 조상)에서 CSS 변수 `--cm-block-margin-x`로 바꿀 수 있습니다. 여백 없이: `0`.
+ * 줄에 세로 margin을 주면 CodeMirror의 줄 높이 계산이 틀어지지만, 가로 margin은 괜찮습니다.
+ */
+export const BLOCK_MARGIN_X = "var(--cm-block-margin-x, 8px)";

package/dist/utils/codePoint.d.ts

@@ -0,0 +1,13 @@
+import type { InlineContext } from "@lezer/markdown";
+/** 코드 포인트가 차지하는 UTF-16 코드 단위 수 */
+export declare const sizeOf: (codePoint: number) => number;
+/** pos 위치의 코드 포인트. 구간 끝이면 -1 (서로게이트 쌍을 하나로 합칩니다) */
+export declare function codePointAt(cx: InlineContext, pos: number): number;
+/** pos 바로 앞의 코드 포인트. 구간 시작이면 -1 (서로게이트 쌍을 하나로 합칩니다) */
+export declare function codePointBefore(cx: InlineContext, pos: number): number;
+/**
+ * 코드 포인트 → 비트 플래그 분류 함수를 만듭니다.
+ * ASCII는 미리 계산한 테이블로 O(1) 조회하고, 그 외에는 classify를 호출합니다.
+ * 구간 끝(-1)은 0을 반환합니다.
+ */
+export declare function createClassifier(classify: (ch: string) => number): (codePoint: number) => number;

package/dist/utils/codePoint.js

@@ -0,0 +1,43 @@
+const isHighSurrogate = (c) => c >= 0xd800 && c <= 0xdbff;
+const isLowSurrogate = (c) => c >= 0xdc00 && c <= 0xdfff;
+const combine = (high, low) => ((high - 0xd800) << 10) + (low - 0xdc00) + 0x10000;
+/** 코드 포인트가 차지하는 UTF-16 코드 단위 수 */
+export const sizeOf = (codePoint) => (codePoint > 0xffff ? 2 : 1);
+/** pos 위치의 코드 포인트. 구간 끝이면 -1 (서로게이트 쌍을 하나로 합칩니다) */
+export function codePointAt(cx, pos) {
+    const c = cx.char(pos);
+    if (isHighSurrogate(c)) {
+        const low = cx.char(pos + 1);
+        if (isLowSurrogate(low))
+            return combine(c, low);
+    }
+    return c;
+}
+/** pos 바로 앞의 코드 포인트. 구간 시작이면 -1 (서로게이트 쌍을 하나로 합칩니다) */
+export function codePointBefore(cx, pos) {
+    // cx.char()는 구간 시작 이전 위치에서 NaN을 반환하므로 직접 경계를 처리합니다.
+    if (pos <= cx.offset)
+        return -1;
+    const c = cx.char(pos - 1);
+    if (isLowSurrogate(c) && pos - 2 >= cx.offset) {
+        const high = cx.char(pos - 2);
+        if (isHighSurrogate(high))
+            return combine(high, c);
+    }
+    return c;
+}
+/**
+ * 코드 포인트 → 비트 플래그 분류 함수를 만듭니다.
+ * ASCII는 미리 계산한 테이블로 O(1) 조회하고, 그 외에는 classify를 호출합니다.
+ * 구간 끝(-1)은 0을 반환합니다.
+ */
+export function createClassifier(classify) {
+    const ascii = new Uint8Array(128);
+    for (let code = 0; code < 128; code++)
+        ascii[code] = classify(String.fromCharCode(code));
+    return (codePoint) => codePoint < 0
+        ? 0
+        : codePoint < 128
+            ? ascii[codePoint]
+            : classify(String.fromCodePoint(codePoint));
+}

package/dist/utils/container.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 컨테이너(인용, 콜아웃)가 줄에 알려주는 내용 영역 정보. 코드 블록처럼 줄 안에 상자를 그리는 블록이
+ * 컨테이너의 세로줄/상자를 가리지 않고 그 안쪽에 그리도록 씁니다.
+ * - `--cm-container-indent`: 줄 왼쪽에서 내용이 시작하는 곳까지 (기본: CodeMirror 줄 왼쪽 padding 6px)
+ * - `--cm-container-right`: 줄 오른쪽에서 내용이 끝나는 곳까지 (기본: CodeMirror 줄 오른쪽 padding 2px)
+ * - `--cm-container-bottom`: 줄 아래에서 내용이 끝나는 곳까지 (콜아웃의 끝 줄 아래 여백, 기본 0)
+ */
+export declare const CONTAINER_INDENT = "var(--cm-container-indent, 6px)";
+export declare const CONTAINER_RIGHT = "var(--cm-container-right, 2px)";
+export declare const CONTAINER_BOTTOM = "var(--cm-container-bottom, 0px)";

package/dist/utils/container.js

@@ -0,0 +1,10 @@
+/**
+ * 컨테이너(인용, 콜아웃)가 줄에 알려주는 내용 영역 정보. 코드 블록처럼 줄 안에 상자를 그리는 블록이
+ * 컨테이너의 세로줄/상자를 가리지 않고 그 안쪽에 그리도록 씁니다.
+ * - `--cm-container-indent`: 줄 왼쪽에서 내용이 시작하는 곳까지 (기본: CodeMirror 줄 왼쪽 padding 6px)
+ * - `--cm-container-right`: 줄 오른쪽에서 내용이 끝나는 곳까지 (기본: CodeMirror 줄 오른쪽 padding 2px)
+ * - `--cm-container-bottom`: 줄 아래에서 내용이 끝나는 곳까지 (콜아웃의 끝 줄 아래 여백, 기본 0)
+ */
+export const CONTAINER_INDENT = "var(--cm-container-indent, 6px)";
+export const CONTAINER_RIGHT = "var(--cm-container-right, 2px)";
+export const CONTAINER_BOTTOM = "var(--cm-container-bottom, 0px)";

package/dist/utils/reveal.d.ts

@@ -0,0 +1,99 @@
+import { EditorState, StateField, type EditorSelection, type Range } from "@codemirror/state";
+import { Decoration, EditorView, ViewPlugin, type DecorationSet, type PluginValue, type ViewUpdate } from "@codemirror/view";
+import { type SyntaxTreeIterator } from "./syntaxTree.js";
+/** 선택 범위(멀티 커서 포함) 중 하나라도 노드에 닿아 있으면 true */
+export declare function isRevealed(selection: EditorSelection, node: {
+    from: number;
+    to: number;
+}): boolean;
+/**
+ * 데코레이션을 처음부터 다시 만들어야 하는지 여부
+ * - 백그라운드 파싱이 끝나면 문서/뷰포트/선택 변화 없이 트리만 바뀌므로 트리도 비교합니다.
+ * - 설정이 바뀌면(확장 추가/제거, Facet 값 변경) 다른 플러그인과의 역할 분담이 달라질 수 있습니다.
+ */
+export declare function needsRebuild(update: ViewUpdate): boolean;
+/**
+ * 빌드 시 각 노드의 "기호 표시 여부"를 기록해 두었다가,
+ * 선택만 바뀌었을 때 표시 여부가 달라진 노드가 있는지 빠르게 확인합니다.
+ */
+export declare class RevealTracker {
+    private ranges;
+    private flags;
+    /** 새 빌드를 시작할 때 호출합니다. */
+    reset(): void;
+    /** 노드의 표시 여부를 계산하고 기록합니다. */
+    track(selection: EditorSelection, from: number, to: number): boolean;
+    /** 주어진 선택에서 표시 여부가 달라지는 노드가 하나라도 있으면 true */
+    changed(selection: EditorSelection): boolean;
+}
+/** 빌드 1회 동안 visit 콜백에 전달되는 컨텍스트 */
+export interface RevealContext {
+    readonly state: EditorState;
+    /** 에디터 뷰 (보이는 범위 등이 필요할 때) */
+    readonly view: EditorView;
+    /** 결과 데코레이션 목록. 여기에 push 합니다. */
+    readonly decorations: Range<Decoration>[];
+    /**
+     * 노드의 기호를 보여줄지(선택 범위가 노드에 닿는지) 계산하고 기록합니다.
+     * 기록된 노드만 "선택만 바뀐 경우 재빌드 생략" 판정에 사용되므로,
+     * 표시 여부에 따라 데코레이션이 달라지는 노드는 반드시 이 함수로 판정해야 합니다.
+     */
+    isRevealed(from: number, to: number): boolean;
+}
+export interface RevealPluginSpec {
+    /**
+     * 빌드마다 호출되어, 보이는 구문 트리를 순회할 콜백을 돌려줍니다.
+     * 빌드 단위 상태(스택 등)는 이 함수의 클로저에 둡니다.
+     */
+    visit(cx: RevealContext): SyntaxTreeIterator;
+    /** 데코레이션이 문서 순서대로 추가되지 않는다면 true (기본값 false) */
+    readonly sort?: boolean;
+    /** 기본 조건(문서/뷰포트/구문 트리/설정 변경) 외에 다시 빌드해야 하는 업데이트 (예: 접기 상태 변경) */
+    rebuildOn?(update: ViewUpdate): boolean;
+}
+/** createRevealPlugin()이 만드는 플러그인 인스턴스 */
+export declare class RevealPluginValue implements PluginValue {
+    decorations: DecorationSet;
+    private readonly tracker;
+    private readonly spec;
+    constructor(view: EditorView, spec: RevealPluginSpec);
+    update(update: ViewUpdate): void;
+    private build;
+}
+/**
+ * "커서가 닿은 노드만 기호를 보여주는" 플러그인의 공용 골격을 만듭니다.
+ *
+ * 공통으로 처리하는 것:
+ * - 보이는 범위의 구문 트리만 순회 (접힌 영역 중복 방문 없음)
+ * - 문서/뷰포트/구문 트리 변경 시 재빌드
+ * - 선택만 바뀐 경우 표시 여부가 달라진 노드가 있을 때만 재빌드
+ * - 멀티 커서 지원
+ */
+export declare function createRevealPlugin(spec: RevealPluginSpec): ViewPlugin<RevealPluginValue>;
+export interface RevealFieldSpec<T extends {
+    readonly from: number;
+    readonly to: number;
+}> {
+    /**
+     * 대상(블록)들을 문서 순서대로 찾습니다. 문서/구문 트리/설정이 바뀔 때만 호출됩니다.
+     * 문서 전체를 다루므로, 대상이 올 수 있는 곳만 훑도록 구현하는 것이 좋습니다.
+     */
+    scan(state: EditorState): readonly T[];
+    /** 대상과 각 대상의 표시 여부(커서가 닿았는지)로 데코레이션을 만듭니다. */
+    build(items: readonly T[], revealed: readonly boolean[], state: EditorState): DecorationSet;
+    /**
+     * 숨겨진 대상이 줄 전체를 대체하는 블록 위젯으로 그려지는지.
+     * CodeMirror의 위/아래 화살표는 블록 위젯을 건너뛰므로, true인 대상은 건너뛰는 대신 커서를 대상 안으로
+     * 옮겨 원문을 펼칩니다. (없으면 건너뛰기를 고치지 않습니다)
+     */
+    block?(item: T): boolean;
+}
+export interface RevealFieldValue<T> {
+    readonly items: readonly T[];
+    readonly revealed: readonly boolean[];
+    readonly decorations: DecorationSet;
+}
+export declare function createRevealField<T extends {
+    readonly from: number;
+    readonly to: number;
+}>(spec: RevealFieldSpec<T>): StateField<RevealFieldValue<T>>;