mdsquare 0.0.0-stage → 0.2.0

package/dist/mathSyntax.d.ts

@@ -0,0 +1,24 @@
+import type { MarkdownConfig } from "@lezer/markdown";
+/**
+ * LaTeX 수식 문법입니다.
+ *
+ * 인라인 `$x^2$` (문단 안의 `$$x$$`도 인라인 노드, 디스플레이 모양으로 그림):
+ * ```
+ * InlineMath
+ *   InlineMathMark  "$" 또는 "$$"
+ *   MathText        "x^2"
+ *   InlineMathMark
+ * ```
+ * 블록 (줄 맨 앞의 `$$`, 한 줄 `$$ x $$`도 가능):
+ * ```
+ * BlockMath
+ *   BlockMathMark  "$$"
+ *   MathText       줄마다 (인용 기호 등 컨테이너 기호는 제외)
+ *   BlockMathMark  "$$"   (닫히지 않았으면 없음)
+ * ```
+ * - 인라인 `$`: 여는 `$` 바로 뒤와 닫는 `$` 바로 앞은 공백이 아니어야 하고, 닫는 `$` 바로 뒤는 숫자가 아니어야
+ *   합니다. (Pandoc 규칙, `$5와 $6`은 수식 아님)
+ * - `\$`는 수식 기호가 아닙니다. 수식 안의 `\`는 다음 글자와 함께 건너뜁니다.
+ * - 블록은 문단을 빈 줄 없이 끊고 시작할 수 있습니다.
+ */
+export declare const MathSyntax: MarkdownConfig;

package/dist/mathSyntax.js

@@ -0,0 +1,179 @@
+import { styleTags, tags as t } from "@lezer/highlight";
+const Dollar = 36; // "$"
+const Backslash = 92; // "\"
+const isSpace = (code) => code === 32 || code === 9 || code === 10 || code === 13;
+const isDigit = (code) => code >= 48 && code <= 57;
+/** text[from..]에서 이스케이프되지 않은 `$$`의 위치 (없으면 -1) */
+function findDoubleDollar(text, from) {
+    for (let i = from; i < text.length - 1; i++) {
+        const code = text.charCodeAt(i);
+        if (code === Backslash)
+            i++;
+        else if (code === Dollar && text.charCodeAt(i + 1) === Dollar)
+            return i;
+    }
+    return -1;
+}
+/** 줄의 line.pos가 블록 수식 시작(`$$`)인지. 같은 줄에서 닫히면 닫는 `$$` 뒤에 다른 글자가 없어야 합니다. */
+function isBlockMathStart(line) {
+    if (line.next !== Dollar || line.text.charCodeAt(line.pos + 1) !== Dollar)
+        return false;
+    if (line.indent - line.baseIndent >= 4)
+        return false; // 들여쓴 코드 블록
+    const close = findDoubleDollar(line.text, line.pos + 2);
+    return close < 0 || line.skipSpace(close + 2) === line.text.length;
+}
+// ---------------------------------------------------------------------------
+// 인라인: $...$, $$...$$
+// ---------------------------------------------------------------------------
+/**
+ * 인라인 구간별로 "이 위치부터는 닫는 기호가 없다"를 기억합니다. ([한 겹, 두 겹])
+ * 닫는 기호의 조건은 여는 기호와 무관하므로, 앞에서 찾지 못했다면 뒤의 여는 기호도 찾지 못합니다.
+ * (`$5, $6, $7 …`처럼 짝 없는 `$`가 많은 문단에서 매번 끝까지 훑는 O(n²)을 막습니다)
+ */
+const noCloser = new WeakMap();
+function parseInlineMath(cx, next, pos) {
+    if (next !== Dollar)
+        return -1;
+    const double = cx.char(pos + 1) === Dollar;
+    const open = double ? 2 : 1;
+    const contentFrom = pos + open;
+    const first = cx.char(contentFrom);
+    // 여는 기호 바로 뒤가 공백이거나 끝이면 수식이 아닙니다. (`$ 5` 등)
+    if (contentFrom >= cx.end || isSpace(first) || (double && first === Dollar))
+        return -1;
+    const memo = noCloser.get(cx);
+    if (memo && pos >= memo[double ? 1 : 0])
+        return -1;
+    let close = -1;
+    for (let i = contentFrom; i < cx.end; i++) {
+        const code = cx.char(i);
+        if (code === Backslash) {
+            i++;
+            continue;
+        }
+        if (code !== Dollar)
+            continue;
+        if (double) {
+            if (cx.char(i + 1) === Dollar) {
+                close = i;
+                break;
+            }
+        }
+        else if (!isSpace(cx.char(i - 1)) && !isDigit(cx.char(i + 1))) {
+            // 닫는 `$`: 바로 앞이 공백이 아니고 바로 뒤가 숫자가 아님 (`$5와 $6` 같은 금액 오인식 방지)
+            close = i;
+            break;
+        }
+    }
+    if (close < 0) {
+        const value = memo ?? [Infinity, Infinity];
+        value[double ? 1 : 0] = Math.min(value[double ? 1 : 0], pos);
+        noCloser.set(cx, value);
+        return -1;
+    }
+    return cx.addElement(cx.elt("InlineMath", pos, close + open, [
+        cx.elt("InlineMathMark", pos, contentFrom),
+        cx.elt("MathText", contentFrom, close),
+        cx.elt("InlineMathMark", close, close + open),
+    ]));
+}
+// ---------------------------------------------------------------------------
+// 블록: $$ ... $$
+// ---------------------------------------------------------------------------
+/**
+ * 현재 줄이 이 블록을 담은 컨테이너(인용, 목록) 안에 계속 있는지.
+ * 공개 API에는 이 정보가 없어서, @lezer/markdown의 FencedCode와 같은 내부 필드(line.depth, cx.stack)를
+ * 읽습니다. 내부 필드가 없어지면(라이브러리 변경) 컨테이너 끝을 확인하지 않습니다.
+ * (테스트 "ends a block inside a quote where the quote ends"가 이 변화를 잡아냅니다)
+ */
+function inSameContainer(cx, line) {
+    const depth = line.depth;
+    const stack = cx.stack;
+    return depth === undefined || stack === undefined || depth >= stack.length;
+}
+function parseBlockMath(cx, line) {
+    if (!isBlockMathStart(line))
+        return false;
+    const start = cx.lineStart + line.pos;
+    const children = [cx.elt("BlockMathMark", start, start + 2)];
+    const text = (from, to) => {
+        if (line.skipSpace(from) < to)
+            children.push(cx.elt("MathText", cx.lineStart + from, cx.lineStart + to));
+    };
+    // 한 줄: $$ x $$
+    const sameLine = findDoubleDollar(line.text, line.pos + 2);
+    if (sameLine >= 0) {
+        text(line.pos + 2, sameLine);
+        const end = cx.lineStart + sameLine + 2;
+        children.push(cx.elt("BlockMathMark", end - 2, end));
+        cx.nextLine();
+        cx.addElement(cx.elt("BlockMath", start, end, children));
+        return true;
+    }
+    text(line.pos + 2, line.text.length);
+    let end = cx.lineStart + line.text.length;
+    // 닫는 `$$`까지. 닫히지 않으면 담고 있는 블록(인용, 목록)이나 문서 끝까지입니다. (펜스 코드와 같음)
+    while (cx.nextLine() && inSameContainer(cx, line)) {
+        for (const marker of line.markers)
+            children.push(marker);
+        const close = findDoubleDollar(line.text, line.basePos);
+        if (close >= 0 && line.skipSpace(close + 2) === line.text.length) {
+            text(line.basePos, close);
+            end = cx.lineStart + close + 2;
+            children.push(cx.elt("BlockMathMark", end - 2, end));
+            cx.nextLine();
+            break;
+        }
+        text(line.basePos, line.text.length);
+        end = cx.lineStart + line.text.length;
+    }
+    cx.addElement(cx.elt("BlockMath", start, end, children));
+    return true;
+}
+/**
+ * LaTeX 수식 문법입니다.
+ *
+ * 인라인 `$x^2$` (문단 안의 `$$x$$`도 인라인 노드, 디스플레이 모양으로 그림):
+ * ```
+ * InlineMath
+ *   InlineMathMark  "$" 또는 "$$"
+ *   MathText        "x^2"
+ *   InlineMathMark
+ * ```
+ * 블록 (줄 맨 앞의 `$$`, 한 줄 `$$ x $$`도 가능):
+ * ```
+ * BlockMath
+ *   BlockMathMark  "$$"
+ *   MathText       줄마다 (인용 기호 등 컨테이너 기호는 제외)
+ *   BlockMathMark  "$$"   (닫히지 않았으면 없음)
+ * ```
+ * - 인라인 `$`: 여는 `$` 바로 뒤와 닫는 `$` 바로 앞은 공백이 아니어야 하고, 닫는 `$` 바로 뒤는 숫자가 아니어야
+ *   합니다. (Pandoc 규칙, `$5와 $6`은 수식 아님)
+ * - `\$`는 수식 기호가 아닙니다. 수식 안의 `\`는 다음 글자와 함께 건너뜁니다.
+ * - 블록은 문단을 빈 줄 없이 끊고 시작할 수 있습니다.
+ */
+export const MathSyntax = {
+    defineNodes: [
+        { name: "InlineMath" },
+        { name: "InlineMathMark" },
+        { name: "BlockMath", block: true },
+        { name: "BlockMathMark" },
+        { name: "MathText" },
+    ],
+    props: [
+        styleTags({
+            "InlineMathMark BlockMathMark": t.processingInstruction,
+            MathText: t.monospace,
+        }),
+    ],
+    parseInline: [{ name: "InlineMath", parse: parseInlineMath, before: "Escape" }],
+    parseBlock: [
+        {
+            name: "BlockMath",
+            parse: parseBlockMath,
+            endLeaf: (_cx, line) => isBlockMathStart(line),
+            before: "FencedCode",
+        },
+    ],
+};

package/dist/mention.d.ts

@@ -0,0 +1,4 @@
+import type { Extension } from "@codemirror/state";
+export declare const mentionPlugin: import("@codemirror/view").ViewPlugin<import("./extensions.js").RevealPluginValue, undefined>;
+/** `@user` 멘션에 스타일을 적용하는 확장입니다. */
+export declare function mention(): Extension;

package/dist/mention.js

@@ -0,0 +1,58 @@
+import { Decoration, EditorView } from "@codemirror/view";
+import { createRevealPlugin } from "./utils/reveal.js";
+// 데코레이션 객체는 모듈 로드 시 한 번만 만들고 재사용합니다.
+const begin = Decoration.mark({ class: "cm-mention cm-mention-begin" });
+const end = Decoration.mark({ class: "cm-mention cm-mention-end" });
+const beginRevealed = Decoration.mark({
+    class: "cm-formatting cm-formatting-mention cm-mention cm-mention-begin",
+});
+const endRevealed = Decoration.mark({
+    class: "cm-formatting cm-formatting-mention cm-mention cm-mention-end",
+});
+/** 멘션이 올 수 없으므로 자식 순회를 생략하는 노드 */
+const SKIP_CHILDREN = new Set([
+    "FencedCode",
+    "CodeBlock",
+    "InlineCode",
+    "HTMLBlock",
+    "CommentBlock",
+    "URL",
+    "Autolink",
+]);
+export const mentionPlugin = createRevealPlugin({
+    // 멘션은 서로 겹치지 않고 문서 순서대로 추가되므로 정렬이 필요 없습니다.
+    visit({ decorations, isRevealed }) {
+        return {
+            enter(node) {
+                if (node.name === "Mention") {
+                    const revealed = isRevealed(node.from, node.to);
+                    // 파서가 MentionMark를 항상 '@' 한 글자로 만듭니다.
+                    decorations.push((revealed ? beginRevealed : begin).range(node.from, node.from + 1), (revealed ? endRevealed : end).range(node.from + 1, node.to));
+                    return false;
+                }
+                if (SKIP_CHILDREN.has(node.name))
+                    return false;
+            },
+        };
+    },
+});
+const mentionTheme = EditorView.baseTheme({
+    ".cm-mention": {
+        backgroundColor: "rgba(135, 131, 120, 0.15)",
+        // `.cm-mention *`로 지정하면 안쪽 span이 있을 때만 적용되어
+        // (구문 강조 span이 없으면 적용되지 않음) 글자 크기가 바뀌지 않으므로 직접 지정합니다.
+        fontSize: "0.75rem",
+    },
+    ".cm-mention.cm-mention-begin": {
+        borderRadius: "2px 0 0 2px",
+        padding: "1px 0 1px 4px",
+    },
+    ".cm-mention.cm-mention-end": {
+        borderRadius: "0 2px 2px 0",
+        padding: "1px 4px 1px 0",
+    },
+});
+/** `@user` 멘션에 스타일을 적용하는 확장입니다. */
+export function mention() {
+    return [mentionPlugin, mentionTheme];
+}

package/dist/mentionSyntax.d.ts

@@ -0,0 +1,14 @@
+import type { MarkdownConfig } from "@lezer/markdown";
+import { Tag } from "@lezer/highlight";
+/** `@user` 멘션에 사용할 하이라이트 태그 */
+export declare const mentionTag: Tag;
+/**
+ * `@user` 인라인 멘션 문법입니다. (노드: Mention > MentionMark)
+ *
+ * - `@` 앞: 인라인 구간의 시작(줄 시작 등) 또는 공백만 허용
+ *   (`a@b`, `user@example.com`, `(@user)`는 멘션이 아님)
+ * - 이름: Unicode 문자/숫자/결합 문자와 `_`, `-`
+ *   `.`은 이름 문자 사이에만 허용 (`@john.doe`는 허용, `@john.`은 `@john`까지만)
+ * - 이름에 문자(letter)가 최소 1개 있어야 합니다. (`@123`은 멘션이 아님)
+ */
+export declare const Mention: MarkdownConfig;

package/dist/mentionSyntax.js

@@ -0,0 +1,71 @@
+import { Tag, tags } from "@lezer/highlight";
+import { codePointAt, codePointBefore, createClassifier, sizeOf } from "./utils/codePoint.js";
+/** `@user` 멘션에 사용할 하이라이트 태그 */
+export const mentionTag = Tag.define(tags.content);
+const At = 64; // "@"
+const Dot = 46; // "."
+// ---------------------------------------------------------------------------
+// 문자 분류 (코드 포인트 단위, ASCII는 테이블 조회)
+// ---------------------------------------------------------------------------
+const NAME = 1; // 이름에 올 수 있는 문자 ('.' 제외)
+const LETTER = 2; // 문자(letter). 이름에 최소 1개 필요 (@123 같은 숫자만은 제외)
+const SPACE = 4; // '@' 앞에 올 수 있는 공백
+const NameRe = /[\p{L}\p{N}\p{M}_-]/u;
+const LetterRe = /\p{L}/u;
+const SpaceRe = /\s/u;
+const flagsOf = createClassifier((ch) => (NameRe.test(ch) ? NAME : 0) | (LetterRe.test(ch) ? LETTER : 0) | (SpaceRe.test(ch) ? SPACE : 0));
+/**
+ * `@user` 인라인 멘션 문법입니다. (노드: Mention > MentionMark)
+ *
+ * - `@` 앞: 인라인 구간의 시작(줄 시작 등) 또는 공백만 허용
+ *   (`a@b`, `user@example.com`, `(@user)`는 멘션이 아님)
+ * - 이름: Unicode 문자/숫자/결합 문자와 `_`, `-`
+ *   `.`은 이름 문자 사이에만 허용 (`@john.doe`는 허용, `@john.`은 `@john`까지만)
+ * - 이름에 문자(letter)가 최소 1개 있어야 합니다. (`@123`은 멘션이 아님)
+ */
+export const Mention = {
+    defineNodes: [
+        { name: "Mention", style: { "Mention/...": mentionTag } },
+        // '@'에 processingInstruction 등의 색을 따로 주지 않습니다.
+        // (구문 강조가 안쪽 span에 색을 직접 지정해 테마 색을 덮어쓰는 문제 방지)
+        { name: "MentionMark" },
+    ],
+    parseInline: [
+        {
+            name: "Mention",
+            parse(cx, next, pos) {
+                // 핫 패스: 모든 문자 위치마다 호출되므로 첫 비교로 즉시 빠져나갑니다.
+                if (next !== At)
+                    return -1;
+                const before = codePointBefore(cx, pos);
+                if (before >= 0 && !(flagsOf(before) & SPACE))
+                    return -1;
+                let end = pos + 1;
+                let hasLetter = false;
+                for (;;) {
+                    // '.'으로 구분된 이름 조각 하나를 읽습니다.
+                    const partStart = end;
+                    let cp = codePointAt(cx, end);
+                    let flags = flagsOf(cp);
+                    while (flags & NAME) {
+                        if (flags & LETTER)
+                            hasLetter = true;
+                        end += sizeOf(cp);
+                        cp = codePointAt(cx, end);
+                        flags = flagsOf(cp);
+                    }
+                    if (end === partStart)
+                        break; // 빈 조각 (첫 조각이면 멘션 아님)
+                    // 다음 조각이 이어지는 '.'만 이름에 포함합니다. ('.' 끝, '..'는 제외)
+                    if (cp !== Dot || !(flagsOf(codePointAt(cx, end + 1)) & NAME))
+                        break;
+                    end += 1;
+                }
+                if (!hasLetter)
+                    return -1;
+                return cx.addElement(cx.elt("Mention", pos, end, [cx.elt("MentionMark", pos, pos + 1)]));
+            },
+            after: "Emphasis",
+        },
+    ],
+};

package/dist/quote.d.ts

@@ -0,0 +1,9 @@
+import type { Extension } from "@codemirror/state";
+export declare const quotePlugin: import("@codemirror/view").ViewPlugin<import("./extensions.js").RevealPluginValue, undefined>;
+/**
+ * 인용(`> 내용`)을 하이브리드 방식으로 보여주는 확장입니다.
+ * - 인용 줄에는 왼쪽 세로줄만 그립니다. (중첩 깊이만큼 세로줄 반복, 깊이 제한 없음)
+ * - `> ` 기호는 숨기고, 커서가 기호에 닿으면 원문을 보여줍니다.
+ * - 게으른 연속 줄(`>` 없이 이어지는 줄)과 인용 안의 목록/제목/코드 블록도 함께 처리합니다.
+ */
+export declare function quote(): Extension;

package/dist/quote.js

@@ -0,0 +1,122 @@
+import { Decoration, EditorView } from "@codemirror/view";
+import { calloutsHandled, readCalloutHeader } from "./calloutHeader.js";
+import { createRevealPlugin } from "./utils/reveal.js";
+// ---------------------------------------------------------------------------
+// 데코레이션
+// ---------------------------------------------------------------------------
+const hiddenMark = Decoration.replace({});
+const revealedMark = Decoration.mark({ class: "cm-formatting cm-formatting-quote" });
+/** 깊이별 줄 데코레이션 (깊이 제한이 없으므로 처음 쓸 때 만들어 재사용) */
+const lineCache = new Map();
+function quoteLine(depth) {
+    let deco = lineCache.get(depth);
+    if (!deco) {
+        deco = Decoration.line({
+            class: `cm-quote-line cm-quote-line-${depth}`,
+            // 테마에서 깊이만큼 왼쪽 세로줄을 그리는 데 씁니다.
+            attributes: { style: `--cm-quote-depth: ${depth}` },
+        });
+        lineCache.set(depth, deco);
+    }
+    return deco;
+}
+/** 인용 밖에서는 인용을 담을 수 있는 컨테이너만 내려갑니다. */
+const CONTAINERS = new Set(["Document", "BulletList", "OrderedList", "ListItem"]);
+const Space = 32;
+// ---------------------------------------------------------------------------
+// 플러그인
+// ---------------------------------------------------------------------------
+export const quotePlugin = createRevealPlugin({
+    // 줄 데코레이션을 인용 블록이 끝날 때 한꺼번에 추가하므로 정렬합니다.
+    sort: true,
+    visit({ state, decorations, isRevealed }) {
+        const { doc } = state;
+        const skipCallouts = state.facet(calloutsHandled);
+        /**
+         * 방문 중인 인용 스택.
+         * - bar: 세로줄을 그리는 인용인지 (callout()이 그리는 콜아웃은 false)
+         * - source: 커서가 들어와 원문을 보여주는 콜아웃 안인지 (모든 ">"를 보여주고 세로줄도 그리지 않음)
+         */
+        const stack = [];
+        let depth = 0; // 세로줄을 그리는 인용의 깊이
+        const inSource = () => stack.length > 0 && stack[stack.length - 1].source;
+        /** 줄 번호 → 그 줄을 덮는 인용의 최대 깊이 (가장 바깥 인용이 끝날 때 줄 데코레이션으로 변환) */
+        const lineDepth = new Map();
+        return {
+            enter(node) {
+                if (node.name === "Blockquote") {
+                    // 콜아웃은 callout()이 박스로 그리므로 세로줄을 그리지 않습니다. (">" 숨김은 계속 처리)
+                    const isCallout = skipCallouts && readCalloutHeader(state, node.node) !== null;
+                    // 커서가 가장 바깥 콜아웃 안에 있으면 그 콜아웃 전체를 원문으로 보여줍니다. (Obsidian과 같은 편집 방식)
+                    const source = inSource() || (isCallout && isRevealed(node.from, node.to));
+                    const bar = !isCallout && !source;
+                    stack.push({ bar, source });
+                    if (!bar)
+                        return;
+                    depth++;
+                    // 안쪽 인용이 나중에 방문되므로 더 깊은 값으로 덮어씁니다. (게으른 연속 줄 포함)
+                    const first = doc.lineAt(node.from).number;
+                    const last = doc.lineAt(node.to).number;
+                    for (let n = first; n <= last; n++)
+                        lineDepth.set(n, depth);
+                    return;
+                }
+                if (node.name === "QuoteMark") {
+                    // ">" 뒤의 공백 한 칸까지 숨겨 내용이 세로줄 옆에 붙도록 합니다.
+                    const end = doc.sliceString(node.to, node.to + 1).charCodeAt(0) === Space ? node.to + 1 : node.to;
+                    if (inSource() || isRevealed(node.from, node.to)) {
+                        decorations.push(revealedMark.range(node.from, node.to));
+                    }
+                    else {
+                        decorations.push(hiddenMark.range(node.from, end));
+                    }
+                    return false;
+                }
+                // 인용 안: 이어지는 줄의 ">"는 문단/코드 블록 등의 자식(또는 그 안의 인라인 노드)이므로
+                // 끝까지 내려가며 찾습니다. 인용 밖: 컨테이너만 내려갑니다.
+                if (stack.length === 0 && !CONTAINERS.has(node.name))
+                    return false;
+            },
+            leave(node) {
+                if (node.name !== "Blockquote")
+                    return;
+                if (stack.pop()?.bar)
+                    depth--;
+                if (stack.length > 0)
+                    return;
+                // 가장 바깥 인용이 끝나면 줄마다 하나의 줄 데코레이션을 추가합니다.
+                // (같은 줄에 style이 다른 줄 데코레이션이 여러 개면 하나만 남고 어느 쪽이 남을지는
+                //  데코레이션 순서에 달려 있어 깊이가 틀릴 수 있으므로, 최대 깊이 하나만 넣습니다.)
+                for (const [n, d] of lineDepth)
+                    decorations.push(quoteLine(d).range(doc.line(n).from));
+                lineDepth.clear();
+            },
+        };
+    },
+});
+// ---------------------------------------------------------------------------
+// 테마: 왼쪽 세로줄만 (깊이만큼 반복)
+// ---------------------------------------------------------------------------
+const BAR = "3px"; // 세로줄 두께
+const STEP = "14px"; // 깊이 한 단계의 폭
+const quoteTheme = EditorView.baseTheme({
+    ".cm-quote-line": {
+        backgroundImage: `repeating-linear-gradient(to right, var(--cm-quote-color) 0 ${BAR}, transparent ${BAR} ${STEP})`,
+        backgroundSize: `calc(var(--cm-quote-depth) * ${STEP}) 100%`,
+        backgroundRepeat: "no-repeat",
+        // 내용 시작 위치를 다른 블록(코드 블록 등)에도 알려줍니다. (utils/container.ts)
+        "--cm-container-indent": `calc(var(--cm-quote-depth) * ${STEP} + 2px)`,
+        paddingLeft: "var(--cm-container-indent)",
+    },
+    "&light .cm-quote-line": { "--cm-quote-color": "#d1d5db" },
+    "&dark .cm-quote-line": { "--cm-quote-color": "#4b5563" },
+});
+/**
+ * 인용(`> 내용`)을 하이브리드 방식으로 보여주는 확장입니다.
+ * - 인용 줄에는 왼쪽 세로줄만 그립니다. (중첩 깊이만큼 세로줄 반복, 깊이 제한 없음)
+ * - `> ` 기호는 숨기고, 커서가 기호에 닿으면 원문을 보여줍니다.
+ * - 게으른 연속 줄(`>` 없이 이어지는 줄)과 인용 안의 목록/제목/코드 블록도 함께 처리합니다.
+ */
+export function quote() {
+    return [quotePlugin, quoteTheme];
+}

package/dist/setup.d.ts

@@ -0,0 +1,13 @@
+import { type Extension } from "@codemirror/state";
+export interface BasicSetupOptions {
+    /** 줄 번호와 접기 표시 (기본 false: 글쓰기 화면) */
+    readonly lineNumbers?: boolean;
+}
+/**
+ * 에디터 기본 구성: CodeMirror의 basicSetup에서 활성 줄 강조(markVision이 담당)를 빼고
+ * Tab 들여쓰기를 더했습니다. 줄 번호는 선택.
+ * - 실행 취소, 여러 커서, 괄호 자동 닫기, 검색(Mod-f), 같은 단어 강조, 사각형 선택(Alt-드래그)
+ * - Tab: 들여쓰기 (목록·표 안에서는 각 확장이 먼저 처리). 키보드로 에디터 밖으로 포커스를 옮기려면
+ *   Ctrl-m (macOS: Alt-Shift-m)으로 Tab 이동 모드를 켠 뒤 Tab
+ */
+export declare function basicSetup(options?: BasicSetupOptions): Extension;

package/dist/setup.js

@@ -0,0 +1,40 @@
+import { autocompletion, closeBrackets, closeBracketsKeymap, completionKeymap } from "@codemirror/autocomplete";
+import { defaultKeymap, history, historyKeymap, indentWithTab } from "@codemirror/commands";
+import { bracketMatching, defaultHighlightStyle, foldGutter, foldKeymap, indentOnInput, syntaxHighlighting, } from "@codemirror/language";
+import { highlightSelectionMatches, searchKeymap } from "@codemirror/search";
+import { EditorState } from "@codemirror/state";
+import { crosshairCursor, drawSelection, dropCursor, highlightActiveLineGutter, highlightSpecialChars, keymap, lineNumbers, rectangularSelection, } from "@codemirror/view";
+/**
+ * 에디터 기본 구성: CodeMirror의 basicSetup에서 활성 줄 강조(markVision이 담당)를 빼고
+ * Tab 들여쓰기를 더했습니다. 줄 번호는 선택.
+ * - 실행 취소, 여러 커서, 괄호 자동 닫기, 검색(Mod-f), 같은 단어 강조, 사각형 선택(Alt-드래그)
+ * - Tab: 들여쓰기 (목록·표 안에서는 각 확장이 먼저 처리). 키보드로 에디터 밖으로 포커스를 옮기려면
+ *   Ctrl-m (macOS: Alt-Shift-m)으로 Tab 이동 모드를 켠 뒤 Tab
+ */
+export function basicSetup(options = {}) {
+    return [
+        options.lineNumbers ? [lineNumbers(), highlightActiveLineGutter(), foldGutter()] : [],
+        highlightSpecialChars(),
+        history(),
+        drawSelection(),
+        dropCursor(),
+        EditorState.allowMultipleSelections.of(true),
+        indentOnInput(),
+        syntaxHighlighting(defaultHighlightStyle, { fallback: true }),
+        bracketMatching(),
+        closeBrackets(),
+        autocompletion(),
+        rectangularSelection(),
+        crosshairCursor(),
+        highlightSelectionMatches(),
+        keymap.of([
+            ...closeBracketsKeymap,
+            ...defaultKeymap,
+            ...searchKeymap,
+            ...historyKeymap,
+            ...foldKeymap,
+            ...completionKeymap,
+            indentWithTab,
+        ]),
+    ];
+}

package/dist/style.css

@@ -0,0 +1,6 @@
+/*
+ * mdsquare 스타일: 에디터 자체의 스타일은 JS(CodeMirror 테마)에 들어 있고,
+ * 여기서는 수식(KaTeX)의 글꼴과 스타일을 불러옵니다.
+ * 번들러(Vite, webpack 등)가 패키지 경로를 풀어 줍니다.
+ */
+@import "katex/dist/katex.min.css";

package/dist/style.css.d.ts

@@ -0,0 +1,2 @@
+// `import "mdsquare/style.css"`를 위한 빈 선언
+export {};

package/dist/table.d.ts

@@ -0,0 +1,38 @@
+import { Facet, type EditorState, type Extension, type StateCommand } from "@codemirror/state";
+import type { SyntaxNode } from "@lezer/common";
+import { type TableBlock, type TableRowInfo } from "./tableModel.js";
+interface CellPosition {
+    readonly table: SyntaxNode;
+    readonly block: TableBlock;
+    readonly rows: readonly TableRowInfo[];
+    /** rows 안의 위치. 구분 줄이면 -1 */
+    readonly row: number;
+    readonly cell: number;
+}
+/** 커서가 있는 칸 (단일 빈 커서일 때만) */
+export declare function cellAt(state: EditorState, pos: number): CellPosition | null;
+/** Enter: 아래에 새 행. 비어 있는 마지막 행에서는 표를 끝냅니다(행을 빈 줄로). */
+export declare const insertTableRow: StateCommand;
+export declare const nextTableCell: StateCommand;
+export declare const previousTableCell: StateCommand;
+/**
+ * 빈 커서가 표 행의 앞 "|" 앞(접두어 포함)이나 뒤 "|" 뒤에 놓이면 첫 칸/마지막 칸 내용으로 옮깁니다.
+ * 키보드(←/→/Home/End/↑/↓), 클릭, 명령 등 어떤 경로든 같은 규칙을 적용합니다.
+ * (구분 줄과 선택 영역은 건드리지 않습니다)
+ */
+export declare function clampTableCursor(state: EditorState, pos: number): number;
+/** table()이 켜져 있는지 (다른 확장이 역할을 나눌 때) */
+export declare const tablesHandled: Facet<boolean, boolean>;
+/**
+ * GFM 표를 표 모양으로 보여주고 편집하는 확장입니다.
+ * - 원문은 그대로 두고 화면에서만 표로 그립니다. (`|` 숨김, 칸 테두리, 열 너비는 내용에 맞춤, 칸 안 줄바꿈)
+ * - 칸 안의 굵게/링크/수식 등은 다른 확장이 그대로 그립니다.
+ * - 구분 줄(`|---|`)은 숨기고, 열 정렬(`:-:`)은 칸 정렬로 보여줍니다.
+ * - 제목 행/열: 표 바로 윗줄의 `<!-- table: header-column no-header-row -->` 주석 (다른 렌더러에서는 보이지 않음).
+ *   첫 행/첫 열에 마우스를 올리면 나타나는 손잡이 메뉴로 켜고 끕니다.
+ * - Enter: 아래에 새 행 (비어 있는 마지막 행에서는 표 끝내기), Tab/Shift+Tab: 칸 이동 (마지막 칸에서 Tab은 새 행)
+ * - 칸 처음/끝에서 Backspace/Delete는 `|`를 지우지 않고 옆 칸으로 이동합니다.
+ * - 인용, 목록, 콜아웃 안의 표도 지원합니다.
+ */
+export declare function table(): Extension;
+export {};