mdsquare 0.0.0-stage → 0.2.0

package/dist/hashtagSyntax.d.ts

@@ -0,0 +1,36 @@
+import type { MarkdownConfig } from "@lezer/markdown";
+import { Tag } from "@lezer/highlight";
+/** `#tag` 해시태그에 사용할 하이라이트 태그 */
+export declare const hashtagTag: Tag;
+/**
+ * `#tag`, `#부모/자식` 인라인 해시태그 문법입니다.
+ *
+ * 노드 구조:
+ * ```
+ * Hashtag
+ *   HashtagMark       "#"
+ *   HashtagSegment    "부모"
+ *   HashtagSeparator  "/"
+ *   HashtagSegment    "자식"
+ * ```
+ *
+ * - `#` 앞: 인라인 구간의 시작(줄 시작 등) 또는 공백만 허용 (`a#b`, `(#tag)`는 해시태그가 아님)
+ * - 세그먼트: Unicode 문자/숫자/결합 문자와 `_`, `-`
+ * - 계층: 세그먼트를 `/`로 구분하며 빈 세그먼트는 허용하지 않습니다.
+ *   (`#/a`는 해시태그가 아니고, `#a/`, `#a//b`는 `#a`까지만 인식)
+ * - 태그 전체에 문자(letter)가 최소 1개 있어야 합니다. (`#123`은 아님, `#2024/회의`는 허용)
+ */
+export declare const Hashtag: MarkdownConfig;
+export interface HashtagInfo {
+    /** `#`을 뺀 전체 이름 (예: "부모/자식") */
+    readonly name: string;
+    /** 계층별 세그먼트 (예: ["부모", "자식"]) */
+    readonly segments: readonly string[];
+    /** 자신을 포함한 상위 태그 목록, 상위부터 (예: ["부모", "부모/자식"]) */
+    readonly ancestors: readonly string[];
+}
+/**
+ * 해시태그 노드의 텍스트(예: `#부모/자식`)에서 계층 정보를 추출합니다.
+ * 파서가 형식(빈 세그먼트 없음)을 보장하므로 단순 분리로 충분합니다.
+ */
+export declare function parseHashtag(text: string): HashtagInfo;

package/dist/hashtagSyntax.js

@@ -0,0 +1,99 @@
+import { Tag, tags } from "@lezer/highlight";
+import { codePointAt, codePointBefore, createClassifier, sizeOf } from "./utils/codePoint.js";
+/** `#tag` 해시태그에 사용할 하이라이트 태그 */
+export const hashtagTag = Tag.define(tags.content);
+const Hash = 35; // "#"
+const Slash = 47; // "/"
+// ---------------------------------------------------------------------------
+// 문자 분류
+// - ASCII는 테이블로 O(1) 조회, 그 외에는 Unicode 정규식으로 판정 (utils/codePoint.ts)
+// - 코드 포인트 단위로 판정합니다. (서로게이트 쌍 문자도 올바르게 처리)
+// ---------------------------------------------------------------------------
+const SEGMENT = 1; // 세그먼트(계층의 한 단계)에 올 수 있는 문자
+const LETTER = 2; // 문자(letter). 태그 전체에 최소 1개 필요 (#123 같은 숫자만은 제외)
+const SPACE = 4; // '#' 앞에 올 수 있는 공백
+const SegmentRe = /[\p{L}\p{N}\p{M}_-]/u;
+const LetterRe = /\p{L}/u;
+const SpaceRe = /\s/u;
+const flagsOf = createClassifier((ch) => (SegmentRe.test(ch) ? SEGMENT : 0) |
+    (LetterRe.test(ch) ? LETTER : 0) |
+    (SpaceRe.test(ch) ? SPACE : 0));
+/**
+ * `#tag`, `#부모/자식` 인라인 해시태그 문법입니다.
+ *
+ * 노드 구조:
+ * ```
+ * Hashtag
+ *   HashtagMark       "#"
+ *   HashtagSegment    "부모"
+ *   HashtagSeparator  "/"
+ *   HashtagSegment    "자식"
+ * ```
+ *
+ * - `#` 앞: 인라인 구간의 시작(줄 시작 등) 또는 공백만 허용 (`a#b`, `(#tag)`는 해시태그가 아님)
+ * - 세그먼트: Unicode 문자/숫자/결합 문자와 `_`, `-`
+ * - 계층: 세그먼트를 `/`로 구분하며 빈 세그먼트는 허용하지 않습니다.
+ *   (`#/a`는 해시태그가 아니고, `#a/`, `#a//b`는 `#a`까지만 인식)
+ * - 태그 전체에 문자(letter)가 최소 1개 있어야 합니다. (`#123`은 아님, `#2024/회의`는 허용)
+ */
+export const Hashtag = {
+    defineNodes: [
+        { name: "Hashtag", style: { "Hashtag/...": hashtagTag } },
+        // 기호에는 processingInstruction 등의 색을 따로 주지 않습니다.
+        // (구문 강조가 안쪽 span에 색을 직접 지정해 테마 색을 덮어쓰는 문제 방지)
+        { name: "HashtagMark" },
+        { name: "HashtagSegment" },
+        { name: "HashtagSeparator" },
+    ],
+    parseInline: [
+        {
+            name: "Hashtag",
+            parse(cx, next, pos) {
+                // 핫 패스: 모든 문자 위치마다 호출되므로 첫 비교로 즉시 빠져나갑니다.
+                if (next !== Hash)
+                    return -1;
+                const before = codePointBefore(cx, pos);
+                if (before >= 0 && !(flagsOf(before) & SPACE))
+                    return -1;
+                const children = [cx.elt("HashtagMark", pos, pos + 1)];
+                let hasLetter = false;
+                let segmentStart = pos + 1;
+                let end = pos + 1;
+                for (;;) {
+                    // 세그먼트 하나를 읽습니다.
+                    let cp = codePointAt(cx, end);
+                    let flags = flagsOf(cp);
+                    while (flags & SEGMENT) {
+                        if (flags & LETTER)
+                            hasLetter = true;
+                        end += sizeOf(cp);
+                        cp = codePointAt(cx, end);
+                        flags = flagsOf(cp);
+                    }
+                    if (end === segmentStart)
+                        break; // 빈 세그먼트 (첫 세그먼트면 해시태그 아님)
+                    children.push(cx.elt("HashtagSegment", segmentStart, end));
+                    // 다음 세그먼트가 이어지는 '/'만 구분자로 받습니다. ('/' 끝, '//'는 제외)
+                    if (cp !== Slash || !(flagsOf(codePointAt(cx, end + 1)) & SEGMENT))
+                        break;
+                    children.push(cx.elt("HashtagSeparator", end, end + 1));
+                    segmentStart = end = end + 1;
+                }
+                if (!hasLetter)
+                    return -1;
+                return cx.addElement(cx.elt("Hashtag", pos, end, children));
+            },
+            after: "Emphasis",
+        },
+    ],
+};
+/**
+ * 해시태그 노드의 텍스트(예: `#부모/자식`)에서 계층 정보를 추출합니다.
+ * 파서가 형식(빈 세그먼트 없음)을 보장하므로 단순 분리로 충분합니다.
+ */
+export function parseHashtag(text) {
+    const name = text.startsWith("#") ? text.slice(1) : text;
+    const segments = name.split("/");
+    const ancestors = segments.map((_, i) => segments.slice(0, i + 1).join("/"));
+    return { name, segments, ancestors };
+}

package/dist/heading.d.ts

@@ -0,0 +1,7 @@
+import type { Extension } from "@codemirror/state";
+export declare const headingPlugin: import("@codemirror/view").ViewPlugin<import("./extensions.js").RevealPluginValue, undefined>;
+/**
+ * 제목(ATX `#`, Setext `===`/`---`)에 스타일을 적용하고,
+ * `#` 기호는 커서가 해당 제목에 닿아 있을 때만 보여주는 확장입니다.
+ */
+export declare function heading(): Extension;

package/dist/heading.js

@@ -0,0 +1,159 @@
+import { Decoration, EditorView } from "@codemirror/view";
+import { createRevealPlugin } from "./utils/reveal.js";
+const HEADINGS = new Map([
+    ...[1, 2, 3, 4, 5, 6].map((level) => [`ATXHeading${level}`, { setext: false, level }]),
+    ...[1, 2].map((level) => [`SetextHeading${level}`, { setext: true, level }]),
+]);
+/**
+ * 제목(블록)을 포함할 수 있는 컨테이너 블록입니다.
+ * 이 외의 노드(문단, 인라인 요소, 코드 블록 등)는 자식 순회를 생략합니다.
+ */
+const CONTAINERS = new Set([
+    "Document",
+    "Blockquote",
+    "BulletList",
+    "OrderedList",
+    "ListItem",
+]);
+// 데코레이션 객체는 모듈 로드 시 한 번만 만들고 재사용합니다. (index = level)
+const levels = [0, 1, 2, 3, 4, 5, 6];
+const headingLine = levels.map((l) => Decoration.line({ class: `cm-heading cm-heading-${l}` }));
+const atxFormatting = levels.map((l) => Decoration.mark({
+    class: `cm-formatting cm-formatting-heading cm-formatting-heading-${l} cm-heading cm-heading-${l}`,
+}));
+const setextUnderline = levels.map((l) => Decoration.line({ class: `cm-heading-line cm-heading-line-${l}` }));
+const setextUnderlineRevealed = levels.map((l) => Decoration.line({
+    class: `cm-formatting cm-formatting-heading-line cm-formatting-heading-line-${l} cm-heading-line cm-heading-line-${l}`,
+}));
+const hiddenMark = Decoration.replace({});
+const isBlank = (code) => code === 32 /* space */ || code === 9; /* tab */
+// ---------------------------------------------------------------------------
+// 데코레이션 생성
+// ---------------------------------------------------------------------------
+/** `# 제목 #` 형태 */
+function decorateAtx(out, doc, node, level, revealed) {
+    // 들여쓰기/인용/리스트 안의 제목은 node.from이 줄 시작이 아니므로 줄 시작을 따로 구합니다.
+    const line = doc.lineAt(node.from);
+    out.push(headingLine[level].range(line.from));
+    const marks = node.getChildren("HeaderMark");
+    const open = marks[0];
+    if (!open)
+        return;
+    const markDeco = revealed ? atxFormatting[level] : hiddenMark;
+    // 여는 기호 + 뒤따르는 공백. 줄 끝을 넘지 않습니다.
+    // (빈 제목 "#" 다음에 줄바꿈이 오는 경우에도 줄바꿈을 숨기지 않도록)
+    let openEnd = open.to;
+    while (openEnd < line.to && isBlank(line.text.charCodeAt(openEnd - line.from)))
+        openEnd++;
+    out.push(markDeco.range(open.from, openEnd));
+    // 닫는 기호(`# 제목 ##`) + 그 앞의 공백
+    const close = marks.length > 1 ? marks[marks.length - 1] : undefined;
+    if (close && close.from >= openEnd) {
+        let closeStart = close.from;
+        while (closeStart > openEnd && isBlank(line.text.charCodeAt(closeStart - 1 - line.from))) {
+            closeStart--;
+        }
+        out.push(markDeco.range(closeStart, close.to));
+    }
+}
+/** `제목\n===` 형태 */
+function decorateSetext(out, doc, node, level, revealed) {
+    const underline = node.lastChild;
+    if (!underline || underline.name !== "HeaderMark")
+        return;
+    // 줄 번호로 순회하므로 들여쓰기/인용 안의 밑줄에서도 무한 루프가 생기지 않습니다.
+    const firstLine = doc.lineAt(node.from).number;
+    const underlineLine = doc.lineAt(underline.from);
+    for (let n = firstLine; n < underlineLine.number; n++) {
+        out.push(headingLine[level].range(doc.line(n).from));
+    }
+    // 밑줄 줄 전체를 숨기려면 줄바꿈까지 대체해야 하는데, ViewPlugin에서는 불가능하므로
+    // 클래스만 바꿔 테마에서 표현하도록 합니다.
+    out.push((revealed ? setextUnderlineRevealed : setextUnderline)[level].range(underlineLine.from));
+}
+// ---------------------------------------------------------------------------
+// 플러그인
+// ---------------------------------------------------------------------------
+export const headingPlugin = createRevealPlugin({
+    // 줄 데코레이션과 기호 데코레이션이 같은 위치에서 섞일 수 있으므로 정렬합니다.
+    sort: true,
+    visit({ state, decorations, isRevealed }) {
+        const { doc } = state;
+        return {
+            enter(node) {
+                if (CONTAINERS.has(node.name))
+                    return; // 자식 블록 순회
+                const spec = HEADINGS.get(node.name);
+                if (spec) {
+                    (spec.setext ? decorateSetext : decorateAtx)(decorations, doc, node.node, spec.level, isRevealed(node.from, node.to));
+                }
+                // 제목 내부(인라인)와 그 밖의 블록은 순회하지 않습니다.
+                return false;
+            },
+        };
+    },
+});
+// ---------------------------------------------------------------------------
+// 테마
+// ---------------------------------------------------------------------------
+const headingTheme = EditorView.baseTheme({
+    ".cm-heading": {
+        fontWeight: "bold",
+    },
+    // CodeMirror는 줄 높이를 getBoundingClientRect().height로 측정하므로 margin은
+    // 높이 계산에서 빠집니다(클릭/스크롤 위치 어긋남). 세로 여백은 padding으로 줍니다.
+    // .cm-line의 기본 가로 padding을 덮어쓰지 않도록 top/bottom만 지정합니다.
+    ".cm-line.cm-heading": {
+        paddingTop: "0.5rem",
+        paddingBottom: "0.35rem",
+    },
+    ".cm-heading *": {
+        textDecoration: "none",
+    },
+    // '#'(HeaderMark)에는 구문 강조(processingInstruction)가 안쪽 span에 직접 색을 지정하므로,
+    // 기호 영역의 안쪽 span이 제목 색(.cm-heading-N)을 상속하도록 합니다.
+    // .cm-line을 붙여 테마 범위가 지정된 HighlightStyle(명시도 0,2,0)보다 우선하게 합니다.
+    ".cm-line .cm-formatting-heading *": {
+        color: "inherit",
+    },
+    ".cm-heading-line *": {
+        textDecoration: "none",
+    },
+    ".cm-heading-1": {
+        fontSize: "2.027rem",
+        lineHeight: "1.15",
+        color: "oklch(0.577 0.245 27.325)", // dark and light common
+    },
+    ".cm-heading-2": {
+        fontSize: "1.802rem",
+        lineHeight: "1.15",
+        color: "oklch(0.769 0.188 70.08)", // dark and light common
+    },
+    ".cm-heading-3": {
+        fontSize: "1.602rem",
+        lineHeight: "1.15",
+        color: "oklch(0.905 0.182 98.111)", // dark and light common
+    },
+    ".cm-heading-4": {
+        fontSize: "1.424rem",
+        lineHeight: "1.15",
+        color: "oklch(0.841 0.238 128.85)", // dark and light common
+    },
+    ".cm-heading-5": {
+        fontSize: "1.266rem",
+        lineHeight: "1.15",
+        color: "oklch(0.746 0.16 232.661)", // dark and light common
+    },
+    ".cm-heading-6": {
+        fontSize: "1.125rem",
+        lineHeight: "1.15",
+        color: "oklch(0.714 0.203 305.504)", // dark and light common
+    },
+});
+/**
+ * 제목(ATX `#`, Setext `===`/`---`)에 스타일을 적용하고,
+ * `#` 기호는 커서가 해당 제목에 닿아 있을 때만 보여주는 확장입니다.
+ */
+export function heading() {
+    return [headingPlugin, headingTheme];
+}

package/dist/highlight.d.ts

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

package/dist/highlight.js

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

package/dist/horizontalRule.d.ts

@@ -0,0 +1,21 @@
+import type { Extension } from "@codemirror/state";
+interface RuleInfo {
+    readonly from: number;
+    readonly to: number;
+    readonly lineFrom: number;
+    readonly lineTo: number;
+    /** 줄에 구분선만 있는지 (앞뒤 공백 제외). 아니면 인용 등 접두어가 있는 줄 */
+    readonly wholeLine: boolean;
+}
+/**
+ * 구분선 `---`, `***`, `___`를 보여주는 StateField.
+ * (줄 전체를 대체하는 블록 위젯은 ViewPlugin으로 제공할 수 없습니다)
+ */
+export declare const horizontalRuleField: import("@codemirror/state").StateField<import("./extensions.js").RevealFieldValue<RuleInfo>>;
+/**
+ * 구분선(`---`, `***`, `___`)을 하이브리드 방식으로 보여주는 확장입니다.
+ * - 커서가 닿지 않으면 구분선을 그리고, 닿으면 원문을 보여줍니다.
+ * - 인용 안처럼 접두어가 있는 줄은 줄을 쪼개지 않도록 접두어 뒤에 인라인으로 그립니다.
+ */
+export declare function horizontalRule(): Extension;
+export {};

package/dist/horizontalRule.js

@@ -0,0 +1,142 @@
+import { syntaxTree } from "@codemirror/language";
+import { Decoration, EditorView, WidgetType } from "@codemirror/view";
+import { createRevealField } from "./utils/reveal.js";
+// ---------------------------------------------------------------------------
+// 위젯
+// ---------------------------------------------------------------------------
+class HorizontalRuleWidget extends WidgetType {
+    block;
+    constructor(block) {
+        super();
+        this.block = block;
+    }
+    eq(other) {
+        return other.block === this.block;
+    }
+    toDOM() {
+        if (!this.block) {
+            // 인용 등 접두어가 있는 줄: 접두어 뒤를 채우는 인라인 구분선
+            const span = document.createElement("span");
+            span.className = "cm-hr cm-hr-inline";
+            return span;
+        }
+        // 블록 위젯에 세로 margin을 주면 에디터의 높이 계산이 어긋나므로,
+        // 감싸는 요소의 padding으로 여백을 주고 hr의 margin은 0으로 둡니다.
+        const wrap = document.createElement("div");
+        wrap.className = "cm-hr cm-hr-block";
+        wrap.appendChild(document.createElement("hr")).className = "cm-hr-line";
+        return wrap;
+    }
+    // 클릭을 에디터가 처리해 커서가 구분선으로 이동하고 원문이 펼쳐지도록 합니다.
+    ignoreEvent() {
+        return false;
+    }
+}
+const blockRule = Decoration.replace({ widget: new HorizontalRuleWidget(true), block: true });
+const inlineRule = Decoration.replace({ widget: new HorizontalRuleWidget(false) });
+const inlineRuleLine = Decoration.line({ class: "cm-hr-inline-line" });
+const revealedLine = Decoration.line({ class: "cm-formatting cm-formatting-hr-line cm-hr-line" });
+/** 구분선을 담을 수 있는 컨테이너 블록 */
+const CONTAINERS = new Set([
+    "Blockquote",
+    "BulletList",
+    "OrderedList",
+    "ListItem",
+]);
+/**
+ * 구분선은 블록이므로, 문서 전체 트리를 훑지 않고 블록 컨테이너만 내려가며 찾습니다.
+ * (문단 안의 인라인 요소는 방문하지 않습니다)
+ */
+function scanRules(state) {
+    const { doc } = state;
+    const rules = [];
+    const cursor = syntaxTree(state).cursor();
+    const visitChildren = () => {
+        if (!cursor.firstChild())
+            return;
+        do {
+            if (cursor.type.is("HorizontalRule")) {
+                const line = doc.lineAt(cursor.from);
+                const before = line.text.slice(0, cursor.from - line.from);
+                const after = line.text.slice(Math.min(cursor.to, line.to) - line.from);
+                rules.push({
+                    from: cursor.from,
+                    to: cursor.to,
+                    lineFrom: line.from,
+                    lineTo: line.to,
+                    wholeLine: !before.trim() && !after.trim(),
+                });
+            }
+            else if (CONTAINERS.has(cursor.name)) {
+                visitChildren();
+            }
+        } while (cursor.nextSibling());
+        cursor.parent();
+    };
+    visitChildren();
+    return rules;
+}
+/**
+ * 구분선 `---`, `***`, `___`를 보여주는 StateField.
+ * (줄 전체를 대체하는 블록 위젯은 ViewPlugin으로 제공할 수 없습니다)
+ */
+export const horizontalRuleField = createRevealField({
+    scan: scanRules,
+    block: (rule) => rule.wholeLine,
+    build(rules, revealed) {
+        const out = [];
+        rules.forEach((rule, i) => {
+            if (revealed[i]) {
+                // 줄 데코레이션은 줄 시작에 있어야 합니다. (인용 안에서는 rule.from이 줄 시작이 아님)
+                out.push(revealedLine.range(rule.lineFrom));
+            }
+            else if (rule.wholeLine) {
+                out.push(blockRule.range(rule.lineFrom, rule.lineTo));
+            }
+            else {
+                // 줄 중간의 블록 위젯은 줄을 둘로 쪼개므로, 접두어가 있는 줄은 인라인으로 그립니다.
+                out.push(inlineRuleLine.range(rule.lineFrom));
+                out.push(inlineRule.range(rule.from, rule.to));
+            }
+        });
+        // 구분선이 문서 순서이고, 줄 데코레이션(줄 시작) → 대체(그 뒤) 순서로 추가됩니다.
+        return Decoration.set(out);
+    },
+});
+// ---------------------------------------------------------------------------
+// 테마
+// ---------------------------------------------------------------------------
+const horizontalRuleTheme = EditorView.baseTheme({
+    ".cm-hr-block": {
+        padding: "0.35rem 0.5rem",
+    },
+    ".cm-hr-block hr.cm-hr-line": {
+        margin: "0",
+        border: "none",
+        borderTop: "1px solid",
+    },
+    // 접두어 뒤의 남은 공간을 구분선이 채우도록 줄을 flex로 배치합니다.
+    ".cm-hr-inline-line": {
+        display: "flex",
+        alignItems: "center",
+    },
+    ".cm-hr-inline": {
+        flex: "1",
+        borderTop: "1px solid",
+        margin: "0 0.5rem",
+    },
+    "&light .cm-hr-line, &light .cm-hr-inline": {
+        borderColor: "oklch(0.869 0.005 56.366)",
+    },
+    "&dark .cm-hr-line, &dark .cm-hr-inline": {
+        borderColor: "oklch(0.444 0.011 73.639)",
+    },
+});
+/**
+ * 구분선(`---`, `***`, `___`)을 하이브리드 방식으로 보여주는 확장입니다.
+ * - 커서가 닿지 않으면 구분선을 그리고, 닿으면 원문을 보여줍니다.
+ * - 인용 안처럼 접두어가 있는 줄은 줄을 쪼개지 않도록 접두어 뒤에 인라인으로 그립니다.
+ */
+export function horizontalRule() {
+    return [horizontalRuleField, horizontalRuleTheme];
+}

package/dist/image.d.ts

@@ -0,0 +1,58 @@
+import type { EditorState, Extension } from "@codemirror/state";
+import type { SyntaxNode } from "@lezer/common";
+export type ImageAlign = "left" | "center" | "right";
+export interface ImageAltOptions {
+    /** 캡션 (대체 텍스트). 이스케이프(`\|` 등)가 해제된 값 */
+    readonly caption: string;
+    /** CSS 너비 (예: "300px", "50%") */
+    readonly width: string | null;
+    /** CSS 높이 (예: "200px") */
+    readonly height: string | null;
+    readonly align: ImageAlign | null;
+    /** 원문 대체 텍스트에서 캡션이 끝나는 위치 (그 뒤는 |size|align 옵션) */
+    readonly captionLength: number;
+}
+/**
+ * 이미지 대체 텍스트 `caption|size|align`을 해석합니다.
+ * - 뒤에서부터 크기(`300`, `300x200`, `x200`, `50%`)나 정렬(`left|center|right`) 형식인 조각만
+ *   옵션으로 인식하고, 나머지는 모두 캡션입니다. (캡션에 "|"가 있어도 깨지지 않음, `\|`로 이스케이프 가능)
+ * - inTable: 표 칸 안의 이미지. `\|`도 구분자로 봅니다. (`![아이콘\|16x16](url)`)
+ * - 크기와 정렬의 순서는 바뀌어도 되고 각각 생략할 수 있습니다.
+ */
+export declare function parseImageAlt(raw: string, inTable?: boolean): ImageAltOptions;
+export interface ImageInfo extends ImageAltOptions {
+    readonly from: number;
+    readonly to: number;
+    /** 대체 텍스트 범위 (![ 와 ] 사이) */
+    readonly altFrom: number;
+    readonly altTo: number;
+    readonly src: string;
+    readonly title: string | null;
+    /** 최상위 문단에서 이미지만 있는 줄이면 그 줄 범위 (블록 이미지로 표시), 아니면 null (인라인 이미지) */
+    readonly line: {
+        readonly from: number;
+        readonly to: number;
+    } | null;
+    /** 기호와 URL/제목 노드 (원문 표시용) */
+    readonly parts: {
+        readonly open: SyntaxNode;
+        readonly close: SyntaxNode;
+        readonly paren: SyntaxNode;
+        readonly end: SyntaxNode;
+        readonly url: SyntaxNode | null;
+        readonly title: SyntaxNode | null;
+    };
+}
+/** Image 노드에서 `![alt](url "title")` 정보를 읽습니다. 참조 이미지(`![a][ref]`)는 null */
+export declare function readImage(state: EditorState, node: SyntaxNode): ImageInfo | null;
+export interface ImageOptions {
+    /** 원문의 주소를 실제로 불러올 주소로 바꿉니다. (상대 경로 처리 등) 기본값: 그대로 사용 */
+    resolveUrl?: (src: string) => string;
+}
+/**
+ * 이미지 `![caption|size|align](url "title")`를 하이브리드 방식으로 보여주는 확장입니다.
+ * - 이미지만 있는 줄은 블록 이미지(캡션/정렬 포함)로, 글 사이의 이미지는 인라인 이미지로 보여줍니다.
+ * - 커서가 이미지에 닿으면 원문을 보여주고, 이미지만 있는 줄은 원문 아래에 미리보기를 유지합니다.
+ * - 대체 텍스트의 `|size|align` 옵션: 크기 `300`, `300x200`, `x200`, `50%` / 정렬 `left|center|right`
+ */
+export declare function image(options?: ImageOptions): Extension;