@moda-editor/core 0.1.3 → 0.1.5

package/dist/features/code-block.js

@@ -1,10 +1,20 @@
-import { firstTextPath, nodeAt } from "../model/traverse.js";
-import { leafPoint } from "../state/apply.js";
-import { normalizedRange, pointCmp, pointEq, textSelection, } from "../state/selection.js";
-import { codeLangOptions, highlightCode, } from "../presets/highlight.js";
+import { nodeAt } from "../model/traverse.js";
+import { normalizedRange, pointEq, textSelection } from "../state/selection.js";
+import { codeLangOptions, highlightCode } from "../presets/highlight.js";
 import { PATH_ATTR } from "../view/dom.js";
 import { defineFeature } from "./feature.js";
+import { codeBracketAt, codeContext, codeStringMask, codeTextAt, isCodeBlock, } from "./code-context.js";
+import { dedentCode, duplicateCodeLines, exitCodeArrow, formatCode, formatCodeAt, indentCode, moveCodeLines, toggleCodeComment, } from "./code-edit.js";
 import { blockRule, blockText, blockTextPoint, caretBlockPath, } from "../commands.js";
+/**
+ * 코드블록 — ` ``` ` 입력 규칙, 구문 하이라이트, Ace/VS Code 관례의
+ * 코드 편집 명령(들여쓰기·주석 토글·줄 이동/복제·괄호 매칭·화살표
+ * 탈출). 코드 텍스트는 마크 없는 순수 텍스트다.
+ *
+ * 모듈 구성 — 이 파일은 스키마·블록 변환·크롬 UI·feature 정의만 갖고,
+ * 컨텍스트 해석은 code-context.ts, 편집 커맨드는 code-edit.ts,
+ * 서식 엔진은 code-format.ts에 있다.
+ */
 /**
  * 코드블록 — ` ``` ` 입력 규칙, 구문 하이라이트, Ace/VS Code 관례의
  * 코드 편집 명령(들여쓰기·주석 토글·줄 이동/복제·괄호 매칭·화살표
@@ -43,16 +53,17 @@ export const toggleCodeBlock = ({ state, tr, dispatch }) => {
             return false;
         const merged = {
             type: "codeBlock",
-            content: [
-                { type: "text", text: blocks.map(blockText).join("\n") },
-            ],
+            content: [{ type: "text", text: blocks.map(blockText).join("\n") }],
         };
         tr.delete({
             anchor: { path: [], offset: a },
             focus: { path: [], offset: b + 1 },
         });
         tr.insertNode({ path: [], offset: a }, merged);
-        tr.setSelection(textSelection({ path: [a, 0], offset: merged.content?.[0]?.text?.length ?? 0 }));
+        tr.setSelection(textSelection({
+            path: [a, 0],
+            offset: merged.content?.[0]?.text?.length ?? 0,
+        }));
         dispatch();
         return true;
     }
@@ -91,1014 +102,6 @@ export function setCodeLanguageAt(blockPath, language) {
         return true;
     };
 }
-/** 문자열·주석·정규식을 공백으로 마스킹.
- *  블록 주석·템플릿 리터럴은 줄을 넘나드는 상태 머신으로 처리하고,
- *  템플릿의 `${`/`}`는 `{`/`}`로 남겨 안쪽 식의 들여쓰기도 잡는다. */
-function maskCode(src) {
-    const modes = ["code"];
-    const out = src.split("");
-    const interior = [];
-    let lineNo = 0;
-    let prevSig = ""; // 정규식 vs 나누기 판별용 — 마지막 유의미 문자
-    let rxClass = false;
-    for (let i = 0; i < src.length; i++) {
-        const c = src[i];
-        const n = src[i + 1] ?? "";
-        const top = modes[modes.length - 1];
-        const blank = () => {
-            out[i] = " ";
-        };
-        if (c === "\n") {
-            lineNo++;
-            // 다음 줄이 여러 줄 구문의 "본문"에서 시작하는지 기록 —
-            // 'line' 주석은 \n에서 끝나고 sq/dq/rx도 줄 끝에서 닫히므로
-            // 남는 다중줄 모드(block/tmpl 또는 tmpl 안 code)만 본다
-            const next = modes.filter((m) => m === "block" || m === "tmpl").length > 0
-                && !(modes.length > 1 && modes[modes.length - 1] === "code");
-            if (next)
-                interior[lineNo] = true;
-        }
-        switch (top) {
-            case "line":
-                if (c === "\n")
-                    modes.pop();
-                else
-                    blank();
-                break;
-            case "block":
-                if (c === "*" && n === "/") {
-                    blank();
-                    out[++i] = " ";
-                    modes.pop();
-                }
-                else if (c !== "\n")
-                    blank();
-                break;
-            case "sq":
-            case "dq": {
-                const q = top === "sq" ? "'" : '"';
-                if (c === "\n")
-                    modes.pop(); // 미닫힘 문자열 — 개행은 유지
-                else {
-                    blank();
-                    if (c === "\\")
-                        out[++i] = " ";
-                    else if (c === q)
-                        modes.pop();
-                }
-                break;
-            }
-            case "tmpl":
-                if (c === "\\") {
-                    blank();
-                    out[++i] = " ";
-                }
-                else if (c === "`") {
-                    blank();
-                    modes.pop();
-                }
-                else if (c === "$" && n === "{") {
-                    // ${ 식 — 코드 구간으로 돌아간다. 여는 기호는 { 로 남긴다
-                    blank();
-                    out[++i] = "{";
-                    modes.push("code");
-                }
-                else if (c !== "\n")
-                    blank();
-                break;
-            case "rx":
-                if (c === "\n")
-                    modes.pop(); // 미닫힘 정규식 — 개행은 유지
-                else {
-                    blank();
-                    if (c === "\\")
-                        out[++i] = " ";
-                    else if (c === "[")
-                        rxClass = true;
-                    else if (c === "]")
-                        rxClass = false;
-                    else if (c === "/" && !rxClass)
-                        modes.pop();
-                }
-                break;
-            default: {
-                // "code" — 템플릿 ${} 안이면 } 가 이 구간을 닫는다
-                if (c === "/" && n === "/") {
-                    blank();
-                    out[++i] = " ";
-                    modes.push("line");
-                }
-                else if (c === "/" && n === "*") {
-                    blank();
-                    out[++i] = " ";
-                    modes.push("block");
-                }
-                else if (c === "'")
-                    modes.push("sq");
-                else if (c === '"')
-                    modes.push("dq");
-                else if (c === "`")
-                    modes.push("tmpl");
-                else if (c === "/" &&
-                    "(,=:[!&|?{};+-*%<>\n~^".includes(prevSig || "\n")) {
-                    modes.push("rx");
-                    rxClass = false;
-                    blank();
-                }
-                else if (c === "}" && modes.length > 1) {
-                    // 템플릿 ${} 의 닫기 — 식 구간을 빠져나간다
-                    modes.pop();
-                }
-                if (!/\s/.test(c))
-                    prevSig = c;
-            }
-        }
-    }
-    return { text: out.join(""), interior };
-}
-const BRACE_LANGS = new Set([
-    "js", "jsx", "ts", "tsx", "javascript", "typescript",
-    "java", "c", "cpp", "cs", "go", "rust", "rs", "php",
-    "swift", "kotlin", "kt", "css", "scss", "less", "json",
-]);
-const MARKUP_LANGS = new Set(["html", "xml", "vue", "svelte"]);
-const SHELL_LANGS = new Set(["sh", "bash", "shell", "zsh"]);
-/** 들여쓰기 단위 추정 — 탭이 우세하면 탭, 아니면 가장 얕은 기존
- *  들여쓰기 폭(2/4)을 따르고 둘 다 없으면 prettier 관례 2칸 */
-function indentUnit(lines) {
-    let tabs = 0;
-    let minSpace = 0;
-    for (const l of lines) {
-        const ws = l.match(/^[ \t]+/)?.[0];
-        if (!ws)
-            continue;
-        if (ws.includes("\t"))
-            tabs++;
-        else if (!minSpace || ws.length < minSpace)
-            minSpace = ws.length;
-    }
-    if (tabs > 0)
-        return "\t";
-    if (minSpace >= 3)
-        return "    ";
-    return "  ";
-}
-/** 중괄호 계열 재들여쓰기 — 줄 구조는 건드리지 않고 선행 공백만
- *  깊이에 맞게 다시 쓴다. case/default 라벨도 깊이로 모델한다 */
-function reindentBraces(code, unit) {
-    const mask = maskCode(code);
-    const masked = mask.text.split("\n");
-    const lines = code.split("\n");
-    const stack = [];
-    return lines
-        .map((line, i) => {
-        const t = (masked[i] ?? "").trim();
-        // 여러 줄 문자열/블록 주석/템플릿 본문 — 값이 바뀌므로 원문 유지
-        if (mask.interior[i])
-            return line;
-        if (!t) {
-            // 주석 전용 줄은 깊이에 맞춰 재들여쓰기, 진짜 빈 줄은 빈 줄로
-            return line.trim() ? unit.repeat(stack.length) + line.trim() : "";
-        }
-        const leadClosers = t.match(/^[}\])]+/)?.[0].length ?? 0;
-        const isCase = /^(case\b[^:]*|default)\s*:/.test(t);
-        for (let k = 0; k < leadClosers; k++) {
-            // 한 개의 } 는 열린 case 몸통과 그 블록을 함께 닫는다
-            if (stack[stack.length - 1] === "case")
-                stack.pop();
-            if (stack[stack.length - 1] === "brace")
-                stack.pop();
-        }
-        if (isCase && stack[stack.length - 1] === "case")
-            stack.pop();
-        const indent = stack.length;
-        if (isCase)
-            stack.push("case");
-        for (const ch of t.slice(leadClosers)) {
-            if (ch === "{" || ch === "[" || ch === "(")
-                stack.push("brace");
-            else if (ch === "}" || ch === "]" || ch === ")") {
-                if (stack[stack.length - 1] === "case")
-                    stack.pop();
-                if (stack[stack.length - 1] === "brace")
-                    stack.pop();
-            }
-        }
-        return unit.repeat(indent) + line.trim();
-    })
-        .join("\n");
-}
-const VOID_TAGS = new Set([
-    "area", "base", "br", "col", "embed", "hr", "img", "input",
-    "link", "meta", "param", "source", "track", "wbr",
-]);
-/** HTML/XML 계열 재들여쓰기 — 태그 열기/닫기만 센다 */
-function reindentTags(code, unit) {
-    const masked = code
-        .replace(/<!--[\s\S]*?-->/g, (m) => m.replace(/[^\n]/g, " "))
-        .split("\n");
-    const lines = code.split("\n");
-    let depth = 0;
-    return lines
-        .map((line, i) => {
-        const t = (masked[i] ?? "").trim();
-        if (!t)
-            return "";
-        const leadClose = /^<\//.test(t);
-        if (leadClose)
-            depth = Math.max(0, depth - 1);
-        const indent = depth;
-        for (const m of t.matchAll(/<(\/?)([a-zA-Z][\w:-]*)((?:"[^"]*"|'[^']*'|[^>"'])*)>/g)) {
-            if (m[1] === "/")
-                depth = Math.max(0, depth - 1);
-            else if (!m[3].trimEnd().endsWith("/") && !VOID_TAGS.has(m[2].toLowerCase()))
-                depth++;
-        }
-        return unit.repeat(indent) + line.trim();
-    })
-        .join("\n");
-}
-/** POSIX 쉘 재들여쓰기 — if/fi, for|while/done, case/esac, {} 블록 */
-function reindentShell(code, unit) {
-    const lines = code.split("\n");
-    let depth = 0;
-    return lines
-        .map((line) => {
-        // 문자열과 # 주석을 지운 스캔용 사본
-        const t = line
-            .replace(/"(?:[^"\\]|\\.)*"?/g, "")
-            .replace(/'(?:[^'\\]|\\.)*'?/g, "")
-            .replace(/#[^\n]*/, "")
-            .trim();
-        if (!t)
-            return "";
-        // elif/else/then/do 는 이전 몸통을 닫고 다음 몸통을 연다
-        const transient = /^(elif|else|then|do|fi|done|esac|\}|\))/.test(t) ? 1 : 0;
-        const indent = Math.max(0, depth - transient);
-        if (/^(elif|else|then|do)\b/.test(t)) {
-            // 같은 깊이에서 계속 — 순수 클로저만 depth를 낮춘다
-        }
-        else if (/^(fi|done|esac|\}|\))/.test(t)) {
-            depth = Math.max(0, depth - 1);
-        }
-        if (/^(if|for|while|until|select|case)\b/.test(t) || /\b(then|do)\s*$/.test(t) || /\{\s*$/.test(t)) {
-            depth++;
-        }
-        return unit.repeat(indent) + line.trim();
-    })
-        .join("\n");
-}
-const SQL_KEYWORDS = new Set([
-    "select", "from", "where", "group", "by", "having", "order",
-    "limit", "offset", "insert", "into", "values", "update", "set",
-    "delete", "join", "inner", "left", "right", "full", "outer", "on",
-    "as", "and", "or", "not", "null", "is", "in", "exists", "union",
-    "all", "distinct", "case", "when", "then", "else", "end",
-    "between", "like", "asc", "desc", "create", "table", "drop",
-    "alter", "primary", "key", "foreign", "references", "index",
-]);
-/** SQL — 예약어를 대문자로 (문자열/주석 밖만) */
-function upperSqlKeywords(code) {
-    // -- 줄 주석도 마스킹에 포함 (maskCode는 C 계열 주석만 안다)
-    const masked = maskCode(code).text.replace(/--[^\n]*/g, (m) => " ".repeat(m.length));
-    return code.replace(/\b[a-z]+\b/gi, (w, off) => masked[off] !== " " && SQL_KEYWORDS.has(w.toLowerCase())
-        ? w.toUpperCase()
-        : w);
-}
-/**
- * 코드 서식 정리 — 언어 서버 없이 안전한 수준만 한다:
- *  - 언어가 json이거나(미지정이고 {/[ 로 시작할 때) JSON으로 파싱되면
- *    2칸 pretty-print
- *  - 중괄호 계열(js/ts/java/c/go/rust/php/css…): 브래킷 깊이로
- *    재들여쓰기 — 문자열·주석·템플릿·정규식 안의 기호는 세지 않는다
- *  - 마크업(html/xml/vue/svelte): 태그 깊이로 재들여쓰기
- *  - 쉘(sh/bash): if/fi·do/done·case/esac·{} 블록으로 재들여쓰기
- *  - sql: 예약어 대문자화
- *  - 모든 언어: 줄 끝 공백 제거 + 3개 이상 연속 빈 줄을 2개로 +
- *    파일 끝 빈 줄 제거 (EditorConfig/prettier 공통 규칙)
- * 들여쓰기 단위는 기존 코드에서 추정하고 없으면 2칸. 줄 구조는 바꾸지
- * 않는다 — 선행 공백만 다시 쓰는 수준이라 깨진 코드에서도 안전하다.
- * 바뀔 게 없으면 null.
- */
-export function formatCodeText(code, language) {
-    let out = code;
-    const lang = language.toLowerCase();
-    const lead = code.trimStart()[0] ?? "";
-    let jsonOk = false;
-    if (lang === "json" || (!lang && (lead === "{" || lead === "["))) {
-        try {
-            out = JSON.stringify(JSON.parse(code), null, 2);
-            jsonOk = true;
-        }
-        catch {
-            // 깨진 JSON은 아래 재들여쓰기·공통 정리만 적용한다
-        }
-    }
-    if (!jsonOk) {
-        const unit = indentUnit(out.split("\n"));
-        if (BRACE_LANGS.has(lang) || (!lang && lead === "{")) {
-            out = reindentBraces(out, unit);
-        }
-        else if (MARKUP_LANGS.has(lang)) {
-            out = reindentTags(out, unit);
-        }
-        else if (SHELL_LANGS.has(lang)) {
-            out = reindentShell(out, unit);
-        }
-        else if (lang === "sql") {
-            out = upperSqlKeywords(out);
-        }
-    }
-    out = out
-        .split("\n")
-        .map((l) => l.replace(/[ \t]+$/, ""))
-        .join("\n")
-        .replace(/\n{3,}/g, "\n\n")
-        .replace(/\n+$/, "");
-    return out === code ? null : out;
-}
-/**
- * 경로로 지정한 코드블록 서식 정리 — 노드 뷰 크롬 바처럼 캐럿과
- * 무관하게 특정 블록을 정리할 때 쓴다. 이 블록 안의 셀렉션
- * 엔드포인트는 새 텍스트 길이로 클램프해 보존한다.
- */
-export function formatCodeAt(blockPath) {
-    return ({ state, tr, dispatch }) => {
-        const block = nodeAt(state.doc, blockPath);
-        if (!block || !state.schema.nodeSpec(block.type)?.code)
-            return false;
-        const text = (block.content ?? []).map((c) => c.text ?? "").join("");
-        const formatted = formatCodeText(text, String(block.attrs?.["language"] ?? ""));
-        if (formatted == null)
-            return false;
-        const next = {
-            ...block,
-            content: [{ type: "text", text: formatted }],
-        };
-        tr.replaceNode(blockPath, next);
-        const sel = state.selection;
-        if (sel.type === "text") {
-            const fix = (p) => {
-                const off = charOffset(block, blockPath, leafPoint(state.doc, p));
-                return off == null
-                    ? p
-                    : charPoint(next, blockPath, Math.min(off, formatted.length));
-            };
-            tr.setSelection(textSelection(fix(sel.anchor), fix(sel.focus)));
-        }
-        dispatch();
-        return true;
-    };
-}
-/** 캐럿 코드블록 서식 정리 — Shift-Alt-F/정리 버튼 (VS Code 관례) */
-export const formatCode = (ctx) => {
-    const c = codeContext(ctx.state);
-    if (!c)
-        return false;
-    return formatCodeAt(c.blockPath)(ctx);
-};
-/**
- * 선택과 겹치는 `code: true` 블록별 문자 좌표를 돌려준다.
- * 콜아웃·인용 같은 컨테이너 안의 중첩 코드블록도 찾는다 —
- * 톱레벨 인덱스(loI..hiI)로 먼저 좁히고 그 아래를 임의 깊이로
- * 순회한다. 컨테이너 경계 포인트(전체 선택의 {path:[],offset:k}
- * 등)는 텍스트 리프로 내려 해석하고, 블록 밖으로 나간 엔드포인트는
- * 그 블록의 경계로 클램프한다 — Mod-A 처럼 여러 블록을 걸친
- * 선택에서도 코드 블록 구간만 정확히 잘라낸다.
- */
-function codeSelectionContexts(state) {
-    const sel = state.selection;
-    if (sel.type !== "text")
-        return [];
-    const r = normalizedRange(sel);
-    const aLeaf = leafPoint(state.doc, r.anchor);
-    const fLeaf = leafPoint(state.doc, r.focus);
-    const loI = aLeaf.path[0];
-    const hiI = fLeaf.path[0];
-    if (loI == null || hiI == null)
-        return [];
-    const out = [];
-    const visit = (block, blockPath) => {
-        if (state.schema.nodeSpec(block.type)?.code) {
-            // 선택과 실제로 겹치는 블록만 낸다 — 리프를 부모 레벨의 자식
-            // 인덱스로 환산해 비교한다 (pointCmp는 리프와 부모 경계 포인트를
-            // 비교하지 못한다 — 경로 길이 차이로 항상 "뒤" 판정).
-            // -1: 리프가 블록보다 앞, 0: 블록 서브트리 안, +1: 뒤
-            const pl = blockPath.length - 1;
-            const last = blockPath[pl];
-            const rel = (leaf) => {
-                for (let i = 0; i < pl; i++) {
-                    const li = leaf.path[i];
-                    if (li !== blockPath[i])
-                        return (li ?? -1) < blockPath[i] ? -1 : 1;
-                }
-                const idx = leaf.path[pl];
-                if (idx == null)
-                    return 0;
-                return idx < last ? -1 : idx > last ? 1 : 0;
-            };
-            if (rel(aLeaf) > 0 || rel(fLeaf) < 0)
-                return;
-            const text = (block.content ?? []).map((c) => c.text ?? "").join("");
-            // 블록 밖 엔드포인트는 앞이면 0, 뒤면 끝으로 클램프
-            const clamp = (leaf) => {
-                const off = charOffset(block, blockPath, leaf);
-                if (off != null)
-                    return off;
-                return pointCmp(leaf, { path: blockPath, offset: 0 }) <= 0
-                    ? 0
-                    : text.length;
-            };
-            out.push({
-                blockPath,
-                block,
-                text,
-                from: clamp(aLeaf),
-                to: clamp(fLeaf),
-            });
-            return;
-        }
-        for (const [i, child] of (block.content ?? []).entries()) {
-            if (child.type !== "text")
-                visit(child, [...blockPath, i]);
-        }
-    };
-    for (let i = loI; i <= hiI && i < (state.doc.content?.length ?? 0); i++) {
-        visit(state.doc.content[i], [i]);
-    }
-    return out;
-}
-/**
- * 캐럿(포커스)이 속한 코드 컨텍스트 — 포커스 리프가 그 블록 안에
- * 있어야 한다 (화살표 탈출·들여쓰기 등 캐럿 명령용). 선택만 걸치고
- * 포커스는 비코드 블록에 있으면 null.
- */
-function codeContext(state) {
-    const sel = state.selection;
-    if (sel.type !== "text")
-        return null;
-    const r = normalizedRange(sel);
-    const fLeaf = leafPoint(state.doc, r.focus);
-    // 리프가 텍스트면 부모가 블록, 컨테이너(빈 코드블록 등)면 자기 자신
-    const fBlock = nodeAt(state.doc, fLeaf.path)?.type === "text"
-        ? fLeaf.path.slice(0, -1)
-        : fLeaf.path;
-    for (const ctx of codeSelectionContexts(state)) {
-        if (ctx.blockPath.length === fBlock.length &&
-            ctx.blockPath.every((v, i) => v === fBlock[i])) {
-            return ctx;
-        }
-    }
-    return null;
-}
-/** 블록 포인트 → 병합 문자 오프셋. 블록 밖 포인트면 null */
-function charOffset(block, blockPath, p) {
-    const kids = block.content ?? [];
-    const rel = p.path.slice(blockPath.length);
-    if (!p.path.slice(0, blockPath.length).every((v, i) => v === blockPath[i])) {
-        return null;
-    }
-    if (rel.length === 0) {
-        // 컨테이너 포인트 — 앞쪽 자식들의 텍스트 합
-        let sum = 0;
-        for (let i = 0; i < Math.min(p.offset, kids.length); i++) {
-            sum += kids[i].text?.length ?? 0;
-        }
-        return sum;
-    }
-    if (rel.length !== 1)
-        return null;
-    let sum = p.offset;
-    for (let i = 0; i < rel[0] && i < kids.length; i++) {
-        sum += kids[i].text?.length ?? 0;
-    }
-    return sum;
-}
-/** 병합 문자 오프셋 → 텍스트 포인트 (기존 자식 경계로 해석) */
-function charPoint(block, blockPath, off, lens) {
-    const kids = block.content ?? [];
-    let rest = off;
-    for (let i = 0; i < kids.length; i++) {
-        const t = lens?.[i] ?? kids[i].text?.length ?? 0;
-        if (rest <= t || i === kids.length - 1) {
-            return { path: [...blockPath, i], offset: Math.min(rest, t) };
-        }
-        rest -= t;
-    }
-    return { path: [...blockPath, 0], offset: 0 };
-}
-/**
- * 문자열/주석 토큰 안의 문자 오프셋 판정 — spec.codeHighlighter로
- * 토큰화해 그 구간에 있으면 true를 돌린다 (Ace가 페어링·매칭을
- * 끌 때 쓰는 isCodeLike 관례). 하이라이터가 없으면 null.
- */
-export function codeStringMask(state, block) {
-    const hl = state.schema.nodeSpec(block.type)?.codeHighlighter;
-    if (!hl)
-        return null;
-    const text = (block.content ?? []).map((c) => c.text ?? "").join("");
-    const lang = block.attrs?.["language"] ?? null;
-    const spans = [];
-    let i = 0;
-    for (const t of hl(text, lang)) {
-        const end = i + t.text.length;
-        if (t.kind === "string" || t.kind === "comment") {
-            const first = t.text[0] ?? "";
-            // 열린 토큰(//·# 라인 주석, 닫히지 않은 문자열/블록 주석)은
-            // 끝 경계도 안쪽으로 본다 — 그 자리의 입력이 토큰을 이어받는다
-            const open = first === "#" ||
-                (first === "/" && !t.text.endsWith("*/")) ||
-                (first !== "/" &&
-                    first !== "#" &&
-                    !(t.text.length > 1 && t.text.endsWith(first)));
-            spans.push([i, open ? end + 1 : end]);
-        }
-        i = end;
-    }
-    return (off) => spans.some(([a, b]) => off >= a && off < b);
-}
-/** 문자열의 줄 시작 오프셋 목록 (0과 각 '\n' 직후) */
-function lineStarts(text) {
-    const out = [0];
-    for (let i = 0; i < text.length; i++) {
-        if (text[i] === "\n")
-            out.push(i + 1);
-    }
-    return out;
-}
-const CODE_TAB = "\t";
-const CODE_TAB_SIZE = 4;
-// ── 들여쓰기 (VS Code 관례) ───────────────────────────────
-/**
- * Tab — 코드블록 들여쓰기. collapsed면 캐럿에 \t 삽입,
- * 범위 선택이면 걸친 줄 전부의 앞에 \t를 단다 (VS Code 관례).
- * 코드블록 밖이면 false — 리스트/표 키바인딩으로 폴스루.
- */
-export const indentCode = ({ state, tr, dispatch }) => {
-    const ctx = codeContext(state);
-    if (!ctx)
-        return false;
-    const { blockPath, block, text, from, to } = ctx;
-    if (from === to) {
-        const at = charPoint(block, blockPath, from);
-        tr.insertText(CODE_TAB, at);
-        // 삽입 후 길이로 해석해야 from+1이 삽입 전 길이에 클램프되지 않는다
-        const kidIdx = at.path[at.path.length - 1];
-        const lens = (block.content ?? []).map((k, i) => (k.text?.length ?? 0) + (i === kidIdx ? 1 : 0));
-        tr.setSelection(textSelection(charPoint(block, blockPath, from + 1, lens)));
-        dispatch();
-        return true;
-    }
-    // 걸친 줄들의 시작 — 'to'가 정확히 줄 시작이면 그 줄은 제외
-    const starts = lineStarts(text);
-    const start0 = Math.max(...starts.filter((s) => s <= from));
-    const covered = starts.filter((s) => s >= start0 && s < to);
-    if (!covered.length)
-        return false;
-    // 뒤쪽 줄부터 삽입해야 앞쪽 좌표가 안 밀린다
-    const kids = block.content ?? [];
-    const extra = kids.map(() => 0);
-    for (const s of [...covered].sort((a, b) => b - a)) {
-        const p = charPoint(block, blockPath, s);
-        tr.insertText(CODE_TAB, p);
-        extra[p.path[p.path.length - 1]] += 1;
-    }
-    const lens = kids.map((k, i) => (k.text?.length ?? 0) + extra[i]);
-    const shift = (off) => off + covered.filter((s) => s <= off).length;
-    tr.setSelection(textSelection(charPoint(block, blockPath, shift(from), lens), charPoint(block, blockPath, shift(to), lens)));
-    dispatch();
-    return true;
-};
-/**
- * Shift-Tab — 코드블록 내어쓰기. 걸친 각 줄의 앞에서 \t 하나 또는
- * 스페이스 최대 tabSize개를 지운다. 코드블록 밖이면 false로 폴스루.
- */
-export const dedentCode = ({ state, tr, dispatch }) => {
-    const ctx = codeContext(state);
-    if (!ctx)
-        return false;
-    const { blockPath, block, text, from, to } = ctx;
-    const starts = lineStarts(text);
-    const start0 = Math.max(...starts.filter((s) => s <= from));
-    // 각 줄에서 지울 들여쓰기 — \t 하나 또는 앞쪽 연속 스페이스 최대 tabSize개
-    const edits = starts
-        .filter((s) => s >= start0 && (from === to ? s <= from : s < to))
-        .map((s) => {
-        let n = 0;
-        if (text[s] === CODE_TAB)
-            n = 1;
-        else
-            while (n < CODE_TAB_SIZE && text[s + n] === " ")
-                n++;
-        return { s, n };
-    })
-        .filter((e) => e.n > 0);
-    // 코드블록 안인데 지울 들여쓰기가 없으면 그냥 삼킨다 — false로
-    // 폴스루하면 브라우저가 포커스를 에디터 밖으로 옮긴다 (Ace/VS Code는 no-op)
-    if (!edits.length)
-        return true;
-    const kids = block.content ?? [];
-    const extra = kids.map(() => 0);
-    for (const { s, n } of [...edits].sort((a, b) => b.s - a.s)) {
-        const a = charPoint(block, blockPath, s);
-        tr.delete({
-            anchor: a,
-            focus: { path: a.path, offset: a.offset + n },
-        });
-        extra[a.path[a.path.length - 1]] -= n;
-    }
-    const lens = kids.map((k, i) => (k.text?.length ?? 0) + extra[i]);
-    // 지워진 들여쓰기만큼 좌표를 당긴다 — 줄 시작(s === off) 위치의
-    // 캐럿은 들여쓰기 앞에 머문다 (s < off 기준)
-    const shift = (off) => Math.max(0, off - edits.reduce((d, e) => d + (e.s < off ? e.n : 0), 0));
-    tr.setSelection(textSelection(charPoint(block, blockPath, shift(from), lens), charPoint(block, blockPath, shift(to), lens)));
-    dispatch();
-    return true;
-};
-/**
- * ArrowDown/ArrowUp — 코드블록 가장자리 줄 탈출 (Tiptap
- * exitOnArrowDown/Up 관례). 마지막 줄에서 ArrowDown을 누르면 블록
- * 뒤로, 첫 줄에서 ArrowUp이면 블록 앞으로 나간다 — 이웃 블록이
- * 없으면 빈 문단을 만든다. Notion의 코드블록 화살표 탈출과 같다.
- */
-export function exitCodeArrow(direction) {
-    return ({ state, tr, dispatch }) => {
-        const ctx = codeContext(state);
-        if (!ctx || ctx.from !== ctx.to)
-            return false;
-        const { blockPath, text, from } = ctx;
-        const onEdge = direction === "down"
-            ? !text.slice(from).includes("\n")
-            : !text.slice(0, from).includes("\n");
-        if (!onEdge)
-            return false;
-        const parentPath = blockPath.slice(0, -1);
-        const bi = blockPath[blockPath.length - 1];
-        const si = direction === "down" ? bi + 1 : bi - 1;
-        const sib = si >= 0 ? nodeAt(state.doc, [...parentPath, si]) : undefined;
-        if (sib) {
-            const tp = direction === "down" ? firstTextPath(sib) : null;
-            const sp = tp
-                ? [...parentPath, si, ...tp]
-                : [...parentPath, si];
-            tr.setSelection(textSelection({ path: sp, offset: 0 }));
-            dispatch();
-            return true;
-        }
-        // 이웃이 없으면 빈 문단을 만들어 탈출 — bi=0에서 ArrowUp이면
-        // 코드블록 앞에, 끝에서 ArrowDown이면 뒤에 놓인다
-        const at = { path: parentPath, offset: direction === "down" ? bi + 1 : bi };
-        tr.insertNode(at, { type: "paragraph", content: [] });
-        tr.setSelection(textSelection({ path: [...at.path, at.offset], offset: 0 }));
-        dispatch();
-        return true;
-    };
-}
-/** 캐럿 코드블록의 텍스트 — 복사 버튼 등 UI용. 밖이면 null */
-export function codeTextAt(state) {
-    const ctx = codeContext(state);
-    return ctx ? ctx.text : null;
-}
-/** 코드블록 안 캐럿의 줄/열 (Ace 상태바 Ln:Col 관례). 밖이면 null */
-export function codeCaret(state) {
-    const ctx = codeContext(state);
-    if (!ctx)
-        return null;
-    const before = ctx.text.slice(0, ctx.to);
-    const nl = before.lastIndexOf("\n");
-    return { line: before.split("\n").length, col: before.length - nl };
-}
-// ── 코드 편집 명령 — 주석 토글·줄 이동/복제·괄호 매칭 (Ace 관례) ──
-/** 선택이 걸친 줄 범위 [lo, hi] — to가 정확히 줄 시작이면 그 줄은 제외 */
-function codeLineRange(text, from, to) {
-    const starts = lineStarts(text);
-    const lo = starts.filter((s) => s <= from).length - 1;
-    let hi = starts.filter((s) => s <= to).length - 1;
-    if (to > from && starts[hi] === to)
-        hi--;
-    return [Math.max(0, lo), Math.max(0, hi)];
-}
-/**
- * 문자 오프셋 편집 목록(삽입/삭제)을 블록에 적용하고 새 doc 기준
- * 텍스트 자식별 길이 배열을 돌려준다. ops는 겹치지 않는 원본 좌표 —
- * 뒤쪽(큰 pos)부터 적용해야 앞쪽 좌표가 안 밀린다.
- */
-function applyCharOps(tr, block, blockPath, ops) {
-    const kids = block.content ?? [];
-    const extra = kids.map(() => 0);
-    const ends = [];
-    let acc = 0;
-    for (const k of kids) {
-        acc += k.text?.length ?? 0;
-        ends.push(acc);
-    }
-    for (const op of [...ops].sort((a, b) => b.pos - a.pos)) {
-        if (op.del) {
-            tr.delete({
-                anchor: charPoint(block, blockPath, op.pos),
-                focus: charPoint(block, blockPath, op.pos + op.del),
-            });
-            for (let i = 0; i < kids.length; i++) {
-                const ks = i === 0 ? 0 : ends[i - 1];
-                const ov = Math.min(op.pos + op.del, ends[i]) - Math.max(op.pos, ks);
-                if (ov > 0)
-                    extra[i] -= ov;
-            }
-        }
-        if (op.ins) {
-            const at = charPoint(block, blockPath, op.pos);
-            tr.insertText(op.ins, at);
-            extra[at.path[at.path.length - 1]] += op.ins.length;
-        }
-    }
-    return kids.map((k, i) => (k.text?.length ?? 0) + extra[i]);
-}
-/** ops 기준으로 문자 오프셋을 새 좌표로 옮긴다 */
-function shiftCharOff(ops, off) {
-    let v = off;
-    for (const op of [...ops].sort((a, b) => a.pos - b.pos)) {
-        if (op.pos > off)
-            break;
-        const ins = op.ins?.length ?? 0;
-        const del = op.del ?? 0;
-        if (op.pos + del <= off)
-            v += ins - del;
-        else
-            v = op.pos + ins;
-    }
-    return Math.max(0, v);
-}
-/** 언어 → 주석 문법. 문자열=줄 주석, 쌍=블록 래핑 (Ace mode 주석 관례) */
-const CODE_COMMENT = {
-    py: "#", python: "#", rb: "#", ruby: "#", pl: "#", perl: "#",
-    sh: "#", bash: "#", zsh: "#", shell: "#", yaml: "#", yml: "#",
-    toml: "#", ini: "#", dockerfile: "#", makefile: "#", make: "#",
-    r: "#", coffee: "#", ps1: "#", powershell: "#", nim: "#",
-    sql: "--", lua: "--", haskell: "--", hs: "--", ada: "--",
-    css: ["/*", "*/"], scss: ["/*", "*/"], less: ["/*", "*/"],
-    html: ["<!--", "-->"], xml: ["<!--", "-->"], svg: ["<!--", "-->"],
-    md: ["<!--", "-->"], markdown: ["<!--", "-->"],
-};
-/**
- * Mod-/ — 코드블록 줄 주석 토글 (Ace toggleCommentLines 관례).
- * 걸친 줄이 전부 주석이면 해제, 아니면 주석을 단다 — 마커는
- * 선행 공백 뒤에 붙어 들여쓰기가 보존된다 (VS Code 관례).
- * 블록 주석 언어(css/html 등)는 줄마다 블록 마커로 감싼다.
- */
-export const toggleCodeComment = ({ state, tr, dispatch }) => {
-    // 선택과 겹치는 모든 코드 블록에 적용 — 전체 선택(Mod-A)이 여러
-    // 블록을 걸쳐도 코드 구간을 빠뜨리지 않는다 (VS Code 관례)
-    const ctxs = codeSelectionContexts(state);
-    if (!ctxs.length)
-        return false;
-    const parts = ctxs.map((ctx) => {
-        const lang = String(ctx.block.attrs?.["language"] ?? "").toLowerCase();
-        const lines = ctx.text.split("\n");
-        const [lo, hi] = codeLineRange(ctx.text, ctx.from, ctx.to);
-        return {
-            ctx,
-            syn: CODE_COMMENT[lang] ?? "//",
-            lines,
-            starts: lineStarts(ctx.text),
-            indent: (i) => lines[i].match(/^[ \t]*/)[0].length,
-            idx: Array.from({ length: hi - lo + 1 }, (_, k) => lo + k).filter((i) => lines[i].trim().length > 0),
-        };
-    });
-    if (!parts.some((p) => p.idx.length))
-        return false;
-    // 전부 주석이면 해제, 하나라도 아니면 주석 (블록을 넘나드는 선택도
-    // 같은 규칙 — VS Code는 선택 전체 기준으로 토글한다)
-    const commentedOf = (p, i) => {
-        const t = p.lines[i].slice(p.indent(i));
-        return typeof p.syn === "string"
-            ? t.startsWith(p.syn)
-            : t.trimEnd().startsWith(p.syn[0]) &&
-                t.trimEnd().endsWith(p.syn[1]) &&
-                t.trimEnd().length > p.syn[0].length + p.syn[1].length;
-    };
-    const allCommented = parts.every((p) => p.idx.every((i) => commentedOf(p, i)));
-    const edits = parts.map((p) => {
-        const { ctx, syn, lines, starts, idx, indent } = p;
-        const ops = [];
-        if (typeof syn === "string") {
-            if (allCommented) {
-                for (const i of idx) {
-                    if (!commentedOf(p, i))
-                        continue;
-                    let n = syn.length;
-                    if (lines[i][indent(i) + syn.length] === " ")
-                        n += 1;
-                    ops.push({ pos: starts[i] + indent(i), del: n });
-                }
-            }
-            else {
-                for (const i of idx) {
-                    ops.push({ pos: starts[i] + indent(i), ins: `${syn} ` });
-                }
-            }
-        }
-        else {
-            const [o, c] = syn;
-            if (allCommented) {
-                for (const i of idx) {
-                    if (!commentedOf(p, i))
-                        continue;
-                    const bp = starts[i] + indent(i);
-                    const t = lines[i].slice(indent(i));
-                    let open = o.length;
-                    if (t[o.length] === " ")
-                        open += 1;
-                    const te = t.trimEnd().length;
-                    let cs = te - c.length;
-                    if (t[cs - 1] === " ")
-                        cs -= 1;
-                    ops.push({ pos: bp, del: open });
-                    ops.push({ pos: bp + cs, del: te - cs });
-                }
-            }
-            else {
-                for (const i of idx) {
-                    const bp = starts[i] + indent(i);
-                    const te = lines[i].trimEnd().length;
-                    ops.push({ pos: bp, ins: `${o} ` });
-                    ops.push({ pos: bp + te, ins: ` ${c}` });
-                }
-            }
-        }
-        return ops;
-    });
-    const lens = parts.map((p, i) => applyCharOps(tr, p.ctx.block, p.ctx.blockPath, edits[i]));
-    // 셀렉션 복원 — 코드블록 안 엔드포인트는 삽입/삭제만큼 옮기고,
-    // 바깥(전체 선택의 비코드 쪽) 엔드포인트는 원래 위치를 유지한다
-    if (state.selection.type !== "text")
-        return false;
-    const selR = normalizedRange(state.selection);
-    const remap = (leaf) => {
-        // 리프가 어느 코드블록 서브트리에 속하는지 — 중첩 블록은
-        // 톱레벨 인덱스가 같을 수 있으니 경로 접두어로 판정한다
-        const pi = parts.findIndex((p) => leaf.path.length >= p.ctx.blockPath.length &&
-            p.ctx.blockPath.every((v, i) => v === leaf.path[i]));
-        if (pi < 0)
-            return leaf;
-        const p = parts[pi];
-        const off = charOffset(p.ctx.block, p.ctx.blockPath, leaf);
-        if (off == null)
-            return leaf;
-        return charPoint(p.ctx.block, p.ctx.blockPath, shiftCharOff(edits[pi], off), lens[pi]);
-    };
-    tr.setSelection(textSelection(remap(leafPoint(state.doc, selR.anchor)), remap(leafPoint(state.doc, selR.focus))));
-    dispatch();
-    return true;
-};
-/**
- * Alt-↑/↓ — 선택이 걸친 줄들을 위/아래 한 줄 이동 (Ace movelines·
- * VS Code 관례). 첫/마지막 줄 가장자리에선 false로 폴스루한다.
- */
-export function moveCodeLines(direction) {
-    return ({ state, tr, dispatch }) => {
-        const ctx = codeContext(state);
-        if (!ctx)
-            return false;
-        const { blockPath, block, text, from, to } = ctx;
-        const lines = text.split("\n");
-        const starts = lineStarts(text);
-        const [lo, hi] = codeLineRange(text, from, to);
-        const sA = starts[lo];
-        // sB는 다음 줄 시작 — 블록과 사이의 개행은 sB-1에 있다
-        const sB = hi + 1 < lines.length ? starts[hi + 1] : text.length;
-        let ops;
-        let delta;
-        if (direction === "up") {
-            if (lo === 0)
-                return false;
-            const prev = lines[lo - 1];
-            const pStart = starts[lo - 1];
-            ops =
-                sB === text.length
-                    ? // 블록이 마지막 줄 — "block\nprev"가 되도록 끝에 붙인다
-                        [
-                            { pos: sB, ins: `\n${prev}` },
-                            { pos: pStart, del: sA - pStart },
-                        ]
-                    : // 다음 줄 시작(sB)에 "prev\n"을 끼운다 — 블록 뒤 개행(sB-1)이
-                        // block과 prev를 자연스럽게 이어준다
-                        [
-                            { pos: sB, ins: `${prev}\n` },
-                            { pos: pStart, del: sA - pStart },
-                        ];
-            delta = -(prev.length + 1);
-        }
-        else {
-            if (hi === lines.length - 1)
-                return false;
-            const next = lines[hi + 1];
-            const nextLast = hi + 1 === lines.length - 1;
-            ops = nextLast
-                ? // 다음 줄이 끝줄 — 앞 개행 포함 "\nnext"를 통째로 지운다
-                    [
-                        { pos: sB - 1, del: next.length + 1 },
-                        { pos: sA, ins: `${next}\n` },
-                    ]
-                : [
-                    { pos: sB, del: next.length + 1 },
-                    { pos: sA, ins: `${next}\n` },
-                ];
-            delta = next.length + 1;
-        }
-        const lens = applyCharOps(tr, block, blockPath, ops);
-        tr.setSelection(textSelection(charPoint(block, blockPath, from + delta, lens), charPoint(block, blockPath, to + delta, lens)));
-        dispatch();
-        return true;
-    };
-}
-/**
- * Mod-Shift-D — 선택이 걸친 줄들을 바로 아래에 복제
- * (Ace duplicateSelection 관례). 사본이 선택된다.
- */
-export const duplicateCodeLines = ({ state, tr, dispatch }) => {
-    const ctx = codeContext(state);
-    if (!ctx)
-        return false;
-    const { blockPath, block, text, from, to } = ctx;
-    const starts = lineStarts(text);
-    const [lo, hi] = codeLineRange(text, from, to);
-    const sA = starts[lo];
-    // sB는 다음 줄 시작 — 줄 텍스트는 [sA, sB-1) (sB-1이 개행)
-    const sB = hi + 1 < starts.length ? starts[hi + 1] : text.length;
-    const tail = sB === text.length;
-    const dup = text.slice(sA, tail ? sB : sB - 1);
-    const ops = [{ pos: sB, ins: tail ? `\n${dup}` : `${dup}\n` }];
-    const cs = tail ? sB + 1 : sB;
-    const lens = applyCharOps(tr, block, blockPath, ops);
-    tr.setSelection(textSelection(charPoint(block, blockPath, from - sA + cs, lens), charPoint(block, blockPath, to - sA + cs, lens)));
-    dispatch();
-    return true;
-};
-const BRACKET_OPEN = "([{";
-const BRACKET_CLOSE = ")]}";
-const BRACKET_PAIR = {
-    "(": ")", "[": "]", "{": "}",
-    ")": "(", "]": "[", "}": "{",
-};
-/**
- * 캐럿 인접 괄호와 짝의 문자 오프셋 (Ace bracket matching 관례).
- * 캐럿 앞/뒤의 ()[]{}를 보고 같은 종류만 세는 깊이 스캔으로 짝을
- * 찾는다 — 문자열/주석 토큰 안쪽의 괄호는 코드로 세지 않는다.
- * 없으면 null.
- */
-export function codeBracketAt(state) {
-    const ctx = codeContext(state);
-    if (!ctx || ctx.from !== ctx.to)
-        return null;
-    const { text, to: off } = ctx;
-    const inStr = codeStringMask(state, ctx.block) ?? (() => false);
-    let idx = -1;
-    let dir = 0;
-    if (off > 0 && BRACKET_CLOSE.includes(text[off - 1])) {
-        idx = off - 1;
-        dir = -1;
-    }
-    else if (off < text.length && BRACKET_OPEN.includes(text[off])) {
-        idx = off;
-        dir = 1;
-    }
-    else if (off > 0 && BRACKET_OPEN.includes(text[off - 1])) {
-        idx = off - 1;
-        dir = 1;
-    }
-    else if (off < text.length && BRACKET_CLOSE.includes(text[off])) {
-        idx = off;
-        dir = -1;
-    }
-    if (idx < 0 || inStr(idx))
-        return null;
-    const ch = text[idx];
-    const want = BRACKET_PAIR[ch];
-    let depth = 0;
-    if (dir > 0) {
-        for (let j = idx; j < text.length; j++) {
-            if (inStr(j))
-                continue;
-            const c = text[j];
-            if (c === ch)
-                depth++;
-            else if (c === want && --depth === 0)
-                return { a: idx, b: j };
-        }
-    }
-    else {
-        for (let j = idx; j >= 0; j--) {
-            if (inStr(j))
-                continue;
-            const c = text[j];
-            if (c === ch)
-                depth++;
-            else if (c === want && --depth === 0)
-                return { a: j, b: idx };
-        }
-    }
-    return null;
-}
 // ── 뷰 입력 훅 — Ace behaviours 관례의 타이핑 동작 ────────────
 /** 자동 쌍 테이블 — 열기 문자 → 닫기 문자 */
 const CODE_PAIRS = {
@@ -1111,7 +114,6 @@ const CODE_PAIRS = {
 };
 /** 타입오버 대상 — 닫기/인용이 바로 뒤에 있으면 입력 대신 넘어간다 */
 const CODE_CLOSERS = ")]}'\"`";
-const isCodeBlock = (state, block) => state.schema.nodeSpec(block.type)?.code === true;
 const codeUIs = new WeakMap();
 /** 캐럿이 속한 코드블록의 pre — 코드 캐럿 아니면 null */
 function activePreEl(el, state) {
@@ -1147,7 +149,7 @@ function ensureCodeUI(el, editor) {
     };
     box.append(sel, mkBtn("정리", "format", "코드 서식 정리 (Alt+Shift+F) — JSON pretty-print·줄 끝 공백·빈 줄 정리"), mkBtn("⧉", "copy", "코드 복사"));
     (el.parentElement ?? el).appendChild(box);
-    const ui = { box, sel };
+    const ui = { box, sel, observer: null };
     codeUIs.set(el, ui);
     // 버튼은 캐럿을 빼앗지 않는다 — select는 기본 동작(드롭다운)이
     // 필요해 mousedown을 먹지 않는다
@@ -1175,10 +177,11 @@ function ensureCodeUI(el, editor) {
     });
     // 레이아웃 변화로 위치가 어긋나면 다시 맞춘다
     if (typeof ResizeObserver !== "undefined") {
-        new ResizeObserver(() => {
+        ui.observer = new ResizeObserver(() => {
             if (!ui.box.hidden)
                 paintCodeOverlay(el, editor);
-        }).observe(el);
+        });
+        ui.observer.observe(el);
     }
     return ui;
 }
@@ -1267,9 +270,12 @@ export const codeBlockFeature = defineFeature({
         // 코드블록 — ``` / ~~~ + 스페이스. ```js 처럼 언어 지정 가능
         // (Tiptap backtickInputRegex 관례 — 공백 트리거라 언어
         // 접미사를 칠 시간이 있다)
-        blockRule(/^(?:```|~~~)([\w+-]*) $/, (m) => ({
+        blockRule(/^(?:```|~~~)([\w+-]*) $/, (m, block) => ({
             type: "codeBlock",
             attrs: { language: m[1] ?? "" },
+            // 코드는 마크를 받지 않는다 — toggleCodeBlock과 같은 규칙으로
+            // 기존 인라인 마크(대기 서식이 입혀진 fence 텍스트 등)를 벗긴다
+            content: (block.content ?? []).map((c) => ({ ...c, marks: undefined })),
         })),
     ],
     input: {
@@ -1286,9 +292,7 @@ export const codeBlockFeature = defineFeature({
                 if (!pointEq(ctx.anchor, ctx.focus)) {
                     ctx.tr.delete({ anchor: ctx.anchor, focus: ctx.focus });
                 }
-                ctx.tr
-                    .insertText(data.text, ctx.anchor)
-                    .setMeta("paste", true);
+                ctx.tr.insertText(data.text, ctx.anchor).setMeta("paste", true);
                 ctx.dispatch();
             }
             return true;
@@ -1361,9 +365,7 @@ export const codeBlockFeature = defineFeature({
             const caretOff = ctx.offsetOf(ctx.anchor);
             const lineStart = caretOff === 0 ? 0 : text.lastIndexOf("\n", caretOff - 1) + 1;
             const curLine = text.slice(lineStart, caretOff);
-            const atEmptyTail = caretOff === text.length &&
-                lineStart > 0 &&
-                /^[ \t]*$/.test(curLine);
+            const atEmptyTail = caretOff === text.length && lineStart > 0 && /^[ \t]*$/.test(curLine);
             if (!text || atEmptyTail) {
                 // 꼬리 빈 줄(개행 + 공백)을 지우고 블록 뒤에 본문 삽입
                 if (atEmptyTail) {
@@ -1496,6 +498,14 @@ export const codeBlockFeature = defineFeature({
             }
             reg.set("me-bracket", new H(...ranges));
         },
+        destroyOverlay(el) {
+            // 크롬 바 + 옵저버 + 괄호 하이라이트를 정리하고 맵 엔트리를 지운다
+            const ui = codeUIs.get(el);
+            ui?.observer?.disconnect();
+            ui?.box.remove();
+            codeUIs.delete(el);
+            el.ownerDocument.defaultView?.CSS?.highlights?.delete("me-bracket");
+        },
     },
 });
 //# sourceMappingURL=code-block.js.map