@moda-editor/core 0.1.1

package/dist/state/transaction.js

@@ -0,0 +1,988 @@
+import { firstTextPath, lastTextPath, nodeAt } from "../model/traverse.js";
+import { applyStep, computeSplitOps, mapThroughSplitOp, marksEq, } from "./apply.js";
+import { normalizeRange, pointEq, textSelection } from "./selection.js";
+// ── 구현 ────────────────────────────────────────────────────
+function pathEq(a, b) {
+    return a.length === b.length && a.every((v, i) => v === b[i]);
+}
+/**
+ * 트랜잭션 빌더 — EditorState.tr()이 만든다.
+ * delete() 지원 범위 (Phase 2):
+ *   같은 노드 안 / 같은 부모 안 형제 / 같은 grandparent 아래 텍스트블록
+ *   사이(anchor 블록에 focus 잔여 inline을 join). 더 깊은 중첩은 양끝
+ *   trim만 하고 join 없이 둔다 — 스키마 검증과 함께 보강 예정.
+ */
+export class TransactionBuilder {
+    constructor(state) {
+        Object.defineProperty(this, "state", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: state
+        });
+        Object.defineProperty(this, "steps", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "selection", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "storedMarks", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "meta", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+    }
+    get docChanged() {
+        return this.steps.length > 0;
+    }
+    get doc() {
+        return this.state.doc;
+    }
+    /**
+     * 이미 쌓인 스텝까지 적용된 doc — 빌더 메서드의 위치 인자는
+     * PM 관례상 "직전 스텝까지 적용된 문서" 좌표다. tr.delete(sel) 뒤
+     * insertText가 삭제된 노드를 가리키는 일이 없게 한다.
+     */
+    docNow() {
+        return (this.steps.length ? this.simulate() : this.doc);
+    }
+    pushRemove(at, node) {
+        this.steps.push({ op: "remove", at, node });
+    }
+    /** atom 리프가 아닌 컨테이너인가 — content가 있거나 spec이 자식을 허용 */
+    isContainer(n) {
+        return (n.content !== undefined ||
+            !!this.state.schema.nodeSpec(n.type)?.content);
+    }
+    /** 컨테이너가 인라인 자식을 허용하는가 — 스키마 content 표현 기준 */
+    acceptsInline(n) {
+        return /inline/.test(this.state.schema.nodeSpec(n.type)?.content ?? "");
+    }
+    /**
+     * DOM 셀렉션에서 오는 임의 포인트를 텍스트 삽입 가능한 형태로 정규화한다.
+     * 브라우저는 캐럿을 컨테이너 경계(block 엘리먼트, doc 루트)나
+     * contenteditable=false 노드(atom) 안쪽에도 놓는다 — 그대로 insert하면
+     * doc 루트에 bare text 같은 잘못된 구조가 나온다.
+     *   - text    : 텍스트 노드 안 포인트 — 문자 오프셋 의미
+     *   - inside  : 인라인 전용 빈 컨테이너 — 텍스트 노드를 자식으로 삽입
+     *   - block   : 블록 경계 — paragraph로 감싼 블록을 삽입
+     */
+    resolveInsert(doc, p) {
+        const node = nodeAt(doc, p.path);
+        if (!node)
+            return { kind: "block", path: [], offset: 0 };
+        if (node.type === "text")
+            return { kind: "text", point: p };
+        if (!this.isContainer(node)) {
+            // atom 리프 — 오프셋은 의미가 없으므로 부모 경계(노드 뒤)로 올린다
+            const idx = p.path[p.path.length - 1];
+            if (idx == null)
+                return { kind: "block", path: [], offset: 0 };
+            return this.resolveInsert(doc, {
+                path: p.path.slice(0, -1),
+                offset: idx + 1,
+            });
+        }
+        const children = node.content ?? [];
+        // 앞으로 탐색 — 경계 뒤 첫 텍스트 후손의 시작
+        for (let i = p.offset; i < children.length; i++) {
+            const ftp = firstTextPath(children[i]);
+            if (ftp) {
+                return {
+                    kind: "text",
+                    point: { path: [...p.path, i, ...ftp], offset: 0 },
+                };
+            }
+        }
+        // 뒤로 탐색 — 경계 앞 마지막 텍스트의 끝
+        for (let i = Math.min(p.offset, children.length) - 1; i >= 0; i--) {
+            const ltp = lastTextPath(children[i]);
+            if (ltp) {
+                const len = nodeAt(children[i], ltp)?.text?.length ?? 0;
+                return {
+                    kind: "text",
+                    point: { path: [...p.path, i, ...ltp], offset: len },
+                };
+            }
+        }
+        // 텍스트 후손이 전혀 없다 — 인라인 블록이면 안에, 아니면 새 블록으로
+        if (p.path.length > 0 && this.acceptsInline(node)) {
+            return { kind: "inside", path: p.path, offset: p.offset };
+        }
+        return { kind: "block", path: p.path, offset: p.offset };
+    }
+    /** 기본 텍스트블록 타입 — paragraph, 없으면 inline을 받는 첫 block */
+    defaultBlockType() {
+        const spec = this.state.schema.spec.nodes;
+        return spec["paragraph"]
+            ? "paragraph"
+            : (Object.keys(spec).find((t) => spec[t].group?.split(" ").includes("block") &&
+                /inline/.test(spec[t].content ?? "")) ?? "paragraph");
+    }
+    /** 텍스트를 담는 새 블록 — 스키마에 paragraph가 없으면 inline 블록을 찾는다 */
+    newTextBlock(children) {
+        return { type: this.defaultBlockType(), content: [...children] };
+    }
+    /** 블록 시작 셀렉션 — 텍스트 자식이 있으면 첫 텍스트 앞, 없으면 블록 안 */
+    selStartOfBlock(blockPath, block) {
+        const t = firstTextPath(block);
+        return textSelection(t
+            ? { path: [...blockPath, ...t], offset: 0 }
+            : { path: [...blockPath], offset: 0 });
+    }
+    /** 블록 경계에 새 빈 블록을 넣고 캐럿을 그 안에 둔다 */
+    insertEmptyBlock(insertAt, type) {
+        this.steps.push({
+            op: "insert",
+            at: insertAt,
+            node: type
+                ? { type, content: [] }
+                : this.newTextBlock([]),
+        });
+        this.selection = textSelection({
+            path: [...insertAt.path, insertAt.offset],
+            offset: 0,
+        });
+        return this;
+    }
+    insertText(text, at) {
+        if (!text)
+            return this;
+        let target = at;
+        if (!target) {
+            const sel = this.selection ?? this.state.selection;
+            if (sel.type !== "text")
+                return this;
+            const r = normalizeRange(sel);
+            if (!pointEq(r.anchor, r.focus))
+                this.delete(r);
+            target = r.anchor;
+        }
+        const doc = this.docNow();
+        const t = this.resolveInsert(doc, target);
+        // 마크 우선순위: 이 tr에서 명시한 storedMarks → 이전 tr이 남긴
+        // state.storedMarks(툴바 토글 등) → 커서 위치 텍스트 마크
+        const marks = this.storedMarks ??
+            this.state.storedMarks ??
+            (t.kind === "text" ? nodeAt(doc, t.point.path)?.marks : undefined);
+        const node = {
+            type: "text",
+            text,
+            ...(marks?.length ? { marks } : {}),
+        };
+        if (t.kind === "text") {
+            this.steps.push({ op: "insert", at: t.point, node });
+            this.selection = this.selectionAfterInsert(t.point, node, nodeAt(doc, t.point.path));
+            return this;
+        }
+        if (t.kind === "inside") {
+            const at2 = { path: t.path, offset: t.offset };
+            this.steps.push({ op: "insert", at: at2, node });
+            this.selection = textSelection({
+                path: [...t.path, t.offset],
+                offset: text.length,
+            });
+            return this;
+        }
+        // 블록 경계 — paragraph로 감싸 삽입 (전체 선택 후 타이핑 등)
+        const block = this.newTextBlock([node]);
+        const at2 = { path: t.path, offset: t.offset };
+        this.steps.push({ op: "insert", at: at2, node: block });
+        this.selection = textSelection({
+            path: [...t.path, t.offset, 0],
+            offset: text.length,
+        });
+        return this;
+    }
+    selectionAfterInsert(at, node, target) {
+        const len = node.text?.length ?? 0;
+        if (target?.type === "text") {
+            if (node.type === "text" && marksEq(target.marks, node.marks)) {
+                return textSelection({ path: at.path, offset: at.offset + len });
+            }
+            // 마크가 달라 [head?, 삽입, tail?]로 분할된다 — 삽입 노드는
+            // head가 있으면 idx+1, 없으면(맨 앞) idx에 놓인다. 캐럿은
+            // 삽입 노드 끝 — 끝 삽입에서 idx+2 같은 빈 경로를 만들면
+            // 안 된다 (회귀 — 다음 tr이 무효 경로를 block 폴백으로 해석)
+            const parent = at.path.slice(0, -1);
+            const idx = at.path[at.path.length - 1] + (at.offset > 0 ? 1 : 0);
+            return textSelection({ path: [...parent, idx], offset: len });
+        }
+        if (node.type === "text") {
+            return textSelection({ path: [...at.path, at.offset], offset: len });
+        }
+        return textSelection({ path: at.path, offset: at.offset + 1 });
+    }
+    insertNode(at, node) {
+        this.steps.push({ op: "insert", at, node });
+        this.selection = this.selectionAfterInsert(at, node, nodeAt(this.docNow(), at.path));
+        return this;
+    }
+    /**
+     * at 위치에서 노드를 분할한다 (Enter). 생략하면 현재 셀렉션 —
+     * 비어있지 않은 셀렉션이면 먼저 지운 뒤 분할한다.
+     * 셀렉션은 분할된 "오른쪽" 부분의 시작으로 옮긴다.
+     */
+    split(at, depth = 1) {
+        let p = at;
+        if (!p) {
+            const sel = this.selection ?? this.state.selection;
+            if (sel.type !== "text")
+                return this;
+            const r = normalizeRange(sel);
+            if (!pointEq(r.anchor, r.focus))
+                this.delete(r);
+            p = r.anchor;
+        }
+        const doc = this.docNow();
+        if (nodeAt(doc, p.path)?.type !== "text") {
+            // 비텍스트 포인트 Enter — 인라인 컨테이너 경계면 가장 가까운
+            // 텍스트 위치로 환원해 정상 분할하고, 그 외(블록 컨테이너 경계,
+            // atom 안, 빈 블록)에는 그 자리에 새 빈 블록을 만든다.
+            const node = nodeAt(doc, p.path);
+            let insertAt = null;
+            if (node && this.isContainer(node) && this.acceptsInline(node)) {
+                const res = this.resolveInsert(doc, p);
+                if (res.kind === "text") {
+                    p = res.point;
+                }
+                else {
+                    // 빈 인라인 블록 — 뒤에 새 블록
+                    insertAt = {
+                        path: p.path.slice(0, -1),
+                        offset: p.path[p.path.length - 1] + 1,
+                    };
+                }
+            }
+            else if (node && this.isContainer(node)) {
+                // 블록 전용 컨테이너(doc 등) 경계 — 그 위치 그대로
+                insertAt = p;
+            }
+            else {
+                // atom/리프 안 — 노드 뒤 부모 경계
+                const idx = p.path[p.path.length - 1];
+                insertAt =
+                    idx == null
+                        ? p
+                        : { path: p.path.slice(0, -1), offset: idx + 1 };
+            }
+            if (insertAt)
+                return this.insertEmptyBlock(insertAt);
+        }
+        // 블록 "끝"에서의 Enter는 splitExit 타입의 블록을 새로 만든다 — PM
+        // 관례 (heading 끝 Enter → 다음 heading이 아니라 paragraph. 중간
+        // 분할은 타입을 유지한다). splitExit 미지정 블록은 기본 블록 타입으로.
+        const target = nodeAt(doc, p.path);
+        if (target?.type === "text" && p.path.length >= 2) {
+            const blockPath = p.path.slice(0, -1);
+            const block = nodeAt(doc, blockPath);
+            const lastIdx = (block?.content?.length ?? 0) - 1;
+            const atEnd = p.offset === (target.text ?? "").length &&
+                p.path[p.path.length - 1] === lastIdx;
+            const exitType = block
+                ? (this.state.schema.nodeSpec(block.type)?.splitExit ??
+                    this.defaultBlockType())
+                : undefined;
+            if (atEnd && block && exitType && exitType !== block.type) {
+                return this.insertEmptyBlock({
+                    path: blockPath.slice(0, -1),
+                    offset: blockPath[blockPath.length - 1] + 1,
+                }, exitType);
+            }
+        }
+        const step = { op: "split", at: p, depth };
+        this.steps.push(step);
+        const ops = computeSplitOps(doc, step);
+        let caret = null;
+        if (target?.type === "text") {
+            // 텍스트 분할 뒤 경계(= 오른쪽 텍스트 시작)를 만들어 나머지
+            // nodeSplit op들로 매핑 — 오른쪽 편향
+            caret = {
+                path: p.path.slice(0, -1),
+                offset: p.path[p.path.length - 1] + 1,
+            };
+            for (const op of ops.slice(1))
+                caret = mapThroughSplitOp(caret, op);
+        }
+        else {
+            caret = p;
+            for (const op of ops)
+                caret = mapThroughSplitOp(caret, op);
+        }
+        this.selection = textSelection(caret);
+        return this;
+    }
+    /**
+     * 리스트 아이템 분할 — caret이 가리키는 인라인 블록을 캐럿에서 자르고
+     * 꼬리(블록 꼬리 + 이후 아이템 자식들)를 새 아이템으로 만든다.
+     * caret은 아이템 안의 텍스트 포인트여야 한다.
+     */
+    splitItem(itemPath, caret) {
+        const doc = this.docNow();
+        const listPath = itemPath.slice(0, -1);
+        const k = itemPath[itemPath.length - 1];
+        const list = k == null ? undefined : nodeAt(doc, listPath);
+        const item = nodeAt(doc, itemPath);
+        if (!list?.content || !item?.content || k == null)
+            return this;
+        // caret = [...itemPath, childIdx, textIdx]/offset
+        const childIdx = caret.path[itemPath.length] ?? 0;
+        const child = item.content[childIdx];
+        const textIdx = caret.path[itemPath.length + 1] ?? 0;
+        const textNode = child?.content?.[textIdx];
+        const headText = textNode?.type === "text" ? (textNode.text ?? "").slice(0, caret.offset) : "";
+        const tailText = textNode?.type === "text" ? (textNode.text ?? "").slice(caret.offset) : "";
+        if (child && !childIdx && !textIdx && !headText) {
+            // 아이템 맨 앞 Enter — 빈 아이템을 위에 삽입 (PM liftEmptyItem과 유사)
+            const empty = {
+                type: item.type,
+                content: [{ type: child.type, content: [] }],
+            };
+            this.replaceNode(listPath, {
+                ...list,
+                content: [
+                    ...list.content.slice(0, k),
+                    empty,
+                    item,
+                    ...list.content.slice(k + 1),
+                ],
+            });
+            this.selection = this.selStartOfBlock([...listPath, k], empty);
+            return this;
+        }
+        const headChild = child
+            ? {
+                ...child,
+                content: [
+                    ...(child.content ?? []).slice(0, textIdx),
+                    ...(textNode ? [{ ...textNode, text: headText }] : []),
+                ],
+            }
+            : { type: this.defaultBlockType(), content: [] };
+        const tailChildContent = [
+            ...(textNode || tailText ? [{ type: "text", text: tailText }] : []),
+            ...(child?.content?.slice(textIdx + 1) ?? []),
+        ];
+        const tailChild = {
+            type: child?.type ?? this.defaultBlockType(),
+            content: tailChildContent,
+        };
+        const headItem = {
+            ...item,
+            content: [...item.content.slice(0, childIdx), headChild],
+        };
+        const tailItem = {
+            type: item.type,
+            content: [tailChild, ...item.content.slice(childIdx + 1)],
+        };
+        this.replaceNode(listPath, {
+            ...list,
+            content: [
+                ...list.content.slice(0, k),
+                headItem,
+                tailItem,
+                ...list.content.slice(k + 1),
+            ],
+        });
+        this.selection = this.selStartOfBlock([...listPath, k + 1], tailItem);
+        return this;
+    }
+    /**
+     * 리스트 아이템을 리스트 밖으로 꺼낸다 — 아이템의 블록들이 리스트의
+     * 형제가 된다. 리스트가 아이템 하나뿐이면 리스트 통째 교체, 머리/꼬리
+     * 아이템이면 리스트 앞/뒤에 삽입, 중간이면 리스트를 둘로 나눠 사이에
+     * 끼운다 (PM liftListItem 관례).
+     */
+    liftItem(itemPath) {
+        const doc = this.docNow();
+        const listPath = itemPath.slice(0, -1);
+        const k = itemPath[itemPath.length - 1];
+        const list = k == null ? undefined : nodeAt(doc, listPath);
+        const item = nodeAt(doc, itemPath);
+        const blocks = item?.content ?? [];
+        if (!list?.content ||
+            !item ||
+            !blocks.length ||
+            k == null ||
+            !listPath.length) {
+            return this;
+        }
+        const gPath = listPath.slice(0, -1);
+        const container = gPath.length ? nodeAt(doc, gPath) : undefined;
+        if (container && this.state.schema.nodeSpec(container.type)?.listItem) {
+            // 중첩 아이템 — 부모 li 안에 풀지 않고 바깥 리스트의 형제 li로 들어올린다.
+            // 뒤따르는 형제들은 들어올린 아이템의 서브리스트로 딸려 나간다(PM 관례)
+            const outerListPath = gPath.slice(0, -1);
+            const outerIdx = gPath[gPath.length - 1];
+            const subIdx = listPath[listPath.length - 1];
+            const trailing = list.content.slice(k + 1);
+            const before = list.content.slice(0, k);
+            const lifted = {
+                ...item,
+                content: trailing.length
+                    ? [...blocks, { type: list.type, content: trailing }]
+                    : blocks,
+            };
+            this.delete({
+                anchor: { path: listPath, offset: k },
+                focus: { path: listPath, offset: list.content.length },
+            });
+            if (!before.length) {
+                this.delete({
+                    anchor: { path: gPath, offset: subIdx },
+                    focus: { path: gPath, offset: subIdx + 1 },
+                });
+            }
+            this.insertNode({ path: outerListPath, offset: outerIdx + 1 }, lifted);
+            this.selection = this.selStartOfBlock([...outerListPath, outerIdx + 1, 0], blocks[0]);
+            return this;
+        }
+        const li = listPath[listPath.length - 1];
+        const len = list.content.length;
+        if (len === 1) {
+            // 유일한 아이템 — 리스트 통째를 아이템 블록들로 교체
+            this.delete({
+                anchor: { path: gPath, offset: li },
+                focus: { path: gPath, offset: li + 1 },
+            });
+            for (let i = 0; i < blocks.length; i++) {
+                this.insertNode({ path: gPath, offset: li + i }, blocks[i]);
+            }
+            this.selection = this.selStartOfBlock([...gPath, li], blocks[0]);
+            return this;
+        }
+        if (k === 0 || k === len - 1) {
+            // 머리 → 리스트 앞 / 꼬리 → 리스트 뒤
+            const out = k === 0 ? li : li + 1;
+            this.delete({
+                anchor: { path: listPath, offset: k },
+                focus: { path: listPath, offset: k + 1 },
+            });
+            for (let i = 0; i < blocks.length; i++) {
+                this.insertNode({ path: gPath, offset: out + i }, blocks[i]);
+            }
+            this.selection = this.selStartOfBlock([...gPath, out], blocks[0]);
+            return this;
+        }
+        // 중간 — 리스트를 [앞], 아이템 블록들, [뒤]로 쪼갠다
+        const listA = { ...list, content: list.content.slice(0, k) };
+        const listB = { ...list, content: list.content.slice(k + 1) };
+        this.delete({
+            anchor: { path: gPath, offset: li },
+            focus: { path: gPath, offset: li + 1 },
+        });
+        let off = li;
+        this.insertNode({ path: gPath, offset: off++ }, listA);
+        for (const b of blocks)
+            this.insertNode({ path: gPath, offset: off++ }, b);
+        this.insertNode({ path: gPath, offset: off }, listB);
+        this.selection = this.selStartOfBlock([...gPath, li + 1], blocks[0]);
+        return this;
+    }
+    /**
+     * 리스트 아이템을 이전 형제 아래로 넣는다 (Tab 인덴트) — 형제의 마지막
+     * 자식이 같은 타입 리스트면 그 끝에, 아니면 새 리스트를 만들어 넣는다.
+     */
+    sinkItem(itemPath) {
+        const doc = this.docNow();
+        const listPath = itemPath.slice(0, -1);
+        const k = itemPath[itemPath.length - 1];
+        const list = k == null ? undefined : nodeAt(doc, listPath);
+        const item = nodeAt(doc, itemPath);
+        if (!list?.content || !item || k == null || k === 0)
+            return this;
+        const prev = list.content[k - 1];
+        const prevContent = prev.content ?? [];
+        const last = prevContent[prevContent.length - 1];
+        let childIdx;
+        let subIdx;
+        let newPrev;
+        if (last?.type === list.type && last.content !== undefined) {
+            childIdx = prevContent.length - 1;
+            subIdx = last.content.length;
+            newPrev = {
+                ...prev,
+                content: [
+                    ...prevContent.slice(0, -1),
+                    { ...last, content: [...last.content, item] },
+                ],
+            };
+        }
+        else {
+            childIdx = prevContent.length;
+            subIdx = 0;
+            newPrev = {
+                ...prev,
+                content: [...prevContent, { type: list.type, content: [item] }],
+            };
+        }
+        this.replaceNode(listPath, {
+            ...list,
+            content: [
+                ...list.content.slice(0, k - 1),
+                newPrev,
+                ...list.content.slice(k + 1),
+            ],
+        });
+        this.selection = this.selStartOfBlock([...listPath, k - 1, childIdx, subIdx], item);
+        return this;
+    }
+    replaceNode(path, node) {
+        const idx = path[path.length - 1];
+        const old = idx == null ? undefined : nodeAt(this.docNow(), path);
+        if (idx == null || !old)
+            return this;
+        const at = { path: path.slice(0, -1), offset: idx };
+        this.steps.push({ op: "remove", at, node: old });
+        this.steps.push({ op: "insert", at, node });
+        return this;
+    }
+    addStep(step) {
+        this.steps.push(step);
+        return this;
+    }
+    isInlineNode(n) {
+        return n.type === "text" || this.state.schema.isInline(n.type);
+    }
+    isTextBlock(n) {
+        return (!this.isInlineNode(n) &&
+            (n.content ?? []).length > 0 &&
+            (n.content ?? []).every((c) => this.isInlineNode(c)));
+    }
+    insertSlice(at, nodes) {
+        if (!nodes.length)
+            return this;
+        const doc = this.docNow();
+        if (nodeAt(doc, at.path)?.type !== "text") {
+            // 컨테이너 경계/atom 안 포인트 — 텍스트 위치로 해석해 수준을 맞춘다
+            const r = this.resolveInsert(doc, at);
+            if (r.kind === "text") {
+                at = r.point;
+            }
+            else if (r.kind === "inside") {
+                at = nodes.every((n) => this.isInlineNode(n))
+                    ? { path: r.path, offset: r.offset }
+                    : // 블록은 인라인 컨테이너 안에 못 넣는다 — 블록 뒤 경계로 승격
+                        {
+                            path: r.path.slice(0, -1),
+                            offset: r.path[r.path.length - 1] + 1,
+                        };
+            }
+            else {
+                const at2 = { path: r.path, offset: r.offset };
+                // doc 루트 등 블록 경계 — 인라인 조각은 paragraph로 감싼다
+                return nodes.every((n) => this.isInlineNode(n))
+                    ? this.insertBlockSlice(doc, at2, [this.newTextBlock(nodes)])
+                    : this.insertBlockSlice(doc, at2, nodes);
+            }
+        }
+        const target = nodeAt(doc, at.path);
+        // 문단 하나짜리 붙여넣기 — 인라인으로 풀어 삽입 (PM slice 관례)
+        if (nodes.length === 1 &&
+            target?.type === "text" &&
+            this.isTextBlock(nodes[0])) {
+            return this.insertInlineSlice(at, nodes[0].content ?? []);
+        }
+        if (nodes.every((n) => this.isInlineNode(n))) {
+            return this.insertInlineSlice(at, nodes);
+        }
+        return this.insertBlockSlice(doc, at, nodes);
+    }
+    /** 인라인 조각 — 텍스트를 o에서 나누고 사이에 끼운다 */
+    insertInlineSlice(at, nodes) {
+        const target = nodeAt(this.docNow(), at.path);
+        if (target?.type === "text") {
+            const parent = at.path.slice(0, -1);
+            const i = at.path[at.path.length - 1];
+            const len = target.text?.length ?? 0;
+            let base;
+            let caretAfter;
+            if (at.offset === 0) {
+                base = i;
+                caretAfter = { path: [...parent, i + nodes.length], offset: 0 };
+            }
+            else if (at.offset >= len) {
+                base = i + 1;
+                caretAfter = { path: [...parent, i + 1 + nodes.length], offset: 0 };
+            }
+            else {
+                this.steps.push({ op: "split", at, depth: 0 });
+                base = i + 1;
+                caretAfter = { path: [...parent, i + 1 + nodes.length], offset: 0 };
+            }
+            nodes.forEach((node, j) => {
+                this.steps.push({
+                    op: "insert",
+                    at: { path: parent, offset: base + j },
+                    node,
+                });
+            });
+            this.selection = textSelection(caretAfter);
+            return this;
+        }
+        // 컨테이너 경계
+        nodes.forEach((node, j) => {
+            this.steps.push({
+                op: "insert",
+                at: { path: at.path, offset: at.offset + j },
+                node,
+            });
+        });
+        this.selection = textSelection({
+            path: at.path,
+            offset: at.offset + nodes.length,
+        });
+        return this;
+    }
+    /** 블록 조각 — 현재 블록을 나누고 사이에 삽입 (doc 최상위 기준) */
+    insertBlockSlice(doc, at, nodes) {
+        const target = nodeAt(doc, at.path);
+        if (target?.type === "text") {
+            const bi = at.path[0];
+            if (bi == null)
+                return this;
+            // 텍스트 + 상위 체인을 전부 나눠 최상위 블록을 둘로 만든다
+            this.steps.push({ op: "split", at, depth: at.path.length - 1 });
+            const insertAt = bi + 1;
+            nodes.forEach((node, j) => {
+                this.steps.push({
+                    op: "insert",
+                    at: { path: [], offset: insertAt + j },
+                    node,
+                });
+            });
+            // 캐럿 = 오른쪽 부분 블록(bi+1+n)의 첫 텍스트, 없으면 마지막 삽입 끝
+            const sim = this.simulate();
+            const right = nodeAt(sim, [insertAt + nodes.length]);
+            const ftp = right ? firstTextPath(right) : null;
+            if (ftp) {
+                this.selection = textSelection({
+                    path: [insertAt + nodes.length, ...ftp],
+                    offset: 0,
+                });
+            }
+            else {
+                const last = nodes[nodes.length - 1];
+                const ltp = last ? lastTextPath(last) : null;
+                this.selection = ltp
+                    ? textSelection({
+                        path: [insertAt + nodes.length - 1, ...ltp],
+                        offset: (nodeAt(last, ltp)?.text ?? "").length,
+                    })
+                    : textSelection({ path: [insertAt], offset: 0 });
+            }
+            return this;
+        }
+        // 컨테이너 경계 — 같은 부모 안에 순서대로 삽입
+        nodes.forEach((node, j) => {
+            this.steps.push({
+                op: "insert",
+                at: { path: at.path, offset: at.offset + j },
+                node,
+            });
+        });
+        this.selection = textSelection({
+            path: at.path,
+            offset: at.offset + nodes.length,
+        });
+        return this;
+    }
+    /** 지금까지 쌓인 스텝을 doc에 적용한 결과 — 캐럿 계산용 */
+    simulate() {
+        let d = this.doc;
+        for (const s of this.steps)
+            d = applyStep(d, s);
+        return d;
+    }
+    /**
+     * 문서 순서 비교 — pointCmp와 다른 점: 컨테이너 경계 포인트를
+     * "자식 offset 앞"으로 해석한다. pointCmp는 [i]/k < [i,j]/m이지만
+     * 실제 문서 순서에선 [i]/k 는 k>j 이면 [i,j] 안쪽 "뒤"다 —
+     * DOM 셀렉션이 만드는 (블록엘리먼트, 자식인덱스) 포인트를 정렬할 때
+     * pointCmp를 쓰면 범위가 뒤집힌다.
+     */
+    docOrderCmp(a, b) {
+        const d = Math.min(a.path.length, b.path.length);
+        for (let i = 0; i < d; i++) {
+            if (a.path[i] !== b.path[i])
+                return a.path[i] - b.path[i];
+        }
+        if (a.path.length === b.path.length)
+            return a.offset - b.offset;
+        if (a.path.length < b.path.length) {
+            return b.path[a.path.length] < a.offset ? 1 : -1;
+        }
+        return a.path[b.path.length] < b.offset ? -1 : 1;
+    }
+    /** atom 리프 안 포인트를 부모 경계로 올린다 — dir>0이면 노드 "뒤" 경계 */
+    resolveBoundary(doc, p, dir) {
+        const node = nodeAt(doc, p.path);
+        if (!node || node.type === "text" || this.isContainer(node))
+            return p;
+        const idx = p.path[p.path.length - 1];
+        if (idx == null)
+            return p;
+        return {
+            path: p.path.slice(0, -1),
+            offset: idx + (dir > 0 ? 1 : 0),
+        };
+    }
+    delete(range) {
+        const doc = this.docNow();
+        const fwd = this.docOrderCmp(range.anchor, range.focus) <= 0;
+        const a = this.resolveBoundary(doc, fwd ? range.anchor : range.focus, -1);
+        const f = this.resolveBoundary(doc, fwd ? range.focus : range.anchor, 1);
+        return this.deleteOrdered(doc, a, f);
+    }
+    /** a<f로 정렬 + atom 경계 해석이 끝난 범위 삭제 — 재귀용 내부 구현 */
+    deleteOrdered(doc, a, f) {
+        if (pointEq(a, f))
+            return this;
+        const aNode = nodeAt(doc, a.path);
+        const fNode = nodeAt(doc, f.path);
+        // 같은 노드 안
+        if (pathEq(a.path, f.path)) {
+            if (aNode?.type === "text") {
+                this.pushRemove(a, {
+                    type: "text",
+                    text: (aNode.text ?? "").slice(a.offset, f.offset),
+                    ...(aNode.marks && { marks: aNode.marks }),
+                });
+            }
+            else if (aNode?.content) {
+                for (let j = f.offset - 1; j >= a.offset; j--) {
+                    const child = aNode.content[j];
+                    if (child)
+                        this.pushRemove({ path: a.path, offset: j }, child);
+                }
+            }
+            return this.setSelection(textSelection(a));
+        }
+        const aParent = a.path.slice(0, -1);
+        const fParent = f.path.slice(0, -1);
+        // 같은 부모 안 형제 사이
+        if (pathEq(aParent, fParent)) {
+            if (fNode?.type === "text" && f.offset > 0) {
+                this.pushRemove({ path: f.path, offset: 0 }, {
+                    type: "text",
+                    text: fNode.text.slice(0, f.offset),
+                    ...(fNode.marks && { marks: fNode.marks }),
+                });
+            }
+            const ai = a.path[a.path.length - 1];
+            const fi = f.path[f.path.length - 1];
+            for (let j = fi - 1; j > ai; j--) {
+                const child = nodeAt(doc, [...aParent, j]);
+                if (child)
+                    this.pushRemove({ path: aParent, offset: j }, child);
+            }
+            if (aNode?.type === "text") {
+                const tail = (aNode.text ?? "").slice(a.offset);
+                if (tail) {
+                    this.pushRemove(a, {
+                        type: "text",
+                        text: tail,
+                        ...(aNode.marks && { marks: aNode.marks }),
+                    });
+                }
+            }
+            return this.setSelection(textSelection(a));
+        }
+        // 다른 블록 — 같은 grandparent 아래 텍스트블록 사이면 join한다
+        const aGrand = aParent.slice(0, -1);
+        const fGrand = fParent.slice(0, -1);
+        const joinable = pathEq(aGrand, fGrand) &&
+            aParent.length === fParent.length &&
+            aNode?.type === "text" &&
+            fNode?.type === "text";
+        if (joinable) {
+            const ai = aParent[aParent.length - 1];
+            const fi = fParent[fParent.length - 1];
+            const ti = a.path[a.path.length - 1];
+            const tj = f.path[f.path.length - 1];
+            const aBlock = nodeAt(doc, aParent);
+            const fBlock = nodeAt(doc, fParent);
+            // anchor 텍스트 tail 제거
+            const aTail = aNode.text.slice(a.offset);
+            if (aTail) {
+                this.pushRemove(a, {
+                    type: "text",
+                    text: aTail,
+                    ...(aNode.marks && { marks: aNode.marks }),
+                });
+            }
+            // anchor 블록의 뒤쪽 형제 제거 (desc)
+            const aSibs = aBlock.content ?? [];
+            for (let j = aSibs.length - 1; j > ti; j--) {
+                this.pushRemove({ path: aParent, offset: j }, aSibs[j]);
+            }
+            // focus 잔여분을 anchor 블록에 join
+            const fTail = fNode.text.slice(f.offset);
+            let insAt = ti + 1;
+            if (fTail) {
+                this.steps.push({
+                    op: "insert",
+                    at: { path: aParent, offset: insAt++ },
+                    node: {
+                        type: "text",
+                        text: fTail,
+                        ...(fNode.marks && { marks: fNode.marks }),
+                    },
+                });
+            }
+            const fSibs = fBlock.content ?? [];
+            for (let j = tj + 1; j < fSibs.length; j++) {
+                this.steps.push({
+                    op: "insert",
+                    at: { path: aParent, offset: insAt++ },
+                    node: fSibs[j],
+                });
+            }
+            // focus 블록 + 중간 블록 제거 (desc index — anchor는 항상 앞)
+            for (let j = fi; j > ai; j--) {
+                const blk = nodeAt(doc, [...aGrand, j]);
+                if (blk)
+                    this.pushRemove({ path: aGrand, offset: j }, blk);
+            }
+            return this.setSelection(textSelection(a));
+        }
+        // 일반화 — LCA 레벨에서 완전히 선택된 자식을 제거하고, 양 끝은
+        // 각각 "자식 끝까지"/"자식 처음부터" 범위로 재귀 trim한다.
+        // DOM 셀렉션이 만드는 경계↔내부 혼합 범위(전체 선택, atom 걸침)를 커버.
+        let l = 0;
+        const minLen = Math.min(a.path.length, f.path.length);
+        while (l < minLen && a.path[l] === f.path[l])
+            l++;
+        const lca = a.path.slice(0, l);
+        const aIn = a.path.length > l;
+        const fIn = f.path.length > l;
+        const aChild = aIn ? a.path[l] : a.offset;
+        const fChild = fIn ? f.path[l] : f.offset;
+        const remStart = aIn ? aChild + 1 : a.offset;
+        const remEnd = fIn ? fChild : f.offset;
+        // 끝쪽 부분 삭제 — f가 담긴 자식의 처음부터 f까지
+        if (fIn) {
+            this.deleteOrdered(doc, { path: [...lca, fChild], offset: 0 }, f);
+        }
+        // 시작쪽 부분 삭제 — a부터 a가 담긴 자식의 끝까지
+        // (텍스트 자식의 끝은 문자 길이, 컨테이너는 자식 수)
+        if (aIn) {
+            const aChildPath = [...lca, aChild];
+            const aChildNode = nodeAt(doc, aChildPath);
+            const endOffset = aChildNode?.type === "text"
+                ? (aChildNode.text?.length ?? 0)
+                : (aChildNode?.content?.length ?? 0);
+            this.deleteOrdered(doc, a, { path: aChildPath, offset: endOffset });
+        }
+        // 완전 삭제 구간 — LCA의 자식 [remStart, remEnd)을 역순으로
+        const lcaNode = nodeAt(doc, lca);
+        for (let j = remEnd - 1; j >= remStart; j--) {
+            const child = lcaNode?.content?.[j];
+            if (child)
+                this.pushRemove({ path: lca, offset: j }, child);
+        }
+        return this.setSelection(textSelection(a));
+    }
+    addMark(range, mark) {
+        this.steps.push({ op: "addMark", range: normalizeRange(range), mark });
+        return this;
+    }
+    removeMark(range, markType) {
+        this.steps.push({ op: "removeMark", range: normalizeRange(range), markType });
+        return this;
+    }
+    setNodeAttr(path, key, value) {
+        const prev = nodeAt(this.docNow(), path)?.attrs?.[key];
+        this.steps.push({ op: "setAttr", path, key, value, prev });
+        return this;
+    }
+    setSelection(selection) {
+        this.selection = selection;
+        return this;
+    }
+    setStoredMarks(marks) {
+        this.storedMarks = marks ? [...marks] : null;
+        return this;
+    }
+    /**
+     * 입력 규칙 — 마크다운식 변환(`# `→heading, `**x**`→bold).
+     * 캐럿이 속한 인라인 블록의 블록 시작~커서 텍스트를 만들어 각
+     * 규칙의 pattern에 매칭한다. 매치가 커서에서 끝나는 첫 규칙이
+     * 이 tr 위에 변환 스텝을 쌓는다 — 위치는 docNow 좌표라 규칙
+     * 핸들러가 쌓은 스텝도 직전 스텝 기준으로 해석된다.
+     */
+    applyInputRules(rules) {
+        if (!rules.length)
+            return this;
+        const sel = this.selection ?? this.state.selection;
+        if (sel.type !== "text" || !pointEq(sel.anchor, sel.focus))
+            return this;
+        const doc = this.docNow();
+        const caret = sel.anchor;
+        const node = nodeAt(doc, caret.path);
+        if (node?.type !== "text")
+            return this;
+        const blockPath = caret.path.slice(0, -1);
+        const block = nodeAt(doc, blockPath);
+        if (!block?.content || !this.acceptsInline(block))
+            return this;
+        // 코드 블록 안에서는 마크다운 변환을 하지 않는다
+        if (this.state.schema.nodeSpec(block.type)?.code)
+            return this;
+        const kids = block.content;
+        const ci = caret.path[caret.path.length - 1];
+        // 블록 시작~커서의 인라인 텍스트 + 각 세그먼트의 절대 오프셋
+        let textBefore = "";
+        const segs = [];
+        for (let i = 0; i <= ci && i < kids.length; i++) {
+            const t = kids[i]?.text ?? "";
+            const take = i === ci ? Math.min(caret.offset, t.length) : t.length;
+            segs.push({ path: [...blockPath, i], start: textBefore.length, len: take });
+            textBefore += t.slice(0, take);
+        }
+        if (!textBefore)
+            return this;
+        // textBefore 절대 오프셋 → Point (끝은 항상 캐럿)
+        const toPoint = (pos) => {
+            for (const s of segs) {
+                if (!s.len)
+                    continue;
+                if (pos < s.start + s.len || pos === s.start) {
+                    return { path: s.path, offset: pos - s.start };
+                }
+            }
+            return caret;
+        };
+        for (const rule of rules) {
+            const m = rule.pattern.exec(textBefore);
+            if (!m)
+                continue;
+            const start = m.index;
+            const end = start + m[0].length;
+            if (end !== textBefore.length)
+                continue; // 커서에서 끝나는 매치만
+            const handled = rule.handler({ state: this.state, tr: this, dispatch: () => { } }, m, { anchor: toPoint(start), focus: caret }, doc);
+            if (handled !== false)
+                break;
+        }
+        return this;
+    }
+    setMeta(key, value) {
+        this.meta[key] = value;
+        return this;
+    }
+}
+//# sourceMappingURL=transaction.js.map